Focu Ui

Change-Id: I7e3084ff5f3554903a18cd8e4e11a00d73fc16e7
Signed-off-by: keonpyo.kong <keonpyo.kong@samsung.com>
apply code review

Change-Id: I561689799d46e28a50ddd6fb80bc5ee149c96c47
Signed-off-by: keonpyo.kong <keonpyo.kong@samsung.com>
apply codereviw3

Change-Id: I9d6e0b9eb6728f2578b5336d859f3e1620e59e68
Signed-off-by: keonpyo.kong <keonpyo.kong@samsung.com>
apply codereview 5

Change-Id: I465eb07a578aecbd7f8ea1aaeea77d6cdbbab369
Signed-off-by: keonpyo.kong <keonpyo.kong@samsung.com>

diff --git a/src/ui/FUi_Control.cpp b/src/ui/FUi_Control.cpp
index 304e5c1..b803f56 100755 (executable)
--- a/src/ui/FUi_Control.cpp
+++ b/src/ui/FUi_Control.cpp
@@ -4925,6 +4925,12 @@ _Control::OnChildControlFocusMoved(const _Control& control)
 {
 }
 
+bool
+_Control::IsChildControlFocusManage(void) const
+{
+       return false;
+}
+
 result
 _Control::SetFontFromFile(const String& fileName)
 {
@@ -4954,4 +4960,10 @@ _Control::GetFontFile(void) const
 {
        return __fontFileName;
 }
+void
+_Control::DrawFocus(void)
+{
+       _IControlDelegate& delegate = GetControlDelegate();
+       delegate.OnDrawFocus();
+}
 }} // Tizen::Ui

diff --git a/src/ui/FUi_ControlImpl.cpp b/src/ui/FUi_ControlImpl.cpp
index 266ee2e..b336c31 100755 (executable)
--- a/src/ui/FUi_ControlImpl.cpp
+++ b/src/ui/FUi_ControlImpl.cpp
@@ -4529,6 +4529,11 @@ _ControlImpl::OnChildControlFocusMoved(const _Control& control)
        GetCore().OnChildControlFocusMoved(control);
 }
 
+bool
+_ControlImpl::IsChildControlFocusManage(void) const
+{
+       GetCore().IsChildControlFocusManage();
+}
 void
 _ControlImpl::SetTouchPressThreshold(float distance)
 {

diff --git a/src/ui/FUi_ControlImplManager.cpp b/src/ui/FUi_ControlImplManager.cpp
index b113013..6ffd2f8 100644 (file)
--- a/src/ui/FUi_ControlImplManager.cpp
+++ b/src/ui/FUi_ControlImplManager.cpp
@@ -33,6 +33,7 @@
 #include <FApp_AppInfo.h>
 #include <FGrp_CoordinateSystem.h>
 #include <FSys_SystemInfoImpl.h>
+#include "FUi_FocusManagerImpl.h"
 #include "FUi_ControlImplManager.h"
 #include "FUi_ControlManager.h"
 #include "FUi_WindowImpl.h"
@@ -183,6 +184,8 @@ _ControlImplManager::Initialize(void)
 
        _ControlManager::Initialize();
 
+       _KeyEventManagerImpl::Initialize();
+       _FocusManagerImpl::Initialize();
        result r = InitializeTestbuddyManager();
        SetLastResult(r);
 }
@@ -192,6 +195,9 @@ _ControlImplManager::Release(void)
 {
        _ControlManager::Release();
 
+       _FocusManagerImpl::ReleaseInstance();
+       _KeyEventManagerImpl::ReleaseInstance();
+
        delete __pInstance;
        __pInstance = null;
 }
@@ -217,14 +223,10 @@ _ControlImplManager::InitInstance(void)
 _ControlImplManager::_ControlImplManager(void)
        : __pFrameImpl(null)
 {
-       _KeyEventManagerImpl::Initialize();
-       _FocusManagerImpl::Initialize();
 }
 
 _ControlImplManager::~_ControlImplManager(void)
 {
-       _FocusManagerImpl::ReleaseInstance();
-       _KeyEventManagerImpl::ReleaseInstance();
 }
 
 _WindowImpl*

diff --git a/src/ui/FUi_FocusManagerImpl.cpp b/src/ui/FUi_FocusManagerImpl.cpp
index f548a47..a7e0297 100644 (file)
--- a/src/ui/FUi_FocusManagerImpl.cpp
+++ b/src/ui/FUi_FocusManagerImpl.cpp
@@ -21,11 +21,22 @@
 *
 */
 
