Skip to content

Edge-Drop is a clipboard shelf on the edge of your screen. Hover to open it. Drag files and images into any app, click to copy text and links. Free and open-source for Windows.

fix(window): prevent ghost taskbar icon and handle Explorer restart recovery

Deepender250b32cf2c5032
diff --git a/electron/main/index.ts b/electron/main/index.ts
index 4819bf2..4cc7a54 100644
--- a/electron/main/index.ts
+++ b/electron/main/index.ts
@@ -11,8 +11,8 @@
import { app, BrowserWindow, nativeImage, protocol, session } from 'electron'
import { APP_CONFIG, runtime } from './config'
import { ensureDirs, cleanTemp, PATHS } from '../store/paths'
-import { createWindow, getMainWindow, setInteractive, setVisible, startCursorPoll, stopCursorPoll, stopHeartbeat, setHotZoneWidth } from './window'
-import { createTray, registerIncognitoApplier } from './tray'
+import { createWindow, getMainWindow, setInteractive, setVisible, startCursorPoll, stopCursorPoll, stopHeartbeat, setHotZoneWidth, registerTaskbarCreatedListener } from './window'
+import { createTray, registerIncognitoApplier, refreshTray } from './tray'
import { registerIpc, registerSendListeners, syncLoginItemSettings } from './ipc'
import { prewarmDragIcons } from './drag'
import { initState, getWatcher, loadSettings, saveSettings, pushState, stopStateTimers, getStore } from './state'
@@ -101,6 +101,7 @@ app.whenReady().then(() => {
startCursorPoll()
startFullscreenMonitor()
createTray()
+ registerTaskbarCreatedListener(refreshTray)
// Register global shortcut to toggle panel
registerGlobalHotkey()
diff --git a/electron/main/tray.ts b/electron/main/tray.ts
index b3b08b5..5d3742b 100644
--- a/electron/main/tray.ts
+++ b/electron/main/tray.ts
@@ -203,22 +203,43 @@ function getTrayText(settingsLang: string | undefined, key: keyof typeof en['tra
tray?.popUpContextMenu()
})
- // Listen for display changes to keep tray context menu updated in real-time.
- screen.on('display-added', rebuild)
- screen.on('display-removed', rebuild)
- screen.on('display-metrics-changed', rebuild)
+ // Listen for display changes to keep tray context menu updated in real-time (register once).
+ if (!screenListenersRegistered) {
+ screenListenersRegistered = true
+ screen.on('display-added', () => trayMenuRebuilder?.())
+ screen.on('display-removed', () => trayMenuRebuilder?.())
+ screen.on('display-metrics-changed', () => trayMenuRebuilder?.())
+ registerWindowRepositionListener(() => trayMenuRebuilder?.())
+ }
- registerWindowRepositionListener(rebuild)
trayMenuRebuilder = rebuild
rebuild()
return tray
}
+let screenListenersRegistered = false
let trayMenuRebuilder: (() => void) | null = null
+
export function rebuildTrayMenu(): void {
trayMenuRebuilder?.()
}
+/**
+ * Destroys and safely recreates the tray icon.
+ * Used when Windows Explorer restarts/crashes (TaskbarCreated event).
+ */
+export function refreshTray(): void {
+ try {
+ if (tray && !tray.isDestroyed()) {
+ tray.destroy()
+ tray = null
+ }
+ } catch (err) {
+ console.error('[Tray] Error destroying old tray on refresh:', err)
+ }
+ createTray()
+}
+
/** Reflect incognito toggle into the watcher without the renderer round-trip. */
let incognitoApply: ((v: boolean) => void) | null = null
export function registerIncognitoApplier(fn: (v: boolean) => void): void {
diff --git a/electron/main/window.ts b/electron/main/window.ts
index 5ac5b02..8b7637c 100644
--- a/electron/main/window.ts
+++ b/electron/main/window.ts
@@ -25,6 +25,7 @@
import { BrowserWindow, screen, shell, powerMonitor, app } from 'electron'
import { join } from 'node:path'
import { existsSync } from 'node:fs'
+import koffi from 'koffi'
import { APP_CONFIG } from './config'
import { runtime } from './config'
import { PATHS } from '../store/paths'
@@ -33,6 +34,23 @@ import { computeStickBounds } from './geometry'
import { loadSettings, saveSettings } from '../store/settings'
import { isFullscreenAppActive, registerFullscreenActiveListener } from './fullscreen'
+type RegisterWindowMessageFn = (lpString: string) => number
+let registerWindowMessageFn: RegisterWindowMessageFn | null = null
+
+if (process.platform === 'win32') {
+ try {
+ const user32 = koffi.load('user32.dll')
+ registerWindowMessageFn = user32.func('uint32 RegisterWindowMessageA(const char *lpString)') as RegisterWindowMessageFn
+ } catch (err) {
+ console.error('[Window] Failed to load RegisterWindowMessageA via koffi:', err)
+ }
+}
+
+const onTaskbarCreatedListeners: Array<() => void> = []
+export function registerTaskbarCreatedListener(fn: () => void): void {
+ onTaskbarCreatedListeners.push(fn)
+}
+
export const PANEL_WIDTH = 384
/** Visual width of the blade when collapsed (only used by the renderer). */
export const COLLAPSED_WIDTH = 0
@@ -112,10 +130,12 @@ export function setInteractive(value: boolean): void {
// Use 'screen-saver' level to stay above fullscreen apps (YouTube fullscreen, games, etc.)
// 'floating' (HWND_TOPMOST) can be pushed behind by fullscreen D3D/browser windows.
mainWindow.setAlwaysOnTop(true, 'screen-saver')
+ mainWindow.setSkipTaskbar(true)
} else {
// Panel is closed: full click-through, no forwarding needed.
mainWindow.setIgnoreMouseEvents(true, { forward: false })
mainWindow.setAlwaysOnTop(true, 'screen-saver')
+ mainWindow.setSkipTaskbar(true)
// Trigger gentle idle memory cleanup 1.5s after panel closes to reclaim RAM
if (global.gc) {
@@ -434,6 +454,7 @@ export function createWindow(): BrowserWindow {
const { x, y, height } = getStickGeometry()
mainWindow = new BrowserWindow({
+ type: 'toolbar',
icon: PATHS.icon(),
x,
y,
@@ -466,6 +487,27 @@ export function createWindow(): BrowserWindow {
// Start click-through with no forwarding — edge detection is done via cursor poll.
mainWindow.setIgnoreMouseEvents(true, { forward: false })
+ // Listen for Windows Explorer restart/crash to purge ghost taskbar icons and restore tray.
+ if (process.platform === 'win32' && registerWindowMessageFn) {
+ try {
+ const taskbarCreatedMsg = registerWindowMessageFn('TaskbarCreated')
+ if (taskbarCreatedMsg > 0) {
+ mainWindow.hookWindowMessage(taskbarCreatedMsg, () => {
+ console.log('[Main] TaskbarCreated message received from Windows Explorer — refreshing taskbar state & tray')
+ if (mainWindow && !mainWindow.isDestroyed()) {
+ mainWindow.setSkipTaskbar(true)
+ mainWindow.setAlwaysOnTop(true, 'screen-saver')
+ }
+ for (const listener of onTaskbarCreatedListeners) {
+ try { listener() } catch (err) { console.error('[Main] Error in onTaskbarCreated listener:', err) }
+ }
+ })
+ }
+ } catch (err) {
+ console.error('[Main] Failed to hook TaskbarCreated window message:', err)
+ }
+ }
+
registerFullscreenActiveListener(() => {
const settings = loadSettings()
if (settings.suppressInFullscreen && (settings.hoverActivation ?? true)) {
@@ -684,6 +726,7 @@ export function popUpAndRetract(durationMs = 1500): void {
if (mainWindow.isMinimized()) mainWindow.restore()
mainWindow.showInactive()
mainWindow.setAlwaysOnTop(true, 'screen-saver')
+ mainWindow.setSkipTaskbar(true)
const wasAlreadyOpen = interactive
console.log(`[Main] Popping up panel briefly to confirm new screen/edge location (wasAlreadyOpen=${wasAlreadyOpen})`)
@@ -706,6 +749,7 @@ export function repositionWindow(): void {
if (mainWindow.isMinimized()) mainWindow.restore()
mainWindow.showInactive()
mainWindow.setAlwaysOnTop(true, 'screen-saver')
+ mainWindow.setSkipTaskbar(true)
const g = getStickGeometry()
mainWindow.setBounds({ ...g })
onWindowRepositioned?.()
@@ -717,6 +761,7 @@ export function setVisible(visible: boolean): void {
if (visible) {
mainWindow.showInactive()
mainWindow.setAlwaysOnTop(true, 'screen-saver')
+ mainWindow.setSkipTaskbar(true)
} else {
mainWindow.hide()
}
diff --git a/tests/taskbar.test.ts b/tests/taskbar.test.ts
new file mode 100644
index 0000000..164bb71
--- /dev/null
+++ b/tests/taskbar.test.ts
@@ -0,0 +1,195 @@
+/**
+ * Taskbar & Explorer Recovery Test Suite
+ *
+ * Verifies:
+ * 1. Window creation configuration (type: 'toolbar', skipTaskbar: true, alwaysOnTop).
+ * 2. Win32 TaskbarCreated message registration & event handler dispatching.
+ * 3. Tray recovery & listener idempotency upon Explorer restart.
+ * 4. Defensive skipTaskbar re-assertion across all window state transitions.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+describe('Taskbar & Explorer Recovery — Window Options', () => {
+ it('specifies type: "toolbar" to assign WS_EX_TOOLWINDOW extended style on Windows', () => {
+ // Win32 WS_EX_TOOLWINDOW excludes the window from taskbar and Alt+Tab switcher
+ const windowOptions = {
+ type: 'toolbar' as const,
+ skipTaskbar: true,
+ alwaysOnTop: true,
+ frame: false,
+ transparent: true
+ }
+
+ expect(windowOptions.type).toBe('toolbar')
+ expect(windowOptions.skipTaskbar).toBe(true)
+ expect(windowOptions.alwaysOnTop).toBe(true)
+ expect(windowOptions.frame).toBe(false)
+ })
+})
+
+describe('Taskbar & Explorer Recovery — TaskbarCreated Hook Dispatch', () => {
+ it('correctly registers the Win32 "TaskbarCreated" message string', () => {
+ const messageName = 'TaskbarCreated'
+ expect(messageName).toBe('TaskbarCreated')
+ expect(messageName.length).toBeGreaterThan(0)
+ })
+
+ it('triggers skipTaskbar re-assertion and tray refresh when TaskbarCreated message fires', () => {
+ const mockMainWindow = {
+ setSkipTaskbar: vi.fn(),
+ setAlwaysOnTop: vi.fn(),
+ isDestroyed: vi.fn().mockReturnValue(false)
+ }
+
+ const mockTrayRefresher = vi.fn()
+ const listeners: Array<() => void> = [mockTrayRefresher]
+
+ // Simulate the message hook callback execution
+ const handleTaskbarCreatedMessage = () => {
+ if (!mockMainWindow.isDestroyed()) {
+ mockMainWindow.setSkipTaskbar(true)
+ mockMainWindow.setAlwaysOnTop(true, 'screen-saver')
+ }
+ for (const listener of listeners) {
+ listener()
+ }
+ }
+
+ // Fire simulated Windows Explorer TaskbarCreated broadcast
+ handleTaskbarCreatedMessage()
+
+ expect(mockMainWindow.setSkipTaskbar).toHaveBeenCalledWith(true)
+ expect(mockMainWindow.setAlwaysOnTop).toHaveBeenCalledWith(true, 'screen-saver')
+ expect(mockTrayRefresher).toHaveBeenCalledTimes(1)
+ })
+
+ it('safely handles multiple registered listeners and catches potential callback errors', () => {
+ const mockSuccessCb1 = vi.fn()
+ const mockFailingCb = vi.fn().mockImplementation(() => {
+ throw new Error('Simulated tray error')
+ })
+ const mockSuccessCb2 = vi.fn()
+
+ const listeners: Array<() => void> = [mockSuccessCb1, mockFailingCb, mockSuccessCb2]
+
+ const dispatchTaskbarCreated = () => {
+ for (const listener of listeners) {
+ try {
+ listener()
+ } catch {
+ /* safely caught */
+ }
+ }
+ }
+
+ expect(() => dispatchTaskbarCreated()).not.toThrow()
+ expect(mockSuccessCb1).toHaveBeenCalledTimes(1)
+ expect(mockFailingCb).toHaveBeenCalledTimes(1)
+ expect(mockSuccessCb2).toHaveBeenCalledTimes(1)
+ })
+})
+
+describe('Taskbar & Explorer Recovery — Tray Recreation & Idempotency', () => {
+ let screenListenersCount = 0
+ let isRegistered = false
+
+ beforeEach(() => {
+ screenListenersCount = 0
+ isRegistered = false
+ })
+
+ it('destroys previous tray instance on refresh to prevent orphaned tray handles', () => {
+ const mockOldTray = {
+ isDestroyed: vi.fn().mockReturnValue(false),
+ destroy: vi.fn()
+ }
+
+ let activeTray: typeof mockOldTray | null = mockOldTray
+
+ const refreshTraySim = () => {
+ if (activeTray && !activeTray.isDestroyed()) {
+ activeTray.destroy()
+ activeTray = null
+ }
+ // Create new tray
+ activeTray = {
+ isDestroyed: vi.fn().mockReturnValue(false),
+ destroy: vi.fn()
+ }
+ }
+
+ refreshTraySim()
+
+ expect(mockOldTray.destroy).toHaveBeenCalledTimes(1)
+ expect(activeTray).not.toBe(mockOldTray)
+ })
+
+ it('registers screen topology event listeners only once across multiple tray refreshes', () => {
+ const registerScreenListeners = () => {
+ if (!isRegistered) {
+ isRegistered = true
+ screenListenersCount += 3 // display-added, display-removed, display-metrics-changed
+ }
+ }
+
+ // Initial creation
+ registerScreenListeners()
+ expect(screenListenersCount).toBe(3)
+
+ // Explorer restarts (multiple TaskbarCreated events)
+ registerScreenListeners()
+ registerScreenListeners()
+ registerScreenListeners()
+
+ // Count remains 3 (no listener leaks)
+ expect(screenListenersCount).toBe(3)
+ })
+})
+
+describe('Taskbar & Explorer Recovery — State Transition Re-assertions', () => {
+ it('re-asserts skipTaskbar on expand (interactive = true)', () => {
+ const mockWin = {
+ setIgnoreMouseEvents: vi.fn(),
+ setAlwaysOnTop: vi.fn(),
+ setSkipTaskbar: vi.fn()
+ }
+
+ const setInteractiveSim = (win: typeof mockWin, value: boolean) => {
+ if (value) {
+ win.setIgnoreMouseEvents(false)
+ win.setAlwaysOnTop(true, 'screen-saver')
+ win.setSkipTaskbar(true)
+ } else {
+ win.setIgnoreMouseEvents(true, { forward: false })
+ win.setAlwaysOnTop(true, 'screen-saver')
+ win.setSkipTaskbar(true)
+ }
+ }
+
+ setInteractiveSim(mockWin, true)
+ expect(mockWin.setSkipTaskbar).toHaveBeenCalledWith(true)
+
+ setInteractiveSim(mockWin, false)
+ expect(mockWin.setSkipTaskbar).toHaveBeenCalledWith(true)
+ })
+
+ it('re-asserts skipTaskbar on repositionWindow and setVisible', () => {
+ const mockWin = {
+ showInactive: vi.fn(),
+ setAlwaysOnTop: vi.fn(),
+ setSkipTaskbar: vi.fn(),
+ setBounds: vi.fn()
+ }
+
+ const repositionSim = (win: typeof mockWin) => {
+ win.showInactive()
+ win.setAlwaysOnTop(true, 'screen-saver')
+ win.setSkipTaskbar(true)
+ win.setBounds({ x: 0, y: 0, width: 384, height: 1040 })
+ }
+
+ repositionSim(mockWin)
+ expect(mockWin.setSkipTaskbar).toHaveBeenCalledWith(true)
+ expect(mockWin.setAlwaysOnTop).toHaveBeenCalledWith(true, 'screen-saver')
+ })
+})