| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/browser_accessibility_win.h" | |
| 6 | |
| 7 #include "base/logging.h" | |
| 8 #include "base/string_util.h" | |
| 9 #include "base/utf_string_conversions.h" | |
| 10 #include "chrome/browser/browser_accessibility_manager_win.h" | |
| 11 #include "net/base/escape.h" | |
| 12 | |
| 13 using webkit_glue::WebAccessibility; | |
| 14 | |
| 15 BrowserAccessibility::BrowserAccessibility() | |
| 16 : manager_(NULL), | |
| 17 parent_(NULL), | |
| 18 child_id_(-1), | |
| 19 index_in_parent_(-1), | |
| 20 renderer_id_(-1), | |
| 21 instance_active_(false) { | |
| 22 } | |
| 23 | |
| 24 BrowserAccessibility::~BrowserAccessibility() { | |
| 25 InactivateTree(); | |
| 26 } | |
| 27 | |
| 28 void BrowserAccessibility::Initialize( | |
| 29 BrowserAccessibilityManager* manager, | |
| 30 BrowserAccessibility* parent, | |
| 31 LONG child_id, | |
| 32 LONG index_in_parent, | |
| 33 const webkit_glue::WebAccessibility& src) { | |
| 34 DCHECK_EQ(children_.size(), 0U); | |
| 35 | |
| 36 manager_ = manager; | |
| 37 parent_ = parent; | |
| 38 child_id_ = child_id; | |
| 39 index_in_parent_ = index_in_parent; | |
| 40 | |
| 41 renderer_id_ = src.id; | |
| 42 name_ = src.name; | |
| 43 value_ = src.value; | |
| 44 attributes_ = src.attributes; | |
| 45 html_attributes_ = src.html_attributes; | |
| 46 location_ = src.location; | |
| 47 InitRoleAndState(src.role, src.state); | |
| 48 | |
| 49 // Expose headings levels to NVDA with the "level" object attribute. | |
| 50 if (src.role == WebAccessibility::ROLE_HEADING && role_name_.size() == 2 && | |
| 51 IsAsciiDigit(role_name_[1])) { | |
| 52 html_attributes_.push_back(std::make_pair(L"level", role_name_.substr(1))); | |
| 53 } | |
| 54 | |
| 55 // If this object doesn't have a name but it does have a description, | |
| 56 // use the description as its name - because some screen readers only | |
| 57 // announce the name. | |
| 58 if (name_.empty() && HasAttribute(WebAccessibility::ATTR_DESCRIPTION)) { | |
| 59 GetAttribute(WebAccessibility::ATTR_DESCRIPTION, &name_); | |
| 60 } | |
| 61 | |
| 62 instance_active_ = true; | |
| 63 } | |
| 64 | |
| 65 void BrowserAccessibility::AddChild(BrowserAccessibility* child) { | |
| 66 children_.push_back(child); | |
| 67 } | |
| 68 | |
| 69 void BrowserAccessibility::InactivateTree() { | |
| 70 if (!instance_active_) | |
| 71 return; | |
| 72 | |
| 73 // Mark this object as inactive, so calls to all COM methods will return | |
| 74 // failure. | |
| 75 instance_active_ = false; | |
| 76 | |
| 77 // Now we can safely call InactivateTree on our children and remove | |
| 78 // references to them, so that as much of the tree as possible will be | |
| 79 // destroyed now - however, nodes that still have references to them | |
| 80 // might stick around a while until all clients have released them. | |
| 81 for (std::vector<BrowserAccessibility*>::iterator iter = | |
| 82 children_.begin(); | |
| 83 iter != children_.end(); ++iter) { | |
| 84 (*iter)->InactivateTree(); | |
| 85 (*iter)->Release(); | |
| 86 } | |
| 87 children_.clear(); | |
| 88 manager_->Remove(child_id_); | |
| 89 } | |
| 90 | |
| 91 bool BrowserAccessibility::IsDescendantOf(BrowserAccessibility* ancestor) { | |
| 92 if (this == ancestor) { | |
| 93 return true; | |
| 94 } else if (parent_) { | |
| 95 return parent_->IsDescendantOf(ancestor); | |
| 96 } | |
| 97 | |
| 98 return false; | |
| 99 } | |
| 100 | |
| 101 BrowserAccessibility* BrowserAccessibility::GetParent() { | |
| 102 return parent_; | |
| 103 } | |
| 104 | |
| 105 uint32 BrowserAccessibility::GetChildCount() { | |
| 106 return children_.size(); | |
| 107 } | |
| 108 | |
| 109 BrowserAccessibility* BrowserAccessibility::GetPreviousSibling() { | |
| 110 if (parent_ && index_in_parent_ > 0) | |
| 111 return parent_->children_[index_in_parent_ - 1]; | |
| 112 | |
| 113 return NULL; | |
| 114 } | |
| 115 | |
| 116 BrowserAccessibility* BrowserAccessibility::GetNextSibling() { | |
| 117 if (parent_ && | |
| 118 index_in_parent_ >= 0 && | |
| 119 index_in_parent_ < static_cast<int>(parent_->children_.size() - 1)) { | |
| 120 return parent_->children_[index_in_parent_ + 1]; | |
| 121 } | |
| 122 | |
| 123 return NULL; | |
| 124 } | |
| 125 | |
| 126 void BrowserAccessibility::ReplaceChild( | |
| 127 const BrowserAccessibility* old_acc, BrowserAccessibility* new_acc) { | |
| 128 DCHECK_EQ(children_[old_acc->index_in_parent_], old_acc); | |
| 129 | |
| 130 old_acc = children_[old_acc->index_in_parent_]; | |
| 131 children_[old_acc->index_in_parent_] = new_acc; | |
| 132 } | |
| 133 | |
| 134 BrowserAccessibility* BrowserAccessibility::NewReference() { | |
| 135 AddRef(); | |
| 136 return this; | |
| 137 } | |
| 138 | |
| 139 // | |
| 140 // IAccessible methods. | |
| 141 // | |
| 142 // Conventions: | |
| 143 // * Always test for instance_active_ first and return E_FAIL if it's false. | |
| 144 // * Always check for invalid arguments first, even if they're unused. | |
| 145 // * Return S_FALSE if the only output is a string argument and it's empty. | |
| 146 // | |
| 147 | |
| 148 HRESULT BrowserAccessibility::accDoDefaultAction(VARIANT var_id) { | |
| 149 if (!instance_active_) | |
| 150 return E_FAIL; | |
| 151 | |
| 152 BrowserAccessibility* target = GetTargetFromChildID(var_id); | |
| 153 if (!target) | |
| 154 return E_INVALIDARG; | |
| 155 | |
| 156 manager_->DoDefaultAction(*target); | |
| 157 return S_OK; | |
| 158 } | |
| 159 | |
| 160 STDMETHODIMP BrowserAccessibility::accHitTest(LONG x_left, LONG y_top, | |
| 161 VARIANT* child) { | |
| 162 if (!instance_active_) | |
| 163 return E_FAIL; | |
| 164 | |
| 165 if (!child) | |
| 166 return E_INVALIDARG; | |
| 167 | |
| 168 return E_NOTIMPL; | |
| 169 } | |
| 170 | |
| 171 STDMETHODIMP BrowserAccessibility::accLocation(LONG* x_left, LONG* y_top, | |
| 172 LONG* width, LONG* height, | |
| 173 VARIANT var_id) { | |
| 174 if (!instance_active_) | |
| 175 return E_FAIL; | |
| 176 | |
| 177 if (!x_left || !y_top || !width || !height) | |
| 178 return E_INVALIDARG; | |
| 179 | |
| 180 BrowserAccessibility* target = GetTargetFromChildID(var_id); | |
| 181 if (!target) | |
| 182 return E_INVALIDARG; | |
| 183 | |
| 184 // Find the top left corner of the containing window in screen coords, and | |
| 185 // adjust the output position by this amount. | |
| 186 HWND parent_hwnd = manager_->GetParentHWND(); | |
| 187 POINT top_left = {0, 0}; | |
| 188 ::ClientToScreen(parent_hwnd, &top_left); | |
| 189 | |
| 190 *x_left = target->location_.x + top_left.x; | |
| 191 *y_top = target->location_.y + top_left.y; | |
| 192 *width = target->location_.width; | |
| 193 *height = target->location_.height; | |
| 194 | |
| 195 return S_OK; | |
| 196 } | |
| 197 | |
| 198 STDMETHODIMP BrowserAccessibility::accNavigate( | |
| 199 LONG nav_dir, VARIANT start, VARIANT* end) { | |
| 200 BrowserAccessibility* target = GetTargetFromChildID(start); | |
| 201 if (!target) | |
| 202 return E_INVALIDARG; | |
| 203 | |
| 204 if ((nav_dir == NAVDIR_LASTCHILD || nav_dir == NAVDIR_FIRSTCHILD) && | |
| 205 start.lVal != CHILDID_SELF) { | |
| 206 // MSAA states that navigating to first/last child can only be from self. | |
| 207 return E_INVALIDARG; | |
| 208 } | |
| 209 | |
| 210 BrowserAccessibility* result = NULL; | |
| 211 switch (nav_dir) { | |
| 212 case NAVDIR_DOWN: | |
| 213 case NAVDIR_UP: | |
| 214 case NAVDIR_LEFT: | |
| 215 case NAVDIR_RIGHT: | |
| 216 // These directions are not implemented, matching Mozilla and IE. | |
| 217 return E_NOTIMPL; | |
| 218 case NAVDIR_FIRSTCHILD: | |
| 219 if (target->children_.size() > 0) | |
| 220 result = target->children_[0]; | |
| 221 break; | |
| 222 case NAVDIR_LASTCHILD: | |
| 223 if (target->children_.size() > 0) | |
| 224 result = target->children_[target->children_.size() - 1]; | |
| 225 break; | |
| 226 case NAVDIR_NEXT: | |
| 227 result = target->GetNextSibling(); | |
| 228 break; | |
| 229 case NAVDIR_PREVIOUS: | |
| 230 result = target->GetPreviousSibling(); | |
| 231 break; | |
| 232 } | |
| 233 | |
| 234 if (!result) { | |
| 235 end->vt = VT_EMPTY; | |
| 236 return S_FALSE; | |
| 237 } | |
| 238 | |
| 239 end->vt = VT_DISPATCH; | |
| 240 end->pdispVal = result->NewReference(); | |
| 241 return S_OK; | |
| 242 } | |
| 243 | |
| 244 STDMETHODIMP BrowserAccessibility::get_accChild(VARIANT var_child, | |
| 245 IDispatch** disp_child) { | |
| 246 if (!instance_active_) | |
| 247 return E_FAIL; | |
| 248 | |
| 249 if (!disp_child) | |
| 250 return E_INVALIDARG; | |
| 251 | |
| 252 *disp_child = NULL; | |
| 253 | |
| 254 BrowserAccessibility* target = GetTargetFromChildID(var_child); | |
| 255 if (!target) | |
| 256 return E_INVALIDARG; | |
| 257 | |
| 258 (*disp_child) = target->NewReference(); | |
| 259 return S_OK; | |
| 260 } | |
| 261 | |
| 262 STDMETHODIMP BrowserAccessibility::get_accChildCount(LONG* child_count) { | |
| 263 if (!instance_active_) | |
| 264 return E_FAIL; | |
| 265 | |
| 266 if (!child_count) | |
| 267 return E_INVALIDARG; | |
| 268 | |
| 269 *child_count = children_.size(); | |
| 270 return S_OK; | |
| 271 } | |
| 272 | |
| 273 STDMETHODIMP BrowserAccessibility::get_accDefaultAction(VARIANT var_id, | |
| 274 BSTR* def_action) { | |
| 275 if (!instance_active_) | |
| 276 return E_FAIL; | |
| 277 | |
| 278 if (!def_action) | |
| 279 return E_INVALIDARG; | |
| 280 | |
| 281 BrowserAccessibility* target = GetTargetFromChildID(var_id); | |
| 282 if (!target) | |
| 283 return E_INVALIDARG; | |
| 284 | |
| 285 return target->GetAttributeAsBstr( | |
| 286 WebAccessibility::ATTR_SHORTCUT, def_action); | |
| 287 } | |
| 288 | |
| 289 STDMETHODIMP BrowserAccessibility::get_accDescription(VARIANT var_id, | |
| 290 BSTR* desc) { | |
| 291 if (!instance_active_) | |
| 292 return E_FAIL; | |
| 293 | |
| 294 if (!desc) | |
| 295 return E_INVALIDARG; | |
| 296 | |
| 297 BrowserAccessibility* target = GetTargetFromChildID(var_id); | |
| 298 if (!target) | |
| 299 return E_INVALIDARG; | |
| 300 | |
| 301 return target->GetAttributeAsBstr(WebAccessibility::ATTR_DESCRIPTION, desc); | |
| 302 } | |
| 303 | |
| 304 STDMETHODIMP BrowserAccessibility::get_accFocus(VARIANT* focus_child) { | |
| 305 if (!instance_active_) | |
| 306 return E_FAIL; | |
| 307 | |
| 308 if (!focus_child) | |
| 309 return E_INVALIDARG; | |
| 310 | |
| 311 BrowserAccessibility* focus = manager_->GetFocus(this); | |
| 312 if (focus == this) { | |
| 313 focus_child->vt = VT_I4; | |
| 314 focus_child->lVal = CHILDID_SELF; | |
| 315 } else if (focus == NULL) { | |
| 316 focus_child->vt = VT_EMPTY; | |
| 317 } else { | |
| 318 focus_child->vt = VT_DISPATCH; | |
| 319 focus_child->pdispVal = focus->NewReference(); | |
| 320 } | |
| 321 | |
| 322 return S_OK; | |
| 323 } | |
| 324 | |
| 325 STDMETHODIMP BrowserAccessibility::get_accHelp(VARIANT var_id, BSTR* help) { | |
| 326 if (!instance_active_) | |
| 327 return E_FAIL; | |
| 328 | |
| 329 if (!help) | |
| 330 return E_INVALIDARG; | |
| 331 | |
| 332 BrowserAccessibility* target = GetTargetFromChildID(var_id); | |
| 333 if (!target) | |
| 334 return E_INVALIDARG; | |
| 335 | |
| 336 return target->GetAttributeAsBstr(WebAccessibility::ATTR_HELP, help); | |
| 337 } | |
| 338 | |
| 339 STDMETHODIMP BrowserAccessibility::get_accKeyboardShortcut(VARIANT var_id, | |
| 340 BSTR* acc_key) { | |
| 341 if (!instance_active_) | |
| 342 return E_FAIL; | |
| 343 | |
| 344 if (!acc_key) | |
| 345 return E_INVALIDARG; | |
| 346 | |
| 347 BrowserAccessibility* target = GetTargetFromChildID(var_id); | |
| 348 if (!target) | |
| 349 return E_INVALIDARG; | |
| 350 | |
| 351 return target->GetAttributeAsBstr(WebAccessibility::ATTR_SHORTCUT, acc_key); | |
| 352 } | |
| 353 | |
| 354 STDMETHODIMP BrowserAccessibility::get_accName(VARIANT var_id, BSTR* name) { | |
| 355 if (!instance_active_) | |
| 356 return E_FAIL; | |
| 357 | |
| 358 if (!name) | |
| 359 return E_INVALIDARG; | |
| 360 | |
| 361 BrowserAccessibility* target = GetTargetFromChildID(var_id); | |
| 362 if (!target) | |
| 363 return E_INVALIDARG; | |
| 364 | |
| 365 if (target->name_.empty()) | |
| 366 return S_FALSE; | |
| 367 | |
| 368 *name = SysAllocString(target->name_.c_str()); | |
| 369 | |
| 370 DCHECK(*name); | |
| 371 return S_OK; | |
| 372 } | |
| 373 | |
| 374 STDMETHODIMP BrowserAccessibility::get_accParent(IDispatch** disp_parent) { | |
| 375 if (!instance_active_) | |
| 376 return E_FAIL; | |
| 377 | |
| 378 if (!disp_parent) | |
| 379 return E_INVALIDARG; | |
| 380 | |
| 381 IAccessible* parent = parent_; | |
| 382 if (parent == NULL) { | |
| 383 // This happens if we're the root of the tree; | |
| 384 // return the IAccessible for the window. | |
| 385 parent = manager_->GetParentWindowIAccessible(); | |
| 386 } | |
| 387 | |
| 388 parent->AddRef(); | |
| 389 *disp_parent = parent; | |
| 390 return S_OK; | |
| 391 } | |
| 392 | |
| 393 STDMETHODIMP BrowserAccessibility::get_accRole(VARIANT var_id, VARIANT* role) { | |
| 394 if (!instance_active_) | |
| 395 return E_FAIL; | |
| 396 | |
| 397 if (!role) | |
| 398 return E_INVALIDARG; | |
| 399 | |
| 400 BrowserAccessibility* target = GetTargetFromChildID(var_id); | |
| 401 if (!target) | |
| 402 return E_INVALIDARG; | |
| 403 | |
| 404 if (!target->role_name_.empty()) { | |
| 405 role->vt = VT_BSTR; | |
| 406 role->bstrVal = SysAllocString(target->role_name_.c_str()); | |
| 407 } else { | |
| 408 role->vt = VT_I4; | |
| 409 role->lVal = target->role_; | |
| 410 } | |
| 411 return S_OK; | |
| 412 } | |
| 413 | |
| 414 STDMETHODIMP BrowserAccessibility::get_accState(VARIANT var_id, | |
| 415 VARIANT* state) { | |
| 416 if (!instance_active_) | |
| 417 return E_FAIL; | |
| 418 | |
| 419 if (!state) | |
| 420 return E_INVALIDARG; | |
| 421 | |
| 422 BrowserAccessibility* target = GetTargetFromChildID(var_id); | |
| 423 if (!target) | |
| 424 return E_INVALIDARG; | |
| 425 | |
| 426 state->vt = VT_I4; | |
| 427 state->lVal = target->state_; | |
| 428 if (manager_->GetFocus(NULL) == this) | |
| 429 state->lVal |= STATE_SYSTEM_FOCUSED; | |
| 430 | |
| 431 return S_OK; | |
| 432 } | |
| 433 | |
| 434 STDMETHODIMP BrowserAccessibility::get_accValue(VARIANT var_id, BSTR* value) { | |
| 435 if (!instance_active_) | |
| 436 return E_FAIL; | |
| 437 | |
| 438 if (!value) | |
| 439 return E_INVALIDARG; | |
| 440 | |
| 441 BrowserAccessibility* target = GetTargetFromChildID(var_id); | |
| 442 if (!target) | |
| 443 return E_INVALIDARG; | |
| 444 | |
| 445 *value = SysAllocString(target->value_.c_str()); | |
| 446 | |
| 447 DCHECK(*value); | |
| 448 return S_OK; | |
| 449 } | |
| 450 | |
| 451 STDMETHODIMP BrowserAccessibility::get_accHelpTopic(BSTR* help_file, | |
| 452 VARIANT var_id, | |
| 453 LONG* topic_id) { | |
| 454 return E_NOTIMPL; | |
| 455 } | |
| 456 | |
| 457 STDMETHODIMP BrowserAccessibility::get_accSelection(VARIANT* selected) { | |
| 458 if (!instance_active_) | |
| 459 return E_FAIL; | |
| 460 | |
| 461 return E_NOTIMPL; | |
| 462 } | |
| 463 | |
| 464 STDMETHODIMP BrowserAccessibility::accSelect(LONG flags_sel, VARIANT var_id) { | |
| 465 if (!instance_active_) | |
| 466 return E_FAIL; | |
| 467 | |
| 468 if (flags_sel & SELFLAG_TAKEFOCUS) { | |
| 469 manager_->SetFocus(*this); | |
| 470 return S_OK; | |
| 471 } | |
| 472 | |
| 473 return S_FALSE; | |
| 474 } | |
| 475 | |
| 476 // | |
| 477 // IAccessible2 methods. | |
| 478 // | |
| 479 | |
| 480 STDMETHODIMP BrowserAccessibility::role(LONG* role) { | |
| 481 if (!instance_active_) | |
| 482 return E_FAIL; | |
| 483 | |
| 484 if (!role) | |
| 485 return E_INVALIDARG; | |
| 486 | |
| 487 *role = ia2_role_; | |
| 488 | |
| 489 return S_OK; | |
| 490 } | |
| 491 | |
| 492 STDMETHODIMP BrowserAccessibility::get_attributes(BSTR* attributes) { | |
| 493 if (!instance_active_) | |
| 494 return E_FAIL; | |
| 495 | |
| 496 if (!attributes) | |
| 497 return E_INVALIDARG; | |
| 498 | |
| 499 // Follow Firefox's convention, which is to return a set of key-value pairs | |
| 500 // separated by semicolons, with a colon between the key and the value. | |
| 501 string16 str; | |
| 502 for (unsigned int i = 0; i < html_attributes_.size(); i++) { | |
| 503 if (i != 0) | |
| 504 str += L';'; | |
| 505 str += Escape(html_attributes_[i].first); | |
| 506 str += L':'; | |
| 507 str += Escape(html_attributes_[i].second); | |
| 508 } | |
| 509 | |
| 510 if (str.empty()) | |
| 511 return S_FALSE; | |
| 512 | |
| 513 *attributes = SysAllocString(str.c_str()); | |
| 514 DCHECK(*attributes); | |
| 515 return S_OK; | |
| 516 } | |
| 517 | |
| 518 STDMETHODIMP BrowserAccessibility::get_states(AccessibleStates* states) { | |
| 519 if (!instance_active_) | |
| 520 return E_FAIL; | |
| 521 | |
| 522 if (!states) | |
| 523 return E_INVALIDARG; | |
| 524 | |
| 525 *states = ia2_state_; | |
| 526 | |
| 527 return S_OK; | |
| 528 } | |
| 529 | |
| 530 STDMETHODIMP BrowserAccessibility::get_uniqueID(LONG* unique_id) { | |
| 531 if (!instance_active_) | |
| 532 return E_FAIL; | |
| 533 | |
| 534 if (!unique_id) | |
| 535 return E_INVALIDARG; | |
| 536 | |
| 537 *unique_id = child_id_; | |
| 538 return S_OK; | |
| 539 } | |
| 540 | |
| 541 STDMETHODIMP BrowserAccessibility::get_windowHandle(HWND* window_handle) { | |
| 542 if (!instance_active_) | |
| 543 return E_FAIL; | |
| 544 | |
| 545 if (!window_handle) | |
| 546 return E_INVALIDARG; | |
| 547 | |
| 548 *window_handle = manager_->GetParentHWND(); | |
| 549 return S_OK; | |
| 550 } | |
| 551 | |
| 552 STDMETHODIMP BrowserAccessibility::get_indexInParent(LONG* index_in_parent) { | |
| 553 if (!instance_active_) | |
| 554 return E_FAIL; | |
| 555 | |
| 556 if (!index_in_parent) | |
| 557 return E_INVALIDARG; | |
| 558 | |
| 559 *index_in_parent = index_in_parent_; | |
| 560 return S_OK; | |
| 561 } | |
| 562 | |
| 563 // | |
| 564 // IAccessibleImage methods. | |
| 565 // | |
| 566 | |
| 567 STDMETHODIMP BrowserAccessibility::get_description(BSTR* desc) { | |
| 568 if (!instance_active_) | |
| 569 return E_FAIL; | |
| 570 | |
| 571 if (!desc) | |
| 572 return E_INVALIDARG; | |
| 573 | |
| 574 return GetAttributeAsBstr(WebAccessibility::ATTR_DESCRIPTION, desc); | |
| 575 } | |
| 576 | |
| 577 STDMETHODIMP BrowserAccessibility::get_imagePosition( | |
| 578 enum IA2CoordinateType coordinate_type, long* x, long* y) { | |
| 579 if (!instance_active_) | |
| 580 return E_FAIL; | |
| 581 | |
| 582 if (!x || !y) | |
| 583 return E_INVALIDARG; | |
| 584 | |
| 585 if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) { | |
| 586 HWND parent_hwnd = manager_->GetParentHWND(); | |
| 587 POINT top_left = {0, 0}; | |
| 588 ::ClientToScreen(parent_hwnd, &top_left); | |
| 589 *x = location_.x + top_left.x; | |
| 590 *y = location_.y + top_left.y; | |
| 591 } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) { | |
| 592 *x = location_.x; | |
| 593 *y = location_.y; | |
| 594 if (parent_) { | |
| 595 *x -= parent_->location_.x; | |
| 596 *y -= parent_->location_.y; | |
| 597 } | |
| 598 } else { | |
| 599 return E_INVALIDARG; | |
| 600 } | |
| 601 | |
| 602 return S_OK; | |
| 603 } | |
| 604 | |
| 605 STDMETHODIMP BrowserAccessibility::get_imageSize(long* height, long* width) { | |
| 606 if (!instance_active_) | |
| 607 return E_FAIL; | |
| 608 | |
| 609 if (!height || !width) | |
| 610 return E_INVALIDARG; | |
| 611 | |
| 612 *height = location_.height; | |
| 613 *width = location_.width; | |
| 614 return S_OK; | |
| 615 } | |
| 616 | |
| 617 // | |
| 618 // IAccessibleText methods. | |
| 619 // | |
| 620 | |
| 621 STDMETHODIMP BrowserAccessibility::get_nCharacters(long* n_characters) { | |
| 622 if (!instance_active_) | |
| 623 return E_FAIL; | |
| 624 | |
| 625 if (!n_characters) | |
| 626 return E_INVALIDARG; | |
| 627 | |
| 628 *n_characters = name_.length(); | |
| 629 return S_OK; | |
| 630 } | |
| 631 | |
| 632 STDMETHODIMP BrowserAccessibility::get_text( | |
| 633 long start_offset, long end_offset, BSTR* text) { | |
| 634 if (!instance_active_) | |
| 635 return E_FAIL; | |
| 636 | |
| 637 if (!text) | |
| 638 return E_INVALIDARG; | |
| 639 | |
| 640 long len = name_.length(); | |
| 641 if (start_offset < 0) | |
| 642 start_offset = 0; | |
| 643 if (end_offset > len) | |
| 644 end_offset = len; | |
| 645 | |
| 646 string16 substr = name_.substr(start_offset, end_offset - start_offset); | |
| 647 if (substr.empty()) | |
| 648 return S_FALSE; | |
| 649 | |
| 650 *text = SysAllocString(substr.c_str()); | |
| 651 DCHECK(*text); | |
| 652 return S_OK; | |
| 653 } | |
| 654 | |
| 655 STDMETHODIMP BrowserAccessibility::get_caretOffset(long* offset) { | |
| 656 if (!instance_active_) | |
| 657 return E_FAIL; | |
| 658 | |
| 659 if (!offset) | |
| 660 return E_INVALIDARG; | |
| 661 | |
| 662 *offset = 0; | |
| 663 return S_OK; | |
| 664 } | |
| 665 | |
| 666 // | |
| 667 // ISimpleDOMDocument methods. | |
| 668 // | |
| 669 | |
| 670 STDMETHODIMP BrowserAccessibility::get_URL(BSTR* url) { | |
| 671 if (!instance_active_) | |
| 672 return E_FAIL; | |
| 673 | |
| 674 if (!url) | |
| 675 return E_INVALIDARG; | |
| 676 | |
| 677 return GetAttributeAsBstr(WebAccessibility::ATTR_DOC_URL, url); | |
| 678 } | |
| 679 | |
| 680 STDMETHODIMP BrowserAccessibility::get_title(BSTR* title) { | |
| 681 if (!instance_active_) | |
| 682 return E_FAIL; | |
| 683 | |
| 684 if (!title) | |
| 685 return E_INVALIDARG; | |
| 686 | |
| 687 return GetAttributeAsBstr(WebAccessibility::ATTR_DOC_TITLE, title); | |
| 688 } | |
| 689 | |
| 690 STDMETHODIMP BrowserAccessibility::get_mimeType(BSTR* mime_type) { | |
| 691 if (!instance_active_) | |
| 692 return E_FAIL; | |
| 693 | |
| 694 if (!mime_type) | |
| 695 return E_INVALIDARG; | |
| 696 | |
| 697 return GetAttributeAsBstr(WebAccessibility::ATTR_DOC_MIMETYPE, mime_type); | |
| 698 } | |
| 699 | |
| 700 STDMETHODIMP BrowserAccessibility::get_docType(BSTR* doc_type) { | |
| 701 if (!instance_active_) | |
| 702 return E_FAIL; | |
| 703 | |
| 704 if (!doc_type) | |
| 705 return E_INVALIDARG; | |
| 706 | |
| 707 return GetAttributeAsBstr(WebAccessibility::ATTR_DOC_DOCTYPE, doc_type); | |
| 708 } | |
| 709 | |
| 710 // | |
| 711 // ISimpleDOMNode methods. | |
| 712 // | |
| 713 | |
| 714 STDMETHODIMP BrowserAccessibility::get_nodeInfo( | |
| 715 BSTR* node_name, | |
| 716 short* name_space_id, | |
| 717 BSTR* node_value, | |
| 718 unsigned int* num_children, | |
| 719 unsigned int* unique_id, | |
| 720 unsigned short* node_type) { | |
| 721 if (!instance_active_) | |
| 722 return E_FAIL; | |
| 723 | |
| 724 if (!node_name || !name_space_id || !node_value || !num_children || | |
| 725 !unique_id || !node_type) { | |
| 726 return E_INVALIDARG; | |
| 727 } | |
| 728 | |
| 729 string16 tag; | |
| 730 if (GetAttribute(WebAccessibility::ATTR_HTML_TAG, &tag)) | |
| 731 *node_name = SysAllocString(tag.c_str()); | |
| 732 else | |
| 733 *node_name = NULL; | |
| 734 | |
| 735 *name_space_id = 0; | |
| 736 *node_value = SysAllocString(value_.c_str()); | |
| 737 *num_children = children_.size(); | |
| 738 *unique_id = child_id_; | |
| 739 | |
| 740 if (role_ == ROLE_SYSTEM_DOCUMENT) { | |
| 741 *node_type = NODETYPE_DOCUMENT; | |
| 742 } else if (role_ == ROLE_SYSTEM_TEXT && | |
| 743 ((ia2_state_ & IA2_STATE_EDITABLE) == 0)) { | |
| 744 *node_type = NODETYPE_TEXT; | |
| 745 } else { | |
| 746 *node_type = NODETYPE_ELEMENT; | |
| 747 } | |
| 748 | |
| 749 return S_OK; | |
| 750 } | |
| 751 | |
| 752 STDMETHODIMP BrowserAccessibility::get_attributes( | |
| 753 unsigned short max_attribs, | |
| 754 BSTR* attrib_names, | |
| 755 short* name_space_id, | |
| 756 BSTR* attrib_values, | |
| 757 unsigned short* num_attribs) { | |
| 758 if (!instance_active_) | |
| 759 return E_FAIL; | |
| 760 | |
| 761 if (!attrib_names || !name_space_id || !attrib_values || !num_attribs) | |
| 762 return E_INVALIDARG; | |
| 763 | |
| 764 *num_attribs = max_attribs; | |
| 765 if (*num_attribs > html_attributes_.size()) | |
| 766 *num_attribs = html_attributes_.size(); | |
| 767 | |
| 768 for (unsigned short i = 0; i < *num_attribs; ++i) { | |
| 769 attrib_names[i] = SysAllocString(html_attributes_[i].first.c_str()); | |
| 770 name_space_id[i] = 0; | |
| 771 attrib_values[i] = SysAllocString(html_attributes_[i].second.c_str()); | |
| 772 } | |
| 773 return S_OK; | |
| 774 } | |
| 775 | |
| 776 STDMETHODIMP BrowserAccessibility::get_attributesForNames( | |
| 777 unsigned short num_attribs, | |
| 778 BSTR* attrib_names, | |
| 779 short* name_space_id, | |
| 780 BSTR* attrib_values) { | |
| 781 if (!instance_active_) | |
| 782 return E_FAIL; | |
| 783 | |
| 784 if (!attrib_names || !name_space_id || !attrib_values) | |
| 785 return E_INVALIDARG; | |
| 786 | |
| 787 for (unsigned short i = 0; i < num_attribs; ++i) { | |
| 788 name_space_id[i] = 0; | |
| 789 bool found = false; | |
| 790 string16 name = (LPCWSTR)attrib_names[i]; | |
| 791 for (unsigned int j = 0; j < html_attributes_.size(); ++j) { | |
| 792 if (html_attributes_[j].first == name) { | |
| 793 attrib_values[i] = SysAllocString(html_attributes_[j].second.c_str()); | |
| 794 found = true; | |
| 795 break; | |
| 796 } | |
| 797 } | |
| 798 if (!found) { | |
| 799 attrib_values[i] = NULL; | |
| 800 } | |
| 801 } | |
| 802 return S_OK; | |
| 803 } | |
| 804 | |
| 805 STDMETHODIMP BrowserAccessibility::get_computedStyle( | |
| 806 unsigned short max_style_properties, | |
| 807 boolean use_alternate_view, | |
| 808 BSTR *style_properties, | |
| 809 BSTR *style_values, | |
| 810 unsigned short *num_style_properties) { | |
| 811 if (!instance_active_) | |
| 812 return E_FAIL; | |
| 813 | |
| 814 if (!style_properties || !style_values) | |
| 815 return E_INVALIDARG; | |
| 816 | |
| 817 // We only cache a single style property for now: DISPLAY | |
| 818 | |
| 819 if (max_style_properties == 0 || | |
| 820 !HasAttribute(WebAccessibility::ATTR_DISPLAY)) { | |
| 821 *num_style_properties = 0; | |
| 822 return S_OK; | |
| 823 } | |
| 824 | |
| 825 string16 display; | |
| 826 GetAttribute(WebAccessibility::ATTR_DISPLAY, &display); | |
| 827 *num_style_properties = 1; | |
| 828 style_properties[0] = SysAllocString(L"display"); | |
| 829 style_values[0] = SysAllocString(display.c_str()); | |
| 830 | |
| 831 return S_OK; | |
| 832 } | |
| 833 | |
| 834 STDMETHODIMP BrowserAccessibility::get_computedStyleForProperties( | |
| 835 unsigned short num_style_properties, | |
| 836 boolean use_alternate_view, | |
| 837 BSTR* style_properties, | |
| 838 BSTR* style_values) { | |
| 839 if (!instance_active_) | |
| 840 return E_FAIL; | |
| 841 | |
| 842 if (!style_properties || !style_values) | |
| 843 return E_INVALIDARG; | |
| 844 | |
| 845 // We only cache a single style property for now: DISPLAY | |
| 846 | |
| 847 for (unsigned short i = 0; i < num_style_properties; i++) { | |
| 848 string16 name = (LPCWSTR)style_properties[i]; | |
| 849 StringToLowerASCII(&name); | |
| 850 if (name == L"display") { | |
| 851 string16 display; | |
| 852 GetAttribute(WebAccessibility::ATTR_DISPLAY, &display); | |
| 853 style_values[i] = SysAllocString(display.c_str()); | |
| 854 } else { | |
| 855 style_values[i] = NULL; | |
| 856 } | |
| 857 } | |
| 858 | |
| 859 return S_OK; | |
| 860 } | |
| 861 | |
| 862 STDMETHODIMP BrowserAccessibility::scrollTo(boolean placeTopLeft) { | |
| 863 return E_NOTIMPL; | |
| 864 } | |
| 865 | |
| 866 STDMETHODIMP BrowserAccessibility::get_parentNode(ISimpleDOMNode** node) { | |
| 867 if (!instance_active_) | |
| 868 return E_FAIL; | |
| 869 | |
| 870 if (!node) | |
| 871 return E_INVALIDARG; | |
| 872 | |
| 873 *node = parent_->NewReference(); | |
| 874 return S_OK; | |
| 875 } | |
| 876 | |
| 877 STDMETHODIMP BrowserAccessibility::get_firstChild(ISimpleDOMNode** node) { | |
| 878 if (!instance_active_) | |
| 879 return E_FAIL; | |
| 880 | |
| 881 if (!node) | |
| 882 return E_INVALIDARG; | |
| 883 | |
| 884 if (children_.size()) { | |
| 885 *node = children_[0]->NewReference(); | |
| 886 return S_OK; | |
| 887 } else { | |
| 888 *node = NULL; | |
| 889 return S_FALSE; | |
| 890 } | |
| 891 } | |
| 892 | |
| 893 STDMETHODIMP BrowserAccessibility::get_lastChild(ISimpleDOMNode** node) { | |
| 894 if (!instance_active_) | |
| 895 return E_FAIL; | |
| 896 | |
| 897 if (!node) | |
| 898 return E_INVALIDARG; | |
| 899 | |
| 900 if (children_.size()) { | |
| 901 *node = children_[children_.size() - 1]->NewReference(); | |
| 902 return S_OK; | |
| 903 } else { | |
| 904 *node = NULL; | |
| 905 return S_FALSE; | |
| 906 } | |
| 907 } | |
| 908 | |
| 909 STDMETHODIMP BrowserAccessibility::get_previousSibling( | |
| 910 ISimpleDOMNode** node) { | |
| 911 if (!instance_active_) | |
| 912 return E_FAIL; | |
| 913 | |
| 914 if (!node) | |
| 915 return E_INVALIDARG; | |
| 916 | |
| 917 if (parent_ && index_in_parent_ > 0) { | |
| 918 *node = parent_->children_[index_in_parent_ - 1]->NewReference(); | |
| 919 return S_OK; | |
| 920 } else { | |
| 921 *node = NULL; | |
| 922 return S_FALSE; | |
| 923 } | |
| 924 } | |
| 925 | |
| 926 STDMETHODIMP BrowserAccessibility::get_nextSibling(ISimpleDOMNode** node) { | |
| 927 if (!instance_active_) | |
| 928 return E_FAIL; | |
| 929 | |
| 930 if (!node) | |
| 931 return E_INVALIDARG; | |
| 932 | |
| 933 if (parent_ && | |
| 934 index_in_parent_ >= 0 && | |
| 935 index_in_parent_ < static_cast<int>(parent_->children_.size()) - 1) { | |
| 936 *node = parent_->children_[index_in_parent_ + 1]->NewReference(); | |
| 937 return S_OK; | |
| 938 } else { | |
| 939 *node = NULL; | |
| 940 return S_FALSE; | |
| 941 } | |
| 942 } | |
| 943 | |
| 944 STDMETHODIMP BrowserAccessibility::get_childAt( | |
| 945 unsigned int child_index, | |
| 946 ISimpleDOMNode** node) { | |
| 947 if (!instance_active_) | |
| 948 return E_FAIL; | |
| 949 | |
| 950 if (!node) | |
| 951 return E_INVALIDARG; | |
| 952 | |
| 953 if (child_index < children_.size()) { | |
| 954 *node = children_[child_index]->NewReference(); | |
| 955 return S_OK; | |
| 956 } else { | |
| 957 *node = NULL; | |
| 958 return S_FALSE; | |
| 959 } | |
| 960 } | |
| 961 | |
| 962 // | |
| 963 // ISimpleDOMText methods. | |
| 964 // | |
| 965 | |
| 966 STDMETHODIMP BrowserAccessibility::get_domText(BSTR* dom_text) { | |
| 967 if (!instance_active_) | |
| 968 return E_FAIL; | |
| 969 | |
| 970 if (!dom_text) | |
| 971 return E_INVALIDARG; | |
| 972 | |
| 973 if (name_.empty()) | |
| 974 return S_FALSE; | |
| 975 | |
| 976 *dom_text = SysAllocString(name_.c_str()); | |
| 977 DCHECK(*dom_text); | |
| 978 return S_OK; | |
| 979 } | |
| 980 | |
| 981 // | |
| 982 // IServiceProvider methods. | |
| 983 // | |
| 984 | |
| 985 STDMETHODIMP BrowserAccessibility::QueryService( | |
| 986 REFGUID guidService, REFIID riid, void** object) { | |
| 987 if (!instance_active_) | |
| 988 return E_FAIL; | |
| 989 | |
| 990 if (guidService == IID_IAccessible || | |
| 991 guidService == IID_IAccessible2 || | |
| 992 guidService == IID_IAccessibleImage || | |
| 993 guidService == IID_IAccessibleText || | |
| 994 guidService == IID_ISimpleDOMDocument || | |
| 995 guidService == IID_ISimpleDOMNode || | |
| 996 guidService == IID_ISimpleDOMText) { | |
| 997 return QueryInterface(riid, object); | |
| 998 } | |
| 999 | |
| 1000 *object = NULL; | |
| 1001 return E_FAIL; | |
| 1002 } | |
| 1003 | |
| 1004 // | |
| 1005 // CComObjectRootEx methods. | |
| 1006 // | |
| 1007 | |
| 1008 HRESULT WINAPI BrowserAccessibility::InternalQueryInterface( | |
| 1009 void* this_ptr, | |
| 1010 const _ATL_INTMAP_ENTRY* entries, | |
| 1011 REFIID iid, | |
| 1012 void** object) { | |
| 1013 if (iid == IID_IAccessibleText) { | |
| 1014 if (role_ != ROLE_SYSTEM_LINK) { | |
| 1015 *object = NULL; | |
| 1016 return E_NOINTERFACE; | |
| 1017 } | |
| 1018 } else if (iid == IID_IAccessibleImage) { | |
| 1019 if (role_ != ROLE_SYSTEM_GRAPHIC) { | |
| 1020 *object = NULL; | |
| 1021 return E_NOINTERFACE; | |
| 1022 } | |
| 1023 } else if (iid == IID_ISimpleDOMDocument) { | |
| 1024 if (role_ != ROLE_SYSTEM_DOCUMENT) { | |
| 1025 *object = NULL; | |
| 1026 return E_NOINTERFACE; | |
| 1027 } | |
| 1028 } | |
| 1029 | |
| 1030 return CComObjectRootBase::InternalQueryInterface( | |
| 1031 this_ptr, entries, iid, object); | |
| 1032 } | |
| 1033 | |
| 1034 // | |
| 1035 // Private methods. | |
| 1036 // | |
| 1037 | |
| 1038 BrowserAccessibility* BrowserAccessibility::GetTargetFromChildID( | |
| 1039 const VARIANT& var_id) { | |
| 1040 if (var_id.vt != VT_I4) | |
| 1041 return NULL; | |
| 1042 | |
| 1043 LONG child_id = var_id.lVal; | |
| 1044 if (child_id == CHILDID_SELF) | |
| 1045 return this; | |
| 1046 | |
| 1047 if (child_id >= 1 && child_id <= static_cast<LONG>(children_.size())) | |
| 1048 return children_[child_id - 1]; | |
| 1049 | |
| 1050 return manager_->GetFromChildID(child_id); | |
| 1051 } | |
| 1052 | |
| 1053 bool BrowserAccessibility::HasAttribute(WebAccessibility::Attribute attribute) { | |
| 1054 return (attributes_.find(attribute) != attributes_.end()); | |
| 1055 } | |
| 1056 | |
| 1057 bool BrowserAccessibility::GetAttribute( | |
| 1058 WebAccessibility::Attribute attribute, string16* value) { | |
| 1059 std::map<int32, string16>::iterator iter = attributes_.find(attribute); | |
| 1060 if (iter != attributes_.end()) { | |
| 1061 *value = iter->second; | |
| 1062 return true; | |
| 1063 } | |
| 1064 | |
| 1065 return false; | |
| 1066 } | |
| 1067 | |
| 1068 HRESULT BrowserAccessibility::GetAttributeAsBstr( | |
| 1069 WebAccessibility::Attribute attribute, BSTR* value_bstr) { | |
| 1070 string16 str; | |
| 1071 | |
| 1072 if (!GetAttribute(attribute, &str)) | |
| 1073 return S_FALSE; | |
| 1074 | |
| 1075 if (str.empty()) | |
| 1076 return S_FALSE; | |
| 1077 | |
| 1078 *value_bstr = SysAllocString(str.c_str()); | |
| 1079 DCHECK(*value_bstr); | |
| 1080 | |
| 1081 return S_OK; | |
| 1082 } | |
| 1083 | |
| 1084 string16 BrowserAccessibility::Escape(string16 str) { | |
| 1085 return UTF8ToUTF16(EscapeNonASCII(UTF16ToUTF8(str))); | |
| 1086 } | |
| 1087 | |
| 1088 void BrowserAccessibility::InitRoleAndState(LONG web_role, | |
| 1089 LONG web_state) { | |
| 1090 state_ = 0; | |
| 1091 ia2_state_ = IA2_STATE_OPAQUE; | |
| 1092 | |
| 1093 if ((web_state >> WebAccessibility::STATE_CHECKED) & 1) | |
| 1094 state_ |= STATE_SYSTEM_CHECKED; | |
| 1095 if ((web_state >> WebAccessibility::STATE_COLLAPSED) & 1) | |
| 1096 state_ |= STATE_SYSTEM_COLLAPSED; | |
| 1097 if ((web_state >> WebAccessibility::STATE_EXPANDED) & 1) | |
| 1098 state_ |= STATE_SYSTEM_EXPANDED; | |
| 1099 if ((web_state >> WebAccessibility::STATE_FOCUSABLE) & 1) | |
| 1100 state_ |= STATE_SYSTEM_FOCUSABLE; | |
| 1101 if ((web_state >> WebAccessibility::STATE_HASPOPUP) & 1) | |
| 1102 state_ |= STATE_SYSTEM_HASPOPUP; | |
| 1103 if ((web_state >> WebAccessibility::STATE_HOTTRACKED) & 1) | |
| 1104 state_ |= STATE_SYSTEM_HOTTRACKED; | |
| 1105 if ((web_state >> WebAccessibility::STATE_INDETERMINATE) & 1) | |
| 1106 state_ |= STATE_SYSTEM_INDETERMINATE; | |
| 1107 if ((web_state >> WebAccessibility::STATE_INVISIBLE) & 1) | |
| 1108 state_ |= STATE_SYSTEM_INVISIBLE; | |
| 1109 if ((web_state >> WebAccessibility::STATE_LINKED) & 1) | |
| 1110 state_ |= STATE_SYSTEM_LINKED; | |
| 1111 if ((web_state >> WebAccessibility::STATE_MULTISELECTABLE) & 1) | |
| 1112 state_ |= STATE_SYSTEM_MULTISELECTABLE; | |
| 1113 // TODO(ctguil): Support STATE_SYSTEM_EXTSELECTABLE/accSelect. | |
| 1114 if ((web_state >> WebAccessibility::STATE_OFFSCREEN) & 1) | |
| 1115 state_ |= STATE_SYSTEM_OFFSCREEN; | |
| 1116 if ((web_state >> WebAccessibility::STATE_PRESSED) & 1) | |
| 1117 state_ |= STATE_SYSTEM_PRESSED; | |
| 1118 if ((web_state >> WebAccessibility::STATE_PROTECTED) & 1) | |
| 1119 state_ |= STATE_SYSTEM_PROTECTED; | |
| 1120 if ((web_state >> WebAccessibility::STATE_SELECTABLE) & 1) | |
| 1121 state_ |= STATE_SYSTEM_SELECTABLE; | |
| 1122 if ((web_state >> WebAccessibility::STATE_SELECTED) & 1) | |
| 1123 state_ |= STATE_SYSTEM_SELECTED; | |
| 1124 if ((web_state >> WebAccessibility::STATE_READONLY) & 1) | |
| 1125 state_ |= STATE_SYSTEM_READONLY; | |
| 1126 if ((web_state >> WebAccessibility::STATE_TRAVERSED) & 1) | |
| 1127 state_ |= STATE_SYSTEM_TRAVERSED; | |
| 1128 if ((web_state >> WebAccessibility::STATE_BUSY) & 1) | |
| 1129 state_ |= STATE_SYSTEM_BUSY; | |
| 1130 if ((web_state >> WebAccessibility::STATE_UNAVAILABLE) & 1) | |
| 1131 state_ |= STATE_SYSTEM_UNAVAILABLE; | |
| 1132 | |
| 1133 role_ = 0; | |
| 1134 ia2_role_ = 0; | |
| 1135 switch (web_role) { | |
| 1136 case WebAccessibility::ROLE_ALERT: | |
| 1137 case WebAccessibility::ROLE_ALERT_DIALOG: | |
| 1138 role_ = ROLE_SYSTEM_ALERT; | |
| 1139 break; | |
| 1140 case WebAccessibility::ROLE_APPLICATION: | |
| 1141 role_ = ROLE_SYSTEM_APPLICATION; | |
| 1142 break; | |
| 1143 case WebAccessibility::ROLE_ARTICLE: | |
| 1144 role_ = ROLE_SYSTEM_GROUPING; | |
| 1145 ia2_role_ = IA2_ROLE_SECTION; | |
| 1146 break; | |
| 1147 case WebAccessibility::ROLE_BUTTON: | |
| 1148 role_ = ROLE_SYSTEM_PUSHBUTTON; | |
| 1149 break; | |
| 1150 case WebAccessibility::ROLE_CELL: | |
| 1151 role_ = ROLE_SYSTEM_CELL; | |
| 1152 break; | |
| 1153 case WebAccessibility::ROLE_CHECKBOX: | |
| 1154 role_ = ROLE_SYSTEM_CHECKBUTTON; | |
| 1155 break; | |
| 1156 case WebAccessibility::ROLE_COLOR_WELL: | |
| 1157 role_ = ROLE_SYSTEM_CLIENT; | |
| 1158 ia2_role_ = IA2_ROLE_COLOR_CHOOSER; | |
| 1159 break; | |
| 1160 case WebAccessibility::ROLE_COLUMN: | |
| 1161 role_ = ROLE_SYSTEM_COLUMN; | |
| 1162 break; | |
| 1163 case WebAccessibility::ROLE_COLUMN_HEADER: | |
| 1164 role_ = ROLE_SYSTEM_COLUMNHEADER; | |
| 1165 break; | |
| 1166 case WebAccessibility::ROLE_COMBO_BOX: | |
| 1167 role_ = ROLE_SYSTEM_COMBOBOX; | |
| 1168 break; | |
| 1169 case WebAccessibility::ROLE_DEFINITION_LIST_DEFINITION: | |
| 1170 GetAttribute(WebAccessibility::ATTR_HTML_TAG, &role_name_); | |
| 1171 ia2_role_ = IA2_ROLE_PARAGRAPH; | |
| 1172 break; | |
| 1173 case WebAccessibility::ROLE_DEFINITION_LIST_TERM: | |
| 1174 role_ = ROLE_SYSTEM_LISTITEM; | |
| 1175 break; | |
| 1176 case WebAccessibility::ROLE_DIALOG: | |
| 1177 role_ = ROLE_SYSTEM_DIALOG; | |
| 1178 break; | |
| 1179 case WebAccessibility::ROLE_DOCUMENT: | |
| 1180 case WebAccessibility::ROLE_WEB_AREA: | |
| 1181 role_ = ROLE_SYSTEM_DOCUMENT; | |
| 1182 state_ |= STATE_SYSTEM_READONLY; | |
| 1183 state_ |= STATE_SYSTEM_FOCUSABLE; | |
| 1184 break; | |
| 1185 case WebAccessibility::ROLE_EDITABLE_TEXT: | |
| 1186 role_ = ROLE_SYSTEM_TEXT; | |
| 1187 ia2_state_ |= IA2_STATE_SINGLE_LINE; | |
| 1188 ia2_state_ |= IA2_STATE_EDITABLE; | |
| 1189 break; | |
| 1190 case WebAccessibility::ROLE_GRID: | |
| 1191 role_ = ROLE_SYSTEM_TABLE; | |
| 1192 break; | |
| 1193 case WebAccessibility::ROLE_GROUP: | |
| 1194 GetAttribute(WebAccessibility::ATTR_HTML_TAG, &role_name_); | |
| 1195 if (role_name_.empty()) | |
| 1196 role_name_ = L"div"; | |
| 1197 ia2_role_ = IA2_ROLE_SECTION; | |
| 1198 break; | |
| 1199 case WebAccessibility::ROLE_HEADING: | |
| 1200 GetAttribute(WebAccessibility::ATTR_HTML_TAG, &role_name_); | |
| 1201 ia2_role_ = IA2_ROLE_HEADING; | |
| 1202 break; | |
| 1203 case WebAccessibility::ROLE_IMAGE: | |
| 1204 role_ = ROLE_SYSTEM_GRAPHIC; | |
| 1205 break; | |
| 1206 case WebAccessibility::ROLE_IMAGE_MAP: | |
| 1207 GetAttribute(WebAccessibility::ATTR_HTML_TAG, &role_name_); | |
| 1208 ia2_role_ = IA2_ROLE_IMAGE_MAP; | |
| 1209 break; | |
| 1210 case WebAccessibility::ROLE_IMAGE_MAP_LINK: | |
| 1211 role_ = ROLE_SYSTEM_LINK; | |
| 1212 state_ |= STATE_SYSTEM_LINKED; | |
| 1213 break; | |
| 1214 case WebAccessibility::ROLE_LANDMARK_APPLICATION: | |
| 1215 case WebAccessibility::ROLE_LANDMARK_BANNER: | |
| 1216 case WebAccessibility::ROLE_LANDMARK_COMPLEMENTARY: | |
| 1217 case WebAccessibility::ROLE_LANDMARK_CONTENTINFO: | |
| 1218 case WebAccessibility::ROLE_LANDMARK_MAIN: | |
| 1219 case WebAccessibility::ROLE_LANDMARK_NAVIGATION: | |
| 1220 case WebAccessibility::ROLE_LANDMARK_SEARCH: | |
| 1221 role_ = ROLE_SYSTEM_GROUPING; | |
| 1222 ia2_role_ = IA2_ROLE_SECTION; | |
| 1223 break; | |
| 1224 case WebAccessibility::ROLE_LINK: | |
| 1225 case WebAccessibility::ROLE_WEBCORE_LINK: | |
| 1226 role_ = ROLE_SYSTEM_LINK; | |
| 1227 state_ |= STATE_SYSTEM_LINKED; | |
| 1228 break; | |
| 1229 case WebAccessibility::ROLE_LIST: | |
| 1230 role_ = ROLE_SYSTEM_LIST; | |
| 1231 break; | |
| 1232 case WebAccessibility::ROLE_LISTBOX: | |
| 1233 role_ = ROLE_SYSTEM_LIST; | |
| 1234 break; | |
| 1235 case WebAccessibility::ROLE_LISTBOX_OPTION: | |
| 1236 case WebAccessibility::ROLE_LIST_ITEM: | |
| 1237 case WebAccessibility::ROLE_LIST_MARKER: | |
| 1238 role_ = ROLE_SYSTEM_LISTITEM; | |
| 1239 break; | |
| 1240 case WebAccessibility::ROLE_MENU: | |
| 1241 case WebAccessibility::ROLE_MENU_BUTTON: | |
| 1242 role_ = ROLE_SYSTEM_MENUPOPUP; | |
| 1243 break; | |
| 1244 case WebAccessibility::ROLE_MENU_BAR: | |
| 1245 role_ = ROLE_SYSTEM_MENUBAR; | |
| 1246 break; | |
| 1247 case WebAccessibility::ROLE_MENU_ITEM: | |
| 1248 case WebAccessibility::ROLE_MENU_LIST_OPTION: | |
| 1249 role_ = ROLE_SYSTEM_MENUITEM; | |
| 1250 break; | |
| 1251 case WebAccessibility::ROLE_MENU_LIST_POPUP: | |
| 1252 role_ = ROLE_SYSTEM_MENUPOPUP; | |
| 1253 break; | |
| 1254 case WebAccessibility::ROLE_NOTE: | |
| 1255 role_ = ROLE_SYSTEM_GROUPING; | |
| 1256 ia2_role_ = IA2_ROLE_NOTE; | |
| 1257 break; | |
| 1258 case WebAccessibility::ROLE_OUTLINE: | |
| 1259 role_ = ROLE_SYSTEM_OUTLINE; | |
| 1260 break; | |
| 1261 case WebAccessibility::ROLE_POPUP_BUTTON: | |
| 1262 role_ = ROLE_SYSTEM_COMBOBOX; | |
| 1263 break; | |
| 1264 case WebAccessibility::ROLE_PROGRESS_INDICATOR: | |
| 1265 role_ = ROLE_SYSTEM_PROGRESSBAR; | |
| 1266 break; | |
| 1267 case WebAccessibility::ROLE_RADIO_BUTTON: | |
| 1268 role_ = ROLE_SYSTEM_RADIOBUTTON; | |
| 1269 break; | |
| 1270 case WebAccessibility::ROLE_RADIO_GROUP: | |
| 1271 role_ = ROLE_SYSTEM_GROUPING; | |
| 1272 ia2_role_ = IA2_ROLE_SECTION; | |
| 1273 break; | |
| 1274 case WebAccessibility::ROLE_REGION: | |
| 1275 role_ = ROLE_SYSTEM_GROUPING; | |
| 1276 ia2_role_ = IA2_ROLE_SECTION; | |
| 1277 break; | |
| 1278 case WebAccessibility::ROLE_ROW: | |
| 1279 role_ = ROLE_SYSTEM_ROW; | |
| 1280 break; | |
| 1281 case WebAccessibility::ROLE_ROW_HEADER: | |
| 1282 role_ = ROLE_SYSTEM_ROWHEADER; | |
| 1283 break; | |
| 1284 case WebAccessibility::ROLE_RULER: | |
| 1285 role_ = ROLE_SYSTEM_CLIENT; | |
| 1286 ia2_role_ = IA2_ROLE_RULER; | |
| 1287 break; | |
| 1288 case WebAccessibility::ROLE_SCROLLAREA: | |
| 1289 role_ = ROLE_SYSTEM_CLIENT; | |
| 1290 ia2_role_ = IA2_ROLE_SCROLL_PANE; | |
| 1291 break; | |
| 1292 case WebAccessibility::ROLE_SCROLLBAR: | |
| 1293 role_ = ROLE_SYSTEM_SCROLLBAR; | |
| 1294 break; | |
| 1295 case WebAccessibility::ROLE_SLIDER: | |
| 1296 role_ = ROLE_SYSTEM_SLIDER; | |
| 1297 break; | |
| 1298 case WebAccessibility::ROLE_SPLIT_GROUP: | |
| 1299 role_ = ROLE_SYSTEM_CLIENT; | |
| 1300 ia2_role_ = IA2_ROLE_SPLIT_PANE; | |
| 1301 break; | |
| 1302 case WebAccessibility::ROLE_ANNOTATION: | |
| 1303 case WebAccessibility::ROLE_STATIC_TEXT: | |
| 1304 role_ = ROLE_SYSTEM_TEXT; | |
| 1305 break; | |
| 1306 case WebAccessibility::ROLE_STATUS: | |
| 1307 role_ = ROLE_SYSTEM_STATUSBAR; | |
| 1308 break; | |
| 1309 case WebAccessibility::ROLE_TAB: | |
| 1310 role_ = ROLE_SYSTEM_PAGETAB; | |
| 1311 break; | |
| 1312 case WebAccessibility::ROLE_TABLE: | |
| 1313 role_ = ROLE_SYSTEM_TABLE; | |
| 1314 break; | |
| 1315 case WebAccessibility::ROLE_TABLE_HEADER_CONTAINER: | |
| 1316 role_ = ROLE_SYSTEM_GROUPING; | |
| 1317 ia2_role_ = IA2_ROLE_SECTION; | |
| 1318 break; | |
| 1319 case WebAccessibility::ROLE_TAB_GROUP: | |
| 1320 case WebAccessibility::ROLE_TAB_LIST: | |
| 1321 case WebAccessibility::ROLE_TAB_PANEL: | |
| 1322 role_ = ROLE_SYSTEM_PAGETABLIST; | |
| 1323 break; | |
| 1324 case WebAccessibility::ROLE_TEXTAREA: | |
| 1325 role_ = ROLE_SYSTEM_TEXT; | |
| 1326 ia2_state_ |= IA2_STATE_MULTI_LINE; | |
| 1327 ia2_state_ |= IA2_STATE_EDITABLE; | |
| 1328 break; | |
| 1329 case WebAccessibility::ROLE_TEXT_FIELD: | |
| 1330 role_ = ROLE_SYSTEM_TEXT; | |
| 1331 ia2_state_ |= IA2_STATE_SINGLE_LINE; | |
| 1332 ia2_state_ |= IA2_STATE_EDITABLE; | |
| 1333 break; | |
| 1334 case WebAccessibility::ROLE_TOOLBAR: | |
| 1335 role_ = ROLE_SYSTEM_TOOLBAR; | |
| 1336 break; | |
| 1337 case WebAccessibility::ROLE_TOOLTIP: | |
| 1338 role_ = ROLE_SYSTEM_TOOLTIP; | |
| 1339 break; | |
| 1340 case WebAccessibility::ROLE_TREE: | |
| 1341 role_ = ROLE_SYSTEM_OUTLINE; | |
| 1342 break; | |
| 1343 case WebAccessibility::ROLE_TREE_GRID: | |
| 1344 role_ = ROLE_SYSTEM_OUTLINE; | |
| 1345 break; | |
| 1346 case WebAccessibility::ROLE_TREE_ITEM: | |
| 1347 role_ = ROLE_SYSTEM_OUTLINEITEM; | |
| 1348 break; | |
| 1349 case WebAccessibility::ROLE_WINDOW: | |
| 1350 role_ = ROLE_SYSTEM_WINDOW; | |
| 1351 break; | |
| 1352 | |
| 1353 // TODO(dmazzoni): figure out the proper MSAA role for all of these. | |
| 1354 case WebAccessibility::ROLE_BROWSER: | |
| 1355 case WebAccessibility::ROLE_BUSY_INDICATOR: | |
| 1356 case WebAccessibility::ROLE_DIRECTORY: | |
| 1357 case WebAccessibility::ROLE_DISCLOSURE_TRIANGLE: | |
| 1358 case WebAccessibility::ROLE_DRAWER: | |
| 1359 case WebAccessibility::ROLE_GROW_AREA: | |
| 1360 case WebAccessibility::ROLE_HELP_TAG: | |
| 1361 case WebAccessibility::ROLE_IGNORED: | |
| 1362 case WebAccessibility::ROLE_INCREMENTOR: | |
| 1363 case WebAccessibility::ROLE_LOG: | |
| 1364 case WebAccessibility::ROLE_MARQUEE: | |
| 1365 case WebAccessibility::ROLE_MATH: | |
| 1366 case WebAccessibility::ROLE_MATTE: | |
| 1367 case WebAccessibility::ROLE_RULER_MARKER: | |
| 1368 case WebAccessibility::ROLE_SHEET: | |
| 1369 case WebAccessibility::ROLE_SLIDER_THUMB: | |
| 1370 case WebAccessibility::ROLE_SPLITTER: | |
| 1371 case WebAccessibility::ROLE_SYSTEM_WIDE: | |
| 1372 case WebAccessibility::ROLE_TIMER: | |
| 1373 case WebAccessibility::ROLE_VALUE_INDICATOR: | |
| 1374 default: | |
| 1375 role_ = ROLE_SYSTEM_CLIENT; | |
| 1376 break; | |
| 1377 } | |
| 1378 | |
| 1379 // The role should always be set. | |
| 1380 DCHECK(!role_name_.empty() || role_); | |
| 1381 | |
| 1382 // If we didn't explicitly set the IAccessible2 role, make it the same | |
| 1383 // as the MSAA role. | |
| 1384 if (!ia2_role_) | |
| 1385 ia2_role_ = role_; | |
| 1386 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 3591003:
Make BrowserAccessibilityManager cross platform. Step 1.... (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/