more flexability with windows

[w2ntv]

the ability to move and or resize the windows is limited ... it would be helpful to beable to make, say the freq/mode/band to a smaller display... lots of "empty space imo Also, no real need in looking at the rig and IP address... would be nice for that to auto hide after connected.
so, inshort the ability to custumize the windows smaller...bigger... etc

[brianbruff]

@claude this has been asked for on a few occations
from what i'm aware flex-layout supports multiple windows

can you analyze if it's feasible and how do we manage situations when we try starup up with only one monitor when multiple were previously connected?

start by doing a feasability study and define the heuristics for how this would work and most importantly handle changing monitor counts

[claude]

Claude finished @brianbruff's task in 3m 10s —— View job

---

Feasibility Study: Multi-Window & Flexible Layout Support

• Gather context — reading codebase
• Analyze current FlexLayout usage
• Research FlexLayout multi-window capabilities
• Define feasibility assessment
• Define heuristics for monitor count changes
• Write final report

---

Current State

• FlexLayout: v0.7.15, tabEnableFloat: false (intentionally disabled in layoutStore.ts:7)
• Electron: Single BrowserWindow (1400×900 min 800×600), no monitor awareness
• Layout persistence: MongoDB only, single UserSettings.LayoutJson string
• Plugins: 24 registered components, all rendered in one layout model

---

Two Distinct Approaches

Approach A — FlexLayout Floating Tabs (In-Window)

FlexLayout has a built-in float feature. When tabEnableFloat: true, any tab can be dragged out into a floating, resizable overlay within the same Electron window.

What this gives:

• Panels can be freely moved and resized anywhere within the window
• Float position/size (floatX, floatY, floatWidth, floatHeight) is stored directly in the existing IJsonModel JSON — zero schema changes needed
• Works in both web and Electron targets immediately
• Addresses the original request: "make freq/mode/band smaller", "resize windows"
• One-line change: tabEnableFloat: false → true in layoutStore.ts

Limitation: Everything stays within the single Electron window. Floating panels cannot cross to a second monitor.

Effort: ~1 hour. Very low risk. Reversible.

---

Approach B — True Multi-OS-Window (Electron BrowserWindow)

Each additional "window" is a new BrowserWindow in main.js, each loading the full React app, each with its own FlexLayout model. This is the only way to span multiple physical monitors.

What this requires:

1. Electron side (main.js):

• createSecondaryWindow(windowConfig) — spawns new BrowserWindow at saved x,y,width,height
• IPC channels: open-secondary-window, close-secondary-window, window-layout-changed
• Window state (position/size) persisted separately from FlexLayout layout

2. React side:

• A windowId query param tells each window which layout slice to load
• Each window loads its own IJsonModel from MongoDB (keyed by window ID)
• A "Pop out to new window" button per tabset (via onRenderTabSet in App.tsx)
• When a tab is "popped out", it is removed from the source window's model and added to the new window's model

3. State synchronization:

• SignalR is already running — secondary windows can subscribe to the same hubs
• Layout saves: each window PUTs to /api/settings/layout/{windowId}
• All windows share the same backend state (QSO log, rig connection, etc.)

4. Data model (UserSettings.cs + LayoutJson):

// Current
public string? LayoutJson { get; set; }

// Proposed
public string? LayoutJson { get; set; }           // primary window
public List<WindowLayout>? WindowLayouts { get; set; }  // additional windows

interface WindowLayout {
  id: string;               // stable UUID per window
  displayFingerprint: string; // hash of the display it was last on
  windowBounds: { x: number; y: number; width: number; height: number; };
  layout: IJsonModel;
  status: 'active' | 'orphaned';
}

Effort: 3–5 days. Medium complexity. The SignalR hub reuse significantly reduces state-sync work.

---

Monitor Count Change Heuristics (Critical)

This is the most important design concern. The proposed strategy:

1. Display Fingerprinting

On startup, enumerate electron.screen.getAllDisplays() and hash the array of {width, height, x, y, scaleFactor} tuples → generates a displayConfigHash. Saved window layouts include the displayFingerprint of the monitor they were last on.

2. Window Validation on Startup

For each saved WindowLayout in MongoDB:

