fix: ensure grid and hint dont sleep when refresh overlays (#124)

Author: y3owk1n

cmd/neru/lifecycle.go

@@ -60,30 +60,52 @@ func (a *App) handleScreenParametersChange() {
 	defer func() { a.screenChangeProcessing = false }()
 
 	a.logger.Info("Screen parameters changed; adjusting overlays")
-	// Only act if grid is enabled
+
+	// Handle grid overlay
 	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
-		}
+		} else {
+			// Grid mode is active - resize the existing overlay window to match new screen bounds
+			gridOverlay := *a.gridCtx.gridOverlay
 
-		// 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.ResizeToActiveScreenSync()
 
-		// 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
+			}
 
-		// 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")
 		}
+	}
 
-		a.logger.Info("Grid overlay resized and regenerated for new screen bounds")
+	// Handle hint overlay
+	if a.config.Hints.Enabled && a.hintOverlay != nil {
+		// If hints mode is not active, mark for refresh on next activation
+		if a.currentMode != ModeHints {
+			a.hintOverlayNeedsRefresh = true
+		} else {
+			// Hints mode is active - resize the overlay and regenerate hints
+			a.hintOverlay.ResizeToActiveScreenSync()
+
+			// Regenerate hints for current action
+			a.updateRolesForCurrentApp()
+			elements := a.collectElementsForAction(a.currentAction)
+			if len(elements) > 0 {
+				if err := a.setupHints(elements, a.currentAction); err != nil {
+					a.logger.Error("Failed to refresh hints after screen change", zap.Error(err))
+					return
+				}
+				a.logger.Info("Hint overlay resized and regenerated for new screen bounds")
+			} else {
+				a.logger.Warn("No elements found after screen change")
+				a.exitMode()
+			}
+		}
 	}
 }
 

cmd/neru/main.go

@@ -73,6 +73,7 @@ type App struct {
 	hotkeysRegistered       bool
 	screenChangeProcessing  bool
 	gridOverlayNeedsRefresh bool
+	hintOverlayNeedsRefresh bool
 	hotkeyRefreshPending    bool
 }
 

cmd/neru/modes.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"image"
 	"strings"
-	"time"
 
 	"github.com/y3owk1n/neru/internal/accessibility"
 	"github.com/y3owk1n/neru/internal/bridge"
@@ -75,11 +74,12 @@ func (a *App) activateHintMode(action Action) {
 		return
 	}
 
-	// Resize overlay to the active screen before collecting elements
+	// Always resize overlay to the active screen (where mouse is) before collecting elements
+	// This ensures proper positioning when switching between multiple displays
 	if a.hintOverlay != nil {
-		a.hintOverlay.ResizeToActiveScreen()
-		// Wait for async resize to complete on main thread
-		time.Sleep(100 * time.Millisecond)
+		// Use synchronous resize with callback - no artificial delay needed
+		a.hintOverlay.ResizeToActiveScreenSync()
+		a.hintOverlayNeedsRefresh = false
 	}
 
 	// Update roles for the current focused app
@@ -167,17 +167,13 @@ func (a *App) activateGridMode(action Action) {
 
 	a.exitMode() // Exit current mode first
 
-	if a.gridOverlayNeedsRefresh {
-		if a.gridCtx != nil && a.gridCtx.gridOverlay != nil {
-			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)
-		}
+	// Always resize overlay to the active screen (where mouse is) before drawing grid
+	// This ensures proper positioning when switching between multiple displays
+	if a.gridCtx != nil && a.gridCtx.gridOverlay != nil {
+		gridOverlay := *a.gridCtx.gridOverlay
 
+		// Use synchronous resize with callback - no artificial delay needed
+		gridOverlay.ResizeToActiveScreenSync()
 		a.gridOverlayNeedsRefresh = false
 	}
 

internal/bridge/overlay.h

@@ -53,6 +53,9 @@ typedef struct {
     int isSubgrid;  // 1 if cell is part of subgrid, 0 otherwise
 } GridCell;
 
+// Callback type for async operations
+typedef void (*ResizeCompletionCallback)(void* context);
+
 // Function declarations
 OverlayWindow createOverlayWindow();
 void destroyOverlayWindow(OverlayWindow window);
@@ -66,6 +69,7 @@ void drawTargetDot(OverlayWindow window, CGPoint center, double radius, const ch
 void replaceOverlayWindow(OverlayWindow *pwindow);
 void resizeOverlayToMainScreen(OverlayWindow window);
 void resizeOverlayToActiveScreen(OverlayWindow window);
+void resizeOverlayToActiveScreenWithCallback(OverlayWindow window, ResizeCompletionCallback callback, void* context);
 
 // Grid-specific drawing functions
 void drawGridCells(OverlayWindow window, GridCell* cells, int count, GridCellStyle style);

internal/bridge/overlay.m

@@ -724,6 +724,51 @@ void resizeOverlayToActiveScreen(OverlayWindow window) {
     });
 }
 
