/* -*- 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/. */
/** * Returns the common ancestor for mouseup purpose, given the * current mouseup target and the previous mousedown target.
*/ static nsINode* GetCommonAncestorForMouseUp(
nsINode* aCurrentMouseUpTarget, nsINode* aLastMouseDownTarget,
Maybe<FormControlType>& aLastMouseDownInputControlType) { if (!aCurrentMouseUpTarget || !aLastMouseDownTarget) { return nullptr;
}
if (aCurrentMouseUpTarget == aLastMouseDownTarget) { return aCurrentMouseUpTarget;
}
// Build the chain of parents
AutoTArray<nsINode*, 30> parents1; do {
parents1.AppendElement(aCurrentMouseUpTarget);
aCurrentMouseUpTarget = aCurrentMouseUpTarget->GetFlattenedTreeParentNode();
} while (aCurrentMouseUpTarget);
AutoTArray<nsINode*, 30> parents2; do {
parents2.AppendElement(aLastMouseDownTarget); if (aLastMouseDownTarget == parents1.LastElement()) { break;
}
aLastMouseDownTarget = aLastMouseDownTarget->GetFlattenedTreeParentNode();
} while (aLastMouseDownTarget);
// Find where the parent chain differs
uint32_t pos1 = parents1.Length();
uint32_t pos2 = parents2.Length();
nsINode* parent = nullptr; for (uint32_t len = std::min(pos1, pos2); len > 0; --len) {
nsINode* child1 = parents1.ElementAt(--pos1);
nsINode* child2 = parents2.ElementAt(--pos2); if (child1 != child2) { break;
}
// If the input control type is different between mouseup and mousedown, // this is not a valid click. if (HTMLInputElement* input = HTMLInputElement::FromNodeOrNull(child1)) { if (aLastMouseDownInputControlType.isSome() &&
aLastMouseDownInputControlType.ref() != input->ControlType()) { break;
}
}
parent = child1;
}
if (!StaticPrefs::
dom_events_mouse_pointer_boundary_keep_enter_targets_after_over_target_removed()) {
MOZ_LOG(logModule, LogLevel::Info,
("The last \"over\" event target (%p) is removed",
mDeepestEnterEventTarget.get()));
StoreOverEventTargetAndDeepestEnterEventTarget(nullptr); return;
}
if (mDispatchingOverEventTarget &&
(mDeepestEnterEventTarget == mDispatchingOverEventTarget ||
nsContentUtils::ContentIsFlattenedTreeDescendantOf(
mDispatchingOverEventTarget, &aContent))) { if (mDispatchingOverEventTarget ==
mDispatchingOutOrDeepestLeaveEventTarget) {
MOZ_LOG(logModule, LogLevel::Info,
("The dispatching \"%s\" event target (%p) is removed",
LastOverEventTargetIsOutEventTarget() ? "out" : "leave",
mDispatchingOutOrDeepestLeaveEventTarget.get()));
mDispatchingOutOrDeepestLeaveEventTarget = nullptr;
}
MOZ_LOG(logModule, LogLevel::Info,
("The dispatching \"over\" event target (%p) is removed",
mDispatchingOverEventTarget.get()));
mDispatchingOverEventTarget = nullptr;
} if (mDispatchingOutOrDeepestLeaveEventTarget &&
(mDeepestEnterEventTarget == mDispatchingOutOrDeepestLeaveEventTarget ||
nsContentUtils::ContentIsFlattenedTreeDescendantOf(
mDispatchingOutOrDeepestLeaveEventTarget, &aContent))) {
MOZ_LOG(logModule, LogLevel::Info,
("The dispatching \"%s\" event target (%p) is removed",
LastOverEventTargetIsOutEventTarget() ? "out" : "leave",
mDispatchingOutOrDeepestLeaveEventTarget.get()));
mDispatchingOutOrDeepestLeaveEventTarget = nullptr;
}
MOZ_LOG(logModule, LogLevel::Info,
("The last \"%s\" event target (%p) is removed and now the last " "deepest enter target becomes %s(%p)",
LastOverEventTargetIsOutEventTarget() ? "over" : "enter",
mDeepestEnterEventTarget.get(),
aContent.GetFlattenedTreeParent()
? ToString(*aContent.GetFlattenedTreeParent()).c_str()
: "nullptr",
aContent.GetFlattenedTreeParent()));
UpdateDeepestEnterEventTarget(aContent.GetFlattenedTreeParent());
}
// If we receive a mouse event immediately, let's try to restore the last // "over" event target as the following "out" event target. We assume that a // synthesized mousemove or another mouse event is being dispatched at latest // the next animation frame from the removal. However, synthesized mouse move // which is enqueued by ContentRemoved() may not sent to this instance because // the target is considered with the latest layout, so the document of this // instance may be moved somewhere before the next animation frame. // Therefore, we should not restore the last "over" target if we receive an // unexpected event like a keyboard event, a wheel event, etc. if (aEvent->AsMouseEvent()) { // Restore the original "over" event target should be allowed only when it's // reconnected under the last deepest "enter" event target because we need // to dispatch "leave" events later at least on the ancestors which have // never been removed from the tree. // XXX If new ancestor is inserted between mDeepestEnterEventTarget and // mPendingToRemoveLastOverEventTarget, we will dispatch "leave" event even // though we have not dispatched "enter" event on the element. For fixing // this, we need to store the full path of the last "out" event target when // it's removed from the tree. I guess we can be relax for this issue // because this hack is required for web apps which reconnect the target // to the same position immediately. // XXX Should be IsInclusiveFlatTreeDescendantOf()? However, it may // be reconnected into a subtree which is different from where the // last over element was.
nsCOMPtr<nsIContent> pendingRemovingOverEventTarget =
GetPendingRemovingOverEventTarget(); if (pendingRemovingOverEventTarget &&
pendingRemovingOverEventTarget->IsInclusiveDescendantOf(
mDeepestEnterEventTarget)) { // StoreOverEventTargetAndDeepestEnterEventTarget() always resets // mLastOverWidget. When we restore the pending removing "over" event // target, we need to keep storing the original "over" widget too.
nsCOMPtr<nsIWeakReference> widget = std::move(mLastOverWidget);
StoreOverEventTargetAndDeepestEnterEventTarget(
pendingRemovingOverEventTarget);
mLastOverWidget = std::move(widget);
MOZ_LOG(logModule, LogLevel::Info,
("The \"over\" event target (%p) is restored",
mDeepestEnterEventTarget.get())); return;
}
MOZ_LOG(logModule, LogLevel::Debug,
("Forgetting the last \"over\" event target (%p) because it is not " "reconnected under the deepest enter event target (%p)",
mPendingRemovingOverEventTarget.get(),
mDeepestEnterEventTarget.get()));
} else {
MOZ_LOG(logModule, LogLevel::Debug,
("Forgetting the last \"over\" event target (%p) because an " "unexpected event (%s) is being dispatched, that means that " "EventStateManager didn't receive a synthesized mousemove which " "should be dispatched at next animation frame from the removal",
mPendingRemovingOverEventTarget.get(), ToChar(aEvent->mMessage)));
}
// Now, we should not restore mPendingRemovingOverEventTarget to // mDeepestEnterEventTarget anymore since mPendingRemovingOverEventTarget was // moved outside the subtree of mDeepestEnterEventTarget.
mPendingRemovingOverEventTarget = nullptr;
}
void OverOutElementsWrapper::WillDispatchOverAndEnterEvent(
nsIContent* aOverEventTarget) {
StoreOverEventTargetAndDeepestEnterEventTarget(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;
}
// Pointer Events define that once the `pointerover` event target is removed // from the tree, `pointerout` should not be fired on that and the closest // connected ancestor at the target removal should be kept as the deepest // `pointerleave` target. Therefore, we don't need the special handling for // `pointerout` event target if the last `pointerover` target is temporarily // removed from the tree. if (mType == OverOutElementsWrapper::BoundaryEventType::Pointer) { return;
}
// Assume that the caller checks whether aOriginalOverTarget is in the // original document. If we don't enable the strict mouse/pointer event // boundary event dispatching by the pref (see below), // mDeepestEnterEventTarget is set to nullptr when the last "over" target is // removed. Therefore, we cannot check whether aOriginalOverTarget is in the // original document here. if (!aOriginalOverTargetInComposedDoc) { return;
}
MOZ_ASSERT_IF(mDeepestEnterEventTarget,
mDeepestEnterEventTarget->GetComposedDoc() ==
aOriginalOverTargetInComposedDoc->GetComposedDoc()); // If the "mouseover" event target is removed temporarily while we're // dispatching "mouseover" and "mouseenter" events and the target gets back // under the deepest enter event target, we should restore the "mouseover" // target. if ((!StaticPrefs::
dom_events_mouse_pointer_boundary_keep_enter_targets_after_over_target_removed() &&
!mDeepestEnterEventTarget) ||
(!LastOverEventTargetIsOutEventTarget() && mDeepestEnterEventTarget &&
nsContentUtils::ContentIsFlattenedTreeDescendantOf(
aOriginalOverTargetInComposedDoc, mDeepestEnterEventTarget))) {
StoreOverEventTargetAndDeepestEnterEventTarget(
aOriginalOverTargetInComposedDoc);
LogModule* const logModule = mType == BoundaryEventType::Mouse
? sMouseBoundaryLog
: sPointerBoundaryLog;
MOZ_LOG(logModule, LogLevel::Info,
("The \"over\" event target (%p) is restored",
mDeepestEnterEventTarget.get()));
}
}
void OverOutElementsWrapper::StoreOverEventTargetAndDeepestEnterEventTarget(
nsIContent* aOverEventTargetAndDeepestEnterEventTarget) {
mDeepestEnterEventTarget = aOverEventTargetAndDeepestEnterEventTarget;
mPendingRemovingOverEventTarget = nullptr;
mDeepestEnterEventTargetIsOverEventTarget = !!mDeepestEnterEventTarget;
mLastOverWidget = nullptr; // Set it after dispatching the "over" event.
}
if (!aDeepestEnterEventTarget) { // If the root element is removed, we don't need to dispatch "leave" // events on any elements. Therefore, we can forget everything.
StoreOverEventTargetAndDeepestEnterEventTarget(nullptr); return;
}
if (LastOverEventTargetIsOutEventTarget()) {
MOZ_ASSERT(mDeepestEnterEventTarget); if (mType == BoundaryEventType::Pointer) { // The spec of Pointer Events defines that once the `pointerover` event // target is removed from the tree, `pointerout` should not be fired on // that and the closest connected ancestor at the target removal should be // kept as the deepest `pointerleave` target. All browsers considers the // last `pointerover` event target is removed immediately when it occurs. // Therefore, we don't need the special handling which we do for the // `mouseout` event target below for considering whether we'll dispatch // `pointerout` on the last `pointerover` target.
mPendingRemovingOverEventTarget = nullptr;
} else { // Now, the `mouseout` event target is removed from the DOM at least // temporarily. Let's keep storing it for restoring it if it's // reconnected into mDeepestEnterEventTarget in a tick because the other // browsers do not treat temporary removal of the last `mouseover` target // keeps storing it as the next `mouseout` event target.
MOZ_ASSERT(!mPendingRemovingOverEventTarget);
MOZ_ASSERT(mDeepestEnterEventTarget);
mPendingRemovingOverEventTarget =
do_GetWeakReference(mDeepestEnterEventTarget);
}
} else {
MOZ_ASSERT(!mDeepestEnterEventTargetIsOverEventTarget); // If mDeepestEnterEventTarget is not the last "over" event target, we've // already done the complicated state managing above. Therefore, we only // need to update mDeepestEnterEventTarget in this case.
}
mDeepestEnterEventTarget = aDeepestEnterEventTarget;
mDeepestEnterEventTargetIsOverEventTarget = false; // Do not update mLastOverWidget here because it's required to ignore some // following pointer events which are fired on widget under different top // level widget.
}
// Don't remove from Observer service in Shutdown because Shutdown also // gets called from xpcom shutdown observer. And we don't want to remove // from the service in that case.
// static bool EventStateManager::IsKeyboardEventUserActivity(WidgetEvent* aEvent) { // We ignore things that shouldn't cause popups, but also things that look // like shortcut presses. In some obscure cases these may actually be // website input, but any meaningful website will have other input anyway, // and we can't very well tell whether shortcut input was supposed to be // directed at chrome or the document.
WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent(); // Access keys should be treated as page interaction. if (keyEvent->ModifiersMatchWithAccessKey(AccessKeyType::eContent)) { returntrue;
} if (!keyEvent->CanTreatAsUserInput() || keyEvent->IsControl() ||
keyEvent->IsMeta() || keyEvent->IsAlt()) { returnfalse;
} // Deal with function keys: switch (keyEvent->mKeyNameIndex) { case KEY_NAME_INDEX_F1: case KEY_NAME_INDEX_F2: case KEY_NAME_INDEX_F3: case KEY_NAME_INDEX_F4: case KEY_NAME_INDEX_F5: case KEY_NAME_INDEX_F6: case KEY_NAME_INDEX_F7: case KEY_NAME_INDEX_F8: case KEY_NAME_INDEX_F9: case KEY_NAME_INDEX_F10: case KEY_NAME_INDEX_F11: case KEY_NAME_INDEX_F12: case KEY_NAME_INDEX_F13: case KEY_NAME_INDEX_F14: case KEY_NAME_INDEX_F15: case KEY_NAME_INDEX_F16: case KEY_NAME_INDEX_F17: case KEY_NAME_INDEX_F18: case KEY_NAME_INDEX_F19: case KEY_NAME_INDEX_F20: case KEY_NAME_INDEX_F21: case KEY_NAME_INDEX_F22: case KEY_NAME_INDEX_F23: case KEY_NAME_INDEX_F24: returnfalse; default: returntrue;
}
}
staticvoid OnTypingInteractionEnded() { // We don't consider a single keystroke to be typing. if (gTypingInteractionKeyPresses > 1) {
gTypingInteraction.mInteractionCount += gTypingInteractionKeyPresses;
gTypingInteraction.mInteractionTimeInMilliseconds += static_cast<uint32_t>(
std::ceil((gTypingEndTime - gTypingStartTime).ToMilliseconds()));
}
staticvoid HandleKeyUpInteraction(WidgetKeyboardEvent* aKeyEvent) { if (EventStateManager::IsKeyboardEventUserActivity(aKeyEvent)) {
TimeStamp now = TimeStamp::Now(); if (gTypingEndTime.IsNull()) {
gTypingEndTime = now;
}
TimeDuration delay = now - gTypingEndTime; // Has it been too long since the last keystroke to be considered typing? if (gTypingInteractionKeyPresses > 0 &&
delay >
TimeDuration::FromMilliseconds(
StaticPrefs::browser_places_interactions_typing_timeout_ms())) {
OnTypingInteractionEnded();
}
gTypingInteractionKeyPresses++; if (gTypingStartTime.IsNull()) {
gTypingStartTime = now;
}
gTypingEndTime = now;
}
}
nsresult EventStateManager::PreHandleEvent(nsPresContext* aPresContext,
WidgetEvent* aEvent,
nsIFrame* aTargetFrame,
nsIContent* aTargetContent,
nsEventStatus* aStatus,
nsIContent* aOverrideClickTarget) {
AUTO_PROFILER_LABEL("EventStateManager::PreHandleEvent", DOM);
NS_ENSURE_ARG_POINTER(aStatus);
NS_ENSURE_ARG(aPresContext); if (!aEvent) {
NS_ERROR("aEvent is null. This should never happen."); return NS_ERROR_NULL_POINTER;
}
NS_WARNING_ASSERTION(
!aTargetFrame || !aTargetFrame->GetContent() ||
aTargetFrame->GetContent() == aTargetContent ||
aTargetFrame->GetContent()->GetFlattenedTreeParent() ==
aTargetContent ||
aTargetFrame->IsGeneratedContentFrame(), "aTargetFrame should be related with aTargetContent"); #if DEBUG if (aTargetFrame && aTargetFrame->IsGeneratedContentFrame()) {
nsCOMPtr<nsIContent> targetContent;
aTargetFrame->GetContentForEvent(aEvent, getter_AddRefs(targetContent));
MOZ_ASSERT(aTargetContent == targetContent, "Unexpected target for generated content frame!");
} #endif
// Do not take account eMouseEnterIntoWidget/ExitFromWidget so that loading // a page when user is not active doesn't change the state to active.
WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent(); if (aEvent->IsTrusted() &&
((mouseEvent && mouseEvent->IsReal() &&
IsMessageMouseUserActivity(mouseEvent->mMessage)) ||
aEvent->mClass == eWheelEventClass ||
aEvent->mClass == ePointerEventClass ||
aEvent->mClass == eTouchEventClass ||
aEvent->mClass == eKeyboardEventClass ||
(aEvent->mClass == eDragEventClass && aEvent->mMessage == eDrop) ||
IsMessageGamepadUserActivity(aEvent->mMessage))) { if (gMouseOrKeyboardEventCounter == 0) {
nsCOMPtr<nsIObserverService> obs =
mozilla::services::GetObserverService(); if (obs) {
obs->NotifyObservers(nullptr, "user-interaction-active", nullptr);
UpdateUserActivityTimer();
}
}
++gMouseOrKeyboardEventCounter;
// Focus events don't necessarily need a frame. if (!mCurrentTarget && !aTargetContent) {
NS_ERROR("mCurrentTarget and aTargetContent are null"); return NS_ERROR_NULL_POINTER;
} #ifdef DEBUG if (aEvent->HasDragEventMessage() && PointerLockManager::IsLocked()) {
NS_ASSERTION(PointerLockManager::IsLocked(), "Pointer is locked. Drag events should be suppressed when " "the pointer is locked.");
} #endif // Store last known screenPoint and clientPoint so pointer lock // can use these values as constants. if (aEvent->IsTrusted() &&
((mouseEvent && mouseEvent->IsReal()) ||
aEvent->mClass == eWheelEventClass) &&
!PointerLockManager::IsLocked()) { // XXX Probably doesn't matter much, but storing these in CSS pixels instead // of device pixels means behavior can be a bit odd if you zoom while // pointer-locked.
sLastScreenPoint = RoundedToInt(
Event::GetScreenCoords(aPresContext, aEvent, aEvent->mRefPoint)
.extract());
sLastClientPoint = RoundedToInt(Event::GetClientCoords(
aPresContext, aEvent, aEvent->mRefPoint, CSSDoublePoint{0, 0}));
}
*aStatus = nsEventStatus_eIgnore;
if (aEvent->mClass == eQueryContentEventClass) {
HandleQueryContentEvent(aEvent->AsQueryContentEvent()); return NS_OK;
}
if (mMouseEnterLeaveHelper && aEvent->IsTrusted()) { // When the last `mouseover` event target is removed from the document, // we makes mMouseEnterLeaveHelper update the last deepest `mouseenter` // event target to the removed node parent and mark it as not the following // `mouseout` event target. However, the other browsers may dispatch // `mouseout` on it if it's restored "immediately". Therefore, we use // the next animation frame as the deadline. ContentRemoved() enqueues a // synthesized `mousemove` to dispatch mouse boundary events under the // mouse cursor soon and the synthesized event (or eMouseExitFromWidget if // our window is moved) will reach here at latest the next animation frame. // Therefore, we can use the event as the deadline. If the removed last // `mouseover` target is reconnected before a synthesized mouse event or // a real mouse event, let's restore it as the following `mouseout` event // target. Otherwise, e.g., a keyboard event, let's forget it.
mMouseEnterLeaveHelper->TryToRestorePendingRemovedOverTarget(aEvent);
}
switch (aEvent->mMessage) { case eContextMenu: if (PointerLockManager::IsLocked()) { return NS_ERROR_DOM_INVALID_STATE_ERR;
} break; case eMouseTouchDrag:
mInTouchDrag = true;
BeginTrackingDragGesture(aPresContext, mouseEvent, aTargetFrame); break; case eMouseDown: { switch (mouseEvent->mButton) { case MouseButton::ePrimary:
BeginTrackingDragGesture(aPresContext, mouseEvent, aTargetFrame);
mLastLeftMouseDownInfo.mClickCount = mouseEvent->mClickCount;
SetClickCount(mouseEvent, aStatus);
sNormalLMouseEventInProcess = true; break; case MouseButton::eMiddle:
mLastMiddleMouseDownInfo.mClickCount = mouseEvent->mClickCount;
SetClickCount(mouseEvent, aStatus); break; case MouseButton::eSecondary:
mLastRightMouseDownInfo.mClickCount = mouseEvent->mClickCount;
SetClickCount(mouseEvent, aStatus); break;
} if (!StaticPrefs::dom_popup_experimental()) {
NotifyTargetUserActivation(aEvent, aTargetContent);
} break;
} case eMouseUp: { switch (mouseEvent->mButton) { case MouseButton::ePrimary: if (StaticPrefs::ui_click_hold_context_menus()) {
KillClickHoldTimer();
}
mInTouchDrag = false;
StopTrackingDragGesture(true);
sNormalLMouseEventInProcess = false; // then fall through...
[[fallthrough]]; case MouseButton::eSecondary: case MouseButton::eMiddle:
RefPtr<EventStateManager> esm =
ESMFromContentOrThis(aOverrideClickTarget);
esm->SetClickCount(mouseEvent, aStatus, aOverrideClickTarget); break;
} break;
} case eMouseEnterIntoWidget:
PointerEventHandler::UpdateActivePointerState(mouseEvent, aTargetContent); // In some cases on e10s eMouseEnterIntoWidget // event was sent twice into child process of content. // (From specific widget code (sending is not permanent) and // from ESM::DispatchMouseOrPointerBoundaryEvent (sending is permanent)). // IsCrossProcessForwardingStopped() helps to suppress sending accidental // event from widget code.
aEvent->StopCrossProcessForwarding(); break; case eMouseExitFromWidget: // If this is a remote frame, we receive eMouseExitFromWidget from the // parent the mouse exits our content. Since the parent may update the // cursor while the mouse is outside our frame, and since PuppetWidget // caches the current cursor internally, re-entering our content (say from // over a window edge) wont update the cursor if the cached value and the // current cursor match. So when the mouse exits a remote frame, clear the // cached widget cursor so a proper update will occur when the mouse // re-enters. if (XRE_IsContentProcess()) {
ClearCachedWidgetCursor(mCurrentTarget);
}
// IsCrossProcessForwardingStopped() helps to suppress double event // sending into process of content. For more information see comment // above, at eMouseEnterIntoWidget case.
aEvent->StopCrossProcessForwarding();
// If the event is not a top-level window or puppet widget exit, then it's // not really an exit --- we may have traversed widget boundaries but // we're still in our toplevel window or puppet widget. if (mouseEvent->mExitFrom.value() !=
WidgetMouseEvent::ePlatformTopLevel &&
mouseEvent->mExitFrom.value() != WidgetMouseEvent::ePuppet) { // Treat it as a synthetic move so we don't generate spurious // "exit" or "move" events. Any necessary "out" or "over" events // will be generated by GenerateMouseEnterExit
mouseEvent->mMessage = eMouseMove;
mouseEvent->mReason = WidgetMouseEvent::eSynthesized; // then fall through...
} else {
MOZ_ASSERT_IF(XRE_IsParentProcess(),
mouseEvent->mExitFrom.value() ==
WidgetMouseEvent::ePlatformTopLevel);
MOZ_ASSERT_IF(XRE_IsContentProcess(), mouseEvent->mExitFrom.value() ==
WidgetMouseEvent::ePuppet); // We should synthetize corresponding pointer events
GeneratePointerEnterExit(ePointerLeave, mouseEvent);
GenerateMouseEnterExit(mouseEvent); // This is really an exit and should stop here
aEvent->mMessage = eVoidEvent; break;
}
[[fallthrough]]; case eMouseMove: case ePointerDown: if (aEvent->mMessage == ePointerDown) {
PointerEventHandler::UpdateActivePointerState(mouseEvent,
aTargetContent);
PointerEventHandler::ImplicitlyCapturePointer(aTargetFrame, aEvent); if (StaticPrefs::dom_popup_experimental()) { // https://html.spec.whatwg.org/multipage/interaction.html#activation-triggering-input-event if (mouseEvent->mInputSource ==
MouseEvent_Binding::MOZ_SOURCE_MOUSE) {
NotifyTargetUserActivation(aEvent, aTargetContent);
}
} elseif (mouseEvent->mInputSource !=
MouseEvent_Binding::MOZ_SOURCE_TOUCH) {
NotifyTargetUserActivation(aEvent, aTargetContent);
}
LightDismissOpenPopovers(aEvent, aTargetContent);
}
[[fallthrough]]; case ePointerMove: { if (!mInTouchDrag &&
PointerEventHandler::IsDragAndDropEnabled(*mouseEvent)) {
GenerateDragGesture(aPresContext, mouseEvent);
} // on the Mac, GenerateDragGesture() may not return until the drag // has completed and so |aTargetFrame| may have been deleted (moving // a bookmark, for example). If this is the case, however, we know // that ClearFrameRefs() has been called and it cleared out // |mCurrentTarget|. As a result, we should pass |mCurrentTarget| // into UpdateCursor().
UpdateCursor(aPresContext, mouseEvent, mCurrentTarget, aStatus);
UpdateLastRefPointOfMouseEvent(mouseEvent); if (PointerLockManager::IsLocked()) {
ResetPointerToWindowCenterWhilePointerLocked(mouseEvent);
}
UpdateLastPointerPosition(mouseEvent);
GenerateMouseEnterExit(mouseEvent); // Flush pending layout changes, so that later mouse move events // will go to the right nodes.
FlushLayout(aPresContext); break;
} case ePointerUp:
LightDismissOpenPopovers(aEvent, aTargetContent);
GenerateMouseEnterExit(mouseEvent); if (StaticPrefs::dom_popup_experimental() &&
mouseEvent->mInputSource != MouseEvent_Binding::MOZ_SOURCE_MOUSE) {
NotifyTargetUserActivation(aEvent, aTargetContent);
} break; case ePointerGotCapture:
GenerateMouseEnterExit(mouseEvent); break; case eDragStart: if (StaticPrefs::ui_click_hold_context_menus()) { // an external drag gesture event came in, not generated internally // by Gecko. Make sure we get rid of the click-hold timer.
KillClickHoldTimer();
} break; case eDragOver: {
WidgetDragEvent* dragEvent = aEvent->AsDragEvent();
MOZ_ASSERT(dragEvent); if (dragEvent->mFlags.mIsSynthesizedForTests &&
allowSynthesisForTests()) {
dragEvent->InitDropEffectForTests();
} // Send the enter/exit events before eDrop.
GenerateDragDropEnterExit(aPresContext, dragEvent); break;
} case eDrop: { if (aEvent->mFlags.mIsSynthesizedForTests && allowSynthesisForTests()) {
MOZ_ASSERT(aEvent->AsDragEvent());
aEvent->AsDragEvent()->InitDropEffectForTests();
} break;
} case eKeyPress: {
WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent(); if ((keyEvent->ModifiersMatchWithAccessKey(AccessKeyType::eChrome) ||
keyEvent->ModifiersMatchWithAccessKey(AccessKeyType::eContent)) && // If the key binding of this event is a native key binding, we // prioritize it.
!HasNativeKeyBindings(aTargetContent, keyEvent)) { // If the eKeyPress event will be sent to a remote process, this // process needs to wait reply from the remote process for checking if // preceding eKeyDown event is consumed. If preceding eKeyDown event // is consumed in the remote process, BrowserChild won't send the event // back to this process. So, only when this process receives a reply // eKeyPress event in BrowserParent, we should handle accesskey in this // process. if (IsTopLevelRemoteTarget(GetFocusedElement())) { // However, if there is no accesskey target for the key combination, // we don't need to wait reply from the remote process. Otherwise, // Mark the event as waiting reply from remote process and stop // propagation in this process. if (CheckIfEventMatchesAccessKey(keyEvent, aPresContext)) {
keyEvent->StopPropagation();
keyEvent->MarkAsWaitingReplyFromRemoteProcess();
}
} // If the event target is in this process, we can handle accesskey now // since if preceding eKeyDown event was consumed, eKeyPress event // won't be dispatched by widget. So, coming eKeyPress event means // that the preceding eKeyDown event wasn't consumed in this case. else {
AutoTArray<uint32_t, 10> accessCharCodes;
keyEvent->GetAccessKeyCandidates(accessCharCodes);
if (HandleAccessKey(keyEvent, aPresContext, accessCharCodes)) {
*aStatus = nsEventStatus_eConsumeNoDefault;
}
}
}
} // then fall through...
[[fallthrough]]; case eKeyDown: if (aEvent->mMessage == eKeyDown) {
NotifyTargetUserActivation(aEvent, aTargetContent);
}
[[fallthrough]]; case eKeyUp: {
Element* element = GetFocusedElement(); if (element) {
mCurrentTargetContent = element;
}
// NOTE: Don't refer TextComposition::IsComposing() since UI Events // defines that KeyboardEvent.isComposing is true when it's // dispatched after compositionstart and compositionend. // TextComposition::IsComposing() is false even before // compositionend if there is no composing string. // And also don't expose other document's composition state. // A native IME context is typically shared by multiple documents. // So, don't use GetTextCompositionFor(nsIWidget*) here.
RefPtr<TextComposition> composition =
IMEStateManager::GetTextCompositionFor(aPresContext);
aEvent->AsKeyboardEvent()->mIsComposing = !!composition;
// Widget may need to perform default action for specific keyboard // event if it's not consumed. In this case, widget has already marked // the event as "waiting reply from remote process". However, we need // to reset it if the target (focused content) isn't in a remote process // because PresShell needs to check if it's marked as so before // dispatching events into the DOM tree. if (aEvent->IsWaitingReplyFromRemoteProcess() &&
!aEvent->PropagationStopped() && !IsTopLevelRemoteTarget(element)) {
aEvent->ResetWaitingReplyFromRemoteProcessState();
}
} break; case eWheel: case eWheelOperationStart: case eWheelOperationEnd: {
NS_ASSERTION(aEvent->IsTrusted(), "Untrusted wheel event shouldn't be here"); using DeltaModeCheckingState = WidgetWheelEvent::DeltaModeCheckingState;
if (Element* element = GetFocusedElement()) {
mCurrentTargetContent = element;
}
// Init lineOrPageDelta values for line scroll events for some devices // on some platforms which might dispatch wheel events which don't // have lineOrPageDelta values. And also, if delta values are // customized by prefs, this recomputes them.
DeltaAccumulator::GetInstance()->InitLineOrPageDelta(aTargetFrame, this,
wheelEvent);
} break; case eSetSelection: {
RefPtr<Element> focuedElement = GetFocusedElement();
IMEStateManager::HandleSelectionEvent(aPresContext, focuedElement,
aEvent->AsSelectionEvent()); break;
} case eContentCommandCut: case eContentCommandCopy: case eContentCommandPaste: case eContentCommandDelete: case eContentCommandUndo: case eContentCommandRedo: case eContentCommandPasteTransferable: case eContentCommandLookUpDictionary:
DoContentCommandEvent(aEvent->AsContentCommandEvent()); break; case eContentCommandInsertText:
DoContentCommandInsertTextEvent(aEvent->AsContentCommandEvent()); break; case eContentCommandReplaceText:
DoContentCommandReplaceTextEvent(aEvent->AsContentCommandEvent()); break; case eContentCommandScroll:
DoContentCommandScrollEvent(aEvent->AsContentCommandEvent()); break; case eCompositionStart: if (aEvent->IsTrusted()) { // If the event is trusted event, set the selected text to data of // composition event.
WidgetCompositionEvent* compositionEvent = aEvent->AsCompositionEvent();
WidgetQueryContentEvent querySelectedTextEvent( true, eQuerySelectedText, compositionEvent->mWidget);
HandleQueryContentEvent(&querySelectedTextEvent); if (querySelectedTextEvent.FoundSelection()) {
compositionEvent->mData = querySelectedTextEvent.mReply->DataRef();
}
NS_ASSERTION(querySelectedTextEvent.Succeeded(), "Failed to get selected text");
} break; case eTouchStart:
SetGestureDownPoint(aEvent->AsTouchEvent()); break; case eTouchEnd: if (!StaticPrefs::dom_popup_experimental()) {
NotifyTargetUserActivation(aEvent, aTargetContent);
} break; default: break;
} return NS_OK;
}
// Returns true if this event is likely an user activation for a link or // a link-like button, where modifier keys are likely be used for controlling // where the link is opened. // // The modifiers associated with the user activation is used for controlling // where the `window.open` is opened into. staticbool CanReflectModifiersToUserActivation(WidgetInputEvent* aEvent) { if (StaticPrefs::dom_popup_experimental()) {
MOZ_ASSERT(aEvent->mMessage == eKeyDown ||
aEvent->mMessage == ePointerDown ||
aEvent->mMessage == ePointerUp);
} else {
MOZ_ASSERT(aEvent->mMessage == eKeyDown || aEvent->mMessage == eMouseDown ||
aEvent->mMessage == ePointerDown ||
aEvent->mMessage == eTouchEnd);
}
WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent(); if (keyEvent) { return keyEvent->CanReflectModifiersToUserActivation();
}
nsCOMPtr<nsINode> node = aTargetContent; if (!node) { return;
}
Document* doc = node->OwnerDoc(); if (!doc) { return;
}
// Don't gesture activate for key events for keys which are likely // to be interaction with the browser, OS.
WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent(); if (keyEvent && !keyEvent->CanUserGestureActivateTarget()) { return;
}
// Touch gestures that end outside the drag target were touches that turned // into scroll/pan/swipe actions. We don't want to gesture activate on such // actions, we want to only gesture activate on touches that are taps. // That is, touches that end in roughly the same place that they started. if ((aEvent->mMessage == eTouchEnd ||
(aEvent->mMessage == ePointerUp &&
aEvent->AsPointerEvent()->mInputSource ==
MouseEvent_Binding::MOZ_SOURCE_TOUCH)) &&
IsEventOutsideDragThreshold(aEvent->AsInputEvent())) { return;
}
// Do not treat the click on scrollbar as a user interaction with the web // content. if (StaticPrefs::dom_user_activation_ignore_scrollbars() &&
((StaticPrefs::dom_popup_experimental() &&
(aEvent->mMessage == ePointerDown || aEvent->mMessage == ePointerUp)) ||
(!StaticPrefs::dom_popup_experimental() &&
(aEvent->mMessage == eMouseDown ||
aEvent->mMessage == ePointerDown))) &&
aTargetContent->IsInNativeAnonymousSubtree()) {
nsIContent* current = aTargetContent; do {
nsIContent* root = current->GetClosestNativeAnonymousSubtreeRoot(); if (!root) { break;
} if (root->IsXULElement(nsGkAtoms::scrollbar)) { return;
}
current = root->GetParent();
} while (current);
}
UserActivation::Modifiers modifiers; if (WidgetInputEvent* inputEvent = aEvent->AsInputEvent()) { if (CanReflectModifiersToUserActivation(inputEvent)) { if (inputEvent->IsShift()) {
modifiers.SetShift();
} if (inputEvent->IsMeta()) {
modifiers.SetMeta();
} if (inputEvent->IsControl()) {
modifiers.SetControl();
} if (inputEvent->IsAlt()) {
modifiers.SetAlt();
}
WidgetMouseEvent* mouseEvent = inputEvent->AsMouseEvent(); if (mouseEvent) { if (mouseEvent->mButton == MouseButton::eMiddle) {
modifiers.SetMiddleMouse();
}
}
}
}
doc->NotifyUserGestureActivation(modifiers);
}
// https://html.spec.whatwg.org/multipage/popover.html#popover-light-dismiss void EventStateManager::LightDismissOpenPopovers(WidgetEvent* aEvent,
nsIContent* aTargetContent) {
MOZ_ASSERT(aEvent->mMessage == ePointerDown || aEvent->mMessage == ePointerUp, "Light dismiss must be called for pointer up/down only");
if (!aEvent->IsTrusted() || !aTargetContent) { return;
}
Element* topmostPopover = aTargetContent->OwnerDoc()->GetTopmostAutoPopover(); if (!topmostPopover) { return;
}
// Pointerdown: set document's popover pointerdown target to the result of // running topmost clicked popover given target. if (aEvent->mMessage == ePointerDown) {
mPopoverPointerDownTarget = aTargetContent->GetTopmostClickedPopover(); return;
}
EventStateManager::LastMouseDownInfo& EventStateManager::GetLastMouseDownInfo(
int16_t aButton) { switch (aButton) { case MouseButton::ePrimary: return mLastLeftMouseDownInfo; case MouseButton::eMiddle: return mLastMiddleMouseDownInfo; case MouseButton::eSecondary: return mLastRightMouseDownInfo; default:
MOZ_ASSERT_UNREACHABLE("This button shouldn't use this method"); return mLastLeftMouseDownInfo;
}
}
void EventStateManager::HandleQueryContentEvent(
WidgetQueryContentEvent* aEvent) { switch (aEvent->mMessage) { case eQuerySelectedText: case eQueryTextContent: case eQueryCaretRect: case eQueryTextRect: case eQueryEditorRect: if (!IsTargetCrossProcess(aEvent)) { break;
} // Will not be handled locally, remote the event
GetCrossProcessTarget()->HandleQueryContentEvent(*aEvent); return; // Following events have not been supported in e10s mode yet. case eQueryContentState: case eQuerySelectionAsTransferable: case eQueryCharacterAtPoint: case eQueryDOMWidgetHittest: case eQueryTextRectArray: case eQueryDropTargetHittest: break; default: return;
}
// If there is an IMEContentObserver, we need to handle QueryContentEvent // with it. // eQueryDropTargetHittest is not really an IME event, though if (mIMEContentObserver && aEvent->mMessage != eQueryDropTargetHittest) {
RefPtr<IMEContentObserver> contentObserver = mIMEContentObserver;
contentObserver->HandleQueryContentEvent(aEvent); return;
}
switch (treeItem->ItemType()) { case nsIDocShellTreeItem::typeChrome: return AccessKeyType::eChrome; case nsIDocShellTreeItem::typeContent: return AccessKeyType::eContent; default: return AccessKeyType::eNone;
}
}
staticbool IsAccessKeyTarget(Element* aElement, nsAString& aKey) { // Use GetAttr because we want Unicode case=insensitive matching // XXXbz shouldn't this be case-sensitive, per spec?
nsString contentKey; if (!aElement || !aElement->GetAttr(nsGkAtoms::accesskey, contentKey) ||
!contentKey.Equals(aKey, nsCaseInsensitiveStringComparator)) { returnfalse;
}
if (!aElement->IsXULElement()) { returntrue;
}
// For XUL we do visibility checks.
nsIFrame* frame = aElement->GetPrimaryFrame(); if (!frame) { returnfalse;
}
if (frame->IsFocusable()) { returntrue;
}
if (!frame->IsVisibleConsideringAncestors()) { returnfalse;
}
// XUL controls can be activated.
nsCOMPtr<nsIDOMXULControlElement> control = aElement->AsXULControl(); if (control) { returntrue;
}
// XUL label elements are never focusable, so we need to check for them // explicitly before giving up. if (aElement->IsXULElement(nsGkAtoms::label)) { returntrue;
}
bool EventStateManager::LookForAccessKeyAndExecute(
nsTArray<uint32_t>& aAccessCharCodes, bool aIsTrustedEvent, bool aIsRepeat, bool aExecute) {
int32_t count, start = -1; if (Element* focusedElement = GetFocusedElement()) {
start = mAccessKeys.IndexOf(focusedElement); if (start == -1 && focusedElement->IsInNativeAnonymousSubtree()) {
start = mAccessKeys.IndexOf(Element::FromNodeOrNull(
focusedElement->GetClosestNativeAnonymousSubtreeRootParentOrHost()));
}
}
RefPtr<Element> element;
int32_t length = mAccessKeys.Count(); for (uint32_t i = 0; i < aAccessCharCodes.Length(); ++i) {
uint32_t ch = aAccessCharCodes[i];
nsAutoString accessKey;
AppendUCS4ToUTF16(ch, accessKey); for (count = 1; count <= length; ++count) { // mAccessKeys always stores Element instances.
MOZ_DIAGNOSTIC_ASSERT(length == mAccessKeys.Count());
element = mAccessKeys[(start + count) % length]; if (IsAccessKeyTarget(element, accessKey)) { if (!aExecute) { returntrue;
}
Document* doc = element->OwnerDoc(); constbool shouldActivate = [&] { if (!StaticPrefs::accessibility_accesskeycausesactivation()) { returnfalse;
} if (aIsRepeat && nsContentUtils::IsChromeDoc(doc)) { returnfalse;
}
// XXXedgar, Bug 1700646, maybe we could use other data structure to // make searching target with same accesskey easier, and current setup // could not ensure we cycle the target with tree order.
int32_t j = 0; while (++j < length) {
Element* el = mAccessKeys[(start + count + j) % length]; if (IsAccessKeyTarget(el, accessKey)) { returnfalse;
}
} returntrue;
}();
// TODO(bug 1641171): This shouldn't be needed if we considered the // accesskey combination properly. if (aIsTrustedEvent) {
doc->NotifyUserGestureActivation();
}
auto result =
element->PerformAccesskey(shouldActivate, aIsTrustedEvent); if (result.isOk()) { if (result.unwrap() && aIsTrustedEvent) { // If this is a child process, inform the parent that we want the // focus, but pass false since we don't want to change the window // order.
nsIDocShell* docShell = mPresContext->GetDocShell();
nsCOMPtr<nsIBrowserChild> child =
docShell ? docShell->GetBrowserChild() : nullptr; if (child) {
child->SendRequestFocus(false, CallerType::System);
}
} returntrue;
}
}
}
} returnfalse;
}
bool EventStateManager::WalkESMTreeToHandleAccessKey(
WidgetKeyboardEvent* aEvent, nsPresContext* aPresContext,
nsTArray<uint32_t>& aAccessCharCodes, nsIDocShellTreeItem* aBubbledFrom,
ProcessingAccessKeyState aAccessKeyState, bool aExecute) {
EnsureDocument(mPresContext);
nsCOMPtr<nsIDocShell> docShell = aPresContext->GetDocShell(); if (NS_WARN_IF(!docShell) || NS_WARN_IF(!mDocument)) { returnfalse;
}
AccessKeyType accessKeyType = GetAccessKeyTypeFor(docShell); if (accessKeyType == AccessKeyType::eNone) { returnfalse;
} // Alt or other accesskey modifier is down, we may need to do an accesskey. if (mAccessKeys.Count() > 0 &&
aEvent->ModifiersMatchWithAccessKey(accessKeyType)) { // Someone registered an accesskey. Find and activate it. if (LookForAccessKeyAndExecute(aAccessCharCodes, aEvent->IsTrusted(),
aEvent->mIsRepeat, aExecute)) { returntrue;
}
}
int32_t childCount;
docShell->GetInProcessChildCount(&childCount); for (int32_t counter = 0; counter < childCount; counter++) { // Not processing the child which bubbles up the handling
nsCOMPtr<nsIDocShellTreeItem> subShellItem;
docShell->GetInProcessChildAt(counter, getter_AddRefs(subShellItem)); if (aAccessKeyState == eAccessKeyProcessingUp &&
subShellItem == aBubbledFrom) { continue;
}
nsCOMPtr<nsIDocShell> subDS = do_QueryInterface(subShellItem); if (subDS && IsShellVisible(subDS)) { // Guarantee subPresShell lifetime while we're handling access key // since somebody may assume that it won't be deleted before the // corresponding nsPresContext and EventStateManager.
RefPtr<PresShell> subPresShell = subDS->GetPresShell();
// Docshells need not have a presshell (eg. display:none // iframes, docshells in transition between documents, etc). if (!subPresShell) { // Oh, well. Just move on to the next child continue;
}
if (esm && esm->WalkESMTreeToHandleAccessKey(
aEvent, subPresContext, aAccessCharCodes, nullptr,
eAccessKeyProcessingDown, aExecute)) { returntrue;
}
}
} // if end . checking all sub docshell ends here.
// bubble up the process to the parent docshell if necessary if (eAccessKeyProcessingDown != aAccessKeyState) {
nsCOMPtr<nsIDocShellTreeItem> parentShellItem;
docShell->GetInProcessParent(getter_AddRefs(parentShellItem));
nsCOMPtr<nsIDocShell> parentDS = do_QueryInterface(parentShellItem); if (parentDS) { // Guarantee parentPresShell lifetime while we're handling access key // since somebody may assume that it won't be deleted before the // corresponding nsPresContext and EventStateManager.
RefPtr<PresShell> parentPresShell = parentDS->GetPresShell();
NS_ASSERTION(parentPresShell, "Our PresShell exists but the parent's does not?");
RefPtr<nsPresContext> parentPresContext =
parentPresShell->GetPresContext();
NS_ASSERTION(parentPresContext, "PresShell without PresContext");
RefPtr<EventStateManager> esm = static_cast<EventStateManager*>(
parentPresContext->EventStateManager()); if (esm && esm->WalkESMTreeToHandleAccessKey(
aEvent, parentPresContext, aAccessCharCodes, docShell,
eAccessKeyProcessingDown, aExecute)) { returntrue;
}
}
} // if end. bubble up process
// If the content access key modifier is pressed, try remote children if (aExecute &&
aEvent->ModifiersMatchWithAccessKey(AccessKeyType::eContent) &&
mDocument && mDocument->GetWindow()) { // If the focus is currently on a node with a BrowserParent, the key event // should've gotten forwarded to the child process and HandleAccessKey // called from there. if (BrowserParent::GetFrom(GetFocusedElement())) { // If access key may be only in remote contents, this method won't handle // access key synchronously. In this case, only reply event should reach // here.
MOZ_ASSERT(aEvent->IsHandledInRemoteProcess() ||
!aEvent->IsWaitingReplyFromRemoteProcess());
} // If focus is somewhere else, then we need to check the remote children. // However, if the event has already been handled in a remote process, // then, focus is moved from the remote process after posting the event. // In such case, we shouldn't retry to handle access keys in remote // processes. elseif (!aEvent->IsHandledInRemoteProcess()) {
AccessKeyInfo accessKeyInfo(aEvent, aAccessCharCodes);
nsContentUtils::CallOnAllRemoteChildren(
mDocument->GetWindow(),
[&accessKeyInfo](BrowserParent* aBrowserParent) -> CallState { // Only forward accesskeys for the active tab. if (aBrowserParent->GetDocShellIsActive()) { // Even if there is no target for the accesskey in this process, // the event may match with a content accesskey. If so, the // keyboard event should be handled with reply event for // preventing double action. (e.g., Alt+Shift+F on Windows may // focus a content in remote and open "File" menu.)
accessKeyInfo.event->StopPropagation();
accessKeyInfo.event->MarkAsWaitingReplyFromRemoteProcess();
aBrowserParent->HandleAccessKey(*accessKeyInfo.event,
accessKeyInfo.charCodes); return CallState::Stop;
}
WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent(); bool isContextMenuKey = mouseEvent && mouseEvent->IsContextMenuKeyEvent(); if (aEvent->mClass == eKeyboardEventClass || isContextMenuKey) { // APZ attaches a LayersId to hit-testable events, for keyboard events, // we use focus.
BrowserParent* preciseRemote = BrowserParent::GetFocused(); if (preciseRemote) {
remote = preciseRemote;
} // else there is a race between layout and focus tracking, // so fall back to delivering the event to the topmost child process.
} elseif (aEvent->mLayersId.IsValid()) {
BrowserParent* preciseRemote =
BrowserParent::GetBrowserParentFromLayersId(aEvent->mLayersId); if (preciseRemote) {
remote = preciseRemote;
} // else there is a race between APZ and the LayersId to BrowserParent // mapping, so fall back to delivering the event to the topmost child // process.
}
// SendReal* will transform the coordinate to the child process coordinate // space. So restore the coordinate after the event has been dispatched to the // child process to avoid using the transformed coordinate afterward.
AutoRestore<LayoutDeviceIntPoint> restore(aEvent->mRefPoint); switch (aEvent->mClass) { case ePointerEventClass:
MOZ_ASSERT(aEvent->mMessage == eContextMenu);
[[fallthrough]]; case eMouseEventClass: {
BrowserParent* oldRemote = BrowserParent::GetLastMouseRemoteTarget();
// If this is a eMouseExitFromWidget event, need to redirect the event to // the last remote and and notify all its ancestors about the exit, if // any. if (mouseEvent->mMessage == eMouseExitFromWidget) {
MOZ_ASSERT(mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePuppet);
MOZ_ASSERT(mouseEvent->mReason == WidgetMouseEvent::eReal);
MOZ_ASSERT(!mouseEvent->mLayersId.IsValid());
MOZ_ASSERT(remote->GetBrowserHost());
// If a mouse is over a remote target A, and then moves to // remote target B, we'd deliver the event directly to remote target B // after the moving, A would never get notified that the mouse left. // So we generate a exit event to notify A after the move. // XXXedgar, if the synthesized mouse events could deliver to the correct // process directly (see // https://bugzilla.mozilla.org/show_bug.cgi?id=1549355), we probably // don't need to check mReason then. if (mouseEvent->mReason == WidgetMouseEvent::eReal &&
remote != oldRemote) {
MOZ_ASSERT(mouseEvent->mMessage != eMouseExitFromWidget); if (oldRemote) {
BrowserParent* commonAncestor =
nsContentUtils::GetCommonBrowserParentAncestor(remote, oldRemote); if (commonAncestor == oldRemote) { // Mouse moves to the inner OOP frame, it is not a really exit.
DispatchCrossProcessMouseExitEvents(
mouseEvent, GetBrowserParentAncestor(remote),
GetBrowserParentAncestor(commonAncestor), false);
} elseif (commonAncestor == remote) { // Mouse moves to the outer OOP frame, it is a really exit.
DispatchCrossProcessMouseExitEvents(mouseEvent, oldRemote,
commonAncestor, true);
} else { // Mouse moves to OOP frame in other subtree, it is a really exit, // need to notify all its ancestors before common ancestor about the // exit.
DispatchCrossProcessMouseExitEvents(mouseEvent, oldRemote,
commonAncestor, true); if (commonAncestor) {
UniquePtr<WidgetMouseEvent> mouseExitEvent =
CreateMouseOrPointerWidgetEvent(mouseEvent,
eMouseExitFromWidget,
mouseEvent->mRelatedTarget);
mouseExitEvent->mExitFrom =
Some(WidgetMouseEvent::ePuppetParentToPuppetChild);
commonAncestor->SendRealMouseEvent(*mouseExitEvent);
}
}
}
if (mouseEvent->mMessage != eMouseExitFromWidget &&
mouseEvent->mMessage != eMouseEnterIntoWidget) { // This is to make cursor would be updated correctly.
remote->MouseEnterIntoWidget();
}
}
remote->SendRealMouseEvent(*mouseEvent); return;
} case eKeyboardEventClass: { auto* keyboardEvent = aEvent->AsKeyboardEvent(); if (aEvent->mMessage == eKeyUp) {
HandleKeyUpInteraction(keyboardEvent);
}
remote->SendRealKeyEvent(*keyboardEvent); return;
} case eWheelEventClass: { if (BrowserParent* pointerLockedRemote =
PointerLockManager::GetLockedRemoteTarget()) {
remote = pointerLockedRemote;
}
remote->SendMouseWheelEvent(*aEvent->AsWheelEvent()); return;
} case eTouchEventClass: { // Let the child process synthesize a mouse event if needed, and // ensure we don't synthesize one in this process.
*aStatus = nsEventStatus_eConsumeNoDefault;
remote->SendRealTouchEvent(*aEvent->AsTouchEvent()); return;
} case eDragEventClass: {
RefPtr<BrowserParent> browserParent = remote;
browserParent->MaybeInvokeDragSession(aEvent->mMessage);
MOZ_ASSERT(!aEvent->HasBeenPostedToRemoteProcess(), "Why do we need to post same event to remote processes again?");
// Collect the remote event targets we're going to forward this // event to. // // NB: the elements of |remoteTargets| must be unique, for correctness.
AutoTArray<RefPtr<BrowserParent>, 1> remoteTargets; if (aEvent->mClass != eTouchEventClass || aEvent->mMessage == eTouchStart) { // If this event only has one target, and it's remote, add it to // the array.
nsIFrame* frame = aEvent->mMessage == eDragExit
? sLastDragOverFrame.GetFrame()
: GetEventTarget();
nsIContent* target = frame ? frame->GetContent() : nullptr; if (BrowserParent* remoteTarget = BrowserParent::GetFrom(target)) {
remoteTargets.AppendElement(remoteTarget);
}
} else { // This is a touch event with possibly multiple touch points. // Each touch point may have its own target. So iterate through // all of them and collect the unique set of targets for event // forwarding. // // This loop is similar to the one used in // PresShell::DispatchTouchEvent(). const WidgetTouchEvent::TouchArray& touches =
aEvent->AsTouchEvent()->mTouches; for (uint32_t i = 0; i < touches.Length(); ++i) {
Touch* touch = touches[i]; // NB: the |mChanged| check is an optimization, subprocesses can // compute this for themselves. If the touch hasn't changed, we // may be able to avoid forwarding the event entirely (which is // not free). if (!touch || !touch->mChanged) { continue;
}
nsCOMPtr<EventTarget> targetPtr = touch->mTarget; if (!targetPtr) { continue;
}
nsCOMPtr<nsIContent> target = do_QueryInterface(targetPtr);
BrowserParent* remoteTarget = BrowserParent::GetFrom(target); if (remoteTarget && !remoteTargets.Contains(remoteTarget)) {
remoteTargets.AppendElement(remoteTarget);
}
}
}
if (remoteTargets.Length() == 0) { returnfalse;
}
// Dispatch the event to the remote target. for (uint32_t i = 0; i < remoteTargets.Length(); ++i) {
DispatchCrossProcessEvent(aEvent, remoteTargets[i], aStatus);
} return aEvent->HasBeenPostedToRemoteProcess();
}
// // CreateClickHoldTimer // // Fire off a timer for determining if the user wants click-hold. This timer // is a one-shot that will be cancelled when the user moves enough to fire // a drag. // void EventStateManager::CreateClickHoldTimer(nsPresContext* inPresContext,
nsIFrame* inDownFrame,
WidgetGUIEvent* inMouseDownEvent) { if (!inMouseDownEvent->IsTrusted() ||
IsTopLevelRemoteTarget(mGestureDownContent) ||
PointerLockManager::IsLocked()) { return;
}
// just to be anal (er, safe) if (mClickHoldTimer) {
mClickHoldTimer->Cancel();
mClickHoldTimer = nullptr;
}
// if content clicked on has a popup, don't even start the timer // since we'll end up conflicting and both will show. if (mGestureDownContent &&
nsContentUtils::HasNonEmptyAttr(mGestureDownContent, kNameSpaceID_None,
nsGkAtoms::popup)) { return;
}
// // KillClickHoldTimer // // Stop the timer that would show the context menu dead in its tracks // void EventStateManager::KillClickHoldTimer() { if (mClickHoldTimer) {
mClickHoldTimer->Cancel();
mClickHoldTimer = nullptr;
}
}
// // sClickHoldCallback // // This fires after the mouse has been down for a certain length of time. // void EventStateManager::sClickHoldCallback(nsITimer* aTimer, void* aESM) {
RefPtr<EventStateManager> self = static_cast<EventStateManager*>(aESM); if (self) {
self->FireContextClick();
}
// NOTE: |aTimer| and |self->mAutoHideTimer| are invalid after calling // ClosePopup();
} // sAutoHideCallback
// // FireContextClick // // If we're this far, our timer has fired, which means the mouse has been down // for a certain period of time and has not moved enough to generate a // dragGesture. We can be certain the user wants a context-click at this stage, // so generate a dom event and fire it in. // // After the event fires, check if PreventDefault() has been set on the event // which means that someone either ate the event or put up a context menu. This // is our cue to stop tracking the drag gesture. If we always did this, // draggable items w/out a context menu wouldn't be draggable after a certain // length of time, which is _not_ what we want. // void EventStateManager::FireContextClick() { if (!mGestureDownContent || !mPresContext || PointerLockManager::IsLocked()) { return;
}
#ifdef XP_MACOSX // Hack to ensure that we don't show a context menu when the user // let go of the mouse after a long cpu-hogging operation prevented // us from handling any OS events. See bug 117589. if (!CGEventSourceButtonState(kCGEventSourceStateCombinedSessionState,
kCGMouseButtonLeft)) return; #endif
nsEventStatus status = nsEventStatus_eIgnore;
// Dispatch to the DOM. We have to fake out the ESM and tell it that the // current target frame is actually where the mouseDown occurred, otherwise it // will use the frame the mouse is currently over which may or may not be // the same. (Note: saari and I have decided that we don't have to reset // |mCurrentTarget| when we're through because no one else is doing anything // more with this event and it will get reset on the very next event to the // correct frame).
mCurrentTarget = mPresContext->GetPrimaryFrameFor(mGestureDownContent); // make sure the widget sticks around
nsCOMPtr<nsIWidget> targetWidget; if (mCurrentTarget && (targetWidget = mCurrentTarget->GetNearestWidget())) {
NS_ASSERTION(
mPresContext == mCurrentTarget->PresContext(), "a prescontext returned a primary frame that didn't belong to it?");
// before dispatching, check that we're not on something that // doesn't get a context menu bool allowedToDispatch = true;
if (mGestureDownContent->IsAnyOfXULElements(nsGkAtoms::scrollbar,
nsGkAtoms::scrollbarbutton,
nsGkAtoms::button)) {
allowedToDispatch = false;
} elseif (mGestureDownContent->IsXULElement(nsGkAtoms::toolbarbutton)) { // a <toolbarbutton> that has the container attribute set // will already have its own dropdown. if (nsContentUtils::HasNonEmptyAttr(
mGestureDownContent, kNameSpaceID_None, nsGkAtoms::container)) {
allowedToDispatch = false;
} else { // If the toolbar button has an open menu, don't attempt to open // a second menu if (mGestureDownContent->IsElement() &&
mGestureDownContent->AsElement()->AttrValueIs(
kNameSpaceID_None, nsGkAtoms::open, nsGkAtoms::_true,
eCaseMatters)) {
allowedToDispatch = false;
}
}
} elseif (mGestureDownContent->IsHTMLElement()) { if (constauto* formCtrl =
nsIFormControl::FromNode(mGestureDownContent)) {
allowedToDispatch =
formCtrl->IsTextControl(/*aExcludePassword*/ false) ||
formCtrl->ControlType() == FormControlType::InputFile;
} elseif (mGestureDownContent->IsAnyOfHTMLElements(
nsGkAtoms::embed, nsGkAtoms::object, nsGkAtoms::label)) {
allowedToDispatch = false;
}
}
if (allowedToDispatch) { // init the event while mCurrentTarget is still good
WidgetPointerEvent event(true, eContextMenu, targetWidget);
event.mClickCount = 1;
FillInEventFromGestureDown(&event);
// we need to forget the clicking content and click count for the // following eMouseUp event when click-holding context menus
LastMouseDownInfo& mouseDownInfo = GetLastMouseDownInfo(event.mButton);
mouseDownInfo.mLastMouseDownContent = nullptr;
mouseDownInfo.mClickCount = 0;
mouseDownInfo.mLastMouseDownInputControlType = Nothing();
// stop selection tracking, we're in control now if (mCurrentTarget) {
RefPtr<nsFrameSelection> frameSel = mCurrentTarget->GetFrameSelection();
if (frameSel && frameSel->GetDragState()) { // note that this can cause selection changed events to fire if we're // in a text field, which will null out mCurrentTarget
frameSel->SetDragState(false);
}
}
// dispatch to DOM
RefPtr<nsPresContext> presContext = mPresContext;
// The contextmenu event handled by PresShell will apply to elements (not // all nodes) correctly and will be dispatched to EventStateManager for // further handling preventing click event and stopping tracking drag // gesture. if (RefPtr<PresShell> presShell = presContext->GetPresShell()) {
presShell->HandleEvent(mCurrentTarget, &event, false, &status);
}
// We don't need to dispatch to frame handling because no frames // watch eContextMenu except for nsMenuFrame and that's only for // dismissal. That's just as well since we don't really know // which frame to send it to.
}
}
// stop tracking a drag whatever the event has been handled or not.
StopTrackingDragGesture(true);
KillClickHoldTimer();
} // FireContextClick
// // BeginTrackingDragGesture // // Record that the mouse has gone down and that we should move to TRACKING state // of d&d gesture tracker. // // We also use this to track click-hold context menus. When the mouse goes down, // fire off a short timer. If the timer goes off and we have yet to fire the // drag gesture (ie, the mouse hasn't moved a certain distance), then we can // assume the user wants a click-hold, so fire a context-click event. We only // want to cancel the drag gesture if the context-click event is handled. // void EventStateManager::BeginTrackingDragGesture(nsPresContext* aPresContext,
WidgetMouseEvent* inDownEvent,
nsIFrame* inDownFrame) { if (!inDownEvent->mWidget) { return;
}
// Note that |inDownEvent| could be either a mouse down event or a // synthesized mouse move event.
SetGestureDownPoint(inDownEvent);
if (inDownFrame) {
inDownFrame->GetContentForEvent(inDownEvent,
getter_AddRefs(mGestureDownContent));
if (inDownEvent->mMessage != eMouseTouchDrag &&
StaticPrefs::ui_click_hold_context_menus()) { // fire off a timer to track click-hold
CreateClickHoldTimer(aPresContext, inDownFrame, inDownEvent);
}
}
// // StopTrackingDragGesture // // Record that the mouse has gone back up so that we should leave the TRACKING // state of d&d gesture tracker and return to the START state. // void EventStateManager::StopTrackingDragGesture(bool aClearInChildProcesses) {
mGestureDownContent = nullptr;
mGestureDownFrameOwner = nullptr;
mGestureDownInTextControl = false;
mGestureDownDragStartData = nullptr;
// If a content process starts a drag but the mouse is released before the // parent starts the actual drag, the content process will think a drag is // still happening. Inform any child processes with active drags that the drag // should be stopped. if (!aClearInChildProcesses || !XRE_IsParentProcess()) { return;
}
// Only notify if there is NOT a drag session active in the parent.
RefPtr<nsIDragSession> dragSession =
nsContentUtils::GetDragSession(mPresContext); if (dragSession) { return;
}
nsCOMPtr<nsIDragService> dragService =
do_GetService("@mozilla.org/widget/dragservice;1"); if (!dragService) { return;
}
dragService->RemoveAllBrowsers();
}
// Set the coordinates in the new event to the coordinates of // the old event, adjusted for the fact that the widget might be // different
aEvent->mRefPoint =
mGestureDownPoint - aEvent->mWidget->WidgetToScreenOffset();
aEvent->mModifiers = mGestureModifiers;
aEvent->mButtons = mGestureDownButtons; if (aEvent->mMessage == eContextMenu) {
aEvent->mButton = mGestureDownButton;
}
}
// HandleEventWithTarget clears out mCurrentTarget, which may be used in the // caller GenerateDragGesture. We have to restore mCurrentTarget.
mCurrentTarget = targetFrame;
}
// // GenerateDragGesture // // If we're in the TRACKING state of the d&d gesture tracker, check the current // position of the mouse in relation to the old one. If we've moved a sufficient // amount from the mouse down, then fire off a drag gesture event. void EventStateManager::GenerateDragGesture(nsPresContext* aPresContext,
WidgetInputEvent* aEvent) {
NS_ASSERTION(aPresContext, "This shouldn't happen."); if (!IsTrackingDragGesture()) { return;
}
if (!mCurrentTarget || !mCurrentTarget->GetNearestWidget()) {
StopTrackingDragGesture(true); return;
}
// Check if selection is tracking drag gestures, if so // don't interfere! if (mCurrentTarget) {
RefPtr<nsFrameSelection> frameSel = mCurrentTarget->GetFrameSelection(); if (frameSel && frameSel->GetDragState()) {
StopTrackingDragGesture(true); return;
}
}
// If non-native code is capturing the mouse don't start a drag. if (PresShell::IsMouseCapturePreventingDrag()) {
StopTrackingDragGesture(true); return;
}
if (!IsEventOutsideDragThreshold(aEvent)) { // To keep the old behavior, flush layout even if we don't start dnd.
FlushLayout(aPresContext); return;
}
if (StaticPrefs::ui_click_hold_context_menus()) { // stop the click-hold before we fire off the drag gesture, in case // it takes a long time
KillClickHoldTimer();
}
nsCOMPtr<nsIDocShell> docshell = aPresContext->GetDocShell(); if (!docshell) { return;
}
nsCOMPtr<nsPIDOMWindowOuter> window = docshell->GetWindow(); if (!window) return;
RefPtr<DataTransfer> dataTransfer = new DataTransfer(window, eDragStart, /* aIsExternal */ false, /* aClipboardType */ Nothing()); auto protectDataTransfer = MakeScopeExit([&] { if (dataTransfer) {
dataTransfer->Disconnect();
}
});
RefPtr<Selection> selection;
RefPtr<RemoteDragStartData> remoteDragStartData;
nsCOMPtr<nsIContent> eventContent, targetContent;
nsCOMPtr<nsIPrincipal> principal;
nsCOMPtr<nsIContentSecurityPolicy> csp;
nsCOMPtr<nsICookieJarSettings> cookieJarSettings; bool allowEmptyDataTransfer = false;
mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(eventContent)); if (eventContent) { // If the content is a text node in a password field, we shouldn't // allow to drag its raw text. Note that we've supported drag from // password fields but dragging data was masked text. So, it doesn't // make sense anyway. if (eventContent->IsText() && eventContent->HasFlag(NS_MAYBE_MASKED)) { // However, it makes sense to allow to drag selected password text // when copying selected password is allowed because users may want // to use drag and drop rather than copy and paste when web apps // request to input password twice for conforming new password but // they used password generator. const TextEditor* const textEditor =
nsContentUtils::GetExtantTextEditorFromAnonymousNode(eventContent); if (!textEditor || !textEditor->IsCopyToClipboardAllowed()) {
StopTrackingDragGesture(true); return;
}
}
DetermineDragTargetAndDefaultData(
window, eventContent, dataTransfer, &allowEmptyDataTransfer,
getter_AddRefs(selection), getter_AddRefs(remoteDragStartData),
getter_AddRefs(targetContent), getter_AddRefs(principal),
getter_AddRefs(csp), getter_AddRefs(cookieJarSettings));
}
// Stop tracking the drag gesture now. This should stop us from // reentering GenerateDragGesture inside DOM event processing. // Pass false to avoid clearing the child process state since a real // drag should be starting.
StopTrackingDragGesture(false);
if (!targetContent) return;
// Use our targetContent, now that we've determined it, as the // parent object of the DataTransfer.
nsCOMPtr<nsIContent> parentContent =
targetContent->FindFirstNonChromeOnlyAccessContent();
dataTransfer->SetParentObject(parentContent);
// get the widget from the target frame
WidgetDragEvent startEvent(aEvent->IsTrusted(), eDragStart, widget);
startEvent.mFlags.mIsSynthesizedForTests =
aEvent->mFlags.mIsSynthesizedForTests;
FillInEventFromGestureDown(&startEvent);
// Dispatch to the DOM. By setting mCurrentTarget we are faking // out the ESM and telling it that the current target frame is // actually where the mouseDown occurred, otherwise it will use // the frame the mouse is currently over which may or may not be // the same.
// Hold onto old target content through the event and reset after.
nsCOMPtr<nsIContent> targetBeforeEvent = mCurrentTargetContent;
// Set the current target to the content for the mouse down
mCurrentTargetContent = targetContent;
// Dispatch the dragstart event to the DOM.
nsEventStatus status = nsEventStatus_eIgnore;
EventDispatcher::Dispatch(targetContent, aPresContext, &startEvent, nullptr,
&status);
WidgetDragEvent* event = &startEvent;
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService(); // Emit observer event to allow addons to modify the DataTransfer // object. if (observerService) {
observerService->NotifyObservers(dataTransfer, "on-datatransfer-available",
nullptr);
}
// In chrome, only allow dragging inside editable areas. bool isChromeContext = !aWindow->GetBrowsingContext()->IsContent(); if (isChromeContext && !editingElement) { if (mGestureDownDragStartData) { // A child process started a drag so use any data it assigned for the dnd // session.
mGestureDownDragStartData->AddInitialDnDDataTo(aDataTransfer, aPrincipal,
aCsp, aCookieJarSettings);
mGestureDownDragStartData.forget(aRemoteDragStartData);
*aAllowEmptyDataTransfer = true;
}
} else {
mGestureDownDragStartData = nullptr;
// GetDragData determines if a selection, link or image in the content // should be dragged, and places the data associated with the drag in the // data transfer. // mGestureDownContent is the node where the mousedown event for the drag // occurred, and aSelectionTarget is the node to use when a selection is // used bool canDrag; bool wasAlt = (mGestureModifiers & MODIFIER_ALT) != 0;
nsresult rv = nsContentAreaDragDrop::GetDragData(
aWindow, mGestureDownContent, aSelectionTarget, wasAlt, aDataTransfer,
&canDrag, aSelection, getter_AddRefs(dragDataNode), aCsp,
aCookieJarSettings); if (NS_FAILED(rv) || !canDrag) { return;
}
}
// if GetDragData returned a node, use that as the node being dragged. // Otherwise, if a selection is being dragged, use the node within the // selection that was dragged. Otherwise, just use the mousedown target.
nsIContent* dragContent = mGestureDownContent; if (dragDataNode)
dragContent = dragDataNode; elseif (*aSelection)
dragContent = aSelectionTarget;
nsIContent* originalDragContent = dragContent;
// If a selection isn't being dragged, look for an ancestor with the // draggable property set. If one is found, use that as the target of the // drag instead of the node that was clicked on. If a draggable node wasn't // found, just use the clicked node. if (!*aSelection) { while (dragContent) { if (auto htmlElement = nsGenericHTMLElement::FromNode(dragContent)) { if (htmlElement->Draggable()) { // We let draggable elements to trigger dnd even if there is no data // in the DataTransfer.
*aAllowEmptyDataTransfer = true; break;
}
} else { if (dragContent->IsXULElement()) { // All XUL elements are draggable, so if a XUL element is // encountered, stop looking for draggable nodes and just use the // original clicked node instead. // XXXndeakin // In the future, we will want to improve this so that XUL has a // better way to specify whether something is draggable than just // on/off.
dragContent = mGestureDownContent; break;
} // otherwise, it's not an HTML or XUL element, so just keep looking
}
dragContent = dragContent->GetFlattenedTreeParent();
}
}
// if no node in the hierarchy was found to drag, but the GetDragData method // returned a node, use that returned node. Otherwise, nothing is draggable. if (!dragContent && dragDataNode) dragContent = dragDataNode;
if (dragContent) { // if an ancestor node was used instead, clear the drag data // XXXndeakin rework this a bit. Find a way to just not call GetDragData if // we don't need to. if (dragContent != originalDragContent) aDataTransfer->ClearAll();
*aTargetNode = dragContent;
NS_ADDREF(*aTargetNode);
}
}
// Default handling for the dragstart event. // // First, check if a drag session already exists. This means that the drag // service was called directly within a draggesture handler. In this case, // don't do anything more, as it is assumed that the handler is managing // drag and drop manually. Make sure to return true to indicate that a drag // began. However, if we're handling drag session for synthesized events, // we need to initialize some information of the session. Therefore, we // need to keep going for synthesized case. if (MOZ_UNLIKELY(!mPresContext)) { returntrue;
}
nsCOMPtr<nsIDragSession> dragSession =
dragService->GetCurrentSession(mPresContext->GetRootWidget()); if (dragSession && !dragSession->IsSynthesizedForTests()) { returntrue;
}
// No drag session is currently active, so check if a handler added // any items to be dragged. If not, there isn't anything to drag.
uint32_t count = 0; if (aDataTransfer) {
count = aDataTransfer->MozItemCount();
} if (!aAllowEmptyDataTransfer && !count) { returnfalse;
}
// Get the target being dragged, which may not be the same as the // target of the mouse event. If one wasn't set in the // aDataTransfer during the event handler, just use the original // target instead.
nsCOMPtr<nsIContent> dragTarget = aDataTransfer->GetDragTarget(); if (!dragTarget) {
dragTarget = aDragTarget; if (!dragTarget) { returnfalse;
}
}
// check which drag effect should initially be used. If the effect was not // set, just use all actions, otherwise Windows won't allow a drop.
uint32_t action = aDataTransfer->EffectAllowedInt(); if (action == nsIDragService::DRAGDROP_ACTION_UNINITIALIZED) {
action = nsIDragService::DRAGDROP_ACTION_COPY |
nsIDragService::DRAGDROP_ACTION_MOVE |
nsIDragService::DRAGDROP_ACTION_LINK;
}
// get any custom drag image that was set
int32_t imageX, imageY;
RefPtr<Element> dragImage = aDataTransfer->GetDragImage(&imageX, &imageY);
nsCOMPtr<nsIArray> transArray = aDataTransfer->GetTransferables(dragTarget); if (!transArray) { returnfalse;
}
RefPtr<DataTransfer> dataTransfer; if (!dragSession) { // After this function returns, the DataTransfer will be cleared so it // appears empty to content. We need to pass a DataTransfer into the Drag // Session, so we need to make a copy.
aDataTransfer->Clone(aDragTarget, eDrop, aDataTransfer->MozUserCancelled(), false, getter_AddRefs(dataTransfer));
// Copy over the drop effect, as Clone doesn't copy it for us.
dataTransfer->SetDropEffectInt(aDataTransfer->DropEffectInt());
} else {
MOZ_ASSERT(dragSession->IsSynthesizedForTests());
MOZ_ASSERT(aDragEvent->mFlags.mIsSynthesizedForTests); // If we're initializing synthesized drag session, we should use given // DataTransfer as is because it'll be used with following drag events // in any tests, therefore it should be set to nsIDragSession.dataTransfer // because it and DragEvent.dataTransfer should be same instance.
dataTransfer = aDataTransfer;
}
// XXXndeakin don't really want to create a new drag DOM event // here, but we need something to pass to the InvokeDragSession // methods.
RefPtr<DragEvent> event =
NS_NewDOMDragEvent(dragTarget, aPresContext, aDragEvent);
// Use InvokeDragSessionWithSelection if a selection is being dragged, // such that the image can be generated from the selected text. However, // use InvokeDragSessionWithImage if a custom image was set or something // other than a selection is being dragged. if (!dragImage && aSelection) {
dragService->InvokeDragSessionWithSelection(
aSelection, aPrincipal, aCsp, aCookieJarSettings, transArray, action,
event, dataTransfer, dragTarget);
} elseif (aDragStartData) {
MOZ_ASSERT(XRE_IsParentProcess());
dragService->InvokeDragSessionWithRemoteImage(
dragTarget, aPrincipal, aCsp, aCookieJarSettings, transArray, action,
aDragStartData, event, dataTransfer);
} else {
dragService->InvokeDragSessionWithImage(
dragTarget, aPrincipal, aCsp, aCookieJarSettings, transArray, action,
dragImage, imageX, imageY, event, dataTransfer);
}
returntrue;
}
void EventStateManager::ChangeZoom(bool aIncrease) { // Send the zoom change to the top level browser so it will be handled by the // front end in the same way as other zoom actions.
nsIDocShell* docShell = mDocument->GetDocShell(); if (!docShell) { return;
}
BrowsingContext* bc = docShell->GetBrowsingContext(); if (!bc) { return;
}
void EventStateManager::DoScrollHistory(int32_t direction) {
nsCOMPtr<nsISupports> pcContainer(mPresContext->GetContainerWeak()); if (pcContainer) {
nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(pcContainer)); if (webNav) { // positive direction to go back one step, nonpositive to go forward // This is doing user-initiated history traversal, hence we want // to require that history entries we navigate to have user interaction. if (direction > 0)
webNav->GoBack(StaticPrefs::browser_navigation_requireUserInteraction(), true); else
webNav->GoForward(
StaticPrefs::browser_navigation_requireUserInteraction(), true);
}
}
}
void EventStateManager::DoScrollZoom(nsIFrame* aTargetFrame,
int32_t adjustment) { // Exclude content in chrome docshells.
nsIContent* content = aTargetFrame->GetContent(); if (content && !nsContentUtils::IsInChromeDocshell(content->OwnerDoc())) { // Positive adjustment to decrease zoom, negative to increase constbool increase = adjustment <= 0;
EnsureDocument(mPresContext);
ChangeZoom(increase);
}
}
static nsIFrame* GetParentFrameToScroll(nsIFrame* aFrame) { if (!aFrame) return nullptr;
if (!aTargetFrame || *aStatus == nsEventStatus_eConsumeNoDefault) { return;
}
// Ignore mouse wheel transaction for computing legacy mouse wheel // events' delta value. // DOM event's delta vales are computed from CSS pixels. auto scrollAmountInCSSPixels =
CSSIntSize::FromAppUnitsRounded(aEvent->mScrollAmount);
// XXX We don't deal with fractional amount in legacy event, though the // default action handler (DoScrollText()) deals with it. // If we implemented such strict computation, we would need additional // accumulated delta values. It would made the code more complicated. // And also it would computes different delta values from older version. // It doesn't make sense to implement such code for legacy events and // rare cases.
int32_t scrollDeltaX, scrollDeltaY, pixelDeltaX, pixelDeltaY; switch (aEvent->mDeltaMode) { case WheelEvent_Binding::DOM_DELTA_PAGE:
scrollDeltaX = !aEvent->mLineOrPageDeltaX
? 0
: (aEvent->mLineOrPageDeltaX > 0
? UIEvent_Binding::SCROLL_PAGE_DOWN
: UIEvent_Binding::SCROLL_PAGE_UP);
scrollDeltaY = !aEvent->mLineOrPageDeltaY
? 0
: (aEvent->mLineOrPageDeltaY > 0
? UIEvent_Binding::SCROLL_PAGE_DOWN
: UIEvent_Binding::SCROLL_PAGE_UP);
pixelDeltaX = RoundDown(aEvent->mDeltaX * scrollAmountInCSSPixels.width);
pixelDeltaY = RoundDown(aEvent->mDeltaY * scrollAmountInCSSPixels.height); break;
default:
MOZ_CRASH("Invalid deltaMode value comes");
}
// Send the legacy events in following order: // 1. Vertical scroll // 2. Vertical pixel scroll (even if #1 isn't consumed) // 3. Horizontal scroll (even if #1 and/or #2 are consumed) // 4. Horizontal pixel scroll (even if #3 isn't consumed)
AutoWeakFrame targetFrame(aTargetFrame);
MOZ_ASSERT(*aStatus != nsEventStatus_eConsumeNoDefault &&
!aEvent->DefaultPrevented(), "If you make legacy events dispatched for default prevented wheel " "event, you need to initialize stateX and stateY");
EventState stateX, stateY; if (scrollDeltaY) {
SendLineScrollEvent(aTargetFrame, aEvent, stateY, scrollDeltaY,
DELTA_DIRECTION_Y); if (!targetFrame.IsAlive()) {
*aStatus = nsEventStatus_eConsumeNoDefault; return;
}
}
if (pixelDeltaY) {
SendPixelScrollEvent(aTargetFrame, aEvent, stateY, pixelDeltaY,
DELTA_DIRECTION_Y); if (!targetFrame.IsAlive()) {
*aStatus = nsEventStatus_eConsumeNoDefault; return;
}
}
if (scrollDeltaX) {
SendLineScrollEvent(aTargetFrame, aEvent, stateX, scrollDeltaX,
DELTA_DIRECTION_X); if (!targetFrame.IsAlive()) {
*aStatus = nsEventStatus_eConsumeNoDefault; return;
}
}
if (pixelDeltaX) {
SendPixelScrollEvent(aTargetFrame, aEvent, stateX, pixelDeltaX,
DELTA_DIRECTION_X); if (!targetFrame.IsAlive()) {
*aStatus = nsEventStatus_eConsumeNoDefault; return;
}
}
if (stateY.mDefaultPrevented) {
*aStatus = nsEventStatus_eConsumeNoDefault;
aEvent->PreventDefault(!stateY.mDefaultPreventedByContent);
}
if (stateX.mDefaultPrevented) {
*aStatus = nsEventStatus_eConsumeNoDefault;
aEvent->PreventDefault(!stateX.mDefaultPreventedByContent);
}
}
// Overload ComputeScrollTargetAndMayAdjustWheelEvent method to allow passing // "test" dx and dy when looking for which scrollbarmediators to activate when // two finger down on trackpad and before any actual motion
ScrollContainerFrame*
EventStateManager::ComputeScrollTargetAndMayAdjustWheelEvent(
nsIFrame* aTargetFrame, double aDirectionX, double aDirectionY,
WidgetWheelEvent* aEvent, ComputeScrollTargetOptions aOptions) { bool isAutoDir = false; bool honoursRoot = false; if (MAY_BE_ADJUSTED_BY_AUTO_DIR & aOptions) { // If the scroll is respected as auto-dir, aDirection* should always be // equivalent to the event's delta vlaues(Currently, there are only one case // where aDirection*s have different values from the widget wheel event's // original delta values and the only case isn't auto-dir, see // ScrollbarsForWheel::TemporarilyActivateAllPossibleScrollTargets).
MOZ_ASSERT(aDirectionX == aEvent->mDeltaX &&
aDirectionY == aEvent->mDeltaY);
if (aOptions & PREFER_MOUSE_WHEEL_TRANSACTION) { // If the user recently scrolled with the mousewheel, then they probably // want to scroll the same view as before instead of the view under the // cursor. WheelTransaction tracks the frame currently being // scrolled with the mousewheel. We consider the transaction ended when the // mouse moves more than "mousewheel.transaction.ignoremovedelay" // milliseconds after the last scroll operation, or any time the mouse moves // out of the frame, or when more than "mousewheel.transaction.timeout" // milliseconds have passed after the last operation, even if the mouse // hasn't moved.
nsIFrame* lastScrollFrame = WheelTransaction::GetScrollTargetFrame(); if (lastScrollFrame) {
ScrollContainerFrame* scrollContainerFrame =
lastScrollFrame->GetScrollTargetFrame(); if (scrollContainerFrame) { if (isAutoDir) {
ESMAutoDirWheelDeltaAdjuster adjuster(*aEvent, *lastScrollFrame,
honoursRoot); // Note that calling this function will not always cause the delta to // be adjusted, it only adjusts the delta when it should, because // Adjust() internally calls ShouldBeAdjusted() before making // adjustment.
adjuster.Adjust();
} return scrollContainerFrame;
}
}
}
// If the event doesn't cause scroll actually, we cannot find scroll target // because we check if the event can cause scroll actually on each found // scrollable frame. if (!aDirectionX && !aDirectionY) { return nullptr;
}
bool checkIfScrollableX; bool checkIfScrollableY; if (isAutoDir) { // Always check the frame's scrollability in both the two directions for an // auto-dir scroll. That is, for an auto-dir scroll, // PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_X_AXIS and // PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_Y_AXIS should be ignored.
checkIfScrollableX = true;
checkIfScrollableY = true;
} else {
checkIfScrollableX =
aDirectionX &&
(aOptions & PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_X_AXIS);
checkIfScrollableY =
aDirectionY &&
(aOptions & PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_Y_AXIS);
}
nsIFrame* scrollFrame = !(aOptions & START_FROM_PARENT)
? aTargetFrame
: GetParentFrameToScroll(aTargetFrame); for (; scrollFrame; scrollFrame = GetParentFrameToScroll(scrollFrame)) { // Check whether the frame wants to provide us with a scrollable view.
ScrollContainerFrame* scrollContainerFrame =
scrollFrame->GetScrollTargetFrame(); if (!scrollContainerFrame) {
nsMenuPopupFrame* menuPopupFrame = do_QueryFrame(scrollFrame); if (menuPopupFrame) { return nullptr;
} continue;
}
if (!checkIfScrollableX && !checkIfScrollableY) { return scrollContainerFrame;
}
// If the frame disregards the direction the user is trying to scroll, then // it should just bubbles the scroll event up to its parental scroll frame
Maybe<layers::ScrollDirection> disregardedDirection =
WheelHandlingUtils::GetDisregardedWheelScrollDirection(scrollFrame); if (disregardedDirection) { switch (disregardedDirection.ref()) { case layers::ScrollDirection::eHorizontal: if (checkIfScrollableX) { continue;
} break; case layers::ScrollDirection::eVertical: if (checkIfScrollableY) { continue;
} break;
}
}
// Computes whether the currently checked frame is scrollable by this wheel // event. bool canScroll = false; if (isAutoDir) {
ESMAutoDirWheelDeltaAdjuster adjuster(*aEvent, *scrollFrame, honoursRoot); if (adjuster.ShouldBeAdjusted()) {
adjuster.Adjust();
canScroll = true;
} elseif (WheelHandlingUtils::CanScrollOn(scrollContainerFrame,
aDirectionX, aDirectionY)) {
canScroll = true;
}
} elseif (WheelHandlingUtils::CanScrollOn(scrollContainerFrame,
aDirectionX, aDirectionY)) {
canScroll = true;
}
if (canScroll) { return scrollContainerFrame;
}
// Where we are at is the block ending in a for loop. // The current frame has been checked to be unscrollable by this wheel // event, continue the loop to check its parent, if any.
}
constbool isPage = aEvent->mDeltaMode == WheelEvent_Binding::DOM_DELTA_PAGE; if (!aScrollContainerFrame) { // If there is no scrollable frame, we should use root, see below.
aScrollContainerFrame =
aPresContext->PresShell()->GetRootScrollContainerFrame();
}
if (aScrollContainerFrame) { return isPage ? aScrollContainerFrame->GetPageScrollAmount()
: aScrollContainerFrame->GetLineScrollAmount();
}
// If there is no scrollable frame and page scrolling, use viewport size. if (isPage) { return aPresContext->GetVisibleArea().Size();
}
// Otherwise use root frame's font metrics. // // FIXME(emilio): Should this use the root element's style frame? The root // frame will always have the initial font. Then again it should never matter // for content, we should always have a root scrollable frame in html // documents.
nsIFrame* rootFrame = aPresContext->PresShell()->GetRootFrame(); if (!rootFrame) { return nsSize(0, 0);
}
RefPtr<nsFontMetrics> fm =
nsLayoutUtils::GetInflatedFontMetricsForFrame(rootFrame);
NS_ENSURE_TRUE(fm, nsSize(0, 0)); return nsSize(fm->AveCharWidth(), fm->MaxHeight());
}
// We shouldn't scroll more one page at once except when over one page scroll // is allowed for the event.
nsSize pageSize = aScrollContainerFrame->GetPageScrollAmount();
nsIntSize devPixelPageSize(pc->AppUnitsToDevPixels(pageSize.width),
pc->AppUnitsToDevPixels(pageSize.height)); if (!WheelPrefs::GetInstance()->IsOverOnePageScrollAllowedX(aEvent) &&
DeprecatedAbs(actualDevPixelScrollAmount.x.value) >
devPixelPageSize.width) {
actualDevPixelScrollAmount.x = (actualDevPixelScrollAmount.x >= 0)
? devPixelPageSize.width
: -devPixelPageSize.width;
}
if (!scrollFrameWeak.IsAlive()) { // If the scroll causes changing the layout, we can think that the event // has been completely consumed by the content. Then, users probably don't // want additional action.
aEvent->mOverflowDeltaX = aEvent->mOverflowDeltaY = 0;
} elseif (isDeltaModePixel) {
aEvent->mOverflowDeltaX = overflow.x;
aEvent->mOverflowDeltaY = overflow.y;
} else {
aEvent->mOverflowDeltaX = static_cast<double>(overflow.x) / scrollAmountInDevPixels.width;
aEvent->mOverflowDeltaY = static_cast<double>(overflow.y) / scrollAmountInDevPixels.height;
}
// If CSS overflow properties caused not to scroll, the overflowDelta* values // should be same as delta* values since they may be used as gesture event by // widget. However, if there is another scrollable element in the ancestor // along the axis, probably users don't want the operation to cause // additional action such as moving history. In such case, overflowDelta // values should stay zero. if (scrollFrameWeak.IsAlive()) { if (aEvent->mDeltaX && overflowStyle.mHorizontal == StyleOverflow::Hidden &&
!ComputeScrollTargetAndMayAdjustWheelEvent(
aScrollContainerFrame, aEvent,
COMPUTE_SCROLLABLE_ANCESTOR_ALONG_X_AXIS_WITH_AUTO_DIR)) {
aEvent->mOverflowDeltaX = aEvent->mDeltaX;
} if (aEvent->mDeltaY && overflowStyle.mVertical == StyleOverflow::Hidden &&
!ComputeScrollTargetAndMayAdjustWheelEvent(
aScrollContainerFrame, aEvent,
COMPUTE_SCROLLABLE_ANCESTOR_ALONG_Y_AXIS_WITH_AUTO_DIR)) {
aEvent->mOverflowDeltaY = aEvent->mDeltaY;
}
}
NS_ASSERTION(
aEvent->mOverflowDeltaX == 0 ||
(aEvent->mOverflowDeltaX > 0) == (aEvent->mDeltaX > 0), "The sign of mOverflowDeltaX is different from the scroll direction");
NS_ASSERTION(
aEvent->mOverflowDeltaY == 0 ||
(aEvent->mOverflowDeltaY > 0) == (aEvent->mDeltaY > 0), "The sign of mOverflowDeltaY is different from the scroll direction");
void EventStateManager::DecideGestureEvent(WidgetGestureNotifyEvent* aEvent,
nsIFrame* targetFrame) {
NS_ASSERTION(aEvent->mMessage == eGestureNotify, "DecideGestureEvent called with a non-gesture event");
/* Check the ancestor tree to decide if any frame is willing* to receive * a MozPixelScroll event. If that's the case, the current touch gesture * will be used as a pan gesture; otherwise it will be a regular * mousedown/mousemove/click event. * * *willing: determine if it makes sense to pan the element using scroll * events: * - For web content: if there are any visible scrollbars on the touch point * - For XUL: if it's an scrollable element that can currently scroll in some * direction. * * Note: we'll have to one-off various cases to ensure a good usable behavior
*/
WidgetGestureNotifyEvent::PanDirection panDirection =
WidgetGestureNotifyEvent::ePanNone; bool displayPanFeedback = false; for (nsIFrame* current = targetFrame; current;
current = nsLayoutUtils::GetCrossDocParentFrame(current)) { // e10s - mark remote content as pannable. This is a work around since // we don't have access to remote frame scroll info here. Apz data may // assist is solving this. if (current && IsTopLevelRemoteTarget(current->GetContent())) {
panDirection = WidgetGestureNotifyEvent::ePanBoth; // We don't know when we reach bounds, so just disable feedback for now.
displayPanFeedback = false; break;
}
// Scrollbars should always be draggable if (currentFrameType == LayoutFrameType::Scrollbar) {
panDirection = WidgetGestureNotifyEvent::ePanNone; break;
}
// Special check for trees if (nsTreeBodyFrame* treeFrame = do_QueryFrame(current)) { if (treeFrame->GetVerticalOverflow()) {
panDirection = WidgetGestureNotifyEvent::ePanVertical;
} break;
}
if (ScrollContainerFrame* scrollContainerFrame = do_QueryFrame(current)) {
layers::ScrollDirections scrollbarVisibility =
scrollContainerFrame->GetScrollbarVisibility();
// Check if we have visible scrollbars if (scrollbarVisibility.contains(layers::ScrollDirection::eVertical)) {
panDirection = WidgetGestureNotifyEvent::ePanVertical;
displayPanFeedback = true; break;
}
if (!aKeyboardEvent->HasBeenPostedToRemoteProcess()) { if (aKeyboardEvent->IsWaitingReplyFromRemoteProcess()) {
RefPtr<BrowserParent> remote =
aTargetFrame ? BrowserParent::GetFrom(aTargetFrame->GetContent())
: nullptr; if (remote) { // remote is null-checked above in order to let pre-existing event // targeting code's chrome vs. content decision override in case of // disagreement in order not to disrupt non-Fission e10s mode in case // there are still bugs in the Fission-mode code. That is, if remote // is nullptr, the pre-existing event targeting code has deemed this // event to belong to chrome rather than content.
BrowserParent* preciseRemote = BrowserParent::GetFocused(); if (preciseRemote) {
remote = preciseRemote;
} // else there was a race between layout and focus tracking
} if (remote && !remote->IsReadyToHandleInputEvents()) { // We need to dispatch the event to the browser element again if we were // waiting for the key reply but the event wasn't sent to the content // process due to the remote browser wasn't ready.
WidgetKeyboardEvent keyEvent(*aKeyboardEvent);
aKeyboardEvent->MarkAsHandledInRemoteProcess();
RefPtr<Element> ownerElement = remote->GetOwnerElement();
EventDispatcher::Dispatch(ownerElement, presContext, &keyEvent); if (keyEvent.DefaultPrevented()) {
aKeyboardEvent->PreventDefault(!keyEvent.DefaultPreventedByContent());
aStatus = nsEventStatus_eConsumeNoDefault; return;
}
}
} // The widget expects a reply for every keyboard event. If the event wasn't // dispatched to a content process (non-e10s or no content process // running), we need to short-circuit here. Otherwise, we need to wait for // the content process to handle the event. if (aKeyboardEvent->mWidget) {
aKeyboardEvent->mWidget->PostHandleKeyEvent(aKeyboardEvent);
} if (aKeyboardEvent->DefaultPrevented()) {
aStatus = nsEventStatus_eConsumeNoDefault; return;
}
}
// XXX Currently, our automated tests don't support mKeyNameIndex. // Therefore, we still need to handle this with keyCode. switch (aKeyboardEvent->mKeyCode) { case NS_VK_TAB: case NS_VK_F6: // This is to prevent keyboard scrolling while alt modifier in use. if (!aKeyboardEvent->IsAlt()) {
aStatus = nsEventStatus_eConsumeNoDefault;
// Handling the tab event after it was sent to content is bad, // because to the FocusManager the remote-browser looks like one // element, so we would just move the focus to the next element // in chrome, instead of handling it in content. if (aKeyboardEvent->HasBeenPostedToRemoteProcess()) { break;
}
EnsureDocument(presContext);
nsFocusManager* fm = nsFocusManager::GetFocusManager(); if (fm && mDocument) { // Shift focus forward or back depending on shift key bool isDocMove = aKeyboardEvent->IsControl() ||
aKeyboardEvent->mKeyCode == NS_VK_F6;
uint32_t dir =
aKeyboardEvent->IsShift()
? (isDocMove ? static_cast<uint32_t>(
nsIFocusManager::MOVEFOCUS_BACKWARDDOC)
: static_cast<uint32_t>(
nsIFocusManager::MOVEFOCUS_BACKWARD))
: (isDocMove ? static_cast<uint32_t>(
nsIFocusManager::MOVEFOCUS_FORWARDDOC)
: static_cast<uint32_t>(
nsIFocusManager::MOVEFOCUS_FORWARD));
RefPtr<Element> result;
fm->MoveFocus(mDocument->GetWindow(), nullptr, dir,
nsIFocusManager::FLAG_BYKEY, getter_AddRefs(result));
}
} return; case 0: // We handle keys with no specific keycode value below. break; default: return;
}
switch (aKeyboardEvent->mKeyNameIndex) { case KEY_NAME_INDEX_ZoomIn: case KEY_NAME_INDEX_ZoomOut:
ChangeZoom(aKeyboardEvent->mKeyNameIndex == KEY_NAME_INDEX_ZoomIn);
aStatus = nsEventStatus_eConsumeNoDefault; break; default: break;
}
}
staticbool NeedsActiveContentChange(const WidgetMouseEvent* aMouseEvent) { // If the mouse event is a synthesized mouse event due to a touch, do // not set/clear the activation state. Element activation is handled by APZ. return !aMouseEvent ||
aMouseEvent->mInputSource != MouseEvent_Binding::MOZ_SOURCE_TOUCH;
}
HandleCrossProcessEvent(aEvent, aStatus); // NOTE: the above call may have destroyed aTargetFrame, please use // mCurrentTarget henceforth. This is to avoid using it accidentally:
aTargetFrame = nullptr;
// Most of the events we handle below require a frame. // Add special cases here. if (!mCurrentTarget && aEvent->mMessage != eMouseUp &&
aEvent->mMessage != eMouseDown && aEvent->mMessage != eDragEnter &&
aEvent->mMessage != eDragOver && aEvent->mMessage != ePointerUp &&
aEvent->mMessage != ePointerCancel) { return NS_OK;
}
// Keep the prescontext alive, we might need it after event dispatch
RefPtr<nsPresContext> presContext = aPresContext;
nsresult ret = NS_OK;
switch (aEvent->mMessage) { case eMouseDown: {
WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent(); if (mouseEvent->mButton == MouseButton::ePrimary &&
!sNormalLMouseEventInProcess) { // We got a mouseup event while a mousedown event was being processed. // Make sure that the capturing content is cleared.
PresShell::ReleaseCapturingContent(); break;
}
// For remote content, capture the event in the parent process at the // <xul:browser remote> element. This will ensure that subsequent // mousemove/mouseup events will continue to be dispatched to this element // and therefore forwarded to the child. if (aEvent->HasBeenPostedToRemoteProcess() &&
!PresShell::GetCapturingContent()) { if (nsIContent* content =
mCurrentTarget ? mCurrentTarget->GetContent() : nullptr) {
PresShell::SetCapturingContent(content, CaptureFlags::None, aEvent);
} else {
PresShell::ReleaseCapturingContent();
}
}
// If MouseEvent::PreventClickEvent() was called by chrome script, // we need to forget the clicking content and click count for the // following eMouseUp event. if (mouseEvent->mClickEventPrevented) { switch (mouseEvent->mButton) { case MouseButton::ePrimary: case MouseButton::eSecondary: case MouseButton::eMiddle: {
LastMouseDownInfo& mouseDownInfo =
GetLastMouseDownInfo(mouseEvent->mButton);
mouseDownInfo.mLastMouseDownContent = nullptr;
mouseDownInfo.mClickCount = 0;
mouseDownInfo.mLastMouseDownInputControlType = Nothing(); break;
}
default: break;
}
}
nsCOMPtr<nsIContent> activeContent; // When content calls PreventDefault on pointerdown, we also call // PreventDefault on the subsequent mouse events to suppress default // behaviors. Normally, aStatus should be nsEventStatus_eConsumeNoDefault // when the event is DefaultPrevented but it's reset to // nsEventStatus_eIgnore in EventStateManager::PreHandleEvent. So we also // check if the event is DefaultPrevented. if (nsEventStatus_eConsumeNoDefault != *aStatus &&
!aEvent->DefaultPrevented()) {
nsCOMPtr<nsIContent> newFocus; bool suppressBlur = false; if (mCurrentTarget) {
mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(newFocus));
activeContent = mCurrentTarget->GetContent();
// In some cases, we do not want to even blur the current focused // element. Those cases are: // 1. -moz-user-focus CSS property is set to 'ignore'; // 2. XUL control element has the disabled property set to 'true'. // // We can't use nsIFrame::IsFocusable() because we want to blur when // we click on a visibility: none element. // We can't use nsIContent::IsFocusable() because we want to blur when // we click on a non-focusable element like a <div>. // We have to use |aEvent->mTarget| to not make sure we do not check // an anonymous node of the targeted element.
suppressBlur =
mCurrentTarget->StyleUI()->UserFocus() == StyleUserFocus::Ignore;
if (!suppressBlur) { if (Element* element =
Element::FromEventTargetOrNull(aEvent->mTarget)) { if (nsCOMPtr<nsIDOMXULControlElement> xulControl =
element->AsXULControl()) { bool disabled = false;
xulControl->GetDisabled(&disabled);
suppressBlur = disabled;
}
}
}
}
// When a root content which isn't editable but has an editable HTML // <body> element is clicked, we should redirect the focus to the // the <body> element. E.g., when an user click bottom of the editor // where is outside of the <body> element, the <body> should be focused // and the user can edit immediately after that. // // NOTE: The newFocus isn't editable that also means it's not in // designMode. In designMode, all contents are not focusable. if (newFocus && !newFocus->IsEditable()) {
Document* doc = newFocus->GetComposedDoc(); if (doc && newFocus == doc->GetRootElement()) {
nsIContent* bodyContent =
nsLayoutUtils::GetEditableRootContentByContentEditable(doc); if (bodyContent && bodyContent->GetPrimaryFrame()) {
newFocus = bodyContent;
}
}
}
// When the mouse is pressed, the default action is to focus the // target. Look for the nearest enclosing focusable frame. // // TODO: Probably this should be moved to Element::PostHandleEvent. for (; newFocus; newFocus = newFocus->GetFlattenedTreeParent()) { if (!newFocus->IsElement()) { continue;
}
nsIFrame* frame = newFocus->GetPrimaryFrame(); if (!frame) { continue;
}
// If the mousedown happened inside a popup, don't try to set focus on // one of its containing elements if (frame->IsMenuPopupFrame()) {
newFocus = nullptr; break;
}
auto flags = IsFocusableFlags::WithMouse; if (frame->IsFocusable(flags)) { break;
}
if (ShadowRoot* root = newFocus->GetShadowRoot()) { if (root->DelegatesFocus()) { if (Element* firstFocusable = root->GetFocusDelegate(flags)) {
newFocus = firstFocusable; break;
}
}
}
}
MOZ_ASSERT_IF(newFocus, newFocus->IsElement());
if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) { // if something was found to focus, focus it. Otherwise, if the // element that was clicked doesn't have -moz-user-focus: ignore, // clear the existing focus. For -moz-user-focus: ignore, the focus // is just left as is. // Another effect of mouse clicking, handled in Selection, is that // it should update the caret position to where the mouse was // clicked. Because the focus is cleared when clicking on a // non-focusable node, the next press of the tab key will cause // focus to be shifted from the caret position instead of the root. if (newFocus) { // use the mouse flag and the noscroll flag so that the content // doesn't unexpectedly scroll when clicking an element that is // only half visible
uint32_t flags =
nsIFocusManager::FLAG_BYMOUSE | nsIFocusManager::FLAG_NOSCROLL; // If this was a touch-generated event, pass that information: if (mouseEvent->mInputSource ==
MouseEvent_Binding::MOZ_SOURCE_TOUCH) {
flags |= nsIFocusManager::FLAG_BYTOUCH;
}
fm->SetFocus(MOZ_KnownLive(newFocus->AsElement()), flags);
} elseif (!suppressBlur) { // clear the focus within the frame and then set it as the // focused frame
EnsureDocument(mPresContext); if (mDocument) {
nsCOMPtr<nsPIDOMWindowOuter> outerWindow = mDocument->GetWindow(); #ifdef XP_MACOSX if (!activeContent || !activeContent->IsXULElement()) #endif
fm->ClearFocus(outerWindow); // Prevent switch frame if we're already not in the foreground tab // and we're in a content process. // TODO: If we were inactive frame in this tab, and now in // background tab, we shouldn't make the tab foreground, but // we should set focus to clicked document in the background // tab. However, nsFocusManager does not have proper method // for doing this. Therefore, we should skip setting focus // to clicked document for now. if (XRE_IsParentProcess() || IsInActiveTab(mDocument)) {
fm->SetFocusedWindow(outerWindow);
}
}
}
}
// The rest is left button-specific. if (mouseEvent->mButton != MouseButton::ePrimary) { break;
}
// The nearest enclosing element goes into the :active state. If we're // not an element (so we're text or something) we need to obtain // our parent element and put it into :active instead. if (activeContent && !activeContent->IsElement()) { if (nsIContent* par = activeContent->GetFlattenedTreeParent()) {
activeContent = par;
}
}
} else { // if we're here, the event handler returned false, so stop // any of our own processing of a drag. Workaround for bug 43258.
StopTrackingDragGesture(true);
} // XXX Why do we always set this is active? Active window may be changed // by a mousedown event listener. if (NeedsActiveContentChange(mouseEvent)) {
SetActiveManager(this, activeContent);
}
} break; case ePointerCancel: case ePointerUp: {
WidgetPointerEvent* pointerEvent = aEvent->AsPointerEvent();
MOZ_ASSERT(pointerEvent); // Implicitly releasing capture for given pointer. ePointerLostCapture // should be send after ePointerUp or ePointerCancel.
PointerEventHandler::ImplicitlyReleasePointerCapture(pointerEvent);
PointerEventHandler::UpdateActivePointerState(pointerEvent);
if ( // After pointercancel, pointer becomes invalid so we can remove // relevant helper from table.
pointerEvent->mMessage == ePointerCancel || // pointerup for non-hoverable pointer needs to dispatch pointerout // and pointerleave events because the pointer is valid only while the // pointer is "down".
!pointerEvent->InputSourceSupportsHover()) {
GenerateMouseEnterExit(pointerEvent);
mPointersEnterLeaveHelper.Remove(pointerEvent->pointerId);
}
break;
} case eMouseUp: { // We can unconditionally stop capturing because // we should never be capturing when the mouse button is up
PresShell::ReleaseCapturingContent();
WidgetMouseEvent* mouseUpEvent = aEvent->AsMouseEvent(); if (NeedsActiveContentChange(mouseUpEvent)) {
ClearGlobalActiveContent(this);
} if (mouseUpEvent && EventCausesClickEvents(*mouseUpEvent)) { // Make sure to dispatch the click even if there is no frame for // the current target element. This is required for Web compatibility.
RefPtr<EventStateManager> esm =
ESMFromContentOrThis(aOverrideClickTarget);
ret =
esm->PostHandleMouseUp(mouseUpEvent, aStatus, aOverrideClickTarget);
}
if (PresShell* presShell = presContext->GetPresShell()) {
RefPtr<nsFrameSelection> frameSelection = presShell->FrameSelection();
frameSelection->SetDragState(false);
}
} break; case eWheelOperationEnd: {
MOZ_ASSERT(aEvent->IsTrusted());
ScrollbarsForWheel::MayInactivate();
WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent();
ScrollContainerFrame* scrollTarget =
ComputeScrollTargetAndMayAdjustWheelEvent(
mCurrentTarget, wheelEvent,
COMPUTE_DEFAULT_ACTION_TARGET_WITH_AUTO_DIR); // If the wheel event was handled by APZ, APZ will perform the scroll // snap. if (scrollTarget && !WheelTransaction::HandledByApz()) {
scrollTarget->ScrollSnap();
}
} break; case eWheel: case eWheelOperationStart: {
MOZ_ASSERT(aEvent->IsTrusted());
if (*aStatus == nsEventStatus_eConsumeNoDefault) {
ScrollbarsForWheel::Inactivate(); break;
}
// When APZ is enabled, the actual scroll animation might be handled by // the compositor.
WheelPrefs::Action action =
wheelEvent->mFlags.mHandledByAPZ
? WheelPrefs::ACTION_NONE
: WheelPrefs::GetInstance()->ComputeActionFor(wheelEvent);
WheelDeltaAdjustmentStrategy strategy =
GetWheelDeltaAdjustmentStrategy(*wheelEvent); // Adjust the delta values of the wheel event if the current default // action is to horizontalize scrolling. I.e., deltaY values are set to // deltaX and deltaY and deltaZ values are set to 0. // If horizontalized, the delta values will be restored and its overflow // deltaX will become 0 when the WheelDeltaHorizontalizer instance is // being destroyed.
WheelDeltaHorizontalizer horizontalizer(*wheelEvent); if (WheelDeltaAdjustmentStrategy::eHorizontalize == strategy) {
horizontalizer.Horizontalize();
}
// Since ComputeScrollTargetAndMayAdjustWheelEvent() may adjust the delta // if the event is auto-dir. So we use |ESMAutoDirWheelDeltaRestorer| // here. // An instance of |ESMAutoDirWheelDeltaRestorer| is used to monitor // auto-dir adjustment which may happen during its lifetime. If the delta // values is adjusted during its lifetime, the instance will restore the // adjusted delta when it's being destrcuted.
ESMAutoDirWheelDeltaRestorer restorer(*wheelEvent);
ScrollContainerFrame* scrollTarget =
ComputeScrollTargetAndMayAdjustWheelEvent(
mCurrentTarget, wheelEvent,
COMPUTE_DEFAULT_ACTION_TARGET_WITH_AUTO_DIR);
switch (action) { case WheelPrefs::ACTION_SCROLL: case WheelPrefs::ACTION_HORIZONTALIZED_SCROLL: { // For scrolling of default action, we should honor the mouse wheel // transaction.
ScrollContainerFrame* rootScrollContainerFrame =
!mCurrentTarget
? nullptr
: mCurrentTarget->PresShell()->GetRootScrollContainerFrame(); if (!scrollTarget || scrollTarget == rootScrollContainerFrame) {
wheelEvent->mViewPortIsOverscrolled = true;
}
wheelEvent->mOverflowDeltaX = wheelEvent->mDeltaX;
wheelEvent->mOverflowDeltaY = wheelEvent->mDeltaY;
WheelPrefs::GetInstance()->CancelApplyingUserPrefsFromOverflowDelta(
wheelEvent); if (scrollTarget) {
DoScrollText(scrollTarget, wheelEvent);
} else {
WheelTransaction::EndTransaction();
ScrollbarsForWheel::Inactivate();
} break;
} case WheelPrefs::ACTION_HISTORY: { // If this event doesn't cause eLegacyMouseLineOrPageScroll event or // the direction is oblique, don't perform history back/forward.
int32_t intDelta = wheelEvent->GetPreferredIntDelta(); if (!intDelta) { break;
}
DoScrollHistory(intDelta); break;
} case WheelPrefs::ACTION_ZOOM: { // If this event doesn't cause eLegacyMouseLineOrPageScroll event or // the direction is oblique, don't perform zoom in/out.
int32_t intDelta = wheelEvent->GetPreferredIntDelta(); if (!intDelta) { break;
}
DoScrollZoom(mCurrentTarget, intDelta); break;
} case WheelPrefs::ACTION_NONE: default: bool allDeltaOverflown = false; if (StaticPrefs::dom_event_wheel_event_groups_enabled() &&
(wheelEvent->mDeltaX != 0.0 || wheelEvent->mDeltaY != 0.0)) { if (scrollTarget) {
WheelTransaction::WillHandleDefaultAction(
wheelEvent, scrollTarget, mCurrentTarget);
} else {
WheelTransaction::EndTransaction();
}
} if (wheelEvent->mFlags.mHandledByAPZ) { if (wheelEvent->mCanTriggerSwipe) { // For events that can trigger swipes, APZ needs to know whether // scrolling is possible in the requested direction. It does this // by looking at the scroll overflow values on mCanTriggerSwipe // events after they have been processed.
allDeltaOverflown = !ComputeScrollTarget(
mCurrentTarget, wheelEvent, COMPUTE_DEFAULT_ACTION_TARGET);
}
} else { // The event was processed neither by APZ nor by us, so all of the // delta values must be overflown delta values.
allDeltaOverflown = true;
}
case eGestureNotify: { if (nsEventStatus_eConsumeNoDefault != *aStatus) {
DecideGestureEvent(aEvent->AsGestureNotifyEvent(), mCurrentTarget);
}
} break;
case eDragEnter: case eDragOver: {
NS_ASSERTION(aEvent->mClass == eDragEventClass, "Expected a drag event");
// Check if the drag is occurring inside a scrollable area. If so, scroll // the area when the mouse is near the edges. if (mCurrentTarget && aEvent->mMessage == eDragOver) {
nsIFrame* checkFrame = mCurrentTarget; while (checkFrame) {
ScrollContainerFrame* scrollFrame = do_QueryFrame(checkFrame); // Break out so only the innermost scrollframe is scrolled. if (scrollFrame && scrollFrame->DragScroll(aEvent)) { break;
}
checkFrame = checkFrame->GetParent();
}
}
nsCOMPtr<nsIDragSession> dragSession =
nsContentUtils::GetDragSession(mPresContext); if (!dragSession) break;
// Reset the flag.
dragSession->SetOnlyChromeDrop(false); if (mPresContext) {
EnsureDocument(mPresContext);
} bool isChromeDoc = nsContentUtils::IsChromeDoc(mDocument);
// the initial dataTransfer is the one from the dragstart event that // was set on the dragSession when the drag began.
RefPtr<DataTransfer> dataTransfer;
RefPtr<DataTransfer> initialDataTransfer = dragSession->GetDataTransfer();
// collect any changes to moz cursor settings stored in the event's // data transfer.
UpdateDragDataTransfer(dragEvent);
// cancelling a dragenter or dragover event means that a drop should be // allowed, so update the dropEffect and the canDrop state to indicate // that a drag is allowed. If the event isn't cancelled, a drop won't be // allowed. Essentially, to allow a drop somewhere, specify the effects // using the effectAllowed and dropEffect properties in a dragenter or // dragover event and cancel the event. To not allow a drop somewhere, // don't cancel the event or set the effectAllowed or dropEffect to // "none". This way, if the event is just ignored, no drop will be // allowed.
uint32_t dropEffect = nsIDragService::DRAGDROP_ACTION_NONE;
uint32_t action = nsIDragService::DRAGDROP_ACTION_NONE; if (nsEventStatus_eConsumeNoDefault == *aStatus) { // If the event has initialized its mDataTransfer, use it. // Or the event has not been initialized its mDataTransfer, but // it's set before dispatch because of synthesized, but without // testing session (e.g., emulating drag from another app), use it // coming from outside. // XXX Perhaps, for the latter case, we need new API because we don't // have a chance to initialize allowed effects of the session. if (dragEvent->mDataTransfer) { // get the dataTransfer and the dropEffect that was set on it
dataTransfer = dragEvent->mDataTransfer;
dropEffect = dataTransfer->DropEffectInt();
} else { // if dragEvent->mDataTransfer is null, it means that no attempt was // made to access the dataTransfer during the event, yet the event // was cancelled. Instead, use the initial data transfer available // from the drag session. The drop effect would not have been // initialized (which is done in DragEvent::GetDataTransfer), // so set it from the drag action. We'll still want to filter it // based on the effectAllowed below.
dataTransfer = initialDataTransfer;
dragSession->GetDragAction(&action);
// filter the drop effect based on the action. Use UNINITIALIZED as // any effect is allowed.
dropEffect = nsContentUtils::FilterDropEffect(
action, nsIDragService::DRAGDROP_ACTION_UNINITIALIZED);
}
// At this point, if the dataTransfer is null, it means that the // drag was originally started by directly calling the drag service. // Just assume that all effects are allowed.
uint32_t effectAllowed = nsIDragService::DRAGDROP_ACTION_UNINITIALIZED; if (dataTransfer) {
effectAllowed = dataTransfer->EffectAllowedInt();
}
// set the drag action based on the drop effect and effect allowed. // The drop effect field on the drag transfer object specifies the // desired current drop effect. However, it cannot be used if the // effectAllowed state doesn't include that type of action. If the // dropEffect is "none", then the action will be 'none' so a drop will // not be allowed. if (effectAllowed == nsIDragService::DRAGDROP_ACTION_UNINITIALIZED ||
dropEffect & effectAllowed)
action = dropEffect;
if (action == nsIDragService::DRAGDROP_ACTION_NONE)
dropEffect = nsIDragService::DRAGDROP_ACTION_NONE;
// inform the drag session that a drop is allowed on this node.
dragSession->SetDragAction(action);
dragSession->SetCanDrop(action != nsIDragService::DRAGDROP_ACTION_NONE);
// For now, do this only for dragover. // XXXsmaug dragenter needs some more work. if (aEvent->mMessage == eDragOver && !isChromeDoc) { // Someone has called preventDefault(), check whether is was on // content or chrome.
dragSession->SetOnlyChromeDrop(
!dragEvent->mDefaultPreventedOnContent);
}
} elseif (aEvent->mMessage == eDragOver && !isChromeDoc) { // No one called preventDefault(), so handle drop only in chrome.
dragSession->SetOnlyChromeDrop(true);
} if (auto* bc = BrowserChild::GetFrom(presContext->GetDocShell())) {
bc->SendUpdateDropEffect(action, dropEffect);
} if (aEvent->HasBeenPostedToRemoteProcess()) {
dragSession->SetCanDrop(true);
} elseif (initialDataTransfer) { // Now set the drop effect in the initial dataTransfer. This ensures // that we can get the desired drop effect in the drop event. For events // dispatched to content, the content process will take care of setting // this.
initialDataTransfer->SetDropEffectInt(dropEffect);
}
} break;
case eDrop: { if (aEvent->mFlags.mIsSynthesizedForTests) {
nsCOMPtr<nsIDragService> dragService =
do_GetService("@mozilla.org/widget/dragservice;1");
nsCOMPtr<nsIDragSession> dragSession =
nsContentUtils::GetDragSession(mPresContext); if (dragSession && dragService &&
!dragService->GetNeverAllowSessionIsSynthesizedForTests()) {
MOZ_ASSERT(dragSession->IsSynthesizedForTests());
RefPtr<WindowContext> sourceWC;
DebugOnly<nsresult> rvIgnored =
dragSession->GetSourceWindowContext(getter_AddRefs(sourceWC));
NS_WARNING_ASSERTION(
NS_SUCCEEDED(rvIgnored), "nsIDragSession::GetSourceDocument() failed, but ignored"); // If the drag source hasn't been initialized, i.e., dragstart was // consumed by the test, the test needs to dispatch "dragend" event // instead of the drag session. Therefore, it does not make sense // to set drag end point in such case (you hit assersion if you do // it). if (sourceWC) { const CSSIntPoint dropPointInScreen = RoundedToInt(
Event::GetScreenCoords(aPresContext, aEvent, aEvent->mRefPoint)
.extract());
dragSession->SetDragEndPointForTests(dropPointInScreen.x,
dropPointInScreen.y);
}
}
}
sLastDragOverFrame = nullptr;
ClearGlobalActiveContent(this); break;
} case eDragExit: { // make sure to fire the enter and exit_synth events after the // eDragExit event, otherwise we'll clean up too early
GenerateDragDropEnterExit(presContext, aEvent->AsDragEvent()); if (auto* bc = BrowserChild::GetFrom(presContext->GetDocShell())) { // SendUpdateDropEffect to prevent nsIDragService from waiting for // response of forwarded dragexit event.
bc->SendUpdateDropEffect(nsIDragService::DRAGDROP_ACTION_NONE,
nsIDragService::DRAGDROP_ACTION_NONE);
} break;
} case eKeyUp: // If space key is released, we need to inactivate the element which was // activated by preceding space key down. // XXX Currently, we don't store the reason of activation. Therefore, // this may cancel what is activated by a mousedown, but it must not // cause actual problem in web apps in the wild since it must be // rare case that users release space key during a mouse click/drag. if (aEvent->AsKeyboardEvent()->ShouldWorkAsSpaceKey()) {
ClearGlobalActiveContent(this);
} break;
bool EventStateManager::IsTargetCrossProcess(WidgetGUIEvent* aEvent) { // Check to see if there is a focused, editable content in chrome, // in that case, do not forward IME events to content
Element* focusedElement = GetFocusedElement(); if (focusedElement && focusedElement->IsEditable()) { returnfalse;
} return IMEStateManager::GetActiveBrowserParent() != nullptr;
}
// Bug 70855: Presentation is going away, possibly for a reframe. // Reset the hover state so that if we're recreating the presentation, // we won't have the old hover state still set in the new presentation, // as if the new presentation is resized, a new element may be hovered.
ResetHoverState();
// Given the event that we're processing, and the computed cursor and hotspot, // determine whether the custom CSS cursor should be blocked (that is, not // honored). // // We will not honor it all of the following are true: // // * the size of the custom cursor is bigger than layout.cursor.block.max-size. // * the bounds of the cursor would end up outside of the viewport of the // top-level content document. // // This is done in order to prevent hijacking the cursor, see bug 1445844 and // co. staticbool ShouldBlockCustomCursor(nsPresContext* aPresContext,
WidgetEvent* aEvent, const CursorImage& aCursor) {
int32_t width = 0;
int32_t height = 0;
aCursor.mContainer->GetWidth(&width);
aCursor.mContainer->GetHeight(&height);
aCursor.mResolution.ApplyTo(width, height);
auto input = DOMIntersectionObserver::ComputeInput(*aPresContext->Document(),
nullptr, nullptr);
if (!input.mRootFrame) { returnfalse;
}
nsPoint point = nsLayoutUtils::GetEventCoordinatesRelativeTo(
aEvent, RelativeTo{input.mRootFrame});
// The cursor size won't be affected by our full zoom in the parent process, // so undo that before checking the rect. float zoom = aPresContext->GetFullZoom();
// Also adjust for accessibility cursor scaling factor.
zoom /= LookAndFeel::GetFloat(LookAndFeel::FloatID::CursorScale, 1.0f);
// css3-ui says to use the CSS-specified hotspot if present, // otherwise use the intrinsic hotspot, otherwise use the top left // corner. if (aHotspot) {
int32_t imgWidth, imgHeight;
aContainer->GetWidth(&imgWidth);
aContainer->GetHeight(&imgHeight); auto hotspot = gfx::IntPoint::Round(*aHotspot); return {std::max(std::min(hotspot.x.value, imgWidth - 1), 0),
std::max(std::min(hotspot.y.value, imgHeight - 1), 0)};
}
// If we are falling back because any cursor before us is loading, let the // consumer know. bool loading = false; for (constauto& image : style.StyleUI()->Cursor().images.AsSpan()) {
MOZ_ASSERT(image.image.IsImageRequestType(), "Cursor image should only parse url() types");
uint32_t status;
imgRequestProxy* req = image.image.GetImageRequest(); if (!req || NS_FAILED(req->GetImageStatus(&status))) { continue;
} if (!(status & imgIRequest::STATUS_LOAD_COMPLETE)) {
loading = true; continue;
} if (status & imgIRequest::STATUS_ERROR) { continue;
}
nsCOMPtr<imgIContainer> container;
req->GetImage(getter_AddRefs(container)); if (!container) { continue;
}
StyleImageOrientation orientation =
aFrame.StyleVisibility()->UsedImageOrientation(req);
container = nsLayoutUtils::OrientImage(container, orientation);
Maybe<gfx::Point> specifiedHotspot =
image.has_hotspot ? Some(gfx::Point{image.hotspot_x, image.hotspot_y})
: Nothing();
gfx::IntPoint hotspot = ComputeHotspot(container, specifiedHotspot);
CursorImage result{hotspot, std::move(container),
image.image.GetResolution(style), loading}; if (ShouldBlockCustomCursor(aPresContext, aEvent, result)) { continue;
} // This is the one we want! return result;
} return {{}, nullptr, {}, loading};
}
void EventStateManager::UpdateCursor(nsPresContext* aPresContext,
WidgetMouseEvent* aEvent,
nsIFrame* aTargetFrame,
nsEventStatus* aStatus) { // XXX This is still not entirely correct, e.g. when mouse hover over the // broder of a cross-origin iframe, we should show the cursor specified on the // iframe (see bug 1943530). if (nsSubDocumentFrame* f = do_QueryFrame(aTargetFrame)) { if (auto* fl = f->FrameLoader();
fl && fl->IsRemoteFrame() && f->ContentReactsToPointerEvents()) { // The sub-frame will update the cursor if needed. return;
}
}
auto cursor = StyleCursorKind::Default;
nsCOMPtr<imgIContainer> container;
ImageResolution resolution;
Maybe<gfx::IntPoint> hotspot;
if (mHidingCursorWhileTyping && aEvent->IsReal()) { // Any non-synthetic mouse event makes us show the cursor again.
mHidingCursorWhileTyping = false;
}
if (mHidingCursorWhileTyping) {
cursor = StyleCursorKind::None;
} elseif (mLockCursor != kInvalidCursorKind) { // If cursor is locked just use the locked one
cursor = mLockCursor;
} elseif (aTargetFrame) { // If not locked, look for correct cursor
nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(
aEvent, RelativeTo{aTargetFrame}); const nsIFrame::Cursor framecursor = aTargetFrame->GetCursor(pt); const CursorImage customCursor =
ComputeCustomCursor(aPresContext, aEvent, *aTargetFrame, framecursor);
// If the current cursor is from the same frame, and it is now // loading some new image for the cursor, we should wait for a // while rather than taking its fallback cursor directly. if (customCursor.mEarlierCursorLoading &&
gLastCursorSourceFrame == aTargetFrame &&
TimeStamp::NowLoRes() - gLastCursorUpdateTime <
TimeDuration::FromMilliseconds(kCursorLoadingTimeout)) { return;
}
cursor = framecursor.mCursor;
container = std::move(customCursor.mContainer);
resolution = customCursor.mResolution;
hotspot = Some(customCursor.mHotspot);
}
NS_ENSURE_TRUE(aWidget, NS_ERROR_FAILURE); if (aLockCursor) { if (StyleCursorKind::Auto != aCursor) {
mLockCursor = aCursor;
} else { // If cursor style is set to auto we unlock the cursor again.
mLockCursor = kInvalidCursorKind;
}
}
nsCursor c; switch (aCursor) { case StyleCursorKind::Auto: case StyleCursorKind::Default:
c = eCursor_standard; break; case StyleCursorKind::Pointer:
c = eCursor_hyperlink; break; case StyleCursorKind::Crosshair:
c = eCursor_crosshair; break; case StyleCursorKind::Move:
c = eCursor_move; break; case StyleCursorKind::Text:
c = eCursor_select; break; case StyleCursorKind::Wait:
c = eCursor_wait; break; case StyleCursorKind::Help:
c = eCursor_help; break; case StyleCursorKind::NResize:
c = eCursor_n_resize; break; case StyleCursorKind::SResize:
c = eCursor_s_resize; break; case StyleCursorKind::WResize:
c = eCursor_w_resize; break; case StyleCursorKind::EResize:
c = eCursor_e_resize; break; case StyleCursorKind::NwResize:
c = eCursor_nw_resize; break; case StyleCursorKind::SeResize:
c = eCursor_se_resize; break; case StyleCursorKind::NeResize:
c = eCursor_ne_resize; break; case StyleCursorKind::SwResize:
c = eCursor_sw_resize; break; case StyleCursorKind::Copy: // CSS3
c = eCursor_copy; break; case StyleCursorKind::Alias:
c = eCursor_alias; break; case StyleCursorKind::ContextMenu:
c = eCursor_context_menu; break; case StyleCursorKind::Cell:
c = eCursor_cell; break; case StyleCursorKind::Grab:
c = eCursor_grab; break; case StyleCursorKind::Grabbing:
c = eCursor_grabbing; break; case StyleCursorKind::Progress:
c = eCursor_spinning; break; case StyleCursorKind::ZoomIn:
c = eCursor_zoom_in; break; case StyleCursorKind::ZoomOut:
c = eCursor_zoom_out; break; case StyleCursorKind::NotAllowed:
c = eCursor_not_allowed; break; case StyleCursorKind::ColResize:
c = eCursor_col_resize; break; case StyleCursorKind::RowResize:
c = eCursor_row_resize; break; case StyleCursorKind::NoDrop:
c = eCursor_no_drop; break; case StyleCursorKind::VerticalText:
c = eCursor_vertical_text; break; case StyleCursorKind::AllScroll:
c = eCursor_all_scroll; break; case StyleCursorKind::NeswResize:
c = eCursor_nesw_resize; break; case StyleCursorKind::NwseResize:
c = eCursor_nwse_resize; break; case StyleCursorKind::NsResize:
c = eCursor_ns_resize; break; case StyleCursorKind::EwResize:
c = eCursor_ew_resize; break; case StyleCursorKind::None:
c = eCursor_none; break; default:
MOZ_ASSERT_UNREACHABLE("Unknown cursor kind");
c = eCursor_standard; break;
}
uint32_t x = aHotspot ? aHotspot->x.value : 0;
uint32_t y = aHotspot ? aHotspot->y.value : 0;
aWidget->SetCursor(nsIWidget::Cursor{c, aContainer, x, y, aResolution}); return NS_OK;
}
// Inherit whether the event is synthesized by the test API or not. // Then, when the event is synthesized by a test API and handled in a remote // process, it won't be ignored. See PresShell::HandleEvent().
newEvent->mFlags.mIsSynthesizedForTests =
aMouseEvent->mFlags.mIsSynthesizedForTests;
newEvent->mRelatedTarget = aRelatedTarget;
newEvent->mRefPoint = aMouseEvent->mRefPoint;
newEvent->mModifiers = aMouseEvent->mModifiers; if (!aMouseEvent->mFlags.mDispatchedAtLeastOnce &&
aMouseEvent->InputSourceSupportsHover()) { // If we synthesize a pointer event or a mouse event from another event // which changes a button state whose input soucre supports hover state and // the source event has not been dispatched yet, we should set to the button // state of the synthesizing event to previous one. // Note that we don't need to do this if the input source does not support // hover state because a WPT check the behavior (see below) and the other // browsers pass the test even though this is inconsistent behavior.
newEvent->mButton =
sourcePointer ? MouseButton::eNotPressed : MouseButton::ePrimary; if (aMouseEvent->IsPressingButton()) { // If the source event has not been dispatched into the DOM yet, we // need to remove the flag which is being pressed.
newEvent->mButtons = static_cast<decltype(WidgetMouseEvent::mButtons)>(
aMouseEvent->mButtons &
~MouseButtonsFlagToChange( static_cast<MouseButton>(aMouseEvent->mButton)));
} elseif (aMouseEvent->IsReleasingButton()) { // If the source event has not been dispatched into the DOM yet, we // need to add the flag which is being released.
newEvent->mButtons = static_cast<decltype(WidgetMouseEvent::mButtons)>(
aMouseEvent->mButtons |
MouseButtonsFlagToChange( static_cast<MouseButton>(aMouseEvent->mButton)));
} else { // The source event does not change the buttons state so that we can // set mButtons value as-is.
newEvent->mButtons = aMouseEvent->mButtons;
} // Adjust pressure if it does not matches with mButtons. // FIXME: We may use wrong pressure value if the source event has not been // dispatched into the DOM yet. However, fixing this requires to store the // last pressure value somewhere. if (newEvent->mButtons && aMouseEvent->mPressure == 0) {
newEvent->mPressure = 0.5f;
} elseif (!newEvent->mButtons && aMouseEvent->mPressure != 0) {
newEvent->mPressure = 0;
} else {
newEvent->mPressure = aMouseEvent->mPressure;
}
} else { // If the event has already been dispatched into the tree, web apps has // already handled the button state change, so the button state of the // source event has already synced. // If the input source does not have hover state, we don't need to modify // the state because the other browsers behave so and tested by // pointerevent_attributes_nohover_pointers.html even though this is // different expectation from // pointerevent_attributes_hoverable_pointers.html, but the other browsers // pass both of them.
newEvent->mButton = aMouseEvent->mButton;
newEvent->mButtons = aMouseEvent->mButtons;
newEvent->mPressure = aMouseEvent->mPressure;
}
// https://w3c.github.io/pointerlock/#dom-element-requestpointerlock // "[Once in the locked state...E]vents that require the concept // of a mouse cursor must not be dispatched (for example: mouseover, // mouseout...). // XXXedgar should we also block pointer events? if (PointerLockManager::IsLocked() &&
(aMessage == eMouseLeave || aMessage == eMouseEnter ||
aMessage == eMouseOver || aMessage == eMouseOut)) {
mCurrentTargetContent = nullptr;
nsCOMPtr<Element> pointerLockedElement =
PointerLockManager::GetLockedElement(); if (!pointerLockedElement) {
NS_WARNING("Should have pointer locked element, but didn't."); return nullptr;
}
nsIFrame* const pointerLockedFrame =
mPresContext->GetPrimaryFrameFor(pointerLockedElement); if (NS_WARN_IF(!pointerLockedFrame)) { return nullptr;
} return do_AddRef(pointerLockedFrame->GetNearestWidget());
}
mCurrentTargetContent = nullptr;
if (!aTargetContent) { return nullptr;
}
// Store the widget before dispatching the event because some event listeners // of the dispatching event may cause reframe the target or remove the target // from the tree.
nsCOMPtr<nsIWidget> targetWidget; if (nsIFrame* const targetFrame =
mPresContext->GetPrimaryFrameFor(aTargetContent)) {
targetWidget = targetFrame->GetNearestWidget();
}
if (mPresContext) { // If we are entering/leaving remote content, dispatch a mouse enter/exit // event to the remote frame. if (IsTopLevelRemoteTarget(targetContent)) { if (aMessage == eMouseOut) { // For remote content, send a puppet widget mouse exit event.
UniquePtr<WidgetMouseEvent> remoteEvent =
CreateMouseOrPointerWidgetEvent(aMouseEvent, eMouseExitFromWidget,
relatedContent);
remoteEvent->mExitFrom = Some(WidgetMouseEvent::ePuppet);
// mCurrentTarget is set to the new target, so we must reset it to the // old target and then dispatch a cross-process event. (mCurrentTarget // will be set back below.) HandleCrossProcessEvent will query for the // proper target via GetEventTarget which will return mCurrentTarget.
mCurrentTarget = mPresContext->GetPrimaryFrameFor(targetContent);
HandleCrossProcessEvent(remoteEvent.get(), &status);
} elseif (aMessage == eMouseOver) {
UniquePtr<WidgetMouseEvent> remoteEvent =
CreateMouseOrPointerWidgetEvent(aMouseEvent, eMouseEnterIntoWidget,
relatedContent);
HandleCrossProcessEvent(remoteEvent.get(), &status);
}
}
}
// If there is no deepest "leave" event target, that means the last "over" // target has already been removed from the tree. Therefore, checking only // the "leave" event target is enough. if (!wrapper || !wrapper->GetDeepestLeaveEventTarget()) { return;
} // Before firing "out" and/or "leave" events, check for recursion if (wrapper->IsDispatchingOutEventOnLastOverEventTarget()) { return;
}
MOZ_LOG(logModule, LogLevel::Info,
("NotifyMouseOut: the source event is %s (IsReal()=%s)",
ToChar(aMouseEvent->mMessage),
aMouseEvent->IsReal() ? "true" : "false"));
// XXX If a content node is a container of remove content, it should be // replaced with them and its children should not be visible. Therefore, // if the deepest "enter" target is not the last "over" target, i.e., the // last "over" target has been removed from the DOM tree, it means that the // child/descendant was not replaced by remote content. So, // wrapper->GetOutEventTaget() may be enough here. if (RefPtr<nsFrameLoaderOwner> flo =
do_QueryObject(wrapper->GetDeepestLeaveEventTarget())) { if (BrowsingContext* bc = flo->GetExtantBrowsingContext()) { if (nsIDocShell* docshell = bc->GetDocShell()) { if (RefPtr<nsPresContext> presContext = docshell->GetPresContext()) {
EventStateManager* kidESM = presContext->EventStateManager(); // Not moving into any element in this subdocument
MOZ_LOG(logModule, LogLevel::Info,
("Notifying child EventStateManager (%p) of \"out\" " "event...",
kidESM));
kidESM->NotifyMouseOut(aMouseEvent, nullptr);
}
}
}
} // That could have caused DOM events which could wreak havoc. Reverify // things and be careful. if (!wrapper->GetDeepestLeaveEventTarget()) { return;
}
wrapper->WillDispatchOutAndOrLeaveEvent();
// Don't touch hover state if aMovingInto is non-null. Caller will update // hover state itself, and we have optimizations for hover switching between // two nearby elements both deep in the DOM tree that would be defeated by // switching the hover state to null here. if (!aMovingInto && !isPointer) { // Unset :hover
SetContentState(nullptr, ElementState::HOVER);
}
// If we have next "out" event target and it's the new "over" target, we don't // need to dispatch "out" nor "enter" event. if (!wrapper || aContent == wrapper->GetOutEventTarget()) { return;
}
// Before firing "over" and "enter" events, check for recursion if (wrapper->IsDispatchingOverEventOn(aContent)) { return;
}
MOZ_LOG(logModule, LogLevel::Info,
("NotifyMouseOver: the source event is %s (IsReal()=%s)",
ToChar(aMouseEvent->mMessage),
aMouseEvent->IsReal() ? "true" : "false"));
// Check to see if we're a subdocument and if so update the parent // document's ESM state to indicate that the mouse is over the // content associated with our subdocument.
EnsureDocument(mPresContext); if (Document* parentDoc = mDocument->GetInProcessParentDocument()) { if (nsCOMPtr<nsIContent> docContent = mDocument->GetEmbedderElement()) { if (PresShell* parentPresShell = parentDoc->GetPresShell()) {
RefPtr<EventStateManager> parentESM =
parentPresShell->GetPresContext()->EventStateManager();
MOZ_LOG(logModule, LogLevel::Info,
("Notifying parent EventStateManager (%p) of \"over\" " "event...",
parentESM.get()));
parentESM->NotifyMouseOver(aMouseEvent, docContent);
}
}
} // Firing the DOM event in the parent document could cause all kinds // of havoc. Reverify and take care. if (aContent == wrapper->GetOutEventTarget()) { return;
}
// Remember the deepest leave event target as the related content for the // DispatchMouseOrPointerBoundaryEvent() call below, since NotifyMouseOut() // resets it, bug 298477.
nsCOMPtr<nsIContent> deepestLeaveEventTarget =
wrapper->GetDeepestLeaveEventTarget();
if (!isPointer) {
SetContentState(aContent, ElementState::HOVER);
}
NotifyMouseOut(aMouseEvent, aContent);
wrapper->WillDispatchOverAndEnterEvent(aContent);
// Fire mouseover // XXX If aContent has already been removed from the DOM tree, what should we // do? At least, dispatching `mouseover` on it is odd.
MOZ_LOG(logModule, LogLevel::Info,
("Dispatching %s event to %s (%p)",
isPointer ? "ePointerOver" : "eMouseOver",
aContent ? ToString(*aContent).c_str() : "nullptr", aContent));
nsCOMPtr<nsIWidget> targetWidget = DispatchMouseOrPointerBoundaryEvent(
aMouseEvent, isPointer ? ePointerOver : eMouseOver, aContent,
deepestLeaveEventTarget);
MOZ_LOG(logModule, LogLevel::Info,
("Dispatching %s event to %s (%p) and its ancestors",
isPointer ? "ePointerEnter" : "eMouseEnter",
aContent ? ToString(*aContent).c_str() : "nullptr", aContent));
enterDispatcher.Dispatch();
MOZ_LOG(logModule, LogLevel::Info,
("Dispatched \"over\" and \"enter\" events (the original \"over\" " "event target was in the document %p, and now in %p)",
aContent->GetComposedDoc(), mDocument.get()));
wrapper->DidDispatchOverAndEnterEvent(
aContent->GetComposedDoc() == mDocument ? aContent : nullptr,
targetWidget);
}
// Returns the center point of the window's client area. This is // in widget coordinates, i.e. relative to the widget's top-left // corner, not in screen coordinates, the same units that UIEvent:: // refpoint is in. It may not be the exact center of the window if // the platform requires rounding the coordinate. static LayoutDeviceIntPoint GetWindowClientRectCenter(nsIWidget* aWidget) {
NS_ENSURE_TRUE(aWidget, LayoutDeviceIntPoint(0, 0));
// Mouse movement is reported on the MouseEvent.movement{X,Y} fields. // Movement is calculated in UIEvent::GetMovementPoint() as: // previous_mousemove_mRefPoint - current_mousemove_mRefPoint. if (PointerLockManager::IsLocked() && aMouseEvent->mWidget) { // The pointer is locked. If the pointer is not located at the center of // the window, dispatch a synthetic mousemove to return the pointer there. // Doing this between "real" pointer moves gives the impression that the // (locked) pointer can continue moving and won't stop at the screen // boundary. We cancel the synthetic event so that we don't end up // dispatching the centering move event to content.
aMouseEvent->mLastRefPoint =
GetWindowClientRectCenter(aMouseEvent->mWidget);
} elseif (sLastRefPoint == kInvalidRefPoint) { // We don't have a valid previous mousemove mRefPoint. This is either // the first move we've encountered, or the mouse has just re-entered // the application window. We should report (0,0) movement for this // case, so make the current and previous mRefPoints the same.
aMouseEvent->mLastRefPoint = aMouseEvent->mRefPoint;
} else {
aMouseEvent->mLastRefPoint = sLastRefPoint;
}
}
// We generate pointermove from mousemove event, so only synthesize native // mouse move and update sSynthCenteringPoint by mousemove event. bool updateSynthCenteringPoint = aMouseEvent->mMessage == eMouseMove;
// The pointer is locked. If the pointer is not located at the center of // the window, dispatch a synthetic mousemove to return the pointer there. // Doing this between "real" pointer moves gives the impression that the // (locked) pointer can continue moving and won't stop at the screen // boundary. We cancel the synthetic event so that we don't end up // dispatching the centering move event to content.
LayoutDeviceIntPoint center = GetWindowClientRectCenter(aMouseEvent->mWidget);
if (aMouseEvent->mRefPoint != center && updateSynthCenteringPoint) { // Mouse move doesn't finish at the center of the window. Dispatch a // synthetic native mouse event to move the pointer back to the center // of the window, to faciliate more movement. But first, record that // we've dispatched a synthetic mouse movement, so we can cancel it // in the other branch here.
sSynthCenteringPoint = center; // XXX Once we fix XXX comments in SetPointerLock about this API, we could // restrict that this API works only in the automation mode or in the // pointer locked situation.
aMouseEvent->mWidget->SynthesizeNativeMouseMove(
center + aMouseEvent->mWidget->WidgetToScreenOffset(), nullptr);
} elseif (aMouseEvent->mRefPoint == sSynthCenteringPoint) { // This is the "synthetic native" event we dispatched to re-center the // pointer. Cancel it so we don't expose the centering move to content.
aMouseEvent->StopPropagation(); // Clear sSynthCenteringPoint so we don't cancel other events // targeted at the center. if (updateSynthCenteringPoint) {
sSynthCenteringPoint = kInvalidRefPoint;
}
}
}
void EventStateManager::GenerateMouseEnterExit(WidgetMouseEvent* aMouseEvent) {
EnsureDocument(mPresContext); if (!mDocument) return;
// Hold onto old target content through the event and reset after.
nsCOMPtr<nsIContent> targetBeforeEvent = mCurrentTargetContent;
switch (aMouseEvent->mMessage) { case eMouseMove: case ePointerMove: case ePointerDown: case ePointerGotCapture: { // Get the target content target (mousemove target == mouseover target)
nsCOMPtr<nsIContent> targetElement = GetEventTargetContent(aMouseEvent); if (!targetElement) { // We're always over the document root, even if we're only // over dead space in a page (whose frame is not associated with // any content) or in print preview dead space
targetElement = mDocument->GetRootElement();
} if (targetElement) {
NotifyMouseOver(aMouseEvent, targetElement);
} break;
} case ePointerUp: { if (!StaticPrefs::
dom_events_mouse_pointer_boundary_keep_enter_targets_after_over_target_removed()) { // In the legacy mode, we should do nothing if the event has not been // dispatched yet (i.e., called by PreHandleEvent). // On the other hand, if the event was dispatched (i.e., called by // PostEventHandler), we need to dispatch "pointerout" and // "pointerleave" events because the pointer will be removed // (invalidated) by the "pointerup" operation. if (!aMouseEvent->mFlags.mDispatchedAtLeastOnce) { break;
}
MOZ_ASSERT(!aMouseEvent->InputSourceSupportsHover()); // Get the target content target (pointermove target == pointerover // target)
nsCOMPtr<nsIContent> targetElement = GetEventTargetContent(aMouseEvent); if (!targetElement) { // We're always over the document root, even if we're only // over dead space in a page (whose frame is not associated with // any content) or in print preview dead space
targetElement = mDocument->GetRootElement();
} if (targetElement) { // XXX It's odd to override the `pointerout` event target with the // content under the pointer or something because it may have never // received `pointerover` event. I think that this was required for // digitizer which supports hover state (bug 985511). However, this // is now not called at ePointerUp if the device supports hover.
RefPtr<OverOutElementsWrapper> helper =
GetWrapperByEventID(aMouseEvent); if (helper) {
helper->OverrideOverEventTarget(targetElement);
}
NotifyMouseOut(aMouseEvent, nullptr);
} break;
}
if (aMouseEvent->mFlags.mDispatchedAtLeastOnce) { // If we've already dispatched the pointerup event caused by // non-hoverable input device like touch, we need to synthesize // pointerout and pointerleave events because the poiner is valid only // while it's "down". if (!aMouseEvent->InputSourceSupportsHover()) {
NotifyMouseOut(aMouseEvent, nullptr);
} break;
}
// If we're going to dispatch the pointerup event and the element under // the pointer is changed from the previous pointer event dispatching, we // need to dispatch pointer boundary events. If the pointing device is // hoverable, we always need to do it. Otherwise, an element captures the // pointer by default. If so, we don't need the boundary events, but if // the capture has already been released, e.g., by the capturing element // is removed, we need to dispatch the pointer boundary event the same // way as with hoverable pointer. if (aMouseEvent->InputSourceSupportsHover() ||
!PointerEventHandler::GetPointerCapturingElement(
aMouseEvent->pointerId)) {
nsCOMPtr<nsIContent> targetElement = GetEventTargetContent(aMouseEvent); if (!targetElement) {
targetElement = mDocument->GetRootElement();
} if (targetElement) {
NotifyMouseOver(aMouseEvent, targetElement);
} break;
} break;
} case ePointerLeave: case ePointerCancel: case eMouseExitFromWidget: { // This is actually the window mouse exit or pointer leave event. We're // not moving into any new element.
RefPtr<OverOutElementsWrapper> helper = GetWrapperByEventID(aMouseEvent); if (helper) {
nsCOMPtr<nsIWidget> lastOverWidget = helper->GetLastOverWidget(); if (lastOverWidget &&
nsContentUtils::GetTopLevelWidget(aMouseEvent->mWidget) !=
nsContentUtils::GetTopLevelWidget(lastOverWidget)) { // the Mouse/PointerOut event widget doesn't have same top widget with // the last over event target, it's a spurious event for the frame for // the target. break;
}
}
// Reset sLastRefPoint, so that we'll know not to report any // movement the next time we re-enter the window.
sLastRefPoint = kInvalidRefPoint;
// Deal with DnD events
nsCOMPtr<nsIDragService> dragService =
do_GetService("@mozilla.org/widget/dragservice;1");
if (PointerLockManager::IsLocked()) {
MOZ_ASSERT(aWidget, "Locking pointer requires a widget");
MOZ_ASSERT(aPresContext, "Locking pointer requires a presContext");
// Release all pointer capture when a pointer lock is successfully applied // on an element.
PointerEventHandler::ReleaseAllPointerCapture();
// Store the last known ref point so we can reposition the pointer after // unlock.
sPreLockScreenPoint = LayoutDeviceIntPoint::Round(
sLastScreenPoint * aPresContext->CSSToDevPixelScale());
// Fire a synthetic mouse move to ensure event state is updated. We first // set the mouse to the center of the window, so that the mouse event // doesn't report any movement. // XXX Cannot we do synthesize the native mousemove in the parent process // with calling LockNativePointer below? Then, we could make this API // work only in the automation mode.
sLastRefPoint = GetWindowClientRectCenter(aWidget);
aWidget->SynthesizeNativeMouseMove(
sLastRefPoint + aWidget->WidgetToScreenOffset(), nullptr);
// Suppress DnD if (dragService) {
dragService->Suppress();
}
// Activate native pointer lock on platforms where it is required (Wayland)
aWidget->LockNativePointer();
} else { if (aWidget) { // Deactivate native pointer lock on platforms where it is required
aWidget->UnlockNativePointer();
}
// Reset SynthCenteringPoint to invalid so that next time we start // locking pointer, it has its initial value.
sSynthCenteringPoint = kInvalidRefPoint; if (aWidget) { // Unlocking, so return pointer to the original position by firing a // synthetic mouse event. We first reset sLastRefPoint to its // pre-pointerlock position, so that the synthetic mouse event reports // no movement.
sLastRefPoint = sPreLockScreenPoint - aWidget->WidgetToScreenOffset(); // XXX Cannot we do synthesize the native mousemove in the parent process // with calling `UnlockNativePointer` above? Then, we could make this // API work only in the automation mode.
aWidget->SynthesizeNativeMouseMove(sPreLockScreenPoint, nullptr);
}
// Unsuppress DnD if (dragService) {
dragService->Unsuppress();
}
}
}
void EventStateManager::GenerateDragDropEnterExit(nsPresContext* aPresContext,
WidgetDragEvent* aDragEvent) { // Hold onto old target content through the event and reset after.
nsCOMPtr<nsIContent> targetBeforeEvent = mCurrentTargetContent;
switch (aDragEvent->mMessage) { case eDragOver: { // when dragging from one frame to another, events are fired in the // order: dragexit, dragenter, dragleave if (sLastDragOverFrame != mCurrentTarget) { // We'll need the content, too, to check if it changed separately from // the frames.
nsCOMPtr<nsIContent> lastContent;
nsCOMPtr<nsIContent> targetContent;
mCurrentTarget->GetContentForEvent(aDragEvent,
getter_AddRefs(targetContent)); if (targetContent && targetContent->IsText()) {
targetContent = targetContent->GetFlattenedTreeParent();
}
if (sLastDragOverFrame) { // The frame has changed but the content may not have. Check before // dispatching to content
sLastDragOverFrame->GetContentForEvent(aDragEvent,
getter_AddRefs(lastContent)); if (lastContent && lastContent->IsText()) {
lastContent = lastContent->GetFlattenedTreeParent();
}
RefPtr<nsPresContext> presContext = sLastDragOverFrame->PresContext();
FireDragEnterOrExit(presContext, aDragEvent, eDragExit, targetContent,
lastContent, sLastDragOverFrame);
nsIContent* target = sLastDragOverFrame
? sLastDragOverFrame.GetFrame()->GetContent()
: nullptr; // XXXedgar, look like we need to consider fission OOP iframe, too. if (IsTopLevelRemoteTarget(target)) { // Dragging something and moving from web content to chrome only // fires dragexit and dragleave to xul:browser. We have to forward // dragexit to sLastDragOverFrame when its content is a remote // target. We don't forward dragleave since it's generated from // dragexit.
WidgetDragEvent remoteEvent(aDragEvent->IsTrusted(), eDragExit,
aDragEvent->mWidget);
remoteEvent.AssignDragEventData(*aDragEvent, true);
remoteEvent.mFlags.mIsSynthesizedForTests =
aDragEvent->mFlags.mIsSynthesizedForTests;
nsEventStatus remoteStatus = nsEventStatus_eIgnore;
HandleCrossProcessEvent(&remoteEvent, &remoteStatus);
}
}
case eDragExit: { // This is actually the window mouse exit event. if (sLastDragOverFrame) {
nsCOMPtr<nsIContent> lastContent;
sLastDragOverFrame->GetContentForEvent(aDragEvent,
getter_AddRefs(lastContent));
if (aTargetContent != aRelatedTarget) { // XXX This event should still go somewhere!! if (aTargetContent) {
EventDispatcher::Dispatch(aTargetContent, aPresContext, &event, nullptr,
&status);
}
// adjust the drag hover if the dragenter event was cancelled or this is a // drag exit if (status == nsEventStatus_eConsumeNoDefault || aMessage == eDragExit) {
SetContentState((aMessage == eDragEnter) ? aTargetContent : nullptr,
ElementState::DRAGOVER);
}
// collect any changes to moz cursor settings stored in the event's // data transfer.
UpdateDragDataTransfer(&event);
}
// Finally dispatch the event to the frame if (aTargetFrame) {
aTargetFrame->HandleEvent(aPresContext, &event, &status);
}
}
void EventStateManager::UpdateDragDataTransfer(WidgetDragEvent* dragEvent) {
NS_ASSERTION(dragEvent, "drag event is null in UpdateDragDataTransfer!"); if (!dragEvent->mDataTransfer) { return;
}
if (dragSession) { // the initial dataTransfer is the one from the dragstart event that // was set on the dragSession when the drag began.
RefPtr<DataTransfer> initialDataTransfer = dragSession->GetDataTransfer(); if (initialDataTransfer) { // retrieve the current moz cursor setting and save it.
nsAutoString mozCursor;
dragEvent->mDataTransfer->GetMozCursor(mozCursor);
initialDataTransfer->SetMozCursor(mozCursor);
}
}
}
// static bool EventStateManager::EventCausesClickEvents( const WidgetMouseEvent& aMouseEvent) { if (NS_WARN_IF(aMouseEvent.mMessage != eMouseUp)) { returnfalse;
} // If the mouseup event is synthesized event, we don't need to dispatch // click events. if (!aMouseEvent.IsReal()) { returnfalse;
} // If mouse is still over same element, clickcount will be > 1. // If it has moved it will be zero, so no click. if (!aMouseEvent.mClickCount || !aMouseEvent.mClickTarget) { returnfalse;
} // If click event was explicitly prevented, we shouldn't dispatch it. if (aMouseEvent.mClickEventPrevented) { returnfalse;
} // Check that the window isn't disabled before firing a click // (see bug 366544). return !(aMouseEvent.mWidget && !aMouseEvent.mWidget->IsEnabled());
}
// Use local event status for each click event dispatching since it'll be // cleared by EventStateManager::PreHandleEvent(). Therefore, dispatching // an event means that previous event status will be ignored.
nsEventStatus status = nsEventStatus_eIgnore;
nsresult rv = aPresShell->HandleEventWithTarget(
&mouseOrPointerEvent, targetFrame, MOZ_KnownLive(target), &status);
// Copy mMultipleActionsPrevented flag from a click event to the mouseup // event only when it's set to true. It may be set to true if an editor has // already handled it. This is important to avoid two or more default // actions handled here.
aMouseUpEvent->mFlags.mMultipleActionsPrevented |=
mouseOrPointerEvent.mFlags.mMultipleActionsPrevented; // If current status is nsEventStatus_eConsumeNoDefault, we don't need to // overwrite it. if (*aStatus == nsEventStatus_eConsumeNoDefault) { return rv;
} // If new status is nsEventStatus_eConsumeNoDefault or // nsEventStatus_eConsumeDoDefault, use it. if (status == nsEventStatus_eConsumeNoDefault ||
status == nsEventStatus_eConsumeDoDefault) {
*aStatus = status; return rv;
} // Otherwise, keep the original status. return rv;
}
// Fire click events if the event target is still available. // Note that do not include the eMouseUp event's status since we ignore it // for compatibility with the other browsers.
nsEventStatus status = nsEventStatus_eIgnore;
nsresult rv = DispatchClickEvents(presShell, aMouseUpEvent, &status,
clickTarget, aOverrideClickTarget); if (NS_WARN_IF(NS_FAILED(rv))) { return rv;
}
// Do not do anything if preceding click events are consumed. // Note that Chromium dispatches "paste" event and actually pates clipboard // text into focused editor even if the preceding click events are consumed. // However, this is different from our traditional behavior and does not // conform to DOM events. If we need to keep compatibility with Chromium, // we should change it later. if (status == nsEventStatus_eConsumeNoDefault) {
*aStatus = nsEventStatus_eConsumeNoDefault; return NS_OK;
}
// Handle middle click paste if it's enabled and the mouse button is middle. if (aMouseUpEvent->mButton != MouseButton::eMiddle ||
!WidgetMouseEvent::IsMiddleClickPasteEnabled()) { return NS_OK;
}
DebugOnly<nsresult> rvIgnored =
HandleMiddleClickPaste(presShell, aMouseUpEvent, &status, nullptr);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored), "Failed to paste for a middle click");
// If new status is nsEventStatus_eConsumeNoDefault or // nsEventStatus_eConsumeDoDefault, use it. if (*aStatus != nsEventStatus_eConsumeNoDefault &&
(status == nsEventStatus_eConsumeNoDefault ||
status == nsEventStatus_eConsumeDoDefault)) {
*aStatus = status;
}
// Don't return error even if middle mouse paste fails since we haven't // handled it here. return NS_OK;
}
// Even if we're called twice or more for a mouse operation, we should // handle only once. Although mMultipleActionsPrevented may be set to // true by different event handler in the future, we can use it for now. if (aMouseEvent->mFlags.mMultipleActionsPrevented) { return NS_OK;
}
aMouseEvent->mFlags.mMultipleActionsPrevented = true;
RefPtr<Selection> selection; if (aEditorBase) {
selection = aEditorBase->GetSelection(); if (NS_WARN_IF(!selection)) { return NS_ERROR_FAILURE;
}
} else {
Document* document = aPresShell->GetDocument(); if (NS_WARN_IF(!document)) { return NS_ERROR_FAILURE;
}
selection = nsCopySupport::GetSelectionForCopy(document); if (NS_WARN_IF(!selection)) { return NS_ERROR_FAILURE;
}
const nsRange* range = selection->GetRangeAt(0); if (range) {
nsINode* target = range->GetStartContainer(); if (target && target->OwnerDoc()->IsInChromeDocShell()) { // In Chrome document, limit middle-click pasting to only the editor // because it looks odd if pasting works in the focused editor when you // middle-click toolbar or something which are far from the editor. // However, as DevTools especially Web Console module assumes that paste // event will be fired when middle-click even on not editor, don't limit // it. return NS_OK;
}
}
}
// Don't modify selection here because we've already set caret to the point // at "mousedown" event.
RefPtr<DataTransfer> dataTransfer; if (aEditorBase) { // Create the same DataTransfer object here so we can share it between // the clipboard event and the call to HandlePaste below. This prevents // race conditions with Content Analysis on like we see in bug 1918027.
dataTransfer =
aEditorBase->CreateDataTransferForPaste(ePaste, clipboardType);
} constauto clearDataTransfer = MakeScopeExit([&] { if (dataTransfer) {
dataTransfer->ClearForPaste();
}
});
// Fire ePaste event by ourselves since we need to dispatch "paste" event // even if the middle click event was consumed for compatibility with // Chromium. if (!nsCopySupport::FireClipboardEvent(ePaste, Some(clipboardType),
aPresShell, selection, dataTransfer)) {
*aStatus = nsEventStatus_eConsumeNoDefault; return NS_OK;
}
// Although we've fired "paste" event, there is no editor to accept the // clipboard content. if (!aEditorBase) { return NS_OK;
}
// Check if the editor is still the good target to paste. if (aEditorBase->Destroyed() || aEditorBase->IsReadonly()) { // XXX Should we consume the event when the editor is readonly and/or // disabled? return NS_OK;
}
// The selection may have been modified during reflow. Therefore, we // should adjust event target to pass IsAcceptableInputEvent(). const nsRange* range = selection->GetRangeAt(0); if (!range) { return NS_OK;
}
WidgetMouseEvent mouseEvent(*aMouseEvent);
mouseEvent.mOriginalTarget = range->GetStartContainer(); if (NS_WARN_IF(!mouseEvent.mOriginalTarget) ||
!aEditorBase->IsAcceptableInputEvent(&mouseEvent)) { return NS_OK;
}
// If Control key is pressed, we should paste clipboard content as // quotation. Otherwise, paste it as is. if (aMouseEvent->IsControl()) {
DebugOnly<nsresult> rv = aEditorBase->PasteAsQuotationAsAction(
clipboardType, EditorBase::DispatchPasteEvent::No, dataTransfer);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Failed to paste as quotation");
} else {
DebugOnly<nsresult> rv = aEditorBase->PasteAsAction(
clipboardType, EditorBase::DispatchPasteEvent::No, dataTransfer);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Failed to paste");
}
*aStatus = nsEventStatus_eConsumeNoDefault;
// Some events here may set mCurrentTarget but not set the corresponding // event target in the PresShell. if (!content && mCurrentTarget) {
mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(content));
}
/* static */ void EventStateManager::UpdateAncestorState(nsIContent* aStartNode,
nsIContent* aStopBefore,
ElementState aState, bool aAddState) { for (; aStartNode && aStartNode != aStopBefore;
aStartNode = aStartNode->GetFlattenedTreeParent()) { // We might be starting with a non-element (e.g. a text node) and // if someone is doing something weird might be ending with a // non-element too (e.g. a document fragment) if (!aStartNode->IsElement()) { continue;
}
Element* element = aStartNode->AsElement();
DoStateChange(element, aState, aAddState);
Element* labelTarget = GetLabelTarget(element); if (labelTarget) {
DoStateChange(labelTarget, aState, aAddState);
}
}
if (aAddState) { // We might be in a situation where a node was in hover both // because it was hovered and because the label for it was // hovered, and while we stopped hovering the node the label is // still hovered. Or we might have had two nested labels for the // same node, and while one is no longer hovered the other still // is. In that situation, the label that's still hovered will be // aStopBefore or some ancestor of it, and the call we just made // to UpdateAncestorState with aAddState = false would have // removed the hover state from the node. But the node should // still be in hover state. To handle this situation we need to // keep walking up the tree and any time we find a label mark its // corresponding node as still in our state. for (; aStartNode; aStartNode = aStartNode->GetFlattenedTreeParent()) { if (!aStartNode->IsElement()) { continue;
}
// static bool CanContentHaveActiveState(nsIContent& aContent) { // Editable content can never become active since their default actions // are disabled. Watch out for editable content in native anonymous // subtrees though, as they belong to text controls. return !aContent.IsEditable() || aContent.IsInNativeAnonymousSubtree();
}
if (aState == ElementState::HOVER || aState == ElementState::ACTIVE) { // Hover and active are hierarchical
updateAncestors = true;
// check to see that this state is allowed by style. Check dragover too? // XXX Is this even what we want? if (mCurrentTarget &&
mCurrentTarget->StyleUI()->UserInput() == StyleUserInput::None) { returnfalse;
}
if (aState == ElementState::ACTIVE) { if (aContent && !CanContentHaveActiveState(*aContent)) {
aContent = nullptr;
} if (aContent != mActiveContent) {
notifyContent1 = aContent;
notifyContent2 = mActiveContent;
mActiveContent = aContent;
}
} else {
NS_ASSERTION(aState == ElementState::HOVER, "How did that happen?");
nsIContent* newHover;
if (mPresContext->IsDynamic()) {
newHover = aContent;
} else {
NS_ASSERTION(!aContent || aContent->GetComposedDoc() ==
mPresContext->PresShell()->GetDocument(), "Unexpected document");
nsIFrame* frame = aContent ? aContent->GetPrimaryFrame() : nullptr; if (frame && nsLayoutUtils::IsViewportScrollbarFrame(frame)) { // The scrollbars of viewport should not ignore the hover state. // Because they are *not* the content of the web page.
newHover = aContent;
} else { // All contents of the web page should ignore the hover state.
newHover = nullptr;
}
}
// We need to keep track of which of notifyContent1 and notifyContent2 is // getting the state set and which is getting it unset. If both are // non-null, then notifyContent1 is having the state set and notifyContent2 // is having it unset. But if one of them is null, we need to keep track of // the right thing for notifyContent1 explicitly. bool content1StateSet = true; if (!notifyContent1) { // This is ok because FindCommonAncestor wouldn't find anything // anyway if notifyContent1 is null.
notifyContent1 = notifyContent2;
notifyContent2 = nullptr;
content1StateSet = false;
}
if (notifyContent1 && mPresContext) {
EnsureDocument(mPresContext); if (mDocument) {
nsAutoScriptBlocker scriptBlocker;
if (updateAncestors) {
nsCOMPtr<nsIContent> commonAncestor =
FindCommonAncestor(notifyContent1, notifyContent2); if (notifyContent2) { // It's very important to first notify the state removal and // then the state addition, because due to labels it's // possible that we're removing state from some element but // then adding it again (say because mHoverContent changed // from a control to its label).
UpdateAncestorState(notifyContent2, commonAncestor, aState, false);
}
UpdateAncestorState(notifyContent1, commonAncestor, aState,
content1StateSet);
} else { if (notifyContent2) {
DoStateChange(notifyContent2, aState, false);
}
DoStateChange(notifyContent1, aState, content1StateSet);
}
}
}
MOZ_ASSERT(leaf); // These two NS_ASSERTIONS below can fail for Shadow DOM sometimes, and it's // not clear how to best handle it, see // https://github.com/whatwg/html/issues/4795 and bug 1551621.
NS_ASSERTION(
nsContentUtils::ContentIsFlattenedTreeDescendantOf(leaf, aContentRemoved), "Flat tree and active / hover chain got out of sync");
nsIContent* newLeaf = aContentRemoved->GetFlattenedTreeParent();
MOZ_ASSERT(!newLeaf || newLeaf->IsElement());
NS_ASSERTION(!newLeaf || newLeaf->AsElement()->State().HasState(aState), "State got out of sync because of shadow DOM"); if (aNotify) {
SetContentState(newLeaf, aState);
} else { // We don't update the removed content's state here, since removing NAC // happens from layout and we don't really want to notify at that point or // what not. // // Also, NAC is not observable and NAC being removed will go away soon.
leaf = newLeaf;
}
MOZ_ASSERT(leaf == newLeaf || (aState == ElementState::ACTIVE && !leaf &&
!CanContentHaveActiveState(*newLeaf)));
}
void EventStateManager::ContentRemoved(Document* aDocument,
nsIContent* aContent) { /* * Anchor and area elements when focused or hovered might make the UI to show * the current link. We want to make sure that the UI gets informed when they * are actually removed from the DOM.
*/ if (aContent->IsAnyOfHTMLElements(nsGkAtoms::a, nsGkAtoms::area) &&
(aContent->AsElement()->State().HasAtLeastOneOfStates(
ElementState::FOCUS | ElementState::HOVER))) {
Element* element = aContent->AsElement();
element->LeaveLink(element->GetPresContext(Element::eForComposedDoc));
}
if (aContent->IsElement()) { if (RefPtr<nsPresContext> presContext = mPresContext) {
IMEStateManager::OnRemoveContent(*presContext,
MOZ_KnownLive(*aContent->AsElement()));
}
WheelTransaction::OnRemoveElement(aContent);
}
// inform the focus manager that the content is being removed. If this // content is focused, the focus will be removed without firing events. if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
fm->ContentRemoved(aDocument, aContent);
}
if (mMouseEnterLeaveHelper) { constbool hadMouseOutTarget =
mMouseEnterLeaveHelper->GetOutEventTarget() != nullptr;
mMouseEnterLeaveHelper->ContentRemoved(*aContent); // If we lose the mouseout target, we need to dispatch mouseover on an // ancestor. For ensuring the chance to do it before next user input, we // need a synthetic mouse move. if (hadMouseOutTarget && !mMouseEnterLeaveHelper->GetOutEventTarget()) { if (PresShell* presShell =
mPresContext ? mPresContext->GetPresShell() : nullptr) {
presShell->SynthesizeMouseMove(false);
}
}
} for (constauto& entry : mPointersEnterLeaveHelper) { if (entry.GetData()) {
entry.GetData()->ContentRemoved(*aContent);
}
}
}
void EventStateManager::TextControlRootWillBeRemoved(
TextControlElement& aTextControlElement) { if (!mGestureDownInTextControl || !mGestureDownFrameOwner ||
!mGestureDownFrameOwner->IsInNativeAnonymousSubtree()) { return;
} // If we track gesture to start drag in aTextControlElement, we should keep // tracking it with aTextContrlElement itself for now because this may be // caused by reframing aTextControlElement which may not be intended by the // user. if (&aTextControlElement ==
mGestureDownFrameOwner
->GetClosestNativeAnonymousSubtreeRootParentOrHost()) {
mGestureDownFrameOwner = &aTextControlElement;
}
}
void EventStateManager::TextControlRootAdded(
Element& aAnonymousDivElement, TextControlElement& aTextControlElement) { if (!mGestureDownInTextControl ||
mGestureDownFrameOwner != &aTextControlElement) { return;
} // If we track gesture to start drag in aTextControlElement, but the frame // owner is the text control element itself, the anonymous nodes in it are // recreated by a reframe. If so, we should keep tracking it with the // recreated native anonymous node.
mGestureDownFrameOwner =
aAnonymousDivElement.GetFirstChild()
? aAnonymousDivElement.GetFirstChild()
: static_cast<nsIContent*>(&aAnonymousDivElement);
}
nsCOMPtr<nsPIWindowRoot> root = window->GetTopWindowRoot();
NS_ENSURE_TRUE(root, NS_ERROR_FAILURE); constchar* cmd; bool maybeNeedToHandleInRemote = false; switch (aEvent->mMessage) { case eContentCommandCut:
cmd = "cmd_cut";
maybeNeedToHandleInRemote = true; break; case eContentCommandCopy:
cmd = "cmd_copy";
maybeNeedToHandleInRemote = true; break; case eContentCommandPaste:
cmd = "cmd_paste";
maybeNeedToHandleInRemote = true; break; case eContentCommandDelete:
cmd = "cmd_delete";
maybeNeedToHandleInRemote = true; break; case eContentCommandUndo:
cmd = "cmd_undo";
maybeNeedToHandleInRemote = true; break; case eContentCommandRedo:
cmd = "cmd_redo";
maybeNeedToHandleInRemote = true; break; case eContentCommandPasteTransferable:
cmd = "cmd_pasteTransferable"; break; case eContentCommandLookUpDictionary:
cmd = "cmd_lookUpDictionary"; break; default: return NS_ERROR_NOT_IMPLEMENTED;
} if (XRE_IsParentProcess() && maybeNeedToHandleInRemote) { if (BrowserParent* remote = BrowserParent::GetFocused()) { if (!aEvent->mOnlyEnabledCheck) {
remote->SendSimpleContentCommandEvent(*aEvent);
} // XXX The command may be disabled in the parent process. Perhaps, we // should set actual enabled state in the parent process here and there // should be another bool flag which indicates whether the content is sent // to a remote process.
aEvent->mIsEnabled = true;
aEvent->mSucceeded = true; return NS_OK;
}
} // If user tries to do something, user must try to do it in visible window. // So, let's retrieve controller of visible window.
nsCOMPtr<nsIController> controller;
nsresult rv =
root->GetControllerForCommand(cmd, true, getter_AddRefs(controller));
NS_ENSURE_SUCCESS(rv, rv); if (!controller) { // When GetControllerForCommand succeeded but there is no controller, the // command isn't supported.
aEvent->mIsEnabled = false;
} else { bool canDoIt;
rv = controller->IsCommandEnabled(cmd, &canDoIt);
NS_ENSURE_SUCCESS(rv, rv);
aEvent->mIsEnabled = canDoIt; if (canDoIt && !aEvent->mOnlyEnabledCheck) { switch (aEvent->mMessage) { case eContentCommandPasteTransferable: {
BrowserParent* remote = BrowserParent::GetFocused(); if (remote) {
IPCTransferable ipcTransferable;
nsContentUtils::TransferableToIPCTransferable(
aEvent->mTransferable, &ipcTransferable, false,
remote->Manager());
remote->SendPasteTransferable(std::move(ipcTransferable));
rv = NS_OK;
} else {
nsCOMPtr<nsICommandController> commandController =
do_QueryInterface(controller);
NS_ENSURE_STATE(commandController);
if (XRE_IsParentProcess()) { // Handle it in focused content process if there is. if (BrowserParent* remote = BrowserParent::GetFocused()) { if (!aEvent->mOnlyEnabledCheck) {
remote->SendInsertText(*aEvent);
} // XXX The remote process may be not editable right now. Therefore, this // may be different from actual state in the remote process.
aEvent->mIsEnabled = true;
aEvent->mSucceeded = true; return NS_OK;
}
}
// If there is no active editor in this process, we should treat the command // is disabled.
RefPtr<EditorBase> activeEditor =
nsContentUtils::GetActiveEditor(mPresContext); if (!activeEditor) {
aEvent->mSucceeded = true; return NS_OK;
}
if (XRE_IsParentProcess()) { // Handle it in focused content process if there is. if (BrowserParent* remote = BrowserParent::GetFocused()) { if (!aEvent->mOnlyEnabledCheck) {
Unused << remote->SendReplaceText(*aEvent);
} // XXX The remote process may be not editable right now. Therefore, this // may be different from actual state in the remote process.
aEvent->mIsEnabled = true;
aEvent->mSucceeded = true; return NS_OK;
}
}
// If there is no active editor in this process, we should treat the command // is disabled.
RefPtr<EditorBase> activeEditor =
nsContentUtils::GetActiveEditor(mPresContext); if (NS_WARN_IF(!activeEditor)) {
aEvent->mSucceeded = true; return NS_OK;
}
RefPtr<TextComposition> composition =
IMEStateManager::GetTextCompositionFor(mPresContext); if (NS_WARN_IF(composition)) { // We don't support replace text action during composition.
aEvent->mSucceeded = true; return NS_OK;
}
ContentEventHandler handler(mPresContext);
RefPtr<nsRange> range = handler.GetRangeFromFlatTextOffset(
aEvent, aEvent->mSelection.mOffset,
aEvent->mSelection.mReplaceSrcString.Length()); if (NS_WARN_IF(!range)) {
aEvent->mSucceeded = false; return NS_OK;
}
// If original replacement text isn't matched with selection text, throws // error.
nsAutoString targetStr;
nsresult rv = handler.GenerateFlatTextContent(range, targetStr); if (NS_WARN_IF(NS_FAILED(rv))) {
aEvent->mSucceeded = false; return NS_OK;
} if (!aEvent->mSelection.mReplaceSrcString.Equals(targetStr)) {
aEvent->mSucceeded = false; return NS_OK;
}
// Reset if the previous wheel event is too old. if (!mLastTime.IsNull()) {
TimeDuration duration = TimeStamp::Now() - mLastTime; if (duration.ToMilliseconds() >
StaticPrefs::mousewheel_transaction_timeout()) {
Reset();
}
} // If we have accumulated delta, we may need to reset it. if (IsInTransaction()) { // If wheel event type is changed, reset the values. if (mHandlingDeltaMode != aEvent->mDeltaMode ||
mIsNoLineOrPageDeltaDevice != aEvent->mIsNoLineOrPageDelta) {
Reset();
} else { // If the delta direction is changed, we should reset only the // accumulated values. if (mX && aEvent->mDeltaX && ((aEvent->mDeltaX > 0.0) != (mX > 0.0))) {
mX = mPendingScrollAmountX = 0.0;
} if (mY && aEvent->mDeltaY && ((aEvent->mDeltaY > 0.0) != (mY > 0.0))) {
mY = mPendingScrollAmountY = 0.0;
}
}
}
// If it's handling neither a device that does not provide line or page deltas // nor delta values multiplied by prefs, we must not modify lineOrPageDelta // values. // TODO(emilio): Does this care about overridden scroll speed? if (!mIsNoLineOrPageDeltaDevice &&
!EventStateManager::WheelPrefs::GetInstance()
->NeedToComputeLineOrPageDelta(aEvent)) { // Set the delta values to mX and mY. They would be used when above block // resets mX/mY/mPendingScrollAmountX/mPendingScrollAmountY if the direction // is changed. // NOTE: We shouldn't accumulate the delta values, it might could cause // overflow even though it's not a realistic situation. if (aEvent->mDeltaX) {
mX = aEvent->mDeltaX;
} if (aEvent->mDeltaY) {
mY = aEvent->mDeltaY;
}
mLastTime = TimeStamp::Now(); return;
}
mX += aEvent->mDeltaX;
mY += aEvent->mDeltaY;
if (mHandlingDeltaMode == WheelEvent_Binding::DOM_DELTA_PIXEL) { // Records pixel delta values and init mLineOrPageDeltaX and // mLineOrPageDeltaY for wheel events which are caused by pixel only // devices. Ignore mouse wheel transaction for computing this. The // lineOrPageDelta values will be used by dispatching legacy // eMouseScrollEventClass (DOMMouseScroll) but not be used for scrolling // of default action. The transaction should be used only for the default // action. auto scrollAmountInCSSPixels =
CSSIntSize::FromAppUnitsRounded(aEvent->mScrollAmount);
// static void EventStateManager::WheelPrefs::OnPrefChanged(constchar* aPrefName, void* aClosure) { // forget all prefs, it's not problem for performance.
sInstance->Reset();
DeltaAccumulator::GetInstance()->Reset();
}
switch (modifiers) { case MODIFIER_ALT: return INDEX_ALT; case MODIFIER_CONTROL: return INDEX_CONTROL; case MODIFIER_META: return INDEX_META; case MODIFIER_SHIFT: return INDEX_SHIFT; default: // If two or more modifier keys are pressed, we should use default // settings. return INDEX_DEFAULT;
}
}
void EventStateManager::WheelPrefs::GetBasePrefName(
EventStateManager::WheelPrefs::Index aIndex, nsACString& aBasePrefName) {
aBasePrefName.AssignLiteral("mousewheel."); switch (aIndex) { case INDEX_ALT:
aBasePrefName.AppendLiteral("with_alt."); break; case INDEX_CONTROL:
aBasePrefName.AppendLiteral("with_control."); break; case INDEX_META:
aBasePrefName.AppendLiteral("with_meta."); break; case INDEX_SHIFT:
aBasePrefName.AppendLiteral("with_shift."); break; case INDEX_DEFAULT: default:
aBasePrefName.AppendLiteral("default."); break;
}
}
// Compute action values overridden by .override_x pref. // At present, override is possible only for the x-direction // because this pref is introduced mainly for tilt wheels. // Note that ACTION_HORIZONTALIZED_SCROLL isn't a valid value for this pref // because it affects only to deltaY.
prefNameAction.AppendLiteral(".override_x");
int32_t actionOverrideX = Preferences::GetInt(prefNameAction.get(), -1); if (actionOverrideX < -1 || actionOverrideX > int32_t(ACTION_LAST) ||
actionOverrideX == ACTION_HORIZONTALIZED_SCROLL) {
NS_WARNING("Unsupported action override pref value, didn't override.");
actionOverrideX = -1;
}
mOverriddenActionsX[aIndex] = (actionOverrideX == -1)
? static_cast<Action>(action)
: static_cast<Action>(actionOverrideX);
}
void EventStateManager::WheelPrefs::GetMultiplierForDeltaXAndY( const WidgetWheelEvent* aEvent, Index aIndex, double* aMultiplierForDeltaX, double* aMultiplierForDeltaY) {
*aMultiplierForDeltaX = mMultiplierX[aIndex];
*aMultiplierForDeltaY = mMultiplierY[aIndex]; // If the event has been horizontalized(I.e. treated as a horizontal wheel // scroll for a vertical wheel scroll), then we should swap mMultiplierX and // mMultiplierY. By doing this, multipliers will still apply to the delta // values they origianlly corresponded to. if (aEvent->mDeltaValuesHorizontalizedForDefaultHandler &&
ComputeActionFor(aEvent) == ACTION_HORIZONTALIZED_SCROLL) {
std::swap(*aMultiplierForDeltaX, *aMultiplierForDeltaY);
}
}
void EventStateManager::WheelPrefs::ApplyUserPrefsToDelta(
WidgetWheelEvent* aEvent) { if (aEvent->mCustomizedByUserPrefs) { return;
}
// If the multiplier is 1.0 or -1.0, i.e., it doesn't change the absolute // value, we should use lineOrPageDelta values which were set by widget. // Otherwise, we need to compute them from accumulated delta values. if (!NeedToComputeLineOrPageDelta(aEvent)) {
aEvent->mLineOrPageDeltaX *= static_cast<int32_t>(multiplierForDeltaX);
aEvent->mLineOrPageDeltaY *= static_cast<int32_t>(multiplierForDeltaY);
} else {
aEvent->mLineOrPageDeltaX = 0;
aEvent->mLineOrPageDeltaY = 0;
}
void EventStateManager::WheelPrefs::CancelApplyingUserPrefsFromOverflowDelta(
WidgetWheelEvent* aEvent) {
Index index = GetIndexFor(aEvent);
Init(index);
// XXX If the multiplier pref value is negative, the scroll direction was // changed and caused to scroll different direction. In such case, // this method reverts the sign of overflowDelta. Does it make widget // happy? Although, widget can know the pref applied delta values by // referrencing the deltaX and deltaY of the event.
// Momentum events shouldn't run special actions. if (aEvent->mIsMomentum) { // Use the default action. Note that user might kill the wheel scrolling.
Init(INDEX_DEFAULT); if (actions[INDEX_DEFAULT] == ACTION_SCROLL ||
actions[INDEX_DEFAULT] == ACTION_HORIZONTALIZED_SCROLL) { return actions[INDEX_DEFAULT];
} return ACTION_NONE;
}
return actions[index];
}
bool EventStateManager::WheelPrefs::NeedToComputeLineOrPageDelta( const WidgetWheelEvent* aEvent) {
Index index = GetIndexFor(aEvent);
Init(index);
bool EventStateManager::WheelPrefs::IsOverOnePageScrollAllowedX( const WidgetWheelEvent* aEvent) {
Index index = GetIndexFor(aEvent);
Init(index); return Abs(mMultiplierX[index]) >=
MIN_MULTIPLIER_VALUE_ALLOWING_OVER_ONE_PAGE_SCROLL;
}
bool EventStateManager::WheelPrefs::IsOverOnePageScrollAllowedY( const WidgetWheelEvent* aEvent) {
Index index = GetIndexFor(aEvent);
Init(index); return Abs(mMultiplierY[index]) >=
MIN_MULTIPLIER_VALUE_ALLOWING_OVER_ONE_PAGE_SCROLL;
}
} // namespace mozilla
Messung V0.5 in Prozent
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.214Bemerkung:
(vorverarbeitet am 2026-04-25)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
