/*
- * Copyright (c) 2015 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.
#include <dali/devel-api/adaptor-framework/sound-player.h>
#include <dali/public-api/animation/constraints.h>
#include <dali/devel-api/events/hit-test-algorithm.h>
-#include <dali/public-api/images/resource-image.h>
#include <dali/integration-api/debug.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>
const char* const ACTOR_FOCUSABLE("focusable");
const char* const IS_FOCUS_GROUP("isFocusGroup");
-const char* FOCUS_BORDER_IMAGE_PATH = DALI_IMAGE_DIR "B16-8_TTS_focus.9.png";
+const char* FOCUS_BORDER_IMAGE_FILE_NAME = "B16-8_TTS_focus.9.png";
-const char* FOCUS_SOUND_FILE = DALI_SOUND_DIR "Focus.ogg";
-const char* FOCUS_CHAIN_END_SOUND_FILE = DALI_SOUND_DIR "End_of_List.ogg";
+const char* FOCUS_SOUND_FILE_NAME = "Focus.ogg";
+const char* FOCUS_CHAIN_END_SOUND_FILE_NAME = "End_of_List.ogg";
/**
* The function to be used in the hit-test algorithm to check whether the actor is hittable.
case Dali::HitTestAlgorithm::CHECK_ACTOR:
{
// Check whether the actor is visible and not fully transparent.
- if( actor.IsVisible()
- && actor.GetCurrentWorldColor().a > 0.01f) // not FULLY_TRANSPARENT
+ if( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE )
+ && actor.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ).a > 0.01f) // not FULLY_TRANSPARENT
{
// Check whether the actor is focusable
Property::Index propertyActorFocusable = actor.GetPropertyIndex(ACTOR_FOCUSABLE);
}
case Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE:
{
- if( actor.IsVisible() ) // Actor is visible, if not visible then none of its children are visible.
+ if( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) ) // Actor is visible, if not visible then none of its children are visible.
{
hittable = true;
}
AccessibilityManager::AccessibilityManager()
: mCurrentFocusActor(FocusIDPair(0, 0)),
- mFocusIndicatorActor(Actor()),
+ mCurrentGesturedActor(),
+ mFocusIndicatorActor(),
+ mPreviousPosition( 0.0f, 0.0f ),
mRecursiveFocusMoveCounter(0),
+ mFocusSoundFilePath(),
+ mFocusChainEndSoundFilePath(),
mIsWrapped(false),
mIsFocusWithinGroup(false),
mIsEndcapFeedbackEnabled(false),
mIsAccessibilityTtsEnabled(false),
mTtsCreated(false),
mIsFocusIndicatorEnabled(false),
- mContinuousPlayMode(false)
+ mContinuousPlayMode(false),
+ mIsFocusSoundFilePathSet(false),
+ mIsFocusChainEndSoundFilePathSet(false)
{
}
void AccessibilityManager::Initialise()
{
- CreateDefaultFocusIndicatorActor();
-
AccessibilityAdaptor adaptor = AccessibilityAdaptor::Get();
adaptor.SetActionHandler(*this);
adaptor.SetGestureHandler(*this);
{
if(actor)
{
- unsigned int actorID = actor.GetId();
+ unsigned int actorID = actor.GetProperty< int >( Actor::Property::ID );
ActorAdditionalInfo info = GetActorAdditionalInfo(actorID);
info.mAccessibilityAttributes[type] = text;
if(actor)
{
- ActorAdditionalInfo data = GetActorAdditionalInfo(actor.GetId());
+ ActorAdditionalInfo data = GetActorAdditionalInfo(actor.GetProperty< int >( Actor::Property::ID ));
text = data.mAccessibilityAttributes[type];
}
actor.SetProperty(propertyActorFocusable, true);
// Now we insert the actor into the focus chain with the specified focus order
- mFocusIDContainer.insert(FocusIDPair(order, actor.GetId()));
+ mFocusIDContainer.insert(FocusIDPair(order, actor.GetProperty< int >( Actor::Property::ID )));
}
// Update the actor's focus order in its additional data
- SynchronizeActorAdditionalInfo(actor.GetId(), order);
+ SynchronizeActorAdditionalInfo(actor.GetProperty< int >( Actor::Property::ID ), order);
}
}
if(actor)
{
- ActorAdditionalInfo data = GetActorAdditionalInfo(actor.GetId());
+ ActorAdditionalInfo data = GetActorAdditionalInfo(actor.GetProperty< int >( Actor::Property::ID ));
focusOrder = data.mFocusOrder;
}
{
if(actor)
{
- return DoSetCurrentFocusActor(actor.GetId());
+ return DoSetCurrentFocusActor(actor.GetProperty< int >( Actor::Property::ID ));
}
return false;
}
// Go through the actor's hierarchy to check whether the actor is visible
- bool actorVisible = actor.IsVisible();
+ bool actorVisible = actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE );
Actor parent = actor.GetParent();
while (actorVisible && parent && parent != rootActor)
{
- actorVisible = parent.IsVisible();
+ actorVisible = parent.GetCurrentProperty< bool >( Actor::Property::VISIBLE );
parent = parent.GetParent();
}
// Check whether the actor is fully transparent
- bool actorOpaque = actor.GetCurrentWorldColor().a > 0.01f;
+ bool actorOpaque = actor.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ).a > 0.01f;
// Set the focus only when the actor is focusable and visible and not fully transparent
if(actorVisible && actorFocusable && actorOpaque)
{
// Draw the focus indicator upon the focused actor
- if(mIsFocusIndicatorEnabled && mFocusIndicatorActor)
+ if( mIsFocusIndicatorEnabled )
{
- actor.Add(mFocusIndicatorActor);
+ actor.Add( GetFocusIndicatorActor() );
}
// Send notification for the change of focus actor
Dali::SoundPlayer soundPlayer = Dali::SoundPlayer::Get();
if(soundPlayer)
{
- soundPlayer.PlaySound(FOCUS_SOUND_FILE);
+ if (!mIsFocusSoundFilePathSet)
+ {
+ const std::string soundDirPath = AssetManager::GetDaliSoundPath();
+ mFocusSoundFilePath = soundDirPath + FOCUS_SOUND_FILE_NAME;
+ mIsFocusSoundFilePathSet = true;
+ }
+ soundPlayer.PlaySound(mFocusSoundFilePath);
}
// Play the accessibility attributes with the TTS player.
void AccessibilityManager::ClearFocus()
{
Actor actor = GetCurrentFocusActor();
- if(actor)
+ if( actor && mFocusIndicatorActor )
{
- actor.Remove(mFocusIndicatorActor);
+ actor.Remove( mFocusIndicatorActor );
}
mCurrentFocusActor = FocusIDPair(0, 0);
void AccessibilityManager::SetFocusIndicatorActor(Actor indicator)
{
- mFocusIndicatorActor = indicator;
+ if( mFocusIndicatorActor != indicator )
+ {
+ Actor currentFocusActor = GetCurrentFocusActor();
+ if( currentFocusActor )
+ {
+ // The new focus indicator should be added to the current focused actor immediately
+ if( mFocusIndicatorActor )
+ {
+ currentFocusActor.Remove( mFocusIndicatorActor );
+ }
+
+ if( indicator )
+ {
+ currentFocusActor.Add( indicator );
+ }
+ }
+
+ mFocusIndicatorActor = indicator;
+ }
}
Actor AccessibilityManager::GetFocusIndicatorActor()
{
+ if( ! mFocusIndicatorActor )
+ {
+ // Create the default if it hasn't been set and one that's shared by all the keyboard focusable actors
+ const std::string imageDirPath = AssetManager::GetDaliImagePath();
+ const std::string focusBorderImagePath = imageDirPath + FOCUS_BORDER_IMAGE_FILE_NAME;
+
+ mFocusIndicatorActor = Toolkit::ImageView::New(focusBorderImagePath);
+ mFocusIndicatorActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ mFocusIndicatorActor.SetProperty( Actor::Property::POSITION_Z, 1.0f );
+
+ // Apply size constraint to the focus indicator
+ mFocusIndicatorActor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+ }
+
return mFocusIndicatorActor;
}
Dali::SoundPlayer soundPlayer = Dali::SoundPlayer::Get();
if(soundPlayer)
{
- soundPlayer.PlaySound(FOCUS_CHAIN_END_SOUND_FILE);
+ if (!mIsFocusChainEndSoundFilePathSet)
+ {
+ const std::string soundDirPath = AssetManager::GetDaliSoundPath();
+ mFocusChainEndSoundFilePath = soundDirPath + FOCUS_CHAIN_END_SOUND_FILE_NAME;
+ mIsFocusChainEndSoundFilePathSet = true;
+ }
+ soundPlayer.PlaySound(mFocusChainEndSoundFilePath);
}
mIsEndcapFeedbackPlayed = true;
}
}
-void AccessibilityManager::CreateDefaultFocusIndicatorActor()
-{
- // Create a focus indicator actor shared by all the focusable actors
- Toolkit::ImageView focusIndicator = Toolkit::ImageView::New(FOCUS_BORDER_IMAGE_PATH);
- focusIndicator.SetParentOrigin( ParentOrigin::CENTER );
- focusIndicator.SetPosition(Vector3(0.0f, 0.0f, 1.0f));
-
- // Apply size constraint to the focus indicator
- focusIndicator.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
-
- SetFocusIndicatorActor(focusIndicator);
-}
-
bool AccessibilityManager::ChangeAccessibilityStatus()
{
AccessibilityAdaptor adaptor = AccessibilityAdaptor::Get();
Actor actor = GetCurrentFocusActor();
if(actor)
{
- if(mFocusIndicatorActor)
- {
- actor.Add(mFocusIndicatorActor);
- }
+ actor.Add( GetFocusIndicatorActor() );
}
mIsFocusIndicatorEnabled = true;
{
// Hide indicator when tts turned off
Actor actor = GetCurrentFocusActor();
- if(actor)
+ if( actor && mFocusIndicatorActor )
{
- actor.Remove(mFocusIndicatorActor);
+ actor.Remove( mFocusIndicatorActor );
}
mIsFocusIndicatorEnabled = false;
}
}
-bool AccessibilityManager::AccessibilityActionScroll( Dali::TouchEvent& touchEvent )
+bool AccessibilityManager::AccessibilityActionScroll( Dali::TouchData& touchData )
{
Dali::Toolkit::AccessibilityManager handle( this );
if( !mActionScrollSignal.Empty() )
{
- mActionScrollSignal.Emit( handle, touchEvent );
+ mActionScrollSignal.Emit( handle, touchData );
}
return true;
return ret;
}
-bool AccessibilityManager::AccessibilityActionReadIndicatorInformation()
-{
- Dali::Toolkit::AccessibilityManager handle( this );
- if( !mActionReadIndicatorInformationSignal.Empty() )
- {
- mActionReadIndicatorInformationSignal.Emit( handle );
- }
-
- // TODO: Read the information in the indicator
-
- return mIsAccessibilityTtsEnabled;
-}
-
bool AccessibilityManager::AccessibilityActionReadPauseResume()
{
Dali::Toolkit::AccessibilityManager handle( this );
return mIsAccessibilityTtsEnabled;
}
-bool AccessibilityManager::AccessibilityActionTouch(const TouchEvent& touchEvent)
+bool AccessibilityManager::AccessibilityActionTouch(const TouchData& touchData)
{
bool handled = false;
Dali::Toolkit::Control control = Dali::Toolkit::Control::DownCast(GetCurrentFocusActor());
if(control)
{
- handled = GetImplementation( control ).OnAccessibilityTouch(touchEvent);
+ handled = GetImplementation( control ).OnAccessibilityTouch(touchData);
}
return handled;
}
-bool AccessibilityManager::HandlePanGesture(const Integration::PanGestureEvent& panEvent)
+bool AccessibilityManager::HandlePanGesture(const AccessibilityGestureEvent& panEvent)
{
bool handled = false;
- if( panEvent.state == Gesture::Started )
+ if( panEvent.state == AccessibilityGestureEvent::Started )
{
// Find the focusable actor at the event position
Dali::HitTestAlgorithm::Results results;
if(!mCurrentGesturedActor)
{
- DALI_LOG_ERROR("Gesture detected, but no hit actor");
+ DALI_LOG_ERROR("Gesture detected, but no hit actor\n");
}
}
// Gesture::Finished (Up) events are delivered with previous (Motion) event position
// Use the real previous position; otherwise we may incorrectly get a ZERO velocity
- if ( Gesture::Finished != panEvent.state )
+ if ( AccessibilityGestureEvent::Finished != panEvent.state )
{
// Store the previous position for next Gesture::Finished iteration.
mPreviousPosition = panEvent.previousPosition;
Actor rootActor = Stage::GetCurrent().GetRootLayer();
- Dali::PanGesture pan(panEvent.state);
+ Dali::PanGesture pan( static_cast<Dali::Gesture::State>(panEvent.state) );
+
pan.time = panEvent.time;
pan.numberOfTouches = panEvent.numberOfTouches;
pan.screenPosition = panEvent.currentPosition;
if(!mCurrentGesturedActor)
{
- DALI_LOG_ERROR("no more gestured actor");
+ DALI_LOG_ERROR("no more gestured actor\n");
}
}
else
return mFocusedActorActivatedSignal;
}
-bool AccessibilityManager::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
-{
- Dali::BaseHandle handle( object );
-
- bool connected( true );
- AccessibilityManager* manager = dynamic_cast<AccessibilityManager*>( object );
-
- if( 0 == strcmp( signalName.c_str(), SIGNAL_FOCUS_CHANGED ) )
- {
- manager->FocusChangedSignal().Connect( tracker, functor );
- }
- else if( 0 == strcmp( signalName.c_str(), SIGNAL_FOCUS_OVERSHOT ) )
- {
- manager->FocusOvershotSignal().Connect( tracker, functor );
- }
- else if( 0 == strcmp( signalName.c_str(), SIGNAL_FOCUSED_ACTOR_ACTIVATED ) )
- {
- manager->FocusedActorActivatedSignal().Connect( tracker, functor );
- }
- else
- {
- // signalName does not match any signal
- connected = false;
- }
-
- return connected;
-}
-
} // namespace Internal
} // namespace Toolkit
projects / platform / core / uifw / dali-toolkit.git / blobdiff