+#include <unique_ptr.h>
 #include "FUi_FocusManagerImpl.h"
 #include "FUi_ControlImpl.h"
 #include "FUi_WindowImpl.h"
 #include "FUi_ControlManager.h"
+#include "FUiCtrl_Form.h"
+#include "FUi_UiEventManager.h"
+#include "FUi_ResourceManager.h"
+#include "FUi_UiKeyEvent.h"
 
+using namespace std;
+using namespace Tizen::Base::Collection;
+using namespace Tizen::Graphics;
+using namespace Tizen::Ui;
+using namespace Tizen::Ui::Controls;
+using namespace Tizen::Ui::Animations;
 
 namespace Tizen { namespace Ui
 {
@@ -35,7 +46,8 @@ _FocusManagerImpl* _FocusManagerImpl::__pInstance = null;
 
 _FocusManagerImpl::_FocusManagerImpl(void)
 {
-       //NOHING
+    result r = _UiEventManager::GetInstance()->AddPostKeyEventListener(*this);
+    SysTryReturnVoidResult(NID_UI,  r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 }
 
 
@@ -119,4 +131,146 @@ _FocusManagerImpl::GetCurrentFocusedWindow(void) const
        return pWindowImpl;
 }
 
+int
+_FocusManagerImpl::GetNextIndex(int currentIndex, FocusDirection focusDirection, const IListT<_Control*>* pFocusControlList)
+{
+       int nextIndex = currentIndex;
+       if (focusDirection == FOCUS_DIRECTION_DOWNWARD)
+       {
+               ++nextIndex;
+               if (nextIndex == pFocusControlList->GetCount())
+               {
+                       nextIndex = 0;
+               }
+       }
+       else
+       {
+               --nextIndex;
+               if (nextIndex  < 0)
+               {
+                       nextIndex = pFocusControlList->GetCount() - 1;
+               }
+       }
+       return nextIndex;
+
+
+}
+
+void
+_FocusManagerImpl::StartFocusTraversal(_Control* pControl, FocusDirection focusDirection)
+{
+       if (focusDirection == FOCUS_DIRECTION_DOWNWARD)
+       {
+               _Control* pFocusControl =  pControl->GetNextFocus();
+               if (pFocusControl)
+               {
+                       pFocusControl->SetFocused();
+                       pFocusControl->DrawFocus();
+                       return;
+               }
+       }
+       else
+       {
+               _Control* pFocusControl =  pControl->GetPreviousFocus();
+               if (pFocusControl)
+               {
+                       pFocusControl->SetFocused();
+                       pFocusControl->DrawFocus();
+                       return;
+               }
+       }
+
+       _Form* pForm = null;
+       _Control* pParentControl = pControl;
+
+       while(pControl)
+       {
+               pForm = dynamic_cast<_Form*>(pParentControl);
+
+               if (pForm != null)
+               {
+                       break;
+               }
+               else
+               {
+                       pParentControl = pParentControl->GetParent();
+               }
+       }
+
+       IListT<_Control*>* pFocusControlList = pForm->GetFocusList();
+       unique_ptr<IEnumeratorT<_Control*> > pEnum (pFocusControlList->GetEnumeratorN());
+
+       int index = 0;
+       bool findNextFocusControl = false;
+       _Control* pFocusControl = null;
+       while (pEnum->MoveNext() == E_SUCCESS)
+       {
+               _Control* pEnumeratorControl = null;
+               pEnum->GetCurrent(pEnumeratorControl);
+
+               //Find current focused control
+               if (pControl == pEnumeratorControl)
+               {
+               //Find next focusable control.
+               index = GetNextIndex(index, focusDirection, pFocusControlList);
+               while (pFocusControlList->GetAt(index, pFocusControl) == E_SUCCESS)
+               {
+                       bool isFocusalbe = pFocusControl->IsFocusable();
+                       bool enableState = pFocusControl->GetEnableState();
+                       bool visibleState = pFocusControl->GetVisibleState();
+                       if (enableState == true && visibleState == true && isFocusalbe == true)
+                       {
+                               pFocusControl->SetFocused();
+                               findNextFocusControl = true;
+                               break;
+                       }
+                       else
+                       {
+                               index = GetNextIndex(index, focusDirection, pFocusControlList);
+                       }
+               }
+               }
+
+               if (findNextFocusControl == true)
+               {
+                       break;
+               }
+
+               index ++;
+       }
+
+       if (pFocusControl && findNextFocusControl == true)
+       {
+               _Control* pParentControl =  pFocusControl->GetParent();
+               if (pParentControl)
+               {
+                       pParentControl->OnChildControlFocusMoved(*pFocusControl);
+               }
+               pFocusControl->DrawFocus();
+       }
+}
+
+bool
+_FocusManagerImpl::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
+{
+       _KeyCode keyCode = keyInfo.GetKeyCode();
+
+       if(keyCode == _KEY_TAB)
+       {
+               FocusDirection focusDirection = FOCUS_DIRECTION_DOWNWARD;
+               if (keyInfo.GetKeyModifier() & _KEY_MODIFIER_SHIFT)
+               {
+                       focusDirection = FOCUS_DIRECTION_UPWARD;
+               }
+
+               _Control* pControl = const_cast<_Control*> (&source);
+               StartFocusTraversal(pControl, focusDirection);
+       }
+       return true;
+}
+bool
+_FocusManagerImpl::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
+{
+       return true;
+}
 } } //Tizen::Ui

