Merge branch 'master' into fix/repaint-bounds-update

Author: notluquis

.github/workflows/publish.yml

@@ -34,7 +34,11 @@ jobs:
       matrix:
         cfg:
         - { platform: linux-64, platform_name: Linux x64,  os: ubuntu-latest, build_platform: linux-64, conda_platform: linux-64 }
-        - { platform: osx-64, platform_name: macOS x64, os: macos-latest, build_platform: osx-64, conda_platform: osx-64 }
+        # Native Intel runner: macos-latest is arm64, and packing the osx-64
+        # env there runs its x86_64 Python under Rosetta, which aborts conda
+        # pack intermittently (#1018). macos-26-intel is the newest x86_64
+        # image (GitHub offers no macos-latest-intel; -latest is arm64 only).
+        - { platform: osx-64, platform_name: macOS x64, os: macos-26-intel, build_platform: osx-64, conda_platform: osx-64 }
         - { platform: osx-arm64, platform_name: macOS arm64, os: macos-latest, build_platform: osx-64, conda_platform: osx-arm64 }
         - { platform: win-64, platform_name: Windows x64, os: windows-latest, build_platform: win-64, conda_platform: win-64 }
 

src/main/eventtypes.ts

@@ -96,6 +96,7 @@ export enum EventTypeRenderer {
   SetRunningServerList = 'set-running-server-list',
   SetTitle = 'set-title',
   SetActive = 'set-active',
+  SetMaximized = 'set-maximized',
   ShowServerStatus = 'show-server-status',
   ShowServerNotificationBadge = 'show-server-notification-badge',
   SetRecentSessionList = 'set-recent-session-list',

src/main/sessionwindow/sessionwindow.ts

@@ -177,6 +177,7 @@ export class SessionWindow implements IDisposable {
     });
     this._window.on('blur', () => {
       titleBarView.deactivate();
+      this._hideEnvSelectPopup();
     });
 
     titleBarView.load();
