/*
- * Copyright (c) 2018 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/devel-api/scripting/scripting.h>
#include <dali/integration-api/debug.h>
#include <dali/public-api/object/type-registry-helper.h>
+#include <dali/public-api/common/stage.h>
+#include <dali-toolkit/public-api/controls/control.h>
+#include <dali/public-api/object/object-registry.h>
+#include <dali/devel-api/adaptor-framework/accessibility.h>
+#include <dali-toolkit/public-api/controls/control-impl.h>
+#include <dali/devel-api/actors/actor-devel.h>
#include <cstring>
#include <limits>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/visuals/visual-base-impl.h>
-#include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
-#include <dali-toolkit/internal/styling/style-manager-impl.h>
#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
#include <dali-toolkit/public-api/visuals/visual-properties.h>
-#include <dali-toolkit/internal/visuals/visual-string-constants.h>
+#include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
#include <dali-toolkit/devel-api/controls/control-devel.h>
#include <dali-toolkit/devel-api/controls/control-wrapper-impl.h>
+#include <dali-toolkit/internal/styling/style-manager-impl.h>
+#include <dali-toolkit/internal/visuals/visual-string-constants.h>
+#include <dali-toolkit/public-api/focus-manager/keyboard-focus-manager.h>
+#include <dali-toolkit/public-api/controls/image-view/image-view.h>
+
+namespace
+{
+ const std::string READING_INFO_TYPE_NAME = "name";
+ const std::string READING_INFO_TYPE_ROLE = "role";
+ const std::string READING_INFO_TYPE_DESCRIPTION = "description";
+ const std::string READING_INFO_TYPE_STATE = "state";
+ const std::string READING_INFO_TYPE_ATTRIBUTE_NAME = "reading_info_type";
+ const std::string READING_INFO_TYPE_SEPARATOR = "|";
+}
namespace Dali
{
* @return true if action has been accepted by this control
*/
const char* ACTION_ACCESSIBILITY_ACTIVATED = "accessibilityActivated";
+const char* ACTION_ACCESSIBILITY_READING_SKIPPED = "ReadingSkipped";
+const char* ACTION_ACCESSIBILITY_READING_CANCELLED = "ReadingCancelled";
+const char* ACTION_ACCESSIBILITY_READING_STOPPED = "ReadingStopped";
+
static bool DoAction( BaseObject* object, const std::string& actionName, const Property::Map& attributes )
{
bool ret = false;
- if( object && ( 0 == strcmp( actionName.c_str(), ACTION_ACCESSIBILITY_ACTIVATED ) ) )
+ if( object &&
+ ( 0 == strcmp( actionName.c_str(), ACTION_ACCESSIBILITY_ACTIVATED ) ||
+ actionName == "activate" ) )
+ {
+ Toolkit::Control control = Toolkit::Control::DownCast( BaseHandle( object ) );
+ if( control )
+ {
+ // if cast succeeds there is an implementation so no need to check
+ if (!DevelControl::AccessibilityActivateSignal( control ).Empty()) {
+ DevelControl::AccessibilityActivateSignal( control ).Emit();
+ ret = true;
+ }
+ else
+ ret = Internal::GetImplementation( control ).OnAccessibilityActivated();
+ }
+ }
+ else if( object && ( 0 == strcmp( actionName.c_str(), ACTION_ACCESSIBILITY_READING_SKIPPED ) ) )
{
Toolkit::Control control = Toolkit::Control::DownCast( BaseHandle( object ) );
if( control )
{
// if cast succeeds there is an implementation so no need to check
- ret = Internal::GetImplementation( control ).OnAccessibilityActivated();
+ if (!DevelControl::AccessibilityReadingSkippedSignal( control ).Empty())
+ {
+ DevelControl::AccessibilityReadingSkippedSignal( control ).Emit();
+ ret = true;
+ }
+ }
+ }
+ else if( object && ( 0 == strcmp( actionName.c_str(), ACTION_ACCESSIBILITY_READING_CANCELLED ) ) )
+ {
+ Toolkit::Control control = Toolkit::Control::DownCast( BaseHandle( object ) );
+ if( control )
+ {
+ // if cast succeeds there is an implementation so no need to check
+ if (!DevelControl::AccessibilityReadingCancelledSignal( control ).Empty())
+ {
+ DevelControl::AccessibilityReadingCancelledSignal( control ).Emit();
+ ret = true;
+ }
+ }
+ }
+ else if( object && ( 0 == strcmp( actionName.c_str(), ACTION_ACCESSIBILITY_READING_STOPPED ) ) )
+ {
+ Toolkit::Control control = Toolkit::Control::DownCast( BaseHandle( object ) );
+ if( control )
+ {
+ // if cast succeeds there is an implementation so no need to check
+ if (!DevelControl::AccessibilityReadingStoppedSignal( control ).Empty())
+ {
+ DevelControl::AccessibilityReadingStoppedSignal( control ).Emit();
+ ret = true;
+ }
}
}
const char* SIGNAL_PANNED = "panned";
const char* SIGNAL_PINCHED = "pinched";
const char* SIGNAL_LONG_PRESSED = "longPressed";
+const char* SIGNAL_GET_NAME = "getName";
+const char* SIGNAL_GET_DESCRIPTION = "getDescription";
+const char* SIGNAL_DO_GESTURE = "doGesture";
static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
{
Dali::BaseHandle handle( object );
controlImpl.EnableGestureDetection( Gesture::LongPress );
controlImpl.GetLongPressGestureDetector().DetectedSignal().Connect( tracker, functor );
}
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_GET_NAME ) )
+ {
+ DevelControl::AccessibilityGetNameSignal( control ).Connect( tracker, functor );
+ }
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_GET_DESCRIPTION ) )
+ {
+ DevelControl::AccessibilityGetDescriptionSignal( control ).Connect( tracker, functor );
+ }
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_DO_GESTURE ) )
+ {
+ DevelControl::AccessibilityDoGestureSignal( control ).Connect( tracker, functor );
+ }
+
}
return connected;
}
SignalConnectorType registerSignal5( typeRegistration, SIGNAL_PANNED, &DoConnectSignal );
SignalConnectorType registerSignal6( typeRegistration, SIGNAL_PINCHED, &DoConnectSignal );
SignalConnectorType registerSignal7( typeRegistration, SIGNAL_LONG_PRESSED, &DoConnectSignal );
+SignalConnectorType registerSignal8( typeRegistration, SIGNAL_GET_NAME, &DoConnectSignal );
+SignalConnectorType registerSignal9( typeRegistration, SIGNAL_GET_DESCRIPTION, &DoConnectSignal );
+SignalConnectorType registerSignal10( typeRegistration, SIGNAL_DO_GESTURE, &DoConnectSignal );
-TypeAction registerAction( typeRegistration, ACTION_ACCESSIBILITY_ACTIVATED, &DoAction );
+TypeAction registerAction1( typeRegistration, "activate", &DoAction );
+TypeAction registerAction2( typeRegistration, ACTION_ACCESSIBILITY_ACTIVATED, &DoAction );
+TypeAction registerAction3( typeRegistration, ACTION_ACCESSIBILITY_READING_SKIPPED, &DoAction );
+TypeAction registerAction4( typeRegistration, ACTION_ACCESSIBILITY_READING_CANCELLED, &DoAction );
+TypeAction registerAction5( typeRegistration, ACTION_ACCESSIBILITY_READING_STOPPED, &DoAction );
DALI_TYPE_REGISTRATION_END()
// Properties registered without macro to use specific member variables.
const PropertyRegistration Control::Impl::PROPERTY_1( typeRegistration, "styleName", Toolkit::Control::Property::STYLE_NAME, Property::STRING, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
-const PropertyRegistration Control::Impl::PROPERTY_2( typeRegistration, "backgroundColor", Toolkit::Control::Property::BACKGROUND_COLOR, Property::VECTOR4, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
-const PropertyRegistration Control::Impl::PROPERTY_3( typeRegistration, "backgroundImage", Toolkit::Control::Property::BACKGROUND_IMAGE, Property::MAP, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_2( typeRegistration, "reservedProperty01", Toolkit::Control::Property::RESERVED_PROPERTY_01, Property::VECTOR4, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_3( typeRegistration, "reservedProperty02", Toolkit::Control::Property::RESERVED_PROPERTY_02, Property::MAP, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
const PropertyRegistration Control::Impl::PROPERTY_4( typeRegistration, "keyInputFocus", Toolkit::Control::Property::KEY_INPUT_FOCUS, Property::BOOLEAN, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
const PropertyRegistration Control::Impl::PROPERTY_5( typeRegistration, "background", Toolkit::Control::Property::BACKGROUND, Property::MAP, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
const PropertyRegistration Control::Impl::PROPERTY_6( typeRegistration, "margin", Toolkit::Control::Property::MARGIN, Property::EXTENTS, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
const PropertyRegistration Control::Impl::PROPERTY_12( typeRegistration, "rightFocusableActorId", Toolkit::DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID,Property::INTEGER, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
const PropertyRegistration Control::Impl::PROPERTY_13( typeRegistration, "upFocusableActorId", Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID, Property::INTEGER, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
const PropertyRegistration Control::Impl::PROPERTY_14( typeRegistration, "downFocusableActorId", Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID, Property::INTEGER, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
-
+const PropertyRegistration Control::Impl::PROPERTY_15( typeRegistration, "accessibilityAttributes", Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES, Property::MAP, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_16( typeRegistration, "accessibilityName", Toolkit::DevelControl::Property::ACCESSIBILITY_NAME, Property::STRING, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_17( typeRegistration, "accessibilityDescription", Toolkit::DevelControl::Property::ACCESSIBILITY_DESCRIPTON, Property::STRING, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_18( typeRegistration, "accessibilityTranslationDomain", Toolkit::DevelControl::Property::ACCESSIBILITY_TRANSLATION_DOMAIN, Property::STRING, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_19( typeRegistration, "accessibilityRole", Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE, Property::INTEGER, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_20( typeRegistration, "accessibilityHighlightable", Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, Property::BOOLEAN, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
+const PropertyRegistration Control::Impl::PROPERTY_21( typeRegistration, "accessibilityAnimated", Toolkit::DevelControl::Property::ACCESSIBILITY_ANIMATED, Property::BOOLEAN, &Control::Impl::SetProperty, &Control::Impl::GetProperty );
Control::Impl::Impl( Control& controlImpl )
: mControlImpl( controlImpl ),
mKeyInputFocusGainedSignal(),
mKeyInputFocusLostSignal(),
mResourceReadySignal(),
+ mVisualEventSignal(),
+ mAccessibilityGetNameSignal(),
+ mAccessibilityGetDescriptionSignal(),
+ mAccessibilityDoGestureSignal(),
mPinchGestureDetector(),
mPanGestureDetector(),
mTapGestureDetector(),
mLongPressGestureDetector(),
+ mTooltip( NULL ),
+ mInputMethodContext(),
+ mAutofillItem(),
+ mAutofillContainer(),
mFlags( Control::ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ),
mIsKeyboardNavigationSupported( false ),
- mIsKeyboardFocusGroup( false )
+ mIsKeyboardFocusGroup( false ),
+ mIsAutofillEnabled( false )
{
+ Dali::Accessibility::Accessible::RegisterControlAccessibilityGetter(
+ []( Dali::Actor actor ) -> Dali::Accessibility::Accessible* {
+ return Control::Impl::GetAccessibilityObject( actor );
+ } );
+
+ accessibilityConstructor = []( Dali::Actor actor ) -> std::unique_ptr< Dali::Accessibility::Accessible > {
+ return std::unique_ptr< Dali::Accessibility::Accessible >( new AccessibleImpl( actor,
+ Dali::Accessibility::Role::UNKNOWN ) );
+ };
+
+ size_t len = static_cast<size_t>(Dali::Accessibility::RelationType::LAST_DEFINED);
+ mAccessibilityRelations.reserve(len);
+ for (auto i = 0u; i < len; ++i)
+ {
+ mAccessibilityRelations.push_back({});
+ }
}
Control::Impl::~Impl()
{
+ AccessibilityDeregister();
// All gesture detectors will be destroyed so no need to disconnect.
delete mStartingPinchScale;
}
// ( If the control has been type registered )
if( visual.GetName().empty() )
{
- try
- {
- std::string visualName = self.GetPropertyName( index );
- if( !visualName.empty() )
- {
- DALI_LOG_INFO( gLogFilter, Debug::Concise, "Setting visual name for property %d to %s\n",
- index, visualName.c_str() );
- visual.SetName( visualName );
- }
- }
- catch( Dali::DaliException e )
+ // returns empty string if index is not found as long as index is not -1
+ std::string visualName = self.GetPropertyName( index );
+ if( !visualName.empty() )
{
- DALI_LOG_WARNING( "Attempting to register visual without a registered property, index: %d\n", index );
+ DALI_LOG_INFO( gLogFilter, Debug::Concise, "Setting visual name for property %d to %s\n",
+ index, visualName.c_str() );
+ visual.SetName( visualName );
}
}
void Control::Impl::EnableVisual( Property::Index index, bool enable )
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::EnableVisual Visual (%d)\n", index);
+ DALI_LOG_INFO( gLogFilter, Debug::General, "Control::EnableVisual(%d, %s)\n", index, enable?"T":"F");
RegisteredVisualContainer::Iterator iter;
if ( FindVisual( index, mVisuals, iter ) )
}
}
}
+ else
+ {
+ DALI_LOG_WARNING( "Control::EnableVisual(%d, %s) FAILED - NO SUCH VISUAL\n", index, enable?"T":"F" );
+ }
}
bool Control::Impl::IsVisualEnabled( Property::Index index ) const
Internal::Visual::Base& visualImpl = Toolkit::GetImplementation( visual );
// Stop observing the visual
- visualImpl.RemoveResourceObserver( *this );
+ visualImpl.RemoveEventObserver( *this );
}
void Control::Impl::StartObservingVisual( Toolkit::Visual::Base& visual)
{
Internal::Visual::Base& visualImpl = Toolkit::GetImplementation( visual );
- // start observing the visual for resource ready
- visualImpl.AddResourceObserver( *this );
+ // start observing the visual for events
+ visualImpl.AddEventObserver( *this );
}
// Called by a Visual when it's resource is ready
void Control::Impl::ResourceReady( Visual::Base& object)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "ResourceReady replacements pending[%d]\n", mRemoveVisuals.Count() );
+ DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Control::Impl::ResourceReady() replacements pending[%d]\n", mRemoveVisuals.Count() );
Actor self = mControlImpl.Self();
}
}
+void Control::Impl::NotifyVisualEvent( Visual::Base& object, Property::Index signalId )
+{
+ for( auto registeredIter = mVisuals.Begin(), end = mVisuals.End(); registeredIter != end; ++registeredIter )
+ {
+ Internal::Visual::Base& registeredVisualImpl = Toolkit::GetImplementation( (*registeredIter)->visual );
+ if( &object == ®isteredVisualImpl )
+ {
+ Dali::Toolkit::Control handle( mControlImpl.GetOwner() );
+ mVisualEventSignal.Emit( handle, (*registeredIter)->index, signalId );
+ break;
+ }
+ }
+}
+
bool Control::Impl::IsResourceReady() const
{
// Iterate through and check all the enabled visuals are ready
return Toolkit::Visual::ResourceStatus::PREPARING;
}
-Dali::Animation Control::Impl::CreateTransition( const Toolkit::TransitionData& handle )
+
+
+void Control::Impl::AddTransitions( Dali::Animation& animation,
+ const Toolkit::TransitionData& handle,
+ bool createAnimation )
{
- Dali::Animation transition;
+ // Setup a Transition from TransitionData.
const Internal::TransitionData& transitionData = Toolkit::GetImplementation( handle );
-
- if( transitionData.Count() > 0 )
+ TransitionData::Iterator end = transitionData.End();
+ for( TransitionData::Iterator iter = transitionData.Begin() ;
+ iter != end; ++iter )
{
- // Setup a Transition from TransitionData.
- TransitionData::Iterator end = transitionData.End();
- for( TransitionData::Iterator iter = transitionData.Begin() ;
- iter != end; ++iter )
- {
- TransitionData::Animator* animator = (*iter);
+ TransitionData::Animator* animator = (*iter);
- Toolkit::Visual::Base visual = GetVisualByName( mVisuals, animator->objectName );
+ Toolkit::Visual::Base visual = GetVisualByName( mVisuals, animator->objectName );
- if( visual )
- {
+ if( visual )
+ {
#if defined(DEBUG_ENABLED)
- Dali::TypeInfo typeInfo;
- ControlWrapper* controlWrapperImpl = dynamic_cast<ControlWrapper*>(&mControlImpl);
- if( controlWrapperImpl )
- {
- typeInfo = controlWrapperImpl->GetTypeInfo();
- }
+ Dali::TypeInfo typeInfo;
+ ControlWrapper* controlWrapperImpl = dynamic_cast<ControlWrapper*>(&mControlImpl);
+ if( controlWrapperImpl )
+ {
+ typeInfo = controlWrapperImpl->GetTypeInfo();
+ }
- DALI_LOG_INFO( gLogFilter, Debug::Concise, "CreateTransition: Found %s visual for %s\n",
- visual.GetName().c_str(), typeInfo?typeInfo.GetName().c_str():"Unknown" );
+ DALI_LOG_INFO( gLogFilter, Debug::Concise, "CreateTransition: Found %s visual for %s\n",
+ visual.GetName().c_str(), typeInfo?typeInfo.GetName().c_str():"Unknown" );
#endif
- Internal::Visual::Base& visualImpl = Toolkit::GetImplementation( visual );
-
- visualImpl.AnimateProperty( transition, *animator );
- }
- else
+ Internal::Visual::Base& visualImpl = Toolkit::GetImplementation( visual );
+ visualImpl.AnimateProperty( animation, *animator );
+ }
+ else
+ {
+ DALI_LOG_INFO( gLogFilter, Debug::Concise, "CreateTransition: Could not find visual. Trying actors");
+ // Otherwise, try any actor children of control (Including the control)
+ Actor child = mControlImpl.Self().FindChildByName( animator->objectName );
+ if( child )
{
- DALI_LOG_INFO( gLogFilter, Debug::Concise, "CreateTransition: Could not find visual. Trying actors");
- // Otherwise, try any actor children of control (Including the control)
- Actor child = mControlImpl.Self().FindChildByName( animator->objectName );
- if( child )
+ Property::Index propertyIndex = DevelHandle::GetPropertyIndex( child, animator->propertyKey );
+ if( propertyIndex != Property::INVALID_INDEX )
{
- Property::Index propertyIndex = DevelHandle::GetPropertyIndex( child, animator->propertyKey );
- if( propertyIndex != Property::INVALID_INDEX )
+ if( animator->animate == false )
{
- if( animator->animate == false )
+ if( animator->targetValue.GetType() != Property::NONE )
{
- if( animator->targetValue.GetType() != Property::NONE )
- {
- child.SetProperty( propertyIndex, animator->targetValue );
- }
+ child.SetProperty( propertyIndex, animator->targetValue );
}
- else // animate the property
+ }
+ else // animate the property
+ {
+ if( animator->initialValue.GetType() != Property::NONE )
+ {
+ child.SetProperty( propertyIndex, animator->initialValue );
+ }
+
+ if( createAnimation && !animation )
{
- if( animator->initialValue.GetType() != Property::NONE )
- {
- child.SetProperty( propertyIndex, animator->initialValue );
- }
-
- if( ! transition )
- {
- transition = Dali::Animation::New( 0.1f );
- }
-
- transition.AnimateTo( Property( child, propertyIndex ),
- animator->targetValue,
- animator->alphaFunction,
- TimePeriod( animator->timePeriodDelay,
- animator->timePeriodDuration ) );
+ animation = Dali::Animation::New( 0.1f );
}
+
+ animation.AnimateTo( Property( child, propertyIndex ),
+ animator->targetValue,
+ animator->alphaFunction,
+ TimePeriod( animator->timePeriodDelay,
+ animator->timePeriodDuration ) );
}
}
}
}
}
+}
+Dali::Animation Control::Impl::CreateTransition( const Toolkit::TransitionData& transitionData )
+{
+ Dali::Animation transition;
+
+ if( transitionData.Count() > 0 )
+ {
+ AddTransitions( transition, transitionData, true );
+ }
return transition;
}
+
+
void Control::Impl::DoAction( Dali::Property::Index visualIndex, Dali::Property::Index actionId, const Dali::Property::Value attributes )
{
RegisteredVisualContainer::Iterator iter;
}
}
+void Control::Impl::AppendAccessibilityAttribute( const std::string& key,
+ const std::string value )
+{
+ Property::Value* val = mAccessibilityAttributes.Find( key );
+ if( val )
+ {
+ mAccessibilityAttributes[key] = Property::Value( value );
+ }
+ else
+ {
+ mAccessibilityAttributes.Insert( key, value );
+ }
+}
+
void Control::Impl::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
{
Toolkit::Control control = Toolkit::Control::DownCast( BaseHandle( object ) );
}
break;
- case Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID:
+ case Toolkit::DevelControl::Property::ACCESSIBILITY_NAME:
{
- int focusId;
- if( value.Get( focusId ) )
+ std::string name;
+ if( value.Get( name ) )
{
- controlImpl.mImpl->mUpFocusableActorId = focusId;
+ controlImpl.mImpl->mAccessibilityName = name;
+ controlImpl.mImpl->mAccessibilityNameSet = true;
+ }
+ else
+ {
+ controlImpl.mImpl->mAccessibilityNameSet = false;
}
}
break;
- case Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID:
+ case Toolkit::DevelControl::Property::ACCESSIBILITY_DESCRIPTON:
{
- int focusId;
- if( value.Get( focusId ) )
+ std::string txt;
+ if( value.Get( txt ) )
{
- controlImpl.mImpl->mDownFocusableActorId = focusId;
+ controlImpl.mImpl->mAccessibilityDescription = txt;
+ controlImpl.mImpl->mAccessibilityDescriptionSet = true;
+ }
+ else
+ {
+ controlImpl.mImpl->mAccessibilityDescriptionSet = false;
}
}
break;
- case Toolkit::Control::Property::BACKGROUND_COLOR:
+ case Toolkit::DevelControl::Property::ACCESSIBILITY_TRANSLATION_DOMAIN:
{
- DALI_LOG_WARNING( "BACKGROUND_COLOR property is deprecated. Use BACKGROUND property instead\n" );
- controlImpl.SetBackgroundColor( value.Get< Vector4 >() );
- break;
+ std::string txt;
+ if( value.Get( txt ) )
+ {
+ controlImpl.mImpl->mAccessibilityTranslationDomain = txt;
+ controlImpl.mImpl->mAccessibilityTranslationDomainSet = true;
+ }
+ else
+ {
+ controlImpl.mImpl->mAccessibilityTranslationDomainSet = false;
+ }
}
+ break;
- case Toolkit::Control::Property::BACKGROUND_IMAGE:
+ case Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE:
{
- DALI_LOG_WARNING( "BACKGROUND_IMAGE property is deprecated. Use BACKGROUND property instead\n" );
- Image image = Scripting::NewImage( value );
- if ( image )
+ bool highlightable;
+ if( value.Get( highlightable ) )
{
- controlImpl.SetBackgroundImage( image );
+ controlImpl.mImpl->mAccessibilityHighlightable = highlightable;
+ controlImpl.mImpl->mAccessibilityHighlightableSet = true;
}
else
{
- // An empty image means the background is no longer required
- controlImpl.ClearBackground();
+ controlImpl.mImpl->mAccessibilityHighlightableSet = false;
+ }
+ }
+ break;
+
+ case Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE:
+ {
+ Dali::Accessibility::Role val;
+ if( value.Get( val ) )
+ {
+ controlImpl.mImpl->mAccessibilityRole = val;
}
- break;
}
+ break;
+
+ case Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID:
+ {
+ int focusId;
+ if( value.Get( focusId ) )
+ {
+ controlImpl.mImpl->mUpFocusableActorId = focusId;
+ }
+ }
+ break;
+
+ case Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID:
+ {
+ int focusId;
+ if( value.Get( focusId ) )
+ {
+ controlImpl.mImpl->mDownFocusableActorId = focusId;
+ }
+ }
+ break;
case Toolkit::Control::Property::KEY_INPUT_FOCUS:
{
break;
}
+ case Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES:
+ {
+ value.Get( controlImpl.mImpl->mAccessibilityAttributes );
+ break;
+ }
+
+ case Toolkit::DevelControl::Property::ACCESSIBILITY_ANIMATED:
+ {
+ value.Get( controlImpl.mImpl->mAccessibilityAnimated );
+ break;
+ }
}
}
}
break;
}
- case Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID:
+ case Toolkit::DevelControl::Property::ACCESSIBILITY_NAME:
{
- value = controlImpl.mImpl->mUpFocusableActorId;
+ if (controlImpl.mImpl->mAccessibilityNameSet)
+ {
+ value = controlImpl.mImpl->mAccessibilityName;
+ }
break;
}
- case Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID:
+ case Toolkit::DevelControl::Property::ACCESSIBILITY_DESCRIPTON:
{
- value = controlImpl.mImpl->mDownFocusableActorId;
+ if (controlImpl.mImpl->mAccessibilityDescriptionSet)
+ {
+ value = controlImpl.mImpl->mAccessibilityDescription;
+ }
break;
}
- case Toolkit::Control::Property::BACKGROUND_COLOR:
+ case Toolkit::DevelControl::Property::ACCESSIBILITY_TRANSLATION_DOMAIN:
{
- DALI_LOG_WARNING( "BACKGROUND_COLOR property is deprecated. Use BACKGROUND property instead\n" );
- value = controlImpl.GetBackgroundColor();
+ if (controlImpl.mImpl->mAccessibilityTranslationDomainSet)
+ {
+ value = controlImpl.mImpl->mAccessibilityTranslationDomain;
+ }
break;
}
- case Toolkit::Control::Property::BACKGROUND_IMAGE:
+ case Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE:
{
- DALI_LOG_WARNING( "BACKGROUND_IMAGE property is deprecated. Use BACKGROUND property instead\n" );
- Property::Map map;
- Toolkit::Visual::Base visual = controlImpl.mImpl->GetVisual( Toolkit::Control::Property::BACKGROUND );
- if( visual )
+ if (controlImpl.mImpl->mAccessibilityHighlightableSet)
{
- visual.CreatePropertyMap( map );
+ value = controlImpl.mImpl->mAccessibilityHighlightable;
}
- value = map;
+ break;
+ }
+
+ case Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE:
+ {
+ value = Property::Value(controlImpl.mImpl->mAccessibilityRole);
+ break;
+ }
+
+ case Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID:
+ {
+ value = controlImpl.mImpl->mUpFocusableActorId;
+ break;
+ }
+
+ case Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID:
+ {
+ value = controlImpl.mImpl->mDownFocusableActorId;
break;
}
value = map;
break;
}
+
+ case Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES:
+ {
+ value = controlImpl.mImpl->mAccessibilityAttributes;
+ break;
+ }
+
+ case Toolkit::DevelControl::Property::ACCESSIBILITY_ANIMATED:
+ {
+ value = controlImpl.mImpl->mAccessibilityAnimated;
+ break;
+ }
}
}
return value;
}
+void Control::Impl::RemoveAccessibilityAttribute( const std::string& key )
+{
+ Property::Value* val = mAccessibilityAttributes.Find( key );
+ if( val )
+ mAccessibilityAttributes[key] = Property::Value();
+}
+
+void Control::Impl::ClearAccessibilityAttributes()
+{
+ mAccessibilityAttributes.Clear();
+}
+
+void Control::Impl::SetAccessibilityReadingInfoType( const Dali::Accessibility::ReadingInfoTypes types )
+{
+ std::string value;
+ if ( types[ Dali::Accessibility::ReadingInfoType::NAME ] )
+ {
+ value += READING_INFO_TYPE_NAME;
+ }
+ if ( types[ Dali::Accessibility::ReadingInfoType::ROLE ] )
+ {
+ if( !value.empty() )
+ {
+ value += READING_INFO_TYPE_SEPARATOR;
+ }
+ value += READING_INFO_TYPE_ROLE;
+ }
+ if ( types[ Dali::Accessibility::ReadingInfoType::DESCRIPTION ] )
+ {
+ if( !value.empty() )
+ {
+ value += READING_INFO_TYPE_SEPARATOR;
+ }
+ value += READING_INFO_TYPE_DESCRIPTION;
+ }
+ if ( types[ Dali::Accessibility::ReadingInfoType::STATE ] )
+ {
+ if( !value.empty() )
+ {
+ value += READING_INFO_TYPE_SEPARATOR;
+ }
+ value += READING_INFO_TYPE_STATE;
+ }
+ AppendAccessibilityAttribute( READING_INFO_TYPE_ATTRIBUTE_NAME, value );
+}
+
+Dali::Accessibility::ReadingInfoTypes Control::Impl::GetAccessibilityReadingInfoType() const
+{
+ std::string value;
+ auto place = mAccessibilityAttributes.Find( READING_INFO_TYPE_ATTRIBUTE_NAME );
+ if( place )
+ {
+ place->Get( value );
+ }
+
+ if ( value.empty() )
+ {
+ return {};
+ }
+
+ Dali::Accessibility::ReadingInfoTypes types;
+
+ if ( value.find( READING_INFO_TYPE_NAME ) != std::string::npos )
+ {
+ types[ Dali::Accessibility::ReadingInfoType::NAME ] = true;
+ }
+ if ( value.find( READING_INFO_TYPE_ROLE ) != std::string::npos )
+ {
+ types[ Dali::Accessibility::ReadingInfoType::ROLE ] = true;
+ }
+ if ( value.find( READING_INFO_TYPE_DESCRIPTION ) != std::string::npos )
+ {
+ types[ Dali::Accessibility::ReadingInfoType::DESCRIPTION ] = true;
+ }
+ if ( value.find( READING_INFO_TYPE_STATE ) != std::string::npos )
+ {
+ types[ Dali::Accessibility::ReadingInfoType::STATE ] = true;
+ }
+
+ return types;
+}
void Control::Impl::CopyInstancedProperties( RegisteredVisualContainer& visuals, Dictionary<Property::Map>& instancedProperties )
{
void Control::Impl::SetMargin( Extents margin )
{
mControlImpl.mImpl->mMargin = margin;
+
+ // Trigger a size negotiation request that may be needed when setting a margin.
+ mControlImpl.RelayoutRequest();
}
Extents Control::Impl::GetMargin() const
void Control::Impl::SetPadding( Extents padding )
{
mControlImpl.mImpl->mPadding = padding;
+
+ // Trigger a size negotiation request that may be needed when setting a padding.
+ mControlImpl.RelayoutRequest();
}
Extents Control::Impl::GetPadding() const
return consumed;
}
+DevelControl::VisualEventSignalType& Control::Impl::VisualEventSignal()
+{
+ return mVisualEventSignal;
+}
+
+void Control::Impl::SetAutofillEnabled( bool autofillEnabled )
+{
+ mIsAutofillEnabled = autofillEnabled;
+}
+
+bool Control::Impl::IsAutofillEnabled()
+{
+ return mIsAutofillEnabled;
+}
+
+void Control::Impl::SetAutofillItemHandle( Dali::AutofillItem item )
+{
+ mAutofillItem = item;
+}
+
+Dali::AutofillItem Control::Impl::GetAutofillItemHandle()
+{
+ return mAutofillItem;
+}
+
+void Control::Impl::SetAutofillContainer( Toolkit::AutofillContainer container )
+{
+ mAutofillContainer = container;
+}
+
+Toolkit::AutofillContainer Control::Impl::GetAutofillContainer()
+{
+ return mAutofillContainer;
+}
+
+
+Dali::Accessibility::Accessible *Control::Impl::GetAccessibilityObject()
+{
+ if( !accessibilityObject )
+ accessibilityObject = accessibilityConstructor( mControlImpl.Self() );
+ return accessibilityObject.get();
+}
+
+Dali::Accessibility::Accessible *Control::Impl::GetAccessibilityObject(Dali::Actor actor)
+{
+ if( actor )
+ {
+ auto q = Dali::Toolkit::Control::DownCast( actor );
+ if( q )
+ {
+ auto q2 = static_cast< Internal::Control* >( &q.GetImplementation() );
+ return q2->mImpl->GetAccessibilityObject();
+ }
+ }
+ return nullptr;
+}
+
+Control::Impl::AccessibleImpl::AccessibleImpl(Dali::Actor self, Dali::Accessibility::Role role, bool modal)
+ : self(self), modal(modal)
+{
+ auto control = Dali::Toolkit::Control::DownCast(self);
+
+ Internal::Control& internalControl = Toolkit::Internal::GetImplementation( control );
+ Internal::Control::Impl& controlImpl = Internal::Control::Impl::Get( internalControl );
+ if( controlImpl.mAccessibilityRole == Dali::Accessibility::Role::UNKNOWN )
+ controlImpl.mAccessibilityRole = role;
+}
+
+std::string Control::Impl::AccessibleImpl::GetName()
+{
+ auto control = Dali::Toolkit::Control::DownCast(self);
+
+ Internal::Control& internalControl = Toolkit::Internal::GetImplementation( control );
+ Internal::Control::Impl& controlImpl = Internal::Control::Impl::Get( internalControl );
+
+ if (!controlImpl.mAccessibilityGetNameSignal.Empty()) {
+ std::string ret;
+ controlImpl.mAccessibilityGetNameSignal.Emit(ret);
+ return ret;
+ }
+
+ if (controlImpl.mAccessibilityNameSet)
+ return controlImpl.mAccessibilityName;
+
+ return GetNameRaw();
+}
+
+std::string Control::Impl::AccessibleImpl::GetNameRaw()
+{
+ return self.GetName();
+}
+
+std::string Control::Impl::AccessibleImpl::GetDescription()
+{
+ auto control = Dali::Toolkit::Control::DownCast(self);
+
+ Internal::Control& internalControl = Toolkit::Internal::GetImplementation( control );
+ Internal::Control::Impl& controlImpl = Internal::Control::Impl::Get( internalControl );
+
+ if (!controlImpl.mAccessibilityGetDescriptionSignal.Empty()) {
+ std::string ret;
+ controlImpl.mAccessibilityGetDescriptionSignal.Emit(ret);
+ return ret;
+ }
+
+ if (controlImpl.mAccessibilityDescriptionSet)
+ return controlImpl.mAccessibilityDescription;
+
+ return GetDescriptionRaw();
+}
+
+std::string Control::Impl::AccessibleImpl::GetDescriptionRaw()
+{
+ return "";
+}
+
+Dali::Accessibility::Accessible* Control::Impl::AccessibleImpl::GetParent()
+{
+ return Dali::Accessibility::Accessible::Get( self.GetParent() );
+}
+
+size_t Control::Impl::AccessibleImpl::GetChildCount()
+{
+ return self.GetChildCount();
+}
+
+Dali::Accessibility::Accessible* Control::Impl::AccessibleImpl::GetChildAtIndex( size_t index )
+{
+ return Dali::Accessibility::Accessible::Get( self.GetChildAt( static_cast< unsigned int >( index ) ) );
+}
+
+size_t Control::Impl::AccessibleImpl::GetIndexInParent()
+{
+ auto s = self;
+ auto parent = s.GetParent();
+ DALI_ASSERT_ALWAYS( parent && "can't call GetIndexInParent on object without parent" );
+ auto count = parent.GetChildCount();
+ for( auto i = 0u; i < count; ++i )
+ {
+ auto c = parent.GetChildAt( i );
+ if( c == s )
+ return i;
+ }
+ DALI_ASSERT_ALWAYS( false && "object isn't child of it's parent" );
+ return static_cast<size_t>(-1);
+}
+
+Dali::Accessibility::Role Control::Impl::AccessibleImpl::GetRole()
+{
+ return self.GetProperty<Dali::Accessibility::Role>( Toolkit::DevelControl::Property::ACCESSIBILITY_ROLE );
+}
+
+Dali::Accessibility::States Control::Impl::AccessibleImpl::CalculateStates()
+{
+ Dali::Accessibility::States s;
+ s[Dali::Accessibility::State::FOCUSABLE] = self.IsKeyboardFocusable();
+ s[Dali::Accessibility::State::FOCUSED] = Toolkit::KeyboardFocusManager::Get().GetCurrentFocusActor() == self;
+ if(self.GetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE ).GetType() == Property::NONE )
+ s[Dali::Accessibility::State::HIGHLIGHTABLE] = true;
+ else
+ s[Dali::Accessibility::State::HIGHLIGHTABLE] = self.GetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE ).Get< bool >();
+ s[Dali::Accessibility::State::HIGHLIGHTED] = GetCurrentlyHighlightedActor() == self;
+ s[Dali::Accessibility::State::ENABLED] = true;
+ s[Dali::Accessibility::State::SENSITIVE] = true;
+ s[Dali::Accessibility::State::ANIMATED] = self.GetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_ANIMATED ).Get< bool >();
+ s[Dali::Accessibility::State::VISIBLE] = self.IsVisible();
+ if( modal )
+ {
+ s[Dali::Accessibility::State::MODAL] = true;
+ }
+ s[Dali::Accessibility::State::SHOWING] = !self.GetProperty( Dali::DevelActor::Property::CULLED ).Get< bool >();
+ return s;
+}
+
+Dali::Accessibility::States Control::Impl::AccessibleImpl::GetStates()
+{
+ return CalculateStates();
+}
+
+Dali::Accessibility::Attributes Control::Impl::AccessibleImpl::GetAttributes()
+{
+ std::unordered_map< std::string, std::string > attribute_map;
+ auto q = Dali::Toolkit::Control::DownCast( self );
+ auto w =
+ q.GetProperty( Dali::Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES );
+ auto z = w.GetMap();
+
+ if( z )
+ {
+ auto map_size = z->Count();
+
+ for( unsigned int i = 0; i < map_size; i++ )
+ {
+ auto map_key = z->GetKeyAt( i );
+ if( map_key.type == Property::Key::STRING )
+ {
+ std::string map_value;
+ if( z->GetValue( i ).Get( map_value ) )
+ {
+ attribute_map.emplace( std::move( map_key.stringKey ),
+ std::move( map_value ) );
+ }
+ }
+ }
+ }
+
+ return attribute_map;
+}
+
+Dali::Accessibility::ComponentLayer Control::Impl::AccessibleImpl::GetLayer()
+{
+ return Dali::Accessibility::ComponentLayer::WINDOW;
+}
+
+Dali::Rect<> Control::Impl::AccessibleImpl::GetExtents( Dali::Accessibility::CoordType ctype )
+{
+ Vector2 screenPosition =
+ self.GetProperty( Dali::DevelActor::Property::SCREEN_POSITION )
+ .Get< Vector2 >();
+ Vector3 size = self.GetCurrentSize() * self.GetCurrentWorldScale();
+ bool positionUsesAnchorPoint =
+ self.GetProperty( Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT )
+ .Get< bool >();
+ Vector3 anchorPointOffSet =
+ size * ( positionUsesAnchorPoint ? self.GetCurrentAnchorPoint()
+ : AnchorPoint::TOP_LEFT );
+ Vector2 position = Vector2( screenPosition.x - anchorPointOffSet.x,
+ screenPosition.y - anchorPointOffSet.y );
+
+ return { position.x, position.y, size.x, size.y };
+}
+
+int16_t Control::Impl::AccessibleImpl::GetMdiZOrder() { return 0; }
+double Control::Impl::AccessibleImpl::GetAlpha() { return 0; }
+
+bool Control::Impl::AccessibleImpl::GrabFocus()
+{
+ return Toolkit::KeyboardFocusManager::Get().SetCurrentFocusActor( self );
+}
+
+const char* const FOCUS_BORDER_IMAGE_PATH = DALI_IMAGE_DIR "keyboard_focus.9.png";
+
+static Dali::Actor CreateHighlightIndicatorActor()
+{
+ // Create the default if it hasn't been set and one that's shared by all the
+ // keyboard focusable actors const char* const FOCUS_BORDER_IMAGE_PATH =
+ // DALI_IMAGE_DIR "keyboard_focus.9.png";
+ auto actor = Toolkit::ImageView::New( FOCUS_BORDER_IMAGE_PATH );
+ actor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+ DevelControl::AppendAccessibilityAttribute( actor, "highlight", "" );
+ actor.SetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_ANIMATED, true);
+
+ return actor;
+}
+
+bool Control::Impl::AccessibleImpl::GrabHighlight()
+{
+ auto old = GetCurrentlyHighlightedActor();
+
+ if( !Dali::Accessibility::IsUp() )
+ return false;
+ if( self == old )
+ return true;
+ if( old )
+ {
+ auto c = dynamic_cast< Dali::Accessibility::Component* >( GetAccessibilityObject( old ) );
+ if( c )
+ c->ClearHighlight();
+ }
+ auto highlight = GetHighlightActor();
+ if ( !highlight )
+ {
+ highlight = CreateHighlightIndicatorActor();
+ SetHighlightActor( highlight );
+ }
+ highlight.SetParentOrigin( ParentOrigin::CENTER );
+ highlight.SetAnchorPoint( AnchorPoint::CENTER );
+ highlight.SetZ( 1.0f );
+ highlight.SetPosition( 0.0f, 0.0f );
+
+ self.Add( highlight );
+ SetCurrentlyHighlightedActor( self );
+ EmitHighlighted( true );
+
+ return true;
+}
+
+
+
+bool Control::Impl::AccessibleImpl::ClearHighlight()
+{
+ if( !Dali::Accessibility::IsUp() )
+ return false;
+ if( GetCurrentlyHighlightedActor() == self )
+ {
+ self.Remove( GetHighlightActor() );
+ SetCurrentlyHighlightedActor( {} );
+ EmitHighlighted( false );
+ return true;
+ }
+ return false;
+}
+
+int Control::Impl::AccessibleImpl::GetHighlightIndex()
+{
+ return 0;
+}
+
+std::string Control::Impl::AccessibleImpl::GetActionName( size_t index )
+{
+ if ( index >= GetActionCount() ) return "";
+ Dali::TypeInfo type;
+ self.GetTypeInfo( type );
+ DALI_ASSERT_ALWAYS( type && "no TypeInfo object" );
+ return type.GetActionName( index );
+}
+std::string Control::Impl::AccessibleImpl::GetLocalizedActionName( size_t index )
+{
+ // TODO: add localization
+ return GetActionName( index );
+}
+std::string Control::Impl::AccessibleImpl::GetActionDescription( size_t index )
+{
+ return "";
+}
+size_t Control::Impl::AccessibleImpl::GetActionCount()
+{
+ Dali::TypeInfo type;
+ self.GetTypeInfo( type );
+ DALI_ASSERT_ALWAYS( type && "no TypeInfo object" );
+ return type.GetActionCount();
+}
+std::string Control::Impl::AccessibleImpl::GetActionKeyBinding( size_t index )
+{
+ return "";
+}
+bool Control::Impl::AccessibleImpl::DoAction( size_t index )
+{
+ std::string actionName = GetActionName( index );
+ return self.DoAction( actionName, {} );
+}
+bool Control::Impl::AccessibleImpl::DoAction(const std::string& name)
+{
+ return self.DoAction( name, {} );
+}
+
+bool Control::Impl::AccessibleImpl::DoGesture(const Dali::Accessibility::GestureInfo &gestureInfo)
+{
+ auto control = Dali::Toolkit::Control::DownCast(self);
+
+ Internal::Control& internalControl = Toolkit::Internal::GetImplementation( control );
+ Internal::Control::Impl& controlImpl = Internal::Control::Impl::Get( internalControl );
+
+ if (!controlImpl.mAccessibilityDoGestureSignal.Empty()) {
+ auto ret = std::make_pair(gestureInfo, false);
+ controlImpl.mAccessibilityDoGestureSignal.Emit(ret);
+ return ret.second;
+ }
+
+ return false;
+}
+
+std::vector<Dali::Accessibility::Relation> Control::Impl::AccessibleImpl::GetRelationSet()
+{
+ auto control = Dali::Toolkit::Control::DownCast(self);
+
+ Internal::Control& internalControl = Toolkit::Internal::GetImplementation( control );
+ Internal::Control::Impl& controlImpl = Internal::Control::Impl::Get( internalControl );
+
+ std::vector<Dali::Accessibility::Relation> ret;
+
+ auto &v = controlImpl.mAccessibilityRelations;
+ for (auto i = 0u; i < v.size(); ++i)
+ {
+ if ( v[i].empty() )
+ continue;
+
+ ret.emplace_back( Accessibility::Relation{ static_cast<Accessibility::RelationType>(i), v[i] } );
+ }
+
+ return ret;
+}
+
+void Control::Impl::PositionOrSizeChangedCallback( PropertyNotification &p )
+{
+ auto self = Dali::Actor::DownCast(p.GetTarget());
+ if (Dali::Accessibility::IsUp() && !self.GetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_ANIMATED ).Get< bool >())
+ {
+ auto extents = DevelActor::CalculateScreenExtents( self );
+ Dali::Accessibility::Accessible::Get( self )->EmitBoundsChanged( extents );
+ }
+}
+
+void Control::Impl::CulledChangedCallback( PropertyNotification &p)
+{
+ if (Dali::Accessibility::IsUp())
+ {
+ auto self = Dali::Actor::DownCast(p.GetTarget());
+ Dali::Accessibility::Accessible::Get(self)->EmitShowing( !self.GetProperty( DevelActor::Property::CULLED ).Get<bool>() );
+ }
+}
+
+void Control::Impl::AccessibilityRegister()
+{
+ if (!accessibilityNotificationSet)
+ {
+ accessibilityNotificationPosition = mControlImpl.Self().AddPropertyNotification( Actor::Property::POSITION, StepCondition( 0.01f ) );
+ accessibilityNotificationPosition.SetNotifyMode( PropertyNotification::NotifyOnChanged );
+ accessibilityNotificationPosition.NotifySignal().Connect( &Control::Impl::PositionOrSizeChangedCallback );
+
+ accessibilityNotificationSize = mControlImpl.Self().AddPropertyNotification( Actor::Property::SIZE, StepCondition( 0.01f ) );
+ accessibilityNotificationSize.SetNotifyMode( PropertyNotification::NotifyOnChanged );
+ accessibilityNotificationSize.NotifySignal().Connect( &Control::Impl::PositionOrSizeChangedCallback );
+
+ accessibilityNotificationCulled = mControlImpl.Self().AddPropertyNotification( DevelActor::Property::CULLED, LessThanCondition( 0.5f ) );
+ accessibilityNotificationCulled.SetNotifyMode( PropertyNotification::NotifyOnChanged );
+ accessibilityNotificationCulled.NotifySignal().Connect( &Control::Impl::CulledChangedCallback );
+
+ accessibilityNotificationSet = true;
+ }
+}
+
+void Control::Impl::AccessibilityDeregister()
+{
+ if (accessibilityNotificationSet)
+ {
+ accessibilityNotificationPosition = {};
+ accessibilityNotificationSize = {};
+ accessibilityNotificationCulled = {};
+ accessibilityNotificationSet = false;
+ }
+}
+
} // namespace Internal
} // namespace Toolkit
projects / platform / core / uifw / dali-toolkit.git / blobdiff