fix: react to screen changes and support extended displays for grid (#116)

Author: y3owk1n

cmd/neru/lifecycle.go

@@ -45,15 +45,61 @@ func (a *App) setupAppWatcherCallbacks() {
 	a.appWatcher.OnActivate(func(appName, bundleID string) {
 		a.handleAppActivation(bundleID)
 	})
+	// Watch for display parameter changes (monitor unplug/plug, resolution changes)
+	a.appWatcher.OnScreenParametersChanged(func() {
+		a.handleScreenParametersChange()
+	})
+}
+
+// handleScreenParametersChange handles display changes and resizes/regenerates overlays
+func (a *App) handleScreenParametersChange() {
+	if a.screenChangeProcessing {
+		return
+	}
+	a.screenChangeProcessing = true
+	defer func() { a.screenChangeProcessing = false }()
+
+	a.logger.Info("Screen parameters changed; adjusting overlays")
+	// Only act if grid is enabled
+	if a.config.Grid.Enabled && a.gridCtx != nil && a.gridCtx.gridOverlay != nil {
+		// If grid mode is not active, mark for refresh on next activation
+		if a.currentMode != ModeGrid {
+			a.gridOverlayNeedsRefresh = true
+			return
+		}
+
+		// Grid mode is active - resize the existing overlay window to match new screen bounds
+		gridOverlay := *a.gridCtx.gridOverlay
+
+		// Resize overlay window to current active screen (where mouse is)
+		gridOverlay.ResizeToActiveScreen()
+
+		// Give the UI thread a moment to complete the resize
+		time.Sleep(150 * time.Millisecond)
+
+		// Regenerate the grid cells with updated screen bounds
+		if err := a.setupGrid(a.gridCtx.currentAction); err != nil {
+			a.logger.Error("Failed to refresh grid after screen change", zap.Error(err))
+			return
+		}
+
+		a.logger.Info("Grid overlay resized and regenerated for new screen bounds")
+	}
 }
 
 // handleAppActivation handles application activation events
 func (a *App) handleAppActivation(bundleID string) {
 	a.logger.Debug("App activated", zap.String("bundle_id", bundleID))
 
 	// refresh hotkeys for app
-	go a.refreshHotkeysForAppOrCurrent(bundleID)
-	a.logger.Debug("Handled hotkey refresh")
+	if a.currentMode == ModeIdle {
+		go a.refreshHotkeysForAppOrCurrent(bundleID)
+		a.logger.Debug("Handled hotkey refresh")
+	} else {
+		// Defer hotkey refresh to avoid re-entry during active modes
+		a.hotkeyRefreshPending = true
+		a.logger.Debug("Deferred hotkey refresh due to active mode")
+	}
 
 	if a.config.Hints.Enabled {
 		if a.config.Accessibility.AdditionalAXSupport.Enable {

cmd/neru/main.go

@@ -69,8 +69,11 @@ type App struct {
 	gridRouter       *grid.Router
 	gridCtx          *GridContext
 
-	enabled           bool
-	hotkeysRegistered bool
+	enabled                 bool
+	hotkeysRegistered       bool
+	screenChangeProcessing  bool
+	gridOverlayNeedsRefresh bool
+	hotkeyRefreshPending    bool
 }
 
 // NewApp creates a new application instance

cmd/neru/modes.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"image"
 	"strings"
+	"time"
 
 	"github.com/y3owk1n/neru/internal/accessibility"
 	"github.com/y3owk1n/neru/internal/bridge"
@@ -147,12 +148,18 @@ func (a *App) activateGridMode(action Action) {
 
 	a.exitMode() // Exit current mode first
 
-	if actionString == "unknown" {
-		a.logger.Warn("Unknown action, ignoring")
-		return
+	// Always resize overlay to the active screen (where mouse is) before drawing grid
+	if a.gridCtx != nil && a.gridCtx.gridOverlay != nil {
+		(*a.gridCtx.gridOverlay).ResizeToActiveScreen()
+		// Wait for async resize to complete on main thread
+		time.Sleep(100 * time.Millisecond)
+	}
+
+	// If screen changed while grid was inactive, clear the refresh flag
+	if a.gridOverlayNeedsRefresh {
+		a.gridOverlayNeedsRefresh = false
 	}
 
-	// Generate grid cells
 	if err := a.setupGrid(action); err != nil {
 		a.logger.Error("Failed to setup grid", zap.Error(err), zap.String("action", actionString))
 		return
@@ -176,7 +183,12 @@ func (a *App) activateGridMode(action Action) {
 func (a *App) setupGrid(action Action) error {
 	// Create grid with active screen bounds (screen containing mouse cursor)
 	// This ensures proper multi-monitor support
-	bounds := bridge.GetActiveScreenBounds()
+	screenBounds := bridge.GetActiveScreenBounds()
+
+	// Normalize bounds to window-local coordinates (0,0 origin)
+	// The overlay window is positioned at the screen origin, but the view uses local coordinates
+	bounds := image.Rect(0, 0, screenBounds.Dx(), screenBounds.Dy())
+
 	characters := a.config.Grid.Characters
 	if strings.TrimSpace(characters) == "" {
 		characters = a.config.Hints.HintCharacters
@@ -920,6 +932,12 @@ func (a *App) exitMode() {
 	a.currentAction = ActionLeftClick
 	a.logger.Debug("Mode transition complete",
 		zap.String("to", "idle"))
+
+	// If a hotkey refresh was deferred while in an active mode, perform it now
+	if a.hotkeyRefreshPending {
+		a.hotkeyRefreshPending = false
+		go a.refreshHotkeysForAppOrCurrent("")
+	}
 }
 
 func getModeString(mode Mode) string {

internal/appwatcher/watcher.go

@@ -13,10 +13,11 @@ type AppCallback func(appName string, bundleID string)
 type Watcher struct {
 	mu sync.RWMutex
 	// Callbacks for different events
-	launchCallbacks     []AppCallback
-	terminateCallbacks  []AppCallback
-	activateCallbacks   []AppCallback
-	deactivateCallbacks []AppCallback
+	launchCallbacks       []AppCallback
+	terminateCallbacks    []AppCallback
+	activateCallbacks     []AppCallback
+	deactivateCallbacks   []AppCallback
+	screenChangeCallbacks []func()
 }
 
 func NewWatcher() *Watcher {
@@ -35,11 +36,11 @@ func (w *Watcher) Stop() {
 	bridge.StopAppWatcher()
 }
 
-// OnLaunch registers a callback for application launch events
-func (w *Watcher) OnLaunch(callback AppCallback) {
+// OnScreenParametersChanged registers a callback for screen parameter change events
+func (w *Watcher) OnScreenParametersChanged(callback func()) {
 	w.mu.Lock()
 	defer w.mu.Unlock()
-	w.launchCallbacks = append(w.launchCallbacks, callback)
+	w.screenChangeCallbacks = append(w.screenChangeCallbacks, callback)
 }
 
 // OnTerminate registers a callback for application termination events
@@ -98,3 +99,12 @@ func (w *Watcher) HandleDeactivate(appName, bundleID string) {
 		callback(appName, bundleID)
 	}
 }
+
+// HandleScreenParametersChanged is called from the bridge when display parameters change
+func (w *Watcher) HandleScreenParametersChanged() {
+	w.mu.RLock()
+	defer w.mu.RUnlock()
+	for _, callback := range w.screenChangeCallbacks {
+		callback()
+	}
+}

internal/bridge/appwatcher.m

@@ -5,6 +5,7 @@
 extern void handleAppTerminate(const char* appName, const char* bundleID);
 extern void handleAppActivate(const char* appName, const char* bundleID);
 extern void handleAppDeactivate(const char* appName, const char* bundleID);
+extern void handleScreenParametersChanged(void);
 
 @interface AppWatcherDelegate : NSObject
 @end
@@ -108,6 +109,15 @@ - (void)applicationDidDeactivate:(NSNotification *)notification {
     }
 }
 
+- (void)screenParametersDidChange:(NSNotification *)notification {
+    @autoreleasepool {
+        // Debounce to allow system to settle, then invoke Go handler on watcherQueue (not main thread)
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.1 * NSEC_PER_SEC)), dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+            handleScreenParametersChanged();
+        });
+    }
+}
+
 @end
 
 static AppWatcherDelegate *delegate = nil;
@@ -145,6 +155,12 @@ void startAppWatcher(void) {
                       selector:@selector(applicationDidDeactivate:)
                           name:NSWorkspaceDidDeactivateApplicationNotification
                         object:nil];
+
+            // Observe screen parameter changes (display add/remove, resolution changes)
+            [[NSNotificationCenter defaultCenter] addObserver:delegate
+                                                     selector:@selector(screenParametersDidChange:)
+                                                         name:NSApplicationDidChangeScreenParametersNotification
+                                                       object:nil];
         }
     });
 }

internal/bridge/bridge.go

@@ -59,6 +59,7 @@ type AppWatcher interface {
 	HandleTerminate(appName, bundleID string)
 	HandleActivate(appName, bundleID string)
 	HandleDeactivate(appName, bundleID string)
+	HandleScreenParametersChanged()
 }
 
 // SetAppWatcher sets the application watcher implementation
@@ -103,6 +104,13 @@ func handleAppActivate(cAppName *C.char, cBundleID *C.char) {
 	}
 }
 
+//export handleScreenParametersChanged
+func handleScreenParametersChanged() {
+	if appWatcher != nil {
+		go appWatcher.HandleScreenParametersChanged()
+	}
+}
+
 //export handleAppDeactivate
 func handleAppDeactivate(cAppName *C.char, cBundleID *C.char) {
 	if appWatcher != nil {
@@ -112,17 +120,6 @@ func handleAppDeactivate(cAppName *C.char, cBundleID *C.char) {
 	}
 }
 
-// GetMainScreenBounds returns the bounds of the main screen
-func GetMainScreenBounds() image.Rectangle {
-	rect := C.getMainScreenBounds()
-	return image.Rect(
-		int(rect.origin.x),
-		int(rect.origin.y),
-		int(rect.origin.x+rect.size.width),
-		int(rect.origin.y+rect.size.height),
-	)
-}
-
 // GetActiveScreenBounds returns the bounds of the screen containing the mouse cursor
 func GetActiveScreenBounds() image.Rectangle {
 	rect := C.getActiveScreenBounds()

internal/bridge/eventtap.m

@@ -238,6 +238,15 @@ EventTap createEventTap(EventTapCallback callback, void* userData) {
 
     context->runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, context->eventTap, 0);
 
+    // Add to main run loop once during creation to avoid re-entry on enable
+    if ([NSThread isMainThread]) {
+        CFRunLoopAddSource(CFRunLoopGetMain(), context->runLoopSource, kCFRunLoopCommonModes);
+    } else {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            CFRunLoopAddSource(CFRunLoopGetMain(), context->runLoopSource, kCFRunLoopCommonModes);
+        });
+    }
+
     return (EventTap)context;
 }
 
@@ -268,33 +277,24 @@ void enableEventTap(EventTap tap) {
 
     EventTapContext* context = (EventTapContext*)tap;
 
-    // Must run on main thread since we're modifying the main run loop
-    if ([NSThread isMainThread]) {
-        CFRunLoopAddSource(CFRunLoopGetMain(), context->runLoopSource, kCFRunLoopCommonModes);
-        CGEventTapEnable(context->eventTap, true);
-    } else {
-        dispatch_sync(dispatch_get_main_queue(), ^{
-            CFRunLoopAddSource(CFRunLoopGetMain(), context->runLoopSource, kCFRunLoopCommonModes);
+    // Always enable asynchronously to avoid overlap with disable/destroy
+    // Use a short delay to ensure prior disable completes first
+    dispatch_async(dispatch_get_main_queue(), ^{
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.15 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
             CGEventTapEnable(context->eventTap, true);
         });
-    }
+    });
 }
 
 void disableEventTap(EventTap tap) {
     if (!tap) return;
 
     EventTapContext* context = (EventTapContext*)tap;
 
-    // Must run on main thread since we're modifying the main run loop
-    if ([NSThread isMainThread]) {
+    // Always disable asynchronously to avoid overlap with enable/destroy
+    dispatch_async(dispatch_get_main_queue(), ^{
         CGEventTapEnable(context->eventTap, false);
-        CFRunLoopRemoveSource(CFRunLoopGetMain(), context->runLoopSource, kCFRunLoopCommonModes);
-    } else {
-        dispatch_sync(dispatch_get_main_queue(), ^{
-            CGEventTapEnable(context->eventTap, false);
-            CFRunLoopRemoveSource(CFRunLoopGetMain(), context->runLoopSource, kCFRunLoopCommonModes);
-        });
-    }
+    });
 }
 
 void destroyEventTap(EventTap tap) {
@@ -311,7 +311,7 @@ void destroyEventTap(EventTap tap) {
             CFRunLoopRemoveSource(CFRunLoopGetMain(), context->runLoopSource, kCFRunLoopCommonModes);
         }
     } else {
-        dispatch_sync(dispatch_get_main_queue(), ^{
+        dispatch_async(dispatch_get_main_queue(), ^{
             if (context->eventTap) {
                 CGEventTapEnable(context->eventTap, false);
             }

internal/bridge/overlay.h

@@ -63,6 +63,9 @@ void drawHints(OverlayWindow window, HintData* hints, int count, HintStyle style
 void drawScrollHighlight(OverlayWindow window, CGRect bounds, char* color, int width);
 void setOverlayLevel(OverlayWindow window, int level);
 void drawTargetDot(OverlayWindow window, CGPoint center, double radius, const char *color, const char *borderColor, double borderWidth);
+void replaceOverlayWindow(OverlayWindow *pwindow);
+void resizeOverlayToMainScreen(OverlayWindow window);
+void resizeOverlayToActiveScreen(OverlayWindow window);
 
 // Grid-specific drawing functions
 void drawGridCells(OverlayWindow window, GridCell* cells, int count, GridCellStyle style);