Source code

Revision control

Copy as Markdown

Other Tools

/* -*- 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/. */
#ifndef mozilla_EventStateManager_h_
#define mozilla_EventStateManager_h_
#include "mozilla/EventForwards.h"
#include "nsIObserver.h"
#include "nsWeakReference.h"
#include "nsCOMPtr.h"
#include "nsCOMArray.h"
#include "nsCycleCollectionParticipant.h"
#include "nsRefPtrHashtable.h"
#include "mozilla/Attributes.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/layers/APZPublicUtils.h"
#include "mozilla/dom/Record.h"
#include "Units.h"
#include "WheelHandlingHelper.h" // for WheelDeltaAdjustmentStrategy
class nsFrameLoader;
class nsIContent;
class nsICookieJarSettings;
class nsIDocShell;
class nsIDocShellTreeItem;
class nsIFrame;
class imgIContainer;
class nsIDocumentViewer;
class nsIScrollableFrame;
class nsITimer;
class nsPresContext;
enum class FormControlType : uint8_t;
namespace mozilla {
class EditorBase;
class EnterLeaveDispatcher;
class IMEContentObserver;
class ScrollbarsForWheel;
class TextControlElement;
class WheelTransaction;
namespace dom {
class DataTransfer;
class Document;
class Element;
class Selection;
class BrowserParent;
class RemoteDragStartData;
} // namespace dom
class OverOutElementsWrapper final : public nsISupports {
~OverOutElementsWrapper();
public:
OverOutElementsWrapper();
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_CLASS(OverOutElementsWrapper)
void ContentRemoved(nsIContent& aContent);
void WillDispatchOverAndEnterEvent(nsIContent* aOverEventTarget) {
mDeepestEnterEventTarget = aOverEventTarget;
// Store the first "over" event target we fire and don't refire "over" event
// to that element while the first "over" event is still ongoing.
mDispatchingOverEventTarget = aOverEventTarget;
mDeepestEnterEventTargetIsOverEventTarget = true;
}
void DidDispatchOverAndEnterEvent() { mDispatchingOverEventTarget = nullptr; }
[[nodiscard]] bool IsDispatchingOverEventOn(
nsIContent* aOverEventTarget) const {
MOZ_ASSERT(aOverEventTarget);
return mDeepestEnterEventTargetIsOverEventTarget &&
mDeepestEnterEventTarget == aOverEventTarget;
}
void WillDispatchOutAndOrLeaveEvent() {
// Store the first "out" event target or the deepest "leave" event target
// which we fire and don't refire "out" event to that element while the
// first "out" event is still ongoing.
mDispatchingOutOrDeepestLeaveEventTarget = mDeepestEnterEventTarget;
}
void DidDispatchOutAndOrLeaveEvent() {
mLastOverFrame = nullptr;
mDeepestEnterEventTarget = mDispatchingOutOrDeepestLeaveEventTarget =
nullptr;
}
[[nodiscard]] bool IsDispatchingOutEventOnLastOverEventTarget() const {
return mDispatchingOutOrDeepestLeaveEventTarget &&
mDispatchingOutOrDeepestLeaveEventTarget == mDeepestEnterEventTarget;
}
void OverrideOverEventTarget(nsIContent* aOverEventTarget) {
mDeepestEnterEventTarget = aOverEventTarget;
mDeepestEnterEventTargetIsOverEventTarget = true;
}
[[nodiscard]] nsIContent* GetDeepestLeaveEventTarget() const {
// The last deepest "enter" event targe (it may be same as the last "over"
// target) is the deepest "leave" event target.
return mDeepestEnterEventTarget;
}
[[nodiscard]] nsIContent* GetOutEventTarget() const {
// The last deepest "enter" event target is same as the "over" event target
// unless it's never been removed from the DOM tree. If and only if the
// last "over" event target has not been removed from the DOM tree, it's
// the next "out" event target. Once the last "over" target is removed,
// "out" event should not be fired on the target nor its ancestor.
return mDeepestEnterEventTargetIsOverEventTarget
? mDeepestEnterEventTarget.get()
: nullptr;
}
public:
WeakFrame mLastOverFrame;
private:
// The deepest event target of the last "enter" event. If
// mDeepestEnterEventTargetIsOverEventTarget is true, this is the last "over"
// event target too. If it's set to false, this is an ancestor of the last
// "over" event target which has not been removed from the DOM tree.
nsCOMPtr<nsIContent> mDeepestEnterEventTarget;
// While we're dispatching "over" and "enter" events, this is set to the
// "over" event target. If it's removed from the DOM tree, this is set to
// nullptr.
nsCOMPtr<nsIContent> mDispatchingOverEventTarget;
// While we're dispatching "out" and/or "leave" events, this is set to the
// "out" event target or the deepest leave event target. If it's removed from
// the DOM tree, this is set to nullptr.
nsCOMPtr<nsIContent> mDispatchingOutOrDeepestLeaveEventTarget;
// Once the last "over" element is removed from the tree, this is set
// to false. Then, mDeepestEnterEventTarget may be an ancestor of the
// "over" element which should be the deepest target of next "leave"
// element but shouldn't be target of "out" event.
bool mDeepestEnterEventTargetIsOverEventTarget = true;
};
class EventStateManager : public nsSupportsWeakReference, public nsIObserver {
friend class mozilla::EnterLeaveDispatcher;
friend class mozilla::ScrollbarsForWheel;
friend class mozilla::WheelTransaction;
using ElementState = dom::ElementState;
virtual ~EventStateManager();
public:
EventStateManager();
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_NSIOBSERVER
nsresult Init();
nsresult Shutdown();
/* The PreHandleEvent method is called before event dispatch to either
* the DOM or frames. Any processing which must not be prevented or
* cancelled should occur here. Any processing which is intended to
* be conditional based on either DOM or frame processing should occur in
* PostHandleEvent. Any centralized event processing which must occur before
* DOM or frame event handling should occur here as well.
*
* aOverrideClickTarget can be used to indicate which element should be
* used as the *up target when deciding whether to send click event.
* This is used when releasing pointer capture. Otherwise null.
*/
MOZ_CAN_RUN_SCRIPT
nsresult PreHandleEvent(nsPresContext* aPresContext, WidgetEvent* aEvent,
nsIFrame* aTargetFrame, nsIContent* aTargetContent,
nsEventStatus* aStatus,
nsIContent* aOverrideClickTarget);
/* The PostHandleEvent method should contain all system processing which
* should occur conditionally based on DOM or frame processing. It should
* also contain any centralized event processing which must occur after
* DOM and frame processing.
*/
MOZ_CAN_RUN_SCRIPT
nsresult PostHandleEvent(nsPresContext* aPresContext, WidgetEvent* aEvent,
nsIFrame* aTargetFrame, nsEventStatus* aStatus,
nsIContent* aOverrideClickTarget);
MOZ_CAN_RUN_SCRIPT void PostHandleKeyboardEvent(
WidgetKeyboardEvent* aKeyboardEvent, nsIFrame* aTargetFrame,
nsEventStatus& aStatus);
/**
* DispatchLegacyMouseScrollEvents() dispatches eLegacyMouseLineOrPageScroll
* event and eLegacyMousePixelScroll event for compatibility with old Gecko.
*/
MOZ_CAN_RUN_SCRIPT_BOUNDARY void DispatchLegacyMouseScrollEvents(
nsIFrame* aTargetFrame, WidgetWheelEvent* aEvent, nsEventStatus* aStatus);
MOZ_CAN_RUN_SCRIPT_BOUNDARY void NotifyDestroyPresContext(
nsPresContext* aPresContext);
void ResetHoverState();
void SetPresContext(nsPresContext* aPresContext);
void ClearFrameRefs(nsIFrame* aFrame);
nsIFrame* GetEventTarget();
already_AddRefed<nsIContent> GetEventTargetContent(WidgetEvent* aEvent);
// We manage 4 states here: ACTIVE, HOVER, DRAGOVER, URLTARGET
static bool ManagesState(ElementState aState) {
return aState == ElementState::ACTIVE || aState == ElementState::HOVER ||
aState == ElementState::DRAGOVER ||
aState == ElementState::URLTARGET;
}
/**
* Notify that the given ElementState::* bit has changed for this content.
* @param aContent Content which has changed states
* @param aState Corresponding state flags such as ElementState::FOCUS
* @return Whether the content was able to change all states. Returns false
* if a resulting DOM event causes the content node passed in
* to not change states. Note, the frame for the content may
* change as a result of the content state change, because of
* frame reconstructions that may occur, but this does not
* affect the return value.
*/
bool SetContentState(nsIContent* aContent, ElementState aState);
nsIContent* GetActiveContent() const { return mActiveContent; }
void NativeAnonymousContentRemoved(nsIContent* aAnonContent);
MOZ_CAN_RUN_SCRIPT_BOUNDARY void ContentRemoved(dom::Document* aDocument,
nsIContent* aContent);
/**
* Called when a native anonymous <div> element which is root element of
* text editor will be removed.
*/
void TextControlRootWillBeRemoved(TextControlElement& aTextControlElement);
/**
* Called when a native anonymous <div> element which is root element of
* text editor is created.
*/
void TextControlRootAdded(dom::Element& aAnonymousDivElement,
TextControlElement& aTextControlElement);
bool EventStatusOK(WidgetGUIEvent* aEvent);
/**
* EventStateManager stores IMEContentObserver while it's observing contents.
* Following mehtods are called by IMEContentObserver when it starts to
* observe or stops observing the content.
*/
void OnStartToObserveContent(IMEContentObserver* aIMEContentObserver);
void OnStopObservingContent(IMEContentObserver* aIMEContentObserver);
/**
* TryToFlushPendingNotificationsToIME() suggests flushing pending
* notifications to IME to IMEContentObserver.
* Doesn't do anything in child processes where flushing happens
* asynchronously.
*/
void TryToFlushPendingNotificationsToIME();
static bool IsKeyboardEventUserActivity(WidgetEvent* aEvent);
/**
* Register accesskey on the given element. When accesskey is activated then
* the element will be notified via Element::PerformAccesskey() method.
*
* @param aElement the given element
* @param aKey accesskey
*/
void RegisterAccessKey(dom::Element* aElement, uint32_t aKey);
/**
* Unregister accesskey for the given element.
*
* @param aElement the given element
* @param aKey accesskey
*/
void UnregisterAccessKey(dom::Element* aElement, uint32_t aKey);
/**
* Get accesskey registered on the given element or 0 if there is none.
*
* @param aElement the given element (must not be null)
* @return registered accesskey
*/
uint32_t GetRegisteredAccessKey(dom::Element* aContent);
static void GetAccessKeyLabelPrefix(dom::Element* aElement,
nsAString& aPrefix);
/**
* HandleAccessKey() looks for access keys which matches with aEvent and
* execute when it matches with a chrome access key or some content access
* keys.
* If the event may match chrome access keys, this handles the access key
* synchronously (if there are nested ESMs, their HandleAccessKey() are
* also called recursively).
* If the event may match content access keys and focused target is a remote
* process, this does nothing for the content because when this is called,
* it should already have been handled in the remote process.
* If the event may match content access keys and focused target is not in
* remote process but there are some remote children, this will post
* HandleAccessKey messages to all remote children.
*
* @return true if there is accesskey which aEvent and
* aAccessCharCodes match with. Otherwise, false.
* I.e., when this returns true, a target is executed
* or focused.
* Note that even if this returns false, a target in
* remote process may be executed or focused
* asynchronously.
*/
bool HandleAccessKey(WidgetKeyboardEvent* aEvent, nsPresContext* aPresContext,
nsTArray<uint32_t>& aAccessCharCodes) {
return WalkESMTreeToHandleAccessKey(aEvent, aPresContext, aAccessCharCodes,
nullptr, eAccessKeyProcessingNormal,
true);
}
/**
* CheckIfEventMatchesAccessKey() looks for access key which matches with
* aEvent in the process but won't execute it.
*
* @return true if there is accesskey which aEvent matches with
* in this process. Otherwise, false.
*/
bool CheckIfEventMatchesAccessKey(WidgetKeyboardEvent* aEvent,
nsPresContext* aPresContext);
nsresult SetCursor(StyleCursorKind, imgIContainer*, const ImageResolution&,
const Maybe<gfx::IntPoint>& aHotspot, nsIWidget* aWidget,
bool aLockCursor);
void StartHidingCursorWhileTyping(nsIWidget*);
/**
* Checks if the current mouse over element matches the given
* Element (which has a remote frame), and if so, notifies
* the BrowserParent of the mouse enter.
* Called when we reconstruct the BrowserParent and need to
* recompute state on the new object.
*/
void RecomputeMouseEnterStateForRemoteFrame(dom::Element& aElement);
nsPresContext* GetPresContext() { return mPresContext; }
NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(EventStateManager, nsIObserver)
// The manager in this process that is setting the cursor. In the parent
// process it might be null if a remote process is setting the cursor.
static EventStateManager* sCursorSettingManager;
static void ClearCursorSettingManager() { sCursorSettingManager = nullptr; }
static EventStateManager* GetActiveEventStateManager() { return sActiveESM; }
// Sets aNewESM to be the active event state manager, and
// if aContent is non-null, marks the object as active.
static void SetActiveManager(EventStateManager* aNewESM,
nsIContent* aContent);
static bool IsRemoteTarget(nsIContent* target);
static bool IsTopLevelRemoteTarget(nsIContent* aTarget);
// Returns the kind of APZ action the given WidgetWheelEvent will perform.
static Maybe<layers::APZWheelAction> APZWheelActionFor(
const WidgetWheelEvent* aEvent);
// For some kinds of scrollings, the delta values of WidgetWheelEvent are
// possbile to be adjusted. This function is used to detect such scrollings
// and returns a wheel delta adjustment strategy to use, which is corresponded
// to the kind of the scrolling.
// It returns WheelDeltaAdjustmentStrategy::eAutoDir if the current default
// action is auto-dir scrolling which honours the scrolling target(The
// comments in WheelDeltaAdjustmentStrategy describes the concept in detail).
// It returns WheelDeltaAdjustmentStrategy::eAutoDirWithRootHonour if the
// current action is auto-dir scrolling which honours the root element in the
// document where the scrolling target is(The comments in
// WheelDeltaAdjustmentStrategy describes the concept in detail).
// It returns WheelDeltaAdjustmentStrategy::eHorizontalize if the current
// default action is horizontalized scrolling.
// It returns WheelDeltaAdjustmentStrategy::eNone to mean no delta adjustment
// strategy should be used if the scrolling is just a tranditional scrolling
// whose delta values are never possible to be adjusted.
static WheelDeltaAdjustmentStrategy GetWheelDeltaAdjustmentStrategy(
const WidgetWheelEvent& aEvent);
// Returns user-set multipliers for a wheel event.
static void GetUserPrefsForWheelEvent(const WidgetWheelEvent* aEvent,
double* aOutMultiplierX,
double* aOutMultiplierY);
// Holds the point in screen coords that a mouse event was dispatched to,
// before we went into pointer lock mode. This is constantly updated while
// the pointer is not locked, but we don't update it while the pointer is
// locked. This is used by dom::Event::GetScreenCoords() to make mouse
// events' screen coord appear frozen at the last mouse position while
// the pointer is locked.
static CSSIntPoint sLastScreenPoint;
// Holds the point in client coords of the last mouse event. Used by
// dom::Event::GetClientCoords() to make mouse events' client coords appear
// frozen at the last mouse position while the pointer is locked.
static CSSIntPoint sLastClientPoint;
/**
* If the absolute values of mMultiplierX and/or mMultiplierY are equal or
* larger than this value, the computed scroll amount isn't rounded down to
* the page width or height.
*/
static constexpr double MIN_MULTIPLIER_VALUE_ALLOWING_OVER_ONE_PAGE_SCROLL =
1000.0;
/**
* HandleMiddleClickPaste() handles middle mouse button event as pasting
* clipboard text. Note that if aEditorBase is nullptr, this only
* dispatches ePaste event because it's necessary for some web apps which
* want to implement their own editor and supports middle click paste.
*
* @param aPresShell The PresShell for the ESM. This lifetime
* should be guaranteed by the caller.
* @param aMouseEvent The eMouseClick event which caused the
* paste.
* @param aStatus The event status of aMouseEvent.
* @param aEditorBase EditorBase which may be pasted the
* clipboard text by the middle click.
* If there is no editor for aMouseEvent,
* set nullptr.
*/
MOZ_CAN_RUN_SCRIPT
nsresult HandleMiddleClickPaste(PresShell* aPresShell,
WidgetMouseEvent* aMouseEvent,
nsEventStatus* aStatus,
EditorBase* aEditorBase);
static void ConsumeInteractionData(
dom::Record<nsString, dom::InteractionData>& aInteractions);
// Stop tracking a possible drag. If aClearInChildProcesses is true, send
// a notification to any child processes that are in the drag service that
// tried to start a drag.
void StopTrackingDragGesture(bool aClearInChildProcesses);
protected:
/*
* If aTargetFrame's widget has a cached cursor value, resets the cursor
* such that the next call to SetCursor on the widget will force an update
* of the native cursor. For use in getting puppet widget to update its
* cursor between mouse exit / enter transitions. This call basically wraps
* nsIWidget ClearCachedCursor.
*/
void ClearCachedWidgetCursor(nsIFrame* aTargetFrame);
void UpdateCursor(nsPresContext*, WidgetMouseEvent*, nsIFrame* aTargetFrame,
nsEventStatus* aStatus);
/**
* Turn a GUI mouse/pointer event into a mouse/pointer event targeted at the
* specified content. This returns the primary frame for the content (or null
* if it goes away during the event).
*/
MOZ_CAN_RUN_SCRIPT nsIFrame* DispatchMouseOrPointerEvent(
WidgetMouseEvent* aMouseEvent, EventMessage aMessage,
nsIContent* aTargetContent, nsIContent* aRelatedContent);
/**
* Synthesize DOM pointerover and pointerout events
*/
void GeneratePointerEnterExit(EventMessage aMessage,
WidgetMouseEvent* aEvent);
/**
* Synthesize DOM and frame mouseover and mouseout events from this
* MOUSE_MOVE or MOUSE_EXIT event.
*/
void GenerateMouseEnterExit(WidgetMouseEvent* aMouseEvent);
/**
* Tell this ESM and ESMs in parent documents that the mouse is
* over some content in this document.
*/
MOZ_CAN_RUN_SCRIPT_BOUNDARY void NotifyMouseOver(
WidgetMouseEvent* aMouseEvent, nsIContent* aContent);
/**
* Tell this ESM and ESMs in affected child documents that the mouse
* has exited this document's currently hovered content.
* TODO: Convert this to MOZ_CAN_RUN_SCRIPT (bug 1415230)
*
* @param aMouseEvent the event that triggered the mouseout
* @param aMovingInto the content node we've moved into. This is used to set
* the relatedTarget for mouseout events. Also, if it's non-null
* NotifyMouseOut will NOT change the current hover content to null;
* in that case the caller is responsible for updating hover state.
*/
MOZ_CAN_RUN_SCRIPT_BOUNDARY void NotifyMouseOut(WidgetMouseEvent* aMouseEvent,
nsIContent* aMovingInto);
MOZ_CAN_RUN_SCRIPT void GenerateDragDropEnterExit(
nsPresContext* aPresContext, WidgetDragEvent* aDragEvent);
/**
* Return mMouseEnterLeaveHelper or relevant mPointersEnterLeaveHelper
* elements wrapper. If mPointersEnterLeaveHelper does not contain wrapper for
* pointerId it create new one
*/
OverOutElementsWrapper* GetWrapperByEventID(WidgetMouseEvent* aMouseEvent);
/**
* Fire the dragenter and dragexit/dragleave events when the mouse moves to a
* new target.
*
* @param aRelatedTarget relatedTarget to set for the event
* @param aTargetContent target to set for the event
* @param aTargetFrame target frame for the event
*/
MOZ_CAN_RUN_SCRIPT void FireDragEnterOrExit(nsPresContext* aPresContext,
WidgetDragEvent* aDragEvent,
EventMessage aMessage,
nsIContent* aRelatedTarget,
nsIContent* aTargetContent,
AutoWeakFrame& aTargetFrame);
/**
* Update the initial drag session data transfer with any changes that occur
* on cloned data transfer objects used for events.
*/
void UpdateDragDataTransfer(WidgetDragEvent* dragEvent);
/**
* InitAndDispatchClickEvent() dispatches a click event.
*
* @param aMouseUpEvent eMouseUp event which causes the click event.
* EventCausesClickEvents() must return true
* if this event is set to it.
* @param aStatus Returns the result of click event.
* If the status indicates consumed, the
* value won't be overwritten with
* nsEventStatus_eIgnore.
* @param aMessage Should be eMouseClick, eMouseDoubleClick or
* eMouseAuxClick.
* @param aPresShell The PresShell.
* @param aMouseUpContent The event target of aMouseUpEvent.
* @param aCurrentTarget Current target of the caller.
* @param aNoContentDispatch true if the event shouldn't be exposed to
* web contents (although will be fired on
* document and window).
* @param aOverrideClickTarget Preferred click event target. If this is
* not nullptr, aMouseUpContent and
* aCurrentTarget are ignored.
*/
MOZ_CAN_RUN_SCRIPT
static nsresult InitAndDispatchClickEvent(
WidgetMouseEvent* aMouseUpEvent, nsEventStatus* aStatus,
EventMessage aMessage, PresShell* aPresShell, nsIContent* aMouseUpContent,
AutoWeakFrame aCurrentTarget, bool aNoContentDispatch,
nsIContent* aOverrideClickTarget);
nsresult SetClickCount(WidgetMouseEvent* aEvent, nsEventStatus* aStatus,
nsIContent* aOverrideClickTarget = nullptr);
/**
* EventCausesClickEvents() returns true when aMouseEvent is an eMouseUp
* event and it should cause eMouseClick, eMouseDoubleClick and/or
* eMouseAuxClick events. Note that this method assumes that
* aMouseEvent.mClickCount has already been initialized with SetClickCount().
*/
static bool EventCausesClickEvents(const WidgetMouseEvent& aMouseEvent);
/**
* PostHandleMouseUp() handles default actions of eMouseUp event.
*
* @param aMouseUpEvent eMouseUp event which causes the click event.
* EventCausesClickEvents() must return true
* if this event is set to it.
* @param aStatus Returns the result of event status.
* If one of dispatching event is consumed or
* this does something as default action,
* returns nsEventStatus_eConsumeNoDefault.
* @param aOverrideClickTarget Preferred click event target. If nullptr,
* aMouseUpEvent target and current target
* are used.
*/
MOZ_CAN_RUN_SCRIPT
nsresult PostHandleMouseUp(WidgetMouseEvent* aMouseUpEvent,
nsEventStatus* aStatus,
nsIContent* aOverrideClickTarget);
/**
* DispatchClickEvents() dispatches eMouseClick, eMouseDoubleClick and
* eMouseAuxClick events for aMouseUpEvent. aMouseUpEvent should cause
* click event.
*
* @param aPresShell The PresShell.
* @param aMouseUpEvent eMouseUp event which causes the click event.
* EventCausesClickEvents() must return true
* if this event is set to it.
* @param aStatus Returns the result of event status.
* If one of dispatching click event is
* consumed, returns
* nsEventStatus_eConsumeNoDefault.
* @param aMouseUpContent The event target of aMouseUpEvent.
* @param aOverrideClickTarget Preferred click event target. If this is
* not nullptr, aMouseUpContent and
* current target frame of the ESM are ignored.
*/
MOZ_CAN_RUN_SCRIPT
nsresult DispatchClickEvents(PresShell* aPresShell,
WidgetMouseEvent* aMouseUpEvent,
nsEventStatus* aStatus,
nsIContent* aMouseUpContent,
nsIContent* aOverrideClickTarget);
void EnsureDocument(nsPresContext* aPresContext);
MOZ_CAN_RUN_SCRIPT_BOUNDARY
void FlushLayout(nsPresContext* aPresContext);
/**
* The phases of WalkESMTreeToHandleAccessKey processing. See below.
*/
enum ProcessingAccessKeyState {
eAccessKeyProcessingNormal = 0,
eAccessKeyProcessingUp,
eAccessKeyProcessingDown
};
/**
* Walk EMS to look for access key and execute found access key when aExecute
* is true.
* If there is registered element for the accesskey given by the key event
* and modifier mask then call element.PerformAccesskey(), otherwise call
* WalkESMTreeToHandleAccessKey() recursively, on descendant docshells first,
* then on the ancestor (with |aBubbledFrom| set to the docshell associated
* with |this|), until something matches.
*
* @param aEvent the keyboard event triggering the acccess key
* @param aPresContext the presentation context
* @param aAccessCharCodes list of charcode candidates
* @param aBubbledFrom is used by an ancestor to avoid calling
* WalkESMTreeToHandleAccessKey() on the child the call originally
* came from, i.e. this is the child that recursively called us in
* its Up phase. The initial caller passes |nullptr| here. This is to
* avoid an infinite loop.
* @param aAccessKeyState Normal, Down or Up processing phase (see enums
* above). The initial event receiver uses 'normal', then 'down' when
* processing children and Up when recursively calling its ancestor.
* @param aExecute is true, execute an accesskey if it's found. Otherwise,
* found accesskey won't be executed.
*
* @return true if there is a target which aEvent and
* aAccessCharCodes match with in this process.
* Otherwise, false. I.e., when this returns true and
* aExecute is true, a target is executed or focused.
* Note that even if this returns false, a target in
* remote process may be executed or focused
* asynchronously.
*/
bool WalkESMTreeToHandleAccessKey(WidgetKeyboardEvent* aEvent,
nsPresContext* aPresContext,
nsTArray<uint32_t>& aAccessCharCodes,
nsIDocShellTreeItem* aBubbledFrom,
ProcessingAccessKeyState aAccessKeyState,
bool aExecute);
/**
* Look for access key and execute found access key if aExecute is true in
* the instance.
*
* @return true if there is a target which matches with
* aAccessCharCodes and aIsTrustedEvent. Otherwise,
* false. I.e., when this returns true and aExecute
* is true, a target is executed or focused.
*/
MOZ_CAN_RUN_SCRIPT_BOUNDARY bool LookForAccessKeyAndExecute(
nsTArray<uint32_t>& aAccessCharCodes, bool aIsTrustedEvent,
bool aIsRepeat, bool aExecute);
//---------------------------------------------
// DocShell Focus Traversal Methods
//---------------------------------------------
dom::Element* GetFocusedElement();
bool IsShellVisible(nsIDocShell* aShell);
// These functions are for mousewheel and pixel scrolling
class WheelPrefs {
public:
static WheelPrefs* GetInstance();
static void Shutdown();
/**
* ApplyUserPrefsToDelta() overrides the wheel event's delta values with
* user prefs.
*/
void ApplyUserPrefsToDelta(WidgetWheelEvent* aEvent);
/**
* Returns whether or not ApplyUserPrefsToDelta() would change the delta
* values of an event.
*/
void GetUserPrefsForEvent(const WidgetWheelEvent* aEvent,
double* aOutMultiplierX, double* aOutMultiplierY);
/**
* If ApplyUserPrefsToDelta() changed the delta values with customized
* prefs, the overflowDelta values would be inflated.
* CancelApplyingUserPrefsFromOverflowDelta() cancels the inflation.
*/
void CancelApplyingUserPrefsFromOverflowDelta(WidgetWheelEvent* aEvent);
/**
* Computes the default action for the aEvent with the prefs.
*/
enum Action : uint8_t {
ACTION_NONE = 0,
ACTION_SCROLL,
ACTION_HISTORY,
ACTION_ZOOM,
// Horizontalized scrolling means treating vertical wheel scrolling as
// horizontal scrolling during the process of its default action and
// plugins handling scrolling. Note that delta values as the event object
// in a DOM event listener won't be affected, and will be still the
// original values. For more details, refer to
// mozilla::WheelDeltaAdjustmentStrategy::eHorizontalize
ACTION_HORIZONTALIZED_SCROLL,
ACTION_PINCH_ZOOM,
ACTION_LAST = ACTION_PINCH_ZOOM,
// Following actions are used only by internal processing. So, cannot
// specified by prefs.
ACTION_SEND_TO_PLUGIN,
};
Action ComputeActionFor(const WidgetWheelEvent* aEvent);
/**
* NeedToComputeLineOrPageDelta() returns if the aEvent needs to be
* computed the lineOrPageDelta values.
*/
bool NeedToComputeLineOrPageDelta(const WidgetWheelEvent* aEvent);
/**
* IsOverOnePageScrollAllowed*() checks whether wheel scroll amount should
* be rounded down to the page width/height (false) or not (true).
*/
bool IsOverOnePageScrollAllowedX(const WidgetWheelEvent* aEvent);
bool IsOverOnePageScrollAllowedY(const WidgetWheelEvent* aEvent);
private:
WheelPrefs();
~WheelPrefs();
static void OnPrefChanged(const char* aPrefName, void* aClosure);
enum Index {
INDEX_DEFAULT = 0,
INDEX_ALT,
INDEX_CONTROL,
INDEX_META,
INDEX_SHIFT,
COUNT_OF_MULTIPLIERS
};
/**
* GetIndexFor() returns the index of the members which should be used for
* the aEvent. When only one modifier key of MODIFIER_ALT,
* MODIFIER_CONTROL, MODIFIER_META or MODIFIER_SHIFT is pressed, returns the
* index for the modifier. Otherwise, this return the default index which
* is used at either no modifier key is pressed or two or modifier keys are
* pressed.
*/
Index GetIndexFor(const WidgetWheelEvent* aEvent);
/**
* GetPrefNameBase() returns the base pref name for aEvent.
* It's decided by GetModifierForPref() which modifier should be used for
* the aEvent.
*
* @param aBasePrefName The result, must be "mousewheel.with_*." or
* "mousewheel.default.".
*/
void GetBasePrefName(Index aIndex, nsACString& aBasePrefName);
void Init(Index aIndex);
void Reset();
/**
* Retrieve multiplier for aEvent->mDeltaX and aEvent->mDeltaY.
*
* Note that if the default action is ACTION_HORIZONTALIZED_SCROLL and the
* delta values have been adjusted by WheelDeltaHorizontalizer() before this
* function is called, this function will swap the X and Y multipliers. By
* doing this, multipliers will still apply to the delta values they
* originally corresponded to.
*
* @param aEvent The event which is being handled.
* @param aIndex The index of mMultiplierX and mMultiplierY.
* Should be result of GetIndexFor(aEvent).
* @param aMultiplierForDeltaX Will be set to multiplier for
* aEvent->mDeltaX.
* @param aMultiplierForDeltaY Will be set to multiplier for
* aEvent->mDeltaY.
*/
void GetMultiplierForDeltaXAndY(const WidgetWheelEvent* aEvent,
Index aIndex, double* aMultiplierForDeltaX,
double* aMultiplierForDeltaY);
bool mInit[COUNT_OF_MULTIPLIERS];
double mMultiplierX[COUNT_OF_MULTIPLIERS];
double mMultiplierY[COUNT_OF_MULTIPLIERS];
double mMultiplierZ[COUNT_OF_MULTIPLIERS];
Action mActions[COUNT_OF_MULTIPLIERS];
/**
* action values overridden by .override_x pref.
* If an .override_x value is -1, same as the
* corresponding mActions value.
*/
Action mOverriddenActionsX[COUNT_OF_MULTIPLIERS];
static WheelPrefs* sInstance;
};
/**
* DeltaDirection is used for specifying whether the called method should
* handle vertical delta or horizontal delta.
* This is clearer than using bool.
*/
enum DeltaDirection { DELTA_DIRECTION_X = 0, DELTA_DIRECTION_Y };
struct MOZ_STACK_CLASS EventState {
bool mDefaultPrevented;
bool mDefaultPreventedByContent;
EventState()
: mDefaultPrevented(false), mDefaultPreventedByContent(false) {}
};
/**
* SendLineScrollEvent() dispatches a DOMMouseScroll event for the
* WidgetWheelEvent. This method shouldn't be called for non-trusted
* wheel event because it's not necessary for compatiblity.
*
* @param aTargetFrame The event target of wheel event.
* @param aEvent The original Wheel event.
* @param aState The event which should be set to the dispatching
* event. This also returns the dispatched event
* state.
* @param aDelta The delta value of the event.
* @param aDeltaDirection The X/Y direction of dispatching event.
*/
MOZ_CAN_RUN_SCRIPT void SendLineScrollEvent(nsIFrame* aTargetFrame,
WidgetWheelEvent* aEvent,
EventState& aState,
int32_t aDelta,
DeltaDirection aDeltaDirection);
/**
* SendPixelScrollEvent() dispatches a MozMousePixelScroll event for the
* WidgetWheelEvent. This method shouldn't be called for non-trusted
* wheel event because it's not necessary for compatiblity.
*
* @param aTargetFrame The event target of wheel event.
* @param aEvent The original Wheel event.
* @param aState The event which should be set to the dispatching
* event. This also returns the dispatched event
* state.
* @param aPixelDelta The delta value of the event.
* @param aDeltaDirection The X/Y direction of dispatching event.
*/
MOZ_CAN_RUN_SCRIPT void SendPixelScrollEvent(nsIFrame* aTargetFrame,
WidgetWheelEvent* aEvent,
EventState& aState,
int32_t aPixelDelta,
DeltaDirection aDeltaDirection);
/**
* ComputeScrollTargetAndMayAdjustWheelEvent() returns the scrollable frame
* which should be scrolled.
*
* @param aTargetFrame The event target of the wheel event.
* @param aEvent The handling mouse wheel event.
* @param aOptions The options for finding the scroll target.
* Callers should use COMPUTE_*.
* @return The scrollable frame which should be scrolled.
*/
// These flags are used in ComputeScrollTargetAndMayAdjustWheelEvent().
// Callers should use COMPUTE_*.
enum {
PREFER_MOUSE_WHEEL_TRANSACTION = 0x00000001,
PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_X_AXIS = 0x00000002,
PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_Y_AXIS = 0x00000004,
START_FROM_PARENT = 0x00000008,
INCLUDE_PLUGIN_AS_TARGET = 0x00000010,
// Indicates the wheel scroll event being computed is an auto-dir scroll, so
// its delta may be adjusted after being computed.
MAY_BE_ADJUSTED_BY_AUTO_DIR = 0x00000020,
};
enum ComputeScrollTargetOptions {
// At computing scroll target for legacy mouse events, we should return
// first scrollable element even when it's not scrollable to the direction.
COMPUTE_LEGACY_MOUSE_SCROLL_EVENT_TARGET = 0,
// Default action prefers the scrolled element immediately before if it's
// still under the mouse cursor. Otherwise, it prefers the nearest
// scrollable ancestor which will be scrolled actually.
COMPUTE_DEFAULT_ACTION_TARGET =
(PREFER_MOUSE_WHEEL_TRANSACTION |
PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_X_AXIS |
PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_Y_AXIS),
COMPUTE_DEFAULT_ACTION_TARGET_WITH_AUTO_DIR =
(COMPUTE_DEFAULT_ACTION_TARGET | MAY_BE_ADJUSTED_BY_AUTO_DIR),
// Look for the nearest scrollable ancestor which can be scrollable with
// aEvent.
COMPUTE_SCROLLABLE_ANCESTOR_ALONG_X_AXIS =
(PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_X_AXIS | START_FROM_PARENT),
COMPUTE_SCROLLABLE_ANCESTOR_ALONG_Y_AXIS =
(PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_Y_AXIS | START_FROM_PARENT),
COMPUTE_SCROLLABLE_ANCESTOR_ALONG_X_AXIS_WITH_AUTO_DIR =
(COMPUTE_SCROLLABLE_ANCESTOR_ALONG_X_AXIS |
MAY_BE_ADJUSTED_BY_AUTO_DIR),
COMPUTE_SCROLLABLE_ANCESTOR_ALONG_Y_AXIS_WITH_AUTO_DIR =
(COMPUTE_SCROLLABLE_ANCESTOR_ALONG_Y_AXIS |
MAY_BE_ADJUSTED_BY_AUTO_DIR),
};
// Compute the scroll target.
// The delta values in the wheel event may be changed if the event is for
// auto-dir scrolling. For information on auto-dir,
// @see mozilla::WheelDeltaAdjustmentStrategy
nsIFrame* ComputeScrollTargetAndMayAdjustWheelEvent(
nsIFrame* aTargetFrame, WidgetWheelEvent* aEvent,
ComputeScrollTargetOptions aOptions);
nsIFrame* ComputeScrollTargetAndMayAdjustWheelEvent(
nsIFrame* aTargetFrame, double aDirectionX, double aDirectionY,
WidgetWheelEvent* aEvent, ComputeScrollTargetOptions aOptions);
nsIFrame* ComputeScrollTarget(nsIFrame* aTargetFrame,
WidgetWheelEvent* aEvent,
ComputeScrollTargetOptions aOptions) {
MOZ_ASSERT(!(aOptions & MAY_BE_ADJUSTED_BY_AUTO_DIR),
"aEvent may be modified by auto-dir");
return ComputeScrollTargetAndMayAdjustWheelEvent(aTargetFrame, aEvent,
aOptions);
}
nsIFrame* ComputeScrollTarget(nsIFrame* aTargetFrame, double aDirectionX,
double aDirectionY, WidgetWheelEvent* aEvent,
ComputeScrollTargetOptions aOptions) {
MOZ_ASSERT(!(aOptions & MAY_BE_ADJUSTED_BY_AUTO_DIR),
"aEvent may be modified by auto-dir");
return ComputeScrollTargetAndMayAdjustWheelEvent(
aTargetFrame, aDirectionX, aDirectionY, aEvent, aOptions);
}
/**
* GetScrollAmount() returns the scroll amount in app uints of one line or
* one page. If the wheel event scrolls a page, returns the page width and
* height. Otherwise, returns line height for both its width and height.
*
* @param aScrollableFrame A frame which will be scrolled by the event.
* The result of
* ComputeScrollTargetAndMayAdjustWheelEvent() is
* expected for this value.
* This can be nullptr if there is no scrollable
* frame. Then, this method uses root frame's
* line height or visible area's width and height.
*/
nsSize GetScrollAmount(nsPresContext* aPresContext, WidgetWheelEvent* aEvent,
nsIScrollableFrame* aScrollableFrame);
/**
* DoScrollText() scrolls the scrollable frame for aEvent.
*/
void DoScrollText(nsIScrollableFrame* aScrollableFrame,
WidgetWheelEvent* aEvent);
void DoScrollHistory(int32_t direction);
void DoScrollZoom(nsIFrame* aTargetFrame, int32_t adjustment);
void ChangeZoom(bool aIncrease);
/**
* DeltaAccumulator class manages delta values for dispatching DOMMouseScroll
* event. If wheel events are caused by pixel scroll only devices or
* the delta values are customized by prefs, this class stores the delta
* values and set lineOrPageDelta values.
*/
class DeltaAccumulator {
public:
static DeltaAccumulator* GetInstance() {
if (!sInstance) {
sInstance = new DeltaAccumulator;
}
return sInstance;
}
static void Shutdown() {
delete sInstance;
sInstance = nullptr;
}
bool IsInTransaction() { return mHandlingDeltaMode != UINT32_MAX; }
/**
* InitLineOrPageDelta() stores pixel delta values of WidgetWheelEvents
* which are caused if it's needed. And if the accumulated delta becomes a
* line height, sets lineOrPageDeltaX and lineOrPageDeltaY automatically.
*/
void InitLineOrPageDelta(nsIFrame* aTargetFrame, EventStateManager* aESM,
WidgetWheelEvent* aEvent);
/**
* Reset() resets all members.
*/
void Reset();
/**
* ComputeScrollAmountForDefaultAction() computes the default action's
* scroll amount in device pixels with mPendingScrollAmount*.
*/
nsIntPoint ComputeScrollAmountForDefaultAction(
WidgetWheelEvent* aEvent, const nsIntSize& aScrollAmountInDevPixels);
private:
DeltaAccumulator()
: mX(0.0),
mY(0.0),
mPendingScrollAmountX(0.0),
mPendingScrollAmountY(0.0),
mHandlingDeltaMode(UINT32_MAX),
mIsNoLineOrPageDeltaDevice(false) {}
double mX;
double mY;
// When default action of a wheel event is scroll but some delta values
// are ignored because the computed amount values are not integer, the
// fractional values are saved by these members.
double mPendingScrollAmountX;
double mPendingScrollAmountY;
TimeStamp mLastTime;
uint32_t mHandlingDeltaMode;
bool mIsNoLineOrPageDeltaDevice;
static DeltaAccumulator* sInstance;
};
// end mousewheel functions
/*
* When a touch gesture is about to start, this function determines what
* kind of gesture interaction we will want to use, based on what is
* underneath the initial touch point.
* Currently it decides between panning (finger scrolling) or dragging
* the target element, as well as the orientation to trigger panning and
* display visual boundary feedback. The decision is stored back in aEvent.
*/
void DecideGestureEvent(WidgetGestureNotifyEvent* aEvent,
nsIFrame* targetFrame);
// routines for the d&d gesture tracking state machine
void BeginTrackingDragGesture(nsPresContext* aPresContext,
WidgetMouseEvent* aDownEvent,
nsIFrame* aDownFrame);
void SetGestureDownPoint(WidgetGUIEvent* aEvent);
LayoutDeviceIntPoint GetEventRefPoint(WidgetEvent* aEvent) const;
friend class mozilla::dom::BrowserParent;
void BeginTrackingRemoteDragGesture(nsIContent* aContent,
dom::RemoteDragStartData* aDragStartData);
MOZ_CAN_RUN_SCRIPT
void GenerateDragGesture(nsPresContext* aPresContext,
WidgetInputEvent* aEvent);
/**
* When starting a dnd session, UA must fire a pointercancel event and stop
* firing the subsequent pointer events.
*/
MOZ_CAN_RUN_SCRIPT
void MaybeFirePointerCancel(WidgetInputEvent* aEvent);
/**
* Determine which node the drag should be targeted at.
* This is either the node clicked when there is a selection, or, for HTML,
* the element with a draggable property set to true.
*
* aSelectionTarget - target to check for selection
* aDataTransfer - data transfer object that will contain the data to drag
* aAllowEmptyDataTransfer - [out] set to true, if dnd operation can be
* started even if DataTransfer is empty
* aSelection - [out] set to the selection to be dragged
* aTargetNode - [out] the draggable node, or null if there isn't one
* aPrincipal - [out] set to the triggering principal of the drag, or null
* if it's from browser chrome or OS
* aCookieJarSettings - [out] set to the cookieJarSettings of the drag, or
* null if it's from browser chrome or OS.
*/
void DetermineDragTargetAndDefaultData(
nsPIDOMWindowOuter* aWindow, nsIContent* aSelectionTarget,
dom::DataTransfer* aDataTransfer, bool* aAllowEmptyDataTransfer,
dom::Selection** aSelection,
dom::RemoteDragStartData** aRemoteDragStartData, nsIContent** aTargetNode,
nsIPrincipal** aPrincipal, nsIContentSecurityPolicy** aCsp,
nsICookieJarSettings** aCookieJarSettings);
/*
* Perform the default handling for the dragstart event and set up a
* drag for aDataTransfer if it contains any data. Returns true if a drag has
* started.
*
* aDragEvent - the dragstart event
* aDataTransfer - the data transfer that holds the data to be dragged
* aAllowEmptyDataTransfer - if true, dnd can be started even if there is no
* data to drag
* aDragTarget - the target of the drag
* aSelection - the selection to be dragged
* aData - information pertaining to a drag started in a child process
* aPrincipal - the triggering principal of the drag, or null if it's from
* browser chrome or OS
* aCookieJarSettings - the cookieJarSettings of the drag. or null if it's
* from browser chrome or OS.
*/
MOZ_CAN_RUN_SCRIPT
bool DoDefaultDragStart(
nsPresContext* aPresContext, WidgetDragEvent* aDragEvent,
dom::DataTransfer* aDataTransfer, bool aAllowEmptyDataTransfer,
nsIContent* aDragTarget, dom::Selection* aSelection,
dom::RemoteDragStartData* aDragStartData, nsIPrincipal* aPrincipal,
nsIContentSecurityPolicy* aCsp, nsICookieJarSettings* aCookieJarSettings);
bool IsTrackingDragGesture() const { return mGestureDownContent != nullptr; }
/**
* Set the fields of aEvent to reflect the mouse position and modifier keys
* that were set when the user first pressed the mouse button (stored by
* BeginTrackingDragGesture). aEvent->mWidget must be
* mCurrentTarget->GetNearestWidget().
*/
void FillInEventFromGestureDown(WidgetMouseEvent* aEvent);
MOZ_CAN_RUN_SCRIPT
nsresult DoContentCommandEvent(WidgetContentCommandEvent* aEvent);
MOZ_CAN_RUN_SCRIPT
nsresult DoContentCommandInsertTextEvent(WidgetContentCommandEvent* aEvent);
nsresult DoContentCommandScrollEvent(WidgetContentCommandEvent* aEvent);
dom::BrowserParent* GetCrossProcessTarget();
bool IsTargetCrossProcess(WidgetGUIEvent* aEvent);
/**
* DispatchCrossProcessEvent() try to post aEvent to target remote process.
* If you need to check if the event is posted to a remote process, you
* can use aEvent->HasBeenPostedToRemoteProcess().
*/
void DispatchCrossProcessEvent(WidgetEvent* aEvent,
dom::BrowserParent* aRemoteTarget,
nsEventStatus* aStatus);
/**
* HandleCrossProcessEvent() may post aEvent to target remote processes.
* When it succeeded to post the event to at least one remote process,
* returns true. Otherwise, including the case not tried to dispatch to
* post the event, returns false.
* If you need to check if the event is posted to at least one remote
* process, you can use aEvent->HasBeenPostedToRemoteProcess().
*/
bool HandleCrossProcessEvent(WidgetEvent* aEvent, nsEventStatus* aStatus);
void ReleaseCurrentIMEContentObserver();
MOZ_CAN_RUN_SCRIPT void HandleQueryContentEvent(
WidgetQueryContentEvent* aEvent);
private:
// Removes a node from the :hover / :active chain if needed, notifying if the
// node is not a NAC subtree.
//
// Only meant to be called from ContentRemoved and
// NativeAnonymousContentRemoved.
void RemoveNodeFromChainIfNeeded(ElementState aState,
nsIContent* aContentRemoved, bool aNotify);
bool IsEventOutsideDragThreshold(WidgetInputEvent* aEvent) const;
static inline void DoStateChange(dom::Element* aElement, ElementState aState,
bool aAddState);
static inline void DoStateChange(nsIContent* aContent, ElementState aState,
bool aAddState);
static void UpdateAncestorState(nsIContent* aStartNode,
nsIContent* aStopBefore, ElementState aState,
bool aAddState);
/**
* Update the attribute mLastRefPoint of the mouse event. It should be
* the center of the window while the pointer is locked.
* the same value as mRefPoint while there is no known last ref point.
* the same value as the last known mRefPoint.
*/
static void UpdateLastRefPointOfMouseEvent(WidgetMouseEvent* aMouseEvent);
static void ResetPointerToWindowCenterWhilePointerLocked(
WidgetMouseEvent* aMouseEvent);
// Update the last known ref point to the current event's mRefPoint.
static void UpdateLastPointerPosition(WidgetMouseEvent* aMouseEvent);
/**
* Notify target when user has been interaction with some speicific user
* gestures which are eKeyUp, eMouseUp, eTouchEnd.
*/
void NotifyTargetUserActivation(WidgetEvent* aEvent,
nsIContent* aTargetContent);
/**
*/
MOZ_CAN_RUN_SCRIPT void LightDismissOpenPopovers(WidgetEvent* aEvent,
nsIContent* aTargetContent);
already_AddRefed<EventStateManager> ESMFromContentOrThis(
nsIContent* aContent);
struct LastMouseDownInfo {
nsCOMPtr<nsIContent> mLastMouseDownContent;
Maybe<FormControlType> mLastMouseDownInputControlType;
uint32_t mClickCount = 0;
};
LastMouseDownInfo& GetLastMouseDownInfo(int16_t aButton);
// These variables are only relevant if we're the cursor-setting manager.
StyleCursorKind mLockCursor;
bool mHidingCursorWhileTyping = false;
// Last mouse event screen point (in device pixel) when mouse was locked, used
// to restore mouse position after unlocking.
static LayoutDeviceIntPoint sPreLockScreenPoint;
// Stores the mRefPoint of the last synthetic mouse move we dispatched
// to re-center the mouse when we were pointer locked. If this is (-1,-1) it
// means we've not recently dispatched a centering event. We use this to
// detect when we receive the synth event, so we can cancel and not send it
// to content.
static LayoutDeviceIntPoint sSynthCenteringPoint;
WeakFrame mCurrentTarget;
nsCOMPtr<nsIContent> mCurrentTargetContent;
static AutoWeakFrame sLastDragOverFrame;
// Stores the mRefPoint (the offset from the widget's origin in device
// pixels) of the last mouse event.
static LayoutDeviceIntPoint sLastRefPoint;
// member variables for the d&d gesture state machine
LayoutDeviceIntPoint mGestureDownPoint; // screen coordinates
// The content to use as target if we start a d&d (what we drag).
RefPtr<nsIContent> mGestureDownContent;
// The content of the frame where the mouse-down event occurred. It's the same
// as the target in most cases but not always - for example when dragging
// an <area> of an image map this is the image. (bug 289667)
nsCOMPtr<nsIContent> mGestureDownFrameOwner;
// Data associated with a drag started in a content process.
RefPtr<dom::RemoteDragStartData> mGestureDownDragStartData;
// State of keys when the original gesture-down happened
Modifiers mGestureModifiers;
uint16_t mGestureDownButtons;
LastMouseDownInfo mLastLeftMouseDownInfo;
LastMouseDownInfo mLastMiddleMouseDownInfo;
LastMouseDownInfo mLastRightMouseDownInfo;
nsCOMPtr<nsIContent> mActiveContent;
nsCOMPtr<nsIContent> mHoverContent;
static nsCOMPtr<nsIContent> sDragOverContent;
nsCOMPtr<nsIContent> mURLTargetContent;
nsCOMPtr<nsINode> mPopoverPointerDownTarget;
nsPresContext* mPresContext; // Not refcnted
RefPtr<dom::Document> mDocument; // Doesn't necessarily need to be owner
RefPtr<IMEContentObserver> mIMEContentObserver;
bool mShouldAlwaysUseLineDeltas : 1;
bool mShouldAlwaysUseLineDeltasInitialized : 1;
bool mGestureDownInTextControl : 1;
bool mInTouchDrag;
bool m_haveShutdown;
RefPtr<OverOutElementsWrapper> mMouseEnterLeaveHelper;
nsRefPtrHashtable<nsUint32HashKey, OverOutElementsWrapper>
mPointersEnterLeaveHelper;
// Array for accesskey support
nsCOMArray<dom::Element> mAccessKeys;
bool ShouldAlwaysUseLineDeltas();
public:
static nsresult UpdateUserActivityTimer(void);
static bool sNormalLMouseEventInProcess;
static int16_t sCurrentMouseBtn;
static EventStateManager* sActiveESM;
static void ClearGlobalActiveContent(EventStateManager* aClearer);
// Functions used for click hold context menus
nsCOMPtr<nsITimer> mClickHoldTimer;
void CreateClickHoldTimer(nsPresContext* aPresContext, nsIFrame* aDownFrame,
WidgetGUIEvent* aMouseDownEvent);
void KillClickHoldTimer();
MOZ_CAN_RUN_SCRIPT_BOUNDARY void FireContextClick();
MOZ_CAN_RUN_SCRIPT static void SetPointerLock(nsIWidget* aWidget,
nsPresContext* aPresContext);
static void sClickHoldCallback(nsITimer* aTimer, void* aESM);
};
} // namespace mozilla
// Click and double-click events need to be handled even for content that
// has no frame. This is required for Web compatibility.
#define NS_EVENT_NEEDS_FRAME(event) \
((event)->mMessage != eMouseClick && \
(event)->mMessage != eMouseDoubleClick && \
(event)->mMessage != eMouseAuxClick)
#endif // mozilla_EventStateManager_h_