diff --git a/src/ui/controls/FUiCtrl_Form.cpp b/src/ui/controls/FUiCtrl_Form.cpp
index 93a0fdc..25977b2 100644 (file)
--- a/src/ui/controls/FUiCtrl_Form.cpp
+++ b/src/ui/controls/FUiCtrl_Form.cpp
@@ -20,9 +20,11 @@
  */
 
 #include <new>
+#include <unique_ptr.h>
 #include <FBaseErrorDefine.h>
 #include <FBaseInteger.h>
 #include <FBaseSysLog.h>
+#include <FBaseColArrayListT.h>
 #include <FGrpFloatRectangle.h>
 #include <FBase_Log.h>
 #include <FGrp_BitmapImpl.h>
@@ -45,10 +47,12 @@
 #include "FUiCtrl_Indicator.h"
 #include "FUi_SystemUtilImpl.h"
 
+using namespace std;
 using namespace Tizen::Ui::Animations;
 using namespace Tizen::Ui;
 using namespace Tizen::Base;  // Rotation
 using namespace Tizen::Base::Runtime;
+using namespace Tizen::Base::Collection;
 using namespace Tizen::Graphics;
 
 namespace Tizen { namespace Ui { namespace Controls
@@ -2600,4 +2604,94 @@ _Form::IsNotificationTrayOpenEnabled(void) const
        return true;
 }
 
+void
+_Form::MakeFocusList(const _Control* pControl, IListT<_Control*>*  pFocusControlList) const
+{
+       int childCount = pControl->GetChildCount();
+       for(int i = 0; i < childCount; i++)
+       {
+               _Control* pChildControl = pControl->GetChild(i);
+               Rectangle rect = pChildControl->GetAbsoluteBounds();
+               unique_ptr<IEnumeratorT<_Control*> > pEnum (pFocusControlList->GetEnumeratorN());
+               int index = 0;
+               while (pEnum->MoveNext() == E_SUCCESS)
+               {
+                       _Control* pEnumeratorControl = null;
+                       pEnum->GetCurrent(pEnumeratorControl);
+                       if (pEnumeratorControl != null)
+                       {
+                               Rectangle enumeratorRect = pEnumeratorControl->GetAbsoluteBounds();
+                               if(enumeratorRect.y > rect.y)
+                               {
+                                       break;
+                               }
+                               else if (enumeratorRect.y == rect.y)
+                               {
+                                       if(enumeratorRect.x > rect.x)
+                                       {
+                                               break;
+                                       }
+                               }
+
+                               index ++;
+                       }
+               }
+               pFocusControlList->InsertAt(pChildControl, index);
+       }
+}
+
+void
+_Form::MakeChildContainerFocusList(_Control* pControl, int startIndex) const
+{
+       unique_ptr<IListT<_Control*> > pTempList (new (std::nothrow) ArrayListT<_Control*>);
+       SysTryReturnVoidResult(NID_UI_CTRL, pTempList, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+       MakeFocusList(pControl, pTempList.get());
+
+       unique_ptr<IEnumeratorT<_Control*> > pTempEnum(pTempList->GetEnumeratorN());
+       int index = ++startIndex;
+       while (pTempEnum->MoveNext() == E_SUCCESS)
+       {
+               _Control* pEnumeratorControl = null;
+               pTempEnum->GetCurrent(pEnumeratorControl);
+               __pFocusControlList->InsertAt(pEnumeratorControl, index);
+               index ++;
+       }
+}
+
+IListT<_Control*>*
+_Form::GetFocusList(void) const
+{
+       if(!__pFocusControlList)
+       {
+               __pFocusControlList.reset(new (std::nothrow) ArrayListT<_Control*>);
+               SysTryReturn(NID_UI, __pFocusControlList, null, E_SYSTEM, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+               MakeFocusList(this, __pFocusControlList.get());
+
+               unique_ptr<IEnumeratorT<_Control*> > pEnum(__pFocusControlList->GetEnumeratorN());
+               int i =0;
+               int nextContainerIndex = -1;
+               while ( pEnum->MoveNext() == E_SUCCESS)
+               {
+                       _Control* pEnumeratorControl = null;
+                       pEnum->GetCurrent(pEnumeratorControl);
+                       _ContainerImpl* pTempContainerImpl = dynamic_cast<_ContainerImpl*>(static_cast <_ControlImpl* >(pEnumeratorControl->GetUserData()));
+
+                       if (pTempContainerImpl != null && (nextContainerIndex < i))
+                       {
+                               if (pEnumeratorControl->IsChildControlFocusManage() == false)
+                               {
+                                       MakeChildContainerFocusList(pEnumeratorControl, i);
+                                       nextContainerIndex = i;
+                                       pEnum.reset(__pFocusControlList->GetEnumeratorN());
+                                       i = -1;
+                               }
+                       }
+                       i++;
+               }
+               __pFocusControlList->InsertAt(dynamic_cast<_Control*> (const_cast<_Form*>(this)), 0);
+       }
+
+       return __pFocusControlList.get();
+}
+
 }}} // Tizen::Ui::Controls

