/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
#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/adaptor-framework/window-devel.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/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/adaptors/adaptor.h>
+#include <dali/integration-api/adaptors/scene-holder.h>
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
#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/focus-manager/keyinput-focus-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>
namespace Dali
{
mFocusChangedSignal(),
mFocusGroupChangedSignal(),
mFocusedActorEnterKeySignal(),
- mCurrentFocusActor( 0 ),
+ mCurrentFocusActor(),
mFocusIndicatorActor(),
+ mIsFocusIndicatorShown( -1 ),
mFocusGroupLoopEnabled( false ),
- mIsFocusIndicatorEnabled( false ),
mIsWaitingKeyboardFocusChangeCommit( false ),
+ mClearFocusOnTouch( true ),
+ mEnableFocusIndicator( true ),
+ mAlwaysShowIndicator( true ),
mFocusHistory(),
- mSlotDelegate( this )
+ mSlotDelegate( this ),
+ mCustomAlgorithmInterface(NULL)
{
- // TODO: Get FocusIndicatorEnable constant from stylesheet to set mIsFocusIndicatorEnabled.
- Toolkit::KeyInputFocusManager::Get().UnhandledKeyEventSignal().Connect(mSlotDelegate, &KeyboardFocusManager::OnKeyEvent);
- Stage::GetCurrent().TouchSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch );
+ // TODO: Get FocusIndicatorEnable constant from stylesheet to set mIsFocusIndicatorShown.
+
+ LifecycleController::Get().InitSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnAdaptorInit );
+}
+
+void KeyboardFocusManager::OnAdaptorInit()
+{
+ if( Adaptor::IsAvailable() )
+ {
+ // Retrieve all the existing widnows
+ Dali::WindowContainer windows = Adaptor::Get().GetWindows();
+ for ( auto iter = windows.begin(); iter != windows.end(); ++iter )
+ {
+ DevelWindow::KeyEventSignal( *iter ).Connect( mSlotDelegate, &KeyboardFocusManager::OnKeyEvent);
+ DevelWindow::TouchSignal( *iter ).Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch);
+ }
+
+ // Get notified when any new window is created afterwards
+ Adaptor::Get().WindowCreatedSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnWindowCreated);
+ }
+}
+
+void KeyboardFocusManager::OnWindowCreated( Dali::Window& window )
+{
+ DevelWindow::KeyEventSignal( window ).Connect( mSlotDelegate, &KeyboardFocusManager::OnKeyEvent);
+ DevelWindow::TouchSignal( window ).Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch);
}
KeyboardFocusManager::~KeyboardFocusManager()
{
}
+void KeyboardFocusManager::GetConfigurationFromStyleManger()
+{
+ Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
+ if( styleManager )
+ {
+ Property::Map config = Toolkit::DevelStyleManager::GetConfigurations( styleManager );
+ mAlwaysShowIndicator = config["alwaysShowFocus"].Get<bool>();
+ mIsFocusIndicatorShown = static_cast<int>(mAlwaysShowIndicator);
+ mClearFocusOnTouch = mIsFocusIndicatorShown ? false : true;
+ }
+}
+
bool KeyboardFocusManager::SetCurrentFocusActor( Actor actor )
{
DALI_ASSERT_DEBUG( !mIsWaitingKeyboardFocusChangeCommit && "Calling this function in the PreFocusChangeSignal callback?" );
- if( actor )
+ if( mIsFocusIndicatorShown == -1 )
{
- return DoSetCurrentFocusActor( actor.GetId() );
+ GetConfigurationFromStyleManger();
}
- return false;
+ return DoSetCurrentFocusActor( actor );
}
-bool KeyboardFocusManager::DoSetCurrentFocusActor( const unsigned int actorID )
+bool KeyboardFocusManager::DoSetCurrentFocusActor( Actor actor )
{
- Actor rootActor = Stage::GetCurrent().GetRootLayer();
- Actor actor = rootActor.FindChildById( actorID );
bool success = false;
+ Actor currentFocusedActor = GetCurrentFocusActor();
+
+ // If developer set focus on same actor, doing nothing
+ if( actor == currentFocusedActor )
+ {
+ if( !actor )
+ {
+ return false;
+ }
+ return true;
+ }
+
// Check whether the actor is in the stage and is keyboard focusable.
- if( actor && actor.IsKeyboardFocusable() )
+ if( actor && actor.IsKeyboardFocusable() && actor.OnStage() )
{
- if( mIsFocusIndicatorEnabled )
+ if( mIsFocusIndicatorShown && mEnableFocusIndicator )
{
actor.Add( GetFocusIndicatorActor() );
}
- // Send notification for the change of focus actor
- Actor currentFocusedActor = GetCurrentFocusActor();
+ // Send notification for the change of focus actor
if( !mFocusChangedSignal.Empty() )
{
mFocusChangedSignal.Emit(currentFocusedActor, actor);
{
// Do we need it to remember if it was previously DISABLED?
currentlyFocusedControl.SetProperty(DevelControl::Property::STATE, DevelControl::NORMAL );
+ currentlyFocusedControl.ClearKeyInputFocus();
}
DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] Focus Changed\n", __FUNCTION__, __LINE__);
// Save the current focused actor
- mCurrentFocusActor = actorID;
+ mCurrentFocusActor = actor;
Toolkit::Control newlyFocusedControl = Toolkit::Control::DownCast(actor);
if( newlyFocusedControl )
{
newlyFocusedControl.SetProperty(DevelControl::Property::STATE, DevelControl::FOCUSED );
+ newlyFocusedControl.SetKeyInputFocus();
}
// Push Current Focused Actor to FocusHistory
- mFocusHistory.PushBack( &actor.GetBaseObject() );
+ mFocusHistory.push_back( actor );
// Delete first element before add new element when Stack is full.
- if( mFocusHistory.Count() > MAX_HISTORY_AMOUNT )
+ if( mFocusHistory.size() > MAX_HISTORY_AMOUNT )
{
- FocusStackIterator beginPos = mFocusHistory.Begin();
- mFocusHistory.Erase( beginPos );
+ FocusStackIterator beginPos = mFocusHistory.begin();
+ mFocusHistory.erase( beginPos );
}
DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] SUCCEED\n", __FUNCTION__, __LINE__);
Actor KeyboardFocusManager::GetCurrentFocusActor()
{
- Actor rootActor = Stage::GetCurrent().GetRootLayer();
- return rootActor.FindChildById(mCurrentFocusActor);
+ Actor actor = mCurrentFocusActor.GetHandle();
+ if( actor && ! actor.OnStage() )
+ {
+ // If the actor has been removed from the stage, then it should not be focused
+
+ actor.Reset();
+ mCurrentFocusActor.Reset();
+ }
+ return actor;
}
Actor KeyboardFocusManager::GetCurrentFocusGroup()
void KeyboardFocusManager::MoveFocusBackward()
{
// Find Pre Focused Actor when the list size is more than 1
- if( mFocusHistory.Count() > 1 )
+ if( mFocusHistory.size() > 1 )
{
// Delete current focused actor in history
- FocusStackIterator endPos = mFocusHistory.End();
- endPos = mFocusHistory.Erase( --endPos );
+ mFocusHistory.pop_back();
- // If pre-focused actors are not on stage, remove them in stack
- while( !Dali::Actor::DownCast(BaseHandle(mFocusHistory[ mFocusHistory.Count() - 1 ])).OnStage() )
+ // If pre-focused actors are not on stage or deleted, remove them in stack
+ while( mFocusHistory.size() > 0 )
{
- endPos = mFocusHistory.Erase( --endPos );
- }
-
- // Get pre focused actor
- BaseObject* object = mFocusHistory[ mFocusHistory.Count() - 1 ];
- BaseHandle handle( object );
- Actor preFocusedActor = Dali::Actor::DownCast( handle );
+ // Get pre focused actor
+ Actor target = mFocusHistory[ mFocusHistory.size() -1 ].GetHandle();
- // Delete pre focused actor in history because it will pushed again by SetCurrentFocusActor()
- mFocusHistory.Erase( --endPos );
+ // Impl of Actor is not null
+ if( target && target.OnStage() )
+ {
+ // Delete pre focused actor in history because it will pushed again by SetCurrentFocusActor()
+ mFocusHistory.pop_back();
+ SetCurrentFocusActor( target );
+ break;
+ }
+ else
+ {
+ // Target is empty handle or off stage. Erase from queue
+ mFocusHistory.pop_back();
+ }
+ }
- SetCurrentFocusActor( preFocusedActor );
- }
+ // if there is no actor which can get focus, then push current focus actor in stack again
+ if( mFocusHistory.size() == 0 )
+ {
+ Actor currentFocusedActor = GetCurrentFocusActor();
+ mFocusHistory.push_back( currentFocusedActor );
+ }
+ }
}
bool KeyboardFocusManager::IsLayoutControl(Actor actor) const
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)
{
+ rootActor = Integration::SceneHolder::Get( actor ).GetRootLayer();
parent = actor.GetParent();
}
bool succeed = false;
// Go through the actor's hierarchy until we find a layout control that knows how to move the focus
- Toolkit::Control parentLayoutControl = GetParentLayoutControl(currentFocusActor);
- while(parentLayoutControl && !succeed)
+ Toolkit::Control parentLayoutControl = GetParentLayoutControl( currentFocusActor );
+ while( parentLayoutControl && !succeed )
{
- succeed = DoMoveFocusWithinLayoutControl(parentLayoutControl, currentFocusActor, direction);
- parentLayoutControl = GetParentLayoutControl(parentLayoutControl);
+ succeed = DoMoveFocusWithinLayoutControl( parentLayoutControl, currentFocusActor, direction );
+ parentLayoutControl = GetParentLayoutControl( parentLayoutControl );
}
- if(!succeed && !mPreFocusChangeSignal.Empty())
+ if( !succeed )
{
- // Don't know how to move the focus further. The application needs to tell us which actor to move the focus to
- mIsWaitingKeyboardFocusChangeCommit = true;
- Actor nextFocusableActor = mPreFocusChangeSignal.Emit(currentFocusActor, Actor(), direction);
- mIsWaitingKeyboardFocusChangeCommit = false;
+ Actor nextFocusableActor;
+
+ Toolkit::Control currentFocusControl = Toolkit::Control::DownCast(currentFocusActor);
+
+ // If the current focused actor is a control, then find the next focusable actor via the focusable properties.
+ if( currentFocusControl )
+ {
+ int actorId = -1;
+ Property::Index index = Property::INVALID_INDEX;
+ Property::Value value;
+
+ // Find property index based upon focus direction
+ switch ( direction )
+ {
+ case Toolkit::Control::KeyboardFocus::LEFT:
+ {
+ index = Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID;
+ break;
+ }
+ case Toolkit::Control::KeyboardFocus::RIGHT:
+ {
+ index = Toolkit::DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID;
+ break;
+ }
+ case Toolkit::Control::KeyboardFocus::UP:
+ {
+ index = Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID;
+ break;
+ }
+ case Toolkit::Control::KeyboardFocus::DOWN:
+ {
+ index = Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID;
+ break;
+ }
+ default:
+ break;
+ }
+
+ // If the focusable property is set then determine next focusable actor
+ if( index != Property::INVALID_INDEX)
+ {
+ value = currentFocusActor.GetProperty( index );
+ actorId = value.Get<int>();
+
+ // If actor's id is valid then find actor form actor's id. The actor should be on the stage.
+ if( actorId != -1 )
+ {
+ if( currentFocusActor.GetParent() )
+ {
+ nextFocusableActor = currentFocusActor.GetParent().FindChildById( actorId );
+ }
+
+ if( !nextFocusableActor )
+ {
+ nextFocusableActor = Integration::SceneHolder::Get( currentFocusActor ).GetRootLayer().FindChildById( actorId );
+ }
+ }
+ }
+ }
- if ( nextFocusableActor && nextFocusableActor.IsKeyboardFocusable() )
+ if( !nextFocusableActor )
+ {
+ // If the implementation of CustomAlgorithmInterface is provided then the PreFocusChangeSignal is no longer emitted.
+ if( mCustomAlgorithmInterface )
+ {
+ mIsWaitingKeyboardFocusChangeCommit = true;
+ nextFocusableActor = mCustomAlgorithmInterface->GetNextFocusableActor( currentFocusActor, Actor(), direction );
+ mIsWaitingKeyboardFocusChangeCommit = false;
+ }
+ else if( !mPreFocusChangeSignal.Empty() )
+ {
+ // Don't know how to move the focus further. The application needs to tell us which actor to move the focus to
+ mIsWaitingKeyboardFocusChangeCommit = true;
+ nextFocusableActor = mPreFocusChangeSignal.Emit( currentFocusActor, Actor(), direction );
+ mIsWaitingKeyboardFocusChangeCommit = false;
+ }
+ }
+
+ if( nextFocusableActor && nextFocusableActor.IsKeyboardFocusable() )
{
// Whether the next focusable actor is a layout control
- if(IsLayoutControl(nextFocusableActor))
+ if( IsLayoutControl( nextFocusableActor ) )
{
// If so, move the focus inside it.
- Toolkit::Control layoutControl = Toolkit::Control::DownCast(nextFocusableActor);
- succeed = DoMoveFocusWithinLayoutControl(layoutControl, currentFocusActor, direction);
+ Toolkit::Control layoutControl = Toolkit::Control::DownCast( nextFocusableActor) ;
+ succeed = DoMoveFocusWithinLayoutControl( layoutControl, currentFocusActor, direction );
}
else
{
// Otherwise, just set focus to the next focusable actor
- succeed = SetCurrentFocusActor(nextFocusableActor);
+ succeed = SetCurrentFocusActor( nextFocusableActor );
}
}
}
if( currentlyFocusedControl )
{
currentlyFocusedControl.SetProperty( DevelControl::Property::STATE, DevelControl::NORMAL );
+ currentlyFocusedControl.ClearKeyInputFocus();
}
}
- mCurrentFocusActor = 0;
- mIsFocusIndicatorEnabled = false;
+ mCurrentFocusActor.Reset();
+ mIsFocusIndicatorShown = static_cast<int>(mAlwaysShowIndicator);
}
void KeyboardFocusManager::SetFocusGroupLoop(bool enabled)
{
// 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 );
- mFocusIndicatorActor.SetParentOrigin( ParentOrigin::CENTER );
// 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);
+
return mFocusIndicatorActor;
}
std::string keyName = event.keyPressedName;
+ if( mIsFocusIndicatorShown == -1 )
+ {
+ GetConfigurationFromStyleManger();
+ }
+
bool isFocusStartableKey = false;
if(event.state == KeyEvent::Down)
{
if(!isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = true;
+ mIsFocusIndicatorShown = 1;
}
else
{
{
if(!isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = true;
+ mIsFocusIndicatorShown = 1;
}
else
{
}
else if (keyName == "Up" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = true;
+ mIsFocusIndicatorShown = 1;
}
else
{
}
else if (keyName == "Down" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = true;
+ mIsFocusIndicatorShown = 1;
}
else
{
}
else if (keyName == "Prior" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = true;
+ mIsFocusIndicatorShown = 1;
}
else
{
}
else if (keyName == "Next" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = true;
+ mIsFocusIndicatorShown = 1;
}
else
{
}
else if (keyName == "Tab" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = true;
+ mIsFocusIndicatorShown = 1;
}
else
{
}
else if (keyName == "space" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = true;
+ mIsFocusIndicatorShown = 1;
}
isFocusStartableKey = true;
else if (keyName == "" && !isAccessibilityEnabled)
{
// Check the fake key event for evas-plugin case
- if(!mIsFocusIndicatorEnabled)
+ if(!mIsFocusIndicatorShown)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = true;
+ mIsFocusIndicatorShown = 1;
}
isFocusStartableKey = true;
{
if (keyName == "Return")
{
- if(!mIsFocusIndicatorEnabled && !isAccessibilityEnabled)
+ if(!mIsFocusIndicatorShown && !isAccessibilityEnabled)
{
// Show focus indicator
- mIsFocusIndicatorEnabled = true;
+ mIsFocusIndicatorShown = 1;
}
else
{
}
}
- if(isFocusStartableKey && mIsFocusIndicatorEnabled && !isAccessibilityEnabled)
+ if(isFocusStartableKey && mIsFocusIndicatorShown && !isAccessibilityEnabled)
{
Actor actor = GetCurrentFocusActor();
if( actor )
{
- // Make sure the focused actor is highlighted
- actor.Add( GetFocusIndicatorActor() );
+ if( mEnableFocusIndicator )
+ {
+ // Make sure the focused actor is highlighted
+ actor.Add( GetFocusIndicatorActor() );
+ }
}
else
{
void KeyboardFocusManager::OnTouch(const TouchData& touch)
{
+ // if mIsFocusIndicatorShown is -1, it means Configuration is not loaded.
+ // Try to load configuration.
+ if( mIsFocusIndicatorShown == -1 )
+ {
+ GetConfigurationFromStyleManger();
+ }
+
// Clear the focus when user touch the screen.
// We only do this on a Down event, otherwise the clear action may override a manually focused actor.
- if( ( touch.GetPointCount() < 1 ) || ( touch.GetState( 0 ) == PointState::DOWN ) )
+ // If mClearFocusOnTouch is false, do not clear the focus even if user touch the screen.
+ if( (( touch.GetPointCount() < 1 ) || ( touch.GetState( 0 ) == PointState::DOWN )) && mClearFocusOnTouch )
{
ClearFocus();
}
return connected;
}
+void KeyboardFocusManager::SetCustomAlgorithm(CustomAlgorithmInterface& interface)
+{
+ mCustomAlgorithmInterface = &interface;
+}
+
+void KeyboardFocusManager::EnableFocusIndicator(bool enable)
+{
+ if( !enable && mFocusIndicatorActor )
+ {
+ mFocusIndicatorActor.Unparent();
+ }
+
+ mEnableFocusIndicator = enable;
+}
+
+bool KeyboardFocusManager::IsFocusIndicatorEnabled() const
+{
+ return mEnableFocusIndicator;
+}
+
} // namespace Internal
} // namespace Toolkit
projects / platform / core / uifw / dali-toolkit.git / blobdiff