/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
// EXTERNAL INCLUDES
#include <cstring> // for strcmp
#include <dali/public-api/actors/layer.h>
-#include <dali/devel-api/adaptor-framework/accessibility-adaptor.h>
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
+#include <dali/devel-api/common/singleton-service.h>
+#include <dali/devel-api/adaptor-framework/lifecycle-controller.h>
#include <dali/public-api/animation/constraints.h>
-#include <dali/public-api/common/stage.h>
#include <dali/public-api/events/key-event.h>
-#include <dali/public-api/events/touch-data.h>
+#include <dali/public-api/events/touch-event.h>
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/type-registry-helper.h>
#include <dali/public-api/object/property-map.h>
-#include <dali/public-api/images/resource-image.h>
#include <dali/integration-api/debug.h>
+#include <dali/integration-api/adaptor-framework/adaptor.h>
+#include <dali/integration-api/adaptor-framework/scene-holder.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
-#include <dali-toolkit/public-api/accessibility-manager/accessibility-manager.h>
#include <dali-toolkit/devel-api/controls/control-devel.h>
#include <dali-toolkit/public-api/styling/style-manager.h>
#include <dali-toolkit/devel-api/styling/style-manager-devel.h>
+#include <dali/devel-api/adaptor-framework/accessibility.h>
namespace Dali
{
const char* const IS_FOCUS_GROUP_PROPERTY_NAME = "isKeyboardFocusGroup"; // This property will be replaced by a flag in Control.
-const char* const FOCUS_BORDER_IMAGE_PATH = DALI_IMAGE_DIR "keyboard_focus.9.png";
+const char* const FOCUS_BORDER_IMAGE_FILE_NAME = "keyboard_focus.9.png";
BaseHandle Create()
{
mFocusedActorEnterKeySignal(),
mCurrentFocusActor(),
mFocusIndicatorActor(),
- mIsFocusIndicatorShown( -1 ),
- mFocusGroupLoopEnabled( false ),
- mIsWaitingKeyboardFocusChangeCommit( false ),
- mClearFocusOnTouch( true ),
- mEnableFocusIndicator( true ),
- mAlwaysShowIndicator( true ),
mFocusHistory(),
mSlotDelegate( this ),
- mCustomAlgorithmInterface(NULL)
+ mCustomAlgorithmInterface(NULL),
+ mCurrentFocusedWindow(),
+ mIsFocusIndicatorShown( UNKNOWN ),
+ mEnableFocusIndicator( ENABLE ),
+ mAlwaysShowIndicator( ALWAYS_SHOW ),
+ mFocusGroupLoopEnabled( false ),
+ mIsWaitingKeyboardFocusChangeCommit( false ),
+ mClearFocusOnTouch( true )
{
// TODO: Get FocusIndicatorEnable constant from stylesheet to set mIsFocusIndicatorShown.
- Stage::GetCurrent().KeyEventSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnKeyEvent);
- Stage::GetCurrent().TouchSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch );
+
+ LifecycleController::Get().InitSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnAdaptorInit );
+}
+
+void KeyboardFocusManager::OnAdaptorInit()
+{
+ if( Adaptor::IsAvailable() )
+ {
+ // Retrieve all the existing scene holders
+ Dali::SceneHolderList sceneHolders = Adaptor::Get().GetSceneHolders();
+ for( auto iter = sceneHolders.begin(); iter != sceneHolders.end(); ++iter )
+ {
+ ( *iter ).KeyEventSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnKeyEvent );
+ ( *iter ).TouchedSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch );
+ Dali::Window window = DevelWindow::DownCast( *iter );
+ if( window )
+ {
+ window.FocusChangeSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnWindowFocusChanged);
+ }
+ }
+
+ // Get notified when any new scene holder is created afterwards
+ Adaptor::Get().WindowCreatedSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnSceneHolderCreated );
+ }
+}
+
+void KeyboardFocusManager::OnSceneHolderCreated( Dali::Integration::SceneHolder& sceneHolder )
+{
+ sceneHolder.KeyEventSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnKeyEvent );
+ sceneHolder.TouchedSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch );
+ Dali::Window window = DevelWindow::DownCast( sceneHolder );
+ if( window )
+ {
+ window.FocusChangeSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnWindowFocusChanged);
+ }
}
KeyboardFocusManager::~KeyboardFocusManager()
if( styleManager )
{
Property::Map config = Toolkit::DevelStyleManager::GetConfigurations( styleManager );
- mAlwaysShowIndicator = config["alwaysShowFocus"].Get<bool>();
- mIsFocusIndicatorShown = static_cast<int>(mAlwaysShowIndicator);
- mClearFocusOnTouch = mIsFocusIndicatorShown ? false : true;
+ mAlwaysShowIndicator = config["alwaysShowFocus"].Get<bool>() ? ALWAYS_SHOW : NONE;
+ mIsFocusIndicatorShown = ( mAlwaysShowIndicator == ALWAYS_SHOW )? SHOW : HIDE;
+ mClearFocusOnTouch = ( mIsFocusIndicatorShown == SHOW ) ? false : true;
}
}
{
DALI_ASSERT_DEBUG( !mIsWaitingKeyboardFocusChangeCommit && "Calling this function in the PreFocusChangeSignal callback?" );
- if( mIsFocusIndicatorShown == -1 )
+ if( mIsFocusIndicatorShown == UNKNOWN )
{
GetConfigurationFromStyleManger();
}
bool KeyboardFocusManager::DoSetCurrentFocusActor( Actor actor )
{
bool success = false;
+ if( actor && actor.GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE ) && actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) )
+ {
+ Integration::SceneHolder currentWindow = Integration::SceneHolder::Get( actor );
+
+ if( currentWindow.GetRootLayer() != mCurrentFocusedWindow.GetHandle())
+ {
+ Layer rootLayer = currentWindow.GetRootLayer();
+ mCurrentFocusedWindow = rootLayer;
+ }
+ }
Actor currentFocusedActor = GetCurrentFocusActor();
}
// Check whether the actor is in the stage and is keyboard focusable.
- if( actor && actor.IsKeyboardFocusable() && actor.OnStage() )
+ if( actor && actor.GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE ) && actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) )
{
- if( mIsFocusIndicatorShown && mEnableFocusIndicator )
+ if( ( mIsFocusIndicatorShown == SHOW ) && ( mEnableFocusIndicator == ENABLE ) )
{
actor.Add( GetFocusIndicatorActor() );
}
// Save the current focused actor
mCurrentFocusActor = actor;
+ bool focusedWindowFound = false;
+ for( unsigned int i = 0; i < mCurrentFocusActors.size(); i++ )
+ {
+ if( mCurrentFocusActors[i].first == mCurrentFocusedWindow )
+ {
+ mCurrentFocusActors[i].second = actor;
+ focusedWindowFound = true;
+ break;
+ }
+ }
+ if( !focusedWindowFound)
+ {
+ // A new window gains the focus, so store the focused actor in that window.
+ mCurrentFocusActors.push_back( std::pair< WeakHandle< Layer>, WeakHandle< Actor > >( mCurrentFocusedWindow , actor ));
+ }
+
Toolkit::Control newlyFocusedControl = Toolkit::Control::DownCast(actor);
if( newlyFocusedControl )
{
Actor KeyboardFocusManager::GetCurrentFocusActor()
{
Actor actor = mCurrentFocusActor.GetHandle();
- if( actor && ! actor.OnStage() )
+
+ if( actor && ! actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) )
{
// If the actor has been removed from the stage, then it should not be focused
-
actor.Reset();
mCurrentFocusActor.Reset();
}
return actor;
}
+Actor KeyboardFocusManager::GetFocusActorFromCurrentWindow()
+{
+ Actor actor;
+ unsigned int index;
+ for( index = 0; index < mCurrentFocusActors.size(); index++ )
+ {
+ if( mCurrentFocusActors[index].first == mCurrentFocusedWindow )
+ {
+ actor = mCurrentFocusActors[index].second.GetHandle();
+ break;
+ }
+ }
+
+ if( actor && ! actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) )
+ {
+ // If the actor has been removed from the window, then the window doesn't have any focused actor
+ actor.Reset();
+ mCurrentFocusActors.erase( mCurrentFocusActors.begin() + index );
+ }
+
+ return actor;
+}
+
Actor KeyboardFocusManager::GetCurrentFocusGroup()
{
return GetFocusGroup(GetCurrentFocusActor());
Actor target = mFocusHistory[ mFocusHistory.size() -1 ].GetHandle();
// Impl of Actor is not null
- if( target && target.OnStage() )
+ if( target && target.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) )
{
// Delete pre focused actor in history because it will pushed again by SetCurrentFocusActor()
mFocusHistory.pop_back();
Toolkit::Control KeyboardFocusManager::GetParentLayoutControl(Actor actor) const
{
// Get the actor's parent layout control that supports two dimensional keyboard navigation
- Actor rootActor = Stage::GetCurrent().GetRootLayer();
+ Actor rootActor;
Actor parent;
if(actor)
{
+ Integration::SceneHolder window = Integration::SceneHolder::Get( actor );
+ if ( window )
+ {
+ rootActor = window.GetRootLayer();
+ }
+
parent = actor.GetParent();
}
if( !nextFocusableActor )
{
- nextFocusableActor = Stage::GetCurrent().GetRootLayer().FindChildById( actorId );
+ Integration::SceneHolder window = Integration::SceneHolder::Get( currentFocusActor );
+ if ( window )
+ {
+ nextFocusableActor = window.GetRootLayer().FindChildById( actorId );
+ }
}
}
}
}
}
- if( nextFocusableActor && nextFocusableActor.IsKeyboardFocusable() )
+ if( nextFocusableActor && nextFocusableActor.GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE ) )
{
// Whether the next focusable actor is a layout control
if( IsLayoutControl( nextFocusableActor ) )
Actor nextFocusableActor = GetImplementation( control ).GetNextKeyboardFocusableActor(actor, direction, mFocusGroupLoopEnabled);
if(nextFocusableActor)
{
- if(!nextFocusableActor.IsKeyboardFocusable())
+ if(!nextFocusableActor.GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE ))
{
// If the actor is not focusable, ask the same layout control for the next actor to focus
return DoMoveFocusWithinLayoutControl(control, nextFocusableActor, direction);
mIsWaitingKeyboardFocusChangeCommit = false;
}
- if (committedFocusActor && committedFocusActor.IsKeyboardFocusable())
+ if (committedFocusActor && committedFocusActor.GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE ))
{
// Whether the commited focusable actor is a layout control
if(IsLayoutControl(committedFocusActor))
}
mCurrentFocusActor.Reset();
- mIsFocusIndicatorShown = static_cast<int>(mAlwaysShowIndicator);
+ mIsFocusIndicatorShown = ( mAlwaysShowIndicator == ALWAYS_SHOW ) ? SHOW : HIDE;
}
void KeyboardFocusManager::SetFocusGroupLoop(bool enabled)
if( ! mFocusIndicatorActor )
{
// Create the default if it hasn't been set and one that's shared by all the keyboard focusable actors
- mFocusIndicatorActor = Toolkit::ImageView::New( FOCUS_BORDER_IMAGE_PATH );
+ const std::string imageDirPath = AssetManager::GetDaliImagePath();
+ mFocusIndicatorActor = Toolkit::ImageView::New( imageDirPath + FOCUS_BORDER_IMAGE_FILE_NAME );
// Apply size constraint to the focus indicator
mFocusIndicatorActor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
}
- mFocusIndicatorActor.SetParentOrigin( ParentOrigin::CENTER );
- mFocusIndicatorActor.SetAnchorPoint( AnchorPoint::CENTER );
- mFocusIndicatorActor.SetPosition(0.0f, 0.0f);
+ mFocusIndicatorActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ mFocusIndicatorActor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+ mFocusIndicatorActor.SetProperty( Actor::Property::POSITION, Vector2(0.0f, 0.0f));
return mFocusIndicatorActor;
}
void KeyboardFocusManager::OnKeyEvent(const KeyEvent& event)
{
- AccessibilityAdaptor accessibilityAdaptor = AccessibilityAdaptor::Get();
- bool isAccessibilityEnabled = accessibilityAdaptor.IsEnabled();
+ std::string keyName = event.GetKeyName();
- Toolkit::AccessibilityManager accessibilityManager = Toolkit::AccessibilityManager::Get();
-
- std::string keyName = event.keyPressedName;
-
- if( mIsFocusIndicatorShown == -1 )
+ if( mIsFocusIndicatorShown == UNKNOWN )
{
GetConfigurationFromStyleManger();
}
bool isFocusStartableKey = false;
- if(event.state == KeyEvent::Down)
+ if(event.GetState() == KeyEvent::DOWN)
{
if (keyName == "Left")
{
- if(!isAccessibilityEnabled)
+ if(!mIsFocusIndicatorShown)
{
- if(!mIsFocusIndicatorShown)
+ if(mIsFocusIndicatorShown == HIDE)
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
}
else
{
- // Move the accessibility focus backward
- accessibilityManager.MoveFocusBackward();
+ // Move the focus towards left
+ MoveFocus(Toolkit::Control::KeyboardFocus::LEFT);
}
+
+ isFocusStartableKey = true;
}
else if (keyName == "Right")
{
- if(!isAccessibilityEnabled)
+ if(!mIsFocusIndicatorShown)
{
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
}
else
{
- // Move the accessibility focus forward
- accessibilityManager.MoveFocusForward();
+ // Move the focus towards right
+ MoveFocus(Toolkit::Control::KeyboardFocus::RIGHT);
}
isFocusStartableKey = true;
}
- else if (keyName == "Up" && !isAccessibilityEnabled)
+ else if (keyName == "Up")
{
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
isFocusStartableKey = true;
}
- else if (keyName == "Down" && !isAccessibilityEnabled)
+ else if (keyName == "Down")
{
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
isFocusStartableKey = true;
}
- else if (keyName == "Prior" && !isAccessibilityEnabled)
+ else if (keyName == "Prior")
{
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
isFocusStartableKey = true;
}
- else if (keyName == "Next" && !isAccessibilityEnabled)
+ else if (keyName == "Next")
{
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
isFocusStartableKey = true;
}
- else if (keyName == "Tab" && !isAccessibilityEnabled)
+ else if (keyName == "Tab")
{
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
isFocusStartableKey = true;
}
- else if (keyName == "space" && !isAccessibilityEnabled)
+ else if (keyName == "space")
{
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
isFocusStartableKey = true;
}
- else if (keyName == "" && !isAccessibilityEnabled)
+ else if (keyName == "")
{
// Check the fake key event for evas-plugin case
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
isFocusStartableKey = true;
}
- else if (keyName == "Backspace" && !isAccessibilityEnabled)
+ else if (keyName == "Backspace")
{
// Emit signal to go back to the previous view???
}
- else if (keyName == "Escape" && !isAccessibilityEnabled)
+ else if (keyName == "Escape")
{
}
}
- else if(event.state == KeyEvent::Up)
+ else if(event.GetState() == KeyEvent::UP)
{
if (keyName == "Return")
{
- if(!mIsFocusIndicatorShown && !isAccessibilityEnabled)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
// The focused actor has enter pressed on it
- Actor actor;
- if( !isAccessibilityEnabled )
- {
- actor = GetCurrentFocusActor();
- }
- else
- {
- actor = accessibilityManager.GetCurrentFocusActor();
- }
-
+ Actor actor = GetCurrentFocusActor();
if( actor )
{
DoKeyboardEnter( actor );
}
}
- if(isFocusStartableKey && mIsFocusIndicatorShown && !isAccessibilityEnabled)
+ if( isFocusStartableKey && mIsFocusIndicatorShown == SHOW )
{
Actor actor = GetCurrentFocusActor();
if( actor )
{
- if( mEnableFocusIndicator )
+ if( mEnableFocusIndicator == ENABLE )
{
// Make sure the focused actor is highlighted
actor.Add( GetFocusIndicatorActor() );
// Let's try to move the initial focus
MoveFocus(Toolkit::Control::KeyboardFocus::RIGHT);
}
+
}
}
-void KeyboardFocusManager::OnTouch(const TouchData& touch)
+void KeyboardFocusManager::OnTouch(const TouchEvent& touch)
{
- // if mIsFocusIndicatorShown is -1, it means Configuration is not loaded.
+ // if mIsFocusIndicatorShown is UNKNOWN, it means Configuration is not loaded.
// Try to load configuration.
- if( mIsFocusIndicatorShown == -1 )
+ if( mIsFocusIndicatorShown == UNKNOWN )
{
GetConfigurationFromStyleManger();
}
}
}
+void KeyboardFocusManager::OnWindowFocusChanged(Window window, bool focusIn )
+{
+ if( focusIn && mCurrentFocusedWindow.GetHandle() != window.GetRootLayer() )
+ {
+ // Change Current Focused Window
+ Layer rootLayer = window.GetRootLayer();
+ mCurrentFocusedWindow = rootLayer;
+
+ // Get Current Focused Actor from window
+ Actor currentFocusedActor = GetFocusActorFromCurrentWindow();
+ SetCurrentFocusActor( currentFocusedActor );
+
+ if( currentFocusedActor && ( mEnableFocusIndicator == ENABLE ) )
+ {
+ // Make sure the focused actor is highlighted
+ currentFocusedActor.Add( GetFocusIndicatorActor() );
+ mIsFocusIndicatorShown = SHOW;
+ }
+ }
+}
+
Toolkit::KeyboardFocusManager::PreFocusChangeSignalType& KeyboardFocusManager::PreFocusChangeSignal()
{
return mPreFocusChangeSignal;
mFocusIndicatorActor.Unparent();
}
- mEnableFocusIndicator = enable;
+ mEnableFocusIndicator = enable? ENABLE : DISABLE;
+
}
bool KeyboardFocusManager::IsFocusIndicatorEnabled() const
{
- return mEnableFocusIndicator;
+ return ( mEnableFocusIndicator == ENABLE );
}
} // namespace Internal
projects / platform / core / uifw / dali-toolkit.git / blobdiff