@gtkx/testing 1.0.0 → 1.2.0

package/src/user-event/event-wrapper.ts

@@ -2,35 +2,38 @@ import * as Gtk from "@gtkx/gi/gtk";
 import { runInAct } from "../act.js";
 import { getConfig } from "../config.js";
 import { formatRole } from "../role-helpers.js";
+import { delay, now } from "../timers.js";
+import { getWidgetAccessibleName } from "../widget-accessible-properties.js";
+import { getTypeTag, isDefaultWidgetName } from "../widget-getters.js";
+import { isWindowAllocated, isWindowBlockedByModal } from "../window-state.js";
 
 const NOT_SENSITIVE = "it is not sensitive (the widget or one of its ancestors is disabled)";
+const NOT_ROOTED = "it is not inside a toplevel (it was removed from the widget tree, or was never added to one)";
+const WINDOW_NOT_VISIBLE = "its window is not visible (it was hidden, or it was never shown)";
 const WINDOW_NOT_ALLOCATED = "its window has not been allocated a size";
 const NOT_MAPPED = "it is not mapped (it is not shown on screen, e.g. it is hidden or on a non-visible page)";
-const WINDOW_NOT_ACTIVE = "its window never became active";
+const BLOCKED_BY_MODAL = "its window is blocked by a modal window holding the grab";
+const ACTIONABLE_HOP_MS = 1;
 
