Source/WebCore/accessibility/AccessibilityRenderObject.cpp

   1 /*
   2 * Copyright (C) 2008 Apple 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
   6 * are met:
   7 *
   8 * 1.  Redistributions of source code must retain the above copyright
   9 *     notice, this list of conditions and the following disclaimer.
  10 * 2.  Redistributions in binary form must reproduce the above copyright
  11 *     notice, this list of conditions and the following disclaimer in the
  12 *     documentation and/or other materials provided with the distribution.
  13 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  14 *     its contributors may be used to endorse or promote products derived
  15 *     from this software without specific prior written permission.
  16 *
  17 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27 */
  28
  29 #include "config.h"
  30 #include "AccessibilityRenderObject.h"
  31
  32 #include "AXObjectCache.h"
  33 #include "AccessibilityImageMapLink.h"
  34 #include "AccessibilityListBox.h"
  35 #include "AccessibilitySpinButton.h"
  36 #include "AccessibilityTable.h"
  37 #include "EventNames.h"
  38 #include "FloatRect.h"
  39 #include "Frame.h"
  40 #include "FrameLoader.h"
  41 #include "FrameSelection.h"
  42 #include "HTMLAreaElement.h"
  43 #include "HTMLFormElement.h"
  44 #include "HTMLFrameElementBase.h"
  45 #include "HTMLImageElement.h"
  46 #include "HTMLInputElement.h"
  47 #include "HTMLLabelElement.h"
  48 #include "HTMLMapElement.h"
  49 #include "HTMLNames.h"
  50 #include "HTMLOptGroupElement.h"
  51 #include "HTMLOptionElement.h"
  52 #include "HTMLOptionsCollection.h"
  53 #include "HTMLSelectElement.h"
  54 #include "HTMLTextAreaElement.h"
  55 #include "HitTestRequest.h"
  56 #include "HitTestResult.h"
  57 #include "LocalizedStrings.h"
  58 #include "MathMLNames.h"
  59 #include "NodeList.h"
  60 #include "Page.h"
  61 #include "ProgressTracker.h"
  62 #include "RenderButton.h"
  63 #include "RenderFieldset.h"
  64 #include "RenderFileUploadControl.h"
  65 #include "RenderHTMLCanvas.h"
  66 #include "RenderImage.h"
  67 #include "RenderInline.h"
  68 #include "RenderLayer.h"
  69 #include "RenderListBox.h"
  70 #include "RenderListMarker.h"
  71 #include "RenderMenuList.h"
  72 #include "RenderText.h"
  73 #include "RenderTextControl.h"
  74 #include "RenderTextControlSingleLine.h"
  75 #include "RenderTextFragment.h"
  76 #include "RenderTheme.h"
  77 #include "RenderView.h"
  78 #include "RenderWidget.h"
  79 #include "RenderedPosition.h"
  80 #include "Text.h"
  81 #include "TextControlInnerElements.h"
  82 #include "TextIterator.h"
  83 #include "htmlediting.h"
  84 #include "visible_units.h"
  85 #include <wtf/StdLibExtras.h>
  86 #include <wtf/text/StringBuilder.h>
  87 #include <wtf/unicode/CharacterNames.h>
  88
  89 using namespace std;
  90
  91 namespace WebCore {
  92
  93 using namespace HTMLNames;
  94
  95 AccessibilityRenderObject::AccessibilityRenderObject(RenderObject* renderer)
  96     : AccessibilityNodeObject(renderer->node())
  97     , m_renderer(renderer)
  98 {
  99 #ifndef NDEBUG
 100     m_renderer->setHasAXObject(true);
 101 #endif
 102 }
 103
 104 AccessibilityRenderObject::~AccessibilityRenderObject()
 105 {
 106     ASSERT(isDetached());
 107 }
 108
 109 void AccessibilityRenderObject::init()
 110 {
 111     AccessibilityNodeObject::init();
 112 }
 113
 114 PassRefPtr<AccessibilityRenderObject> AccessibilityRenderObject::create(RenderObject* renderer)
 115 {
 116     AccessibilityRenderObject* obj = new AccessibilityRenderObject(renderer);
 117     obj->init();
 118     return adoptRef(obj);
 119 }
 120
 121 void AccessibilityRenderObject::detach()
 122 {
 123     AccessibilityNodeObject::detach();
 124
 125 #ifndef NDEBUG
 126     if (m_renderer)
 127         m_renderer->setHasAXObject(false);
 128 #endif
 129     m_renderer = 0;
 130 }
 131
 132 RenderBoxModelObject* AccessibilityRenderObject::renderBoxModelObject() const
 133 {
 134     if (!m_renderer || !m_renderer->isBoxModelObject())
 135         return 0;
 136     return toRenderBoxModelObject(m_renderer);
 137 }
 138
 139 void AccessibilityRenderObject::setRenderer(RenderObject* renderer)
 140 {
 141     m_renderer = renderer;
 142     setNode(renderer->node());
 143 }
 144
 145 static inline bool isInlineWithContinuation(RenderObject* object)
 146 {
 147     if (!object->isBoxModelObject())
 148         return false;
 149
 150     RenderBoxModelObject* renderer = toRenderBoxModelObject(object);
 151     if (!renderer->isRenderInline())
 152         return false;
 153
 154     return toRenderInline(renderer)->continuation();
 155 }
 156
 157 static inline RenderObject* firstChildInContinuation(RenderObject* renderer)
 158 {
 159     RenderObject* r = toRenderInline(renderer)->continuation();
 160
 161     while (r) {
 162         if (r->isRenderBlock())
 163             return r;
 164         if (RenderObject* child = r->firstChild())
 165             return child;
 166         r = toRenderInline(r)->continuation();
 167     }
 168
 169     return 0;
 170 }
 171
 172 static inline RenderObject* firstChildConsideringContinuation(RenderObject* renderer)
 173 {
 174     RenderObject* firstChild = renderer->firstChild();
 175
 176     if (!firstChild && isInlineWithContinuation(renderer))
 177         firstChild = firstChildInContinuation(renderer);
 178
 179     return firstChild;
 180 }
 181
 182
 183 static inline RenderObject* lastChildConsideringContinuation(RenderObject* renderer)
 184 {
 185     RenderObject* lastChild = renderer->lastChild();
 186     RenderObject* prev;
 187     RenderObject* cur = renderer;
 188
 189     if (!cur->isRenderInline() && !cur->isRenderBlock())
 190         return renderer;
 191
 192     while (cur) {
 193         prev = cur;
 194
 195         if (RenderObject* lc = cur->lastChild())
 196             lastChild = lc;
 197
 198         if (cur->isRenderInline()) {
 199             cur = toRenderInline(cur)->inlineElementContinuation();
 200             ASSERT_UNUSED(prev, cur || !toRenderInline(prev)->continuation());
 201         } else
 202             cur = toRenderBlock(cur)->inlineElementContinuation();
 203     }
 204
 205     return lastChild;
 206 }
 207
 208 AccessibilityObject* AccessibilityRenderObject::firstChild() const
 209 {
 210     if (!m_renderer)
 211         return 0;
 212
 213     RenderObject* firstChild = firstChildConsideringContinuation(m_renderer);
 214
 215     if (!firstChild)
 216         return 0;
 217
 218     return axObjectCache()->getOrCreate(firstChild);
 219 }
 220
 221 AccessibilityObject* AccessibilityRenderObject::lastChild() const
 222 {
 223     if (!m_renderer)
 224         return 0;
 225
 226     RenderObject* lastChild = lastChildConsideringContinuation(m_renderer);
 227
 228     if (!lastChild)
 229         return 0;
 230
 231     return axObjectCache()->getOrCreate(lastChild);
 232 }
 233
 234 static inline RenderInline* startOfContinuations(RenderObject* r)
 235 {
 236     if (r->isInlineElementContinuation())
 237         return toRenderInline(r->node()->renderer());
 238
 239     // Blocks with a previous continuation always have a next continuation
 240     if (r->isRenderBlock() && toRenderBlock(r)->inlineElementContinuation())
 241         return toRenderInline(toRenderBlock(r)->inlineElementContinuation()->node()->renderer());
 242
 243     return 0;
 244 }
 245
 246 static inline RenderObject* endOfContinuations(RenderObject* renderer)
 247 {
 248     RenderObject* prev = renderer;
 249     RenderObject* cur = renderer;
 250
 251     if (!cur->isRenderInline() && !cur->isRenderBlock())
 252         return renderer;
 253
 254     while (cur) {
 255         prev = cur;
 256         if (cur->isRenderInline()) {
 257             cur = toRenderInline(cur)->inlineElementContinuation();
 258             ASSERT(cur || !toRenderInline(prev)->continuation());
 259         } else
 260             cur = toRenderBlock(cur)->inlineElementContinuation();
 261     }
 262
 263     return prev;
 264 }
 265
 266
 267 static inline RenderObject* childBeforeConsideringContinuations(RenderInline* r, RenderObject* child)
 268 {
 269     RenderBoxModelObject* curContainer = r;
 270     RenderObject* cur = 0;
 271     RenderObject* prev = 0;
 272
 273     while (curContainer) {
 274         if (curContainer->isRenderInline()) {
 275             cur = curContainer->firstChild();
 276             while (cur) {
 277                 if (cur == child)
 278                     return prev;
 279                 prev = cur;
 280                 cur = cur->nextSibling();
 281             }
 282
 283             curContainer = toRenderInline(curContainer)->continuation();
 284         } else if (curContainer->isRenderBlock()) {
 285             if (curContainer == child)
 286                 return prev;
 287
 288             prev = curContainer;
 289             curContainer = toRenderBlock(curContainer)->inlineElementContinuation();
 290         }
 291     }
 292
 293     ASSERT_NOT_REACHED();
 294
 295     return 0;
 296 }
 297
 298 static inline bool firstChildIsInlineContinuation(RenderObject* renderer)
 299 {
 300     return renderer->firstChild() && renderer->firstChild()->isInlineElementContinuation();
 301 }
 302
 303 AccessibilityObject* AccessibilityRenderObject::previousSibling() const
 304 {
 305     if (!m_renderer)
 306         return 0;
 307
 308     RenderObject* previousSibling = 0;
 309
 310     // Case 1: The node is a block and is an inline's continuation. In that case, the inline's
 311     // last child is our previous sibling (or further back in the continuation chain)
 312     RenderInline* startOfConts;
 313     if (m_renderer->isRenderBlock() && (startOfConts = startOfContinuations(m_renderer)))
 314         previousSibling = childBeforeConsideringContinuations(startOfConts, m_renderer);
 315
 316     // Case 2: Anonymous block parent of the end of a continuation - skip all the way to before
 317     // the parent of the start, since everything in between will be linked up via the continuation.
 318     else if (m_renderer->isAnonymousBlock() && firstChildIsInlineContinuation(m_renderer)) {
 319         RenderObject* firstParent = startOfContinuations(m_renderer->firstChild())->parent();
 320         while (firstChildIsInlineContinuation(firstParent))
 321             firstParent = startOfContinuations(firstParent->firstChild())->parent();
 322         previousSibling = firstParent->previousSibling();
 323     }
 324
 325     // Case 3: The node has an actual previous sibling
 326     else if (RenderObject* ps = m_renderer->previousSibling())
 327         previousSibling = ps;
 328
 329     // Case 4: This node has no previous siblings, but its parent is an inline,
 330     // and is another node's inline continutation. Follow the continuation chain.
 331     else if (m_renderer->parent()->isRenderInline() && (startOfConts = startOfContinuations(m_renderer->parent())))
 332         previousSibling = childBeforeConsideringContinuations(startOfConts, m_renderer->parent()->firstChild());
 333
 334     if (!previousSibling)
 335         return 0;
 336
 337     return axObjectCache()->getOrCreate(previousSibling);
 338 }
 339
 340 static inline bool lastChildHasContinuation(RenderObject* renderer)
 341 {
 342     return renderer->lastChild() && isInlineWithContinuation(renderer->lastChild());
 343 }
 344
 345 AccessibilityObject* AccessibilityRenderObject::nextSibling() const
 346 {
 347     if (!m_renderer)
 348         return 0;
 349
 350     RenderObject* nextSibling = 0;
 351
 352     // Case 1: node is a block and has an inline continuation. Next sibling is the inline continuation's
 353     // first child.
 354     RenderInline* inlineContinuation;
 355     if (m_renderer->isRenderBlock() && (inlineContinuation = toRenderBlock(m_renderer)->inlineElementContinuation()))
 356         nextSibling = firstChildConsideringContinuation(inlineContinuation);
 357
 358     // Case 2: Anonymous block parent of the start of a continuation - skip all the way to
 359     // after the parent of the end, since everything in between will be linked up via the continuation.
 360     else if (m_renderer->isAnonymousBlock() && lastChildHasContinuation(m_renderer)) {
 361         RenderObject* lastParent = endOfContinuations(m_renderer->lastChild())->parent();
 362         while (lastChildHasContinuation(lastParent))
 363             lastParent = endOfContinuations(lastParent->lastChild())->parent();
 364         nextSibling = lastParent->nextSibling();
 365     }
 366
 367     // Case 3: node has an actual next sibling
 368     else if (RenderObject* ns = m_renderer->nextSibling())
 369         nextSibling = ns;
 370
 371     // Case 4: node is an inline with a continuation. Next sibling is the next sibling of the end
 372     // of the continuation chain.
 373     else if (isInlineWithContinuation(m_renderer))
 374         nextSibling = endOfContinuations(m_renderer)->nextSibling();
 375
 376     // Case 5: node has no next sibling, and its parent is an inline with a continuation.
 377     else if (isInlineWithContinuation(m_renderer->parent())) {
 378         RenderObject* continuation = toRenderInline(m_renderer->parent())->continuation();
 379
 380         // Case 5a: continuation is a block - in this case the block itself is the next sibling.
 381         if (continuation->isRenderBlock())
 382             nextSibling = continuation;
 383         // Case 5b: continuation is an inline - in this case the inline's first child is the next sibling
 384         else
 385             nextSibling = firstChildConsideringContinuation(continuation);
 386     }
 387
 388     if (!nextSibling)
 389         return 0;
 390
 391     return axObjectCache()->getOrCreate(nextSibling);
 392 }
 393
 394 static RenderBoxModelObject* nextContinuation(RenderObject* renderer)
 395 {
 396     ASSERT(renderer);
 397     if (renderer->isRenderInline() && !renderer->isReplaced())
 398         return toRenderInline(renderer)->continuation();
 399     if (renderer->isRenderBlock())
 400         return toRenderBlock(renderer)->inlineElementContinuation();
 401     return 0;
 402 }
 403
 404 RenderObject* AccessibilityRenderObject::renderParentObject() const
 405 {
 406     if (!m_renderer)
 407         return 0;
 408
 409     RenderObject* parent = m_renderer->parent();
 410
 411     // Case 1: node is a block and is an inline's continuation. Parent
 412     // is the start of the continuation chain.
 413     RenderObject* startOfConts = 0;
 414     RenderObject* firstChild = 0;
 415     if (m_renderer->isRenderBlock() && (startOfConts = startOfContinuations(m_renderer)))
 416         parent = startOfConts;
 417
 418     // Case 2: node's parent is an inline which is some node's continuation; parent is
 419     // the earliest node in the continuation chain.
 420     else if (parent && parent->isRenderInline() && (startOfConts = startOfContinuations(parent)))
 421         parent = startOfConts;
 422
 423     // Case 3: The first sibling is the beginning of a continuation chain. Find the origin of that continuation.
 424     else if (parent && (firstChild = parent->firstChild()) && firstChild->node()) {
 425         // Get the node's renderer and follow that continuation chain until the first child is found
 426         RenderObject* nodeRenderFirstChild = firstChild->node()->renderer();
 427         while (nodeRenderFirstChild != firstChild) {
 428             for (RenderObject* contsTest = nodeRenderFirstChild; contsTest; contsTest = nextContinuation(contsTest)) {
 429                 if (contsTest == firstChild) {
 430                     parent = nodeRenderFirstChild->parent();
 431                     break;
 432                 }
 433             }
 434             if (firstChild == parent->firstChild())
 435                 break;
 436             firstChild = parent->firstChild();
 437             if (!firstChild->node())
 438                 break;
 439             nodeRenderFirstChild = firstChild->node()->renderer();
 440         }
 441     }
 442
 443     return parent;
 444 }
 445
 446 AccessibilityObject* AccessibilityRenderObject::parentObjectIfExists() const
 447 {
 448     // WebArea's parent should be the scroll view containing it.
 449     if (isWebArea())
 450         return axObjectCache()->get(m_renderer->frame()->view());
 451
 452     return axObjectCache()->get(renderParentObject());
 453 }
 454
 455 AccessibilityObject* AccessibilityRenderObject::parentObject() const
 456 {
 457     if (!m_renderer)
 458         return 0;
 459
 460     if (ariaRoleAttribute() == MenuBarRole)
 461         return axObjectCache()->getOrCreate(m_renderer->parent());
 462
 463     // menuButton and its corresponding menu are DOM siblings, but Accessibility needs them to be parent/child
 464     if (ariaRoleAttribute() == MenuRole) {
 465         AccessibilityObject* parent = menuButtonForMenu();
 466         if (parent)
 467             return parent;
 468     }
 469
 470     RenderObject* parentObj = renderParentObject();
 471     if (parentObj)
 472         return axObjectCache()->getOrCreate(parentObj);
 473
 474     // WebArea's parent should be the scroll view containing it.
 475     if (isWebArea())
 476         return axObjectCache()->getOrCreate(m_renderer->frame()->view());
 477
 478     return 0;
 479 }
 480
 481 bool AccessibilityRenderObject::isWebArea() const
 482 {
 483     return roleValue() == WebAreaRole;
 484 }
 485
 486 bool AccessibilityRenderObject::isImageButton() const
 487 {
 488     return isNativeImage() && roleValue() == ButtonRole;
 489 }
 490
 491 bool AccessibilityRenderObject::isAnchor() const
 492 {
 493     return !isNativeImage() && isLink();
 494 }
 495
 496 bool AccessibilityRenderObject::isNativeTextControl() const
 497 {
 498     return m_renderer->isTextControl();
 499 }
 500
 501 bool AccessibilityRenderObject::isSearchField() const
 502 {
 503     if (!node())
 504         return false;
 505
 506     HTMLInputElement* inputElement = node()->toInputElement();
 507     if (!inputElement)
 508         return false;
 509
 510     if (inputElement->isSearchField())
 511         return true;
 512
 513     // Some websites don't label their search fields as such. However, they will
 514     // use the word "search" in either the form or input type. This won't catch every case,
 515     // but it will catch google.com for example.
 516
 517     // Check the node name of the input type, sometimes it's "search".
 518     const AtomicString& nameAttribute = getAttribute(nameAttr);
 519     if (nameAttribute.contains("search", false))
 520         return true;
 521
 522     // Check the form action and the name, which will sometimes be "search".
 523     HTMLFormElement* form = inputElement->form();
 524     if (form && (form->name().contains("search", false) || form->action().contains("search", false)))
 525         return true;
 526
 527     return false;
 528 }
 529
 530 bool AccessibilityRenderObject::isNativeImage() const
 531 {
 532     return m_renderer->isBoxModelObject() && toRenderBoxModelObject(m_renderer)->isImage();
 533 }
 534
 535 bool AccessibilityRenderObject::isImage() const
 536 {
 537     return roleValue() == ImageRole;
 538 }
 539
 540 bool AccessibilityRenderObject::isAttachment() const
 541 {
 542     RenderBoxModelObject* renderer = renderBoxModelObject();
 543     if (!renderer)
 544         return false;
 545     // Widgets are the replaced elements that we represent to AX as attachments
 546     bool isWidget = renderer->isWidget();
 547     ASSERT(!isWidget || (renderer->isReplaced() && !isImage()));
 548     return isWidget && ariaRoleAttribute() == UnknownRole;
 549 }
 550
 551 bool AccessibilityRenderObject::isPasswordField() const
 552 {
 553     ASSERT(m_renderer);
 554     if (!m_renderer->node() || !m_renderer->node()->isHTMLElement())
 555         return false;
 556     if (ariaRoleAttribute() != UnknownRole)
 557         return false;
 558
 559     HTMLInputElement* inputElement = m_renderer->node()->toInputElement();
 560     if (!inputElement)
 561         return false;
 562
 563     return inputElement->isPasswordField();
 564 }
 565
 566 bool AccessibilityRenderObject::isFileUploadButton() const
 567 {
 568     if (m_renderer && m_renderer->node() && m_renderer->node()->hasTagName(inputTag)) {
 569         HTMLInputElement* input = static_cast<HTMLInputElement*>(m_renderer->node());
 570         return input->isFileUpload();
 571     }
 572
 573     return false;
 574 }
 575
 576 bool AccessibilityRenderObject::isInputImage() const
 577 {
 578     Node* elementNode = node();
 579     if (roleValue() == ButtonRole && elementNode && elementNode->hasTagName(inputTag)) {
 580         HTMLInputElement* input = static_cast<HTMLInputElement*>(elementNode);
 581         return input->isImageButton();
 582     }
 583
 584     return false;
 585 }
 586
 587 bool AccessibilityRenderObject::isProgressIndicator() const
 588 {
 589     return roleValue() == ProgressIndicatorRole;
 590 }
 591
 592 bool AccessibilityRenderObject::isSlider() const
 593 {
 594     return roleValue() == SliderRole;
 595 }
 596
 597 bool AccessibilityRenderObject::isMenuRelated() const
 598 {
 599     AccessibilityRole role = roleValue();
 600     return role == MenuRole
 601         || role == MenuBarRole
 602         || role == MenuButtonRole
 603         || role == MenuItemRole;
 604 }
 605
 606 bool AccessibilityRenderObject::isMenu() const
 607 {
 608     return roleValue() == MenuRole;
 609 }
 610
 611 bool AccessibilityRenderObject::isMenuBar() const
 612 {
 613     return roleValue() == MenuBarRole;
 614 }
 615
 616 bool AccessibilityRenderObject::isMenuButton() const
 617 {
 618     return roleValue() == MenuButtonRole;
 619 }
 620
 621 bool AccessibilityRenderObject::isMenuItem() const
 622 {
 623     return roleValue() == MenuItemRole;
 624 }
 625
 626 bool AccessibilityRenderObject::isPressed() const
 627 {
 628     ASSERT(m_renderer);
 629     if (roleValue() != ButtonRole)
 630         return false;
 631
 632     Node* node = m_renderer->node();
 633     if (!node)
 634         return false;
 635
 636     // If this is an ARIA button, check the aria-pressed attribute rather than node()->active()
 637     if (ariaRoleAttribute() == ButtonRole) {
 638         if (equalIgnoringCase(getAttribute(aria_pressedAttr), "true"))
 639             return true;
 640         return false;
 641     }
 642
 643     return node->active();
 644 }
 645
 646 bool AccessibilityRenderObject::isIndeterminate() const
 647 {
 648     ASSERT(m_renderer);
 649     if (!m_renderer->node())
 650         return false;
 651
 652     HTMLInputElement* inputElement = m_renderer->node()->toInputElement();
 653     if (!inputElement)
 654         return false;
 655
 656     return inputElement->isIndeterminate();
 657 }
 658
 659 bool AccessibilityRenderObject::isNativeCheckboxOrRadio() const
 660 {
 661     Node* elementNode = node();
 662     if (elementNode) {
 663         HTMLInputElement* input = elementNode->toInputElement();
 664         if (input)
 665             return input->isCheckbox() || input->isRadioButton();
 666     }
 667
 668     return false;
 669 }
 670
 671 bool AccessibilityRenderObject::isChecked() const
 672 {
 673     ASSERT(m_renderer);
 674
 675     Node* node = this->node();
 676     if (!node)
 677         return false;
 678
 679     // First test for native checkedness semantics
 680     HTMLInputElement* inputElement = node->toInputElement();
 681     if (inputElement)
 682         return inputElement->shouldAppearChecked();
 683
 684     // Else, if this is an ARIA checkbox or radio, respect the aria-checked attribute
 685     AccessibilityRole ariaRole = ariaRoleAttribute();
 686     if (ariaRole == RadioButtonRole || ariaRole == CheckBoxRole) {
 687         if (equalIgnoringCase(getAttribute(aria_checkedAttr), "true"))
 688             return true;
 689         return false;
 690     }
 691
 692     // Otherwise it's not checked
 693     return false;
 694 }
 695
 696 bool AccessibilityRenderObject::isHovered() const
 697 {
 698     ASSERT(m_renderer);
 699     return m_renderer->node() && m_renderer->node()->hovered();
 700 }
 701
 702 bool AccessibilityRenderObject::isMultiSelectable() const
 703 {
 704     ASSERT(m_renderer);
 705
 706     const AtomicString& ariaMultiSelectable = getAttribute(aria_multiselectableAttr);
 707     if (equalIgnoringCase(ariaMultiSelectable, "true"))
 708         return true;
 709     if (equalIgnoringCase(ariaMultiSelectable, "false"))
 710         return false;
 711
 712     if (!m_renderer->isBoxModelObject() || !toRenderBoxModelObject(m_renderer)->isListBox())
 713         return false;
 714     return m_renderer->node() && toHTMLSelectElement(m_renderer->node())->multiple();
 715 }
 716
 717 bool AccessibilityRenderObject::isReadOnly() const
 718 {
 719     ASSERT(m_renderer);
 720
 721     if (isWebArea()) {
 722         Document* document = m_renderer->document();
 723         if (!document)
 724             return true;
 725
 726         HTMLElement* body = document->body();
 727         if (body && body->rendererIsEditable())
 728             return false;
 729
 730         return !document->rendererIsEditable();
 731     }
 732
 733     if (m_renderer->isBoxModelObject()) {
 734         RenderBoxModelObject* box = toRenderBoxModelObject(m_renderer);
 735         if (box->isTextField())
 736             return static_cast<HTMLInputElement*>(box->node())->readOnly();
 737         if (box->isTextArea())
 738             return static_cast<HTMLTextAreaElement*>(box->node())->readOnly();
 739     }
 740
 741     return !m_renderer->node() || !m_renderer->node()->rendererIsEditable();
 742 }
 743
 744 bool AccessibilityRenderObject::isOffScreen() const
 745 {
 746     ASSERT(m_renderer);
 747     IntRect contentRect = pixelSnappedIntRect(m_renderer->absoluteClippedOverflowRect());
 748     FrameView* view = m_renderer->frame()->view();
 749     IntRect viewRect = view->visibleContentRect();
 750     viewRect.intersect(contentRect);
 751     return viewRect.isEmpty();
 752 }
 753
 754 int AccessibilityRenderObject::headingLevel() const
 755 {
 756     // headings can be in block flow and non-block flow
 757     Node* element = node();
 758     if (!element)
 759         return 0;
 760
 761     if (ariaRoleAttribute() == HeadingRole)
 762         return getAttribute(aria_levelAttr).toInt();
 763
 764     if (element->hasTagName(h1Tag))
 765         return 1;
 766
 767     if (element->hasTagName(h2Tag))
 768         return 2;
 769
 770     if (element->hasTagName(h3Tag))
 771         return 3;
 772
 773     if (element->hasTagName(h4Tag))
 774         return 4;
 775
 776     if (element->hasTagName(h5Tag))
 777         return 5;
 778
 779     if (element->hasTagName(h6Tag))
 780         return 6;
 781
 782     return 0;
 783 }
 784
 785 bool AccessibilityRenderObject::isHeading() const
 786 {
 787     return roleValue() == HeadingRole;
 788 }
 789
 790 bool AccessibilityRenderObject::isLink() const
 791 {
 792     return roleValue() == WebCoreLinkRole;
 793 }
 794
 795 bool AccessibilityRenderObject::isControl() const
 796 {
 797     if (!m_renderer)
 798         return false;
 799
 800     Node* node = m_renderer->node();
 801     return node && ((node->isElementNode() && static_cast<Element*>(node)->isFormControlElement())
 802                     || AccessibilityObject::isARIAControl(ariaRoleAttribute()));
 803 }
 804
 805 bool AccessibilityRenderObject::isFieldset() const
 806 {
 807     RenderBoxModelObject* renderer = renderBoxModelObject();
 808     if (!renderer)
 809         return false;
 810     return renderer->isFieldset();
 811 }
 812
 813 bool AccessibilityRenderObject::isGroup() const
 814 {
 815     return roleValue() == GroupRole;
 816 }
 817
 818 AccessibilityObject* AccessibilityRenderObject::selectedRadioButton()
 819 {
 820     if (!isRadioGroup())
 821         return 0;
 822
 823     AccessibilityObject::AccessibilityChildrenVector children = this->children();
 824
 825     // Find the child radio button that is selected (ie. the intValue == 1).
 826     size_t size = children.size();
 827     for (size_t i = 0; i < size; ++i) {
 828         AccessibilityObject* object = children[i].get();
 829         if (object->roleValue() == RadioButtonRole && object->checkboxOrRadioValue() == ButtonStateOn)
 830             return object;
 831     }
 832     return 0;
 833 }
 834
 835 AccessibilityObject* AccessibilityRenderObject::selectedTabItem()
 836 {
 837     if (!isTabList())
 838         return 0;
 839
 840     // Find the child tab item that is selected (ie. the intValue == 1).
 841     AccessibilityObject::AccessibilityChildrenVector tabs;
 842     tabChildren(tabs);
 843
 844     AccessibilityObject::AccessibilityChildrenVector children = this->children();
 845
 846     size_t size = tabs.size();
 847     for (size_t i = 0; i < size; ++i) {
 848         AccessibilityObject* object = children[i].get();
 849         if (object->isTabItem() && object->isChecked())
 850             return object;
 851     }
 852     return 0;
 853 }
 854
 855 Element* AccessibilityRenderObject::anchorElement() const
 856 {
 857     if (!m_renderer)
 858         return 0;
 859
 860     AXObjectCache* cache = axObjectCache();
 861     RenderObject* currRenderer;
 862
 863     // Search up the render tree for a RenderObject with a DOM node.  Defer to an earlier continuation, though.
 864     for (currRenderer = m_renderer; currRenderer && !currRenderer->node(); currRenderer = currRenderer->parent()) {
 865         if (currRenderer->isAnonymousBlock()) {
 866             RenderObject* continuation = toRenderBlock(currRenderer)->continuation();
 867             if (continuation)
 868                 return cache->getOrCreate(continuation)->anchorElement();
 869         }
 870     }
 871
 872     // bail if none found
 873     if (!currRenderer)
 874         return 0;
 875
 876     // search up the DOM tree for an anchor element
 877     // NOTE: this assumes that any non-image with an anchor is an HTMLAnchorElement
 878     Node* node = currRenderer->node();
 879     for ( ; node; node = node->parentNode()) {
 880         if (node->hasTagName(aTag) || (node->renderer() && cache->getOrCreate(node->renderer())->isAnchor()))
 881             return static_cast<Element*>(node);
 882     }
 883
 884     return 0;
 885 }
 886
 887 Element* AccessibilityRenderObject::actionElement() const
 888 {
 889     if (!m_renderer)
 890         return 0;
 891
 892     Node* node = m_renderer->node();
 893     if (node) {
 894         if (node->hasTagName(inputTag)) {
 895             HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
 896             if (!input->disabled() && (isCheckboxOrRadio() || input->isTextButton()))
 897                 return input;
 898         } else if (node->hasTagName(buttonTag))
 899             return toElement(node);
 900     }
 901
 902     if (isFileUploadButton())
 903         return toElement(m_renderer->node());
 904
 905     if (AccessibilityObject::isARIAInput(ariaRoleAttribute()))
 906         return toElement(m_renderer->node());
 907
 908     if (isImageButton())
 909         return toElement(m_renderer->node());
 910
 911     if (m_renderer->isBoxModelObject() && toRenderBoxModelObject(m_renderer)->isMenuList())
 912         return toElement(m_renderer->node());
 913
 914     switch (roleValue()) {
 915     case ButtonRole:
 916     case PopUpButtonRole:
 917     case TabRole:
 918     case MenuItemRole:
 919     case ListItemRole:
 920         return toElement(m_renderer->node());
 921     default:
 922         break;
 923     }
 924
 925     Element* elt = anchorElement();
 926     if (!elt)
 927         elt = mouseButtonListener();
 928     return elt;
 929 }
 930
 931 Element* AccessibilityRenderObject::mouseButtonListener() const
 932 {
 933     Node* node = m_renderer->node();
 934     if (!node)
 935         return 0;
 936
 937     // check if our parent is a mouse button listener
 938     while (node && !node->isElementNode())
 939         node = node->parentNode();
 940
 941     if (!node)
 942         return 0;
 943
 944     // FIXME: Do the continuation search like anchorElement does
 945     for (Element* element = static_cast<Element*>(node); element; element = element->parentElement()) {
 946         if (element->getAttributeEventListener(eventNames().clickEvent) || element->getAttributeEventListener(eventNames().mousedownEvent) || element->getAttributeEventListener(eventNames().mouseupEvent))
 947             return element;
 948     }
 949
 950     return 0;
 951 }
 952
 953 void AccessibilityRenderObject::alterSliderValue(bool increase)
 954 {
 955     if (roleValue() != SliderRole)
 956         return;
 957
 958     if (!getAttribute(stepAttr).isEmpty())
 959         changeValueByStep(increase);
 960     else
 961         changeValueByPercent(increase ? 5 : -5);
 962 }
 963
 964 void AccessibilityRenderObject::increment()
 965 {
 966     alterSliderValue(true);
 967 }
 968
 969 void AccessibilityRenderObject::decrement()
 970 {
 971     alterSliderValue(false);
 972 }
 973
 974 static Element* siblingWithAriaRole(String role, Node* node)
 975 {
 976     Node* sibling = node->parentNode()->firstChild();
 977     while (sibling) {
 978         if (sibling->isElementNode()) {
 979             const AtomicString& siblingAriaRole = static_cast<Element*>(sibling)->getAttribute(roleAttr);
 980             if (equalIgnoringCase(siblingAriaRole, role))
 981                 return static_cast<Element*>(sibling);
 982         }
 983         sibling = sibling->nextSibling();
 984     }
 985
 986     return 0;
 987 }
 988
 989 Element* AccessibilityRenderObject::menuElementForMenuButton() const
 990 {
 991     if (ariaRoleAttribute() != MenuButtonRole)
 992         return 0;
 993
 994     return siblingWithAriaRole("menu", renderer()->node());
 995 }
 996
 997 AccessibilityObject* AccessibilityRenderObject::menuForMenuButton() const
 998 {
 999     Element* menu = menuElementForMenuButton();
1000     if (menu && menu->renderer())
1001         return axObjectCache()->getOrCreate(menu->renderer());
1002     return 0;
1003 }
1004
1005 Element* AccessibilityRenderObject::menuItemElementForMenu() const
1006 {
1007     if (ariaRoleAttribute() != MenuRole)
1008         return 0;
1009
1010     return siblingWithAriaRole("menuitem", renderer()->node());
1011 }
1012
1013 AccessibilityObject* AccessibilityRenderObject::menuButtonForMenu() const
1014 {
1015     Element* menuItem = menuItemElementForMenu();
1016
1017     if (menuItem && menuItem->renderer()) {
1018         // ARIA just has generic menu items.  AppKit needs to know if this is a top level items like MenuBarButton or MenuBarItem
1019         AccessibilityObject* menuItemAX = axObjectCache()->getOrCreate(menuItem->renderer());
1020         if (menuItemAX->isMenuButton())
1021             return menuItemAX;
1022     }
1023     return 0;
1024 }
1025
1026 String AccessibilityRenderObject::helpText() const
1027 {
1028     if (!m_renderer)
1029         return String();
1030
1031     const AtomicString& ariaHelp = getAttribute(aria_helpAttr);
1032     if (!ariaHelp.isEmpty())
1033         return ariaHelp;
1034
1035     String describedBy = ariaDescribedByAttribute();
1036     if (!describedBy.isEmpty())
1037         return describedBy;
1038
1039     String description = accessibilityDescription();
1040     for (RenderObject* curr = m_renderer; curr; curr = curr->parent()) {
1041         if (curr->node() && curr->node()->isHTMLElement()) {
1042             const AtomicString& summary = static_cast<Element*>(curr->node())->getAttribute(summaryAttr);
1043             if (!summary.isEmpty())
1044                 return summary;
1045
1046             // The title attribute should be used as help text unless it is already being used as descriptive text.
1047             const AtomicString& title = static_cast<Element*>(curr->node())->getAttribute(titleAttr);
1048             if (!title.isEmpty() && description != title)
1049                 return title;
1050         }
1051
1052         // Only take help text from an ancestor element if its a group or an unknown role. If help was
1053         // added to those kinds of elements, it is likely it was meant for a child element.
1054         AccessibilityObject* axObj = axObjectCache()->getOrCreate(curr);
1055         if (axObj) {
1056             AccessibilityRole role = axObj->roleValue();
1057             if (role != GroupRole && role != UnknownRole)
1058                 break;
1059         }
1060     }
1061
1062     return String();
1063 }
1064
1065 unsigned AccessibilityRenderObject::hierarchicalLevel() const
1066 {
1067     if (!m_renderer)
1068         return 0;
1069
1070     Node* node = m_renderer->node();
1071     if (!node || !node->isElementNode())
1072         return 0;
1073     Element* element = static_cast<Element*>(node);
1074     String ariaLevel = element->getAttribute(aria_levelAttr);
1075     if (!ariaLevel.isEmpty())
1076         return ariaLevel.toInt();
1077
1078     // Only tree item will calculate its level through the DOM currently.
1079     if (roleValue() != TreeItemRole)
1080         return 0;
1081
1082     // Hierarchy leveling starts at 0.
1083     // We measure tree hierarchy by the number of groups that the item is within.
1084     unsigned level = 0;
1085     AccessibilityObject* parent = parentObject();
1086     while (parent) {
1087         AccessibilityRole parentRole = parent->roleValue();
1088         if (parentRole == GroupRole)
1089             level++;
1090         else if (parentRole == TreeRole)
1091             break;
1092
1093         parent = parent->parentObject();
1094     }
1095
1096     return level;
1097 }
1098
1099 static TextIteratorBehavior textIteratorBehaviorForTextRange()
1100 {
1101     TextIteratorBehavior behavior = TextIteratorIgnoresStyleVisibility;
1102
1103 #if PLATFORM(GTK)
1104     // We need to emit replaced elements for GTK, and present
1105     // them with the 'object replacement character' (0xFFFC).
1106     behavior = static_cast<TextIteratorBehavior>(behavior | TextIteratorEmitsObjectReplacementCharacters);
1107 #endif
1108
1109     return behavior;
1110 }
1111
1112 String AccessibilityRenderObject::textUnderElement() const
1113 {
1114     if (!m_renderer)
1115         return String();
1116
1117     if (m_renderer->isFileUploadControl())
1118         return toRenderFileUploadControl(m_renderer)->buttonValue();
1119
1120     Node* node = m_renderer->node();
1121     if (node) {
1122         if (Frame* frame = node->document()->frame()) {
1123             // catch stale WebCoreAXObject (see <rdar://problem/3960196>)
1124             if (frame->document() != node->document())
1125                 return String();
1126
1127             return plainText(rangeOfContents(node).get(), textIteratorBehaviorForTextRange());
1128         }
1129     }
1130
1131     // Sometimes text fragments don't have Node's associated with them (like when
1132     // CSS content is used to insert text).
1133     if (m_renderer->isText()) {
1134         RenderText* renderTextObject = toRenderText(m_renderer);
1135         if (renderTextObject->isTextFragment())
1136             return String(static_cast<RenderTextFragment*>(m_renderer)->contentString());
1137     }
1138
1139     // return the null string for anonymous text because it is non-trivial to get
1140     // the actual text and, so far, that is not needed
1141     return String();
1142 }
1143
1144 Node* AccessibilityRenderObject::node() const
1145 {
1146     return m_renderer ? m_renderer->node() : 0;
1147 }
1148
1149 AccessibilityButtonState AccessibilityRenderObject::checkboxOrRadioValue() const
1150 {
1151     if (isNativeCheckboxOrRadio())
1152         return isChecked() ? ButtonStateOn : ButtonStateOff;
1153
1154     return AccessibilityObject::checkboxOrRadioValue();
1155 }
1156
1157 String AccessibilityRenderObject::valueDescription() const
1158 {
1159     // Only sliders and progress bars support value descriptions currently.
1160     if (!isProgressIndicator() && !isSlider())
1161         return String();
1162
1163     return getAttribute(aria_valuetextAttr).string();
1164 }
1165
1166 float AccessibilityRenderObject::stepValueForRange() const
1167 {
1168     return getAttribute(stepAttr).toFloat();
1169 }
1170
1171 float AccessibilityRenderObject::valueForRange() const
1172 {
1173     if (!isProgressIndicator() && !isSlider() && !isScrollbar())
1174         return 0.0f;
1175
1176     return getAttribute(aria_valuenowAttr).toFloat();
1177 }
1178
1179 float AccessibilityRenderObject::maxValueForRange() const
1180 {
1181     if (!isProgressIndicator() && !isSlider())
1182         return 0.0f;
1183
1184     return getAttribute(aria_valuemaxAttr).toFloat();
1185 }
1186
1187 float AccessibilityRenderObject::minValueForRange() const
1188 {
1189     if (!isProgressIndicator() && !isSlider())
1190         return 0.0f;
1191
1192     return getAttribute(aria_valueminAttr).toFloat();
1193 }
1194
1195 String AccessibilityRenderObject::stringValue() const
1196 {
1197     if (!m_renderer || isPasswordField())
1198         return String();
1199
1200     RenderBoxModelObject* cssBox = renderBoxModelObject();
1201
1202     if (ariaRoleAttribute() == StaticTextRole) {
1203         String staticText = text();
1204         if (!staticText.length())
1205             staticText = textUnderElement();
1206         return staticText;
1207     }
1208
1209     if (m_renderer->isText())
1210         return textUnderElement();
1211
1212     if (cssBox && cssBox->isMenuList()) {
1213         // RenderMenuList will go straight to the text() of its selected item.
1214         // This has to be overridden in the case where the selected item has an ARIA label.
1215         HTMLSelectElement* selectElement = toHTMLSelectElement(m_renderer->node());
1216         int selectedIndex = selectElement->selectedIndex();
1217         const Vector<HTMLElement*> listItems = selectElement->listItems();
1218         if (selectedIndex >= 0 && static_cast<size_t>(selectedIndex) < listItems.size()) {
1219             const AtomicString& overriddenDescription = listItems[selectedIndex]->fastGetAttribute(aria_labelAttr);
1220             if (!overriddenDescription.isNull())
1221                 return overriddenDescription;
1222         }
1223         return toRenderMenuList(m_renderer)->text();
1224     }
1225
1226     if (m_renderer->isListMarker())
1227         return toRenderListMarker(m_renderer)->text();
1228
1229     if (isWebArea()) {
1230         // FIXME: Why would a renderer exist when the Document isn't attached to a frame?
1231         if (m_renderer->frame())
1232             return String();
1233
1234         ASSERT_NOT_REACHED();
1235     }
1236
1237     if (isTextControl())
1238         return text();
1239
1240     if (m_renderer->isFileUploadControl())
1241         return toRenderFileUploadControl(m_renderer)->fileTextValue();
1242
1243     // FIXME: We might need to implement a value here for more types
1244     // FIXME: It would be better not to advertise a value at all for the types for which we don't implement one;
1245     // this would require subclassing or making accessibilityAttributeNames do something other than return a
1246     // single static array.
1247     return String();
1248 }
1249
1250 // This function implements the ARIA accessible name as described by the Mozilla
1251 // ARIA Implementer's Guide.
1252 static String accessibleNameForNode(Node* node)
1253 {
1254     if (node->isTextNode())
1255         return toText(node)->data();
1256
1257     if (node->hasTagName(inputTag))
1258         return static_cast<HTMLInputElement*>(node)->value();
1259
1260     if (node->isHTMLElement()) {
1261         const AtomicString& alt = toHTMLElement(node)->getAttribute(altAttr);
1262         if (!alt.isEmpty())
1263             return alt;
1264     }
1265
1266     return String();
1267 }
1268
1269 String AccessibilityRenderObject::accessibilityDescriptionForElements(Vector<Element*> &elements) const
1270 {
1271     StringBuilder builder;
1272     unsigned size = elements.size();
1273     for (unsigned i = 0; i < size; ++i) {
1274         Element* idElement = elements[i];
1275
1276         builder.append(accessibleNameForNode(idElement));
1277         for (Node* n = idElement->firstChild(); n; n = n->traverseNextNode(idElement))
1278             builder.append(accessibleNameForNode(n));
1279
1280         if (i != size - 1)
1281             builder.append(' ');
1282     }
1283     return builder.toString();
1284 }
1285
1286 void AccessibilityRenderObject::elementsFromAttribute(Vector<Element*>& elements, const QualifiedName& attribute) const
1287 {
1288     Node* node = m_renderer->node();
1289     if (!node || !node->isElementNode())
1290         return;
1291
1292     TreeScope* scope = node->treeScope();
1293     if (!scope)
1294         return;
1295
1296     String idList = getAttribute(attribute).string();
1297     if (idList.isEmpty())
1298         return;
1299
1300     idList.replace('\n', ' ');
1301     Vector<String> idVector;
1302     idList.split(' ', idVector);
1303
1304     unsigned size = idVector.size();
1305     for (unsigned i = 0; i < size; ++i) {
1306         AtomicString idName(idVector[i]);
1307         Element* idElement = scope->getElementById(idName);
1308         if (idElement)
1309             elements.append(idElement);
1310     }
1311 }
1312
1313 void AccessibilityRenderObject::ariaLabeledByElements(Vector<Element*>& elements) const
1314 {
1315     elementsFromAttribute(elements, aria_labeledbyAttr);
1316     if (!elements.size())
1317         elementsFromAttribute(elements, aria_labelledbyAttr);
1318 }
1319
1320 String AccessibilityRenderObject::ariaLabeledByAttribute() const
1321 {
1322     Vector<Element*> elements;
1323     ariaLabeledByElements(elements);
1324
1325     return accessibilityDescriptionForElements(elements);
1326 }
1327
1328 static HTMLLabelElement* labelForElement(Element* element)
1329 {
1330     RefPtr<NodeList> list = element->document()->getElementsByTagName("label");
1331     unsigned len = list->length();
1332     for (unsigned i = 0; i < len; i++) {
1333         if (list->item(i)->hasTagName(labelTag)) {
1334             HTMLLabelElement* label = static_cast<HTMLLabelElement*>(list->item(i));
1335             if (label->control() == element)
1336                 return label;
1337         }
1338     }
1339
1340     return 0;
1341 }
1342
1343 HTMLLabelElement* AccessibilityRenderObject::labelElementContainer() const
1344 {
1345     if (!m_renderer)
1346         return 0;
1347
1348     // the control element should not be considered part of the label
1349     if (isControl())
1350         return 0;
1351
1352     // find if this has a parent that is a label
1353     for (Node* parentNode = m_renderer->node(); parentNode; parentNode = parentNode->parentNode()) {
1354         if (parentNode->hasTagName(labelTag))
1355             return static_cast<HTMLLabelElement*>(parentNode);
1356     }
1357
1358     return 0;
1359 }
1360
1361 String AccessibilityRenderObject::title() const
1362 {
1363     AccessibilityRole role = roleValue();
1364
1365     if (!m_renderer)
1366         return String();
1367
1368     Node* node = m_renderer->node();
1369     if (!node)
1370         return String();
1371
1372     bool isInputTag = node->hasTagName(inputTag);
1373     if (isInputTag) {
1374         HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
1375         if (input->isTextButton())
1376             return input->valueWithDefault();
1377     }
1378
1379     if (isInputTag || AccessibilityObject::isARIAInput(ariaRoleAttribute()) || isControl()) {
1380         HTMLLabelElement* label = labelForElement(static_cast<Element*>(node));
1381         if (label && !exposesTitleUIElement())
1382             return label->innerText();
1383     }
1384
1385     switch (role) {
1386     case ButtonRole:
1387     case ListBoxOptionRole:
1388     case MenuItemRole:
1389     case MenuButtonRole:
1390     case RadioButtonRole:
1391     case CheckBoxRole:
1392     case TabRole:
1393     case PopUpButtonRole:
1394         return textUnderElement();
1395     default:
1396         break;
1397     }
1398
1399     if (isHeading() || isLink())
1400         return textUnderElement();
1401
1402     return String();
1403 }
1404
1405 String AccessibilityRenderObject::ariaDescribedByAttribute() const
1406 {
1407     Vector<Element*> elements;
1408     elementsFromAttribute(elements, aria_describedbyAttr);
1409
1410     return accessibilityDescriptionForElements(elements);
1411 }
1412
1413 String AccessibilityRenderObject::ariaAccessibilityDescription() const
1414 {
1415     String ariaLabeledBy = ariaLabeledByAttribute();
1416     if (!ariaLabeledBy.isEmpty())
1417         return ariaLabeledBy;
1418
1419     const AtomicString& ariaLabel = getAttribute(aria_labelAttr);
1420     if (!ariaLabel.isEmpty())
1421         return ariaLabel;
1422
1423     return String();
1424 }
1425
1426 String AccessibilityRenderObject::webAreaAccessibilityDescription() const
1427 {
1428     // The WebArea description should follow this order:
1429     //     aria-label on the <html>
1430     //     title on the <html>
1431     //     <title> inside the <head> (of it was set through JS)
1432     //     name on the <html>
1433     // For iframes:
1434     //     aria-label on the <iframe>
1435     //     title on the <iframe>
1436     //     name on the <iframe>
1437
1438     if (!m_renderer)
1439         return String();
1440
1441     Document* document = m_renderer->document();
1442
1443     // Check if the HTML element has an aria-label for the webpage.
1444     if (Element* documentElement = document->documentElement()) {
1445         const AtomicString& ariaLabel = documentElement->getAttribute(aria_labelAttr);
1446         if (!ariaLabel.isEmpty())
1447             return ariaLabel;
1448     }
1449
1450     Node* owner = document->ownerElement();
1451     if (owner) {
1452         if (owner->hasTagName(frameTag) || owner->hasTagName(iframeTag)) {
1453             const AtomicString& title = static_cast<HTMLFrameElementBase*>(owner)->getAttribute(titleAttr);
1454             if (!title.isEmpty())
1455                 return title;
1456             return static_cast<HTMLFrameElementBase*>(owner)->getNameAttribute();
1457         }
1458         if (owner->isHTMLElement())
1459             return toHTMLElement(owner)->getNameAttribute();
1460     }
1461
1462     String documentTitle = document->title();
1463     if (!documentTitle.isEmpty())
1464         return documentTitle;
1465
1466     owner = document->body();
1467     if (owner && owner->isHTMLElement())
1468         return toHTMLElement(owner)->getNameAttribute();
1469
1470     return String();
1471 }
1472
1473 String AccessibilityRenderObject::accessibilityDescription() const
1474 {
1475     if (!m_renderer)
1476         return String();
1477
1478     // Static text should not have a description, it should only have a stringValue.
1479     if (roleValue() == StaticTextRole)
1480         return String();
1481
1482     String ariaDescription = ariaAccessibilityDescription();
1483     if (!ariaDescription.isEmpty())
1484         return ariaDescription;
1485
1486     Node* node = m_renderer->node();
1487     if (isImage() || isInputImage() || isNativeImage()) {
1488         if (node && node->isHTMLElement()) {
1489             const AtomicString& alt = toHTMLElement(node)->getAttribute(altAttr);
1490             if (alt.isEmpty())
1491                 return String();
1492             return alt;
1493         }
1494     }
1495
1496 #if ENABLE(MATHML)
1497     if (node && node->isElementNode() && static_cast<Element*>(node)->isMathMLElement())
1498         return getAttribute(MathMLNames::alttextAttr);
1499 #endif
1500
1501     if (isWebArea())
1502         return webAreaAccessibilityDescription();
1503
1504     // An element's descriptive text is comprised of title() (what's visible on the screen) and accessibilityDescription() (other descriptive text).
1505     // Both are used to generate what a screen reader speaks.
1506     // If this point is reached (i.e. there's no accessibilityDescription) and there's no title(), we should fallback to using the title attribute.
1507     // The title attribute is normally used as help text (because it is a tooltip), but if there is nothing else available, this should be used (according to ARIA).
1508     if (title().isEmpty())
1509         return getAttribute(titleAttr);
1510
1511     return String();
1512 }
1513
1514 LayoutRect AccessibilityRenderObject::boundingBoxRect() const
1515 {
1516     RenderObject* obj = m_renderer;
1517
1518     if (!obj)
1519         return LayoutRect();
1520
1521     if (obj->node()) // If we are a continuation, we want to make sure to use the primary renderer.
1522         obj = obj->node()->renderer();
1523
1524     // absoluteFocusRingQuads will query the hierarchy below this element, which for large webpages can be very slow.
1525     // For a web area, which will have the most elements of any element, absoluteQuads should be used.
1526     Vector<FloatQuad> quads;
1527     if (obj->isText())
1528         toRenderText(obj)->absoluteQuads(quads, 0, RenderText::ClipToEllipsis);
1529     else if (isWebArea())
1530         obj->absoluteQuads(quads);
1531     else
1532         obj->absoluteFocusRingQuads(quads);
1533
1534     LayoutRect result = boundingBoxForQuads(obj, quads);
1535
1536     // The size of the web area should be the content size, not the clipped size.
1537     if (isWebArea() && obj->frame()->view())
1538         result.setSize(obj->frame()->view()->contentsSize());
1539
1540     return result;
1541 }
1542
1543 LayoutRect AccessibilityRenderObject::checkboxOrRadioRect() const
1544 {
1545     if (!m_renderer)
1546         return LayoutRect();
1547
1548     HTMLLabelElement* label = labelForElement(static_cast<Element*>(m_renderer->node()));
1549     if (!label || !label->renderer())
1550         return boundingBoxRect();
1551
1552     LayoutRect labelRect = axObjectCache()->getOrCreate(label->renderer())->elementRect();
1553     labelRect.unite(boundingBoxRect());
1554     return labelRect;
1555 }
1556
1557 LayoutRect AccessibilityRenderObject::elementRect() const
1558 {
1559     // a checkbox or radio button should encompass its label
1560     if (isCheckboxOrRadio())
1561         return checkboxOrRadioRect();
1562
1563     return boundingBoxRect();
1564 }
1565
1566 IntPoint AccessibilityRenderObject::clickPoint()
1567 {
1568     // Headings are usually much wider than their textual content. If the mid point is used, often it can be wrong.
1569     if (isHeading() && children().size() == 1)
1570         return children()[0]->clickPoint();
1571
1572     // use the default position unless this is an editable web area, in which case we use the selection bounds.
1573     if (!isWebArea() || isReadOnly())
1574         return AccessibilityObject::clickPoint();
1575
1576     VisibleSelection visSelection = selection();
1577     VisiblePositionRange range = VisiblePositionRange(visSelection.visibleStart(), visSelection.visibleEnd());
1578     IntRect bounds = boundsForVisiblePositionRange(range);
1579 #if PLATFORM(MAC)
1580     bounds.setLocation(m_renderer->document()->view()->screenToContents(bounds.location()));
1581 #endif
1582     return IntPoint(bounds.x() + (bounds.width() / 2), bounds.y() - (bounds.height() / 2));
1583 }
1584
1585 AccessibilityObject* AccessibilityRenderObject::internalLinkElement() const
1586 {
1587     Element* element = anchorElement();
1588     if (!element)
1589         return 0;
1590
1591     // Right now, we do not support ARIA links as internal link elements
1592     if (!element->hasTagName(aTag))
1593         return 0;
1594     HTMLAnchorElement* anchor = static_cast<HTMLAnchorElement*>(element);
1595
1596     KURL linkURL = anchor->href();
1597     String fragmentIdentifier = linkURL.fragmentIdentifier();
1598     if (fragmentIdentifier.isEmpty())
1599         return 0;
1600
1601     // check if URL is the same as current URL
1602     KURL documentURL = m_renderer->document()->url();
1603     if (!equalIgnoringFragmentIdentifier(documentURL, linkURL))
1604         return 0;
1605
1606     Node* linkedNode = m_renderer->document()->findAnchor(fragmentIdentifier);
1607     if (!linkedNode)
1608         return 0;
1609
1610     // The element we find may not be accessible, so find the first accessible object.
1611     return firstAccessibleObjectFromNode(linkedNode);
1612 }
1613
1614 ESpeak AccessibilityRenderObject::speakProperty() const
1615 {
1616     if (!m_renderer)
1617         return AccessibilityObject::speakProperty();
1618
1619     return m_renderer->style()->speak();
1620 }
1621
1622 void AccessibilityRenderObject::addRadioButtonGroupMembers(AccessibilityChildrenVector& linkedUIElements) const
1623 {
1624     if (!m_renderer || roleValue() != RadioButtonRole)
1625         return;
1626
1627     Node* node = m_renderer->node();
1628     if (!node || !node->hasTagName(inputTag))
1629         return;
1630
1631     HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
1632     // if there's a form, then this is easy
1633     if (input->form()) {
1634         Vector<RefPtr<Node> > formElements;
1635         input->form()->getNamedElements(input->name(), formElements);
1636
1637         unsigned len = formElements.size();
1638         for (unsigned i = 0; i < len; ++i) {
1639             Node* associateElement = formElements[i].get();
1640             if (AccessibilityObject* object = axObjectCache()->getOrCreate(associateElement->renderer()))
1641                 linkedUIElements.append(object);
1642         }
1643     } else {
1644         RefPtr<NodeList> list = node->document()->getElementsByTagName("input");
1645         unsigned len = list->length();
1646         for (unsigned i = 0; i < len; ++i) {
1647             if (list->item(i)->hasTagName(inputTag)) {
1648                 HTMLInputElement* associateElement = static_cast<HTMLInputElement*>(list->item(i));
1649                 if (associateElement->isRadioButton() && associateElement->name() == input->name()) {
1650                     if (AccessibilityObject* object = axObjectCache()->getOrCreate(associateElement->renderer()))
1651                         linkedUIElements.append(object);
1652                 }
1653             }
1654         }
1655     }
1656 }
1657
1658 // linked ui elements could be all the related radio buttons in a group
1659 // or an internal anchor connection
1660 void AccessibilityRenderObject::linkedUIElements(AccessibilityChildrenVector& linkedUIElements) const
1661 {
1662     ariaFlowToElements(linkedUIElements);
1663
1664     if (isAnchor()) {
1665         AccessibilityObject* linkedAXElement = internalLinkElement();
1666         if (linkedAXElement)
1667             linkedUIElements.append(linkedAXElement);
1668     }
1669
1670     if (roleValue() == RadioButtonRole)
1671         addRadioButtonGroupMembers(linkedUIElements);
1672 }
1673
1674 bool AccessibilityRenderObject::hasTextAlternative() const
1675 {
1676     // ARIA: section 2A, bullet #3 says if aria-labeledby or aria-label appears, it should
1677     // override the "label" element association.
1678     if (!ariaLabeledByAttribute().isEmpty() || !getAttribute(aria_labelAttr).isEmpty())
1679         return true;
1680
1681     return false;
1682 }
1683
1684 bool AccessibilityRenderObject::ariaHasPopup() const
1685 {
1686     return elementAttributeValue(aria_haspopupAttr);
1687 }
1688
1689 bool AccessibilityRenderObject::supportsARIAFlowTo() const
1690 {
1691     return !getAttribute(aria_flowtoAttr).isEmpty();
1692 }
1693
1694 void AccessibilityRenderObject::ariaFlowToElements(AccessibilityChildrenVector& flowTo) const
1695 {
1696     Vector<Element*> elements;
1697     elementsFromAttribute(elements, aria_flowtoAttr);
1698
1699     AXObjectCache* cache = axObjectCache();
1700     unsigned count = elements.size();
1701     for (unsigned k = 0; k < count; ++k) {
1702         Element* element = elements[k];
1703         AccessibilityObject* flowToElement = cache->getOrCreate(element->renderer());
1704         if (flowToElement)
1705             flowTo.append(flowToElement);
1706     }
1707
1708 }
1709
1710 bool AccessibilityRenderObject::supportsARIADropping() const
1711 {
1712     const AtomicString& dropEffect = getAttribute(aria_dropeffectAttr);
1713     return !dropEffect.isEmpty();
1714 }
1715
1716 bool AccessibilityRenderObject::supportsARIADragging() const
1717 {
1718     const AtomicString& grabbed = getAttribute(aria_grabbedAttr);
1719     return equalIgnoringCase(grabbed, "true") || equalIgnoringCase(grabbed, "false");
1720 }
1721
1722 bool AccessibilityRenderObject::isARIAGrabbed()
1723 {
1724     return elementAttributeValue(aria_grabbedAttr);
1725 }
1726
1727 void AccessibilityRenderObject::determineARIADropEffects(Vector<String>& effects)
1728 {
1729     const AtomicString& dropEffects = getAttribute(aria_dropeffectAttr);
1730     if (dropEffects.isEmpty()) {
1731         effects.clear();
1732         return;
1733     }
1734
1735     String dropEffectsString = dropEffects.string();
1736     dropEffectsString.replace('\n', ' ');
1737     dropEffectsString.split(' ', effects);
1738 }
1739
1740 bool AccessibilityRenderObject::exposesTitleUIElement() const
1741 {
1742     if (!isControl())
1743         return false;
1744
1745     // If this control is ignored (because it's invisible),
1746     // then the label needs to be exposed so it can be visible to accessibility.
1747     if (accessibilityIsIgnored())
1748         return true;
1749
1750     // Checkboxes and radio buttons use the text of their title ui element as their own AXTitle.
1751     // This code controls whether the title ui element should appear in the AX tree (usually, no).
1752     // It should appear if the control already has a label (which will be used as the AXTitle instead).
1753     if (isCheckboxOrRadio())
1754         return hasTextAlternative();
1755
1756     // When controls have their own descriptions, the title element should be ignored.
1757     if (hasTextAlternative())
1758         return false;
1759
1760     return true;
1761 }
1762
1763 AccessibilityObject* AccessibilityRenderObject::titleUIElement() const
1764 {
1765     if (!m_renderer)
1766         return 0;
1767
1768     // if isFieldset is true, the renderer is guaranteed to be a RenderFieldset
1769     if (isFieldset())
1770         return axObjectCache()->getOrCreate(toRenderFieldset(m_renderer)->findLegend());
1771
1772     Node* element = m_renderer->node();
1773     if (!element)
1774         return 0;
1775     HTMLLabelElement* label = labelForElement(static_cast<Element*>(element));
1776     if (label && label->renderer())
1777         return axObjectCache()->getOrCreate(label->renderer());
1778
1779     return 0;
1780 }
1781
1782 bool AccessibilityRenderObject::ariaIsHidden() const
1783 {
1784     if (equalIgnoringCase(getAttribute(aria_hiddenAttr), "true"))
1785         return true;
1786
1787     // aria-hidden hides this object and any children
1788     AccessibilityObject* object = parentObject();
1789     while (object) {
1790         if (equalIgnoringCase(object->getAttribute(aria_hiddenAttr), "true"))
1791             return true;
1792         object = object->parentObject();
1793     }
1794
1795     return false;
1796 }
1797
1798 bool AccessibilityRenderObject::isDescendantOfBarrenParent() const
1799 {
1800     for (AccessibilityObject* object = parentObject(); object; object = object->parentObject()) {
1801         if (!object->canHaveChildren())
1802             return true;
1803     }
1804
1805     return false;
1806 }
1807
1808 bool AccessibilityRenderObject::isAllowedChildOfTree() const
1809 {
1810     // Determine if this is in a tree. If so, we apply special behavior to make it work like an AXOutline.
1811     AccessibilityObject* axObj = parentObject();
1812     bool isInTree = false;
1813     while (axObj) {
1814         if (axObj->isTree()) {
1815             isInTree = true;
1816             break;
1817         }
1818         axObj = axObj->parentObject();
1819     }
1820
1821     // If the object is in a tree, only tree items should be exposed (and the children of tree items).
1822     if (isInTree) {
1823         AccessibilityRole role = roleValue();
1824         if (role != TreeItemRole && role != StaticTextRole)
1825             return false;
1826     }
1827     return true;
1828 }
1829
1830 AccessibilityObjectInclusion AccessibilityRenderObject::accessibilityIsIgnoredBase() const
1831 {
1832     // The following cases can apply to any element that's a subclass of AccessibilityRenderObject.
1833
1834     // Ignore invisible elements.
1835     if (!m_renderer || m_renderer->style()->visibility() != VISIBLE)
1836         return IgnoreObject;
1837
1838     // Anything marked as aria-hidden or a child of something aria-hidden must be hidden.
1839     if (ariaIsHidden())
1840         return IgnoreObject;
1841
1842     // Anything that is a presentational role must be hidden.
1843     if (isPresentationalChildOfAriaRole())
1844         return IgnoreObject;
1845
1846     // Allow the platform to make a decision.
1847     AccessibilityObjectInclusion decision = accessibilityPlatformIncludesObject();
1848     if (decision == IncludeObject)
1849         return IncludeObject;
1850     if (decision == IgnoreObject)
1851         return IgnoreObject;
1852
1853     return DefaultBehavior;
1854 }
1855
1856 bool AccessibilityRenderObject::accessibilityIsIgnored() const
1857 {
1858     // Check first if any of the common reasons cause this element to be ignored.
1859     // Then process other use cases that need to be applied to all the various roles
1860     // that AccessibilityRenderObjects take on.
1861     AccessibilityObjectInclusion decision = accessibilityIsIgnoredBase();
1862     if (decision == IncludeObject)
1863         return false;
1864     if (decision == IgnoreObject)
1865         return true;
1866
1867     // If this element is within a parent that cannot have children, it should not be exposed.
1868     if (isDescendantOfBarrenParent())
1869         return true;
1870
1871     if (roleValue() == IgnoredRole)
1872         return true;
1873
1874     if (roleValue() == PresentationalRole || inheritsPresentationalRole())
1875         return true;
1876
1877     // An ARIA tree can only have tree items and static text as children.
1878     if (!isAllowedChildOfTree())
1879         return true;
1880
1881     // Allow the platform to decide if the attachment is ignored or not.
1882     if (isAttachment())
1883         return accessibilityIgnoreAttachment();
1884
1885     // ignore popup menu items because AppKit does
1886     for (RenderObject* parent = m_renderer->parent(); parent; parent = parent->parent()) {
1887         if (parent->isBoxModelObject() && toRenderBoxModelObject(parent)->isMenuList())
1888             return true;
1889     }
1890
1891     // find out if this element is inside of a label element.
1892     // if so, it may be ignored because it's the label for a checkbox or radio button
1893     AccessibilityObject* controlObject = correspondingControlForLabelElement();
1894     if (controlObject && !controlObject->exposesTitleUIElement() && controlObject->isCheckboxOrRadio())
1895         return true;
1896
1897     // NOTE: BRs always have text boxes now, so the text box check here can be removed
1898     if (m_renderer->isText()) {
1899         // static text beneath MenuItems and MenuButtons are just reported along with the menu item, so it's ignored on an individual level
1900         if (parentObjectUnignored()->ariaRoleAttribute() == MenuItemRole
1901             || parentObjectUnignored()->ariaRoleAttribute() == MenuButtonRole)
1902             return true;
1903         RenderText* renderText = toRenderText(m_renderer);
1904         if (m_renderer->isBR() || !renderText->firstTextBox())
1905             return true;
1906
1907         // static text beneath TextControls is reported along with the text control text so it's ignored.
1908         for (AccessibilityObject* parent = parentObject(); parent; parent = parent->parentObject()) {
1909             if (parent->roleValue() == TextFieldRole)
1910                 return true;
1911         }
1912
1913         // text elements that are just empty whitespace should not be returned
1914         return renderText->text()->containsOnlyWhitespace();
1915     }
1916
1917     if (isHeading())
1918         return false;
1919
1920     if (isLink())
1921         return false;
1922
1923     // all controls are accessible
1924     if (isControl())
1925         return false;
1926
1927     if (ariaRoleAttribute() != UnknownRole)
1928         return false;
1929
1930     // don't ignore labels, because they serve as TitleUIElements
1931     Node* node = m_renderer->node();
1932     if (node && node->hasTagName(labelTag))
1933         return false;
1934
1935     // Anything that is content editable should not be ignored.
1936     // However, one cannot just call node->rendererIsEditable() since that will ask if its parents
1937     // are also editable. Only the top level content editable region should be exposed.
1938     if (node && node->isElementNode()) {
1939         Element* element = static_cast<Element*>(node);
1940         const AtomicString& contentEditable = element->getAttribute(contenteditableAttr);
1941         if (equalIgnoringCase(contentEditable, "true"))
1942             return false;
1943     }
1944
1945     // List items play an important role in defining the structure of lists. They should not be ignored.
1946     if (roleValue() == ListItemRole)
1947         return false;
1948
1949     // if this element has aria attributes on it, it should not be ignored.
1950     if (supportsARIAAttributes())
1951         return false;
1952
1953     if (m_renderer->isBlockFlow() && m_renderer->childrenInline())
1954         return !toRenderBlock(m_renderer)->firstLineBox() && !mouseButtonListener();
1955
1956     // ignore images seemingly used as spacers
1957     if (isImage()) {
1958
1959         // If the image can take focus, it should not be ignored, lest the user not be able to interact with something important.
1960         if (canSetFocusAttribute())
1961             return false;
1962
1963         if (node && node->isElementNode()) {
1964             Element* elt = static_cast<Element*>(node);
1965             const AtomicString& alt = elt->getAttribute(altAttr);
1966             // don't ignore an image that has an alt tag
1967             if (!alt.string().containsOnlyWhitespace())
1968                 return false;
1969             // informal standard is to ignore images with zero-length alt strings
1970             if (!alt.isNull())
1971                 return true;
1972         }
1973
1974         if (node && node->hasTagName(canvasTag)) {
1975             RenderHTMLCanvas* canvas = toRenderHTMLCanvas(m_renderer);
1976             if (canvas->height() <= 1 || canvas->width() <= 1)
1977                 return true;
1978             return false;
1979         }
1980
1981         if (isNativeImage()) {
1982             // check for one-dimensional image
1983             RenderImage* image = toRenderImage(m_renderer);
1984             if (image->height() <= 1 || image->width() <= 1)
1985                 return true;
1986
1987             // check whether rendered image was stretched from one-dimensional file image
1988             if (image->cachedImage()) {
1989                 LayoutSize imageSize = image->cachedImage()->imageSizeForRenderer(m_renderer, image->view()->zoomFactor());
1990                 return imageSize.height() <= 1 || imageSize.width() <= 1;
1991             }
1992         }
1993         return false;
1994     }
1995
1996     if (isWebArea() || m_renderer->isListMarker())
1997         return false;
1998
1999     // Using the help text to decide an element's visibility is not as definitive
2000     // as previous checks, so this should remain as one of the last.
2001     if (!helpText().isEmpty())
2002         return false;
2003
2004     // By default, objects should be ignored so that the AX hierarchy is not
2005     // filled with unnecessary items.
2006     return true;
2007 }
2008
2009 bool AccessibilityRenderObject::isLoaded() const
2010 {
2011     return !m_renderer->document()->parser();
2012 }
2013
2014 double AccessibilityRenderObject::estimatedLoadingProgress() const
2015 {
2016     if (!m_renderer)
2017         return 0;
2018
2019     if (isLoaded())
2020         return 1.0;
2021
2022     Page* page = m_renderer->document()->page();
2023     if (!page)
2024         return 0;
2025
2026     return page->progress()->estimatedProgress();
2027 }
2028
2029 int AccessibilityRenderObject::layoutCount() const
2030 {
2031     if (!m_renderer->isRenderView())
2032         return 0;
2033     return toRenderView(m_renderer)->frameView()->layoutCount();
2034 }
2035
2036 String AccessibilityRenderObject::text() const
2037 {
2038     // If this is a user defined static text, use the accessible name computation.
2039     if (ariaRoleAttribute() == StaticTextRole)
2040         return ariaAccessibilityDescription();
2041
2042     if (!isTextControl() || isPasswordField())
2043         return String();
2044
2045     Node* node = m_renderer->node();
2046     if (!node)
2047         return String();
2048
2049     if (isNativeTextControl())
2050         return toRenderTextControl(m_renderer)->textFormControlElement()->value();
2051
2052     if (!node->isElementNode())
2053         return String();
2054
2055     return static_cast<Element*>(node)->innerText();
2056 }
2057
2058 int AccessibilityRenderObject::textLength() const
2059 {
2060     ASSERT(isTextControl());
2061
2062     if (isPasswordField())
2063         return -1; // need to return something distinct from 0
2064
2065     return text().length();
2066 }
2067
2068 PlainTextRange AccessibilityRenderObject::ariaSelectedTextRange() const
2069 {
2070     Node* node = m_renderer->node();
2071     if (!node)
2072         return PlainTextRange();
2073
2074     ExceptionCode ec = 0;
2075     VisibleSelection visibleSelection = selection();
2076     RefPtr<Range> currentSelectionRange = visibleSelection.toNormalizedRange();
2077     if (!currentSelectionRange || !currentSelectionRange->intersectsNode(node, ec))
2078         return PlainTextRange();
2079
2080     int start = indexForVisiblePosition(visibleSelection.start());
2081     int end = indexForVisiblePosition(visibleSelection.end());
2082
2083     return PlainTextRange(start, end - start);
2084 }
2085
2086 String AccessibilityRenderObject::selectedText() const
2087 {
2088     ASSERT(isTextControl());
2089
2090     if (isPasswordField())
2091         return String(); // need to return something distinct from empty string
2092
2093     if (isNativeTextControl()) {
2094         HTMLTextFormControlElement* textControl = toRenderTextControl(m_renderer)->textFormControlElement();
2095         return textControl->selectedText();
2096     }
2097
2098     if (ariaRoleAttribute() == UnknownRole)
2099         return String();
2100
2101     return doAXStringForRange(ariaSelectedTextRange());
2102 }
2103
2104 const AtomicString& AccessibilityRenderObject::accessKey() const
2105 {
2106     Node* node = m_renderer->node();
2107     if (!node)
2108         return nullAtom;
2109     if (!node->isElementNode())
2110         return nullAtom;
2111     return static_cast<Element*>(node)->getAttribute(accesskeyAttr);
2112 }
2113
2114 VisibleSelection AccessibilityRenderObject::selection() const
2115 {
2116     return m_renderer->frame()->selection()->selection();
2117 }
2118
2119 PlainTextRange AccessibilityRenderObject::selectedTextRange() const
2120 {
2121     ASSERT(isTextControl());
2122
2123     if (isPasswordField())
2124         return PlainTextRange();
2125
2126     AccessibilityRole ariaRole = ariaRoleAttribute();
2127     if (isNativeTextControl() && ariaRole == UnknownRole) {
2128         HTMLTextFormControlElement* textControl = toRenderTextControl(m_renderer)->textFormControlElement();
2129         return PlainTextRange(textControl->selectionStart(), textControl->selectionEnd() - textControl->selectionStart());
2130     }
2131
2132     if (ariaRole == UnknownRole)
2133         return PlainTextRange();
2134
2135     return ariaSelectedTextRange();
2136 }
2137
2138 void AccessibilityRenderObject::setSelectedTextRange(const PlainTextRange& range)
2139 {
2140     if (isNativeTextControl()) {
2141         HTMLTextFormControlElement* textControl = toRenderTextControl(m_renderer)->textFormControlElement();
2142         textControl->setSelectionRange(range.start, range.start + range.length);
2143         return;
2144     }
2145
2146     Document* document = m_renderer->document();
2147     if (!document)
2148         return;
2149     Frame* frame = document->frame();
2150     if (!frame)
2151         return;
2152     Node* node = m_renderer->node();
2153     frame->selection()->setSelection(VisibleSelection(Position(node, range.start, Position::PositionIsOffsetInAnchor),
2154         Position(node, range.start + range.length, Position::PositionIsOffsetInAnchor), DOWNSTREAM));
2155 }
2156
2157 KURL AccessibilityRenderObject::url() const
2158 {
2159     if (isAnchor() && m_renderer->node()->hasTagName(aTag)) {
2160         if (HTMLAnchorElement* anchor = static_cast<HTMLAnchorElement*>(anchorElement()))
2161             return anchor->href();
2162     }
2163
2164     if (isWebArea())
2165         return m_renderer->document()->url();
2166
2167     if (isImage() && m_renderer->node() && m_renderer->node()->hasTagName(imgTag))
2168         return static_cast<HTMLImageElement*>(m_renderer->node())->src();
2169
2170     if (isInputImage())
2171         return static_cast<HTMLInputElement*>(m_renderer->node())->src();
2172
2173     return KURL();
2174 }
2175
2176 bool AccessibilityRenderObject::isUnvisited() const
2177 {
2178     // FIXME: Is it a privacy violation to expose unvisited information to accessibility APIs?
2179     return m_renderer->style()->isLink() && m_renderer->style()->insideLink() == InsideUnvisitedLink;
2180 }
2181
2182 bool AccessibilityRenderObject::isVisited() const
2183 {
2184     // FIXME: Is it a privacy violation to expose visited information to accessibility APIs?
2185     return m_renderer->style()->isLink() && m_renderer->style()->insideLink() == InsideVisitedLink;
2186 }
2187
2188 void AccessibilityRenderObject::setElementAttributeValue(const QualifiedName& attributeName, bool value)
2189 {
2190     if (!m_renderer)
2191         return;
2192
2193     Node* node = m_renderer->node();
2194     if (!node || !node->isElementNode())
2195         return;
2196
2197     Element* element = static_cast<Element*>(node);
2198     element->setAttribute(attributeName, (value) ? "true" : "false");
2199 }
2200
2201 bool AccessibilityRenderObject::elementAttributeValue(const QualifiedName& attributeName) const
2202 {
2203     if (!m_renderer)
2204         return false;
2205
2206     return equalIgnoringCase(getAttribute(attributeName), "true");
2207 }
2208
2209 bool AccessibilityRenderObject::isRequired() const
2210 {
2211     if (equalIgnoringCase(getAttribute(aria_requiredAttr), "true"))
2212         return true;
2213
2214     Node* n = node();
2215     if (n && (n->isElementNode() && static_cast<Element*>(n)->isFormControlElement()))
2216         return static_cast<HTMLFormControlElement*>(n)->required();
2217
2218     return false;
2219 }
2220
2221 bool AccessibilityRenderObject::isSelected() const
2222 {
2223     if (!m_renderer)
2224         return false;
2225
2226     Node* node = m_renderer->node();
2227     if (!node)
2228         return false;
2229
2230     const AtomicString& ariaSelected = getAttribute(aria_selectedAttr);
2231     if (equalIgnoringCase(ariaSelected, "true"))
2232         return true;
2233
2234     if (isTabItem() && isTabItemSelected())
2235         return true;
2236
2237     return false;
2238 }
2239
2240 bool AccessibilityRenderObject::isTabItemSelected() const
2241 {
2242     if (!isTabItem() || !m_renderer)
2243         return false;
2244
2245     Node* node = m_renderer->node();
2246     if (!node || !node->isElementNode())
2247         return false;
2248
2249     // The ARIA spec says a tab item can also be selected if it is aria-labeled by a tabpanel
2250     // that has keyboard focus inside of it, or if a tabpanel in its aria-controls list has KB
2251     // focus inside of it.
2252     AccessibilityObject* focusedElement = focusedUIElement();
2253     if (!focusedElement)
2254         return false;
2255
2256     Vector<Element*> elements;
2257     elementsFromAttribute(elements, aria_controlsAttr);
2258
2259     unsigned count = elements.size();
2260     for (unsigned k = 0; k < count; ++k) {
2261         Element* element = elements[k];
2262         AccessibilityObject* tabPanel = axObjectCache()->getOrCreate(element->renderer());
2263
2264         // A tab item should only control tab panels.
2265         if (!tabPanel || tabPanel->roleValue() != TabPanelRole)
2266             continue;
2267
2268         AccessibilityObject* checkFocusElement = focusedElement;
2269         // Check if the focused element is a descendant of the element controlled by the tab item.
2270         while (checkFocusElement) {
2271             if (tabPanel == checkFocusElement)
2272                 return true;
2273             checkFocusElement = checkFocusElement->parentObject();
2274         }
2275     }
2276
2277     return false;
2278 }
2279
2280 bool AccessibilityRenderObject::isFocused() const
2281 {
2282     if (!m_renderer)
2283         return false;
2284
2285     Document* document = m_renderer->document();
2286     if (!document)
2287         return false;
2288
2289     Node* focusedNode = document->focusedNode();
2290     if (!focusedNode)
2291         return false;
2292
2293     // A web area is represented by the Document node in the DOM tree, which isn't focusable.
2294     // Check instead if the frame's selection controller is focused
2295     if (focusedNode == m_renderer->node()
2296         || (roleValue() == WebAreaRole && document->frame()->selection()->isFocusedAndActive()))
2297         return true;
2298
2299     return false;
2300 }
2301
2302 void AccessibilityRenderObject::setFocused(bool on)
2303 {
2304     if (!canSetFocusAttribute())
2305         return;
2306
2307     if (!on)
2308         m_renderer->document()->setFocusedNode(0);
2309     else {
2310         if (m_renderer->node()->isElementNode())
2311             static_cast<Element*>(m_renderer->node())->focus();
2312         else
2313             m_renderer->document()->setFocusedNode(m_renderer->node());
2314     }
2315 }
2316
2317 void AccessibilityRenderObject::changeValueByStep(bool increase)
2318 {
2319     float step = stepValueForRange();
2320     float value = valueForRange();
2321
2322     value += increase ? step : -step;
2323
2324     setValue(String::number(value));
2325
2326     axObjectCache()->postNotification(m_renderer, AXObjectCache::AXValueChanged, true);
2327 }
2328
2329 void AccessibilityRenderObject::changeValueByPercent(float percentChange)
2330 {
2331     float range = maxValueForRange() - minValueForRange();
2332     float value = valueForRange();
2333
2334     value += range * (percentChange / 100);
2335     setValue(String::number(value));
2336
2337     axObjectCache()->postNotification(m_renderer, AXObjectCache::AXValueChanged, true);
2338 }
2339
2340 void AccessibilityRenderObject::setSelectedRows(AccessibilityChildrenVector& selectedRows)
2341 {
2342     // Setting selected only makes sense in trees and tables (and tree-tables).
2343     AccessibilityRole role = roleValue();
2344     if (role != TreeRole && role != TreeGridRole && role != TableRole)
2345         return;
2346
2347     bool isMulti = isMultiSelectable();
2348     unsigned count = selectedRows.size();
2349     if (count > 1 && !isMulti)
2350         count = 1;
2351
2352     for (unsigned k = 0; k < count; ++k)
2353         selectedRows[k]->setSelected(true);
2354 }
2355
2356 void AccessibilityRenderObject::setValue(const String& string)
2357 {
2358     if (!m_renderer || !m_renderer->node() || !m_renderer->node()->isElementNode())
2359         return;
2360     Element* element = static_cast<Element*>(m_renderer->node());
2361
2362     if (!m_renderer->isBoxModelObject())
2363         return;
2364     RenderBoxModelObject* renderer = toRenderBoxModelObject(m_renderer);
2365
2366     // FIXME: Do we want to do anything here for ARIA textboxes?
2367     if (renderer->isTextField()) {
2368         // FIXME: This is not safe!  Other elements could have a TextField renderer.
2369         static_cast<HTMLInputElement*>(element)->setValue(string);
2370     } else if (renderer->isTextArea()) {
2371         // FIXME: This is not safe!  Other elements could have a TextArea renderer.
2372         static_cast<HTMLTextAreaElement*>(element)->setValue(string);
2373     }
2374 }
2375
2376 void AccessibilityRenderObject::ariaOwnsElements(AccessibilityChildrenVector& axObjects) const
2377 {
2378     Vector<Element*> elements;
2379     elementsFromAttribute(elements, aria_ownsAttr);
2380
2381     unsigned count = elements.size();
2382     for (unsigned k = 0; k < count; ++k) {
2383         RenderObject* render = elements[k]->renderer();
2384         AccessibilityObject* obj = axObjectCache()->getOrCreate(render);
2385         if (obj)
2386             axObjects.append(obj);
2387     }
2388 }
2389
2390 bool AccessibilityRenderObject::supportsARIAOwns() const
2391 {
2392     if (!m_renderer)
2393         return false;
2394     const AtomicString& ariaOwns = getAttribute(aria_ownsAttr);
2395
2396     return !ariaOwns.isEmpty();
2397 }
2398
2399 bool AccessibilityRenderObject::isEnabled() const
2400 {
2401     ASSERT(m_renderer);
2402
2403     if (equalIgnoringCase(getAttribute(aria_disabledAttr), "true"))
2404         return false;
2405
2406     Node* node = m_renderer->node();
2407     if (!node || !node->isElementNode())
2408         return true;
2409
2410     return static_cast<Element*>(node)->isEnabledFormControl();
2411 }
2412
2413 RenderView* AccessibilityRenderObject::topRenderer() const
2414 {
2415     Document* topDoc = topDocument();
2416     if (!topDoc)
2417         return 0;
2418
2419     return topDoc->renderView();
2420 }
2421
2422 Document* AccessibilityRenderObject::document() const
2423 {
2424     if (!m_renderer)
2425         return 0;
2426     return m_renderer->document();
2427 }
2428
2429 Document* AccessibilityRenderObject::topDocument() const
2430 {
2431     if (!document())
2432         return 0;
2433     return document()->topDocument();
2434 }
2435
2436 FrameView* AccessibilityRenderObject::topDocumentFrameView() const
2437 {
2438     RenderView* renderView = topRenderer();
2439     if (!renderView || !renderView->view())
2440         return 0;
2441     return renderView->view()->frameView();
2442 }
2443
2444 Widget* AccessibilityRenderObject::widget() const
2445 {
2446     if (!m_renderer->isBoxModelObject() || !toRenderBoxModelObject(m_renderer)->isWidget())
2447         return 0;
2448     return toRenderWidget(m_renderer)->widget();
2449 }
2450
2451 AccessibilityObject* AccessibilityRenderObject::accessibilityParentForImageMap(HTMLMapElement* map) const
2452 {
2453     // find an image that is using this map
2454     if (!map)
2455         return 0;
2456
2457     HTMLImageElement* imageElement = map->imageElement();
2458     if (!imageElement)
2459         return 0;
2460
2461     return axObjectCache()->getOrCreate(imageElement->renderer());
2462 }
2463
2464 void AccessibilityRenderObject::getDocumentLinks(AccessibilityChildrenVector& result)
2465 {
2466     Document* document = m_renderer->document();
2467     RefPtr<HTMLCollection> links = document->links();
2468     for (unsigned i = 0; Node* curr = links->item(i); i++) {
2469         RenderObject* obj = curr->renderer();
2470         if (obj) {
2471             RefPtr<AccessibilityObject> axobj = document->axObjectCache()->getOrCreate(obj);
2472             ASSERT(axobj);
2473             if (!axobj->accessibilityIsIgnored() && axobj->isLink())
2474                 result.append(axobj);
2475         } else {
2476             Node* parent = curr->parentNode();
2477             if (parent && curr->hasTagName(areaTag) && parent->hasTagName(mapTag)) {
2478                 AccessibilityImageMapLink* areaObject = static_cast<AccessibilityImageMapLink*>(axObjectCache()->getOrCreate(ImageMapLinkRole));
2479                 areaObject->setHTMLAreaElement(static_cast<HTMLAreaElement*>(curr));
2480                 areaObject->setHTMLMapElement(static_cast<HTMLMapElement*>(parent));
2481                 areaObject->setParent(accessibilityParentForImageMap(static_cast<HTMLMapElement*>(parent)));
2482
2483                 result.append(areaObject);
2484             }
2485         }
2486     }
2487 }
2488
2489 FrameView* AccessibilityRenderObject::documentFrameView() const
2490 {
2491     if (!m_renderer || !m_renderer->document())
2492         return 0;
2493
2494     // this is the RenderObject's Document's Frame's FrameView
2495     return m_renderer->document()->view();
2496 }
2497
2498 Widget* AccessibilityRenderObject::widgetForAttachmentView() const
2499 {
2500     if (!isAttachment())
2501         return 0;
2502     return toRenderWidget(m_renderer)->widget();
2503 }
2504
2505 FrameView* AccessibilityRenderObject::frameViewIfRenderView() const
2506 {
2507     if (!m_renderer->isRenderView())
2508         return 0;
2509     // this is the RenderObject's Document's renderer's FrameView
2510     return m_renderer->view()->frameView();
2511 }
2512
2513 // This function is like a cross-platform version of - (WebCoreTextMarkerRange*)textMarkerRange. It returns
2514 // a Range that we can convert to a WebCoreTextMarkerRange in the Obj-C file
2515 VisiblePositionRange AccessibilityRenderObject::visiblePositionRange() const
2516 {
2517     if (!m_renderer)
2518         return VisiblePositionRange();
2519
2520     // construct VisiblePositions for start and end
2521     Node* node = m_renderer->node();
2522     if (!node)
2523         return VisiblePositionRange();
2524
2525     VisiblePosition startPos = firstPositionInOrBeforeNode(node);
2526     VisiblePosition endPos = lastPositionInOrAfterNode(node);
2527
2528     // the VisiblePositions are equal for nodes like buttons, so adjust for that
2529     // FIXME: Really?  [button, 0] and [button, 1] are distinct (before and after the button)
2530     // I expect this code is only hit for things like empty divs?  In which case I don't think
2531     // the behavior is correct here -- eseidel
2532     if (startPos == endPos) {
2533         endPos = endPos.next();
2534         if (endPos.isNull())
2535             endPos = startPos;
2536     }
2537
2538     return VisiblePositionRange(startPos, endPos);
2539 }
2540
2541 VisiblePositionRange AccessibilityRenderObject::visiblePositionRangeForLine(unsigned lineCount) const
2542 {
2543     if (!lineCount || !m_renderer)
2544         return VisiblePositionRange();
2545
2546     // iterate over the lines
2547     // FIXME: this is wrong when lineNumber is lineCount+1,  because nextLinePosition takes you to the
2548     // last offset of the last line
2549     VisiblePosition visiblePos = m_renderer->document()->renderer()->positionForPoint(IntPoint());
2550     VisiblePosition savedVisiblePos;
2551     while (--lineCount) {
2552         savedVisiblePos = visiblePos;
2553         visiblePos = nextLinePosition(visiblePos, 0);
2554         if (visiblePos.isNull() || visiblePos == savedVisiblePos)
2555             return VisiblePositionRange();
2556     }
2557
2558     // make a caret selection for the marker position, then extend it to the line
2559     // NOTE: ignores results of sel.modify because it returns false when
2560     // starting at an empty line.  The resulting selection in that case
2561     // will be a caret at visiblePos.
2562     FrameSelection selection;
2563     selection.setSelection(VisibleSelection(visiblePos));
2564     selection.modify(FrameSelection::AlterationExtend, DirectionRight, LineBoundary);
2565
2566     return VisiblePositionRange(selection.selection().visibleStart(), selection.selection().visibleEnd());
2567 }
2568
2569 VisiblePosition AccessibilityRenderObject::visiblePositionForIndex(int index) const
2570 {
2571     if (!m_renderer)
2572         return VisiblePosition();
2573
2574     if (isNativeTextControl())
2575         return toRenderTextControl(m_renderer)->visiblePositionForIndex(index);
2576
2577     if (!allowsTextRanges() && !m_renderer->isText())
2578         return VisiblePosition();
2579
2580     Node* node = m_renderer->node();
2581     if (!node)
2582         return VisiblePosition();
2583
2584     if (index <= 0)
2585         return VisiblePosition(firstPositionInOrBeforeNode(node), DOWNSTREAM);
2586
2587     ExceptionCode ec = 0;
2588     RefPtr<Range> range = Range::create(m_renderer->document());
2589     range->selectNodeContents(node, ec);
2590     CharacterIterator it(range.get());
2591     it.advance(index - 1);
2592     return VisiblePosition(Position(it.range()->endContainer(ec), it.range()->endOffset(ec), Position::PositionIsOffsetInAnchor), UPSTREAM);
2593 }
2594
2595 int AccessibilityRenderObject::indexForVisiblePosition(const VisiblePosition& pos) const
2596 {
2597     if (isNativeTextControl()) {
2598         HTMLTextFormControlElement* textControl = toRenderTextControl(m_renderer)->textFormControlElement();
2599         return textControl->indexForVisiblePosition(pos);
2600     }
2601
2602     if (!isTextControl())
2603         return 0;
2604
2605     Node* node = m_renderer->node();
2606     if (!node)
2607         return 0;
2608
2609     Position indexPosition = pos.deepEquivalent();
2610     if (indexPosition.isNull() || highestEditableRoot(indexPosition, HasEditableAXRole) != node)
2611         return 0;
2612
2613     ExceptionCode ec = 0;
2614     RefPtr<Range> range = Range::create(m_renderer->document());
2615     range->setStart(node, 0, ec);
2616     range->setEnd(indexPosition, ec);
2617
2618 #if PLATFORM(GTK)
2619     // We need to consider replaced elements for GTK, as they will be
2620     // presented with the 'object replacement character' (0xFFFC).
2621     return TextIterator::rangeLength(range.get(), true);
2622 #else
2623     return TextIterator::rangeLength(range.get());
2624 #endif
2625 }
2626
2627 Element* AccessibilityRenderObject::rootEditableElementForPosition(const Position& position) const
2628 {
2629     // Find the root editable or pseudo-editable (i.e. having an editable ARIA role) element.
2630     Element* result = 0;
2631
2632     Element* rootEditableElement = position.rootEditableElement();
2633
2634     for (Element* e = position.element(); e && e != rootEditableElement; e = e->parentElement()) {
2635         if (nodeIsTextControl(e))
2636             result = e;
2637         if (e->hasTagName(bodyTag))
2638             break;
2639     }
2640
2641     if (result)
2642         return result;
2643
2644     return rootEditableElement;
2645 }
2646
2647 bool AccessibilityRenderObject::nodeIsTextControl(const Node* node) const
2648 {
2649     if (!node)
2650         return false;
2651
2652     const AccessibilityObject* axObjectForNode = axObjectCache()->getOrCreate(node->renderer());
2653     if (!axObjectForNode)
2654         return false;
2655
2656     return axObjectForNode->isTextControl();
2657 }
2658
2659 IntRect AccessibilityRenderObject::boundsForVisiblePositionRange(const VisiblePositionRange& visiblePositionRange) const
2660 {
2661     if (visiblePositionRange.isNull())
2662         return IntRect();
2663
2664     // Create a mutable VisiblePositionRange.
2665     VisiblePositionRange range(visiblePositionRange);
2666     LayoutRect rect1 = range.start.absoluteCaretBounds();
2667     LayoutRect rect2 = range.end.absoluteCaretBounds();
2668
2669     // readjust for position at the edge of a line.  This is to exclude line rect that doesn't need to be accounted in the range bounds
2670     if (rect2.y() != rect1.y()) {
2671         VisiblePosition endOfFirstLine = endOfLine(range.start);
2672         if (range.start == endOfFirstLine) {
2673             range.start.setAffinity(DOWNSTREAM);
2674             rect1 = range.start.absoluteCaretBounds();
2675         }
2676         if (range.end == endOfFirstLine) {
2677             range.end.setAffinity(UPSTREAM);
2678             rect2 = range.end.absoluteCaretBounds();
2679         }
2680     }
2681
2682     LayoutRect ourrect = rect1;
2683     ourrect.unite(rect2);
2684
2685     // if the rectangle spans lines and contains multiple text chars, use the range's bounding box intead
2686     if (rect1.maxY() != rect2.maxY()) {
2687         RefPtr<Range> dataRange = makeRange(range.start, range.end);
2688         LayoutRect boundingBox = dataRange->boundingBox();
2689         String rangeString = plainText(dataRange.get());
2690         if (rangeString.length() > 1 && !boundingBox.isEmpty())
2691             ourrect = boundingBox;
2692     }
2693
2694 #if PLATFORM(MAC)
2695     return m_renderer->document()->view()->contentsToScreen(pixelSnappedIntRect(ourrect));
2696 #else
2697     return pixelSnappedIntRect(ourrect);
2698 #endif
2699 }
2700
2701 void AccessibilityRenderObject::setSelectedVisiblePositionRange(const VisiblePositionRange& range) const
2702 {
2703     if (range.start.isNull() || range.end.isNull())
2704         return;
2705
2706     // make selection and tell the document to use it. if it's zero length, then move to that position
2707     if (range.start == range.end)
2708         m_renderer->frame()->selection()->moveTo(range.start, UserTriggered);
2709     else {
2710         VisibleSelection newSelection = VisibleSelection(range.start, range.end);
2711         m_renderer->frame()->selection()->setSelection(newSelection);
2712     }
2713 }
2714
2715 VisiblePosition AccessibilityRenderObject::visiblePositionForPoint(const IntPoint& point) const
2716 {
2717     if (!m_renderer)
2718         return VisiblePosition();
2719
2720     // convert absolute point to view coordinates
2721     Document* topDoc = topDocument();
2722     if (!topDoc || !topDoc->renderer() || !topDoc->renderer()->view())
2723         return VisiblePosition();
2724
2725     FrameView* frameView = topDoc->renderer()->view()->frameView();
2726     if (!frameView)
2727         return VisiblePosition();
2728
2729     RenderView* renderView = topRenderer();
2730     if (!renderView)
2731         return VisiblePosition();
2732
2733     Node* innerNode = 0;
2734
2735     // locate the node containing the point
2736     LayoutPoint pointResult;
2737     while (1) {
2738         LayoutPoint ourpoint;
2739 #if PLATFORM(MAC)
2740         ourpoint = frameView->screenToContents(point);
2741 #else
2742         ourpoint = point;
2743 #endif
2744         HitTestRequest request(HitTestRequest::ReadOnly |
2745                                HitTestRequest::Active);
2746         HitTestResult result(ourpoint);
2747         renderView->hitTest(request, result);
2748         innerNode = result.innerNode();
2749         if (!innerNode)
2750             return VisiblePosition();
2751
2752         RenderObject* renderer = innerNode->renderer();
2753         if (!renderer)
2754             return VisiblePosition();
2755
2756         pointResult = result.localPoint();
2757
2758         // done if hit something other than a widget
2759         if (!renderer->isWidget())
2760             break;
2761
2762         // descend into widget (FRAME, IFRAME, OBJECT...)
2763         Widget* widget = toRenderWidget(renderer)->widget();
2764         if (!widget || !widget->isFrameView())
2765             break;
2766         Frame* frame = static_cast<FrameView*>(widget)->frame();
2767         if (!frame)
2768             break;
2769         renderView = frame->document()->renderView();
2770         frameView = static_cast<FrameView*>(widget);
2771     }
2772
2773     return innerNode->renderer()->positionForPoint(pointResult);
2774 }
2775
2776 // NOTE: Consider providing this utility method as AX API
2777 VisiblePosition AccessibilityRenderObject::visiblePositionForIndex(unsigned indexValue, bool lastIndexOK) const
2778 {
2779     if (!isTextControl())
2780         return VisiblePosition();
2781
2782     // lastIndexOK specifies whether the position after the last character is acceptable
2783     if (indexValue >= text().length()) {
2784         if (!lastIndexOK || indexValue > text().length())
2785             return VisiblePosition();
2786     }
2787     VisiblePosition position = visiblePositionForIndex(indexValue);
2788     position.setAffinity(DOWNSTREAM);
2789     return position;
2790 }
2791
2792 // NOTE: Consider providing this utility method as AX API
2793 int AccessibilityRenderObject::index(const VisiblePosition& position) const
2794 {
2795     if (position.isNull() || !isTextControl())
2796         return -1;
2797
2798     if (renderObjectContainsPosition(m_renderer, position.deepEquivalent()))
2799         return indexForVisiblePosition(position);
2800
2801     return -1;
2802 }
2803
2804 // Given a line number, the range of characters of the text associated with this accessibility
2805 // object that contains the line number.
2806 PlainTextRange AccessibilityRenderObject::doAXRangeForLine(unsigned lineNumber) const
2807 {
2808     if (!isTextControl())
2809         return PlainTextRange();
2810
2811     // iterate to the specified line
2812     VisiblePosition visiblePos = visiblePositionForIndex(0);
2813     VisiblePosition savedVisiblePos;
2814     for (unsigned lineCount = lineNumber; lineCount; lineCount -= 1) {
2815         savedVisiblePos = visiblePos;
2816         visiblePos = nextLinePosition(visiblePos, 0);
2817         if (visiblePos.isNull() || visiblePos == savedVisiblePos)
2818             return PlainTextRange();
2819     }
2820
2821     // Get the end of the line based on the starting position.
2822     VisiblePosition endPosition = endOfLine(visiblePos);
2823
2824     int index1 = indexForVisiblePosition(visiblePos);
2825     int index2 = indexForVisiblePosition(endPosition);
2826
2827     // add one to the end index for a line break not caused by soft line wrap (to match AppKit)
2828     if (endPosition.affinity() == DOWNSTREAM && endPosition.next().isNotNull())
2829         index2 += 1;
2830
2831     // return nil rather than an zero-length range (to match AppKit)
2832     if (index1 == index2)
2833         return PlainTextRange();
2834
2835     return PlainTextRange(index1, index2 - index1);
2836 }
2837
2838 // The composed character range in the text associated with this accessibility object that
2839 // is specified by the given index value. This parameterized attribute returns the complete
2840 // range of characters (including surrogate pairs of multi-byte glyphs) at the given index.
2841 PlainTextRange AccessibilityRenderObject::doAXRangeForIndex(unsigned index) const
2842 {
2843     if (!isTextControl())
2844         return PlainTextRange();
2845
2846     String elementText = text();
2847     if (!elementText.length() || index > elementText.length() - 1)
2848         return PlainTextRange();
2849
2850     return PlainTextRange(index, 1);
2851 }
2852
2853 // A substring of the text associated with this accessibility object that is
2854 // specified by the given character range.
2855 String AccessibilityRenderObject::doAXStringForRange(const PlainTextRange& range) const
2856 {
2857     if (isPasswordField())
2858         return String();
2859
2860     if (!range.length)
2861         return String();
2862
2863     if (!isTextControl())
2864         return String();
2865
2866     String elementText = text();
2867     if (range.start + range.length > elementText.length())
2868         return String();
2869
2870     return elementText.substring(range.start, range.length);
2871 }
2872
2873 // The bounding rectangle of the text associated with this accessibility object that is
2874 // specified by the given range. This is the bounding rectangle a sighted user would see
2875 // on the display screen, in pixels.
2876 IntRect AccessibilityRenderObject::doAXBoundsForRange(const PlainTextRange& range) const
2877 {
2878     if (allowsTextRanges())
2879         return boundsForVisiblePositionRange(visiblePositionRangeForRange(range));
2880     return IntRect();
2881 }
2882
2883 AccessibilityObject* AccessibilityRenderObject::accessibilityImageMapHitTest(HTMLAreaElement* area, const IntPoint& point) const
2884 {
2885     if (!area)
2886         return 0;
2887
2888     HTMLMapElement* map = static_cast<HTMLMapElement*>(area->parentNode());
2889     AccessibilityObject* parent = accessibilityParentForImageMap(map);
2890     if (!parent)
2891         return 0;
2892
2893     AccessibilityObject::AccessibilityChildrenVector children = parent->children();
2894
2895     unsigned count = children.size();
2896     for (unsigned k = 0; k < count; ++k) {
2897         if (children[k]->elementRect().contains(point))
2898             return children[k].get();
2899     }
2900
2901     return 0;
2902 }
2903
2904 AccessibilityObject* AccessibilityRenderObject::accessibilityHitTest(const IntPoint& point) const
2905 {
2906     if (!m_renderer || !m_renderer->hasLayer())
2907         return 0;
2908
2909     RenderLayer* layer = toRenderBox(m_renderer)->layer();
2910
2911     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active);
2912     HitTestResult hitTestResult = HitTestResult(point);
2913     layer->hitTest(request, hitTestResult);
2914     if (!hitTestResult.innerNode())
2915         return 0;
2916     Node* node = hitTestResult.innerNode()->shadowAncestorNode();
2917
2918     if (node->hasTagName(areaTag))
2919         return accessibilityImageMapHitTest(static_cast<HTMLAreaElement*>(node), point);
2920
2921     if (node->hasTagName(optionTag))
2922         node = static_cast<HTMLOptionElement*>(node)->ownerSelectElement();
2923
2924     RenderObject* obj = node->renderer();
2925     if (!obj)
2926         return 0;
2927
2928     AccessibilityObject* result = obj->document()->axObjectCache()->getOrCreate(obj);
2929     result->updateChildrenIfNecessary();
2930
2931     // Allow the element to perform any hit-testing it might need to do to reach non-render children.
2932     result = result->elementAccessibilityHitTest(point);
2933
2934     if (result && result->accessibilityIsIgnored()) {
2935         // If this element is the label of a control, a hit test should return the control.
2936         AccessibilityObject* controlObject = result->correspondingControlForLabelElement();
2937         if (controlObject && !controlObject->exposesTitleUIElement())
2938             return controlObject;
2939
2940         result = result->parentObjectUnignored();
2941     }
2942
2943     return result;
2944 }
2945
2946 bool AccessibilityRenderObject::shouldFocusActiveDescendant() const
2947 {
2948     switch (ariaRoleAttribute()) {
2949     case GroupRole:
2950     case ComboBoxRole:
2951     case ListBoxRole:
2952     case MenuRole:
2953     case MenuBarRole:
2954     case RadioGroupRole:
2955     case RowRole:
2956     case PopUpButtonRole:
2957     case ProgressIndicatorRole:
2958     case ToolbarRole:
2959     case OutlineRole:
2960     case TreeRole:
2961     case GridRole:
2962     /* FIXME: replace these with actual roles when they are added to AccessibilityRole
2963     composite
2964     alert
2965     alertdialog
2966     status
2967     timer
2968     */
2969         return true;
2970     default:
2971         return false;
2972     }
2973 }
2974
2975 AccessibilityObject* AccessibilityRenderObject::activeDescendant() const
2976 {
2977     if (!m_renderer)
2978         return 0;
2979
2980     if (m_renderer->node() && !m_renderer->node()->isElementNode())
2981         return 0;
2982     Element* element = static_cast<Element*>(m_renderer->node());
2983
2984     const AtomicString& activeDescendantAttrStr = element->getAttribute(aria_activedescendantAttr);
2985     if (activeDescendantAttrStr.isNull() || activeDescendantAttrStr.isEmpty())
2986         return 0;
2987
2988     Element* target = element->treeScope()->getElementById(activeDescendantAttrStr);
2989     if (!target)
2990         return 0;
2991
2992     AccessibilityObject* obj = axObjectCache()->getOrCreate(target->renderer());
2993     if (obj && obj->isAccessibilityRenderObject())
2994     // an activedescendant is only useful if it has a renderer, because that's what's needed to post the notification
2995         return obj;
2996     return 0;
2997 }
2998
2999 void AccessibilityRenderObject::handleAriaExpandedChanged()
3000 {
3001     // Find if a parent of this object should handle aria-expanded changes.
3002     AccessibilityObject* containerParent = this->parentObject();
3003     while (containerParent) {
3004         bool foundParent = false;
3005
3006         switch (containerParent->roleValue()) {
3007         case TreeRole:
3008         case TreeGridRole:
3009         case GridRole:
3010         case TableRole:
3011         case BrowserRole:
3012             foundParent = true;
3013             break;
3014         default:
3015             break;
3016         }
3017
3018         if (foundParent)
3019             break;
3020
3021         containerParent = containerParent->parentObject();
3022     }
3023
3024     // Post that the row count changed.
3025     if (containerParent)
3026         axObjectCache()->postNotification(containerParent, document(), AXObjectCache::AXRowCountChanged, true);
3027
3028     // Post that the specific row either collapsed or expanded.
3029     if (roleValue() == RowRole || roleValue() == TreeItemRole)
3030         axObjectCache()->postNotification(this, document(), isExpanded() ? AXObjectCache::AXRowExpanded : AXObjectCache::AXRowCollapsed, true);
3031 }
3032
3033 void AccessibilityRenderObject::handleActiveDescendantChanged()
3034 {
3035     Element* element = static_cast<Element*>(renderer()->node());
3036     if (!element)
3037         return;
3038     Document* doc = renderer()->document();
3039     if (!doc->frame()->selection()->isFocusedAndActive() || doc->focusedNode() != element)
3040         return;
3041     AccessibilityRenderObject* activedescendant = static_cast<AccessibilityRenderObject*>(activeDescendant());
3042
3043     if (activedescendant && shouldFocusActiveDescendant())
3044         doc->axObjectCache()->postNotification(m_renderer, AXObjectCache::AXActiveDescendantChanged, true);
3045 }
3046
3047 AccessibilityObject* AccessibilityRenderObject::correspondingControlForLabelElement() const
3048 {
3049     HTMLLabelElement* labelElement = labelElementContainer();
3050     if (!labelElement)
3051         return 0;
3052
3053     HTMLElement* correspondingControl = labelElement->control();
3054     if (!correspondingControl)
3055         return 0;
3056
3057     return axObjectCache()->getOrCreate(correspondingControl->renderer());
3058 }
3059
3060 AccessibilityObject* AccessibilityRenderObject::correspondingLabelForControlElement() const
3061 {
3062     if (!m_renderer)
3063         return 0;
3064
3065     Node* node = m_renderer->node();
3066     if (node && node->isHTMLElement()) {
3067         HTMLLabelElement* label = labelForElement(static_cast<Element*>(node));
3068         if (label)
3069             return axObjectCache()->getOrCreate(label->renderer());
3070     }
3071
3072     return 0;
3073 }
3074
3075 bool AccessibilityRenderObject::renderObjectIsObservable(RenderObject* renderer) const
3076 {
3077     // AX clients will listen for AXValueChange on a text control.
3078     if (renderer->isTextControl())
3079         return true;
3080
3081     // AX clients will listen for AXSelectedChildrenChanged on listboxes.
3082     Node* node = renderer->node();
3083     if (nodeHasRole(node, "listbox") || (renderer->isBoxModelObject() && toRenderBoxModelObject(renderer)->isListBox()))
3084         return true;
3085
3086     // Textboxes should send out notifications.
3087     if (nodeHasRole(node, "textbox"))
3088         return true;
3089
3090     return false;
3091 }
3092
3093 AccessibilityObject* AccessibilityRenderObject::observableObject() const
3094 {
3095     // Find the object going up the parent chain that is used in accessibility to monitor certain notifications.
3096     for (RenderObject* renderer = m_renderer; renderer && renderer->node(); renderer = renderer->parent()) {
3097         if (renderObjectIsObservable(renderer))
3098             return axObjectCache()->getOrCreate(renderer);
3099     }
3100
3101     return 0;
3102 }
3103
3104 bool AccessibilityRenderObject::isDescendantOfElementType(const QualifiedName& tagName) const
3105 {
3106     for (RenderObject* parent = m_renderer->parent(); parent; parent = parent->parent()) {
3107         if (parent->node() && parent->node()->hasTagName(tagName))
3108             return true;
3109     }
3110     return false;
3111 }
3112
3113 AccessibilityRole AccessibilityRenderObject::determineAccessibilityRole()
3114 {
3115     if (!m_renderer)
3116         return UnknownRole;
3117
3118     m_ariaRole = determineAriaRoleAttribute();
3119
3120     Node* node = m_renderer->node();
3121     AccessibilityRole ariaRole = ariaRoleAttribute();
3122     if (ariaRole != UnknownRole)
3123         return ariaRole;
3124
3125     RenderBoxModelObject* cssBox = renderBoxModelObject();
3126
3127     if (node && node->isLink()) {
3128         if (cssBox && cssBox->isImage())
3129             return ImageMapRole;
3130         return WebCoreLinkRole;
3131     }
3132     if (cssBox && cssBox->isListItem())
3133         return ListItemRole;
3134     if (m_renderer->isListMarker())
3135         return ListMarkerRole;
3136     if (node && node->hasTagName(buttonTag))
3137         return ariaHasPopup() ? PopUpButtonRole : ButtonRole;
3138     if (m_renderer->isText())
3139         return StaticTextRole;
3140     if (cssBox && cssBox->isImage()) {
3141         if (node && node->hasTagName(inputTag))
3142             return ariaHasPopup() ? PopUpButtonRole : ButtonRole;
3143         return ImageRole;
3144     }
3145     if (node && node->hasTagName(canvasTag))
3146         return ImageRole;
3147
3148     if (cssBox && cssBox->isRenderView())
3149         return WebAreaRole;
3150
3151     if (cssBox && cssBox->isTextField())
3152         return TextFieldRole;
3153
3154     if (cssBox && cssBox->isTextArea())
3155         return TextAreaRole;
3156
3157     if (node && node->hasTagName(inputTag)) {
3158         HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
3159         if (input->isCheckbox())
3160             return CheckBoxRole;
3161         if (input->isRadioButton())
3162             return RadioButtonRole;
3163         if (input->isTextButton())
3164             return ariaHasPopup() ? PopUpButtonRole : ButtonRole;
3165     }
3166
3167     if (isFileUploadButton())
3168         return ButtonRole;
3169
3170     if (cssBox && cssBox->isMenuList())
3171         return PopUpButtonRole;
3172
3173     if (headingLevel())
3174         return HeadingRole;
3175
3176 #if ENABLE(MATHML)
3177     if (node && node->hasTagName(MathMLNames::mathTag))
3178         return DocumentMathRole;
3179 #endif
3180
3181     if (node && node->hasTagName(ddTag))
3182         return DefinitionListDefinitionRole;
3183
3184     if (node && node->hasTagName(dtTag))
3185         return DefinitionListTermRole;
3186
3187     if (node && (node->hasTagName(rpTag) || node->hasTagName(rtTag)))
3188         return AnnotationRole;
3189
3190 #if PLATFORM(GTK)
3191     // Gtk ATs expect all tables, data and layout, to be exposed as tables.
3192     if (node && (node->hasTagName(tdTag) || node->hasTagName(thTag)))
3193         return CellRole;
3194
3195     if (node && node->hasTagName(trTag))
3196         return RowRole;
3197
3198     if (node && node->hasTagName(tableTag))
3199         return TableRole;
3200 #endif
3201
3202     // Table sections should be ignored.
3203     if (m_renderer->isTableSection())
3204         return IgnoredRole;
3205
3206 #if PLATFORM(GTK)
3207     if (m_renderer->isHR())
3208         return SplitterRole;
3209
3210     if (node && node->hasTagName(pTag))
3211         return ParagraphRole;
3212
3213     if (node && node->hasTagName(labelTag))
3214         return LabelRole;
3215
3216     if (node && node->hasTagName(divTag))
3217         return DivRole;
3218
3219     if (node && node->hasTagName(formTag))
3220         return FormRole;
3221 #else
3222     if (node && node->hasTagName(labelTag))
3223         return GroupRole;
3224 #endif
3225
3226     if (node && node->hasTagName(articleTag))
3227         return DocumentArticleRole;
3228
3229     if (node && node->hasTagName(navTag))
3230         return LandmarkNavigationRole;
3231
3232     if (node && node->hasTagName(asideTag))
3233         return LandmarkComplementaryRole;
3234
3235     if (node && node->hasTagName(sectionTag))
3236         return DocumentRegionRole;
3237
3238     if (node && node->hasTagName(addressTag))
3239         return LandmarkContentInfoRole;
3240
3241     // There should only be one banner/contentInfo per page. If header/footer are being used within an article or section
3242     // then it should not be exposed as whole page's banner/contentInfo
3243     if (node && node->hasTagName(headerTag) && !isDescendantOfElementType(articleTag) && !isDescendantOfElementType(sectionTag))
3244         return LandmarkBannerRole;
3245     if (node && node->hasTagName(footerTag) && !isDescendantOfElementType(articleTag) && !isDescendantOfElementType(sectionTag))
3246         return FooterRole;
3247
3248     if (m_renderer->isBlockFlow())
3249         return GroupRole;
3250
3251     // If the element does not have role, but it has ARIA attributes, accessibility should fallback to exposing it as a group.
3252     if (supportsARIAAttributes())
3253         return GroupRole;
3254
3255     return UnknownRole;
3256 }
3257
3258 AccessibilityOrientation AccessibilityRenderObject::orientation() const
3259 {
3260     const AtomicString& ariaOrientation = getAttribute(aria_orientationAttr);
3261     if (equalIgnoringCase(ariaOrientation, "horizontal"))
3262         return AccessibilityOrientationHorizontal;
3263     if (equalIgnoringCase(ariaOrientation, "vertical"))
3264         return AccessibilityOrientationVertical;
3265
3266     return AccessibilityObject::orientation();
3267 }
3268
3269 bool AccessibilityRenderObject::inheritsPresentationalRole() const
3270 {
3271     // ARIA states if an item can get focus, it should not be presentational.
3272     if (canSetFocusAttribute())
3273         return false;
3274
3275     // ARIA spec says that when a parent object is presentational, and it has required child elements,
3276     // those child elements are also presentational. For example, <li> becomes presentational from <ul>.
3277     // http://www.w3.org/WAI/PF/aria/complete#presentation
3278     DEFINE_STATIC_LOCAL(HashSet<QualifiedName>, listItemParents, ());
3279
3280     HashSet<QualifiedName>* possibleParentTagNames = 0;
3281     switch (roleValue()) {
3282     case ListItemRole:
3283     case ListMarkerRole:
3284         if (listItemParents.isEmpty()) {
3285             listItemParents.add(ulTag);
3286             listItemParents.add(olTag);
3287             listItemParents.add(dlTag);
3288         }
3289         possibleParentTagNames = &listItemParents;
3290         break;
3291     default:
3292         break;
3293     }
3294
3295     // Not all elements need to check for this, only ones that are required children.
3296     if (!possibleParentTagNames)
3297         return false;
3298
3299     for (AccessibilityObject* parent = parentObject(); parent; parent = parent->parentObject()) {
3300         if (!parent->isAccessibilityRenderObject())
3301             continue;
3302
3303         Node* elementNode = static_cast<AccessibilityRenderObject*>(parent)->node();
3304         if (!elementNode || !elementNode->isElementNode())
3305             continue;
3306
3307         // If native tag of the parent element matches an acceptable name, then return
3308         // based on its presentational status.
3309         if (possibleParentTagNames->contains(static_cast<Element*>(elementNode)->tagQName()))
3310             return parent->roleValue() == PresentationalRole;
3311     }
3312
3313     return false;
3314 }
3315
3316 bool AccessibilityRenderObject::isPresentationalChildOfAriaRole() const
3317 {
3318     // Walk the parent chain looking for a parent that has presentational children
3319     AccessibilityObject* parent;
3320     for (parent = parentObject(); parent && !parent->ariaRoleHasPresentationalChildren(); parent = parent->parentObject())
3321     { }
3322
3323     return parent;
3324 }
3325
3326 bool AccessibilityRenderObject::ariaRoleHasPresentationalChildren() const
3327 {
3328     switch (m_ariaRole) {
3329     case ButtonRole:
3330     case SliderRole:
3331     case ImageRole:
3332     case ProgressIndicatorRole:
3333     // case SeparatorRole:
3334         return true;
3335     default:
3336         return false;
3337     }
3338 }
3339
3340 bool AccessibilityRenderObject::canSetExpandedAttribute() const
3341 {
3342     // An object can be expanded if it aria-expanded is true or false.
3343     const AtomicString& ariaExpanded = getAttribute(aria_expandedAttr);
3344     return equalIgnoringCase(ariaExpanded, "true") || equalIgnoringCase(ariaExpanded, "false");
3345 }
3346
3347 bool AccessibilityRenderObject::canSetValueAttribute() const
3348 {
3349     if (equalIgnoringCase(getAttribute(aria_readonlyAttr), "true"))
3350         return false;
3351
3352     if (isProgressIndicator() || isSlider())
3353         return true;
3354
3355     if (isTextControl() && !isNativeTextControl())
3356         return true;
3357
3358     // Any node could be contenteditable, so isReadOnly should be relied upon
3359     // for this information for all elements.
3360     return !isReadOnly();
3361 }
3362
3363 bool AccessibilityRenderObject::canSetTextRangeAttributes() const
3364 {
3365     return isTextControl();
3366 }
3367
3368 void AccessibilityRenderObject::contentChanged()
3369 {
3370     // If this element supports ARIA live regions, or is part of a region with an ARIA editable role,
3371     // then notify the AT of changes.
3372     AXObjectCache* cache = axObjectCache();
3373     for (RenderObject* renderParent = m_renderer; renderParent; renderParent = renderParent->parent()) {
3374         AccessibilityObject* parent = cache->get(renderParent);
3375         if (!parent)
3376             continue;
3377
3378         if (parent->supportsARIALiveRegion())
3379             cache->postNotification(renderParent, AXObjectCache::AXLiveRegionChanged, true);
3380
3381         if (parent->isARIATextControl() && !parent->isNativeTextControl() && !parent->node()->rendererIsEditable())
3382             cache->postNotification(renderParent, AXObjectCache::AXValueChanged, true);
3383     }
3384 }
3385
3386 bool AccessibilityRenderObject::canHaveChildren() const
3387 {
3388     if (!m_renderer)
3389         return false;
3390
3391     // Canvas is a special case; its role is ImageRole but it is allowed to have children.
3392     if (node() && node()->hasTagName(canvasTag))
3393         return true;
3394
3395     // Elements that should not have children
3396     switch (roleValue()) {
3397     case ImageRole:
3398     case ButtonRole:
3399     case PopUpButtonRole:
3400     case CheckBoxRole:
3401     case RadioButtonRole:
3402     case TabRole:
3403     case StaticTextRole:
3404     case ListBoxOptionRole:
3405     case ScrollBarRole:
3406         return false;
3407     default:
3408         return true;
3409     }
3410 }
3411
3412 void AccessibilityRenderObject::clearChildren()
3413 {
3414     AccessibilityObject::clearChildren();
3415     m_childrenDirty = false;
3416 }
3417
3418 void AccessibilityRenderObject::addImageMapChildren()
3419 {
3420     RenderBoxModelObject* cssBox = renderBoxModelObject();
3421     if (!cssBox || !cssBox->isRenderImage())
3422         return;
3423
3424     HTMLMapElement* map = toRenderImage(cssBox)->imageMap();
3425     if (!map)
3426         return;
3427
3428     for (Node* current = map->firstChild(); current; current = current->traverseNextNode(map)) {
3429
3430         // add an <area> element for this child if it has a link
3431         if (current->hasTagName(areaTag) && current->isLink()) {
3432             AccessibilityImageMapLink* areaObject = static_cast<AccessibilityImageMapLink*>(axObjectCache()->getOrCreate(ImageMapLinkRole));
3433             areaObject->setHTMLAreaElement(static_cast<HTMLAreaElement*>(current));
3434             areaObject->setHTMLMapElement(map);
3435             areaObject->setParent(this);
3436
3437             m_children.append(areaObject);
3438         }
3439     }
3440 }
3441
3442 void AccessibilityRenderObject::updateChildrenIfNecessary()
3443 {
3444     if (needsToUpdateChildren())
3445         clearChildren();
3446
3447     AccessibilityObject::updateChildrenIfNecessary();
3448 }
3449
3450 void AccessibilityRenderObject::addTextFieldChildren()
3451 {
3452     Node* node = this->node();
3453     if (!node || !node->hasTagName(inputTag))
3454         return;
3455
3456     HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
3457     HTMLElement* spinButtonElement = input->innerSpinButtonElement();
3458     if (!spinButtonElement || !spinButtonElement->isSpinButtonElement())
3459         return;
3460
3461     AccessibilitySpinButton* axSpinButton = static_cast<AccessibilitySpinButton*>(axObjectCache()->getOrCreate(SpinButtonRole));
3462     axSpinButton->setSpinButtonElement(static_cast<SpinButtonElement*>(spinButtonElement));
3463     axSpinButton->setParent(this);
3464     m_children.append(axSpinButton);
3465 }
3466
3467 void AccessibilityRenderObject::addCanvasChildren()
3468 {
3469     if (!node() || !node()->hasTagName(canvasTag))
3470         return;
3471
3472     // If it's a canvas, it won't have rendered children, but it might have accessible fallback content.
3473     // Clear m_haveChildren because AccessibilityNodeObject::addChildren will expect it to be false.
3474     ASSERT(!m_children.size());
3475     m_haveChildren = false;
3476     AccessibilityNodeObject::addChildren();
3477 }
3478
3479 void AccessibilityRenderObject::addAttachmentChildren()
3480 {
3481     if (!isAttachment())
3482         return;
3483
3484     // FrameView's need to be inserted into the AX hierarchy when encountered.
3485     Widget* widget = widgetForAttachmentView();
3486     if (!widget || !widget->isFrameView())
3487         return;
3488
3489     AccessibilityObject* axWidget = axObjectCache()->getOrCreate(widget);
3490     if (!axWidget->accessibilityIsIgnored())
3491         m_children.append(axWidget);
3492 }
3493
3494 #if PLATFORM(MAC)
3495 void AccessibilityRenderObject::updateAttachmentViewParents()
3496 {
3497     // Only the unignored parent should set the attachment parent, because that's what is reflected in the AX
3498     // hierarchy to the client.
3499     if (accessibilityIsIgnored())
3500         return;
3501
3502     size_t length = m_children.size();
3503     for (size_t k = 0; k < length; k++) {
3504         if (m_children[k]->isAttachment())
3505             m_children[k]->overrideAttachmentParent(this);
3506     }
3507 }
3508 #endif
3509
3510 void AccessibilityRenderObject::addChildren()
3511 {
3512     // If the need to add more children in addition to existing children arises,
3513     // childrenChanged should have been called, leaving the object with no children.
3514     ASSERT(!m_haveChildren);
3515
3516     m_haveChildren = true;
3517
3518     if (!canHaveChildren())
3519         return;
3520
3521     // add all unignored acc children
3522     for (RefPtr<AccessibilityObject> obj = firstChild(); obj; obj = obj->nextSibling()) {
3523         // If the parent is asking for this child's children, then either it's the first time (and clearing is a no-op),
3524         // or its visibility has changed. In the latter case, this child may have a stale child cached.
3525         // This can prevent aria-hidden changes from working correctly. Hence, whenever a parent is getting children, ensure data is not stale.
3526         obj->clearChildren();
3527
3528         if (obj->accessibilityIsIgnored()) {
3529             AccessibilityChildrenVector children = obj->children();
3530             unsigned length = children.size();
3531             for (unsigned i = 0; i < length; ++i)
3532                 m_children.append(children[i]);
3533         } else {
3534             ASSERT(obj->parentObject() == this);
3535             m_children.append(obj);
3536         }
3537     }
3538
3539     addAttachmentChildren();
3540     addImageMapChildren();
3541     addTextFieldChildren();
3542     addCanvasChildren();
3543
3544 #if PLATFORM(MAC)
3545     updateAttachmentViewParents();
3546 #endif
3547 }
3548
3549 const AtomicString& AccessibilityRenderObject::ariaLiveRegionStatus() const
3550 {
3551     DEFINE_STATIC_LOCAL(const AtomicString, liveRegionStatusAssertive, ("assertive"));
3552     DEFINE_STATIC_LOCAL(const AtomicString, liveRegionStatusPolite, ("polite"));
3553     DEFINE_STATIC_LOCAL(const AtomicString, liveRegionStatusOff, ("off"));
3554
3555     const AtomicString& liveRegionStatus = getAttribute(aria_liveAttr);
3556     // These roles have implicit live region status.
3557     if (liveRegionStatus.isEmpty()) {
3558         switch (roleValue()) {
3559         case ApplicationAlertDialogRole:
3560         case ApplicationAlertRole:
3561             return liveRegionStatusAssertive;
3562         case ApplicationLogRole:
3563         case ApplicationStatusRole:
3564             return liveRegionStatusPolite;
3565         case ApplicationTimerRole:
3566         case ApplicationMarqueeRole:
3567             return liveRegionStatusOff;
3568         default:
3569             break;
3570         }
3571     }
3572
3573     return liveRegionStatus;
3574 }
3575
3576 const AtomicString& AccessibilityRenderObject::ariaLiveRegionRelevant() const
3577 {
3578     DEFINE_STATIC_LOCAL(const AtomicString, defaultLiveRegionRelevant, ("additions text"));
3579     const AtomicString& relevant = getAttribute(aria_relevantAttr);
3580
3581     // Default aria-relevant = "additions text".
3582     if (relevant.isEmpty())
3583         return defaultLiveRegionRelevant;
3584
3585     return relevant;
3586 }
3587
3588 bool AccessibilityRenderObject::ariaLiveRegionAtomic() const
3589 {
3590     return elementAttributeValue(aria_atomicAttr);
3591 }
3592
3593 bool AccessibilityRenderObject::ariaLiveRegionBusy() const
3594 {
3595     return elementAttributeValue(aria_busyAttr);
3596 }
3597
3598 void AccessibilityRenderObject::ariaSelectedRows(AccessibilityChildrenVector& result)
3599 {
3600     // Get all the rows.
3601     AccessibilityChildrenVector allRows;
3602     if (isTree())
3603         ariaTreeRows(allRows);
3604     else if (isAccessibilityTable() && toAccessibilityTable(this)->supportsSelectedRows())
3605         allRows = toAccessibilityTable(this)->rows();
3606
3607     // Determine which rows are selected.
3608     bool isMulti = isMultiSelectable();
3609
3610     // Prefer active descendant over aria-selected.
3611     AccessibilityObject* activeDesc = activeDescendant();
3612     if (activeDesc && (activeDesc->isTreeItem() || activeDesc->isTableRow())) {
3613         result.append(activeDesc);
3614         if (!isMulti)
3615             return;
3616     }
3617
3618     unsigned count = allRows.size();
3619     for (unsigned k = 0; k < count; ++k) {
3620         if (allRows[k]->isSelected()) {
3621             result.append(allRows[k]);
3622             if (!isMulti)
3623                 break;
3624         }
3625     }
3626 }
3627
3628 void AccessibilityRenderObject::ariaListboxSelectedChildren(AccessibilityChildrenVector& result)
3629 {
3630     bool isMulti = isMultiSelectable();
3631
3632     AccessibilityChildrenVector childObjects = children();
3633     unsigned childrenSize = childObjects.size();
3634     for (unsigned k = 0; k < childrenSize; ++k) {
3635         // Every child should have aria-role option, and if so, check for selected attribute/state.
3636         AccessibilityObject* child = childObjects[k].get();
3637         if (child->isSelected() && child->ariaRoleAttribute() == ListBoxOptionRole) {
3638             result.append(child);
3639             if (!isMulti)
3640                 return;
3641         }
3642     }
3643 }
3644
3645 void AccessibilityRenderObject::selectedChildren(AccessibilityChildrenVector& result)
3646 {
3647     ASSERT(result.isEmpty());
3648
3649     // only listboxes should be asked for their selected children.
3650     AccessibilityRole role = roleValue();
3651     if (role == ListBoxRole) // native list boxes would be AccessibilityListBoxes, so only check for aria list boxes
3652         ariaListboxSelectedChildren(result);
3653     else if (role == TreeRole || role == TreeGridRole || role == TableRole)
3654         ariaSelectedRows(result);
3655 }
3656
3657 void AccessibilityRenderObject::ariaListboxVisibleChildren(AccessibilityChildrenVector& result)
3658 {
3659     if (!hasChildren())
3660         addChildren();
3661
3662     AccessibilityObject::AccessibilityChildrenVector children = this->children();
3663     size_t size = children.size();
3664     for (size_t i = 0; i < size; i++) {
3665         if (!children[i]->isOffScreen())
3666             result.append(children[i]);
3667     }
3668 }
3669
3670 void AccessibilityRenderObject::visibleChildren(AccessibilityChildrenVector& result)
3671 {
3672     ASSERT(result.isEmpty());
3673
3674     // only listboxes are asked for their visible children.
3675     if (ariaRoleAttribute() != ListBoxRole) { // native list boxes would be AccessibilityListBoxes, so only check for aria list boxes
3676         ASSERT_NOT_REACHED();
3677         return;
3678     }
3679     return ariaListboxVisibleChildren(result);
3680 }
3681
3682 void AccessibilityRenderObject::tabChildren(AccessibilityChildrenVector& result)
3683 {
3684     ASSERT(roleValue() == TabListRole);
3685
3686     AccessibilityObject::AccessibilityChildrenVector children = this->children();
3687     size_t size = children.size();
3688     for (size_t i = 0; i < size; ++i) {
3689         if (children[i]->isTabItem())
3690             result.append(children[i]);
3691     }
3692 }
3693
3694 const String& AccessibilityRenderObject::actionVerb() const
3695 {
3696     // FIXME: Need to add verbs for select elements.
3697     DEFINE_STATIC_LOCAL(const String, buttonAction, (AXButtonActionVerb()));
3698     DEFINE_STATIC_LOCAL(const String, textFieldAction, (AXTextFieldActionVerb()));
3699     DEFINE_STATIC_LOCAL(const String, radioButtonAction, (AXRadioButtonActionVerb()));
3700     DEFINE_STATIC_LOCAL(const String, checkedCheckBoxAction, (AXCheckedCheckBoxActionVerb()));
3701     DEFINE_STATIC_LOCAL(const String, uncheckedCheckBoxAction, (AXUncheckedCheckBoxActionVerb()));
3702     DEFINE_STATIC_LOCAL(const String, linkAction, (AXLinkActionVerb()));
3703     DEFINE_STATIC_LOCAL(const String, noAction, ());
3704
3705     switch (roleValue()) {
3706     case ButtonRole:
3707         return buttonAction;
3708     case TextFieldRole:
3709     case TextAreaRole:
3710         return textFieldAction;
3711     case RadioButtonRole:
3712         return radioButtonAction;
3713     case CheckBoxRole:
3714         return isChecked() ? checkedCheckBoxAction : uncheckedCheckBoxAction;
3715     case LinkRole:
3716     case WebCoreLinkRole:
3717         return linkAction;
3718     default:
3719         return noAction;
3720     }
3721 }
3722
3723 void AccessibilityRenderObject::setAccessibleName(const AtomicString& name)
3724 {
3725     // Setting the accessible name can store the value in the DOM
3726     if (!m_renderer)
3727         return;
3728
3729     Node* domNode = 0;
3730     // For web areas, set the aria-label on the HTML element.
3731     if (isWebArea())
3732         domNode = m_renderer->document()->documentElement();
3733     else
3734         domNode = m_renderer->node();
3735
3736     if (domNode && domNode->isElementNode())
3737         static_cast<Element*>(domNode)->setAttribute(aria_labelAttr, name);
3738 }
3739
3740 static bool isLinkable(const AccessibilityRenderObject& object)
3741 {
3742     if (!object.renderer())
3743         return false;
3744
3745     // See https://wiki.mozilla.org/Accessibility/AT-Windows-API for the elements
3746     // Mozilla considers linkable.
3747     return object.isLink() || object.isImage() || object.renderer()->isText();
3748 }
3749
3750 String AccessibilityRenderObject::stringValueForMSAA() const
3751 {
3752     if (isLinkable(*this)) {
3753         Element* anchor = anchorElement();
3754         if (anchor && anchor->hasTagName(aTag))
3755             return static_cast<HTMLAnchorElement*>(anchor)->href();
3756     }
3757
3758     return stringValue();
3759 }
3760
3761 bool AccessibilityRenderObject::isLinked() const
3762 {
3763     if (!isLinkable(*this))
3764         return false;
3765
3766     Element* anchor = anchorElement();
3767     if (!anchor || !anchor->hasTagName(aTag))
3768         return false;
3769
3770     return !static_cast<HTMLAnchorElement*>(anchor)->href().isEmpty();
3771 }
3772
3773 bool AccessibilityRenderObject::hasBoldFont() const
3774 {
3775     if (!m_renderer)
3776         return false;
3777
3778     return m_renderer->style()->fontDescription().weight() >= FontWeightBold;
3779 }
3780
3781 bool AccessibilityRenderObject::hasItalicFont() const
3782 {
3783     if (!m_renderer)
3784         return false;
3785
3786     return m_renderer->style()->fontDescription().italic() == FontItalicOn;
3787 }
3788
3789 bool AccessibilityRenderObject::hasPlainText() const
3790 {
3791     if (!m_renderer)
3792         return false;
3793
3794     RenderStyle* style = m_renderer->style();
3795
3796     return style->fontDescription().weight() == FontWeightNormal
3797         && style->fontDescription().italic() == FontItalicOff
3798         && style->textDecorationsInEffect() == TDNONE;
3799 }
3800
3801 bool AccessibilityRenderObject::hasSameFont(RenderObject* renderer) const
3802 {
3803     if (!m_renderer || !renderer)
3804         return false;
3805
3806     return m_renderer->style()->fontDescription().family() == renderer->style()->fontDescription().family();
3807 }
3808
3809 bool AccessibilityRenderObject::hasSameFontColor(RenderObject* renderer) const
3810 {
3811     if (!m_renderer || !renderer)
3812         return false;
3813
3814     return m_renderer->style()->visitedDependentColor(CSSPropertyColor) == renderer->style()->visitedDependentColor(CSSPropertyColor);
3815 }
3816
3817 bool AccessibilityRenderObject::hasSameStyle(RenderObject* renderer) const
3818 {
3819     if (!m_renderer || !renderer)
3820         return false;
3821
3822     return m_renderer->style() == renderer->style();
3823 }
3824
3825 bool AccessibilityRenderObject::hasUnderline() const
3826 {
3827     if (!m_renderer)
3828         return false;
3829
3830     return m_renderer->style()->textDecorationsInEffect() & UNDERLINE;
3831 }
3832
3833 String AccessibilityRenderObject::nameForMSAA() const
3834 {
3835     if (m_renderer && m_renderer->isText())
3836         return textUnderElement();
3837
3838     return title();
3839 }
3840
3841 static bool shouldReturnTagNameAsRoleForMSAA(const Element& element)
3842 {
3843     // See "document structure",
3844     // https://wiki.mozilla.org/Accessibility/AT-Windows-API
3845     // FIXME: Add the other tag names that should be returned as the role.
3846     return element.hasTagName(h1Tag) || element.hasTagName(h2Tag)
3847         || element.hasTagName(h3Tag) || element.hasTagName(h4Tag)
3848         || element.hasTagName(h5Tag) || element.hasTagName(h6Tag);
3849 }
3850
3851 String AccessibilityRenderObject::stringRoleForMSAA() const
3852 {
3853     if (!m_renderer)
3854         return String();
3855
3856     Node* node = m_renderer->node();
3857     if (!node || !node->isElementNode())
3858         return String();
3859
3860     Element* element = static_cast<Element*>(node);
3861     if (!shouldReturnTagNameAsRoleForMSAA(*element))
3862         return String();
3863
3864     return element->tagName();
3865 }
3866
3867 String AccessibilityRenderObject::positionalDescriptionForMSAA() const
3868 {
3869     // See "positional descriptions",
3870     // https://wiki.mozilla.org/Accessibility/AT-Windows-API
3871     if (isHeading())
3872         return "L" + String::number(headingLevel());
3873
3874     // FIXME: Add positional descriptions for other elements.
3875     return String();
3876 }
3877
3878 String AccessibilityRenderObject::descriptionForMSAA() const
3879 {
3880     String description = positionalDescriptionForMSAA();
3881     if (!description.isEmpty())
3882         return description;
3883
3884     description = accessibilityDescription();
3885     if (!description.isEmpty()) {
3886         // From the Mozilla MSAA implementation:
3887         // "Signal to screen readers that this description is speakable and is not
3888         // a formatted positional information description. Don't localize the
3889         // 'Description: ' part of this string, it will be parsed out by assistive
3890         // technologies."
3891         return "Description: " + description;
3892     }
3893
3894     return String();
3895 }
3896
3897 static AccessibilityRole msaaRoleForRenderer(const RenderObject* renderer)
3898 {
3899     if (!renderer)
3900         return UnknownRole;
3901
3902     if (renderer->isText())
3903         return EditableTextRole;
3904
3905     if (renderer->isBoxModelObject() && toRenderBoxModelObject(renderer)->isListItem())
3906         return ListItemRole;
3907
3908     return UnknownRole;
3909 }
3910
3911 AccessibilityRole AccessibilityRenderObject::roleValueForMSAA() const
3912 {
3913     if (m_roleForMSAA != UnknownRole)
3914         return m_roleForMSAA;
3915
3916     m_roleForMSAA = msaaRoleForRenderer(m_renderer);
3917
3918     if (m_roleForMSAA == UnknownRole)
3919         m_roleForMSAA = roleValue();
3920
3921     return m_roleForMSAA;
3922 }
3923
3924 ScrollableArea* AccessibilityRenderObject::getScrollableAreaIfScrollable() const
3925 {
3926     // If the parent is a scroll view, then this object isn't really scrollable, the parent ScrollView should handle the scrolling.
3927     if (parentObject() && parentObject()->isAccessibilityScrollView())
3928         return 0;
3929
3930     if (!m_renderer || !m_renderer->isBox())
3931         return 0;
3932
3933     RenderBox* box = toRenderBox(m_renderer);
3934     if (!box->canBeScrolledAndHasScrollableArea())
3935         return 0;
3936
3937     return box->layer();
3938 }
3939
3940 void AccessibilityRenderObject::scrollTo(const IntPoint& point) const
3941 {
3942     if (!m_renderer || !m_renderer->isBox())
3943         return;
3944
3945     RenderBox* box = toRenderBox(m_renderer);
3946     if (!box->canBeScrolledAndHasScrollableArea())
3947         return;
3948
3949     RenderLayer* layer = box->layer();
3950     layer->scrollToOffset(toSize(point), RenderLayer::ScrollOffsetClamped);
3951 }
3952
3953 } // namespace WebCore