The Tor Browser: comparison accessible/src/base/AccEvent.h

--1:000000000000
+:9574fa699f63
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef _AccEvent_H_
+#define _AccEvent_H_
+#include "nsIAccessibleEvent.h"
+#include "mozilla/a11y/Accessible.h"
+namespace mozilla {
+namespace dom {
+class Selection;
+}
+namespace a11y {
+class DocAccessible;
+// Constants used to point whether the event is from user input.
+enum EIsFromUserInput
+{
+// eNoUserInput: event is not from user input
+eNoUserInput = 0,
+// eFromUserInput: event is from user input
+eFromUserInput = 1,
+// eAutoDetect: the value should be obtained from event state manager
+eAutoDetect = -1
+};
+/**
+* Generic accessible event.
+*/
+class AccEvent
+{
+public:
+// Rule for accessible events.
+// The rule will be applied when flushing pending events.
+enum EEventRule {
+// eAllowDupes : More than one event of the same type is allowed.
+//    This event will always be emitted. This flag is used for events that
+//    don't support coalescence.
+eAllowDupes,
+// eCoalesceReorder : For reorder events from the same subtree or the same
+//    node, only the umbrella event on the ancestor will be emitted.
+eCoalesceReorder,
+// eCoalesceMutationTextChange : coalesce text change events caused by
+// tree mutations of the same tree level.
+eCoalesceMutationTextChange,
+// eCoalesceOfSameType : For events of the same type, only the newest event
+// will be processed.
+eCoalesceOfSameType,
+// eCoalesceSelectionChange: coalescence of selection change events.
+eCoalesceSelectionChange,
+// eCoalesceStateChange: coalesce state change events.
+eCoalesceStateChange,
+// eCoalesceTextSelChange: coalescence of text selection change events.
+eCoalesceTextSelChange,
+// eRemoveDupes : For repeat events, only the newest event in queue
+//    will be emitted.
+eRemoveDupes,
+// eDoNotEmit : This event is confirmed as a duplicate, do not emit it.
+eDoNotEmit
+};
+// Initialize with an nsIAccessible
+AccEvent(uint32_t aEventType, Accessible* aAccessible,
+EIsFromUserInput aIsFromUserInput = eAutoDetect,
+EEventRule aEventRule = eRemoveDupes);
+virtual ~AccEvent() {}
+// AccEvent
+uint32_t GetEventType() const { return mEventType; }
+EEventRule GetEventRule() const { return mEventRule; }
+bool IsFromUserInput() const { return mIsFromUserInput; }
+EIsFromUserInput FromUserInput() const
+{ return static_cast<EIsFromUserInput>(mIsFromUserInput); }
+Accessible* GetAccessible() const { return mAccessible; }
+DocAccessible* GetDocAccessible() const { return mAccessible->Document(); }
+/**
+* Down casting.
+*/
+enum EventGroup {
+eGenericEvent,
+eStateChangeEvent,
+eTextChangeEvent,
+eMutationEvent,
+eReorderEvent,
+eHideEvent,
+eShowEvent,
+eCaretMoveEvent,
+eTextSelChangeEvent,
+eSelectionChangeEvent,
+eTableChangeEvent,
+eVirtualCursorChangeEvent
+};
+static const EventGroup kEventGroup = eGenericEvent;
+virtual unsigned int GetEventGroups() const
+{
+return 1U << eGenericEvent;
+}
+/**
+* Reference counting and cycle collection.
+*/
+NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(AccEvent)
+NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(AccEvent)
+protected:
+bool mIsFromUserInput;
+uint32_t mEventType;
+EEventRule mEventRule;
+nsRefPtr<Accessible> mAccessible;
+friend class EventQueue;
+friend class AccReorderEvent;
+};
+/**
+* Accessible state change event.
+*/
+class AccStateChangeEvent: public AccEvent
+{
+public:
+AccStateChangeEvent(Accessible* aAccessible, uint64_t aState,
+bool aIsEnabled,
+EIsFromUserInput aIsFromUserInput = eAutoDetect) :
+AccEvent(nsIAccessibleEvent::EVENT_STATE_CHANGE, aAccessible,
+aIsFromUserInput, eCoalesceStateChange),
+mState(aState), mIsEnabled(aIsEnabled) { }
+AccStateChangeEvent(Accessible* aAccessible, uint64_t aState) :
+AccEvent(::nsIAccessibleEvent::EVENT_STATE_CHANGE, aAccessible,
+eAutoDetect, eCoalesceStateChange), mState(aState)
+{ mIsEnabled = (mAccessible->State() & mState) != 0; }
+// AccEvent
+static const EventGroup kEventGroup = eStateChangeEvent;
+virtual unsigned int GetEventGroups() const
+{
+return AccEvent::GetEventGroups() | (1U << eStateChangeEvent);
+}
+// AccStateChangeEvent
+uint64_t GetState() const { return mState; }
+bool IsStateEnabled() const { return mIsEnabled; }
+private:
+uint64_t mState;
+bool mIsEnabled;
+friend class EventQueue;
+};
+/**
+* Accessible text change event.
+*/
+class AccTextChangeEvent: public AccEvent
+{
+public:
+AccTextChangeEvent(Accessible* aAccessible, int32_t aStart,
+const nsAString& aModifiedText, bool aIsInserted,
+EIsFromUserInput aIsFromUserInput = eAutoDetect);
+// AccEvent
+static const EventGroup kEventGroup = eTextChangeEvent;
+virtual unsigned int GetEventGroups() const
+{
+return AccEvent::GetEventGroups() | (1U << eTextChangeEvent);
+}
+// AccTextChangeEvent
+int32_t GetStartOffset() const { return mStart; }
+uint32_t GetLength() const { return mModifiedText.Length(); }
+bool IsTextInserted() const { return mIsInserted; }
+void GetModifiedText(nsAString& aModifiedText)
+{ aModifiedText = mModifiedText; }
+private:
+int32_t mStart;
+bool mIsInserted;
+nsString mModifiedText;
+friend class EventQueue;
+friend class AccReorderEvent;
+};
+/**
+* Base class for show and hide accessible events.
+*/
+class AccMutationEvent: public AccEvent
+{
+public:
+AccMutationEvent(uint32_t aEventType, Accessible* aTarget,
+nsINode* aTargetNode) :
+AccEvent(aEventType, aTarget, eAutoDetect, eCoalesceMutationTextChange)
+{
+// Don't coalesce these since they are coalesced by reorder event. Coalesce
+// contained text change events.
+mParent = mAccessible->Parent();
+}
+virtual ~AccMutationEvent() { }
+// Event
+static const EventGroup kEventGroup = eMutationEvent;
+virtual unsigned int GetEventGroups() const
+{
+return AccEvent::GetEventGroups() | (1U << eMutationEvent);
+}
+// MutationEvent
+bool IsShow() const { return mEventType == nsIAccessibleEvent::EVENT_SHOW; }
+bool IsHide() const { return mEventType == nsIAccessibleEvent::EVENT_HIDE; }
+protected:
+nsCOMPtr<nsINode> mNode;
+nsRefPtr<Accessible> mParent;
+nsRefPtr<AccTextChangeEvent> mTextChangeEvent;
+friend class EventQueue;
+};
+/**
+* Accessible hide event.
+*/
+class AccHideEvent: public AccMutationEvent
+{
+public:
+AccHideEvent(Accessible* aTarget, nsINode* aTargetNode);
+// Event
+static const EventGroup kEventGroup = eHideEvent;
+virtual unsigned int GetEventGroups() const
+{
+return AccMutationEvent::GetEventGroups() | (1U << eHideEvent);
+}
+// AccHideEvent
+Accessible* TargetParent() const { return mParent; }
+Accessible* TargetNextSibling() const { return mNextSibling; }
+Accessible* TargetPrevSibling() const { return mPrevSibling; }
+protected:
+nsRefPtr<Accessible> mNextSibling;
+nsRefPtr<Accessible> mPrevSibling;
+friend class EventQueue;
+};
+/**
+* Accessible show event.
+*/
+class AccShowEvent: public AccMutationEvent
+{
+public:
+AccShowEvent(Accessible* aTarget, nsINode* aTargetNode);
+// Event
+static const EventGroup kEventGroup = eShowEvent;
+virtual unsigned int GetEventGroups() const
+{
+return AccMutationEvent::GetEventGroups() | (1U << eShowEvent);
+}
+};
+/**
+* Class for reorder accessible event. Takes care about
+*/
+class AccReorderEvent : public AccEvent
+{
+public:
+AccReorderEvent(Accessible* aTarget) :
+AccEvent(::nsIAccessibleEvent::EVENT_REORDER, aTarget,
+eAutoDetect, eCoalesceReorder) { }
+virtual ~AccReorderEvent() { }
+// Event
+static const EventGroup kEventGroup = eReorderEvent;
+virtual unsigned int GetEventGroups() const
+{
+return AccEvent::GetEventGroups() | (1U << eReorderEvent);
+}
+/**
+* Get connected with mutation event.
+*/
+void AddSubMutationEvent(AccMutationEvent* aEvent)
+{ mDependentEvents.AppendElement(aEvent); }
+/**
+* Do not emit the reorder event and its connected mutation events.
+*/
+void DoNotEmitAll()
+{
+mEventRule = AccEvent::eDoNotEmit;
+uint32_t eventsCount = mDependentEvents.Length();
+for (uint32_t idx = 0; idx < eventsCount; idx++)
+mDependentEvents[idx]->mEventRule = AccEvent::eDoNotEmit;
+}
+/**
+* Return true if the given accessible is a target of connected mutation
+* event.
+*/
+uint32_t IsShowHideEventTarget(const Accessible* aTarget) const;
+protected:
+/**
+* Show and hide events causing this reorder event.
+*/
+nsTArray<AccMutationEvent*> mDependentEvents;
+friend class EventQueue;
+};
+/**
+* Accessible caret move event.
+*/
+class AccCaretMoveEvent: public AccEvent
+{
+public:
+AccCaretMoveEvent(Accessible* aAccessible, int32_t aCaretOffset,
+EIsFromUserInput aIsFromUserInput = eAutoDetect) :
+AccEvent(::nsIAccessibleEvent::EVENT_TEXT_CARET_MOVED, aAccessible,
+aIsFromUserInput),
+mCaretOffset(aCaretOffset) { }
+virtual ~AccCaretMoveEvent() { }
+// AccEvent
+static const EventGroup kEventGroup = eCaretMoveEvent;
+virtual unsigned int GetEventGroups() const
+{
+return AccEvent::GetEventGroups() | (1U << eCaretMoveEvent);
+}
+// AccCaretMoveEvent
+int32_t GetCaretOffset() const { return mCaretOffset; }
+private:
+int32_t mCaretOffset;
+};
+/**
+* Accessible text selection change event.
+*/
+class AccTextSelChangeEvent : public AccEvent
+{
+public:
+AccTextSelChangeEvent(HyperTextAccessible* aTarget,
+dom::Selection* aSelection,
+int32_t aReason);
+virtual ~AccTextSelChangeEvent();
+// AccEvent
+static const EventGroup kEventGroup = eTextSelChangeEvent;
+virtual unsigned int GetEventGroups() const
+{
+return AccEvent::GetEventGroups() | (1U << eTextSelChangeEvent);
+}
+// AccTextSelChangeEvent
+/**
+* Return true if the text selection change wasn't caused by pure caret move.
+*/
+bool IsCaretMoveOnly() const;
+private:
+nsRefPtr<dom::Selection> mSel;
+int32_t mReason;
+friend class EventQueue;
+friend class SelectionManager;
+};
+/**
+* Accessible widget selection change event.
+*/
+class AccSelChangeEvent : public AccEvent
+{
+public:
+enum SelChangeType {
+eSelectionAdd,
+eSelectionRemove
+};
+AccSelChangeEvent(Accessible* aWidget, Accessible* aItem,
+SelChangeType aSelChangeType);
+virtual ~AccSelChangeEvent() { }
+// AccEvent
+static const EventGroup kEventGroup = eSelectionChangeEvent;
+virtual unsigned int GetEventGroups() const
+{
+return AccEvent::GetEventGroups() | (1U << eSelectionChangeEvent);
+}
+// AccSelChangeEvent
+Accessible* Widget() const { return mWidget; }
+private:
+nsRefPtr<Accessible> mWidget;
+nsRefPtr<Accessible> mItem;
+SelChangeType mSelChangeType;
+uint32_t mPreceedingCount;
+AccSelChangeEvent* mPackedEvent;
+friend class EventQueue;
+};
+/**
+* Accessible table change event.
+*/
+class AccTableChangeEvent : public AccEvent
+{
+public:
+AccTableChangeEvent(Accessible* aAccessible, uint32_t aEventType,
+int32_t aRowOrColIndex, int32_t aNumRowsOrCols);
+// AccEvent
+static const EventGroup kEventGroup = eTableChangeEvent;
+virtual unsigned int GetEventGroups() const
+{
+return AccEvent::GetEventGroups() | (1U << eTableChangeEvent);
+}
+// AccTableChangeEvent
+uint32_t GetIndex() const { return mRowOrColIndex; }
+uint32_t GetCount() const { return mNumRowsOrCols; }
+private:
+uint32_t mRowOrColIndex;   // the start row/column after which the rows are inserted/deleted.
+uint32_t mNumRowsOrCols;   // the number of inserted/deleted rows/columns
+};
+/**
+* Accessible virtual cursor change event.
+*/
+class AccVCChangeEvent : public AccEvent
+{
+public:
+AccVCChangeEvent(Accessible* aAccessible,
+nsIAccessible* aOldAccessible,
+int32_t aOldStart, int32_t aOldEnd,
+int16_t aReason);
+virtual ~AccVCChangeEvent() { }
+// AccEvent
+static const EventGroup kEventGroup = eVirtualCursorChangeEvent;
+virtual unsigned int GetEventGroups() const
+{
+return AccEvent::GetEventGroups() | (1U << eVirtualCursorChangeEvent);
+}
+// AccTableChangeEvent
+nsIAccessible* OldAccessible() const { return mOldAccessible; }
+int32_t OldStartOffset() const { return mOldStart; }
+int32_t OldEndOffset() const { return mOldEnd; }
+int32_t Reason() const { return mReason; }
+private:
+nsRefPtr<nsIAccessible> mOldAccessible;
+int32_t mOldStart;
+int32_t mOldEnd;
+int16_t mReason;
+};
+/**
+* Downcast the generic accessible event object to derived type.
+*/
+class downcast_accEvent
+{
+public:
+downcast_accEvent(AccEvent* e) : mRawPtr(e) { }
+template<class Destination>
+operator Destination*() {
+if (!mRawPtr)
+return nullptr;
+return mRawPtr->GetEventGroups() & (1U << Destination::kEventGroup) ?
+static_cast<Destination*>(mRawPtr) : nullptr;
+}
+private:
+AccEvent* mRawPtr;
+};
+/**
+* Return a new xpcom accessible event for the given internal one.
+*/
+already_AddRefed<nsIAccessibleEvent>
+MakeXPCEvent(AccEvent* aEvent);
+} // namespace a11y
+} // namespace mozilla
+#endif

The Tor Browser / file comparison

comparison: accessible/src/base/AccEvent.h

accessible/src/base/AccEvent.h