@gtkx/testing 1.0.0-rc.4 → 1.1.0

package/src/user-event/keyboard.ts

@@ -1,9 +1,11 @@
 import * as Gdk from "@gtkx/gi/gdk";
+import * as Gio from "@gtkx/gi/gio";
 import * as Gtk from "@gtkx/gi/gtk";
+import { hasSignalListener } from "@gtkx/runtime/internal";
 import type { UserEventState } from "./state.js";
 import { getEditableDelegate } from "../editable.js";
 import { fireEvent } from "../fire-event.js";
-import { getOrCreateControllers } from "./controller.js";
+import { ancestors, descendants } from "../traversal.js";
 import { wrapEvent } from "./event-wrapper.js";
 
 /** Options for `userEvent.tab`. */
@@ -14,6 +16,8 @@ type TabOptions = {
 
 type KeyAction = { keyval: number; isPress: boolean };
 type ParseStep = { actions: KeyAction[]; next: number };
+type KeyStopController = Gtk.EventControllerKey | Gtk.ShortcutController;
+type KeyStop = { widget: Gtk.Widget; controller: KeyStopController };
 
 const KEY_MAP: Record<string, number> = {
     Enter: Gdk.KEY_Return,
@@ -48,6 +52,8 @@ const KEY_MAP: Record<string, number> = {
     F12: Gdk.KEY_F12,
 };
 
+const KEY_CONTROLLER_SIGNALS = ["key-pressed", "key-released"];
+
 const MODIFIER_KEYVAL_TO_MASK: Record<number, number> = {
     [Gdk.KEY_Shift_L]: Gdk.ModifierType.SHIFT_MASK,
     [Gdk.KEY_Shift_R]: Gdk.ModifierType.SHIFT_MASK,
@@ -179,6 +185,61 @@ const isTriggerMatch = (
     return false;
 };
 
+const controllersOn = function* (widget: Gtk.Widget): Generator<Gtk.EventController> {
+    const controllers = widget.observeControllers();
+    const count = controllers.getNItems();
+
+    for (let i = 0; i < count; i++) {
+        const controller = controllers.getItem(i);
+
+        if (controller instanceof Gtk.EventController) {
+            yield controller;
+        }
+    }
+};
+
+const hasShortcut = (controller: Gtk.ShortcutController, shortcut: Gtk.Shortcut): boolean => {
+    const count = controller.getNItems();
+
+    for (let i = 0; i < count; i++) {
+        if (controller.getItem(i) === shortcut) {
+            return true;
+        }
+    }
+
+    return false;
+};
+
+const isManagingShortcut = (controller: Gtk.EventController, shortcut: Gtk.Shortcut): boolean =>
+    controller instanceof Gtk.ShortcutController &&
+    controller.getScope() !== Gtk.ShortcutScope.LOCAL &&
+    hasShortcut(controller, shortcut);
+
+const managedShortcutHost = (manager: Gtk.Widget, shortcut: Gtk.Shortcut): Gtk.Widget | null => {
+    for (const current of [manager, ...descendants(manager)]) {
+        if (controllersOn(current).some((controller) => isManagingShortcut(controller, shortcut))) {
+            return current;
+        }
+    }
+
+    return null;
+};
+
+const isMovingFocus = (action: Gtk.ShortcutAction): boolean =>
+    action instanceof Gtk.SignalAction && action.getSignalName() === "move-focus";
+
+const isShortcutLive = (host: Gtk.Widget): boolean => host.isSensitive() && host.getMapped();
+
+const didRunShortcutAction = (shortcut: Gtk.Shortcut, host: Gtk.Widget): boolean => {
+    const action = shortcut.getAction();
+
+    if (action === null || isMovingFocus(action) || !isShortcutLive(host)) {
+        return false;
+    }
+
+    return action.activate(0 as Gtk.ShortcutActionFlags, host, shortcut.getArguments());
+};
+
 const didActivateShortcut = (
     shortcut: Gtk.Shortcut,
     widget: Gtk.Widget,
@@ -189,13 +250,7 @@ const didActivateShortcut = (
         return false;
     }
 
-    const action = shortcut.getAction();
-
-    if (action instanceof Gtk.SignalAction && action.getSignalName() === "move-focus") {
-        return false;
-    }
-
-    return action?.activate(0 as Gtk.ShortcutActionFlags, widget, shortcut.getArguments()) ?? false;
+    return didRunShortcutAction(shortcut, managedShortcutHost(widget, shortcut) ?? widget);
 };
 
 const didActivateMatchingShortcut = (
@@ -221,71 +276,134 @@ const didActivateMatchingShortcut = (
     return false;
 };
 
-const didDispatchShortcutsOnWidget = (widget: Gtk.Widget, keyval: number, modifiers: number): boolean => {
-    const controllers = widget.observeControllers();
+const isAccelMatch = (accel: string, keyval: number, modifiers: Gdk.ModifierType): boolean => {
+    const [isParsed, accelKeyval, accelModifiers] = Gtk.acceleratorParse(accel);
 
-    for (let i = 0; i < controllers.getNItems(); i++) {
-        const controller = controllers.getItem(i);
+    return isParsed && accelKeyval === keyval && accelModifiers === modifiers;
+};
 
-        if (
-            controller instanceof Gtk.ShortcutController &&
-            didActivateMatchingShortcut(controller, widget, keyval, modifiers)
-        ) {
-            return true;
+const hasMatchingAccel = (
+    application: Gtk.Application,
+    detailedActionName: string,
+    keyval: number,
+    modifiers: number,
+): boolean =>
+    application.getAccelsForAction(detailedActionName).some((accel) => isAccelMatch(accel, keyval, modifiers));
+
+const didActivateDetailedAction = (window: Gtk.Window, detailedActionName: string): boolean => {
+    const [isParsed, actionName, target] = Gio.Action.parseDetailedName(detailedActionName);
+
+    return isParsed && window.activateAction(actionName, target);
+};
+
+const didDispatchAccelsOnWindow = (window: Gtk.Window, keyval: number, modifiers: number): boolean => {
+    const application = window.getApplication();
+
+    if (!application) {
+        return false;
+    }
+
+    for (const detailedActionName of application.listActionDescriptions()) {
+        if (hasMatchingAccel(application, detailedActionName, keyval, modifiers)) {
+            return didActivateDetailedAction(window, detailedActionName);
         }
     }
 
     return false;
 };
 
-const didDispatchShortcuts = (widget: Gtk.Widget, keyval: number, modifiers: number): boolean => {
-    const delegate = getEditableDelegate(widget);
+const didDispatchApplicationAccels = (widget: Gtk.Widget, keyval: number, modifiers: number): boolean => {
+    const root = widget.getRoot();
+
+    return root instanceof Gtk.Window && didDispatchAccelsOnWindow(root, keyval, modifiers);
+};
 
-    if (delegate && didDispatchShortcutsOnWidget(delegate, keyval, modifiers)) {
-        return true;
+const isKeyStopController = (controller: Gtk.EventController): controller is KeyStopController => {
+    if (controller instanceof Gtk.ShortcutController) {
+        return controller.getScope() === Gtk.ShortcutScope.LOCAL;
     }
 
-    for (let current: Gtk.Widget | null = widget; current; current = current.getParent()) {
-        if (didDispatchShortcutsOnWidget(current, keyval, modifiers)) {
-            return true;
+    return controller instanceof Gtk.EventControllerKey && hasSignalListener(controller, KEY_CONTROLLER_SIGNALS);
+};
+
+const keyStopsInPhase = (widget: Gtk.Widget, phase: Gtk.PropagationPhase): KeyStop[] => {
+    const stops: KeyStop[] = [];
+
+    for (const controller of controllersOn(widget)) {
+        if (controller.getPropagationPhase() === phase && isKeyStopController(controller)) {
+            stops.push({ widget, controller });
         }
     }
 
-    return false;
+    return stops;
 };
 
-const handleKeyPress = async (widget: Gtk.Widget, keyval: number, modifiers: number): Promise<void> => {
-    const isHandled = didDispatchShortcuts(widget, keyval, modifiers);
+const propagationChain = (widget: Gtk.Widget): Gtk.Widget[] => {
+    const delegate = getEditableDelegate(widget);
+    const below = delegate === null ? [] : [delegate];
 
-    if (!isHandled && keyval === Gdk.KEY_Return && widget instanceof Gtk.Editable) {
-        await fireEvent(widget, "activate");
+    return [...below, widget, ...ancestors(widget)];
+};
+
+const keyPropagationChain = (widget: Gtk.Widget): KeyStop[] => {
+    const chain = propagationChain(widget);
+    const [eventWidget = widget] = chain;
+
+    return [
+        ...chain.toReversed().flatMap((current) => keyStopsInPhase(current, Gtk.PropagationPhase.CAPTURE)),
+        ...keyStopsInPhase(eventWidget, Gtk.PropagationPhase.TARGET),
+        ...chain.flatMap((current) => keyStopsInPhase(current, Gtk.PropagationPhase.BUBBLE)),
+    ];
+};
+
+const didStopHandlePress = (stop: KeyStop, keyval: number, modifiers: Gdk.ModifierType): boolean => {
+    const { controller, widget } = stop;
+
+    if (controller instanceof Gtk.ShortcutController) {
+        return didActivateMatchingShortcut(controller, widget, keyval, modifiers);
     }
+
+    return controller.emit("key-pressed", keyval, 0, modifiers);
 };
 
-const applyKeyAction = async (
-    widget: Gtk.Widget,
-    controllers: Gtk.EventControllerKey[],
-    state: UserEventState,
-    action: KeyAction,
-): Promise<void> => {
-    updateModifierState(state, action);
-    const signalName = action.isPress ? "key-pressed" : "key-released";
+const didHandlePress = (widget: Gtk.Widget, keyval: number, modifiers: Gdk.ModifierType): boolean =>
+    didDispatchApplicationAccels(widget, keyval, modifiers) ||
+    keyPropagationChain(widget).some((stop) => didStopHandlePress(stop, keyval, modifiers));
 
-    for (const controller of controllers) {
-        controller.emit(signalName, action.keyval, 0, state.modifierState);
+const emitKeyReleased = (widget: Gtk.Widget, keyval: number, modifiers: Gdk.ModifierType): void => {
+    for (const stop of keyPropagationChain(widget)) {
+        if (stop.controller instanceof Gtk.EventControllerKey) {
+            stop.controller.emit("key-released", keyval, 0, modifiers);
+        }
+    }
+};
+
+const applyKeyPress = async (widget: Gtk.Widget, keyval: number, modifiers: Gdk.ModifierType): Promise<void> => {
+    if (didHandlePress(widget, keyval, modifiers)) {
+        return;
     }
 
+    if (keyval === Gdk.KEY_Return && widget instanceof Gtk.Editable) {
+        await fireEvent(widget, "activate");
+    }
+};
+
+const applyKeyAction = async (widget: Gtk.Widget, state: UserEventState, action: KeyAction): Promise<void> => {
+    updateModifierState(state, action);
+
     if (action.isPress) {
-        await handleKeyPress(widget, action.keyval, state.modifierState);
+        await applyKeyPress(widget, action.keyval, state.modifierState);
+
+        return;
     }
+
+    emitKeyReleased(widget, action.keyval, state.modifierState);
 };
 
 const keyboard = (state: UserEventState, widget: Gtk.Widget, input: string): Promise<void> =>
     wrapEvent(widget, async () => {
-        const controllers = getOrCreateControllers(widget, Gtk.EventControllerKey);
-
         for (const action of parseKeyboardInput(input)) {
-            await applyKeyAction(widget, controllers, state, action);
+            await applyKeyAction(widget, state, action);
         }
     });
 

package/src/user-event/list-row-click.ts

@@ -0,0 +1,54 @@
+import type * as Gtk from "@gtkx/gi/gtk";
+import * as GLib from "@gtkx/gi/glib";
+import { ancestors } from "../traversal.js";
+import { callBooleanGetter, hasWidgetMethod } from "../widget-getters.js";
+
+const SELECT_ACTION = "listitem.select";
+const SINGLE_CLICK_ACTIVATE_GETTER = "getSingleClickActivate";
+const DOUBLE_CLICK_PRESS = 2;
+
+const viewFor = (row: Gtk.Widget): Gtk.Widget | null => {
+    for (const ancestor of ancestors(row)) {
+        if (hasWidgetMethod(ancestor, SINGLE_CLICK_ACTIVATE_GETTER)) {
+            return ancestor;
+        }
+    }
+
+    return null;
+};
+
+const isViewSingleClickActivating = (row: Gtk.Widget): boolean => {
+    const view = viewFor(row);
+
+    return view === null ? false : callBooleanGetter(view, SINGLE_CLICK_ACTIVATE_GETTER) ?? false;
+};
+
+const selectRow = (row: Gtk.Widget): void => {
+    row.activateAction(
+        SELECT_ACTION,
+        GLib.Variant.newTuple([GLib.Variant.newBoolean(false), GLib.Variant.newBoolean(false)]),
+    );
+};
+
+const isRowActivatedByPress = (row: Gtk.Widget, press: number): boolean =>
+    press === DOUBLE_CLICK_PRESS || isViewSingleClickActivating(row);
+
+const applyRowPress = (row: Gtk.Widget, press: number): void => {
+    if (row.getFocusOnClick()) {
+        row.grabFocus();
+    }
+
+    selectRow(row);
+
+    if (isRowActivatedByPress(row, press)) {
+        row.activate();
+    }
+};
+
+const applyRowClick = (row: Gtk.Widget, nPress: number): void => {
+    for (let press = 1; press <= nPress; press++) {
+        applyRowPress(row, press);
+    }
+};
+
+export { applyRowClick };

package/src/user-event/native-click.ts

@@ -0,0 +1,51 @@
+import * as Gtk from "@gtkx/gi/gtk";
+import { getWidgetTypeName } from "../widget-getters.js";
+import { applyHeaderClick } from "./column-header-click.js";
+import { applyRowClick } from "./list-row-click.js";
+import { applyTabClick, isNotebookTab } from "./notebook-tab-click.js";
+
+type NativeClick = (widget: Gtk.Widget, nPress: number) => void;
+
+const COLUMN_ROW_TYPE_NAME = "GtkColumnViewRowWidget";
+const ROW_TYPE_NAMES: Set<string> = new Set([COLUMN_ROW_TYPE_NAME, "GtkListItemWidget"]);
+const CELL_TYPE_NAME = "GtkColumnViewCellWidget";
+const TITLE_TYPE_NAME = "GtkColumnViewTitle";
+const TOGGLE_EXPAND_ACTION = "listitem.toggle-expand";
+
+const isHeaderRow = (widget: Gtk.Widget): boolean =>
+    getWidgetTypeName(widget) === COLUMN_ROW_TYPE_NAME && widget.getParent() instanceof Gtk.ColumnView;
+
+const isClickTransparent = (widget: Gtk.Widget): boolean =>
+    getWidgetTypeName(widget) === CELL_TYPE_NAME || isHeaderRow(widget);
+
+const isExpanderToggling = (widget: Gtk.Widget): boolean =>
+    widget instanceof Gtk.TreeExpander &&
+    widget.getListRow()?.isExpandable() === true &&
+    !widget.getHideExpander();
+
+const isColumnHeader = (widget: Gtk.Widget): boolean => getWidgetTypeName(widget) === TITLE_TYPE_NAME;
+const isFactoryRow = (widget: Gtk.Widget): boolean => ROW_TYPE_NAMES.has(getWidgetTypeName(widget) ?? "");
+
+const toggleExpander = (widget: Gtk.Widget, nPress: number): void => {
+    for (let press = 1; press <= nPress; press++) {
+        widget.activateAction(TOGGLE_EXPAND_ACTION, null);
+    }
+};
+
+const nativeClickFor = (widget: Gtk.Widget, isClicked: boolean): NativeClick | null => {
+    if (isClicked && isExpanderToggling(widget)) {
+        return toggleExpander;
+    }
+
+    if (isColumnHeader(widget)) {
+        return applyHeaderClick;
+    }
+
+    if (isNotebookTab(widget)) {
+        return applyTabClick;
+    }
+
+    return isFactoryRow(widget) ? applyRowClick : null;
+};
+
+export { isClickTransparent, type NativeClick, nativeClickFor };

package/src/user-event/notebook-tab-click.ts

@@ -0,0 +1,57 @@
+import * as Gtk from "@gtkx/gi/gtk";
+import { ancestorFor } from "../traversal.js";
+
+type NotebookTab = { notebook: Gtk.Notebook; index: number };
+
+const tabLabelsFor = (notebook: Gtk.Notebook): (Gtk.Widget | null)[] => {
+    const labels: (Gtk.Widget | null)[] = [];
+
+    for (let index = 0; index < notebook.getNPages(); index++) {
+        const child = notebook.getNthPage(index);
+        labels.push(child === null ? null : notebook.getPage(child).tab);
+    }
+
+    return labels;
+};
+
+const isNested = (outer: Gtk.Widget, inner: Gtk.Widget): boolean => outer === inner || inner.isAncestor(outer);
+
+const isSameTab = (tab: Gtk.Widget, label: Gtk.Widget | null): boolean =>
+    label !== null && (isNested(tab, label) || isNested(label, tab));
+
+const tabIndexFor = (notebook: Gtk.Notebook, tab: Gtk.Widget): number => {
+    const matches = tabLabelsFor(notebook)
+        .map((label, index) => (isSameTab(tab, label) ? index : -1))
+        .filter((index) => index >= 0);
+
+    return matches.length === 1 ? matches[0] ?? -1 : -1;
+};
+
+const notebookTabFor = (widget: Gtk.Widget): NotebookTab | null => {
+    if (widget.getAccessibleRole() !== Gtk.AccessibleRole.TAB) {
+        return null;
+    }
+
+    const notebook = ancestorFor(widget, Gtk.Notebook);
+    const index = notebook === null ? -1 : tabIndexFor(notebook, widget);
+
+    return notebook === null || index < 0 ? null : { notebook, index };
+};
+
+const isNotebookTab = (widget: Gtk.Widget): boolean => notebookTabFor(widget) !== null;
+
+const applyTabClick = (widget: Gtk.Widget): void => {
+    const tab = notebookTabFor(widget);
+
+    if (tab === null) {
+        return;
+    }
+
+    if (tab.notebook.getFocusOnClick()) {
+        tab.notebook.grabFocus();
+    }
+
+    tab.notebook.setCurrentPage(tab.index);
+};
+
+export { applyTabClick, isNotebookTab };

package/src/user-event/pointer.ts

@@ -1,39 +1,78 @@
-import * as Gtk from "@gtkx/gi/gtk";
+import type * as Gtk from "@gtkx/gi/gtk";
+import type { NativeClick } from "./native-click.js";
 import type { UserEventState } from "./state.js";
-import { emitPress, emitRelease } from "./click.js";
-import { getOrCreateControllers } from "./controller.js";
+import { clickGestures, emitClickPhase, getAuthoredClickGestures } from "./click.js";
 import { wrapEvent } from "./event-wrapper.js";
+import { isClickTransparent, nativeClickFor } from "./native-click.js";
 
 /**
  * A pointer action token: a full click (`click`, `[MouseLeft]`), a button press (`down`,
  * `[MouseLeft>]`), or a button release (`up`, `[/MouseLeft]`).
  */
 type PointerInput = "click" | "down" | "up" | "[MouseLeft]" | "[MouseLeft>]" | "[/MouseLeft]";
+type PointerTarget = { widget: Gtk.Widget; gestures: Gtk.GestureClick[]; native: NativeClick | null };
 
 const PRESS_INPUTS: Set<PointerInput> = new Set(["[MouseLeft>]", "down"]);
 const RELEASE_INPUTS: Set<PointerInput> = new Set(["[/MouseLeft]", "up"]);
 const CLICK_INPUTS: Set<PointerInput> = new Set(["[MouseLeft]", "click"]);
 
+const pointerWidgetFor = (widget: Gtk.Widget): Gtk.Widget => {
+    let current = widget;
+
+    while (isClickTransparent(current)) {
+        const parent = current.getParent();
+
+        if (parent === null) {
+            return current;
+        }
+
+        current = parent;
+    }
+
+    return current;
+};
+
+const pointerGesturesFor = (widget: Gtk.Widget, native: NativeClick | null): Gtk.GestureClick[] =>
+    native === null ? clickGestures(widget) : getAuthoredClickGestures(widget);
+
+const pointerTargetFor = (widget: Gtk.Widget): PointerTarget => {
+    const target = pointerWidgetFor(widget);
+    const native = nativeClickFor(target, true);
+
+    return { widget: target, gestures: pointerGesturesFor(target, native), native };
+};
+
+const pressPointer = ({ widget, gestures }: PointerTarget): void => {
+    emitClickPhase(widget, gestures, 1, "pressed");
+};
+
+const releasePointer = ({ widget, gestures, native }: PointerTarget): void => {
+    emitClickPhase(widget, gestures, 1, "released");
+    native?.(widget, 1);
+};
+
+const isPointerPressable = (target: PointerTarget): boolean => target.native !== null || target.gestures.length > 0;
+
 const applyPointerInput = (widget: Gtk.Widget, state: UserEventState, input: PointerInput): void => {
-    const controllers = getOrCreateControllers(widget, Gtk.GestureClick);
+    const target = pointerTargetFor(widget);
 
     if (CLICK_INPUTS.has(input)) {
-        emitPress(widget, controllers, 1);
-        emitRelease(widget, controllers, 1);
+        pressPointer(target);
+        releasePointer(target);
         state.isMouseLeftDown = false;
 
         return;
     }
 
-    if (PRESS_INPUTS.has(input) && !state.isMouseLeftDown) {
-        emitPress(widget, controllers, 1);
+    if (PRESS_INPUTS.has(input) && !state.isMouseLeftDown && isPointerPressable(target)) {
+        pressPointer(target);
         state.isMouseLeftDown = true;
 
         return;
     }
 
     if (RELEASE_INPUTS.has(input) && state.isMouseLeftDown) {
-        emitRelease(widget, controllers, 1);
+        releasePointer(target);
         state.isMouseLeftDown = false;
     }
 };