/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2016 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/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/devel-api/object/type-registry-helper.h>
+#include <dali/public-api/object/type-registry-helper.h>
#include <dali/public-api/images/resource-image.h>
#include <dali/integration-api/debug.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>
namespace Dali
{
DALI_TYPE_REGISTRATION_BEGIN_CREATE( Toolkit::KeyboardFocusManager, Dali::BaseHandle, Create, true )
-DALI_SIGNAL_REGISTRATION( Toolkit, KeyboardFocusManager, "keyboardPreFocusChange", SIGNAL_PRE_FOCUS_CHANGE )
-DALI_SIGNAL_REGISTRATION( Toolkit, KeyboardFocusManager, "keyboardFocusChanged", SIGNAL_FOCUS_CHANGED )
-DALI_SIGNAL_REGISTRATION( Toolkit, KeyboardFocusManager, "keyboardFocusGroupChanged", SIGNAL_FOCUS_GROUP_CHANGED )
+DALI_SIGNAL_REGISTRATION( Toolkit, KeyboardFocusManager, "keyboardPreFocusChange", SIGNAL_PRE_FOCUS_CHANGE )
+DALI_SIGNAL_REGISTRATION( Toolkit, KeyboardFocusManager, "keyboardFocusChanged", SIGNAL_FOCUS_CHANGED )
+DALI_SIGNAL_REGISTRATION( Toolkit, KeyboardFocusManager, "keyboardFocusGroupChanged", SIGNAL_FOCUS_GROUP_CHANGED )
DALI_SIGNAL_REGISTRATION( Toolkit, KeyboardFocusManager, "keyboardFocusedActorEnterKey", SIGNAL_FOCUSED_ACTOR_ENTER_KEY )
DALI_TYPE_REGISTRATION_END()
+const unsigned int MAX_HISTORY_AMOUNT = 30; ///< Max length of focus history stack
+
} // unnamed namespace
Toolkit::KeyboardFocusManager KeyboardFocusManager::Get()
}
KeyboardFocusManager::KeyboardFocusManager()
-: mCurrentFocusActor(0),
- mFocusIndicatorActor(Actor()),
- mFocusGroupLoopEnabled(false),
- mIsKeyboardFocusEnabled(false),
- mIsFocusIndicatorEnabled(false),
- mIsWaitingKeyboardFocusChangeCommit(false),
- mSlotDelegate(this)
-{
- CreateDefaultFocusIndicatorActor();
-
- OnPhysicalKeyboardStatusChanged(PhysicalKeyboard::Get());
-
+: mPreFocusChangeSignal(),
+ mFocusChangedSignal(),
+ mFocusGroupChangedSignal(),
+ mFocusedActorEnterKeySignal(),
+ mCurrentFocusActor( 0 ),
+ mFocusIndicatorActor(),
+ mFocusGroupLoopEnabled( false ),
+ mIsFocusIndicatorEnabled( false ),
+ mIsWaitingKeyboardFocusChangeCommit( false ),
+ mFocusHistory(),
+ mSlotDelegate( this )
+{
+ // TODO: Get FocusIndicatorEnable constant from stylesheet to set mIsFocusIndicatorEnabled.
Toolkit::KeyInputFocusManager::Get().UnhandledKeyEventSignal().Connect(mSlotDelegate, &KeyboardFocusManager::OnKeyEvent);
- Stage::GetCurrent().TouchedSignal().Connect(mSlotDelegate, &KeyboardFocusManager::OnTouched);
- PhysicalKeyboard::Get().StatusChangedSignal().Connect(mSlotDelegate, &KeyboardFocusManager::OnPhysicalKeyboardStatusChanged);
+ Stage::GetCurrent().TouchSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch );
}
KeyboardFocusManager::~KeyboardFocusManager()
// Check whether the actor is in the stage and is keyboard focusable.
if( actor && actor.IsKeyboardFocusable() )
{
- mIsFocusIndicatorEnabled = true;
- // Draw the focus indicator upon the focused actor
- if( mFocusIndicatorActor )
+ if( mIsFocusIndicatorEnabled )
{
- actor.Add( mFocusIndicatorActor );
+ actor.Add( GetFocusIndicatorActor() );
}
-
// Send notification for the change of focus actor
+ Actor currentFocusedActor = GetCurrentFocusActor();
+
if( !mFocusChangedSignal.Empty() )
{
- mFocusChangedSignal.Emit(GetCurrentFocusActor(), actor);
+ mFocusChangedSignal.Emit(currentFocusedActor, actor);
+ }
+
+ Toolkit::Control currentlyFocusedControl = Toolkit::Control::DownCast(currentFocusedActor);
+ if( currentlyFocusedControl )
+ {
+ // Do we need it to remember if it was previously DISABLED?
+ currentlyFocusedControl.SetProperty(DevelControl::Property::STATE, DevelControl::NORMAL );
}
DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] Focus Changed\n", __FUNCTION__, __LINE__);
// Save the current focused actor
mCurrentFocusActor = actorID;
+ Toolkit::Control newlyFocusedControl = Toolkit::Control::DownCast(actor);
+ if( newlyFocusedControl )
+ {
+ newlyFocusedControl.SetProperty(DevelControl::Property::STATE, DevelControl::FOCUSED );
+ }
+
+ // Push Current Focused Actor to FocusHistory
+ mFocusHistory.PushBack( &actor.GetBaseObject() );
+
+ // Delete first element before add new element when Stack is full.
+ if( mFocusHistory.Count() > MAX_HISTORY_AMOUNT )
+ {
+ FocusStackIterator beginPos = mFocusHistory.Begin();
+ mFocusHistory.Erase( beginPos );
+ }
+
DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] SUCCEED\n", __FUNCTION__, __LINE__);
success = true;
}
return GetFocusGroup(GetCurrentFocusActor());
}
+void KeyboardFocusManager::MoveFocusBackward()
+{
+ // Find Pre Focused Actor when the list size is more than 1
+ if( mFocusHistory.Count() > 1 )
+ {
+ // Delete current focused actor in history
+ FocusStackIterator endPos = mFocusHistory.End();
+ endPos = mFocusHistory.Erase( --endPos );
+
+ // If pre-focused actors are not on stage, remove them in stack
+ while( !Dali::Actor::DownCast(BaseHandle(mFocusHistory[ mFocusHistory.Count() - 1 ])).OnStage() )
+ {
+ endPos = mFocusHistory.Erase( --endPos );
+ }
+
+ // Get pre focused actor
+ BaseObject* object = mFocusHistory[ mFocusHistory.Count() - 1 ];
+ BaseHandle handle( object );
+ Actor preFocusedActor = Dali::Actor::DownCast( handle );
+
+ // Delete pre focused actor in history because it will pushed again by SetCurrentFocusActor()
+ mFocusHistory.Erase( --endPos );
+
+ SetCurrentFocusActor( preFocusedActor );
+ }
+}
+
bool KeyboardFocusManager::IsLayoutControl(Actor actor) const
{
Toolkit::Control control = Toolkit::Control::DownCast(actor);
void KeyboardFocusManager::ClearFocus()
{
Actor actor = GetCurrentFocusActor();
- if(actor)
+ if( actor )
{
- if(mFocusIndicatorActor)
+ if( mFocusIndicatorActor )
{
- actor.Remove(mFocusIndicatorActor);
+ actor.Remove( mFocusIndicatorActor );
}
// Send notification for the change of focus actor
if( !mFocusChangedSignal.Empty() )
{
- mFocusChangedSignal.Emit(actor, Actor());
+ mFocusChangedSignal.Emit( actor, Actor() );
+ }
+
+ Toolkit::Control currentlyFocusedControl = Toolkit::Control::DownCast( actor );
+ if( currentlyFocusedControl )
+ {
+ currentlyFocusedControl.SetProperty( DevelControl::Property::STATE, DevelControl::NORMAL );
}
}
Actor KeyboardFocusManager::GetFocusIndicatorActor()
{
- return mFocusIndicatorActor;
-}
-
-void KeyboardFocusManager::CreateDefaultFocusIndicatorActor()
-{
- // Create a focus indicator actor shared by all the keyboard focusable actors
- Toolkit::ImageView focusIndicator = Toolkit::ImageView::New(FOCUS_BORDER_IMAGE_PATH);
- focusIndicator.SetParentOrigin( ParentOrigin::CENTER );
-
- // Apply size constraint to the focus indicator
- focusIndicator.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
-
- SetFocusIndicatorActor(focusIndicator);
-}
-
-void KeyboardFocusManager::OnPhysicalKeyboardStatusChanged(PhysicalKeyboard keyboard)
-{
- mIsKeyboardFocusEnabled = keyboard.IsAttached();
-
- if(mIsKeyboardFocusEnabled)
- {
- // Show indicator when keyboard focus turned on if there is focused actor.
- Actor actor = GetCurrentFocusActor();
- if(actor)
- {
- if(mFocusIndicatorActor)
- {
- actor.Add(mFocusIndicatorActor);
- }
- }
- mIsFocusIndicatorEnabled = true;
- }
- else
+ if( ! mFocusIndicatorActor )
{
- // Hide indicator when keyboard focus turned off
- Actor actor = GetCurrentFocusActor();
- if(actor)
- {
- actor.Remove(mFocusIndicatorActor);
- }
- mIsFocusIndicatorEnabled = false;
+ // 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 );
}
+
+ return mFocusIndicatorActor;
}
void KeyboardFocusManager::OnKeyEvent(const KeyEvent& event)
{
- if(!mIsKeyboardFocusEnabled)
- {
- return;
- }
-
AccessibilityAdaptor accessibilityAdaptor = AccessibilityAdaptor::Get();
bool isAccessibilityEnabled = accessibilityAdaptor.IsEnabled();
isFocusStartableKey = true;
}
+ else if (keyName == "Prior" && !isAccessibilityEnabled)
+ {
+ if(!mIsFocusIndicatorEnabled)
+ {
+ // Show focus indicator
+ mIsFocusIndicatorEnabled = true;
+ }
+ else
+ {
+ // Move the focus towards the previous page
+ MoveFocus(Toolkit::Control::KeyboardFocus::PAGE_UP);
+ }
+
+ isFocusStartableKey = true;
+ }
+ else if (keyName == "Next" && !isAccessibilityEnabled)
+ {
+ if(!mIsFocusIndicatorEnabled)
+ {
+ // Show focus indicator
+ mIsFocusIndicatorEnabled = true;
+ }
+ else
+ {
+ // Move the focus towards the next page
+ MoveFocus(Toolkit::Control::KeyboardFocus::PAGE_DOWN);
+ }
+
+ isFocusStartableKey = true;
+ }
else if (keyName == "Tab" && !isAccessibilityEnabled)
{
if(!mIsFocusIndicatorEnabled)
{
// Emit signal to go back to the previous view???
}
+ else if (keyName == "Escape" && !isAccessibilityEnabled)
+ {
+ }
}
else if(event.state == KeyEvent::Up)
{
if(isFocusStartableKey && mIsFocusIndicatorEnabled && !isAccessibilityEnabled)
{
Actor actor = GetCurrentFocusActor();
- if( !actor )
+ if( actor )
+ {
+ // Make sure the focused actor is highlighted
+ actor.Add( GetFocusIndicatorActor() );
+ }
+ else
{
// No actor is focused but keyboard focus is activated by the key press
// Let's try to move the initial focus
MoveFocus(Toolkit::Control::KeyboardFocus::RIGHT);
}
- else if(mFocusIndicatorActor)
- {
- // Make sure the focused actor is highlighted
- actor.Add(mFocusIndicatorActor);
- }
}
}
-void KeyboardFocusManager::OnTouched(const TouchEvent& touchEvent)
+void KeyboardFocusManager::OnTouch(const TouchData& touch)
{
// 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( ( touchEvent.GetPointCount() < 1 ) || ( touchEvent.GetPoint( 0 ).state == TouchPoint::Down ) )
+ if( ( touch.GetPointCount() < 1 ) || ( touch.GetState( 0 ) == PointState::DOWN ) )
{
ClearFocus();
}
Dali::BaseHandle handle( object );
bool connected( true );
- KeyboardFocusManager* manager = dynamic_cast<KeyboardFocusManager*>( object );
+ KeyboardFocusManager* manager = static_cast< KeyboardFocusManager* >( object ); // TypeRegistry guarantees that this is the correct type.
if( 0 == strcmp( signalName.c_str(), SIGNAL_PRE_FOCUS_CHANGE ) )
{
manager->PreFocusChangeSignal().Connect( tracker, functor );
}
- if( 0 == strcmp( signalName.c_str(), SIGNAL_FOCUS_CHANGED ) )
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_FOCUS_CHANGED ) )
{
manager->FocusChangedSignal().Connect( tracker, functor );
}
- if( 0 == strcmp( signalName.c_str(), SIGNAL_FOCUS_GROUP_CHANGED ) )
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_FOCUS_GROUP_CHANGED ) )
{
manager->FocusGroupChangedSignal().Connect( tracker, functor );
}