@@ -187,10 +188,16 @@ export class SessionWindow implements IDisposable {
     // this._labView freshly means an env switch that recreates the labView cannot
     // leave a stale, disposed webContents behind, nor accumulate a handler per switch.
     this._window.webContents.on('focus', () => {
-      this._labView?.view?.webContents?.focus();
+      const wc = this.contentView?.webContents;
+      if (wc && !wc.isDestroyed()) {
+        wc.focus();
+      }
     });
     this._titleBarView.view.webContents.on('focus', () => {
-      this._labView?.view?.webContents?.focus();
+      const wc = this.contentView?.webContents;
+      if (wc && !wc.isDestroyed()) {
+        wc.focus();
+      }
     });
 
     if (this._contentViewType === ContentViewType.Lab) {
@@ -235,12 +242,15 @@ export class SessionWindow implements IDisposable {
       this._resizeViewsDelayed();
     });
     this._window.on('maximize', () => {
+      this._titleBarView.setMaximized(this._window.isMaximized());
       this._resizeViewsDelayed();
     });
     this._window.on('unmaximize', () => {
+      this._titleBarView.setMaximized(this._window.isMaximized());
       this._resizeViewsDelayed();
     });
     this._window.on('restore', () => {
+      this._titleBarView.setMaximized(this._window.isMaximized());
       this._resizeViewsDelayed();
     });
     this._window.on('move', () => {
@@ -373,7 +383,9 @@ export class SessionWindow implements IDisposable {
     this._window.contentView.addChildView(labView.view);
 
     labView.view.webContents.on('did-finish-load', () => {
-      labView.view.webContents.focus();
+      if (this._window.isFocused()) {
+        labView.view.webContents.focus();
+      }
     });
 
     labView.load((errorCode: number, errorDescription: string) => {
@@ -1363,18 +1375,23 @@ export class SessionWindow implements IDisposable {
     }
 
     const titleBarRect = this._titleBarView.view.getBounds();
-    const popupWidth = 600;
     const paddingRight = process.platform === 'darwin' ? 33 : 127;
+    // Anchor the popup's right edge near the env button and cap its width to
+    // what fits, so on a narrow window it shrinks (the popup content is
+    // responsive) instead of hanging off an edge with the search box or the
+    // env list clipped.
+    const rightEdge = titleBarRect.width - paddingRight;
+    const popupWidth = Math.min(600, rightEdge);
     // shorten browser view height if larger than max allowed
     const maxHeight = Math.min(
       this._envSelectPopup.getScrollHeight(),
       defaultEnvSelectPopupHeight
     );
 
     this._envSelectPopup.view.view.setBounds({
-      x: Math.round(titleBarRect.width - paddingRight - popupWidth),
+      x: Math.round(rightEdge - popupWidth),
       y: Math.round(titleBarRect.height),
-      width: popupWidth,
+      width: Math.round(popupWidth),
       height: Math.round(maxHeight)
     });
   }

src/main/titlebarview/preload.ts

@@ -5,11 +5,13 @@ const { contextBridge, ipcRenderer } = electron;
 
 type SetTitleListener = (title: string) => void;
 type SetActiveListener = (active: boolean) => void;
+type SetMaximizedListener = (isMaximized: boolean) => void;
 type ShowServerStatusListener = (show: boolean) => void;
 type ShowServerNotificationBadgeListener = (show: boolean) => void;
 
 let onSetTitleListener: SetTitleListener;
 let onSetActiveListener: SetActiveListener;
+let onSetMaximizedListener: SetMaximizedListener;
 let onShowServerStatusListener: ShowServerStatusListener;
 let onShowServerNotificationBadgeListener: ShowServerNotificationBadgeListener;
 
@@ -52,6 +54,9 @@ contextBridge.exposeInMainWorld('electronAPI', {
   onSetActive: (callback: SetActiveListener) => {
     onSetActiveListener = callback;
   },
+  onSetMaximized: (callback: SetMaximizedListener) => {
+    onSetMaximizedListener = callback;
+  },
   onShowServerStatus: (callback: ShowServerStatusListener) => {
     onShowServerStatusListener = callback;
   },
@@ -74,6 +79,12 @@ ipcRenderer.on(EventTypeRenderer.SetActive, (event, active) => {
   }
 });
 
+ipcRenderer.on(EventTypeRenderer.SetMaximized, (event, isMaximized) => {
+  if (onSetMaximizedListener) {
+    onSetMaximizedListener(isMaximized);
+  }
+});
+
 ipcRenderer.on(EventTypeRenderer.ShowServerStatus, (event, show) => {
   if (onShowServerStatusListener) {
     onShowServerStatusListener(show);

src/main/titlebarview/titlebar.html

@@ -230,6 +230,11 @@
         }
       });
 
+      window.electronAPI.onSetMaximized((isMaximized) => {
+        maximizeButton.style.display = isMaximized ? 'none' : 'block';
+        restoreButton.style.display = isMaximized ? 'block' : 'none';
+      });
+
       window.electronAPI.onShowServerStatus((show) => {
         serverButton.style.display = show ? 'flex' : 'none';
 
@@ -255,15 +260,11 @@
       maximizeButton.onclick = (ev) => {
         ev.stopPropagation();
         window.electronAPI.maximizeWindow();
-        maximizeButton.style.display = 'none';
-        restoreButton.style.display = 'block';
       };
 
       restoreButton.onclick = (ev) => {
         ev.stopPropagation();
         window.electronAPI.restoreWindow();
-        restoreButton.style.display = 'none';
-        maximizeButton.style.display = 'block';
       };
 
       closeButton.onclick = (ev) => {

src/main/titlebarview/titlebarview.ts

@@ -62,6 +62,10 @@ export class TitleBarView {
     );
   }
 
+  setMaximized(isMaximized: boolean) {
+    this._view.webContents.send(EventTypeRenderer.SetMaximized, isMaximized);
+  }
+
   showServerStatus(show: boolean) {
     this._view.webContents.send(EventTypeRenderer.ShowServerStatus, show);
   }

test/e2e/titlebar-dragregion.test.ts

@@ -0,0 +1,71 @@
+import { expect, test } from '@playwright/test';
+import { cleanup, launchApp } from './helpers';
+
+// The title bar is drawn inside its own WebContentsView. Window dragging relies
+// on `-webkit-app-region: drag` on the `.app-title` element, and every control
+// button opts back out with `-webkit-app-region: no-drag`. Dropping either rule
+// in a refactor silently breaks window moving or makes the buttons undraggable.
+//
+// This is only a guard on the computed CSS declaration. It does NOT exercise a
+// real window move: synthetic Playwright/CDP mouse events do not drive the OS
+// drag on the app-region hit-test, so an actual drag cannot be asserted here.
+// The real window move, and the layered-WebContentsView no-drag hit-testing
+// (electron/electron#43320), still have to be verified by hand per OS.
+test('the title bar keeps its drag region and no-drag controls', async () => {
+  const { app, userDataDir, jupyterDir } = await launchApp();
+  try {
+    // Arrange: find the titlebar page. It has no window title, so it is located
+    // by the presence of its `#app-title` element, the same element-probe
+    // pattern the dialog-titlebar test uses.
+    const deadline = Date.now() + 20_000;
+    let titlebar;
+    while (!titlebar && Date.now() < deadline) {
+      for (const page of app.windows()) {
+        const hasTitle = await page
+          .evaluate(() => !!document.getElementById('app-title'))
+          .catch(() => false);
+        if (hasTitle) {
+          titlebar = page;
+          break;
+        }
+      }
+      if (!titlebar) {
+        await new Promise(resolve => setTimeout(resolve, 200));
+      }
+    }
+    if (!titlebar) {
+      throw new Error('title bar page with #app-title never appeared');
+    }
+    await titlebar.waitForLoadState('load');
+
+    // Act: read the computed app-region of the drag surface and of two control
+    // buttons. The JS-side property is `webkitAppRegion`; its value is the
+    // keyword ('drag' / 'no-drag'), not a length.
+    const regions = await titlebar.evaluate(() => {
+      const regionOf = (id: string) => {
+        const el = document.getElementById(id);
+        if (!el) {
+          return null;
+        }
+        return (getComputedStyle(el) as CSSStyleDeclaration & {
+          webkitAppRegion?: string;
+        }).webkitAppRegion;
+      };
+      return {
+        appTitle: regionOf('app-title'),
+        closeButton: regionOf('close-button'),
+        serverButton: regionOf('server-button')
+      };
+    });
+
+    // Assert: the title is draggable and the controls explicitly opt out. If a
+    // refactor drops the `-webkit-app-region` rules these flip to the inherited
+    // default ('none') and the test fails.
+    expect(regions.appTitle).toBe('drag');
+    expect(regions.closeButton).toBe('no-drag');
+    expect(regions.serverButton).toBe('no-drag');
+  } finally {
+    await app.close();
+    cleanup(userDataDir, jupyterDir);
+  }
+});

test/unit/preload/titlebarview.test.ts

@@ -29,6 +29,7 @@ describe('titlebarview preload', () => {
         'sendMouseEvent',
         'onSetTitle',
         'onSetActive',
+        'onSetMaximized',
         'onShowServerStatus',
         'onShowServerNotificationBadge'
       ].sort()
@@ -89,6 +90,14 @@ describe('titlebarview preload', () => {
     expect(cb).toHaveBeenCalledWith(true);
   });
 
+  it('onSetMaximized relays SetMaximized to the callback', async () => {
+    const api = await load();
+    const cb = vi.fn();
+    api.onSetMaximized(cb);
+    rendererHandler(EventTypeRenderer.SetMaximized)({}, true);
+    expect(cb).toHaveBeenCalledWith(true);
+  });
+
   it('onShowServerStatus relays ShowServerStatus to the callback', async () => {
     const api = await load();
     const cb = vi.fn();

test/unit/sessionwindow-dispose.test.ts

@@ -23,3 +23,32 @@ describe('SessionWindow._disposeSession', () => {
     await expect(win._disposeSession()).resolves.toBeUndefined();
   });
 });
+
+describe('SessionWindow._resizeEnvSelectPopup', () => {
+  it('keeps the popup on screen when the window is narrower than the popup', () => {
+    // Arrange: a 400px title bar (the window minWidth) is narrower than the
+    // 600px popup, so an unclamped x would place the popup off the left edge.
+    const setBounds = vi.fn();
+    const win = makeWindow({
+      _envSelectPopupVisible: true,
+      _titleBarView: {
+        view: { getBounds: () => ({ width: 400, height: 60 }) }
+      },
+      _envSelectPopup: {
+        getScrollHeight: () => 300,
+        view: { view: { setBounds } }
+      }
+    });
+
+    // Act
+    win._resizeEnvSelectPopup();
+
+    // Assert: the whole popup fits inside the window, so neither the search box
+    // on the left nor the env list on the right is clipped. Clamping x alone
+    // would only move the clipping to the other edge, so the width is capped too.
+    expect(setBounds).toHaveBeenCalledTimes(1);
+    const bounds = setBounds.mock.calls[0][0];
+    expect(bounds.x).toBeGreaterThanOrEqual(0);
+    expect(bounds.x + bounds.width).toBeLessThanOrEqual(400);
+  });
+});

test/unit/titlebarview-maximized.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it, vi } from 'vitest';
+import { TitleBarView } from '../../src/main/titlebarview/titlebarview';
+import { EventTypeRenderer } from '../../src/main/eventtypes';
+
+// Drive setMaximized without the heavy WebContentsView constructor: create an
+// instance linked to the prototype and stub only the webContents.send it uses.
+function makeTitleBarView(send: ReturnType<typeof vi.fn>): TitleBarView {
+  const view = Object.create(TitleBarView.prototype);
+  view._view = { webContents: { send } };
+  return view;
+}
+
+describe('TitleBarView.setMaximized', () => {
+  it('sends SetMaximized with true when the window is maximized', () => {
+    // Arrange
+    const send = vi.fn();
+    const titleBarView = makeTitleBarView(send);
+
+    // Act
+    titleBarView.setMaximized(true);
+
+    // Assert
+    expect(send).toHaveBeenCalledWith(EventTypeRenderer.SetMaximized, true);
+  });
+
+  it('sends SetMaximized with false when the window is restored', () => {
+    // Arrange
+    const send = vi.fn();
+    const titleBarView = makeTitleBarView(send);
+
+    // Act
+    titleBarView.setMaximized(false);
+
+    // Assert
+    expect(send).toHaveBeenCalledWith(EventTypeRenderer.SetMaximized, false);
+  });
+});