diff --git a/src/ui/controls/FUiCtrl_ScrollPanel.cpp b/src/ui/controls/FUiCtrl_ScrollPanel.cpp
index e311347..3db7a01 100644 (file)
--- a/src/ui/controls/FUiCtrl_ScrollPanel.cpp
+++ b/src/ui/controls/FUiCtrl_ScrollPanel.cpp
@@ -440,6 +440,13 @@ _ScrollPanel::OnAccessibilityValueDecreased(const _AccessibilityContainer& contr
 {
        return true;
 }
+
+void
+_ScrollPanel::OnChildControlFocusMoved(const _Control& control)
+{
+       __pScrollPanelPresenter->OnChildControlFocusMoved(control);
+}
+
 bool
 _ScrollPanel::OnAccessibilityItemRefreshed(const _AccessibilityContainer& control, const _AccessibilityElement& element, _AccessibilityFocusDirection direction)
 {

diff --git a/src/ui/controls/FUiCtrl_ScrollPanelPresenter.cpp b/src/ui/controls/FUiCtrl_ScrollPanelPresenter.cpp
index 589044d..073d943 100644 (file)
--- a/src/ui/controls/FUiCtrl_ScrollPanelPresenter.cpp
+++ b/src/ui/controls/FUiCtrl_ScrollPanelPresenter.cpp
@@ -1245,6 +1245,12 @@ _ScrollPanelPresenter::OnAccessibilityActionPerformed(const _AccessibilityContai
        return false;
 }
 
+void
+_ScrollPanelPresenter::OnChildControlFocusMoved(const _Control& control)
+{
+       ScrollToControlWhenOutOfView(control);
+}
+
 bool
 _ScrollPanelPresenter::OnAccessibilityItemRefreshed(const _AccessibilityContainer& control, const _AccessibilityElement& element, _AccessibilityFocusDirection direction)
 {

diff --git a/src/ui/controls/FUiCtrl_TableView.cpp b/src/ui/controls/FUiCtrl_TableView.cpp
index 171f0ea..27e8e0e 100644 (file)
--- a/src/ui/controls/FUiCtrl_TableView.cpp
+++ b/src/ui/controls/FUiCtrl_TableView.cpp
@@ -1354,4 +1354,9 @@ _TableView::GetVisualElementValueAnimation(const Tizen::Base::String& keyName) c
        return pAnimation;
 }
 
+bool
+_TableView::IsChildControlFocusManage(void) const
+{
+       return true;
+}
 }}} // Tizen::Ui::Controls

