win32: menu removed and position stored

Author: gcclinux

README.md

@@ -7,7 +7,6 @@ A compact weather widget for your desktop.
 ### Windows
 ```powershell
     $env:PATH = "C:\msys64\ucrt64\bin;" + $env:PATH; $env:CGO_ENABLED = "1"; gcc --version | Select-Object -First 1
-    make build
 ```
 
 ```powershell
@@ -55,11 +54,25 @@ A compact weather widget for your desktop.
       "timezone": "Europe/Warsaw"
     }
   ],
-  "refreshInterval": 23,
-  "cornerPosition": "bottom-right",
+  "refreshInterval": 30,
+  "cornerPosition": "top-right",
   "apiConfig": {
     "provider": "openweathermap",
     "apiKey": "YOUR_API_KEY"
   }
 }
+```
+
+### Windows COnfig location
+
+```powershell
+Get-Content "$env:APPDATA\WeatherWidget\WeatherWidget\config.json"
+or
+type "$env:APPDATA\WeatherWidget\WeatherWidget\config.json"
+```
+
+```bash
+cat $HOME/.config/WeatherWidget/WeatherWidget/config.json
+or
+more $HOME/.config/WeatherWidget/WeatherWidget/config.json
 ```

internal/app/manager.go

@@ -64,12 +64,7 @@ func (a *AppManager) Run() error {
 	// 3. Create UI manager.
 	a.ui = ui.NewUIManager(a.app)
 
-	// 4. Setup context menu and system tray.
-	a.ui.SetupContextMenu(
-		func() { a.openSettings() },
-		func(pos string) { a.saveCornerPosition(pos) },
-		func() { a.Shutdown() },
-	)
+	// 4. Setup system tray.
 	a.ui.SetupSystemTray(
 		func() { a.openSettings() },
 		func() { a.Shutdown() },
@@ -87,9 +82,21 @@ func (a *AppManager) Run() error {
 	// 7. Show widget and apply Win32 styles.
 	a.ui.ShowWidget(cfg.Cities)
 	a.ui.ApplyWin32Styles()
-	a.ui.SetCorner(cfg.CornerPosition)
+	a.applyPosition(cfg)
 	log.Printf("WeatherWidget window shown at %s", cfg.CornerPosition)
 
+	// 8. Enable drag-to-reposition — persists custom coordinates on drag end.
+	a.ui.EnableDrag(func() {
+		x, y := a.ui.GetPosition()
+		a.cfg.CustomX = &x
+		a.cfg.CustomY = &y
+		if err := a.config.Save(a.cfg); err != nil {
+			log.Printf("failed to save custom position (%d, %d): %v", x, y, err)
+		} else {
+			log.Printf("custom position saved: (%d, %d)", x, y)
+		}
+	})
+
 	// 8. Start clocks for each panel.
 	a.startPanelClocks(cfg.Cities)
 
@@ -140,15 +147,14 @@ func (a *AppManager) openSettings() {
 	a.ui.ShowSettings(a.cfg, a.onSettingsSave)
 }
 
-// saveCornerPosition updates the in-memory config with the new corner position
-// and persists it to disk. Called when the user picks a position from the
-// right-click context menu.
-func (a *AppManager) saveCornerPosition(pos string) {
-	a.cfg.CornerPosition = pos
-	if err := a.config.Save(a.cfg); err != nil {
-		log.Printf("failed to save corner position %q: %v", pos, err)
+// applyPosition moves the widget to custom coordinates if set, otherwise
+// falls back to the configured corner position.
+func (a *AppManager) applyPosition(cfg *config.Config) {
+	if cfg.CustomX != nil && cfg.CustomY != nil {
+		a.ui.SetPosition(*cfg.CustomX, *cfg.CustomY)
+		log.Printf("positioned widget at custom coordinates (%d, %d)", *cfg.CustomX, *cfg.CustomY)
 	} else {
-		log.Printf("corner position saved: %s", pos)
+		a.ui.SetCorner(cfg.CornerPosition)
 	}
 }
 
@@ -203,7 +209,7 @@ func (a *AppManager) onSettingsSave(newCfg *config.Config) error {
 	}
 
 	// Always reposition the widget window (position may have changed independently).
-	a.ui.SetCorner(newCfg.CornerPosition)
+	a.applyPosition(newCfg)
 
 	return nil
 }

internal/config/types.go

@@ -14,6 +14,8 @@ type Config struct {
 	Cities          []CityConfig    `json:"cities"`
 	RefreshInterval int             `json:"refreshInterval"` // minutes, 1–60, default 10
 	CornerPosition  string          `json:"cornerPosition"`  // "top-left"|"top-right"|"bottom-left"|"bottom-right"
+	CustomX         *int            `json:"customX,omitempty"`
+	CustomY         *int            `json:"customY,omitempty"`
 	APIConfig       *APIConfig      `json:"apiConfig,omitempty"`
 	DatabaseConfig  *DatabaseConfig `json:"databaseConfig,omitempty"`
 }

internal/ui/contextmenu.go

@@ -0,0 +1,95 @@
+//go:build linux
+
+package ui
+
+import (
+	"log"
+	"sync"
+	"time"
+)
+
+var (
+	linuxDragMu       sync.Mutex
+	linuxDragStop     chan struct{}
+	linuxDragCallback func()
+	linuxLastX        int
+	linuxLastY        int
+	linuxMovedByUs    bool // true briefly after we call moveWindow
+)
+
+// enableWindowDrag enables drag-to-reposition detection on Linux.
+//
+// Since the title bar is removed, most window managers still allow moving
+// via Alt+left-click drag or Super+drag. This function starts a background
+// poller that detects when the window position changes and calls onDragEnd
+// so the caller can persist the new coordinates.
+//
+// Requires xdotool to be installed.
+func enableWindowDrag(onDragEnd func()) {
+	linuxDragMu.Lock()
+	defer linuxDragMu.Unlock()
+
+	// Stop any existing poller.
+	if linuxDragStop != nil {
+		close(linuxDragStop)
+	}
+
+	linuxDragCallback = onDragEnd
+	linuxDragStop = make(chan struct{})
+	linuxLastX, linuxLastY = getWindowPosition()
+
+	go pollWindowPosition(linuxDragStop)
+	log.Println("Linux drag: position poller started")
+}
+
+// notifyLinuxMoveByUs should be called before programmatic moves so the
+// poller doesn't treat them as user drags.
+func notifyLinuxMoveByUs() {
+	linuxDragMu.Lock()
+	linuxMovedByUs = true
+	linuxDragMu.Unlock()
+}
+
+// pollWindowPosition checks the window position every 500ms and fires the
+// callback when it detects a change not initiated by the application.
+func pollWindowPosition(stop chan struct{}) {
+	ticker := time.NewTicker(500 * time.Millisecond)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-stop:
+			return
+		case <-ticker.C:
+			x, y := getWindowPosition()
+
+			linuxDragMu.Lock()
+			movedByUs := linuxMovedByUs
+			linuxMovedByUs = false
+			lastX, lastY := linuxLastX, linuxLastY
+			cb := linuxDragCallback
+			linuxDragMu.Unlock()
+
+			if movedByUs {
+				// Update last known position but don't fire callback.
+				linuxDragMu.Lock()
+				linuxLastX = x
+				linuxLastY = y
+				linuxDragMu.Unlock()
+				continue
+			}
+
+			if x != lastX || y != lastY {
+				linuxDragMu.Lock()
+				linuxLastX = x
+				linuxLastY = y
+				linuxDragMu.Unlock()
+
+				if cb != nil {
+					log.Printf("Linux drag: position changed from (%d,%d) to (%d,%d), saving", lastX, lastY, x, y)
+					cb()
+				}
+			}
+		}
+	}
+}

internal/ui/drag_linux.go

@@ -0,0 +1,6 @@
+//go:build !windows && !linux
+
+package ui
+
+// enableWindowDrag is a no-op on unsupported platforms.
+func enableWindowDrag(_ func()) {}

internal/ui/drag_other.go

@@ -0,0 +1,80 @@
+//go:build windows
+
+package ui
+
+import (
+	"log"
+
+	"golang.org/x/sys/windows"
+)
+
+var (
+	procSetWindowLongPtrW = user32.NewProc("SetWindowLongPtrW")
+	procGetWindowLongPtrW = user32.NewProc("GetWindowLongPtrW")
+	procCallWindowProcW   = user32.NewProc("CallWindowProcW")
+	procSendMessageW      = user32.NewProc("SendMessageW")
+	procReleaseCapture    = user32.NewProc("ReleaseCapture")
+)
+
+const (
+	gwlpWndProc     uintptr = ^uintptr(3) // -4, GWLP_WNDPROC
+	wmLButtonDown           = 0x0201      // WM_LBUTTONDOWN
+	wmNCLButtonDown         = 0x00A1      // WM_NCLBUTTONDOWN
+	wmExitSizeMove          = 0x0232      // WM_EXITSIZEMOVE
+	htCaption               = 2           // HTCAPTION
+)
+
+// dragState holds the subclass state for a single window.
+var dragState struct {
+	origProc  uintptr
+	onDragEnd func()
+}
+
+// dragWndProc is the replacement window procedure that intercepts mouse
+// and move events to implement drag-to-reposition.
+func dragWndProc(hwnd, msg, wParam, lParam uintptr) uintptr {
+	switch msg {
+	case wmLButtonDown:
+		// Initiate a native title-bar drag so Windows handles the move.
+		procReleaseCapture.Call()
+		procSendMessageW.Call(hwnd, wmNCLButtonDown, htCaption, 0)
+		return 0
+
+	case wmExitSizeMove:
+		// The user released the mouse after dragging. Save position.
+		if dragState.onDragEnd != nil {
+			dragState.onDragEnd()
+		}
+	}
+
+	// Forward everything else to the original window procedure.
+	ret, _, _ := procCallWindowProcW.Call(dragState.origProc, hwnd, msg, wParam, lParam)
+	return ret
+}
+
+// enableWindowDrag subclasses the widget window so that left-click anywhere
+// initiates a native window drag, and calls onDragEnd when the drag finishes.
+func enableWindowDrag(onDragEnd func()) {
+	hwnd := findHWND(widgetTitle)
+	if hwnd == 0 {
+		log.Println("enableWindowDrag: could not find HWND")
+		return
+	}
+
+	dragState.onDragEnd = onDragEnd
+
+	// Only subclass once — if origProc is already set, just update the callback.
+	if dragState.origProc != 0 {
+		return
+	}
+
+	cb := windows.NewCallback(dragWndProc)
+	origProc, _, _ := procSetWindowLongPtrW.Call(hwnd, uintptr(gwlpWndProc), cb)
+	if origProc == 0 {
+		// On 32-bit Windows, SetWindowLongPtrW may not exist; try GetWindowLongW path.
+		origProc, _, _ = procGetWindowLongPtrW.Call(hwnd, uintptr(gwlpWndProc))
+		log.Println("enableWindowDrag: SetWindowLongPtrW returned 0, fallback origProc:", origProc)
+	}
+	dragState.origProc = origProc
+	log.Println("enableWindowDrag: window subclassed for drag support")
+}