#include <dali/internal/accessibility/bridge/bridge-accessible.h>
// EXTERNAL INCLUDES
+#include <algorithm>
#include <iostream>
//comment out 2 lines below to get more logs
#define GET_NAVIGABLE_AT_POINT_MAX_RECURSION_DEPTH 10000
+namespace {
+
+bool SortVertically(Component* lhs, Component* rhs)
+{
+ 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(CoordinateType::WINDOW);
+ auto rightRect = rhs->GetExtents(CoordinateType::WINDOW);
+
+ return leftRect.x < rightRect.x;
+}
+
+std::vector<std::vector<Component*>> SplitLines(const std::vector<Component*>& children)
+{
+ // Find first with non-zero area
+ auto first = std::find_if(children.begin(), children.end(), [](Component* component) -> bool {
+ auto extents = component->GetExtents(CoordinateType::WINDOW);
+ return extents.height != 0.0f && extents.width != 0.0f;
+ });
+
+ if(first == children.end())
+ {
+ return {};
+ }
+
+ std::vector<std::vector<Component*>> lines(1);
+ Dali::Rect<> lineRect = (*first)->GetExtents(CoordinateType::WINDOW);
+ Dali::Rect<> rect;
+
+ // Split into lines
+ for(auto it = first; it != children.end(); ++it)
+ {
+ auto child = *it;
+
+ rect = child->GetExtents(CoordinateType::WINDOW);
+ if(rect.height == 0.0f || rect.width == 0.0f)
+ {
+ // Zero area, ignore
+ continue;
+ }
+
+ if(lineRect.y + (0.25 * lineRect.height) >= rect.y)
+ {
+ // Same line
+ lines.back().push_back(child);
+ }
+ else
+ {
+ // Start a new line
+ lineRect = rect;
+ lines.emplace_back();
+ lines.back().push_back(child);
+ }
+ }
+
+ return lines;
+}
+
+} // anonymous namespace
+
BridgeAccessible::BridgeAccessible()
{
}
dbusServer.addInterface("/", desc, true);
}
-static bool AcceptObjectCheckRole(Component* obj)
-{
- if(!obj)
- return false;
- switch(obj->GetRole())
- {
- case Role::APPLICATION:
- case Role::FILLER:
- case Role::SCROLL_PANE:
- case Role::SPLIT_PANE:
- case Role::WINDOW:
- case Role::IMAGE:
- case Role::IMAGE_MAP:
- case Role::LIST:
- case Role::ICON:
- case Role::TOOL_BAR:
- case Role::REDUNDANT_OBJECT:
- case Role::COLOR_CHOOSER:
- case Role::TREE_TABLE:
- case Role::PAGE_TAB_LIST:
- case Role::PAGE_TAB:
- case Role::SPIN_BUTTON:
- case Role::INPUT_METHOD_WINDOW:
- case Role::EMBEDDED:
- case Role::INVALID:
- case Role::NOTIFICATION:
- case Role::DATE_EDITOR:
- case Role::TABLE:
- {
- return false;
- }
- default:
- {
- break;
- }
- }
-
- return true;
-}
-
static bool AcceptObjectCheckRelations(Component* obj)
{
auto r = obj->GetRelationSet();
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;
}
const auto states = obj->GetStates();
if(!states[State::VISIBLE])
return false;
- if(!AcceptObjectCheckRole(obj))
- return false;
if(!AcceptObjectCheckRelations(obj))
return false;
if(!states[State::HIGHLIGHTABLE])
}
else
{
- if(OobjectIsZeroSize(obj))
+ if(ObjectIsZeroSize(obj))
{
return false;
}
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();
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<Component*>(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))
{
void BridgeAccessible::SuppressScreenReader(bool suppress)
{
- suppressScreenReader = suppress;
+ suppressScreenReader = suppress;
}
DBus::ValueOrError<bool> BridgeAccessible::DoGesture(Dali::Accessibility::Gesture type, int32_t xBeg, int32_t yBeg, int32_t xEnd, int32_t yEnd, Dali::Accessibility::GestureState state, uint32_t eventTime)
return FindSelf()->DoGesture(Dali::Accessibility::GestureInfo{type, xBeg, xEnd, yBeg, yEnd, state, eventTime});
}
-DBus::ValueOrError<Accessible*, uint8_t, Accessible*> BridgeAccessible::GetNavigableAtPoint(int32_t x, int32_t y, uint32_t coordType)
+DBus::ValueOrError<Accessible*, uint8_t, Accessible*> BridgeAccessible::GetNavigableAtPoint(int32_t x, int32_t y, uint32_t coordinateType)
{
Accessible* deputy = nullptr;
auto accessible = FindSelf();
- auto cType = static_cast<CoordType>(coordType);
- LOG() << "GetNavigableAtPoint: " << x << ", " << y << " type: " << coordType;
+ auto cType = static_cast<CoordinateType>(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)
std::vector<Accessible*> BridgeAccessible::ValidChildrenGet(const std::vector<Accessible*>& children, Accessible* start, Accessible* root)
{
- return children;
+ std::vector<Component*> vec;
+ std::vector<Accessible*> ret;
+
+ for(auto child : children)
+ {
+ if(auto* component = dynamic_cast<Component*>(child); component)
+ {
+ vec.push_back(component);
+ }
+ }
+
+ std::sort(vec.begin(), vec.end(), &SortVertically);
+
+ for(auto& line : SplitLines(vec))
+ {
+ std::sort(line.begin(), line.end(), &SortHorizontally);
+ ret.insert(ret.end(), line.begin(), line.end());
+ }
+
+ return ret;
}
static bool DeputyIs(Accessible* obj)
// if you want more, then you need to change setApplicationRoot to
// add/remove ApplicationRoot and make roots a vector.
auto p = FindSelf()->GetParent();
- assert(p);
+
return p;
}
DBus::ValueOrError<std::vector<Accessible*>> BridgeAccessible::GetChildren()