The Tor Browser: dom/events/EventDispatcher.h@6474c204b198 (annotated)

dom/events/EventDispatcher.h@6474c204b198 (annotated)

dom/events/EventDispatcher.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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/. */
 #ifdef MOZILLA_INTERNAL_API
 #ifndef mozilla_EventDispatcher_h_
 #define mozilla_EventDispatcher_h_
 #include "mozilla/EventForwards.h"
 #include "nsCOMPtr.h"
 // Microsoft's API Name hackery sucks
 #undef CreateEvent
 class nsIDOMEvent;
 class nsIScriptGlobalObject;
 class nsPresContext;
 template<class E> class nsCOMArray;
 namespace mozilla {
 namespace dom {
 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<nsISupports> 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;
 };
 class EventChainPostVisitor : public mozilla::EventChainVisitor
 {
 public:
   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->target is.
    * In other words, aEvent->target 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->message should be
    * NS_EVENT_NULL.
    * @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,
                            nsCOMArray<dom::EventTarget>* 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.
    */
   static nsresult CreateEvent(dom::EventTarget* aOwner,
                               nsPresContext* aPresContext,
                               WidgetEvent* aEvent,
                               const nsAString& aEventType,
                               nsIDOMEvent** aDOMEvent);
   /**
    * Called at shutting down.
    */
   static void Shutdown();
 };
 } // namespace mozilla
 #endif // mozilla_EventDispatcher_h_
 #endif

The Tor Browser / annotate

dom/events/EventDispatcher.h@6474c204b198 (annotated)

dom/events/EventDispatcher.h