accessible/mac/mozAccessible.mm

   1 /* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #import "mozAccessible.h"
   7
   8 #import "MacUtils.h"
   9 #import "mozView.h"
  10
  11 #include "Accessible-inl.h"
  12 #include "nsAccUtils.h"
  13 #include "nsIPersistentProperties2.h"
  14 #include "DocAccessibleParent.h"
  15 #include "Relation.h"
  16 #include "Role.h"
  17 #include "RootAccessible.h"
  18 #include "TableAccessible.h"
  19 #include "TableCellAccessible.h"
  20 #include "mozilla/a11y/PDocAccessible.h"
  21 #include "mozilla/dom/BrowserParent.h"
  22 #include "OuterDocAccessible.h"
  23 #include "nsChildView.h"
  24
  25 #include "nsRect.h"
  26 #include "nsCocoaUtils.h"
  27 #include "nsCoord.h"
  28 #include "nsObjCExceptions.h"
  29 #include "nsWhitespaceTokenizer.h"
  30 #include <prdtoa.h>
  31
  32 using namespace mozilla;
  33 using namespace mozilla::a11y;
  34
  35 #pragma mark -
  36
  37 @interface mozAccessible ()
  38 - (BOOL)providesLabelNotTitle;
  39 @end
  40
  41 @implementation mozAccessible
  42
  43 - (id)initWithAccessible:(AccessibleOrProxy)aAccOrProxy {
  44   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
  45   MOZ_ASSERT(!aAccOrProxy.IsNull(), "Cannot init mozAccessible with null");
  46   if ((self = [super init])) {
  47     mGeckoAccessible = aAccOrProxy;
  48     mRole = aAccOrProxy.Role();
  49   }
  50
  51   return self;
  52
  53   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
  54 }
  55
  56 - (void)dealloc {
  57   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
  58
  59   [super dealloc];
  60
  61   NS_OBJC_END_TRY_ABORT_BLOCK;
  62 }
  63
  64 #pragma mark - mozAccessible widget
  65
  66 - (BOOL)hasRepresentedView {
  67   return NO;
  68 }
  69
  70 - (id)representedView {
  71   return nil;
  72 }
  73
  74 - (BOOL)isRoot {
  75   return NO;
  76 }
  77
  78 #pragma mark -
  79
  80 - (BOOL)isAccessibilityElement {
  81   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
  82
  83   if ([self isExpired]) {
  84     return ![self ignoreWithParent:nil];
  85   }
  86
  87   mozAccessible* parent = nil;
  88   AccessibleOrProxy p = mGeckoAccessible.Parent();
  89
  90   if (!p.IsNull()) {
  91     parent = GetNativeFromGeckoAccessible(p);
  92   }
  93
  94   return ![self ignoreWithParent:parent];
  95
  96   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NO);
  97 }
  98
  99 - (BOOL)ignoreWithParent:(mozAccessible*)parent {
 100   if (Accessible* acc = mGeckoAccessible.AsAccessible()) {
 101     if (acc->IsContent() && acc->GetContent()->IsXULElement()) {
 102       if (acc->VisibilityState() & states::INVISIBLE) {
 103         return YES;
 104       }
 105     }
 106   }
 107
 108   return [parent ignoreChild:self];
 109 }
 110
 111 - (BOOL)ignoreChild:(mozAccessible*)child {
 112   return NO;
 113 }
 114
 115 - (id)childAt:(uint32_t)i {
 116   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
 117
 118   AccessibleOrProxy child = mGeckoAccessible.ChildAt(i);
 119   return !child.IsNull() ? GetNativeFromGeckoAccessible(child) : nil;
 120
 121   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 122 }
 123
 124 static const uint64_t kCachedStates = states::CHECKED | states::PRESSED | states::MIXED |
 125                                       states::EXPANDED | states::CURRENT | states::SELECTED |
 126                                       states::TRAVERSED | states::LINKED | states::HASPOPUP;
 127 static const uint64_t kCacheInitialized = ((uint64_t)0x1) << 63;
 128
 129 - (uint64_t)state {
 130   uint64_t state = 0;
 131
 132   if (Accessible* acc = mGeckoAccessible.AsAccessible()) {
 133     state = acc->State();
 134   }
 135
 136   if (ProxyAccessible* proxy = mGeckoAccessible.AsProxy()) {
 137     state = proxy->State();
 138   }
 139
 140   if (!(mCachedState & kCacheInitialized)) {
 141     mCachedState = state & kCachedStates;
 142     mCachedState |= kCacheInitialized;
 143   }
 144
 145   return state;
 146 }
 147
 148 - (uint64_t)stateWithMask:(uint64_t)mask {
 149   if ((mask & kCachedStates) == mask && (mCachedState & kCacheInitialized) != 0) {
 150     return mCachedState & mask;
 151   }
 152
 153   return [self state] & mask;
 154 }
 155
 156 - (void)stateChanged:(uint64_t)state isEnabled:(BOOL)enabled {
 157   if ((state & kCachedStates) == 0) {
 158     return;
 159   }
 160
 161   if (!(mCachedState & kCacheInitialized)) {
 162     [self state];
 163     return;
 164   }
 165
 166   if (enabled) {
 167     mCachedState |= state;
 168   } else {
 169     mCachedState &= ~state;
 170   }
 171 }
 172
 173 - (void)invalidateState {
 174   mCachedState = 0;
 175 }
 176
 177 - (BOOL)providesLabelNotTitle {
 178   // These accessible types are the exception to the rule of label vs. title:
 179   // They may be named explicitly, but they still provide a label not a title.
 180   return mRole == roles::GROUPING || mRole == roles::RADIO_GROUP || mRole == roles::FIGURE ||
 181          mRole == roles::GRAPHIC || mRole == roles::DOCUMENT;
 182 }
 183
 184 - (mozilla::a11y::AccessibleOrProxy)geckoAccessible {
 185   return mGeckoAccessible;
 186 }
 187
 188 #pragma mark - MOXAccessible protocol
 189
 190 - (BOOL)moxBlockSelector:(SEL)selector {
 191   if (selector == @selector(moxPerformPress)) {
 192     uint8_t actionCount = mGeckoAccessible.IsAccessible()
 193                               ? mGeckoAccessible.AsAccessible()->ActionCount()
 194                               : mGeckoAccessible.AsProxy()->ActionCount();
 195
 196     // If we have no action, we don't support press, so return YES.
 197     return actionCount == 0;
 198   }
 199
 200   if (selector == @selector(moxSetFocused:)) {
 201     return [self stateWithMask:states::FOCUSABLE] == 0;
 202   }
 203
 204   return [super moxBlockSelector:selector];
 205 }
 206
 207 - (id)moxFocusedUIElement {
 208   MOZ_ASSERT(!mGeckoAccessible.IsNull());
 209
 210   Accessible* acc = mGeckoAccessible.AsAccessible();
 211   ProxyAccessible* proxy = mGeckoAccessible.AsProxy();
 212
 213   mozAccessible* focusedChild = nil;
 214   if (acc) {
 215     Accessible* focusedGeckoChild = acc->FocusedChild();
 216     if (focusedGeckoChild) {
 217       focusedChild = GetNativeFromGeckoAccessible(focusedGeckoChild);
 218     } else {
 219       dom::BrowserParent* browser = dom::BrowserParent::GetFocused();
 220       if (browser) {
 221         a11y::DocAccessibleParent* proxyDoc = browser->GetTopLevelDocAccessible();
 222         if (proxyDoc) {
 223           mozAccessible* nativeRemoteChild = GetNativeFromGeckoAccessible(proxyDoc);
 224           return [nativeRemoteChild accessibilityFocusedUIElement];
 225         }
 226       }
 227     }
 228   } else if (proxy) {
 229     ProxyAccessible* focusedGeckoChild = proxy->FocusedChild();
 230     if (focusedGeckoChild) {
 231       focusedChild = GetNativeFromGeckoAccessible(focusedGeckoChild);
 232     }
 233   }
 234
 235   if ([focusedChild isAccessibilityElement]) {
 236     return focusedChild;
 237   }
 238
 239   // return ourself if we can't get a native focused child.
 240   return self;
 241 }
 242
 243 - (id<MOXTextMarkerSupport>)moxTextMarkerDelegate {
 244   MOZ_ASSERT(!mGeckoAccessible.IsNull());
 245
 246   if (mGeckoAccessible.IsAccessible()) {
 247     return [MOXTextMarkerDelegate getOrCreateForDoc:mGeckoAccessible.AsAccessible()->Document()];
 248   }
 249
 250   return [MOXTextMarkerDelegate getOrCreateForDoc:mGeckoAccessible.AsProxy()->Document()];
 251 }
 252
 253 - (id)moxHitTest:(NSPoint)point {
 254   MOZ_ASSERT(!mGeckoAccessible.IsNull());
 255
 256   // Convert the given screen-global point in the cocoa coordinate system (with
 257   // origin in the bottom-left corner of the screen) into point in the Gecko
 258   // coordinate system (with origin in a top-left screen point).
 259   NSScreen* mainView = [[NSScreen screens] objectAtIndex:0];
 260   NSPoint tmpPoint = NSMakePoint(point.x, [mainView frame].size.height - point.y);
 261   LayoutDeviceIntPoint geckoPoint =
 262       nsCocoaUtils::CocoaPointsToDevPixels(tmpPoint, nsCocoaUtils::GetBackingScaleFactor(mainView));
 263
 264   AccessibleOrProxy child =
 265       mGeckoAccessible.ChildAtPoint(geckoPoint.x, geckoPoint.y, Accessible::eDeepestChild);
 266
 267   if (!child.IsNull()) {
 268     mozAccessible* nativeChild = GetNativeFromGeckoAccessible(child);
 269     return [nativeChild isAccessibilityElement] ? nativeChild : [nativeChild moxParent];
 270   }
 271
 272   // if we didn't find anything, return ourself or child view.
 273   return self;
 274 }
 275
 276 - (id<mozAccessible>)moxParent {
 277   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
 278   if ([self isExpired]) {
 279     return nil;
 280   }
 281
 282   AccessibleOrProxy parent = mGeckoAccessible.Parent();
 283
 284   if (parent.IsNull()) {
 285     return nil;
 286   }
 287
 288   id nativeParent = GetNativeFromGeckoAccessible(parent);
 289   if (!nativeParent && mGeckoAccessible.IsAccessible()) {
 290     // Return native of root accessible if we have no direct parent.
 291     // XXX: need to return a sensible fallback in proxy case as well
 292     nativeParent = GetNativeFromGeckoAccessible(mGeckoAccessible.AsAccessible()->RootAccessible());
 293   }
 294
 295   if (![nativeParent isAccessibilityElement]) {
 296     nativeParent = [nativeParent moxParent];
 297   }
 298
 299   return GetObjectOrRepresentedView(nativeParent);
 300
 301   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 302 }
 303
 304 // gets our native children lazily.
 305 - (NSArray*)moxChildren {
 306   MOZ_ASSERT(!mGeckoAccessible.IsNull());
 307
 308   NSMutableArray* children =
 309       [[NSMutableArray alloc] initWithCapacity:mGeckoAccessible.ChildCount()];
 310
 311   for (uint32_t childIdx = 0; childIdx < mGeckoAccessible.ChildCount(); childIdx++) {
 312     AccessibleOrProxy child = mGeckoAccessible.ChildAt(childIdx);
 313     mozAccessible* nativeChild = GetNativeFromGeckoAccessible(child);
 314     if (!nativeChild) {
 315       continue;
 316     }
 317
 318     if ([nativeChild ignoreWithParent:self]) {
 319       // If this child should be ignored get its unignored children.
 320       // This will in turn recurse to any unignored descendants if the
 321       // child is ignored.
 322       [children addObjectsFromArray:[nativeChild moxChildren]];
 323     } else {
 324       [children addObject:nativeChild];
 325     }
 326   }
 327
 328   return children;
 329 }
 330
 331 - (NSValue*)moxPosition {
 332   MOZ_ASSERT(!mGeckoAccessible.IsNull());
 333
 334   nsIntRect rect = mGeckoAccessible.IsAccessible() ? mGeckoAccessible.AsAccessible()->Bounds()
 335                                                    : mGeckoAccessible.AsProxy()->Bounds();
 336
 337   NSScreen* mainView = [[NSScreen screens] objectAtIndex:0];
 338   CGFloat scaleFactor = nsCocoaUtils::GetBackingScaleFactor(mainView);
 339   NSPoint p = NSMakePoint(
 340       static_cast<CGFloat>(rect.x) / scaleFactor,
 341       [mainView frame].size.height - static_cast<CGFloat>(rect.y + rect.height) / scaleFactor);
 342
 343   return [NSValue valueWithPoint:p];
 344 }
 345
 346 - (NSValue*)moxSize {
 347   MOZ_ASSERT(!mGeckoAccessible.IsNull());
 348
 349   nsIntRect rect = mGeckoAccessible.IsAccessible() ? mGeckoAccessible.AsAccessible()->Bounds()
 350                                                    : mGeckoAccessible.AsProxy()->Bounds();
 351
 352   CGFloat scaleFactor = nsCocoaUtils::GetBackingScaleFactor([[NSScreen screens] objectAtIndex:0]);
 353   return [NSValue valueWithSize:NSMakeSize(static_cast<CGFloat>(rect.width) / scaleFactor,
 354                                            static_cast<CGFloat>(rect.height) / scaleFactor)];
 355 }
 356
 357 - (NSString*)moxRole {
 358 #define ROLE(geckoRole, stringRole, atkRole, macRole, macSubrole, msaaRole, ia2Role, androidClass, \
 359              nameRule)                                                                             \
 360   case roles::geckoRole:                                                                           \
 361     return macRole;
 362
 363   switch (mRole) {
 364 #include "RoleMap.h"
 365     default:
 366       MOZ_ASSERT_UNREACHABLE("Unknown role.");
 367       return NSAccessibilityUnknownRole;
 368   }
 369
 370 #undef ROLE
 371 }
 372
 373 - (NSString*)moxSubrole {
 374   MOZ_ASSERT(!mGeckoAccessible.IsNull());
 375
 376   Accessible* acc = mGeckoAccessible.AsAccessible();
 377   ProxyAccessible* proxy = mGeckoAccessible.AsProxy();
 378
 379   // Deal with landmarks first
 380   // macOS groups the specific landmark types of DPub ARIA into two broad
 381   // categories with corresponding subroles: Navigation and region/container.
 382   if (mRole == roles::LANDMARK) {
 383     nsAtom* landmark = acc ? acc->LandmarkRole() : proxy->LandmarkRole();
 384     // HTML Elements treated as landmarks, and ARIA landmarks.
 385     if (landmark) {
 386       if (landmark == nsGkAtoms::banner) return @"AXLandmarkBanner";
 387       if (landmark == nsGkAtoms::complementary) return @"AXLandmarkComplementary";
 388       if (landmark == nsGkAtoms::contentinfo) return @"AXLandmarkContentInfo";
 389       if (landmark == nsGkAtoms::main) return @"AXLandmarkMain";
 390       if (landmark == nsGkAtoms::navigation) return @"AXLandmarkNavigation";
 391       if (landmark == nsGkAtoms::search) return @"AXLandmarkSearch";
 392     }
 393
 394     // None of the above, so assume DPub ARIA.
 395     return @"AXLandmarkRegion";
 396   }
 397
 398   // Now, deal with widget roles
 399   nsStaticAtom* roleAtom = nullptr;
 400
 401   if (mRole == roles::DIALOG) {
 402     if (acc && acc->HasARIARole()) {
 403       const nsRoleMapEntry* roleMap = acc->ARIARoleMap();
 404       roleAtom = roleMap->roleAtom;
 405     } else if (proxy) {
 406       roleAtom = proxy->ARIARoleAtom();
 407     }
 408
 409     if (roleAtom) {
 410       if (roleAtom == nsGkAtoms::alertdialog) {
 411         return @"AXApplicationAlertDialog";
 412       }
 413       if (roleAtom == nsGkAtoms::dialog) {
 414         return @"AXApplicationDialog";
 415       }
 416     }
 417   }
 418
 419   if (mRole == roles::FORM) {
 420     // This only gets exposed as a landmark if the role comes from ARIA.
 421     if (acc && acc->HasARIARole()) {
 422       const nsRoleMapEntry* roleMap = acc->ARIARoleMap();
 423       roleAtom = roleMap->roleAtom;
 424     } else if (proxy) {
 425       roleAtom = proxy->ARIARoleAtom();
 426     }
 427
 428     if (roleAtom && roleAtom == nsGkAtoms::form) {
 429       return @"AXLandmarkForm";
 430     }
 431   }
 432
 433 #define ROLE(geckoRole, stringRole, atkRole, macRole, macSubrole, msaaRole, ia2Role, androidClass, \
 434              nameRule)                                                                             \
 435   case roles::geckoRole:                                                                           \
 436     if (![macSubrole isEqualToString:NSAccessibilityUnknownSubrole]) {                             \
 437       return macSubrole;                                                                           \
 438     } else {                                                                                       \
 439       break;                                                                                       \
 440     }
 441
 442   switch (mRole) {
 443 #include "RoleMap.h"
 444   }
 445
 446   // These are special. They map to roles::NOTHING
 447   // and are instructed by the ARIA map to use the native host role.
 448   if (acc && acc->HasARIARole()) {
 449     const nsRoleMapEntry* roleMap = acc->ARIARoleMap();
 450     roleAtom = roleMap->roleAtom;
 451   }
 452   if (proxy) roleAtom = proxy->ARIARoleAtom();
 453
 454   if (roleAtom) {
 455     if (roleAtom == nsGkAtoms::log_) return @"AXApplicationLog";
 456     if (roleAtom == nsGkAtoms::timer) return @"AXApplicationTimer";
 457     // macOS added an AXSubrole value to distinguish generic AXGroup objects
 458     // from those which are AXGroups as a result of an explicit ARIA role,
 459     // such as the non-landmark, non-listitem text containers in DPub ARIA.
 460     if (mRole == roles::FOOTNOTE || mRole == roles::SECTION) {
 461       return @"AXApplicationGroup";
 462     }
 463   }
 464
 465   return NSAccessibilityUnknownSubrole;
 466
 467 #undef ROLE
 468 }
 469
 470 struct RoleDescrMap {
 471   NSString* role;
 472   const nsString description;
 473 };
 474
 475 static const RoleDescrMap sRoleDescrMap[] = {{@"AXApplicationAlert", u"alert"_ns},
 476                                              {@"AXApplicationAlertDialog", u"alertDialog"_ns},
 477                                              {@"AXApplicationDialog", u"dialog"_ns},
 478                                              {@"AXApplicationLog", u"log"_ns},
 479                                              {@"AXApplicationMarquee", u"marquee"_ns},
 480                                              {@"AXApplicationStatus", u"status"_ns},
 481                                              {@"AXApplicationTimer", u"timer"_ns},
 482                                              {@"AXContentSeparator", u"separator"_ns},
 483                                              {@"AXDefinition", u"definition"_ns},
 484                                              {@"AXDetails", u"details"_ns},
 485                                              {@"AXDocument", u"document"_ns},
 486                                              {@"AXDocumentArticle", u"article"_ns},
 487                                              {@"AXDocumentMath", u"math"_ns},
 488                                              {@"AXDocumentNote", u"note"_ns},
 489                                              {@"AXLandmarkApplication", u"application"_ns},
 490                                              {@"AXLandmarkBanner", u"banner"_ns},
 491                                              {@"AXLandmarkComplementary", u"complementary"_ns},
 492                                              {@"AXLandmarkContentInfo", u"content"_ns},
 493                                              {@"AXLandmarkMain", u"main"_ns},
 494                                              {@"AXLandmarkNavigation", u"navigation"_ns},
 495                                              {@"AXLandmarkRegion", u"region"_ns},
 496                                              {@"AXLandmarkSearch", u"search"_ns},
 497                                              {@"AXSearchField", u"searchTextField"_ns},
 498                                              {@"AXSummary", u"summary"_ns},
 499                                              {@"AXTabPanel", u"tabPanel"_ns},
 500                                              {@"AXTerm", u"term"_ns},
 501                                              {@"AXUserInterfaceTooltip", u"tooltip"_ns}};
 502
 503 struct RoleDescrComparator {
 504   const NSString* mRole;
 505   explicit RoleDescrComparator(const NSString* aRole) : mRole(aRole) {}
 506   int operator()(const RoleDescrMap& aEntry) const { return [mRole compare:aEntry.role]; }
 507 };
 508
 509 - (NSString*)moxRoleDescription {
 510   if (mRole == roles::DOCUMENT) return utils::LocalizedString(u"htmlContent"_ns);
 511
 512   if (mRole == roles::FIGURE) return utils::LocalizedString(u"figure"_ns);
 513
 514   if (mRole == roles::HEADING) return utils::LocalizedString(u"heading"_ns);
 515
 516   if (mRole == roles::MARK) {
 517     return utils::LocalizedString(u"highlight"_ns);
 518   }
 519
 520   NSString* subrole = [self moxSubrole];
 521
 522   if (subrole) {
 523     size_t idx = 0;
 524     if (BinarySearchIf(sRoleDescrMap, 0, ArrayLength(sRoleDescrMap), RoleDescrComparator(subrole),
 525                        &idx)) {
 526       return utils::LocalizedString(sRoleDescrMap[idx].description);
 527     }
 528   }
 529
 530   return NSAccessibilityRoleDescription([self moxRole], subrole);
 531 }
 532
 533 - (NSString*)moxLabel {
 534   if ([self isExpired]) {
 535     return nil;
 536   }
 537
 538   Accessible* acc = mGeckoAccessible.AsAccessible();
 539   ProxyAccessible* proxy = mGeckoAccessible.AsProxy();
 540   nsAutoString name;
 541
 542   /* If our accessible is:
 543    * 1. Named by invisible text, or
 544    * 2. Has more than one labeling relation, or
 545    * 3. Is a special role defined in providesLabelNotTitle
 546    *   ... return its name as a label (AXDescription).
 547    */
 548   if (acc) {
 549     ENameValueFlag flag = acc->Name(name);
 550     if (flag == eNameFromSubtree) {
 551       return nil;
 552     }
 553
 554     if (![self providesLabelNotTitle]) {
 555       Relation rel = acc->RelationByType(RelationType::LABELLED_BY);
 556       if (rel.Next() && !rel.Next()) {
 557         return nil;
 558       }
 559     }
 560   } else if (proxy) {
 561     uint32_t flag = proxy->Name(name);
 562     if (flag == eNameFromSubtree) {
 563       return nil;
 564     }
 565
 566     if (![self providesLabelNotTitle]) {
 567       nsTArray<ProxyAccessible*> rels = proxy->RelationByType(RelationType::LABELLED_BY);
 568       if (rels.Length() == 1) {
 569         return nil;
 570       }
 571     }
 572   }
 573
 574   return nsCocoaUtils::ToNSString(name);
 575 }
 576
 577 - (NSString*)moxTitle {
 578   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
 579
 580   // In some special cases we provide the name in the label (AXDescription).
 581   if ([self providesLabelNotTitle]) {
 582     return nil;
 583   }
 584
 585   nsAutoString title;
 586   if (Accessible* acc = mGeckoAccessible.AsAccessible()) {
 587     acc->Name(title);
 588   } else {
 589     mGeckoAccessible.AsProxy()->Name(title);
 590   }
 591
 592   return nsCocoaUtils::ToNSString(title);
 593
 594   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 595 }
 596
 597 - (id)moxValue {
 598   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
 599
 600   nsAutoString value;
 601   if (Accessible* acc = mGeckoAccessible.AsAccessible()) {
 602     acc->Value(value);
 603   } else {
 604     mGeckoAccessible.AsProxy()->Value(value);
 605   }
 606
 607   return nsCocoaUtils::ToNSString(value);
 608
 609   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 610 }
 611
 612 - (NSString*)moxHelp {
 613   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
 614
 615   // What needs to go here is actually the accDescription of an item.
 616   // The MSAA acc_help method has nothing to do with this one.
 617   nsAutoString helpText;
 618   if (Accessible* acc = mGeckoAccessible.AsAccessible()) {
 619     acc->Description(helpText);
 620   } else {
 621     mGeckoAccessible.AsProxy()->Description(helpText);
 622   }
 623
 624   return nsCocoaUtils::ToNSString(helpText);
 625
 626   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 627 }
 628
 629 - (NSWindow*)moxWindow {
 630   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
 631
 632   // Get a pointer to the native window (NSWindow) we reside in.
 633   NSWindow* nativeWindow = nil;
 634   DocAccessible* docAcc = nullptr;
 635   if (Accessible* acc = mGeckoAccessible.AsAccessible()) {
 636     docAcc = acc->Document();
 637   } else {
 638     ProxyAccessible* proxy = mGeckoAccessible.AsProxy();
 639     Accessible* outerDoc = proxy->OuterDocOfRemoteBrowser();
 640     if (outerDoc) docAcc = outerDoc->Document();
 641   }
 642
 643   if (docAcc) nativeWindow = static_cast<NSWindow*>(docAcc->GetNativeWindow());
 644
 645   MOZ_ASSERT(nativeWindow, "Couldn't get native window");
 646   return nativeWindow;
 647
 648   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 649 }
 650
 651 - (NSNumber*)moxEnabled {
 652   if ([self stateWithMask:states::UNAVAILABLE]) {
 653     return @NO;
 654   }
 655
 656   if (![self isRoot]) {
 657     mozAccessible* parent = (mozAccessible*)[self moxParent];
 658     if (![parent isRoot]) {
 659       return @(![parent disableChild:self]);
 660     }
 661   }
 662
 663   return @YES;
 664 }
 665
 666 - (NSNumber*)moxFocused {
 667   return @([self stateWithMask:states::FOCUSED] != 0);
 668 }
 669
 670 - (NSNumber*)moxSelected {
 671   return @NO;
 672 }
 673
 674 - (NSString*)moxARIACurrent {
 675   if (![self stateWithMask:states::CURRENT]) {
 676     return nil;
 677   }
 678
 679   return utils::GetAccAttr(self, "current");
 680 }
 681
 682 - (id)moxTitleUIElement {
 683   MOZ_ASSERT(!mGeckoAccessible.IsNull());
 684
 685   if (Accessible* acc = mGeckoAccessible.AsAccessible()) {
 686     Relation rel = acc->RelationByType(RelationType::LABELLED_BY);
 687     Accessible* tempAcc = rel.Next();
 688     if (tempAcc && !rel.Next()) {
 689       mozAccessible* label = GetNativeFromGeckoAccessible(tempAcc);
 690       return [label isAccessibilityElement] ? label : nil;
 691     }
 692
 693     return nil;
 694   }
 695
 696   ProxyAccessible* proxy = mGeckoAccessible.AsProxy();
 697   nsTArray<ProxyAccessible*> rel = proxy->RelationByType(RelationType::LABELLED_BY);
 698   ProxyAccessible* tempProxy = rel.SafeElementAt(0);
 699   if (tempProxy && rel.Length() <= 1) {
 700     mozAccessible* label = GetNativeFromGeckoAccessible(tempProxy);
 701     return [label isAccessibilityElement] ? label : nil;
 702   }
 703
 704   return nil;
 705 }
 706
 707 - (NSString*)moxDOMIdentifier {
 708   MOZ_ASSERT(!mGeckoAccessible.IsNull());
 709
 710   nsAutoString id;
 711   if (Accessible* acc = mGeckoAccessible.AsAccessible()) {
 712     if (acc->GetContent()) {
 713       nsCoreUtils::GetID(acc->GetContent(), id);
 714     }
 715   } else {
 716     mGeckoAccessible.AsProxy()->DOMNodeID(id);
 717   }
 718
 719   return nsCocoaUtils::ToNSString(id);
 720 }
 721
 722 - (NSNumber*)moxRequired {
 723   return @([self stateWithMask:states::REQUIRED] != 0);
 724 }
 725
 726 - (void)moxSetFocused:(NSNumber*)focused {
 727   MOZ_ASSERT(!mGeckoAccessible.IsNull());
 728
 729   if ([focused boolValue]) {
 730     if (mGeckoAccessible.IsAccessible()) {
 731       mGeckoAccessible.AsAccessible()->TakeFocus();
 732     } else {
 733       mGeckoAccessible.AsProxy()->TakeFocus();
 734     }
 735   }
 736 }
 737
 738 - (void)moxPerformScrollToVisible {
 739   MOZ_ASSERT(!mGeckoAccessible.IsNull());
 740
 741   if (mGeckoAccessible.IsAccessible()) {
 742     // Need strong ref because of MOZ_CAN_RUN_SCRIPT
 743     RefPtr<Accessible> acc = mGeckoAccessible.AsAccessible();
 744     acc->ScrollTo(nsIAccessibleScrollType::SCROLL_TYPE_ANYWHERE);
 745   } else {
 746     mGeckoAccessible.AsProxy()->ScrollTo(nsIAccessibleScrollType::SCROLL_TYPE_ANYWHERE);
 747   }
 748 }
 749
 750 - (void)moxPerformShowMenu {
 751   MOZ_ASSERT(!mGeckoAccessible.IsNull());
 752
 753   nsIntRect bounds = mGeckoAccessible.IsAccessible() ? mGeckoAccessible.AsAccessible()->Bounds()
 754                                                      : mGeckoAccessible.AsProxy()->Bounds();
 755   // We don't need to convert this rect into mac coordinates because the
 756   // mouse event synthesizer expects layout (gecko) coordinates.
 757   LayoutDeviceIntRect geckoRect = LayoutDeviceIntRect::FromUnknownRect(bounds);
 758
 759   Accessible* rootAcc =
 760       mGeckoAccessible.IsAccessible()
 761           ? mGeckoAccessible.AsAccessible()->RootAccessible()
 762           : mGeckoAccessible.AsProxy()->OuterDocOfRemoteBrowser()->RootAccessible();
 763   id objOrView = GetObjectOrRepresentedView(GetNativeFromGeckoAccessible(rootAcc));
 764
 765   LayoutDeviceIntPoint p = LayoutDeviceIntPoint(geckoRect.X() + (geckoRect.Width() / 2),
 766                                                 geckoRect.Y() + (geckoRect.Height() / 2));
 767   nsIWidget* widget = [objOrView widget];
 768   // XXX: NSRightMouseDown is depreciated in 10.12, should be
 769   // changed to NSEventTypeRightMouseDown after refactoring.
 770   widget->SynthesizeNativeMouseEvent(p, NSRightMouseDown, 0, nullptr);
 771 }
 772
 773 - (void)moxPerformPress {
 774   MOZ_ASSERT(!mGeckoAccessible.IsNull());
 775
 776   if (mGeckoAccessible.IsAccessible()) {
 777     mGeckoAccessible.AsAccessible()->DoAction(0);
 778   } else {
 779     mGeckoAccessible.AsProxy()->DoAction(0);
 780   }
 781
 782   // Activating accessible may alter its state.
 783   [self invalidateState];
 784 }
 785
 786 #pragma mark -
 787
 788 // objc-style description (from NSObject); not to be confused with the accessible description above.
 789 - (NSString*)description {
 790   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
 791
 792   return [NSString stringWithFormat:@"(%p) %@", self, [self moxRole]];
 793
 794   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 795 }
 796
 797 - (BOOL)disableChild:(mozAccessible*)child {
 798   return NO;
 799 }
 800
 801 - (void)handleAccessibleEvent:(uint32_t)eventType {
 802   switch (eventType) {
 803     case nsIAccessibleEvent::EVENT_FOCUS:
 804       [self moxPostNotification:NSAccessibilityFocusedUIElementChangedNotification];
 805       break;
 806     case nsIAccessibleEvent::EVENT_MENUPOPUP_START:
 807       [self moxPostNotification:@"AXMenuOpened"];
 808       break;
 809     case nsIAccessibleEvent::EVENT_MENUPOPUP_END:
 810       [self moxPostNotification:@"AXMenuClosed"];
 811       break;
 812     case nsIAccessibleEvent::EVENT_SELECTION:
 813     case nsIAccessibleEvent::EVENT_SELECTION_ADD:
 814     case nsIAccessibleEvent::EVENT_SELECTION_REMOVE:
 815     case nsIAccessibleEvent::EVENT_SELECTION_WITHIN:
 816       [self moxPostNotification:NSAccessibilitySelectedChildrenChangedNotification];
 817       break;
 818   }
 819 }
 820
 821 - (void)expire {
 822   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
 823
 824   [self invalidateState];
 825
 826   mGeckoAccessible.SetBits(0);
 827
 828   [self moxPostNotification:NSAccessibilityUIElementDestroyedNotification];
 829
 830   NS_OBJC_END_TRY_ABORT_BLOCK;
 831 }
 832
 833 - (BOOL)isExpired {
 834   return !mGeckoAccessible.AsAccessible() && !mGeckoAccessible.AsProxy();
 835 }
 836
 837 @end