# SPDX-License-Identifier: FSL-1.1-MIT # Copyright (c) 2026 Cua AI, Inc. """BenchLab for Windows: the seven Bench v2 BenchLab modes with native Win32 controls (wxPython). A port of linux/benchlab.py. Seeds, parameters, the state file and the event log are the same on every OS (probes/_common/benchlab_common.py), so the task checkers run unchanged. Controls are native (Button, Edit, ComboBox, CheckBox, SysListView32, tooltips_class32), so UI Automation exposes real elements. Windows-specific behaviour, kept close to the Linux port: * Dialogs are owned by the BenchLab window, which is disabled while one is open (modal). When BenchLab is not the foreground window, a dialog is shown without activation and stays just above BenchLab in the z-order, as the Linux port's dialogs do (set_focus_on_map False), so the app never raises itself over another window. * Field values are also polled every 250 ms: UI Automation can change a combo box with CB_SETCURSEL, which sends no notification, and the state file must still follow the control. * MB-09: rows reorder by a native list drag (LVN_BEGINDRAG, then the button release over a row). * MB-11: a tooltip counts as shown when BenchLab's own tooltip window is visible (polled every 100 ms). """ from __future__ import annotations import argparse import ctypes import json import os import sys import time from ctypes import wintypes from pathlib import Path import wx sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "probes" / "_common")) import benchlab_common as C # noqa: E402 MODES = ("listdrag", "hover", "tooltip", "irmodal", "irbanner", "irunsaved", "irconsent") ROW_HEIGHT = 40 user32 = ctypes.WinDLL("user32", use_last_error=True) user32.GetForegroundWindow.restype = wintypes.HWND user32.GetWindow.restype = wintypes.HWND user32.GetWindow.argtypes = [wintypes.HWND, wintypes.UINT] user32.SetWindowPos.argtypes = [ wintypes.HWND, wintypes.HWND, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int, wintypes.UINT ] # fmt: skip user32.EnableWindow.argtypes = [wintypes.HWND, wintypes.BOOL] user32.IsWindowVisible.argtypes = [wintypes.HWND] user32.GetClassNameW.argtypes = [wintypes.HWND, wintypes.LPWSTR, ctypes.c_int] user32.GetWindowTextW.argtypes = [wintypes.HWND, wintypes.LPWSTR, ctypes.c_int] WNDENUMPROC = ctypes.WINFUNCTYPE(wintypes.BOOL, wintypes.HWND, wintypes.LPARAM) user32.EnumThreadWindows.argtypes = [wintypes.DWORD, WNDENUMPROC, wintypes.LPARAM] kernel32 = ctypes.WinDLL("kernel32") GW_HWNDPREV = 3 HWND_TOP = 0 SWP_NOSIZE, SWP_NOMOVE, SWP_NOACTIVATE = 0x1, 0x2, 0x10 def _text(hwnd: int, getter) -> str: buf = ctypes.create_unicode_buffer(256) getter(hwnd, buf, 256) return buf.value def visible_tooltips() -> list[str]: """Texts of the visible tooltip windows of this (the UI) thread.""" found: list[str] = [] def each(hwnd, _): if _text(hwnd, user32.GetClassNameW) == "tooltips_class32" and user32.IsWindowVisible(hwnd): found.append(_text(hwnd, user32.GetWindowTextW)) return True user32.EnumThreadWindows(kernel32.GetCurrentThreadId(), WNDENUMPROC(each), 0) return found class Lab: def __init__(self, args: argparse.Namespace) -> None: self.args = args self.state = {"mode": args.mode, "seed": args.seed, "seq": 0} self.params = getattr(C, "derive_" + args.mode)(args.seed) self.fields: dict[str, wx.Window] = {} self.last_values: dict = {} self.loading = False self.dialog_open: wx.Dialog | None = None args.events.parent.mkdir(parents=True, exist_ok=True) self.events = args.events.open("w", buffering=1, encoding="utf-8") self.frame = wx.Frame(None, title=f"BenchLab — {args.mode}", size=(760, 540)) self.frame.SetName("BenchLab") if args.frame: x, y, w, h = map(int, args.frame.split(",")) self.frame.SetPosition((x, y)) self.frame.SetSize((w, h)) self.panel = wx.Panel(self.frame) self.box = wx.BoxSizer(wx.VERTICAL) outer = wx.BoxSizer(wx.VERTICAL) outer.Add(self.box, 1, wx.EXPAND | wx.ALL, 24) self.panel.SetSizer(outer) self.hidden: list[wx.Window] = [] getattr(self, args.mode)() self.panel.Layout() if args.no_activate: self.frame.ShowWithoutActivating() else: self.frame.Show() for widget in self.hidden: widget.Hide() self.panel.Layout() self.last_values = self.values() self.poll = wx.Timer(self.frame) self.frame.Bind(wx.EVT_TIMER, lambda _: self.poll_values(), self.poll) self.poll.Start(250) self.emit("app_start", mode=args.mode, seed=args.seed) # ------------------------------------------------------------------ plumbing def emit(self, event: str, **details: object) -> None: self.state["seq"] += 1 record = { "seq": self.state["seq"], "t": time.time() * 1000, "type": event, "details": details, } self.events.write(json.dumps(record) + "\n") self.args.state.parent.mkdir(parents=True, exist_ok=True) tmp = self.args.state.with_suffix(".tmp") tmp.write_text(json.dumps(self.state), encoding="utf-8") os.replace(tmp, self.args.state) def label(self, text: str, parent: wx.Window | None = None, sizer: wx.Sizer | None = None): label = wx.StaticText(parent or self.panel, label=text) (sizer or self.box).Add(label, 0, wx.BOTTOM, 4) return label def button(self, text: str, callback, parent=None, sizer=None) -> wx.Button: button = wx.Button(parent or self.panel, label=text) button.Bind(wx.EVT_BUTTON, lambda _: callback()) (sizer or self.box).Add(button, 0, wx.TOP | wx.BOTTOM | wx.RIGHT, 4) return button def field(self, name: str, choices: list[str] | None = None, value: str = ""): # The label comes first so UI Automation names the control after it. caption = self.label(name.capitalize()) if choices: widget = wx.Choice(self.panel, choices=choices, name=name.capitalize()) widget.SetSelection(choices.index(value) if value in choices else 0) widget.Bind(wx.EVT_CHOICE, lambda _: self.edit(name)) else: widget = wx.TextCtrl(self.panel, value=value, name=name.capitalize()) widget.Bind(wx.EVT_TEXT, lambda _: self.edit(name)) widget.caption = caption self.fields[name] = widget self.box.Add(widget, 0, wx.EXPAND | wx.BOTTOM, 8) return widget def values(self) -> dict: out = {} for key, widget in self.fields.items(): if isinstance(widget, wx.Choice): out[key] = widget.GetStringSelection() elif isinstance(widget, wx.CheckBox): out[key] = widget.GetValue() else: out[key] = widget.GetValue() return out def poll_values(self) -> None: if self.loading or not self.fields: return now = self.values() for name in self.fields: if now.get(name) != self.last_values.get(name): self.edit(name) def edit(self, name: str) -> None: if self.loading: return values = self.values() if values.get(name) == self.last_values.get(name): return # the poll and the control's own notification report one change once self.last_values = values self.state["fields"] = values if self.args.mode == "irunsaved": self.state["dirty"] = True self.emit("field_edit", field=name, value=values[name]) if self.args.mode == "irbanner" and not self.state["banner_shown"]: self.state["banner_shown"] = True wx.CallLater(200, self.show_banner) if self.args.mode == "irconsent" and not self.state["consent_shown"]: self.state["consent_shown"] = True wx.CallLater(250, self.show_consent) def set_loaded(self, name: str, value) -> None: widget = self.fields[name] if isinstance(widget, wx.Choice): widget.SetStringSelection(value) else: widget.ChangeValue(value) def dialog(self, title: str, buttons: list[tuple[str, str]], callback) -> None: dialog = wx.Dialog(self.frame, title=title, style=wx.CAPTION | wx.SYSTEM_MENU) sizer = wx.BoxSizer(wx.VERTICAL) sizer.Add(wx.StaticText(dialog, label=title), 0, wx.ALL, 24) row = wx.BoxSizer(wx.HORIZONTAL) for text, answer in buttons: b = wx.Button(dialog, label=text) b.Bind(wx.EVT_BUTTON, lambda _, a=answer: self.dialog_answer(dialog, callback, a)) row.Add(b, 0, wx.ALL, 6) sizer.Add(row, 0, wx.ALIGN_RIGHT | wx.ALL, 12) dialog.SetSizerAndFit(sizer) # A close from the title bar or Esc is not an answer; keep the dialog until a button is used. dialog.Bind(wx.EVT_CLOSE, lambda e: e.Veto() if e.CanVeto() else None) dialog.Bind( wx.EVT_CHAR_HOOK, lambda e: None if e.GetKeyCode() == wx.WXK_ESCAPE else e.Skip() ) dialog.CentreOnParent() self.dialog_open = dialog frame = self.frame.GetHandle() user32.EnableWindow(frame, False) if user32.GetForegroundWindow() == frame: dialog.Show() else: dialog.ShowWithoutActivating() above = user32.GetWindow(frame, GW_HWNDPREV) or HWND_TOP user32.SetWindowPos( dialog.GetHandle(), above, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE ) def dialog_answer(self, dialog: wx.Dialog, callback, answer: str) -> None: user32.EnableWindow(self.frame.GetHandle(), True) self.dialog_open = None dialog.Destroy() callback(answer) # ------------------------------------------------------------------ MB-09 listdrag def listdrag(self) -> None: self.state.update( order=list(self.params["initial"]), move_count=0, drag_begins=0, done=False, done_count=0, ) self.label("Drag the rows to reorder them, then press Done") self.rows = wx.ListCtrl( self.panel, style=wx.LC_REPORT | wx.LC_SINGLE_SEL | wx.LC_NO_HEADER, name="Tasks" ) self.rows.InsertColumn(0, "Task", width=640) spacer = wx.ImageList(1, ROW_HEIGHT) # sets the row height self.rows.AssignImageList(spacer, wx.IMAGE_LIST_SMALL) self.box.Add(self.rows, 1, wx.EXPAND | wx.BOTTOM, 8) self.drag_item: str | None = None self.draw_rows() self.rows.Bind(wx.EVT_LIST_BEGIN_DRAG, self.drag_begin) self.rows.Bind(wx.EVT_LEFT_UP, self.drag_end) self.rows.Bind(wx.EVT_MOUSE_CAPTURE_LOST, lambda _: self.drag_cancel()) self.button("Done", self.list_done) def draw_rows(self) -> None: self.rows.DeleteAllItems() for index, item in enumerate(self.state["order"]): self.rows.InsertItem(index, item) def drag_begin(self, event: wx.ListEvent) -> None: item = self.state["order"][event.GetIndex()] self.drag_item = item self.state["drag_begins"] += 1 self.emit("drag_begin", item=item) if not self.rows.HasCapture(): self.rows.CaptureMouse() def drag_cancel(self) -> None: self.drag_item = None def drag_end(self, event: wx.MouseEvent) -> None: event.Skip() item = self.drag_item if self.rows.HasCapture(): self.rows.ReleaseMouse() self.drag_item = None if item is None or item not in self.state["order"]: return pos = event.GetPosition() width, height = self.rows.GetClientSize() if not (0 <= pos.x < width and 0 <= pos.y < height): return # released outside the list: no drop index, _ = self.rows.HitTest(pos) if index == wx.NOT_FOUND: index = ( len(self.state["order"]) - 1 ) # the empty area below the rows belongs to the last row order = self.state["order"] source = order.index(item) order.pop(source) order.insert(index, item) self.state["move_count"] += 1 self.emit("reorder", **{"from": source, "to": index, "item": item, "order": list(order)}) wx.CallAfter(self.draw_rows) def list_done(self) -> None: self.state.update( done=True, done_count=self.state["done_count"] + 1, done_order=list(self.state["order"]) ) self.emit("done_click", order=self.state["done_order"]) # ------------------------------------------------------------------ MB-10 hover def hover(self) -> None: self.state.update( overlay_names=self.params["names"], clicks=[], hover_enter_count=0, hover_exit_count=0 ) zone = wx.Panel(self.panel, name="Hot zone", style=wx.BORDER_SIMPLE) content = wx.BoxSizer(wx.VERTICAL) self.label("Hover here to reveal actions", zone, content) actions_panel = wx.Panel(zone) actions = wx.BoxSizer(wx.HORIZONTAL) for name in self.params["names"]: self.button(name, lambda n=name: self.hover_click(n), actions_panel, actions) actions_panel.SetSizer(actions) content.Add(actions_panel, 0, wx.TOP, 10) wrap = wx.BoxSizer(wx.VERTICAL) wrap.Add(content, 1, wx.EXPAND | wx.ALL, 16) zone.SetSizer(wrap) self.box.Add(zone, 1, wx.EXPAND) self.zone, self.actions = zone, actions_panel self.hidden = [actions_panel] self.visible = False self.inside = False self.crossing = 0 for widget in [zone, *self._descendants(zone)]: widget.Bind(wx.EVT_ENTER_WINDOW, self.hover_enter) widget.Bind(wx.EVT_LEAVE_WINDOW, self.hover_leave) @staticmethod def _descendants(widget: wx.Window) -> list[wx.Window]: out = [] for child in widget.GetChildren(): out += [child, *Lab._descendants(child)] return out def hover_enter(self, event: wx.MouseEvent) -> None: event.Skip() # Moving between the zone and its own children is not a crossing (GTK's NotifyType.INFERIOR). self.crossing += 1 if not self.inside: self.hover_set(True) def hover_leave(self, event: wx.MouseEvent) -> None: event.Skip() token = self.crossing + 1 self.crossing = token wx.CallLater(40, lambda: self.crossing == token and self.inside and self.hover_set(False)) def hover_set(self, entered: bool) -> None: self.inside = entered self.state["hover_enter_count" if entered else "hover_exit_count"] += 1 self.emit("mouse", region="hot_zone", phase="mouseEntered" if entered else "mouseExited") self.visible = entered self.actions.Show(entered) self.zone.Layout() if entered: self.emit("overlay_shown") def hover_click(self, name: str) -> None: self.state["clicks"].append({"name": name}) self.state.update(last_clicked=name, last_click_overlay_visible=self.visible) self.emit("overlay_click", name=name, overlay_visible=self.visible) # ------------------------------------------------------------------ MB-11 tooltip def tooltip(self) -> None: self.state.update(submit_count=0, status="Ready") icons = wx.BoxSizer(wx.HORIZONTAL) self.box.Add(icons, 1, wx.EXPAND) self.tip_icon: str | None = None self.tip_shown = False self.tip_codes = dict(zip(self.params["codes"], self.params["order"])) for index, icon in enumerate(self.params["order"]): cell = wx.Panel(self.panel, size=(120, 80), name=icon) text = wx.StaticText(cell, label=icon, pos=(30, 30), name=icon) for widget in (cell, text): widget.SetToolTip(self.params["codes"][index]) widget.Bind( wx.EVT_ENTER_WINDOW, lambda e, i=icon: (setattr(self, "tip_icon", i), e.Skip()) ) icons.Add(cell, 1, wx.EXPAND | wx.ALL, 12) self.field("code") self.button("Submit", self.tooltip_submit) self.tip_timer = wx.Timer(self.frame) self.frame.Bind(wx.EVT_TIMER, lambda _: self.tooltip_poll(), self.tip_timer) self.tip_timer.Start(100) def tooltip_poll(self) -> None: shown = [t for t in visible_tooltips() if t] if shown and not self.tip_shown: icon = self.tip_codes.get(shown[0], self.tip_icon) if icon is not None: self.emit("tooltip_query", icon=icon) self.tip_shown = bool(shown) def tooltip_submit(self) -> None: value = self.values()["code"] self.state.update( submit_count=self.state["submit_count"] + 1, status="Submitted", submitted_value=value ) self.emit("submit", value=value) # ------------------------------------------------------------------ IR-01 irmodal def irmodal(self) -> None: self.state.update( prompt_answers=[], submit_count=0, page=1, prompt_state="not_shown", next_count=0 ) self.field("name") self.field("email") self.step1 = [ w for f in ("name", "email") for w in (self.fields[f].caption, self.fields[f]) ] self.field("team", C.IR_TEAMS) self.field("seats") self.step2 = [ w for f in ("team", "seats") for w in (self.fields[f].caption, self.fields[f]) ] self.hidden = list(self.step2) self.submit_button = self.button("Next", self.permission) self.state["fields"] = self.values() def permission(self) -> None: self.state["next_count"] += 1 self.emit("next", count=self.state["next_count"], values=self.values()) self.state["prompt_state"] = "open" self.emit("permission_prompt_shown", resource=self.params["resource"]) self.dialog( f"Allow BenchLab to access {self.params['resource']}?", [("Don’t Allow", "deny"), ("Allow", "allow")], self.permission_answer, ) def permission_answer(self, answer: str) -> None: self.state["prompt_answers"].append(answer) self.state.update(page=2, prompt_state="denied" if answer == "deny" else "allowed") self.emit("permission_answer", answer=answer, resource=self.params["resource"]) for widget in self.step1: widget.Hide() for widget in self.step2: widget.Show() self.submit_button.Destroy() self.button("Submit", self.form_submit) self.panel.Layout() def form_submit(self) -> None: values = self.values() self.state.update(submit_count=self.state["submit_count"] + 1, submitted=values) self.emit("submit", values=values) # ------------------------------------------------------------------ IR-02 irbanner def irbanner(self) -> None: self.state.update( banner_shown=False, banner_actions=[], banner_body_clicks=0, apply_count=0 ) self.label(self.params["item"]) self.field("quantity", value="1") self.field("priority", C.PRIORITIES) self.apply_button = self.button("Apply", self.apply) # The banner is a sibling drawn over the Apply button (Gtk.Overlay in the Linux port). self.banner = wx.Panel(self.panel, name="Notification", style=wx.BORDER_SIMPLE) self.banner.SetBackgroundColour(wx.Colour(255, 244, 200)) row = wx.BoxSizer(wx.HORIZONTAL) text = wx.StaticText(self.banner, label="Update available") row.Add(text, 0, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 8) for label, action in ( ("Restart Now", "restart"), ("Later", "later"), ("Dismiss", "dismiss"), ): self.button(label, lambda a=action: self.banner_action(a), self.banner, row) self.banner.SetSizerAndFit(row) for widget in (self.banner, text): widget.Bind(wx.EVT_LEFT_DOWN, self.banner_body_click) self.hidden = [self.banner] self.state["fields"] = self.values() def place_banner(self) -> None: x, y = self.apply_button.GetPosition() self.banner.SetPosition((max(0, x - 8), max(0, y - 8))) self.banner.Raise() def banner_body_click(self, event: wx.MouseEvent) -> None: event.Skip() self.state["banner_body_clicks"] += 1 self.emit("banner_body_click", count=self.state["banner_body_clicks"]) def show_banner(self) -> None: self.place_banner() self.banner.Show() self.emit("banner_shown") def banner_action(self, action: str) -> None: self.state["banner_actions"].append(action) if action == "restart": self.loading = True self.fields["quantity"].ChangeValue("1") self.fields["priority"].SetSelection(0) self.loading = False self.last_values = self.values() self.state["fields"] = self.last_values self.banner.Hide() self.emit("banner_action", action=action) def apply(self) -> None: self.state["apply_count"] += 1 self.emit("apply", values=self.values()) # ------------------------------------------------------------------ IR-03 irunsaved def irunsaved(self) -> None: self.state.update( saved=[ {"title": t, "status": C.IR_INITIAL_STATUS, "body": f"Working notes for {t}."} for t in self.params["titles"] ], dirty=False, answers=[], done_count=0, ) self.selected = 0 for index, title in enumerate(self.params["titles"]): self.button(title, lambda i=index: self.navigate(i)) self.field("title", value=self.state["saved"][0]["title"]) self.field("status", [C.IR_INITIAL_STATUS, *C.IR_STATUS_WORDS]) self.field("body", value=self.state["saved"][0]["body"]) self.button("Done", lambda: self.navigate(None)) def navigate(self, index: int | None) -> None: if self.state["dirty"]: self.emit("save_prompt_shown") self.dialog( "Save changes before leaving?", [("Save", "save"), ("Don’t Save", "dont_save"), ("Cancel", "cancel")], lambda answer: self.save_answer(answer, index), ) else: self.visit(index) def save_answer(self, answer: str, index: int | None) -> None: self.state["answers"].append(answer) self.emit("save_answer", answer=answer) if answer == "cancel": return if answer == "save": self.state["saved"][self.selected] = self.values() self.emit("save", index=self.selected, values=self.values()) else: self.emit("discard", index=self.selected) self.state["dirty"] = False self.visit(index) def visit(self, index: int | None) -> None: if index is None: self.state["done_count"] += 1 self.emit("done", clean=not self.state["dirty"]) else: self.selected = index self.loading = True for key, value in self.state["saved"][self.selected].items(): self.set_loaded(key, value) self.loading = False self.last_values = self.values() if index is not None: self.emit("note_selected", index=index) # ------------------------------------------------------------------ IR-04 irconsent def irconsent(self) -> None: self.state.update( consent_shown=False, consent_answers=[], submit_count=0, submits_blocked=0 ) self.field("email") self.field("plan", C.IR_PLANS) digest = wx.CheckBox(self.panel, label="Email digest", name="Email digest") self.fields["digest"] = digest digest.Bind(wx.EVT_CHECKBOX, lambda _: self.edit("digest")) self.box.Add(digest, 0, wx.BOTTOM, 8) self.button("Sign up", self.signup) def show_consent(self) -> None: self.emit("consent_shown") self.dialog( "Cookie preferences", [("Reject optional", "reject"), ("Accept all", "accept")], self.consent_answer, ) def consent_answer(self, answer: str) -> None: details = {"answer": answer, "analytics": answer == "accept", "ads": answer == "accept"} self.state["consent_answers"].append(details) self.emit("consent_answer", **details) def signup(self) -> None: if not self.state["consent_answers"]: self.state["submits_blocked"] += 1 self.emit("submit_blocked") return self.state["submit_count"] += 1 self.emit("submit", **self.values()) def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--mode", choices=MODES, required=True) parser.add_argument("--seed", type=int, required=True) parser.add_argument("--state", type=Path, required=True) parser.add_argument("--events", type=Path, required=True) parser.add_argument("--frame", help="x,y,width,height of the window") parser.add_argument( "--no-activate", action="store_true", help="show the window without activating it" ) args = parser.parse_args() ctypes.windll.shcore.SetProcessDpiAwareness(2) app = wx.App(False) app.SetAppName("BenchLab") lab = Lab(args) try: app.MainLoop() finally: lab.events.close() if __name__ == "__main__": main()