1 /* 2 * Copyright (C) 2008, 2009, 2010 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 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY 14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR 17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY 21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 */ 25 26 #include "config.h" 27 #include "WebKitDLL.h" 28 #include "AccessibleBase.h" 29 30 #include "AccessibleImage.h" 31 #include "WebView.h" 32 #include <WebCore/AccessibilityListBox.h> 33 #include <WebCore/AccessibilityMenuListPopup.h> 34 #include <WebCore/AccessibilityObject.h> 35 #include <WebCore/AXObjectCache.h> 36 #include <WebCore/BString.h> 37 #include <WebCore/Element.h> 38 #include <WebCore/EventHandler.h> 39 #include <WebCore/FrameView.h> 40 #include <WebCore/HostWindow.h> 41 #include <WebCore/HTMLNames.h> 42 #include <WebCore/HTMLFrameElementBase.h> 43 #include <WebCore/HTMLInputElement.h> 44 #include <WebCore/IntRect.h> 45 #include <WebCore/PlatformKeyboardEvent.h> 46 #include <WebCore/RenderFrame.h> 47 #include <WebCore/RenderObject.h> 48 #include <WebCore/RenderView.h> 49 #include <oleacc.h> 50 #include <wtf/RefPtr.h> 51 52 using namespace WebCore; 53 54 AccessibleBase::AccessibleBase(AccessibilityObject* obj) 55 : AccessibilityObjectWrapper(obj) 56 , m_refCount(0) 57 { 58 ASSERT_ARG(obj, obj); 59 m_object->setWrapper(this); 60 ++gClassCount; 61 gClassNameCount.add("AccessibleBase"); 62 } 63 64 AccessibleBase::~AccessibleBase() 65 { 66 --gClassCount; 67 gClassNameCount.remove("AccessibleBase"); 68 } 69 70 AccessibleBase* AccessibleBase::createInstance(AccessibilityObject* obj) 71 { 72 ASSERT_ARG(obj, obj); 73 74 if (obj->isImage()) 75 return new AccessibleImage(obj); 76 77 return new AccessibleBase(obj); 78 } 79 80 HRESULT AccessibleBase::QueryService(REFGUID guidService, REFIID riid, void **ppvObject) 81 { 82 if (!IsEqualGUID(guidService, SID_AccessibleComparable)) { 83 *ppvObject = 0; 84 return E_INVALIDARG; 85 } 86 return QueryInterface(riid, ppvObject); 87 } 88 89 // IUnknown 90 HRESULT STDMETHODCALLTYPE AccessibleBase::QueryInterface(REFIID riid, void** ppvObject) 91 { 92 if (IsEqualGUID(riid, __uuidof(IAccessible))) 93 *ppvObject = static_cast<IAccessible*>(this); 94 else if (IsEqualGUID(riid, __uuidof(IDispatch))) 95 *ppvObject = static_cast<IAccessible*>(this); 96 else if (IsEqualGUID(riid, __uuidof(IUnknown))) 97 *ppvObject = static_cast<IAccessible*>(this); 98 else if (IsEqualGUID(riid, __uuidof(IAccessibleComparable))) 99 *ppvObject = static_cast<IAccessibleComparable*>(this); 100 else if (IsEqualGUID(riid, __uuidof(IServiceProvider))) 101 *ppvObject = static_cast<IServiceProvider*>(this); 102 else if (IsEqualGUID(riid, __uuidof(AccessibleBase))) 103 *ppvObject = static_cast<AccessibleBase*>(this); 104 else { 105 *ppvObject = 0; 106 return E_NOINTERFACE; 107 } 108 AddRef(); 109 return S_OK; 110 } 111 112 ULONG STDMETHODCALLTYPE AccessibleBase::Release(void) 113 { 114 ASSERT(m_refCount > 0); 115 if (--m_refCount) 116 return m_refCount; 117 delete this; 118 return 0; 119 } 120 121 // IAccessible 122 HRESULT STDMETHODCALLTYPE AccessibleBase::get_accParent(IDispatch** parent) 123 { 124 *parent = 0; 125 126 if (!m_object) 127 return E_FAIL; 128 129 AccessibilityObject* parentObject = m_object->parentObjectUnignored(); 130 if (parentObject) { 131 *parent = wrapper(parentObject); 132 (*parent)->AddRef(); 133 return S_OK; 134 } 135 136 if (!m_object->topDocumentFrameView()) 137 return E_FAIL; 138 139 return WebView::AccessibleObjectFromWindow(m_object->topDocumentFrameView()->hostWindow()->platformPageClient(), 140 OBJID_WINDOW, __uuidof(IAccessible), reinterpret_cast<void**>(parent)); 141 } 142 143 HRESULT STDMETHODCALLTYPE AccessibleBase::get_accChildCount(long* count) 144 { 145 if (!m_object) 146 return E_FAIL; 147 if (!count) 148 return E_POINTER; 149 *count = static_cast<long>(m_object->children().size()); 150 return S_OK; 151 } 152 153 HRESULT STDMETHODCALLTYPE AccessibleBase::get_accChild(VARIANT vChild, IDispatch** ppChild) 154 { 155 if (!ppChild) 156 return E_POINTER; 157 158 *ppChild = 0; 159 160 AccessibilityObject* childObj; 161 162 HRESULT hr = getAccessibilityObjectForChild(vChild, childObj); 163 if (FAILED(hr)) 164 return hr; 165 166 *ppChild = static_cast<IDispatch*>(wrapper(childObj)); 167 (*ppChild)->AddRef(); 168 return S_OK; 169 } 170 171 HRESULT STDMETHODCALLTYPE AccessibleBase::get_accName(VARIANT vChild, BSTR* name) 172 { 173 if (!name) 174 return E_POINTER; 175 176 *name = 0; 177 178 AccessibilityObject* childObj; 179 HRESULT hr = getAccessibilityObjectForChild(vChild, childObj); 180 181 if (FAILED(hr)) 182 return hr; 183 184 if (*name = BString(wrapper(childObj)->name()).release()) 185 return S_OK; 186 return S_FALSE; 187 } 188 189 HRESULT STDMETHODCALLTYPE AccessibleBase::get_accValue(VARIANT vChild, BSTR* value) 190 { 191 if (!value) 192 return E_POINTER; 193 194 *value = 0; 195 196 AccessibilityObject* childObj; 197 HRESULT hr = getAccessibilityObjectForChild(vChild, childObj); 198 199 if (FAILED(hr)) 200 return hr; 201 202 if (*value = BString(wrapper(childObj)->value()).release()) 203 return S_OK; 204 return S_FALSE; 205 } 206 207 HRESULT STDMETHODCALLTYPE AccessibleBase::get_accDescription(VARIANT vChild, BSTR* description) 208 { 209 if (!description) 210 return E_POINTER; 211 212 *description = 0; 213 214 AccessibilityObject* childObj; 215 HRESULT hr = getAccessibilityObjectForChild(vChild, childObj); 216 217 if (FAILED(hr)) 218 return hr; 219 220 if (*description = BString(childObj->descriptionForMSAA()).release()) 221 return S_OK; 222 223 return S_FALSE; 224 } 225 226 HRESULT STDMETHODCALLTYPE AccessibleBase::get_accRole(VARIANT vChild, VARIANT* pvRole) 227 { 228 if (!pvRole) 229 return E_POINTER; 230 231 ::VariantInit(pvRole); 232 233 AccessibilityObject* childObj; 234 HRESULT hr = getAccessibilityObjectForChild(vChild, childObj); 235 236 if (FAILED(hr)) 237 return hr; 238 239 String roleString = childObj->stringRoleForMSAA(); 240 if (!roleString.isEmpty()) { 241 V_VT(pvRole) = VT_BSTR; 242 V_BSTR(pvRole) = BString(roleString).release(); 243 return S_OK; 244 } 245 246 pvRole->vt = VT_I4; 247 pvRole->lVal = wrapper(childObj)->role(); 248 return S_OK; 249 } 250 251 HRESULT STDMETHODCALLTYPE AccessibleBase::get_accState(VARIANT vChild, VARIANT* pvState) 252 { 253 if (!pvState) 254 return E_POINTER; 255 256 ::VariantInit(pvState); 257 258 AccessibilityObject* childObj; 259 HRESULT hr = getAccessibilityObjectForChild(vChild, childObj); 260 261 if (FAILED(hr)) 262 return hr; 263 264 pvState->vt = VT_I4; 265 pvState->lVal = 0; 266 267 if (childObj->isLinked()) 268 pvState->lVal |= STATE_SYSTEM_LINKED; 269 270 if (childObj->isHovered()) 271 pvState->lVal |= STATE_SYSTEM_HOTTRACKED; 272 273 if (!childObj->isEnabled()) 274 pvState->lVal |= STATE_SYSTEM_UNAVAILABLE; 275 276 if (childObj->isReadOnly()) 277 pvState->lVal |= STATE_SYSTEM_READONLY; 278 279 if (childObj->isOffScreen()) 280 pvState->lVal |= STATE_SYSTEM_OFFSCREEN; 281 282 if (childObj->isPasswordField()) 283 pvState->lVal |= STATE_SYSTEM_PROTECTED; 284 285 if (childObj->isIndeterminate()) 286 pvState->lVal |= STATE_SYSTEM_INDETERMINATE; 287 288 if (childObj->isChecked()) 289 pvState->lVal |= STATE_SYSTEM_CHECKED; 290 291 if (childObj->isPressed()) 292 pvState->lVal |= STATE_SYSTEM_PRESSED; 293 294 if (childObj->isFocused()) 295 pvState->lVal |= STATE_SYSTEM_FOCUSED; 296 297 if (childObj->isVisited()) 298 pvState->lVal |= STATE_SYSTEM_TRAVERSED; 299 300 if (childObj->canSetFocusAttribute()) 301 pvState->lVal |= STATE_SYSTEM_FOCUSABLE; 302 303 if (childObj->isSelected()) 304 pvState->lVal |= STATE_SYSTEM_SELECTED; 305 306 if (childObj->canSetSelectedAttribute()) 307 pvState->lVal |= STATE_SYSTEM_SELECTABLE; 308 309 if (childObj->isMultiSelectable()) 310 pvState->lVal |= STATE_SYSTEM_EXTSELECTABLE | STATE_SYSTEM_MULTISELECTABLE; 311 312 if (!childObj->isVisible()) 313 pvState->lVal |= STATE_SYSTEM_INVISIBLE; 314 315 if (childObj->isCollapsed()) 316 pvState->lVal |= STATE_SYSTEM_COLLAPSED; 317 318 if (childObj->roleValue() == PopUpButtonRole) { 319 pvState->lVal |= STATE_SYSTEM_HASPOPUP; 320 321 if (!childObj->isCollapsed()) 322 pvState->lVal |= STATE_SYSTEM_EXPANDED; 323 } 324 325 return S_OK; 326 } 327 328 HRESULT STDMETHODCALLTYPE AccessibleBase::get_accHelp(VARIANT vChild, BSTR* helpText) 329 { 330 if (!helpText) 331 return E_POINTER; 332 333 *helpText = 0; 334 335 AccessibilityObject* childObj; 336 HRESULT hr = getAccessibilityObjectForChild(vChild, childObj); 337 338 if (FAILED(hr)) 339 return hr; 340 341 if (*helpText = BString(childObj->helpText()).release()) 342 return S_OK; 343 return S_FALSE; 344 } 345 346 HRESULT STDMETHODCALLTYPE AccessibleBase::get_accKeyboardShortcut(VARIANT vChild, BSTR* shortcut) 347 { 348 if (!shortcut) 349 return E_POINTER; 350 351 *shortcut = 0; 352 353 AccessibilityObject* childObj; 354 HRESULT hr = getAccessibilityObjectForChild(vChild, childObj); 355 356 if (FAILED(hr)) 357 return hr; 358 359 String accessKey = childObj->accessKey(); 360 if (accessKey.isNull()) 361 return S_FALSE; 362 363 static String accessKeyModifiers; 364 if (accessKeyModifiers.isNull()) { 365 unsigned modifiers = EventHandler::accessKeyModifiers(); 366 // Follow the same order as Mozilla MSAA implementation: 367 // Ctrl+Alt+Shift+Meta+key. MSDN states that keyboard shortcut strings 368 // should not be localized and defines the separator as "+". 369 if (modifiers & PlatformKeyboardEvent::CtrlKey) 370 accessKeyModifiers += "Ctrl+"; 371 if (modifiers & PlatformKeyboardEvent::AltKey) 372 accessKeyModifiers += "Alt+"; 373 if (modifiers & PlatformKeyboardEvent::ShiftKey) 374 accessKeyModifiers += "Shift+"; 375 if (modifiers & PlatformKeyboardEvent::MetaKey) 376 accessKeyModifiers += "Win+"; 377 } 378 *shortcut = BString(accessKeyModifiers + accessKey).release(); 379 return S_OK; 380 } 381 382 HRESULT STDMETHODCALLTYPE AccessibleBase::accSelect(long selectionFlags, VARIANT vChild) 383 { 384 // According to MSDN, these combinations are invalid. 385 if (((selectionFlags & (SELFLAG_ADDSELECTION | SELFLAG_REMOVESELECTION)) == (SELFLAG_ADDSELECTION | SELFLAG_REMOVESELECTION)) 386 || ((selectionFlags & (SELFLAG_ADDSELECTION | SELFLAG_TAKESELECTION)) == (SELFLAG_ADDSELECTION | SELFLAG_TAKESELECTION)) 387 || ((selectionFlags & (SELFLAG_REMOVESELECTION | SELFLAG_TAKESELECTION)) == (SELFLAG_REMOVESELECTION | SELFLAG_TAKESELECTION)) 388 || ((selectionFlags & (SELFLAG_EXTENDSELECTION | SELFLAG_TAKESELECTION)) == (SELFLAG_EXTENDSELECTION | SELFLAG_TAKESELECTION))) 389 return E_INVALIDARG; 390 391 AccessibilityObject* childObject; 392 HRESULT hr = getAccessibilityObjectForChild(vChild, childObject); 393 394 if (FAILED(hr)) 395 return hr; 396 397 if (selectionFlags & SELFLAG_TAKEFOCUS) 398 childObject->setFocused(true); 399 400 AccessibilityObject* parentObject = childObject->parentObject(); 401 if (!parentObject) 402 return E_INVALIDARG; 403 404 if (selectionFlags & SELFLAG_TAKESELECTION) { 405 if (parentObject->isListBox()) { 406 Vector<RefPtr<AccessibilityObject> > selectedChildren(1); 407 selectedChildren[0] = childObject; 408 static_cast<AccessibilityListBox*>(parentObject)->setSelectedChildren(selectedChildren); 409 } else { // any element may be selectable by virtue of it having the aria-selected property 410 ASSERT(!parentObject->isMultiSelectable()); 411 childObject->setSelected(true); 412 } 413 } 414 415 // MSDN says that ADD, REMOVE, and EXTENDSELECTION with no other flags are invalid for 416 // single-select. 417 const long allSELFLAGs = SELFLAG_TAKEFOCUS | SELFLAG_TAKESELECTION | SELFLAG_EXTENDSELECTION | SELFLAG_ADDSELECTION | SELFLAG_REMOVESELECTION; 418 if (!parentObject->isMultiSelectable() 419 && (((selectionFlags & allSELFLAGs) == SELFLAG_ADDSELECTION) 420 || ((selectionFlags & allSELFLAGs) == SELFLAG_REMOVESELECTION) 421 || ((selectionFlags & allSELFLAGs) == SELFLAG_EXTENDSELECTION))) 422 return E_INVALIDARG; 423 424 if (selectionFlags & SELFLAG_ADDSELECTION) 425 childObject->setSelected(true); 426 427 if (selectionFlags & SELFLAG_REMOVESELECTION) 428 childObject->setSelected(false); 429 430 // FIXME: Should implement SELFLAG_EXTENDSELECTION. For now, we just return 431 // S_OK, matching Firefox. 432 433 return S_OK; 434 } 435 436 HRESULT STDMETHODCALLTYPE AccessibleBase::get_accSelection(VARIANT*) 437 { 438 return E_NOTIMPL; 439 } 440 441 HRESULT STDMETHODCALLTYPE AccessibleBase::get_accFocus(VARIANT* pvFocusedChild) 442 { 443 if (!pvFocusedChild) 444 return E_POINTER; 445 446 ::VariantInit(pvFocusedChild); 447 448 if (!m_object) 449 return E_FAIL; 450 451 AccessibilityObject* focusedObj = m_object->focusedUIElement(); 452 if (!focusedObj) 453 return S_FALSE; 454 455 if (focusedObj == m_object) { 456 V_VT(pvFocusedChild) = VT_I4; 457 V_I4(pvFocusedChild) = CHILDID_SELF; 458 return S_OK; 459 } 460 461 V_VT(pvFocusedChild) = VT_DISPATCH; 462 V_DISPATCH(pvFocusedChild) = wrapper(focusedObj); 463 V_DISPATCH(pvFocusedChild)->AddRef(); 464 return S_OK; 465 } 466 467 HRESULT STDMETHODCALLTYPE AccessibleBase::get_accDefaultAction(VARIANT vChild, BSTR* action) 468 { 469 if (!action) 470 return E_POINTER; 471 472 *action = 0; 473 474 AccessibilityObject* childObj; 475 HRESULT hr = getAccessibilityObjectForChild(vChild, childObj); 476 477 if (FAILED(hr)) 478 return hr; 479 480 if (*action = BString(childObj->actionVerb()).release()) 481 return S_OK; 482 return S_FALSE; 483 } 484 485 HRESULT STDMETHODCALLTYPE AccessibleBase::accLocation(long* left, long* top, long* width, long* height, VARIANT vChild) 486 { 487 if (!left || !top || !width || !height) 488 return E_POINTER; 489 490 *left = *top = *width = *height = 0; 491 492 AccessibilityObject* childObj; 493 HRESULT hr = getAccessibilityObjectForChild(vChild, childObj); 494 495 if (FAILED(hr)) 496 return hr; 497 498 if (!childObj->documentFrameView()) 499 return E_FAIL; 500 501 IntRect screenRect(childObj->documentFrameView()->contentsToScreen(childObj->elementRect())); 502 *left = screenRect.x(); 503 *top = screenRect.y(); 504 *width = screenRect.width(); 505 *height = screenRect.height(); 506 return S_OK; 507 } 508 509 HRESULT STDMETHODCALLTYPE AccessibleBase::accNavigate(long direction, VARIANT vFromChild, VARIANT* pvNavigatedTo) 510 { 511 if (!pvNavigatedTo) 512 return E_POINTER; 513 514 ::VariantInit(pvNavigatedTo); 515 516 AccessibilityObject* childObj = 0; 517 518 switch (direction) { 519 case NAVDIR_DOWN: 520 case NAVDIR_UP: 521 case NAVDIR_LEFT: 522 case NAVDIR_RIGHT: 523 // These directions are not implemented, matching Mozilla and IE. 524 return E_NOTIMPL; 525 case NAVDIR_LASTCHILD: 526 case NAVDIR_FIRSTCHILD: 527 // MSDN states that navigating to first/last child can only be from self. 528 if (vFromChild.lVal != CHILDID_SELF) 529 return E_INVALIDARG; 530 531 if (!m_object) 532 return E_FAIL; 533 534 if (direction == NAVDIR_FIRSTCHILD) 535 childObj = m_object->firstChild(); 536 else 537 childObj = m_object->lastChild(); 538 break; 539 case NAVDIR_NEXT: 540 case NAVDIR_PREVIOUS: { 541 // Navigating to next and previous is allowed from self or any of our children. 542 HRESULT hr = getAccessibilityObjectForChild(vFromChild, childObj); 543 if (FAILED(hr)) 544 return hr; 545 546 if (direction == NAVDIR_NEXT) 547 childObj = childObj->nextSibling(); 548 else 549 childObj = childObj->previousSibling(); 550 break; 551 } 552 default: 553 ASSERT_NOT_REACHED(); 554 return E_INVALIDARG; 555 } 556 557 if (!childObj) 558 return S_FALSE; 559 560 V_VT(pvNavigatedTo) = VT_DISPATCH; 561 V_DISPATCH(pvNavigatedTo) = wrapper(childObj); 562 V_DISPATCH(pvNavigatedTo)->AddRef(); 563 return S_OK; 564 } 565 566 HRESULT STDMETHODCALLTYPE AccessibleBase::accHitTest(long x, long y, VARIANT* pvChildAtPoint) 567 { 568 if (!pvChildAtPoint) 569 return E_POINTER; 570 571 ::VariantInit(pvChildAtPoint); 572 573 if (!m_object || !m_object->documentFrameView()) 574 return E_FAIL; 575 576 IntPoint point = m_object->documentFrameView()->screenToContents(IntPoint(x, y)); 577 AccessibilityObject* childObj = m_object->accessibilityHitTest(point); 578 579 if (!childObj) { 580 // If we did not hit any child objects, test whether the point hit us, and 581 // report that. 582 if (!m_object->boundingBoxRect().contains(point)) 583 return S_FALSE; 584 childObj = m_object; 585 } 586 587 if (childObj == m_object) { 588 V_VT(pvChildAtPoint) = VT_I4; 589 V_I4(pvChildAtPoint) = CHILDID_SELF; 590 } else { 591 V_VT(pvChildAtPoint) = VT_DISPATCH; 592 V_DISPATCH(pvChildAtPoint) = static_cast<IDispatch*>(wrapper(childObj)); 593 V_DISPATCH(pvChildAtPoint)->AddRef(); 594 } 595 return S_OK; 596 } 597 598 HRESULT STDMETHODCALLTYPE AccessibleBase::accDoDefaultAction(VARIANT vChild) 599 { 600 AccessibilityObject* childObj; 601 HRESULT hr = getAccessibilityObjectForChild(vChild, childObj); 602 603 if (FAILED(hr)) 604 return hr; 605 606 if (!childObj->performDefaultAction()) 607 return S_FALSE; 608 609 return S_OK; 610 } 611 612 // AccessibleBase 613 String AccessibleBase::name() const 614 { 615 return m_object->nameForMSAA(); 616 } 617 618 String AccessibleBase::value() const 619 { 620 return m_object->stringValueForMSAA(); 621 } 622 623 static long MSAARole(AccessibilityRole role) 624 { 625 switch (role) { 626 case WebCore::ButtonRole: 627 return ROLE_SYSTEM_PUSHBUTTON; 628 case WebCore::RadioButtonRole: 629 return ROLE_SYSTEM_RADIOBUTTON; 630 case WebCore::CheckBoxRole: 631 return ROLE_SYSTEM_CHECKBUTTON; 632 case WebCore::SliderRole: 633 return ROLE_SYSTEM_SLIDER; 634 case WebCore::TabGroupRole: 635 return ROLE_SYSTEM_PAGETABLIST; 636 case WebCore::TextFieldRole: 637 case WebCore::TextAreaRole: 638 case WebCore::EditableTextRole: 639 return ROLE_SYSTEM_TEXT; 640 case WebCore::ListMarkerRole: 641 case WebCore::StaticTextRole: 642 return ROLE_SYSTEM_STATICTEXT; 643 case WebCore::OutlineRole: 644 return ROLE_SYSTEM_OUTLINE; 645 case WebCore::ColumnRole: 646 return ROLE_SYSTEM_COLUMN; 647 case WebCore::RowRole: 648 return ROLE_SYSTEM_ROW; 649 case WebCore::GroupRole: 650 return ROLE_SYSTEM_GROUPING; 651 case WebCore::ListRole: 652 case WebCore::ListBoxRole: 653 case WebCore::MenuListPopupRole: 654 return ROLE_SYSTEM_LIST; 655 case WebCore::TableRole: 656 return ROLE_SYSTEM_TABLE; 657 case WebCore::LinkRole: 658 case WebCore::WebCoreLinkRole: 659 return ROLE_SYSTEM_LINK; 660 case WebCore::ImageMapRole: 661 case WebCore::ImageRole: 662 return ROLE_SYSTEM_GRAPHIC; 663 case WebCore::MenuListOptionRole: 664 case WebCore::ListItemRole: 665 case WebCore::ListBoxOptionRole: 666 return ROLE_SYSTEM_LISTITEM; 667 case WebCore::PopUpButtonRole: 668 return ROLE_SYSTEM_COMBOBOX; 669 default: 670 // This is the default role for MSAA. 671 return ROLE_SYSTEM_CLIENT; 672 } 673 } 674 675 long AccessibleBase::role() const 676 { 677 return MSAARole(m_object->roleValueForMSAA()); 678 } 679 680 HRESULT AccessibleBase::getAccessibilityObjectForChild(VARIANT vChild, AccessibilityObject*& childObj) const 681 { 682 childObj = 0; 683 684 if (!m_object) 685 return E_FAIL; 686 687 if (vChild.vt != VT_I4) 688 return E_INVALIDARG; 689 690 if (vChild.lVal == CHILDID_SELF) 691 childObj = m_object; 692 else if (vChild.lVal < 0) { 693 // When broadcasting MSAA events, we negate the AXID and pass it as the 694 // child ID. 695 Document* document = m_object->document(); 696 if (!document) 697 return E_FAIL; 698 699 childObj = document->axObjectCache()->objectFromAXID(-vChild.lVal); 700 } else { 701 size_t childIndex = static_cast<size_t>(vChild.lVal - 1); 702 703 if (childIndex >= m_object->children().size()) 704 return E_FAIL; 705 childObj = m_object->children().at(childIndex).get(); 706 } 707 708 if (!childObj) 709 return E_FAIL; 710 711 return S_OK; 712 } 713 714 AccessibleBase* AccessibleBase::wrapper(AccessibilityObject* obj) 715 { 716 AccessibleBase* result = static_cast<AccessibleBase*>(obj->wrapper()); 717 if (!result) 718 result = createInstance(obj); 719 return result; 720 } 721 722 HRESULT AccessibleBase::isSameObject(IAccessibleComparable* other, BOOL* result) 723 { 724 COMPtr<AccessibleBase> otherAccessibleBase(Query, other); 725 *result = (otherAccessibleBase == this || otherAccessibleBase->m_object == m_object); 726 return S_OK; 727 } 728
