Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
fix(hud): keep the HUD's size while it is dragged at fractional scaling (#1004)
EtienneLescot1509e6f4ef77
diff --git a/electron/windows.test.ts b/electron/windows.test.tsnew file mode 100644index 000000000..de7e2d8e6--- /dev/null+++ b/electron/windows.test.ts@@ -0,0 +1,132 @@+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";++// Windows at 125 %, as in #1004: a 1920x1080 panel whose taskbar leaves a 1032px work area.+const WORK_AREA_BOTTOM_PX = 1032;+// The bar as LaunchWindow lays it out: centred, 20 CSS px above the window's bottom edge.+const BAR = { width: 560, height: 64, bottomInset: 20 };++const electron = vi.hoisted(() => {+ type Rect = { x: number; y: number; width: number; height: number };+ const scale = 1.25;+ // Chromium's DIP <-> pixel conversion on Windows (ui/display/win/screen_win.cc): the+ // origin is rounded, the size is ScaleToEnclosingRect's, i.e. the span rounded outwards.+ const enclosing = (start: number, size: number, factor: number) =>+ Math.ceil((start + size) * factor) - Math.floor(start * factor);+ const convert = (rect: Rect, factor: number): Rect => ({+ x: Math.round(rect.x * factor),+ y: Math.round(rect.y * factor),+ width: enclosing(rect.x, rect.width, factor),+ height: enclosing(rect.y, rect.height, factor),+ });++ /** A BrowserWindow as Electron drives one on Windows: only the pixel rect is real. */+ class FakeWindow {+ pixels: Rect;+ webContents = { on: vi.fn(), send: vi.fn() };+ setContentProtection = vi.fn();+ once = vi.fn();+ on = vi.fn();+ loadURL = vi.fn();+ loadFile = vi.fn();+ constructor(options: Rect) {+ this.pixels = convert(options, scale);+ }+ getBounds() {+ return convert(this.pixels, 1 / scale);+ }+ getPosition() {+ const { x, y } = this.getBounds();+ return [x, y];+ }+ setBounds(bounds: Rect) {+ this.pixels = convert(bounds, scale);+ }+ // Electron's own implementation (shell/browser/native_window.cc).+ setPosition(x: number, y: number) {+ const { width, height } = this.getBounds();+ this.setBounds({ x, y, width, height });+ }+ isDestroyed() {+ return false;+ }+ isMinimized() {+ return false;+ }+ }++ // 1920x1032 px of work area, enclosed in DIP the way Chromium reports it.+ const display = { workArea: { x: 0, y: 0, width: 1536, height: 826 } };+ const handlers = new Map<string, (event: unknown, ...args: unknown[]) => void>();+ return { scale, FakeWindow, display, handlers };+});++vi.mock("electron", () => ({+ app: {},+ BrowserWindow: electron.FakeWindow,+ ipcMain: {+ on: (channel: string, handler: (event: unknown, ...args: unknown[]) => void) =>+ electron.handlers.set(channel, handler),+ },+ screen: {+ getPrimaryDisplay: () => electron.display,+ getDisplayMatching: () => electron.display,+ on: vi.fn(),+ },+}));++const REAL_PLATFORM = process.platform;+let createHudOverlayWindow: typeof import("./windows").createHudOverlayWindow;++beforeAll(async () => {+ // windows.ts decides at import whether to clamp the bar or, on Linux, the whole window.+ Object.defineProperty(process, "platform", { value: "win32", configurable: true });+ ({ createHudOverlayWindow } = await import("./windows"));+});++afterAll(() => {+ Object.defineProperty(process, "platform", { value: REAL_PLATFORM, configurable: true });+});++const send = (channel: string, ...args: unknown[]) => electron.handlers.get(channel)?.({}, ...args);++/** A new HUD, sized by the renderer's first measurement: 944x705 DIP, 1180x882 px. */+function openHud() {+ const win = createHudOverlayWindow() as unknown as InstanceType<typeof electron.FakeWindow>;+ const size = { width: 944, height: 705 };+ send("hud-overlay-set-size", size.width, size.height, {+ x: (size.width - BAR.width) / 2,+ y: size.height - BAR.bottomInset - BAR.height,+ width: BAR.width,+ height: BAR.height,+ });+ return win;+}++/** A drag by the handle in small steps; the renderer sends the total travel each time. */+function drag(steps: number, stepX: number, stepY: number) {+ send("hud-overlay-drag-start");+ for (let i = 1; i <= steps; i++) {+ send("hud-overlay-drag-to", i * stepX, i * stepY);+ }+ send("hud-overlay-drag-end");+}++describe("HUD drag at 125 % scaling (#1004)", () => {+ it("keeps the window's size", () => {+ const win = openHud();+ const { width, height } = win.pixels;+ drag(40, 1.6, -2.4);+ // One DIP size lands on 1180 or 1181 px depending on where it starts: a pixel of+ // wobble, never growth.+ expect(Math.abs(win.pixels.width - width)).toBeLessThanOrEqual(1);+ expect(Math.abs(win.pixels.height - height)).toBeLessThanOrEqual(1);+ });++ it("keeps the bar above the taskbar after a long drag down", () => {+ const win = openHud();+ drag(40, 0.8, 40);+ const barBottom = win.pixels.y + win.pixels.height - BAR.bottomInset * electron.scale;+ // One row of slack: the work area Electron reports is enclosed in DIP (825.6 -> 826).+ expect(barBottom).toBeLessThanOrEqual(WORK_AREA_BOTTOM_PX + 1);+ });+});diff --git a/electron/windows.ts b/electron/windows.tsindex 72f2fe938..fafac9a46 100644--- a/electron/windows.ts+++ b/electron/windows.ts@@ -108,6 +108,22 @@ export const ASSET_BASE_URL_ARG = `--asset-base-url=${pathToFileURL(`${ASSET_BASlet hudOverlayWindow: BrowserWindow | null = null;+// The HUD's size in DIP, as last given: at creation, then by "hud-overlay-set-size".+// Every move re-applies this size, never one read back from the window, because the+// read-back drifts: on Windows, getBounds() converts the physical rect to DIP by+// enclosing it (rounding outwards) and setBounds() converts back the same way, so under+// fractional scaling each read-modify-write grows the window by a pixel or two. At 125 %+// a drag grew it on every step, sliding the bar off the pointer and under the taskbar+// (#1004). setPosition() is no way out: Electron implements it as setBounds() with the+// size from getBounds().+let hudWindowSize = { width: 0, height: 0 };++/** The HUD's position, with its own size instead of the drifting read-back. */+function hudBounds(win: BrowserWindow): Electron.Rectangle {+ const [x, y] = win.getPosition();+ return { x, y, ...hudWindowSize };+}+// Origin the current drag gesture started from. The renderer sends the pointer's// *total* travel since pointerdown rather than per-frame deltas, so every move is// an absolute `origin + delta` — no rounding to accumulate, and a dropped message@@ -139,7 +155,7 @@ function reclampHud() {const win = hudOverlayWindow;if (!win || win.isDestroyed() || win.isMinimized() || hudDragOrigin) return;- const bounds = win.getBounds();+ const bounds = hudBounds(win);const next = clampHudBoundsToWorkArea(bounds, hudContentRect, hudWorkAreaFor(bounds));if (!sameRect(next, bounds)) {win.setBounds(next, false);@@ -247,9 +263,10 @@ ipcMain.on("hud-overlay-drag-start", () => {// Under Wayland this origin is a lie: Electron documents getPosition() as returning// [0, 0] there, because the protocol prohibits a client from introspecting or// setting its own global coordinates. The origin+delta scheme below therefore- // resolves against 0 rather than the window's real position, and setPosition() is- // itself a no-op — so dragging cannot work on Wayland by this route at all. The- // finiteness check only keeps a garbage origin from reaching a native setter.+ // resolves against 0 rather than the window's real position, and the position+ // setBounds() asks for is ignored — so dragging cannot work on Wayland by this+ // route at all. The finiteness check only keeps a garbage origin from reaching a+ // native setter.const [x, y] = hudOverlayWindow.getPosition();hudDragOrigin = Number.isFinite(x) && Number.isFinite(y) ? { x, y } : null;});@@ -272,14 +289,14 @@ ipcMain.on("hud-overlay-drag-to", (_event, deltaX: number, deltaY: number) => {// the bar is transparent reserve (see hudWindowBounds.ts), and clamping the// window instead would hand the bar the reserve's width and ~600px of height as// a margin it can never cross — the "stuck at the bottom of the screen" trap.- const bounds = hudOverlayWindow.getBounds();+ const bounds = hudBounds(hudOverlayWindow);const destination = hudDragDestination({ bounds, origin: hudDragOrigin, deltaX, deltaY });const next = clampHudBoundsToWorkArea(destination, hudContentRect, hudWorkAreaFor(destination));- // Position only: a per-frame setBounds round-trips the size through DIP rounding,- // which can creep it a pixel at a time under fractional scaling.- hudOverlayWindow.setPosition(next.x, next.y, false);+ // setBounds with the HUD's own size, not setPosition, which re-applies the size read+ // back from the window and grows it every frame under fractional scaling.+ hudOverlayWindow.setBounds(next, false);});ipcMain.on("hud-overlay-drag-end", () => {@@ -316,7 +333,7 @@ ipcMain.on("hud-overlay-set-size", (_event, width: number, height: number, contereturn;}- const bounds = hudOverlayWindow.getBounds();+ const bounds = hudBounds(hudOverlayWindow);const nextContent = HUD_CLAMPS_CONTENT ? parseHudContentRect(content) : null;const next = hudResizeBounds({bounds,@@ -331,6 +348,7 @@ ipcMain.on("hud-overlay-set-size", (_event, width: number, height: number, conteif (nextContent) {hudContentRect = nextContent;}+ hudWindowSize = { width: next.width, height: next.height };if (!sameRect(next, bounds)) {hudOverlayWindow.setBounds(next, false);@@ -426,6 +444,7 @@ export function createHudOverlayWindow(): BrowserWindow {});hudOverlayWindow = win;+ hudWindowSize = { width: windowWidth, height: windowHeight };watchHudWorkAreaChanges();// Display changes while minimized were skipped; catch up on the way back.win.on("restore", reclampHud);