Tools/DumpRenderTree/chromium/AccessibilityUIElement.cpp

   1 /*
   2  * Copyright (C) 2010 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "AccessibilityUIElement.h"
  33
  34 #include "WebAccessibilityObject.h"
  35 #include "WebCString.h"
  36 #include "WebRect.h"
  37 #include "WebString.h"
  38 #include <wtf/Assertions.h>
  39
  40 using namespace WebKit;
  41 using namespace std;
  42
  43 // Map role value to string, matching Safari/Mac platform implementation to
  44 // avoid rebaselining layout tests.
  45 static string roleToString(WebAccessibilityRole role)
  46 {
  47     string result = "AXRole: AX";
  48     switch (role) {
  49     case WebAccessibilityRoleButton:
  50         return result.append("Button");
  51     case WebAccessibilityRoleRadioButton:
  52         return result.append("RadioButton");
  53     case WebAccessibilityRoleCheckBox:
  54         return result.append("CheckBox");
  55     case WebAccessibilityRoleSlider:
  56         return result.append("Slider");
  57     case WebAccessibilityRoleTabGroup:
  58         return result.append("TabGroup");
  59     case WebAccessibilityRoleTextField:
  60         return result.append("TextField");
  61     case WebAccessibilityRoleStaticText:
  62         return result.append("StaticText");
  63     case WebAccessibilityRoleTextArea:
  64         return result.append("TextArea");
  65     case WebAccessibilityRoleScrollArea:
  66         return result.append("ScrollArea");
  67     case WebAccessibilityRolePopUpButton:
  68         return result.append("PopUpButton");
  69     case WebAccessibilityRoleMenuButton:
  70         return result.append("MenuButton");
  71     case WebAccessibilityRoleTable:
  72         return result.append("Table");
  73     case WebAccessibilityRoleApplication:
  74         return result.append("Application");
  75     case WebAccessibilityRoleGroup:
  76         return result.append("Group");
  77     case WebAccessibilityRoleRadioGroup:
  78         return result.append("RadioGroup");
  79     case WebAccessibilityRoleList:
  80         return result.append("List");
  81     case WebAccessibilityRoleScrollBar:
  82         return result.append("ScrollBar");
  83     case WebAccessibilityRoleValueIndicator:
  84         return result.append("ValueIndicator");
  85     case WebAccessibilityRoleImage:
  86         return result.append("Image");
  87     case WebAccessibilityRoleMenuBar:
  88         return result.append("MenuBar");
  89     case WebAccessibilityRoleMenu:
  90         return result.append("Menu");
  91     case WebAccessibilityRoleMenuItem:
  92         return result.append("MenuItem");
  93     case WebAccessibilityRoleColumn:
  94         return result.append("Column");
  95     case WebAccessibilityRoleRow:
  96         return result.append("Row");
  97     case WebAccessibilityRoleToolbar:
  98         return result.append("Toolbar");
  99     case WebAccessibilityRoleBusyIndicator:
 100         return result.append("BusyIndicator");
 101     case WebAccessibilityRoleProgressIndicator:
 102         return result.append("ProgressIndicator");
 103     case WebAccessibilityRoleWindow:
 104         return result.append("Window");
 105     case WebAccessibilityRoleDrawer:
 106         return result.append("Drawer");
 107     case WebAccessibilityRoleSystemWide:
 108         return result.append("SystemWide");
 109     case WebAccessibilityRoleOutline:
 110         return result.append("Outline");
 111     case WebAccessibilityRoleIncrementor:
 112         return result.append("Incrementor");
 113     case WebAccessibilityRoleBrowser:
 114         return result.append("Browser");
 115     case WebAccessibilityRoleComboBox:
 116         return result.append("ComboBox");
 117     case WebAccessibilityRoleSplitGroup:
 118         return result.append("SplitGroup");
 119     case WebAccessibilityRoleSplitter:
 120         return result.append("Splitter");
 121     case WebAccessibilityRoleColorWell:
 122         return result.append("ColorWell");
 123     case WebAccessibilityRoleGrowArea:
 124         return result.append("GrowArea");
 125     case WebAccessibilityRoleSheet:
 126         return result.append("Sheet");
 127     case WebAccessibilityRoleHelpTag:
 128         return result.append("HelpTag");
 129     case WebAccessibilityRoleMatte:
 130         return result.append("Matte");
 131     case WebAccessibilityRoleRuler:
 132         return result.append("Ruler");
 133     case WebAccessibilityRoleRulerMarker:
 134         return result.append("RulerMarker");
 135     case WebAccessibilityRoleLink:
 136         return result.append("Link");
 137     case WebAccessibilityRoleDisclosureTriangle:
 138         return result.append("DisclosureTriangle");
 139     case WebAccessibilityRoleGrid:
 140         return result.append("Grid");
 141     case WebAccessibilityRoleCell:
 142         return result.append("Cell");
 143     case WebAccessibilityRoleColumnHeader:
 144         return result.append("ColumnHeader");
 145     case WebAccessibilityRoleRowHeader:
 146         return result.append("RowHeader");
 147     case WebAccessibilityRoleWebCoreLink:
 148         // Maps to Link role.
 149         return result.append("Link");
 150     case WebAccessibilityRoleImageMapLink:
 151         return result.append("ImageMapLink");
 152     case WebAccessibilityRoleImageMap:
 153         return result.append("ImageMap");
 154     case WebAccessibilityRoleListMarker:
 155         return result.append("ListMarker");
 156     case WebAccessibilityRoleWebArea:
 157         return result.append("WebArea");
 158     case WebAccessibilityRoleHeading:
 159         return result.append("Heading");
 160     case WebAccessibilityRoleListBox:
 161         return result.append("ListBox");
 162     case WebAccessibilityRoleListBoxOption:
 163         return result.append("ListBoxOption");
 164     case WebAccessibilityRoleTableHeaderContainer:
 165         return result.append("TableHeaderContainer");
 166     case WebAccessibilityRoleDefinitionListTerm:
 167         return result.append("DefinitionListTerm");
 168     case WebAccessibilityRoleDefinitionListDefinition:
 169         return result.append("DefinitionListDefinition");
 170     case WebAccessibilityRoleAnnotation:
 171         return result.append("Annotation");
 172     case WebAccessibilityRoleSliderThumb:
 173         return result.append("SliderThumb");
 174     case WebAccessibilityRoleLandmarkApplication:
 175         return result.append("LandmarkApplication");
 176     case WebAccessibilityRoleLandmarkBanner:
 177         return result.append("LandmarkBanner");
 178     case WebAccessibilityRoleLandmarkComplementary:
 179         return result.append("LandmarkComplementary");
 180     case WebAccessibilityRoleLandmarkContentInfo:
 181         return result.append("LandmarkContentInfo");
 182     case WebAccessibilityRoleLandmarkMain:
 183         return result.append("LandmarkMain");
 184     case WebAccessibilityRoleLandmarkNavigation:
 185         return result.append("LandmarkNavigation");
 186     case WebAccessibilityRoleLandmarkSearch:
 187         return result.append("LandmarkSearch");
 188     case WebAccessibilityRoleApplicationLog:
 189         return result.append("ApplicationLog");
 190     case WebAccessibilityRoleApplicationMarquee:
 191         return result.append("ApplicationMarquee");
 192     case WebAccessibilityRoleApplicationStatus:
 193         return result.append("ApplicationStatus");
 194     case WebAccessibilityRoleApplicationTimer:
 195         return result.append("ApplicationTimer");
 196     case WebAccessibilityRoleDocument:
 197         return result.append("Document");
 198     case WebAccessibilityRoleDocumentArticle:
 199         return result.append("DocumentArticle");
 200     case WebAccessibilityRoleDocumentNote:
 201         return result.append("DocumentNote");
 202     case WebAccessibilityRoleDocumentRegion:
 203         return result.append("DocumentRegion");
 204     case WebAccessibilityRoleUserInterfaceTooltip:
 205         return result.append("UserInterfaceTooltip");
 206     default:
 207         // Also matches WebAccessibilityRoleUnknown.
 208         return result.append("Unknown");
 209     }
 210 }
 211
 212 string getDescription(const WebAccessibilityObject& object)
 213 {
 214     string description = object.accessibilityDescription().utf8();
 215     return description.insert(0, "AXDescription: ");
 216 }
 217
 218 string getHelpText(const WebAccessibilityObject& object)
 219 {
 220     string helpText = object.helpText().utf8();
 221     return helpText.insert(0, "AXHelp: ");
 222 }
 223
 224 string getStringValue(const WebAccessibilityObject& object)
 225 {
 226     string value = object.stringValue().utf8();
 227     return value.insert(0, "AXValue: ");
 228 }
 229
 230 string getRole(const WebAccessibilityObject& object)
 231 {
 232     return roleToString(object.roleValue());
 233 }
 234
 235 string getTitle(const WebAccessibilityObject& object)
 236 {
 237     string title = object.title().utf8();
 238     return title.insert(0, "AXTitle: ");
 239 }
 240
 241 string getOrientation(const WebAccessibilityObject& object)
 242 {
 243     if (object.isVertical())
 244         return "AXOrientation: AXVerticalOrientation";
 245
 246     return "AXOrientation: AXHorizontalOrientation";
 247 }
 248
 249 string getAttributes(const WebAccessibilityObject& object)
 250 {
 251     // FIXME: Concatenate all attributes of the AccessibilityObject.
 252     string attributes(getTitle(object));
 253     attributes.append("\n");
 254     attributes.append(getRole(object));
 255     attributes.append("\n");
 256     attributes.append(getDescription(object));
 257     return attributes;
 258 }
 259
 260
 261 // Collects attributes into a string, delimited by dashes. Used by all methods
 262 // that output lists of attributes: attributesOfLinkedUIElementsCallback,
 263 // AttributesOfChildrenCallback, etc.
 264 class AttributesCollector {
 265 public:
 266     void collectAttributes(const WebAccessibilityObject& object)
 267     {
 268         m_attributes.append("\n------------\n");
 269         m_attributes.append(getAttributes(object));
 270     }
 271
 272     string attributes() const { return m_attributes; }
 273
 274 private:
 275     string m_attributes;
 276 };
 277
 278 AccessibilityUIElement::AccessibilityUIElement(const WebAccessibilityObject& object, Factory* factory)
 279     : m_accessibilityObject(object)
 280     , m_factory(factory)
 281 {
 282
 283     ASSERT(factory);
 284
 285     //
 286     // Properties
 287     //
 288
 289     bindProperty("role", &AccessibilityUIElement::roleGetterCallback);
 290     bindProperty("title", &AccessibilityUIElement::titleGetterCallback);
 291     bindProperty("description", &AccessibilityUIElement::descriptionGetterCallback);
 292     bindProperty("helpText", &AccessibilityUIElement::helpTextGetterCallback);
 293     bindProperty("stringValue", &AccessibilityUIElement::stringValueGetterCallback);
 294     bindProperty("x", &AccessibilityUIElement::xGetterCallback);
 295     bindProperty("y", &AccessibilityUIElement::yGetterCallback);
 296     bindProperty("width", &AccessibilityUIElement::widthGetterCallback);
 297     bindProperty("height", &AccessibilityUIElement::heightGetterCallback);
 298     bindProperty("intValue", &AccessibilityUIElement::intValueGetterCallback);
 299     bindProperty("minValue", &AccessibilityUIElement::minValueGetterCallback);
 300     bindProperty("maxValue", &AccessibilityUIElement::maxValueGetterCallback);
 301     bindProperty("childrenCount", &AccessibilityUIElement::childrenCountGetterCallback);
 302     bindProperty("insertionPointLineNumber", &AccessibilityUIElement::insertionPointLineNumberGetterCallback);
 303     bindProperty("selectedTextRange", &AccessibilityUIElement::selectedTextRangeGetterCallback);
 304     bindProperty("isEnabled", &AccessibilityUIElement::isEnabledGetterCallback);
 305     bindProperty("isRequired", &AccessibilityUIElement::isRequiredGetterCallback);
 306     bindProperty("isFocused", &AccessibilityUIElement::isFocusedGetterCallback);
 307     bindProperty("isFocusable", &AccessibilityUIElement::isFocusableGetterCallback);
 308     bindProperty("isSelected", &AccessibilityUIElement::isSelectedGetterCallback);
 309     bindProperty("isSelectable", &AccessibilityUIElement::isSelectableGetterCallback);
 310     bindProperty("isMultiSelectable", &AccessibilityUIElement::isMultiSelectableGetterCallback);
 311     bindProperty("isSelectedOptionActive", &AccessibilityUIElement::isSelectedOptionActiveGetterCallback);
 312     bindProperty("isExpanded", &AccessibilityUIElement::isExpandedGetterCallback);
 313     bindProperty("isChecked", &AccessibilityUIElement::isCheckedGetterCallback);
 314     bindProperty("isVisible", &AccessibilityUIElement::isVisibleGetterCallback);
 315     bindProperty("isOffScreen", &AccessibilityUIElement::isOffScreenGetterCallback);
 316     bindProperty("isCollapsed", &AccessibilityUIElement::isCollapsedGetterCallback);
 317     bindProperty("hasPopup", &AccessibilityUIElement::hasPopupGetterCallback);
 318     bindProperty("isValid", &AccessibilityUIElement::isValidGetterCallback);
 319     bindProperty("orientation", &AccessibilityUIElement::orientationGetterCallback);
 320
 321     //
 322     // Methods
 323     //
 324
 325     bindMethod("allAttributes", &AccessibilityUIElement::allAttributesCallback);
 326     bindMethod("attributesOfLinkedUIElements", &AccessibilityUIElement::attributesOfLinkedUIElementsCallback);
 327     bindMethod("attributesOfDocumentLinks", &AccessibilityUIElement::attributesOfDocumentLinksCallback);
 328     bindMethod("attributesOfChildren", &AccessibilityUIElement::attributesOfChildrenCallback);
 329     bindMethod("lineForIndex", &AccessibilityUIElement::lineForIndexCallback);
 330     bindMethod("boundsForRange", &AccessibilityUIElement::boundsForRangeCallback);
 331     bindMethod("stringForRange", &AccessibilityUIElement::stringForRangeCallback);
 332     bindMethod("childAtIndex", &AccessibilityUIElement::childAtIndexCallback);
 333     bindMethod("elementAtPoint", &AccessibilityUIElement::elementAtPointCallback);
 334     bindMethod("attributesOfColumnHeaders", &AccessibilityUIElement::attributesOfColumnHeadersCallback);
 335     bindMethod("attributesOfRowHeaders", &AccessibilityUIElement::attributesOfRowHeadersCallback);
 336     bindMethod("attributesOfColumns", &AccessibilityUIElement::attributesOfColumnsCallback);
 337     bindMethod("attributesOfRows", &AccessibilityUIElement::attributesOfRowsCallback);
 338     bindMethod("attributesOfVisibleCells", &AccessibilityUIElement::attributesOfVisibleCellsCallback);
 339     bindMethod("attributesOfHeader", &AccessibilityUIElement::attributesOfHeaderCallback);
 340     bindMethod("indexInTable", &AccessibilityUIElement::indexInTableCallback);
 341     bindMethod("rowIndexRange", &AccessibilityUIElement::rowIndexRangeCallback);
 342     bindMethod("columnIndexRange", &AccessibilityUIElement::columnIndexRangeCallback);
 343     bindMethod("cellForColumnAndRow", &AccessibilityUIElement::cellForColumnAndRowCallback);
 344     bindMethod("titleUIElement", &AccessibilityUIElement::titleUIElementCallback);
 345     bindMethod("setSelectedTextRange", &AccessibilityUIElement::setSelectedTextRangeCallback);
 346     bindMethod("attributeValue", &AccessibilityUIElement::attributeValueCallback);
 347     bindMethod("isAttributeSettable", &AccessibilityUIElement::isAttributeSettableCallback);
 348     bindMethod("isActionSupported", &AccessibilityUIElement::isActionSupportedCallback);
 349     bindMethod("parentElement", &AccessibilityUIElement::parentElementCallback);
 350     bindMethod("increment", &AccessibilityUIElement::incrementCallback);
 351     bindMethod("decrement", &AccessibilityUIElement::decrementCallback);
 352     bindMethod("showMenu", &AccessibilityUIElement::showMenuCallback);
 353     bindMethod("press", &AccessibilityUIElement::pressCallback);
 354     bindMethod("isEqual", &AccessibilityUIElement::isEqualCallback);
 355     bindMethod("addNotificationListener", &AccessibilityUIElement::addNotificationListenerCallback);
 356     bindMethod("removeNotificationListener", &AccessibilityUIElement::removeNotificationListenerCallback);
 357     bindMethod("takeFocus", &AccessibilityUIElement::takeFocusCallback);
 358
 359     bindFallbackMethod(&AccessibilityUIElement::fallbackCallback);
 360 }
 361
 362 AccessibilityUIElement* AccessibilityUIElement::getChildAtIndex(unsigned index)
 363 {
 364     return m_factory->getOrCreate(accessibilityObject().childAt(index));
 365 }
 366
 367 bool AccessibilityUIElement::isEqual(const WebKit::WebAccessibilityObject& other)
 368 {
 369     return accessibilityObject().equals(other);
 370 }
 371
 372 void AccessibilityUIElement::notificationReceived(const char* notificationName)
 373 {
 374     size_t callbackCount = m_notificationCallbacks.size();
 375     for (size_t i = 0; i < callbackCount; i++) {
 376         CppVariant notificationNameArgument;
 377         notificationNameArgument.set(notificationName);
 378         CppVariant invokeResult;
 379         m_notificationCallbacks[i].invokeDefault(&notificationNameArgument, 1, invokeResult);
 380     }
 381 }
 382
 383 //
 384 // Properties
 385 //
 386
 387 void AccessibilityUIElement::roleGetterCallback(CppVariant* result)
 388 {
 389     result->set(getRole(accessibilityObject()));
 390 }
 391
 392 void AccessibilityUIElement::titleGetterCallback(CppVariant* result)
 393 {
 394     result->set(getTitle(accessibilityObject()));
 395 }
 396
 397 void AccessibilityUIElement::descriptionGetterCallback(CppVariant* result)
 398 {
 399     result->set(getDescription(accessibilityObject()));
 400 }
 401
 402 void AccessibilityUIElement::helpTextGetterCallback(CppVariant* result)
 403 {
 404     result->set(getHelpText(accessibilityObject()));
 405 }
 406
 407 void AccessibilityUIElement::stringValueGetterCallback(CppVariant* result)
 408 {
 409     result->set(getStringValue(accessibilityObject()));
 410 }
 411
 412 void AccessibilityUIElement::xGetterCallback(CppVariant* result)
 413 {
 414     result->set(accessibilityObject().boundingBoxRect().x);
 415 }
 416
 417 void AccessibilityUIElement::yGetterCallback(CppVariant* result)
 418 {
 419     result->set(accessibilityObject().boundingBoxRect().y);
 420 }
 421
 422 void AccessibilityUIElement::widthGetterCallback(CppVariant* result)
 423 {
 424     result->set(accessibilityObject().boundingBoxRect().width);
 425 }
 426
 427 void AccessibilityUIElement::heightGetterCallback(CppVariant* result)
 428 {
 429     result->set(accessibilityObject().boundingBoxRect().height);
 430 }
 431
 432 void AccessibilityUIElement::intValueGetterCallback(CppVariant* result)
 433 {
 434     result->set(accessibilityObject().valueForRange());
 435 }
 436
 437 void AccessibilityUIElement::minValueGetterCallback(CppVariant* result)
 438 {
 439     result->set(accessibilityObject().minValueForRange());
 440 }
 441
 442 void AccessibilityUIElement::maxValueGetterCallback(CppVariant* result)
 443 {
 444     result->set(accessibilityObject().maxValueForRange());
 445 }
 446
 447 void AccessibilityUIElement::childrenCountGetterCallback(CppVariant* result)
 448 {
 449     int count = 1; // Root object always has only one child, the WebView.
 450     if (!isRoot())
 451         count = accessibilityObject().childCount();
 452     result->set(count);
 453 }
 454
 455 void AccessibilityUIElement::insertionPointLineNumberGetterCallback(CppVariant* result)
 456 {
 457     WebVector<int> lineBreaks;
 458     accessibilityObject().lineBreaks(lineBreaks);
 459     int cursor = accessibilityObject().selectionEnd();
 460     int line = 0;
 461     while (line < static_cast<int>(lineBreaks.size()) && lineBreaks[line] <= cursor)
 462         line++;
 463     result->set(line);
 464 }
 465
 466 void AccessibilityUIElement::selectedTextRangeGetterCallback(CppVariant* result)
 467 {
 468     // FIXME: Implement this.
 469     result->set(std::string());
 470 }
 471
 472 void AccessibilityUIElement::isEnabledGetterCallback(CppVariant* result)
 473 {
 474     result->set(accessibilityObject().isEnabled());
 475 }
 476
 477 void AccessibilityUIElement::isRequiredGetterCallback(CppVariant* result)
 478 {
 479     result->set(accessibilityObject().isRequired());
 480 }
 481
 482 void AccessibilityUIElement::isFocusedGetterCallback(CppVariant* result)
 483 {
 484     result->set(accessibilityObject().isFocused());
 485 }
 486
 487 void AccessibilityUIElement::isFocusableGetterCallback(CppVariant* result)
 488 {
 489     result->set(accessibilityObject().canSetFocusAttribute());
 490 }
 491
 492 void AccessibilityUIElement::isSelectedGetterCallback(CppVariant* result)
 493 {
 494     result->set(accessibilityObject().isSelected());
 495 }
 496
 497 void AccessibilityUIElement::isSelectableGetterCallback(CppVariant* result)
 498 {
 499     result->set(accessibilityObject().canSetSelectedAttribute());
 500 }
 501
 502 void AccessibilityUIElement::isMultiSelectableGetterCallback(CppVariant* result)
 503 {
 504     result->set(accessibilityObject().isMultiSelectable());
 505 }
 506
 507 void AccessibilityUIElement::isSelectedOptionActiveGetterCallback(CppVariant* result)
 508 {
 509     result->set(accessibilityObject().isSelectedOptionActive());
 510 }
 511
 512 void AccessibilityUIElement::isExpandedGetterCallback(CppVariant* result)
 513 {
 514     result->set(!accessibilityObject().isCollapsed());
 515 }
 516
 517 void AccessibilityUIElement::isCheckedGetterCallback(CppVariant* result)
 518 {
 519     result->set(accessibilityObject().isChecked());
 520 }
 521
 522 void AccessibilityUIElement::isVisibleGetterCallback(CppVariant* result)
 523 {
 524     result->set(accessibilityObject().isVisible());
 525 }
 526
 527 void AccessibilityUIElement::isOffScreenGetterCallback(CppVariant* result)
 528 {
 529     result->set(accessibilityObject().isOffScreen());
 530 }
 531
 532 void AccessibilityUIElement::isCollapsedGetterCallback(CppVariant* result)
 533 {
 534     result->set(accessibilityObject().isCollapsed());
 535 }
 536
 537 void AccessibilityUIElement::hasPopupGetterCallback(CppVariant* result)
 538 {
 539     result->set(accessibilityObject().ariaHasPopup());
 540 }
 541
 542 void AccessibilityUIElement::isValidGetterCallback(CppVariant* result)
 543 {
 544     result->set(accessibilityObject().isValid());
 545 }
 546
 547 void AccessibilityUIElement::orientationGetterCallback(CppVariant* result)
 548 {
 549     result->set(getOrientation(accessibilityObject()));
 550 }
 551
 552 //
 553 // Methods
 554 //
 555
 556 void AccessibilityUIElement::allAttributesCallback(const CppArgumentList&, CppVariant* result)
 557 {
 558     result->set(getAttributes(accessibilityObject()));
 559 }
 560
 561 void AccessibilityUIElement::attributesOfLinkedUIElementsCallback(const CppArgumentList&, CppVariant* result)
 562 {
 563     result->setNull();
 564 }
 565
 566 void AccessibilityUIElement::attributesOfDocumentLinksCallback(const CppArgumentList&, CppVariant* result)
 567 {
 568     result->setNull();
 569 }
 570
 571 void AccessibilityUIElement::attributesOfChildrenCallback(const CppArgumentList& arguments, CppVariant* result)
 572 {
 573     AttributesCollector collector;
 574     unsigned size = accessibilityObject().childCount();
 575     for (unsigned i = 0; i < size; ++i)
 576         collector.collectAttributes(accessibilityObject().childAt(i));
 577     result->set(collector.attributes());
 578 }
 579
 580 void AccessibilityUIElement::parametrizedAttributeNamesCallback(const CppArgumentList&, CppVariant* result)
 581 {
 582     result->setNull();
 583 }
 584
 585 void AccessibilityUIElement::lineForIndexCallback(const CppArgumentList&, CppVariant* result)
 586 {
 587     result->setNull();
 588 }
 589
 590 void AccessibilityUIElement::boundsForRangeCallback(const CppArgumentList&, CppVariant* result)
 591 {
 592     result->setNull();
 593 }
 594
 595 void AccessibilityUIElement::stringForRangeCallback(const CppArgumentList&, CppVariant* result)
 596 {
 597     result->setNull();
 598 }
 599
 600 void AccessibilityUIElement::childAtIndexCallback(const CppArgumentList& arguments, CppVariant* result)
 601 {
 602     if (!arguments.size() || !arguments[0].isNumber()) {
 603         result->setNull();
 604         return;
 605     }
 606
 607     AccessibilityUIElement* child = getChildAtIndex(arguments[0].toInt32());
 608     if (!child) {
 609         result->setNull();
 610         return;
 611     }
 612
 613     result->set(*(child->getAsCppVariant()));
 614 }
 615
 616 void AccessibilityUIElement::elementAtPointCallback(const CppArgumentList&, CppVariant* result)
 617 {
 618     result->setNull();
 619 }
 620
 621 void AccessibilityUIElement::attributesOfColumnHeadersCallback(const CppArgumentList&, CppVariant* result)
 622 {
 623     result->setNull();
 624 }
 625
 626 void AccessibilityUIElement::attributesOfRowHeadersCallback(const CppArgumentList&, CppVariant* result)
 627 {
 628     result->setNull();
 629 }
 630
 631 void AccessibilityUIElement::attributesOfColumnsCallback(const CppArgumentList&, CppVariant* result)
 632 {
 633     result->setNull();
 634 }
 635
 636 void AccessibilityUIElement::attributesOfRowsCallback(const CppArgumentList&, CppVariant* result)
 637 {
 638     result->setNull();
 639 }
 640
 641 void AccessibilityUIElement::attributesOfVisibleCellsCallback(const CppArgumentList&, CppVariant* result)
 642 {
 643     result->setNull();
 644 }
 645
 646 void AccessibilityUIElement::attributesOfHeaderCallback(const CppArgumentList&, CppVariant* result)
 647 {
 648     result->setNull();
 649 }
 650
 651 void AccessibilityUIElement::indexInTableCallback(const CppArgumentList&, CppVariant* result)
 652 {
 653     result->setNull();
 654 }
 655
 656 void AccessibilityUIElement::rowIndexRangeCallback(const CppArgumentList&, CppVariant* result)
 657 {
 658     result->setNull();
 659 }
 660
 661 void AccessibilityUIElement::columnIndexRangeCallback(const CppArgumentList&, CppVariant* result)
 662 {
 663     result->setNull();
 664 }
 665
 666 void AccessibilityUIElement::cellForColumnAndRowCallback(const CppArgumentList&, CppVariant* result)
 667 {
 668     result->setNull();
 669 }
 670
 671 void AccessibilityUIElement::titleUIElementCallback(const CppArgumentList&, CppVariant* result)
 672 {
 673     result->setNull();
 674 }
 675
 676 void AccessibilityUIElement::setSelectedTextRangeCallback(const CppArgumentList&, CppVariant* result)
 677 {
 678     result->setNull();
 679 }
 680
 681 void AccessibilityUIElement::attributeValueCallback(const CppArgumentList&, CppVariant* result)
 682 {
 683     result->setNull();
 684 }
 685
 686 void AccessibilityUIElement::isAttributeSettableCallback(const CppArgumentList& arguments, CppVariant* result)
 687 {
 688     if (arguments.size() < 1 && !arguments[0].isString()) {
 689         result->setNull();
 690         return;
 691     }
 692
 693     string attribute = arguments[0].toString();
 694     bool settable = false;
 695     if (attribute == "AXValue")
 696         settable = accessibilityObject().canSetValueAttribute();
 697     result->set(settable);
 698 }
 699
 700 void AccessibilityUIElement::isActionSupportedCallback(const CppArgumentList&, CppVariant* result)
 701 {
 702     // This one may be really hard to implement.
 703     // Not exposed by AccessibilityObject.
 704     result->setNull();
 705 }
 706
 707 void AccessibilityUIElement::parentElementCallback(const CppArgumentList&, CppVariant* result)
 708 {
 709     result->setNull();
 710 }
 711
 712 void AccessibilityUIElement::incrementCallback(const CppArgumentList&, CppVariant* result)
 713 {
 714     result->setNull();
 715 }
 716
 717 void AccessibilityUIElement::decrementCallback(const CppArgumentList&, CppVariant* result)
 718 {
 719     result->setNull();
 720 }
 721
 722 void AccessibilityUIElement::showMenuCallback(const CppArgumentList&, CppVariant* result)
 723 {
 724     result->setNull();
 725 }
 726
 727 void AccessibilityUIElement::pressCallback(const CppArgumentList&, CppVariant* result)
 728 {
 729     accessibilityObject().performDefaultAction();
 730     result->setNull();
 731 }
 732
 733 void AccessibilityUIElement::isEqualCallback(const CppArgumentList& arguments, CppVariant* result)
 734 {
 735     if (arguments.size() < 1 || !arguments[0].isObject()) {
 736         result->setNull();
 737         return;
 738     }
 739
 740     result->set(arguments[0].isEqual(*getAsCppVariant()));
 741 }
 742
 743 void AccessibilityUIElement::addNotificationListenerCallback(const CppArgumentList& arguments, CppVariant* result)
 744 {
 745     if (arguments.size() < 1 || !arguments[0].isObject()) {
 746         result->setNull();
 747         return;
 748     }
 749
 750     m_notificationCallbacks.push_back(arguments[0]);
 751     result->setNull();
 752 }
 753
 754 void AccessibilityUIElement::removeNotificationListenerCallback(const CppArgumentList&, CppVariant* result)
 755 {
 756     // FIXME: Implement this.
 757     result->setNull();
 758 }
 759
 760 void AccessibilityUIElement::takeFocusCallback(const CppArgumentList&, CppVariant* result)
 761 {
 762     accessibilityObject().setFocused(true);
 763     result->setNull();
 764 }
 765
 766 void AccessibilityUIElement::fallbackCallback(const CppArgumentList &, CppVariant* result)
 767 {
 768     // FIXME: Implement this.
 769     result->setNull();
 770 }
 771
 772 RootAccessibilityUIElement::RootAccessibilityUIElement(const WebAccessibilityObject &object, Factory *factory)
 773     : AccessibilityUIElement(object, factory) { }
 774
 775 AccessibilityUIElement* RootAccessibilityUIElement::getChildAtIndex(unsigned index)
 776 {
 777     if (index)
 778         return 0;
 779
 780     return factory()->getOrCreate(accessibilityObject());
 781 }
 782
 783
 784 AccessibilityUIElementList ::~AccessibilityUIElementList()
 785 {
 786     clear();
 787 }
 788
 789 void AccessibilityUIElementList::clear()
 790 {
 791     for (ElementList::iterator i = m_elements.begin(); i != m_elements.end(); ++i)
 792         delete (*i);
 793     m_elements.clear();
 794 }
 795
 796 AccessibilityUIElement* AccessibilityUIElementList::getOrCreate(const WebAccessibilityObject& object)
 797 {
 798     if (object.isNull())
 799         return 0;
 800
 801     size_t elementCount = m_elements.size();
 802     for (size_t i = 0; i < elementCount; i++) {
 803         if (m_elements[i]->isEqual(object))
 804             return m_elements[i];
 805     }
 806
 807     AccessibilityUIElement* element = new AccessibilityUIElement(object, this);
 808     m_elements.append(element);
 809     return element;
 810 }
 811
 812 AccessibilityUIElement* AccessibilityUIElementList::createRoot(const WebAccessibilityObject& object)
 813 {
 814     AccessibilityUIElement* element = new RootAccessibilityUIElement(object, this);
 815     m_elements.append(element);
 816     return element;
 817 }