*/
virtual ~Bridge() = default;
- /**
- * @brief Adds the accessible object associated with given actorId to the brige.
- */
- virtual void AddAccessible(uint32_t actorId, std::shared_ptr<Accessible> accessible) = 0;
-
- /**
- * @brief Removed the accessible object associated with given actorId from the brige.
- */
- virtual void RemoveAccessible(uint32_t actorId) = 0;
-
- /**
- * @brief Gets the accessible object associated with given actor from the brige.
- */
- virtual std::shared_ptr<Accessible> GetAccessible(Actor actor) const = 0;
-
- /**
- * @brief Returns true if GetChildren should include hidden objects; false otherwise.
- */
- virtual bool ShouldIncludeHidden() const = 0;
-
/**
* @brief Gets bus name which bridge is initialized on.
*
*
* @param[in] object The accessible object
*/
- virtual void RegisterDefaultLabel(std::shared_ptr<Accessible> object) = 0;
+ virtual void RegisterDefaultLabel(Accessible* object) = 0;
/**
* @brief Removes object from the stack of "default label" sourcing objects.
*
* @param[in] object The accessible object
*/
- virtual void UnregisterDefaultLabel(std::shared_ptr<Accessible> object) = 0;
+ virtual void UnregisterDefaultLabel(Accessible* object) = 0;
/**
* @brief Gets the top-most object from the stack of "default label" sourcing objects.
* Following strings are valid values for "default_label" attribute: "enabled", "disabled".
* Any other value will be interpreted as "enabled".
*/
- virtual Accessible* GetDefaultLabel(Accessible* root) = 0;
+ virtual Accessible* GetDefaultLabel(Accessible* root) const = 0;
/**
* @brief Sets name of current application which will be visible on accessibility bus.
* @param[in] newValue Whether the state value is changed to new value or not.
* @param[in] reserved Reserved. (Currently, this argument is not implemented in dali)
**/
- virtual void EmitStateChanged(std::shared_ptr<Accessible> obj, State state, int newValue, int reserved = 0) = 0;
+ virtual void EmitStateChanged(Accessible* obj, State state, int newValue, int reserved = 0) = 0;
/**
* @brief Emits window event on at-spi bus.
* @param[in] obj The accessible object
* @param[in] event Property changed event
**/
- virtual void Emit(std::shared_ptr<Accessible> obj, ObjectPropertyChangeEvent event) = 0;
+ virtual void Emit(Accessible* obj, ObjectPropertyChangeEvent event) = 0;
/**
* @brief Emits bounds-changed event on at-spi bus.
* @param[in] obj The accessible object
* @param[in] rect The rectangle for changed bounds
**/
- virtual void EmitBoundsChanged(std::shared_ptr<Accessible> obj, Rect<> rect) = 0;
+ virtual void EmitBoundsChanged(Accessible* obj, Rect<> rect) = 0;
+
+ /**
+ * @brief Emits key event on at-spi bus.
+ *
+ * Screen-reader might receive this event and reply, that given keycode is consumed. In that case
+ * further processing of the keycode should be ignored.
+ *
+ * @param[in] type Key event type
+ * @param[in] keyCode Key code
+ * @param[in] keyName Key name
+ * @param[in] timeStamp Time stamp
+ * @param[in] isText Whether it's text or not
+ * @return Whether this event is consumed or not
+ **/
+ virtual Consumed Emit(KeyEventType type, unsigned int keyCode, const std::string& keyName, unsigned int timeStamp, bool isText) = 0;
/**
* @brief Reads given text by screen reader
#include <dali/public-api/actors/actor.h>
#include <dali/public-api/actors/layer.h>
#include <dali/public-api/object/base-object.h>
+#include <dali/public-api/object/object-registry.h>
#include <dali/public-api/object/type-info.h>
#include <dali/public-api/object/type-registry-helper.h>
#include <map>
class AdaptorAccessible : public ActorAccessible
{
private:
- std::unique_ptr<TriggerEventInterface> mRenderNotification{nullptr};
- bool mRoot{false};
+ std::unique_ptr<TriggerEventInterface> mRenderNotification = nullptr;
+
+protected:
+ bool mRoot = false;
public:
AdaptorAccessible(Dali::Actor actor, bool isRoot)
}; // AdaptorAccessible
-using ConvertingResult = std::pair<std::shared_ptr<Accessible>, bool>;
+using AdaptorAccessiblesType = std::map<const Dali::RefObject*, std::unique_ptr<AdaptorAccessible>>;
+
+// Save RefObject from an Actor in Accessible::Get()
+AdaptorAccessiblesType gAdaptorAccessibles;
-std::function<ConvertingResult(Dali::Actor)> convertingFunctor = [](Dali::Actor) -> ConvertingResult {
- return {nullptr, true};
+std::function<Accessible*(Dali::Actor)> convertingFunctor = [](Dali::Actor) -> Accessible* {
+ return nullptr;
};
+ObjectRegistry objectRegistry;
} // namespace
-void Accessible::RegisterExternalAccessibleGetter(std::function<ConvertingResult(Dali::Actor)> functor)
+void Accessible::SetObjectRegistry(ObjectRegistry registry)
+{
+ objectRegistry = registry;
+ objectRegistry.ObjectDestroyedSignal().Connect([](const Dali::RefObject* obj) {
+ gAdaptorAccessibles.erase(obj);
+ });
+}
+
+void Accessible::RegisterExternalAccessibleGetter(std::function<Accessible*(Dali::Actor)> functor)
{
convertingFunctor = functor;
}
-std::shared_ptr<Accessible> Accessible::GetOwningPtr(Dali::Actor actor)
+Accessible* Accessible::Get(Dali::Actor actor)
{
if(!actor)
{
return nullptr;
}
- auto bridge = Bridge::GetCurrentBridge();
-
- // Try finding exsiting accessible object.
- auto accessible = bridge->GetAccessible(actor);
- if(accessible)
- {
- return accessible;
- }
-
- // No acessible object created, let's create one.
- auto result = convertingFunctor(actor);
- accessible = result.first;
- const bool creationEnabled = result.second;
- if(!accessible && creationEnabled)
+ auto accessible = convertingFunctor(actor);
+ if(!accessible)
{
- bool isRoot = false;
- Dali::Integration::Scene scene = Dali::Integration::Scene::Get(actor);
- if(scene)
+ auto pair = gAdaptorAccessibles.emplace(&actor.GetBaseObject(), nullptr);
+ if(pair.second)
{
- isRoot = (actor == scene.GetRootLayer());
- }
- accessible = std::make_shared<AdaptorAccessible>(actor, isRoot);
- }
-
- if(accessible)
- {
- uint32_t actorId = actor.GetProperty<int>(Dali::Actor::Property::ID);
- bridge->AddAccessible(actorId, accessible);
- if(auto actorAccesible = std::dynamic_pointer_cast<ActorAccessible>(accessible))
- {
- actorAccesible->StartObservingDestruction();
+ bool isRoot = false;
+ Dali::Integration::Scene scene = Dali::Integration::Scene::Get(actor);
+ if(scene)
+ {
+ isRoot = (actor == scene.GetRootLayer());
+ }
+ pair.first->second.reset(new AdaptorAccessible(actor, isRoot));
}
+ accessible = pair.first->second.get();
}
return accessible;
}
-
-Accessible* Accessible::Get(Dali::Actor actor)
-{
- auto accessible = Accessible::GetOwningPtr(actor);
- return accessible ? accessible.get() : nullptr;
-}
\ No newline at end of file
mutable std::string mBus, mPath;\r
};\r
\r
+/**\r
+ * @brief Enumeration describing type of key event\r
+ * @see Adaptor::AccessibilityObserver::OnAccessibleKeyEvent\r
+ */\r
+enum class KeyEventType\r
+{\r
+ KEY_PRESSED,\r
+ KEY_RELEASED,\r
+};\r
+\r
/**\r
* @brief Enumeration with human readable values describing state of event\r
* @see Dali::Accessibility::Bridge::Emit\r
namespace Dali::Accessibility
{
ActorAccessible::ActorAccessible(Actor actor)
-: Dali::BaseObjectObserver(actor),
- mSelf(actor),
- mChildrenDirty{true}, // to trigger the initial UpdateChildren()
- mActorId{static_cast<uint32_t>(actor.GetProperty<int>(Dali::Actor::Property::ID))}
+: mSelf(actor),
+ mChildrenDirty{true} // to trigger the initial UpdateChildren()
{
// Select the right overload manually because Connect(this, &OnChildrenChanged) is ambiguous.
void (ActorAccessible::*handler)(Dali::Actor) = &ActorAccessible::OnChildrenChanged;
Dali::DevelActor::ChildOrderChangedSignal(actor).Connect(this, handler);
}
-void ActorAccessible::ObjectDestroyed()
-{
- Bridge::GetCurrentBridge()->RemoveAccessible(mActorId);
-}
-
std::string ActorAccessible::GetName() const
{
return Self().GetProperty<std::string>(Dali::Actor::Property::NAME);
mChildren.clear();
DoGetChildren(mChildren);
- const bool shouldIncludeHidden = Bridge::GetCurrentBridge()->ShouldIncludeHidden();
-
// Erase-remove idiom
// TODO (C++20): Replace with std::erase_if
- auto it = std::remove_if(mChildren.begin(), mChildren.end(), [shouldIncludeHidden](const Accessible* child) {
- return !child || (!shouldIncludeHidden && child->IsHidden());
+ auto it = std::remove_if(mChildren.begin(), mChildren.end(), [](const Accessible* child) {
+ return !child || child->IsHidden();
});
mChildren.erase(it, mChildren.end());
mChildren.shrink_to_fit();
*/
// EXTERNAL INCLUDES
-#include <dali/devel-api/object/base-object-observer.h>
#include <dali/public-api/actors/actor.h>
#include <dali/public-api/object/weak-handle.h>
#include <dali/public-api/signals/connection-tracker.h>
class DALI_ADAPTOR_API ActorAccessible : public virtual Accessible,
public virtual Collection,
public virtual Component,
- public Dali::ConnectionTracker,
- public Dali::BaseObjectObserver
+ public Dali::ConnectionTracker
{
public:
ActorAccessible() = delete;
ActorAccessible(Actor actor);
- // BaseObjectObserver::ObjectDestroyed
- void ObjectDestroyed() override;
-
/**
* @copydoc Dali::Accessibility::Accessible::GetName()
*/
Dali::WeakHandle<Dali::Actor> mSelf;
std::vector<Accessible*> mChildren;
bool mChildrenDirty;
- const uint32_t mActorId;
};
} // namespace Dali::Accessibility
/**
* @brief Basic interface implemented by all accessibility objects.
*/
-class DALI_ADAPTOR_API Accessible : public std::enable_shared_from_this<Accessible>
+class DALI_ADAPTOR_API Accessible
{
public:
virtual ~Accessible() noexcept;
static void SetCurrentlyHighlightedActor(Dali::Actor actor);
/**
- * @brief The method registers functor resposible for converting Actor into Accessible.
- * @param functor The returning Accessible handle from Actor object
+ * @brief Sets ObjectRegistry.
+ *
+ * @param[in] registry ObjectRegistry instance
*/
- static void RegisterExternalAccessibleGetter(std::function<std::pair<std::shared_ptr<Accessible>, bool>(Dali::Actor)> functor);
+ static void SetObjectRegistry(ObjectRegistry registry);
/**
- * @brief Acquires Accessible object from Actor object.
- *
- * @param[in] actor Actor object
- *
- * @return The raw pointer to Accessible object
+ * @brief The method registers functor resposible for converting Actor into Accessible.
+ * @param functor The returning Accessible handle from Actor object
*/
- static Accessible* Get(Dali::Actor actor);
+ static void RegisterExternalAccessibleGetter(std::function<Accessible*(Dali::Actor)> functor);
/**
* @brief Acquires Accessible object from Actor object.
*
* @param[in] actor Actor object
*
- * @return The owning pointer to Accessible object
+ * @return The handle to Accessible object
*/
- static std::shared_ptr<Accessible> GetOwningPtr(Dali::Actor actor);
+ static Accessible* Get(Dali::Actor actor);
/**
* @brief Obtains the DBus interface name for the specified AT-SPI interface.
#define DALI_ADAPTOR_ATSPI_APPLICATION_H
/*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 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.
*/
virtual std::string GetVersion() const = 0;
- /**
- * @brief Gets include_hidden flag currently set on the application.
- *
- * @return true is include_hidden is set; false otherwise.
- */
- virtual bool GetIncludeHidden() const = 0;
-
- /**
- * @brief Sets include_hidden flag to the application.
- *
- * @return true is include_hidden flag is updated; false otherwise.
- */
- virtual bool SetIncludeHidden(bool includeHidden) = 0;
-
/**
* @brief Downcasts an Accessible to an Application.
*
if(shouldEmit)
{
- bridgeData->mBridge->EmitStateChanged(shared_from_this(), state, newValue, reserved);
+ bridgeData->mBridge->EmitStateChanged(this, state, newValue, reserved);
}
}
}
{
if(auto bridgeData = GetBridgeData())
{
- bridgeData->mBridge->Emit(shared_from_this(), event);
+ bridgeData->mBridge->Emit(this, event);
}
}
{
if(auto bridgeData = GetBridgeData())
{
- bridgeData->mBridge->EmitBoundsChanged(shared_from_this(), rect);
+ bridgeData->mBridge->EmitBoundsChanged(this, rect);
}
}
/*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 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.
DBus::DBusInterfaceDescription desc{Accessible::GetInterfaceName(AtspiInterface::APPLICATION)};
AddGetPropertyToInterface(desc, "ToolkitName", &BridgeApplication::GetToolkitName);
AddGetPropertyToInterface(desc, "Version", &BridgeApplication::GetVersion);
- AddFunctionToInterface(desc, "GetIncludeHidden", &BridgeApplication::GetIncludeHidden);
- AddFunctionToInterface(desc, "SetIncludeHidden", &BridgeApplication::SetIncludeHidden);
mDbusServer.addInterface("/", desc, true);
}
{
return FindSelf()->GetVersion();
}
-
-DBus::ValueOrError<bool> BridgeApplication::GetIncludeHidden()
-{
- return FindSelf()->GetIncludeHidden();
-}
-
-DBus::ValueOrError<void> BridgeApplication::SetIncludeHidden(bool includeHidden)
-{
- if(FindSelf()->SetIncludeHidden(includeHidden))
- {
- NotifyIncludeHiddenChanged();
- }
- return {};
-}
#define DALI_INTERNAL_ACCESSIBILITY_BRIDGE_APPLICATION_H
/*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 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.
*/
Dali::Accessibility::Application* FindSelf() const;
-private:
- virtual void NotifyIncludeHiddenChanged(){};
-
public:
/**
* @brief Gets name of graphic user interface framework used by an application.
* @return String with version
*/
std::string GetVersion();
-
- /**
- * @brief Gets include_hidden flag currently set on the application.
- *
- * @return true is include_hidden is set; false otherwise.
- */
- DBus::ValueOrError<bool> GetIncludeHidden();
-
- /**
- * @brief Sets include_hidden flag to the application.
- */
- DBus::ValueOrError<void> SetIncludeHidden(bool includeHidden);
};
#endif // DALI_INTERNAL_ACCESSIBILITY_BRIDGE_APPLICATION_H
{
// Remove entries for objects which no longer exist
mDefaultLabels.remove_if([](const DefaultLabelType& label) {
- // Check 1) window's weak handle; 2) accessible's ref object
- return !label.first.GetBaseHandle() || label.second.expired();
+ return !label.first.GetBaseHandle(); // Check window's weak handle
+ // TODO: Once Accessible becomes a handle type, check its weak handle here as well
});
}
-void BridgeBase::RegisterDefaultLabel(std::shared_ptr<Accessible> object)
+void BridgeBase::RegisterDefaultLabel(Accessible* object)
{
CompressDefaultLabels();
- Dali::WeakHandle<Dali::Window> window = GetWindow(object.get());
+ Dali::WeakHandle<Dali::Window> window = GetWindow(object);
if(!window.GetBaseHandle()) // true also if `object` is null
{
DALI_LOG_ERROR("Cannot register default label: object does not belong to any window");
return;
}
- auto it = std::find_if(mDefaultLabels.begin(), mDefaultLabels.end(), [&object](const DefaultLabelType& label) {
- auto labelPtr = label.second.lock();
- return labelPtr && object == labelPtr;
+ auto it = std::find_if(mDefaultLabels.begin(), mDefaultLabels.end(), [object](const DefaultLabelType& label) {
+ return object == label.second;
});
if(it == mDefaultLabels.end())
}
}
-void BridgeBase::UnregisterDefaultLabel(std::shared_ptr<Accessible> object)
+void BridgeBase::UnregisterDefaultLabel(Accessible* object)
{
CompressDefaultLabels();
- mDefaultLabels.remove_if([&object](const DefaultLabelType& label) {
- auto labelPtr = label.second.lock();
- return labelPtr && object == labelPtr;
+ mDefaultLabels.remove_if([object](const DefaultLabelType& label) {
+ return object == label.second;
});
}
-Accessible* BridgeBase::GetDefaultLabel(Accessible* root)
+Accessible* BridgeBase::GetDefaultLabel(Accessible* root) const
{
- CompressDefaultLabels();
-
Dali::WeakHandle<Dali::Window> window = GetWindow(root);
if(!window.GetBaseHandle())
{
return window == label.first;
});
- Accessible* rawPtr = root;
- if(it != mDefaultLabels.rend())
- {
- if(auto labelPtr = it->second.lock())
- {
- rawPtr = labelPtr.get();
- }
- }
-
- return rawPtr;
+ return (it == mDefaultLabels.rend()) ? root : it->second;
}
std::string BridgeBase::StripPrefix(const std::string& path)
}
auto it = mData->mKnownObjects.find(static_cast<Accessible*>(accessible));
- if(it == mData->mKnownObjects.end() || (!mApplication.mShouldIncludeHidden && (*it)->IsHidden()))
+ if(it == mData->mKnownObjects.end() || (*it)->IsHidden())
{
throw std::domain_error{"unknown object '" + path + "'"};
}
std::string mName;
std::string mToolkitName{"dali"};
bool mIsEmbedded{false};
- bool mShouldIncludeHidden{false};
std::string GetName() const override
{
return std::to_string(Dali::ADAPTOR_MAJOR_VERSION) + "." + std::to_string(Dali::ADAPTOR_MINOR_VERSION);
}
- bool GetIncludeHidden() const override
- {
- return mShouldIncludeHidden;
- }
-
- bool SetIncludeHidden(bool includeHidden) override
- {
- if(mShouldIncludeHidden != includeHidden)
- {
- mShouldIncludeHidden = includeHidden;
- return true;
- }
- return false;
- }
-
// Socket
Dali::Accessibility::Address Embed(Dali::Accessibility::Address plug) override
/**
* @copydoc Dali::Accessibility::Bridge::RegisterDefaultLabel()
*/
- void RegisterDefaultLabel(std::shared_ptr<Dali::Accessibility::Accessible> object) override;
+ void RegisterDefaultLabel(Dali::Accessibility::Accessible* object) override;
/**
* @copydoc Dali::Accessibility::Bridge::UnregisterDefaultLabel()
*/
- void UnregisterDefaultLabel(std::shared_ptr<Dali::Accessibility::Accessible> object) override;
+ void UnregisterDefaultLabel(Dali::Accessibility::Accessible* object) override;
/**
* @copydoc Dali::Accessibility::Bridge::GetDefaultLabel()
*/
- Dali::Accessibility::Accessible* GetDefaultLabel(Dali::Accessibility::Accessible* root) override;
+ Dali::Accessibility::Accessible* GetDefaultLabel(Dali::Accessibility::Accessible* root) const override;
/**
* @copydoc Dali::Accessibility::Bridge::GetApplication()
protected:
// We use a weak handle in order not to keep a window alive forever if someone forgets to UnregisterDefaultLabel()
- using DefaultLabelType = std::pair<Dali::WeakHandle<Dali::Window>, std::weak_ptr<Dali::Accessibility::Accessible>>;
+ using DefaultLabelType = std::pair<Dali::WeakHandle<Dali::Window>, Dali::Accessibility::Accessible*>;
using DefaultLabelsType = std::list<DefaultLabelType>;
mutable ApplicationAccessible mApplication;
#include <map>
// INTERNAL INCLUDES
-#include <dali/devel-api/adaptor-framework/actor-accessible.h>
#include <dali/devel-api/adaptor-framework/environment-variable.h>
#include <dali/devel-api/adaptor-framework/window-devel.h>
#include <dali/internal/accessibility/bridge/accessibility-common.h>
public BridgeTable,
public BridgeTableCell
{
- DBus::DBusClient mAccessibilityStatusClient{};
- DBus::DBusClient mRegistryClient{};
- DBus::DBusClient mDirectReadingClient{};
- bool mIsScreenReaderEnabled{false};
- bool mIsEnabled{false};
- bool mIsApplicationRunning{false};
- std::unordered_map<int32_t, std::function<void(std::string)>> mDirectReadingCallbacks{};
- Dali::Actor mHighlightedActor;
- std::function<void(Dali::Actor)> mHighlightClearAction{nullptr};
- Dali::CallbackBase* mIdleCallback{};
- Dali::Timer mInitializeTimer;
- Dali::Timer mReadIsEnabledTimer;
- Dali::Timer mReadScreenReaderEnabledTimer;
- Dali::Timer mForceUpTimer;
- std::string mPreferredBusName;
- std::map<uint32_t, std::shared_ptr<Accessible>> mAccessibles; // Actor.ID to Accessible map
+ DBus::DBusClient mAccessibilityStatusClient;
+ DBus::DBusClient mRegistryClient;
+ DBus::DBusClient mDirectReadingClient;
+ bool mIsScreenReaderEnabled = false;
+ bool mIsEnabled = false;
+ bool mIsApplicationRunning = false;
+ std::map<int32_t, std::function<void(std::string)>> mDirectReadingCallbacks;
+ Dali::Actor mHighlightedActor;
+ std::function<void(Dali::Actor)> mHighlightClearAction;
+ Dali::CallbackBase* mIdleCallback = NULL;
+ Dali::Timer mInitializeTimer;
+ Dali::Timer mReadIsEnabledTimer;
+ Dali::Timer mReadScreenReaderEnabledTimer;
+ Dali::Timer mForceUpTimer;
+ std::string mPreferredBusName;
public:
BridgeImpl()
}
/**
- * @copydoc Dali::Accessibility::Bridge::AddAccessible()
+ * @copydoc Dali::Accessibility::Bridge::Emit()
*/
- void AddAccessible(uint32_t actorId, std::shared_ptr<Accessible> accessible) override
+ Consumed Emit(KeyEventType type, unsigned int keyCode, const std::string& keyName, unsigned int timeStamp, bool isText) override
{
- mAccessibles[actorId] = std::move(accessible);
- }
-
- /**
- * @copydoc Dali::Accessibility::Bridge::RemoveAccessible()
- */
- void RemoveAccessible(uint32_t actorId) override
- {
- mAccessibles.erase(actorId);
- }
-
- /**
- * @copydoc Dali::Accessibility::Bridge::GetAccessible()
- */
- std::shared_ptr<Accessible> GetAccessible(Dali::Actor actor) const override
- {
- uint32_t actorId = actor.GetProperty<int>(Dali::Actor::Property::ID);
- auto iter = mAccessibles.find(actorId);
- return iter != mAccessibles.end() ? iter->second : nullptr;
- }
+ if(!IsUp())
+ {
+ return Consumed::NO;
+ }
- /**
- * @copydoc Dali::Accessibility::Bridge::ShouldIncludeHidden()
- */
- bool ShouldIncludeHidden() const override
- {
- return mApplication.mShouldIncludeHidden;
- }
+ unsigned int keyType = 0;
- void NotifyIncludeHiddenChanged() override
- {
- for(const auto& iter : mAccessibles)
+ switch(type)
{
- const auto& accessible = iter.second;
- if(accessible->IsHidden())
+ case KeyEventType::KEY_PRESSED:
{
- auto* parent = dynamic_cast<ActorAccessible*>(accessible->GetParent());
- if(parent)
- {
- parent->OnChildrenChanged();
- }
+ keyType = 0;
+ break;
+ }
+ case KeyEventType::KEY_RELEASED:
+ {
+ keyType = 1;
+ break;
+ }
+ default:
+ {
+ return Consumed::NO;
}
}
+
+ return Consumed::NO;
}
/**
{"", "root"});
}
-void BridgeObject::Emit(std::shared_ptr<Accessible> obj, ObjectPropertyChangeEvent event)
+void BridgeObject::Emit(Accessible* obj, ObjectPropertyChangeEvent event)
{
static const std::map<ObjectPropertyChangeEvent, std::string_view> eventMap{
{ObjectPropertyChangeEvent::NAME, "accessible-name"},
if(eventName != eventMap.end())
{
mDbusServer.emit2<std::string, int, int, DBus::EldbusVariant<int>, Address>(
- GetAccessiblePath(obj.get()),
+ GetAccessiblePath(obj),
Accessible::GetInterfaceName(AtspiInterface::EVENT_OBJECT),
"PropertyChange",
std::string{eventName->second},
}
}
-void BridgeObject::EmitStateChanged(std::shared_ptr<Accessible> obj, State state, int newValue, int reserved)
+void BridgeObject::EmitStateChanged(Accessible* obj, State state, int newValue, int reserved)
{
static const std::map<State, std::string_view> stateMap{
{State::INVALID, "invalid"},
if(stateName != stateMap.end())
{
mDbusServer.emit2<std::string, int, int, DBus::EldbusVariant<int>, Address>(
- GetAccessiblePath(obj.get()),
+ GetAccessiblePath(obj),
Accessible::GetInterfaceName(AtspiInterface::EVENT_OBJECT),
"StateChanged",
std::string{stateName->second},
}
}
-void BridgeObject::EmitBoundsChanged(std::shared_ptr<Accessible> obj, Dali::Rect<> rect)
+void BridgeObject::EmitBoundsChanged(Accessible* obj, Dali::Rect<> rect)
{
if(!IsUp() || !IsBoundsChangedEventAllowed || obj->IsHidden() || obj->GetSuppressedEvents()[AtspiEvent::BOUNDS_CHANGED])
{
return;
}
- AddCoalescableMessage(CoalescableMessages::BOUNDS_CHANGED, obj.get(), 1.0f, [=, weakObj = std::weak_ptr<Accessible>(obj), rect = std::move(rect)]() {
- if(auto accessible = weakObj.lock())
- {
- DBus::EldbusVariant<std::tuple<int32_t, int32_t, int32_t, int32_t> > tmp{
- std::tuple<int32_t, int32_t, int32_t, int32_t>{rect.x, rect.y, rect.width, rect.height}};
-
- mDbusServer.emit2<std::string, int, int, DBus::EldbusVariant<std::tuple<int32_t, int32_t, int32_t, int32_t> >, Address>(
- GetAccessiblePath(accessible.get()),
- Accessible::GetInterfaceName(AtspiInterface::EVENT_OBJECT),
- "BoundsChanged",
- "",
- 0,
- 0,
- tmp,
- {"", "root"});
- }
+ DBus::EldbusVariant<std::tuple<int32_t, int32_t, int32_t, int32_t> > tmp{
+ std::tuple<int32_t, int32_t, int32_t, int32_t>{rect.x, rect.y, rect.width, rect.height}};
+
+ AddCoalescableMessage(CoalescableMessages::BOUNDS_CHANGED, obj, 1.0f, [=]() {
+ mDbusServer.emit2<std::string, int, int, DBus::EldbusVariant<std::tuple<int32_t, int32_t, int32_t, int32_t> >, Address>(
+ GetAccessiblePath(obj),
+ Accessible::GetInterfaceName(AtspiInterface::EVENT_OBJECT),
+ "BoundsChanged",
+ "",
+ 0,
+ 0,
+ tmp,
+ {"", "root"});
});
}
/**
* @copydoc Dali::Accessibility::Bridge::EmitStateChanged()
*/
- void EmitStateChanged(std::shared_ptr<Dali::Accessibility::Accessible> obj, Dali::Accessibility::State state, int newValue, int reserved) override;
+ void EmitStateChanged(Dali::Accessibility::Accessible* obj, Dali::Accessibility::State state, int newValue, int reserved) override;
/**
* @copydoc Dali::Accessibility::Bridge::Emit()
/**
* @copydoc Dali::Accessibility::Bridge::Emit()
*/
- void Emit(std::shared_ptr<Dali::Accessibility::Accessible> obj, Dali::Accessibility::ObjectPropertyChangeEvent event) override;
+ void Emit(Dali::Accessibility::Accessible* obj, Dali::Accessibility::ObjectPropertyChangeEvent event) override;
/**
* @copydoc Dali::Accessibility::Bridge::EmitBoundsChanged()
*/
- void EmitBoundsChanged(std::shared_ptr<Dali::Accessibility::Accessible> obj, Dali::Rect<> rect) override;
+ void EmitBoundsChanged(Dali::Accessibility::Accessible* obj, Dali::Rect<> rect) override;
/**
* @copydoc Dali::Accessibility::Bridge::EmitMovedOutOfScreen()
{
}
- void RegisterDefaultLabel(std::shared_ptr<Accessibility::Accessible> object) override
+ void RegisterDefaultLabel(Accessibility::Accessible* object) override
{
}
- void UnregisterDefaultLabel(std::shared_ptr<Accessibility::Accessible> object) override
+ void UnregisterDefaultLabel(Accessibility::Accessible* object) override
{
}
- Dali::Accessibility::Accessible* GetDefaultLabel(Dali::Accessibility::Accessible* root) override
+ Dali::Accessibility::Accessible* GetDefaultLabel(Dali::Accessibility::Accessible* root) const override
{
return nullptr;
}
{
}
- void EmitStateChanged(std::shared_ptr<Accessibility::Accessible> obj, Accessibility::State state, int newValue, int reserved) override
+ void EmitStateChanged(Accessibility::Accessible* obj, Accessibility::State state, int newValue, int reserved) override
{
}
{
}
- void Emit(std::shared_ptr<Accessibility::Accessible> obj, Accessibility::ObjectPropertyChangeEvent event) override
+ void Emit(Accessibility::Accessible* obj, Accessibility::ObjectPropertyChangeEvent event) override
{
}
- void EmitBoundsChanged(std::shared_ptr<Accessibility::Accessible> obj, Rect<> rect) override
+ void EmitBoundsChanged(Accessibility::Accessible* obj, Rect<> rect) override
{
}
+ Accessibility::Consumed Emit(Accessibility::KeyEventType type, unsigned int keyCode, const std::string& keyName, unsigned int timeStamp, bool isText) override
+ {
+ return Accessibility::Consumed::YES;
+ }
+
void Say(const std::string& text, bool discardable, std::function<void(std::string)> callback) override
{
}
void SetPreferredBusName(std::string_view preferredBusName) override
{
}
-
- void AddAccessible(uint32_t actorId, std::shared_ptr<Accessible> accessible) override
- {
- }
-
- void RemoveAccessible(uint32_t actorId) override
- {
- }
-
- std::shared_ptr<Accessible> GetAccessible(Actor actor) const override
- {
- return nullptr;
- };
-
- bool ShouldIncludeHidden() const override
- {
- return false;
- }
};
} // namespace Dali::Accessibility
mConfigurationManager = Utils::MakeUnique<ConfigurationManager>(systemCachePath, mGraphics.get(), mThreadController);
}
+void Adaptor::AccessibilityObserver::OnAccessibleKeyEvent(const Dali::KeyEvent& event)
+{
+ Accessibility::KeyEventType type;
+ if(event.GetState() == Dali::KeyEvent::DOWN)
+ {
+ type = Accessibility::KeyEventType::KEY_PRESSED;
+ }
+ else if(event.GetState() == Dali::KeyEvent::UP)
+ {
+ type = Accessibility::KeyEventType::KEY_RELEASED;
+ }
+ else
+ {
+ return;
+ }
+ Dali::Accessibility::Bridge::GetCurrentBridge()->Emit(type, event.GetKeyCode(), event.GetKeyName(), event.GetTime(), !event.GetKeyString().empty());
+}
+
Adaptor::~Adaptor()
{
Accessibility::Bridge::GetCurrentBridge()->Terminate();
auto bridge = Accessibility::Bridge::GetCurrentBridge();
bridge->SetApplicationName(appName);
bridge->Initialize();
+ Dali::Stage::GetCurrent().KeyEventSignal().Connect(&mAccessibilityObserver, &AccessibilityObserver::OnAccessibleKeyEvent);
Dali::Internal::Adaptor::SceneHolder* defaultWindow = mWindows.front();
std::unique_ptr<Integration::AddOnManager> mAddOnManager; ///< Pointer to the addon manager
+ class AccessibilityObserver : public ConnectionTracker
+ {
+ public:
+ void OnAccessibleKeyEvent(const Dali::KeyEvent& event);
+ };
+ AccessibilityObserver mAccessibilityObserver;
+
public:
inline static Adaptor& GetImplementation(Dali::Adaptor& adaptor)
{
DALI_TRACE_BEGIN(gTraceFilter, "DALI_APP_ADAPTOR_START");
mAdaptor->Start();
DALI_TRACE_END(gTraceFilter, "DALI_APP_ADAPTOR_START");
+ Accessibility::Accessible::SetObjectRegistry(mAdaptor->GetObjectRegistry());
if(!mStylesheet.empty())
{
projects / platform / core / uifw / dali-adaptor.git / commitdiff