@gtkx/testing 2.0.0-beta.5 → 2.0.0-beta.7

package/src/user-event/click.ts

@@ -11,6 +11,7 @@ type PressPoint = { x: number; y: number };
 type ClickPhase = "pressed" | "released";
 type ClickSite = { gestures: Gtk.GestureClick[]; point: PressPoint };
 type ClickScope = { isClicked: boolean; isInternalAllowed: boolean };
+type DirectClick = { sites: ClickSite[]; outcome: NativeClick | null };
 
 type ClickTarget = {
     widget: Gtk.Widget;
@@ -59,15 +60,6 @@ const emitGesture = (
     }
 };
 
-const emitClickPhase = (
-    widget: Gtk.Widget,
-    controllers: Gtk.GestureClick[],
-    nPress: number,
-    phase: ClickPhase,
-): void => {
-    emitGesture(getCenterPoint(widget), controllers, nPress, phase);
-};
-
 const emitSitePhase = (sites: ClickSite[], nPress: number, phase: ClickPhase): void => {
     for (const site of sites) {
         emitGesture(site.point, site.gestures, nPress, phase);
@@ -97,14 +89,23 @@ const clickGestures = (widget: Gtk.Widget): Gtk.GestureClick[] =>
 const getAuthoredClickGestures = (widget: Gtk.Widget): Gtk.GestureClick[] =>
     clickGestures(widget).filter((gesture) => hasClickHandlers(gesture));
 
-const isClaimingTarget = (widget: Gtk.Widget): boolean =>
-    widget instanceof Gtk.Button || containerFor(widget) !== null;
-
 const gestureTargetFor = (widget: Gtk.Widget, isInternalAllowed: boolean): ClickTarget | null => {
     const gestures = clickGestures(widget);
 
-    if (isClaimingTarget(widget)) {
-        return { widget, container: containerFor(widget), gestures, isClaiming: true, native: null };
+    if (widget instanceof Gtk.Button) {
+        return { widget, container: null, gestures, isClaiming: true, native: null };
+    }
+
+    const container = containerFor(widget);
+
+    if (container !== null) {
+        return {
+            widget,
+            container,
+            gestures: gestures.filter((gesture) => hasClickHandlers(gesture)),
+            isClaiming: true,
+            native: null,
+        };
     }
 
     const authored = gestures.filter((gesture) => hasClickHandlers(gesture));
@@ -223,6 +224,24 @@ const applyClickOutcome = (target: ClickTarget, nPress: number): void => {
     target.native(target.widget, nPress);
 };
 
+const applyContainerClick: NativeClick = (widget, nPress) => {
+    const container = containerFor(widget);
+
+    if (container !== null) {
+        applyContainerOutcome({ widget, container, gestures: [], isClaiming: true, native: null }, nPress);
+    }
+};
+
+const directClickFor = (widget: Gtk.Widget): DirectClick => {
+    const native = nativeClickFor(widget, true);
+    const container = native === null ? containerFor(widget) : null;
+    const gestures =
+        native !== null || container !== null ? getAuthoredClickGestures(widget) : clickGestures(widget);
+    const target: ClickTarget = { widget, container, gestures, isClaiming: true, native };
+
+    return { sites: targetSites(widget, target), outcome: native ?? (container === null ? null : applyContainerClick) };
+};
+
 const applyClickOutcomes = (targets: ClickTarget[], nPress: number): void => {
     for (const target of targets) {
         applyClickOutcome(target, nPress);
@@ -266,4 +285,5 @@ const dblClick = (widget: Gtk.Widget): Promise<void> => deliverClick(widget, 2);
 /** Delivers a triple-click gesture. */
 const tripleClick = (widget: Gtk.Widget): Promise<void> => deliverClick(widget, 3);
 
-export { clickGestures, emitClickPhase, getAuthoredClickGestures, click, dblClick, tripleClick };
+export { directClickFor, emitSitePhase, click, dblClick, tripleClick };
+export type { DirectClick };

package/src/user-event/keyboard.ts

@@ -18,6 +18,7 @@ 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 };
+type KeyTarget = { root: Gtk.Root | null; focus: Gtk.Widget | null };
 
 const KEY_MAP: Record<string, number> = {
     Enter: Gdk.KEY_Return,
@@ -366,9 +367,37 @@ const didStopHandlePress = (stop: KeyStop, keyval: number, modifiers: Gdk.Modifi
     return controller.emit("key-pressed", keyval, 0, modifiers);
 };
 
-const didHandlePress = (widget: Gtk.Widget, keyval: number, modifiers: Gdk.ModifierType): boolean =>
-    didDispatchApplicationAccels(widget, keyval, modifiers) ||
-    keyPropagationChain(widget).some((stop) => didStopHandlePress(stop, keyval, modifiers));
+const keyTargetFor = (widget: Gtk.Widget): KeyTarget => {
+    const root = widget.getRoot();
+
+    return { root, focus: root instanceof Gtk.Window ? root.getFocus() : null };
+};
+
+const isKeyTargetInvalidated = (widget: Gtk.Widget, target: KeyTarget): boolean => {
+    const current = keyTargetFor(widget);
+
+    return current.root !== target.root || current.focus !== target.focus || !widget.getMapped();
+};
+
+const didHandlePress = (widget: Gtk.Widget, keyval: number, modifiers: Gdk.ModifierType): boolean => {
+    const target = keyTargetFor(widget);
+
+    if (didDispatchApplicationAccels(widget, keyval, modifiers)) {
+        return true;
+    }
+
+    if (isKeyTargetInvalidated(widget, target)) {
+        return true;
+    }
+
+    for (const stop of keyPropagationChain(widget)) {
+        if (didStopHandlePress(stop, keyval, modifiers) || isKeyTargetInvalidated(widget, target)) {
+            return true;
+        }
+    }
+
+    return false;
+};
 
 const emitKeyReleased = (widget: Gtk.Widget, keyval: number, modifiers: Gdk.ModifierType): void => {
     for (const stop of keyPropagationChain(widget)) {

package/src/user-event/pointer.ts

@@ -1,16 +1,15 @@
 import type * as Gtk from "@gtkx/gi/gtk";
-import type { NativeClick } from "./native-click.js";
 import type { UserEventState } from "./state.js";
-import { clickGestures, emitClickPhase, getAuthoredClickGestures } from "./click.js";
+import { type DirectClick, directClickFor, emitSitePhase } from "./click.js";
 import { wrapEvent } from "./event-wrapper.js";
-import { isClickTransparent, nativeClickFor } from "./native-click.js";
+import { isClickTransparent } 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 };
+type PointerTarget = { widget: Gtk.Widget; click: DirectClick };
 
 const PRESS_INPUTS: Set<PointerInput> = new Set(["[MouseLeft>]", "down"]);
 const RELEASE_INPUTS: Set<PointerInput> = new Set(["[/MouseLeft]", "up"]);
@@ -32,26 +31,23 @@ const pointerWidgetFor = (widget: Gtk.Widget): Gtk.Widget => {
     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 };
+    return { widget: target, click: directClickFor(target) };
 };
 
-const pressPointer = ({ widget, gestures }: PointerTarget): void => {
-    emitClickPhase(widget, gestures, 1, "pressed");
+const pressPointer = ({ click }: PointerTarget): void => {
+    emitSitePhase(click.sites, 1, "pressed");
 };
 
-const releasePointer = ({ widget, gestures, native }: PointerTarget): void => {
-    emitClickPhase(widget, gestures, 1, "released");
-    native?.(widget, 1);
+const releasePointer = ({ widget, click }: PointerTarget): void => {
+    emitSitePhase(click.sites, 1, "released");
+    click.outcome?.(widget, 1);
 };
 
-const isPointerPressable = (target: PointerTarget): boolean => target.native !== null || target.gestures.length > 0;
+const isPointerPressable = (target: PointerTarget): boolean =>
+    target.click.outcome !== null || target.click.sites.some((site) => site.gestures.length > 0);
 
 const applyPointerInput = (widget: Gtk.Widget, state: UserEventState, input: PointerInput): void => {
     const target = pointerTargetFor(widget);

package/src/widget-accessible-properties.ts

@@ -401,22 +401,22 @@ const isSelfLabelling = (widget: Gtk.Widget, targets: Gtk.Widget[]): boolean =>
     return targets.every((target) => own.has(target));
 };
 
-const getWidgetLabelledByText = (widget: Gtk.Widget): string | null => {
-    const targets = readAccessibleWidgets(widget, Gtk.AccessibleRelation.LABELLED_BY);
-
-    if (targets === null) {
-        return null;
-    }
-
+const labelledByText = (targets: Gtk.Widget[]): string | null => {
     const texts = collectAccessibleNames(targets);
 
     return texts.length > 0 ? texts.join(" ") : null;
 };
 
+const getWidgetLabelledByText = (widget: Gtk.Widget): string | null => {
+    const targets = readAccessibleWidgets(widget, Gtk.AccessibleRelation.LABELLED_BY);
+
+    return targets === null ? null : labelledByText(targets);
+};
+
 const getWidgetExternalLabelText = (widget: Gtk.Widget): string | null => {
     const targets = readAccessibleWidgets(widget, Gtk.AccessibleRelation.LABELLED_BY);
 
-    return targets === null || isSelfLabelling(widget, targets) ? null : getWidgetLabelledByText(widget);
+    return targets === null || isSelfLabelling(widget, targets) ? null : labelledByText(targets);
 };
 
 const isTooltipUsedAsName = (widget: Gtk.Widget): boolean =>
@@ -441,28 +441,40 @@ const getWidgetDescribedByText = (widget: Gtk.Widget): string | null => {
     return isTooltipUsedAsName(widget) ? null : callStringGetter(widget, "getTooltipText");
 };
 
+const isHiddenWithin = (widget: Gtk.Widget, hiddenWidgets: Map<Gtk.Widget, boolean>): boolean => {
+    const cached = hiddenWidgets.get(widget);
+
+    if (cached !== undefined) {
+        return cached;
+    }
+
+    const parent = widget.getParent();
+
+    const isHidden =
+        readAccessibleBoolean(widget, Gtk.AccessibleState.HIDDEN) === true ||
+        (parent !== null && isHiddenWithin(parent, hiddenWidgets));
+
+    hiddenWidgets.set(widget, isHidden);
+
+    return isHidden;
+};
+
+const buildInaccessibilityCheck = (): ((target: Gtk.Accessible) => boolean) => {
+    const hiddenWidgets: Map<Gtk.Widget, boolean> = new Map();
+
+    return (target) => isHiddenWithin(requireWidget(target), hiddenWidgets);
+};
+
 /**
  * Returns whether a widget is excluded from the accessibility tree, because it or one of its
  * ancestors is marked hidden.
  *
  * @param widget The widget to test.
  */
-const isInaccessible = (target: Gtk.Accessible): boolean => {
-    const widget = requireWidget(target);
-    let current: Gtk.Widget | null = widget;
-
-    while (current) {
-        if (readAccessibleBoolean(current, Gtk.AccessibleState.HIDDEN) === true) {
-            return true;
-        }
-
-        current = current.getParent();
-    }
-
-    return false;
-};
+const isInaccessible = (target: Gtk.Accessible): boolean => buildInaccessibilityCheck()(target);
 
 export {
+    buildInaccessibilityCheck,
     namingLabelText,
     getWidgetText,
     getWidgetTextContent,