using namespace Tizen::Graphics;
using namespace Tizen::Ui;
using namespace Tizen::Ui::Animations;
+using namespace Tizen::Ui::Controls;
namespace {
pTouchManager->ResetTouchInfo();
}
}
-
- if (IsVisible() == false)
- {
- _Control* pControl = GetFocused();
- if (pControl == this)
- {
- SetFocused(false);
- }
- }
}
void
_Window* pTop = control.GetRootWindow();
if (pTop)
{
- if ((&control) == pTop->GetFocusedControl())
+ _Control* pControl = pTop->GetFocusControl();
+ if ((&control) == pControl)
{
- pTop->SetFocusedControl(null);
+ pTop->SetFocusControl(null);
}
}
+
if (!__isPostOrderTraversal)
{
r = control.GetControlDelegate().OnDetachingFromMainTree();
{
ClearLastResult();
- if (!__focusSet)
- {
- return false;
- }
-
- for (int i = 0; i < GetChildCount(); ++i)
- {
- _Control* pChild = GetChild(i);
-
- SysAssert(pChild);
- if (pChild == null)
- {
- continue;
- }
-
- if (pChild->__focusSet)
- {
- return false;
- }
- }
-
- return true;
-}
-
-_Control*
-_Control::GetFocused(void) const
-{
- for (int i = GetChildCount() - 1; i >= 0; --i)
- {
- _Control* pChild = GetChild(i);
-
- SysAssert(pChild);
- if (pChild == null)
- {
- continue;
- }
-
- if (pChild->__focusSet == true)
- {
- return pChild->GetFocused();
- }
- }
+ _Window* pTop = GetRootWindow();
+ SysAssert(pTop);
- if (__focusSet == true)
+ if (this == pTop->GetFocusControl())
{
- return const_cast <_Control*>(this);
- }
- else
- {
- return null;
+ return true;
}
+ return false;
}
result
{
_Window* pTop = GetRootWindow();
SysAssert(pTop);
- pTop->SetFocusedControl(this);
- pTop->SetFocusState(false);
+ pTop->SetFocusControl(this);
_ControlManager* pControlMgr = _ControlManager::GetInstance();
SysAssert(pControlMgr);
if (pTop->IsActivated() && pTop->IsFocusableDescendant(this))
{
- pControlMgr->SetFocusedControl(*this);
- SetFocusState(true);
+ pControlMgr->SetFocusControl(*this);
}
if (IsFailed(GetLastResult()))
{
_Window* pTop = GetRootWindow();
SysAssert(pTop);
- pTop->SetFocusedControl(null);
+ pTop->SetFocusControl(null);
_ControlManager* pControlMgr = _ControlManager::GetInstance();
SysAssert(pControlMgr);
- pControlMgr->SetFocusedControl(*this, false);
- SetFocusState(false);
+ pControlMgr->SetFocusControl(*this, false);
if (IsFailed(GetLastResult()))
{
return E_SUCCESS;
}
-// [ToDo] Find the focused descendent and clear flags upwards.
-void
-_Control::SetFocusState(bool on)
-{
- ClearLastResult();
-
- if (on)
- {
- __focusSet = true;
- _Control* pParent = GetParent();
- if (pParent)
- {
- pParent->SetFocusState(true);
- }
- }
- else
- {
- __focusSet = false;
- for (int i = 0; i < GetChildCount(); ++i)
- {
- _Control* pChild = GetChild(i);
-
- SysAssert(pChild);
- if (pChild == null)
- {
- continue;
- }
-
- if (pChild->__focusSet == true)
- {
- pChild->SetFocusState(false);
- return;
- }
- }
- }
-}
-
result
_Control::SetFont(const String& fontName)
{
const bool changed = (__enabledState != enabledState);
if (changed)
{
- _Control* pControl = GetFocused();
- if (!enabledState && pControl)
- {
- pControl->SetFocused(false);
- }
__enabledState = enabledState;
CallOnAncestorEnableStateChanged();
}
if (visibleState == false)
{
- _Window* pTop = GetRootWindow();
- if (pTop)
- {
- if ((this) == pTop->GetFocusedControl())
- {
- pTop->SetFocusedControl(null);
- }
- }
-
- _Control* pControl = GetFocused();
- if (pControl == this)
- {
- SetFocused(false);
- }
int owneeCount = GetOwneeCount();
for (int i = 0; i < owneeCount; ++i)
{
, __visibleState(true)
, __initVisibleState(false)
, __clipToParent(true)
- , __focusSet(false)
, __multiTouchEnabled(false)
, __dragEnabled(false)
, __dropEnabled(false)
#include "FUiAnim_VisualElement.h"
#include "FUiAnim_VisualElementImpl.h"
#include "FUiCtrl_Popup.h"
+#include "FUi_Window.h"
//#define _TC_PASS
__focusableChangable, E_INVALID_OPERATION,
E_INVALID_OPERATION, "[E_INVALID_OPERATION] The control can't chage it's focusable property.");
- SysTryReturn(NID_UI,
- focusable || GetCore().GetFocused() != &this->GetCore(), E_INVALID_OPERATION,
- E_INVALID_OPERATION, "[E_INVALID_OPERATION] This already focused control cannot be unfocusable.");
+ _Window* pTop = GetCore().GetRootWindow();
+ if (pTop)
+ {
+ SysTryReturn(NID_UI,
+ focusable || pTop->GetFocusControl() != &this->GetCore(), E_INVALID_OPERATION,
+ E_INVALID_OPERATION, "[E_INVALID_OPERATION] This already focused control cannot be unfocusable.");
+ }
+
GetCore().SetFocusable(focusable);
return E_SUCCESS;
, __logicalCoordinateSystem(0)
, __logicalBaseScreenSize(BASE_SCREEN_SIZE_NONE)
, __pSystemWindowList(null)
- , __pFocusedControl(null)
+ , __pFocusControl(null)
, __screenRotation(_CONTROL_ROTATION_0)
, __orientationStatus(_CONTROL_ROTATION_0)
, __orientation(_CONTROL_ORIENTATION_PORTRAIT)
}
void
-_ControlManager::SetFocusedControl(const _Control& control, bool on)
+_ControlManager::SetFocusControl(const _Control& control, bool on)
{
if (on)
{
- if (__pFocusedControl == &control)
+ if (__pFocusControl == &control)
{
return;
}
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
SysTryReturnVoidResult(NID_UI, pEcoreEvas, E_SYSTEM, "[E_SYSTEM] System error occurred.");
- _Control *pPreviousFocusedControl = __pFocusedControl;
+ _Control *pPreviousFocusedControl = __pFocusControl;
if (pPreviousFocusedControl)
{
// [review] make SetFocus() return result and use the returned result here.
pEcoreEvas->SetFocus(*pPreviousFocusedControl, false);
if (GetLastResult() == E_SUCCESS)
{
- if (pPreviousFocusedControl)
- {
- pPreviousFocusedControl->SetFocusState(false);
- }
_UiFocusEvent event(pPreviousFocusedControl->GetHandle(), FOCUS_LOST);
_UiEventManager::GetInstance()->SendEvent(event);
}
if (GetLastResult() == E_SUCCESS)
{
- __pFocusedControl = const_cast<_Control*>(&control);
+ __pFocusControl = const_cast<_Control*>(&control);
_UiFocusEvent event(control.GetHandle(), FOCUS_GAINED);
_UiEventManager::GetInstance()->SendEvent(event);
}
}
else
{
- if (__pFocusedControl != &control)
+ if (__pFocusControl != &control)
{
return;
}
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
SysTryReturnVoidResult(NID_UI, pEcoreEvas, E_SYSTEM, "[E_SYSTEM] System error occurred.");
- if (__pFocusedControl)
+ if (__pFocusControl)
{
// [review] make SetFocus() return result and use the returned result here.
- pEcoreEvas->SetFocus(*__pFocusedControl, false);
+ pEcoreEvas->SetFocus(*__pFocusControl, false);
if (GetLastResult() == E_SUCCESS)
{
- _UiFocusEvent event(__pFocusedControl->GetHandle(), FOCUS_LOST);
+ _UiFocusEvent event(__pFocusControl->GetHandle(), FOCUS_LOST);
_UiEventManager::GetInstance()->SendEvent(event);
}
}
pEcoreEvas->SetFocus(*pTopWindow, true);
if (GetLastResult() == E_SUCCESS)
{
- pTopWindow->SetFocusState(true);
_UiFocusEvent event(pTopWindow->GetHandle(), FOCUS_GAINED);
_UiEventManager::GetInstance()->SendEvent(event);
}
- __pFocusedControl = static_cast<_Control*>(pTopWindow);
+ __pFocusControl = static_cast<_Control*>(pTopWindow);
}
}
}
bool
_ControlManager::TakeFocusFromControl(const _Control& control)
{
- if (__pFocusedControl == &control)
+ if (__pFocusControl == &control)
{
- _Control *pPreviousFocusedControl = __pFocusedControl;
- __pFocusedControl = null;
+ _Control *pPreviousFocusedControl = __pFocusControl;
+ __pFocusControl = null;
_UiFocusEvent event(pPreviousFocusedControl->GetHandle(), FOCUS_LOST);
_UiEventManager::GetInstance()->SendEvent(event);
}
_Control*
-_ControlManager::GetFocusedControl(void) const
+_ControlManager::GetFocusControl(void) const
{
- return __pFocusedControl;
+ return __pFocusControl;
}
void
using namespace Tizen::Graphics;
using namespace Tizen::Base::Collection;
using namespace Tizen::Base;
+using namespace Tizen::Ui::Controls;
namespace
{
_ControlManager* pControlManager = _ControlManager::GetInstance();
SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
- pControl = pControlManager->GetFocusedControl();
+ pControl = pControlManager->GetFocusControl();
if (!pControl)
{
_ControlManager* pControlManager = _ControlManager::GetInstance();
SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
- pControl = pControlManager->GetFocusedControl();
+ pControl = pControlManager->GetFocusControl();
if (!pControl)
{
pControl = pControlManager->GetCurrentFrame();
_UiEventManager* pEventManager = _UiEventManager::GetInstance();
SysTryReturn(NID_UI, pEventManager, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] System error occurred.");
- _Control* pControl = _ControlManager::GetInstance()->GetFocusedControl();
+ _Control* pControl = _ControlManager::GetInstance()->GetFocusControl();
SysTryReturn(NID_UI, pControl, ECORE_CALLBACK_PASS_ON, E_SYSTEM, "[E_SYSTEM] System error occurred.");
bool isKeyboardOn = false;
NativeWindowHandle nativeWindowHandle = pWindow->GetNativeHandle();
if (pEv->win == nativeWindowHandle)
{
- pFocusedControl = pWindow->GetFocused();
+ pFocusedControl = pWindow->GetFocusControl();
+
if (pFocusedControl)
{
pFocusedControl->SetFocused();
_ControlManager* pControlManager = _ControlManager::GetInstance();
SysTryReturn(NID_UI, pControlManager, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
- _Control* pFocusedControl = pControlManager->GetFocusedControl();
+ _Control* pFocusedControl = pControlManager->GetFocusControl();
if (pFocusedControl)
{
_Window* pRootWindow = pFocusedControl->GetRootWindow();
_ControlImpl*
_FocusManagerImpl::GetCurrentFocusOwner(void) const
{
- _Control* pFocus = _ControlManager::GetInstance()->GetFocusedControl();
+ _Control* pFocus = _ControlManager::GetInstance()->GetFocusControl();
if(pFocus == null)
{
return null;
_WindowImpl*
_FocusManagerImpl::GetCurrentFocusedWindow(void) const
{
- _Control* pFocus = _ControlManager::GetInstance()->GetFocusedControl();
+ _Control* pFocus = _ControlManager::GetInstance()->GetFocusControl();
if(pFocus == null)
{
return null;
void
_FocusManagerImpl::StartFocusTraversal(_Control* pControl, FocusDirection focusDirection)
{
+ _Window* pTop = pControl->GetRootWindow();
+ if (pTop)
+ {
+ _Control* pFocusTraversalControl = pTop->GetFocusTraversalControl();
+ if (pFocusTraversalControl)
+ {
+ pControl = pTop->GetFocusTraversalControl();
+ pControl->SetFocused();
+ }
+ }
+
bool focusMode = pControl->IsFocusModeStateEnabled();
if (focusMode == false && pControl->IsFocused())
{
if (IsFocusable(pControl))
{
- __pCurrentFocusUiControl = pControl;
+ pTop->SetFocusTraversalControl(pControl);
pControl->DrawFocus();
pControl->SetFocusModeStateEnabled(true);
return;
}
IListT<_Control*>* pFocusControlList = null;
- _Window* pTop = pControl->GetRootWindow();
+
if (pTop)
{
- _Frame* pFrame = dynamic_cast<_Frame*>(pTop);
- if (pFrame)
- {
- _Form* pForm = pFrame->GetCurrentForm();
- pFocusControlList = pForm->GetFocusList();
- }
- else
- {
- pFocusControlList = pTop->GetFocusList();
- }
+ pFocusControlList = pTop->GetFocusList();
}
if (pFocusControlList)
index ++;
}
- __pCurrentFocusUiControl = pNextFocusControl;
+ pTop->SetFocusTraversalControl(pNextFocusControl);
if (pNextFocusControl && findNextFocusControl == true)
{
_Control* pParentControl = pNextFocusControl->GetParent();
bool
_FocusManagerImpl::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
-{
- if (__pCurrentFocusUiControl)
+{
+ _Window* pTop = source.GetRootWindow();
+ if (pTop)
{
- __pCurrentFocusUiControl->RemoveFocusRing();
- __pCurrentFocusUiControl->SetFocusModeStateEnabled(false);
- __pCurrentFocusUiControl = null;
+ _Control* pFocusTraversalControl = pTop->GetFocusTraversalControl();
+ if (pFocusTraversalControl)
+ {
+ pFocusTraversalControl->RemoveFocusRing();
+ pFocusTraversalControl->SetFocusModeStateEnabled(false);
+ pTop->SetFocusTraversalControl(null);
+ }
}
+
return false;
}
}
else
{
- SysLogException(NID_UI, E_OUT_OF_MEMORY, "[kongp]Failed to CreateControl()");
+ SysLogException(NID_UI, E_OUT_OF_MEMORY, "[UiBuilder] Failed to CreateControl()");
}
SysLog(NID_UI, "[UiBuilder]Register success [%ls]", pUiBuilderControlTableInFomation->__controlMakerName.GetPointer());
_UiObjectHandle
_UiEventManager::GetTarget(void) const
{
- _Control* pControl = _ControlManager::GetInstance()->GetFocusedControl();
+ _Control* pControl = _ControlManager::GetInstance()->GetFocusControl();
SysTryReturn(NID_UI, pControl, _UiObjectHandle(), E_SYSTEM, "[E_SYSTEM] System error occurred.");
return pControl->GetHandle();
bool isFrameActivated = _ControlManager::GetInstance()->IsFrameActivated();
SysLog(NID_UI, "frameActivated(%d)", isFrameActivated);
- _Control* focusedControl = GetFocusedControl();
+ _Control* focusedControl = GetFocusControl();
if (focusedControl)
{
focusedControl->SetFocused();
}
-
- if (!isFrameActivated)
+ else
{
- return;
+ SetFocused();
}
- _Control* pFocus = GetFocused();
- if (pFocus)
- {
- pFocus->SetFocused();
- }
- else
+ if (!isFrameActivated)
{
- SetFocused();
+ return;
}
_TouchManager* pTouchMgr = _TouchManager::GetInstance();
, __systemWindow(false)
, __isOpened(false)
, __isInitialized(false)
- , __pFocusedControl(null)
+ , __pFocusControl(null)
+ , __pFocusTraversalControl(null)
, __transient(true)
, __dimmingEnabled(false)
, __rotation(-1)
}
void
-_Window::SetFocusedControl(const _Control* pControl)
+_Window::SetFocusControl(const _Control* pControl)
{
- __pFocusedControl = const_cast<_Control*>(pControl);
+ __pFocusControl = const_cast<_Control*>(pControl);
}
_Control*
-_Window::GetFocusedControl(void) const
+_Window::GetFocusControl(void) const
{
- return __pFocusedControl;
+ return __pFocusControl;
}
IListT<_Control*>*
return __orientationCallbackMode;
}
+_Control*
+_Window::GetFocusTraversalControl(void) const
+{
+ return __pFocusTraversalControl;
+}
+void
+_Window::SetFocusTraversalControl(_Control* pControl)
+{
+ __pFocusTraversalControl = pControl;
+}
}} // Tizen::Ui
#include "FUiCtrl_ScrollPanel.h"
#include "FUiCtrl_Toolbar.h"
#include "FUiCtrl_TableView.h"
+#include "FUi_Window.h"
using namespace Tizen::Base::Runtime;
bool focused = true;
if (__pParentPanel)
{
- if ((__pParentPanel->GetFocused() != __pEdit) && IsInternalFocused() == false)
+ _Window* pTop = __pParentPanel->GetRootWindow();
+ if (pTop)
{
- focused = false;
+ if ((pTop->GetFocusControl() != __pEdit) && IsInternalFocused() == false)
+ {
+ focused = false;
+ }
}
}
else if (IsInternalFocused() == false)
, __keypadShowstate(false)
, __clipboardShowstate(false)
, __pFormOrientationstatusEventListener(null)
+ , __pFocusControl(null)
+ , __pFocusTraversalControl(null)
{
Color color;
result r = GET_COLOR_CONFIG(FORM::BG_NORMAL,color);
}
void
+_Form::SetFocusControl(const _Control* pControl)
+{
+ __pFocusControl = const_cast<_Control*>(pControl);
+}
+
+_Control*
+_Form::GetFocusControl(void) const
+{
+ return __pFocusControl;
+}
+
+void
_Form::ResetFocusList(void)
{
if(__pFocusControlList)
return ORIENTATION_STATUS_PORTRAIT;
}
+_Control*
+_Form::GetFocusTraversalControl(void) const
+{
+ return __pFocusTraversalControl;
+}
+void
+_Form::SetFocusTraversalControl(_Control* pControl)
+{
+ __pFocusTraversalControl = pControl;
+}
}}} // Tizen::Ui::Controls
pCurrentForm->AddIndicatorObject();
- _Control* pFocusedControl = pCurrentForm->GetFocused();
- if (pFocusedControl)
+ _Control* pFocusControl = pCurrentForm->GetFocusControl();
+ if (pFocusControl)
{
- pFocusedControl->SetFocused();
+ pFocusControl->SetFocused();
}
else
{
{
if (pCurrentForm != pForm)
{
+ _Control* pFocusTraversalControl = pCurrentForm->GetFocusTraversalControl();
+ if (pFocusTraversalControl)
+ {
+ pFocusTraversalControl->SetFocusModeStateEnabled(false) ;
+ }
// Change order
r = MoveChildToTop(*pForm);
SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
}
}
- _Control* pFocus = pNewForm->GetFocused();
+ _Control* pFocus = pNewForm->GetFocusControl();
if (pFocus)
{
pFocus->SetFocused();
_Control* pOldCurrentForm = GetChild(controlCount - 2);
SysTryReturnVoidResult(NID_UI_CTRL, pOldCurrentForm != null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
pOldCurrentForm->SetVisibleState(false);
+ _Form* pOldForm = static_cast<_Form*>(pOldCurrentForm);
+ if (pOldForm)
+ {
+ _Control* pFocusTraversalControl = pOldForm->GetFocusTraversalControl();
+ if (pFocusTraversalControl)
+ {
+ pFocusTraversalControl->SetFocusModeStateEnabled(false) ;
+ }
+ }
}
}
}
pCurrentForm->ResetFocusList();
}
}
+
+_Control*
+_Frame::GetFocusControl(void) const
+{
+ _Form* pForm = GetCurrentForm();
+ if (pForm)
+ {
+ return pForm->GetFocusControl();
+ }
+ return null;
+}
+
+void
+_Frame::SetFocusControl(const _Control* pControl)
+{
+ _Form* pForm = GetCurrentForm();
+ if (pForm)
+ {
+ pForm->SetFocusControl(pControl);
+ }
+}
+
+
+Tizen::Base::Collection::IListT<_Control*>*
+_Frame::GetFocusList(void) const
+{
+ _Form* pForm = GetCurrentForm();
+ if (pForm)
+ {
+ return pForm->GetFocusList();
+ }
+ return null;
+}
+
+_Control*
+_Frame::GetFocusTraversalControl(void) const
+{
+ _Form* pForm = GetCurrentForm();
+ if (pForm)
+ {
+ return pForm->GetFocusTraversalControl();
+ }
+ return null;
+}
+
+void
+_Frame::SetFocusTraversalControl(_Control* pControl)
+{
+ _Form* pForm = GetCurrentForm();
+ if (pForm)
+ {
+ pForm->SetFocusTraversalControl(pControl);
+ }
+}
}}} // Tizen::Ui::Controls
#include "FUi_CoordinateSystemUtils.h"
#include "FUi_Math.h"
#include "FUiCtrl_LabelImpl.h"
+#include "FUi_Window.h"
using namespace Tizen::Base;
using namespace Tizen::Base::Runtime;
_TableViewItem::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
{
_KeyCode keyCode = keyInfo.GetKeyCode();
- _Control* pFocusedControl = GetFocused();
+ _Control* pFocusedControl = null;
+ _Window* pTop = source.GetRootWindow();
+ if (pTop)
+ {
+ pFocusedControl = pTop->GetFocusControl();
+ }
_Control* pChildControl = null;
switch (keyCode)
#include "FUiCtrl_TableViewItemProviderAdaptor.h"
#include "FUi_CoordinateSystemUtils.h"
#include "FUi_Math.h"
+#include "FUi_Window.h"
using namespace Tizen::Ui::Animations;
using namespace Tizen::Graphics;
using namespace Tizen::Base;
using namespace Tizen::Base::Runtime;
+using namespace Tizen::Ui::Controls;
namespace Tizen { namespace Ui { namespace Controls
{
_TableViewPresenter::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
{
_KeyCode keyCode = keyInfo.GetKeyCode();
- _Control* pFocusedControl = __pTableView->GetFocused();
+ _Control* pFocusedControl = null;
+ _Window* pTop = source.GetRootWindow();
+ if (pTop)
+ {
+ pFocusedControl = pTop->GetFocusControl();
+ }
+
_TableView* pTableView = null;
_TableViewItem* pItem = null;
TableViewItemTag itemPos = {-1, -1};
// Focus UI
Tizen::Base::Collection::IListT<_Control*>* GetFocusList(void) const;
void ResetFocusList(void);
+ _Control* GetFocusTraversalControl(void) const;
+ void SetFocusTraversalControl(_Control* pControl);
+
+// Focus
+ _Control* GetFocusControl(void) const;
+ void SetFocusControl(const _Control* pControl);
// Accessor
protected:
//For Focus UI
mutable std::unique_ptr<Tizen::Base::Collection::IListT<_Control*> > __pFocusControlList;
-
+ _Control* __pFocusControl;
+ _Control* __pFocusTraversalControl;
friend class _Frame;
friend class _OverlayRegionImpl;
}; // _Form
// Focus Ui
virtual void ResetFocusList(void);
+ virtual Tizen::Base::Collection::IListT<_Control*>* GetFocusList(void) const;
+ virtual _Control* GetFocusTraversalControl(void) const;
+ virtual void SetFocusTraversalControl(_Control* pControl);
+
+// Focus
+ virtual _Control* GetFocusControl(void) const;
+ virtual void SetFocusControl(const _Control* pControl);
protected:
result SetPresenter(const _FramePresenter& framePresenter);
bool IsFocusable(void) const;
void SetFocusable(bool focusable);
bool IsFocused(void) const;
- _Control* GetFocused(void) const;
result SetFocused(bool on = true);
- void SetFocusState(bool on);
bool IsNativeObjectFocusable(void) const;
void SetNativeObjectFocusable(bool focusable);
bool __visibleState;
bool __initVisibleState;
bool __clipToParent;
- bool __focusSet;
bool __multiTouchEnabled;
bool __dragEnabled;
bool __dropEnabled;
Tizen::Graphics::_BaseScreenSize GetLogicalBaseScreenSize(void) const;
// Focus
- _Control* GetFocusedControl(void) const;
- void SetFocusedControl(const _Control& control, bool on = true);
+ _Control* GetFocusControl(void) const;
+ void SetFocusControl(const _Control& control, bool on = true);
bool TakeFocusFromControl(const _Control& control);
// Queries
int __logicalCoordinateSystem;
Tizen::Graphics::_BaseScreenSize __logicalBaseScreenSize;
Tizen::Base::Collection::LinkedListT<_Window*>* __pSystemWindowList;
- _Control* __pFocusedControl;
+ _Control* __pFocusControl;
_ControlRotation __screenRotation;
_ControlRotation __orientationStatus;
_ControlOrientation __orientation;
_WindowType GetWindowType(void);
// Focus
- _Control* GetFocusedControl(void) const;
- void SetFocusedControl(const _Control* pControl);
+ virtual _Control* GetFocusControl(void) const;
+ virtual void SetFocusControl(const _Control* pControl);
// Callbacks
virtual void OnActivated(void);
virtual void OnNativeWindowActivated(void);
bool IsSystemWindow(void) const;
// Focus UI
- Tizen::Base::Collection::IListT<_Control*>* GetFocusList(void) const;
+ virtual Tizen::Base::Collection::IListT<_Control*>* GetFocusList(void) const;
virtual void ResetFocusList(void);
+ virtual _Control* GetFocusTraversalControl(void) const;
+ virtual void SetFocusTraversalControl(_Control* pControl);
// Dimming
result SetDimmingEnabled(bool enabled);
bool __systemWindow;
bool __isOpened;
bool __isInitialized;
- _Control* __pFocusedControl;
+ _Control* __pFocusControl;
+ _Control* __pFocusTraversalControl;
bool __transient;
bool __dimmingEnabled;