X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ffocus-manager%2Fkeyboard-focus-manager-impl.h;h=8212a79913dd86cfcca06547ff3d9758cf805dce;hb=00758f1301dd0bfbf6dc87659a6db9d0ba2c6816;hp=de3770fde1503a81de3169e54b15ab1b8ded4381;hpb=7f36ca9572ba3086167d5238a7aff909b56a50f4;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.h b/dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.h index de3770f..8212a79 100644 --- a/dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.h +++ b/dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.h @@ -1,8 +1,8 @@ -#ifndef __DALI_TOOLKIT_INTERNAL_KEYBOARD_FOCUS_MANAGER_H__ -#define __DALI_TOOLKIT_INTERNAL_KEYBOARD_FOCUS_MANAGER_H__ +#ifndef DALI_TOOLKIT_INTERNAL_KEYBOARD_FOCUS_MANAGER_H +#define DALI_TOOLKIT_INTERNAL_KEYBOARD_FOCUS_MANAGER_H /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2021 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,28 +19,53 @@ */ // EXTERNAL INCLUDES -#include -#include +#include #include +#include // INTERNAL INCLUDES +#include #include +#include namespace Dali { +namespace Integration +{ +class SceneHolder; + +} // namespace Integration namespace Toolkit { - namespace Internal { - /** * @copydoc Toolkit::KeyboardFocusManager */ -class KeyboardFocusManager : public Dali::BaseObject +class KeyboardFocusManager : public Dali::BaseObject, public ConnectionTracker { public: + typedef Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface CustomAlgorithmInterface; + + enum FocusIndicatorState + { + UNKNOWN = -1, ///< Unknown state + HIDE = 0, ///< FocusIndicator is hidden + SHOW = 1, ///< FocusIndicator is shown + }; + + enum EnableFocusedIndicatorState + { + DISABLE = 0, ///< FocusIndicator is disable + ENABLE = 1, ///< FocusIndicator is enable + }; + + enum FocusedIndicatorModeState + { + NONE = 0, ///< Set nothing + ALWAYS_SHOW = 1, ///< FocusIndicator is always shown + }; /** * @copydoc Toolkit::KeyboardFocusManager::Get @@ -107,9 +132,38 @@ public: */ Actor GetFocusIndicatorActor(); -public: + /** + * Move current focus to backward + */ + void MoveFocusBackward(); + + /** + * @copydoc Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm + */ + void SetCustomAlgorithm(CustomAlgorithmInterface& interface); + + /** + * @copydoc Toolkit::DevelKeyboardFocusManager::UseFocusIndicator + */ + void EnableFocusIndicator(bool enable); /** + * @copydoc Toolkit::DevelKeyboardFocusManager::UseFocusIndicator + */ + bool IsFocusIndicatorEnabled() const; + + /** + * @copydoc Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm + */ + void EnableDefaultAlgorithm(bool enable); + + /** + * @copydoc Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled + */ + bool IsDefaultAlgorithmEnabled() const; + +public: + /** * @copydoc Toolkit::KeyboardFocusManager::PreFocusChangeSignal() */ Toolkit::KeyboardFocusManager::PreFocusChangeSignalType& PreFocusChangeSignal(); @@ -138,16 +192,33 @@ public: * @return True if the signal was connected. * @post If a signal was connected, ownership of functor was passed to CallbackBase. Otherwise the caller is responsible for deleting the unused functor. */ - static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor ); + static bool DoConnectSignal(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor); protected: - /** * Destructor */ virtual ~KeyboardFocusManager(); private: + typedef std::vector > FocusStack; ///< Define Dali::Vector< Dali::BaseObject* > as FocusStack to contain focus history + typedef FocusStack::iterator FocusStackIterator; ///< Define FocusStack::Iterator as FocusStackIterator to navigate FocusStack + + /** + * This will be called when the adaptor is initialized + */ + void OnAdaptorInit(); + + /** + * This will be called when a new scene holder is created + * @param sceneHolder The new scene holder + */ + void OnSceneHolderCreated(Dali::Integration::SceneHolder& sceneHolder); + + /** + * Get configuration from StyleManager. + */ + void GetConfigurationFromStyleManger(); /** * Get the focus group of current focused actor. @@ -159,10 +230,10 @@ private: /** * Move the focus to the specified actor and send notification for the focus change. - * @param actorID The ID of the actor to be queried + * @param actor The actor to be queried * @return Whether the focus is successful or not */ - bool DoSetCurrentFocusActor(const unsigned int actorID); + bool DoSetCurrentFocusActor(Actor actor); /** * Move the focus to the next actor towards the specified direction within the layout control @@ -187,12 +258,7 @@ private: * This function will emit FocusedActorEnterKeySignal. * @param actor The actor to notify */ - void DoKeyboardEnter( Actor actor ); - - /** - * Create the default indicator actor to highlight the focused actor. - */ - void CreateDefaultFocusIndicatorActor(); + void DoKeyboardEnter(Actor actor); /** * Check whether the actor is a layout control that supports two dimensional keyboard navigation. @@ -210,7 +276,7 @@ private: * @param actor The actor to be checked for its parent layout control * @return The parent layout control the given actor belongs to or an empty handle if the given actor doesn't belong to a layout control */ - Toolkit::Control GetParentLayoutControl(Actor actor) const; + Toolkit::Control GetParentLayoutControl(Actor actor) const; /** * Callback for the key event when no actor in the stage has gained the key input focus @@ -221,43 +287,63 @@ private: /** * Callback for the touch event when the screen is touched and when the touch ends * (i.e. the down & up touch events only). - * @param[in] touchEvent The touch event + * @param[in] touch The touch information */ - void OnTouched(const TouchEvent& touchEvent); + void OnTouch(const TouchEvent& touch); /** - * Change the keyboard focus status when keyboard focus feature turned on or off. - * @return Whether the status is changed or not. + * Called when the window focus is changed. + * @param[in] window The window whose focus is changed + * @param[in] focusIn Whether the focus is in/out */ - void OnPhysicalKeyboardStatusChanged(PhysicalKeyboard keyboard); + void OnWindowFocusChanged(Window window, bool focusIn); -private: + /** + * Get the focus Actor from current window + */ + Actor GetFocusActorFromCurrentWindow(); +private: // Undefined KeyboardFocusManager(const KeyboardFocusManager&); KeyboardFocusManager& operator=(const KeyboardFocusManager& rhs); private: - - Toolkit::KeyboardFocusManager::PreFocusChangeSignalType mPreFocusChangeSignal; ///< The signal to notify the focus will be changed - Toolkit::KeyboardFocusManager::FocusChangedSignalType mFocusChangedSignal; ///< The signal to notify the focus change - Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType mFocusGroupChangedSignal; ///< The signal to notify the focus group change + Toolkit::KeyboardFocusManager::PreFocusChangeSignalType mPreFocusChangeSignal; ///< The signal to notify the focus will be changed + Toolkit::KeyboardFocusManager::FocusChangedSignalType mFocusChangedSignal; ///< The signal to notify the focus change + Toolkit::KeyboardFocusManager::FocusGroupChangedSignalType mFocusGroupChangedSignal; ///< The signal to notify the focus group change Toolkit::KeyboardFocusManager::FocusedActorEnterKeySignalType mFocusedActorEnterKeySignal; ///< The signal to notify that enter has been pressed on the focused actor - unsigned int mCurrentFocusActor; ///< The actor ID of current focused actor + WeakHandle mCurrentFocusActor; ///< A weak handle to the current focused actor Actor mFocusIndicatorActor; ///< The focus indicator actor shared by all the keyboard focusable actors for highlight - bool mFocusGroupLoopEnabled:1; ///< Whether the focus movement is looped within the same focus group + FocusStack mFocusHistory; ///< Stack to contain pre-focused actor's BaseObject* + + SlotDelegate mSlotDelegate; + + CustomAlgorithmInterface* mCustomAlgorithmInterface; ///< The user's (application / toolkit) implementation of CustomAlgorithmInterface + + typedef std::vector, WeakHandle > > FocusActorContainer; + + FocusActorContainer mCurrentFocusActors; ///< A container of focused actors + + WeakHandle mCurrentFocusedWindow; ///< A weak handle to the current focused window's root layer + + FocusIndicatorState mIsFocusIndicatorShown; ///< Whether indicator should be shown / hidden when getting focus. It could be enabled when keyboard focus feature is enabled and navigation keys or 'Tab' key are pressed. + + EnableFocusedIndicatorState mEnableFocusIndicator; ///< Whether use focus indicator + + FocusedIndicatorModeState mAlwaysShowIndicator; ///< Whether always show indicator. If true, the indicator would be directly shown when focused - bool mIsKeyboardFocusEnabled:1; ///< Whether keyboard focus feature turned on/off + bool mFocusGroupLoopEnabled : 1; ///< Whether the focus movement is looped within the same focus group - bool mIsFocusIndicatorEnabled:1; ///< Whether indicator should be shown / hidden. It could be enabled when keyboard focus feature enabled and navigation keys or 'Tab' key pressed. + bool mIsWaitingKeyboardFocusChangeCommit : 1; /// A flag to indicate PreFocusChangeSignal emitted but the proposed focus actor is not commited by the application yet. - bool mIsWaitingKeyboardFocusChangeCommit:1; /// A flag to indicate PreFocusChangeSignal emitted but the proposed focus actor is not commited by the application yet. + bool mClearFocusOnTouch : 1; ///< Whether clear focus on touch. - SlotDelegate< KeyboardFocusManager > mSlotDelegate; + bool mEnableDefaultAlgorithm : 1; ///< Whether use default algorithm focus }; } // namespace Internal @@ -284,4 +370,4 @@ inline const Internal::KeyboardFocusManager& GetImpl(const Dali::Toolkit::Keyboa } // namespace Dali -#endif // __DALI_TOOLKIT_INTERNAL_KEYBOARD_FOCUS_MANAGER_H__ +#endif // DALI_TOOLKIT_INTERNAL_KEYBOARD_FOCUS_MANAGER_H