. // We have to use |aEvent->target| to not make sure we do not check an // anonymous node of the targeted element. suppressBlur = (ui->mUserFocus == NS_STYLE_USER_FOCUS_IGNORE); if (!suppressBlur) { nsCOMPtr element = do_QueryInterface(aEvent->target); suppressBlur = element && element->State().HasState(NS_EVENT_STATE_DISABLED); } if (!suppressBlur) { nsCOMPtr xulControl = do_QueryInterface(aEvent->target); if (xulControl) { bool disabled; xulControl->GetDisabled(&disabled); suppressBlur = disabled; } } } 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->GetCurrentDoc(); 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 == NS_STYLE_DISPLAY_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 hald visible nsCOMPtr newFocusElement = do_QueryInterface(newFocus); fm->SetFocus(newFocusElement, nsIFocusManager::FLAG_BYMOUSE | nsIFocusManager::FLAG_NOSCROLL); } 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->IsXUL()) #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 currentWindow; fm->GetFocusedWindow(getter_AddRefs(currentWindow)); if (currentWindow && mDocument->GetWindow() && currentWindow != mDocument->GetWindow() && !nsContentUtils::IsChromeDoc(mDocument)) { nsCOMPtr currentTop; nsCOMPtr newTop; currentWindow->GetTop(getter_AddRefs(currentTop)); mDocument->GetWindow()->GetTop(getter_AddRefs(newTop)); nsCOMPtr win = do_QueryInterface(currentWindow); nsCOMPtr currentDoc = win->GetExtantDoc(); if (nsContentUtils::IsChromeDoc(currentDoc) || (currentTop && newTop && currentTop != newTop)) { fm->SetFocusedWindow(mDocument->GetWindow()); } } } } SetActiveManager(this, activeContent); } break; case NS_MOUSE_BUTTON_UP: { ClearGlobalActiveContent(this); if (IsMouseEventReal(aEvent)) { 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(presContext, aEvent->AsMouseEvent(), aStatus); } nsIPresShell *shell = presContext->GetPresShell(); if (shell) { nsRefPtr frameSelection = shell->FrameSelection(); frameSelection->SetMouseDownState(false); } } break; case NS_WHEEL_STOP: { MOZ_ASSERT(aEvent->mFlags.mIsTrusted); nsScrollbarsForWheel::MayInactivate(); } break; case NS_WHEEL_WHEEL: case NS_WHEEL_START: { MOZ_ASSERT(aEvent->mFlags.mIsTrusted); if (*aStatus == nsEventStatus_eConsumeNoDefault) { nsScrollbarsForWheel::Inactivate(); break; } WidgetWheelEvent* wheelEvent = static_cast(aEvent); switch (WheelPrefs::GetInstance()->ComputeActionFor(wheelEvent)) { case WheelPrefs::ACTION_SCROLL: { // For scrolling of default action, we should honor the mouse wheel // transaction. nsScrollbarsForWheel::PrepareToScrollText(this, aTargetFrame, wheelEvent); if (aEvent->message != NS_WHEEL_WHEEL || (!wheelEvent->deltaX && !wheelEvent->deltaY)) { break; } nsIScrollableFrame* scrollTarget = ComputeScrollTarget(aTargetFrame, wheelEvent, COMPUTE_DEFAULT_ACTION_TARGET); nsScrollbarsForWheel::SetActiveScrollTarget(scrollTarget); nsIFrame* rootScrollFrame = !aTargetFrame ? nullptr : aTargetFrame->PresContext()->PresShell()->GetRootScrollFrame(); nsIScrollableFrame* rootScrollableFrame = nullptr; if (rootScrollFrame) { rootScrollableFrame = do_QueryFrame(rootScrollFrame); } if (!scrollTarget || scrollTarget == rootScrollableFrame) { wheelEvent->mViewPortIsOverscrolled = true; } wheelEvent->overflowDeltaX = wheelEvent->deltaX; wheelEvent->overflowDeltaY = wheelEvent->deltaY; WheelPrefs::GetInstance()-> CancelApplyingUserPrefsFromOverflowDelta(wheelEvent); if (scrollTarget) { DoScrollText(scrollTarget, wheelEvent); } else { nsMouseWheelTransaction::EndTransaction(); nsScrollbarsForWheel::Inactivate(); } break; } case WheelPrefs::ACTION_HISTORY: { // If this event doesn't cause NS_MOUSE_SCROLL 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 NS_MOUSE_SCROLL event or the direction // is oblique, don't perform zoom in/out. int32_t intDelta = wheelEvent->GetPreferredIntDelta(); if (!intDelta) { break; } DoScrollZoom(aTargetFrame, intDelta); break; } case WheelPrefs::ACTION_NONE: default: // If we don't handle the wheel event, all of the delta values must // be overflown delta values. wheelEvent->overflowDeltaX = wheelEvent->deltaX; wheelEvent->overflowDeltaY = wheelEvent->deltaY; WheelPrefs::GetInstance()-> CancelApplyingUserPrefsFromOverflowDelta(wheelEvent); break; } *aStatus = nsEventStatus_eConsumeNoDefault; } break; case NS_GESTURENOTIFY_EVENT_START: { if (nsEventStatus_eConsumeNoDefault != *aStatus) { DecideGestureEvent(aEvent->AsGestureNotifyEvent(), mCurrentTarget); } } break; case NS_DRAGDROP_ENTER: case NS_DRAGDROP_OVER: { NS_ASSERTION(aEvent->eventStructType == NS_DRAG_EVENT, "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; if (nsEventStatus_eConsumeNoDefault == *aStatus) { // if the event has a dataTransfer set, use it. if (dragEvent->dataTransfer) { // get the dataTransfer and the dropEffect that was set on it dataTransfer = do_QueryInterface(dragEvent->dataTransfer); dataTransfer->GetDropEffectInt(&dropEffect); } else { // if dragEvent->dataTransfer 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 nsDOMDragEvent::GetDataTransfer), // so set it from the drag action. We'll still want to filter it // based on the effectAllowed below. dataTransfer = initialDataTransfer; uint32_t action; 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. uint32_t action = nsIDragService::DRAGDROP_ACTION_NONE; 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->message == NS_DRAGDROP_OVER && !isChromeDoc) { // Someone has called preventDefault(), check whether is was content. dragSession->SetOnlyChromeDrop( !aEvent->mFlags.mDefaultPreventedByContent); } } else if (aEvent->message == NS_DRAGDROP_OVER && !isChromeDoc) { // No one called preventDefault(), so handle drop only in chrome. dragSession->SetOnlyChromeDrop(true); } // now set the drop effect in the initial dataTransfer. This ensures // that we can get the desired drop effect in the drop event. if (initialDataTransfer) initialDataTransfer->SetDropEffectInt(dropEffect); } break; case NS_DRAGDROP_DROP: { // now fire the dragdrop event, for compatibility with XUL if (mCurrentTarget && nsEventStatus_eConsumeNoDefault != *aStatus) { nsCOMPtr targetContent; mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(targetContent)); nsCOMPtr widget = mCurrentTarget->GetNearestWidget(); WidgetDragEvent event(aEvent->mFlags.mIsTrusted, NS_DRAGDROP_DRAGDROP, widget); WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent(); event.refPoint = mouseEvent->refPoint; if (mouseEvent->widget) { event.refPoint += LayoutDeviceIntPoint::FromUntyped(mouseEvent->widget->WidgetToScreenOffset()); } event.refPoint -= LayoutDeviceIntPoint::FromUntyped(widget->WidgetToScreenOffset()); event.modifiers = mouseEvent->modifiers; event.buttons = mouseEvent->buttons; event.inputSource = mouseEvent->inputSource; nsEventStatus status = nsEventStatus_eIgnore; nsCOMPtr presShell = mPresContext->GetPresShell(); if (presShell) { presShell->HandleEventWithTarget(&event, mCurrentTarget, targetContent, &status); } } sLastDragOverFrame = nullptr; ClearGlobalActiveContent(this); break; } case NS_DRAGDROP_EXIT: // make sure to fire the enter and exit_synth events after the // NS_DRAGDROP_EXIT event, otherwise we'll clean up too early GenerateDragDropEnterExit(presContext, aEvent->AsDragEvent()); break; case NS_KEY_UP: break; case NS_KEY_PRESS: if (nsEventStatus_eConsumeNoDefault != *aStatus) { WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent(); //This is to prevent keyboard scrolling while alt modifier in use. if (!keyEvent->IsAlt()) { switch(keyEvent->keyCode) { case NS_VK_TAB: case NS_VK_F6: // 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 (dispatchedToContentProcess) break; EnsureDocument(mPresContext); nsIFocusManager* fm = nsFocusManager::GetFocusManager(); if (fm && mDocument) { // Shift focus forward or back depending on shift key bool isDocMove = keyEvent->IsControl() || keyEvent->keyCode == NS_VK_F6; uint32_t dir = keyEvent->IsShift() ? (isDocMove ? static_cast(nsIFocusManager::MOVEFOCUS_BACKWARDDOC) : static_cast(nsIFocusManager::MOVEFOCUS_BACKWARD)) : (isDocMove ? static_cast(nsIFocusManager::MOVEFOCUS_FORWARDDOC) : static_cast(nsIFocusManager::MOVEFOCUS_FORWARD)); nsCOMPtr result; fm->MoveFocus(mDocument->GetWindow(), nullptr, dir, nsIFocusManager::FLAG_BYKEY, getter_AddRefs(result)); } *aStatus = nsEventStatus_eConsumeNoDefault; break; } } } break; case NS_MOUSE_ENTER: if (mCurrentTarget) { nsCOMPtr targetContent; mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(targetContent)); SetContentState(targetContent, NS_EVENT_STATE_HOVER); } break; #ifdef XP_MACOSX case NS_MOUSE_ACTIVATE: if (mCurrentTarget) { nsCOMPtr targetContent; mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(targetContent)); if (!NodeAllowsClickThrough(targetContent)) { *aStatus = nsEventStatus_eConsumeNoDefault; } } break; #endif } //Reset target frame to null to avoid mistargeting after reentrant event mCurrentTarget = nullptr; mCurrentTargetContent = nullptr; return ret; } bool nsEventStateManager::RemoteQueryContentEvent(WidgetEvent* aEvent) { WidgetQueryContentEvent* queryEvent = aEvent->AsQueryContentEvent(); if (!IsTargetCrossProcess(queryEvent)) { return false; } // Will not be handled locally, remote the event GetCrossProcessTarget()->HandleQueryContentEvent(*queryEvent); return true; } TabParent* nsEventStateManager::GetCrossProcessTarget() { return TabParent::GetIMETabParent(); } bool nsEventStateManager::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 TabParent::GetIMETabParent() != nullptr; } void nsEventStateManager::NotifyDestroyPresContext(nsPresContext* aPresContext) { nsIMEStateManager::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); } } void nsEventStateManager::SetPresContext(nsPresContext* aPresContext) { mPresContext = aPresContext; } void nsEventStateManager::ClearFrameRefs(nsIFrame* aFrame) { if (aFrame && aFrame == mCurrentTarget) { mCurrentTargetContent = aFrame->GetContent(); } } void nsEventStateManager::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); if (NS_FAILED(aTargetFrame->GetCursor(pt, framecursor))) return; // don't update the cursor if we failed to get it from the frame see bug 118877 cursor = framecursor.mCursor; container = framecursor.mContainer; haveHotspot = framecursor.mHaveHotspot; hotspotX = framecursor.mHotspotX; hotspotY = framecursor.mHotspotY; } if (Preferences::GetBool("ui.use_activity_cursor", false)) { // Check whether or not to show the busy cursor nsCOMPtr pcContainer = aPresContext->GetContainer(); nsCOMPtr docShell(do_QueryInterface(pcContainer)); 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); } if (mLockCursor || NS_STYLE_CURSOR_AUTO != cursor) { *aStatus = nsEventStatus_eConsumeDoDefault; } } nsresult nsEventStateManager::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 nsESMEventCB : public nsDispatchingCallback { public: nsESMEventCB(nsIContent* aTarget) : mTarget(aTarget) {} virtual void HandleEvent(nsEventChainPostVisitor& 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 nsEventStateManager::IsHandlingUserInput() { if (sUserInputEventDepth <= 0) { return false; } TimeDuration timeout = nsContentUtils::HandlingUserInputTimeout(); return timeout <= TimeDuration(0) || (TimeStamp::Now() - sHandlingInputStart) <= timeout; } nsIFrame* nsEventStateManager::DispatchMouseEvent(WidgetMouseEvent* aMouseEvent, uint32_t 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 == NS_MOUSELEAVE || aMessage == NS_MOUSEENTER || aMessage == NS_MOUSE_ENTER_SYNTH || aMessage == NS_MOUSE_EXIT_SYNTH)) { mCurrentTargetContent = nullptr; nsCOMPtr pointerLockedElement = do_QueryReferent(nsEventStateManager::sPointerLockedElement); if (!pointerLockedElement) { NS_WARNING("Should have pointer locked element, but didn't."); return nullptr; } nsCOMPtr content = do_QueryInterface(pointerLockedElement); return mPresContext->GetPrimaryFrameFor(content); } PROFILER_LABEL("Input", "DispatchMouseEvent"); nsEventStatus status = nsEventStatus_eIgnore; WidgetMouseEvent event(aMouseEvent->mFlags.mIsTrusted, aMessage, aMouseEvent->widget, WidgetMouseEvent::eReal); event.refPoint = aMouseEvent->refPoint; event.modifiers = aMouseEvent->modifiers; event.buttons = aMouseEvent->buttons; event.pluginEvent = aMouseEvent->pluginEvent; event.relatedTarget = aRelatedContent; event.inputSource = aMouseEvent->inputSource; nsWeakFrame previousTarget = mCurrentTarget; mCurrentTargetContent = aTargetContent; nsIFrame* targetFrame = nullptr; if (aTargetContent) { nsESMEventCB callback(aTargetContent); nsEventDispatcher::Dispatch(aTargetContent, mPresContext, &event, nullptr, &status, &callback); // Although the primary frame was checked in event callback, // it may not be the same object after event dispatching and handling. // So we need to refetch it. if (mPresContext) { targetFrame = mPresContext->GetPrimaryFrameFor(aTargetContent); } } mCurrentTargetContent = nullptr; mCurrentTarget = previousTarget; return targetFrame; } class MouseEnterLeaveDispatcher { public: MouseEnterLeaveDispatcher(nsEventStateManager* aESM, nsIContent* aTarget, nsIContent* aRelatedTarget, WidgetMouseEvent* aMouseEvent, uint32_t aType) : mESM(aESM), mMouseEvent(aMouseEvent), mType(aType) { nsPIDOMWindow* win = aTarget ? aTarget->OwnerDoc()->GetInnerWindow() : nullptr; if (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(); } } } ~MouseEnterLeaveDispatcher() { if (mType == NS_MOUSEENTER) { for (int32_t i = mTargets.Count() - 1; i >= 0; --i) { mESM->DispatchMouseEvent(mMouseEvent, mType, mTargets[i], mRelatedTarget); } } else { for (int32_t i = 0; i < mTargets.Count(); ++i) { mESM->DispatchMouseEvent(mMouseEvent, mType, mTargets[i], mRelatedTarget); } } } nsEventStateManager* mESM; nsCOMArray mTargets; nsCOMPtr mRelatedTarget; WidgetMouseEvent* mMouseEvent; uint32_t mType; }; void nsEventStateManager::NotifyMouseOut(WidgetMouseEvent* aMouseEvent, nsIContent* aMovingInto) { if (!mLastMouseOverElement) return; // Before firing mouseout, check for recursion if (mLastMouseOverElement == mFirstMouseOutEventElement) return; if (mLastMouseOverFrame) { // if the frame is associated with a subdocument, // tell the subdocument that we're moving out of it nsSubDocumentFrame* subdocFrame = do_QueryFrame(mLastMouseOverFrame.GetFrame()); if (subdocFrame) { nsCOMPtr docshell; subdocFrame->GetDocShell(getter_AddRefs(docshell)); if (docshell) { nsRefPtr presContext; docshell->GetPresContext(getter_AddRefs(presContext)); if (presContext) { nsEventStateManager* 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 (!mLastMouseOverElement) return; // Store the first mouseOut event we fire and don't refire mouseOut // to that element while the first mouseOut is still ongoing. mFirstMouseOutEventElement = mLastMouseOverElement; // 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) { // Unset :hover SetContentState(nullptr, NS_EVENT_STATE_HOVER); } MouseEnterLeaveDispatcher leaveDispatcher(this, mLastMouseOverElement, aMovingInto, aMouseEvent, NS_MOUSELEAVE); // Fire mouseout DispatchMouseEvent(aMouseEvent, NS_MOUSE_EXIT_SYNTH, mLastMouseOverElement, aMovingInto); mLastMouseOverFrame = nullptr; mLastMouseOverElement = nullptr; // Turn recursion protection back off mFirstMouseOutEventElement = nullptr; } void nsEventStateManager::NotifyMouseOver(WidgetMouseEvent* aMouseEvent, nsIContent* aContent) { NS_ASSERTION(aContent, "Mouse must be over something"); if (mLastMouseOverElement == aContent) return; // Before firing mouseover, check for recursion if (aContent == mFirstMouseOverEventElement) 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); nsIDocument *parentDoc = mDocument->GetParentDocument(); if (parentDoc) { nsIContent *docContent = parentDoc->FindContentForSubDocument(mDocument); if (docContent) { nsIPresShell *parentShell = parentDoc->GetShell(); if (parentShell) { nsEventStateManager* 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 (mLastMouseOverElement == aContent) return; // Remember mLastMouseOverElement as the related content for the // DispatchMouseEvent() call below, since NotifyMouseOut() resets it, bug 298477. nsCOMPtr lastMouseOverElement = mLastMouseOverElement; MouseEnterLeaveDispatcher enterDispatcher(this, aContent, lastMouseOverElement, aMouseEvent, NS_MOUSEENTER); 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. mFirstMouseOverEventElement = aContent; SetContentState(aContent, NS_EVENT_STATE_HOVER); // Fire mouseover mLastMouseOverFrame = DispatchMouseEvent(aMouseEvent, NS_MOUSE_ENTER_SYNTH, aContent, lastMouseOverElement); mLastMouseOverElement = aContent; // Turn recursion protection back off mFirstMouseOverEventElement = nullptr; } // Returns the center point of the window's inner content area. // This is in widget coordinates, i.e. relative to the widget's top // left corner, not in screen coordinates, the same units that // nsDOMUIEvent::refPoint is in. // // XXX Hack alert: XXX // However, we do the computation in integer CSS pixels, NOT device pix, // in order to fudge around the one-pixel error in innerHeight in fullscreen // mode (see bug 799523 comment 35, and bug 729011). Using integer CSS pix // makes us throw away the fractional error that results, rather than having // it manifest as a potential one-device-pix discrepancy. static LayoutDeviceIntPoint GetWindowInnerRectCenter(nsPIDOMWindow* aWindow, nsIWidget* aWidget, nsPresContext* aContext) { NS_ENSURE_TRUE(aWindow && aWidget && aContext, LayoutDeviceIntPoint(0, 0)); float cssInnerX = 0.0; aWindow->GetMozInnerScreenX(&cssInnerX); int32_t innerX = int32_t(NS_round(cssInnerX)); float cssInnerY = 0.0; aWindow->GetMozInnerScreenY(&cssInnerY); int32_t innerY = int32_t(NS_round(cssInnerY)); int32_t innerWidth = 0; aWindow->GetInnerWidth(&innerWidth); int32_t innerHeight = 0; aWindow->GetInnerHeight(&innerHeight); nsIntRect screen; aWidget->GetScreenBounds(screen); int32_t cssScreenX = aContext->DevPixelsToIntCSSPixels(screen.x); int32_t cssScreenY = aContext->DevPixelsToIntCSSPixels(screen.y); return LayoutDeviceIntPoint( aContext->CSSPixelsToDevPixels(innerX - cssScreenX + innerWidth / 2), aContext->CSSPixelsToDevPixels(innerY - cssScreenY + innerHeight / 2)); } void nsEventStateManager::GenerateMouseEnterExit(WidgetMouseEvent* aMouseEvent) { EnsureDocument(mPresContext); if (!mDocument) return; // Hold onto old target content through the event and reset after. nsCOMPtr targetBeforeEvent = mCurrentTargetContent; switch(aMouseEvent->message) { case NS_MOUSE_MOVE: { // Mouse movement is reported on the MouseEvent.movement{X,Y} fields. // Movement is calculated in nsDOMUIEvent::GetMovementPoint() as: // previous_mousemove_refPoint - current_mousemove_refPoint. if (sIsPointerLocked && aMouseEvent->widget) { // 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 = GetWindowInnerRectCenter(mDocument->GetWindow(), aMouseEvent->widget, mPresContext); aMouseEvent->lastRefPoint = center; if (aMouseEvent->refPoint != 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->widget->SynthesizeNativeMouseMove( LayoutDeviceIntPoint::ToUntyped(center) + aMouseEvent->widget->WidgetToScreenOffset()); } else if (aMouseEvent->refPoint == 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->mFlags.mPropagationStopped = true; // 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 refPoint. 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 refPoints the same. aMouseEvent->lastRefPoint = aMouseEvent->refPoint; } else { aMouseEvent->lastRefPoint = sLastRefPoint; } // Update the last known refPoint with the current refPoint. sLastRefPoint = aMouseEvent->refPoint; // 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 NS_MOUSE_EXIT: { // This is actually the window mouse exit event. We're not moving // into any new element. if (mLastMouseOverFrame && nsContentUtils::GetTopLevelWidget(aMouseEvent->widget) != nsContentUtils::GetTopLevelWidget(mLastMouseOverFrame->GetNearestWidget())) { // the MouseOut event widget doesn't have same top widget with // mLastMouseOverFrame, it's a spurious event for mLastMouseOverFrame 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; } // reset mCurretTargetContent to what it was mCurrentTargetContent = targetBeforeEvent; } void nsEventStateManager::SetPointerLock(nsIWidget* aWidget, nsIContent* aElement) { // NOTE: aElement will be nullptr when unlocking. sIsPointerLocked = !!aElement; if (!aWidget) { return; } // Reset mouse wheel transaction nsMouseWheelTransaction::EndTransaction(); // Deal with DnD events nsCOMPtr dragService = do_GetService("@mozilla.org/widget/dragservice;1"); if (sIsPointerLocked) { // Store the last known ref point so we can reposition the pointer after unlock. mPreLockPoint = 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 = GetWindowInnerRectCenter(aElement->OwnerDoc()->GetWindow(), aWidget, mPresContext); aWidget->SynthesizeNativeMouseMove( LayoutDeviceIntPoint::ToUntyped(sLastRefPoint) + aWidget->WidgetToScreenOffset()); // Retarget all events to this element via capture. nsIPresShell::SetCapturingContent(aElement, CAPTURE_POINTERLOCK); // 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 = mPreLockPoint; aWidget->SynthesizeNativeMouseMove( LayoutDeviceIntPoint::ToUntyped(mPreLockPoint) + aWidget->WidgetToScreenOffset()); // Don't retarget events to this element any more. nsIPresShell::SetCapturingContent(nullptr, CAPTURE_POINTERLOCK); // Unsuppress DnD if (dragService) { dragService->Unsuppress(); } } } void nsEventStateManager::GenerateDragDropEnterExit(nsPresContext* aPresContext, WidgetDragEvent* aDragEvent) { //Hold onto old target content through the event and reset after. nsCOMPtr targetBeforeEvent = mCurrentTargetContent; switch(aDragEvent->message) { case NS_DRAGDROP_OVER: { // 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, NS_DRAGDROP_EXIT_SYNTH, targetContent, lastContent, sLastDragOverFrame); } FireDragEnterOrExit(aPresContext, aDragEvent, NS_DRAGDROP_ENTER, lastContent, targetContent, mCurrentTarget); if (sLastDragOverFrame) { FireDragEnterOrExit(sLastDragOverFrame->PresContext(), aDragEvent, NS_DRAGDROP_LEAVE_SYNTH, targetContent, lastContent, sLastDragOverFrame); } sLastDragOverFrame = mCurrentTarget; } } break; case NS_DRAGDROP_EXIT: { //This is actually the window mouse exit event. if (sLastDragOverFrame) { nsCOMPtr lastContent; sLastDragOverFrame->GetContentForEvent(aDragEvent, getter_AddRefs(lastContent)); nsRefPtr lastDragOverFramePresContext = sLastDragOverFrame->PresContext(); FireDragEnterOrExit(lastDragOverFramePresContext, aDragEvent, NS_DRAGDROP_EXIT_SYNTH, nullptr, lastContent, sLastDragOverFrame); FireDragEnterOrExit(lastDragOverFramePresContext, aDragEvent, NS_DRAGDROP_LEAVE_SYNTH, nullptr, lastContent, sLastDragOverFrame); sLastDragOverFrame = nullptr; } } break; } //reset mCurretTargetContent to what it was mCurrentTargetContent = targetBeforeEvent; // Now flush all pending notifications, for better responsiveness. FlushPendingEvents(aPresContext); } void nsEventStateManager::FireDragEnterOrExit(nsPresContext* aPresContext, WidgetDragEvent* aDragEvent, uint32_t aMsg, nsIContent* aRelatedTarget, nsIContent* aTargetContent, nsWeakFrame& aTargetFrame) { nsEventStatus status = nsEventStatus_eIgnore; WidgetDragEvent event(aDragEvent->mFlags.mIsTrusted, aMsg, aDragEvent->widget); event.refPoint = aDragEvent->refPoint; event.modifiers = aDragEvent->modifiers; event.buttons = aDragEvent->buttons; event.relatedTarget = aRelatedTarget; event.inputSource = aDragEvent->inputSource; mCurrentTargetContent = aTargetContent; if (aTargetContent != aRelatedTarget) { //XXX This event should still go somewhere!! if (aTargetContent) nsEventDispatcher::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 || aMsg == NS_DRAGDROP_EXIT) SetContentState((aMsg == NS_DRAGDROP_ENTER) ? aTargetContent : nullptr, NS_EVENT_STATE_DRAGOVER); // collect any changes to moz cursor settings stored in the event's // data transfer. if (aMsg == NS_DRAGDROP_LEAVE_SYNTH || aMsg == NS_DRAGDROP_EXIT_SYNTH || aMsg == NS_DRAGDROP_ENTER) UpdateDragDataTransfer(&event); } // Finally dispatch the event to the frame if (aTargetFrame) aTargetFrame->HandleEvent(aPresContext, &event, &status); } void nsEventStateManager::UpdateDragDataTransfer(WidgetDragEvent* dragEvent) { NS_ASSERTION(dragEvent, "drag event is null in UpdateDragDataTransfer!"); if (!dragEvent->dataTransfer) 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->dataTransfer->GetMozCursor(mozCursor); initialDataTransfer->SetMozCursor(mozCursor); } } } nsresult nsEventStateManager::SetClickCount(nsPresContext* aPresContext, WidgetMouseEvent* aEvent, nsEventStatus* aStatus) { nsCOMPtr mouseContent; nsIContent* mouseContentParent = nullptr; 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->message == NS_MOUSE_BUTTON_DOWN) { mLastLeftMouseDownContent = mouseContent; mLastLeftMouseDownContentParent = mouseContentParent; } else if (aEvent->message == NS_MOUSE_BUTTON_UP) { if (mLastLeftMouseDownContent == mouseContent || mLastLeftMouseDownContentParent == mouseContent || mLastLeftMouseDownContent == mouseContentParent) { aEvent->clickCount = mLClickCount; mLClickCount = 0; } else { aEvent->clickCount = 0; } mLastLeftMouseDownContent = nullptr; mLastLeftMouseDownContentParent = nullptr; } break; case WidgetMouseEvent::eMiddleButton: if (aEvent->message == NS_MOUSE_BUTTON_DOWN) { mLastMiddleMouseDownContent = mouseContent; mLastMiddleMouseDownContentParent = mouseContentParent; } else if (aEvent->message == NS_MOUSE_BUTTON_UP) { if (mLastMiddleMouseDownContent == mouseContent || mLastMiddleMouseDownContentParent == mouseContent || mLastMiddleMouseDownContent == mouseContentParent) { aEvent->clickCount = mMClickCount; mMClickCount = 0; } else { aEvent->clickCount = 0; } mLastMiddleMouseDownContent = nullptr; mLastMiddleMouseDownContentParent = nullptr; } break; case WidgetMouseEvent::eRightButton: if (aEvent->message == NS_MOUSE_BUTTON_DOWN) { mLastRightMouseDownContent = mouseContent; mLastRightMouseDownContentParent = mouseContentParent; } else if (aEvent->message == NS_MOUSE_BUTTON_UP) { if (mLastRightMouseDownContent == mouseContent || mLastRightMouseDownContentParent == mouseContent || mLastRightMouseDownContent == mouseContentParent) { aEvent->clickCount = mRClickCount; mRClickCount = 0; } else { aEvent->clickCount = 0; } mLastRightMouseDownContent = nullptr; mLastRightMouseDownContentParent = nullptr; } break; } return NS_OK; } nsresult nsEventStateManager::CheckForAndDispatchClick(nsPresContext* aPresContext, 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 (0 != aEvent->clickCount) { //Check that the window isn't disabled before firing a click //(see bug 366544). if (aEvent->widget && !aEvent->widget->IsEnabled()) { return ret; } //fire click bool notDispatchToContents = (aEvent->button == WidgetMouseEvent::eMiddleButton || aEvent->button == WidgetMouseEvent::eRightButton); WidgetMouseEvent event(aEvent->mFlags.mIsTrusted, NS_MOUSE_CLICK, aEvent->widget, WidgetMouseEvent::eReal); event.refPoint = aEvent->refPoint; event.clickCount = aEvent->clickCount; event.modifiers = aEvent->modifiers; event.buttons = aEvent->buttons; event.time = aEvent->time; event.mFlags.mNoContentDispatch = notDispatchToContents; event.button = aEvent->button; event.inputSource = aEvent->inputSource; nsCOMPtr presShell = mPresContext->GetPresShell(); if (presShell) { nsCOMPtr mouseContent = GetEventTargetContent(aEvent); if (!mouseContent && !mCurrentTarget) { return NS_OK; } // HandleEvent clears out mCurrentTarget which we might need again nsWeakFrame currentTarget = mCurrentTarget; ret = presShell->HandleEventWithTarget(&event, currentTarget, mouseContent, aStatus); if (NS_SUCCEEDED(ret) && aEvent->clickCount == 2) { //fire double click WidgetMouseEvent event2(aEvent->mFlags.mIsTrusted, NS_MOUSE_DOUBLECLICK, aEvent->widget, WidgetMouseEvent::eReal); event2.refPoint = aEvent->refPoint; event2.clickCount = aEvent->clickCount; event2.modifiers = aEvent->modifiers; event2.buttons = aEvent->buttons; event2.mFlags.mNoContentDispatch = notDispatchToContents; event2.button = aEvent->button; event2.inputSource = aEvent->inputSource; ret = presShell->HandleEventWithTarget(&event2, currentTarget, mouseContent, aStatus); } } } return ret; } nsIFrame* nsEventStateManager::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 nsEventStateManager::GetEventTargetContent(WidgetEvent* aEvent) { if (aEvent && (aEvent->message == NS_FOCUS_CONTENT || aEvent->message == NS_BLUR_CONTENT)) { 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->GetParent(); if (!parent) break; anc1 = parent; } nsIContent *anc2 = aNode2; for (;;) { --offset; nsIContent* parent = anc2->GetParent(); if (!parent) break; anc2 = parent; } if (anc1 == anc2) { anc1 = aNode1; anc2 = aNode2; while (offset > 0) { anc1 = anc1->GetParent(); --offset; } while (offset < 0) { anc2 = anc2->GetParent(); ++offset; } while (anc1 != anc2) { anc1 = anc1->GetParent(); anc2 = anc2->GetParent(); } return anc1; } } return nullptr; } static Element* GetParentElement(Element* aElement) { nsIContent* p = aElement->GetParent(); return (p && p->IsElement()) ? p->AsElement() : nullptr; } /* static */ void nsEventStateManager::SetFullScreenState(Element* aElement, bool aIsFullScreen) { DoStateChange(aElement, NS_EVENT_STATE_FULL_SCREEN, aIsFullScreen); Element* ancestor = aElement; while ((ancestor = GetParentElement(ancestor))) { DoStateChange(ancestor, NS_EVENT_STATE_FULL_SCREEN_ANCESTOR, aIsFullScreen); } } /* static */ inline void nsEventStateManager::DoStateChange(Element* aElement, nsEventStates aState, bool aAddState) { if (aAddState) { aElement->AddStates(aState); } else { aElement->RemoveStates(aState); } } /* static */ inline void nsEventStateManager::DoStateChange(nsIContent* aContent, nsEventStates aState, bool aStateAdded) { if (aContent->IsElement()) { DoStateChange(aContent->AsElement(), aState, aStateAdded); } } /* static */ void nsEventStateManager::UpdateAncestorState(nsIContent* aStartNode, nsIContent* aStopBefore, nsEventStates aState, bool aAddState) { for (; aStartNode && aStartNode != aStopBefore; aStartNode = aStartNode->GetParent()) { // 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->GetParent()) { if (!aStartNode->IsElement()) { continue; } Element* labelTarget = GetLabelTarget(aStartNode->AsElement()); if (labelTarget && !labelTarget->State().HasState(aState)) { DoStateChange(labelTarget, aState, true); } } } } bool nsEventStateManager::SetContentState(nsIContent *aContent, nsEventStates 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 == NS_STYLE_USER_INPUT_NONE) return false; } if (aState == NS_EVENT_STATE_ACTIVE) { 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->GetCurrentDoc() == 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 nsEventStateManager::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->IsHTML() && (aContent->Tag() == nsGkAtoms::a || aContent->Tag() == nsGkAtoms::area) && (aContent->AsElement()->State().HasAtLeastOneOfStates(NS_EVENT_STATE_FOCUS | NS_EVENT_STATE_HOVER))) { nsGenericHTMLElement* element = static_cast(aContent); element->LeaveLink(element->GetPresContext()); } nsIMEStateManager::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; } if (mLastMouseOverElement && nsContentUtils::ContentIsDescendantOf(mLastMouseOverElement, aContent)) { // See bug 292146 for why we want to null this out mLastMouseOverElement = nullptr; } } bool nsEventStateManager::EventStatusOK(WidgetGUIEvent* aEvent) { return !(aEvent->message == NS_MOUSE_BUTTON_DOWN && aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton && !sNormalLMouseEventInProcess); } //------------------------------------------- // Access Key Registration //------------------------------------------- void nsEventStateManager::RegisterAccessKey(nsIContent* aContent, uint32_t aKey) { if (aContent && mAccessKeys.IndexOf(aContent) == -1) mAccessKeys.AppendObject(aContent); } void nsEventStateManager::UnregisterAccessKey(nsIContent* aContent, uint32_t aKey) { if (aContent) mAccessKeys.RemoveObject(aContent); } uint32_t nsEventStateManager::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 nsEventStateManager::EnsureDocument(nsPresContext* aPresContext) { if (!mDocument) mDocument = aPresContext->Document(); } void nsEventStateManager::FlushPendingEvents(nsPresContext* aPresContext) { NS_PRECONDITION(nullptr != aPresContext, "nullptr ptr"); nsIPresShell *shell = aPresContext->GetPresShell(); if (shell) { shell->FlushPendingNotifications(Flush_InterruptibleLayout); } } nsIContent* nsEventStateManager::GetFocusedContent() { nsIFocusManager* fm = nsFocusManager::GetFocusManager(); if (!fm || !mDocument) return nullptr; nsCOMPtr focusedWindow; return nsFocusManager::GetFocusedDescendant(mDocument->GetWindow(), false, getter_AddRefs(focusedWindow)); } //------------------------------------------------------- // Return true if the docshell is visible bool nsEventStateManager::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 nsEventStateManager::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->message) { case NS_CONTENT_COMMAND_CUT: cmd = "cmd_cut"; break; case NS_CONTENT_COMMAND_COPY: cmd = "cmd_copy"; break; case NS_CONTENT_COMMAND_PASTE: cmd = "cmd_paste"; break; case NS_CONTENT_COMMAND_DELETE: cmd = "cmd_delete"; break; case NS_CONTENT_COMMAND_UNDO: cmd = "cmd_undo"; break; case NS_CONTENT_COMMAND_REDO: cmd = "cmd_redo"; break; case NS_CONTENT_COMMAND_PASTE_TRANSFERABLE: cmd = "cmd_pasteTransferable"; 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->message) { case NS_CONTENT_COMMAND_PASTE_TRANSFERABLE: { 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; } default: rv = controller->DoCommand(cmd); break; } NS_ENSURE_SUCCESS(rv, rv); } } aEvent->mSucceeded = true; return NS_OK; } nsresult nsEventStateManager::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 ? CanScrollOn(sf, aEvent->mScroll.mAmount, 0) : 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 nsEventStateManager::DoQuerySelectedText(WidgetQueryContentEvent* aEvent) { if (RemoteQueryContentEvent(aEvent)) { return; } nsContentEventHandler handler(mPresContext); handler.OnQuerySelectedText(aEvent); } void nsEventStateManager::SetActiveManager(nsEventStateManager* 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 nsEventStateManager::ClearGlobalActiveContent(nsEventStateManager* 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; } /******************************************************************/ /* nsEventStateManager::DeltaAccumulator */ /******************************************************************/ void nsEventStateManager::DeltaAccumulator::InitLineOrPageDelta( nsIFrame* aTargetFrame, nsEventStateManager* 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() > nsMouseWheelTransaction::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->deltaMode || mHandlingPixelOnlyDevice != aEvent->isPixelOnlyDevice) { Reset(); } else { // If the delta direction is changed, we should reset only the // accumulated values. if (mX && aEvent->deltaX && ((aEvent->deltaX > 0.0) != (mX > 0.0))) { mX = mPendingScrollAmountX = 0.0; } if (mY && aEvent->deltaY && ((aEvent->deltaY > 0.0) != (mY > 0.0))) { mY = mPendingScrollAmountY = 0.0; } } } mHandlingDeltaMode = aEvent->deltaMode; mHandlingPixelOnlyDevice = aEvent->isPixelOnlyDevice; // If it's handling neither pixel scroll mode for pixel only device nor // delta values multiplied by prefs, we must not modify lineOrPageDelta // values. if (!(mHandlingDeltaMode == nsIDOMWheelEvent::DOM_DELTA_PIXEL && mHandlingPixelOnlyDevice) && !nsEventStateManager::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->deltaX) { mX = aEvent->deltaX; } if (aEvent->deltaY) { mY = aEvent->deltaY; } mLastTime = TimeStamp::Now(); return; } mX += aEvent->deltaX; mY += aEvent->deltaY; if (mHandlingDeltaMode == nsIDOMWheelEvent::DOM_DELTA_PIXEL) { // Records pixel delta values and init lineOrPageDeltaX and // lineOrPageDeltaY 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 // NS_MOUSE_SCROLL_EVENT (DOMMouseScroll) but not be used for scrolling // of default action. The transaction should be used only for the default // action. nsIScrollableFrame* scrollTarget = aESM->ComputeScrollTarget(aTargetFrame, aEvent, COMPUTE_LEGACY_MOUSE_SCROLL_EVENT_TARGET); nsIFrame* frame = do_QueryFrame(scrollTarget); nsPresContext* pc = frame ? frame->PresContext() : aTargetFrame->PresContext(); nsSize scrollAmount = aESM->GetScrollAmount(pc, aEvent, scrollTarget); nsIntSize scrollAmountInCSSPixels( nsPresContext::AppUnitsToIntCSSPixels(scrollAmount.width), nsPresContext::AppUnitsToIntCSSPixels(scrollAmount.height)); aEvent->lineOrPageDeltaX = RoundDown(mX) / scrollAmountInCSSPixels.width; aEvent->lineOrPageDeltaY = RoundDown(mY) / scrollAmountInCSSPixels.height; mX -= aEvent->lineOrPageDeltaX * scrollAmountInCSSPixels.width; mY -= aEvent->lineOrPageDeltaY * scrollAmountInCSSPixels.height; } else { aEvent->lineOrPageDeltaX = RoundDown(mX); aEvent->lineOrPageDeltaY = RoundDown(mY); mX -= aEvent->lineOrPageDeltaX; mY -= aEvent->lineOrPageDeltaY; } mLastTime = TimeStamp::Now(); } void nsEventStateManager::DeltaAccumulator::Reset() { mX = mY = 0.0; mPendingScrollAmountX = mPendingScrollAmountY = 0.0; mHandlingDeltaMode = UINT32_MAX; mHandlingPixelOnlyDevice = false; } nsIntPoint nsEventStateManager::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->customizedByUserPrefs && aEvent->deltaMode == nsIDOMWheelEvent::DOM_DELTA_LINE); DeltaValues acceleratedDelta = nsMouseWheelTransaction::AccelerateWheelDelta(aEvent, allowScrollSpeedOverride); nsIntPoint result(0, 0); if (aEvent->deltaMode == 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; } /******************************************************************/ /* nsEventStateManager::WheelPrefs */ /******************************************************************/ // static nsEventStateManager::WheelPrefs* nsEventStateManager::WheelPrefs::GetInstance() { if (!sInstance) { sInstance = new WheelPrefs(); } return sInstance; } // static void nsEventStateManager::WheelPrefs::Shutdown() { delete sInstance; sInstance = nullptr; } // static int nsEventStateManager::WheelPrefs::OnPrefChanged(const char* aPrefName, void* aClosure) { // forget all prefs, it's not problem for performance. sInstance->Reset(); DeltaAccumulator::GetInstance()->Reset(); return 0; } nsEventStateManager::WheelPrefs::WheelPrefs() { Reset(); Preferences::RegisterCallback(OnPrefChanged, "mousewheel.", nullptr); } nsEventStateManager::WheelPrefs::~WheelPrefs() { Preferences::UnregisterCallback(OnPrefChanged, "mousewheel.", nullptr); } void nsEventStateManager::WheelPrefs::Reset() { memset(mInit, 0, sizeof(mInit)); } nsEventStateManager::WheelPrefs::Index nsEventStateManager::WheelPrefs::GetIndexFor(WidgetWheelEvent* aEvent) { if (!aEvent) { return INDEX_DEFAULT; } Modifiers modifiers = (aEvent->modifiers & (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 nsEventStateManager::WheelPrefs::GetBasePrefName( nsEventStateManager::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 nsEventStateManager::WheelPrefs::Init( nsEventStateManager::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 nsEventStateManager::WheelPrefs::ApplyUserPrefsToDelta(WidgetWheelEvent* aEvent) { Index index = GetIndexFor(aEvent); Init(index); aEvent->deltaX *= mMultiplierX[index]; aEvent->deltaY *= mMultiplierY[index]; aEvent->deltaZ *= 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->lineOrPageDeltaX *= static_cast(mMultiplierX[index]); aEvent->lineOrPageDeltaY *= static_cast(mMultiplierY[index]); } else { aEvent->lineOrPageDeltaX = 0; aEvent->lineOrPageDeltaY = 0; } aEvent->customizedByUserPrefs = ((mMultiplierX[index] != 1.0) || (mMultiplierY[index] != 1.0) || (mMultiplierZ[index] != 1.0)); } void nsEventStateManager::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->overflowDeltaX /= mMultiplierX[index]; } if (mMultiplierY[index]) { aEvent->overflowDeltaY /= mMultiplierY[index]; } } nsEventStateManager::WheelPrefs::Action nsEventStateManager::WheelPrefs::ComputeActionFor(WidgetWheelEvent* aEvent) { Index index = GetIndexFor(aEvent); Init(index); bool deltaXPreferred = (Abs(aEvent->deltaX) > Abs(aEvent->deltaY) && Abs(aEvent->deltaX) > Abs(aEvent->deltaZ)); 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->isMomentum) { // 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 nsEventStateManager::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); } bool nsEventStateManager::WheelPrefs::IsOverOnePageScrollAllowedX( WidgetWheelEvent* aEvent) { Index index = GetIndexFor(aEvent); Init(index); return Abs(mMultiplierX[index]) >= MIN_MULTIPLIER_VALUE_ALLOWING_OVER_ONE_PAGE_SCROLL; } bool nsEventStateManager::WheelPrefs::IsOverOnePageScrollAllowedY( WidgetWheelEvent* aEvent) { Index index = GetIndexFor(aEvent); Init(index); return Abs(mMultiplierY[index]) >= MIN_MULTIPLIER_VALUE_ALLOWING_OVER_ONE_PAGE_SCROLL; } /******************************************************************/ /* nsEventStateManager::Prefs */ /******************************************************************/ bool nsEventStateManager::Prefs::sKeyCausesActivation = true; bool nsEventStateManager::Prefs::sClickHoldContextMenu = false; int32_t nsEventStateManager::Prefs::sGenericAccessModifierKey = -1; int32_t nsEventStateManager::Prefs::sChromeAccessModifierMask = 0; int32_t nsEventStateManager::Prefs::sContentAccessModifierMask = 0; // static void nsEventStateManager::Prefs::Init() { DebugOnly 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\""); rv = Preferences::RegisterCallback(OnChange, "dom.popup_allowed_events"); MOZ_ASSERT(NS_SUCCEEDED(rv), "Failed to observe \"dom.popup_allowed_events\""); } // static int nsEventStateManager::Prefs::OnChange(const char* aPrefName, void*) { nsDependentCString prefName(aPrefName); if (prefName.EqualsLiteral("dom.popup_allowed_events")) { nsDOMEvent::PopupAllowedEventsChanged(); } return 0; } // static void nsEventStateManager::Prefs::Shutdown() { Preferences::UnregisterCallback(OnChange, "dom.popup_allowed_events"); } // static int32_t nsEventStateManager::Prefs::ChromeAccessModifierMask() { return GetAccessModifierMask(nsIDocShellTreeItem::typeChrome); } // static int32_t nsEventStateManager::Prefs::ContentAccessModifierMask() { return GetAccessModifierMask(nsIDocShellTreeItem::typeContent); } // static int32_t nsEventStateManager::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; } }