ui/accessibility/ax_node_data.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/accessibility/ax_node_data.h"
   6
   7 #include <set>
   8
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/strings/utf_string_conversions.h"
  12
  13 using base::DoubleToString;
  14 using base::IntToString;
  15
  16 namespace ui {
  17
  18 namespace {
  19
  20 std::string IntVectorToString(const std::vector<int>& items) {
  21   std::string str;
  22   for (size_t i = 0; i < items.size(); ++i) {
  23     if (i > 0)
  24       str += ",";
  25     str += IntToString(items[i]);
  26   }
  27   return str;
  28 }
  29
  30 }  // Anonymous namespace
  31
  32 AXNodeData::AXNodeData()
  33     : id(-1),
  34       role(AX_ROLE_UNKNOWN),
  35       state(0xFFFFFFFF) {
  36 }
  37
  38 AXNodeData::~AXNodeData() {
  39 }
  40
  41 void AXNodeData::AddStringAttribute(
  42     AXStringAttribute attribute, const std::string& value) {
  43   string_attributes.push_back(std::make_pair(attribute, value));
  44 }
  45
  46 void AXNodeData::AddIntAttribute(
  47     AXIntAttribute attribute, int value) {
  48   int_attributes.push_back(std::make_pair(attribute, value));
  49 }
  50
  51 void AXNodeData::AddFloatAttribute(
  52     AXFloatAttribute attribute, float value) {
  53   float_attributes.push_back(std::make_pair(attribute, value));
  54 }
  55
  56 void AXNodeData::AddBoolAttribute(
  57     AXBoolAttribute attribute, bool value) {
  58   bool_attributes.push_back(std::make_pair(attribute, value));
  59 }
  60
  61 void AXNodeData::AddIntListAttribute(
  62     AXIntListAttribute attribute, const std::vector<int32>& value) {
  63   intlist_attributes.push_back(std::make_pair(attribute, value));
  64 }
  65
  66 void AXNodeData::SetName(std::string name) {
  67   string_attributes.push_back(std::make_pair(AX_ATTR_NAME, name));
  68 }
  69
  70 void AXNodeData::SetValue(std::string value) {
  71   string_attributes.push_back(std::make_pair(AX_ATTR_VALUE, value));
  72 }
  73
  74 std::string AXNodeData::ToString() const {
  75   std::string result;
  76
  77   result += "id=" + IntToString(id);
  78   result += " " + ui::ToString(role);
  79
  80   if (state & (1 << ui::AX_STATE_BUSY))
  81     result += " BUSY";
  82   if (state & (1 << ui::AX_STATE_CHECKED))
  83     result += " CHECKED";
  84   if (state & (1 << ui::AX_STATE_COLLAPSED))
  85     result += " COLLAPSED";
  86   if (state & (1 << ui::AX_STATE_EXPANDED))
  87     result += " EXPANDED";
  88   if (state & (1 << ui::AX_STATE_FOCUSABLE))
  89     result += " FOCUSABLE";
  90   if (state & (1 << ui::AX_STATE_FOCUSED))
  91     result += " FOCUSED";
  92   if (state & (1 << ui::AX_STATE_HASPOPUP))
  93     result += " HASPOPUP";
  94   if (state & (1 << ui::AX_STATE_HOVERED))
  95     result += " HOVERED";
  96   if (state & (1 << ui::AX_STATE_INDETERMINATE))
  97     result += " INDETERMINATE";
  98   if (state & (1 << ui::AX_STATE_INVISIBLE))
  99     result += " INVISIBLE";
 100   if (state & (1 << ui::AX_STATE_LINKED))
 101     result += " LINKED";
 102   if (state & (1 << ui::AX_STATE_MULTISELECTABLE))
 103     result += " MULTISELECTABLE";
 104   if (state & (1 << ui::AX_STATE_OFFSCREEN))
 105     result += " OFFSCREEN";
 106   if (state & (1 << ui::AX_STATE_PRESSED))
 107     result += " PRESSED";
 108   if (state & (1 << ui::AX_STATE_PROTECTED))
 109     result += " PROTECTED";
 110   if (state & (1 << ui::AX_STATE_READ_ONLY))
 111     result += " READONLY";
 112   if (state & (1 << ui::AX_STATE_REQUIRED))
 113     result += " REQUIRED";
 114   if (state & (1 << ui::AX_STATE_SELECTABLE))
 115     result += " SELECTABLE";
 116   if (state & (1 << ui::AX_STATE_SELECTED))
 117     result += " SELECTED";
 118   if (state & (1 << ui::AX_STATE_VERTICAL))
 119     result += " VERTICAL";
 120   if (state & (1 << ui::AX_STATE_VISITED))
 121     result += " VISITED";
 122
 123   result += " (" + IntToString(location.x()) + ", " +
 124                    IntToString(location.y()) + ")-(" +
 125                    IntToString(location.width()) + ", " +
 126                    IntToString(location.height()) + ")";
 127
 128   for (size_t i = 0; i < int_attributes.size(); ++i) {
 129     std::string value = IntToString(int_attributes[i].second);
 130     switch (int_attributes[i].first) {
 131       case AX_ATTR_SCROLL_X:
 132         result += " scroll_x=" + value;
 133         break;
 134       case AX_ATTR_SCROLL_X_MIN:
 135         result += " scroll_x_min=" + value;
 136         break;
 137       case AX_ATTR_SCROLL_X_MAX:
 138         result += " scroll_x_max=" + value;
 139         break;
 140       case AX_ATTR_SCROLL_Y:
 141         result += " scroll_y=" + value;
 142         break;
 143       case AX_ATTR_SCROLL_Y_MIN:
 144         result += " scroll_y_min=" + value;
 145         break;
 146       case AX_ATTR_SCROLL_Y_MAX:
 147         result += " scroll_y_max=" + value;
 148         break;
 149       case AX_ATTR_HIERARCHICAL_LEVEL:
 150         result += " level=" + value;
 151         break;
 152       case AX_ATTR_TEXT_SEL_START:
 153         result += " sel_start=" + value;
 154         break;
 155       case AX_ATTR_TEXT_SEL_END:
 156         result += " sel_end=" + value;
 157         break;
 158       case AX_ATTR_TABLE_ROW_COUNT:
 159         result += " rows=" + value;
 160         break;
 161       case AX_ATTR_TABLE_COLUMN_COUNT:
 162         result += " cols=" + value;
 163         break;
 164       case AX_ATTR_TABLE_CELL_COLUMN_INDEX:
 165         result += " col=" + value;
 166         break;
 167       case AX_ATTR_TABLE_CELL_ROW_INDEX:
 168         result += " row=" + value;
 169         break;
 170       case AX_ATTR_TABLE_CELL_COLUMN_SPAN:
 171         result += " colspan=" + value;
 172         break;
 173       case AX_ATTR_TABLE_CELL_ROW_SPAN:
 174         result += " rowspan=" + value;
 175         break;
 176       case AX_ATTR_TABLE_COLUMN_HEADER_ID:
 177         result += " column_header_id=" + value;
 178         break;
 179       case AX_ATTR_TABLE_COLUMN_INDEX:
 180         result += " column_index=" + value;
 181         break;
 182       case AX_ATTR_TABLE_HEADER_ID:
 183         result += " header_id=" + value;
 184         break;
 185       case AX_ATTR_TABLE_ROW_HEADER_ID:
 186         result += " row_header_id=" + value;
 187         break;
 188       case AX_ATTR_TABLE_ROW_INDEX:
 189         result += " row_index=" + value;
 190         break;
 191       case AX_ATTR_TITLE_UI_ELEMENT:
 192         result += " title_elem=" + value;
 193         break;
 194       case AX_ATTR_ACTIVEDESCENDANT_ID:
 195         result += " activedescendant=" + value;
 196         break;
 197       case AX_ATTR_COLOR_VALUE_RED:
 198         result += " color_value_red=" + value;
 199         break;
 200       case AX_ATTR_COLOR_VALUE_GREEN:
 201         result += " color_value_green=" + value;
 202         break;
 203       case AX_ATTR_COLOR_VALUE_BLUE:
 204         result += " color_value_blue=" + value;
 205         break;
 206       case AX_ATTR_TEXT_DIRECTION:
 207         switch (int_attributes[i].second) {
 208           case AX_TEXT_DIRECTION_LR:
 209           default:
 210             result += " text_direction=lr";
 211             break;
 212           case AX_TEXT_DIRECTION_RL:
 213             result += " text_direction=rl";
 214             break;
 215           case AX_TEXT_DIRECTION_TB:
 216             result += " text_direction=tb";
 217             break;
 218           case AX_TEXT_DIRECTION_BT:
 219             result += " text_direction=bt";
 220             break;
 221         }
 222         break;
 223       case AX_INT_ATTRIBUTE_NONE:
 224         break;
 225     }
 226   }
 227
 228   for (size_t i = 0; i < string_attributes.size(); ++i) {
 229     std::string value = string_attributes[i].second;
 230     switch (string_attributes[i].first) {
 231       case AX_ATTR_DOC_URL:
 232         result += " doc_url=" + value;
 233         break;
 234       case AX_ATTR_DOC_TITLE:
 235         result += " doc_title=" + value;
 236         break;
 237       case AX_ATTR_DOC_MIMETYPE:
 238         result += " doc_mimetype=" + value;
 239         break;
 240       case AX_ATTR_DOC_DOCTYPE:
 241         result += " doc_doctype=" + value;
 242         break;
 243       case AX_ATTR_ACCESS_KEY:
 244         result += " access_key=" + value;
 245         break;
 246       case AX_ATTR_ACTION:
 247         result += " action=" + value;
 248         break;
 249       case AX_ATTR_DESCRIPTION:
 250         result += " description=" + value;
 251         break;
 252       case AX_ATTR_DISPLAY:
 253         result += " display=" + value;
 254         break;
 255       case AX_ATTR_HELP:
 256         result += " help=" + value;
 257         break;
 258       case AX_ATTR_HTML_TAG:
 259         result += " html_tag=" + value;
 260         break;
 261       case AX_ATTR_LIVE_RELEVANT:
 262         result += " relevant=" + value;
 263         break;
 264       case AX_ATTR_LIVE_STATUS:
 265         result += " live=" + value;
 266         break;
 267       case AX_ATTR_CONTAINER_LIVE_RELEVANT:
 268         result += " container_relevant=" + value;
 269         break;
 270       case AX_ATTR_CONTAINER_LIVE_STATUS:
 271         result += " container_live=" + value;
 272         break;
 273       case AX_ATTR_ROLE:
 274         result += " role=" + value;
 275         break;
 276       case AX_ATTR_SHORTCUT:
 277         result += " shortcut=" + value;
 278         break;
 279       case AX_ATTR_URL:
 280         result += " url=" + value;
 281         break;
 282       case AX_ATTR_NAME:
 283         result += " name=" + value;
 284         break;
 285       case AX_ATTR_VALUE:
 286         result += " value=" + value;
 287         break;
 288       case AX_STRING_ATTRIBUTE_NONE:
 289         break;
 290     }
 291   }
 292
 293   for (size_t i = 0; i < float_attributes.size(); ++i) {
 294     std::string value = DoubleToString(float_attributes[i].second);
 295     switch (float_attributes[i].first) {
 296       case AX_ATTR_DOC_LOADING_PROGRESS:
 297         result += " doc_progress=" + value;
 298         break;
 299       case AX_ATTR_VALUE_FOR_RANGE:
 300         result += " value_for_range=" + value;
 301         break;
 302       case AX_ATTR_MAX_VALUE_FOR_RANGE:
 303         result += " max_value=" + value;
 304         break;
 305       case AX_ATTR_MIN_VALUE_FOR_RANGE:
 306         result += " min_value=" + value;
 307         break;
 308       case AX_FLOAT_ATTRIBUTE_NONE:
 309         break;
 310     }
 311   }
 312
 313   for (size_t i = 0; i < bool_attributes.size(); ++i) {
 314     std::string value = bool_attributes[i].second ? "true" : "false";
 315     switch (bool_attributes[i].first) {
 316       case AX_ATTR_DOC_LOADED:
 317         result += " doc_loaded=" + value;
 318         break;
 319       case AX_ATTR_BUTTON_MIXED:
 320         result += " mixed=" + value;
 321         break;
 322       case AX_ATTR_LIVE_ATOMIC:
 323         result += " atomic=" + value;
 324         break;
 325       case AX_ATTR_LIVE_BUSY:
 326         result += " busy=" + value;
 327         break;
 328       case AX_ATTR_CONTAINER_LIVE_ATOMIC:
 329         result += " container_atomic=" + value;
 330         break;
 331       case AX_ATTR_CONTAINER_LIVE_BUSY:
 332         result += " container_busy=" + value;
 333         break;
 334       case AX_ATTR_ARIA_READONLY:
 335         result += " aria_readonly=" + value;
 336         break;
 337       case AX_ATTR_CAN_SET_VALUE:
 338         result += " can_set_value=" + value;
 339         break;
 340       case AX_ATTR_UPDATE_LOCATION_ONLY:
 341         result += " update_location_only=" + value;
 342         break;
 343       case AX_ATTR_CANVAS_HAS_FALLBACK:
 344         result += " has_fallback=" + value;
 345         break;
 346       case AX_BOOL_ATTRIBUTE_NONE:
 347         break;
 348     }
 349   }
 350
 351   for (size_t i = 0; i < intlist_attributes.size(); ++i) {
 352     const std::vector<int32>& values = intlist_attributes[i].second;
 353     switch (intlist_attributes[i].first) {
 354       case AX_ATTR_INDIRECT_CHILD_IDS:
 355         result += " indirect_child_ids=" + IntVectorToString(values);
 356         break;
 357       case AX_ATTR_CONTROLS_IDS:
 358         result += " controls_ids=" + IntVectorToString(values);
 359         break;
 360       case AX_ATTR_DESCRIBEDBY_IDS:
 361         result += " describedby_ids=" + IntVectorToString(values);
 362         break;
 363       case AX_ATTR_FLOWTO_IDS:
 364         result += " flowto_ids=" + IntVectorToString(values);
 365         break;
 366       case AX_ATTR_LABELLEDBY_IDS:
 367         result += " labelledby_ids=" + IntVectorToString(values);
 368         break;
 369       case AX_ATTR_OWNS_IDS:
 370         result += " owns_ids=" + IntVectorToString(values);
 371         break;
 372       case AX_ATTR_LINE_BREAKS:
 373         result += " line_breaks=" + IntVectorToString(values);
 374         break;
 375       case AX_ATTR_CELL_IDS:
 376         result += " cell_ids=" + IntVectorToString(values);
 377         break;
 378       case AX_ATTR_UNIQUE_CELL_IDS:
 379         result += " unique_cell_ids=" + IntVectorToString(values);
 380         break;
 381       case AX_ATTR_CHARACTER_OFFSETS:
 382         result += " character_offsets=" + IntVectorToString(values);
 383         break;
 384       case AX_ATTR_WORD_STARTS:
 385         result += " word_starts=" + IntVectorToString(values);
 386         break;
 387       case AX_ATTR_WORD_ENDS:
 388         result += " word_ends=" + IntVectorToString(values);
 389         break;
 390       case AX_INT_LIST_ATTRIBUTE_NONE:
 391         break;
 392     }
 393   }
 394
 395   if (!child_ids.empty())
 396     result += " child_ids=" + IntVectorToString(child_ids);
 397
 398   return result;
 399 }
 400
 401 }  // namespace ui