/* -*- 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/. */ #include "EventQueue.h" #include "Accessible-inl.h" #include "nsEventShell.h" #include "DocAccessible.h" #include "DocAccessibleChild.h" #include "nsAccessibilityService.h" #include "nsTextEquivUtils.h" #ifdef A11Y_LOG #include "Logging.h" #endif using namespace mozilla; using namespace mozilla::a11y; // Defines the number of selection add/remove events in the queue when they // aren't packed into single selection within event. const unsigned int kSelChangeCountToPack = 5; //////////////////////////////////////////////////////////////////////////////// // EventQueue //////////////////////////////////////////////////////////////////////////////// bool EventQueue::PushEvent(AccEvent* aEvent) { NS_ASSERTION((aEvent->mAccessible && aEvent->mAccessible->IsApplication()) || aEvent->Document() == mDocument, "Queued event belongs to another document!"); if (!mEvents.AppendElement(aEvent)) return false; // Filter events. CoalesceEvents(); if (aEvent->mEventRule != AccEvent::eDoNotEmit && (aEvent->mEventType == nsIAccessibleEvent::EVENT_NAME_CHANGE || aEvent->mEventType == nsIAccessibleEvent::EVENT_TEXT_REMOVED || aEvent->mEventType == nsIAccessibleEvent::EVENT_TEXT_INSERTED)) { PushNameChange(aEvent->mAccessible); } return true; } bool EventQueue::PushNameChange(Accessible* aTarget) { // Fire name change event on parent given that this event hasn't been // coalesced, the parent's name was calculated from its subtree, and the // subtree was changed. if (aTarget->HasNameDependentParent()) { // Only continue traversing up the tree if it's possible that the parent // accessible's name can depend on this accessible's name. Accessible* parent = aTarget->Parent(); while (parent && nsTextEquivUtils::HasNameRule(parent, eNameFromSubtreeIfReqRule)) { // Test possible name dependent parent. if (nsTextEquivUtils::HasNameRule(parent, eNameFromSubtreeRule)) { nsAutoString name; ENameValueFlag nameFlag = parent->Name(name); // If name is obtained from subtree, fire name change event. if (nameFlag == eNameFromSubtree) { RefPtr<AccEvent> nameChangeEvent = new AccEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, parent); return PushEvent(nameChangeEvent); } break; } parent = parent->Parent(); } } return false; } //////////////////////////////////////////////////////////////////////////////// // EventQueue: private void EventQueue::CoalesceEvents() { NS_ASSERTION(mEvents.Length(), "There should be at least one pending event!"); uint32_t tail = mEvents.Length() - 1; AccEvent* tailEvent = mEvents[tail]; switch(tailEvent->mEventRule) { case AccEvent::eCoalesceReorder: { DebugOnly<Accessible*> target = tailEvent->mAccessible.get(); MOZ_ASSERT(target->IsApplication() || target->IsOuterDoc() || target->IsXULTree(), "Only app or outerdoc accessible reorder events are in the queue"); MOZ_ASSERT(tailEvent->GetEventType() == nsIAccessibleEvent::EVENT_REORDER, "only reorder events should be queued"); break; // case eCoalesceReorder } case AccEvent::eCoalesceOfSameType: { // Coalesce old events by newer event. for (uint32_t index = tail - 1; index < tail; index--) { AccEvent* accEvent = mEvents[index]; if (accEvent->mEventType == tailEvent->mEventType && accEvent->mEventRule == tailEvent->mEventRule) { accEvent->mEventRule = AccEvent::eDoNotEmit; return; } } } break; // case eCoalesceOfSameType case AccEvent::eCoalesceSelectionChange: { AccSelChangeEvent* tailSelChangeEvent = downcast_accEvent(tailEvent); for (uint32_t index = tail - 1; index < tail; index--) { AccEvent* thisEvent = mEvents[index]; if (thisEvent->mEventRule == tailEvent->mEventRule) { AccSelChangeEvent* thisSelChangeEvent = downcast_accEvent(thisEvent); // Coalesce selection change events within same control. if (tailSelChangeEvent->mWidget == thisSelChangeEvent->mWidget) { CoalesceSelChangeEvents(tailSelChangeEvent, thisSelChangeEvent, index); return; } } } } break; // eCoalesceSelectionChange case AccEvent::eCoalesceStateChange: { // If state change event is duped then ignore previous event. If state // change event is opposite to previous event then no event is emitted // (accessible state wasn't changed). for (uint32_t index = tail - 1; index < tail; index--) { AccEvent* thisEvent = mEvents[index]; if (thisEvent->mEventRule != AccEvent::eDoNotEmit && thisEvent->mEventType == tailEvent->mEventType && thisEvent->mAccessible == tailEvent->mAccessible) { AccStateChangeEvent* thisSCEvent = downcast_accEvent(thisEvent); AccStateChangeEvent* tailSCEvent = downcast_accEvent(tailEvent); if (thisSCEvent->mState == tailSCEvent->mState) { thisEvent->mEventRule = AccEvent::eDoNotEmit; if (thisSCEvent->mIsEnabled != tailSCEvent->mIsEnabled) tailEvent->mEventRule = AccEvent::eDoNotEmit; } } } break; // eCoalesceStateChange } case AccEvent::eCoalesceTextSelChange: { // Coalesce older event by newer event for the same selection or target. // Events for same selection may have different targets and vice versa one // target may be pointed by different selections (for latter see // bug 927159). for (uint32_t index = tail - 1; index < tail; index--) { AccEvent* thisEvent = mEvents[index]; if (thisEvent->mEventRule != AccEvent::eDoNotEmit && thisEvent->mEventType == tailEvent->mEventType) { AccTextSelChangeEvent* thisTSCEvent = downcast_accEvent(thisEvent); AccTextSelChangeEvent* tailTSCEvent = downcast_accEvent(tailEvent); if (thisTSCEvent->mSel == tailTSCEvent->mSel || thisEvent->mAccessible == tailEvent->mAccessible) thisEvent->mEventRule = AccEvent::eDoNotEmit; } } } break; // eCoalesceTextSelChange case AccEvent::eRemoveDupes: { // Check for repeat events, coalesce newly appended event by more older // event. for (uint32_t index = tail - 1; index < tail; index--) { AccEvent* accEvent = mEvents[index]; if (accEvent->mEventType == tailEvent->mEventType && accEvent->mEventRule == tailEvent->mEventRule && accEvent->mAccessible == tailEvent->mAccessible) { tailEvent->mEventRule = AccEvent::eDoNotEmit; return; } } } break; // case eRemoveDupes default: break; // case eAllowDupes, eDoNotEmit } // switch } void EventQueue::CoalesceSelChangeEvents(AccSelChangeEvent* aTailEvent, AccSelChangeEvent* aThisEvent, uint32_t aThisIndex) { aTailEvent->mPreceedingCount = aThisEvent->mPreceedingCount + 1; // Pack all preceding events into single selection within event // when we receive too much selection add/remove events. if (aTailEvent->mPreceedingCount >= kSelChangeCountToPack) { aTailEvent->mEventType = nsIAccessibleEvent::EVENT_SELECTION_WITHIN; aTailEvent->mAccessible = aTailEvent->mWidget; aThisEvent->mEventRule = AccEvent::eDoNotEmit; // Do not emit any preceding selection events for same widget if they // weren't coalesced yet. if (aThisEvent->mEventType != nsIAccessibleEvent::EVENT_SELECTION_WITHIN) { for (uint32_t jdx = aThisIndex - 1; jdx < aThisIndex; jdx--) { AccEvent* prevEvent = mEvents[jdx]; if (prevEvent->mEventRule == aTailEvent->mEventRule) { AccSelChangeEvent* prevSelChangeEvent = downcast_accEvent(prevEvent); if (prevSelChangeEvent->mWidget == aTailEvent->mWidget) prevSelChangeEvent->mEventRule = AccEvent::eDoNotEmit; } } } return; } // Pack sequential selection remove and selection add events into // single selection change event. if (aTailEvent->mPreceedingCount == 1 && aTailEvent->mItem != aThisEvent->mItem) { if (aTailEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd && aThisEvent->mSelChangeType == AccSelChangeEvent::eSelectionRemove) { aThisEvent->mEventRule = AccEvent::eDoNotEmit; aTailEvent->mEventType = nsIAccessibleEvent::EVENT_SELECTION; aTailEvent->mPackedEvent = aThisEvent; return; } if (aThisEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd && aTailEvent->mSelChangeType == AccSelChangeEvent::eSelectionRemove) { aTailEvent->mEventRule = AccEvent::eDoNotEmit; aThisEvent->mEventType = nsIAccessibleEvent::EVENT_SELECTION; aThisEvent->mPackedEvent = aTailEvent; return; } } // Unpack the packed selection change event because we've got one // more selection add/remove. if (aThisEvent->mEventType == nsIAccessibleEvent::EVENT_SELECTION) { if (aThisEvent->mPackedEvent) { aThisEvent->mPackedEvent->mEventType = aThisEvent->mPackedEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd ? nsIAccessibleEvent::EVENT_SELECTION_ADD : nsIAccessibleEvent::EVENT_SELECTION_REMOVE; aThisEvent->mPackedEvent->mEventRule = AccEvent::eCoalesceSelectionChange; aThisEvent->mPackedEvent = nullptr; } aThisEvent->mEventType = aThisEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd ? nsIAccessibleEvent::EVENT_SELECTION_ADD : nsIAccessibleEvent::EVENT_SELECTION_REMOVE; return; } // Convert into selection add since control has single selection but other // selection events for this control are queued. if (aTailEvent->mEventType == nsIAccessibleEvent::EVENT_SELECTION) aTailEvent->mEventType = nsIAccessibleEvent::EVENT_SELECTION_ADD; } //////////////////////////////////////////////////////////////////////////////// // EventQueue: event queue void EventQueue::ProcessEventQueue() { // Process only currently queued events. nsTArray<RefPtr<AccEvent> > events; events.SwapElements(mEvents); uint32_t eventCount = events.Length(); #ifdef A11Y_LOG if (eventCount > 0 && logging::IsEnabled(logging::eEvents)) { logging::MsgBegin("EVENTS", "events processing"); logging::Address("document", mDocument); logging::MsgEnd(); } #endif for (uint32_t idx = 0; idx < eventCount; idx++) { AccEvent* event = events[idx]; if (event->mEventRule != AccEvent::eDoNotEmit) { Accessible* target = event->GetAccessible(); if (!target || target->IsDefunct()) continue; // Dispatch the focus event if target is still focused. if (event->mEventType == nsIAccessibleEvent::EVENT_FOCUS) { FocusMgr()->ProcessFocusEvent(event); continue; } // Dispatch caret moved and text selection change events. if (event->mEventType == nsIAccessibleEvent::EVENT_TEXT_SELECTION_CHANGED) { SelectionMgr()->ProcessTextSelChangeEvent(event); continue; } // Fire selected state change events in support to selection events. if (event->mEventType == nsIAccessibleEvent::EVENT_SELECTION_ADD) { nsEventShell::FireEvent(event->mAccessible, states::SELECTED, true, event->mIsFromUserInput); } else if (event->mEventType == nsIAccessibleEvent::EVENT_SELECTION_REMOVE) { nsEventShell::FireEvent(event->mAccessible, states::SELECTED, false, event->mIsFromUserInput); } else if (event->mEventType == nsIAccessibleEvent::EVENT_SELECTION) { AccSelChangeEvent* selChangeEvent = downcast_accEvent(event); nsEventShell::FireEvent(event->mAccessible, states::SELECTED, (selChangeEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd), event->mIsFromUserInput); if (selChangeEvent->mPackedEvent) { nsEventShell::FireEvent(selChangeEvent->mPackedEvent->mAccessible, states::SELECTED, (selChangeEvent->mPackedEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd), selChangeEvent->mPackedEvent->mIsFromUserInput); } } nsEventShell::FireEvent(event); } if (!mDocument) return; } }