foreach window in savedWindowLayouts:
  currentDisplays = electron.screen.getAllDisplays()
  isVisible = any display where window.bounds intersects display.workArea by ≥50%
  
  if isVisible:
    restore window at saved bounds
  else:
    mark window as 'orphaned'
    collect all its panels for consolidation

3. Orphan Consolidation

When windows are orphaned (monitor gone), their panels are merged into the primary window:

• Strategy: Append as new tabs to existing tabsets, ordered by panel category
• Never create new zero-weight tabsets that would render as invisible slivers
• Max consolidation depth: If primary window already has >8 tabs, create one additional tabset column (50/50 split)
• The orphaned WindowLayout is kept in MongoDB with status: 'orphaned' — it is NOT deleted

4. Monitor Reconnect / Restoration

On every startup (or when electron.screen emits display-added):

• Re-check all orphaned windows against current display set
• If a matching display reappears (fingerprint match or bounds overlap), prompt: "Your secondary window layout was restored — open it?"
• Matching is fuzzy: a display with ±5% size difference and same relative position is considered the same display

5. Safe Bounds Fallback

Before opening any window (primary or secondary):

clampToPrimaryDisplay(bounds):
  primary = electron.screen.getPrimaryDisplay()
  ensure x >= primary.workArea.x
  ensure y >= primary.workArea.y  
  ensure x + width <= primary.workArea.x + primary.workArea.width
  ensure y + height <= primary.workArea.y + primary.workArea.height
  enforce minWidth: 800, minHeight: 600

This fires for the primary window too, guarding against corrupted saved bounds.

---

Recommendation

	Approach A (Float)	Approach B (Multi-window)
Addresses original request	✅ Yes	✅ Yes
Multi-monitor span	❌ No	✅ Yes
Effort	~1hr	3–5 days
Risk	Very low	Medium
Monitor handling complexity	None needed	Required (heuristics above)
Data model change	None	WindowLayouts[] in UserSettings

Suggested approach: ship Approach A first (unlock tabEnableFloat), then layer Approach B as a separate feature. This immediately delivers the flexibility users are asking for with minimal risk, while the multi-window design above is sound enough to implement when bandwidth allows.

The main open question for Approach B is whether web-only users (non-Electron) need multi-window support — browser tabs could be a fallback there.

---

[brianbruff]

ok the analysis looks good, let's make this happen @claude have at it!

[claude]

Claude finished @brianbruff's task in 11m 14s —— View job • claude/issue-225-20260416-2249 • Create PR ➔

---

Implementing Flexible Window Support

Both approaches from the feasibility study are now implemented.

Approach A — FlexLayout Floating Tabs

• Enable tabEnableFloat: true in layoutStore.ts — any tab can now be dragged out into a resizable floating overlay inside the existing Electron window. Float position/size is persisted automatically in the existing layout JSON.

Approach B — True Multi-OS-Window (Electron)

• WindowLayout model + WindowLayouts[] added to Settings.cs / UserSettings
• GET/PUT/DELETE /api/settings/window-layout/{id} added to SettingsController.cs
• layoutStore.ts — windowId state + setWindowId; all sync/load calls route to the window-specific endpoint when windowId is set
• main.js — createSecondaryWindow(), window-state.json bounds persistence, isWindowVisible() / clampToPrimaryDisplay(), restoreSecondaryWindows() on startup, open/close-secondary-window IPC handlers, isAppQuitting flag so user-close vs app-quit is distinguished
• preload.js — openSecondaryWindow / closeSecondaryWindow exposed
• electron.d.ts — new API types added
• App.tsx — ?windowId= URL detection; setWindowId called before loadFromMongo; "Pop out to new window" button (external link icon) per tabset in Electron primary window; secondary windows hide setup wizard, status bar, settings panel, splash screen

How it works

Floating panels (Approach A): Drag any tab's title bar out of a tabset — it becomes a freely-positionable, resizable floating panel within the same window. Drop it back to dock it. Layout is persisted automatically.

Pop out to new window (Approach B):

1. Each tabset now has an ↗ button next to the existing + button (Electron only)
2. Clicking it saves the tabset's tabs as a new layout slot in MongoDB and opens a dedicated OS window
3. The new window loads with ?windowId=<uuid>, loads its own layout, and saves independently
4. Closing the window explicitly removes it from auto-restore; quitting the app saves its bounds for next startup
5. On next startup, secondary windows whose layouts still exist in MongoDB are automatically restored at their last position/size

