accessible/generic/LocalAccessible.h

   1 /* -*- Mode: 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 #ifndef _LocalAccessible_H_
   7 #define _LocalAccessible_H_
   8
   9 #include "mozilla/a11y/Accessible.h"
  10 #include "mozilla/a11y/AccTypes.h"
  11 #include "mozilla/a11y/RelationType.h"
  12 #include "mozilla/a11y/States.h"
  13
  14 #include "mozilla/UniquePtr.h"
  15
  16 #include "nsIContent.h"
  17 #include "nsTArray.h"
  18 #include "nsRefPtrHashtable.h"
  19 #include "nsRect.h"
  20
  21 struct nsRoleMapEntry;
  22
  23 class nsIFrame;
  24
  25 class nsAttrValue;
  26
  27 namespace mozilla::dom {
  28 class Element;
  29 }
  30
  31 namespace mozilla {
  32 namespace a11y {
  33
  34 class LocalAccessible;
  35 class AccAttributes;
  36 class AccEvent;
  37 class AccGroupInfo;
  38 class ApplicationAccessible;
  39 class CacheData;
  40 class DocAccessible;
  41 class EmbeddedObjCollector;
  42 class EventTree;
  43 class HTMLImageMapAccessible;
  44 class HTMLLIAccessible;
  45 class HTMLLinkAccessible;
  46 class HyperTextAccessible;
  47 class HyperTextAccessibleBase;
  48 class ImageAccessible;
  49 class KeyBinding;
  50 class OuterDocAccessible;
  51 class RemoteAccessible;
  52 class Relation;
  53 class RootAccessible;
  54 class TableAccessible;
  55 class TableCellAccessible;
  56 class TextLeafAccessible;
  57 class XULLabelAccessible;
  58 class XULTreeAccessible;
  59
  60 enum class CacheUpdateType;
  61
  62 #ifdef A11Y_LOG
  63 namespace logging {
  64 typedef const char* (*GetTreePrefix)(void* aData, LocalAccessible*);
  65 void Tree(const char* aTitle, const char* aMsgText, LocalAccessible* aRoot,
  66           GetTreePrefix aPrefixFunc, void* GetTreePrefixData);
  67 void TreeSize(const char* aTitle, const char* aMsgText, LocalAccessible* aRoot);
  68 };  // namespace logging
  69 #endif
  70
  71 /**
  72  * Group position (level, position in set and set size).
  73  */
  74 struct GroupPos {
  75   GroupPos() : level(0), posInSet(0), setSize(0) {}
  76   GroupPos(int32_t aLevel, int32_t aPosInSet, int32_t aSetSize)
  77       : level(aLevel), posInSet(aPosInSet), setSize(aSetSize) {}
  78
  79   int32_t level;
  80   int32_t posInSet;
  81   int32_t setSize;
  82 };
  83
  84 typedef nsRefPtrHashtable<nsPtrHashKey<const void>, LocalAccessible>
  85     AccessibleHashtable;
  86
  87 #define NS_ACCESSIBLE_IMPL_IID                       \
  88   { /* 133c8bf4-4913-4355-bd50-426bd1d6e1ad */       \
  89     0x133c8bf4, 0x4913, 0x4355, {                    \
  90       0xbd, 0x50, 0x42, 0x6b, 0xd1, 0xd6, 0xe1, 0xad \
  91     }                                                \
  92   }
  93
  94 class LocalAccessible : public nsISupports, public Accessible {
  95  public:
  96   LocalAccessible(nsIContent* aContent, DocAccessible* aDoc);
  97
  98   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  99   NS_DECL_CYCLE_COLLECTION_CLASS(LocalAccessible)
 100
 101   NS_DECLARE_STATIC_IID_ACCESSOR(NS_ACCESSIBLE_IMPL_IID)
 102
 103   //////////////////////////////////////////////////////////////////////////////
 104   // Public methods
 105
 106   /**
 107    * Return the document accessible for this accessible.
 108    */
 109   DocAccessible* Document() const { return mDoc; }
 110
 111   /**
 112    * Return the root document accessible for this accessible.
 113    */
 114   a11y::RootAccessible* RootAccessible() const;
 115
 116   /**
 117    * Return frame for this accessible.
 118    */
 119   virtual nsIFrame* GetFrame() const;
 120
 121   /**
 122    * Return DOM node associated with the accessible.
 123    */
 124   virtual nsINode* GetNode() const;
 125
 126   nsIContent* GetContent() const { return mContent; }
 127   dom::Element* Elm() const;
 128
 129   /**
 130    * Return node type information of DOM node associated with the accessible.
 131    */
 132   bool IsContent() const { return GetNode() && GetNode()->IsContent(); }
 133
 134   /**
 135    * Return the unique identifier of the accessible.
 136    */
 137   void* UniqueID() { return static_cast<void*>(this); }
 138
 139   /**
 140    * Return language associated with the accessible.
 141    */
 142   void Language(nsAString& aLocale);
 143
 144   /**
 145    * Get the description of this accessible.
 146    */
 147   virtual void Description(nsString& aDescription) const override;
 148
 149   /**
 150    * Get the value of this accessible.
 151    */
 152   virtual void Value(nsString& aValue) const;
 153
 154   /**
 155    * Get help string for the accessible.
 156    */
 157   void Help(nsString& aHelp) const { aHelp.Truncate(); }
 158
 159   /**
 160    * Get the name of this accessible.
 161    *
 162    * Note: aName.IsVoid() when name was left empty by the author on purpose.
 163    * aName.IsEmpty() when the author missed name, AT can try to repair a name.
 164    */
 165   virtual ENameValueFlag Name(nsString& aName) const override;
 166
 167   /**
 168    * Maps ARIA state attributes to state of accessible. Note the given state
 169    * argument should hold states for accessible before you pass it into this
 170    * method.
 171    *
 172    * @param  [in/out] where to fill the states into.
 173    */
 174   virtual void ApplyARIAState(uint64_t* aState) const;
 175
 176   /**
 177    * Return enumerated accessible role (see constants in Role.h).
 178    */
 179   virtual mozilla::a11y::role Role() const override;
 180
 181   /**
 182    * Return accessible role specified by ARIA (see constants in
 183    * roles).
 184    */
 185   mozilla::a11y::role ARIARole();
 186
 187   /**
 188    * Return a landmark role if applied.
 189    */
 190   virtual nsAtom* LandmarkRole() const;
 191
 192   /**
 193    * Returns enumerated accessible role from native markup (see constants in
 194    * Role.h). Doesn't take into account ARIA roles.
 195    */
 196   virtual mozilla::a11y::role NativeRole() const;
 197
 198   /**
 199    * Return all states of accessible (including ARIA states).
 200    */
 201   virtual uint64_t State();
 202
 203   /**
 204    * Return interactive states present on the accessible
 205    * (@see NativeInteractiveState).
 206    */
 207   uint64_t InteractiveState() const {
 208     uint64_t state = NativeInteractiveState();
 209     ApplyARIAState(&state);
 210     return state;
 211   }
 212
 213   /**
 214    * Return link states present on the accessible.
 215    */
 216   uint64_t LinkState() const {
 217     uint64_t state = NativeLinkState();
 218     ApplyARIAState(&state);
 219     return state;
 220   }
 221
 222   /**
 223    * Return the states of accessible, not taking into account ARIA states.
 224    * Use State() to get complete set of states.
 225    */
 226   virtual uint64_t NativeState() const;
 227
 228   /**
 229    * Return native interactice state (unavailable, focusable or selectable).
 230    */
 231   virtual uint64_t NativeInteractiveState() const;
 232
 233   /**
 234    * Return native link states present on the accessible.
 235    */
 236   virtual uint64_t NativeLinkState() const;
 237
 238   /**
 239    * Return bit set of invisible and offscreen states.
 240    */
 241   uint64_t VisibilityState() const;
 242
 243   /**
 244    * Return true if native unavailable state present.
 245    */
 246   virtual bool NativelyUnavailable() const;
 247
 248   /**
 249    * Return object attributes for the accessible.
 250    */
 251   virtual already_AddRefed<AccAttributes> Attributes();
 252
 253   /**
 254    * Return group position (level, position in set and set size).
 255    */
 256   virtual mozilla::a11y::GroupPos GroupPosition();
 257
 258   /**
 259    * Return direct or deepest child at the given point.
 260    *
 261    * @param  aX           [in] x coordinate relative screen
 262    * @param  aY           [in] y coordinate relative screen
 263    * @param  aWhichChild  [in] flag points if deepest or direct child
 264    *                        should be returned
 265    */
 266   virtual LocalAccessible* LocalChildAtPoint(int32_t aX, int32_t aY,
 267                                              EWhichChildAtPoint aWhichChild);
 268
 269   /**
 270    * Similar to LocalChildAtPoint but crosses process boundaries.
 271    */
 272   virtual Accessible* ChildAtPoint(int32_t aX, int32_t aY,
 273                                    EWhichChildAtPoint aWhichChild) override;
 274
 275   /**
 276    * Return the focused child if any.
 277    */
 278   virtual LocalAccessible* FocusedChild();
 279
 280   /**
 281    * Return calculated group level based on accessible hierarchy.
 282    */
 283   virtual int32_t GetLevelInternal();
 284
 285   /**
 286    * Calculate position in group and group size ('posinset' and 'setsize') based
 287    * on accessible hierarchy.
 288    *
 289    * @param  aPosInSet  [out] accessible position in the group
 290    * @param  aSetSize   [out] the group size
 291    */
 292   virtual void GetPositionAndSizeInternal(int32_t* aPosInSet,
 293                                           int32_t* aSetSize);
 294
 295   /**
 296    * Get the relation of the given type.
 297    */
 298   virtual Relation RelationByType(RelationType aType) const;
 299
 300   //////////////////////////////////////////////////////////////////////////////
 301   // Initializing methods
 302
 303   /**
 304    * Shutdown this accessible object.
 305    */
 306   virtual void Shutdown();
 307
 308   /**
 309    * Set the ARIA role map entry for a new accessible.
 310    */
 311   void SetRoleMapEntry(const nsRoleMapEntry* aRoleMapEntry);
 312
 313   /**
 314    * Append/insert/remove a child. Return true if operation was successful.
 315    */
 316   bool AppendChild(LocalAccessible* aChild) {
 317     return InsertChildAt(mChildren.Length(), aChild);
 318   }
 319   virtual bool InsertChildAt(uint32_t aIndex, LocalAccessible* aChild);
 320
 321   /**
 322    * Inserts a child after given sibling. If the child cannot be inserted,
 323    * then the child is unbound from the document, and false is returned. Make
 324    * sure to null out any references on the child object as it may be destroyed.
 325    */
 326   bool InsertAfter(LocalAccessible* aNewChild, LocalAccessible* aRefChild);
 327
 328   virtual bool RemoveChild(LocalAccessible* aChild);
 329
 330   /**
 331    * Reallocates the child within its parent.
 332    */
 333   virtual void RelocateChild(uint32_t aNewIndex, LocalAccessible* aChild);
 334
 335   // Accessible hierarchy method overrides
 336
 337   virtual Accessible* Parent() const override { return LocalParent(); }
 338
 339   virtual Accessible* ChildAt(uint32_t aIndex) const override {
 340     return LocalChildAt(aIndex);
 341   }
 342
 343   virtual Accessible* NextSibling() const override {
 344     return LocalNextSibling();
 345   }
 346
 347   virtual Accessible* PrevSibling() const override {
 348     return LocalPrevSibling();
 349   }
 350
 351   //////////////////////////////////////////////////////////////////////////////
 352   // LocalAccessible tree traverse methods
 353
 354   /**
 355    * Return parent accessible.
 356    */
 357   LocalAccessible* LocalParent() const { return mParent; }
 358
 359   /**
 360    * Return child accessible at the given index.
 361    */
 362   virtual LocalAccessible* LocalChildAt(uint32_t aIndex) const;
 363
 364   /**
 365    * Return child accessible count.
 366    */
 367   virtual uint32_t ChildCount() const override;
 368
 369   /**
 370    * Return index of the given child accessible.
 371    */
 372   int32_t GetIndexOf(const LocalAccessible* aChild) const {
 373     return (aChild->mParent != this) ? -1 : aChild->IndexInParent();
 374   }
 375
 376   /**
 377    * Return index in parent accessible.
 378    */
 379   virtual int32_t IndexInParent() const override;
 380
 381   /**
 382    * Return first/last/next/previous sibling of the accessible.
 383    */
 384   inline LocalAccessible* LocalNextSibling() const {
 385     return GetSiblingAtOffset(1);
 386   }
 387   inline LocalAccessible* LocalPrevSibling() const {
 388     return GetSiblingAtOffset(-1);
 389   }
 390   inline LocalAccessible* LocalFirstChild() const { return LocalChildAt(0); }
 391   inline LocalAccessible* LocalLastChild() const {
 392     uint32_t childCount = ChildCount();
 393     return childCount != 0 ? LocalChildAt(childCount - 1) : nullptr;
 394   }
 395
 396   /**
 397    * Return embedded accessible children count.
 398    */
 399   uint32_t EmbeddedChildCount();
 400
 401   /**
 402    * Return embedded accessible child at the given index.
 403    */
 404   virtual LocalAccessible* EmbeddedChildAt(uint32_t aIndex) override;
 405
 406   /**
 407    * Return index of the given embedded accessible child.
 408    */
 409   int32_t GetIndexOfEmbeddedChild(LocalAccessible* aChild);
 410
 411   /**
 412    * Return number of content children/content child at index. The content
 413    * child is created from markup in contrast to it's never constructed by its
 414    * parent accessible (like treeitem accessibles for XUL trees).
 415    */
 416   uint32_t ContentChildCount() const { return mChildren.Length(); }
 417   LocalAccessible* ContentChildAt(uint32_t aIndex) const {
 418     return mChildren.ElementAt(aIndex);
 419   }
 420
 421   /**
 422    * Return true if the accessible is attached to tree.
 423    */
 424   bool IsBoundToParent() const { return !!mParent; }
 425
 426   //////////////////////////////////////////////////////////////////////////////
 427   // Miscellaneous methods
 428
 429   /**
 430    * Handle accessible event, i.e. process it, notifies observers and fires
 431    * platform specific event.
 432    */
 433   virtual nsresult HandleAccEvent(AccEvent* aAccEvent);
 434
 435   /**
 436    * Return true if the accessible is an acceptable child.
 437    */
 438   virtual bool IsAcceptableChild(nsIContent* aEl) const {
 439     return aEl &&
 440            !aEl->IsAnyOfHTMLElements(nsGkAtoms::option, nsGkAtoms::optgroup);
 441   }
 442
 443   virtual void AppendTextTo(nsAString& aText, uint32_t aStartOffset = 0,
 444                             uint32_t aLength = UINT32_MAX) override;
 445
 446   /**
 447    * Return boundaries in screen coordinates in app units.
 448    */
 449   virtual nsRect BoundsInAppUnits() const;
 450
 451   /**
 452    * Return boundaries in screen coordinates.
 453    */
 454   virtual nsIntRect Bounds() const override;
 455
 456   /**
 457    * Return boundaries in screen coordinates in CSS pixels.
 458    */
 459   virtual nsIntRect BoundsInCSSPixels() const;
 460
 461   /**
 462    * Return boundaries rect relative the bounding frame.
 463    */
 464   virtual nsRect RelativeBounds(nsIFrame** aRelativeFrame) const;
 465
 466   /**
 467    * Return boundaries rect relative to the frame of the parent accessible.
 468    */
 469   virtual nsRect ParentRelativeBounds();
 470
 471   /**
 472    * Selects the accessible within its container if applicable.
 473    */
 474   virtual void SetSelected(bool aSelect);
 475
 476   /**
 477    * Select the accessible within its container.
 478    */
 479   void TakeSelection();
 480
 481   /**
 482    * Focus the accessible.
 483    */
 484   MOZ_CAN_RUN_SCRIPT_BOUNDARY virtual void TakeFocus() const;
 485
 486   /**
 487    * Scroll the accessible into view.
 488    */
 489   MOZ_CAN_RUN_SCRIPT
 490   virtual void ScrollTo(uint32_t aHow) const;
 491
 492   /**
 493    * Scroll the accessible to the given point.
 494    */
 495   void ScrollToPoint(uint32_t aCoordinateType, int32_t aX, int32_t aY);
 496
 497   /**
 498    * Get a pointer to accessibility interface for this node, which is specific
 499    * to the OS/accessibility toolkit we're running on.
 500    */
 501   virtual void GetNativeInterface(void** aNativeAccessible);
 502
 503   //////////////////////////////////////////////////////////////////////////////
 504   // Downcasting and types
 505
 506   inline bool IsAbbreviation() const {
 507     return mContent->IsAnyOfHTMLElements(nsGkAtoms::abbr, nsGkAtoms::acronym);
 508   }
 509
 510   ApplicationAccessible* AsApplication();
 511
 512   DocAccessible* AsDoc();
 513
 514   HyperTextAccessible* AsHyperText();
 515   virtual HyperTextAccessibleBase* AsHyperTextBase() override;
 516
 517   HTMLLIAccessible* AsHTMLListItem();
 518
 519   HTMLLinkAccessible* AsHTMLLink();
 520
 521   ImageAccessible* AsImage();
 522
 523   HTMLImageMapAccessible* AsImageMap();
 524
 525   RemoteAccessible* Proxy() const {
 526     MOZ_ASSERT(IsProxy());
 527     return mBits.proxy;
 528   }
 529
 530   OuterDocAccessible* AsOuterDoc();
 531
 532   a11y::RootAccessible* AsRoot();
 533
 534   bool IsSearchbox() const;
 535
 536   virtual TableAccessible* AsTable() { return nullptr; }
 537
 538   virtual TableCellAccessible* AsTableCell() { return nullptr; }
 539   const TableCellAccessible* AsTableCell() const {
 540     return const_cast<LocalAccessible*>(this)->AsTableCell();
 541   }
 542
 543   TextLeafAccessible* AsTextLeaf();
 544
 545   XULLabelAccessible* AsXULLabel();
 546
 547   XULTreeAccessible* AsXULTree();
 548
 549   //////////////////////////////////////////////////////////////////////////////
 550   // ActionAccessible
 551
 552   /**
 553    * Return the number of actions that can be performed on this accessible.
 554    */
 555   virtual uint8_t ActionCount() const;
 556
 557   /**
 558    * Return action name at given index.
 559    */
 560   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName);
 561
 562   /**
 563    * Default to localized action name.
 564    */
 565   void ActionDescriptionAt(uint8_t aIndex, nsAString& aDescription) {
 566     nsAutoString name;
 567     ActionNameAt(aIndex, name);
 568     TranslateString(name, aDescription);
 569   }
 570
 571   /**
 572    * Invoke the accessible action.
 573    */
 574   virtual bool DoAction(uint8_t aIndex) const;
 575
 576   /**
 577    * Return access key, such as Alt+D.
 578    */
 579   virtual KeyBinding AccessKey() const;
 580
 581   /**
 582    * Return global keyboard shortcut for default action, such as Ctrl+O for
 583    * Open file menuitem.
 584    */
 585   virtual KeyBinding KeyboardShortcut() const;
 586
 587   //////////////////////////////////////////////////////////////////////////////
 588   // HyperLinkAccessible (any embedded object in text can implement HyperLink,
 589   // which helps determine where it is located within containing text).
 590
 591   /**
 592    * Return true if the accessible is hyper link accessible.
 593    */
 594   virtual bool IsLink() const override;
 595
 596   /**
 597    * Return the start offset of the link within the parent accessible.
 598    */
 599   virtual uint32_t StartOffset();
 600
 601   /**
 602    * Return the end offset of the link within the parent accessible.
 603    */
 604   virtual uint32_t EndOffset();
 605
 606   /**
 607    * Return true if the link is valid (e. g. points to a valid URL).
 608    */
 609   inline bool IsLinkValid() {
 610     MOZ_ASSERT(IsLink(), "IsLinkValid is called on not hyper link!");
 611
 612     // XXX In order to implement this we would need to follow every link
 613     // Perhaps we can get information about invalid links from the cache
 614     // In the mean time authors can use role="link" aria-invalid="true"
 615     // to force it for links they internally know to be invalid
 616     return (0 == (State() & mozilla::a11y::states::INVALID));
 617   }
 618
 619   /**
 620    * Return the number of anchors within the link.
 621    */
 622   virtual uint32_t AnchorCount();
 623
 624   /**
 625    * Returns an anchor accessible at the given index.
 626    */
 627   virtual LocalAccessible* AnchorAt(uint32_t aAnchorIndex);
 628
 629   /**
 630    * Returns an anchor URI at the given index.
 631    */
 632   virtual already_AddRefed<nsIURI> AnchorURIAt(uint32_t aAnchorIndex) const;
 633
 634   /**
 635    * Returns a text point for the accessible element.
 636    */
 637   void ToTextPoint(HyperTextAccessible** aContainer, int32_t* aOffset,
 638                    bool aIsBefore = true) const;
 639
 640   //////////////////////////////////////////////////////////////////////////////
 641   // SelectAccessible
 642
 643   /**
 644    * Return an array of selected items.
 645    */
 646   virtual void SelectedItems(nsTArray<LocalAccessible*>* aItems);
 647
 648   /**
 649    * Return the number of selected items.
 650    */
 651   virtual uint32_t SelectedItemCount();
 652
 653   /**
 654    * Return selected item at the given index.
 655    */
 656   virtual LocalAccessible* GetSelectedItem(uint32_t aIndex);
 657
 658   /**
 659    * Determine if item at the given index is selected.
 660    */
 661   virtual bool IsItemSelected(uint32_t aIndex);
 662
 663   /**
 664    * Add item at the given index the selection. Return true if success.
 665    */
 666   virtual bool AddItemToSelection(uint32_t aIndex);
 667
 668   /**
 669    * Remove item at the given index from the selection. Return if success.
 670    */
 671   virtual bool RemoveItemFromSelection(uint32_t aIndex);
 672
 673   /**
 674    * Select all items. Return true if success.
 675    */
 676   virtual bool SelectAll();
 677
 678   /**
 679    * Unselect all items. Return true if success.
 680    */
 681   virtual bool UnselectAll();
 682
 683   //////////////////////////////////////////////////////////////////////////////
 684   // Value (numeric value interface)
 685
 686   virtual double MaxValue() const override;
 687   virtual double MinValue() const override;
 688   virtual double CurValue() const override;
 689   virtual double Step() const override;
 690   virtual bool SetCurValue(double aValue);
 691
 692   //////////////////////////////////////////////////////////////////////////////
 693   // Widgets
 694
 695   /**
 696    * Return true if accessible is a widget, i.e. control or accessible that
 697    * manages its items. Note, being a widget the accessible may be a part of
 698    * composite widget.
 699    */
 700   virtual bool IsWidget() const;
 701
 702   /**
 703    * Return true if the widget is active, i.e. has a focus within it.
 704    */
 705   virtual bool IsActiveWidget() const;
 706
 707   /**
 708    * Return true if the widget has items and items are operable by user and
 709    * can be activated.
 710    */
 711   virtual bool AreItemsOperable() const;
 712
 713   /**
 714    * Return the current item of the widget, i.e. an item that has or will have
 715    * keyboard focus when widget gets active.
 716    */
 717   virtual LocalAccessible* CurrentItem() const;
 718
 719   /**
 720    * Set the current item of the widget.
 721    */
 722   virtual void SetCurrentItem(const LocalAccessible* aItem);
 723
 724   /**
 725    * Return container widget this accessible belongs to.
 726    */
 727   virtual LocalAccessible* ContainerWidget() const;
 728
 729   /**
 730    * Return the localized string for the given key.
 731    */
 732   static void TranslateString(const nsString& aKey, nsAString& aStringOut);
 733
 734   /**
 735    * Return true if the accessible is defunct.
 736    */
 737   bool IsDefunct() const;
 738
 739   /**
 740    * Return false if the accessible is no longer in the document.
 741    */
 742   bool IsInDocument() const { return !(mStateFlags & eIsNotInDocument); }
 743
 744   /**
 745    * Return true if the accessible should be contained by document node map.
 746    */
 747   bool IsNodeMapEntry() const {
 748     return HasOwnContent() && !(mStateFlags & eNotNodeMapEntry);
 749   }
 750
 751   /**
 752    * Return true if the accessible's group info needs to be updated.
 753    */
 754   inline bool HasDirtyGroupInfo() const {
 755     return mStateFlags & eGroupInfoDirty;
 756   }
 757
 758   /**
 759    * Return true if the accessible has associated DOM content.
 760    */
 761   bool HasOwnContent() const {
 762     return mContent && !(mStateFlags & eSharedNode);
 763   }
 764
 765   /**
 766    * Return true if native markup has a numeric value.
 767    */
 768   bool NativeHasNumericValue() const;
 769
 770   /**
 771    * Return true if ARIA specifies support for a numeric value.
 772    */
 773   bool ARIAHasNumericValue() const;
 774
 775   /**
 776    * Return true if the accessible has a numeric value.
 777    */
 778   virtual bool HasNumericValue() const override;
 779
 780   /**
 781    * Return true if the accessible state change is processed by handling proper
 782    * DOM UI event, if otherwise then false. For example, CheckboxAccessible
 783    * created for HTML:input@type="checkbox" will process
 784    * nsIDocumentObserver::ContentStateChanged instead of 'CheckboxStateChange'
 785    * event.
 786    */
 787   bool NeedsDOMUIEvent() const { return !(mStateFlags & eIgnoreDOMUIEvent); }
 788
 789   /**
 790    * Get/set repositioned bit indicating that the accessible was moved in
 791    * the accessible tree, i.e. the accessible tree structure differs from DOM.
 792    */
 793   bool IsRelocated() const { return mStateFlags & eRelocated; }
 794   void SetRelocated(bool aRelocated) {
 795     if (aRelocated) {
 796       mStateFlags |= eRelocated;
 797     } else {
 798       mStateFlags &= ~eRelocated;
 799     }
 800   }
 801
 802   /**
 803    * Return true if the accessible allows accessible children from subtree of
 804    * a DOM element of this accessible.
 805    */
 806   bool KidsFromDOM() const { return !(mStateFlags & eNoKidsFromDOM); }
 807
 808   /**
 809    * Return true if this accessible has a parent, relation or ancestor with a
 810    * relation whose name depends on this accessible.
 811    */
 812   bool HasNameDependent() const { return mContextFlags & eHasNameDependent; }
 813
 814   /**
 815    * Return true if this accessible has a parent, relation or ancestor with a
 816    * relation whose description depends on this accessible.
 817    */
 818   bool HasDescriptionDependent() const {
 819     return mContextFlags & eHasDescriptionDependent;
 820   }
 821
 822   /**
 823    * Return true if the element is inside an alert.
 824    */
 825   bool IsInsideAlert() const { return mContextFlags & eInsideAlert; }
 826
 827   /**
 828    * Return true if there is a pending reorder event for this accessible.
 829    */
 830   bool ReorderEventTarget() const { return mReorderEventTarget; }
 831
 832   /**
 833    * Return true if there is a pending show event for this accessible.
 834    */
 835   bool ShowEventTarget() const { return mShowEventTarget; }
 836
 837   /**
 838    * Return true if there is a pending hide event for this accessible.
 839    */
 840   bool HideEventTarget() const { return mHideEventTarget; }
 841
 842   /**
 843    * Set if there is a pending reorder event for this accessible.
 844    */
 845   void SetReorderEventTarget(bool aTarget) { mReorderEventTarget = aTarget; }
 846
 847   /**
 848    * Set if this accessible is a show event target.
 849    */
 850   void SetShowEventTarget(bool aTarget) { mShowEventTarget = aTarget; }
 851
 852   /**
 853    * Set if this accessible is a hide event target.
 854    */
 855   void SetHideEventTarget(bool aTarget) { mHideEventTarget = aTarget; }
 856
 857   void Announce(const nsAString& aAnnouncement, uint16_t aPriority);
 858
 859   virtual bool IsRemote() const override { return false; }
 860
 861   already_AddRefed<AccAttributes> BundleFieldsForCache(
 862       uint64_t aCacheDomain, CacheUpdateType aUpdateType);
 863
 864  protected:
 865   virtual ~LocalAccessible();
 866
 867   /**
 868    * Return the accessible name provided by native markup. It doesn't take
 869    * into account ARIA markup used to specify the name.
 870    */
 871   virtual mozilla::a11y::ENameValueFlag NativeName(nsString& aName) const;
 872
 873   /**
 874    * Return the accessible description provided by native markup. It doesn't
 875    * take into account ARIA markup used to specify the description.
 876    */
 877   void NativeDescription(nsString& aDescription) const;
 878
 879   /**
 880    * Return object attributes provided by native markup. It doesn't take into
 881    * account ARIA.
 882    */
 883   virtual already_AddRefed<AccAttributes> NativeAttributes();
 884
 885   /**
 886    * The given attribute has the potential of changing the accessible's state.
 887    * This is used to capture the state before the attribute change and compare
 888    * it with the state after.
 889    */
 890   virtual bool AttributeChangesState(nsAtom* aAttribute);
 891
 892   /**
 893    * Notify accessible that a DOM attribute on its associated content has
 894    * changed. This allows the accessible to update its state and emit any
 895    * relevant events.
 896    */
 897   virtual void DOMAttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
 898                                    int32_t aModType,
 899                                    const nsAttrValue* aOldValue,
 900                                    uint64_t aOldState);
 901
 902   //////////////////////////////////////////////////////////////////////////////
 903   // Initializing, cache and tree traverse methods
 904
 905   /**
 906    * Destroy the object.
 907    */
 908   void LastRelease();
 909
 910   /**
 911    * Set accessible parent and index in parent.
 912    */
 913   void BindToParent(LocalAccessible* aParent, uint32_t aIndexInParent);
 914   void UnbindFromParent();
 915
 916   /**
 917    * Return sibling accessible at the given offset.
 918    */
 919   virtual LocalAccessible* GetSiblingAtOffset(int32_t aOffset,
 920                                               nsresult* aError = nullptr) const;
 921
 922   void ModifySubtreeContextFlags(uint32_t aContextFlags, bool aAdd);
 923
 924   /**
 925    * Flags used to describe the state of this accessible.
 926    */
 927   enum StateFlags {
 928     eIsDefunct = 1 << 0,        // accessible is defunct
 929     eIsNotInDocument = 1 << 1,  // accessible is not in document
 930     eSharedNode = 1 << 2,  // accessible shares DOM node from another accessible
 931     eNotNodeMapEntry = 1 << 3,   // accessible shouldn't be in document node map
 932     eGroupInfoDirty = 1 << 4,    // accessible needs to update group info
 933     eKidsMutating = 1 << 5,      // subtree is being mutated
 934     eIgnoreDOMUIEvent = 1 << 6,  // don't process DOM UI events for a11y events
 935     eRelocated = 1 << 7,         // accessible was moved in tree
 936     eNoKidsFromDOM = 1 << 8,     // accessible doesn't allow children from DOM
 937     eHasTextKids = 1 << 9,       // accessible have a text leaf in children
 938
 939     eLastStateFlag = eHasTextKids
 940   };
 941
 942   /**
 943    * Flags used for contextual information about the accessible.
 944    */
 945   enum ContextFlags {
 946     eHasNameDependent = 1 << 0,  // See HasNameDependent().
 947     eInsideAlert = 1 << 1,
 948     eHasDescriptionDependent = 1 << 2,  // See HasDescriptionDependent().
 949
 950     eLastContextFlag = eHasDescriptionDependent
 951   };
 952
 953  protected:
 954   //////////////////////////////////////////////////////////////////////////////
 955   // Miscellaneous helpers
 956
 957   /**
 958    * Return ARIA role (helper method).
 959    */
 960   mozilla::a11y::role ARIATransformRole(mozilla::a11y::role aRole) const;
 961
 962   //////////////////////////////////////////////////////////////////////////////
 963   // Name helpers
 964
 965   /**
 966    * Returns the accessible name specified by ARIA.
 967    */
 968   void ARIAName(nsString& aName) const;
 969
 970   /**
 971    * Returns the accessible description specified by ARIA.
 972    */
 973   void ARIADescription(nsString& aDescription) const;
 974
 975   /**
 976    * Returns the accessible name specified for this control using XUL
 977    * <label control="id" ...>.
 978    */
 979   static void NameFromAssociatedXULLabel(DocAccessible* aDocument,
 980                                          nsIContent* aElm, nsString& aName);
 981
 982   /**
 983    * Return the name for XUL element.
 984    */
 985   static void XULElmName(DocAccessible* aDocument, nsIContent* aElm,
 986                          nsString& aName);
 987
 988   // helper method to verify frames
 989   static nsresult GetFullKeyName(const nsAString& aModifierName,
 990                                  const nsAString& aKeyName,
 991                                  nsAString& aStringOut);
 992
 993   //////////////////////////////////////////////////////////////////////////////
 994   // Action helpers
 995
 996   /**
 997    * Prepares click action that will be invoked in timeout.
 998    *
 999    * @note  DoCommand() prepares an action in timeout because when action
1000    *  command opens a modal dialog/window, it won't return until the
1001    *  dialog/window is closed. If executing action command directly in
1002    *  nsIAccessible::DoAction() method, it will block AT tools (e.g. GOK) that
1003    *  invoke action of mozilla accessibles direclty (see bug 277888 for
1004    * details).
1005    *
1006    * @param  aContent      [in, optional] element to click
1007    * @param  aActionIndex  [in, optional] index of accessible action
1008    */
1009   void DoCommand(nsIContent* aContent = nullptr,
1010                  uint32_t aActionIndex = 0) const;
1011
1012   /**
1013    * Dispatch click event.
1014    */
1015   MOZ_CAN_RUN_SCRIPT
1016   virtual void DispatchClickEvent(nsIContent* aContent,
1017                                   uint32_t aActionIndex) const;
1018
1019   //////////////////////////////////////////////////////////////////////////////
1020   // Helpers
1021
1022   /**
1023    *  Get the container node for an atomic region, defined by aria-atomic="true"
1024    *  @return the container node
1025    */
1026   nsIContent* GetAtomicRegion() const;
1027
1028   /**
1029    * Return numeric value of the given ARIA attribute, NaN if not applicable.
1030    *
1031    * @param aARIAProperty  [in] the ARIA property we're using
1032    * @return  a numeric value
1033    */
1034   double AttrNumericValue(nsAtom* aARIAAttr) const;
1035
1036   /**
1037    * Return the action rule based on ARIA enum constants EActionRule
1038    * (see ARIAMap.h). Used by ActionCount() and ActionNameAt().
1039    */
1040   uint32_t GetActionRule() const;
1041
1042   /**
1043    * Return group info.
1044    */
1045   AccGroupInfo* GetGroupInfo() const;
1046
1047   /**
1048    * Push fields to cache.
1049    * aCacheDomain - describes which fields to bundle and ultimately send
1050    * aUpdate - describes whether this is an initial or subsequent update
1051    */
1052   void SendCache(uint64_t aCacheDomain, CacheUpdateType aUpdate);
1053
1054   // Data Members
1055   nsCOMPtr<nsIContent> mContent;
1056   RefPtr<DocAccessible> mDoc;
1057
1058   LocalAccessible* mParent;
1059   nsTArray<LocalAccessible*> mChildren;
1060   int32_t mIndexInParent;
1061   Maybe<nsRect> mBounds;
1062
1063   static const uint8_t kStateFlagsBits = 11;
1064   static const uint8_t kContextFlagsBits = 3;
1065
1066   /**
1067    * Keep in sync with StateFlags, ContextFlags, and AccTypes.
1068    */
1069   mutable uint32_t mStateFlags : kStateFlagsBits;
1070   uint32_t mContextFlags : kContextFlagsBits;
1071   uint32_t mReorderEventTarget : 1;
1072   uint32_t mShowEventTarget : 1;
1073   uint32_t mHideEventTarget : 1;
1074
1075   void StaticAsserts() const;
1076
1077 #ifdef A11Y_LOG
1078   friend void logging::Tree(const char* aTitle, const char* aMsgText,
1079                             LocalAccessible* aRoot,
1080                             logging::GetTreePrefix aPrefixFunc,
1081                             void* aGetTreePrefixData);
1082   friend void logging::TreeSize(const char* aTitle, const char* aMsgText,
1083                                 LocalAccessible* aRoot);
1084 #endif
1085   friend class DocAccessible;
1086   friend class xpcAccessible;
1087   friend class TreeMutation;
1088
1089   UniquePtr<mozilla::a11y::EmbeddedObjCollector> mEmbeddedObjCollector;
1090   int32_t mIndexOfEmbeddedChild;
1091
1092   friend class EmbeddedObjCollector;
1093
1094   union {
1095     AccGroupInfo* groupInfo;
1096     RemoteAccessible* proxy;
1097   } mutable mBits;
1098   friend class AccGroupInfo;
1099
1100  private:
1101   LocalAccessible() = delete;
1102   LocalAccessible(const LocalAccessible&) = delete;
1103   LocalAccessible& operator=(const LocalAccessible&) = delete;
1104 };
1105
1106 NS_DEFINE_STATIC_IID_ACCESSOR(LocalAccessible, NS_ACCESSIBLE_IMPL_IID)
1107
1108 ////////////////////////////////////////////////////////////////////////////////
1109 // LocalAccessible downcasting method
1110
1111 inline LocalAccessible* Accessible::AsLocal() {
1112   return IsLocal() ? static_cast<LocalAccessible*>(this) : nullptr;
1113 }
1114
1115 /**
1116  * Represent key binding associated with accessible (such as access key and
1117  * global keyboard shortcuts).
1118  */
1119 class KeyBinding {
1120  public:
1121   /**
1122    * Modifier mask values.
1123    */
1124   static const uint32_t kShift = 1;
1125   static const uint32_t kControl = 2;
1126   static const uint32_t kAlt = 4;
1127   static const uint32_t kMeta = 8;
1128   static const uint32_t kOS = 16;
1129
1130   static uint32_t AccelModifier();
1131
1132   KeyBinding() : mKey(0), mModifierMask(0) {}
1133   KeyBinding(uint32_t aKey, uint32_t aModifierMask)
1134       : mKey(aKey), mModifierMask(aModifierMask) {}
1135
1136   inline bool IsEmpty() const { return !mKey; }
1137   inline uint32_t Key() const { return mKey; }
1138   inline uint32_t ModifierMask() const { return mModifierMask; }
1139
1140   enum Format { ePlatformFormat, eAtkFormat };
1141
1142   /**
1143    * Return formatted string for this key binding depending on the given format.
1144    */
1145   inline void ToString(nsAString& aValue,
1146                        Format aFormat = ePlatformFormat) const {
1147     aValue.Truncate();
1148     AppendToString(aValue, aFormat);
1149   }
1150   inline void AppendToString(nsAString& aValue,
1151                              Format aFormat = ePlatformFormat) const {
1152     if (mKey) {
1153       if (aFormat == ePlatformFormat) {
1154         ToPlatformFormat(aValue);
1155       } else {
1156         ToAtkFormat(aValue);
1157       }
1158     }
1159   }
1160
1161  private:
1162   void ToPlatformFormat(nsAString& aValue) const;
1163   void ToAtkFormat(nsAString& aValue) const;
1164
1165   uint32_t mKey;
1166   uint32_t mModifierMask;
1167 };
1168
1169 }  // namespace a11y
1170 }  // namespace mozilla
1171
1172 #endif