From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- dom/events/EventDispatcher.h | 292 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 292 insertions(+) create mode 100644 dom/events/EventDispatcher.h (limited to 'dom/events/EventDispatcher.h') diff --git a/dom/events/EventDispatcher.h b/dom/events/EventDispatcher.h new file mode 100644 index 000000000..3c754033d --- /dev/null +++ b/dom/events/EventDispatcher.h @@ -0,0 +1,292 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#ifdef MOZILLA_INTERNAL_API +#ifndef mozilla_EventDispatcher_h_ +#define mozilla_EventDispatcher_h_ + +#include "mozilla/EventForwards.h" +#include "nsCOMPtr.h" +#include "nsTArray.h" + +// Microsoft's API Name hackery sucks +#undef CreateEvent + +class nsIContent; +class nsIDOMEvent; +class nsPresContext; + +template class nsCOMArray; + +namespace mozilla { +namespace dom { +class Event; +class EventTarget; +} // namespace dom + +/** + * About event dispatching: + * When either EventDispatcher::Dispatch or + * EventDispatcher::DispatchDOMEvent is called an event target chain is + * created. EventDispatcher creates the chain by calling PreHandleEvent + * on each event target and the creation continues until either the mCanHandle + * member of the EventChainPreVisitor object is false or the mParentTarget + * does not point to a new target. The event target chain is created in the + * heap. + * + * If the event needs retargeting, mEventTargetAtParent must be set in + * PreHandleEvent. + * + * The capture, target and bubble phases of the event dispatch are handled + * by iterating through the event target chain. Iteration happens twice, + * first for the default event group and then for the system event group. + * While dispatching the event for the system event group PostHandleEvent + * is called right after calling event listener for the current event target. + */ + +class EventChainVisitor +{ +public: + EventChainVisitor(nsPresContext* aPresContext, + WidgetEvent* aEvent, + nsIDOMEvent* aDOMEvent, + nsEventStatus aEventStatus = nsEventStatus_eIgnore) + : mPresContext(aPresContext) + , mEvent(aEvent) + , mDOMEvent(aDOMEvent) + , mEventStatus(aEventStatus) + , mItemFlags(0) + { + } + + /** + * The prescontext, possibly nullptr. + */ + nsPresContext* const mPresContext; + + /** + * The WidgetEvent which is being dispatched. Never nullptr. + */ + WidgetEvent* const mEvent; + + /** + * The DOM Event assiciated with the mEvent. Possibly nullptr if a DOM Event + * is not (yet) created. + */ + nsIDOMEvent* mDOMEvent; + + /** + * The status of the event. + * @see nsEventStatus.h + */ + nsEventStatus mEventStatus; + + /** + * Bits for items in the event target chain. + * Set in PreHandleEvent() and used in PostHandleEvent(). + * + * @note These bits are different for each item in the event target chain. + * It is up to the Pre/PostHandleEvent implementation to decide how to + * use these bits. + * + * @note Using uint16_t because that is used also in EventTargetChainItem. + */ + uint16_t mItemFlags; + + /** + * Data for items in the event target chain. + * Set in PreHandleEvent() and used in PostHandleEvent(). + * + * @note This data is different for each item in the event target chain. + * It is up to the Pre/PostHandleEvent implementation to decide how to + * use this. + */ + nsCOMPtr mItemData; +}; + +class EventChainPreVisitor : public EventChainVisitor +{ +public: + EventChainPreVisitor(nsPresContext* aPresContext, + WidgetEvent* aEvent, + nsIDOMEvent* aDOMEvent, + nsEventStatus aEventStatus, + bool aIsInAnon) + : EventChainVisitor(aPresContext, aEvent, aDOMEvent, aEventStatus) + , mCanHandle(true) + , mAutomaticChromeDispatch(true) + , mForceContentDispatch(false) + , mRelatedTargetIsInAnon(false) + , mOriginalTargetIsInAnon(aIsInAnon) + , mWantsWillHandleEvent(false) + , mMayHaveListenerManager(true) + , mParentTarget(nullptr) + , mEventTargetAtParent(nullptr) + { + } + + void Reset() + { + mItemFlags = 0; + mItemData = nullptr; + mCanHandle = true; + mAutomaticChromeDispatch = true; + mForceContentDispatch = false; + mWantsWillHandleEvent = false; + mMayHaveListenerManager = true; + mParentTarget = nullptr; + mEventTargetAtParent = nullptr; + } + + /** + * Member that must be set in PreHandleEvent by event targets. If set to false, + * indicates that this event target will not be handling the event and + * construction of the event target chain is complete. The target that sets + * mCanHandle to false is NOT included in the event target chain. + */ + bool mCanHandle; + + /** + * If mCanHandle is false and mAutomaticChromeDispatch is also false + * event will not be dispatched to the chrome event handler. + */ + bool mAutomaticChromeDispatch; + + /** + * If mForceContentDispatch is set to true, + * content dispatching is not disabled for this event target. + * FIXME! This is here for backward compatibility. Bug 329119 + */ + bool mForceContentDispatch; + + /** + * true if it is known that related target is or is a descendant of an + * element which is anonymous for events. + */ + bool mRelatedTargetIsInAnon; + + /** + * true if the original target of the event is inside anonymous content. + * This is set before calling PreHandleEvent on event targets. + */ + bool mOriginalTargetIsInAnon; + + /** + * Whether or not nsIDOMEventTarget::WillHandleEvent will be + * called. Default is false; + */ + bool mWantsWillHandleEvent; + + /** + * If it is known that the current target doesn't have a listener manager + * when PreHandleEvent is called, set this to false. + */ + bool mMayHaveListenerManager; + + /** + * Parent item in the event target chain. + */ + dom::EventTarget* mParentTarget; + + /** + * If the event needs to be retargeted, this is the event target, + * which should be used when the event is handled at mParentTarget. + */ + dom::EventTarget* mEventTargetAtParent; + + /** + * An array of destination insertion points that need to be inserted + * into the event path of nodes that are distributed by the + * web components distribution algorithm. + */ + nsTArray mDestInsertionPoints; +}; + +class EventChainPostVisitor : public mozilla::EventChainVisitor +{ +public: + explicit EventChainPostVisitor(EventChainVisitor& aOther) + : EventChainVisitor(aOther.mPresContext, aOther.mEvent, + aOther.mDOMEvent, aOther.mEventStatus) + { + } +}; + +/** + * If an EventDispatchingCallback object is passed to Dispatch, + * its HandleEvent method is called after handling the default event group, + * before handling the system event group. + * This is used in nsPresShell. + */ +class MOZ_STACK_CLASS EventDispatchingCallback +{ +public: + virtual void HandleEvent(EventChainPostVisitor& aVisitor) = 0; +}; + +/** + * The generic class for event dispatching. + * Must not be used outside Gecko! + */ +class EventDispatcher +{ +public: + /** + * aTarget should QI to EventTarget. + * If the target of aEvent is set before calling this method, the target of + * aEvent is used as the target (unless there is event + * retargeting) and the originalTarget of the DOM Event. + * aTarget is always used as the starting point for constructing the event + * target chain, no matter what the value of aEvent->mTarget is. + * In other words, aEvent->mTarget is only a property of the event and it has + * nothing to do with the construction of the event target chain. + * Neither aTarget nor aEvent is allowed to be nullptr. + * + * If aTargets is non-null, event target chain will be created, but + * event won't be handled. In this case aEvent->mMessage should be + * eVoidEvent. + * @note Use this method when dispatching a WidgetEvent. + */ + static nsresult Dispatch(nsISupports* aTarget, + nsPresContext* aPresContext, + WidgetEvent* aEvent, + nsIDOMEvent* aDOMEvent = nullptr, + nsEventStatus* aEventStatus = nullptr, + EventDispatchingCallback* aCallback = nullptr, + nsTArray* aTargets = nullptr); + + /** + * Dispatches an event. + * If aDOMEvent is not nullptr, it is used for dispatching + * (aEvent can then be nullptr) and (if aDOMEvent is not |trusted| already), + * the |trusted| flag is set based on the UniversalXPConnect capability. + * Otherwise this works like EventDispatcher::Dispatch. + * @note Use this method when dispatching nsIDOMEvent. + */ + static nsresult DispatchDOMEvent(nsISupports* aTarget, + WidgetEvent* aEvent, + nsIDOMEvent* aDOMEvent, + nsPresContext* aPresContext, + nsEventStatus* aEventStatus); + + /** + * Creates a DOM Event. Returns null if the event type is unsupported. + */ + static already_AddRefed CreateEvent(dom::EventTarget* aOwner, + nsPresContext* aPresContext, + WidgetEvent* aEvent, + const nsAString& aEventType); + + /** + * Called at shutting down. + */ + static void Shutdown(); +}; + +} // namespace mozilla + +#endif // mozilla_EventDispatcher_h_ +#endif -- cgit v1.2.3