- Added descriptions of the remaining Bridge classes.
- Updated some bridge codes according to dali coding style.
Change-Id: Icf1c9d5968b3397ee7a869ec2ba312037c5d3c56
Signed-off-by: Seoyeon Kim <seoyeon2.kim@samsung.com>
// INTERNAL INCLUDES
#include <dali/internal/accessibility/bridge/bridge-base.h>
+/**
+ * @brief The BridgeAction class is to correspond with Dali::Accessibility::Action.
+ */
class BridgeAction : public virtual BridgeBase
{
protected:
BridgeAction() = default;
+ /**
+ * @brief Registers Action functions to dbus interfaces.
+ */
void RegisterInterfaces();
+ /**
+ * @brief Returns the Action object of the currently executed DBus method call.
+ *
+ * @return The Action object
+ */
Dali::Accessibility::Action* FindSelf() const;
public:
+ /**
+ * @copydoc Dali::Accessibility::Action::GetActionName()
+ */
DBus::ValueOrError<std::string> GetActionName(int32_t index);
+
+ /**
+ * @copydoc Dali::Accessibility::Action::GetLocalizedActionName()
+ */
DBus::ValueOrError<std::string> GetLocalizedActionName(int32_t index);
+
+ /**
+ * @copydoc Dali::Accessibility::Action::GetActionDescription()
+ */
DBus::ValueOrError<std::string> GetActionDescription(int32_t index);
+
+ /**
+ * @copydoc Dali::Accessibility::Action::GetActionKeyBinding()
+ */
DBus::ValueOrError<std::string> GetActionKeyBinding(int32_t index);
- DBus::ValueOrError<int32_t> GetActionCount();
- DBus::ValueOrError<bool> DoAction(int32_t index);
- DBus::ValueOrError<bool> DoActionName(std::string name);
+
+ /**
+ * @copydoc Dali::Accessibility::Action::GetActionCount()
+ */
+ DBus::ValueOrError<int32_t> GetActionCount();
+
+ /**
+ * @copydoc Dali::Accessibility::Action::DoAction()
+ */
+ DBus::ValueOrError<bool> DoAction(int32_t index);
+
+ /**
+ * @copydoc Dali::Accessibility::Action::DoAction()
+ */
+ DBus::ValueOrError<bool> DoActionName(std::string name);
};
#endif // DALI_INTERNAL_ACCESSIBILITY_BRIDGE_ACTION_H
// INTERNAL INCLUDES
#include <dali/internal/accessibility/bridge/bridge-base.h>
-/*
+/**
+ * @brief The BridgeApplication class is to correspond with Dali::Accessibility::Application.
+ *
* Implementation of org.a11y.atspi.Application interface
*/
-
class BridgeApplication : public virtual BridgeBase
{
protected:
BridgeApplication() = default;
+ /**
+ * @brief Registers Application functions to dbus interfaces.
+ */
void RegisterInterfaces();
+ /**
+ * @brief Returns the Application object of the currently executed DBus method call.
+ *
+ * @return The Application object
+ */
Dali::Accessibility::Application* FindSelf() const;
public:
using namespace Dali::Accessibility;
+namespace
+{
+/**
+ * @brief Enumeration used for quering Accessibility objects.
+ *
+ * Refer to MatchType enumeration.
+ */
+enum class AtspiCollection
+{
+ MATCH_INVALID,
+ MATCH_ALL,
+ MATCH_ANY,
+ MATCH_NONE,
+ MATCH_EMPTY,
+ MATCH_LAST_DEFINED,
+};
+} // anonymous namespace
+
void BridgeCollection::RegisterInterfaces()
{
DBus::DBusInterfaceDescription desc{AtspiDbusInterfaceCollection};
return collectionInterface;
}
-enum
-{
- ATSPI_Collection_MATCH_INVALID,
- ATSPI_Collection_MATCH_ALL,
- ATSPI_Collection_MATCH_ANY,
- ATSPI_Collection_MATCH_NONE,
- ATSPI_Collection_MATCH_EMPTY,
- ATSPI_Collection_MATCH_LAST_DEFINED,
-};
-
+/**
+ * @brief The BridgeCollection::Comparer structure.
+ *
+ * Once the data is de-serialized by DBusWrapper, the data of match rule is passed
+ * to Comparer type which do the comparison against a single accessible object.
+ */
struct BridgeCollection::Comparer
{
using Mode = MatchType;
+ /**
+ * @brief Enumeration to check the object is found first.
+ */
enum class CompareFuncExit
{
FIRST_FOUND,
{
switch(mode)
{
- case ATSPI_Collection_MATCH_INVALID:
+ case static_cast<int32_t>(AtspiCollection::MATCH_INVALID):
{
return Mode::INVALID;
}
- case ATSPI_Collection_MATCH_ALL:
+ case static_cast<int32_t>(AtspiCollection::MATCH_ALL):
{
return Mode::ALL;
}
- case ATSPI_Collection_MATCH_ANY:
+ case static_cast<int32_t>(AtspiCollection::MATCH_ANY):
{
return Mode::ANY;
}
- case ATSPI_Collection_MATCH_NONE:
+ case static_cast<int32_t>(AtspiCollection::MATCH_NONE):
{
return Mode::NONE;
}
- case ATSPI_Collection_MATCH_EMPTY:
+ case static_cast<int32_t>(AtspiCollection::MATCH_EMPTY):
{
return Mode::EMPTY;
}
return Mode::INVALID;
}
+ /**
+ * @brief The ComparerInterfaces structure
+ */
struct ComparerInterfaces
{
- std::unordered_set<std::string> object;
- std::vector<std::string> requested;
- Mode mode = Mode::INVALID;
+ std::unordered_set<std::string> mObject;
+ std::vector<std::string> mRequested;
+ Mode mMode = Mode::INVALID;
ComparerInterfaces(MatchRule* rule)
- : mode(ConvertToMatchType(std::get<Index::InterfacesMatchType>(*rule)))
+ : mMode(ConvertToMatchType(std::get<static_cast<std::size_t>(Index::INTERFACES_MATCH_TYPE)>(*rule)))
{
- requested = {std::get<Index::Interfaces>(*rule).begin(), std::get<Index::Interfaces>(*rule).end()};
+ mRequested = {std::get<static_cast<std::size_t>(Index::INTERFACES)>(*rule).begin(), std::get<static_cast<std::size_t>(Index::INTERFACES)>(*rule).end()};
}
void Update(Accessible* obj)
{
- object.clear();
+ mObject.clear();
for(auto& interface : obj->GetInterfaces())
{
- object.insert(std::move(interface));
+ mObject.insert(std::move(interface));
}
}
- bool RequestEmpty() const
+ bool IsRequestEmpty() const
{
- return requested.empty();
+ return mRequested.empty();
}
- bool ObjectEmpty() const
+ bool IsObjectEmpty() const
{
- return object.empty();
+ return mObject.empty();
}
bool Compare(CompareFuncExit exit)
{
bool foundAny = false;
- for(auto& iname : requested)
+ for(auto& iname : mRequested)
{
- bool found = (object.find(iname) != object.end());
+ bool found = (mObject.find(iname) != mObject.end());
if(found)
{
foundAny = true;
}
}; // ComparerInterfaces struct
+ /**
+ * @brief The ComparerAttributes structure
+ */
struct ComparerAttributes
{
- std::unordered_map<std::string, std::string> requested, object;
- Mode mode = Mode::INVALID;
+ std::unordered_map<std::string, std::string> mRequested;
+ std::unordered_map<std::string, std::string> mObject;
+ Mode mMode = Mode::INVALID;
ComparerAttributes(MatchRule* rule)
- : mode(ConvertToMatchType(std::get<Index::AttributesMatchType>(*rule)))
+ : mMode(ConvertToMatchType(std::get<static_cast<std::size_t>(Index::ATTRIBUTES_MATCH_TYPE)>(*rule)))
{
- requested = std::get<Index::Attributes>(*rule);
+ mRequested = std::get<static_cast<std::size_t>(Index::ATTRIBUTES)>(*rule);
}
void Update(Accessible* obj)
{
- object = obj->GetAttributes();
+ mObject = obj->GetAttributes();
}
- bool RequestEmpty() const
+ bool IsRequestEmpty() const
{
- return requested.empty();
+ return mRequested.empty();
}
- bool ObjectEmpty() const
+ bool IsObjectEmpty() const
{
- return object.empty();
+ return mObject.empty();
}
bool Compare(CompareFuncExit exit)
{
bool foundAny = false;
- for(auto& iname : requested)
+ for(auto& iname : mRequested)
{
- auto it = object.find(iname.first);
- bool found = it != object.end() && iname.second == it->second;
+ auto it = mObject.find(iname.first);
+ bool found = it != mObject.end() && iname.second == it->second;
if(found)
{
foundAny = true;
}
}; // ComparerAttributes struct
+ /**
+ * @brief The ComparerRoles structure
+ */
struct ComparerRoles
{
using Roles = BitSets<4, Role>;
- Roles requested, object;
- Mode mode = Mode::INVALID;
+
+ Roles mRequested;
+ Roles mObject;
+ Mode mMode = Mode::INVALID;
ComparerRoles(MatchRule* rule)
- : mode(ConvertToMatchType(std::get<Index::RolesMatchType>(*rule)))
+ : mMode(ConvertToMatchType(std::get<static_cast<std::size_t>(Index::ROLES_MATCH_TYPE)>(*rule)))
{
- requested = Roles{std::get<Index::Roles>(*rule)};
+ mRequested = Roles{std::get<static_cast<std::size_t>(Index::ROLES)>(*rule)};
}
void Update(Accessible* obj)
{
- object = {};
- object[obj->GetRole()] = true;
- assert(object);
+ mObject = {};
+ mObject[obj->GetRole()] = true;
+ assert(mObject);
}
- bool RequestEmpty() const
+ bool IsRequestEmpty() const
{
- return !requested;
+ return !mRequested;
}
- bool ObjectEmpty() const
+ bool IsObjectEmpty() const
{
- return !object;
+ return !mObject;
}
bool Compare(CompareFuncExit exit)
{
- switch(mode)
+ switch(mMode)
{
case Mode::INVALID:
{
case Mode::EMPTY:
case Mode::ALL:
{
- return requested == (object & requested);
+ return mRequested == (mObject & mRequested);
}
case Mode::ANY:
{
- return bool(object & requested);
+ return bool(mObject & mRequested);
}
case Mode::NONE:
{
- return bool(object & requested);
+ return bool(mObject & mRequested);
}
}
return false;
}
}; // ComparerRoles struct
+ /**
+ * @brief The ComparerStates structure
+ */
struct ComparerStates
{
- States requested, object;
- Mode mode = Mode::INVALID;
+ States mRequested;
+ States mObject;
+ Mode mMode = Mode::INVALID;
ComparerStates(MatchRule* rule)
- : mode(ConvertToMatchType(std::get<Index::StatesMatchType>(*rule)))
+ : mMode(ConvertToMatchType(std::get<static_cast<std::size_t>(Index::STATES_MATCH_TYPE)>(*rule)))
{
- requested = States{std::get<Index::States>(*rule)};
+ mRequested = States{std::get<static_cast<std::size_t>(Index::STATES)>(*rule)};
}
void Update(Accessible* obj)
{
- object = obj->GetStates();
+ mObject = obj->GetStates();
}
- bool RequestEmpty() const
+ bool IsRequestEmpty() const
{
- return !requested;
+ return !mRequested;
}
- bool ObjectEmpty() const
+ bool IsObjectEmpty() const
{
- return !object;
+ return !mObject;
}
bool Compare(CompareFuncExit exit)
{
- switch(mode)
+ switch(mMode)
{
case Mode::INVALID:
{
case Mode::EMPTY:
case Mode::ALL:
{
- return requested == (object & requested);
+ return mRequested == (mObject & mRequested);
}
case Mode::ANY:
{
- return bool(object & requested);
+ return bool(mObject & mRequested);
}
case Mode::NONE:
{
- return bool(object & requested);
+ return bool(mObject & mRequested);
}
}
return false;
template<typename T>
bool CompareFunc(T& cmp, Accessible* obj)
{
- if(cmp.mode == Mode::INVALID)
+ if(cmp.mMode == Mode::INVALID)
{
return true;
}
cmp.Update(obj);
- switch(cmp.mode)
+ switch(cmp.mMode)
{
case Mode::ANY:
{
- if(cmp.RequestEmpty() || cmp.ObjectEmpty())
+ if(cmp.IsRequestEmpty() || cmp.IsObjectEmpty())
{
return false;
}
}
case Mode::ALL:
{
- if(cmp.RequestEmpty())
+ if(cmp.IsRequestEmpty())
{
return true;
}
- if(cmp.ObjectEmpty())
+ if(cmp.IsObjectEmpty())
{
return false;
}
}
case Mode::NONE:
{
- if(cmp.RequestEmpty() || cmp.ObjectEmpty())
+ if(cmp.IsRequestEmpty() || cmp.IsObjectEmpty())
{
return true;
}
}
case Mode::EMPTY:
{
- if(cmp.RequestEmpty() && cmp.ObjectEmpty())
+ if(cmp.IsRequestEmpty() && cmp.IsObjectEmpty())
{
return true;
}
- if(cmp.RequestEmpty() || cmp.ObjectEmpty())
+ if(cmp.IsRequestEmpty() || cmp.IsObjectEmpty())
{
return false;
}
}
}
- switch(cmp.mode)
+ switch(cmp.mMode)
{
case Mode::EMPTY:
case Mode::ALL:
return true;
}
}
- switch(cmp.mode)
+
+ switch(cmp.mMode)
{
case Mode::EMPTY:
case Mode::ALL:
return false;
}
- ComparerInterfaces interface;
- ComparerAttributes attribute;
- ComparerRoles role;
- ComparerStates state;
-
- Comparer(MatchRule* mr)
- : interface(mr),
- attribute(mr),
- role(mr),
- state(mr)
+ Comparer(MatchRule* rule)
+ : mInterface(rule),
+ mAttribute(rule),
+ mRole(rule),
+ mState(rule)
{
}
bool operator()(Accessible* obj)
{
- return CompareFunc(interface, obj) &&
- CompareFunc(attribute, obj) &&
- CompareFunc(role, obj) &&
- CompareFunc(state, obj);
+ return CompareFunc(mInterface, obj) &&
+ CompareFunc(mAttribute, obj) &&
+ CompareFunc(mRole, obj) &&
+ CompareFunc(mState, obj);
}
+
+ ComparerInterfaces mInterface;
+ ComparerAttributes mAttribute;
+ ComparerRoles mRole;
+ ComparerStates mState;
}; // BridgeCollection::Comparer struct
-void BridgeCollection::VisitNodes(Accessible* obj, std::vector<Accessible*>& result, Comparer& cmp, size_t maxCount)
+
+void BridgeCollection::VisitNodes(Accessible* obj, std::vector<Accessible*>& result, Comparer& comparer, size_t maxCount)
{
if(maxCount > 0 && result.size() >= maxCount)
{
return;
}
- if(cmp(obj))
+ if(comparer(obj))
{
result.emplace_back(obj);
}
for(auto i = 0u; i < obj->GetChildCount(); ++i)
{
- VisitNodes(obj->GetChildAtIndex(i), result, cmp, maxCount);
+ VisitNodes(obj->GetChildAtIndex(i), result, comparer, maxCount);
}
}
// INTERNAL INCLUDES
#include <dali/internal/accessibility/bridge/bridge-base.h>
+/**
+ * @brief The BridgeCollection class is to correspond with Dali::Accessibility::Collection.
+ *
+ * Collection interface is designed to allow AT-Clients to query the tree of accessibility objects
+ * exposed by an application with a single dbus call.
+ * The query takes as an input a match rule and returns zero or more matching accessibility objects as a result.
+ *
+ * A match rule can be a combination of at least one of four criteria :
+ * Interface, Attribute, Role, State
+ *
+ * If more than one criteria is specified, the matching rule combines them using "AND" semantics.
+ */
class BridgeCollection : public virtual BridgeBase
{
private:
struct Comparer;
- static void VisitNodes(Dali::Accessibility::Accessible* obj, std::vector<Dali::Accessibility::Accessible*>& result, Comparer& cmp, size_t maxCount);
+
+ /**
+ * @brief Visits all nodes of Accessible object and pushes the object to 'result' container.
+ *
+ * To query the entire tree, the BridgeCollection::Comparer is used inside this method,
+ * which traverse the tree using GetChildAtIndex().
+ * @param[in] obj The Accessible object to search
+ * @param[out] result The vector container for result
+ * @param[in] comparer BridgeCollection::Comparer which do the comparison against a single accessible object
+ * @param[in] maxCount The maximum count of containing Accessible object
+ */
+ static void VisitNodes(Dali::Accessibility::Accessible* obj, std::vector<Dali::Accessibility::Accessible*>& result, Comparer& comparer, size_t maxCount);
protected:
BridgeCollection() = default;
+ /**
+ * @brief Registers Collection functions to dbus interfaces.
+ */
void RegisterInterfaces();
+ /**
+ * @brief Returns the Collection object of the currently executed DBus method call.
+ *
+ * @return The Collection object
+ */
Dali::Accessibility::Collection* FindSelf() const;
public:
+ /**
+ * MatchRule type is a tuple that only carries data of de-serialized parameter from BridgeCollection::GetMatches dbus method.
+ */
using MatchRule = std::tuple<
std::array<int32_t, 2>,
int32_t,
std::vector<std::string>,
int32_t,
bool>;
- struct Index
+
+ /**
+ * @brief Enumeration for Collection Index.
+ */
+ enum class Index
{
- enum
- {
- States,
- StatesMatchType,
- Attributes,
- AttributesMatchType,
- Roles,
- RolesMatchType,
- Interfaces,
- InterfacesMatchType,
- };
+ STATES,
+ STATES_MATCH_TYPE,
+ ATTRIBUTES,
+ ATTRIBUTES_MATCH_TYPE,
+ ROLES,
+ ROLES_MATCH_TYPE,
+ INTERFACES,
+ INTERFACES_MATCH_TYPE,
};
+ /**
+ * @brief Gets the matching Accessible objects with MatchRule.
+ *
+ * @param[in] rule BridgeCollection::MatchRule
+ * @param[in] sortBy SortOrder::CANONICAL or SortOrder::REVERSE_CANONICAL
+ * @param[in] count The maximum number of objects
+ * @param[in] traverse True if it is traverse, otherwise false.
+ * @return The matching Accessible objects
+ */
DBus::ValueOrError<std::vector<Dali::Accessibility::Accessible*> > GetMatches(MatchRule rule, uint32_t sortBy, int32_t count, bool traverse);
};
// INTERNAL INCLUDES
#include <dali/internal/accessibility/bridge/bridge-base.h>
+/**
+ * @brief The BridgeComponent class is to correspond with Dali::Accessibility::Component.
+ */
class BridgeComponent : public virtual BridgeBase
{
protected:
+ /**
+ * @brief Constructor.
+ */
BridgeComponent();
+ /**
+ * @brief Registers Component functions to dbus interfaces.
+ */
void RegisterInterfaces();
+ /**
+ * @brief Returns the Component object of the currently executed DBus method call.
+ *
+ * @return The Component object
+ */
Dali::Accessibility::Component* FindSelf() const;
public:
- DBus::ValueOrError<bool> IsAccessibleContainingPoint(int32_t x, int32_t y, uint32_t coordType);
- DBus::ValueOrError<Dali::Accessibility::Accessible*> GetAccessibleAtPoint(int32_t x, int32_t y, uint32_t coordType);
+ /**
+ * @copydoc Dali::Accessibility::Component::IsAccessibleContainingPoint()
+ */
+ DBus::ValueOrError<bool> IsAccessibleContainingPoint(int32_t x, int32_t y, uint32_t coordType);
+
+ /**
+ * @copydoc Dali::Accessibility::Component::GetAccessibleAtPoint()
+ */
+ DBus::ValueOrError<Dali::Accessibility::Accessible*> GetAccessibleAtPoint(int32_t x, int32_t y, uint32_t coordType);
+
+ /**
+ * @copydoc Dali::Accessibility::Component::GetExtents()
+ */
DBus::ValueOrError<std::tuple<int32_t, int32_t, int32_t, int32_t> > GetExtents(uint32_t coordType);
- DBus::ValueOrError<int32_t, int32_t> GetPosition(uint32_t coordType);
- DBus::ValueOrError<int32_t, int32_t> GetSize(uint32_t coordType);
- DBus::ValueOrError<Dali::Accessibility::ComponentLayer> GetLayer();
- DBus::ValueOrError<double> GetAlpha();
- DBus::ValueOrError<bool> GrabFocus();
- DBus::ValueOrError<bool> GrabHighlight();
- DBus::ValueOrError<bool> ClearHighlight();
- DBus::ValueOrError<int16_t> GetMdiZOrder();
+
+ /**
+ * @brief Gets the position from the given coordinate.
+ * @param[in] coordType The enumeration with type of coordinate systems
+ * @return The X and Y position of rectangle
+ */
+ DBus::ValueOrError<int32_t, int32_t> GetPosition(uint32_t coordType);
+
+ /**
+ * @brief Gets the size from the given coordinate.
+ * @param[in] coordType The enumeration with type of coordinate systems
+ * @return The width and height of rectangle
+ */
+ DBus::ValueOrError<int32_t, int32_t> GetSize(uint32_t coordType);
+
+ /**
+ * @copydoc Dali::Accessibility::Component::GetLayer()
+ */
+ DBus::ValueOrError<Dali::Accessibility::ComponentLayer> GetLayer();
+
+ /**
+ * @copydoc Dali::Accessibility::Component::GetAlpha()
+ */
+ DBus::ValueOrError<double> GetAlpha();
+
+ /**
+ * @copydoc Dali::Accessibility::Component::GrabFocus()
+ */
+ DBus::ValueOrError<bool> GrabFocus();
+
+ /**
+ * @copydoc Dali::Accessibility::Component::GrabHighlight()
+ */
+ DBus::ValueOrError<bool> GrabHighlight();
+
+ /**
+ * @copydoc Dali::Accessibility::Component::ClearHighlight()
+ */
+ DBus::ValueOrError<bool> ClearHighlight();
+
+ /**
+ * @copydoc Dali::Accessibility::Component::GetMdiZOrder()
+ */
+ DBus::ValueOrError<int16_t> GetMdiZOrder();
};
#endif // DALI_INTERNAL_ACCESSIBILITY_BRIDGE_COMPONENT_H
return editableTextInterface;
}
-DBus::ValueOrError<bool> BridgeEditableText::CopyText(int32_t startPos, int32_t endPos)
+DBus::ValueOrError<bool> BridgeEditableText::CopyText(int32_t startPosition, int32_t endPosition)
{
- return FindSelf()->CopyText(startPos, endPos);
+ return FindSelf()->CopyText(startPosition, endPosition);
}
-DBus::ValueOrError<bool> BridgeEditableText::CutText(int32_t startPos, int32_t endPos)
+DBus::ValueOrError<bool> BridgeEditableText::CutText(int32_t startPosition, int32_t endPosition)
{
- return FindSelf()->CutText(startPos, endPos);
+ return FindSelf()->CutText(startPosition, endPosition);
}
-DBus::ValueOrError<bool> BridgeEditableText::DeleteText(int32_t startPos, int32_t endPos)
+DBus::ValueOrError<bool> BridgeEditableText::DeleteText(int32_t startPosition, int32_t endPosition)
{
- return FindSelf()->DeleteText(startPos, endPos);
+ return FindSelf()->DeleteText(startPosition, endPosition);
}
-DBus::ValueOrError<bool> BridgeEditableText::InsertText(int32_t startPos, std::string text, [[maybe_unused]] int32_t length)
+DBus::ValueOrError<bool> BridgeEditableText::InsertText(int32_t startPosition, std::string text, [[maybe_unused]] int32_t length)
{
- return FindSelf()->InsertText(startPos, std::move(text));
+ return FindSelf()->InsertText(startPosition, std::move(text));
}
-DBus::ValueOrError<bool> BridgeEditableText::PasteText(int32_t pos)
+DBus::ValueOrError<bool> BridgeEditableText::PasteText(int32_t position)
{
// auto imfManager = Dali::Internal::Adaptor::ImfManager::Get();
- // imfManager.SetCursorPosition( pos );
+ // imfManager.SetCursorPosition( position );
// auto clipboard = Dali::Internal::Adaptor::Clipboard::Get();
// clipboard.RequestItem();
// return true;
// INTERNAL INCLUDES
#include <dali/internal/accessibility/bridge/bridge-base.h>
+/**
+ * @brief The BridgeEditableText class is to correspond with Dali::Accessibility::EditableText.
+ */
class BridgeEditableText : public virtual BridgeBase
{
protected:
BridgeEditableText() = default;
+ /**
+ * @brief Registers EditableText functions to dbus interfaces.
+ */
void RegisterInterfaces();
+ /**
+ * @brief Returns the EditableText object of the currently executed DBus method call.
+ *
+ * @return The EditableText object
+ */
Dali::Accessibility::EditableText* FindSelf() const;
public:
- DBus::ValueOrError<bool> CopyText(int32_t startPos, int32_t endPos);
- DBus::ValueOrError<bool> CutText(int32_t startPos, int32_t endPos);
- DBus::ValueOrError<bool> DeleteText(int32_t startPos, int32_t endPos);
- DBus::ValueOrError<bool> InsertText(int32_t startPos, std::string text, int32_t length);
- DBus::ValueOrError<bool> PasteText(int32_t pos);
+ /**
+ * @copydoc Dali::Accessibility::EditableText::CopyText()
+ */
+ DBus::ValueOrError<bool> CopyText(int32_t startPosition, int32_t endPosition);
+
+ /**
+ * @copydoc Dali::Accessibility::EditableText::CutText()
+ */
+ DBus::ValueOrError<bool> CutText(int32_t startPosition, int32_t endPosition);
+
+ /**
+ * @copydoc Dali::Accessibility::EditableText::DeleteText()
+ */
+ DBus::ValueOrError<bool> DeleteText(int32_t startPosition, int32_t endPosition);
+
+ /**
+ * @copydoc Dali::Accessibility::EditableText::InsertText()
+ */
+ DBus::ValueOrError<bool> InsertText(int32_t startPosition, std::string text, int32_t length);
+
+ /**
+ * @brief Pastes text at position.
+ *
+ * @param[in] position The text position
+ * @return True on success, false otherwise
+ * @note Currently, this function is not implemented yet.
+ */
+ DBus::ValueOrError<bool> PasteText(int32_t position);
+
+ /**
+ * @copydoc Dali::Accessibility::EditableText::SetTextContents()
+ */
DBus::ValueOrError<bool> SetTextContents(std::string newContents);
};
void BridgeObject::RegisterInterfaces()
{
// DBus::DBusInterfaceDescription desc{ AtspiDbusInterfaceEventObject };
- // stateChanged = addSignal<std::string, int, int, DBus::EldbusVariant<int>, Accessible*>(desc, "StateChanged");
+ // mStateChanged = addSignal<std::string, int, int, DBus::EldbusVariant<int>, Accessible*>(desc, "StateChanged");
// mDbusServer.addInterface("/", desc, true);
}
{"", "root"});
}
-void BridgeObject::Emit(Accessible* obj, Dali::Accessibility::ObjectPropertyChangeEvent ev)
+void BridgeObject::Emit(Accessible* obj, Dali::Accessibility::ObjectPropertyChangeEvent event)
{
if(!IsUp()) return;
const char* name = nullptr;
- switch(ev)
+ switch(event)
{
case ObjectPropertyChangeEvent::NAME:
{
#include <dali/internal/accessibility/bridge/bridge-base.h>
#include <dali/public-api/math/rect.h>
+/**
+ * @brief The BridgeObject class is to correspond with Dali::Accessibility::Bridge.
+ */
class BridgeObject : public virtual BridgeBase
{
protected:
+ /**
+ * @brief Constructor.
+ */
BridgeObject();
+ /**
+ * @brief Registers Bridge functions to dbus interfaces.
+ */
void RegisterInterfaces();
- DBus::DBusInterfaceDescription::SignalId stateChanged;
-
+ /**
+ * @copydoc Dali::Accessibility::Bridge::EmitActiveDescendantChanged()
+ */
void EmitActiveDescendantChanged(Dali::Accessibility::Accessible* obj, Dali::Accessibility::Accessible* child) override;
+
+ /**
+ * @copydoc Dali::Accessibility::Bridge::EmitCursorMoved()
+ */
void EmitCursorMoved(Dali::Accessibility::Accessible* obj, unsigned int cursorPosition) override;
+
+ /**
+ * @copydoc Dali::Accessibility::Bridge::EmitTextChanged()
+ */
void EmitTextChanged(Dali::Accessibility::Accessible* obj, Dali::Accessibility::TextChangedState state, unsigned int position, unsigned int length, const std::string& content) override;
+
+ /**
+ * @copydoc Dali::Accessibility::Bridge::EmitStateChanged()
+ */
void EmitStateChanged(Dali::Accessibility::Accessible* obj, Dali::Accessibility::State state, int newValue, int reserved) override;
+
+ /**
+ * @copydoc Dali::Accessibility::Bridge::Emit()
+ */
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;
+
+ /**
+ * @copydoc Dali::Accessibility::Bridge::Emit()
+ */
+ void Emit(Dali::Accessibility::Accessible* obj, Dali::Accessibility::ObjectPropertyChangeEvent event) override;
+
+ /**
+ * @copydoc Dali::Accessibility::Bridge::EmitBoundsChanged()
+ */
void EmitBoundsChanged(Dali::Accessibility::Accessible* obj, Dali::Rect<> rect) override;
+
+ /**
+ * @copydoc Dali::Accessibility::Bridge::EmitMovedOutOfScreen()
+ */
void EmitMovedOutOfScreen(Dali::Accessibility::Accessible* obj, Dali::Accessibility::ScreenRelativeMoveType type) override;
+
+protected:
+ DBus::DBusInterfaceDescription::SignalId mStateChanged;
};
#endif // DALI_INTERNAL_ACCESSIBILITY_BRIDGE_OBJECT_H
// INTERNAL INCLUDES
#include <dali/internal/accessibility/bridge/bridge-base.h>
+/**
+ * @brief The BridgeSelection class is to correspond with Dali::Accessibility::Selection.
+ */
class BridgeSelection : public virtual BridgeBase
{
protected:
BridgeSelection() = default;
+ /**
+ * @brief Registers Selection functions to dbus interfaces.
+ */
void RegisterInterfaces();
+ /**
+ * @brief Returns the Selection object of the currently executed DBus method call.
+ *
+ * @return The Selection object
+ */
Dali::Accessibility::Selection* FindSelf() const;
public:
+ /**
+ * @copydoc Dali::Accessibility::Selection::GetSelectedChildrenCount()
+ */
DBus::ValueOrError<int32_t> GetSelectedChildrenCount();
+
+ /**
+ * @copydoc Dali::Accessibility::Selection::GetSelectedChild()
+ */
DBus::ValueOrError<Dali::Accessibility::Accessible*> GetSelectedChild(int32_t selectedChildIndex);
+
+ /**
+ * @copydoc Dali::Accessibility::Selection::SelectChild()
+ */
DBus::ValueOrError<bool> SelectChild(int32_t childIndex);
+
+ /**
+ * @copydoc Dali::Accessibility::Selection::DeselectSelectedChild()
+ */
DBus::ValueOrError<bool> DeselectSelectedChild(int32_t selectedChildIndex);
+
+ /**
+ * @copydoc Dali::Accessibility::Selection::IsChildSelected()
+ */
DBus::ValueOrError<bool> IsChildSelected(int32_t childIndex);
+
+ /**
+ * @copydoc Dali::Accessibility::Selection::SelectAll()
+ */
DBus::ValueOrError<bool> SelectAll();
+
+ /**
+ * @copydoc Dali::Accessibility::Selection::ClearSelection()
+ */
DBus::ValueOrError<bool> ClearSelection();
+
+ /**
+ * @copydoc Dali::Accessibility::Selection::DeselectChild()
+ */
DBus::ValueOrError<bool> DeselectChild(int32_t childIndex);
};
return {range.content, static_cast<int>(range.startOffset), static_cast<int>(range.endOffset)};
}
-DBus::ValueOrError<int, int> BridgeText::GetRangeOfSelection(int32_t selectionNum)
+DBus::ValueOrError<int, int> BridgeText::GetRangeOfSelection(int32_t selectionIndex)
{
- auto range = FindSelf()->GetRangeOfSelection(selectionNum);
+ auto range = FindSelf()->GetRangeOfSelection(selectionIndex);
return {static_cast<int>(range.startOffset), static_cast<int>(range.endOffset)};
}
-DBus::ValueOrError<bool> BridgeText::RemoveSelection(int32_t selectionNum)
+DBus::ValueOrError<bool> BridgeText::RemoveSelection(int32_t selectionIndex)
{
- return FindSelf()->RemoveSelection(selectionNum);
+ return FindSelf()->RemoveSelection(selectionIndex);
}
-DBus::ValueOrError<bool> BridgeText::SetRangeOfSelection(int32_t selectionNum, int32_t startOffset, int32_t endOffset)
+DBus::ValueOrError<bool> BridgeText::SetRangeOfSelection(int32_t selectionIndex, int32_t startOffset, int32_t endOffset)
{
- return FindSelf()->SetRangeOfSelection(selectionNum, startOffset, endOffset);
+ return FindSelf()->SetRangeOfSelection(selectionIndex, startOffset, endOffset);
}
// INTERNAL INCLUDES
#include <dali/internal/accessibility/bridge/bridge-base.h>
+/**
+ * @brief The BridgeText class is to correspond with Dali::Accessibility::Text.
+ */
class BridgeText : public virtual BridgeBase
{
protected:
BridgeText() = default;
+ /**
+ * @brief Registers Text functions to dbus interfaces.
+ */
void RegisterInterfaces();
+ /**
+ * @brief Returns the Text object of the currently executed DBus method call.
+ *
+ * @return The Text object
+ */
Dali::Accessibility::Text* FindSelf() const;
public:
- DBus::ValueOrError<std::string> GetText(int startOffset, int endOffset);
- DBus::ValueOrError<int32_t> GetCharacterCount();
- DBus::ValueOrError<int32_t> GetCursorOffset();
- DBus::ValueOrError<bool> SetCursorOffset(int32_t offset);
+ /**
+ * @copydoc Dali::Accessibility::Text::GetText()
+ */
+ DBus::ValueOrError<std::string> GetText(int startOffset, int endOffset);
+
+ /**
+ * @copydoc Dali::Accessibility::Text::GetCharacterCount()
+ */
+ DBus::ValueOrError<int32_t> GetCharacterCount();
+
+ /**
+ * @copydoc Dali::Accessibility::Text::GetCursorOffset()
+ */
+ DBus::ValueOrError<int32_t> GetCursorOffset();
+
+ /**
+ * @copydoc Dali::Accessibility::Text::SetCursorOffset()
+ */
+ DBus::ValueOrError<bool> SetCursorOffset(int32_t offset);
+
+ /**
+ * @copydoc Dali::Accessibility::Text::GetTextAtOffset()
+ */
DBus::ValueOrError<std::string, int, int> GetTextAtOffset(int32_t offset, uint32_t boundary);
- DBus::ValueOrError<int, int> GetRangeOfSelection(int32_t selectionNum);
- DBus::ValueOrError<bool> RemoveSelection(int32_t selectionNum);
- DBus::ValueOrError<bool> SetRangeOfSelection(int32_t selectionNum, int32_t startOffset, int32_t endOffset);
+
+ /**
+ * @copydoc Dali::Accessibility::Text::GetRangeOfSelection()
+ */
+ DBus::ValueOrError<int, int> GetRangeOfSelection(int32_t selectionIndex);
+
+ /**
+ * @copydoc Dali::Accessibility::Text::RemoveSelection()
+ */
+ DBus::ValueOrError<bool> RemoveSelection(int32_t selectionIndex);
+
+ /**
+ * @copydoc Dali::Accessibility::Text::SetRangeOfSelection()
+ */
+ DBus::ValueOrError<bool> SetRangeOfSelection(int32_t selectionIndex, int32_t startOffset, int32_t endOffset);
};
#endif // DALI_INTERNAL_ACCESSIBILITY_BRIDGE_TEXT_H
// INTERNAL INCLUDES
#include <dali/internal/accessibility/bridge/bridge-base.h>
+/**
+ * @brief The BridgeValue class is to correspond with Dali::Accessibility::Value.
+ */
class BridgeValue : public virtual BridgeBase
{
protected:
+ /**
+ * @brief Constructor.
+ */
BridgeValue();
+ /**
+ * @brief Registers Value functions to dbus interfaces.
+ */
void RegisterInterfaces();
+ /**
+ * @brief Returns Value Action object of the currently executed DBus method call.
+ *
+ * @return The Value object
+ */
Dali::Accessibility::Value* FindSelf() const;
public:
+ /**
+ * @copydoc Dali::Accessibility::Value::GetCurrent()
+ */
double GetCurrentValue();
- void SetCurrentValue(double newValue);
+
+ /**
+ * @copydoc Dali::Accessibility::Value::SetCurrent()
+ */
+ void SetCurrentValue(double newValue);
+
+ /**
+ * @copydoc Dali::Accessibility::Value::GetMaximum()
+ */
double GetMaximumValue();
+
+ /**
+ * @copydoc Dali::Accessibility::Value::GetMinimumIncrement()
+ */
double GetMinimumIncrement();
+
+ /**
+ * @copydoc Dali::Accessibility::Value::GetMinimum()
+ */
double GetMinimumValue();
};
projects / platform / core / uifw / dali-adaptor.git / commitdiff