From: Eunki Hong Date: Thu, 8 Jul 2021 13:25:58 +0000 (+0000) Subject: Merge "Add class for encoded image buffer" into devel/master X-Git-Tag: dali_2.0.34~1 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=cb3eac000069a449cc32987911322d91ffdf9b57;hp=9eed8b79466caf1505ea0ea49b04e3b54db04383;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git Merge "Add class for encoded image buffer" into devel/master --- diff --git a/automated-tests/src/dali-adaptor/dali-test-suite-utils/test-graphics-reflection.cpp b/automated-tests/src/dali-adaptor/dali-test-suite-utils/test-graphics-reflection.cpp index d59f29f..8493992 100644 --- a/automated-tests/src/dali-adaptor/dali-test-suite-utils/test-graphics-reflection.cpp +++ b/automated-tests/src/dali-adaptor/dali-test-suite-utils/test-graphics-reflection.cpp @@ -240,9 +240,10 @@ bool TestGraphicsReflection::GetNamedUniform(const std::string& name, Dali::Grap return true; } -std::vector TestGraphicsReflection::GetSamplers() const +const std::vector& TestGraphicsReflection::GetSamplers() const { - return std::vector{}; + static std::vector samplers{}; + return samplers; } Graphics::ShaderLanguage TestGraphicsReflection::GetLanguage() const diff --git a/automated-tests/src/dali-adaptor/dali-test-suite-utils/test-graphics-reflection.h b/automated-tests/src/dali-adaptor/dali-test-suite-utils/test-graphics-reflection.h index 7af052e..2147cae 100644 --- a/automated-tests/src/dali-adaptor/dali-test-suite-utils/test-graphics-reflection.h +++ b/automated-tests/src/dali-adaptor/dali-test-suite-utils/test-graphics-reflection.h @@ -28,22 +28,22 @@ class TestGraphicsReflection : public Graphics::Reflection public: TestGraphicsReflection(TestGlAbstraction& gl, Property::Array& vertexFormats, const Graphics::ProgramCreateInfo& createInfo, std::vector& customUniforms); - uint32_t GetVertexAttributeLocation(const std::string& name) const override; - Dali::Graphics::VertexInputAttributeFormat GetVertexAttributeFormat(uint32_t location) const override; - std::string GetVertexAttributeName(uint32_t location) const override; - std::vector GetVertexAttributeLocations() const override; - uint32_t GetUniformBlockCount() const override; - uint32_t GetUniformBlockBinding(uint32_t index) const override; - uint32_t GetUniformBlockSize(uint32_t index) const override; - bool GetUniformBlock(uint32_t index, Dali::Graphics::UniformBlockInfo& out) const override; - std::vector GetUniformBlockLocations() const override; - std::string GetUniformBlockName(uint32_t blockIndex) const override; - uint32_t GetUniformBlockMemberCount(uint32_t blockIndex) const override; - std::string GetUniformBlockMemberName(uint32_t blockIndex, uint32_t memberLocation) const override; - uint32_t GetUniformBlockMemberOffset(uint32_t blockIndex, uint32_t memberLocation) const override; - bool GetNamedUniform(const std::string& name, Dali::Graphics::UniformInfo& out) const override; - std::vector GetSamplers() const override; - Graphics::ShaderLanguage GetLanguage() const override; + uint32_t GetVertexAttributeLocation(const std::string& name) const override; + Dali::Graphics::VertexInputAttributeFormat GetVertexAttributeFormat(uint32_t location) const override; + std::string GetVertexAttributeName(uint32_t location) const override; + std::vector GetVertexAttributeLocations() const override; + uint32_t GetUniformBlockCount() const override; + uint32_t GetUniformBlockBinding(uint32_t index) const override; + uint32_t GetUniformBlockSize(uint32_t index) const override; + bool GetUniformBlock(uint32_t index, Dali::Graphics::UniformBlockInfo& out) const override; + std::vector GetUniformBlockLocations() const override; + std::string GetUniformBlockName(uint32_t blockIndex) const override; + uint32_t GetUniformBlockMemberCount(uint32_t blockIndex) const override; + std::string GetUniformBlockMemberName(uint32_t blockIndex, uint32_t memberLocation) const override; + uint32_t GetUniformBlockMemberOffset(uint32_t blockIndex, uint32_t memberLocation) const override; + bool GetNamedUniform(const std::string& name, Dali::Graphics::UniformInfo& out) const override; + const std::vector& GetSamplers() const override; + Graphics::ShaderLanguage GetLanguage() const override; public: // Test methods void SetAttributes(std::vector locations) diff --git a/dali/devel-api/adaptor-framework/accessibility-impl.cpp b/dali/devel-api/adaptor-framework/accessibility-impl.cpp index dfbaa4d..48b1a10 100644 --- a/dali/devel-api/adaptor-framework/accessibility-impl.cpp +++ b/dali/devel-api/adaptor-framework/accessibility-impl.cpp @@ -547,27 +547,27 @@ std::string Accessible::GetRoleName() Dali::Actor Accessible::GetCurrentlyHighlightedActor() { - return IsUp() ? Bridge::GetCurrentBridge()->data->currentlyHighlightedActor : Dali::Actor{}; + return IsUp() ? Bridge::GetCurrentBridge()->mData->mCurrentlyHighlightedActor : Dali::Actor{}; } void Accessible::SetCurrentlyHighlightedActor(Dali::Actor actor) { if(IsUp()) { - Bridge::GetCurrentBridge()->data->currentlyHighlightedActor = actor; + Bridge::GetCurrentBridge()->mData->mCurrentlyHighlightedActor = actor; } } Dali::Actor Accessible::GetHighlightActor() { - return IsUp() ? Bridge::GetCurrentBridge()->data->highlightActor : Dali::Actor{}; + return IsUp() ? Bridge::GetCurrentBridge()->mData->mHighlightActor : Dali::Actor{}; } void Accessible::SetHighlightActor(Dali::Actor actor) { if(IsUp()) { - Bridge::GetCurrentBridge()->data->highlightActor = actor; + Bridge::GetCurrentBridge()->mData->mHighlightActor = actor; } } @@ -576,18 +576,18 @@ void Bridge::ForceDown() auto highlighted = Accessible::GetCurrentlyHighlightedActor(); if(highlighted) { - auto p = dynamic_cast(Accessible::Get(highlighted)); - if(p) + auto component = dynamic_cast(Accessible::Get(highlighted)); + if(component) { - p->ClearHighlight(); + component->ClearHighlight(); } } - data = {}; + mData = {}; } -void Bridge::SetIsOnRootLevel(Accessible* o) +void Bridge::SetIsOnRootLevel(Accessible* owner) { - o->isOnRootLevel = true; + owner->mIsOnRootLevel = true; } namespace @@ -595,12 +595,12 @@ namespace class NonControlAccessible : public virtual Accessible, public virtual Collection, public virtual Component { protected: - Dali::WeakHandle self; - bool root = false; + Dali::WeakHandle mSelf; + bool mRoot = false; Dali::Actor Self() { - auto handle = self.GetHandle(); + auto handle = mSelf.GetHandle(); // NonControlAccessible is deleted on ObjectDestroyedSignal // for the respective actor (see `nonControlAccessibles`). @@ -610,13 +610,13 @@ protected: } public: - NonControlAccessible(Dali::Actor actor, bool root) - : self(actor), - root(root) + NonControlAccessible(Dali::Actor actor, bool isRoot) + : mSelf(actor), + mRoot(isRoot) { } - Dali::Rect<> GetExtents(Dali::Accessibility::CoordType ctype) override + Dali::Rect<> GetExtents(Dali::Accessibility::CoordinateType type) override { Dali::Actor actor = Self(); Vector2 screenPosition = actor.GetProperty(Actor::Property::SCREEN_POSITION).Get(); @@ -627,64 +627,77 @@ public: return {position.x, position.y, size.x, size.y}; } + Dali::Accessibility::ComponentLayer GetLayer() override { return Dali::Accessibility::ComponentLayer::WINDOW; } - int16_t GetMdiZOrder() + + int16_t GetMdiZOrder() override { return 0; } - double GetAlpha() + + double GetAlpha() override { return 0; } + bool GrabFocus() override { return false; } + bool GrabHighlight() override { return false; } + bool ClearHighlight() override { return false; } + bool IsScrollable() override { return false; } + std::string GetName() override { return Self().GetProperty(Dali::Actor::Property::NAME); } + std::string GetDescription() override { return ""; } + Accessible* GetParent() override { - if(GetIsOnRootLevel()) + if(IsOnRootLevel()) { - auto b = GetBridgeData(); - return b->bridge->GetApplication(); + auto data = GetBridgeData(); + return data->mBridge->GetApplication(); } return Get(Self().GetParent()); } + size_t GetChildCount() override { return static_cast(Self().GetChildCount()); } + Accessible* GetChildAtIndex(size_t index) override { - auto s = static_cast(Self().GetChildCount()); - if(index >= s) + auto numberOfChildren = static_cast(Self().GetChildCount()); + if(index >= numberOfChildren) { - throw std::domain_error{"invalid index " + std::to_string(index) + " for object with " + std::to_string(s) + " children"}; + throw std::domain_error{"invalid index " + std::to_string(index) + " for object with " + std::to_string(numberOfChildren) + " children"}; } return Get(Self().GetChildAt(static_cast(index))); } + size_t GetIndexInParent() override { auto parent = Self().GetParent(); @@ -702,34 +715,38 @@ public: } throw std::domain_error{"actor is not a child of it's parent"}; } + Role GetRole() override { - return root ? Role::WINDOW : Role::REDUNDANT_OBJECT; + return mRoot ? Role::WINDOW : Role::REDUNDANT_OBJECT; } + States GetStates() override { - States s; - if(root) + States state; + if(mRoot) { - s[State::ENABLED] = true; - s[State::SENSITIVE] = true; - s[State::SHOWING] = true; - s[State::VISIBLE] = true; - s[State::ACTIVE] = true; + state[State::ENABLED] = true; + state[State::SENSITIVE] = true; + state[State::SHOWING] = true; + state[State::VISIBLE] = true; + state[State::ACTIVE] = true; } else { - auto t = GetParent()->GetStates(); - s[State::SHOWING] = t[State::SHOWING]; - s[State::VISIBLE] = t[State::VISIBLE]; + auto parentState = GetParent()->GetStates(); + state[State::SHOWING] = parentState[State::SHOWING]; + state[State::VISIBLE] = parentState[State::VISIBLE]; } - return s; + return state; } + Attributes GetAttributes() override { Dali::TypeInfo type; Self().GetTypeInfo(type); - return { + return + { {"class", type.GetName()}, }; } @@ -766,12 +783,13 @@ void Accessible::RegisterControlAccessibilityGetter(std::functionsecond.reset(new NonControlAccessible(actor, root)); + pair.first->second.reset(new NonControlAccessible(actor, isRoot)); } - accessible = it.first->second.get(); + accessible = pair.first->second.get(); } return accessible; } diff --git a/dali/devel-api/adaptor-framework/accessibility-impl.h b/dali/devel-api/adaptor-framework/accessibility-impl.h index f8032fc..304f2c1 100644 --- a/dali/devel-api/adaptor-framework/accessibility-impl.h +++ b/dali/devel-api/adaptor-framework/accessibility-impl.h @@ -49,7 +49,7 @@ class DALI_ADAPTOR_API Collection; class DALI_ADAPTOR_API Action; /** - * @brief Base class for different accessibility bridges + * @brief Base class for different accessibility bridges. * * Bridge is resposible for initializing and managing connection on accessibility bus. * Accessibility clients will not get any information about UI without initialized and upraised bridge. @@ -71,84 +71,94 @@ struct DALI_ADAPTOR_API Bridge virtual ~Bridge() = default; /** - * @brief Get bus name which bridge is initialized on + * @brief Gets bus name which bridge is initialized on. */ virtual const std::string& GetBusName() const = 0; /** - * @brief Registers top level window + * @brief Registers top level window. * * Hierarchy of objects visible for accessibility clients is based on tree-like * structure created from Actors objects. This method allows to connect chosen * object as direct ancestor of application and therefore make it visible for * accessibility clients. + * + * @param[in] object The accessible object */ - virtual void AddTopLevelWindow(Accessible*) = 0; + virtual void AddTopLevelWindow(Accessible* object) = 0; /** - * @brief Removes top level window + * @brief Removes top level window. * * Hierarchy of objects visible for accessibility clients is based on tree-like * structure created from Actors objects. This method removes previously added * window from visible accessibility objects. + * + * @param[in] object The accessible object */ - virtual void RemoveTopLevelWindow(Accessible*) = 0; + virtual void RemoveTopLevelWindow(Accessible* object) = 0; /** - * @brief Adds popup window + * @brief Adds popup window. * * Hierarchy of objects visible for accessibility clients is based on tree-like * structure created from Actors objects. This method adds new popup to the tree. + * + * @param[in] object The accessible object */ - virtual void AddPopup(Accessible*) = 0; + virtual void AddPopup(Accessible* object) = 0; /** - * @brief Removes popup window + * @brief Removes popup window. * * Hierarchy of objects visible for accessibility clients is based on tree-like * structure created from Actors objects. This method removes previously added * popup window. + * + * @param[in] object The accessible object */ - virtual void RemovePopup(Accessible*) = 0; + virtual void RemovePopup(Accessible* object) = 0; /** - * @brief Set name of current application which will be visible on accessibility bus + * @brief Sets name of current application which will be visible on accessibility bus. + * + * @param[in] name The application name */ - virtual void SetApplicationName(std::string) = 0; + virtual void SetApplicationName(std::string name) = 0; /** - * @brief Get object being root of accessibility tree + * @brief Gets object being root of accessibility tree. * * @return handler to accessibility object */ virtual Accessible* GetApplication() const = 0; /** - * @brief Find an object in accessibility tree + * @brief Finds an object in accessibility tree. * - * @param[in] s path to object + * @param[in] path The path to object * - * @return handler to accessibility object + * @return The handler to accessibility object */ - virtual Accessible* FindByPath(const std::string& s) const = 0; + virtual Accessible* FindByPath(const std::string& path) const = 0; /** - * @brief Show application on accessibility bus + * @brief Shows application on accessibility bus. */ virtual void ApplicationShown() = 0; /** - * @brief Hide application on accessibility bus + * @brief Hides application on accessibility bus. */ virtual void ApplicationHidden() = 0; /** - * @brief Initialize accessibility bus + * @brief Initializes accessibility bus. */ virtual void Initialize() = 0; /** - * @brief Terminate accessibility bus + * @brief Terminates accessibility bus. */ virtual void Terminate() = 0; @@ -157,12 +167,12 @@ struct DALI_ADAPTOR_API Bridge */ virtual ForceUpResult ForceUp() { - if(data) + if(mData) { return ForceUpResult::ALREADY_UP; } - data = std::make_shared(); - data->bridge = this; + mData = std::make_shared(); + mData->mBridge = this; return ForceUpResult::JUST_STARTED; } @@ -172,46 +182,73 @@ struct DALI_ADAPTOR_API Bridge virtual void ForceDown() = 0; /** - * @brief Check if bridge is activated or not. + * @brief Checks if bridge is activated or not. * @return True if brige is activated. */ bool IsUp() const { - return bool(data); + return bool(mData); } /** - * @brief Emits caret-moved event on at-spi bus. + * @brief Emits cursor-moved event on at-spi bus. + * + * @param[in] obj The accessible object + * @param[in] cursorPosition The new cursor position **/ - virtual void EmitCaretMoved(Accessible* obj, unsigned int cursorPosition) = 0; + virtual void EmitCursorMoved(Accessible* obj, unsigned int cursorPosition) = 0; /** * @brief Emits active-descendant-changed event on at-spi bus. + * + * @param[in] obj The accessible object + * @param[in] child The child of the object **/ virtual void EmitActiveDescendantChanged(Accessible* obj, Accessible* child) = 0; /** * @brief Emits text-changed event on at-spi bus. + * + * @param[in] obj The accessible object + * @param[in] state The changed state for text, such as Inserted or Deleted + * @param[in] position The cursor position + * @param[in] length The text length + * @param[in] content The changed text **/ virtual void EmitTextChanged(Accessible* obj, TextChangedState state, unsigned int position, unsigned int length, const std::string& content) = 0; /** * @brief Emits state-changed event on at-spi bus. + * + * @param[in] obj The accessible object + * @param[in] state The accessibility state (SHOWING, HIGHLIGHTED, etc) + * @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(Accessible* obj, State state, int val1, int val2 = 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 The enumerated window event + * @param[in] detail The additional parameter which interpretation depends on chosen event **/ - virtual void Emit(Accessible* obj, WindowEvent we, unsigned int detail1 = 0) = 0; + virtual void Emit(Accessible* obj, WindowEvent event, unsigned int detail = 0) = 0; /** * @brief Emits property-changed event on at-spi bus. + * + * @param[in] obj The accessible object + * @param[in] event Property changed event **/ 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(Accessible* obj, Rect<> rect) = 0; @@ -220,16 +257,23 @@ struct DALI_ADAPTOR_API Bridge * * 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 * - * @param text The text to read - * @param discardable If TRUE, reading can be discarded by subsequent reading requests, + * @param[in] text The text to read + * @param[in] discardable If TRUE, reading can be discarded by subsequent reading requests, * if FALSE the reading must finish before next reading request can be started - * @param callback the callback function that is called on reading signals emitted + * @param[in] callback the callback function that is called on reading signals emitted * during processing of this reading request. * Callback can be one of the following signals: * ReadingCancelled, ReadingStopped, ReadingSkipped @@ -249,29 +293,35 @@ struct DALI_ADAPTOR_API Bridge /** * @brief Cancels anything screen-reader is reading / has queued to read * - * @param alsoNonDiscardable whether to cancel non-discardable readings as well + * @param[in] alsoNonDiscardable whether to cancel non-discardable readings as well */ virtual void StopReading(bool alsoNonDiscardable) = 0; /** * @brief Suppresses reading of screen-reader * - * @param suppress whether to suppress reading of screen-reader + * @param[in] suppress whether to suppress reading of screen-reader */ virtual void SuppressScreenReader(bool suppress) = 0; /** - * @brief Get screen reader status. + * @brief Gets screen reader status. + * + * @return True if screen reader is enabled */ virtual bool GetScreenReaderEnabled() = 0; /** - * @brief Get ATSPI status. + * @brief Gets ATSPI status. + * + * @return True if ATSPI is enabled */ - virtual bool GetIsEnabled() = 0; + virtual bool IsEnabled() = 0; /** * @brief Returns instance of bridge singleton object. + * + * @return The current bridge object **/ static Bridge* GetCurrentBridge(); @@ -306,12 +356,13 @@ struct DALI_ADAPTOR_API Bridge protected: struct Data { - std::unordered_set knownObjects; - std::string busName; - Bridge* bridge = nullptr; - Actor highlightActor, currentlyHighlightedActor; + std::unordered_set mKnownObjects; + std::string mBusName; + Bridge* mBridge = nullptr; + Actor mHighlightActor; + Actor mCurrentlyHighlightedActor; }; - std::shared_ptr data; + std::shared_ptr mData; friend class Accessible; enum class AutoInitState @@ -319,28 +370,33 @@ protected: DISABLED, ENABLED }; + inline static AutoInitState autoInitState = AutoInitState::ENABLED; /** - * @brief Registers accessible object to be known in bridge object + * @brief Registers accessible object to be known in bridge object. * * Bridge must known about all currently alive accessible objects, as some requst * might come and object will be identified by number id (it's memory address). * To avoid memory corruption number id is checked against set of known objects. + * + * @param[in] object The accessible object **/ - void RegisterOnBridge(Accessible*); + void RegisterOnBridge(Accessible* object); /** * @brief Tells bridge, that given object is considered root (doesn't have any parents). * * All root objects will have the same parent - application object. Application object * is controlled by bridge and private. + * + * @param[in] owner The accessible object **/ - void SetIsOnRootLevel(Accessible*); + void SetIsOnRootLevel(Accessible* owner); }; /** - * @brief Check if ATSPI is activated or not. + * @brief Checks if ATSPI is activated or not. * @return True if ATSPI is activated. */ inline bool IsUp() @@ -349,15 +405,17 @@ inline bool IsUp() { return false; } - if(Bridge::GetCurrentBridge()->GetIsEnabled() == false) + + if(Bridge::GetCurrentBridge()->IsEnabled() == false) { return false; } + return Bridge::GetCurrentBridge()->IsUp(); } /** - * @brief Basic interface implemented by all accessibility objects + * @brief Basic interface implemented by all accessibility objects. */ class Accessible { @@ -367,160 +425,180 @@ public: using utf8_t = unsigned char; /** - * @brief Calculaties word boundaries in given utf8 text. + * @brief Calculates and finds word boundaries in given utf8 text. * - * s and length represents source text pointer and it's length respectively. langauge represents - * language to use. Word boundaries are returned as non-zero values in table breaks, which - * must be of size at least length. - **/ - void FindWordSeparationsUtf8(const utf8_t* s, size_t length, const char* language, char* breaks); + * @param[in] string The source text to find + * @param[in] length The length of text to find + * @param[in] language The language to use + * @param[out] breaks The word boundaries in given text + * + * @note Word boundaries are returned as non-zero values in table breaks, which must be of size at least length. + */ + void FindWordSeparationsUtf8(const utf8_t* string, size_t length, const char* language, char* breaks); /** - * @brief Calculaties line boundaries in given utf8 text. + * @brief Calculates and finds line boundaries in given utf8 text. * - * s and length represents source text pointer and it's length respectively. langauge represents - * language to use. Line boundaries are returned as non-zero values in table breaks, which - * must be of size at least length. - **/ - void FindLineSeparationsUtf8(const utf8_t* s, size_t length, const char* language, char* breaks); + * @param[in] string The source text to find + * @param[in] length The length of text to find + * @param[in] language The language to use + * @param[out] breaks The line boundaries in given text + * + * @note Line boundaries are returned as non-zero values in table breaks, which must be of size at least length. + */ + void FindLineSeparationsUtf8(const utf8_t* string, size_t length, const char* language, char* breaks); /** - * @brief Helper function for emiting active-descendant-changed event - **/ + * @brief Helper function for emiting active-descendant-changed event. + * + * @param[in] obj The accessible object + * @param[in] child The child of the object + */ void EmitActiveDescendantChanged(Accessible* obj, Accessible* child); /** - * @brief Helper function for emiting state-changed event - **/ - void EmitStateChanged(State state, int newValue1, int newValue2 = 0); + * @brief Helper function for emiting state-changed event. + * + * @param[in] state The accessibility state (SHOWING, HIGHLIGHTED, etc) + * @param[in] newValue Whether the state value is changed to new value or not. + * @param[in] reserved Reserved. (TODO : Currently, this argument is not implemented in dali) + * + * @note The second argument determines which value is depending on State. + * For instance, if the state is PRESSED, newValue means isPressed or isSelected. + * If the state is SHOWING, newValue means isShowing. + */ + void EmitStateChanged(State state, int newValue, int reserved = 0); /** - * @brief Helper function for emiting bounds-changed event - **/ + * @brief Helper function for emiting bounds-changed event. + * + * @param rect The rectangle for changed bounds + */ void EmitBoundsChanged(Rect<> rect); /** - * @brief Emit "showing" event. - * The method inform accessibility clients about "showing" state + * @brief Emits "showing" event. + * The method informs accessibility clients about "showing" state. * - * @param[in] showing flag pointing if object is showing + * @param[in] isShowing The flag pointing if object is showing */ - void EmitShowing(bool showing); + void EmitShowing(bool isShowing); /** - * @brief Emit "visible" event. - * The method inform accessibility clients about "visible" state + * @brief Emits "visible" event. + * The method informs accessibility clients about "visible" state. * - * @param[in] visible flag pointing if object is visible + * @param[in] isVisible The flag pointing if object is visible */ - void EmitVisible(bool visible); + void EmitVisible(bool isVisible); /** - * @brief Emit "highlighted" event. - * The method inform accessibility clients about "highlighted" state + * @brief Emits "highlighted" event. + * The method informs accessibility clients about "highlighted" state. * - * @param[in] set flag pointing if object is highlighted + * @param[in] isHighlighted The flag pointing if object is highlighted */ - void EmitHighlighted(bool set); + void EmitHighlighted(bool isHighlighted); /** - * @brief Emit "focused" event. - * The method inform accessibility clients about "focused" state + * @brief Emits "focused" event. + * The method informs accessibility clients about "focused" state. * - * @param[in] set flag pointing if object is focused + * @param[in] isFocused The flag pointing if object is focused */ - void EmitFocused(bool set); + void EmitFocused(bool isFocused); /** - * @brief Emit "text inserted" event + * @brief Emits "text inserted" event. * - * @param[in] position caret position - * @param[in] length text length - * @param[in] content inserted text + * @param[in] position The cursor position + * @param[in] length The text length + * @param[in] content The inserted text */ void EmitTextInserted(unsigned int position, unsigned int length, const std::string& content); /** - * @brief Emit "text deleted" event + * @brief Emits "text deleted" event. * - * @param[in] position caret position - * @param[in] length text length - * @param[in] content deleted text + * @param[in] position The cursor position + * @param[in] length The text length + * @param[in] content The deleted text */ void EmitTextDeleted(unsigned int position, unsigned int length, const std::string& content); /** - * @brief Emit "caret moved" event + * @brief Emits "cursor moved" event. * - * @param[in] cursorPosition new caret position + * @param[in] cursorPosition The new cursor position */ - void EmitTextCaretMoved(unsigned int cursorPosition); + void EmitTextCursorMoved(unsigned int cursorPosition); /** - * @brief Emit "highlighted" event + * @brief Emits "highlighted" event. * - * @param[in] we enumerated window event - * @param[in] detail1 additional parameter which interpretation depends on chosen event + * @param[in] event The enumerated window event + * @param[in] detail The additional parameter which interpretation depends on chosen event */ - void Emit(WindowEvent we, unsigned int detail1 = 0); + void Emit(WindowEvent event, unsigned int detail = 0); /** - * @brief Emits property-changed event + * @brief Emits property-changed event. + * * @param[in] event Property changed event **/ void Emit(ObjectPropertyChangeEvent event); /** - * @brief Get accessibility name + * @brief Gets accessibility name. * - * @return string with name + * @return The string with name */ virtual std::string GetName() = 0; /** - * @brief Get accessibility description + * @brief Gets accessibility description. * - * @return string with description + * @return The string with description */ virtual std::string GetDescription() = 0; /** - * @brief Get parent + * @brief Gets parent. * - * @return handler to accessibility object + * @return The handler to accessibility object */ virtual Accessible* GetParent() = 0; /** - * @brief Get count of children + * @brief Gets the number of children. * - * @return unsigned integer value + * @return The number of children */ virtual size_t GetChildCount() = 0; /** - * @brief Get collection with all children + * @brief Gets collection with all children. * - * @return collection of accessibility objects + * @return The collection of accessibility objects */ virtual std::vector GetChildren(); /** - * @brief Get nth child + * @brief Gets child of the index. * - * @return accessibility object + * @return The child object */ virtual Accessible* GetChildAtIndex(size_t index) = 0; /** - * @brief Get index that current object has in its parent's children collection + * @brief Gets index that current object has in its parent's children collection. * - * @return unsigned integer index + * @return The index of the current object */ virtual size_t GetIndexInParent() = 0; /** - * @brief Get accessibility role + * @brief Gets accessibility role. * * @return Role enumeration * @@ -529,9 +607,9 @@ public: virtual Role GetRole() = 0; /** - * @brief Get name of accessibility role + * @brief Gets name of accessibility role. * - * @return string with human readable role converted from enumeration + * @return The string with human readable role converted from enumeration * * @see Dali::Accessibility::Role * @see Accessibility::Accessible::GetRole @@ -539,9 +617,9 @@ public: virtual std::string GetRoleName(); /** - * @brief Get localized name of accessibility role + * @brief Gets localized name of accessibility role. * - * @return string with human readable role translated according to current + * @return The string with human readable role translated according to current * translation domain * * @see Dali::Accessibility::Role @@ -553,9 +631,9 @@ public: virtual std::string GetLocalizedRoleName(); /** - * @brief Get accessibility states + * @brief Gets accessibility states. * - * @return collection of states + * @return The collection of states * * @note States class is instatation of ArrayBitset template class * @@ -565,37 +643,39 @@ public: virtual States GetStates() = 0; /** - * @brief Get accessibility attributes + * @brief Gets accessibility attributes. * - * @return map of attributes and their values + * @return The map of attributes and their values */ virtual Attributes GetAttributes() = 0; /** - * @brief Check if this is proxy + * @brief Checks if this is proxy. * * @return True if this is proxy */ virtual bool IsProxy(); /** - * @brief Get unique address on accessibility bus + * @brief Gets unique address on accessibility bus. * - * @return class containing address + * @return The Address class containing address * * @see Dali::Accessibility::Address */ virtual Address GetAddress(); /** - * @brief Get accessibility object, which is "default label" for this object + * @brief Gets accessibility object, which is "default label" for this object. + * + * @return The Accessible object */ virtual Accessible* GetDefaultLabel(); /** - * @brief Depute an object to perform provided gesture + * @brief Deputes an object to perform provided gesture. * - * @param[in] gestureInfo structure describing the gesture + * @param[in] gestureInfo The structure describing the gesture * * @return true on success, false otherwise * @@ -604,53 +684,55 @@ public: virtual bool DoGesture(const GestureInfo& gestureInfo) = 0; /** - * @brief Re-emits selected states of an Accessibility Object + * @brief Re-emits selected states of an Accessibility Object. * - * @param[in] states chosen states to re-emit - * @param[in] doRecursive if true all children of the Accessibility Object will also re-emit the states + * @param[in] states The chosen states to re-emit + * @param[in] isRecursive If true, all children of the Accessibility object will also re-emit the states */ - void NotifyAccessibilityStateChange(Dali::Accessibility::States states, bool doRecursive); + void NotifyAccessibilityStateChange(Dali::Accessibility::States states, bool isRecursive); /** - * @brief Get information about current object and all relations that connects - * it with other accessibility objects + * @brief Gets information about current object and all relations that connects + * it with other accessibility objects. * - * @return iterable collection of Relation objects + * @return The iterable collection of Relation objects * * @see Dali::Accessibility::Relation */ virtual std::vector GetRelationSet() = 0; /** - * @brief Get all implemented interfaces + * @brief Gets all implemented interfaces. * - * @return collection of strings with implemented interfaces + * @return The collection of strings with implemented interfaces */ std::vector GetInterfaces(); /** - * @brief Check if object is on root level + * @brief Checks if object is on root level. + * + * @return Whether object is on root level or not */ - bool GetIsOnRootLevel() const + bool IsOnRootLevel() const { - return isOnRootLevel; + return mIsOnRootLevel; } /** - * @brief The method registers functor resposible for converting Actor into Accessible - * @param functor returning Accessible handle from Actor object + * @brief The method registers functor resposible for converting Actor into Accessible. + * @param functor The returning Accessible handle from Actor object */ static void RegisterControlAccessibilityGetter(std::function functor); /** - * @brief Acquire Accessible object from Actor object + * @brief Acquires Accessible object from Actor object. * * @param[in] actor Actor object - * @param[in] root true, if it's top level object (window) + * @param[in] isRoot True, if it's top level object (window) * - * @return handle to Accessible object + * @return The handle to Accessible object */ - static Accessible* Get(Dali::Actor actor, bool root = false); + static Accessible* Get(Dali::Actor actor, bool isRoot = false); protected: Accessible(); @@ -661,83 +743,114 @@ protected: std::shared_ptr GetBridgeData(); public: + /** + * @brief Gets the highlight actor. + * + * This method is to get the highlight itself. + * @return The highlight actor + */ static Dali::Actor GetHighlightActor(); - static void SetHighlightActor(Dali::Actor actor); + + /** + * @brief Sets the highlight actor. + * + * This method is to set the highlight itself. + * @param[in] actor The highlight actor + */ + static void SetHighlightActor(Dali::Actor actor); + + /** + * @brief Gets the currently highlighted actor. + * + * @return The current highlighted actor + */ static Dali::Actor GetCurrentlyHighlightedActor(); - static void SetCurrentlyHighlightedActor(Dali::Actor); - static void SetObjectRegistry(ObjectRegistry registry); + + /** + * @brief Sets currently highlighted actor. + * + * @param[in] actor The highlight actor + */ + static void SetCurrentlyHighlightedActor(Dali::Actor actor); + + /** + * @brief Sets ObjectRegistry. + * + * @param[in] registry ObjectRegistry instance + */ + static void SetObjectRegistry(ObjectRegistry registry); private: friend class Bridge; - std::weak_ptr bridgeData; - bool isOnRootLevel = false; + std::weak_ptr mBridgeData; + bool mIsOnRootLevel = false; }; /** - * @brief Interface enabling to perform provided actions + * @brief Interface enabling to perform provided actions. */ class Action : public virtual Accessible { public: /** - * @brief Get name of action with given index + * @brief Gets name of action with given index. * - * @param[in] index index of action + * @param[in] index The index of action * - * @return string with name of action + * @return The string with name of action */ virtual std::string GetActionName(size_t index) = 0; /** - * @brief Get translated name of action with given index + * @brief Gets translated name of action with given index. * - * @param[in] index index of action + * @param[in] index The index of action * - * @return string with name of action translated according to current translation domain + * @return The string with name of action translated according to current translation domain * - * @note translation is not supported in this version + * @note The translation is not supported in this version */ virtual std::string GetLocalizedActionName(size_t index) = 0; /** - * @brief Get description of action with given index + * @brief Gets description of action with given index. * - * @param[in] index index of action + * @param[in] index The index of action * - * @return string with description of action + * @return The string with description of action */ virtual std::string GetActionDescription(size_t index) = 0; /** - * @brief Get key code binded to action with given index + * @brief Gets key code binded to action with given index. * - * @param[in] index index of action + * @param[in] index The index of action * - * @return string with key name + * @return The string with key name */ virtual std::string GetActionKeyBinding(size_t index) = 0; /** - * @brief Get number of provided actions + * @brief Gets number of provided actions. * - * @return unsigned integer with number of actions + * @return The number of actions */ virtual size_t GetActionCount() = 0; /** - * @brief Perform an action with given index + * @brief Performs an action with given index. * - * @param index index of action + * @param index The index of action * * @return true on success, false otherwise */ virtual bool DoAction(size_t index) = 0; /** - * @brief Perform an action with given name + * @brief Performs an action with given name. * - * @param name name of action + * @param name The name of action * * @return true on success, false otherwise */ @@ -745,7 +858,7 @@ public: }; /** - * @brief Interface enabling advanced quering of accessibility objects + * @brief Interface enabling advanced quering of accessibility objects. * * @note since all mathods can be implemented inside bridge, * none methods have to be overrided @@ -756,54 +869,57 @@ public: }; /** - * @brief Interface representing objects having screen coordinates + * @brief Interface representing objects having screen coordinates. */ class Component : public virtual Accessible { public: /** - * @brief Get rectangle describing size + * @brief Gets rectangle describing size. * - * @param[in] ctype enumeration with type of coordinate systems + * @param[in] type The enumeration with type of coordinate systems * * @return Rect<> object * * @see Dali::Rect */ - virtual Rect<> GetExtents(CoordType ctype) = 0; + virtual Rect<> GetExtents(CoordinateType type) = 0; /** - * @brief Get layer current object is localized on + * @brief Gets layer current object is localized on. * - * @return enumeration pointing layer + * @return The enumeration pointing layer * * @see Dali::Accessibility::ComponentLayer */ virtual ComponentLayer GetLayer() = 0; /** - * @brief Get value of z-order + * @brief Gets value of z-order. * - * @return value of z-order + * @return The value of z-order + * @remarks MDI means "Multi Document Interface" (https://en.wikipedia.org/wiki/Multiple-document_interface) + * which in short means that many stacked windows can be displayed within a single application. + * In such model, the concept of z-order of UI element became important to deal with element overlapping. */ virtual int16_t GetMdiZOrder() = 0; /** - * @brief Set current object as "focused" + * @brief Sets current object as "focused". * * @return true on success, false otherwise */ virtual bool GrabFocus() = 0; /** - * @brief Get value of alpha channel + * @brief Gets value of alpha channel. * - * @return alpha channel value in range [0.0, 1.0] + * @return The alpha channel value in range [0.0, 1.0] */ virtual double GetAlpha() = 0; /** - * @brief Set current object as "highlighted" + * @brief Sets current object as "highlighted". * * The method assings "highlighted" state, simultaneously removing it * from currently highlighted object. @@ -813,7 +929,7 @@ public: virtual bool GrabHighlight() = 0; /** - * @brief Set current object as "unhighlighted" + * @brief Sets current object as "unhighlighted". * * The method removes "highlighted" state from object. * @@ -824,7 +940,7 @@ public: virtual bool ClearHighlight() = 0; /** - * @brief Check whether object can be scrolled + * @brief Checks whether object can be scrolled. * * @return true if object is scrollable, false otherwise * @@ -833,76 +949,77 @@ public: virtual bool IsScrollable(); /** - * @brief Get Accessible object containing given point + * @brief Gets Accessible object containing given point. * - * @param[in] p two-dimensional point - * @param[in] ctype enumeration with type of coordinate system + * @param[in] point The two-dimensional point + * @param[in] type The enumeration with type of coordinate system * - * @return handle to last child of current object which contains given point + * @return The handle to last child of current object which contains given point * * @see Dali::Accessibility::Point */ - virtual Accessible* GetAccessibleAtPoint(Point p, CoordType ctype); + virtual Accessible* GetAccessibleAtPoint(Point point, CoordinateType type); /** - * @brief Check if current object contains given point + * @brief Checks if current object contains given point. * - * @param[in] p two-dimensional point - * @param[in] ctype enumeration with type of coordinate system + * @param[in] point The two-dimensional point + * @param[in] type The enumeration with type of coordinate system * - * @return handle to Accessible object + * @return True if accessible contains in point, otherwise false. * + * @remarks This method is `Contains` in DBus method. * @see Dali::Accessibility::Point */ - virtual bool Contains(Point p, CoordType ctype); + virtual bool IsAccessibleContainedAtPoint(Point point, CoordinateType type); }; /** - * @brief Interface representing objects which can store numeric value + * @brief Interface representing objects which can store numeric value. */ class Value : public virtual Accessible { public: /** - * @brief Get the lowest possible value + * @brief Gets the lowest possible value. * - * @return double value + * @return The minimum value */ virtual double GetMinimum() = 0; /** - * @brief Get current value + * @brief Gets the current value. * - * @return double value + * @return The current value */ virtual double GetCurrent() = 0; /** - * @brief Get the highest possible value + * @brief Gets the highest possible value. * - * @return double value + * @return The highest value. */ virtual double GetMaximum() = 0; /** - * @brief Set value + * @brief Sets the current value. * - * @param[in] val double value + * @param[in] value The current value to set * * @return true if value could have been assigned, false otherwise */ - virtual bool SetCurrent(double val) = 0; + virtual bool SetCurrent(double value) = 0; /** - * @brief Get the lowest increment that can be distinguished + * @brief Gets the lowest increment that can be distinguished. * - * @return double value + * @return The lowest increment */ virtual double GetMinimumIncrement() = 0; }; /** - * @brief Interface representing objects which can store immutable texts + * @brief Interface representing objects which can store immutable texts. * * @see Dali::Accessibility::EditableText */ @@ -910,43 +1027,46 @@ class DALI_ADAPTOR_API Text : public virtual Accessible { public: /** - * @brief Get stored text in given range + * @brief Gets stored text in given range. * - * @param[in] startOffset index of first character - * @param[in] endOffset index of first character after the last one expected + * @param[in] startOffset The index of first character + * @param[in] endOffset The index of first character after the last one expected * - * @return substring of stored text + * @return The substring of stored text */ virtual std::string GetText(size_t startOffset, size_t endOffset) = 0; /** - * @brief Get number of all stored characters + * @brief Gets number of all stored characters. * - * @return number of characters + * @return The number of characters + * @remarks This method is `CharacterCount` in DBus method. */ virtual size_t GetCharacterCount() = 0; /** - * @brief Get caret offset + * @brief Gets the cursor offset. * - * @return Value of caret offset + * @return Value of cursor offset + * @remarks This method is `CaretOffset` in DBus method. */ - virtual size_t GetCaretOffset() = 0; + virtual size_t GetCursorOffset() = 0; /** - * @brief Set caret offset + * @brief Sets the cursor offset. * - * @param[in] offset Caret offset + * @param[in] offset Cursor offset * * @return True if successful + * @remarks This method is `SetCaretOffset` in DBus method. */ - virtual bool SetCaretOffset(size_t offset) = 0; + virtual bool SetCursorOffset(size_t offset) = 0; /** - * @brief Get substring of stored text truncated in concrete gradation + * @brief Gets substring of stored text truncated in concrete gradation. * - * @param[in] offset position in stored text - * @param[in] boundary enumeration describing text gradation + * @param[in] offset The position in stored text + * @param[in] boundary The enumeration describing text gradation * * @return Range structure containing acquired text and offsets in original string * @@ -955,43 +1075,45 @@ public: virtual Range GetTextAtOffset(size_t offset, TextBoundary boundary) = 0; /** - * @brief Get selected text + * @brief Gets selected text. * - * @param[in] selectionNum selection index + * @param[in] selectionIndex The selection index * @note Currently only one selection (i.e. with index = 0) is supported * * @return Range structure containing acquired text and offsets in original string * + * @remarks This method is `GetSelection` in DBus method. * @see Dali::Accessibility::Range */ - virtual Range GetSelection(size_t selectionNum) = 0; + virtual Range GetRangeOfSelection(size_t selectionIndex) = 0; /** - * @brief Remove selection + * @brief Removes the whole selection. * - * @param[in] selectionNum selection index + * @param[in] selectionIndex The selection index * @note Currently only one selection (i.e. with index = 0) is supported * * @return bool on success, false otherwise */ - virtual bool RemoveSelection(size_t selectionNum) = 0; + virtual bool RemoveSelection(size_t selectionIndex) = 0; /** - * @brief Get selected text + * @brief Sets selected text. * - * @param[in] selectionNum selection index - * @param[in] startOffset index of first character - * @param[in] endOffset index of first character after the last one expected + * @param[in] selectionIndex The selection index + * @param[in] startOffset The index of first character + * @param[in] endOffset The index of first character after the last one expected * * @note Currently only one selection (i.e. with index = 0) is supported * * @return true on success, false otherwise + * @remarks This method is `SetSelection` in DBus method. */ - virtual bool SetSelection(size_t selectionNum, size_t startOffset, size_t endOffset) = 0; + virtual bool SetRangeOfSelection(size_t selectionIndex, size_t startOffset, size_t endOffset) = 0; }; /** - * @brief Interface representing objects which can store editable texts + * @brief Interface representing objects which can store editable texts. * * @note Paste method is entirely implemented inside bridge * @@ -1001,49 +1123,49 @@ class DALI_ADAPTOR_API EditableText : public virtual Accessible { public: /** - * @brief Copy text in range to system clipboard + * @brief Copies text in range to system clipboard. * - * @param[in] startPosition index of first character - * @param[in] endPosition index of first character after the last one expected + * @param[in] startPosition The index of first character + * @param[in] endPosition The index of first character after the last one expected * * @return true on success, false otherwise */ virtual bool CopyText(size_t startPosition, size_t endPosition) = 0; /** - * @brief Cut text in range to system clipboard + * @brief Cuts text in range to system clipboard. * - * @param[in] startPosition index of first character - * @param[in] endPosition index of first character after the last one expected + * @param[in] startPosition The index of first character + * @param[in] endPosition The index of first character after the last one expected * * @return true on success, false otherwise */ virtual bool CutText(size_t startPosition, size_t endPosition) = 0; /** - * @brief Delete text in range + * @brief Deletes text in range. * - * @param[in] startPosition index of first character - * @param[in] endPosition index of first character after the last one expected + * @param[in] startPosition The index of first character + * @param[in] endPosition The index of first character after the last one expected * * @return true on success, false otherwise */ virtual bool DeleteText(size_t startPosition, size_t endPosition) = 0; /** - * @brief Insert text at startPosition + * @brief Inserts text at startPosition. * - * @param[in] startPosition index of first character - * @param[in] text text content + * @param[in] startPosition The index of first character + * @param[in] text The text content * * @return true on success, false otherwise */ virtual bool InsertText(size_t startPosition, std::string text) = 0; /** - * @brief Replace text with content + * @brief Replaces text with content. * - * @param[in] newContents text content + * @param[in] newContents The text content * * @return true on success, false otherwise */ @@ -1051,43 +1173,43 @@ public: }; /** - * @brief Interface representing objects which can store a set of selected items + * @brief Interface representing objects which can store a set of selected items. */ class DALI_ADAPTOR_API Selection : public virtual Accessible { public: /** - * @brief Gets number of selected children + * @brief Gets the number of selected children. * - * @return number of selected children (zero if none) + * @return The number of selected children (zero if none) */ virtual int GetSelectedChildrenCount() = 0; /** - * @brief Gets a specific selected child + * @brief Gets a specific selected child. * - * @param selectedChildIndex index of the selected child + * @param selectedChildIndex The index of the selected child * * @note @p selectedChildIndex refers to the list of selected children, * not the list of all children * - * @return selected child or nullptr if index is invalid + * @return The selected child or nullptr if index is invalid */ virtual Accessible* GetSelectedChild(int selectedChildIndex) = 0; /** - * @brief Selects a child + * @brief Selects a child. * - * @param childIndex index of the child + * @param childIndex The index of the child * * @return true on success, false otherwise */ virtual bool SelectChild(int childIndex) = 0; /** - * @brief Deselects a selected child + * @brief Deselects a selected child. * - * @param selectedChildIndex index of the selected child + * @param selectedChildIndex The index of the selected child * * @note @p selectedChildIndex refers to the list of selected children, * not the list of all children @@ -1099,32 +1221,32 @@ public: virtual bool DeselectSelectedChild(int selectedChildIndex) = 0; /** - * @brief Checks whether a child is selected + * @brief Checks whether a child is selected. * - * @param childIndex index of the child + * @param childIndex The index of the child * * @return true if given child is selected, false otherwise */ virtual bool IsChildSelected(int childIndex) = 0; /** - * @brief Selects all children + * @brief Selects all children. * * @return true on success, false otherwise */ virtual bool SelectAll() = 0; /** - * @brief Deselects all children + * @brief Deselects all children. * * @return true on success, false otherwise */ virtual bool ClearSelection() = 0; /** - * @brief Deselects a child + * @brief Deselects a child. * - * @param childIndex index of the child + * @param childIndex The index of the child. * * @return true on success, false otherwise * @@ -1134,7 +1256,7 @@ public: }; /** - * @brief minimalistic, always empty Accessible object with settable address + * @brief The minimalistic, always empty Accessible object with settable address. * * For those situations, where you want to return address in different bridge * (embedding for example), but the object itself ain't planned to be used otherwise. @@ -1144,72 +1266,86 @@ class DALI_ADAPTOR_API EmptyAccessibleWithAddress : public virtual Accessible { public: EmptyAccessibleWithAddress() = default; + EmptyAccessibleWithAddress(Address address) - : address(std::move(address)) + : mAddress(std::move(address)) { } void SetAddress(Address address) { - this->address = std::move(address); + this->mAddress = std::move(address); } std::string GetName() override { return ""; } + std::string GetDescription() override { return ""; } + Accessible* GetParent() override { return nullptr; } + size_t GetChildCount() override { return 0; } + std::vector GetChildren() override { return {}; } + Accessible* GetChildAtIndex(size_t index) override { throw std::domain_error{"out of bounds index (" + std::to_string(index) + ") - no children"}; } + size_t GetIndexInParent() override { return static_cast(-1); } + Role GetRole() override { return {}; } + std::string GetRoleName() override; - States GetStates() override + + States GetStates() override { return {}; } + Attributes GetAttributes() override { return {}; } + Address GetAddress() override { - return address; + return mAddress; } + bool DoGesture(const GestureInfo& gestureInfo) override { return false; } + std::vector GetRelationSet() override { return {}; } private: - Address address; + Address mAddress; }; } // namespace Accessibility diff --git a/dali/devel-api/adaptor-framework/accessibility.h b/dali/devel-api/adaptor-framework/accessibility.h index a8d0d35..33dc1e1 100644 --- a/dali/devel-api/adaptor-framework/accessibility.h +++ b/dali/devel-api/adaptor-framework/accessibility.h @@ -77,9 +77,9 @@ enum class RelationType : uint32_t /** * @brief Enumeration describing if coordinates are relative to screen or window * @see Accessibility::Component::GetExtents - * @see Accessibility::Component::Contains + * @see Accessibility::Component::IsAccessibleContainedAtPoint */ -enum class CoordType +enum class CoordinateType { SCREEN, ///< Screen. WINDOW ///< Window. @@ -438,32 +438,32 @@ class BitSets { std::array data; - void _set() + void Set() { } - static constexpr bool _accepts() + static constexpr bool Accepts() { return true; } template - static constexpr bool _accepts() + static constexpr bool Accepts() { return std::is_enum::value; } template - static constexpr bool _accepts() + static constexpr bool Accepts() { - return std::is_enum::value && _accepts(); + return std::is_enum::value && Accepts(); } template - void _set(T t, ARGS... args) + void Set(T t, ARGS... args) { (*this)[t] = true; - _set(args...); + Set(args...); } public: @@ -477,12 +477,12 @@ public: BitSets(const BitSets&) = default; BitSets(BitSets&&) = default; - template()>::type* = nullptr> + template()>::type* = nullptr> BitSets(T t, ARGS... args) { for(auto& u : data) u = 0; - _set(t, args...); + Set(t, args...); } explicit BitSets(std::array d) @@ -742,7 +742,7 @@ struct DALI_ADAPTOR_API Size /** * @brief Helper class used to store data related with Accessibility::Text interface * @see Dali::Accessibility::Text::GetTextAtOffset - * @see Dali::Accessibility::Text::GetSelection + * @see Dali::Accessibility::Text::GetRangeOfSelection */ struct DALI_ADAPTOR_API Range { diff --git a/dali/devel-api/adaptor-framework/atspi-accessibility.cpp b/dali/devel-api/adaptor-framework/atspi-accessibility.cpp index 563fe90..64ee565 100644 --- a/dali/devel-api/adaptor-framework/atspi-accessibility.cpp +++ b/dali/devel-api/adaptor-framework/atspi-accessibility.cpp @@ -90,7 +90,7 @@ int Dali::AtspiAccessibility::GetStatus() { if(bridge->GetScreenReaderEnabled()) { - if(bridge->GetIsEnabled()) + if(bridge->IsEnabled()) { return 3; } @@ -101,7 +101,7 @@ int Dali::AtspiAccessibility::GetStatus() } else { - if(bridge->GetIsEnabled()) + if(bridge->IsEnabled()) { return 1; } diff --git a/dali/internal/accessibility/bridge/accessible.cpp b/dali/internal/accessibility/bridge/accessible.cpp index b1bb36e..fb75de8 100644 --- a/dali/internal/accessibility/bridge/accessible.cpp +++ b/dali/internal/accessibility/bridge/accessible.cpp @@ -48,9 +48,9 @@ std::vector Accessible::GetInterfaces() { tmp.push_back(AtspiDbusInterfaceComponent); } - if(auto d = dynamic_cast(this)) + if(auto action = dynamic_cast(this)) { - if(d->GetActionCount() > 0) + if(action->GetActionCount() > 0) { tmp.push_back(AtspiDbusInterfaceAction); } @@ -68,99 +68,101 @@ Accessible::Accessible() Accessible::~Accessible() { - auto b = bridgeData.lock(); - if(b) - b->knownObjects.erase(this); + auto handle = mBridgeData.lock(); + if(handle) + { + handle->mKnownObjects.erase(this); + } } void Accessible::EmitActiveDescendantChanged(Accessible* obj, Accessible* child) { - if(auto b = GetBridgeData()) + if(auto bridgeData = GetBridgeData()) { - b->bridge->EmitActiveDescendantChanged(obj, child); + bridgeData->mBridge->EmitActiveDescendantChanged(obj, child); } } -void Accessible::EmitStateChanged(State state, int newValue1, int newValue2) +void Accessible::EmitStateChanged(State state, int newValue, int reserved) { - if(auto b = GetBridgeData()) + if(auto bridgeData = GetBridgeData()) { - b->bridge->EmitStateChanged(this, state, newValue1, newValue2); + bridgeData->mBridge->EmitStateChanged(this, state, newValue, reserved); } } -void Accessible::EmitShowing(bool showing) +void Accessible::EmitShowing(bool isShowing) { - if(auto b = GetBridgeData()) + if(auto bridgeData = GetBridgeData()) { - b->bridge->EmitStateChanged(this, State::SHOWING, showing ? 1 : 0, 0); + bridgeData->mBridge->EmitStateChanged(this, State::SHOWING, isShowing ? 1 : 0, 0); } } -void Accessible::EmitVisible(bool visible) +void Accessible::EmitVisible(bool isVisible) { - if(auto b = GetBridgeData()) + if(auto bridgeData = GetBridgeData()) { - b->bridge->EmitStateChanged(this, State::VISIBLE, visible ? 1 : 0, 0); + bridgeData->mBridge->EmitStateChanged(this, State::VISIBLE, isVisible ? 1 : 0, 0); } } -void Accessible::EmitHighlighted(bool set) +void Accessible::EmitHighlighted(bool isHighlighted) { - if(auto b = GetBridgeData()) + if(auto bridgeData = GetBridgeData()) { - b->bridge->EmitStateChanged(this, State::HIGHLIGHTED, set ? 1 : 0, 0); + bridgeData->mBridge->EmitStateChanged(this, State::HIGHLIGHTED, isHighlighted ? 1 : 0, 0); } } -void Accessible::EmitFocused(bool set) +void Accessible::EmitFocused(bool isFocused) { - if(auto b = GetBridgeData()) + if(auto bridgeData = GetBridgeData()) { - b->bridge->EmitStateChanged(this, State::FOCUSED, set ? 1 : 0, 0); + bridgeData->mBridge->EmitStateChanged(this, State::FOCUSED, isFocused ? 1 : 0, 0); } } void Accessible::EmitTextInserted(unsigned int position, unsigned int length, const std::string& content) { - if(auto b = GetBridgeData()) + if(auto bridgeData = GetBridgeData()) { - b->bridge->EmitTextChanged(this, TextChangedState::INSERTED, position, length, content); + bridgeData->mBridge->EmitTextChanged(this, TextChangedState::INSERTED, position, length, content); } } void Accessible::EmitTextDeleted(unsigned int position, unsigned int length, const std::string& content) { - if(auto b = GetBridgeData()) + if(auto bridgeData = GetBridgeData()) { - b->bridge->EmitTextChanged(this, TextChangedState::DELETED, position, length, content); + bridgeData->mBridge->EmitTextChanged(this, TextChangedState::DELETED, position, length, content); } } -void Accessible::EmitTextCaretMoved(unsigned int cursorPosition) +void Accessible::EmitTextCursorMoved(unsigned int cursorPosition) { - if(auto b = GetBridgeData()) + if(auto bridgeData = GetBridgeData()) { - b->bridge->EmitCaretMoved(this, cursorPosition); + bridgeData->mBridge->EmitCursorMoved(this, cursorPosition); } } -void Accessible::Emit(WindowEvent we, unsigned int detail1) +void Accessible::Emit(WindowEvent event, unsigned int detail) { - if(auto b = GetBridgeData()) + if(auto bridgeData = GetBridgeData()) { - b->bridge->Emit(this, we, detail1); + bridgeData->mBridge->Emit(this, event, detail); } } -void Accessible::Emit(ObjectPropertyChangeEvent ev) +void Accessible::Emit(ObjectPropertyChangeEvent event) { - if(auto b = GetBridgeData()) + if(auto bridgeData = GetBridgeData()) { - b->bridge->Emit(this, ev); + bridgeData->mBridge->Emit(this, event); } } void Accessible::EmitBoundsChanged(Rect<> rect) { - if(auto b = GetBridgeData()) + if(auto bridgeData = GetBridgeData()) { - b->bridge->EmitBoundsChanged(this, rect); + bridgeData->mBridge->EmitBoundsChanged(this, rect); } } @@ -176,37 +178,39 @@ std::vector Accessible::GetChildren() std::shared_ptr Accessible::GetBridgeData() { - auto b = bridgeData.lock(); - if(!b) + auto handle = mBridgeData.lock(); + if(!handle) { - auto p = Bridge::GetCurrentBridge(); - b = p->data; + auto bridge = Bridge::GetCurrentBridge(); + handle = bridge->mData; } - return b; + return handle; } Address Accessible::GetAddress() { - auto b = bridgeData.lock(); - if(!b) + auto handle = mBridgeData.lock(); + if(!handle) { - b = GetBridgeData(); - if(b) - b->bridge->RegisterOnBridge(this); + handle = GetBridgeData(); + if(handle) + { + handle->mBridge->RegisterOnBridge(this); + } } std::ostringstream tmp; tmp << this; - return {b ? b->busName : "", tmp.str()}; + return {handle ? handle->mBusName : "", tmp.str()}; } -void Bridge::RegisterOnBridge(Accessible* obj) +void Bridge::RegisterOnBridge(Accessible* object) { - assert(!obj->bridgeData.lock() || obj->bridgeData.lock() == data); - if(!obj->bridgeData.lock()) + assert(!object->mBridgeData.lock() || object->mBridgeData.lock() == mData); + if(!object->mBridgeData.lock()) { - assert(data); - data->knownObjects.insert(obj); - obj->bridgeData = data; + assert(mData); + mData->mKnownObjects.insert(object); + object->mBridgeData = mData; } } @@ -220,32 +224,37 @@ Accessible* Accessible::GetDefaultLabel() return this; } -void Accessible::NotifyAccessibilityStateChange(Dali::Accessibility::States states, bool doRecursive) +void Accessible::NotifyAccessibilityStateChange(Dali::Accessibility::States states, bool isRecursive) { - if(auto b = GetBridgeData()) + if(auto data = GetBridgeData()) { - auto s = GetStates() & states; - for(auto i = 0u; i < s.size(); i++) + auto currentState = GetStates() & states; + for(auto i = 0u; i < currentState.size(); i++) { auto index = static_cast(i); - if(s[index]) - b->bridge->EmitStateChanged(this, index, 1, 0); + if(currentState[index]) + { + data->mBridge->EmitStateChanged(this, index, 1, 0); + } } - if(doRecursive) + + if(isRecursive) { auto children = GetChildren(); - for(auto c : children) - c->NotifyAccessibilityStateChange(states, doRecursive); + for(auto iter : children) + { + iter->NotifyAccessibilityStateChange(states, isRecursive); + } } } } -void Accessible::FindWordSeparationsUtf8(const utf8_t* s, size_t length, const char* language, char* breaks) +void Accessible::FindWordSeparationsUtf8(const utf8_t* string, size_t length, const char* language, char* breaks) { - set_wordbreaks_utf8(s, length, language, breaks); + set_wordbreaks_utf8(string, length, language, breaks); } -void Accessible::FindLineSeparationsUtf8(const utf8_t* s, size_t length, const char* language, char* breaks) +void Accessible::FindLineSeparationsUtf8(const utf8_t* string, size_t length, const char* language, char* breaks) { - set_linebreaks_utf8(s, length, language, breaks); + set_linebreaks_utf8(string, length, language, breaks); } diff --git a/dali/internal/accessibility/bridge/bridge-accessible.cpp b/dali/internal/accessibility/bridge/bridge-accessible.cpp index 2ba6212..b28d5f1 100644 --- a/dali/internal/accessibility/bridge/bridge-accessible.cpp +++ b/dali/internal/accessibility/bridge/bridge-accessible.cpp @@ -34,16 +34,16 @@ namespace { bool SortVertically(Component* lhs, Component* rhs) { - auto leftRect = lhs->GetExtents(CoordType::WINDOW); - auto rightRect = rhs->GetExtents(CoordType::WINDOW); + auto leftRect = lhs->GetExtents(CoordinateType::WINDOW); + auto rightRect = rhs->GetExtents(CoordinateType::WINDOW); return leftRect.y < rightRect.y; } bool SortHorizontally(Component* lhs, Component* rhs) { - auto leftRect = lhs->GetExtents(CoordType::WINDOW); - auto rightRect = rhs->GetExtents(CoordType::WINDOW); + auto leftRect = lhs->GetExtents(CoordinateType::WINDOW); + auto rightRect = rhs->GetExtents(CoordinateType::WINDOW); return leftRect.x < rightRect.x; } @@ -52,7 +52,7 @@ std::vector> SplitLines(const std::vector& c { // Find first with non-zero area auto first = std::find_if(children.begin(), children.end(), [](Component* component) -> bool { - auto extents = component->GetExtents(CoordType::WINDOW); + auto extents = component->GetExtents(CoordinateType::WINDOW); return extents.height != 0.0f && extents.width != 0.0f; }); @@ -62,7 +62,7 @@ std::vector> SplitLines(const std::vector& c } std::vector> lines(1); - Dali::Rect<> lineRect = (*first)->GetExtents(CoordType::WINDOW); + Dali::Rect<> lineRect = (*first)->GetExtents(CoordinateType::WINDOW); Dali::Rect<> rect; // Split into lines @@ -70,7 +70,7 @@ std::vector> SplitLines(const std::vector& c { auto child = *it; - rect = child->GetExtents(CoordType::WINDOW); + rect = child->GetExtents(CoordinateType::WINDOW); if(rect.height == 0.0f || rect.width == 0.0f) { // Zero area, ignore @@ -164,11 +164,11 @@ static bool ObjectIsCollapsed(Component* obj) return states[State::EXPANDABLE] && !states[State::EXPANDED]; } -static bool OobjectIsZeroSize(Component* obj) +static bool ObjectIsZeroSize(Component* obj) { if(!obj) return false; - auto extents = obj->GetExtents(CoordType::WINDOW); + auto extents = obj->GetExtents(CoordinateType::WINDOW); return extents.height == 0 || extents.width == 0; } @@ -195,7 +195,7 @@ static bool AcceptObject(Component* obj) } else { - if(OobjectIsZeroSize(obj)) + if(ObjectIsZeroSize(obj)) { return false; } @@ -256,7 +256,7 @@ static std::string objDump(Component* obj) if(!obj) return "nullptr"; std::ostringstream o; - auto e = obj->GetExtents(CoordType::SCREEN); + auto e = obj->GetExtents(CoordinateType::SCREEN); o << "name: " << obj->GetName() << " extent: (" << e.x << ", " << e.y << "), [" << e.width << ", " << e.height << "]"; return o.str(); @@ -286,30 +286,40 @@ static std::string makeIndent(unsigned int maxRecursionDepth) return std::string(GET_NAVIGABLE_AT_POINT_MAX_RECURSION_DEPTH - maxRecursionDepth, ' '); } -Component* BridgeAccessible::CalculateNavigableAccessibleAtPoint(Accessible* root, Point p, CoordType cType, unsigned int maxRecursionDepth) +Component* BridgeAccessible::CalculateNavigableAccessibleAtPoint(Accessible* root, Point p, CoordinateType type, unsigned int maxRecursionDepth) { if(!root || maxRecursionDepth == 0) + { return nullptr; + } + auto root_component = dynamic_cast(root); LOG() << "CalculateNavigableAccessibleAtPoint: checking: " << makeIndent(maxRecursionDepth) << objDump(root_component); - if(root_component && !root_component->Contains(p, cType)) + if(root_component && !root_component->IsAccessibleContainedAtPoint(p, type)) + { return nullptr; + } auto children = root->GetChildren(); for(auto childIt = children.rbegin(); childIt != children.rend(); childIt++) { //check recursively all children first - auto result = CalculateNavigableAccessibleAtPoint(*childIt, p, cType, maxRecursionDepth - 1); + auto result = CalculateNavigableAccessibleAtPoint(*childIt, p, type, maxRecursionDepth - 1); if(result) + { return result; + } } + if(root_component) { //Found a candidate, all its children are already checked auto controledBy = GetObjectInRelation(root_component, RelationType::CONTROLLED_BY); if(!controledBy) + { controledBy = root_component; + } if(controledBy->IsProxy() || AcceptObject(controledBy)) { @@ -445,12 +455,12 @@ DBus::ValueOrError BridgeAccessible::DoGesture(Dali::Accessibility::Gestur return FindSelf()->DoGesture(Dali::Accessibility::GestureInfo{type, xBeg, xEnd, yBeg, yEnd, state, eventTime}); } -DBus::ValueOrError BridgeAccessible::GetNavigableAtPoint(int32_t x, int32_t y, uint32_t coordType) +DBus::ValueOrError BridgeAccessible::GetNavigableAtPoint(int32_t x, int32_t y, uint32_t coordinateType) { Accessible* deputy = nullptr; auto accessible = FindSelf(); - auto cType = static_cast(coordType); - LOG() << "GetNavigableAtPoint: " << x << ", " << y << " type: " << coordType; + auto cType = static_cast(coordinateType); + LOG() << "GetNavigableAtPoint: " << x << ", " << y << " type: " << coordinateType; auto component = CalculateNavigableAccessibleAtPoint(accessible, {x, y}, cType, GET_NAVIGABLE_AT_POINT_MAX_RECURSION_DEPTH); bool recurse = false; if(component) diff --git a/dali/internal/accessibility/bridge/bridge-accessible.h b/dali/internal/accessibility/bridge/bridge-accessible.h index d5bdc52..255dc44 100644 --- a/dali/internal/accessibility/bridge/bridge-accessible.h +++ b/dali/internal/accessibility/bridge/bridge-accessible.h @@ -56,7 +56,7 @@ public: DBus::ValueOrError> GetStates(); DBus::ValueOrError> GetAttributes(); DBus::ValueOrError> GetInterfaces(); - DBus::ValueOrError GetNavigableAtPoint(int32_t x, int32_t y, uint32_t coordType); + DBus::ValueOrError GetNavigableAtPoint(int32_t x, int32_t y, uint32_t coordinateType); DBus::ValueOrError GetNeighbor(std::string root_path, int32_t direction, int32_t search_mode); DBus::ValueOrError> GetDefaultLabelInfo(); using ReadingMaterialType = DBus::ValueOrError< @@ -100,7 +100,7 @@ private: Dali::Accessibility::Accessible* GetCurrentlyHighlighted(); Dali::Accessibility::Accessible* DirectionalDepthFirstSearchTryNonDefunctSibling(bool& all_children_visited, Dali::Accessibility::Accessible* node, Dali::Accessibility::Accessible* start, Dali::Accessibility::Accessible* root, unsigned char forward); Dali::Accessibility::Accessible* GetNextNonDefunctSibling(Dali::Accessibility::Accessible* obj, Dali::Accessibility::Accessible* start, Dali::Accessibility::Accessible* root, unsigned char forward); - Dali::Accessibility::Component* CalculateNavigableAccessibleAtPoint(Dali::Accessibility::Accessible* root, Dali::Accessibility::Point p, Dali::Accessibility::CoordType cType, unsigned int maxRecursionDepth); + Dali::Accessibility::Component* CalculateNavigableAccessibleAtPoint(Dali::Accessibility::Accessible* root, Dali::Accessibility::Point p, Dali::Accessibility::CoordinateType type, unsigned int maxRecursionDepth); Dali::Accessibility::Component* GetObjectInRelation(Dali::Accessibility::Accessible* obj, Dali::Accessibility::RelationType ralationType); }; diff --git a/dali/internal/accessibility/bridge/bridge-base.cpp b/dali/internal/accessibility/bridge/bridge-base.cpp index 3c1ca0b..1e47300 100644 --- a/dali/internal/accessibility/bridge/bridge-base.cpp +++ b/dali/internal/accessibility/bridge/bridge-base.cpp @@ -126,7 +126,7 @@ BridgeBase::ForceUpResult BridgeBase::ForceUp() } con = DBusWrapper::Installed()->eldbus_address_connection_get_impl(std::get<0>(addr)); - data->busName = DBus::getConnectionName(con); + mData->mBusName = DBus::getConnectionName(con); dbusServer = {con}; { @@ -166,7 +166,7 @@ void BridgeBase::ForceDown() const std::string& BridgeBase::GetBusName() const { static std::string empty; - return data ? data->busName : empty; + return mData ? mData->mBusName : empty; } Accessible* BridgeBase::FindByPath(const std::string& name) const @@ -181,22 +181,22 @@ Accessible* BridgeBase::FindByPath(const std::string& name) const } } -void BridgeBase::AddPopup(Accessible* obj) +void BridgeBase::AddPopup(Accessible* object) { - if(std::find(popups.begin(), popups.end(), obj) != popups.end()) + if(std::find(popups.begin(), popups.end(), object) != popups.end()) { return; } - popups.push_back(obj); + popups.push_back(object); if(IsUp()) { - obj->Emit(WindowEvent::ACTIVATE, 0); + object->Emit(WindowEvent::ACTIVATE, 0); } } -void BridgeBase::RemovePopup(Accessible* obj) +void BridgeBase::RemovePopup(Accessible* object) { - auto it = std::find(popups.begin(), popups.end(), obj); + auto it = std::find(popups.begin(), popups.end(), object); if(it == popups.end()) { return; @@ -204,7 +204,7 @@ void BridgeBase::RemovePopup(Accessible* obj) popups.erase(it); if(IsUp()) { - obj->Emit(WindowEvent::DEACTIVATE, 0); + object->Emit(WindowEvent::DEACTIVATE, 0); if(popups.empty()) { application.children.back()->Emit(WindowEvent::ACTIVATE, 0); @@ -246,43 +246,46 @@ Accessible* BridgeBase::Find(const std::string& path) const { return &application; } - void* p; + + void* accessible; std::istringstream tmp{path}; - if(!(tmp >> p)) + if(!(tmp >> accessible)) { throw std::domain_error{"invalid path '" + path + "'"}; } - auto it = data->knownObjects.find(static_cast(p)); - if(it == data->knownObjects.end()) + + auto it = mData->mKnownObjects.find(static_cast(accessible)); + if(it == mData->mKnownObjects.end()) { throw std::domain_error{"unknown object '" + path + "'"}; } - return static_cast(p); + + return static_cast(accessible); } Accessible* BridgeBase::Find(const Address& ptr) const { - assert(ptr.GetBus() == data->busName); + assert(ptr.GetBus() == mData->mBusName); return Find(ptr.GetPath()); } Accessible* BridgeBase::FindSelf() const { - auto pth = DBus::DBusServer::getCurrentObjectPath(); + auto path = DBus::DBusServer::getCurrentObjectPath(); auto size = strlen(AtspiPath); - if(pth.size() <= size) + if(path.size() <= size) { - throw std::domain_error{"invalid path '" + pth + "'"}; + throw std::domain_error{"invalid path '" + path + "'"}; } - if(pth.substr(0, size) != AtspiPath) + if(path.substr(0, size) != AtspiPath) { - throw std::domain_error{"invalid path '" + pth + "'"}; + throw std::domain_error{"invalid path '" + path + "'"}; } - if(pth[size] != '/') + if(path[size] != '/') { - throw std::domain_error{"invalid path '" + pth + "'"}; + throw std::domain_error{"invalid path '" + path + "'"}; } - return Find(StripPrefix(pth)); + return Find(StripPrefix(path)); } void BridgeBase::IdSet(int id) diff --git a/dali/internal/accessibility/bridge/bridge-base.h b/dali/internal/accessibility/bridge/bridge-base.h index ea6c746..fa46045 100644 --- a/dali/internal/accessibility/bridge/bridge-base.h +++ b/dali/internal/accessibility/bridge/bridge-base.h @@ -130,8 +130,8 @@ public: const std::string& GetBusName() const override; void AddTopLevelWindow(Dali::Accessibility::Accessible* window) override; void RemoveTopLevelWindow(Dali::Accessibility::Accessible* window) override; - void AddPopup(Dali::Accessibility::Accessible*) override; - void RemovePopup(Dali::Accessibility::Accessible*) override; + void AddPopup(Dali::Accessibility::Accessible* object) override; + void RemovePopup(Dali::Accessibility::Accessible* object) override; Dali::Accessibility::Accessible* GetApplication() const override { diff --git a/dali/internal/accessibility/bridge/bridge-component.cpp b/dali/internal/accessibility/bridge/bridge-component.cpp index bd85a23..d373bcf 100644 --- a/dali/internal/accessibility/bridge/bridge-component.cpp +++ b/dali/internal/accessibility/bridge/bridge-component.cpp @@ -31,8 +31,12 @@ BridgeComponent::BridgeComponent() void BridgeComponent::RegisterInterfaces() { + // The second arguments below are the names (or signatures) of DBus methods. + // Screen Reader will call the methods with the exact names as specified in the AT-SPI Component interface: + // https://gitlab.gnome.org/GNOME/at-spi2-core/-/blob/master/xml/Component.xml + DBus::DBusInterfaceDescription desc{AtspiDbusInterfaceComponent}; - AddFunctionToInterface(desc, "Contains", &BridgeComponent::Contains); + AddFunctionToInterface(desc, "Contains", &BridgeComponent::IsAccessibleContainedAtPoint); AddFunctionToInterface(desc, "GetAccessibleAtPoint", &BridgeComponent::GetAccessibleAtPoint); AddFunctionToInterface(desc, "GetExtents", &BridgeComponent::GetExtents); AddFunctionToInterface(desc, "GetPosition", &BridgeComponent::GetPosition); @@ -56,27 +60,27 @@ Component* BridgeComponent::FindSelf() const return s2; } -DBus::ValueOrError BridgeComponent::Contains(int32_t x, int32_t y, uint32_t coordType) +DBus::ValueOrError BridgeComponent::IsAccessibleContainedAtPoint(int32_t x, int32_t y, uint32_t coordType) { - return FindSelf()->Contains({x, y}, static_cast(coordType)); + return FindSelf()->IsAccessibleContainedAtPoint({x, y}, static_cast(coordType)); } DBus::ValueOrError BridgeComponent::GetAccessibleAtPoint(int32_t x, int32_t y, uint32_t coordType) { - return FindSelf()->GetAccessibleAtPoint({x, y}, static_cast(coordType)); + return FindSelf()->GetAccessibleAtPoint({x, y}, static_cast(coordType)); } DBus::ValueOrError > BridgeComponent::GetExtents(uint32_t coordType) { - auto p = FindSelf()->GetExtents(static_cast(coordType)); + auto p = FindSelf()->GetExtents(static_cast(coordType)); return std::tuple{p.x, p.y, p.width, p.height}; } DBus::ValueOrError BridgeComponent::GetPosition(uint32_t coordType) { - auto p = FindSelf()->GetExtents(static_cast(coordType)); + auto p = FindSelf()->GetExtents(static_cast(coordType)); return {static_cast(p.x), static_cast(p.y)}; } DBus::ValueOrError BridgeComponent::GetSize(uint32_t coordType) { - auto p = FindSelf()->GetExtents(static_cast(coordType)); + auto p = FindSelf()->GetExtents(static_cast(coordType)); return {static_cast(p.width), static_cast(p.height)}; } DBus::ValueOrError BridgeComponent::GetLayer() diff --git a/dali/internal/accessibility/bridge/bridge-component.h b/dali/internal/accessibility/bridge/bridge-component.h index f073148..4231843 100644 --- a/dali/internal/accessibility/bridge/bridge-component.h +++ b/dali/internal/accessibility/bridge/bridge-component.h @@ -38,7 +38,7 @@ protected: Dali::Accessibility::Component* FindSelf() const; public: - DBus::ValueOrError Contains(int32_t x, int32_t y, uint32_t coordType); + DBus::ValueOrError IsAccessibleContainedAtPoint(int32_t x, int32_t y, uint32_t coordType); DBus::ValueOrError GetAccessibleAtPoint(int32_t x, int32_t y, uint32_t coordType); DBus::ValueOrError > GetExtents(uint32_t coordType); DBus::ValueOrError GetPosition(uint32_t coordType); diff --git a/dali/internal/accessibility/bridge/bridge-impl.cpp b/dali/internal/accessibility/bridge/bridge-impl.cpp index 80b3fb4..11c580e 100644 --- a/dali/internal/accessibility/bridge/bridge-impl.cpp +++ b/dali/internal/accessibility/bridge/bridge-impl.cpp @@ -99,18 +99,18 @@ public: return Consumed::NO; } - unsigned int evType = 0; + unsigned int keyType = 0; switch(type) { case KeyEventType::KEY_PRESSED: { - evType = 0; + keyType = 0; break; } case KeyEventType::KEY_RELEASED: { - evType = 1; + keyType = 1; break; } default: @@ -119,7 +119,7 @@ public: } } auto m = registryClient.method)>("NotifyListenersSync"); - auto result = m.call(std::tuple{evType, 0, static_cast(keyCode), 0, static_cast(timeStamp), keyName, isText ? 1 : 0}); + auto result = m.call(std::tuple{keyType, 0, static_cast(keyCode), 0, static_cast(timeStamp), keyName, isText ? 1 : 0}); if(!result) { LOG() << result.getError().message; @@ -199,14 +199,14 @@ public: void ForceDown() override { - if(data) + if(mData) { - if(data->currentlyHighlightedActor && data->highlightActor) + if(mData->mCurrentlyHighlightedActor && mData->mHighlightActor) { - data->currentlyHighlightedActor.Remove(data->highlightActor); + mData->mCurrentlyHighlightedActor.Remove(mData->mHighlightActor); } - data->currentlyHighlightedActor = {}; - data->highlightActor = {}; + mData->mCurrentlyHighlightedActor = {}; + mData->mHighlightActor = {}; } highlightedActor = {}; highlightClearAction = {}; @@ -218,10 +218,10 @@ public: void Terminate() override { - if(data) + if(mData) { - data->currentlyHighlightedActor = {}; - data->highlightActor = {}; + mData->mCurrentlyHighlightedActor = {}; + mData->mHighlightActor = {}; } ForceDown(); listenOnAtspiEnabledSignalClient = {}; @@ -314,17 +314,19 @@ public: void Initialize() override { - auto req = DBus::DBusClient{A11yDbusName, A11yDbusPath, A11yDbusStatusInterface, DBus::ConnectionType::SESSION}; - auto p = req.property("ScreenReaderEnabled").get(); - if(p) + auto dbusClient = DBus::DBusClient{A11yDbusName, A11yDbusPath, A11yDbusStatusInterface, DBus::ConnectionType::SESSION}; + auto enabled = dbusClient.property("ScreenReaderEnabled").get(); + if(enabled) { - screenReaderEnabled = std::get<0>(p); + screenReaderEnabled = std::get<0>(enabled); } - p = req.property("IsEnabled").get(); - if(p) + + enabled = dbusClient.property("IsEnabled").get(); + if(enabled) { - isEnabled = std::get<0>(p); + isEnabled = std::get<0>(enabled); } + if(screenReaderEnabled || isEnabled) { ForceUp(); @@ -336,7 +338,7 @@ public: return screenReaderEnabled; } - bool GetIsEnabled() + bool IsEnabled() { return isEnabled; } diff --git a/dali/internal/accessibility/bridge/bridge-object.cpp b/dali/internal/accessibility/bridge/bridge-object.cpp index 06bb80d..a0c157d 100644 --- a/dali/internal/accessibility/bridge/bridge-object.cpp +++ b/dali/internal/accessibility/bridge/bridge-object.cpp @@ -111,11 +111,11 @@ void BridgeObject::Emit(Accessible* obj, Dali::Accessibility::ObjectPropertyChan } } -void BridgeObject::Emit(Accessible* obj, WindowEvent we, unsigned int detail1) +void BridgeObject::Emit(Accessible* obj, WindowEvent event, unsigned int detail) { if(!IsUp()) return; const char* name = nullptr; - switch(we) + switch(event) { case WindowEvent::PROPERTY_CHANGE: { @@ -226,14 +226,14 @@ void BridgeObject::Emit(Accessible* obj, WindowEvent we, unsigned int detail1) AtspiDbusInterfaceEventWindow, name, "", - detail1, + detail, 0, {0}, {"", "root"}); } } -void BridgeObject::EmitStateChanged(Accessible* obj, State state, int newValue1, int newValue2) +void BridgeObject::EmitStateChanged(Accessible* obj, State state, int newValue, int reserved) { if(!IsUp()) return; const char* stateName = nullptr; @@ -487,8 +487,8 @@ void BridgeObject::EmitStateChanged(Accessible* obj, State state, int newValue1, AtspiDbusInterfaceEventObject, "StateChanged", stateName, - newValue1, - newValue2, + newValue, + reserved, {0}, {"", "root"}); } @@ -521,7 +521,7 @@ void BridgeObject::EmitBoundsChanged(Accessible* obj, Dali::Rect<> rect) }); } -void BridgeObject::EmitCaretMoved(Accessible* obj, unsigned int cursorPosition) +void BridgeObject::EmitCursorMoved(Accessible* obj, unsigned int cursorPosition) { auto addr = obj->GetAddress(); std::string p = addr ? ATSPI_PREFIX_PATH + addr.GetPath() : ATSPI_NULL_PATH; diff --git a/dali/internal/accessibility/bridge/bridge-object.h b/dali/internal/accessibility/bridge/bridge-object.h index d2b980d..f836c20 100644 --- a/dali/internal/accessibility/bridge/bridge-object.h +++ b/dali/internal/accessibility/bridge/bridge-object.h @@ -38,10 +38,10 @@ protected: DBus::DBusInterfaceDescription::SignalId stateChanged; void EmitActiveDescendantChanged(Dali::Accessibility::Accessible* obj, Dali::Accessibility::Accessible* child) override; - void EmitCaretMoved(Dali::Accessibility::Accessible* obj, unsigned int cursorPosition) override; + void EmitCursorMoved(Dali::Accessibility::Accessible* obj, unsigned int cursorPosition) override; void EmitTextChanged(Dali::Accessibility::Accessible* obj, Dali::Accessibility::TextChangedState state, unsigned int position, unsigned int length, const std::string& content) override; - void EmitStateChanged(Dali::Accessibility::Accessible* obj, Dali::Accessibility::State state, int val1, int val2) override; - void Emit(Dali::Accessibility::Accessible* obj, Dali::Accessibility::WindowEvent we, unsigned int detail1) override; + void EmitStateChanged(Dali::Accessibility::Accessible* obj, Dali::Accessibility::State state, int newValue, int reserved) override; + void Emit(Dali::Accessibility::Accessible* obj, Dali::Accessibility::WindowEvent event, unsigned int detail) override; void Emit(Dali::Accessibility::Accessible* obj, Dali::Accessibility::ObjectPropertyChangeEvent we) override; void EmitBoundsChanged(Dali::Accessibility::Accessible* obj, Dali::Rect<> rect) override; }; diff --git a/dali/internal/accessibility/bridge/bridge-text.cpp b/dali/internal/accessibility/bridge/bridge-text.cpp index 8bcd277..9ca694c 100644 --- a/dali/internal/accessibility/bridge/bridge-text.cpp +++ b/dali/internal/accessibility/bridge/bridge-text.cpp @@ -25,26 +25,32 @@ using namespace Dali::Accessibility; void BridgeText::RegisterInterfaces() { + // The second arguments below are the names (or signatures) of DBus methods. + // Screen Reader will call the methods with the exact names as specified in the AT-SPI Text interface: + // https://gitlab.gnome.org/GNOME/at-spi2-core/-/blob/master/xml/Text.xml + DBus::DBusInterfaceDescription desc{AtspiDbusInterfaceText}; AddFunctionToInterface(desc, "GetText", &BridgeText::GetText); AddGetPropertyToInterface(desc, "CharacterCount", &BridgeText::GetCharacterCount); - AddGetPropertyToInterface(desc, "CaretOffset", &BridgeText::GetCaretOffset); - AddFunctionToInterface(desc, "SetCaretOffset", &BridgeText::SetCaretOffset); + AddGetPropertyToInterface(desc, "CaretOffset", &BridgeText::GetCursorOffset); + AddFunctionToInterface(desc, "SetCaretOffset", &BridgeText::SetCursorOffset); AddFunctionToInterface(desc, "GetTextAtOffset", &BridgeText::GetTextAtOffset); - AddFunctionToInterface(desc, "GetSelection", &BridgeText::GetSelection); - AddFunctionToInterface(desc, "SetSelection", &BridgeText::SetSelection); + AddFunctionToInterface(desc, "GetSelection", &BridgeText::GetRangeOfSelection); + AddFunctionToInterface(desc, "SetSelection", &BridgeText::SetRangeOfSelection); AddFunctionToInterface(desc, "RemoveSelection", &BridgeText::RemoveSelection); dbusServer.addInterface("/", desc, true); } Text* BridgeText::FindSelf() const { - auto s = BridgeBase::FindSelf(); - assert(s); - auto s2 = dynamic_cast(s); - if(!s2) - throw std::domain_error{"object " + s->GetAddress().ToString() + " doesn't have Text interface"}; - return s2; + auto self = BridgeBase::FindSelf(); + assert(self); + auto textObject = dynamic_cast(self); + if(!textObject) + { + throw std::domain_error{"object " + textObject->GetAddress().ToString() + " doesn't have Text interface"}; + } + return textObject; } DBus::ValueOrError BridgeText::GetText(int startOffset, int endOffset) @@ -57,26 +63,26 @@ DBus::ValueOrError BridgeText::GetCharacterCount() return FindSelf()->GetCharacterCount(); } -DBus::ValueOrError BridgeText::GetCaretOffset() +DBus::ValueOrError BridgeText::GetCursorOffset() { - return FindSelf()->GetCaretOffset(); + return FindSelf()->GetCursorOffset(); } -DBus::ValueOrError BridgeText::SetCaretOffset(int32_t offset) +DBus::ValueOrError BridgeText::SetCursorOffset(int32_t offset) { - return FindSelf()->SetCaretOffset(offset); + return FindSelf()->SetCursorOffset(offset); } DBus::ValueOrError BridgeText::GetTextAtOffset(int32_t offset, uint32_t boundary) { - auto r = FindSelf()->GetTextAtOffset(offset, static_cast(boundary)); - return {r.content, static_cast(r.startOffset), static_cast(r.endOffset)}; + auto range = FindSelf()->GetTextAtOffset(offset, static_cast(boundary)); + return {range.content, static_cast(range.startOffset), static_cast(range.endOffset)}; } -DBus::ValueOrError BridgeText::GetSelection(int32_t selectionNum) +DBus::ValueOrError BridgeText::GetRangeOfSelection(int32_t selectionNum) { - auto r = FindSelf()->GetSelection(selectionNum); - return {static_cast(r.startOffset), static_cast(r.endOffset)}; + auto range = FindSelf()->GetRangeOfSelection(selectionNum); + return {static_cast(range.startOffset), static_cast(range.endOffset)}; } DBus::ValueOrError BridgeText::RemoveSelection(int32_t selectionNum) @@ -84,7 +90,7 @@ DBus::ValueOrError BridgeText::RemoveSelection(int32_t selectionNum) return FindSelf()->RemoveSelection(selectionNum); } -DBus::ValueOrError BridgeText::SetSelection(int32_t selectionNum, int32_t startOffset, int32_t endOffset) +DBus::ValueOrError BridgeText::SetRangeOfSelection(int32_t selectionNum, int32_t startOffset, int32_t endOffset) { - return FindSelf()->SetSelection(selectionNum, startOffset, endOffset); + return FindSelf()->SetRangeOfSelection(selectionNum, startOffset, endOffset); } diff --git a/dali/internal/accessibility/bridge/bridge-text.h b/dali/internal/accessibility/bridge/bridge-text.h index 7618b28..86c33d2 100644 --- a/dali/internal/accessibility/bridge/bridge-text.h +++ b/dali/internal/accessibility/bridge/bridge-text.h @@ -33,12 +33,12 @@ protected: public: DBus::ValueOrError GetText(int startOffset, int endOffset); DBus::ValueOrError GetCharacterCount(); - DBus::ValueOrError GetCaretOffset(); - DBus::ValueOrError SetCaretOffset(int32_t offset); + DBus::ValueOrError GetCursorOffset(); + DBus::ValueOrError SetCursorOffset(int32_t offset); DBus::ValueOrError GetTextAtOffset(int32_t offset, uint32_t boundary); - DBus::ValueOrError GetSelection(int32_t selectionNum); + DBus::ValueOrError GetRangeOfSelection(int32_t selectionNum); DBus::ValueOrError RemoveSelection(int32_t selectionNum); - DBus::ValueOrError SetSelection(int32_t selectionNum, int32_t startOffset, int32_t endOffset); + DBus::ValueOrError SetRangeOfSelection(int32_t selectionNum, int32_t startOffset, int32_t endOffset); }; #endif // DALI_INTERNAL_ACCESSIBILITY_BRIDGE_TEXT_H diff --git a/dali/internal/accessibility/bridge/component.cpp b/dali/internal/accessibility/bridge/component.cpp index 7e85d56..a94df86 100644 --- a/dali/internal/accessibility/bridge/component.cpp +++ b/dali/internal/accessibility/bridge/component.cpp @@ -25,19 +25,19 @@ using namespace Dali::Accessibility; -bool Component::Contains(Point p, CoordType ctype) +bool Component::IsAccessibleContainedAtPoint(Point point, Dali::Accessibility::CoordinateType type) { - auto extents = GetExtents(ctype); - return p.x >= extents.x && p.y >= extents.y && p.x <= extents.x + extents.width && p.y <= extents.y + extents.height; + auto extents = GetExtents(type); + return point.x >= extents.x && point.y >= extents.y && point.x <= extents.x + extents.width && point.y <= extents.y + extents.height; } -Accessible* Component::GetAccessibleAtPoint(Point p, CoordType ctype) +Accessible* Component::GetAccessibleAtPoint(Point point, Dali::Accessibility::CoordinateType type) { auto children = GetChildren(); for(auto childIt = children.rbegin(); childIt != children.rend(); childIt++) { auto component = dynamic_cast(*childIt); - if(component && component->Contains(p, ctype)) + if(component && component->IsAccessibleContainedAtPoint(point, type)) { return component; } diff --git a/dali/internal/accessibility/bridge/dummy-atspi.cpp b/dali/internal/accessibility/bridge/dummy-atspi.cpp index 71cdb5e..716a2e7 100644 --- a/dali/internal/accessibility/bridge/dummy-atspi.cpp +++ b/dali/internal/accessibility/bridge/dummy-atspi.cpp @@ -59,12 +59,12 @@ bool Accessibility::Component::IsScrollable() return false; } -bool Accessibility::Component::Contains(Point p, CoordType ctype) +bool Accessibility::Component::IsAccessibleContainedAtPoint(Point point, CoordinateType type) { return false; } -Accessibility::Accessible* Accessibility::Component::GetAccessibleAtPoint(Accessibility::Point p, Accessibility::CoordType ctype) +Accessibility::Accessible* Accessibility::Component::GetAccessibleAtPoint(Accessibility::Point p, Accessibility::CoordinateType ctype) { return nullptr; } @@ -82,7 +82,7 @@ void Accessibility::Bridge::EnableAutoInit() { } -void Accessibility::Accessible::EmitStateChanged(Accessibility::State state, int newValue1, int newValue2) +void Accessibility::Accessible::EmitStateChanged(Accessibility::State state, int newValue, int reserved) { } @@ -118,7 +118,7 @@ void Accessibility::Accessible::EmitTextDeleted(unsigned int position, unsigned { } -void Accessibility::Accessible::EmitTextCaretMoved(unsigned int cursorPosition) +void Accessibility::Accessible::EmitTextCursorMoved(unsigned int cursorPosition) { } @@ -126,15 +126,15 @@ void Accessibility::Accessible::EmitActiveDescendantChanged(Accessibility::Acces { } -void Accessibility::Accessible::FindWordSeparationsUtf8(const utf8_t* s, size_t length, const char* language, char* breaks) +void Accessibility::Accessible::FindWordSeparationsUtf8(const utf8_t* string, size_t length, const char* language, char* breaks) { } -void Accessibility::Accessible::FindLineSeparationsUtf8(const utf8_t* s, size_t length, const char* language, char* breaks) +void Accessibility::Accessible::FindLineSeparationsUtf8(const utf8_t* string, size_t length, const char* language, char* breaks) { } -void Accessibility::Accessible::NotifyAccessibilityStateChange(Accessibility::States states, bool doRecursive) +void Accessibility::Accessible::NotifyAccessibilityStateChange(Accessibility::States states, bool isRecursive) { } diff --git a/dali/internal/accessibility/bridge/dummy-atspi.h b/dali/internal/accessibility/bridge/dummy-atspi.h index bf93553..f48e878 100644 --- a/dali/internal/accessibility/bridge/dummy-atspi.h +++ b/dali/internal/accessibility/bridge/dummy-atspi.h @@ -35,23 +35,23 @@ struct DummyBridge : Dali::Accessibility::Bridge return name; } - void AddTopLevelWindow(Accessibility::Accessible*) override + void AddTopLevelWindow(Accessibility::Accessible* object) override { } - void RemoveTopLevelWindow(Accessibility::Accessible*) override + void RemoveTopLevelWindow(Accessibility::Accessible* object) override { } - void AddPopup(Accessibility::Accessible*) override + void AddPopup(Accessibility::Accessible* object) override { } - void RemovePopup(Accessibility::Accessible*) override + void RemovePopup(Accessibility::Accessible* object) override { } - void SetApplicationName(std::string) override + void SetApplicationName(std::string name) override { } @@ -60,7 +60,7 @@ struct DummyBridge : Dali::Accessibility::Bridge return nullptr; } - Accessibility::Accessible* FindByPath(const std::string& s) const override + Accessibility::Accessible* FindByPath(const std::string& path) const override { return nullptr; } @@ -90,7 +90,7 @@ struct DummyBridge : Dali::Accessibility::Bridge { } - void EmitCaretMoved(Accessibility::Accessible* obj, unsigned int cursorPosition) override + void EmitCursorMoved(Accessibility::Accessible* obj, unsigned int cursorPosition) override { } @@ -102,11 +102,11 @@ struct DummyBridge : Dali::Accessibility::Bridge { } - void EmitStateChanged(Accessibility::Accessible* obj, Accessibility::State state, int val1, int val2) override + void EmitStateChanged(Accessibility::Accessible* obj, Accessibility::State state, int newValue, int reserved) override { } - void Emit(Accessibility::Accessible* obj, Accessibility::WindowEvent we, unsigned int detail1) override + void Emit(Accessibility::Accessible* obj, Accessibility::WindowEvent event, unsigned int detail) override { } @@ -148,7 +148,7 @@ struct DummyBridge : Dali::Accessibility::Bridge return false; } - bool GetIsEnabled() override + bool IsEnabled() override { return false; } diff --git a/dali/internal/adaptor/common/adaptor-impl.cpp b/dali/internal/adaptor/common/adaptor-impl.cpp index c849f93..6338359 100644 --- a/dali/internal/adaptor/common/adaptor-impl.cpp +++ b/dali/internal/adaptor/common/adaptor-impl.cpp @@ -308,7 +308,7 @@ void Adaptor::Initialize(GraphicsFactory& graphicsFactory) auto bridge = Accessibility::Bridge::GetCurrentBridge(); bridge->SetApplicationName(appName); bridge->Initialize(); - Dali::Stage::GetCurrent().KeyEventSignal().Connect(&accessibilityObserver, &AccessibilityObserver::OnAccessibleKeyEvent); + Dali::Stage::GetCurrent().KeyEventSignal().Connect(&mAccessibilityObserver, &AccessibilityObserver::OnAccessibleKeyEvent); } void Adaptor::AccessibilityObserver::OnAccessibleKeyEvent(const Dali::KeyEvent& event) diff --git a/dali/internal/adaptor/common/adaptor-impl.h b/dali/internal/adaptor/common/adaptor-impl.h index b69ad05..331ab9a 100644 --- a/dali/internal/adaptor/common/adaptor-impl.h +++ b/dali/internal/adaptor/common/adaptor-impl.h @@ -691,7 +691,7 @@ private: // Data public: void OnAccessibleKeyEvent(const Dali::KeyEvent& event); }; - AccessibilityObserver accessibilityObserver; + AccessibilityObserver mAccessibilityObserver; public: inline static Adaptor& GetImplementation(Dali::Adaptor& adaptor) diff --git a/dali/internal/graphics/gles-impl/gles-graphics-reflection.cpp b/dali/internal/graphics/gles-impl/gles-graphics-reflection.cpp index 26c4352..05a803d 100644 --- a/dali/internal/graphics/gles-impl/gles-graphics-reflection.cpp +++ b/dali/internal/graphics/gles-impl/gles-graphics-reflection.cpp @@ -558,7 +558,7 @@ const std::vector& Reflection::GetStandaloneUnifor return mStandaloneUniformExtraInfos; } -std::vector Reflection::GetSamplers() const +const std::vector& Reflection::GetSamplers() const { return mUniformOpaques; } diff --git a/dali/internal/graphics/gles-impl/gles-graphics-reflection.h b/dali/internal/graphics/gles-impl/gles-graphics-reflection.h index 3a4a781..06cfba1 100644 --- a/dali/internal/graphics/gles-impl/gles-graphics-reflection.h +++ b/dali/internal/graphics/gles-impl/gles-graphics-reflection.h @@ -186,7 +186,7 @@ public: * * @return A vector of the sampler uniforms */ - [[nodiscard]] std::vector GetSamplers() const override; + const std::vector& GetSamplers() const override; // Language diff --git a/dali/internal/window-system/common/window-impl.cpp b/dali/internal/window-system/common/window-impl.cpp index 0aa1cb1..44f8b66 100644 --- a/dali/internal/window-system/common/window-impl.cpp +++ b/dali/internal/window-system/common/window-impl.cpp @@ -100,8 +100,8 @@ Window::~Window() if(mAdaptor) { auto bridge = Accessibility::Bridge::GetCurrentBridge(); - auto accessible2 = mScene.GetRootLayer(); - auto accessible = Accessibility::Accessible::Get(accessible2); + auto rootLayer = mScene.GetRootLayer(); + auto accessible = Accessibility::Accessible::Get(rootLayer); bridge->RemoveTopLevelWindow(accessible); mAdaptor->RemoveWindow(this); @@ -171,8 +171,8 @@ void Window::OnAdaptorSet(Dali::Adaptor& adaptor) mEventHandler->AddObserver(*this); auto bridge = Accessibility::Bridge::GetCurrentBridge(); - auto v = mScene.GetRootLayer(); - auto accessible = Accessibility::Accessible::Get(v, true); + auto rootLayer = mScene.GetRootLayer(); + auto accessible = Accessibility::Accessible::Get(rootLayer, true); bridge->AddTopLevelWindow(accessible); // If you call the 'Show' before creating the adaptor, the application cannot know the app resource id. @@ -746,15 +746,15 @@ void Window::OnFocusChanged(bool focusIn) mSurface->SetFullSwapNextFrame(); - if(auto b = Dali::Accessibility::Bridge::GetCurrentBridge()) + if(auto bridge = Dali::Accessibility::Bridge::GetCurrentBridge()) { if(focusIn) { - b->ApplicationShown(); + bridge->ApplicationShown(); } else { - b->ApplicationHidden(); + bridge->ApplicationHidden(); } } }