mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
279 lines
9.8 KiB
C++
279 lines
9.8 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is mozilla.org code.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Olli Pettay (Olli.Pettay@helsinki.fi)
|
|
* Portions created by the Initial Developer are Copyright (C) 2006
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
#ifdef MOZILLA_INTERNAL_API
|
|
#ifndef nsEventDispatcher_h___
|
|
#define nsEventDispatcher_h___
|
|
|
|
#include "nsCOMPtr.h"
|
|
#include "nsEvent.h"
|
|
|
|
class nsIContent;
|
|
class nsIDocument;
|
|
class nsPresContext;
|
|
class nsIDOMEvent;
|
|
class nsIScriptGlobalObject;
|
|
class nsIDOMEventTarget;
|
|
class nsEventTargetChainItem;
|
|
template<class E> class nsCOMArray;
|
|
|
|
/**
|
|
* About event dispatching:
|
|
* When either nsEventDispatcher::Dispatch or
|
|
* nsEventDispatcher::DispatchDOMEvent is called an event target chain is
|
|
* created. nsEventDispatcher creates the chain by calling PreHandleEvent
|
|
* on each event target and the creation continues until either the mCanHandle
|
|
* member of the nsEventChainPreVisitor 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 nsEventChainVisitor {
|
|
public:
|
|
nsEventChainVisitor(nsPresContext* aPresContext,
|
|
nsEvent* aEvent,
|
|
nsIDOMEvent* aDOMEvent,
|
|
nsEventStatus aEventStatus = nsEventStatus_eIgnore)
|
|
: mPresContext(aPresContext), mEvent(aEvent), mDOMEvent(aDOMEvent),
|
|
mEventStatus(aEventStatus), mItemFlags(0)
|
|
{}
|
|
|
|
/**
|
|
* The prescontext, possibly nsnull.
|
|
*/
|
|
nsPresContext* const mPresContext;
|
|
|
|
/**
|
|
* The nsEvent which is being dispatched. Never nsnull.
|
|
*/
|
|
nsEvent* const mEvent;
|
|
|
|
/**
|
|
* The DOM Event assiciated with the mEvent. Possibly nsnull 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 PRUint16 because that is used also in nsEventTargetChainItem.
|
|
*/
|
|
PRUint16 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 nsEventChainPreVisitor : public nsEventChainVisitor {
|
|
public:
|
|
nsEventChainPreVisitor(nsPresContext* aPresContext,
|
|
nsEvent* aEvent,
|
|
nsIDOMEvent* aDOMEvent,
|
|
nsEventStatus aEventStatus,
|
|
bool aIsInAnon)
|
|
: nsEventChainVisitor(aPresContext, aEvent, aDOMEvent, aEventStatus),
|
|
mCanHandle(true), mForceContentDispatch(false),
|
|
mRelatedTargetIsInAnon(false), mOriginalTargetIsInAnon(aIsInAnon),
|
|
mWantsWillHandleEvent(false), mMayHaveListenerManager(true),
|
|
mParentTarget(nsnull), mEventTargetAtParent(nsnull) {}
|
|
|
|
void Reset() {
|
|
mItemFlags = 0;
|
|
mItemData = nsnull;
|
|
mCanHandle = true;
|
|
mForceContentDispatch = false;
|
|
mWantsWillHandleEvent = false;
|
|
mMayHaveListenerManager = true;
|
|
mParentTarget = nsnull;
|
|
mEventTargetAtParent = nsnull;
|
|
}
|
|
|
|
/**
|
|
* 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 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.
|
|
*/
|
|
nsIDOMEventTarget* mParentTarget;
|
|
|
|
/**
|
|
* If the event needs to be retargeted, this is the event target,
|
|
* which should be used when the event is handled at mParentTarget.
|
|
*/
|
|
nsIDOMEventTarget* mEventTargetAtParent;
|
|
};
|
|
|
|
class nsEventChainPostVisitor : public nsEventChainVisitor {
|
|
public:
|
|
nsEventChainPostVisitor(nsEventChainVisitor& aOther)
|
|
: nsEventChainVisitor(aOther.mPresContext, aOther.mEvent, aOther.mDOMEvent,
|
|
aOther.mEventStatus)
|
|
{}
|
|
};
|
|
|
|
/**
|
|
* If an nsDispatchingCallback 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 NS_STACK_CLASS nsDispatchingCallback {
|
|
public:
|
|
virtual void HandleEvent(nsEventChainPostVisitor& aVisitor) = 0;
|
|
};
|
|
|
|
/**
|
|
* The generic class for event dispatching.
|
|
* Must not be used outside Gecko!
|
|
*/
|
|
class nsEventDispatcher
|
|
{
|
|
public:
|
|
/**
|
|
* aTarget should QI to nsIDOMEventTarget.
|
|
* 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 nsnull.
|
|
*
|
|
* 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_TYPE_NULL.
|
|
* @note Use this method when dispatching an nsEvent.
|
|
*/
|
|
static nsresult Dispatch(nsISupports* aTarget,
|
|
nsPresContext* aPresContext,
|
|
nsEvent* aEvent,
|
|
nsIDOMEvent* aDOMEvent = nsnull,
|
|
nsEventStatus* aEventStatus = nsnull,
|
|
nsDispatchingCallback* aCallback = nsnull,
|
|
nsCOMArray<nsIDOMEventTarget>* aTargets = nsnull);
|
|
|
|
/**
|
|
* Dispatches an event.
|
|
* If aDOMEvent is not nsnull, it is used for dispatching
|
|
* (aEvent can then be nsnull) and (if aDOMEvent is not |trusted| already),
|
|
* the |trusted| flag is set based on the UniversalBrowserWrite capability.
|
|
* Otherwise this works like nsEventDispatcher::Dispatch.
|
|
* @note Use this method when dispatching nsIDOMEvent.
|
|
*/
|
|
static nsresult DispatchDOMEvent(nsISupports* aTarget,
|
|
nsEvent* aEvent, nsIDOMEvent* aDOMEvent,
|
|
nsPresContext* aPresContext,
|
|
nsEventStatus* aEventStatus);
|
|
|
|
/**
|
|
* Creates a DOM Event.
|
|
*/
|
|
static nsresult CreateEvent(nsPresContext* aPresContext,
|
|
nsEvent* aEvent,
|
|
const nsAString& aEventType,
|
|
nsIDOMEvent** aDOMEvent);
|
|
|
|
};
|
|
|
|
#endif
|
|
#endif
|