/*
- * Copyright (c) 2019 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/actors/actor-devel.h>
#include <dali/devel-api/adaptor-framework/accessibility-adaptor.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/accessibility-manager/accessibility-manager.h>
#include <dali-toolkit/devel-api/controls/control-devel.h>
+#include <dali-toolkit/devel-api/focus-manager/focus-finder.h>
#include <dali-toolkit/public-api/styling/style-manager.h>
#include <dali-toolkit/devel-api/styling/style-manager-devel.h>
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()
{
mAlwaysShowIndicator( ALWAYS_SHOW ),
mFocusGroupLoopEnabled( false ),
mIsWaitingKeyboardFocusChangeCommit( false ),
- mClearFocusOnTouch( true )
+ mClearFocusOnTouch( true ),
+ mEnableDefaultAlgorithm(false)
{
// TODO: Get FocusIndicatorEnable constant from stylesheet to set mIsFocusIndicatorShown.
for( auto iter = sceneHolders.begin(); iter != sceneHolders.end(); ++iter )
{
( *iter ).KeyEventSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnKeyEvent );
- ( *iter ).TouchSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch );
+ ( *iter ).TouchedSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch );
Dali::Window window = DevelWindow::DownCast( *iter );
if( window )
{
void KeyboardFocusManager::OnSceneHolderCreated( Dali::Integration::SceneHolder& sceneHolder )
{
sceneHolder.KeyEventSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnKeyEvent );
- sceneHolder.TouchSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch );
+ sceneHolder.TouchedSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch );
Dali::Window window = DevelWindow::DownCast( sceneHolder );
if( window )
{
bool KeyboardFocusManager::DoSetCurrentFocusActor( Actor actor )
{
bool success = false;
- if( actor && actor.IsKeyboardFocusable() && actor.OnStage() )
+
+ // If the parent's KEYBOARD_FOCUSABLE_CHILDREN is false, it cannot have focus.
+ if(actor)
+ {
+ Actor parent = actor.GetParent();
+ while(parent)
+ {
+ if(!parent.GetProperty<bool>(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN))
+ {
+ DALI_LOG_INFO(gLogFilter, Debug::General, "[%s:%d] Parent Actor has KEYBOARD_FOCUSABLE_CHILDREN false,\n", __FUNCTION__, __LINE__);
+ return false;
+ }
+ parent = parent.GetParent();
+ }
+ }
+
+ if(actor && actor.GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE) && actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE))
{
Integration::SceneHolder currentWindow = Integration::SceneHolder::Get( actor );
}
// 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 == SHOW ) && ( mEnableFocusIndicator == ENABLE ) )
{
{
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();
}
}
- if( actor && ! actor.OnStage() )
+ 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();
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();
nextFocusableActor = mPreFocusChangeSignal.Emit( currentFocusActor, Actor(), direction );
mIsWaitingKeyboardFocusChangeCommit = false;
}
+ else if(mEnableDefaultAlgorithm)
+ {
+ // We should find it among the actors nearby.
+ Integration::SceneHolder window = Integration::SceneHolder::Get(currentFocusActor);
+ if(window)
+ {
+ nextFocusableActor = Toolkit::FocusFinder::GetNearestFocusableActor(window.GetRootLayer(), currentFocusActor, direction);
+ }
+ }
}
- 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))
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;
}
Toolkit::AccessibilityManager accessibilityManager = Toolkit::AccessibilityManager::Get();
- std::string keyName = event.keyPressedName;
+ std::string keyName = event.GetKeyName();
if( mIsFocusIndicatorShown == UNKNOWN )
{
bool isFocusStartableKey = false;
- if(event.state == KeyEvent::Down)
+ if(event.GetState() == KeyEvent::DOWN)
{
if (keyName == "Left")
{
{
// "Tab" key changes the focus group in the forward direction and
// "Shift-Tab" key changes it in the backward direction.
- DoMoveFocusToNextFocusGroup(!event.IsShiftModifier());
+ if(!DoMoveFocusToNextFocusGroup(!event.IsShiftModifier()))
+ {
+ // If the focus group is not changed, Move the focus towards right, "Shift-Tap" key moves the focus towards left.
+ if(!MoveFocus(event.IsShiftModifier() ? Toolkit::Control::KeyboardFocus::LEFT : Toolkit::Control::KeyboardFocus::RIGHT))
+ {
+ // If the focus is not moved, Move the focus towards down, "Shift-Tap" key moves the focus towards up.
+ MoveFocus(event.IsShiftModifier() ? Toolkit::Control::KeyboardFocus::UP : Toolkit::Control::KeyboardFocus::DOWN);
+ }
+ }
}
isFocusStartableKey = true;
{
}
}
- else if(event.state == KeyEvent::Up)
+ else if(event.GetState() == KeyEvent::UP)
{
if (keyName == "Return")
{
}
}
-void KeyboardFocusManager::OnTouch(const TouchData& touch)
+void KeyboardFocusManager::OnTouch(const TouchEvent& touch)
{
// if mIsFocusIndicatorShown is UNKNOWN, it means Configuration is not loaded.
// Try to load configuration.
// 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 mClearFocusOnTouch is false, do not clear the focus even if user touch the screen.
- if( (( touch.GetPointCount() < 1 ) || ( touch.GetState( 0 ) == PointState::DOWN )) && mClearFocusOnTouch )
+ if(((touch.GetPointCount() < 1) || (touch.GetState(0) == PointState::DOWN)))
{
- ClearFocus();
+ // If mClearFocusOnTouch is false, do not clear the focus even if user touch the screen.
+ if(mClearFocusOnTouch)
+ {
+ ClearFocus();
+ }
+
+ // If KEYBOARD_FOCUSABLE and TOUCH_FOCUSABLE is true, set focus actor
+ Actor hitActor = touch.GetHitActor(0);
+ if(hitActor && hitActor.GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE) && hitActor.GetProperty<bool>(DevelActor::Property::TOUCH_FOCUSABLE))
+ {
+ SetCurrentFocusActor(hitActor);
+ }
}
}
return ( mEnableFocusIndicator == ENABLE );
}
+void KeyboardFocusManager::EnableDefaultAlgorithm(bool enable)
+{
+ mEnableDefaultAlgorithm = enable;
+}
+
+bool KeyboardFocusManager::IsDefaultAlgorithmEnabled() const
+{
+ return mEnableDefaultAlgorithm;
+}
+
} // namespace Internal
} // namespace Toolkit
projects / platform / core / uifw / dali-toolkit.git / blobdiff