. // We have to use |aEvent->mTarget| to not make sure we do not check // an anonymous node of the targeted element. suppressBlur = (ui->mUserFocus == StyleUserFocus::Ignore); if (!suppressBlur) { nsCOMPtr element = do_QueryInterface(aEvent->mTarget); suppressBlur = element && element->State().HasState(NS_EVENT_STATE_DISABLED); } if (!suppressBlur) { nsCOMPtr xulControl = do_QueryInterface(aEvent->mTarget); if (xulControl) { bool disabled; xulControl->GetDisabled(&disabled); suppressBlur = disabled; } } } if (!suppressBlur) { suppressBlur = nsContentUtils::IsUserFocusIgnored(activeContent); } nsIFrame* currFrame = mCurrentTarget; // When a root content which isn't editable but has an editable HTML // element is clicked, we should redirect the focus to the // the element. E.g., when an user click bottom of the editor // where is outside of the element, the 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()) { nsIDocument *doc = newFocus->GetComposedDoc(); if (doc && newFocus == doc->GetRootElement()) { nsIContent *bodyContent = nsLayoutUtils::GetEditableRootContentByContentEditable(doc); if (bodyContent) { nsIFrame* bodyFrame = bodyContent->GetPrimaryFrame(); if (bodyFrame) { currFrame = bodyFrame; newFocus = bodyContent; } } } } // When the mouse is pressed, the default action is to focus the // target. Look for the nearest enclosing focusable frame. while (currFrame) { // If the mousedown happened inside a popup, don't // try to set focus on one of its containing elements const nsStyleDisplay* display = currFrame->StyleDisplay(); if (display->mDisplay == StyleDisplay::Popup) { newFocus = nullptr; break; } int32_t tabIndexUnused; if (currFrame->IsFocusable(&tabIndexUnused, true)) { newFocus = currFrame->GetContent(); nsCOMPtr domElement(do_QueryInterface(newFocus)); if (domElement) break; } currFrame = currFrame->GetParent(); } nsIFocusManager* fm = nsFocusManager::GetFocusManager(); if (fm) { // 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 nsSelection, 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 && currFrame) { // 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->inputSource == nsIDOMMouseEvent::MOZ_SOURCE_TOUCH) { flags |= nsIFocusManager::FLAG_BYTOUCH; } nsCOMPtr newFocusElement = do_QueryInterface(newFocus); fm->SetFocus(newFocusElement, flags); } else if (!suppressBlur) { // clear the focus within the frame and then set it as the // focused frame EnsureDocument(mPresContext); if (mDocument) { #ifdef XP_MACOSX if (!activeContent || !activeContent->IsXULElement()) #endif fm->ClearFocus(mDocument->GetWindow()); fm->SetFocusedWindow(mDocument->GetWindow()); } } } // The rest is left button-specific. if (mouseEvent->button != WidgetMouseEvent::eLeftButton) { break; } if (activeContent) { // The nearest enclosing element goes into the // :active state. If we fail the QI to DOMElement, // then we know we're only a node, and that we need // to obtain our parent element and put it into :active // instead. nsCOMPtr elt(do_QueryInterface(activeContent)); if (!elt) { nsIContent* par = activeContent->GetParent(); if (par) 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(); // When the event was cancelled, there is currently a chrome document // focused and a mousedown just occurred on a content document, ensure // that the window that was clicked is focused. EnsureDocument(mPresContext); nsIFocusManager* fm = nsFocusManager::GetFocusManager(); if (mDocument && fm) { nsCOMPtr window; fm->GetFocusedWindow(getter_AddRefs(window)); auto* currentWindow = nsPIDOMWindowOuter::From(window); if (currentWindow && mDocument->GetWindow() && currentWindow != mDocument->GetWindow() && !nsContentUtils::IsChromeDoc(mDocument)) { nsCOMPtr currentTop; nsCOMPtr newTop; currentTop = currentWindow->GetTop(); newTop = mDocument->GetWindow()->GetTop(); nsCOMPtr currentDoc = currentWindow->GetExtantDoc(); if (nsContentUtils::IsChromeDoc(currentDoc) || (currentTop && newTop && currentTop != newTop)) { fm->SetFocusedWindow(mDocument->GetWindow()); } } } } SetActiveManager(this, activeContent); } break; case ePointerCancel: { if(WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent()) { GenerateMouseEnterExit(mouseEvent); } // After firing the pointercancel event, a user agent must also fire a // pointerout event followed by a pointerleave event. MOZ_FALLTHROUGH; } case ePointerUp: { WidgetPointerEvent* pointerEvent = aEvent->AsPointerEvent(); // After UP/Cancel Touch pointers become invalid so we can remove relevant helper from Table // Mouse/Pen pointers are valid all the time (not only between down/up) if (pointerEvent->inputSource == nsIDOMMouseEvent::MOZ_SOURCE_TOUCH) { mPointersEnterLeaveHelper.Remove(pointerEvent->pointerId); GenerateMouseEnterExit(pointerEvent); } break; } case eMouseUp: { ClearGlobalActiveContent(this); WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent(); if (mouseEvent && mouseEvent->IsReal()) { if (!mCurrentTarget) { GetEventTarget(); } // Make sure to dispatch the click even if there is no frame for // the current target element. This is required for Web compatibility. ret = CheckForAndDispatchClick(mouseEvent, aStatus); } nsIPresShell *shell = presContext->GetPresShell(); if (shell) { RefPtr frameSelection = shell->FrameSelection(); frameSelection->SetDragState(false); } } break; case eWheelOperationEnd: { MOZ_ASSERT(aEvent->IsTrusted()); ScrollbarsForWheel::MayInactivate(); WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent(); nsIScrollableFrame* scrollTarget = do_QueryFrame(ComputeScrollTarget(mCurrentTarget, wheelEvent, COMPUTE_DEFAULT_ACTION_TARGET)); if (scrollTarget) { scrollTarget->ScrollSnap(); } } break; case eWheel: case eWheelOperationStart: { MOZ_ASSERT(aEvent->IsTrusted()); if (*aStatus == nsEventStatus_eConsumeNoDefault) { ScrollbarsForWheel::Inactivate(); break; } WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent(); // Check if the frame to scroll before checking the default action // because if the scroll target is a plugin, the default action should be // chosen by the plugin rather than by our prefs. nsIFrame* frameToScroll = ComputeScrollTarget(mCurrentTarget, wheelEvent, COMPUTE_DEFAULT_ACTION_TARGET); nsPluginFrame* pluginFrame = do_QueryFrame(frameToScroll); // When APZ is enabled, the actual scroll animation might be handled by // the compositor. WheelPrefs::Action action; if (pluginFrame) { MOZ_ASSERT(pluginFrame->WantsToHandleWheelEventAsDefaultAction()); action = WheelPrefs::ACTION_SEND_TO_PLUGIN; } else if (wheelEvent->mFlags.mHandledByAPZ) { action = WheelPrefs::ACTION_NONE; } else { action = WheelPrefs::GetInstance()->ComputeActionFor(wheelEvent); } switch (action) { case WheelPrefs::ACTION_HSCROLL: { // Swap axes and fall through double deltaX = wheelEvent->mDeltaX; wheelEvent->mDeltaX = wheelEvent->mDeltaY; wheelEvent->mDeltaY = deltaX; } case WheelPrefs::ACTION_SCROLL: { // For scrolling of default action, we should honor the mouse wheel // transaction. ScrollbarsForWheel::PrepareToScrollText(this, mCurrentTarget, wheelEvent); if (aEvent->mMessage != eWheel || (!wheelEvent->mDeltaX && !wheelEvent->mDeltaY)) { break; } nsIScrollableFrame* scrollTarget = do_QueryFrame(frameToScroll); ScrollbarsForWheel::SetActiveScrollTarget(scrollTarget); nsIFrame* rootScrollFrame = !mCurrentTarget ? nullptr : mCurrentTarget->PresContext()->PresShell()->GetRootScrollFrame(); nsIScrollableFrame* rootScrollableFrame = nullptr; if (rootScrollFrame) { rootScrollableFrame = do_QueryFrame(rootScrollFrame); } if (!scrollTarget || scrollTarget == rootScrollableFrame) { 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_SEND_TO_PLUGIN: MOZ_ASSERT(pluginFrame); if (wheelEvent->mMessage != eWheel || (!wheelEvent->mDeltaX && !wheelEvent->mDeltaY)) { break; } MOZ_ASSERT(static_cast(frameToScroll) == static_cast(pluginFrame)); if (!WheelTransaction::WillHandleDefaultAction(wheelEvent, frameToScroll)) { break; } pluginFrame->HandleWheelEventAsDefaultAction(wheelEvent); break; case WheelPrefs::ACTION_NONE: default: bool allDeltaOverflown = false; 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; } if (!allDeltaOverflown) { break; } wheelEvent->mOverflowDeltaX = wheelEvent->mDeltaX; wheelEvent->mOverflowDeltaY = wheelEvent->mDeltaY; WheelPrefs::GetInstance()-> CancelApplyingUserPrefsFromOverflowDelta(wheelEvent); wheelEvent->mViewPortIsOverscrolled = true; break; } *aStatus = nsEventStatus_eConsumeNoDefault; } break; case eGestureNotify: { if (nsEventStatus_eConsumeNoDefault != *aStatus) { DecideGestureEvent(aEvent->AsGestureNotifyEvent(), mCurrentTarget); } } break; case eDragEnter: case eDragOver: { NS_ASSERTION(aEvent->mClass == eDragEventClass, "Expected a drag event"); nsCOMPtr dragSession = nsContentUtils::GetDragSession(); 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. nsCOMPtr dataTransfer; nsCOMPtr initialDataTransfer; dragSession->GetDataTransfer(getter_AddRefs(initialDataTransfer)); WidgetDragEvent *dragEvent = aEvent->AsDragEvent(); // 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 a dataTransfer set, use it. if (dragEvent->mDataTransfer) { // get the dataTransfer and the dropEffect that was set on it dataTransfer = do_QueryInterface(dragEvent->mDataTransfer); dataTransfer->GetDropEffectInt(&dropEffect); } 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) dataTransfer->GetEffectAllowedInt(&effectAllowed); // 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); } } else if (aEvent->mMessage == eDragOver && !isChromeDoc) { // No one called preventDefault(), so handle drop only in chrome. dragSession->SetOnlyChromeDrop(true); } if (ContentChild* child = ContentChild::GetSingleton()) { child->SendUpdateDropEffect(action, dropEffect); } if (dispatchedToContentProcess) { dragSession->SetCanDrop(true); } else if (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: { 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 (ContentChild* child = ContentChild::GetSingleton()) { // SendUpdateDropEffect to prevent nsIDragService from waiting for // response of forwarded dragexit event. child->SendUpdateDropEffect(nsIDragService::DRAGDROP_ACTION_NONE, nsIDragService::DRAGDROP_ACTION_NONE); } break; case eBeforeKeyUp: case eKeyUp: case eAfterKeyUp: break; case eKeyPress: { WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent(); PostHandleKeyboardEvent(keyEvent, *aStatus, dispatchedToContentProcess); } break; case eMouseEnterIntoWidget: if (mCurrentTarget) { nsCOMPtr targetContent; mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(targetContent)); SetContentState(targetContent, NS_EVENT_STATE_HOVER); } break; #ifdef XP_MACOSX case eMouseActivate: if (mCurrentTarget) { nsCOMPtr targetContent; mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(targetContent)); if (!NodeAllowsClickThrough(targetContent)) { *aStatus = nsEventStatus_eConsumeNoDefault; } } break; #endif default: break; } //Reset target frame to null to avoid mistargeting after reentrant event mCurrentTarget = nullptr; mCurrentTargetContent = nullptr; return ret; } TabParent* EventStateManager::GetCrossProcessTarget() { return IMEStateManager::GetActiveTabParent(); } 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 nsIContent *focusedContent = GetFocusedContent(); if (focusedContent && focusedContent->IsEditable()) return false; return IMEStateManager::GetActiveTabParent() != nullptr; } void EventStateManager::NotifyDestroyPresContext(nsPresContext* aPresContext) { IMEStateManager::OnDestroyPresContext(aPresContext); if (mHoverContent) { // 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. SetContentState(nullptr, NS_EVENT_STATE_HOVER); } mPointersEnterLeaveHelper.Clear(); } void EventStateManager::SetPresContext(nsPresContext* aPresContext) { mPresContext = aPresContext; } void EventStateManager::ClearFrameRefs(nsIFrame* aFrame) { if (aFrame && aFrame == mCurrentTarget) { mCurrentTargetContent = aFrame->GetContent(); } } void EventStateManager::UpdateCursor(nsPresContext* aPresContext, WidgetEvent* aEvent, nsIFrame* aTargetFrame, nsEventStatus* aStatus) { if (aTargetFrame && IsRemoteTarget(aTargetFrame->GetContent())) { return; } int32_t cursor = NS_STYLE_CURSOR_DEFAULT; imgIContainer* container = nullptr; bool haveHotspot = false; float hotspotX = 0.0f, hotspotY = 0.0f; //If cursor is locked just use the locked one if (mLockCursor) { cursor = mLockCursor; } //If not locked, look for correct cursor else if (aTargetFrame) { nsIFrame::Cursor framecursor; nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, aTargetFrame); // Avoid setting cursor when the mouse is over a windowless pluign. if (NS_FAILED(aTargetFrame->GetCursor(pt, framecursor))) { if (XRE_IsContentProcess()) { mLastFrameConsumedSetCursor = true; } return; } // Make sure cursors get reset after the mouse leaves a // windowless plugin frame. if (mLastFrameConsumedSetCursor) { ClearCachedWidgetCursor(aTargetFrame); mLastFrameConsumedSetCursor = false; } // 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 (framecursor.mLoading && gLastCursorSourceFrame == aTargetFrame && TimeStamp::NowLoRes() - gLastCursorUpdateTime < TimeDuration::FromMilliseconds(kCursorLoadingTimeout)) { return; } cursor = framecursor.mCursor; container = framecursor.mContainer; haveHotspot = framecursor.mHaveHotspot; hotspotX = framecursor.mHotspotX; hotspotY = framecursor.mHotspotY; } if (nsContentUtils::UseActivityCursor()) { // Check whether or not to show the busy cursor nsCOMPtr docShell(aPresContext->GetDocShell()); if (!docShell) return; uint32_t busyFlags = nsIDocShell::BUSY_FLAGS_NONE; docShell->GetBusyFlags(&busyFlags); // Show busy cursor everywhere before page loads // and just replace the arrow cursor after page starts loading if (busyFlags & nsIDocShell::BUSY_FLAGS_BUSY && (cursor == NS_STYLE_CURSOR_AUTO || cursor == NS_STYLE_CURSOR_DEFAULT)) { cursor = NS_STYLE_CURSOR_SPINNING; container = nullptr; } } if (aTargetFrame) { SetCursor(cursor, container, haveHotspot, hotspotX, hotspotY, aTargetFrame->GetNearestWidget(), false); gLastCursorSourceFrame = aTargetFrame; gLastCursorUpdateTime = TimeStamp::NowLoRes(); } if (mLockCursor || NS_STYLE_CURSOR_AUTO != cursor) { *aStatus = nsEventStatus_eConsumeDoDefault; } } void EventStateManager::ClearCachedWidgetCursor(nsIFrame* aTargetFrame) { if (!aTargetFrame) { return; } nsIWidget* aWidget = aTargetFrame->GetNearestWidget(); if (!aWidget) { return; } aWidget->ClearCachedCursor(); } nsresult EventStateManager::SetCursor(int32_t aCursor, imgIContainer* aContainer, bool aHaveHotspot, float aHotspotX, float aHotspotY, nsIWidget* aWidget, bool aLockCursor) { EnsureDocument(mPresContext); NS_ENSURE_TRUE(mDocument, NS_ERROR_FAILURE); sMouseOverDocument = mDocument.get(); nsCursor c; NS_ENSURE_TRUE(aWidget, NS_ERROR_FAILURE); if (aLockCursor) { if (NS_STYLE_CURSOR_AUTO != aCursor) { mLockCursor = aCursor; } else { //If cursor style is set to auto we unlock the cursor again. mLockCursor = 0; } } switch (aCursor) { default: case NS_STYLE_CURSOR_AUTO: case NS_STYLE_CURSOR_DEFAULT: c = eCursor_standard; break; case NS_STYLE_CURSOR_POINTER: c = eCursor_hyperlink; break; case NS_STYLE_CURSOR_CROSSHAIR: c = eCursor_crosshair; break; case NS_STYLE_CURSOR_MOVE: c = eCursor_move; break; case NS_STYLE_CURSOR_TEXT: c = eCursor_select; break; case NS_STYLE_CURSOR_WAIT: c = eCursor_wait; break; case NS_STYLE_CURSOR_HELP: c = eCursor_help; break; case NS_STYLE_CURSOR_N_RESIZE: c = eCursor_n_resize; break; case NS_STYLE_CURSOR_S_RESIZE: c = eCursor_s_resize; break; case NS_STYLE_CURSOR_W_RESIZE: c = eCursor_w_resize; break; case NS_STYLE_CURSOR_E_RESIZE: c = eCursor_e_resize; break; case NS_STYLE_CURSOR_NW_RESIZE: c = eCursor_nw_resize; break; case NS_STYLE_CURSOR_SE_RESIZE: c = eCursor_se_resize; break; case NS_STYLE_CURSOR_NE_RESIZE: c = eCursor_ne_resize; break; case NS_STYLE_CURSOR_SW_RESIZE: c = eCursor_sw_resize; break; case NS_STYLE_CURSOR_COPY: // CSS3 c = eCursor_copy; break; case NS_STYLE_CURSOR_ALIAS: c = eCursor_alias; break; case NS_STYLE_CURSOR_CONTEXT_MENU: c = eCursor_context_menu; break; case NS_STYLE_CURSOR_CELL: c = eCursor_cell; break; case NS_STYLE_CURSOR_GRAB: c = eCursor_grab; break; case NS_STYLE_CURSOR_GRABBING: c = eCursor_grabbing; break; case NS_STYLE_CURSOR_SPINNING: c = eCursor_spinning; break; case NS_STYLE_CURSOR_ZOOM_IN: c = eCursor_zoom_in; break; case NS_STYLE_CURSOR_ZOOM_OUT: c = eCursor_zoom_out; break; case NS_STYLE_CURSOR_NOT_ALLOWED: c = eCursor_not_allowed; break; case NS_STYLE_CURSOR_COL_RESIZE: c = eCursor_col_resize; break; case NS_STYLE_CURSOR_ROW_RESIZE: c = eCursor_row_resize; break; case NS_STYLE_CURSOR_NO_DROP: c = eCursor_no_drop; break; case NS_STYLE_CURSOR_VERTICAL_TEXT: c = eCursor_vertical_text; break; case NS_STYLE_CURSOR_ALL_SCROLL: c = eCursor_all_scroll; break; case NS_STYLE_CURSOR_NESW_RESIZE: c = eCursor_nesw_resize; break; case NS_STYLE_CURSOR_NWSE_RESIZE: c = eCursor_nwse_resize; break; case NS_STYLE_CURSOR_NS_RESIZE: c = eCursor_ns_resize; break; case NS_STYLE_CURSOR_EW_RESIZE: c = eCursor_ew_resize; break; case NS_STYLE_CURSOR_NONE: c = eCursor_none; break; } // First, try the imgIContainer, if non-null nsresult rv = NS_ERROR_FAILURE; if (aContainer) { uint32_t hotspotX, hotspotY; // css3-ui says to use the CSS-specified hotspot if present, // otherwise use the intrinsic hotspot, otherwise use the top left // corner. if (aHaveHotspot) { int32_t imgWidth, imgHeight; aContainer->GetWidth(&imgWidth); aContainer->GetHeight(&imgHeight); // XXX std::max(NS_lround(x), 0)? hotspotX = aHotspotX > 0.0f ? uint32_t(aHotspotX + 0.5f) : uint32_t(0); if (hotspotX >= uint32_t(imgWidth)) hotspotX = imgWidth - 1; hotspotY = aHotspotY > 0.0f ? uint32_t(aHotspotY + 0.5f) : uint32_t(0); if (hotspotY >= uint32_t(imgHeight)) hotspotY = imgHeight - 1; } else { hotspotX = 0; hotspotY = 0; nsCOMPtr props(do_QueryInterface(aContainer)); if (props) { nsCOMPtr hotspotXWrap, hotspotYWrap; props->Get("hotspotX", NS_GET_IID(nsISupportsPRUint32), getter_AddRefs(hotspotXWrap)); props->Get("hotspotY", NS_GET_IID(nsISupportsPRUint32), getter_AddRefs(hotspotYWrap)); if (hotspotXWrap) hotspotXWrap->GetData(&hotspotX); if (hotspotYWrap) hotspotYWrap->GetData(&hotspotY); } } rv = aWidget->SetCursor(aContainer, hotspotX, hotspotY); } if (NS_FAILED(rv)) aWidget->SetCursor(c); return NS_OK; } class MOZ_STACK_CLASS ESMEventCB : public EventDispatchingCallback { public: explicit ESMEventCB(nsIContent* aTarget) : mTarget(aTarget) {} virtual void HandleEvent(EventChainPostVisitor& aVisitor) { if (aVisitor.mPresContext) { nsIFrame* frame = aVisitor.mPresContext->GetPrimaryFrameFor(mTarget); if (frame) { frame->HandleEvent(aVisitor.mPresContext, aVisitor.mEvent->AsGUIEvent(), &aVisitor.mEventStatus); } } } nsCOMPtr mTarget; }; /*static*/ bool EventStateManager::IsHandlingUserInput() { if (sUserInputEventDepth <= 0) { return false; } TimeDuration timeout = nsContentUtils::HandlingUserInputTimeout(); return timeout <= TimeDuration(0) || (TimeStamp::Now() - sHandlingInputStart) <= timeout; } static void CreateMouseOrPointerWidgetEvent(WidgetMouseEvent* aMouseEvent, EventMessage aMessage, nsIContent* aRelatedContent, nsAutoPtr& aNewEvent) { WidgetPointerEvent* sourcePointer = aMouseEvent->AsPointerEvent(); if (sourcePointer) { PROFILER_LABEL("Input", "DispatchPointerEvent", js::ProfileEntry::Category::EVENTS); nsAutoPtr newPointerEvent; newPointerEvent = new WidgetPointerEvent(aMouseEvent->IsTrusted(), aMessage, aMouseEvent->mWidget); newPointerEvent->mIsPrimary = sourcePointer->mIsPrimary; newPointerEvent->mWidth = sourcePointer->mWidth; newPointerEvent->mHeight = sourcePointer->mHeight; newPointerEvent->inputSource = sourcePointer->inputSource; newPointerEvent->mRelatedTarget = aRelatedContent; aNewEvent = newPointerEvent.forget(); } else { aNewEvent = new WidgetMouseEvent(aMouseEvent->IsTrusted(), aMessage, aMouseEvent->mWidget, WidgetMouseEvent::eReal); aNewEvent->mRelatedTarget = aRelatedContent; } aNewEvent->mRefPoint = aMouseEvent->mRefPoint; aNewEvent->mModifiers = aMouseEvent->mModifiers; aNewEvent->button = aMouseEvent->button; aNewEvent->buttons = aMouseEvent->buttons; aNewEvent->pressure = aMouseEvent->pressure; aNewEvent->mPluginEvent = aMouseEvent->mPluginEvent; aNewEvent->inputSource = aMouseEvent->inputSource; aNewEvent->pointerId = aMouseEvent->pointerId; } nsIFrame* EventStateManager::DispatchMouseOrPointerEvent(WidgetMouseEvent* aMouseEvent, EventMessage aMessage, nsIContent* aTargetContent, nsIContent* aRelatedContent) { // http://dvcs.w3.org/hg/webevents/raw-file/default/mouse-lock.html#methods // "[When the mouse is locked on an element...e]vents that require the concept // of a mouse cursor must not be dispatched (for example: mouseover, mouseout). if (sIsPointerLocked && (aMessage == eMouseLeave || aMessage == eMouseEnter || aMessage == eMouseOver || aMessage == eMouseOut)) { mCurrentTargetContent = nullptr; nsCOMPtr pointerLockedElement = do_QueryReferent(EventStateManager::sPointerLockedElement); if (!pointerLockedElement) { NS_WARNING("Should have pointer locked element, but didn't."); return nullptr; } nsCOMPtr content = do_QueryInterface(pointerLockedElement); return mPresContext->GetPrimaryFrameFor(content); } mCurrentTargetContent = nullptr; if (!aTargetContent) { return nullptr; } nsCOMPtr targetContent = aTargetContent; nsCOMPtr relatedContent = aRelatedContent; nsAutoPtr dispatchEvent; CreateMouseOrPointerWidgetEvent(aMouseEvent, aMessage, relatedContent, dispatchEvent); nsWeakFrame previousTarget = mCurrentTarget; mCurrentTargetContent = targetContent; nsIFrame* targetFrame = nullptr; if (aMouseEvent->AsMouseEvent()) { PROFILER_LABEL("Input", "DispatchMouseEvent", js::ProfileEntry::Category::EVENTS); } nsEventStatus status = nsEventStatus_eIgnore; ESMEventCB callback(targetContent); EventDispatcher::Dispatch(targetContent, mPresContext, dispatchEvent, nullptr, &status, &callback); if (mPresContext) { // Although the primary frame was checked in event callback, it may not be // the same object after event dispatch and handling, so refetch it. targetFrame = mPresContext->GetPrimaryFrameFor(targetContent); // If we are entering/leaving remote content, dispatch a mouse enter/exit // event to the remote frame. if (IsRemoteTarget(targetContent)) { if (aMessage == eMouseOut) { // For remote content, send a "top-level" widget mouse exit event. nsAutoPtr remoteEvent; CreateMouseOrPointerWidgetEvent(aMouseEvent, eMouseExitFromWidget, relatedContent, remoteEvent); remoteEvent->mExitFrom = WidgetMouseEvent::eTopLevel; // 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 = targetFrame; HandleCrossProcessEvent(remoteEvent, &status); } else if (aMessage == eMouseOver) { nsAutoPtr remoteEvent; CreateMouseOrPointerWidgetEvent(aMouseEvent, eMouseEnterIntoWidget, relatedContent, remoteEvent); HandleCrossProcessEvent(remoteEvent, &status); } } } mCurrentTargetContent = nullptr; mCurrentTarget = previousTarget; return targetFrame; } class EnterLeaveDispatcher { public: EnterLeaveDispatcher(EventStateManager* aESM, nsIContent* aTarget, nsIContent* aRelatedTarget, WidgetMouseEvent* aMouseEvent, EventMessage aEventMessage) : mESM(aESM) , mMouseEvent(aMouseEvent) , mEventMessage(aEventMessage) { nsPIDOMWindowInner* win = aTarget ? aTarget->OwnerDoc()->GetInnerWindow() : nullptr; if (aMouseEvent->AsPointerEvent() ? win && win->HasPointerEnterLeaveEventListeners() : win && win->HasMouseEnterLeaveEventListeners()) { mRelatedTarget = aRelatedTarget ? aRelatedTarget->FindFirstNonChromeOnlyAccessContent() : nullptr; nsINode* commonParent = nullptr; if (aTarget && aRelatedTarget) { commonParent = nsContentUtils::GetCommonAncestor(aTarget, aRelatedTarget); } nsIContent* current = aTarget; // Note, it is ok if commonParent is null! while (current && current != commonParent) { if (!current->ChromeOnlyAccess()) { mTargets.AppendObject(current); } // mouseenter/leave is fired only on elements. current = current->GetParent(); } } } void Dispatch() { if (mEventMessage == eMouseEnter || mEventMessage == ePointerEnter) { for (int32_t i = mTargets.Count() - 1; i >= 0; --i) { mESM->DispatchMouseOrPointerEvent(mMouseEvent, mEventMessage, mTargets[i], mRelatedTarget); } } else { for (int32_t i = 0; i < mTargets.Count(); ++i) { mESM->DispatchMouseOrPointerEvent(mMouseEvent, mEventMessage, mTargets[i], mRelatedTarget); } } } EventStateManager* mESM; nsCOMArray mTargets; nsCOMPtr mRelatedTarget; WidgetMouseEvent* mMouseEvent; EventMessage mEventMessage; }; void EventStateManager::NotifyMouseOut(WidgetMouseEvent* aMouseEvent, nsIContent* aMovingInto) { OverOutElementsWrapper* wrapper = GetWrapperByEventID(aMouseEvent); if (!wrapper->mLastOverElement) return; // Before firing mouseout, check for recursion if (wrapper->mLastOverElement == wrapper->mFirstOutEventElement) return; if (wrapper->mLastOverFrame) { // if the frame is associated with a subdocument, // tell the subdocument that we're moving out of it nsSubDocumentFrame* subdocFrame = do_QueryFrame(wrapper->mLastOverFrame.GetFrame()); if (subdocFrame) { nsCOMPtr docshell; subdocFrame->GetDocShell(getter_AddRefs(docshell)); if (docshell) { RefPtr presContext; docshell->GetPresContext(getter_AddRefs(presContext)); if (presContext) { EventStateManager* kidESM = presContext->EventStateManager(); // Not moving into any element in this subdocument kidESM->NotifyMouseOut(aMouseEvent, nullptr); } } } } // That could have caused DOM events which could wreak havoc. Reverify // things and be careful. if (!wrapper->mLastOverElement) return; // Store the first mouseOut event we fire and don't refire mouseOut // to that element while the first mouseOut is still ongoing. wrapper->mFirstOutEventElement = wrapper->mLastOverElement; // 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. bool isPointer = aMouseEvent->mClass == ePointerEventClass; if (!aMovingInto && !isPointer) { // Unset :hover SetContentState(nullptr, NS_EVENT_STATE_HOVER); } EnterLeaveDispatcher leaveDispatcher(this, wrapper->mLastOverElement, aMovingInto, aMouseEvent, isPointer ? ePointerLeave : eMouseLeave); // Fire mouseout DispatchMouseOrPointerEvent(aMouseEvent, isPointer ? ePointerOut : eMouseOut, wrapper->mLastOverElement, aMovingInto); leaveDispatcher.Dispatch(); wrapper->mLastOverFrame = nullptr; wrapper->mLastOverElement = nullptr; // Turn recursion protection back off wrapper->mFirstOutEventElement = nullptr; } void EventStateManager::NotifyMouseOver(WidgetMouseEvent* aMouseEvent, nsIContent* aContent) { NS_ASSERTION(aContent, "Mouse must be over something"); OverOutElementsWrapper* wrapper = GetWrapperByEventID(aMouseEvent); if (wrapper->mLastOverElement == aContent) return; // Before firing mouseover, check for recursion if (aContent == wrapper->mFirstOverEventElement) return; // 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 (nsIDocument *parentDoc = mDocument->GetParentDocument()) { if (nsCOMPtr docContent = parentDoc->FindContentForSubDocument(mDocument)) { if (nsIPresShell *parentShell = parentDoc->GetShell()) { RefPtr parentESM = parentShell->GetPresContext()->EventStateManager(); parentESM->NotifyMouseOver(aMouseEvent, docContent); } } } // Firing the DOM event in the parent document could cause all kinds // of havoc. Reverify and take care. if (wrapper->mLastOverElement == aContent) return; // Remember mLastOverElement as the related content for the // DispatchMouseOrPointerEvent() call below, since NotifyMouseOut() resets it, bug 298477. nsCOMPtr lastOverElement = wrapper->mLastOverElement; bool isPointer = aMouseEvent->mClass == ePointerEventClass; EnterLeaveDispatcher enterDispatcher(this, aContent, lastOverElement, aMouseEvent, isPointer ? ePointerEnter : eMouseEnter); NotifyMouseOut(aMouseEvent, aContent); // Store the first mouseOver event we fire and don't refire mouseOver // to that element while the first mouseOver is still ongoing. wrapper->mFirstOverEventElement = aContent; if (!isPointer) { SetContentState(aContent, NS_EVENT_STATE_HOVER); } // Fire mouseover wrapper->mLastOverFrame = DispatchMouseOrPointerEvent(aMouseEvent, isPointer ? ePointerOver : eMouseOver, aContent, lastOverElement); enterDispatcher.Dispatch(); wrapper->mLastOverElement = aContent; // Turn recursion protection back off wrapper->mFirstOverEventElement = nullptr; } // 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)); LayoutDeviceIntRect rect = aWidget->GetClientBounds(); LayoutDeviceIntPoint point(rect.x + rect.width / 2, rect.y + rect.height / 2); int32_t round = aWidget->RoundsWidgetCoordinatesTo(); point.x = point.x / round * round; point.y = point.y / round * round; return point - aWidget->WidgetToScreenOffset(); } void EventStateManager::GeneratePointerEnterExit(EventMessage aMessage, WidgetMouseEvent* aEvent) { WidgetPointerEvent pointerEvent(*aEvent); pointerEvent.mMessage = aMessage; GenerateMouseEnterExit(&pointerEvent); } void EventStateManager::GenerateMouseEnterExit(WidgetMouseEvent* aMouseEvent) { EnsureDocument(mPresContext); if (!mDocument) return; // Hold onto old target content through the event and reset after. nsCOMPtr targetBeforeEvent = mCurrentTargetContent; switch(aMouseEvent->mMessage) { case eMouseMove: { // 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 (sIsPointerLocked && 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. LayoutDeviceIntPoint center = GetWindowClientRectCenter(aMouseEvent->mWidget); aMouseEvent->mLastRefPoint = center; if (aMouseEvent->mRefPoint != center) { // 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; aMouseEvent->mWidget->SynthesizeNativeMouseMove( center + aMouseEvent->mWidget->WidgetToScreenOffset(), nullptr); } else if (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. sSynthCenteringPoint = kInvalidRefPoint; } } else if (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; } // Update the last known mRefPoint with the current mRefPoint. sLastRefPoint = aMouseEvent->mRefPoint; } MOZ_FALLTHROUGH; case ePointerMove: case ePointerDown: case ePointerGotCapture: { // Get the target content target (mousemove target == mouseover target) nsCOMPtr 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: { // Get the target content target (mousemove target == mouseover target) nsCOMPtr 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) { OverOutElementsWrapper* helper = GetWrapperByEventID(aMouseEvent); if (helper) { helper->mLastOverElement = targetElement; } NotifyMouseOut(aMouseEvent, nullptr); } } 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. OverOutElementsWrapper* helper = GetWrapperByEventID(aMouseEvent); if (helper->mLastOverFrame && nsContentUtils::GetTopLevelWidget(aMouseEvent->mWidget) != nsContentUtils::GetTopLevelWidget(helper->mLastOverFrame->GetNearestWidget())) { // the Mouse/PointerOut event widget doesn't have same top widget with // mLastOverFrame, it's a spurious event for mLastOverFrame break; } // Reset sLastRefPoint, so that we'll know not to report any // movement the next time we re-enter the window. sLastRefPoint = kInvalidRefPoint; NotifyMouseOut(aMouseEvent, nullptr); } break; default: break; } // reset mCurretTargetContent to what it was mCurrentTargetContent = targetBeforeEvent; } OverOutElementsWrapper* EventStateManager::GetWrapperByEventID(WidgetMouseEvent* aEvent) { WidgetPointerEvent* pointer = aEvent->AsPointerEvent(); if (!pointer) { MOZ_ASSERT(aEvent->AsMouseEvent() != nullptr); if (!mMouseEnterLeaveHelper) { mMouseEnterLeaveHelper = new OverOutElementsWrapper(); } return mMouseEnterLeaveHelper; } RefPtr helper; if (!mPointersEnterLeaveHelper.Get(pointer->pointerId, getter_AddRefs(helper))) { helper = new OverOutElementsWrapper(); mPointersEnterLeaveHelper.Put(pointer->pointerId, helper); } return helper; } /* static */ void EventStateManager::SetPointerLock(nsIWidget* aWidget, nsIContent* aElement) { // NOTE: aElement will be nullptr when unlocking. sIsPointerLocked = !!aElement; // Reset mouse wheel transaction WheelTransaction::EndTransaction(); // Deal with DnD events nsCOMPtr dragService = do_GetService("@mozilla.org/widget/dragservice;1"); if (sIsPointerLocked) { MOZ_ASSERT(aWidget, "Locking pointer requires a widget"); // Store the last known ref point so we can reposition the pointer after unlock. sPreLockPoint = sLastRefPoint; // 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. sLastRefPoint = GetWindowClientRectCenter(aWidget); aWidget->SynthesizeNativeMouseMove( sLastRefPoint + aWidget->WidgetToScreenOffset(), nullptr); // Suppress DnD if (dragService) { dragService->Suppress(); } } else { // 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 = sPreLockPoint; // Reset SynthCenteringPoint to invalid so that next time we start // locking pointer, it has its initial value. sSynthCenteringPoint = kInvalidRefPoint; if (aWidget) { aWidget->SynthesizeNativeMouseMove( sPreLockPoint + aWidget->WidgetToScreenOffset(), 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 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 lastContent; nsCOMPtr targetContent; mCurrentTarget->GetContentForEvent(aDragEvent, getter_AddRefs(targetContent)); if (sLastDragOverFrame) { //The frame has changed but the content may not have. Check before dispatching to content sLastDragOverFrame->GetContentForEvent(aDragEvent, getter_AddRefs(lastContent)); FireDragEnterOrExit(sLastDragOverFrame->PresContext(), aDragEvent, eDragExit, targetContent, lastContent, sLastDragOverFrame); nsIContent* target = sLastDragOverFrame ? sLastDragOverFrame.GetFrame()->GetContent() : nullptr; if (IsRemoteTarget(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); nsEventStatus remoteStatus = nsEventStatus_eIgnore; HandleCrossProcessEvent(&remoteEvent, &remoteStatus); } } FireDragEnterOrExit(aPresContext, aDragEvent, eDragEnter, lastContent, targetContent, mCurrentTarget); if (sLastDragOverFrame) { FireDragEnterOrExit(sLastDragOverFrame->PresContext(), aDragEvent, eDragLeave, targetContent, lastContent, sLastDragOverFrame); } sLastDragOverFrame = mCurrentTarget; } } break; case eDragExit: { //This is actually the window mouse exit event. if (sLastDragOverFrame) { nsCOMPtr lastContent; sLastDragOverFrame->GetContentForEvent(aDragEvent, getter_AddRefs(lastContent)); RefPtr lastDragOverFramePresContext = sLastDragOverFrame->PresContext(); FireDragEnterOrExit(lastDragOverFramePresContext, aDragEvent, eDragExit, nullptr, lastContent, sLastDragOverFrame); FireDragEnterOrExit(lastDragOverFramePresContext, aDragEvent, eDragLeave, nullptr, lastContent, sLastDragOverFrame); sLastDragOverFrame = nullptr; } } break; default: break; } //reset mCurretTargetContent to what it was mCurrentTargetContent = targetBeforeEvent; // Now flush all pending notifications, for better responsiveness. FlushPendingEvents(aPresContext); } void EventStateManager::FireDragEnterOrExit(nsPresContext* aPresContext, WidgetDragEvent* aDragEvent, EventMessage aMessage, nsIContent* aRelatedTarget, nsIContent* aTargetContent, nsWeakFrame& aTargetFrame) { MOZ_ASSERT(aMessage == eDragLeave || aMessage == eDragExit || aMessage == eDragEnter); nsEventStatus status = nsEventStatus_eIgnore; WidgetDragEvent event(aDragEvent->IsTrusted(), aMessage, aDragEvent->mWidget); event.AssignDragEventData(*aDragEvent, true); mCurrentTargetContent = aTargetContent; 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, NS_EVENT_STATE_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; } nsCOMPtr dragSession = nsContentUtils::GetDragSession(); if (dragSession) { // the initial dataTransfer is the one from the dragstart event that // was set on the dragSession when the drag began. nsCOMPtr initialDataTransfer; dragSession->GetDataTransfer(getter_AddRefs(initialDataTransfer)); if (initialDataTransfer) { // retrieve the current moz cursor setting and save it. nsAutoString mozCursor; dragEvent->mDataTransfer->GetMozCursor(mozCursor); initialDataTransfer->SetMozCursor(mozCursor); } } } nsresult EventStateManager::SetClickCount(WidgetMouseEvent* aEvent, nsEventStatus* aStatus) { nsCOMPtr mouseContent; nsIContent* mouseContentParent = nullptr; if (mCurrentTarget) { mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(mouseContent)); } if (mouseContent) { if (mouseContent->IsNodeOfType(nsINode::eTEXT)) { mouseContent = mouseContent->GetParent(); } if (mouseContent && mouseContent->IsRootOfNativeAnonymousSubtree()) { mouseContentParent = mouseContent->GetParent(); } } switch (aEvent->button) { case WidgetMouseEvent::eLeftButton: if (aEvent->mMessage == eMouseDown) { mLastLeftMouseDownContent = mouseContent; mLastLeftMouseDownContentParent = mouseContentParent; } else if (aEvent->mMessage == eMouseUp) { if (mLastLeftMouseDownContent == mouseContent || mLastLeftMouseDownContentParent == mouseContent || mLastLeftMouseDownContent == mouseContentParent) { aEvent->mClickCount = mLClickCount; mLClickCount = 0; } else { aEvent->mClickCount = 0; } mLastLeftMouseDownContent = nullptr; mLastLeftMouseDownContentParent = nullptr; } break; case WidgetMouseEvent::eMiddleButton: if (aEvent->mMessage == eMouseDown) { mLastMiddleMouseDownContent = mouseContent; mLastMiddleMouseDownContentParent = mouseContentParent; } else if (aEvent->mMessage == eMouseUp) { if (mLastMiddleMouseDownContent == mouseContent || mLastMiddleMouseDownContentParent == mouseContent || mLastMiddleMouseDownContent == mouseContentParent) { aEvent->mClickCount = mMClickCount; mMClickCount = 0; } else { aEvent->mClickCount = 0; } mLastMiddleMouseDownContent = nullptr; mLastMiddleMouseDownContentParent = nullptr; } break; case WidgetMouseEvent::eRightButton: if (aEvent->mMessage == eMouseDown) { mLastRightMouseDownContent = mouseContent; mLastRightMouseDownContentParent = mouseContentParent; } else if (aEvent->mMessage == eMouseUp) { if (mLastRightMouseDownContent == mouseContent || mLastRightMouseDownContentParent == mouseContent || mLastRightMouseDownContent == mouseContentParent) { aEvent->mClickCount = mRClickCount; mRClickCount = 0; } else { aEvent->mClickCount = 0; } mLastRightMouseDownContent = nullptr; mLastRightMouseDownContentParent = nullptr; } break; } return NS_OK; } nsresult EventStateManager::InitAndDispatchClickEvent(WidgetMouseEvent* aEvent, nsEventStatus* aStatus, EventMessage aMessage, nsIPresShell* aPresShell, nsIContent* aMouseTarget, nsWeakFrame aCurrentTarget, bool aNoContentDispatch) { WidgetMouseEvent event(aEvent->IsTrusted(), aMessage, aEvent->mWidget, WidgetMouseEvent::eReal); event.mRefPoint = aEvent->mRefPoint; event.mClickCount = aEvent->mClickCount; event.mModifiers = aEvent->mModifiers; event.buttons = aEvent->buttons; event.mTime = aEvent->mTime; event.mTimeStamp = aEvent->mTimeStamp; event.mFlags.mNoContentDispatch = aNoContentDispatch; event.button = aEvent->button; event.inputSource = aEvent->inputSource; return aPresShell->HandleEventWithTarget(&event, aCurrentTarget, aMouseTarget, aStatus); } nsresult EventStateManager::CheckForAndDispatchClick(WidgetMouseEvent* aEvent, nsEventStatus* aStatus) { nsresult ret = NS_OK; //If mouse is still over same element, clickcount will be > 1. //If it has moved it will be zero, so no click. if (aEvent->mClickCount) { //Check that the window isn't disabled before firing a click //(see bug 366544). if (aEvent->mWidget && !aEvent->mWidget->IsEnabled()) { return ret; } //fire click bool notDispatchToContents = (aEvent->button == WidgetMouseEvent::eMiddleButton || aEvent->button == WidgetMouseEvent::eRightButton); bool fireAuxClick = notDispatchToContents; nsCOMPtr presShell = mPresContext->GetPresShell(); if (presShell) { nsCOMPtr mouseContent = GetEventTargetContent(aEvent); // Click events apply to *elements* not nodes. At this point the target // content may have been reset to some non-element content, and so we need // to walk up the closest ancestor element, just like we do in // nsPresShell::HandlePositionedEvent. while (mouseContent && !mouseContent->IsElement()) { mouseContent = mouseContent->GetParent(); } if (!mouseContent && !mCurrentTarget) { return NS_OK; } // HandleEvent clears out mCurrentTarget which we might need again nsWeakFrame currentTarget = mCurrentTarget; ret = InitAndDispatchClickEvent(aEvent, aStatus, eMouseClick, presShell, mouseContent, currentTarget, notDispatchToContents); if (NS_SUCCEEDED(ret) && aEvent->mClickCount == 2 && mouseContent && mouseContent->IsInComposedDoc()) { //fire double click ret = InitAndDispatchClickEvent(aEvent, aStatus, eMouseDoubleClick, presShell, mouseContent, currentTarget, notDispatchToContents); } if (NS_SUCCEEDED(ret) && mouseContent && fireAuxClick && mouseContent->IsInComposedDoc()) { ret = InitAndDispatchClickEvent(aEvent, aStatus, eMouseAuxClick, presShell, mouseContent, currentTarget, false); } } } return ret; } nsIFrame* EventStateManager::GetEventTarget() { nsIPresShell *shell; if (mCurrentTarget || !mPresContext || !(shell = mPresContext->GetPresShell())) { return mCurrentTarget; } if (mCurrentTargetContent) { mCurrentTarget = mPresContext->GetPrimaryFrameFor(mCurrentTargetContent); if (mCurrentTarget) { return mCurrentTarget; } } nsIFrame* frame = shell->GetEventTargetFrame(); return (mCurrentTarget = frame); } already_AddRefed EventStateManager::GetEventTargetContent(WidgetEvent* aEvent) { if (aEvent && (aEvent->mMessage == eFocus || aEvent->mMessage == eBlur)) { nsCOMPtr content = GetFocusedContent(); return content.forget(); } if (mCurrentTargetContent) { nsCOMPtr content = mCurrentTargetContent; return content.forget(); } nsCOMPtr content; nsIPresShell *presShell = mPresContext->GetPresShell(); if (presShell) { content = presShell->GetEventTargetContent(aEvent); } // 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)); } return content.forget(); } static Element* GetLabelTarget(nsIContent* aPossibleLabel) { mozilla::dom::HTMLLabelElement* label = mozilla::dom::HTMLLabelElement::FromContent(aPossibleLabel); if (!label) return nullptr; return label->GetLabeledElement(); } static nsIContent* FindCommonAncestor(nsIContent *aNode1, nsIContent *aNode2) { // Find closest common ancestor if (aNode1 && aNode2) { // Find the nearest common ancestor by counting the distance to the // root and then walking up again, in pairs. int32_t offset = 0; nsIContent *anc1 = aNode1; for (;;) { ++offset; nsIContent* parent = anc1->GetFlattenedTreeParent(); if (!parent) break; anc1 = parent; } nsIContent *anc2 = aNode2; for (;;) { --offset; nsIContent* parent = anc2->GetFlattenedTreeParent(); if (!parent) break; anc2 = parent; } if (anc1 == anc2) { anc1 = aNode1; anc2 = aNode2; while (offset > 0) { anc1 = anc1->GetFlattenedTreeParent(); --offset; } while (offset < 0) { anc2 = anc2->GetFlattenedTreeParent(); ++offset; } while (anc1 != anc2) { anc1 = anc1->GetFlattenedTreeParent(); anc2 = anc2->GetFlattenedTreeParent(); } return anc1; } } return nullptr; } /* static */ void EventStateManager::SetFullScreenState(Element* aElement, bool aIsFullScreen) { DoStateChange(aElement, NS_EVENT_STATE_FULL_SCREEN, aIsFullScreen); } /* static */ inline void EventStateManager::DoStateChange(Element* aElement, EventStates aState, bool aAddState) { if (aAddState) { aElement->AddStates(aState); } else { aElement->RemoveStates(aState); } } /* static */ inline void EventStateManager::DoStateChange(nsIContent* aContent, EventStates aState, bool aStateAdded) { if (aContent->IsElement()) { DoStateChange(aContent->AsElement(), aState, aStateAdded); } } /* static */ void EventStateManager::UpdateAncestorState(nsIContent* aStartNode, nsIContent* aStopBefore, EventStates 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; } Element* labelTarget = GetLabelTarget(aStartNode->AsElement()); if (labelTarget && !labelTarget->State().HasState(aState)) { DoStateChange(labelTarget, aState, true); } } } } bool EventStateManager::SetContentState(nsIContent* aContent, EventStates aState) { // We manage 4 states here: ACTIVE, HOVER, DRAGOVER, URLTARGET // The input must be exactly one of them. NS_PRECONDITION(aState == NS_EVENT_STATE_ACTIVE || aState == NS_EVENT_STATE_HOVER || aState == NS_EVENT_STATE_DRAGOVER || aState == NS_EVENT_STATE_URLTARGET, "Unexpected state"); nsCOMPtr notifyContent1; nsCOMPtr notifyContent2; bool updateAncestors; if (aState == NS_EVENT_STATE_HOVER || aState == NS_EVENT_STATE_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) { const nsStyleUserInterface* ui = mCurrentTarget->StyleUserInterface(); if (ui->mUserInput == StyleUserInput::None) { return false; } } if (aState == NS_EVENT_STATE_ACTIVE) { // 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. if (aContent && aContent->IsEditable() && !aContent->IsInNativeAnonymousSubtree()) { aContent = nullptr; } if (aContent != mActiveContent) { notifyContent1 = aContent; notifyContent2 = mActiveContent; mActiveContent = aContent; } } else { NS_ASSERTION(aState == NS_EVENT_STATE_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; } } if (newHover != mHoverContent) { notifyContent1 = newHover; notifyContent2 = mHoverContent; mHoverContent = newHover; } } } else { updateAncestors = false; if (aState == NS_EVENT_STATE_DRAGOVER) { if (aContent != sDragOverContent) { notifyContent1 = aContent; notifyContent2 = sDragOverContent; sDragOverContent = aContent; } } else if (aState == NS_EVENT_STATE_URLTARGET) { if (aContent != mURLTargetContent) { notifyContent1 = aContent; notifyContent2 = mURLTargetContent; mURLTargetContent = aContent; } } } // 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 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); } } } return true; } void EventStateManager::ResetLastOverForContent( const uint32_t& aIdx, RefPtr& aElemWrapper, nsIContent* aContent) { if (aElemWrapper && aElemWrapper->mLastOverElement && nsContentUtils::ContentIsDescendantOf(aElemWrapper->mLastOverElement, aContent)) { aElemWrapper->mLastOverElement = nullptr; } } void EventStateManager::ContentRemoved(nsIDocument* 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(NS_EVENT_STATE_FOCUS | NS_EVENT_STATE_HOVER))) { nsGenericHTMLElement* element = static_cast(aContent); element->LeaveLink( element->GetPresContext(nsGenericHTMLElement::eForComposedDoc)); } IMEStateManager::OnRemoveContent(mPresContext, aContent); // inform the focus manager that the content is being removed. If this // content is focused, the focus will be removed without firing events. nsFocusManager* fm = nsFocusManager::GetFocusManager(); if (fm) fm->ContentRemoved(aDocument, aContent); if (mHoverContent && nsContentUtils::ContentIsDescendantOf(mHoverContent, aContent)) { // Since hover is hierarchical, set the current hover to the // content's parent node. SetContentState(aContent->GetParent(), NS_EVENT_STATE_HOVER); } if (mActiveContent && nsContentUtils::ContentIsDescendantOf(mActiveContent, aContent)) { // Active is hierarchical, so set the current active to the // content's parent node. SetContentState(aContent->GetParent(), NS_EVENT_STATE_ACTIVE); } if (sDragOverContent && sDragOverContent->OwnerDoc() == aContent->OwnerDoc() && nsContentUtils::ContentIsDescendantOf(sDragOverContent, aContent)) { sDragOverContent = nullptr; } // See bug 292146 for why we want to null this out ResetLastOverForContent(0, mMouseEnterLeaveHelper, aContent); for (auto iter = mPointersEnterLeaveHelper.Iter(); !iter.Done(); iter.Next()) { ResetLastOverForContent(iter.Key(), iter.Data(), aContent); } } bool EventStateManager::EventStatusOK(WidgetGUIEvent* aEvent) { return !(aEvent->mMessage == eMouseDown && aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton && !sNormalLMouseEventInProcess); } //------------------------------------------- // Access Key Registration //------------------------------------------- void EventStateManager::RegisterAccessKey(nsIContent* aContent, uint32_t aKey) { if (aContent && mAccessKeys.IndexOf(aContent) == -1) mAccessKeys.AppendObject(aContent); } void EventStateManager::UnregisterAccessKey(nsIContent* aContent, uint32_t aKey) { if (aContent) mAccessKeys.RemoveObject(aContent); } uint32_t EventStateManager::GetRegisteredAccessKey(nsIContent* aContent) { MOZ_ASSERT(aContent); if (mAccessKeys.IndexOf(aContent) == -1) return 0; nsAutoString accessKey; aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, accessKey); return accessKey.First(); } void EventStateManager::EnsureDocument(nsPresContext* aPresContext) { if (!mDocument) mDocument = aPresContext->Document(); } void EventStateManager::FlushPendingEvents(nsPresContext* aPresContext) { NS_PRECONDITION(nullptr != aPresContext, "nullptr ptr"); nsIPresShell *shell = aPresContext->GetPresShell(); if (shell) { shell->FlushPendingNotifications(Flush_InterruptibleLayout); } } nsIContent* EventStateManager::GetFocusedContent() { nsIFocusManager* fm = nsFocusManager::GetFocusManager(); EnsureDocument(mPresContext); if (!fm || !mDocument) return nullptr; nsCOMPtr focusedWindow; return nsFocusManager::GetFocusedDescendant(mDocument->GetWindow(), false, getter_AddRefs(focusedWindow)); } //------------------------------------------------------- // Return true if the docshell is visible bool EventStateManager::IsShellVisible(nsIDocShell* aShell) { NS_ASSERTION(aShell, "docshell is null"); nsCOMPtr basewin = do_QueryInterface(aShell); if (!basewin) return true; bool isVisible = true; basewin->GetVisibility(&isVisible); // We should be doing some additional checks here so that // we don't tab into hidden tabs of tabbrowser. -bryner return isVisible; } nsresult EventStateManager::DoContentCommandEvent(WidgetContentCommandEvent* aEvent) { EnsureDocument(mPresContext); NS_ENSURE_TRUE(mDocument, NS_ERROR_FAILURE); nsCOMPtr window(mDocument->GetWindow()); NS_ENSURE_TRUE(window, NS_ERROR_FAILURE); nsCOMPtr root = window->GetTopWindowRoot(); NS_ENSURE_TRUE(root, NS_ERROR_FAILURE); const char* cmd; switch (aEvent->mMessage) { case eContentCommandCut: cmd = "cmd_cut"; break; case eContentCommandCopy: cmd = "cmd_copy"; break; case eContentCommandPaste: cmd = "cmd_paste"; break; case eContentCommandDelete: cmd = "cmd_delete"; break; case eContentCommandUndo: cmd = "cmd_undo"; break; case eContentCommandRedo: cmd = "cmd_redo"; break; case eContentCommandPasteTransferable: cmd = "cmd_pasteTransferable"; break; case eContentCommandLookUpDictionary: cmd = "cmd_lookUpDictionary"; break; default: return NS_ERROR_NOT_IMPLEMENTED; } nsCOMPtr controller; nsresult rv = root->GetControllerForCommand(cmd, 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: { nsFocusManager* fm = nsFocusManager::GetFocusManager(); nsIContent* focusedContent = fm ? fm->GetFocusedContent() : nullptr; RefPtr remote = TabParent::GetFrom(focusedContent); if (remote) { NS_ENSURE_TRUE(remote->Manager()->IsContentParent(), NS_ERROR_FAILURE); nsCOMPtr transferable = aEvent->mTransferable; IPCDataTransfer ipcDataTransfer; ContentParent* cp = remote->Manager()->AsContentParent(); nsContentUtils::TransferableToIPCTransferable(transferable, &ipcDataTransfer, false, nullptr, cp); bool isPrivateData = false; transferable->GetIsPrivateData(&isPrivateData); nsCOMPtr requestingPrincipal; transferable->GetRequestingPrincipal(getter_AddRefs(requestingPrincipal)); remote->SendPasteTransferable(ipcDataTransfer, isPrivateData, IPC::Principal(requestingPrincipal)); rv = NS_OK; } else { nsCOMPtr commandController = do_QueryInterface(controller); NS_ENSURE_STATE(commandController); nsCOMPtr params = do_CreateInstance("@mozilla.org/embedcomp/command-params;1", &rv); NS_ENSURE_SUCCESS(rv, rv); rv = params->SetISupportsValue("transferable", aEvent->mTransferable); NS_ENSURE_SUCCESS(rv, rv); rv = commandController->DoCommandWithParams(cmd, params); } break; } case eContentCommandLookUpDictionary: { nsCOMPtr commandController = do_QueryInterface(controller); if (NS_WARN_IF(!commandController)) { return NS_ERROR_FAILURE; } nsCOMPtr params = do_CreateInstance("@mozilla.org/embedcomp/command-params;1", &rv); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } rv = params->SetLongValue("x", aEvent->mRefPoint.x); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } rv = params->SetLongValue("y", aEvent->mRefPoint.y); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } rv = commandController->DoCommandWithParams(cmd, params); break; } default: rv = controller->DoCommand(cmd); break; } NS_ENSURE_SUCCESS(rv, rv); } } aEvent->mSucceeded = true; return NS_OK; } nsresult EventStateManager::DoContentCommandScrollEvent( WidgetContentCommandEvent* aEvent) { NS_ENSURE_TRUE(mPresContext, NS_ERROR_NOT_AVAILABLE); nsIPresShell* ps = mPresContext->GetPresShell(); NS_ENSURE_TRUE(ps, NS_ERROR_NOT_AVAILABLE); NS_ENSURE_TRUE(aEvent->mScroll.mAmount != 0, NS_ERROR_INVALID_ARG); nsIScrollableFrame::ScrollUnit scrollUnit; switch (aEvent->mScroll.mUnit) { case WidgetContentCommandEvent::eCmdScrollUnit_Line: scrollUnit = nsIScrollableFrame::LINES; break; case WidgetContentCommandEvent::eCmdScrollUnit_Page: scrollUnit = nsIScrollableFrame::PAGES; break; case WidgetContentCommandEvent::eCmdScrollUnit_Whole: scrollUnit = nsIScrollableFrame::WHOLE; break; default: return NS_ERROR_INVALID_ARG; } aEvent->mSucceeded = true; nsIScrollableFrame* sf = ps->GetFrameToScrollAsScrollable(nsIPresShell::eEither); aEvent->mIsEnabled = sf ? (aEvent->mScroll.mIsHorizontal ? WheelHandlingUtils::CanScrollOn(sf, aEvent->mScroll.mAmount, 0) : WheelHandlingUtils::CanScrollOn(sf, 0, aEvent->mScroll.mAmount)) : false; if (!aEvent->mIsEnabled || aEvent->mOnlyEnabledCheck) { return NS_OK; } nsIntPoint pt(0, 0); if (aEvent->mScroll.mIsHorizontal) { pt.x = aEvent->mScroll.mAmount; } else { pt.y = aEvent->mScroll.mAmount; } // The caller may want synchronous scrolling. sf->ScrollBy(pt, scrollUnit, nsIScrollableFrame::INSTANT); return NS_OK; } void EventStateManager::SetActiveManager(EventStateManager* aNewESM, nsIContent* aContent) { if (sActiveESM && aNewESM != sActiveESM) { sActiveESM->SetContentState(nullptr, NS_EVENT_STATE_ACTIVE); } sActiveESM = aNewESM; if (sActiveESM && aContent) { sActiveESM->SetContentState(aContent, NS_EVENT_STATE_ACTIVE); } } void EventStateManager::ClearGlobalActiveContent(EventStateManager* aClearer) { if (aClearer) { aClearer->SetContentState(nullptr, NS_EVENT_STATE_ACTIVE); if (sDragOverContent) { aClearer->SetContentState(nullptr, NS_EVENT_STATE_DRAGOVER); } } if (sActiveESM && aClearer != sActiveESM) { sActiveESM->SetContentState(nullptr, NS_EVENT_STATE_ACTIVE); } sActiveESM = nullptr; } /******************************************************************/ /* mozilla::EventStateManager::DeltaAccumulator */ /******************************************************************/ void EventStateManager::DeltaAccumulator::InitLineOrPageDelta( nsIFrame* aTargetFrame, EventStateManager* aESM, WidgetWheelEvent* aEvent) { MOZ_ASSERT(aESM); MOZ_ASSERT(aEvent); // Reset if the previous wheel event is too old. if (!mLastTime.IsNull()) { TimeDuration duration = TimeStamp::Now() - mLastTime; if (duration.ToMilliseconds() > WheelTransaction::GetTimeoutTime()) { 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; } } } mHandlingDeltaMode = aEvent->mDeltaMode; mIsNoLineOrPageDeltaDevice = aEvent->mIsNoLineOrPageDelta; // 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. 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 == nsIDOMWheelEvent::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. nsIFrame* frame = aESM->ComputeScrollTarget(aTargetFrame, aEvent, COMPUTE_LEGACY_MOUSE_SCROLL_EVENT_TARGET); nsPresContext* pc = frame ? frame->PresContext() : aTargetFrame->PresContext(); nsIScrollableFrame* scrollTarget = do_QueryFrame(frame); nsSize scrollAmount = aESM->GetScrollAmount(pc, aEvent, scrollTarget); nsIntSize scrollAmountInCSSPixels( nsPresContext::AppUnitsToIntCSSPixels(scrollAmount.width), nsPresContext::AppUnitsToIntCSSPixels(scrollAmount.height)); aEvent->mLineOrPageDeltaX = RoundDown(mX) / scrollAmountInCSSPixels.width; aEvent->mLineOrPageDeltaY = RoundDown(mY) / scrollAmountInCSSPixels.height; mX -= aEvent->mLineOrPageDeltaX * scrollAmountInCSSPixels.width; mY -= aEvent->mLineOrPageDeltaY * scrollAmountInCSSPixels.height; } else { aEvent->mLineOrPageDeltaX = RoundDown(mX); aEvent->mLineOrPageDeltaY = RoundDown(mY); mX -= aEvent->mLineOrPageDeltaX; mY -= aEvent->mLineOrPageDeltaY; } mLastTime = TimeStamp::Now(); } void EventStateManager::DeltaAccumulator::Reset() { mX = mY = 0.0; mPendingScrollAmountX = mPendingScrollAmountY = 0.0; mHandlingDeltaMode = UINT32_MAX; mIsNoLineOrPageDeltaDevice = false; } nsIntPoint EventStateManager::DeltaAccumulator::ComputeScrollAmountForDefaultAction( WidgetWheelEvent* aEvent, const nsIntSize& aScrollAmountInDevPixels) { MOZ_ASSERT(aEvent); // If the wheel event is line scroll and the delta value is computed from // system settings, allow to override the system speed. bool allowScrollSpeedOverride = (!aEvent->mCustomizedByUserPrefs && aEvent->mDeltaMode == nsIDOMWheelEvent::DOM_DELTA_LINE); DeltaValues acceleratedDelta = WheelTransaction::AccelerateWheelDelta(aEvent, allowScrollSpeedOverride); nsIntPoint result(0, 0); if (aEvent->mDeltaMode == nsIDOMWheelEvent::DOM_DELTA_PIXEL) { mPendingScrollAmountX += acceleratedDelta.deltaX; mPendingScrollAmountY += acceleratedDelta.deltaY; } else { mPendingScrollAmountX += aScrollAmountInDevPixels.width * acceleratedDelta.deltaX; mPendingScrollAmountY += aScrollAmountInDevPixels.height * acceleratedDelta.deltaY; } result.x = RoundDown(mPendingScrollAmountX); result.y = RoundDown(mPendingScrollAmountY); mPendingScrollAmountX -= result.x; mPendingScrollAmountY -= result.y; return result; } /******************************************************************/ /* mozilla::EventStateManager::WheelPrefs */ /******************************************************************/ // static EventStateManager::WheelPrefs* EventStateManager::WheelPrefs::GetInstance() { if (!sInstance) { sInstance = new WheelPrefs(); } return sInstance; } // static void EventStateManager::WheelPrefs::Shutdown() { delete sInstance; sInstance = nullptr; } // static void EventStateManager::WheelPrefs::OnPrefChanged(const char* aPrefName, void* aClosure) { // forget all prefs, it's not problem for performance. sInstance->Reset(); DeltaAccumulator::GetInstance()->Reset(); } EventStateManager::WheelPrefs::WheelPrefs() { Reset(); Preferences::RegisterCallback(OnPrefChanged, "mousewheel.", nullptr); Preferences::AddBoolVarCache(&sWheelEventsEnabledOnPlugins, "plugin.mousewheel.enabled", true); } EventStateManager::WheelPrefs::~WheelPrefs() { Preferences::UnregisterCallback(OnPrefChanged, "mousewheel.", nullptr); } void EventStateManager::WheelPrefs::Reset() { memset(mInit, 0, sizeof(mInit)); } EventStateManager::WheelPrefs::Index EventStateManager::WheelPrefs::GetIndexFor(WidgetWheelEvent* aEvent) { if (!aEvent) { return INDEX_DEFAULT; } Modifiers modifiers = (aEvent->mModifiers & (MODIFIER_ALT | MODIFIER_CONTROL | MODIFIER_META | MODIFIER_SHIFT | MODIFIER_OS)); 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; case MODIFIER_OS: return INDEX_OS; 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_OS: aBasePrefName.AppendLiteral("with_win."); break; case INDEX_DEFAULT: default: aBasePrefName.AppendLiteral("default."); break; } } void EventStateManager::WheelPrefs::Init(EventStateManager::WheelPrefs::Index aIndex) { if (mInit[aIndex]) { return; } mInit[aIndex] = true; nsAutoCString basePrefName; GetBasePrefName(aIndex, basePrefName); nsAutoCString prefNameX(basePrefName); prefNameX.AppendLiteral("delta_multiplier_x"); mMultiplierX[aIndex] = static_cast(Preferences::GetInt(prefNameX.get(), 100)) / 100; nsAutoCString prefNameY(basePrefName); prefNameY.AppendLiteral("delta_multiplier_y"); mMultiplierY[aIndex] = static_cast(Preferences::GetInt(prefNameY.get(), 100)) / 100; nsAutoCString prefNameZ(basePrefName); prefNameZ.AppendLiteral("delta_multiplier_z"); mMultiplierZ[aIndex] = static_cast(Preferences::GetInt(prefNameZ.get(), 100)) / 100; nsAutoCString prefNameAction(basePrefName); prefNameAction.AppendLiteral("action"); int32_t action = Preferences::GetInt(prefNameAction.get(), ACTION_SCROLL); if (action < int32_t(ACTION_NONE) || action > int32_t(ACTION_LAST)) { NS_WARNING("Unsupported action pref value, replaced with 'Scroll'."); action = ACTION_SCROLL; } mActions[aIndex] = static_cast(action); // 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. prefNameAction.AppendLiteral(".override_x"); int32_t actionOverrideX = Preferences::GetInt(prefNameAction.get(), -1); if (actionOverrideX < -1 || actionOverrideX > int32_t(ACTION_LAST)) { NS_WARNING("Unsupported action override pref value, didn't override."); actionOverrideX = -1; } mOverriddenActionsX[aIndex] = (actionOverrideX == -1) ? static_cast(action) : static_cast(actionOverrideX); } void EventStateManager::WheelPrefs::ApplyUserPrefsToDelta(WidgetWheelEvent* aEvent) { if (aEvent->mCustomizedByUserPrefs) { return; } Index index = GetIndexFor(aEvent); Init(index); aEvent->mDeltaX *= mMultiplierX[index]; aEvent->mDeltaY *= mMultiplierY[index]; aEvent->mDeltaZ *= mMultiplierZ[index]; // 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(mMultiplierX[index]); aEvent->mLineOrPageDeltaY *= static_cast(mMultiplierY[index]); } else { aEvent->mLineOrPageDeltaX = 0; aEvent->mLineOrPageDeltaY = 0; } aEvent->mCustomizedByUserPrefs = ((mMultiplierX[index] != 1.0) || (mMultiplierY[index] != 1.0) || (mMultiplierZ[index] != 1.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. if (mMultiplierX[index]) { aEvent->mOverflowDeltaX /= mMultiplierX[index]; } if (mMultiplierY[index]) { aEvent->mOverflowDeltaY /= mMultiplierY[index]; } } EventStateManager::WheelPrefs::Action EventStateManager::WheelPrefs::ComputeActionFor(WidgetWheelEvent* aEvent) { Index index = GetIndexFor(aEvent); Init(index); bool deltaXPreferred = (Abs(aEvent->mDeltaX) > Abs(aEvent->mDeltaY) && Abs(aEvent->mDeltaX) > Abs(aEvent->mDeltaZ)); Action* actions = deltaXPreferred ? mOverriddenActionsX : mActions; if (actions[index] == ACTION_NONE || actions[index] == ACTION_SCROLL) { return actions[index]; } // 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); return (actions[INDEX_DEFAULT] == ACTION_SCROLL) ? ACTION_SCROLL : ACTION_NONE; } return actions[index]; } bool EventStateManager::WheelPrefs::NeedToComputeLineOrPageDelta( WidgetWheelEvent* aEvent) { Index index = GetIndexFor(aEvent); Init(index); return (mMultiplierX[index] != 1.0 && mMultiplierX[index] != -1.0) || (mMultiplierY[index] != 1.0 && mMultiplierY[index] != -1.0); } void EventStateManager::WheelPrefs::GetUserPrefsForEvent(WidgetWheelEvent* aEvent, double* aOutMultiplierX, double* aOutMultiplierY) { Index index = GetIndexFor(aEvent); Init(index); *aOutMultiplierX = mMultiplierX[index]; *aOutMultiplierY = mMultiplierY[index]; } // static bool EventStateManager::WheelPrefs::WheelEventsEnabledOnPlugins() { if (!sInstance) { GetInstance(); // initializing sWheelEventsEnabledOnPlugins } return sWheelEventsEnabledOnPlugins; } bool EventStateManager::WheelEventIsScrollAction(WidgetWheelEvent* aEvent) { return aEvent->mMessage == eWheel && WheelPrefs::GetInstance()->ComputeActionFor(aEvent) == WheelPrefs::ACTION_SCROLL; } void EventStateManager::GetUserPrefsForWheelEvent(WidgetWheelEvent* aEvent, double* aOutMultiplierX, double* aOutMultiplierY) { WheelPrefs::GetInstance()->GetUserPrefsForEvent( aEvent, aOutMultiplierX, aOutMultiplierY); } bool EventStateManager::WheelPrefs::IsOverOnePageScrollAllowedX( WidgetWheelEvent* aEvent) { Index index = GetIndexFor(aEvent); Init(index); return Abs(mMultiplierX[index]) >= MIN_MULTIPLIER_VALUE_ALLOWING_OVER_ONE_PAGE_SCROLL; } bool EventStateManager::WheelPrefs::IsOverOnePageScrollAllowedY( WidgetWheelEvent* aEvent) { Index index = GetIndexFor(aEvent); Init(index); return Abs(mMultiplierY[index]) >= MIN_MULTIPLIER_VALUE_ALLOWING_OVER_ONE_PAGE_SCROLL; } /******************************************************************/ /* mozilla::EventStateManager::Prefs */ /******************************************************************/ bool EventStateManager::Prefs::sKeyCausesActivation = true; bool EventStateManager::Prefs::sClickHoldContextMenu = false; int32_t EventStateManager::Prefs::sGenericAccessModifierKey = -1; int32_t EventStateManager::Prefs::sChromeAccessModifierMask = 0; int32_t EventStateManager::Prefs::sContentAccessModifierMask = 0; // static void EventStateManager::Prefs::Init() { DebugOnly rv = Preferences::RegisterCallback(OnChange, "dom.popup_allowed_events"); MOZ_ASSERT(NS_SUCCEEDED(rv), "Failed to observe \"dom.popup_allowed_events\""); static bool sPrefsAlreadyCached = false; if (sPrefsAlreadyCached) { return; } rv = Preferences::AddBoolVarCache(&sKeyCausesActivation, "accessibility.accesskeycausesactivation", sKeyCausesActivation); MOZ_ASSERT(NS_SUCCEEDED(rv), "Failed to observe \"accessibility.accesskeycausesactivation\""); rv = Preferences::AddBoolVarCache(&sClickHoldContextMenu, "ui.click_hold_context_menus", sClickHoldContextMenu); MOZ_ASSERT(NS_SUCCEEDED(rv), "Failed to observe \"ui.click_hold_context_menus\""); rv = Preferences::AddIntVarCache(&sGenericAccessModifierKey, "ui.key.generalAccessKey", sGenericAccessModifierKey); MOZ_ASSERT(NS_SUCCEEDED(rv), "Failed to observe \"ui.key.generalAccessKey\""); rv = Preferences::AddIntVarCache(&sChromeAccessModifierMask, "ui.key.chromeAccess", sChromeAccessModifierMask); MOZ_ASSERT(NS_SUCCEEDED(rv), "Failed to observe \"ui.key.chromeAccess\""); rv = Preferences::AddIntVarCache(&sContentAccessModifierMask, "ui.key.contentAccess", sContentAccessModifierMask); MOZ_ASSERT(NS_SUCCEEDED(rv), "Failed to observe \"ui.key.contentAccess\""); sPrefsAlreadyCached = true; } // static void EventStateManager::Prefs::OnChange(const char* aPrefName, void*) { nsDependentCString prefName(aPrefName); if (prefName.EqualsLiteral("dom.popup_allowed_events")) { Event::PopupAllowedEventsChanged(); } } // static void EventStateManager::Prefs::Shutdown() { Preferences::UnregisterCallback(OnChange, "dom.popup_allowed_events"); } // static int32_t EventStateManager::Prefs::ChromeAccessModifierMask() { return GetAccessModifierMask(nsIDocShellTreeItem::typeChrome); } // static int32_t EventStateManager::Prefs::ContentAccessModifierMask() { return GetAccessModifierMask(nsIDocShellTreeItem::typeContent); } // static int32_t EventStateManager::Prefs::GetAccessModifierMask(int32_t aItemType) { switch (sGenericAccessModifierKey) { case -1: break; // use the individual prefs case nsIDOMKeyEvent::DOM_VK_SHIFT: return NS_MODIFIER_SHIFT; case nsIDOMKeyEvent::DOM_VK_CONTROL: return NS_MODIFIER_CONTROL; case nsIDOMKeyEvent::DOM_VK_ALT: return NS_MODIFIER_ALT; case nsIDOMKeyEvent::DOM_VK_META: return NS_MODIFIER_META; case nsIDOMKeyEvent::DOM_VK_WIN: return NS_MODIFIER_OS; default: return 0; } switch (aItemType) { case nsIDocShellTreeItem::typeChrome: return sChromeAccessModifierMask; case nsIDocShellTreeItem::typeContent: return sContentAccessModifierMask; default: return 0; } } /******************************************************************/ /* mozilla::AutoHandlingUserInputStatePusher */ /******************************************************************/ AutoHandlingUserInputStatePusher::AutoHandlingUserInputStatePusher( bool aIsHandlingUserInput, WidgetEvent* aEvent, nsIDocument* aDocument) : mIsHandlingUserInput(aIsHandlingUserInput), mIsMouseDown(aEvent && aEvent->mMessage == eMouseDown), mResetFMMouseButtonHandlingState(false) { if (!aIsHandlingUserInput) { return; } EventStateManager::StartHandlingUserInput(); if (mIsMouseDown) { nsIPresShell::SetCapturingContent(nullptr, 0); nsIPresShell::AllowMouseCapture(true); } if (!aDocument || !aEvent || !aEvent->IsTrusted()) { return; } mResetFMMouseButtonHandlingState = (aEvent->mMessage == eMouseDown || aEvent->mMessage == eMouseUp); if (mResetFMMouseButtonHandlingState) { nsFocusManager* fm = nsFocusManager::GetFocusManager(); NS_ENSURE_TRUE_VOID(fm); // If it's in modal state, mouse button event handling may be nested. // E.g., a modal dialog is opened at mousedown or mouseup event handler // and the dialog is clicked. Therefore, we should store current // mouse button event handling document if nsFocusManager already has it. mMouseButtonEventHandlingDocument = fm->SetMouseButtonHandlingDocument(aDocument); } } AutoHandlingUserInputStatePusher::~AutoHandlingUserInputStatePusher() { if (!mIsHandlingUserInput) { return; } EventStateManager::StopHandlingUserInput(); if (mIsMouseDown) { nsIPresShell::AllowMouseCapture(false); } if (mResetFMMouseButtonHandlingState) { nsFocusManager* fm = nsFocusManager::GetFocusManager(); NS_ENSURE_TRUE_VOID(fm); nsCOMPtr handlingDocument = fm->SetMouseButtonHandlingDocument(mMouseButtonEventHandlingDocument); } } } // namespace mozilla