diff --git a/src/ui/inc/FUiCtrl_Form.h b/src/ui/inc/FUiCtrl_Form.h
index 504665b..a8efdb4 100644 (file)
--- a/src/ui/inc/FUiCtrl_Form.h
+++ b/src/ui/inc/FUiCtrl_Form.h
@@ -23,6 +23,7 @@
 #ifndef _FUI_CTRL_INTERNAL_FORM_H_
 #define _FUI_CTRL_INTERNAL_FORM_H_
 
+#include <unique_ptr.h>
 #include <FUiCtrlControlsTypes.h>
 #include <FUiCtrlOverlayRegion.h>
 #include "FUi_Control.h"
@@ -198,6 +199,11 @@ public:
        virtual void OnChildVisibleStateChanged(const _Control& child);
        virtual void OnBoundsChanged(void);
 
+// Focus UI
+   Tizen::Base::Collection::IListT<_Control*>* GetFocusList(void) const;
+   void MakeFocusList(const _Control* pControl, Tizen::Base::Collection::IListT<_Control*>*  pFocusControlList) const;
+   void MakeChildContainerFocusList(_Control* pControl, int startIndex) const;
+
 // Accessor
 protected:
        result SetPresenter(const _FormPresenter& formPresenter);
@@ -257,6 +263,9 @@ private:
        //Back button action ID
        static const int ID_BACK_BUTTON = -10;
 
+       //For Focus UI
+       mutable std::unique_ptr<Tizen::Base::Collection::IListT<_Control*> > __pFocusControlList;
+
        friend class _Frame;
        friend class _OverlayRegionImpl;
 }; // _Form

diff --git a/src/ui/inc/FUiCtrl_ScrollPanel.h b/src/ui/inc/FUiCtrl_ScrollPanel.h
index f36b987..f223d12 100644 (file)
--- a/src/ui/inc/FUiCtrl_ScrollPanel.h
+++ b/src/ui/inc/FUiCtrl_ScrollPanel.h
@@ -130,6 +130,9 @@ public:
        virtual bool OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element);
        virtual bool OnAccessibilityItemRefreshed(const _AccessibilityContainer& control, const _AccessibilityElement& element, _AccessibilityFocusDirection direction);
 
+       // Focus UI
+       void OnChildControlFocusMoved(const _Control& control);
+
        // scroll animation event listener
        virtual void OnVisualElementAnimationStarted(const Tizen::Ui::Animations::VisualElementAnimation& animation, const Tizen::Base::String& keyName, Tizen::Ui::Animations::VisualElement& target);
        virtual void OnVisualElementAnimationRepeated(const Tizen::Ui::Animations::VisualElementAnimation& animation, const Tizen::Base::String& keyName, Tizen::Ui::Animations::VisualElement& target, long currentRepeatCount);

diff --git a/src/ui/inc/FUiCtrl_ScrollPanelPresenter.h b/src/ui/inc/FUiCtrl_ScrollPanelPresenter.h
index 86815dd..824317b 100644 (file)
--- a/src/ui/inc/FUiCtrl_ScrollPanelPresenter.h
+++ b/src/ui/inc/FUiCtrl_ScrollPanelPresenter.h
@@ -96,6 +96,9 @@ public:
        virtual bool OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element);
        virtual bool OnAccessibilityItemRefreshed(const _AccessibilityContainer& control, const _AccessibilityElement& element, _AccessibilityFocusDirection direction);
 
+   // Focus UI
+       virtual void OnChildControlFocusMoved(const _Control& control);
+
        // scroll event listener
        virtual void OnScrollEndReached(_Control& source, ScrollEndEvent type);
        virtual void OnScrollPositionChanged(_Control& source, float scrollPosition);

diff --git a/src/ui/inc/FUiCtrl_TableView.h b/src/ui/inc/FUiCtrl_TableView.h
index dcbb441..448a136 100644 (file)
--- a/src/ui/inc/FUiCtrl_TableView.h
+++ b/src/ui/inc/FUiCtrl_TableView.h
@@ -229,6 +229,8 @@ public:
        // VE Value Animation
        Tizen::Ui::Animations::VisualElementValueAnimation* GetVisualElementValueAnimation(const Tizen::Base::String& keyName) const;
 
+       // Focus Ui
+       virtual bool IsChildControlFocusManage(void) const;
 protected:
        // Properties
        result SetPropertyItemDividerColor(const Variant& itemDividerColor);

