f0fb5ea42ebc2b623637365d5e20a5badd3fd31d
[WebKit-https.git] / 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::isAttachment() const
482 {
483     RenderBoxModelObject* renderer = renderBoxModelObject();
484     if (!renderer)
485         return false;
486     // Widgets are the replaced elements that we represent to AX as attachments
487     bool isWidget = renderer->isWidget();
488     ASSERT(!isWidget || (renderer->isReplaced() && !isImage()));
489     return isWidget && ariaRoleAttribute() == UnknownRole;
490 }
491
492 bool AccessibilityRenderObject::isFileUploadButton() const
493 {
494     if (m_renderer && m_renderer->node() && m_renderer->node()->hasTagName(inputTag)) {
495         HTMLInputElement* input = static_cast<HTMLInputElement*>(m_renderer->node());
496         return input->isFileUpload();
497     }
498     
499     return false;
500 }
501     
502 bool AccessibilityRenderObject::isReadOnly() const
503 {
504     ASSERT(m_renderer);
505     
506     if (isWebArea()) {
507         Document* document = m_renderer->document();
508         if (!document)
509             return true;
510         
511         HTMLElement* body = document->body();
512         if (body && body->rendererIsEditable())
513             return false;
514
515         return !document->rendererIsEditable();
516     }
517
518     return AccessibilityNodeObject::isReadOnly();
519 }
520
521 bool AccessibilityRenderObject::isOffScreen() const
522 {
523     ASSERT(m_renderer);
524     IntRect contentRect = pixelSnappedIntRect(m_renderer->absoluteClippedOverflowRect());
525     FrameView* view = m_renderer->frame()->view();
526     IntRect viewRect = view->visibleContentRect();
527     viewRect.intersect(contentRect);
528     return viewRect.isEmpty();
529 }
530
531 Element* AccessibilityRenderObject::anchorElement() const
532 {
533     if (!m_renderer)
534         return 0;
535     
536     AXObjectCache* cache = axObjectCache();
537     RenderObject* currRenderer;
538     
539     // Search up the render tree for a RenderObject with a DOM node.  Defer to an earlier continuation, though.
540     for (currRenderer = m_renderer; currRenderer && !currRenderer->node(); currRenderer = currRenderer->parent()) {
541         if (currRenderer->isAnonymousBlock()) {
542             RenderObject* continuation = toRenderBlock(currRenderer)->continuation();
543             if (continuation)
544                 return cache->getOrCreate(continuation)->anchorElement();
545         }
546     }
547     
548     // bail if none found
549     if (!currRenderer)
550         return 0;
551     
552     // search up the DOM tree for an anchor element
553     // NOTE: this assumes that any non-image with an anchor is an HTMLAnchorElement
554     Node* node = currRenderer->node();
555     for ( ; node; node = node->parentNode()) {
556         if (node->hasTagName(aTag) || (node->renderer() && cache->getOrCreate(node->renderer())->isAnchor()))
557             return static_cast<Element*>(node);
558     }
559     
560     return 0;
561 }
562
563 String AccessibilityRenderObject::helpText() const
564 {
565     if (!m_renderer)
566         return String();
567     
568     const AtomicString& ariaHelp = getAttribute(aria_helpAttr);
569     if (!ariaHelp.isEmpty())
570         return ariaHelp;
571     
572     String describedBy = ariaDescribedByAttribute();
573     if (!describedBy.isEmpty())
574         return describedBy;
575     
576     String description = accessibilityDescription();
577     for (RenderObject* curr = m_renderer; curr; curr = curr->parent()) {
578         if (curr->node() && curr->node()->isHTMLElement()) {
579             const AtomicString& summary = static_cast<Element*>(curr->node())->getAttribute(summaryAttr);
580             if (!summary.isEmpty())
581                 return summary;
582             
583             // The title attribute should be used as help text unless it is already being used as descriptive text.
584             const AtomicString& title = static_cast<Element*>(curr->node())->getAttribute(titleAttr);
585             if (!title.isEmpty() && description != title)
586                 return title;
587         }
588         
589         // Only take help text from an ancestor element if its a group or an unknown role. If help was 
590         // added to those kinds of elements, it is likely it was meant for a child element.
591         AccessibilityObject* axObj = axObjectCache()->getOrCreate(curr);
592         if (axObj) {
593             AccessibilityRole role = axObj->roleValue();
594             if (role != GroupRole && role != UnknownRole)
595                 break;
596         }
597     }
598     
599     return String();
600 }
601
602 static TextIteratorBehavior textIteratorBehaviorForTextRange()
603 {
604     TextIteratorBehavior behavior = TextIteratorIgnoresStyleVisibility;
605
606 #if PLATFORM(GTK)
607     // We need to emit replaced elements for GTK, and present
608     // them with the 'object replacement character' (0xFFFC).
609     behavior = static_cast<TextIteratorBehavior>(behavior | TextIteratorEmitsObjectReplacementCharacters);
610 #endif
611
612     return behavior;
613 }
614
615 String AccessibilityRenderObject::textUnderElement() const
616 {
617     if (!m_renderer)
618         return String();
619     
620     if (m_renderer->isFileUploadControl())
621         return toRenderFileUploadControl(m_renderer)->buttonValue();
622     
623     Node* node = m_renderer->node();
624     if (node) {
625         if (Frame* frame = node->document()->frame()) {
626             // catch stale WebCoreAXObject (see <rdar://problem/3960196>)
627             if (frame->document() != node->document())
628                 return String();
629
630             return plainText(rangeOfContents(node).get(), textIteratorBehaviorForTextRange());
631         }
632     }
633     
634     // Sometimes text fragments don't have Node's associated with them (like when
635     // CSS content is used to insert text).
636     if (m_renderer->isText()) {
637         RenderText* renderTextObject = toRenderText(m_renderer);
638         if (renderTextObject->isTextFragment())
639             return String(static_cast<RenderTextFragment*>(m_renderer)->contentString());
640     }
641     
642     // return the null string for anonymous text because it is non-trivial to get
643     // the actual text and, so far, that is not needed
644     return String();
645 }
646
647 Node* AccessibilityRenderObject::node() const
648
649     return m_renderer ? m_renderer->node() : 0; 
650 }    
651     
652 String AccessibilityRenderObject::stringValue() const
653 {
654     if (!m_renderer)
655         return String();
656
657     if (isPasswordField())
658         return passwordFieldValue();
659
660     RenderBoxModelObject* cssBox = renderBoxModelObject();
661
662     if (ariaRoleAttribute() == StaticTextRole) {
663         String staticText = text();
664         if (!staticText.length())
665             staticText = textUnderElement();
666         return staticText;
667     }
668         
669     if (m_renderer->isText())
670         return textUnderElement();
671     
672     if (cssBox && cssBox->isMenuList()) {
673         // RenderMenuList will go straight to the text() of its selected item.
674         // This has to be overridden in the case where the selected item has an ARIA label.
675         HTMLSelectElement* selectElement = toHTMLSelectElement(m_renderer->node());
676         int selectedIndex = selectElement->selectedIndex();
677         const Vector<HTMLElement*> listItems = selectElement->listItems();
678         if (selectedIndex >= 0 && static_cast<size_t>(selectedIndex) < listItems.size()) {
679             const AtomicString& overriddenDescription = listItems[selectedIndex]->fastGetAttribute(aria_labelAttr);
680             if (!overriddenDescription.isNull())
681                 return overriddenDescription;
682         }
683         return toRenderMenuList(m_renderer)->text();
684     }
685     
686     if (m_renderer->isListMarker())
687         return toRenderListMarker(m_renderer)->text();
688     
689     if (isWebArea()) {
690         // FIXME: Why would a renderer exist when the Document isn't attached to a frame?
691         if (m_renderer->frame())
692             return String();
693
694         ASSERT_NOT_REACHED();
695     }
696     
697     if (isTextControl())
698         return text();
699     
700     if (m_renderer->isFileUploadControl())
701         return toRenderFileUploadControl(m_renderer)->fileTextValue();
702     
703     // FIXME: We might need to implement a value here for more types
704     // FIXME: It would be better not to advertise a value at all for the types for which we don't implement one;
705     // this would require subclassing or making accessibilityAttributeNames do something other than return a
706     // single static array.
707     return String();
708 }
709
710 HTMLLabelElement* AccessibilityRenderObject::labelElementContainer() const
711 {
712     if (!m_renderer)
713         return 0;
714
715     // the control element should not be considered part of the label
716     if (isControl())
717         return 0;
718     
719     // find if this has a parent that is a label
720     for (Node* parentNode = m_renderer->node(); parentNode; parentNode = parentNode->parentNode()) {
721         if (parentNode->hasTagName(labelTag))
722             return static_cast<HTMLLabelElement*>(parentNode);
723     }
724     
725     return 0;
726 }
727
728 String AccessibilityRenderObject::ariaDescribedByAttribute() const
729 {
730     Vector<Element*> elements;
731     elementsFromAttribute(elements, aria_describedbyAttr);
732     
733     return accessibilityDescriptionForElements(elements);
734 }
735     
736 String AccessibilityRenderObject::webAreaAccessibilityDescription() const
737 {
738     // The WebArea description should follow this order:
739     //     aria-label on the <html>
740     //     title on the <html>
741     //     <title> inside the <head> (of it was set through JS)
742     //     name on the <html>
743     // For iframes:
744     //     aria-label on the <iframe>
745     //     title on the <iframe>
746     //     name on the <iframe>
747     
748     if (!m_renderer)
749         return String();
750     
751     Document* document = m_renderer->document();
752     
753     // Check if the HTML element has an aria-label for the webpage.
754     if (Element* documentElement = document->documentElement()) {
755         const AtomicString& ariaLabel = documentElement->getAttribute(aria_labelAttr);
756         if (!ariaLabel.isEmpty())
757             return ariaLabel;
758     }
759     
760     Node* owner = document->ownerElement();
761     if (owner) {
762         if (owner->hasTagName(frameTag) || owner->hasTagName(iframeTag)) {
763             const AtomicString& title = static_cast<HTMLFrameElementBase*>(owner)->getAttribute(titleAttr);
764             if (!title.isEmpty())
765                 return title;
766             return static_cast<HTMLFrameElementBase*>(owner)->getNameAttribute();
767         }
768         if (owner->isHTMLElement())
769             return toHTMLElement(owner)->getNameAttribute();
770     }
771
772     String documentTitle = document->title();
773     if (!documentTitle.isEmpty())
774         return documentTitle;
775     
776     owner = document->body();
777     if (owner && owner->isHTMLElement())
778         return toHTMLElement(owner)->getNameAttribute();
779     
780     return String();
781 }
782     
783 String AccessibilityRenderObject::accessibilityDescription() const
784 {
785     if (!m_renderer)
786         return String();
787
788     if (isWebArea())
789         return webAreaAccessibilityDescription();
790
791     return AccessibilityNodeObject::accessibilityDescription();
792 }
793
794 LayoutRect AccessibilityRenderObject::boundingBoxRect() const
795 {
796     RenderObject* obj = m_renderer;
797     
798     if (!obj)
799         return LayoutRect();
800     
801     if (obj->node()) // If we are a continuation, we want to make sure to use the primary renderer.
802         obj = obj->node()->renderer();
803     
804     // absoluteFocusRingQuads will query the hierarchy below this element, which for large webpages can be very slow.
805     // For a web area, which will have the most elements of any element, absoluteQuads should be used.
806     Vector<FloatQuad> quads;
807     if (obj->isText())
808         toRenderText(obj)->absoluteQuads(quads, 0, RenderText::ClipToEllipsis);
809     else if (isWebArea())
810         obj->absoluteQuads(quads);
811     else
812         obj->absoluteFocusRingQuads(quads);
813     
814     LayoutRect result = boundingBoxForQuads(obj, quads);
815
816     // The size of the web area should be the content size, not the clipped size.
817     if (isWebArea() && obj->frame()->view())
818         result.setSize(obj->frame()->view()->contentsSize());
819     
820     return result;
821 }
822     
823 LayoutRect AccessibilityRenderObject::checkboxOrRadioRect() const
824 {
825     if (!m_renderer)
826         return LayoutRect();
827     
828     HTMLLabelElement* label = labelForElement(static_cast<Element*>(m_renderer->node()));
829     if (!label || !label->renderer())
830         return boundingBoxRect();
831     
832     LayoutRect labelRect = axObjectCache()->getOrCreate(label)->elementRect();
833     labelRect.unite(boundingBoxRect());
834     return labelRect;
835 }
836
837 LayoutRect AccessibilityRenderObject::elementRect() const
838 {
839     // a checkbox or radio button should encompass its label
840     if (isCheckboxOrRadio())
841         return checkboxOrRadioRect();
842     
843     return boundingBoxRect();
844 }
845
846 IntPoint AccessibilityRenderObject::clickPoint()
847 {
848     // Headings are usually much wider than their textual content. If the mid point is used, often it can be wrong.
849     if (isHeading() && children().size() == 1)
850         return children()[0]->clickPoint();
851
852     // use the default position unless this is an editable web area, in which case we use the selection bounds.
853     if (!isWebArea() || isReadOnly())
854         return AccessibilityObject::clickPoint();
855     
856     VisibleSelection visSelection = selection();
857     VisiblePositionRange range = VisiblePositionRange(visSelection.visibleStart(), visSelection.visibleEnd());
858     IntRect bounds = boundsForVisiblePositionRange(range);
859 #if PLATFORM(MAC)
860     bounds.setLocation(m_renderer->document()->view()->screenToContents(bounds.location()));
861 #endif        
862     return IntPoint(bounds.x() + (bounds.width() / 2), bounds.y() - (bounds.height() / 2));
863 }
864     
865 AccessibilityObject* AccessibilityRenderObject::internalLinkElement() const
866 {
867     Element* element = anchorElement();
868     if (!element)
869         return 0;
870     
871     // Right now, we do not support ARIA links as internal link elements
872     if (!element->hasTagName(aTag))
873         return 0;
874     HTMLAnchorElement* anchor = static_cast<HTMLAnchorElement*>(element);
875     
876     KURL linkURL = anchor->href();
877     String fragmentIdentifier = linkURL.fragmentIdentifier();
878     if (fragmentIdentifier.isEmpty())
879         return 0;
880     
881     // check if URL is the same as current URL
882     KURL documentURL = m_renderer->document()->url();
883     if (!equalIgnoringFragmentIdentifier(documentURL, linkURL))
884         return 0;
885     
886     Node* linkedNode = m_renderer->document()->findAnchor(fragmentIdentifier);
887     if (!linkedNode)
888         return 0;
889     
890     // The element we find may not be accessible, so find the first accessible object.
891     return firstAccessibleObjectFromNode(linkedNode);
892 }
893
894 ESpeak AccessibilityRenderObject::speakProperty() const
895 {
896     if (!m_renderer)
897         return AccessibilityObject::speakProperty();
898     
899     return m_renderer->style()->speak();
900 }
901     
902 void AccessibilityRenderObject::addRadioButtonGroupMembers(AccessibilityChildrenVector& linkedUIElements) const
903 {
904     if (!m_renderer || roleValue() != RadioButtonRole)
905         return;
906     
907     Node* node = m_renderer->node();
908     if (!node || !node->hasTagName(inputTag))
909         return;
910     
911     HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
912     // if there's a form, then this is easy
913     if (input->form()) {
914         Vector<RefPtr<Node> > formElements;
915         input->form()->getNamedElements(input->name(), formElements);
916         
917         unsigned len = formElements.size();
918         for (unsigned i = 0; i < len; ++i) {
919             Node* associateElement = formElements[i].get();
920             if (AccessibilityObject* object = axObjectCache()->getOrCreate(associateElement))
921                 linkedUIElements.append(object);        
922         } 
923     } else {
924         RefPtr<NodeList> list = node->document()->getElementsByTagName("input");
925         unsigned len = list->length();
926         for (unsigned i = 0; i < len; ++i) {
927             if (list->item(i)->hasTagName(inputTag)) {
928                 HTMLInputElement* associateElement = static_cast<HTMLInputElement*>(list->item(i));
929                 if (associateElement->isRadioButton() && associateElement->name() == input->name()) {
930                     if (AccessibilityObject* object = axObjectCache()->getOrCreate(associateElement))
931                         linkedUIElements.append(object);
932                 }
933             }
934         }
935     }
936 }
937     
938 // linked ui elements could be all the related radio buttons in a group
939 // or an internal anchor connection
940 void AccessibilityRenderObject::linkedUIElements(AccessibilityChildrenVector& linkedUIElements) const
941 {
942     ariaFlowToElements(linkedUIElements);
943
944     if (isAnchor()) {
945         AccessibilityObject* linkedAXElement = internalLinkElement();
946         if (linkedAXElement)
947             linkedUIElements.append(linkedAXElement);
948     }
949
950     if (roleValue() == RadioButtonRole)
951         addRadioButtonGroupMembers(linkedUIElements);
952 }
953
954 bool AccessibilityRenderObject::hasTextAlternative() const
955 {
956     // ARIA: section 2A, bullet #3 says if aria-labeledby or aria-label appears, it should
957     // override the "label" element association.
958     if (!ariaLabeledByAttribute().isEmpty() || !getAttribute(aria_labelAttr).isEmpty())
959         return true;
960         
961     return false;   
962 }
963     
964 bool AccessibilityRenderObject::ariaHasPopup() const
965 {
966     return elementAttributeValue(aria_haspopupAttr);
967 }
968
969 bool AccessibilityRenderObject::supportsARIAFlowTo() const
970 {
971     return !getAttribute(aria_flowtoAttr).isEmpty();
972 }
973     
974 void AccessibilityRenderObject::ariaFlowToElements(AccessibilityChildrenVector& flowTo) const
975 {
976     Vector<Element*> elements;
977     elementsFromAttribute(elements, aria_flowtoAttr);
978     
979     AXObjectCache* cache = axObjectCache();
980     unsigned count = elements.size();
981     for (unsigned k = 0; k < count; ++k) {
982         Element* element = elements[k];
983         AccessibilityObject* flowToElement = cache->getOrCreate(element);
984         if (flowToElement)
985             flowTo.append(flowToElement);
986     }
987         
988 }
989     
990 bool AccessibilityRenderObject::supportsARIADropping() const 
991 {
992     const AtomicString& dropEffect = getAttribute(aria_dropeffectAttr);
993     return !dropEffect.isEmpty();
994 }
995
996 bool AccessibilityRenderObject::supportsARIADragging() const
997 {
998     const AtomicString& grabbed = getAttribute(aria_grabbedAttr);
999     return equalIgnoringCase(grabbed, "true") || equalIgnoringCase(grabbed, "false");   
1000 }
1001
1002 bool AccessibilityRenderObject::isARIAGrabbed()
1003 {
1004     return elementAttributeValue(aria_grabbedAttr);
1005 }
1006
1007 void AccessibilityRenderObject::determineARIADropEffects(Vector<String>& effects)
1008 {
1009     const AtomicString& dropEffects = getAttribute(aria_dropeffectAttr);
1010     if (dropEffects.isEmpty()) {
1011         effects.clear();
1012         return;
1013     }
1014     
1015     String dropEffectsString = dropEffects.string();
1016     dropEffectsString.replace('\n', ' ');
1017     dropEffectsString.split(' ', effects);
1018 }
1019     
1020 bool AccessibilityRenderObject::exposesTitleUIElement() const
1021 {
1022     if (!isControl())
1023         return false;
1024
1025     // If this control is ignored (because it's invisible), 
1026     // then the label needs to be exposed so it can be visible to accessibility.
1027     if (accessibilityIsIgnored())
1028         return true;
1029     
1030     // Checkboxes and radio buttons use the text of their title ui element as their own AXTitle.
1031     // This code controls whether the title ui element should appear in the AX tree (usually, no).
1032     // It should appear if the control already has a label (which will be used as the AXTitle instead).
1033     if (isCheckboxOrRadio())
1034         return hasTextAlternative();
1035
1036     // When controls have their own descriptions, the title element should be ignored.
1037     if (hasTextAlternative())
1038         return false;
1039     
1040     return true;
1041 }
1042     
1043 AccessibilityObject* AccessibilityRenderObject::titleUIElement() const
1044 {
1045     if (!m_renderer)
1046         return 0;
1047     
1048     // if isFieldset is true, the renderer is guaranteed to be a RenderFieldset
1049     if (isFieldset())
1050         return axObjectCache()->getOrCreate(toRenderFieldset(m_renderer)->findLegend());
1051     
1052     Node* element = m_renderer->node();
1053     if (!element)
1054         return 0;
1055     HTMLLabelElement* label = labelForElement(static_cast<Element*>(element));
1056     if (label && label->renderer())
1057         return axObjectCache()->getOrCreate(label);
1058
1059     return 0;   
1060 }
1061     
1062 bool AccessibilityRenderObject::ariaIsHidden() const
1063 {
1064     if (equalIgnoringCase(getAttribute(aria_hiddenAttr), "true"))
1065         return true;
1066     
1067     // aria-hidden hides this object and any children
1068     AccessibilityObject* object = parentObject();
1069     while (object) {
1070         if (equalIgnoringCase(object->getAttribute(aria_hiddenAttr), "true"))
1071             return true;
1072         object = object->parentObject();
1073     }
1074
1075     return false;
1076 }
1077
1078 bool AccessibilityRenderObject::isAllowedChildOfTree() const
1079 {
1080     // Determine if this is in a tree. If so, we apply special behavior to make it work like an AXOutline.
1081     AccessibilityObject* axObj = parentObject();
1082     bool isInTree = false;
1083     while (axObj) {
1084         if (axObj->isTree()) {
1085             isInTree = true;
1086             break;
1087         }
1088         axObj = axObj->parentObject();
1089     }
1090     
1091     // If the object is in a tree, only tree items should be exposed (and the children of tree items).
1092     if (isInTree) {
1093         AccessibilityRole role = roleValue();
1094         if (role != TreeItemRole && role != StaticTextRole)
1095             return false;
1096     }
1097     return true;
1098 }
1099     
1100 AccessibilityObjectInclusion AccessibilityRenderObject::accessibilityIsIgnoredBase() const
1101 {
1102     // The following cases can apply to any element that's a subclass of AccessibilityRenderObject.
1103     
1104     // Ignore invisible elements.
1105     if (!m_renderer || m_renderer->style()->visibility() != VISIBLE)
1106         return IgnoreObject;
1107
1108     // Anything marked as aria-hidden or a child of something aria-hidden must be hidden.
1109     if (ariaIsHidden())
1110         return IgnoreObject;
1111     
1112     // Anything that is a presentational role must be hidden.
1113     if (isPresentationalChildOfAriaRole())
1114         return IgnoreObject;
1115
1116     // Allow the platform to make a decision.
1117     AccessibilityObjectInclusion decision = accessibilityPlatformIncludesObject();
1118     if (decision == IncludeObject)
1119         return IncludeObject;
1120     if (decision == IgnoreObject)
1121         return IgnoreObject;
1122         
1123     return DefaultBehavior;
1124 }  
1125  
1126 bool AccessibilityRenderObject::accessibilityIsIgnored() const
1127 {
1128     // Check first if any of the common reasons cause this element to be ignored.
1129     // Then process other use cases that need to be applied to all the various roles
1130     // that AccessibilityRenderObjects take on.
1131     AccessibilityObjectInclusion decision = accessibilityIsIgnoredBase();
1132     if (decision == IncludeObject)
1133         return false;
1134     if (decision == IgnoreObject)
1135         return true;
1136     
1137     // If this element is within a parent that cannot have children, it should not be exposed.
1138     if (isDescendantOfBarrenParent())
1139         return true;    
1140     
1141     if (roleValue() == IgnoredRole)
1142         return true;
1143     
1144     if (roleValue() == PresentationalRole || inheritsPresentationalRole())
1145         return true;
1146     
1147     // An ARIA tree can only have tree items and static text as children.
1148     if (!isAllowedChildOfTree())
1149         return true;
1150
1151     // Allow the platform to decide if the attachment is ignored or not.
1152     if (isAttachment())
1153         return accessibilityIgnoreAttachment();
1154     
1155     // ignore popup menu items because AppKit does
1156     for (RenderObject* parent = m_renderer->parent(); parent; parent = parent->parent()) {
1157         if (parent->isBoxModelObject() && toRenderBoxModelObject(parent)->isMenuList())
1158             return true;
1159     }
1160
1161     // find out if this element is inside of a label element.
1162     // if so, it may be ignored because it's the label for a checkbox or radio button
1163     AccessibilityObject* controlObject = correspondingControlForLabelElement();
1164     if (controlObject && !controlObject->exposesTitleUIElement() && controlObject->isCheckboxOrRadio())
1165         return true;
1166         
1167     // NOTE: BRs always have text boxes now, so the text box check here can be removed
1168     if (m_renderer->isText()) {
1169         // static text beneath MenuItems and MenuButtons are just reported along with the menu item, so it's ignored on an individual level
1170         if (parentObjectUnignored()->ariaRoleAttribute() == MenuItemRole
1171             || parentObjectUnignored()->ariaRoleAttribute() == MenuButtonRole)
1172             return true;
1173         RenderText* renderText = toRenderText(m_renderer);
1174         if (m_renderer->isBR() || !renderText->firstTextBox())
1175             return true;
1176
1177         // static text beneath TextControls is reported along with the text control text so it's ignored.
1178         for (AccessibilityObject* parent = parentObject(); parent; parent = parent->parentObject()) { 
1179             if (parent->roleValue() == TextFieldRole)
1180                 return true;
1181         }
1182
1183         // text elements that are just empty whitespace should not be returned
1184         return renderText->text()->containsOnlyWhitespace();
1185     }
1186     
1187     if (isHeading())
1188         return false;
1189     
1190     if (isLink())
1191         return false;
1192     
1193     // all controls are accessible
1194     if (isControl())
1195         return false;
1196     
1197     if (ariaRoleAttribute() != UnknownRole)
1198         return false;
1199
1200     // don't ignore labels, because they serve as TitleUIElements
1201     Node* node = m_renderer->node();
1202     if (node && node->hasTagName(labelTag))
1203         return false;
1204     
1205     // Anything that is content editable should not be ignored.
1206     // However, one cannot just call node->rendererIsEditable() since that will ask if its parents
1207     // are also editable. Only the top level content editable region should be exposed.
1208     if (hasContentEditableAttributeSet())
1209         return false;
1210     
1211     // List items play an important role in defining the structure of lists. They should not be ignored.
1212     if (roleValue() == ListItemRole)
1213         return false;
1214     
1215     // if this element has aria attributes on it, it should not be ignored.
1216     if (supportsARIAAttributes())
1217         return false;
1218
1219     // <span> tags are inline tags and not meant to convey information if they have no other aria
1220     // information on them. If we don't ignore them, they may emit signals expected to come from
1221     // their parent. In addition, because included spans are GroupRole objects, and GroupRole
1222     // objects are often containers with meaningful information, the inclusion of a span can have
1223     // the side effect of causing the immediate parent accessible to be ignored. This is especially
1224     // problematic for platforms which have distinct roles for textual block elements.
1225     if (node && node->hasTagName(spanTag))
1226         return true;
1227     
1228     if (m_renderer->isBlockFlow() && m_renderer->childrenInline() && !canSetFocusAttribute())
1229         return !toRenderBlock(m_renderer)->firstLineBox() && !mouseButtonListener();
1230     
1231     // ignore images seemingly used as spacers
1232     if (isImage()) {
1233         
1234         // If the image can take focus, it should not be ignored, lest the user not be able to interact with something important.
1235         if (canSetFocusAttribute())
1236             return false;
1237         
1238         if (node && node->isElementNode()) {
1239             Element* elt = static_cast<Element*>(node);
1240             const AtomicString& alt = elt->getAttribute(altAttr);
1241             // don't ignore an image that has an alt tag
1242             if (!alt.string().containsOnlyWhitespace())
1243                 return false;
1244             // informal standard is to ignore images with zero-length alt strings
1245             if (!alt.isNull())
1246                 return true;
1247         }
1248         
1249         if (isNativeImage()) {
1250             // check for one-dimensional image
1251             RenderImage* image = toRenderImage(m_renderer);
1252             if (image->height() <= 1 || image->width() <= 1)
1253                 return true;
1254             
1255             // check whether rendered image was stretched from one-dimensional file image
1256             if (image->cachedImage()) {
1257                 LayoutSize imageSize = image->cachedImage()->imageSizeForRenderer(m_renderer, image->view()->zoomFactor());
1258                 return imageSize.height() <= 1 || imageSize.width() <= 1;
1259             }
1260         }
1261         return false;
1262     }
1263
1264     if (isCanvas()) {
1265         if (canvasHasFallbackContent())
1266             return false;
1267         RenderHTMLCanvas* canvas = toRenderHTMLCanvas(m_renderer);
1268         if (canvas->height() <= 1 || canvas->width() <= 1)
1269             return true;
1270         // Otherwise fall through; use presence of help text, title, or description to decide.
1271     }
1272
1273     if (isWebArea() || m_renderer->isListMarker())
1274         return false;
1275     
1276     // Using the help text, title or accessibility description (so we
1277     // check if there's some kind of accessible name for the element)
1278     // to decide an element's visibility is not as definitive as
1279     // previous checks, so this should remain as one of the last.
1280     if (!helpText().isEmpty() || !title().isEmpty() || !accessibilityDescription().isEmpty())
1281         return false;
1282     
1283     // By default, objects should be ignored so that the AX hierarchy is not 
1284     // filled with unnecessary items.
1285     return true;
1286 }
1287
1288 bool AccessibilityRenderObject::isLoaded() const
1289 {
1290     return !m_renderer->document()->parser();
1291 }
1292
1293 double AccessibilityRenderObject::estimatedLoadingProgress() const
1294 {
1295     if (!m_renderer)
1296         return 0;
1297     
1298     if (isLoaded())
1299         return 1.0;
1300     
1301     Page* page = m_renderer->document()->page();
1302     if (!page)
1303         return 0;
1304     
1305     return page->progress()->estimatedProgress();
1306 }
1307     
1308 int AccessibilityRenderObject::layoutCount() const
1309 {
1310     if (!m_renderer->isRenderView())
1311         return 0;
1312     return toRenderView(m_renderer)->frameView()->layoutCount();
1313 }
1314
1315 String AccessibilityRenderObject::text() const
1316 {
1317     if (isPasswordField())
1318         return passwordFieldValue();
1319
1320     return AccessibilityNodeObject::text();
1321 }
1322     
1323 int AccessibilityRenderObject::textLength() const
1324 {
1325     ASSERT(isTextControl());
1326     
1327     if (isPasswordField())
1328 #if PLATFORM(GTK)
1329         return passwordFieldValue().length();
1330 #else
1331         return -1; // need to return something distinct from 0
1332 #endif
1333
1334     return text().length();
1335 }
1336
1337 PlainTextRange AccessibilityRenderObject::ariaSelectedTextRange() const
1338 {
1339     Node* node = m_renderer->node();
1340     if (!node)
1341         return PlainTextRange();
1342     
1343     ExceptionCode ec = 0;
1344     VisibleSelection visibleSelection = selection();
1345     RefPtr<Range> currentSelectionRange = visibleSelection.toNormalizedRange();
1346     if (!currentSelectionRange || !currentSelectionRange->intersectsNode(node, ec))
1347         return PlainTextRange();
1348     
1349     int start = indexForVisiblePosition(visibleSelection.start());
1350     int end = indexForVisiblePosition(visibleSelection.end());
1351     
1352     return PlainTextRange(start, end - start);
1353 }
1354
1355 String AccessibilityRenderObject::selectedText() const
1356 {
1357     ASSERT(isTextControl());
1358     
1359     if (isPasswordField())
1360         return String(); // need to return something distinct from empty string
1361     
1362     if (isNativeTextControl()) {
1363         HTMLTextFormControlElement* textControl = toRenderTextControl(m_renderer)->textFormControlElement();
1364         return textControl->selectedText();
1365     }
1366     
1367     if (ariaRoleAttribute() == UnknownRole)
1368         return String();
1369     
1370     return doAXStringForRange(ariaSelectedTextRange());
1371 }
1372
1373 const AtomicString& AccessibilityRenderObject::accessKey() const
1374 {
1375     Node* node = m_renderer->node();
1376     if (!node)
1377         return nullAtom;
1378     if (!node->isElementNode())
1379         return nullAtom;
1380     return static_cast<Element*>(node)->getAttribute(accesskeyAttr);
1381 }
1382
1383 VisibleSelection AccessibilityRenderObject::selection() const
1384 {
1385     return m_renderer->frame()->selection()->selection();
1386 }
1387
1388 PlainTextRange AccessibilityRenderObject::selectedTextRange() const
1389 {
1390     ASSERT(isTextControl());
1391     
1392     if (isPasswordField())
1393         return PlainTextRange();
1394     
1395     AccessibilityRole ariaRole = ariaRoleAttribute();
1396     if (isNativeTextControl() && ariaRole == UnknownRole) {
1397         HTMLTextFormControlElement* textControl = toRenderTextControl(m_renderer)->textFormControlElement();
1398         return PlainTextRange(textControl->selectionStart(), textControl->selectionEnd() - textControl->selectionStart());
1399     }
1400     
1401     if (ariaRole == UnknownRole)
1402         return PlainTextRange();
1403     
1404     return ariaSelectedTextRange();
1405 }
1406
1407 void AccessibilityRenderObject::setSelectedTextRange(const PlainTextRange& range)
1408 {
1409     if (isNativeTextControl()) {
1410         HTMLTextFormControlElement* textControl = toRenderTextControl(m_renderer)->textFormControlElement();
1411         textControl->setSelectionRange(range.start, range.start + range.length);
1412         return;
1413     }
1414
1415     Document* document = m_renderer->document();
1416     if (!document)
1417         return;
1418     Frame* frame = document->frame();
1419     if (!frame)
1420         return;
1421     Node* node = m_renderer->node();
1422     frame->selection()->setSelection(VisibleSelection(Position(node, range.start, Position::PositionIsOffsetInAnchor),
1423         Position(node, range.start + range.length, Position::PositionIsOffsetInAnchor), DOWNSTREAM));
1424 }
1425
1426 KURL AccessibilityRenderObject::url() const
1427 {
1428     if (isAnchor() && m_renderer->node()->hasTagName(aTag)) {
1429         if (HTMLAnchorElement* anchor = static_cast<HTMLAnchorElement*>(anchorElement()))
1430             return anchor->href();
1431     }
1432     
1433     if (isWebArea())
1434         return m_renderer->document()->url();
1435     
1436     if (isImage() && m_renderer->node() && m_renderer->node()->hasTagName(imgTag))
1437         return static_cast<HTMLImageElement*>(m_renderer->node())->src();
1438     
1439     if (isInputImage())
1440         return static_cast<HTMLInputElement*>(m_renderer->node())->src();
1441     
1442     return KURL();
1443 }
1444
1445 bool AccessibilityRenderObject::isUnvisited() const
1446 {
1447     // FIXME: Is it a privacy violation to expose unvisited information to accessibility APIs?
1448     return m_renderer->style()->isLink() && m_renderer->style()->insideLink() == InsideUnvisitedLink;
1449 }
1450
1451 bool AccessibilityRenderObject::isVisited() const
1452 {
1453     // FIXME: Is it a privacy violation to expose visited information to accessibility APIs?
1454     return m_renderer->style()->isLink() && m_renderer->style()->insideLink() == InsideVisitedLink;
1455 }
1456
1457 void AccessibilityRenderObject::setElementAttributeValue(const QualifiedName& attributeName, bool value)
1458 {
1459     if (!m_renderer)
1460         return;
1461     
1462     Node* node = m_renderer->node();
1463     if (!node || !node->isElementNode())
1464         return;
1465     
1466     Element* element = static_cast<Element*>(node);
1467     element->setAttribute(attributeName, (value) ? "true" : "false");        
1468 }
1469     
1470 bool AccessibilityRenderObject::elementAttributeValue(const QualifiedName& attributeName) const
1471 {
1472     if (!m_renderer)
1473         return false;
1474     
1475     return equalIgnoringCase(getAttribute(attributeName), "true");
1476 }
1477     
1478 bool AccessibilityRenderObject::isSelected() const
1479 {
1480     if (!m_renderer)
1481         return false;
1482     
1483     Node* node = m_renderer->node();
1484     if (!node)
1485         return false;
1486     
1487     const AtomicString& ariaSelected = getAttribute(aria_selectedAttr);
1488     if (equalIgnoringCase(ariaSelected, "true"))
1489         return true;    
1490     
1491     if (isTabItem() && isTabItemSelected())
1492         return true;
1493
1494     return false;
1495 }
1496
1497 bool AccessibilityRenderObject::isTabItemSelected() const
1498 {
1499     if (!isTabItem() || !m_renderer)
1500         return false;
1501     
1502     Node* node = m_renderer->node();
1503     if (!node || !node->isElementNode())
1504         return false;
1505     
1506     // The ARIA spec says a tab item can also be selected if it is aria-labeled by a tabpanel
1507     // that has keyboard focus inside of it, or if a tabpanel in its aria-controls list has KB
1508     // focus inside of it.
1509     AccessibilityObject* focusedElement = focusedUIElement();
1510     if (!focusedElement)
1511         return false;
1512     
1513     Vector<Element*> elements;
1514     elementsFromAttribute(elements, aria_controlsAttr);
1515     
1516     unsigned count = elements.size();
1517     for (unsigned k = 0; k < count; ++k) {
1518         Element* element = elements[k];
1519         AccessibilityObject* tabPanel = axObjectCache()->getOrCreate(element);
1520
1521         // A tab item should only control tab panels.
1522         if (!tabPanel || tabPanel->roleValue() != TabPanelRole)
1523             continue;
1524         
1525         AccessibilityObject* checkFocusElement = focusedElement;
1526         // Check if the focused element is a descendant of the element controlled by the tab item.
1527         while (checkFocusElement) {
1528             if (tabPanel == checkFocusElement)
1529                 return true;
1530             checkFocusElement = checkFocusElement->parentObject();
1531         }
1532     }
1533     
1534     return false;
1535 }
1536     
1537 bool AccessibilityRenderObject::isFocused() const
1538 {
1539     if (!m_renderer)
1540         return false;
1541     
1542     Document* document = m_renderer->document();
1543     if (!document)
1544         return false;
1545     
1546     Node* focusedNode = document->focusedNode();
1547     if (!focusedNode)
1548         return false;
1549     
1550     // A web area is represented by the Document node in the DOM tree, which isn't focusable.
1551     // Check instead if the frame's selection controller is focused
1552     if (focusedNode == m_renderer->node()
1553         || (roleValue() == WebAreaRole && document->frame()->selection()->isFocusedAndActive()))
1554         return true;
1555     
1556     return false;
1557 }
1558
1559 void AccessibilityRenderObject::setFocused(bool on)
1560 {
1561     if (!canSetFocusAttribute())
1562         return;
1563     
1564     if (!on)
1565         m_renderer->document()->setFocusedNode(0);
1566     else {
1567         if (m_renderer->node()->isElementNode())
1568             static_cast<Element*>(m_renderer->node())->focus();
1569         else
1570             m_renderer->document()->setFocusedNode(m_renderer->node());
1571     }
1572 }
1573
1574 void AccessibilityRenderObject::setSelectedRows(AccessibilityChildrenVector& selectedRows)
1575 {
1576     // Setting selected only makes sense in trees and tables (and tree-tables).
1577     AccessibilityRole role = roleValue();
1578     if (role != TreeRole && role != TreeGridRole && role != TableRole)
1579         return;
1580     
1581     bool isMulti = isMultiSelectable();
1582     unsigned count = selectedRows.size();
1583     if (count > 1 && !isMulti)
1584         count = 1;
1585     
1586     for (unsigned k = 0; k < count; ++k)
1587         selectedRows[k]->setSelected(true);
1588 }
1589     
1590 void AccessibilityRenderObject::setValue(const String& string)
1591 {
1592     if (!m_renderer || !m_renderer->node() || !m_renderer->node()->isElementNode())
1593         return;
1594     Element* element = static_cast<Element*>(m_renderer->node());
1595
1596     if (!m_renderer->isBoxModelObject())
1597         return;
1598     RenderBoxModelObject* renderer = toRenderBoxModelObject(m_renderer);
1599
1600     // FIXME: Do we want to do anything here for ARIA textboxes?
1601     if (renderer->isTextField()) {
1602         // FIXME: This is not safe!  Other elements could have a TextField renderer.
1603         static_cast<HTMLInputElement*>(element)->setValue(string);
1604     } else if (renderer->isTextArea()) {
1605         // FIXME: This is not safe!  Other elements could have a TextArea renderer.
1606         static_cast<HTMLTextAreaElement*>(element)->setValue(string);
1607     }
1608 }
1609
1610 void AccessibilityRenderObject::ariaOwnsElements(AccessibilityChildrenVector& axObjects) const
1611 {
1612     Vector<Element*> elements;
1613     elementsFromAttribute(elements, aria_ownsAttr);
1614     
1615     unsigned count = elements.size();
1616     for (unsigned k = 0; k < count; ++k) {
1617         RenderObject* render = elements[k]->renderer();
1618         AccessibilityObject* obj = axObjectCache()->getOrCreate(render);
1619         if (obj)
1620             axObjects.append(obj);
1621     }
1622 }
1623
1624 bool AccessibilityRenderObject::supportsARIAOwns() const
1625 {
1626     if (!m_renderer)
1627         return false;
1628     const AtomicString& ariaOwns = getAttribute(aria_ownsAttr);
1629
1630     return !ariaOwns.isEmpty();
1631 }
1632     
1633 RenderView* AccessibilityRenderObject::topRenderer() const
1634 {
1635     Document* topDoc = topDocument();
1636     if (!topDoc)
1637         return 0;
1638     
1639     return topDoc->renderView();
1640 }
1641
1642 Document* AccessibilityRenderObject::document() const
1643 {
1644     if (!m_renderer)
1645         return 0;
1646     return m_renderer->document();
1647 }
1648
1649 Document* AccessibilityRenderObject::topDocument() const
1650 {
1651     if (!document())
1652         return 0;
1653     return document()->topDocument();
1654 }
1655     
1656 FrameView* AccessibilityRenderObject::topDocumentFrameView() const
1657 {
1658     RenderView* renderView = topRenderer();
1659     if (!renderView || !renderView->view())
1660         return 0;
1661     return renderView->view()->frameView();
1662 }
1663
1664 Widget* AccessibilityRenderObject::widget() const
1665 {
1666     if (!m_renderer->isBoxModelObject() || !toRenderBoxModelObject(m_renderer)->isWidget())
1667         return 0;
1668     return toRenderWidget(m_renderer)->widget();
1669 }
1670
1671 AccessibilityObject* AccessibilityRenderObject::accessibilityParentForImageMap(HTMLMapElement* map) const
1672 {
1673     // find an image that is using this map
1674     if (!map)
1675         return 0;
1676
1677     HTMLImageElement* imageElement = map->imageElement();
1678     if (!imageElement)
1679         return 0;
1680     
1681     return axObjectCache()->getOrCreate(imageElement);
1682 }
1683     
1684 void AccessibilityRenderObject::getDocumentLinks(AccessibilityChildrenVector& result)
1685 {
1686     Document* document = m_renderer->document();
1687     RefPtr<HTMLCollection> links = document->links();
1688     for (unsigned i = 0; Node* curr = links->item(i); i++) {
1689         RenderObject* obj = curr->renderer();
1690         if (obj) {
1691             RefPtr<AccessibilityObject> axobj = document->axObjectCache()->getOrCreate(obj);
1692             ASSERT(axobj);
1693             if (!axobj->accessibilityIsIgnored() && axobj->isLink())
1694                 result.append(axobj);
1695         } else {
1696             Node* parent = curr->parentNode();
1697             if (parent && curr->hasTagName(areaTag) && parent->hasTagName(mapTag)) {
1698                 AccessibilityImageMapLink* areaObject = static_cast<AccessibilityImageMapLink*>(axObjectCache()->getOrCreate(ImageMapLinkRole));
1699                 areaObject->setHTMLAreaElement(static_cast<HTMLAreaElement*>(curr));
1700                 areaObject->setHTMLMapElement(static_cast<HTMLMapElement*>(parent));
1701                 areaObject->setParent(accessibilityParentForImageMap(static_cast<HTMLMapElement*>(parent)));
1702
1703                 result.append(areaObject);
1704             }
1705         }
1706     }
1707 }
1708
1709 FrameView* AccessibilityRenderObject::documentFrameView() const 
1710
1711     if (!m_renderer || !m_renderer->document()) 
1712         return 0; 
1713
1714     // this is the RenderObject's Document's Frame's FrameView 
1715     return m_renderer->document()->view();
1716 }
1717
1718 Widget* AccessibilityRenderObject::widgetForAttachmentView() const
1719 {
1720     if (!isAttachment())
1721         return 0;
1722     return toRenderWidget(m_renderer)->widget();
1723 }
1724
1725 FrameView* AccessibilityRenderObject::frameViewIfRenderView() const
1726 {
1727     if (!m_renderer->isRenderView())
1728         return 0;
1729     // this is the RenderObject's Document's renderer's FrameView
1730     return m_renderer->view()->frameView();
1731 }
1732
1733 // This function is like a cross-platform version of - (WebCoreTextMarkerRange*)textMarkerRange. It returns
1734 // a Range that we can convert to a WebCoreTextMarkerRange in the Obj-C file
1735 VisiblePositionRange AccessibilityRenderObject::visiblePositionRange() const
1736 {
1737     if (!m_renderer)
1738         return VisiblePositionRange();
1739     
1740     // construct VisiblePositions for start and end
1741     Node* node = m_renderer->node();
1742     if (!node)
1743         return VisiblePositionRange();
1744
1745     VisiblePosition startPos = firstPositionInOrBeforeNode(node);
1746     VisiblePosition endPos = lastPositionInOrAfterNode(node);
1747
1748     // the VisiblePositions are equal for nodes like buttons, so adjust for that
1749     // FIXME: Really?  [button, 0] and [button, 1] are distinct (before and after the button)
1750     // I expect this code is only hit for things like empty divs?  In which case I don't think
1751     // the behavior is correct here -- eseidel
1752     if (startPos == endPos) {
1753         endPos = endPos.next();
1754         if (endPos.isNull())
1755             endPos = startPos;
1756     }
1757
1758     return VisiblePositionRange(startPos, endPos);
1759 }
1760
1761 VisiblePositionRange AccessibilityRenderObject::visiblePositionRangeForLine(unsigned lineCount) const
1762 {
1763     if (!lineCount || !m_renderer)
1764         return VisiblePositionRange();
1765     
1766     // iterate over the lines
1767     // FIXME: this is wrong when lineNumber is lineCount+1,  because nextLinePosition takes you to the
1768     // last offset of the last line
1769     VisiblePosition visiblePos = m_renderer->document()->renderer()->positionForPoint(IntPoint());
1770     VisiblePosition savedVisiblePos;
1771     while (--lineCount) {
1772         savedVisiblePos = visiblePos;
1773         visiblePos = nextLinePosition(visiblePos, 0);
1774         if (visiblePos.isNull() || visiblePos == savedVisiblePos)
1775             return VisiblePositionRange();
1776     }
1777     
1778     // make a caret selection for the marker position, then extend it to the line
1779     // NOTE: ignores results of sel.modify because it returns false when
1780     // starting at an empty line.  The resulting selection in that case
1781     // will be a caret at visiblePos.
1782     FrameSelection selection;
1783     selection.setSelection(VisibleSelection(visiblePos));
1784     selection.modify(FrameSelection::AlterationExtend, DirectionRight, LineBoundary);
1785     
1786     return VisiblePositionRange(selection.selection().visibleStart(), selection.selection().visibleEnd());
1787 }
1788     
1789 VisiblePosition AccessibilityRenderObject::visiblePositionForIndex(int index) const
1790 {
1791     if (!m_renderer)
1792         return VisiblePosition();
1793     
1794     if (isNativeTextControl())
1795         return toRenderTextControl(m_renderer)->visiblePositionForIndex(index);
1796
1797     if (!allowsTextRanges() && !m_renderer->isText())
1798         return VisiblePosition();
1799     
1800     Node* node = m_renderer->node();
1801     if (!node)
1802         return VisiblePosition();
1803     
1804     if (index <= 0)
1805         return VisiblePosition(firstPositionInOrBeforeNode(node), DOWNSTREAM);
1806     
1807     ExceptionCode ec = 0;
1808     RefPtr<Range> range = Range::create(m_renderer->document());
1809     range->selectNodeContents(node, ec);
1810     CharacterIterator it(range.get());
1811     it.advance(index - 1);
1812     return VisiblePosition(Position(it.range()->endContainer(ec), it.range()->endOffset(ec), Position::PositionIsOffsetInAnchor), UPSTREAM);
1813 }
1814     
1815 int AccessibilityRenderObject::indexForVisiblePosition(const VisiblePosition& pos) const
1816 {
1817     if (isNativeTextControl()) {
1818         HTMLTextFormControlElement* textControl = toRenderTextControl(m_renderer)->textFormControlElement();
1819         return textControl->indexForVisiblePosition(pos);
1820     }
1821
1822     if (!isTextControl())
1823         return 0;
1824     
1825     Node* node = m_renderer->node();
1826     if (!node)
1827         return 0;
1828     
1829     Position indexPosition = pos.deepEquivalent();
1830     if (indexPosition.isNull() || highestEditableRoot(indexPosition, HasEditableAXRole) != node)
1831         return 0;
1832     
1833     ExceptionCode ec = 0;
1834     RefPtr<Range> range = Range::create(m_renderer->document());
1835     range->setStart(node, 0, ec);
1836     range->setEnd(indexPosition, ec);
1837
1838 #if PLATFORM(GTK)
1839     // We need to consider replaced elements for GTK, as they will be
1840     // presented with the 'object replacement character' (0xFFFC).
1841     return TextIterator::rangeLength(range.get(), true);
1842 #else
1843     return TextIterator::rangeLength(range.get());
1844 #endif
1845 }
1846
1847 Element* AccessibilityRenderObject::rootEditableElementForPosition(const Position& position) const
1848 {
1849     // Find the root editable or pseudo-editable (i.e. having an editable ARIA role) element.
1850     Element* result = 0;
1851     
1852     Element* rootEditableElement = position.rootEditableElement();
1853
1854     for (Element* e = position.element(); e && e != rootEditableElement; e = e->parentElement()) {
1855         if (nodeIsTextControl(e))
1856             result = e;
1857         if (e->hasTagName(bodyTag))
1858             break;
1859     }
1860
1861     if (result)
1862         return result;
1863
1864     return rootEditableElement;
1865 }
1866
1867 bool AccessibilityRenderObject::nodeIsTextControl(const Node* node) const
1868 {
1869     if (!node)
1870         return false;
1871
1872     const AccessibilityObject* axObjectForNode = axObjectCache()->getOrCreate(const_cast<Node*>(node));
1873     if (!axObjectForNode)
1874         return false;
1875
1876     return axObjectForNode->isTextControl();
1877 }
1878
1879 IntRect AccessibilityRenderObject::boundsForVisiblePositionRange(const VisiblePositionRange& visiblePositionRange) const
1880 {
1881     if (visiblePositionRange.isNull())
1882         return IntRect();
1883     
1884     // Create a mutable VisiblePositionRange.
1885     VisiblePositionRange range(visiblePositionRange);
1886     LayoutRect rect1 = range.start.absoluteCaretBounds();
1887     LayoutRect rect2 = range.end.absoluteCaretBounds();
1888     
1889     // 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
1890     if (rect2.y() != rect1.y()) {
1891         VisiblePosition endOfFirstLine = endOfLine(range.start);
1892         if (range.start == endOfFirstLine) {
1893             range.start.setAffinity(DOWNSTREAM);
1894             rect1 = range.start.absoluteCaretBounds();
1895         }
1896         if (range.end == endOfFirstLine) {
1897             range.end.setAffinity(UPSTREAM);
1898             rect2 = range.end.absoluteCaretBounds();
1899         }
1900     }
1901     
1902     LayoutRect ourrect = rect1;
1903     ourrect.unite(rect2);
1904     
1905     // if the rectangle spans lines and contains multiple text chars, use the range's bounding box intead
1906     if (rect1.maxY() != rect2.maxY()) {
1907         RefPtr<Range> dataRange = makeRange(range.start, range.end);
1908         LayoutRect boundingBox = dataRange->boundingBox();
1909         String rangeString = plainText(dataRange.get());
1910         if (rangeString.length() > 1 && !boundingBox.isEmpty())
1911             ourrect = boundingBox;
1912     }
1913     
1914 #if PLATFORM(MAC)
1915     return m_renderer->document()->view()->contentsToScreen(pixelSnappedIntRect(ourrect));
1916 #else
1917     return pixelSnappedIntRect(ourrect);
1918 #endif
1919 }
1920     
1921 void AccessibilityRenderObject::setSelectedVisiblePositionRange(const VisiblePositionRange& range) const
1922 {
1923     if (range.start.isNull() || range.end.isNull())
1924         return;
1925     
1926     // make selection and tell the document to use it. if it's zero length, then move to that position
1927     if (range.start == range.end)
1928         m_renderer->frame()->selection()->moveTo(range.start, UserTriggered);
1929     else {
1930         VisibleSelection newSelection = VisibleSelection(range.start, range.end);
1931         m_renderer->frame()->selection()->setSelection(newSelection);
1932     }    
1933 }
1934
1935 VisiblePosition AccessibilityRenderObject::visiblePositionForPoint(const IntPoint& point) const
1936 {
1937     if (!m_renderer)
1938         return VisiblePosition();
1939     
1940     // convert absolute point to view coordinates
1941     Document* topDoc = topDocument();
1942     if (!topDoc || !topDoc->renderer() || !topDoc->renderer()->view())
1943         return VisiblePosition();
1944     
1945     FrameView* frameView = topDoc->renderer()->view()->frameView();
1946     if (!frameView)
1947         return VisiblePosition();
1948     
1949     RenderView* renderView = topRenderer();
1950     if (!renderView)
1951         return VisiblePosition();
1952     
1953     Node* innerNode = 0;
1954     
1955     // locate the node containing the point
1956     LayoutPoint pointResult;
1957     while (1) {
1958         LayoutPoint ourpoint;
1959 #if PLATFORM(MAC)
1960         ourpoint = frameView->screenToContents(point);
1961 #else
1962         ourpoint = point;
1963 #endif
1964         HitTestRequest request(HitTestRequest::ReadOnly |
1965                                HitTestRequest::Active);
1966         HitTestResult result(ourpoint);
1967         renderView->hitTest(request, result);
1968         innerNode = result.innerNode();
1969         if (!innerNode)
1970             return VisiblePosition();
1971         
1972         RenderObject* renderer = innerNode->renderer();
1973         if (!renderer)
1974             return VisiblePosition();
1975         
1976         pointResult = result.localPoint();
1977
1978         // done if hit something other than a widget
1979         if (!renderer->isWidget())
1980             break;
1981
1982         // descend into widget (FRAME, IFRAME, OBJECT...)
1983         Widget* widget = toRenderWidget(renderer)->widget();
1984         if (!widget || !widget->isFrameView())
1985             break;
1986         Frame* frame = static_cast<FrameView*>(widget)->frame();
1987         if (!frame)
1988             break;
1989         renderView = frame->document()->renderView();
1990         frameView = static_cast<FrameView*>(widget);
1991     }
1992     
1993     return innerNode->renderer()->positionForPoint(pointResult);
1994 }
1995
1996 // NOTE: Consider providing this utility method as AX API
1997 VisiblePosition AccessibilityRenderObject::visiblePositionForIndex(unsigned indexValue, bool lastIndexOK) const
1998 {
1999     if (!isTextControl())
2000         return VisiblePosition();
2001     
2002     // lastIndexOK specifies whether the position after the last character is acceptable
2003     if (indexValue >= text().length()) {
2004         if (!lastIndexOK || indexValue > text().length())
2005             return VisiblePosition();
2006     }
2007     VisiblePosition position = visiblePositionForIndex(indexValue);
2008     position.setAffinity(DOWNSTREAM);
2009     return position;
2010 }
2011
2012 // NOTE: Consider providing this utility method as AX API
2013 int AccessibilityRenderObject::index(const VisiblePosition& position) const
2014 {
2015     if (position.isNull() || !isTextControl())
2016         return -1;
2017
2018     if (renderObjectContainsPosition(m_renderer, position.deepEquivalent()))
2019         return indexForVisiblePosition(position);
2020     
2021     return -1;
2022 }
2023
2024 // Given a line number, the range of characters of the text associated with this accessibility
2025 // object that contains the line number.
2026 PlainTextRange AccessibilityRenderObject::doAXRangeForLine(unsigned lineNumber) const
2027 {
2028     if (!isTextControl())
2029         return PlainTextRange();
2030     
2031     // iterate to the specified line
2032     VisiblePosition visiblePos = visiblePositionForIndex(0);
2033     VisiblePosition savedVisiblePos;
2034     for (unsigned lineCount = lineNumber; lineCount; lineCount -= 1) {
2035         savedVisiblePos = visiblePos;
2036         visiblePos = nextLinePosition(visiblePos, 0);
2037         if (visiblePos.isNull() || visiblePos == savedVisiblePos)
2038             return PlainTextRange();
2039     }
2040
2041     // Get the end of the line based on the starting position.
2042     VisiblePosition endPosition = endOfLine(visiblePos);
2043
2044     int index1 = indexForVisiblePosition(visiblePos);
2045     int index2 = indexForVisiblePosition(endPosition);
2046     
2047     // add one to the end index for a line break not caused by soft line wrap (to match AppKit)
2048     if (endPosition.affinity() == DOWNSTREAM && endPosition.next().isNotNull())
2049         index2 += 1;
2050     
2051     // return nil rather than an zero-length range (to match AppKit)
2052     if (index1 == index2)
2053         return PlainTextRange();
2054     
2055     return PlainTextRange(index1, index2 - index1);
2056 }
2057
2058 // The composed character range in the text associated with this accessibility object that
2059 // is specified by the given index value. This parameterized attribute returns the complete
2060 // range of characters (including surrogate pairs of multi-byte glyphs) at the given index.
2061 PlainTextRange AccessibilityRenderObject::doAXRangeForIndex(unsigned index) const
2062 {
2063     if (!isTextControl())
2064         return PlainTextRange();
2065     
2066     String elementText = text();
2067     if (!elementText.length() || index > elementText.length() - 1)
2068         return PlainTextRange();
2069     
2070     return PlainTextRange(index, 1);
2071 }
2072
2073 // A substring of the text associated with this accessibility object that is
2074 // specified by the given character range.
2075 String AccessibilityRenderObject::doAXStringForRange(const PlainTextRange& range) const
2076 {
2077     if (!range.length)
2078         return String();
2079     
2080     if (!isTextControl())
2081         return String();
2082     
2083     String elementText = isPasswordField() ? passwordFieldValue() : text();
2084     if (range.start + range.length > elementText.length())
2085         return String();
2086     
2087     return elementText.substring(range.start, range.length);
2088 }
2089
2090 // The bounding rectangle of the text associated with this accessibility object that is
2091 // specified by the given range. This is the bounding rectangle a sighted user would see
2092 // on the display screen, in pixels.
2093 IntRect AccessibilityRenderObject::doAXBoundsForRange(const PlainTextRange& range) const
2094 {
2095     if (allowsTextRanges())
2096         return boundsForVisiblePositionRange(visiblePositionRangeForRange(range));
2097     return IntRect();
2098 }
2099
2100 AccessibilityObject* AccessibilityRenderObject::accessibilityImageMapHitTest(HTMLAreaElement* area, const IntPoint& point) const
2101 {
2102     if (!area)
2103         return 0;
2104     
2105     HTMLMapElement* map = static_cast<HTMLMapElement*>(area->parentNode());
2106     AccessibilityObject* parent = accessibilityParentForImageMap(map);
2107     if (!parent)
2108         return 0;
2109     
2110     AccessibilityObject::AccessibilityChildrenVector children = parent->children();
2111     
2112     unsigned count = children.size();
2113     for (unsigned k = 0; k < count; ++k) {
2114         if (children[k]->elementRect().contains(point))
2115             return children[k].get();
2116     }
2117     
2118     return 0;
2119 }
2120     
2121 AccessibilityObject* AccessibilityRenderObject::accessibilityHitTest(const IntPoint& point) const
2122 {
2123     if (!m_renderer || !m_renderer->hasLayer())
2124         return 0;
2125     
2126     RenderLayer* layer = toRenderBox(m_renderer)->layer();
2127      
2128     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active);
2129     HitTestResult hitTestResult = HitTestResult(point);
2130     layer->hitTest(request, hitTestResult);
2131     if (!hitTestResult.innerNode())
2132         return 0;
2133     Node* node = hitTestResult.innerNode()->shadowAncestorNode();
2134
2135     if (node->hasTagName(areaTag)) 
2136         return accessibilityImageMapHitTest(static_cast<HTMLAreaElement*>(node), point);
2137     
2138     if (node->hasTagName(optionTag))
2139         node = static_cast<HTMLOptionElement*>(node)->ownerSelectElement();
2140     
2141     RenderObject* obj = node->renderer();
2142     if (!obj)
2143         return 0;
2144     
2145     AccessibilityObject* result = obj->document()->axObjectCache()->getOrCreate(obj);
2146     result->updateChildrenIfNecessary();
2147
2148     // Allow the element to perform any hit-testing it might need to do to reach non-render children.
2149     result = result->elementAccessibilityHitTest(point);
2150     
2151     if (result && result->accessibilityIsIgnored()) {
2152         // If this element is the label of a control, a hit test should return the control.
2153         AccessibilityObject* controlObject = result->correspondingControlForLabelElement();
2154         if (controlObject && !controlObject->exposesTitleUIElement())
2155             return controlObject;
2156
2157         result = result->parentObjectUnignored();
2158     }
2159
2160     return result;
2161 }
2162
2163 bool AccessibilityRenderObject::shouldFocusActiveDescendant() const
2164 {
2165     switch (ariaRoleAttribute()) {
2166     case GroupRole:
2167     case ComboBoxRole:
2168     case ListBoxRole:
2169     case MenuRole:
2170     case MenuBarRole:
2171     case RadioGroupRole:
2172     case RowRole:
2173     case PopUpButtonRole:
2174     case ProgressIndicatorRole:
2175     case ToolbarRole:
2176     case OutlineRole:
2177     case TreeRole:
2178     case GridRole:
2179     /* FIXME: replace these with actual roles when they are added to AccessibilityRole
2180     composite
2181     alert
2182     alertdialog
2183     status
2184     timer
2185     */
2186         return true;
2187     default:
2188         return false;
2189     }
2190 }
2191
2192 AccessibilityObject* AccessibilityRenderObject::activeDescendant() const
2193 {
2194     if (!m_renderer)
2195         return 0;
2196     
2197     if (m_renderer->node() && !m_renderer->node()->isElementNode())
2198         return 0;
2199     Element* element = static_cast<Element*>(m_renderer->node());
2200         
2201     const AtomicString& activeDescendantAttrStr = element->getAttribute(aria_activedescendantAttr);
2202     if (activeDescendantAttrStr.isNull() || activeDescendantAttrStr.isEmpty())
2203         return 0;
2204     
2205     Element* target = element->treeScope()->getElementById(activeDescendantAttrStr);
2206     if (!target)
2207         return 0;
2208     
2209     AccessibilityObject* obj = axObjectCache()->getOrCreate(target);
2210     if (obj && obj->isAccessibilityRenderObject())
2211     // an activedescendant is only useful if it has a renderer, because that's what's needed to post the notification
2212         return obj;
2213     return 0;
2214 }
2215
2216 void AccessibilityRenderObject::handleAriaExpandedChanged()
2217 {
2218     // Find if a parent of this object should handle aria-expanded changes.
2219     AccessibilityObject* containerParent = this->parentObject();
2220     while (containerParent) {
2221         bool foundParent = false;
2222         
2223         switch (containerParent->roleValue()) {
2224         case TreeRole:
2225         case TreeGridRole:
2226         case GridRole:
2227         case TableRole:
2228         case BrowserRole:
2229             foundParent = true;
2230             break;
2231         default:
2232             break;
2233         }
2234         
2235         if (foundParent)
2236             break;
2237         
2238         containerParent = containerParent->parentObject();
2239     }
2240     
2241     // Post that the row count changed.
2242     if (containerParent)
2243         axObjectCache()->postNotification(containerParent, document(), AXObjectCache::AXRowCountChanged, true);
2244
2245     // Post that the specific row either collapsed or expanded.
2246     if (roleValue() == RowRole || roleValue() == TreeItemRole)
2247         axObjectCache()->postNotification(this, document(), isExpanded() ? AXObjectCache::AXRowExpanded : AXObjectCache::AXRowCollapsed, true);
2248 }
2249
2250 void AccessibilityRenderObject::handleActiveDescendantChanged()
2251 {
2252     Element* element = static_cast<Element*>(renderer()->node());
2253     if (!element)
2254         return;
2255     Document* doc = renderer()->document();
2256     if (!doc->frame()->selection()->isFocusedAndActive() || doc->focusedNode() != element)
2257         return; 
2258     AccessibilityRenderObject* activedescendant = static_cast<AccessibilityRenderObject*>(activeDescendant());
2259     
2260     if (activedescendant && shouldFocusActiveDescendant())
2261         doc->axObjectCache()->postNotification(m_renderer, AXObjectCache::AXActiveDescendantChanged, true);
2262 }
2263
2264 AccessibilityObject* AccessibilityRenderObject::correspondingControlForLabelElement() const
2265 {
2266     HTMLLabelElement* labelElement = labelElementContainer();
2267     if (!labelElement)
2268         return 0;
2269     
2270     HTMLElement* correspondingControl = labelElement->control();
2271     if (!correspondingControl)
2272         return 0;
2273     
2274     return axObjectCache()->getOrCreate(correspondingControl);     
2275 }
2276
2277 AccessibilityObject* AccessibilityRenderObject::correspondingLabelForControlElement() const
2278 {
2279     if (!m_renderer)
2280         return 0;
2281
2282     Node* node = m_renderer->node();
2283     if (node && node->isHTMLElement()) {
2284         HTMLLabelElement* label = labelForElement(static_cast<Element*>(node));
2285         if (label)
2286             return axObjectCache()->getOrCreate(label);
2287     }
2288
2289     return 0;
2290 }
2291
2292 bool AccessibilityRenderObject::renderObjectIsObservable(RenderObject* renderer) const
2293 {
2294     // AX clients will listen for AXValueChange on a text control.
2295     if (renderer->isTextControl())
2296         return true;
2297     
2298     // AX clients will listen for AXSelectedChildrenChanged on listboxes.
2299     Node* node = renderer->node();
2300     if (nodeHasRole(node, "listbox") || (renderer->isBoxModelObject() && toRenderBoxModelObject(renderer)->isListBox()))
2301         return true;
2302
2303     // Textboxes should send out notifications.
2304     if (nodeHasRole(node, "textbox"))
2305         return true;
2306     
2307     return false;
2308 }
2309     
2310 AccessibilityObject* AccessibilityRenderObject::observableObject() const
2311 {
2312     // Find the object going up the parent chain that is used in accessibility to monitor certain notifications.
2313     for (RenderObject* renderer = m_renderer; renderer && renderer->node(); renderer = renderer->parent()) {
2314         if (renderObjectIsObservable(renderer))
2315             return axObjectCache()->getOrCreate(renderer);
2316     }
2317     
2318     return 0;
2319 }
2320
2321 bool AccessibilityRenderObject::isDescendantOfElementType(const QualifiedName& tagName) const
2322 {
2323     for (RenderObject* parent = m_renderer->parent(); parent; parent = parent->parent()) {
2324         if (parent->node() && parent->node()->hasTagName(tagName))
2325             return true;
2326     }
2327     return false;
2328 }
2329
2330 AccessibilityRole AccessibilityRenderObject::determineAccessibilityRole()
2331 {
2332     if (!m_renderer)
2333         return UnknownRole;
2334
2335     m_ariaRole = determineAriaRoleAttribute();
2336     
2337     Node* node = m_renderer->node();
2338     AccessibilityRole ariaRole = ariaRoleAttribute();
2339     if (ariaRole != UnknownRole)
2340         return ariaRole;
2341
2342     RenderBoxModelObject* cssBox = renderBoxModelObject();
2343
2344     if (node && node->isLink()) {
2345         if (cssBox && cssBox->isImage())
2346             return ImageMapRole;
2347         return WebCoreLinkRole;
2348     }
2349     if (cssBox && cssBox->isListItem())
2350         return ListItemRole;
2351     if (m_renderer->isListMarker())
2352         return ListMarkerRole;
2353     if (node && node->hasTagName(buttonTag))
2354         return buttonRoleType();
2355     if (node && node->hasTagName(legendTag))
2356         return LegendRole;
2357     if (m_renderer->isText())
2358         return StaticTextRole;
2359     if (cssBox && cssBox->isImage()) {
2360         if (node && node->hasTagName(inputTag))
2361             return ariaHasPopup() ? PopUpButtonRole : ButtonRole;
2362         return ImageRole;
2363     }
2364     if (node && node->hasTagName(canvasTag))
2365         return CanvasRole;
2366
2367     if (cssBox && cssBox->isRenderView())
2368         return WebAreaRole;
2369     
2370     if (cssBox && cssBox->isTextField())
2371         return TextFieldRole;
2372     
2373     if (cssBox && cssBox->isTextArea())
2374         return TextAreaRole;
2375
2376     if (node && node->hasTagName(inputTag)) {
2377         HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
2378         if (input->isCheckbox())
2379             return CheckBoxRole;
2380         if (input->isRadioButton())
2381             return RadioButtonRole;
2382         if (input->isTextButton())
2383             return buttonRoleType();
2384     }
2385
2386     if (isFileUploadButton())
2387         return ButtonRole;
2388     
2389     if (cssBox && cssBox->isMenuList())
2390         return PopUpButtonRole;
2391     
2392     if (headingLevel())
2393         return HeadingRole;
2394     
2395 #if ENABLE(MATHML)
2396     if (node && node->hasTagName(MathMLNames::mathTag))
2397         return DocumentMathRole;
2398 #endif
2399     
2400     if (node && node->hasTagName(ddTag))
2401         return DefinitionListDefinitionRole;
2402     
2403     if (node && node->hasTagName(dtTag))
2404         return DefinitionListTermRole;
2405
2406     if (node && (node->hasTagName(rpTag) || node->hasTagName(rtTag)))
2407         return AnnotationRole;
2408
2409 #if PLATFORM(GTK)
2410     // Gtk ATs expect all tables, data and layout, to be exposed as tables.
2411     if (node && (node->hasTagName(tdTag) || node->hasTagName(thTag)))
2412         return CellRole;
2413
2414     if (node && node->hasTagName(trTag))
2415         return RowRole;
2416
2417     if (node && node->hasTagName(tableTag))
2418         return TableRole;
2419 #endif
2420
2421     // Table sections should be ignored.
2422     if (m_renderer->isTableSection())
2423         return IgnoredRole;
2424
2425     if (m_renderer->isHR())
2426         return HorizontalRuleRole;
2427
2428     if (node && node->hasTagName(pTag))
2429         return ParagraphRole;
2430
2431     if (node && node->hasTagName(labelTag))
2432         return LabelRole;
2433
2434     if (node && node->hasTagName(divTag))
2435         return DivRole;
2436
2437     if (node && node->hasTagName(formTag))
2438         return FormRole;
2439
2440     if (node && node->hasTagName(articleTag))
2441         return DocumentArticleRole;
2442
2443     if (node && node->hasTagName(navTag))
2444         return LandmarkNavigationRole;
2445
2446     if (node && node->hasTagName(asideTag))
2447         return LandmarkComplementaryRole;
2448
2449     if (node && node->hasTagName(sectionTag))
2450         return DocumentRegionRole;
2451
2452     if (node && node->hasTagName(addressTag))
2453         return LandmarkContentInfoRole;
2454
2455     // There should only be one banner/contentInfo per page. If header/footer are being used within an article or section
2456     // then it should not be exposed as whole page's banner/contentInfo
2457     if (node && node->hasTagName(headerTag) && !isDescendantOfElementType(articleTag) && !isDescendantOfElementType(sectionTag))
2458         return LandmarkBannerRole;
2459     if (node && node->hasTagName(footerTag) && !isDescendantOfElementType(articleTag) && !isDescendantOfElementType(sectionTag))
2460         return FooterRole;
2461
2462     if (m_renderer->isBlockFlow())
2463         return GroupRole;
2464     
2465     // If the element does not have role, but it has ARIA attributes, accessibility should fallback to exposing it as a group.
2466     if (supportsARIAAttributes())
2467         return GroupRole;
2468     
2469     return UnknownRole;
2470 }
2471
2472 AccessibilityOrientation AccessibilityRenderObject::orientation() const
2473 {
2474     const AtomicString& ariaOrientation = getAttribute(aria_orientationAttr);
2475     if (equalIgnoringCase(ariaOrientation, "horizontal"))
2476         return AccessibilityOrientationHorizontal;
2477     if (equalIgnoringCase(ariaOrientation, "vertical"))
2478         return AccessibilityOrientationVertical;
2479     
2480     return AccessibilityObject::orientation();
2481 }
2482     
2483 bool AccessibilityRenderObject::inheritsPresentationalRole() const
2484 {
2485     // ARIA states if an item can get focus, it should not be presentational.
2486     if (canSetFocusAttribute())
2487         return false;
2488     
2489     // ARIA spec says that when a parent object is presentational, and it has required child elements,
2490     // those child elements are also presentational. For example, <li> becomes presentational from <ul>.
2491     // http://www.w3.org/WAI/PF/aria/complete#presentation
2492     DEFINE_STATIC_LOCAL(HashSet<QualifiedName>, listItemParents, ());
2493
2494     HashSet<QualifiedName>* possibleParentTagNames = 0;
2495     switch (roleValue()) {
2496     case ListItemRole:
2497     case ListMarkerRole:
2498         if (listItemParents.isEmpty()) {
2499             listItemParents.add(ulTag);
2500             listItemParents.add(olTag);
2501             listItemParents.add(dlTag);
2502         }
2503         possibleParentTagNames = &listItemParents;
2504         break;
2505     default:
2506         break;
2507     }
2508     
2509     // Not all elements need to check for this, only ones that are required children.
2510     if (!possibleParentTagNames)
2511         return false;
2512     
2513     for (AccessibilityObject* parent = parentObject(); parent; parent = parent->parentObject()) { 
2514         if (!parent->isAccessibilityRenderObject())
2515             continue;
2516         
2517         Node* elementNode = static_cast<AccessibilityRenderObject*>(parent)->node();
2518         if (!elementNode || !elementNode->isElementNode())
2519             continue;
2520         
2521         // If native tag of the parent element matches an acceptable name, then return
2522         // based on its presentational status.
2523         if (possibleParentTagNames->contains(static_cast<Element*>(elementNode)->tagQName()))
2524             return parent->roleValue() == PresentationalRole;
2525     }
2526     
2527     return false;
2528 }
2529     
2530 bool AccessibilityRenderObject::isPresentationalChildOfAriaRole() const
2531 {
2532     // Walk the parent chain looking for a parent that has presentational children
2533     AccessibilityObject* parent;
2534     for (parent = parentObject(); parent && !parent->ariaRoleHasPresentationalChildren(); parent = parent->parentObject())
2535     { }
2536     
2537     return parent;
2538 }
2539     
2540 bool AccessibilityRenderObject::ariaRoleHasPresentationalChildren() const
2541 {
2542     switch (m_ariaRole) {
2543     case ButtonRole:
2544     case SliderRole:
2545     case ImageRole:
2546     case ProgressIndicatorRole:
2547     case SpinButtonRole:
2548     // case SeparatorRole:
2549         return true;
2550     default:
2551         return false;
2552     }
2553 }
2554
2555 bool AccessibilityRenderObject::canSetExpandedAttribute() const
2556 {
2557     // An object can be expanded if it aria-expanded is true or false.
2558     const AtomicString& ariaExpanded = getAttribute(aria_expandedAttr);
2559     return equalIgnoringCase(ariaExpanded, "true") || equalIgnoringCase(ariaExpanded, "false");
2560 }
2561
2562 bool AccessibilityRenderObject::canSetValueAttribute() const
2563 {
2564     if (equalIgnoringCase(getAttribute(aria_readonlyAttr), "true"))
2565         return false;
2566
2567     if (isProgressIndicator() || isSlider())
2568         return true;
2569
2570     if (isTextControl() && !isNativeTextControl())
2571         return true;
2572
2573     // Any node could be contenteditable, so isReadOnly should be relied upon
2574     // for this information for all elements.
2575     return !isReadOnly();
2576 }
2577
2578 bool AccessibilityRenderObject::canSetTextRangeAttributes() const
2579 {
2580     return isTextControl();
2581 }
2582
2583 void AccessibilityRenderObject::contentChanged()
2584 {
2585     // If this element supports ARIA live regions, or is part of a region with an ARIA editable role,
2586     // then notify the AT of changes.
2587     AXObjectCache* cache = axObjectCache();
2588     for (RenderObject* renderParent = m_renderer; renderParent; renderParent = renderParent->parent()) {
2589         AccessibilityObject* parent = cache->get(renderParent);
2590         if (!parent)
2591             continue;
2592         
2593         if (parent->supportsARIALiveRegion())
2594             cache->postNotification(renderParent, AXObjectCache::AXLiveRegionChanged, true);
2595
2596         if (parent->isARIATextControl() && !parent->isNativeTextControl() && !parent->node()->rendererIsEditable())
2597             cache->postNotification(renderParent, AXObjectCache::AXValueChanged, true);
2598     }
2599 }
2600
2601 void AccessibilityRenderObject::clearChildren()
2602 {
2603     AccessibilityObject::clearChildren();
2604     m_childrenDirty = false;
2605 }
2606
2607 void AccessibilityRenderObject::addImageMapChildren()
2608 {
2609     RenderBoxModelObject* cssBox = renderBoxModelObject();
2610     if (!cssBox || !cssBox->isRenderImage())
2611         return;
2612     
2613     HTMLMapElement* map = toRenderImage(cssBox)->imageMap();
2614     if (!map)
2615         return;
2616
2617     for (Node* current = map->firstChild(); current; current = current->traverseNextNode(map)) {
2618         
2619         // add an <area> element for this child if it has a link
2620         if (current->hasTagName(areaTag) && current->isLink()) {
2621             AccessibilityImageMapLink* areaObject = static_cast<AccessibilityImageMapLink*>(axObjectCache()->getOrCreate(ImageMapLinkRole));
2622             areaObject->setHTMLAreaElement(static_cast<HTMLAreaElement*>(current));
2623             areaObject->setHTMLMapElement(map);
2624             areaObject->setParent(this);
2625             
2626             m_children.append(areaObject);
2627         }
2628     }
2629 }
2630
2631 void AccessibilityRenderObject::updateChildrenIfNecessary()
2632 {
2633     if (needsToUpdateChildren())
2634         clearChildren();        
2635     
2636     AccessibilityObject::updateChildrenIfNecessary();
2637 }
2638     
2639 void AccessibilityRenderObject::addTextFieldChildren()
2640 {
2641     Node* node = this->node();
2642     if (!node || !node->hasTagName(inputTag))
2643         return;
2644     
2645     HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
2646     HTMLElement* spinButtonElement = input->innerSpinButtonElement();
2647     if (!spinButtonElement || !spinButtonElement->isSpinButtonElement())
2648         return;
2649
2650     AccessibilitySpinButton* axSpinButton = static_cast<AccessibilitySpinButton*>(axObjectCache()->getOrCreate(SpinButtonRole));
2651     axSpinButton->setSpinButtonElement(static_cast<SpinButtonElement*>(spinButtonElement));
2652     axSpinButton->setParent(this);
2653     m_children.append(axSpinButton);
2654 }
2655
2656 void AccessibilityRenderObject::addCanvasChildren()
2657 {
2658     if (!node() || !node()->hasTagName(canvasTag))
2659         return;
2660
2661     // If it's a canvas, it won't have rendered children, but it might have accessible fallback content.
2662     // Clear m_haveChildren because AccessibilityNodeObject::addChildren will expect it to be false.
2663     ASSERT(!m_children.size());
2664     m_haveChildren = false;
2665     AccessibilityNodeObject::addChildren();
2666 }
2667
2668 void AccessibilityRenderObject::addAttachmentChildren()
2669 {
2670     if (!isAttachment())
2671         return;
2672
2673     // FrameView's need to be inserted into the AX hierarchy when encountered.
2674     Widget* widget = widgetForAttachmentView();
2675     if (!widget || !widget->isFrameView())
2676         return;
2677     
2678     AccessibilityObject* axWidget = axObjectCache()->getOrCreate(widget);
2679     if (!axWidget->accessibilityIsIgnored())
2680         m_children.append(axWidget);
2681 }
2682
2683 #if PLATFORM(MAC)
2684 void AccessibilityRenderObject::updateAttachmentViewParents()
2685 {
2686     // Only the unignored parent should set the attachment parent, because that's what is reflected in the AX 
2687     // hierarchy to the client.
2688     if (accessibilityIsIgnored())
2689         return;
2690     
2691     size_t length = m_children.size();
2692     for (size_t k = 0; k < length; k++) {
2693         if (m_children[k]->isAttachment())
2694             m_children[k]->overrideAttachmentParent(this);
2695     }
2696 }
2697 #endif
2698
2699 void AccessibilityRenderObject::addChildren()
2700 {
2701     // If the need to add more children in addition to existing children arises, 
2702     // childrenChanged should have been called, leaving the object with no children.
2703     ASSERT(!m_haveChildren); 
2704
2705     m_haveChildren = true;
2706     
2707     if (!canHaveChildren())
2708         return;
2709     
2710     // add all unignored acc children
2711     for (RefPtr<AccessibilityObject> obj = firstChild(); obj; obj = obj->nextSibling()) {
2712         // If the parent is asking for this child's children, then either it's the first time (and clearing is a no-op), 
2713         // or its visibility has changed. In the latter case, this child may have a stale child cached. 
2714         // This can prevent aria-hidden changes from working correctly. Hence, whenever a parent is getting children, ensure data is not stale.
2715         obj->clearChildren();
2716
2717         if (obj->accessibilityIsIgnored()) {
2718             AccessibilityChildrenVector children = obj->children();
2719             unsigned length = children.size();
2720             for (unsigned i = 0; i < length; ++i)
2721                 m_children.append(children[i]);
2722         } else {
2723             ASSERT(obj->parentObject() == this);
2724             m_children.append(obj);
2725         }
2726     }
2727     
2728     addAttachmentChildren();
2729     addImageMapChildren();
2730     addTextFieldChildren();
2731     addCanvasChildren();
2732
2733 #if PLATFORM(MAC)
2734     updateAttachmentViewParents();
2735 #endif
2736 }
2737
2738 bool AccessibilityRenderObject::canHaveChildren() const
2739 {
2740     if (!m_renderer)
2741         return false;
2742
2743     return AccessibilityNodeObject::canHaveChildren();
2744 }
2745
2746 const AtomicString& AccessibilityRenderObject::ariaLiveRegionStatus() const
2747 {
2748     DEFINE_STATIC_LOCAL(const AtomicString, liveRegionStatusAssertive, ("assertive"));
2749     DEFINE_STATIC_LOCAL(const AtomicString, liveRegionStatusPolite, ("polite"));
2750     DEFINE_STATIC_LOCAL(const AtomicString, liveRegionStatusOff, ("off"));
2751     
2752     const AtomicString& liveRegionStatus = getAttribute(aria_liveAttr);
2753     // These roles have implicit live region status.
2754     if (liveRegionStatus.isEmpty()) {
2755         switch (roleValue()) {
2756         case ApplicationAlertDialogRole:
2757         case ApplicationAlertRole:
2758             return liveRegionStatusAssertive;
2759         case ApplicationLogRole:
2760         case ApplicationStatusRole:
2761             return liveRegionStatusPolite;
2762         case ApplicationTimerRole:
2763         case ApplicationMarqueeRole:
2764             return liveRegionStatusOff;
2765         default:
2766             break;
2767         }
2768     }
2769
2770     return liveRegionStatus;
2771 }
2772
2773 const AtomicString& AccessibilityRenderObject::ariaLiveRegionRelevant() const
2774 {
2775     DEFINE_STATIC_LOCAL(const AtomicString, defaultLiveRegionRelevant, ("additions text"));
2776     const AtomicString& relevant = getAttribute(aria_relevantAttr);
2777
2778     // Default aria-relevant = "additions text".
2779     if (relevant.isEmpty())
2780         return defaultLiveRegionRelevant;
2781     
2782     return relevant;
2783 }
2784
2785 bool AccessibilityRenderObject::ariaLiveRegionAtomic() const
2786 {
2787     return elementAttributeValue(aria_atomicAttr);    
2788 }
2789
2790 bool AccessibilityRenderObject::ariaLiveRegionBusy() const
2791 {
2792     return elementAttributeValue(aria_busyAttr);    
2793 }
2794     
2795 void AccessibilityRenderObject::ariaSelectedRows(AccessibilityChildrenVector& result)
2796 {
2797     // Get all the rows. 
2798     AccessibilityChildrenVector allRows;
2799     if (isTree())
2800         ariaTreeRows(allRows);
2801     else if (isAccessibilityTable() && toAccessibilityTable(this)->supportsSelectedRows())
2802         allRows = toAccessibilityTable(this)->rows();
2803
2804     // Determine which rows are selected.
2805     bool isMulti = isMultiSelectable();
2806
2807     // Prefer active descendant over aria-selected.
2808     AccessibilityObject* activeDesc = activeDescendant();
2809     if (activeDesc && (activeDesc->isTreeItem() || activeDesc->isTableRow())) {
2810         result.append(activeDesc);    
2811         if (!isMulti)
2812             return;
2813     }
2814
2815     unsigned count = allRows.size();
2816     for (unsigned k = 0; k < count; ++k) {
2817         if (allRows[k]->isSelected()) {
2818             result.append(allRows[k]);
2819             if (!isMulti)
2820                 break;
2821         }
2822     }
2823 }
2824     
2825 void AccessibilityRenderObject::ariaListboxSelectedChildren(AccessibilityChildrenVector& result)
2826 {
2827     bool isMulti = isMultiSelectable();
2828
2829     AccessibilityChildrenVector childObjects = children();
2830     unsigned childrenSize = childObjects.size();
2831     for (unsigned k = 0; k < childrenSize; ++k) {
2832         // Every child should have aria-role option, and if so, check for selected attribute/state.
2833         AccessibilityObject* child = childObjects[k].get();
2834         if (child->isSelected() && child->ariaRoleAttribute() == ListBoxOptionRole) {
2835             result.append(child);
2836             if (!isMulti)
2837                 return;
2838         }
2839     }
2840 }
2841
2842 void AccessibilityRenderObject::selectedChildren(AccessibilityChildrenVector& result)
2843 {
2844     ASSERT(result.isEmpty());
2845
2846     // only listboxes should be asked for their selected children. 
2847     AccessibilityRole role = roleValue();
2848     if (role == ListBoxRole) // native list boxes would be AccessibilityListBoxes, so only check for aria list boxes
2849         ariaListboxSelectedChildren(result);
2850     else if (role == TreeRole || role == TreeGridRole || role == TableRole)
2851         ariaSelectedRows(result);
2852 }
2853
2854 void AccessibilityRenderObject::ariaListboxVisibleChildren(AccessibilityChildrenVector& result)      
2855 {
2856     if (!hasChildren())
2857         addChildren();
2858     
2859     AccessibilityObject::AccessibilityChildrenVector children = this->children();
2860     size_t size = children.size();
2861     for (size_t i = 0; i < size; i++) {
2862         if (!children[i]->isOffScreen())
2863             result.append(children[i]);
2864     }
2865 }
2866
2867 void AccessibilityRenderObject::visibleChildren(AccessibilityChildrenVector& result)
2868 {
2869     ASSERT(result.isEmpty());
2870         
2871     // only listboxes are asked for their visible children. 
2872     if (ariaRoleAttribute() != ListBoxRole) { // native list boxes would be AccessibilityListBoxes, so only check for aria list boxes
2873         ASSERT_NOT_REACHED();
2874         return;
2875     }
2876     return ariaListboxVisibleChildren(result);
2877 }
2878  
2879 void AccessibilityRenderObject::tabChildren(AccessibilityChildrenVector& result)
2880 {
2881     ASSERT(roleValue() == TabListRole);
2882     
2883     AccessibilityObject::AccessibilityChildrenVector children = this->children();
2884     size_t size = children.size();
2885     for (size_t i = 0; i < size; ++i) {
2886         if (children[i]->isTabItem())
2887             result.append(children[i]);
2888     }
2889 }
2890     
2891 const String& AccessibilityRenderObject::actionVerb() const
2892 {
2893     // FIXME: Need to add verbs for select elements.
2894     DEFINE_STATIC_LOCAL(const String, buttonAction, (AXButtonActionVerb()));
2895     DEFINE_STATIC_LOCAL(const String, textFieldAction, (AXTextFieldActionVerb()));
2896     DEFINE_STATIC_LOCAL(const String, radioButtonAction, (AXRadioButtonActionVerb()));
2897     DEFINE_STATIC_LOCAL(const String, checkedCheckBoxAction, (AXCheckedCheckBoxActionVerb()));
2898     DEFINE_STATIC_LOCAL(const String, uncheckedCheckBoxAction, (AXUncheckedCheckBoxActionVerb()));
2899     DEFINE_STATIC_LOCAL(const String, linkAction, (AXLinkActionVerb()));
2900     DEFINE_STATIC_LOCAL(const String, noAction, ());
2901     
2902     switch (roleValue()) {
2903     case ButtonRole:
2904         return buttonAction;
2905     case TextFieldRole:
2906     case TextAreaRole:
2907         return textFieldAction;
2908     case RadioButtonRole:
2909         return radioButtonAction;
2910     case CheckBoxRole:
2911         return isChecked() ? checkedCheckBoxAction : uncheckedCheckBoxAction;
2912     case LinkRole:
2913     case WebCoreLinkRole:
2914         return linkAction;
2915     default:
2916         return noAction;
2917     }
2918 }
2919     
2920 void AccessibilityRenderObject::setAccessibleName(const AtomicString& name)
2921 {
2922     // Setting the accessible name can store the value in the DOM
2923     if (!m_renderer)
2924         return;
2925
2926     Node* domNode = 0;
2927     // For web areas, set the aria-label on the HTML element.
2928     if (isWebArea())
2929         domNode = m_renderer->document()->documentElement();
2930     else
2931         domNode = m_renderer->node();
2932
2933     if (domNode && domNode->isElementNode())
2934         static_cast<Element*>(domNode)->setAttribute(aria_labelAttr, name);
2935 }
2936     
2937 static bool isLinkable(const AccessibilityRenderObject& object)
2938 {
2939     if (!object.renderer())
2940         return false;
2941
2942     // See https://wiki.mozilla.org/Accessibility/AT-Windows-API for the elements
2943     // Mozilla considers linkable.
2944     return object.isLink() || object.isImage() || object.renderer()->isText();
2945 }
2946
2947 String AccessibilityRenderObject::stringValueForMSAA() const
2948 {
2949     if (isLinkable(*this)) {
2950         Element* anchor = anchorElement();
2951         if (anchor && anchor->hasTagName(aTag))
2952             return static_cast<HTMLAnchorElement*>(anchor)->href();
2953     }
2954
2955     return stringValue();
2956 }
2957
2958 bool AccessibilityRenderObject::isLinked() const
2959 {
2960     if (!isLinkable(*this))
2961         return false;
2962
2963     Element* anchor = anchorElement();
2964     if (!anchor || !anchor->hasTagName(aTag))
2965         return false;
2966
2967     return !static_cast<HTMLAnchorElement*>(anchor)->href().isEmpty();
2968 }
2969
2970 bool AccessibilityRenderObject::hasBoldFont() const
2971 {
2972     if (!m_renderer)
2973         return false;
2974     
2975     return m_renderer->style()->fontDescription().weight() >= FontWeightBold;
2976 }
2977
2978 bool AccessibilityRenderObject::hasItalicFont() const
2979 {
2980     if (!m_renderer)
2981         return false;
2982     
2983     return m_renderer->style()->fontDescription().italic() == FontItalicOn;
2984 }
2985
2986 bool AccessibilityRenderObject::hasPlainText() const
2987 {
2988     if (!m_renderer)
2989         return false;
2990     
2991     RenderStyle* style = m_renderer->style();
2992     
2993     return style->fontDescription().weight() == FontWeightNormal
2994         && style->fontDescription().italic() == FontItalicOff
2995         && style->textDecorationsInEffect() == TDNONE;
2996 }
2997
2998 bool AccessibilityRenderObject::hasSameFont(RenderObject* renderer) const
2999 {
3000     if (!m_renderer || !renderer)
3001         return false;
3002     
3003     return m_renderer->style()->fontDescription().family() == renderer->style()->fontDescription().family();
3004 }
3005
3006 bool AccessibilityRenderObject::hasSameFontColor(RenderObject* renderer) const
3007 {
3008     if (!m_renderer || !renderer)
3009         return false;
3010     
3011     return m_renderer->style()->visitedDependentColor(CSSPropertyColor) == renderer->style()->visitedDependentColor(CSSPropertyColor);
3012 }
3013
3014 bool AccessibilityRenderObject::hasSameStyle(RenderObject* renderer) const
3015 {
3016     if (!m_renderer || !renderer)
3017         return false;
3018     
3019     return m_renderer->style() == renderer->style();
3020 }
3021
3022 bool AccessibilityRenderObject::hasUnderline() const
3023 {
3024     if (!m_renderer)
3025         return false;
3026     
3027     return m_renderer->style()->textDecorationsInEffect() & UNDERLINE;
3028 }
3029
3030 String AccessibilityRenderObject::nameForMSAA() const
3031 {
3032     if (m_renderer && m_renderer->isText())
3033         return textUnderElement();
3034
3035     return title();
3036 }
3037
3038 static bool shouldReturnTagNameAsRoleForMSAA(const Element& element)
3039 {
3040     // See "document structure",
3041     // https://wiki.mozilla.org/Accessibility/AT-Windows-API
3042     // FIXME: Add the other tag names that should be returned as the role.
3043     return element.hasTagName(h1Tag) || element.hasTagName(h2Tag) 
3044         || element.hasTagName(h3Tag) || element.hasTagName(h4Tag)
3045         || element.hasTagName(h5Tag) || element.hasTagName(h6Tag);
3046 }
3047
3048 String AccessibilityRenderObject::stringRoleForMSAA() const
3049 {
3050     if (!m_renderer)
3051         return String();
3052
3053     Node* node = m_renderer->node();
3054     if (!node || !node->isElementNode())
3055         return String();
3056
3057     Element* element = static_cast<Element*>(node);
3058     if (!shouldReturnTagNameAsRoleForMSAA(*element))
3059         return String();
3060
3061     return element->tagName();
3062 }
3063
3064 String AccessibilityRenderObject::positionalDescriptionForMSAA() const
3065 {
3066     // See "positional descriptions",
3067     // https://wiki.mozilla.org/Accessibility/AT-Windows-API
3068     if (isHeading())
3069         return "L" + String::number(headingLevel());
3070
3071     // FIXME: Add positional descriptions for other elements.
3072     return String();
3073 }
3074
3075 String AccessibilityRenderObject::descriptionForMSAA() const
3076 {
3077     String description = positionalDescriptionForMSAA();
3078     if (!description.isEmpty())
3079         return description;
3080
3081     description = accessibilityDescription();
3082     if (!description.isEmpty()) {
3083         // From the Mozilla MSAA implementation:
3084         // "Signal to screen readers that this description is speakable and is not
3085         // a formatted positional information description. Don't localize the
3086         // 'Description: ' part of this string, it will be parsed out by assistive
3087         // technologies."
3088         return "Description: " + description;
3089     }
3090
3091     return String();
3092 }
3093
3094 static AccessibilityRole msaaRoleForRenderer(const RenderObject* renderer)
3095 {
3096     if (!renderer)
3097         return UnknownRole;
3098
3099     if (renderer->isText())
3100         return EditableTextRole;
3101
3102     if (renderer->isBoxModelObject() && toRenderBoxModelObject(renderer)->isListItem())
3103         return ListItemRole;
3104
3105     return UnknownRole;
3106 }
3107
3108 AccessibilityRole AccessibilityRenderObject::roleValueForMSAA() const
3109 {
3110     if (m_roleForMSAA != UnknownRole)
3111         return m_roleForMSAA;
3112
3113     m_roleForMSAA = msaaRoleForRenderer(m_renderer);
3114
3115     if (m_roleForMSAA == UnknownRole)
3116         m_roleForMSAA = roleValue();
3117
3118     return m_roleForMSAA;
3119 }
3120
3121 String AccessibilityRenderObject::passwordFieldValue() const
3122 {
3123 #if PLATFORM(GTK)
3124     ASSERT(isPasswordField());
3125
3126     // Look for the RenderText object in the RenderObject tree for this input field.
3127     RenderObject* renderer = node()->renderer();
3128     while (renderer && !renderer->isText())
3129         renderer = renderer->firstChild();
3130
3131     if (!renderer || !renderer->isText())
3132         return String();
3133
3134     // Return the text that is actually being rendered in the input field.
3135     return static_cast<RenderText*>(renderer)->textWithoutTranscoding();
3136 #else
3137     // It seems only GTK is interested in this at the moment.
3138     return String();
3139 #endif
3140 }
3141
3142 ScrollableArea* AccessibilityRenderObject::getScrollableAreaIfScrollable() const
3143 {
3144     // If the parent is a scroll view, then this object isn't really scrollable, the parent ScrollView should handle the scrolling.
3145     if (parentObject() && parentObject()->isAccessibilityScrollView())
3146         return 0;
3147
3148     if (!m_renderer || !m_renderer->isBox())
3149         return 0;
3150
3151     RenderBox* box = toRenderBox(m_renderer);
3152     if (!box->canBeScrolledAndHasScrollableArea())
3153         return 0;
3154
3155     return box->layer();
3156 }
3157
3158 void AccessibilityRenderObject::scrollTo(const IntPoint& point) const
3159 {
3160     if (!m_renderer || !m_renderer->isBox())
3161         return;
3162
3163     RenderBox* box = toRenderBox(m_renderer);
3164     if (!box->canBeScrolledAndHasScrollableArea())
3165         return;
3166
3167     RenderLayer* layer = box->layer();
3168     layer->scrollToOffset(toSize(point), RenderLayer::ScrollOffsetClamped);
3169 }
3170
3171 } // namespace WebCore