summaryrefslogtreecommitdiffstats
path: root/dom/events/WheelEvent.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 17:32:43 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 17:32:43 +0000
commit6bf0a5cb5034a7e684dcc3500e841785237ce2dd (patch)
treea68f146d7fa01f0134297619fbe7e33db084e0aa /dom/events/WheelEvent.cpp
parentInitial commit. (diff)
downloadthunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.tar.xz
thunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.zip
Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/events/WheelEvent.cpp')
-rw-r--r--dom/events/WheelEvent.cpp178
1 files changed, 178 insertions, 0 deletions
diff --git a/dom/events/WheelEvent.cpp b/dom/events/WheelEvent.cpp
new file mode 100644
index 0000000000..56cfe113ea
--- /dev/null
+++ b/dom/events/WheelEvent.cpp
@@ -0,0 +1,178 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/MouseEventBinding.h"
+#include "mozilla/dom/WheelEvent.h"
+#include "mozilla/MouseEvents.h"
+#include "prtime.h"
+
+namespace mozilla::dom {
+
+WheelEvent::WheelEvent(EventTarget* aOwner, nsPresContext* aPresContext,
+ WidgetWheelEvent* aWheelEvent)
+ : MouseEvent(aOwner, aPresContext,
+ aWheelEvent
+ ? aWheelEvent
+ : new WidgetWheelEvent(false, eVoidEvent, nullptr)),
+ mAppUnitsPerDevPixel(0) {
+ if (aWheelEvent) {
+ mEventIsInternal = false;
+ // If the delta mode is pixel, the WidgetWheelEvent's delta values are in
+ // device pixels. However, JS contents need the delta values in CSS pixels.
+ // We should store the value of mAppUnitsPerDevPixel here because
+ // it might be changed by changing zoom or something.
+ if (aWheelEvent->mDeltaMode == WheelEvent_Binding::DOM_DELTA_PIXEL) {
+ mAppUnitsPerDevPixel = aPresContext->AppUnitsPerDevPixel();
+ }
+ } else {
+ mEventIsInternal = true;
+ mEvent->mRefPoint = LayoutDeviceIntPoint(0, 0);
+ mEvent->AsWheelEvent()->mInputSource =
+ MouseEvent_Binding::MOZ_SOURCE_UNKNOWN;
+ }
+}
+
+void WheelEvent::InitWheelEvent(
+ const nsAString& aType, bool aCanBubble, bool aCancelable,
+ nsGlobalWindowInner* aView, int32_t aDetail, int32_t aScreenX,
+ int32_t aScreenY, int32_t aClientX, int32_t aClientY, uint16_t aButton,
+ EventTarget* aRelatedTarget, const nsAString& aModifiersList,
+ double aDeltaX, double aDeltaY, double aDeltaZ, uint32_t aDeltaMode) {
+ NS_ENSURE_TRUE_VOID(!mEvent->mFlags.mIsBeingDispatched);
+
+ MouseEvent::InitMouseEvent(aType, aCanBubble, aCancelable, aView, aDetail,
+ aScreenX, aScreenY, aClientX, aClientY, aButton,
+ aRelatedTarget, aModifiersList);
+
+ WidgetWheelEvent* wheelEvent = mEvent->AsWheelEvent();
+ // When specified by the caller (for JS-created events), don't mess with the
+ // delta mode.
+ wheelEvent->mDeltaModeCheckingState =
+ WidgetWheelEvent::DeltaModeCheckingState::Checked;
+ wheelEvent->mDeltaX = aDeltaX;
+ wheelEvent->mDeltaY = aDeltaY;
+ wheelEvent->mDeltaZ = aDeltaZ;
+ wheelEvent->mDeltaMode = aDeltaMode;
+ wheelEvent->mAllowToOverrideSystemScrollSpeed = false;
+}
+
+int32_t WheelEvent::WheelDeltaX(CallerType aCallerType) {
+ WidgetWheelEvent* ev = mEvent->AsWheelEvent();
+ if (ev->mWheelTicksX != 0.0) {
+ return int32_t(-ev->mWheelTicksX * kNativeTicksToWheelDelta);
+ }
+ if (IsTrusted()) {
+ // We always return pixels regardless of the checking-state.
+ double pixelDelta =
+ ev->mDeltaMode == WheelEvent_Binding::DOM_DELTA_PIXEL
+ ? DevToCssPixels(ev->OverriddenDeltaX())
+ : ev->OverriddenDeltaX() *
+ CSSPixel::FromAppUnits(ev->mScrollAmount.width).Rounded();
+ return int32_t(-std::round(pixelDelta * kTrustedDeltaToWheelDelta));
+ }
+ return int32_t(-std::round(DeltaX(aCallerType))); // This matches Safari.
+}
+
+int32_t WheelEvent::WheelDeltaY(CallerType aCallerType) {
+ WidgetWheelEvent* ev = mEvent->AsWheelEvent();
+ if (ev->mWheelTicksY != 0.0) {
+ return int32_t(-ev->mWheelTicksY * kNativeTicksToWheelDelta);
+ }
+
+ if (IsTrusted()) {
+ double pixelDelta =
+ ev->mDeltaMode == WheelEvent_Binding::DOM_DELTA_PIXEL
+ ? DevToCssPixels(ev->OverriddenDeltaY())
+ : ev->OverriddenDeltaY() *
+ CSSPixel::FromAppUnits(ev->mScrollAmount.height).Rounded();
+ return int32_t(-std::round(pixelDelta * kTrustedDeltaToWheelDelta));
+ }
+ return int32_t(-std::round(DeltaY(aCallerType))); // This matches Safari.
+}
+
+double WheelEvent::ToWebExposedDelta(WidgetWheelEvent& aWidgetEvent,
+ double aDelta, nscoord aLineOrPageAmount,
+ CallerType aCallerType) {
+ using DeltaModeCheckingState = WidgetWheelEvent::DeltaModeCheckingState;
+ if (aCallerType != CallerType::System) {
+ if (aWidgetEvent.mDeltaModeCheckingState ==
+ DeltaModeCheckingState::Unknown) {
+ aWidgetEvent.mDeltaModeCheckingState = DeltaModeCheckingState::Unchecked;
+ }
+ if (aWidgetEvent.mDeltaModeCheckingState ==
+ DeltaModeCheckingState::Unchecked &&
+ aWidgetEvent.mDeltaMode == WheelEvent_Binding::DOM_DELTA_LINE) {
+ return aDelta * CSSPixel::FromAppUnits(aLineOrPageAmount).Rounded();
+ }
+ }
+ return DevToCssPixels(aDelta);
+}
+
+double WheelEvent::DeltaX(CallerType aCallerType) {
+ WidgetWheelEvent* ev = mEvent->AsWheelEvent();
+ return ToWebExposedDelta(*ev, ev->OverriddenDeltaX(), ev->mScrollAmount.width,
+ aCallerType);
+}
+
+double WheelEvent::DeltaY(CallerType aCallerType) {
+ WidgetWheelEvent* ev = mEvent->AsWheelEvent();
+ return ToWebExposedDelta(*ev, ev->OverriddenDeltaY(),
+ ev->mScrollAmount.height, aCallerType);
+}
+
+double WheelEvent::DeltaZ(CallerType aCallerType) {
+ WidgetWheelEvent* ev = mEvent->AsWheelEvent();
+ // XXX Unclear what scroll amount we should use for deltaZ...
+ auto amount = std::max(ev->mScrollAmount.width, ev->mScrollAmount.height);
+ return ToWebExposedDelta(*ev, ev->mDeltaZ, amount, aCallerType);
+}
+
+uint32_t WheelEvent::DeltaMode(CallerType aCallerType) {
+ using DeltaModeCheckingState = WidgetWheelEvent::DeltaModeCheckingState;
+
+ WidgetWheelEvent* ev = mEvent->AsWheelEvent();
+ uint32_t mode = ev->mDeltaMode;
+ if (aCallerType != CallerType::System) {
+ if (ev->mDeltaModeCheckingState == DeltaModeCheckingState::Unknown) {
+ ev->mDeltaModeCheckingState = DeltaModeCheckingState::Checked;
+ } else if (ev->mDeltaModeCheckingState ==
+ DeltaModeCheckingState::Unchecked &&
+ mode == WheelEvent_Binding::DOM_DELTA_LINE) {
+ return WheelEvent_Binding::DOM_DELTA_PIXEL;
+ }
+ }
+
+ return mode;
+}
+
+already_AddRefed<WheelEvent> WheelEvent::Constructor(
+ const GlobalObject& aGlobal, const nsAString& aType,
+ const WheelEventInit& aParam) {
+ nsCOMPtr<EventTarget> t = do_QueryInterface(aGlobal.GetAsSupports());
+ RefPtr<WheelEvent> e = new WheelEvent(t, nullptr, nullptr);
+ bool trusted = e->Init(t);
+ e->InitWheelEvent(aType, aParam.mBubbles, aParam.mCancelable, aParam.mView,
+ aParam.mDetail, aParam.mScreenX, aParam.mScreenY,
+ aParam.mClientX, aParam.mClientY, aParam.mButton,
+ aParam.mRelatedTarget, u""_ns, aParam.mDeltaX,
+ aParam.mDeltaY, aParam.mDeltaZ, aParam.mDeltaMode);
+ e->InitializeExtraMouseEventDictionaryMembers(aParam);
+ e->SetTrusted(trusted);
+ e->SetComposed(aParam.mComposed);
+ return e.forget();
+}
+
+} // namespace mozilla::dom
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+already_AddRefed<WheelEvent> NS_NewDOMWheelEvent(EventTarget* aOwner,
+ nsPresContext* aPresContext,
+ WidgetWheelEvent* aEvent) {
+ RefPtr<WheelEvent> it = new WheelEvent(aOwner, aPresContext, aEvent);
+ return it.forget();
+}