+void resizeOverlayToActiveScreenWithCallback(OverlayWindow window, ResizeCompletionCallback callback, void* context) {
+    if (!window) {
+        if (callback) callback(context);
+        return;
+    }
+
+    OverlayWindowController *controller = (OverlayWindowController*)window;
+    dispatch_async(dispatch_get_main_queue(), ^{
+        // Get current mouse location
+        NSPoint mouseLoc = [NSEvent mouseLocation];
+        
+        // Find the screen containing the mouse cursor
+        NSScreen *activeScreen = nil;
+        for (NSScreen *screen in [NSScreen screens]) {
+            if (NSPointInRect(mouseLoc, screen.frame)) {
+                activeScreen = screen;
+                break;
+            }
+        }
+        
+        // Fall back to main screen if mouse is somehow not on any screen
+        if (!activeScreen) {
+            activeScreen = [NSScreen mainScreen];
+        }
+        
+        if (!activeScreen) {
+            if (callback) callback(context);
+            return;
+        }
+        
+        NSRect screenFrame = [activeScreen frame];
+        [controller.window setFrame:screenFrame display:YES];
+        
+        // View frame should be in window's coordinate space (origin at 0,0)
+        NSRect viewFrame = NSMakeRect(0, 0, screenFrame.size.width, screenFrame.size.height);
+        [controller.overlayView setFrame:viewFrame];
+        [controller.overlayView setNeedsDisplay:YES];
+        
+        // Call completion callback
+        if (callback) {
+            callback(context);
+        }
+    });
+}
+
 void drawHints(OverlayWindow window, HintData* hints, int count, HintStyle style) {
     if (!window || !hints) return;
 

internal/grid/grid_overlay.go

@@ -4,16 +4,40 @@ package grid
 #cgo CFLAGS: -x objective-c
 #include "../bridge/overlay.h"
 #include <stdlib.h>
+
+// Callback function that Go can reference
+extern void gridResizeCompletionCallback(void* context);
 */
 import "C"
 
 import (
 	"strings"
+	"sync"
+	"sync/atomic"
 	"unsafe"
 
 	"github.com/y3owk1n/neru/internal/config"
 )
 
+var (
+	gridCallbackID   uint64
+	gridCallbackMap  = make(map[uint64]chan struct{})
+	gridCallbackLock sync.Mutex
+)
+
+//export gridResizeCompletionCallback
+func gridResizeCompletionCallback(context unsafe.Pointer) {
+	// Convert context to callback ID
+	id := uint64(uintptr(context))
+
+	gridCallbackLock.Lock()
+	if done, ok := gridCallbackMap[id]; ok {
+		close(done)
+		delete(gridCallbackMap, id)
+	}
+	gridCallbackLock.Unlock()
+}
+
 // GridOverlay manages grid-specific overlay rendering
 type GridOverlay struct {
 	window C.OverlayWindow
@@ -82,6 +106,29 @@ func (o *GridOverlay) ResizeToActiveScreen() {
 	C.resizeOverlayToActiveScreen(o.window)
 }
 
+// ResizeToActiveScreenSync resizes the overlay window synchronously with callback notification
+func (o *GridOverlay) ResizeToActiveScreenSync() {
+	done := make(chan struct{})
+
+	// Generate unique ID for this callback
+	id := atomic.AddUint64(&gridCallbackID, 1)
+
+	// Store channel in map
+	gridCallbackLock.Lock()
+	gridCallbackMap[id] = done
+	gridCallbackLock.Unlock()
+
+	// Pass ID as context (safe - no Go pointers)
+	// Note: uintptr conversion must happen in same expression to satisfy go vet
+	C.resizeOverlayToActiveScreenWithCallback(
+		o.window,
+		(C.ResizeCompletionCallback)(unsafe.Pointer(C.gridResizeCompletionCallback)),
+		*(*unsafe.Pointer)(unsafe.Pointer(&id)),
+	)
+
+	<-done
+}
+
 // Draw renders the flat grid with all 3-char cells visible
 func (o *GridOverlay) Draw(grid *Grid, currentInput string) error {
 	// Clear existing content

internal/hints/overlay.go

@@ -4,17 +4,41 @@ package hints
 #cgo CFLAGS: -x objective-c
 #include "../bridge/overlay.h"
 #include <stdlib.h>
+
+// Callback function that Go can reference
+extern void resizeCompletionCallback(void* context);
 */
 import "C"
 
 import (
 	"fmt"
 	"strings"
+	"sync"
+	"sync/atomic"
 	"unsafe"
 
 	"github.com/y3owk1n/neru/internal/config"
 )
 
+var (
+	hintCallbackID   uint64
+	hintCallbackMap  = make(map[uint64]chan struct{})
+	hintCallbackLock sync.Mutex
+)
+
+//export resizeCompletionCallback
+func resizeCompletionCallback(context unsafe.Pointer) {
+	// Convert context to callback ID
+	id := uint64(uintptr(context))
+
+	hintCallbackLock.Lock()
+	if done, ok := hintCallbackMap[id]; ok {
+		close(done)
+		delete(hintCallbackMap, id)
+	}
+	hintCallbackLock.Unlock()
+}
+
 // Overlay manages the hint overlay window
 type Overlay struct {
 	window C.OverlayWindow
@@ -67,6 +91,29 @@ func (o *Overlay) ResizeToActiveScreen() {
 	C.resizeOverlayToActiveScreen(o.window)
 }
 
+// ResizeToActiveScreenSync resizes the overlay window synchronously with callback notification
+func (o *Overlay) ResizeToActiveScreenSync() {
+	done := make(chan struct{})
+
+	// Generate unique ID for this callback
+	id := atomic.AddUint64(&hintCallbackID, 1)
+
+	// Store channel in map
+	hintCallbackLock.Lock()
+	hintCallbackMap[id] = done
+	hintCallbackLock.Unlock()
+
+	// Pass ID as context (safe - no Go pointers)
+	// Note: uintptr conversion must happen in same expression to satisfy go vet
+	C.resizeOverlayToActiveScreenWithCallback(
+		o.window,
+		(C.ResizeCompletionCallback)(unsafe.Pointer(C.resizeCompletionCallback)),
+		*(*unsafe.Pointer)(unsafe.Pointer(&id)),
+	)
+
+	<-done
+}
+
 // DrawHintsWithoutArrow draws hints without arrows
 func (o *Overlay) DrawHintsWithoutArrow(hints []*Hint, style StyleMode) error {
 	return o.drawHintsInternal(hints, style, false)