accessible/xpcom/xpcAccessible.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "LocalAccessible-inl.h"
   8 #include "mozilla/a11y/DocAccessibleParent.h"
   9 #include "nsAccessibilityService.h"
  10 #include "AccAttributes.h"
  11 #include "nsAccUtils.h"
  12 #include "nsComponentManagerUtils.h"
  13 #include "nsIAccessibleRelation.h"
  14 #include "nsIAccessibleRole.h"
  15 #include "nsAccessibleRelation.h"
  16 #include "Relation.h"
  17 #include "Role.h"
  18 #include "RootAccessible.h"
  19 #include "xpcAccessibleDocument.h"
  20
  21 #include "nsIMutableArray.h"
  22 #include "nsPersistentProperties.h"
  23
  24 #ifdef MOZ_WIDGET_COCOA
  25 #  include "xpcAccessibleMacInterface.h"
  26 #endif
  27
  28 using namespace mozilla::a11y;
  29
  30 NS_IMETHODIMP
  31 xpcAccessible::GetParent(nsIAccessible** aParent) {
  32   NS_ENSURE_ARG_POINTER(aParent);
  33   *aParent = nullptr;
  34   if (!IntlGeneric()) return NS_ERROR_FAILURE;
  35
  36   Accessible* parent = IntlGeneric()->Parent();
  37   NS_IF_ADDREF(*aParent = ToXPC(parent));
  38   return NS_OK;
  39 }
  40
  41 NS_IMETHODIMP
  42 xpcAccessible::GetNextSibling(nsIAccessible** aNextSibling) {
  43   NS_ENSURE_ARG_POINTER(aNextSibling);
  44   *aNextSibling = nullptr;
  45   if (!IntlGeneric()) return NS_ERROR_FAILURE;
  46
  47   NS_IF_ADDREF(*aNextSibling = ToXPC(IntlGeneric()->NextSibling()));
  48
  49   return NS_OK;
  50 }
  51
  52 NS_IMETHODIMP
  53 xpcAccessible::GetPreviousSibling(nsIAccessible** aPreviousSibling) {
  54   NS_ENSURE_ARG_POINTER(aPreviousSibling);
  55   *aPreviousSibling = nullptr;
  56   if (!IntlGeneric()) return NS_ERROR_FAILURE;
  57
  58   NS_IF_ADDREF(*aPreviousSibling = ToXPC(IntlGeneric()->PrevSibling()));
  59
  60   return NS_OK;
  61 }
  62
  63 NS_IMETHODIMP
  64 xpcAccessible::GetFirstChild(nsIAccessible** aFirstChild) {
  65   NS_ENSURE_ARG_POINTER(aFirstChild);
  66   *aFirstChild = nullptr;
  67
  68   if (!IntlGeneric()) return NS_ERROR_FAILURE;
  69
  70   NS_IF_ADDREF(*aFirstChild = ToXPC(IntlGeneric()->FirstChild()));
  71   return NS_OK;
  72 }
  73
  74 NS_IMETHODIMP
  75 xpcAccessible::GetLastChild(nsIAccessible** aLastChild) {
  76   NS_ENSURE_ARG_POINTER(aLastChild);
  77   *aLastChild = nullptr;
  78
  79   if (!IntlGeneric()) return NS_ERROR_FAILURE;
  80
  81   NS_IF_ADDREF(*aLastChild = ToXPC(IntlGeneric()->LastChild()));
  82   return NS_OK;
  83 }
  84
  85 NS_IMETHODIMP
  86 xpcAccessible::GetChildCount(int32_t* aChildCount) {
  87   NS_ENSURE_ARG_POINTER(aChildCount);
  88
  89   if (!IntlGeneric()) return NS_ERROR_FAILURE;
  90
  91   *aChildCount = IntlGeneric()->ChildCount();
  92   return NS_OK;
  93 }
  94
  95 NS_IMETHODIMP
  96 xpcAccessible::GetChildAt(int32_t aChildIndex, nsIAccessible** aChild) {
  97   NS_ENSURE_ARG_POINTER(aChild);
  98   *aChild = nullptr;
  99
 100   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 101
 102   // If child index is negative, then return last child.
 103   // XXX: do we really need this?
 104   if (aChildIndex < 0) aChildIndex = IntlGeneric()->ChildCount() - 1;
 105
 106   Accessible* child = IntlGeneric()->ChildAt(aChildIndex);
 107   if (!child) return NS_ERROR_INVALID_ARG;
 108
 109   NS_ADDREF(*aChild = ToXPC(child));
 110   return NS_OK;
 111 }
 112
 113 NS_IMETHODIMP
 114 xpcAccessible::GetChildren(nsIArray** aChildren) {
 115   NS_ENSURE_ARG_POINTER(aChildren);
 116   *aChildren = nullptr;
 117
 118   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 119
 120   nsresult rv = NS_OK;
 121   nsCOMPtr<nsIMutableArray> children =
 122       do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
 123   NS_ENSURE_SUCCESS(rv, rv);
 124
 125   uint32_t childCount = IntlGeneric()->ChildCount();
 126   for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) {
 127     Accessible* child = IntlGeneric()->ChildAt(childIdx);
 128     children->AppendElement(static_cast<nsIAccessible*>(ToXPC(child)));
 129   }
 130
 131   children.forget(aChildren);
 132   return NS_OK;
 133 }
 134
 135 NS_IMETHODIMP
 136 xpcAccessible::GetIndexInParent(int32_t* aIndexInParent) {
 137   NS_ENSURE_ARG_POINTER(aIndexInParent);
 138   *aIndexInParent = -1;
 139   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 140
 141   *aIndexInParent = IntlGeneric()->IndexInParent();
 142
 143   return *aIndexInParent != -1 ? NS_OK : NS_ERROR_FAILURE;
 144 }
 145
 146 NS_IMETHODIMP
 147 xpcAccessible::GetUniqueID(int64_t* aUniqueID) {
 148   NS_ENSURE_ARG_POINTER(aUniqueID);
 149
 150   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 151
 152   if (IntlGeneric()->IsLocal()) {
 153     *aUniqueID = reinterpret_cast<uintptr_t>(Intl()->UniqueID());
 154   } else if (IntlGeneric()->IsRemote()) {
 155     *aUniqueID = IntlGeneric()->AsRemote()->ID();
 156   }
 157
 158   return NS_OK;
 159 }
 160
 161 NS_IMETHODIMP
 162 xpcAccessible::GetDOMNode(nsINode** aDOMNode) {
 163   NS_ENSURE_ARG_POINTER(aDOMNode);
 164   *aDOMNode = nullptr;
 165
 166   if (!Intl()) return NS_ERROR_FAILURE;
 167
 168   nsCOMPtr<nsINode> node = Intl()->GetNode();
 169   node.forget(aDOMNode);
 170
 171   return NS_OK;
 172 }
 173
 174 NS_IMETHODIMP
 175 xpcAccessible::GetId(nsAString& aID) {
 176   if (!IntlGeneric()) {
 177     return NS_ERROR_FAILURE;
 178   }
 179
 180   RemoteAccessible* proxy = IntlGeneric()->AsRemote();
 181   if (!proxy) {
 182     return NS_ERROR_FAILURE;
 183   }
 184
 185   nsString id;
 186   proxy->DOMNodeID(id);
 187   aID.Assign(id);
 188
 189   return NS_OK;
 190 }
 191
 192 NS_IMETHODIMP
 193 xpcAccessible::GetDocument(nsIAccessibleDocument** aDocument) {
 194   NS_ENSURE_ARG_POINTER(aDocument);
 195   *aDocument = nullptr;
 196
 197   if (!Intl()) return NS_ERROR_FAILURE;
 198
 199   NS_IF_ADDREF(*aDocument = ToXPCDocument(Intl()->Document()));
 200   return NS_OK;
 201 }
 202
 203 NS_IMETHODIMP
 204 xpcAccessible::GetRootDocument(nsIAccessibleDocument** aRootDocument) {
 205   NS_ENSURE_ARG_POINTER(aRootDocument);
 206   *aRootDocument = nullptr;
 207
 208   if (!Intl()) return NS_ERROR_FAILURE;
 209
 210   NS_IF_ADDREF(*aRootDocument = ToXPCDocument(Intl()->RootAccessible()));
 211   return NS_OK;
 212 }
 213
 214 NS_IMETHODIMP
 215 xpcAccessible::GetRole(uint32_t* aRole) {
 216   NS_ENSURE_ARG_POINTER(aRole);
 217   *aRole = nsIAccessibleRole::ROLE_NOTHING;
 218
 219   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 220
 221   *aRole = IntlGeneric()->Role();
 222   return NS_OK;
 223 }
 224
 225 NS_IMETHODIMP
 226 xpcAccessible::GetState(uint32_t* aState, uint32_t* aExtraState) {
 227   NS_ENSURE_ARG_POINTER(aState);
 228
 229   Accessible* acc = IntlGeneric();
 230   if (acc) {
 231     nsAccUtils::To32States(acc->State(), aState, aExtraState);
 232   } else {
 233     nsAccUtils::To32States(states::DEFUNCT, aState, aExtraState);
 234   }
 235
 236   return NS_OK;
 237 }
 238
 239 NS_IMETHODIMP
 240 xpcAccessible::GetName(nsAString& aName) {
 241   aName.Truncate();
 242
 243   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 244
 245   nsAutoString name;
 246   IntlGeneric()->Name(name);
 247
 248   aName.Assign(name);
 249
 250   return NS_OK;
 251 }
 252
 253 NS_IMETHODIMP
 254 xpcAccessible::GetDescription(nsAString& aDescription) {
 255   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 256
 257   nsAutoString desc;
 258   IntlGeneric()->Description(desc);
 259
 260   aDescription.Assign(desc);
 261
 262   return NS_OK;
 263 }
 264
 265 NS_IMETHODIMP
 266 xpcAccessible::GetLanguage(nsAString& aLanguage) {
 267   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 268
 269   nsAutoString lang;
 270   IntlGeneric()->Language(lang);
 271
 272   aLanguage.Assign(lang);
 273   return NS_OK;
 274 }
 275
 276 NS_IMETHODIMP
 277 xpcAccessible::GetValue(nsAString& aValue) {
 278   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 279
 280   nsAutoString value;
 281   IntlGeneric()->Value(value);
 282
 283   aValue.Assign(value);
 284
 285   return NS_OK;
 286 }
 287
 288 NS_IMETHODIMP
 289 xpcAccessible::GetAccessKey(nsAString& aAccessKey) {
 290   aAccessKey.Truncate();
 291
 292   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 293
 294   IntlGeneric()->AccessKey().ToString(aAccessKey);
 295   return NS_OK;
 296 }
 297
 298 NS_IMETHODIMP
 299 xpcAccessible::GetKeyboardShortcut(nsAString& aKeyBinding) {
 300   aKeyBinding.Truncate();
 301   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 302
 303   if (IntlGeneric()->IsRemote()) {
 304     return NS_ERROR_NOT_IMPLEMENTED;
 305   }
 306   Intl()->KeyboardShortcut().ToString(aKeyBinding);
 307   return NS_OK;
 308 }
 309
 310 NS_IMETHODIMP
 311 xpcAccessible::GetAttributes(nsIPersistentProperties** aAttributes) {
 312   NS_ENSURE_ARG_POINTER(aAttributes);
 313   *aAttributes = nullptr;
 314
 315   if (!IntlGeneric()) {
 316     return NS_ERROR_FAILURE;
 317   }
 318
 319   RefPtr<nsPersistentProperties> props = new nsPersistentProperties();
 320
 321   RefPtr<AccAttributes> attributes = IntlGeneric()->Attributes();
 322
 323   nsAutoString unused;
 324   for (auto iter : *attributes) {
 325     nsAutoString name;
 326     iter.NameAsString(name);
 327
 328     nsAutoString value;
 329     iter.ValueAsString(value);
 330
 331     props->SetStringProperty(NS_ConvertUTF16toUTF8(name), value, unused);
 332   }
 333
 334   props.forget(aAttributes);
 335   return NS_OK;
 336 }
 337
 338 NS_IMETHODIMP
 339 xpcAccessible::GetCache(nsIPersistentProperties** aCachedFields) {
 340   NS_ENSURE_ARG_POINTER(aCachedFields);
 341   *aCachedFields = nullptr;
 342
 343   if (!IntlGeneric()) {
 344     return NS_ERROR_FAILURE;
 345   }
 346
 347   RefPtr<nsPersistentProperties> props = new nsPersistentProperties();
 348   if (RemoteAccessible* remoteAcc = IntlGeneric()->AsRemote()) {
 349     if (RefPtr<AccAttributes> cachedFields = remoteAcc->mCachedFields) {
 350       nsAutoString unused;
 351       for (auto iter : *cachedFields) {
 352         nsAutoString name;
 353         iter.NameAsString(name);
 354
 355         nsAutoString value;
 356         iter.ValueAsString(value);
 357
 358         props->SetStringProperty(NS_ConvertUTF16toUTF8(name), value, unused);
 359       }
 360     }
 361   }
 362
 363   props.forget(aCachedFields);
 364   return NS_OK;
 365 }
 366
 367 NS_IMETHODIMP
 368 xpcAccessible::GetNativeInterface(nsISupports** aNativeInterface) {
 369 #ifdef MOZ_WIDGET_COCOA
 370   NS_ENSURE_ARG_POINTER(aNativeInterface);
 371
 372   // We don't cache or store this instance anywhere so each get returns a
 373   // different instance. So `acc.nativeInterface != acc.nativeInterface`. This
 374   // just seems simpler and more robust for now.
 375   nsCOMPtr<nsISupports> macIface = static_cast<nsIAccessibleMacInterface*>(
 376       new xpcAccessibleMacInterface(IntlGeneric()));
 377   macIface.swap(*aNativeInterface);
 378
 379   return NS_OK;
 380 #else
 381   return NS_ERROR_NOT_IMPLEMENTED;
 382 #endif
 383 }
 384
 385 NS_IMETHODIMP
 386 xpcAccessible::GetBounds(int32_t* aX, int32_t* aY, int32_t* aWidth,
 387                          int32_t* aHeight) {
 388   NS_ENSURE_ARG_POINTER(aX);
 389   *aX = 0;
 390   NS_ENSURE_ARG_POINTER(aY);
 391   *aY = 0;
 392   NS_ENSURE_ARG_POINTER(aWidth);
 393   *aWidth = 0;
 394   NS_ENSURE_ARG_POINTER(aHeight);
 395   *aHeight = 0;
 396
 397   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 398
 399   LayoutDeviceIntRect rect = IntlGeneric()->Bounds();
 400   rect.GetRect(aX, aY, aWidth, aHeight);
 401   return NS_OK;
 402 }
 403
 404 NS_IMETHODIMP
 405 xpcAccessible::GetBoundsInCSSPixels(int32_t* aX, int32_t* aY, int32_t* aWidth,
 406                                     int32_t* aHeight) {
 407   NS_ENSURE_ARG_POINTER(aX);
 408   *aX = 0;
 409   NS_ENSURE_ARG_POINTER(aY);
 410   *aY = 0;
 411   NS_ENSURE_ARG_POINTER(aWidth);
 412   *aWidth = 0;
 413   NS_ENSURE_ARG_POINTER(aHeight);
 414   *aHeight = 0;
 415
 416   if (!IntlGeneric()) {
 417     return NS_ERROR_FAILURE;
 418   }
 419
 420   nsIntRect rect = IntlGeneric()->BoundsInCSSPixels();
 421   rect.GetRect(aX, aY, aWidth, aHeight);
 422   return NS_OK;
 423 }
 424
 425 NS_IMETHODIMP
 426 xpcAccessible::GroupPosition(int32_t* aGroupLevel,
 427                              int32_t* aSimilarItemsInGroup,
 428                              int32_t* aPositionInGroup) {
 429   NS_ENSURE_ARG_POINTER(aGroupLevel);
 430   NS_ENSURE_ARG_POINTER(aSimilarItemsInGroup);
 431   NS_ENSURE_ARG_POINTER(aPositionInGroup);
 432
 433   GroupPos groupPos = IntlGeneric()->GroupPosition();
 434
 435   *aGroupLevel = groupPos.level;
 436   *aSimilarItemsInGroup = groupPos.setSize;
 437   *aPositionInGroup = groupPos.posInSet;
 438
 439   return NS_OK;
 440 }
 441
 442 NS_IMETHODIMP
 443 xpcAccessible::GetRelationByType(uint32_t aType,
 444                                  nsIAccessibleRelation** aRelation) {
 445   NS_ENSURE_ARG_POINTER(aRelation);
 446   *aRelation = nullptr;
 447
 448   NS_ENSURE_ARG(aType <= static_cast<uint32_t>(RelationType::LAST));
 449
 450   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 451
 452   Relation rel =
 453       IntlGeneric()->RelationByType(static_cast<RelationType>(aType));
 454   NS_ADDREF(*aRelation = new nsAccessibleRelation(aType, &rel));
 455   return NS_OK;
 456 }
 457
 458 NS_IMETHODIMP
 459 xpcAccessible::GetRelations(nsIArray** aRelations) {
 460   NS_ENSURE_ARG_POINTER(aRelations);
 461   *aRelations = nullptr;
 462
 463   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 464
 465   nsCOMPtr<nsIMutableArray> relations = do_CreateInstance(NS_ARRAY_CONTRACTID);
 466   NS_ENSURE_TRUE(relations, NS_ERROR_OUT_OF_MEMORY);
 467
 468   static const uint32_t relationTypes[] = {
 469       nsIAccessibleRelation::RELATION_LABELLED_BY,
 470       nsIAccessibleRelation::RELATION_LABEL_FOR,
 471       nsIAccessibleRelation::RELATION_DESCRIBED_BY,
 472       nsIAccessibleRelation::RELATION_DESCRIPTION_FOR,
 473       nsIAccessibleRelation::RELATION_NODE_CHILD_OF,
 474       nsIAccessibleRelation::RELATION_NODE_PARENT_OF,
 475       nsIAccessibleRelation::RELATION_CONTROLLED_BY,
 476       nsIAccessibleRelation::RELATION_CONTROLLER_FOR,
 477       nsIAccessibleRelation::RELATION_FLOWS_TO,
 478       nsIAccessibleRelation::RELATION_FLOWS_FROM,
 479       nsIAccessibleRelation::RELATION_MEMBER_OF,
 480       nsIAccessibleRelation::RELATION_SUBWINDOW_OF,
 481       nsIAccessibleRelation::RELATION_EMBEDS,
 482       nsIAccessibleRelation::RELATION_EMBEDDED_BY,
 483       nsIAccessibleRelation::RELATION_POPUP_FOR,
 484       nsIAccessibleRelation::RELATION_PARENT_WINDOW_OF,
 485       nsIAccessibleRelation::RELATION_DEFAULT_BUTTON,
 486       nsIAccessibleRelation::RELATION_CONTAINING_DOCUMENT,
 487       nsIAccessibleRelation::RELATION_CONTAINING_TAB_PANE,
 488       nsIAccessibleRelation::RELATION_CONTAINING_APPLICATION};
 489
 490   for (uint32_t idx = 0; idx < ArrayLength(relationTypes); idx++) {
 491     nsCOMPtr<nsIAccessibleRelation> relation;
 492     nsresult rv =
 493         GetRelationByType(relationTypes[idx], getter_AddRefs(relation));
 494
 495     if (NS_SUCCEEDED(rv) && relation) {
 496       uint32_t targets = 0;
 497       relation->GetTargetsCount(&targets);
 498       if (targets) relations->AppendElement(relation);
 499     }
 500   }
 501
 502   NS_ADDREF(*aRelations = relations);
 503   return NS_OK;
 504 }
 505
 506 NS_IMETHODIMP
 507 xpcAccessible::GetFocusedChild(nsIAccessible** aChild) {
 508   NS_ENSURE_ARG_POINTER(aChild);
 509   *aChild = nullptr;
 510
 511   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 512
 513   NS_IF_ADDREF(*aChild = ToXPC(IntlGeneric()->FocusedChild()));
 514
 515   return NS_OK;
 516 }
 517
 518 NS_IMETHODIMP
 519 xpcAccessible::GetChildAtPoint(int32_t aX, int32_t aY,
 520                                nsIAccessible** aAccessible) {
 521   NS_ENSURE_ARG_POINTER(aAccessible);
 522   *aAccessible = nullptr;
 523
 524   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 525
 526   NS_IF_ADDREF(*aAccessible = ToXPC(IntlGeneric()->ChildAtPoint(
 527                    aX, aY, Accessible::EWhichChildAtPoint::DirectChild)));
 528
 529   return NS_OK;
 530 }
 531
 532 NS_IMETHODIMP
 533 xpcAccessible::GetDeepestChildAtPoint(int32_t aX, int32_t aY,
 534                                       nsIAccessible** aAccessible) {
 535   NS_ENSURE_ARG_POINTER(aAccessible);
 536   *aAccessible = nullptr;
 537
 538   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 539
 540   NS_IF_ADDREF(*aAccessible = ToXPC(IntlGeneric()->ChildAtPoint(
 541                    aX, aY, Accessible::EWhichChildAtPoint::DeepestChild)));
 542
 543   return NS_OK;
 544 }
 545
 546 NS_IMETHODIMP
 547 xpcAccessible::GetDeepestChildAtPointInProcess(int32_t aX, int32_t aY,
 548                                                nsIAccessible** aAccessible) {
 549   NS_ENSURE_ARG_POINTER(aAccessible);
 550   *aAccessible = nullptr;
 551
 552   Accessible* generic = IntlGeneric();
 553   if (!generic || generic->IsRemote()) {
 554     return NS_ERROR_FAILURE;
 555   }
 556
 557   NS_IF_ADDREF(*aAccessible = ToXPC(Intl()->LocalChildAtPoint(
 558                    aX, aY, Accessible::EWhichChildAtPoint::DeepestChild)));
 559   return NS_OK;
 560 }
 561
 562 NS_IMETHODIMP
 563 xpcAccessible::SetSelected(bool aSelect) {
 564   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 565
 566   IntlGeneric()->SetSelected(aSelect);
 567
 568   return NS_OK;
 569 }
 570
 571 NS_IMETHODIMP
 572 xpcAccessible::TakeSelection() {
 573   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 574
 575   IntlGeneric()->TakeSelection();
 576
 577   return NS_OK;
 578 }
 579
 580 NS_IMETHODIMP
 581 xpcAccessible::TakeFocus() {
 582   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 583
 584   IntlGeneric()->TakeFocus();
 585   return NS_OK;
 586 }
 587
 588 NS_IMETHODIMP
 589 xpcAccessible::GetActionCount(uint8_t* aActionCount) {
 590   NS_ENSURE_ARG_POINTER(aActionCount);
 591   *aActionCount = 0;
 592   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 593
 594   *aActionCount = IntlGeneric()->ActionCount();
 595
 596   return NS_OK;
 597 }
 598
 599 NS_IMETHODIMP
 600 xpcAccessible::GetActionName(uint8_t aIndex, nsAString& aName) {
 601   aName.Truncate();
 602
 603   if (!IntlGeneric()) {
 604     return NS_ERROR_FAILURE;
 605   }
 606
 607   if (aIndex >= IntlGeneric()->ActionCount()) {
 608     return NS_ERROR_INVALID_ARG;
 609   }
 610
 611   nsAutoString name;
 612   IntlGeneric()->ActionNameAt(aIndex, name);
 613
 614   aName.Assign(name);
 615
 616   return NS_OK;
 617 }
 618
 619 NS_IMETHODIMP
 620 xpcAccessible::GetActionDescription(uint8_t aIndex, nsAString& aDescription) {
 621   aDescription.Truncate();
 622
 623   if (!IntlGeneric()) {
 624     return NS_ERROR_FAILURE;
 625   }
 626
 627   if (aIndex >= IntlGeneric()->ActionCount()) {
 628     return NS_ERROR_INVALID_ARG;
 629   }
 630
 631   nsAutoString description;
 632   IntlGeneric()->ActionDescriptionAt(aIndex, description);
 633
 634   aDescription.Assign(description);
 635
 636   return NS_OK;
 637 }
 638
 639 NS_IMETHODIMP
 640 xpcAccessible::DoAction(uint8_t aIndex) {
 641   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 642
 643   return IntlGeneric()->DoAction(aIndex) ? NS_OK : NS_ERROR_INVALID_ARG;
 644 }
 645
 646 NS_IMETHODIMP
 647 xpcAccessible::ScrollTo(uint32_t aHow) {
 648   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 649
 650   IntlGeneric()->ScrollTo(aHow);
 651   return NS_OK;
 652 }
 653
 654 NS_IMETHODIMP
 655 xpcAccessible::ScrollToPoint(uint32_t aCoordinateType, int32_t aX, int32_t aY) {
 656   if (!IntlGeneric()) return NS_ERROR_FAILURE;
 657
 658   if (RemoteAccessible* proxy = IntlGeneric()->AsRemote()) {
 659 #if defined(XP_WIN)
 660     return NS_ERROR_NOT_IMPLEMENTED;
 661 #else
 662     proxy->ScrollToPoint(aCoordinateType, aX, aY);
 663 #endif
 664   } else {
 665     Intl()->ScrollToPoint(aCoordinateType, aX, aY);
 666   }
 667
 668   return NS_OK;
 669 }
 670
 671 NS_IMETHODIMP
 672 xpcAccessible::Announce(const nsAString& aAnnouncement, uint16_t aPriority) {
 673   if (RemoteAccessible* proxy = IntlGeneric()->AsRemote()) {
 674 #if defined(XP_WIN)
 675     return NS_ERROR_NOT_IMPLEMENTED;
 676 #else
 677     nsString announcement(aAnnouncement);
 678     proxy->Announce(announcement, aPriority);
 679 #endif
 680   } else {
 681     Intl()->Announce(aAnnouncement, aPriority);
 682   }
 683
 684   return NS_OK;
 685 }
 686
 687 NS_IMETHODIMP
 688 xpcAccessible::GetComputedARIARole(nsAString& aRole) {
 689   if (!IntlGeneric()) {
 690     return NS_ERROR_FAILURE;
 691   }
 692
 693   nsStaticAtom* ariaRole = IntlGeneric()->ComputedARIARole();
 694   if (ariaRole) {
 695     ariaRole->ToString(aRole);
 696   }
 697
 698   return NS_OK;
 699 }