-const actionableHop = (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 1));
-
-const canDisplayDeliverActivation = (window: Gtk.Window): boolean =>
-    window.getDisplay().getDefaultSeat() !== null;
-
-const findWindowActionabilityFailure = (widget: Gtk.Widget, root: Gtk.Window): string | null => {
-    const [isComputed, allocation] = root.computeBounds(root);
-
-    if (!isComputed || allocation.getWidth() === 0) {
-        return WINDOW_NOT_ALLOCATED;
+const findWindowActionabilityFailure = (window: Gtk.Window): string | null => {
+    if (!window.getVisible()) {
+        return WINDOW_NOT_VISIBLE;
     }
 
-    if (!widget.getMapped()) {
-        return NOT_MAPPED;
+    if (!isWindowAllocated(window)) {
+        return WINDOW_NOT_ALLOCATED;
     }
 
-    if (canDisplayDeliverActivation(root) && !root.isActive()) {
-        return WINDOW_NOT_ACTIVE;
+    if (isWindowBlockedByModal(window)) {
+        return BLOCKED_BY_MODAL;
     }
 
     return null;
 };
 
+const findRootActionabilityFailure = (root: Gtk.Root): string | null =>
+    root instanceof Gtk.Window ? findWindowActionabilityFailure(root) : null;
+
 const findActionabilityFailure = (widget: Gtk.Widget): string | null => {
     if (!widget.isSensitive()) {
         return NOT_SENSITIVE;
@@ -38,28 +41,41 @@ const findActionabilityFailure = (widget: Gtk.Widget): string | null => {
 
     const root = widget.getRoot();
 
-    if (!(root instanceof Gtk.Window) || !root.getVisible()) {
-        return null;
+    if (root === null) {
+        return NOT_ROOTED;
     }
 
-    return findWindowActionabilityFailure(widget, root);
+    const rootFailure = findRootActionabilityFailure(root);
+
+    if (rootFailure !== null) {
+        return rootFailure;
+    }
+
+    return widget.getMapped() ? null : NOT_MAPPED;
 };
 
-const describeWidget = (widget: Gtk.Widget): string => {
-    const tag = widget.constructor.name;
+const attribute = (key: string, value: string | null): string => (value === null ? "" : ` ${key}="${value}"`);
+
+const widgetNameAttribute = (widget: Gtk.Widget): string => {
     const name = widget.getName();
-    const nameAttribute = name && !name.endsWith(tag) ? ` name="${name}"` : "";
 
-    return `<${tag}${nameAttribute} role="${formatRole(widget.getAccessibleRole())}">`;
+    return attribute("name", isDefaultWidgetName(widget, name) ? null : name);
+};
+
+const describeWidget = (widget: Gtk.Widget): string => {
+    const accessibleName = attribute("accessible-name", getWidgetAccessibleName(widget));
+    const role = attribute("role", formatRole(widget.getAccessibleRole()));
+
+    return `<${getTypeTag(widget)}${accessibleName}${widgetNameAttribute(widget)}${role}>`;
 };
 
 const waitForActionable = async (widget: Gtk.Widget): Promise<void> => {
     const timeout = getConfig().actionabilityTimeout;
-    const deadline = Date.now() + timeout;
+    const deadline = now() + timeout;
     let failure = findActionabilityFailure(widget);
 
-    while (failure !== null && Date.now() < deadline) {
-        await actionableHop();
+    while (failure !== null && now() < deadline) {
+        await delay(ACTIONABLE_HOP_MS);
         failure = findActionabilityFailure(widget);
     }
 

package/src/user-event/index.ts

@@ -1,4 +1,5 @@
 import type * as Gtk from "@gtkx/gi/gtk";
+import { delay } from "../timers.js";
 import { scroll, slide } from "./adjustment.js";
 import { click, dblClick, tripleClick } from "./click.js";
 import { drag, dragAndDrop, drop, hover, longPress, rotate, swipe, unhover, zoom } from "./gesture.js";
@@ -34,10 +35,11 @@ type UserEvent = {
      * itself, where the gestures that widget carries of its own still take the press and the same
      * outcome is then applied through GTK's own public action: a list, grid, or column-view row is
      * focused and selected, and activated as well when its view activates on a single click; an
-     * expandable tree expander that is itself the clicked widget toggles its expansion; a column
-     * header sorts by its column. A column-view cell and the row carrying the column headers stand
-     * in the way of the click rather than taking it, so a click on either reaches the row or the
-     * view behind it.
+     * expandable tree expander that is itself the clicked widget toggles its expansion; a notebook
+     * tab, clicked directly or through its label, focuses its notebook and switches to its page; a
+     * column header sorts by its column. A column-view cell and the row carrying the column headers
+     * stand in the way of the click rather than taking it, so a click on either reaches the row or
+     * the view behind it.
      */
     click: typeof click;
     /**
@@ -45,19 +47,23 @@ type UserEvent = {
      * activation first, activating a list box row or flow box child on that path and replacing its
      * container's selection whether or not that container activates on a single click. A widget
      * whose click GTK4 implements itself receives that outcome once per press, so a row is selected
-     * and activated by the second press, a tree expander ends back where it started, and a column
-     * header inverts its order after sorting.
+     * and activated by the second press, a tree expander ends back where it started, a notebook tab
+     * stays on the page the first press opened, and a column header inverts its order after sorting.
      */
     dblClick: typeof dblClick;
     /**
      * Delivers a three-press click gesture the same way a double click is delivered, applying the
      * same outcome to a list box row or flow box child, and applying the outcome GTK4 implements
-     * itself once per press to a row, tree expander, or column header.
+     * itself once per press to a row, tree expander, notebook tab, or column header.
      */
     tripleClick: typeof tripleClick;
     /** Moves focus within the widget's root, forward by default and backward with `isShiftHeld`. */
     tab: typeof tab;
-    /** Focuses an editable widget, applies any initial selection, and inserts the text at the cursor. */
+    /**
+     * Focuses an editable widget the way clicking into it does, leaving its text unselected, applies
+     * any initial selection, and inserts the text at the cursor, deleting the text the widget has
+     * selected first, the way GTK4 does.
+     */
     type: typeof type;
     /** Focuses an editable widget and deletes its whole text, leaving nothing selected. */
     clear: typeof clear;
@@ -65,7 +71,10 @@ type UserEvent = {
     copy: typeof copy;
     /** Writes an editable widget's current selection to the clipboard and deletes it. */
     cut: typeof cut;
-    /** Inserts the given text, or the clipboard's text, at an editable widget's cursor. */
+    /**
+     * Inserts the given text, or the clipboard's text, at an editable widget's cursor, deleting the
+     * text the widget has selected first, the way GTK4 does.
+     */
     paste: typeof paste;
     /**
      * Selects the items at those positions in a view or drop-down, or selects the indexed children of
@@ -96,7 +105,25 @@ type UserEvent = {
     slide: typeof slide;
     /** Adds the delta to the adjustments of the widget itself, or of its nearest scrollable ancestor. */
     scroll: typeof scroll;
-    /** Sends a key sequence, dispatching matching shortcuts and tracking held modifiers across calls. */
+    /**
+     * Sends a key sequence along the chain GTK4 propagates a key event through: the application's
+     * accelerators first, then the capture-phase controllers from the root down to the event widget,
+     * the event widget's target-phase controllers, and the bubble-phase controllers from it back up
+     * to the root, so a key controller or shortcut controller a container or window above the widget
+     * carries receives the key too, each in the phase it declares. The event widget is the editable
+     * delegate GTK4 focuses when the widget has one, the `Gtk.Text` inside a `Gtk.Entry` for
+     * instance, so the delegate stands ahead of the widget in the chain. A shortcut controller whose
+     * scope is not local runs where it registered instead, the root for a global one and the nearest
+     * `Gtk.ShortcutManager` for a managed one, so it fires wherever focus sits inside that subtree
+     * and never at its own widget, while a shortcut whose widget is insensitive or unmapped stays
+     * inert wherever it sits. The first controller that handles a press ends the chain, and a
+     * `Gdk.KEY_Return` press none of them handled reaches an editable widget's activate handler.
+     * Built-in key bindings take part, since GTK4 carries them on a shortcut controller: a
+     * `Gtk.Text`'s arrow keys or a `Gtk.TextView`'s undo can consume a press before an ancestor
+     * sees it. Key controllers GTK4 attaches itself are the exception, since they read a GDK event
+     * that off-screen synthesis cannot produce, so only the key controllers the tree connected a
+     * `key-pressed` or `key-released` handler to take part. Held modifiers carry across calls.
+     */
     keyboard: (widget: Gtk.Widget, input: string) => Promise<void>;
     /**
      * Applies a pointer token to the click gestures the widget already carries, tracking whether the
@@ -117,12 +144,12 @@ const userEvent: UserEvent = {
     setup: (options?: UserEventOptions): UserEvent => createInstance(createInitialState(), options ?? {}),
 };
 
-const settle = (delay: number | null | undefined): Promise<void> => {
-    if (delay === null || delay === undefined) {
+const settle = (ms: number | null | undefined): Promise<void> => {
+    if (ms === null || ms === undefined) {
         return Promise.resolve();
     }
 
-    return new Promise((resolve) => setTimeout(resolve, delay));
+    return delay(ms);
 };
 
 function createInstance(state: UserEventState, options: UserEventOptions): UserEvent {

package/src/user-event/keyboard.ts

@@ -1,10 +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`. */
@@ -15,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,
@@ -49,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,
@@ -180,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,
@@ -190,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 = (
@@ -222,23 +276,6 @@ const didActivateMatchingShortcut = (
     return false;
 };
 
-const didDispatchShortcutsOnWidget = (widget: Gtk.Widget, keyval: number, modifiers: number): boolean => {
-    const controllers = widget.observeControllers();
-
-    for (let i = 0; i < controllers.getNItems(); i++) {
-        const controller = controllers.getItem(i);
-
-        if (
-            controller instanceof Gtk.ShortcutController &&
-            didActivateMatchingShortcut(controller, widget, keyval, modifiers)
-        ) {
-            return true;
-        }
-    }
-
-    return false;
-};
-
 const isAccelMatch = (accel: string, keyval: number, modifiers: Gdk.ModifierType): boolean => {
     const [isParsed, accelKeyval, accelModifiers] = Gtk.acceleratorParse(accel);
 
@@ -281,59 +318,92 @@ const didDispatchApplicationAccels = (widget: Gtk.Widget, keyval: number, modifi
     return root instanceof Gtk.Window && didDispatchAccelsOnWindow(root, keyval, modifiers);
 };
 
-const didDispatchDelegateShortcuts = (widget: Gtk.Widget, keyval: number, modifiers: number): boolean => {
-    const delegate = getEditableDelegate(widget);
+const isKeyStopController = (controller: Gtk.EventController): controller is KeyStopController => {
+    if (controller instanceof Gtk.ShortcutController) {
+        return controller.getScope() === Gtk.ShortcutScope.LOCAL;
+    }
 
-    return delegate !== null && didDispatchShortcutsOnWidget(delegate, keyval, modifiers);
+    return controller instanceof Gtk.EventControllerKey && hasSignalListener(controller, KEY_CONTROLLER_SIGNALS);
 };
 
-const didDispatchShortcutsOnAncestors = (widget: Gtk.Widget, keyval: number, modifiers: number): boolean => {
-    for (let current: Gtk.Widget | null = widget; current; current = current.getParent()) {
-        if (didDispatchShortcutsOnWidget(current, keyval, modifiers)) {
-            return true;
+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 propagationChain = (widget: Gtk.Widget): Gtk.Widget[] => {
+    const delegate = getEditableDelegate(widget);
+    const below = delegate === null ? [] : [delegate];
+
+    return [...below, widget, ...ancestors(widget)];
 };
 
-const didDispatchShortcuts = (widget: Gtk.Widget, keyval: number, modifiers: number): boolean =>
+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 didHandlePress = (widget: Gtk.Widget, keyval: number, modifiers: Gdk.ModifierType): boolean =>
     didDispatchApplicationAccels(widget, keyval, modifiers) ||
-    didDispatchDelegateShortcuts(widget, keyval, modifiers) ||
-    didDispatchShortcutsOnAncestors(widget, keyval, modifiers);
+    keyPropagationChain(widget).some((stop) => didStopHandlePress(stop, keyval, modifiers));
 
-const handleKeyPress = async (widget: Gtk.Widget, keyval: number, modifiers: number): Promise<void> => {
-    const isHandled = didDispatchShortcuts(widget, keyval, modifiers);
+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);
+        }
+    }
+};
 
-    if (!isHandled && keyval === Gdk.KEY_Return && widget instanceof Gtk.Editable) {
+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,
-    controllers: Gtk.EventControllerKey[],
-    state: UserEventState,
-    action: KeyAction,
-): Promise<void> => {
+const applyKeyAction = async (widget: Gtk.Widget, state: UserEventState, action: KeyAction): Promise<void> => {
     updateModifierState(state, action);
-    const signalName = action.isPress ? "key-pressed" : "key-released";
-
-    for (const controller of controllers) {
-        controller.emit(signalName, action.keyval, 0, state.modifierState);
-    }
 
     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

@@ -1,5 +1,6 @@
 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";
@@ -7,14 +8,10 @@ const SINGLE_CLICK_ACTIVATE_GETTER = "getSingleClickActivate";
 const DOUBLE_CLICK_PRESS = 2;
 
 const viewFor = (row: Gtk.Widget): Gtk.Widget | null => {
-    let current: Gtk.Widget | null = row.getParent();
-
-    while (current !== null) {
-        if (hasWidgetMethod(current, SINGLE_CLICK_ACTIVATE_GETTER)) {
-            return current;
+    for (const ancestor of ancestors(row)) {
+        if (hasWidgetMethod(ancestor, SINGLE_CLICK_ACTIVATE_GETTER)) {
+            return ancestor;
         }
-
-        current = current.getParent();
     }
 
     return null;

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

@@ -2,6 +2,7 @@ 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;
 
@@ -40,6 +41,10 @@ const nativeClickFor = (widget: Gtk.Widget, isClicked: boolean): NativeClick | n
         return applyHeaderClick;
     }
 
+    if (isNotebookTab(widget)) {
+        return applyTabClick;
+    }
+
     return isFactoryRow(widget) ? applyRowClick : null;
 };
 

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 };