diff --git a/src/ui/inc/FUi_Control.h b/src/ui/inc/FUi_Control.h
index c787aca..6b2aa83 100755 (executable)
--- a/src/ui/inc/FUi_Control.h
+++ b/src/ui/inc/FUi_Control.h
@@ -113,6 +113,7 @@ public:
        virtual void OnBackgroundColorChanged(Tizen::Graphics::Color& backgroundColor) = 0;
        virtual void OnDrawFocus(void) = 0;
        virtual void OnChildControlFocusMoved(const _Control& control) = 0;
+       virtual bool IsChildControlFocusManage(void) const = 0;
 };
 
 class _IPropagatedTouchEventListener
@@ -254,6 +255,7 @@ public:
        virtual void OnBackgroundColorChanged(Tizen::Graphics::Color& backgroundColor);
    virtual void OnDrawFocus(void);
        virtual void OnChildControlFocusMoved(const _Control& control);
+       virtual bool IsChildControlFocusManage(void) const;
 
 // Control Hierarchy - Common
        bool HasParent(void) const;
@@ -399,6 +401,7 @@ public:
    void SetNextFocus(_Control* pNextFocus);
    _Control* GetPreviousFocus() const;
    _Control* GetNextFocus() const;
+   void DrawFocus(void);
 
 // Clipping
        bool IsClipToParent(void) const;

diff --git a/src/ui/inc/FUi_ControlImpl.h b/src/ui/inc/FUi_ControlImpl.h
index b78d2a7..9ce5432 100755 (executable)
--- a/src/ui/inc/FUi_ControlImpl.h
+++ b/src/ui/inc/FUi_ControlImpl.h
@@ -168,6 +168,7 @@ public:
        virtual void OnBackgroundColorChanged(Tizen::Graphics::Color& backgroundColor);
        virtual void OnDrawFocus(void);
        virtual void OnChildControlFocusMoved(const _Control& control);
+       virtual bool IsChildControlFocusManage(void) const;
 
 // Event Callbacks
        virtual bool OnKeyPressed(const _ControlImpl& source, const _KeyInfo& keyInfo);

diff --git a/src/ui/inc/FUi_FocusManagerImpl.h b/src/ui/inc/FUi_FocusManagerImpl.h
index 01da62a..771c44b 100644 (file)
--- a/src/ui/inc/FUi_FocusManagerImpl.h
+++ b/src/ui/inc/FUi_FocusManagerImpl.h
@@ -23,16 +23,31 @@
 #ifndef _FUI_INTERNAL_FOCUS_MANAGER_IMPL_H_
 #define _FUI_INTERNAL_FOCUS_MANAGER_IMPL_H_
 
-// Includes
+#include <FUi_IKeyEventListener.h>
+#include <FUiAnim_VisualElement.h>
+#include <FBaseColIListT.h>
 #include <FBaseObject.h>
 
+namespace Tizen { namespace Ui { namespace Animations
+{
+class VisualElement;
+}}} //Tizen::Ui::Animations
+
 namespace Tizen { namespace Ui
 {
 
+class _Control;
 class _ControlImpl;
 class _WindowImpl;
 
 
+enum FocusDirection
+{
+       FOCUS_DIRECTION_DOWNWARD,
+       FOCUS_DIRECTION_UPWARD
+};
+
+
 /**
  * @class      FocusManager
  * @brief      This class manages the application's current focus owned by the UI control
@@ -43,6 +58,7 @@ class _WindowImpl;
  */
 class  _FocusManagerImpl
        : public Tizen::Base::Object
+       , public Tizen::Ui::_IKeyEventListener
 {
 public:
        /**
@@ -99,10 +115,17 @@ private:
 
        static void InitializeInstance(void);
 
+       virtual bool OnKeyPressed(const Tizen::Ui::_Control& source, const Tizen::Ui::_KeyInfo& keyInfo);
+       virtual bool OnKeyReleased(const Tizen::Ui::_Control& source, const Tizen::Ui::_KeyInfo& keyInfo);
+
+   void        StartFocusTraversal(_Control* pControl, FocusDirection focusDirection);
+   int GetNextIndex(int currentIndex, FocusDirection focusDirection, const Tizen::Base::Collection::IListT<_Control*>* pFocusControlList);
+   Tizen::Ui::Animations::VisualElement* __pFocusVe;
+
 private:
        static _FocusManagerImpl* __pInstance;
 }; // _FocusManagerImpl
 
 }}//Tizen::Ui
 
-#endif // _FUI_INTERNAL_FOCUS_MANAGER_IMPL_H_
\ No newline at end of file
+#endif // _FUI_INTERNAL_FOCUS_MANAGER_IMPL_H_