accessible/base/AccEvent.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 _AccEvent_H_
   7 #define _AccEvent_H_
   8
   9 #include "nsIAccessibleEvent.h"
  10
  11 #include "mozilla/a11y/LocalAccessible.h"
  12
  13 class nsEventShell;
  14 namespace mozilla {
  15
  16 namespace dom {
  17 class Selection;
  18 }
  19
  20 namespace a11y {
  21
  22 class DocAccessible;
  23 class EventQueue;
  24 class TextRange;
  25
  26 // Constants used to point whether the event is from user input.
  27 enum EIsFromUserInput {
  28   // eNoUserInput: event is not from user input
  29   eNoUserInput = 0,
  30   // eFromUserInput: event is from user input
  31   eFromUserInput = 1,
  32   // eAutoDetect: the value should be obtained from event state manager
  33   eAutoDetect = -1
  34 };
  35
  36 /**
  37  * Generic accessible event.
  38  */
  39 class AccEvent {
  40  public:
  41   // Rule for accessible events.
  42   // The rule will be applied when flushing pending events.
  43   enum EEventRule {
  44     // eAllowDupes : More than one event of the same type is allowed.
  45     //    This event will always be emitted. This flag is used for events that
  46     //    don't support coalescence.
  47     eAllowDupes,
  48
  49     // eCoalesceReorder : For reorder events from the same subtree or the same
  50     //    node, only the umbrella event on the ancestor will be emitted.
  51     eCoalesceReorder,
  52
  53     // eCoalesceOfSameType : For events of the same type, only the newest event
  54     // will be processed.
  55     eCoalesceOfSameType,
  56
  57     // eCoalesceSelectionChange: coalescence of selection change events.
  58     eCoalesceSelectionChange,
  59
  60     // eCoalesceStateChange: coalesce state change events.
  61     eCoalesceStateChange,
  62
  63     // eCoalesceTextSelChange: coalescence of text selection change events.
  64     eCoalesceTextSelChange,
  65
  66     // eRemoveDupes : For repeat events, only the newest event in queue
  67     //    will be emitted.
  68     eRemoveDupes,
  69
  70     // eDoNotEmit : This event is confirmed as a duplicate, do not emit it.
  71     eDoNotEmit
  72   };
  73
  74   // Initialize with an accessible.
  75   AccEvent(uint32_t aEventType, LocalAccessible* aAccessible,
  76            EIsFromUserInput aIsFromUserInput = eAutoDetect,
  77            EEventRule aEventRule = eRemoveDupes);
  78
  79   // AccEvent
  80   uint32_t GetEventType() const { return mEventType; }
  81   EEventRule GetEventRule() const { return mEventRule; }
  82   bool IsFromUserInput() const { return mIsFromUserInput; }
  83   EIsFromUserInput FromUserInput() const {
  84     return static_cast<EIsFromUserInput>(mIsFromUserInput);
  85   }
  86
  87   LocalAccessible* GetAccessible() const { return mAccessible; }
  88   DocAccessible* Document() const { return mAccessible->Document(); }
  89
  90   /**
  91    * Down casting.
  92    */
  93   enum EventGroup {
  94     eGenericEvent,
  95     eStateChangeEvent,
  96     eTextChangeEvent,
  97     eTreeMutationEvent,
  98     eMutationEvent,
  99     eReorderEvent,
 100     eHideEvent,
 101     eShowEvent,
 102     eCaretMoveEvent,
 103     eTextSelChangeEvent,
 104     eSelectionChangeEvent,
 105     eTableChangeEvent,
 106     eVirtualCursorChangeEvent,
 107     eObjectAttrChangedEvent,
 108     eScrollingEvent,
 109     eAnnouncementEvent,
 110   };
 111
 112   static const EventGroup kEventGroup = eGenericEvent;
 113   virtual unsigned int GetEventGroups() const { return 1U << eGenericEvent; }
 114
 115   /**
 116    * Reference counting and cycle collection.
 117    */
 118   NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(AccEvent)
 119   NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(AccEvent)
 120
 121  protected:
 122   virtual ~AccEvent() {}
 123
 124   bool mIsFromUserInput;
 125   uint32_t mEventType;
 126   EEventRule mEventRule;
 127   RefPtr<LocalAccessible> mAccessible;
 128
 129   friend class EventQueue;
 130   friend class EventTree;
 131   friend class ::nsEventShell;
 132   friend class NotificationController;
 133 };
 134
 135 /**
 136  * Accessible state change event.
 137  */
 138 class AccStateChangeEvent : public AccEvent {
 139  public:
 140   AccStateChangeEvent(LocalAccessible* aAccessible, uint64_t aState,
 141                       bool aIsEnabled,
 142                       EIsFromUserInput aIsFromUserInput = eAutoDetect)
 143       : AccEvent(nsIAccessibleEvent::EVENT_STATE_CHANGE, aAccessible,
 144                  aIsFromUserInput, eCoalesceStateChange),
 145         mState(aState),
 146         mIsEnabled(aIsEnabled) {}
 147
 148   AccStateChangeEvent(LocalAccessible* aAccessible, uint64_t aState)
 149       : AccEvent(::nsIAccessibleEvent::EVENT_STATE_CHANGE, aAccessible,
 150                  eAutoDetect, eCoalesceStateChange),
 151         mState(aState) {
 152     mIsEnabled = (mAccessible->State() & mState) != 0;
 153   }
 154
 155   // AccEvent
 156   static const EventGroup kEventGroup = eStateChangeEvent;
 157   virtual unsigned int GetEventGroups() const override {
 158     return AccEvent::GetEventGroups() | (1U << eStateChangeEvent);
 159   }
 160
 161   // AccStateChangeEvent
 162   uint64_t GetState() const { return mState; }
 163   bool IsStateEnabled() const { return mIsEnabled; }
 164
 165  private:
 166   uint64_t mState;
 167   bool mIsEnabled;
 168
 169   friend class EventQueue;
 170 };
 171
 172 /**
 173  * Accessible text change event.
 174  */
 175 class AccTextChangeEvent : public AccEvent {
 176  public:
 177   AccTextChangeEvent(LocalAccessible* aAccessible, int32_t aStart,
 178                      const nsAString& aModifiedText, bool aIsInserted,
 179                      EIsFromUserInput aIsFromUserInput = eAutoDetect);
 180
 181   // AccEvent
 182   static const EventGroup kEventGroup = eTextChangeEvent;
 183   virtual unsigned int GetEventGroups() const override {
 184     return AccEvent::GetEventGroups() | (1U << eTextChangeEvent);
 185   }
 186
 187   // AccTextChangeEvent
 188   int32_t GetStartOffset() const { return mStart; }
 189   uint32_t GetLength() const { return mModifiedText.Length(); }
 190   bool IsTextInserted() const { return mIsInserted; }
 191   void GetModifiedText(nsAString& aModifiedText) {
 192     aModifiedText = mModifiedText;
 193   }
 194   const nsString& ModifiedText() const { return mModifiedText; }
 195
 196  private:
 197   int32_t mStart;
 198   bool mIsInserted;
 199   nsString mModifiedText;
 200
 201   friend class EventTree;
 202   friend class NotificationController;
 203 };
 204
 205 /**
 206  * A base class for events related to tree mutation, either an AccMutation
 207  * event, or an AccReorderEvent.
 208  */
 209 class AccTreeMutationEvent : public AccEvent {
 210  public:
 211   AccTreeMutationEvent(uint32_t aEventType, LocalAccessible* aTarget)
 212       : AccEvent(aEventType, aTarget, eAutoDetect, eCoalesceReorder),
 213         mGeneration(0) {}
 214
 215   // Event
 216   static const EventGroup kEventGroup = eTreeMutationEvent;
 217   virtual unsigned int GetEventGroups() const override {
 218     return AccEvent::GetEventGroups() | (1U << eTreeMutationEvent);
 219   }
 220
 221   void SetNextEvent(AccTreeMutationEvent* aNext) { mNextEvent = aNext; }
 222   void SetPrevEvent(AccTreeMutationEvent* aPrev) { mPrevEvent = aPrev; }
 223   AccTreeMutationEvent* NextEvent() const { return mNextEvent; }
 224   AccTreeMutationEvent* PrevEvent() const { return mPrevEvent; }
 225
 226   /**
 227    * A sequence number to know when this event was fired.
 228    */
 229   uint32_t EventGeneration() const { return mGeneration; }
 230   void SetEventGeneration(uint32_t aGeneration) { mGeneration = aGeneration; }
 231
 232  private:
 233   RefPtr<AccTreeMutationEvent> mNextEvent;
 234   RefPtr<AccTreeMutationEvent> mPrevEvent;
 235   uint32_t mGeneration;
 236 };
 237
 238 /**
 239  * Base class for show and hide accessible events.
 240  */
 241 class AccMutationEvent : public AccTreeMutationEvent {
 242  public:
 243   AccMutationEvent(uint32_t aEventType, LocalAccessible* aTarget)
 244       : AccTreeMutationEvent(aEventType, aTarget) {
 245     // Don't coalesce these since they are coalesced by reorder event. Coalesce
 246     // contained text change events.
 247     mParent = mAccessible->LocalParent();
 248   }
 249   virtual ~AccMutationEvent() {}
 250
 251   // Event
 252   static const EventGroup kEventGroup = eMutationEvent;
 253   virtual unsigned int GetEventGroups() const override {
 254     return AccTreeMutationEvent::GetEventGroups() | (1U << eMutationEvent);
 255   }
 256
 257   // MutationEvent
 258   bool IsShow() const { return mEventType == nsIAccessibleEvent::EVENT_SHOW; }
 259   bool IsHide() const { return mEventType == nsIAccessibleEvent::EVENT_HIDE; }
 260
 261   LocalAccessible* LocalParent() const { return mParent; }
 262
 263  protected:
 264   RefPtr<LocalAccessible> mParent;
 265   RefPtr<AccTextChangeEvent> mTextChangeEvent;
 266
 267   friend class EventTree;
 268   friend class NotificationController;
 269 };
 270
 271 /**
 272  * Accessible hide event.
 273  */
 274 class AccHideEvent : public AccMutationEvent {
 275  public:
 276   explicit AccHideEvent(LocalAccessible* aTarget, bool aNeedsShutdown = true);
 277
 278   // Event
 279   static const EventGroup kEventGroup = eHideEvent;
 280   virtual unsigned int GetEventGroups() const override {
 281     return AccMutationEvent::GetEventGroups() | (1U << eHideEvent);
 282   }
 283
 284   // AccHideEvent
 285   LocalAccessible* TargetParent() const { return mParent; }
 286   LocalAccessible* TargetNextSibling() const { return mNextSibling; }
 287   LocalAccessible* TargetPrevSibling() const { return mPrevSibling; }
 288   bool NeedsShutdown() const { return mNeedsShutdown; }
 289
 290  protected:
 291   bool mNeedsShutdown;
 292   RefPtr<LocalAccessible> mNextSibling;
 293   RefPtr<LocalAccessible> mPrevSibling;
 294
 295   friend class EventTree;
 296   friend class NotificationController;
 297 };
 298
 299 /**
 300  * Accessible show event.
 301  */
 302 class AccShowEvent : public AccMutationEvent {
 303  public:
 304   explicit AccShowEvent(LocalAccessible* aTarget)
 305       : AccMutationEvent(::nsIAccessibleEvent::EVENT_SHOW, aTarget) {}
 306
 307   // Event
 308   static const EventGroup kEventGroup = eShowEvent;
 309   virtual unsigned int GetEventGroups() const override {
 310     return AccMutationEvent::GetEventGroups() | (1U << eShowEvent);
 311   }
 312 };
 313
 314 /**
 315  * Class for reorder accessible event. Takes care about
 316  */
 317 class AccReorderEvent : public AccTreeMutationEvent {
 318  public:
 319   explicit AccReorderEvent(LocalAccessible* aTarget)
 320       : AccTreeMutationEvent(::nsIAccessibleEvent::EVENT_REORDER, aTarget) {}
 321   virtual ~AccReorderEvent() {}
 322
 323   // Event
 324   static const EventGroup kEventGroup = eReorderEvent;
 325   virtual unsigned int GetEventGroups() const override {
 326     return AccTreeMutationEvent::GetEventGroups() | (1U << eReorderEvent);
 327   }
 328
 329   /*
 330    * Make this an inner reorder event that is coalesced into
 331    * a reorder event of an ancestor.
 332    */
 333   void SetInner() { mEventType = ::nsIAccessibleEvent::EVENT_INNER_REORDER; }
 334 };
 335
 336 /**
 337  * Accessible caret move event.
 338  */
 339 class AccCaretMoveEvent : public AccEvent {
 340  public:
 341   AccCaretMoveEvent(LocalAccessible* aAccessible, int32_t aCaretOffset,
 342                     bool aIsSelectionCollapsed, bool aIsAtEndOfLine,
 343                     int32_t aGranularity,
 344                     EIsFromUserInput aIsFromUserInput = eAutoDetect)
 345       : AccEvent(::nsIAccessibleEvent::EVENT_TEXT_CARET_MOVED, aAccessible,
 346                  aIsFromUserInput),
 347         mCaretOffset(aCaretOffset),
 348         mIsSelectionCollapsed(aIsSelectionCollapsed),
 349         mIsAtEndOfLine(aIsAtEndOfLine),
 350         mGranularity(aGranularity) {}
 351   virtual ~AccCaretMoveEvent() {}
 352
 353   // AccEvent
 354   static const EventGroup kEventGroup = eCaretMoveEvent;
 355   virtual unsigned int GetEventGroups() const override {
 356     return AccEvent::GetEventGroups() | (1U << eCaretMoveEvent);
 357   }
 358
 359   // AccCaretMoveEvent
 360   int32_t GetCaretOffset() const { return mCaretOffset; }
 361
 362   bool IsSelectionCollapsed() const { return mIsSelectionCollapsed; }
 363   bool IsAtEndOfLine() { return mIsAtEndOfLine; }
 364
 365   int32_t GetGranularity() const { return mGranularity; }
 366
 367  private:
 368   int32_t mCaretOffset;
 369
 370   bool mIsSelectionCollapsed;
 371   bool mIsAtEndOfLine;
 372   int32_t mGranularity;
 373 };
 374
 375 /**
 376  * Accessible text selection change event.
 377  */
 378 class AccTextSelChangeEvent : public AccEvent {
 379  public:
 380   AccTextSelChangeEvent(HyperTextAccessible* aTarget,
 381                         dom::Selection* aSelection, int32_t aReason,
 382                         int32_t aGranularity);
 383   virtual ~AccTextSelChangeEvent();
 384
 385   // AccEvent
 386   static const EventGroup kEventGroup = eTextSelChangeEvent;
 387   virtual unsigned int GetEventGroups() const override {
 388     return AccEvent::GetEventGroups() | (1U << eTextSelChangeEvent);
 389   }
 390
 391   // AccTextSelChangeEvent
 392
 393   /**
 394    * Return true if the text selection change wasn't caused by pure caret move.
 395    */
 396   bool IsCaretMoveOnly() const;
 397
 398   int32_t GetGranularity() const { return mGranularity; }
 399
 400   /**
 401    * Return selection ranges in document/control.
 402    */
 403   void SelectionRanges(nsTArray<a11y::TextRange>* aRanges) const;
 404
 405  private:
 406   RefPtr<dom::Selection> mSel;
 407   int32_t mReason;
 408   int32_t mGranularity;
 409
 410   friend class EventQueue;
 411   friend class SelectionManager;
 412 };
 413
 414 /**
 415  * Accessible widget selection change event.
 416  */
 417 class AccSelChangeEvent : public AccEvent {
 418  public:
 419   enum SelChangeType { eSelectionAdd, eSelectionRemove };
 420
 421   AccSelChangeEvent(LocalAccessible* aWidget, LocalAccessible* aItem,
 422                     SelChangeType aSelChangeType);
 423
 424   virtual ~AccSelChangeEvent() {}
 425
 426   // AccEvent
 427   static const EventGroup kEventGroup = eSelectionChangeEvent;
 428   virtual unsigned int GetEventGroups() const override {
 429     return AccEvent::GetEventGroups() | (1U << eSelectionChangeEvent);
 430   }
 431
 432   // AccSelChangeEvent
 433   LocalAccessible* Widget() const { return mWidget; }
 434
 435  private:
 436   RefPtr<LocalAccessible> mWidget;
 437   RefPtr<LocalAccessible> mItem;
 438   SelChangeType mSelChangeType;
 439   uint32_t mPreceedingCount;
 440   AccSelChangeEvent* mPackedEvent;
 441
 442   friend class EventQueue;
 443 };
 444
 445 /**
 446  * Accessible table change event.
 447  */
 448 class AccTableChangeEvent : public AccEvent {
 449  public:
 450   AccTableChangeEvent(LocalAccessible* aAccessible, uint32_t aEventType,
 451                       int32_t aRowOrColIndex, int32_t aNumRowsOrCols);
 452
 453   // AccEvent
 454   static const EventGroup kEventGroup = eTableChangeEvent;
 455   virtual unsigned int GetEventGroups() const override {
 456     return AccEvent::GetEventGroups() | (1U << eTableChangeEvent);
 457   }
 458
 459   // AccTableChangeEvent
 460   uint32_t GetIndex() const { return mRowOrColIndex; }
 461   uint32_t GetCount() const { return mNumRowsOrCols; }
 462
 463  private:
 464   uint32_t mRowOrColIndex;  // the start row/column after which the rows are
 465                             // inserted/deleted.
 466   uint32_t mNumRowsOrCols;  // the number of inserted/deleted rows/columns
 467 };
 468
 469 /**
 470  * Accessible virtual cursor change event.
 471  */
 472 class AccVCChangeEvent : public AccEvent {
 473  public:
 474   AccVCChangeEvent(LocalAccessible* aAccessible,
 475                    LocalAccessible* aOldAccessible,
 476                    LocalAccessible* aNewAccessible, int16_t aReason,
 477                    EIsFromUserInput aIsFromUserInput = eFromUserInput);
 478
 479   virtual ~AccVCChangeEvent() {}
 480
 481   // AccEvent
 482   static const EventGroup kEventGroup = eVirtualCursorChangeEvent;
 483   virtual unsigned int GetEventGroups() const override {
 484     return AccEvent::GetEventGroups() | (1U << eVirtualCursorChangeEvent);
 485   }
 486
 487   // AccVCChangeEvent
 488   LocalAccessible* OldAccessible() const { return mOldAccessible; }
 489   LocalAccessible* NewAccessible() const { return mNewAccessible; }
 490   int32_t Reason() const { return mReason; }
 491
 492  private:
 493   RefPtr<LocalAccessible> mOldAccessible;
 494   RefPtr<LocalAccessible> mNewAccessible;
 495   int16_t mReason;
 496 };
 497
 498 /**
 499  * Accessible object attribute changed event.
 500  */
 501 class AccObjectAttrChangedEvent : public AccEvent {
 502  public:
 503   AccObjectAttrChangedEvent(LocalAccessible* aAccessible, nsAtom* aAttribute)
 504       : AccEvent(::nsIAccessibleEvent::EVENT_OBJECT_ATTRIBUTE_CHANGED,
 505                  aAccessible),
 506         mAttribute(aAttribute) {}
 507
 508   // AccEvent
 509   static const EventGroup kEventGroup = eObjectAttrChangedEvent;
 510   virtual unsigned int GetEventGroups() const override {
 511     return AccEvent::GetEventGroups() | (1U << eObjectAttrChangedEvent);
 512   }
 513
 514   // AccObjectAttrChangedEvent
 515   nsAtom* GetAttribute() const { return mAttribute; }
 516
 517  private:
 518   RefPtr<nsAtom> mAttribute;
 519
 520   virtual ~AccObjectAttrChangedEvent() {}
 521 };
 522
 523 /**
 524  * Accessible scroll event.
 525  */
 526 class AccScrollingEvent : public AccEvent {
 527  public:
 528   AccScrollingEvent(uint32_t aEventType, LocalAccessible* aAccessible,
 529                     uint32_t aScrollX, uint32_t aScrollY, uint32_t aMaxScrollX,
 530                     uint32_t aMaxScrollY)
 531       : AccEvent(aEventType, aAccessible),
 532         mScrollX(aScrollX),
 533         mScrollY(aScrollY),
 534         mMaxScrollX(aMaxScrollX),
 535         mMaxScrollY(aMaxScrollY) {}
 536
 537   virtual ~AccScrollingEvent() {}
 538
 539   // AccEvent
 540   static const EventGroup kEventGroup = eScrollingEvent;
 541   virtual unsigned int GetEventGroups() const override {
 542     return AccEvent::GetEventGroups() | (1U << eScrollingEvent);
 543   }
 544
 545   // The X scrolling offset of the container when the event was fired.
 546   uint32_t ScrollX() { return mScrollX; }
 547   // The Y scrolling offset of the container when the event was fired.
 548   uint32_t ScrollY() { return mScrollY; }
 549   // The max X offset of the container.
 550   uint32_t MaxScrollX() { return mMaxScrollX; }
 551   // The max Y offset of the container.
 552   uint32_t MaxScrollY() { return mMaxScrollY; }
 553
 554  private:
 555   uint32_t mScrollX;
 556   uint32_t mScrollY;
 557   uint32_t mMaxScrollX;
 558   uint32_t mMaxScrollY;
 559 };
 560
 561 /**
 562  * Accessible announcement event.
 563  */
 564 class AccAnnouncementEvent : public AccEvent {
 565  public:
 566   AccAnnouncementEvent(LocalAccessible* aAccessible,
 567                        const nsAString& aAnnouncement, uint16_t aPriority)
 568       : AccEvent(nsIAccessibleEvent::EVENT_ANNOUNCEMENT, aAccessible),
 569         mAnnouncement(aAnnouncement),
 570         mPriority(aPriority) {}
 571
 572   virtual ~AccAnnouncementEvent() {}
 573
 574   // AccEvent
 575   static const EventGroup kEventGroup = eAnnouncementEvent;
 576   virtual unsigned int GetEventGroups() const override {
 577     return AccEvent::GetEventGroups() | (1U << eAnnouncementEvent);
 578   }
 579
 580   const nsString& Announcement() const { return mAnnouncement; }
 581
 582   uint16_t Priority() { return mPriority; }
 583
 584  private:
 585   nsString mAnnouncement;
 586   uint16_t mPriority;
 587 };
 588
 589 /**
 590  * Downcast the generic accessible event object to derived type.
 591  */
 592 class downcast_accEvent {
 593  public:
 594   explicit downcast_accEvent(AccEvent* e) : mRawPtr(e) {}
 595
 596   template <class Destination>
 597   operator Destination*() {
 598     if (!mRawPtr) return nullptr;
 599
 600     return mRawPtr->GetEventGroups() & (1U << Destination::kEventGroup)
 601                ? static_cast<Destination*>(mRawPtr)
 602                : nullptr;
 603   }
 604
 605  private:
 606   AccEvent* mRawPtr;
 607 };
 608
 609 /**
 610  * Return a new xpcom accessible event for the given internal one.
 611  */
 612 already_AddRefed<nsIAccessibleEvent> MakeXPCEvent(AccEvent* aEvent);
 613
 614 }  // namespace a11y
 615 }  // namespace mozilla
 616
 617 #endif