Monitor-change heuristics: On every window open, isWindowVisible() checks ≥50% overlap with any display's work area. If a window is off-screen (monitor removed), clampToPrimaryDisplay() moves it to a safe position on the primary display.

|

— Log4YM-Agent 📻

[brianbruff]

@claude keep in mind that sometimes on macos when i close the main window the log4ym application is still running,, i'm assuming it's the dotnet backend but it's something that's of no value to stay around when all windows (currently only one) are closed

[claude]

Claude finished @brianbruff's task in 1m 23s —— View job • claude/issue-225-20260416-2251 • Create PR ➔

---

macOS: Kill backend when all windows close

• Gather context — reading current branch state
• Located issue: window-all-closed skips app.quit() on macOS (standard Electron boilerplate, wrong for Log4YM)
• Fixed window-all-closed to always quit on all platforms
• Committed and pushed

Root cause: main.js was using the default Electron macOS pattern — skip quitting when all windows close so the app stays in the dock. For most macOS apps this is correct, but Log4YM owns a .NET backend child process. When the window closed, before-quit/will-quit never fired so cleanup() never ran and the backend stayed alive.

Fix (src/Log4YM.Desktop/main.js):

// Before
app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') {  // ← macOS exception
    app.quit();
  }
});

// After — always quit; cleanup() kills the .NET backend via SIGTERM/SIGKILL
app.on('window-all-closed', () => {
  app.quit();
});

This ensures the existing cleanup() function fires on every platform, sending SIGTERM to the backend and force-killing after 5s if needed.

Note for multi-window (Approach B): this event fires when the last window closes, so multi-window support will work correctly — the backend only dies when the user is truly done.

|

— Log4YM-Agent 📻

[brianbruff]

hi @claude the document is approved, go and implement it

[claude]

Claude finished @brianbruff's task in 11m 8s —— View job • claude/issue-225-20260417-1607 • Create PR ➔

---

Implementing Flexible Window Support

• Gather context — reading codebase and feasibility study
• Phase 1: Enhanced Single-Window Experience
  • Enable tabEnableFloat: true — any tab can be dragged into a resizable floating overlay within the same window
  • Reduced global tabset minimums (100→80px wide, 40→30px tall) so panels can be made smaller
  • Per-tabset minWidth/minHeight in defaultLayout appropriate to each panel's content
  • Bottom border added to layout for panel docking
  • Auto-minimize rig panel to bottom border on first connect — collapses it out of the way once no longer needed (click the border to expand)
• Phase 2: Monitor-Aware Layout
  • Window bounds persistence (window-state.json) — saves x/y/width/height on close, restores on next startup
  • Validates bounds against current displays using 50% overlap heuristic — resets to primary if mostly off-screen
  • display-removed event handler — moves any off-screen windows to primary display at runtime
  • macOS quit fix — removed darwin exception in window-all-closed so the .NET backend is always killed on close
• Committed and pushed

What was implemented

Floating panels (layoutStore.ts + tabEnableFloat: true): Any tab can now be floated by dragging its title bar out of the tabset. The floating panel is freely resizable and repositionable within the Electron window. Float state is preserved in the layout JSON automatically.

Smaller panels (layoutStore.ts): Global minimums reduced, per-tabset minimums set so the header bar, log entry, log history, rig, and cluster panes all have sensible but compact lower bounds.

Rig auto-hide (RigPlugin.tsx + App.tsx): When the rig first connects in a session, a minimize-panel custom event is dispatched. App.tsx handles this by finding the rig tab and docking it to the bottom border — it collapses to a thin strip with a label. Click it to expand back. Disconnecting resets the "auto-minimized" flag so it triggers again on next connect.

Window position memory (main.js): Window position and size are saved to window-state.json in the Electron user data directory. On next startup the saved bounds are restored, validated against the current display layout (50% overlap check), and clamped to the primary display if the previous screen is gone.

Display-removed handling (main.js): Subscribes to screen.on('display-removed'). Any window that becomes more than 50% off-screen is immediately moved to the primary display at (primaryX+100, primaryY+100).

macOS quit (main.js): The window-all-closed handler now always calls app.quit() regardless of platform, ensuring the .NET backend child process is terminated when the user closes the window.
| claude/issue-225-20260417-1607

— Log4YM-Agent 📻