Skip to content

Lightpanda: the headless browser designed for AI and automation

Fire mousewheel only where no wheel listener is registered

Adrià Arrufat6fb46ca22424
diff --git a/src/browser/EventManager.zig b/src/browser/EventManager.zig
index c0c62febc..ba91aebf8 100644
--- a/src/browser/EventManager.zig
+++ b/src/browser/EventManager.zig
@@ -309,8 +309,8 @@ fn dispatchNode(self: *EventManager, target: *Node, event: *Event) !void {
i -= 1;
if (event._stop_propagation) return;
const current_target = path[i];
- if (self.base.getListeners(current_target, event._type_string)) |list| {
- try self.dispatchPhase(list, current_target, event, &was_handled, &ls.local, true);
+ if (self.listenersFor(current_target, event)) |listeners| {
+ try self.dispatchPhase(listeners, current_target, event, &was_handled, &ls.local, true);
}
}
@@ -360,14 +360,14 @@ fn dispatchNode(self: *EventManager, target: *Node, event: *Event) !void {
// and once during the bubbling iteration, each with its own snapshot
// of the listener list: a bubble listener added while running the
// target's capture listeners must run.
- if (self.base.getListeners(target_et, event._type_string)) |list| {
- try self.dispatchPhase(list, target_et, event, &was_handled, &ls.local, true);
+ if (self.listenersFor(target_et, event)) |listeners| {
+ try self.dispatchPhase(listeners, target_et, event, &was_handled, &ls.local, true);
if (event._stop_propagation) {
return;
}
}
- if (self.base.getListeners(target_et, event._type_string)) |list| {
- try self.dispatchPhase(list, target_et, event, &was_handled, &ls.local, false);
+ if (self.listenersFor(target_et, event)) |listeners| {
+ try self.dispatchPhase(listeners, target_et, event, &was_handled, &ls.local, false);
if (event._stop_propagation) {
return;
}
@@ -416,8 +416,8 @@ fn dispatchNode(self: *EventManager, target: *Node, event: *Event) !void {
}
}
- if (self.base.getListeners(current_target, event._type_string)) |list| {
- try self.dispatchPhase(list, current_target, event, &was_handled, &ls.local, false);
+ if (self.listenersFor(current_target, event)) |listeners| {
+ try self.dispatchPhase(listeners, current_target, event, &was_handled, &ls.local, false);
}
}
}
@@ -430,8 +430,8 @@ fn anyNonPassive(self: *EventManager, path: []const *EventTarget, event: *Event)
if (self.getInlineHandler(target, event) != null) {
return true;
}
- if (self.base.getListeners(target, event._type_string)) |list| {
- if (EventManagerBase.hasNonPassiveListener(list)) {
+ if (self.listenersFor(target, event)) |listeners| {
+ if (EventManagerBase.hasNonPassiveListener(listeners.list)) {
return true;
}
}
@@ -439,6 +439,35 @@ fn anyNonPassive(self: *EventManager, path: []const *EventTarget, event: *Event)
return false;
}
+const TargetListeners = struct {
+ list: *std.DoublyLinkedList,
+ typ: lp.String,
+};
+
+/// The listeners `target` runs for `event`. Like Blink, a target with none
+/// for the event's type falls back to the type's legacy alias: a
+/// `mousewheel` listener fires only where no `wheel` listener is registered.
+fn listenersFor(self: *EventManager, target: *EventTarget, event: *const Event) ?TargetListeners {
+ if (self.base.getListeners(target, event._type_string)) |list| {
+ if (EventManagerBase.hasLiveListener(list)) {
+ return .{ .list = list, .typ = event._type_string };
+ }
+ }
+ const legacy = legacyType(event) orelse return null;
+ const list = self.base.getListeners(target, legacy) orelse return null;
+ return .{ .list = list, .typ = legacy };
+}
+
+fn legacyType(event: *const Event) ?lp.String {
+ if (!event._is_trusted) {
+ return null;
+ }
+ if (event._type_string.eql(comptime .wrap("wheel"))) {
+ return comptime .wrap("mousewheel");
+ }
+ return null;
+}
+
fn processHandlerReturnValue(event: *Event, handler_return: ?js.Value) void {
const ret = handler_return orelse return;
if (ret.isFalse() and !event._type_string.eql(comptime .wrap("error"))) {
@@ -452,9 +481,15 @@ fn currentEventForTarget(target: *EventTarget, event: *Event) ?*Event {
return if (rootIsShadowRoot(target)) null else event;
}
-fn dispatchPhase(self: *EventManager, list: *std.DoublyLinkedList, current_target: *EventTarget, event: *Event, was_handled: *bool, local: *const js.Local, comptime capture_only: ?bool) !void {
+fn dispatchPhase(self: *EventManager, listeners: TargetListeners, current_target: *EventTarget, event: *Event, was_handled: *bool, local: *const js.Local, comptime capture_only: ?bool) !void {
const frame = self.frame;
const base = &self.base;
+ const list = listeners.list;
+
+ // Listeners registered under a legacy name see the event under that name.
+ const real_type = event._type_string;
+ event._type_string = listeners.typ;
+ defer event._type_string = real_type;
const window = frame.window;
const prev_current_event = window._current_event;
diff --git a/src/browser/EventManagerBase.zig b/src/browser/EventManagerBase.zig
index f3e901559..ea33c71a9 100644
--- a/src/browser/EventManagerBase.zig
+++ b/src/browser/EventManagerBase.zig
@@ -205,6 +205,20 @@ pub fn getListeners(self: *EventManagerBase, target: *EventTarget, event_type: S
});
}
+/// Whether the list still holds a listener. One removed during a dispatch
+/// stays linked until the dispatch unwinds, but isn't "in" the list anymore,
+/// same as findListener.
+pub fn hasLiveListener(list: *const std.DoublyLinkedList) bool {
+ var node = list.first;
+ while (node) |n| : (node = n.next) {
+ const listener: *align(8) Listener = @fieldParentPtr("node", n);
+ if (!listener.removed) {
+ return true;
+ }
+ }
+ return false;
+}
+
/// Whether a listener in the list can call preventDefault. A removed
/// listener isn't "in" the list anymore, same as findListener.
pub fn hasNonPassiveListener(list: *const std.DoublyLinkedList) bool {
diff --git a/src/browser/frame/user_input.zig b/src/browser/frame/user_input.zig
index 5beb51713..93cc8f417 100644
--- a/src/browser/frame/user_input.zig
+++ b/src/browser/frame/user_input.zig
@@ -290,31 +290,25 @@ pub fn triggerMouseWheel(frame: *Frame, x: f64, y: f64, delta_x: f64, delta_y: f
try wheel(frame, target, x, y, delta_x, delta_y);
}
-/// A wheel over `target`: trusted `wheel`, the legacy `mousewheel` Blink
-/// still fires, then the scroll unless either was canceled. Each event is
-/// cancelable only while a listener on its dispatch path is non-passive.
+/// A wheel over `target`: a trusted `wheel`, then the scroll unless it was
+/// canceled. The event manager retypes it as Blink's legacy `mousewheel` for
+/// targets listening only to that, and makes it cancelable only while a
+/// listener on its dispatch path is non-passive.
pub fn wheel(frame: *Frame, target: *Element, x: f64, y: f64, delta_x: f64, delta_y: f64) !void {
// Listeners live in the event manager of the element's own frame, which
// is not the caller's when the element belongs to an iframe's document.
const owner = target.ownerFrame(frame) orelse return;
- const event_manager = &owner._event_manager;
- var canceled = false;
- inline for (.{ "wheel", "mousewheel" }) |typ| {
- const event: *WheelEvent = try .initTrusted(typ, .{
- .bubbles = true,
- .composed = true,
- .clientX = x,
- .clientY = y,
- .deltaX = delta_x,
- .deltaY = delta_y,
- }, owner);
- event.asEvent()._cancelable_unless_passive = true;
- if (try event_manager.dispatchCancelable(target.asEventTarget(), event.asEvent())) {
- canceled = true;
- }
- }
- if (canceled) {
+ const event: *WheelEvent = try .initTrusted("wheel", .{
+ .bubbles = true,
+ .composed = true,
+ .clientX = x,
+ .clientY = y,
+ .deltaX = delta_x,
+ .deltaY = delta_y,
+ }, owner);
+ event.asEvent()._cancelable_unless_passive = true;
+ if (try owner._event_manager.dispatchCancelable(target.asEventTarget(), event.asEvent())) {
return;
}
diff --git a/src/server/cdp/domains/input.zig b/src/server/cdp/domains/input.zig
index 69b9c8db1..05a30355c 100644
--- a/src/server/cdp/domains/input.zig
+++ b/src/server/cdp/domains/input.zig
@@ -372,11 +372,15 @@ test "cdp.input: dispatchMouseEvent mouseWheel cancelability follows listener pa
defer try_catch.deinit();
// Only passive listeners: the event is non-cancelable, preventDefault is
- // inert and the scroll happens. Blink's legacy mousewheel fires too.
+ // inert and the scroll happens. Blink's legacy mousewheel fires only on a
+ // target with no wheel listener, and sees the event under that name.
_ = try ls.local.compileAndRun(
\\const box = document.getElementById('scrollbox');
\\box.addEventListener('wheel', (e) => { window.passiveCancelable = e.cancelable; e.preventDefault(); }, { passive: true });
- \\box.addEventListener('mousewheel', (e) => { window.legacyDeltaY = e.deltaY; });
+ \\box.addEventListener('mousewheel', () => { window.boxLegacy = true; });
+ \\document.body.addEventListener('mousewheel', (e) => { window.legacyType = e.type; window.legacyDeltaY = e.deltaY; });
+ \\window.bodyWheel = (e) => { window.bodyType = e.type; };
+ \\document.body.addEventListener('wheel', window.bodyWheel, { passive: true });
, null);
const rect_x = try (try ls.local.compileAndRun("document.getElementById('scrollbox').getBoundingClientRect().x", null)).toF64();
@@ -387,7 +391,20 @@ test "cdp.input: dispatchMouseEvent mouseWheel cancelability follows listener pa
.method = "Input.dispatchMouseEvent",
.params = .{ .type = "mouseWheel", .x = rect_x, .y = rect_y, .deltaY = 40 },
});
- var result = try ls.local.compileAndRun("window.passiveCancelable === false && window.legacyDeltaY === 40 && document.getElementById('scrollbox').scrollTop === 40", null);
+ var result = try ls.local.compileAndRun("window.passiveCancelable === false && window.boxLegacy === undefined && window.bodyType === 'wheel' && window.legacyType === undefined && document.getElementById('scrollbox').scrollTop === 40", null);
+ try testing.expect(result.isTrue());
+
+ // Without a wheel listener the body runs its mousewheel listener instead.
+ _ = try ls.local.compileAndRun(
+ \\document.body.removeEventListener('wheel', window.bodyWheel);
+ \\window.bodyType = undefined;
+ , null);
+ try ctx.processMessage(.{
+ .id = 2,
+ .method = "Input.dispatchMouseEvent",
+ .params = .{ .type = "mouseWheel", .x = rect_x, .y = rect_y, .deltaY = 40 },
+ });
+ result = try ls.local.compileAndRun("window.bodyType === undefined && window.legacyType === 'mousewheel' && window.legacyDeltaY === 40 && document.getElementById('scrollbox').scrollTop === 80", null);
try testing.expect(result.isTrue());
// A non-passive listener makes it cancelable, and preventDefault stops the scroll.
@@ -395,11 +412,26 @@ test "cdp.input: dispatchMouseEvent mouseWheel cancelability follows listener pa
\\document.getElementById('scrollbox').addEventListener('wheel', (e) => { window.activeCancelable = e.cancelable; e.preventDefault(); });
, null);
try ctx.processMessage(.{
- .id = 2,
+ .id = 3,
.method = "Input.dispatchMouseEvent",
.params = .{ .type = "mouseWheel", .x = rect_x, .y = rect_y, .deltaY = 40 },
});
- result = try ls.local.compileAndRun("window.activeCancelable === true && document.getElementById('scrollbox').scrollTop === 40", null);
+ result = try ls.local.compileAndRun("window.activeCancelable === true && document.getElementById('scrollbox').scrollTop === 80", null);
+ try testing.expect(result.isTrue());
+
+ // A mousewheel listener standing in for wheel is a listener like any
+ // other: non-passive, it makes the event cancelable and can cancel the scroll.
+ _ = try ls.local.compileAndRun(
+ \\document.getElementById('sheetscroll').addEventListener('mousewheel', (e) => { window.sheetCancelable = e.cancelable; e.preventDefault(); });
+ , null);
+ const sheet_x = try (try ls.local.compileAndRun("document.getElementById('sheetleaf').getBoundingClientRect().x", null)).toF64();
+ const sheet_y = try (try ls.local.compileAndRun("document.getElementById('sheetleaf').getBoundingClientRect().y", null)).toF64();
+ try ctx.processMessage(.{
+ .id = 4,
+ .method = "Input.dispatchMouseEvent",
+ .params = .{ .type = "mouseWheel", .x = sheet_x, .y = sheet_y, .deltaY = 40 },
+ });
+ result = try ls.local.compileAndRun("window.sheetCancelable === true && document.getElementById('sheetscroll').scrollTop === 0", null);
try testing.expect(result.isTrue());
}