shell02_wallpaper_engine.cpp

#ifndef UNICODE
#define UNICODE
#endif

#ifndef _UNICODE
#define _UNICODE
#endif

// windows.h MUST come first on MinGW — it defines HRESULT, CALLBACK,
// DECLSPEC_IMPORT etc. that all other Win32 headers depend on.
#include <windows.h>
#include <windowsx.h>
#include <winuser.h>

#include "json.hpp"
#include <algorithm>
#include <commctrl.h>
#include <dwmapi.h>
#include <fstream>
#include <gdiplus.h>
#include <initguid.h>
#include <map>
#include <powrprof.h>
#include <psapi.h>
#include <shellapi.h>
#include <shlguid.h>
#include <shlobj.h>
#include <set>
#include <string>
#include <tchar.h>
#include <tlhelp32.h>
#include <vector>
#ifdef NO_JSON
void SaveDesktopPositions() {}
void LoadDesktopPositions() {}
void SaveStartMenuPositions() {}
void LoadStartMenuPositions() {}
void SaveTaskbarConfig() {}
void LoadTaskbarConfig() {}
void LoadWindowPositions() {}
#endif

#pragma comment(lib, "shell32.lib")
#pragma comment(lib, "comctl32.lib")
#pragma comment(lib, "ole32.lib")
#pragma comment(lib, "uuid.lib")
#pragma comment(lib, "gdiplus.lib")
#pragma comment(lib, "dwmapi.lib")
#pragma comment(lib, "PowrProf.lib")

HWND g_hDesktopWnd = NULL;
HWND g_hTaskbarWnd = NULL;
HWND g_hStartMenuWnd = NULL;
HWND g_hWeWorkerW =
    NULL; // WE's render-target WorkerW — we stay just above this
static HWINEVENTHOOK g_hWinEventHook = NULL;
HINSTANCE g_hInst = NULL;
int g_taskbarHeight = 64;
bool g_taskbarVisible = true; // Track taskbar visibility state
bool g_taskbarVisibleBeforeWinKey =
    true; // Track taskbar state before Windows key press
bool g_startMenuOpenedByWinKey =
    false; // Track if start menu was opened by Windows key
static bool g_fullscreenActive = false; // Track if a fullscreen app is running

// Keyboard hook for Windows key
static HHOOK g_keyboardHook = NULL;
static bool g_winKeyPressed = false;
// Set true before injecting Win+combo so the hook lets it pass through
static bool g_suppressWinKeyHook = false;

// AppBar callback message
#define APPBAR_CALLBACK (WM_APP + 1)

// Custom colors for taskbar and start menu
static COLORREF g_taskbarColor = RGB(45, 45, 48);     // Default dark gray
static COLORREF g_startMenuColor = RGB(50, 100, 160); // Default blue

#define IDM_ITEM_OPEN 40001
#define IDM_ITEM_PROPERTIES 40002
#define IDM_DESKTOP_REFRESH 40003
#define IDM_RESTART_SHELL 40005
#define IDM_ITEM_RENAME 40006

// New command IDs
#define IDM_VIEW_LARGE 50001
#define IDM_VIEW_MEDIUM 50002
#define IDM_VIEW_SMALL 50003

#define IDM_SORT_NAME 50011
#define IDM_SORT_TYPE 50012
#define IDM_SORT_DATE 50013

#define IDM_TOGGLE_SHOW_ICONS 50021
#define IDM_AUTO_ARRANGE 50022
#define IDM_ALIGN_TO_GRID 50023
#define IDM_CHANGE_BACKGROUND 50024
#define IDM_CHANGE_TASKBAR_COLOR 50025
#define IDM_CHANGE_STARTMENU_COLOR 50026

int g_rightClickSelection = -1;

// Icon/layout constants
// ICON_SIZE_DEFAULT is the pixel size for the default "medium" view mode (mode
// index 1).
const int ICON_SIZE_DEFAULT = 48;
const int ICON_X_SPACING_DEFAULT = 120;
const int ICON_Y_SPACING_DEFAULT = 100;
const int ICON_X_START = 50;
const int ICON_Y_START = 20;

// Current view state
int g_viewMode = 1; // Medium by default
int g_iconSize = ICON_SIZE_DEFAULT;
int g_iconXSpacing = ICON_X_SPACING_DEFAULT;
int g_iconYSpacing = ICON_Y_SPACING_DEFAULT;
bool g_showIcons = true;
bool g_autoArrange = false;

static WNDPROC g_origDesktopProc = NULL;
static WNDPROC g_realDesktopProc = NULL; // The actual DesktopWndProc address
static IContextMenu2 *g_pcm2 = NULL;
static IContextMenu3 *g_pcm3 = NULL;
static Gdiplus::GdiplusStartupInput gdiplusStartupInput;
static ULONG_PTR gdiplusToken;

// Desktop background image
static Gdiplus::Bitmap *g_backgroundImage = NULL;
static std::wstring g_backgroundPath;

struct DesktopItem {
  wchar_t name[MAX_PATH];
  wchar_t path[MAX_PATH];
  HICON hIcon;
  FILETIME ftWrite;
  std::wstring extension;
  int x; // pixel position for custom placement
  int y;
  bool hasPos; // whether x/y have been assigned
};
std::vector<DesktopItem> g_desktopItems;

// Structure for sidebar items with positions
struct SidebarItemInfo {
  bool isFolder;
  std::wstring name;
  std::wstring fullPath;
  int yPos; // Actual screen position
  int height;
};
static std::vector<SidebarItemInfo> g_sidebarItems;

// Structure for running apps
struct RunningApp {
  DWORD processId;
  HWND hwnd;
  std::wstring exePath;
  std::wstring displayName;
  HICON hIcon;
  bool visible;
};
static std::vector<RunningApp> g_runningApps;

// For Windows 11 taskbar behavior
static HWND g_lastForegroundWindow = NULL;
static std::map<HWND, bool> g_windowMinimizedState;

// ==================== SYSTEM TRAY IMPROVEMENTS ====================

// Structure for REAL system tray icons (using Windows Shell API)
struct RealTrayIcon {
  NOTIFYICONDATAW nid;  // Original notify data
  std::wstring tooltip; // Tooltip text
  HICON hIcon;          // Current icon
  DWORD processId;      // Process ID
  HWND hWnd;            // Owner window
  UINT uID;             // Icon ID
  GUID guid;            // GUID (for modern apps)
  bool hidden;          // Hidden in overflow
  int trayIndex;        // Index in tray display
  RECT displayRect;     // Display rectangle
  bool isModernApp;     // UWP/Modern app
  std::wstring appName; // App name
};

static std::vector<RealTrayIcon> g_realTrayIcons;
static HWND g_trayNotifyWnd = NULL;
static bool g_trayIconsInitialized = false;
static int g_trayIconSize = 20;   // Smaller size for tray icons
static int g_trayIconSpacing = 8; // Increased from 4 to 8 for better spacing
static bool g_showTrayIcons = true;

// Structure for our drawn tray icons
struct TrayIcon {
  std::wstring name;
  HICON hIcon;
  int x;
  int y;
  int width;
  int height;
  bool isRealIcon; // Is this a real system tray icon?
  UINT realIconId; // Original icon ID if real
  HWND realOwner;  // Owner window if real
};
static std::vector<TrayIcon> g_trayIcons;

// Hidden icons tracking
static int g_chevronX = 0;
static int g_chevronY = 0;
static int g_chevronSize = 40;
static bool g_hasHiddenIcons = false;
static std::vector<int> g_hiddenIconIndices; // Indices of hidden real icons

// ==================== HELPER FUNCTIONS ====================

// Gets a properly sized icon using SHGetImageList — no pixelation.
// Uses SHIL_EXTRALARGE (48x48) or SHIL_JUMBO (256x256) instead of the
// blurry 32x32 that SHGetFileInfo+SHGFI_LARGEICON returns.
// Caller is responsible for DestroyIcon().
// MinGW doesn't fully declare IImageList — define the GUID manually.
// {46EB5926-582E-4017-9FDF-E8998DAA0950}
static const GUID CLSID_IImageList = {
  0x46eb5926, 0x582e, 0x4017,
  { 0x9f, 0xdf, 0xe8, 0x99, 0x8d, 0xaa, 0x09, 0x50 }
};

static HICON GetIconForPath(const std::wstring &path, int size) {
  int shil = SHIL_LARGE;                   // 32x32
  if (size >= 48)  shil = SHIL_EXTRALARGE; // 48x48
  if (size >= 256) shil = SHIL_JUMBO;      // 256x256

  SHFILEINFOW sfi = {};
  if (!SHGetFileInfoW(path.c_str(), 0, &sfi, sizeof(sfi), SHGFI_SYSICONINDEX))
    return NULL;

  // Use HIMAGELIST + ImageList_GetIcon to avoid MinGW's incomplete IImageList
  HIMAGELIST hil = NULL;
  if (FAILED(SHGetImageList(shil, CLSID_IImageList, (void **)&hil)) || !hil)
    return NULL;

  HICON hIcon = ImageList_GetIcon(hil, sfi.iIcon, ILD_TRANSPARENT);
  return hIcon;
}

// Returns true if the given file path should be blocked from appearing in the
// taskbar, start menu, or being launched. Centralises the previously duplicated
// explorer/shell filtering that was copy-pasted 5+ times across the codebase.
static bool IsBlockedApp(const std::wstring &appPath) {
  size_t slash = appPath.find_last_of(L"\\/");
  std::wstring fileName =
      (slash != std::wstring::npos) ? appPath.substr(slash + 1) : appPath;

  std::wstring lower = fileName;
  std::transform(lower.begin(), lower.end(), lower.begin(), ::towlower);

  return lower.find(L"explorer") != std::wstring::npos ||
         lower.find(L"shell.exe") != std::wstring::npos ||
         lower.find(L"shell.lnk") != std::wstring::npos ||
         lower.find(L"customshell") != std::wstring::npos;
}

std::wstring GetAppDataPath() {
  PWSTR pszPath = NULL;
  std::wstring result;
  if (SUCCEEDED(
          SHGetKnownFolderPath(FOLDERID_RoamingAppData, 0, NULL, &pszPath))) {
    result = pszPath;
    result += L"\\CustomShell";
    CoTaskMemFree(pszPath);
  }
  return result;
}

void SaveDesktopPositions() {
  try {
    nlohmann::json jPositions = nlohmann::json::array();
    for (const auto &item : g_desktopItems) {
      nlohmann::json jItem;
      char pathBuf[MAX_PATH];
      WideCharToMultiByte(CP_UTF8, 0, item.path, -1, pathBuf, sizeof(pathBuf),
                          NULL, NULL);
      jItem["path"] = pathBuf;
      jItem["x"] = item.x;
      jItem["y"] = item.y;
      jPositions.push_back(jItem);
    }

    std::wstring appDataPath = GetAppDataPath();
    CreateDirectoryW(appDataPath.c_str(), NULL);
    std::wstring configPath = appDataPath + L"\\positions.json";
    std::ofstream file(configPath.c_str());
    if (file.is_open()) {
      file << jPositions.dump(2);
      file.close();
    }
  } catch (...) {
#ifdef _DEBUG
    OutputDebugStringW(L"CustomShell: exception swallowed\n");
#endif
  }
}

void LoadDesktopPositions() {
  try {
    std::wstring appDataPath = GetAppDataPath();
    std::wstring configPath = appDataPath + L"\\positions.json";
    std::ifstream file(configPath.c_str());
    if (file.is_open()) {
      nlohmann::json jPositions;
      file >> jPositions;
      file.close();

      for (const auto &jItem : jPositions) {
        std::string pathStr = jItem["path"];
        wchar_t pathW[MAX_PATH];
        MultiByteToWideChar(CP_UTF8, 0, pathStr.c_str(), -1, pathW, MAX_PATH);

        for (auto &item : g_desktopItems) {
          if (_wcsicmp(item.path, pathW) == 0) {
            item.x = jItem["x"];
            item.y = jItem["y"];
            item.hasPos = true;
            break;
          }
        }
      }
    }
  } catch (...) {
#ifdef _DEBUG
    OutputDebugStringW(L"CustomShell: exception swallowed\n");
#endif
  }
}

void DrawIconWithGDIPlus(Gdiplus::Graphics *g, HICON hIcon, int x, int y,
                         int size) {
  if (!g || !hIcon)
    return;

  ICONINFO iconInfo;
  if (GetIconInfo(hIcon, &iconInfo)) {
    HDC hdc = g->GetHDC();
    if (hdc) {
      DrawIconEx(hdc, x, y, hIcon, size, size, 0, NULL, DI_NORMAL);
      g->ReleaseHDC(hdc);
    }
    if (iconInfo.hbmColor)
      DeleteObject(iconInfo.hbmColor);
    if (iconInfo.hbmMask)
      DeleteObject(iconInfo.hbmMask);
  }
}

static std::vector<std::wstring>
    g_pinnedApps; // Paths of pinned apps in start menu
static std::vector<std::wstring>
    g_removedApps; // Apps removed from start menu (don't show)
static std::wstring g_currentSidebarFolder =
    L"C:\\ProgramData\\Microsoft\\Windows\\Start Menu\\Programs"; // Current
                                                                  // sidebar
                                                                  // folder
static int g_sidebarScrollOffset = 0;

// Structure for sidebar items (mixed folders and files)
struct SidebarItem {
  bool isFolder;
  std::wstring name;
  std::wstring fullPath;
};

// Structure for taskbar icons
struct TaskbarIcon {
  std::wstring path;
  HICON hIcon;
  int x; // x position
  int y;
  int width;
  int height;
  bool visible; // whether to show on taskbar
};
static std::vector<TaskbarIcon> g_taskbarIcons;
static std::vector<std::wstring>
    g_taskbarPinned; // Apps pinned to taskbar (persisted)

// Drag state for moving icons (desktop)
static bool g_dragging = false;
static int g_dragIndex = -1;
static int g_dragOffsetX = 0;
static int g_dragOffsetY = 0;

// Drag state for Start menu tiles
static bool g_startMenuDragging = false;
static int g_startMenuDragIndex = -1;
static int g_startMenuDragOffsetX = 0;
static int g_startMenuDragOffsetY = 0;
static std::vector<int> g_tilePositionsX; // Store tile X positions
static std::vector<int> g_tilePositionsY; // Store tile Y positions
static int g_startMenuScrollOffset = 0;   // Scroll offset for main area
static int g_hoveredIcon = -1;            // Track which icon is under cursor

// Forward declarations
void ResizeShellWindows(int dpi = 96);
void ShowShellContextMenu(HWND hwnd, POINT pt, LPCWSTR pszPath);
void ShowDesktopContextMenu(HWND hwnd, POINT pt);
void LaunchApp(LPCWSTR path);
void LaunchExplorer();
void UpdateViewMode(int mode);
void SortByName();
void SortByTypeThenName();
void SortByDateDesc();
void AlignIconsToGrid();
void PopulateDesktopIcons();
void ResetDesktopPositions();
void SaveDesktopPositions();
void LoadDesktopPositions();
void PopulateStartMenuApps();
void DrawIconWithGDIPlus(Gdiplus::Graphics *g, HICON hIcon, int x, int y,
                         int size);
std::wstring GetAppDataPath();
void RegisterAppBar(HWND hwnd);
void SetAppBarPos(HWND hwnd);
void UnregisterAppBar(HWND hwnd);
static void ForceFocusToDesktop();
static void BringShellToTopmost();
static void RestoreShellZOrder();
void CALLBACK WinEventProc(HWINEVENTHOOK hHook, DWORD event, HWND hwnd,
                           LONG idObject, LONG idChild, DWORD dwEventThread,
                           DWORD dwmsEventTime);
// Progman window proc that handles Wallpaper Engine's 0x052C spawn message.
// WE sends this undocumented message to the Progman window so it creates a
// WorkerW below itself for WE to render animated wallpapers into.
// Without handling this, WE cannot find a valid render target.
LRESULT CALLBACK ProgmanWndProc(HWND hwnd, UINT msg, WPARAM wParam,
                                LPARAM lParam) {
  // 0x052C is Wallpaper Engine's undocumented message that causes Progman to
  // spawn a WorkerW render target. We pass it through DefWindowProc so it
  // performs its internal work, then return the result. Previously this called
  // DefWindowProc twice (once discarded, once returned), which was redundant.
  return DefWindowProcW(hwnd, msg, wParam, lParam);
}

// New functions for running apps
void UpdateRunningAppsList();
void AddCommonTrayIcons();
std::wstring GetAppExeName(LPCWSTR appPath);
void DestroyTaskbar();
void RecreateTaskbar();
void ResizeShellWindows(int dpi);

// ==================== SYSTEM TRAY FUNCTIONS ====================

// Find the real Windows tray notification window
HWND FindTrayNotifyWnd() {
  HWND hTrayWnd = FindWindowW(L"Shell_TrayWnd", NULL);
  if (!hTrayWnd)
    return NULL;

  // Look for TrayNotifyWnd inside Shell_TrayWnd
  HWND hTrayNotifyWnd = FindWindowExW(hTrayWnd, NULL, L"TrayNotifyWnd", NULL);
  if (!hTrayNotifyWnd) {
    // Try alternative names for newer Windows versions
    hTrayNotifyWnd = FindWindowExW(
        hTrayWnd, NULL, L"Windows.UI.Composition.DesktopWindowContentBridge",
        NULL);
  }
  return hTrayNotifyWnd;
}

// Hook into Windows Shell to get tray icons
BOOL CALLBACK EnumTrayWindowsProc(HWND hwnd, LPARAM lParam) {
  wchar_t className[256];
  GetClassNameW(hwnd, className, ARRAYSIZE(className));

  // Collect the tray notify / overflow window handle so callers can use it.
  // Previously both branches returned TRUE without storing anything — now we
  // write the found HWND back through lParam so the caller receives it.
  if (wcsstr(className, L"NotifyIconOverflowWindow")) {
    HWND *pResult = reinterpret_cast<HWND *>(lParam);
    if (pResult)
      *pResult = hwnd;
    return FALSE; // Stop enumeration — we found what we needed
  }
  return TRUE; // Continue searching
}

// Get process name from PID
std::wstring GetProcessName(DWORD processId) {
  HANDLE hProcess =
      OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, processId);
  if (hProcess) {
    wchar_t exePath[MAX_PATH] = {0};
    DWORD pathSize = MAX_PATH;

    if (QueryFullProcessImageNameW(hProcess, 0, exePath, &pathSize)) {
      CloseHandle(hProcess);
      std::wstring pathStr = exePath;
      size_t lastSlash = pathStr.find_last_of(L"\\");
      if (lastSlash != std::wstring::npos) {
        return pathStr.substr(lastSlash + 1);
      }
      return pathStr;
    }
    CloseHandle(hProcess);
  }
  return L"Unknown";
}

// Get window text safely
std::wstring GetWindowTextSafe(HWND hwnd) {
  wchar_t buffer[256];
  int len = GetWindowTextW(hwnd, buffer, 256);
  if (len > 0) {
    return std::wstring(buffer);
  }
  return L"";
}

// Simulate getting tray icons by enumerating windows with tray-like properties
void PopulateRealTrayIcons() {
  // Clear old icons
  for (auto &icon : g_realTrayIcons) {
    if (icon.hIcon) {
      DestroyIcon(icon.hIcon);
    }
  }
  g_realTrayIcons.clear();

  // Clear our drawn tray icons
  for (auto &icon : g_trayIcons) {
    if (icon.hIcon && !icon.isRealIcon) {
      DestroyIcon(icon.hIcon);
    }
  }
  g_trayIcons.clear();

  // ADD SYSTEM ICONS FIRST so they always show
  AddCommonTrayIcons();

  // Get all top-level windows and look for tray-like behavior
  std::vector<HWND> potentialTrayWindows;

  EnumWindows(
      [](HWND hwnd, LPARAM lParam) -> BOOL {
        auto &windows = *reinterpret_cast<std::vector<HWND> *>(lParam);

        if (!IsWindowVisible(hwnd))
          return TRUE;

        // Get window class
        wchar_t className[256];
        GetClassNameW(hwnd, className, ARRAYSIZE(className));

        // Look for windows that might have tray icons
        // Many apps create hidden windows for tray notifications
        DWORD processId;
        GetWindowThreadProcessId(hwnd, &processId);

        // Check window style and extended style
        LONG style = GetWindowLongW(hwnd, GWL_STYLE);
        LONG exStyle = GetWindowLongW(hwnd, GWL_EXSTYLE);

        // Hidden windows with tooltip styles might be tray owners
        if ((style & WS_POPUP) && (exStyle & WS_EX_TOOLWINDOW)) {
          windows.push_back(hwnd);
        }

        return TRUE;
      },
      reinterpret_cast<LPARAM>(&potentialTrayWindows));

  // Now try to communicate with these windows to get tray data
  // This is a simplified approach - real implementation would use Shell Hook
  for (HWND hwnd : potentialTrayWindows) {
    DWORD processId;
    GetWindowThreadProcessId(hwnd, &processId);

    // Try to get the window's icon
    HICON hIcon = (HICON)SendMessageW(hwnd, WM_GETICON, ICON_SMALL, 0);
    if (!hIcon) {
      hIcon = (HICON)SendMessageW(hwnd, WM_GETICON, ICON_BIG, 0);
    }
    if (!hIcon) {
      hIcon = (HICON)GetClassLongPtrW(hwnd, GCLP_HICONSM);
    }

    if (hIcon) {
      RealTrayIcon trayIcon = {};
      trayIcon.hWnd = hwnd;
      trayIcon.processId = processId;
      trayIcon.hIcon = CopyIcon(hIcon); // Copy the icon
      trayIcon.tooltip = GetWindowTextSafe(hwnd);
      trayIcon.appName = GetProcessName(processId);
      trayIcon.hidden = false;

      g_realTrayIcons.push_back(trayIcon);
    }
  }

  // NOW add the detected real tray icons AFTER system icons
  for (size_t i = 0; i < g_realTrayIcons.size(); ++i) {
    TrayIcon ti;
    ti.name = g_realTrayIcons[i].appName;
    ti.hIcon = CopyIcon(g_realTrayIcons[i].hIcon);
    ti.isRealIcon = true;
    ti.realOwner = g_realTrayIcons[i].hWnd;
    ti.width = g_trayIconSize;
    ti.height = g_trayIconSize;
    g_trayIcons.push_back(ti);
  }
}

void AddCommonTrayIcons() {
  // Load shell32 once for all icon lookups
  HMODULE hShell32 = LoadLibraryW(L"shell32.dll");

  // Volume icon
  {
    TrayIcon ti;
    ti.name = L"Volume";
    ti.isRealIcon = false;
    ti.hIcon = hShell32 ? (HICON)LoadImageW(hShell32, MAKEINTRESOURCE(168),
                                             IMAGE_ICON, g_trayIconSize,
                                             g_trayIconSize, LR_SHARED)
                        : NULL;
    ti.width = g_trayIconSize;
    ti.height = g_trayIconSize;
    g_trayIcons.push_back(ti);
  }

  // Network icon
  {
    TrayIcon ti;
    ti.name = L"Network";
    ti.isRealIcon = false;
    ti.hIcon = hShell32 ? (HICON)LoadImageW(hShell32, MAKEINTRESOURCE(17),
                                             IMAGE_ICON, g_trayIconSize,
                                             g_trayIconSize, LR_SHARED)
                        : NULL;
    ti.width = g_trayIconSize;
    ti.height = g_trayIconSize;
    g_trayIcons.push_back(ti);
  }

  // Power/battery
  {
    TrayIcon ti;
    ti.name = L"Power";
    ti.isRealIcon = false;
    ti.hIcon = hShell32 ? (HICON)LoadImageW(hShell32, MAKEINTRESOURCE(244),
                                             IMAGE_ICON, g_trayIconSize,
                                             g_trayIconSize, LR_SHARED)
                        : NULL;
    ti.width = g_trayIconSize;
    ti.height = g_trayIconSize;
    g_trayIcons.push_back(ti);
  }

  if (hShell32)
    FreeLibrary(hShell32);

  // Clock (last, on the right)
  {
    TrayIcon ti;
    ti.name = L"Clock";
    ti.isRealIcon = false;
    ti.hIcon = NULL; // Will draw text
    ti.width = 55;   // Wider for bigger time display (increased from 40)
    ti.height = g_trayIconSize;
    g_trayIcons.push_back(ti);
  }
}

// Draw time in tray
void DrawTrayTime(Gdiplus::Graphics *g, int x, int y, int width, int height) {
  SYSTEMTIME st;
  GetLocalTime(&st);

  wchar_t timeStr[64];
  wsprintfW(timeStr, L"%02d:%02d", st.wHour, st.wMinute);

  Gdiplus::FontFamily fontFamily(L"Segoe UI");
  Gdiplus::Font timeFont(&fontFamily, 13, Gdiplus::FontStyleRegular,
                         Gdiplus::UnitPixel); // Increased from 11 to 13
  Gdiplus::SolidBrush textBrush(Gdiplus::Color(255, 240, 240, 240));

  Gdiplus::RectF textRect(x, y, width, height);
  Gdiplus::StringFormat format;
  format.SetAlignment(Gdiplus::StringAlignmentCenter);
  format.SetLineAlignment(Gdiplus::StringAlignmentCenter);

  g->DrawString(timeStr, -1, &timeFont, textRect, &format, &textBrush);
}

// Handle tray icon clicks
void HandleTrayIconClick(int index, bool rightClick) {
  if (index < 0 || index >= (int)g_trayIcons.size())
    return;

  TrayIcon &icon = g_trayIcons[index];

  if (icon.isRealIcon && icon.realOwner) {
    // Notify the real tray icon owner using the callback message registered
    // in its NOTIFYICONDATA (uCallbackMessage). Guessing WM_USER+1 was wrong —
    // we must use the ID the app registered so it can dispatch the event.
    // The lParam carries the mouse notification; wParam is the icon ID.
    UINT callbackMsg = icon.realIconId; // icon ID stored at registration time
    if (rightClick) {
      // Use WM_CONTEXTMENU so the owner can position its context menu
      // correctly.
      POINT cursorPos;
      GetCursorPos(&cursorPos);
      SendMessageW(icon.realOwner, WM_CONTEXTMENU, (WPARAM)icon.realOwner,
                   MAKELPARAM(cursorPos.x, cursorPos.y));
    } else {
      // Deliver standard tray-click notifications using the app's registered
      // callback message. If callbackMsg is 0 fall back to NIN_SELECT.
      UINT msg = (callbackMsg != 0) ? callbackMsg : WM_APP;
      SendMessageW(icon.realOwner, msg, (WPARAM)icon.realIconId,
                   MAKELPARAM(WM_LBUTTONDOWN, icon.realIconId));
      SendMessageW(icon.realOwner, msg, (WPARAM)icon.realIconId,
                   MAKELPARAM(WM_LBUTTONUP, icon.realIconId));
    }
  } else {
    // Handle our built-in icons
    if (icon.name == L"Volume") {
      if (rightClick) {
        // Open sound control panel
        ShellExecuteW(NULL, L"open", L"control.exe", L"mmsys.cpl", NULL,
                      SW_SHOW);
      } else {
        // Open legacy volume control that works without explorer
        ShellExecuteW(NULL, L"open", L"sndvol.exe", NULL, NULL, SW_SHOW);
      }
    } else if (icon.name == L"Network") {
      // Open network connections control panel
      ShellExecuteW(NULL, L"open", L"control.exe", L"ncpa.cpl", NULL, SW_SHOW);
    } else if (icon.name == L"Power") {
      // Open power options control panel
      ShellExecuteW(NULL, L"open", L"control.exe", L"powercfg.cpl", NULL,
                    SW_SHOW);
    } else if (icon.name == L"Clock") {
      // Open Date & Time control panel
      ShellExecuteW(NULL, L"open", L"control.exe", L"timedate.cpl", NULL,
                    SW_SHOW);
    }
  }
}

// ==================== WINDOWS 11 MINIMIZE/RESTORE ====================

void FlashWindowIfMinimized(HWND hwnd) {
  if (IsWindow(hwnd) && IsIconic(hwnd)) {
    FLASHWINFO fwi;
    fwi.cbSize = sizeof(FLASHWINFO);
    fwi.hwnd = hwnd;
    fwi.dwFlags = FLASHW_STOP;
    fwi.uCount = 0;
    fwi.dwTimeout = 0;
    FlashWindowEx(&fwi);

    fwi.dwFlags = FLASHW_TRAY | FLASHW_TIMERNOFG;
    fwi.uCount = 3;
    fwi.dwTimeout = 0;
    FlashWindowEx(&fwi);
  }
}

// MODIFIED: Added Start Menu position saving
void SaveStartMenuPositions() {
  try {
    nlohmann::json jPositions = nlohmann::json::object();
    jPositions["pinnedApps"] = nlohmann::json::array();

    for (const auto &app : g_pinnedApps) {
      char pathBuf[MAX_PATH];
      WideCharToMultiByte(CP_UTF8, 0, app.c_str(), -1, pathBuf, sizeof(pathBuf),
                          NULL, NULL);
      jPositions["pinnedApps"].push_back(pathBuf);
    }

    std::wstring appDataPath = GetAppDataPath();
    CreateDirectoryW(appDataPath.c_str(), NULL);
    std::wstring configPath = appDataPath + L"\\startmenu_positions.json";
    std::ofstream file(configPath.c_str());
    if (file.is_open()) {
      file << jPositions.dump(2);
      file.close();
    }
  } catch (...) {
#ifdef _DEBUG
    OutputDebugStringW(L"CustomShell: exception swallowed\n");
#endif
  }
}

void LoadStartMenuPositions() {
  try {
    std::wstring appDataPath = GetAppDataPath();
    std::wstring configPath = appDataPath + L"\\startmenu_positions.json";
    std::ifstream file(configPath.c_str());
    if (file.is_open()) {
      nlohmann::json jPositions;
      file >> jPositions;
      file.close();

      if (jPositions.contains("pinnedApps") &&
          jPositions["pinnedApps"].is_array()) {
        g_pinnedApps.clear();
        for (const auto &item : jPositions["pinnedApps"]) {
          std::string pathStr = item;
          wchar_t pathW[MAX_PATH];
          MultiByteToWideChar(CP_UTF8, 0, pathStr.c_str(), -1, pathW, MAX_PATH);
          g_pinnedApps.push_back(pathW);
        }
      }
    }
  } catch (...) {
#ifdef _DEBUG
    OutputDebugStringW(L"CustomShell: exception swallowed\n");
#endif
  }
}

// NEW FUNCTION: Clean up explorer and shell from all lists
void CleanupExplorerAndShellFromLists() {
  // Clean up from start menu
  g_pinnedApps.erase(
      std::remove_if(g_pinnedApps.begin(), g_pinnedApps.end(), IsBlockedApp),
      g_pinnedApps.end());

  // Clean up from taskbar
  g_taskbarPinned.erase(std::remove_if(g_taskbarPinned.begin(),
                                       g_taskbarPinned.end(), IsBlockedApp),
                        g_taskbarPinned.end());

  // Clean up from taskbar icons
  for (auto it = g_taskbarIcons.begin(); it != g_taskbarIcons.end();) {
    if (IsBlockedApp(it->path)) {
      if (it->hIcon)
        DestroyIcon(it->hIcon);
      it = g_taskbarIcons.erase(it);
    } else {
      ++it;
    }
  }
}

// MODIFIED: Updated PopulateStartMenuApps to filter explorer and shell
void PopulateStartMenuApps() {
  // First try to load saved positions
  LoadStartMenuPositions();

  // FILTER OUT EXPLORER AND SHELL FROM SAVED POSITIONS TOO
  CleanupExplorerAndShellFromLists();

  // If no saved positions, load default
  if (g_pinnedApps.empty()) {
    std::wstring startMenuPath =
        L"C:\\ProgramData\\Microsoft\\Windows\\Start Menu\\Programs";

    // Scan for .lnk files
    WIN32_FIND_DATAW findData;
    HANDLE hFind =
        FindFirstFileW((startMenuPath + L"\\*.lnk").c_str(), &findData);

    if (hFind != INVALID_HANDLE_VALUE) {
      do {
        if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)) {
          std::wstring fullPath = startMenuPath + L"\\" + findData.cFileName;
          std::wstring fileName = findData.cFileName;

          if (!IsBlockedApp(fullPath)) {
            g_pinnedApps.push_back(fullPath);
          }
        }
      } while (FindNextFileW(hFind, &findData));
      FindClose(hFind);
    }

    // Save filtered positions
    SaveStartMenuPositions();
  }
}

void SaveTaskbarConfig() {
  try {
    nlohmann::json jConfig = nlohmann::json::object();

    // Save pinned apps array
    nlohmann::json jApps = nlohmann::json::array();
    for (const auto &app : g_taskbarPinned) {
      jApps.push_back(app);
    }
    jConfig["apps"] = jApps;

    // Save window positions
    nlohmann::json jWindows = nlohmann::json::object();

    if (g_hTaskbarWnd) {
      RECT rect;
      GetWindowRect(g_hTaskbarWnd, &rect);
      jWindows["taskbar"] = {{"x", rect.left},
                             {"y", rect.top},
                             {"width", rect.right - rect.left},
                             {"height", rect.bottom - rect.top}};
    }

    if (g_hStartMenuWnd) {
      RECT rect;
      GetWindowRect(g_hStartMenuWnd, &rect);
      jWindows["startmenu"] = {{"x", rect.left},
                               {"y", rect.top},
                               {"width", rect.right - rect.left},
                               {"height", rect.bottom - rect.top}};
    }

    jConfig["windows"] = jWindows;

    // Save background image path
    if (!g_backgroundPath.empty()) {
      char bgPath[MAX_PATH];
      WideCharToMultiByte(CP_UTF8, 0, g_backgroundPath.c_str(), -1, bgPath,
                          sizeof(bgPath), NULL, NULL);
      jConfig["background"] = bgPath;
    }

    // Save custom colors
    jConfig["taskbarColor"] = {{"r", GetRValue(g_taskbarColor)},
                               {"g", GetGValue(g_taskbarColor)},
                               {"b", GetBValue(g_taskbarColor)}};
    jConfig["startMenuColor"] = {{"r", GetRValue(g_startMenuColor)},
                                 {"g", GetGValue(g_startMenuColor)},
                                 {"b", GetBValue(g_startMenuColor)}};

    std::wstring appDataPath = GetAppDataPath();
    CreateDirectoryW(appDataPath.c_str(), NULL);

    char filePath[MAX_PATH];
    WideCharToMultiByte(CP_UTF8, 0,
                        (appDataPath + L"\\shell_config.json").c_str(), -1,
                        filePath, sizeof(filePath), NULL, NULL);

    std::ofstream file(filePath);
    if (file.is_open()) {
      file << jConfig.dump(2);
      file.close();
    }
#ifdef _DEBUG
    else {
      OutputDebugStringW(
          L"SaveTaskbarConfig: failed to open config file for writing\n");
    }
#endif
  } catch (...) {
    // Silently fail if can't save
#ifdef _DEBUG
    OutputDebugStringW(L"SaveTaskbarConfig: exception during save\n");
#endif
  }
}

void LoadTaskbarConfig() {
  try {
    std::wstring appDataPath = GetAppDataPath();

    char filePath[MAX_PATH];
    WideCharToMultiByte(CP_UTF8, 0,
                        (appDataPath + L"\\shell_config.json").c_str(), -1,
                        filePath, sizeof(filePath), NULL, NULL);

    std::ifstream file(filePath);
    if (file.is_open()) {
      nlohmann::json jConfig;
      file >> jConfig;
      file.close();

      // Load pinned apps
      if (jConfig.contains("apps") && jConfig["apps"].is_array()) {
        g_taskbarPinned.clear();
        for (const auto &item : jConfig["apps"]) {
          g_taskbarPinned.push_back(item.template get<std::wstring>());
        }
      }
    }
  } catch (...) {
    // Use defaults if can't load
  }
}

int g_taskbarX = 0, g_taskbarY = 0, g_taskbarWidth = 0;
int g_startMenuX = 10, g_startMenuY = 0, g_startMenuWidth = 0,
    g_startMenuHeightCfg = 0;

void LoadWindowPositions() {
  try {
    std::wstring appDataPath = GetAppDataPath();

    char filePath[MAX_PATH];
    WideCharToMultiByte(CP_UTF8, 0,
                        (appDataPath + L"\\shell_config.json").c_str(), -1,
                        filePath, sizeof(filePath), NULL, NULL);

    std::ifstream file(filePath);
    if (file.is_open()) {
      nlohmann::json jConfig;
      file >> jConfig;
      file.close();

      if (jConfig.contains("windows") && jConfig["windows"].is_object()) {
        auto &jWnd = jConfig["windows"];

        if (jWnd.contains("taskbar")) {
          auto &tb = jWnd["taskbar"];
          g_taskbarX = tb.value("x", 0);
          g_taskbarY = tb.value("y", 0);
          g_taskbarWidth = tb.value("width", 0);
        }

        if (jWnd.contains("startmenu")) {
          auto &sm = jWnd["startmenu"];
          g_startMenuX = sm.value("x", 10);
          g_startMenuY = sm.value("y", 0);
          g_startMenuWidth = sm.value("width", 0);
          g_startMenuHeightCfg = sm.value("height", 0);
        }
      }

      // Load background image path
      if (jConfig.contains("background") && jConfig["background"].is_string()) {
        std::string bgPath = jConfig["background"].get<std::string>();
        if (!bgPath.empty()) {
          wchar_t wPath[MAX_PATH];
          MultiByteToWideChar(CP_UTF8, 0, bgPath.c_str(), -1, wPath, MAX_PATH);
          g_backgroundPath = wPath;

          // Load the image
          if (g_backgroundImage) {
            delete g_backgroundImage;
            g_backgroundImage = NULL;
          }
          g_backgroundImage =
              Gdiplus::Bitmap::FromFile(g_backgroundPath.c_str());
          if (g_backgroundImage &&
              g_backgroundImage->GetLastStatus() != Gdiplus::Ok) {
            delete g_backgroundImage;
            g_backgroundImage = NULL;
          }
        }
      }

      // Load custom colors
      if (jConfig.contains("taskbarColor") &&
          jConfig["taskbarColor"].is_object()) {
        auto &tc = jConfig["taskbarColor"];
        int r = tc.value("r", 45);
        int g = tc.value("g", 45);
        int b = tc.value("b", 48);
        g_taskbarColor = RGB(r, g, b);
      }
      if (jConfig.contains("startMenuColor") &&
          jConfig["startMenuColor"].is_object()) {
        auto &sc = jConfig["startMenuColor"];
        int r = sc.value("r", 50);
        int g = sc.value("g", 100);
        int b = sc.value("b", 160);
        g_startMenuColor = RGB(r, g, b);
      }
    }
  } catch (...) {
    // Use defaults
  }
}

// MODIFIED: Updated to filter out explorer and shell from taskbar
void PopulateTaskbarIcons() {
  // Clear existing taskbar icons
  for (auto &icon : g_taskbarIcons) {
    if (icon.hIcon) {
      DestroyIcon(icon.hIcon);
    }
  }
  g_taskbarIcons.clear();

  // Clean up taskbar pinned list first
  CleanupExplorerAndShellFromLists();

  // If no pinned apps, use from start menu but skip explorer and shell
  if (g_taskbarPinned.empty()) {
    for (size_t i = 0; i < g_pinnedApps.size() && i < 6; ++i) {
      if (!IsBlockedApp(g_pinnedApps[i])) {
        g_taskbarPinned.push_back(g_pinnedApps[i]);
      }
    }
    SaveTaskbarConfig();
  }

  // Load icons from pinned apps (excluding explorer and shell)
  for (const auto &appPath : g_taskbarPinned) {
    if (!IsBlockedApp(appPath)) {
      TaskbarIcon tIcon;
      tIcon.path = appPath;
      tIcon.hIcon = NULL;
      tIcon.visible = true;

      // Extract icon from .lnk file
      SHFILEINFOW sfi = {};
      tIcon.hIcon = GetIconForPath(appPath, 48);

      g_taskbarIcons.push_back(tIcon);
    }
  }
}

void DrawPolishedIconBackground(Gdiplus::Graphics *g, int x, int y,
                                int iconSize, int spacing, bool hovered) {
  using namespace Gdiplus;

  int bgX = x - (spacing - iconSize) / 2;
  int bgY = y;
  int bgWidth = spacing;
  int bgHeight = spacing;

  // Draw shadow with rounded effect
  SolidBrush shadowBrush(Color(40, 0, 0, 0));
  RectF shadowRect(bgX + 2, bgY + 2, bgWidth, bgHeight);
  g->FillRectangle(&shadowBrush, shadowRect);

  // Draw background with rounded corners using a path
  Color bgColor;
  if (hovered) {
    bgColor = Color(180, 255, 255, 255);
  } else {
    bgColor = Color(140, 255, 255, 255);
  }
  SolidBrush bgBrush(bgColor);

  GraphicsPath path;
  float radius = 12.0f;
  RectF rect(bgX, bgY, bgWidth, bgHeight);
  path.AddArc(rect.X, rect.Y, radius, radius, 180, 90);
  path.AddArc(rect.X + rect.Width - radius, rect.Y, radius, radius, 270, 90);
  path.AddArc(rect.X + rect.Width - radius, rect.Y + rect.Height - radius,
              radius, radius, 0, 90);
  path.AddArc(rect.X, rect.Y + rect.Height - radius, radius, radius, 90, 90);
  path.CloseFigure();

  g->FillPath(&bgBrush, &path);

  Pen borderPen(Color(200, 200, 200, 200), 1.0f);
  g->DrawPath(&borderPen, &path);
}

LRESULT CALLBACK Desktop_SubclassProc(HWND hwnd, UINT msg, WPARAM wParam,
                                      LPARAM lParam) {
  if (g_pcm3) {
    LRESULT lr = 0;
    if (SUCCEEDED(g_pcm3->HandleMenuMsg2(msg, wParam, lParam, &lr))) {
      return lr;
    }
  }
  if (g_pcm2) {
    if (SUCCEEDED(g_pcm2->HandleMenuMsg(msg, wParam, lParam))) {
      return 0;
    }
  }
  return CallWindowProcW(g_origDesktopProc ? g_origDesktopProc : DefWindowProcW,
                         hwnd, msg, wParam, lParam);
}

std::wstring GetAppExeName(LPCWSTR appPath) {
  std::wstring pathStr(appPath);
  size_t lastSlash = pathStr.find_last_of(L"\\");
  std::wstring fileName = (lastSlash != std::wstring::npos)
                              ? pathStr.substr(lastSlash + 1)
                              : pathStr;

  size_t dotPos = fileName.find(L".lnk");
  if (dotPos != std::wstring::npos) {
    fileName = fileName.substr(0, dotPos);
  }

  dotPos = fileName.find(L".exe");
  if (dotPos != std::wstring::npos) {
    fileName = fileName.substr(0, dotPos);
  }

  return fileName;
}

DWORD FindProcessByName(const std::wstring &appName) {
  HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  if (hSnapshot == INVALID_HANDLE_VALUE)
    return 0;

  PROCESSENTRY32W pe32 = {};
  pe32.dwSize = sizeof(PROCESSENTRY32W);

  DWORD processId = 0;
  if (Process32FirstW(hSnapshot, &pe32)) {
    do {
      std::wstring exeName(pe32.szExeFile);
      if (_wcsicmp(exeName.c_str(), (appName + L".exe").c_str()) == 0 ||
          _wcsicmp(exeName.c_str(), appName.c_str()) == 0) {
        processId = pe32.th32ProcessID;
        break;
      }
    } while (Process32NextW(hSnapshot, &pe32));
  }

  CloseHandle(hSnapshot);
  return processId;
}

HWND FindWindowByProcessId(DWORD processId) {
  HWND hwnd = NULL;
  do {
    hwnd = FindWindowExW(NULL, hwnd, NULL, NULL);
    if (hwnd) {
      DWORD windowPID = 0;
      GetWindowThreadProcessId(hwnd, &windowPID);
      if (windowPID == processId) {
        if (IsWindowVisible(hwnd)) {
          return hwnd;
        }
      }
    }
  } while (hwnd);

  return NULL;
}

void UpdateRunningAppsList() {
  static std::map<HWND, bool> prevMinimizedState;

  for (auto it = g_runningApps.begin(); it != g_runningApps.end();) {
    if (!IsWindow(it->hwnd) || !IsWindowVisible(it->hwnd)) {
      if (it->hIcon)
        DestroyIcon(it->hIcon);
      prevMinimizedState.erase(it->hwnd);
      it = g_runningApps.erase(it);
    } else {
      bool isMinimized = IsIconic(it->hwnd);
      if (prevMinimizedState[it->hwnd] != isMinimized) {
        prevMinimizedState[it->hwnd] = isMinimized;
        g_windowMinimizedState[it->hwnd] = isMinimized;
        InvalidateRect(g_hTaskbarWnd, NULL, FALSE);
      }
      ++it;
    }
  }

  EnumWindows(
      [](HWND hwnd, LPARAM lParam) -> BOOL {
        if (!IsWindowVisible(hwnd))
          return TRUE;

        // Skip tool windows — these should never appear in a taskbar
        LONG_PTR exStyle = GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
        if (exStyle & WS_EX_TOOLWINDOW)
          return TRUE;

        // Skip windows without WS_EX_APPWINDOW that have an owner
        // (these are secondary windows like dropdowns, tooltips, etc.)
        if (!(exStyle & WS_EX_APPWINDOW) && GetWindow(hwnd, GW_OWNER) != NULL)
          return TRUE;

        DWORD processId;
        GetWindowThreadProcessId(hwnd, &processId);

        // Skip our own shell windows and WE's render target
        if (hwnd == g_hDesktopWnd || hwnd == g_hTaskbarWnd ||
            hwnd == g_hStartMenuWnd || hwnd == g_hWeWorkerW) {
          return TRUE;
        }

        // Skip children of g_hWeWorkerW (WE's render window lives here)
        HWND parent = GetAncestor(hwnd, GA_ROOTOWNER);
        if (parent == g_hWeWorkerW)
          return TRUE;

        wchar_t title[256];
        GetWindowTextW(hwnd, title, ARRAYSIZE(title));
        if (wcslen(title) == 0)
          return TRUE;

        bool found = false;
        for (auto &app : g_runningApps) {
          if (app.hwnd == hwnd) {
            found = true;
            break;
          }
        }

        if (!found) {
          HANDLE hProcess =
              OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, processId);
          if (hProcess) {
            wchar_t exePath[MAX_PATH] = {0};
            DWORD pathSize = MAX_PATH;

            if (QueryFullProcessImageNameW(hProcess, 0, exePath, &pathSize)) {
              RunningApp app;
              app.processId = processId;
              app.hwnd = hwnd;
              app.exePath = exePath;
              app.visible = true;
              app.displayName = title;

              SHFILEINFOW sfi = {};
              app.hIcon = GetIconForPath(exePath, 48);

              g_runningApps.push_back(app);
              g_windowMinimizedState[hwnd] = IsIconic(hwnd);
            }
            CloseHandle(hProcess);
          }
        }

        return TRUE;
      },
      0);
}

void LaunchApp(LPCWSTR path) {
  // Block shell replacements and explorer from being re-launched via the UI
  if (IsBlockedApp(std::wstring(path)))
    return;

  std::wstring targetPath = path;

  if (targetPath.find(L".lnk") != std::wstring::npos) {
    IShellLinkW *psl = NULL;
    IPersistFile *ppf = NULL;
    wchar_t resolvedPath[MAX_PATH] = {0};

    if (SUCCEEDED(CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
                                   IID_IShellLinkW, (void **)&psl))) {
      if (SUCCEEDED(psl->QueryInterface(IID_IPersistFile, (void **)&ppf))) {
        if (SUCCEEDED(ppf->Load(path, STGM_READ))) {
          psl->GetPath(resolvedPath, MAX_PATH, NULL, 0);
          // Only override targetPath if GetPath returned a non-empty result.
          // UWP/script shortcuts (e.g. AutoHotkey Dash) return an empty
          // resolvedPath; in that case we keep the original .lnk path so
          // ShellExecuteExW can invoke it correctly via the shell association.
          if (resolvedPath[0] != L'\0') {
            targetPath = resolvedPath;
          }
        }
        ppf->Release();
      }
      psl->Release();
    }
  }

  for (const auto &app : g_runningApps) {
    if (_wcsicmp(app.exePath.c_str(), targetPath.c_str()) == 0) {
      if (IsIconic(app.hwnd)) {
        ShowWindow(app.hwnd, SW_RESTORE);
      }
      SetForegroundWindow(app.hwnd);
      SetWindowPos(app.hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
      return;
    }
  }

  SHELLEXECUTEINFOW sei = {0};
  sei.cbSize = sizeof(sei);
  sei.fMask = SEE_MASK_NOCLOSEPROCESS;
  sei.lpVerb = L"open";
  sei.lpFile = path;
  sei.nShow = SW_SHOWNORMAL;

  if (ShellExecuteExW(&sei)) {
    if (sei.hProcess) {
      CloseHandle(sei.hProcess);
    }
  }
}

bool IsAppRunning(LPCWSTR appPath) {
  std::wstring appName = GetAppExeName(appPath);
  return FindProcessByName(appName) != 0;
}

void LaunchExplorer() {
  ShellExecuteW(NULL, L"open", L"explorer.exe", NULL, NULL, SW_SHOWDEFAULT);
}

void UpdateViewMode(int mode) {
  g_viewMode = mode;
  switch (mode) {
  case 0:
    g_iconSize = 32;
    g_iconXSpacing = 100;
    g_iconYSpacing = 80;
    break;
  case 1:
    g_iconSize = 48;
    g_iconXSpacing = 120;
    g_iconYSpacing = 100;
    break;
  case 2:
  default:
    g_iconSize = 64;
    g_iconXSpacing = 140;
    g_iconYSpacing = 120;
    break;
  }
  InvalidateRect(g_hDesktopWnd, NULL, TRUE);
}

void SortByName() {
  std::sort(g_desktopItems.begin(), g_desktopItems.end(),
            [](const DesktopItem &a, const DesktopItem &b) {
              return _wcsicmp(a.name, b.name) < 0;
            });
}

void SortByTypeThenName() {
  std::sort(g_desktopItems.begin(), g_desktopItems.end(),
            [](const DesktopItem &a, const DesktopItem &b) {
              int extCmp = _wcsicmp(a.extension.c_str(), b.extension.c_str());
              if (extCmp != 0)
                return extCmp < 0;
              return _wcsicmp(a.name, b.name) < 0;
            });
}

void SortByDateDesc() {
  std::sort(g_desktopItems.begin(), g_desktopItems.end(),
            [](const DesktopItem &a, const DesktopItem &b) {
              return CompareFileTime(&a.ftWrite, &b.ftWrite) > 0;
            });
}

void ResetDesktopPositions() {
  SortByName();
  int screenW = GetSystemMetrics(SM_CXSCREEN);
  int curX = ICON_X_START;
  int curY = ICON_Y_START;
  for (auto &it : g_desktopItems) {
    it.x = curX;
    it.y = curY;
    it.hasPos = true;

    curX += g_iconXSpacing;
    if (curX + g_iconXSpacing > screenW) {
      curX = ICON_X_START;
      curY += g_iconYSpacing;
    }
  }
  InvalidateRect(g_hDesktopWnd, NULL, TRUE);
}

void AlignIconsToGrid() {
  // Snap every icon to the nearest grid cell, preserving its approximate
  // position. Grid origin is (ICON_X_START, ICON_Y_START) with cell size
  // g_iconXSpacing x g_iconYSpacing.
  for (auto &item : g_desktopItems) {
    if (!item.hasPos)
      continue;

    // Offset position so (0,0) is grid origin
    int relX = item.x - ICON_X_START;
    int relY = item.y - ICON_Y_START;

    // Round to nearest grid cell (handles negative offsets gracefully)
    int cellX = (int)round((double)relX / g_iconXSpacing);
    int cellY = (int)round((double)relY / g_iconYSpacing);

    // Clamp to non-negative grid
    if (cellX < 0)
      cellX = 0;
    if (cellY < 0)
      cellY = 0;

    item.x = ICON_X_START + cellX * g_iconXSpacing;
    item.y = ICON_Y_START + cellY * g_iconYSpacing;
  }

  SaveDesktopPositions();
  InvalidateRect(g_hDesktopWnd, NULL, TRUE);
}

void PopulateDesktopIcons() {
  std::vector<std::wstring> desktopPaths;

  PWSTR pszPathUser = NULL;
  if (S_OK == SHGetKnownFolderPath(FOLDERID_Desktop, 0, NULL, &pszPathUser)) {
    desktopPaths.push_back(pszPathUser);
    CoTaskMemFree(pszPathUser);
  }

  PWSTR pszPathCommon = NULL;
  if (S_OK ==
      SHGetKnownFolderPath(FOLDERID_PublicDesktop, 0, NULL, &pszPathCommon)) {
    desktopPaths.push_back(pszPathCommon);
    CoTaskMemFree(pszPathCommon);
  }

  for (auto &it : g_desktopItems) {
    if (it.hIcon) {
      DestroyIcon(it.hIcon);
      it.hIcon = NULL;
    }
  }
  g_desktopItems.clear();

  for (const auto &desktopDir : desktopPaths) {
    std::wstring searchPath = desktopDir + L"\\*";
    WIN32_FIND_DATAW findData;
    HANDLE hFind = FindFirstFileW(searchPath.c_str(), &findData);
    if (hFind != INVALID_HANDLE_VALUE) {
      do {
        if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) &&
            wcscmp(findData.cFileName, L".") != 0 &&
            wcscmp(findData.cFileName, L"..") != 0) {
          DesktopItem item = {};
          SHFILEINFOW sfi = {};
          std::wstring fullPath = desktopDir + L"\\" + findData.cFileName;

          if (SHGetFileInfoW(fullPath.c_str(), 0, &sfi, sizeof(sfi),
                             SHGFI_DISPLAYNAME)) {
            wcsncpy_s(item.name, MAX_PATH, sfi.szDisplayName, _TRUNCATE);
          } else {
            wcsncpy_s(item.name, MAX_PATH, findData.cFileName, _TRUNCATE);
          }
          wcsncpy_s(item.path, MAX_PATH, fullPath.c_str(), _TRUNCATE);
          item.hIcon = GetIconForPath(fullPath, 48);
          if (item.hIcon) {

            WIN32_FILE_ATTRIBUTE_DATA fad = {};
            if (GetFileAttributesExW(fullPath.c_str(), GetFileExInfoStandard,
                                     &fad)) {
              item.ftWrite = fad.ftLastWriteTime;
            } else {
              item.ftWrite.dwLowDateTime = 0;
              item.ftWrite.dwHighDateTime = 0;
            }

            const wchar_t *dot = wcsrchr(fullPath.c_str(), L'.');
            item.extension = dot ? dot : L"";
            item.hasPos = false;
            g_desktopItems.push_back(item);
          }
        }
      } while (FindNextFileW(hFind, &findData) != 0);
      FindClose(hFind);
    }
  }

  if (g_autoArrange)
    SortByName();

  LoadDesktopPositions();

  // Build a set of grid cells already occupied by icons with saved positions.
  // A cell is identified by its (col, row) index in the grid.
  int screenW = GetSystemMetrics(SM_CXSCREEN);
  int colsPerRow = std::max(1, (screenW - ICON_X_START) / g_iconXSpacing);

  std::set<std::pair<int,int>> occupiedCells;
  for (const auto &it : g_desktopItems) {
    if (it.hasPos) {
      // Snap back to nearest grid cell — robust even if icon was dragged to
      // a non-grid pixel position before being saved.
      int col = (it.x - ICON_X_START + g_iconXSpacing / 2) / g_iconXSpacing;
      int row = (it.y - ICON_Y_START + g_iconYSpacing / 2) / g_iconYSpacing;
      if (col < 0) col = 0;
      if (row < 0) row = 0;
      occupiedCells.insert({col, row});
    }
  }

  // Assign each new (no saved position) icon to the first free grid cell.
  int searchCol = 0, searchRow = 0;
  auto nextFreeCell = [&]() -> std::pair<int,int> {
    while (occupiedCells.count({searchCol, searchRow})) {
      ++searchCol;
      if (searchCol >= colsPerRow) {
        searchCol = 0;
        ++searchRow;
      }
    }
    std::pair<int,int> cell = {searchCol, searchRow};
    occupiedCells.insert(cell);
    ++searchCol;
    if (searchCol >= colsPerRow) {
      searchCol = 0;
      ++searchRow;
    }
    return cell;
  };

  bool anyNew = false;
  for (auto &it : g_desktopItems) {
    if (!it.hasPos) {
      auto [col, row] = nextFreeCell();
      it.x = ICON_X_START + col * g_iconXSpacing;
      it.y = ICON_Y_START + row * g_iconYSpacing;
      it.hasPos = true;
      anyNew = true;
    }
  }

  // Persist positions for any newly placed icons so they stay put on the
  // next refresh rather than being re-placed from scratch.
  if (anyNew)
    SaveDesktopPositions();

  InvalidateRect(g_hDesktopWnd, NULL, TRUE);
}

LRESULT CALLBACK DesktopWndProc(HWND hwnd, UINT msg, WPARAM wParam,
                                LPARAM lParam) {
  // g_hWeWorkerW shares this class. For paint messages only handle
  // g_hDesktopWnd. For mouse/input messages handle both so right-click on
  // wallpaper works.
  if (g_hDesktopWnd && hwnd != g_hDesktopWnd) {
    switch (msg) {
    case WM_MOUSEACTIVATE: {
      // Allow activation when the user clicks on an icon cell —
      // block it on empty desktop so we don't steal focus from apps.
      POINT pt;
      GetCursorPos(&pt);
      ScreenToClient(hwnd, &pt);
      bool overIcon = false;
      for (auto &icon : g_desktopItems) {
        RECT rcIcon;
        rcIcon.left = icon.x - (g_iconXSpacing - g_iconSize) / 2;
        rcIcon.top = icon.y;
        rcIcon.right = rcIcon.left + g_iconXSpacing;
        rcIcon.bottom = icon.y + g_iconYSpacing;
        if (PtInRect(&rcIcon, pt)) {
          overIcon = true;
          break;
        }
      }
      // Always allow activation so ForceFocusToDesktop() can work.
      // We handle not-stealing-focus from apps in WM_LBUTTONDOWN instead.
      (void)overIcon;
      return MA_ACTIVATE;
    }
    case WM_SETFOCUS:
      // We have focus — good. Don't call ForceFocusToDesktop() here or
      // it creates an infinite loop (SetForegroundWindow → WM_SETFOCUS →
      // repeat).
      return 0;
    case WM_PARENTNOTIFY:
      // WE just called SetParent(its_window, g_hWeWorkerW).
      // Re-apply WS_EX_TOOLWINDOW to us, and also hide WE's render
      // window from the taskbar by adding WS_EX_TOOLWINDOW to it.
      {
        LONG_PTR exStyle = GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
        exStyle |= WS_EX_TOOLWINDOW;
        exStyle &= ~WS_EX_APPWINDOW;
        SetWindowLongPtrW(hwnd, GWL_EXSTYLE, exStyle);

        // Hide WE's child window from taskbar too
        if (LOWORD(wParam) == WM_CREATE) {
          HWND hChild = (HWND)lParam;
          if (hChild && IsWindow(hChild)) {
            LONG_PTR childEx = GetWindowLongPtrW(hChild, GWL_EXSTYLE);
            childEx |= WS_EX_TOOLWINDOW;
            childEx &= ~WS_EX_APPWINDOW;
            SetWindowLongPtrW(hChild, GWL_EXSTYLE, childEx);
          }
        }
      }
      return 0;
    case WM_LBUTTONDOWN: {
      // A transparent-pixel click leaked through from g_hDesktopWnd.
      // Forward it there so empty-desktop left-clicks still focus the
      // shell and close the start menu, instead of activating the wallpaper.
      POINT pt = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
      ClientToScreen(hwnd, &pt);
      ScreenToClient(g_hDesktopWnd, &pt);
      SendMessageW(g_hDesktopWnd, WM_LBUTTONDOWN, wParam,
                   MAKELPARAM(pt.x, pt.y));
      return 0;
    }
    case WM_RBUTTONDOWN: {
      // Forward to g_hDesktopWnd as if it happened there — coordinates
      // are the same since both windows cover the same screen area.
      POINT pt = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
      ClientToScreen(hwnd, &pt);
      ScreenToClient(g_hDesktopWnd, &pt);
      SendMessageW(g_hDesktopWnd, WM_RBUTTONDOWN, wParam,
                   MAKELPARAM(pt.x, pt.y));
      // Also fire the up so capture and context menu trigger correctly
      SendMessageW(g_hDesktopWnd, WM_RBUTTONUP, wParam, MAKELPARAM(pt.x, pt.y));
      return 0;
    }
    default:
      return DefWindowProcW(hwnd, msg, wParam, lParam);
    }
  }
  switch (msg) {
  case WM_ERASEBKGND:
    return 1;
  case WM_PAINT: {
    // For a WS_EX_LAYERED window we must use UpdateLayeredWindow instead of
    // BeginPaint/EndPaint. We create a 32-bit ARGB DIB, paint icons into it
    // (alpha=255 for icon pixels, alpha=0 everywhere else), then hand it to
    // UpdateLayeredWindow. Alpha=0 pixels are fully transparent so WE shows
    // through.
    PAINTSTRUCT ps;
    BeginPaint(hwnd, &ps); // must call to validate the region

    RECT rcClient;
    GetClientRect(hwnd, &rcClient);
    int w = rcClient.right;
    int h = rcClient.bottom;

    // Create a 32-bit DIB section (ARGB)
    BITMAPINFO bmi = {};
    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biWidth = w;
    bmi.bmiHeader.biHeight = -h; // top-down
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biBitCount = 32;
    bmi.bmiHeader.biCompression = BI_RGB;

    void *pvBits = nullptr;
    HDC hdcScreen = GetDC(NULL);
    HDC hdcMem = CreateCompatibleDC(hdcScreen);
    HBITMAP hbm =
        CreateDIBSection(hdcScreen, &bmi, DIB_RGB_COLORS, &pvBits, NULL, 0);
    ReleaseDC(NULL, hdcScreen);

    if (!hbm || !pvBits) {
      EndPaint(hwnd, &ps);
      return 0;
    }

    // Zero the bitmap — all pixels start as transparent black (alpha=0)
    memset(pvBits, 0, w * h * 4);

    HBITMAP hbmOld = (HBITMAP)SelectObject(hdcMem, hbm);

    // Draw icons using GDI+
    if (g_showIcons && !g_desktopItems.empty()) {
      Gdiplus::Graphics g(hdcMem);
      g.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
      g.SetInterpolationMode(Gdiplus::InterpolationModeHighQuality);
      g.SetTextRenderingHint(Gdiplus::TextRenderingHintClearTypeGridFit);
      g.SetCompositingMode(Gdiplus::CompositingModeSourceOver);

      Gdiplus::FontFamily fontFamily(L"Segoe UI");
      Gdiplus::Font labelFont(&fontFamily, 9.0f, Gdiplus::FontStyleRegular,
                              Gdiplus::UnitPoint);
      Gdiplus::SolidBrush textBrush(Gdiplus::Color(255, 255, 255, 255));
      Gdiplus::SolidBrush textBgBrush(Gdiplus::Color(210, 20, 20, 20));

      Gdiplus::StringFormat fmt;
      fmt.SetAlignment(Gdiplus::StringAlignmentCenter);
      fmt.SetLineAlignment(Gdiplus::StringAlignmentCenter);
      fmt.SetTrimming(Gdiplus::StringTrimmingEllipsisCharacter);
      fmt.SetFormatFlags(Gdiplus::StringFormatFlagsNoWrap);

      for (size_t i = 0; i < g_desktopItems.size(); ++i) {
        const auto &item = g_desktopItems[i];
        int ix = item.x;
        int iy = item.y;

        if (item.hIcon) {
          HDC hdcIcon = g.GetHDC();
          DrawIconEx(hdcIcon, ix, iy, item.hIcon, g_iconSize, g_iconSize, 0,
                     NULL, DI_NORMAL);
          g.ReleaseHDC(hdcIcon);
        }

        float pillX = (float)(ix - (g_iconXSpacing - g_iconSize) / 2 + 4);
        float pillY = (float)(iy + g_iconSize + 3);
        float pillW = (float)(g_iconXSpacing - 8);
        float pillH = 18.0f;
        Gdiplus::RectF pillRect(pillX, pillY, pillW, pillH);

        Gdiplus::GraphicsPath path;
        float r = 3.0f;
        path.AddArc(pillX, pillY, r * 2, r * 2, 180, 90);
        path.AddArc(pillX + pillW - r * 2, pillY, r * 2, r * 2, 270, 90);
        path.AddArc(pillX + pillW - r * 2, pillY + pillH - r * 2, r * 2, r * 2,
                    0, 90);
        path.AddArc(pillX, pillY + pillH - r * 2, r * 2, r * 2, 90, 90);
        path.CloseFigure();
        g.FillPath(&textBgBrush, &path);
        g.DrawString(item.name, -1, &labelFont, pillRect, &fmt, &textBrush);
      }
    }

    // Pre-multiply alpha — required by UpdateLayeredWindow
    DWORD *pixels = (DWORD *)pvBits;
    for (int i = 0; i < w * h; i++) {
      BYTE a = (pixels[i] >> 24) & 0xFF;
      BYTE r = (BYTE)((pixels[i] >> 16) & 0xFF);
      BYTE g2 = (BYTE)((pixels[i] >> 8) & 0xFF);
      BYTE b = (BYTE)(pixels[i] & 0xFF);
      r = (BYTE)((r * a) / 255);
      g2 = (BYTE)((g2 * a) / 255);
      b = (BYTE)((b * a) / 255);
      pixels[i] = (a << 24) | (r << 16) | (g2 << 8) | b;
    }

    // Hand the bitmap to the compositor
    POINT ptSrc = {0, 0};
    POINT ptDst = {0, 0};
    SIZE szWnd = {w, h};
    BLENDFUNCTION bf = {};
    bf.BlendOp = AC_SRC_OVER;
    bf.SourceConstantAlpha = 255;
    bf.AlphaFormat = AC_SRC_ALPHA;
    UpdateLayeredWindow(hwnd, NULL, &ptDst, &szWnd, hdcMem, &ptSrc, 0, &bf,
                        ULW_ALPHA);

    SelectObject(hdcMem, hbmOld);
    DeleteObject(hbm);
    DeleteDC(hdcMem);

    EndPaint(hwnd, &ps);
    return 0;
  }

  case WM_DISPLAYCHANGE:
    ResizeShellWindows();
    return 0;
  case WM_DPICHANGED: {
    RECT *const pr = reinterpret_cast<RECT *>(lParam);
    if (pr) {
      SetWindowPos(g_hDesktopWnd, NULL, pr->left, pr->top, pr->right - pr->left,
                   pr->bottom - pr->top, SWP_NOZORDER | SWP_NOACTIVATE);
    }
    ResizeShellWindows((int)wParam);

    PopulateDesktopIcons();
    return 0;
  }
  case WM_NCHITTEST: {
    LRESULT hit = DefWindowProcW(hwnd, msg, wParam, lParam);
    if (hit != HTCLIENT)
      return hit;
    POINT pt = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
    ScreenToClient(hwnd, &pt);
    // Always return HTCLIENT — we handle all clicks ourselves.
    // Empty area clicks are handled in WM_LBUTTONDOWN below.
    (void)pt;
    return HTCLIENT;
  }
  case WM_RBUTTONUP: {
    int clickX = GET_X_LPARAM(lParam);
    int clickY = GET_Y_LPARAM(lParam);

    int sel = -1;
    if (g_showIcons) {
      for (size_t i = 0; i < g_desktopItems.size(); ++i) {
        const auto &it = g_desktopItems[i];
        RECT rcIcon;
        rcIcon.left = it.x - (g_iconXSpacing - g_iconSize) / 2;
        rcIcon.top = it.y;
        rcIcon.right = rcIcon.left + g_iconXSpacing;
        rcIcon.bottom = it.y + g_iconYSpacing;

        if (clickX >= rcIcon.left && clickX < rcIcon.right &&
            clickY >= rcIcon.top && clickY < rcIcon.bottom) {
          sel = (int)i;
          break;
        }
      }
    }

    g_rightClickSelection = sel;

    POINT pt = {clickX, clickY};
    ClientToScreen(hwnd, &pt);

    if (sel >= 0) {
      ShowShellContextMenu(hwnd, pt, g_desktopItems[sel].path);
    } else {
      ShowDesktopContextMenu(hwnd, pt);
    }
    return 0;
  }
  case WM_RBUTTONDOWN:
    // Capture so we get WM_RBUTTONUP even if mouse moves
    SetCapture(hwnd);
    return 0;
  case WM_COMMAND: {
    switch (LOWORD(wParam)) {
    case IDM_ITEM_OPEN:
      if (g_rightClickSelection >= 0 &&
          g_rightClickSelection < (int)g_desktopItems.size()) {
        LaunchApp(g_desktopItems[g_rightClickSelection].path);
      }
      break;
    case IDM_ITEM_PROPERTIES:
      if (g_rightClickSelection >= 0 &&
          g_rightClickSelection < (int)g_desktopItems.size()) {
        ShellExecuteW(NULL, L"properties",
                      g_desktopItems[g_rightClickSelection].path, NULL, NULL,
                      SW_SHOWDEFAULT);
      }
      break;
    case IDM_DESKTOP_REFRESH:
      PopulateDesktopIcons();
      break;

    case IDM_VIEW_LARGE:
      UpdateViewMode(2);
      break;
    case IDM_VIEW_MEDIUM:
      UpdateViewMode(1);
      break;
    case IDM_VIEW_SMALL:
      UpdateViewMode(0);
      break;
    case IDM_SORT_NAME:
      SortByName();
      InvalidateRect(hwnd, NULL, TRUE);
      break;
    case IDM_SORT_TYPE:
      SortByTypeThenName();
      InvalidateRect(hwnd, NULL, TRUE);
      break;
    case IDM_SORT_DATE:
      SortByDateDesc();
      InvalidateRect(hwnd, NULL, TRUE);
      break;
    case IDM_TOGGLE_SHOW_ICONS:
      g_showIcons = !g_showIcons;
      InvalidateRect(hwnd, NULL, TRUE);
      break;
    case IDM_AUTO_ARRANGE:
      g_autoArrange = !g_autoArrange;
      if (g_autoArrange)
        SortByName();
      InvalidateRect(hwnd, NULL, TRUE);
      break;
    case IDM_ALIGN_TO_GRID:
      AlignIconsToGrid();
      break;
    case IDM_CHANGE_TASKBAR_COLOR: {
      // Choose color for taskbar
      CHOOSECOLORW cc = {};
      static COLORREF customColors[16] = {0};

      cc.lStructSize = sizeof(cc);
      cc.hwndOwner = hwnd;
      cc.lpCustColors = customColors;
      cc.rgbResult = g_taskbarColor;
      cc.Flags = CC_FULLOPEN | CC_RGBINIT;

      if (ChooseColorW(&cc)) {
        g_taskbarColor = cc.rgbResult;
        SaveTaskbarConfig();
        InvalidateRect(g_hTaskbarWnd, NULL, TRUE);
      }
      break;
    }
    case IDM_CHANGE_STARTMENU_COLOR: {
      // Choose color for start menu
      CHOOSECOLORW cc = {};
      static COLORREF customColors2[16] = {0};

      cc.lStructSize = sizeof(cc);
      cc.hwndOwner = hwnd;
      cc.lpCustColors = customColors2;
      cc.rgbResult = g_startMenuColor;
      cc.Flags = CC_FULLOPEN | CC_RGBINIT;

      if (ChooseColorW(&cc)) {
        g_startMenuColor = cc.rgbResult;
        SaveTaskbarConfig();
        InvalidateRect(g_hStartMenuWnd, NULL, TRUE);
      }
      break;
    }
    case IDM_CHANGE_BACKGROUND: {
      // Open file dialog to select background image
      OPENFILENAMEW ofn = {};
      wchar_t szFile[MAX_PATH] = L"";

      ofn.lStructSize = sizeof(ofn);
      ofn.hwndOwner = hwnd;
      ofn.lpstrFile = szFile;
      ofn.nMaxFile = MAX_PATH;
      ofn.lpstrFilter =
          L"Image Files\0*.jpg;*.jpeg;*.png;*.bmp;*.gif\0All Files\0*.*\0";
      ofn.nFilterIndex = 1;
      ofn.lpstrTitle = L"Select Background Image";
      ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;

      if (GetOpenFileNameW(&ofn)) {
        // Load the new background image
        if (g_backgroundImage) {
          delete g_backgroundImage;
          g_backgroundImage = NULL;
        }

        g_backgroundImage = Gdiplus::Bitmap::FromFile(szFile);
        if (g_backgroundImage &&
            g_backgroundImage->GetLastStatus() == Gdiplus::Ok) {
          g_backgroundPath = szFile;
          SaveTaskbarConfig();
          InvalidateRect(hwnd, NULL, TRUE);
        } else {
          if (g_backgroundImage) {
            delete g_backgroundImage;
            g_backgroundImage = NULL;
          }
          MessageBoxW(hwnd, L"Failed to load image file.", L"Error",
                      MB_OK | MB_ICONERROR);
        }
      }
      break;
    }
    }
    return 0;
  }
  case WM_LBUTTONDBLCLK: {
    int clickX = LOWORD(lParam);
    int clickY = HIWORD(lParam);

    for (const auto &item : g_desktopItems) {
      RECT rcIcon;
      rcIcon.left = item.x - (g_iconXSpacing - g_iconSize) / 2;
      rcIcon.top = item.y;
      rcIcon.right = rcIcon.left + g_iconXSpacing;
      rcIcon.bottom = item.y + g_iconYSpacing;

      if (clickX >= rcIcon.left && clickX < rcIcon.right &&
          clickY >= rcIcon.top && clickY < rcIcon.bottom) {
        LaunchApp(item.path);
        return 0;
      }
    }

    return 0;
  }
  case WM_LBUTTONDOWN: {
    int clickX = GET_X_LPARAM(lParam);
    int clickY = GET_Y_LPARAM(lParam);

    // NOTE: Desktop clicks no longer close the start menu.
    // The start menu is only toggled by the blue square button on the
    // taskbar or by pressing the Windows key. This way the start menu
    // stays open until the user explicitly dismisses it.

    int sel = -1;
    if (g_showIcons) {
      for (size_t i = 0; i < g_desktopItems.size(); ++i) {
        const auto &it = g_desktopItems[i];
        RECT rcIcon;
        rcIcon.left = it.x - (g_iconXSpacing - g_iconSize) / 2;
        rcIcon.top = it.y;
        rcIcon.right = rcIcon.left + g_iconXSpacing;
        rcIcon.bottom = it.y + g_iconYSpacing;

        if (clickX >= rcIcon.left && clickX < rcIcon.right &&
            clickY >= rcIcon.top && clickY < rcIcon.bottom) {
          sel = (int)i;
          break;
        }
      }
    }

    g_rightClickSelection = sel;
    if (sel >= 0) {
      g_dragIndex = sel;
      g_dragging = true;
      SetCapture(hwnd);
      g_dragOffsetX = clickX - g_desktopItems[sel].x;
      g_dragOffsetY = clickY - g_desktopItems[sel].y;
    } else {
      // Empty area click — just focus ourselves so we're the active window
      SetForegroundWindow(hwnd);
    }
    InvalidateRect(hwnd, NULL, TRUE);
    return 0;
  }
  case WM_MOUSEMOVE: {
    if (g_dragging && g_dragIndex >= 0 &&
        g_dragIndex < (int)g_desktopItems.size()) {
      int mx = GET_X_LPARAM(lParam);
      int my = GET_Y_LPARAM(lParam);
      g_desktopItems[g_dragIndex].x = mx - g_dragOffsetX;
      g_desktopItems[g_dragIndex].y = my - g_dragOffsetY;
      InvalidateRect(hwnd, NULL, FALSE);
      return 0;
    } else if (!g_dragging && g_showIcons) {
      int mx = GET_X_LPARAM(lParam);
      int my = GET_Y_LPARAM(lParam);
      int newHovered = -1;

      for (size_t i = 0; i < g_desktopItems.size(); ++i) {
        const auto &it = g_desktopItems[i];
        RECT rcIcon;
        rcIcon.left = it.x - (g_iconXSpacing - g_iconSize) / 2;
        rcIcon.top = it.y;
        rcIcon.right = rcIcon.left + g_iconXSpacing;
        rcIcon.bottom = it.y + g_iconYSpacing;

        if (mx >= rcIcon.left && mx < rcIcon.right && my >= rcIcon.top &&
            my < rcIcon.bottom) {
          newHovered = (int)i;
          break;
        }
      }

      if (newHovered != g_hoveredIcon) {
        g_hoveredIcon = newHovered;
        InvalidateRect(g_hDesktopWnd, NULL, FALSE);
      }
    }
    break;
  }
  case WM_LBUTTONUP: {
    if (g_dragging) {
      ReleaseCapture();
      g_dragging = false;
      if (g_dragIndex >= 0 && g_dragIndex < (int)g_desktopItems.size()) {
        if (!g_autoArrange) {
          auto &it = g_desktopItems[g_dragIndex];
          int relX = it.x - ICON_X_START;
          int relY = it.y - ICON_Y_START;
          int col = (relX + g_iconXSpacing / 2) / g_iconXSpacing;
          int row = (relY + g_iconYSpacing / 2) / g_iconYSpacing;
          if (col < 0)
            col = 0;
          if (row < 0)
            row = 0;
          it.x = ICON_X_START + col * g_iconXSpacing;
          it.y = ICON_Y_START + row * g_iconYSpacing;
        }
        SaveDesktopPositions();
      }
      g_dragIndex = -1;
      InvalidateRect(hwnd, NULL, TRUE);
    }
    return 0;
  }
  case WM_USER + 1: {
    // Delayed refresh after file operations
    PopulateDesktopIcons();
    InvalidateRect(hwnd, NULL, TRUE);
    return 0;
  }
  case WM_TIMER: {
    if (wParam == 999) {
      KillTimer(hwnd, 999);
      PopulateDesktopIcons();
      InvalidateRect(hwnd, NULL, TRUE);
    }
    return 0;
  }
    // DON'T handle WM_DESTROY - Progman owns this window
    // case WM_DESTROY:
    //     PostQuitMessage(0);
    //     return 0;
  }

  // Pass all unhandled messages to original Progman window proc
  if (g_realDesktopProc) {
    return CallWindowProcW(g_realDesktopProc, hwnd, msg, wParam, lParam);
  }
  return DefWindowProc(hwnd, msg, wParam, lParam);
}

// Returns true if the given window covers the entire screen (real fullscreen).
// Used to reliably detect fullscreen apps since ABN_FULLSCREENAPP is flaky
// for browsers (YouTube) and some games.
static bool IsWindowFullscreen(HWND hwnd) {
  if (!hwnd || !IsWindow(hwnd) || !IsWindowVisible(hwnd))
    return false;

  RECT wndRect;
  if (!GetWindowRect(hwnd, &wndRect))
    return false;

  int sw = GetSystemMetrics(SM_CXSCREEN);
  int sh = GetSystemMetrics(SM_CYSCREEN);

  return wndRect.left <= 0 && wndRect.top <= 0 &&
         wndRect.right >= sw && wndRect.bottom >= sh;
}

// Check if any non-shell window is currently fullscreen.
static bool AnyWindowFullscreen() {
  HWND fgWnd = GetForegroundWindow();
  if (!fgWnd)
    return false;

  // Ignore our own shell windows
  if (fgWnd == g_hDesktopWnd || fgWnd == g_hTaskbarWnd ||
      fgWnd == g_hStartMenuWnd || fgWnd == g_hWeWorkerW ||
      GetAncestor(fgWnd, GA_ROOTOWNER) == g_hWeWorkerW)
    return false;

  return IsWindowFullscreen(fgWnd);
}

LRESULT CALLBACK TaskbarWndProc(HWND hwnd, UINT msg, WPARAM wParam,
                                LPARAM lParam) {
  switch (msg) {
  case WM_PAINT: {
    PAINTSTRUCT ps;
    HDC hdc = BeginPaint(hwnd, &ps);

    RECT rcClient;
    GetClientRect(hwnd, &rcClient);

    // Create buffer for double-buffering
    HDC hdcMem = CreateCompatibleDC(hdc);
    HBITMAP hbmMem =
        CreateCompatibleBitmap(hdc, rcClient.right, rcClient.bottom);
    HBITMAP hbmOld = (HBITMAP)SelectObject(hdcMem, hbmMem);

    // Modern semi-transparent dark background (using custom color)
    HBRUSH br = CreateSolidBrush(g_taskbarColor);
    FillRect(hdcMem, &rcClient, br);
    DeleteObject(br);

    // Draw with GDI+
    Gdiplus::Graphics g(hdcMem);
    g.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);

    // Draw Start button — blue when start menu is closed, brighter/highlighted
    // when open
    bool startMenuOpen = IsWindowVisible(g_hStartMenuWnd) != FALSE;
    int btnX = 6, btnY = 6, btnW = 55, btnH = g_taskbarHeight - 12;
    Gdiplus::RectF btnRect(btnX, btnY, btnW, btnH);

    // Use a brighter blue when the start menu is currently open so the
    // button acts as a clear visual indicator of the toggle state.
    Gdiplus::Color btnColor =
        startMenuOpen
            ? Gdiplus::Color(255, 0, 160, 255)  // bright blue = menu is open
            : Gdiplus::Color(255, 0, 120, 220); // normal blue  = menu is closed
    Gdiplus::SolidBrush btnBrush(btnColor);

    // Rounded square button
    Gdiplus::GraphicsPath btnPath;
    float radius = 4.0f;
    btnPath.AddArc(btnRect.X, btnRect.Y, radius, radius, 180, 90);
    btnPath.AddArc(btnRect.X + btnRect.Width - radius, btnRect.Y, radius,
                   radius, 270, 90);
    btnPath.AddArc(btnRect.X + btnRect.Width - radius,
                   btnRect.Y + btnRect.Height - radius, radius, radius, 0, 90);
    btnPath.AddArc(btnRect.X, btnRect.Y + btnRect.Height - radius, radius,
                   radius, 90, 90);
    btnPath.CloseFigure();

    g.FillPath(&btnBrush, &btnPath);

    // Draw a small "open" indicator line at the top of the button when
    // the start menu is visible, mimicking the Windows 11 underline style.
    if (startMenuOpen) {
      Gdiplus::Pen activePen(Gdiplus::Color(255, 255, 255, 255), 2.0f);
      g.DrawLine(&activePen, btnX + 4, btnY + 2, btnX + btnW - 4, btnY + 2);
    }

    // Draw app icons next to Start button (Windows 11 style)
    int iconSize = 40;
    int iconSpacing = 10;
    int iconStartX = btnX + btnW + 10;
    int currentX = iconStartX;

    // Draw pinned apps with Windows 11 style indicators
    for (size_t i = 0; i < g_taskbarIcons.size(); ++i) {
      if (!g_taskbarIcons[i].visible)
        continue;

      int y = (g_taskbarHeight - iconSize) / 2;
      g_taskbarIcons[i].x = currentX;
      g_taskbarIcons[i].y = y;
      g_taskbarIcons[i].width = iconSize;
      g_taskbarIcons[i].height = iconSize;

      if (g_taskbarIcons[i].hIcon) {
        DrawIconEx(hdcMem, currentX, y, g_taskbarIcons[i].hIcon, iconSize,
                   iconSize, 0, NULL, DI_NORMAL);

        // WINDOWS 11 STYLE: Check if app is running
        bool isRunning = false;
        bool isMinimized = false;
        bool isActive = false;
        HWND appWindow = NULL;

        for (const auto &app : g_runningApps) {
          if (_wcsicmp(GetAppExeName(app.exePath.c_str()).c_str(),
                       GetAppExeName(g_taskbarIcons[i].path.c_str()).c_str()) ==
              0) {
            isRunning = true;
            appWindow = app.hwnd;
            if (appWindow) {
              isMinimized = IsIconic(appWindow);
              isActive = (GetForegroundWindow() == appWindow);
            }
            break;
          }
        }

        // WINDOWS 11 STYLE INDICATORS
        if (isRunning) {
          Gdiplus::Pen *indicatorPen = nullptr;

          if (isActive) {
            indicatorPen =
                new Gdiplus::Pen(Gdiplus::Color(255, 0, 120, 215), 3.0f);
          } else if (isMinimized) {
            indicatorPen =
                new Gdiplus::Pen(Gdiplus::Color(150, 150, 150, 150), 2.0f);
          } else {
            indicatorPen =
                new Gdiplus::Pen(Gdiplus::Color(200, 100, 180, 255), 2.5f);
          }

          int indicatorY = y + iconSize - 4;
          g.DrawLine(indicatorPen, currentX + 8, indicatorY,
                     currentX + iconSize - 8, indicatorY);

          delete indicatorPen;
        }
      }
      currentX += iconSize + iconSpacing;
    }

    // Draw running apps that aren't pinned (to the right of pinned apps)
    int runningAppsX = currentX + 20;

    for (size_t i = 0; i < g_runningApps.size(); ++i) {
      bool alreadyPinned = false;
      for (const auto &pinned : g_taskbarIcons) {
        if (_wcsicmp(GetAppExeName(g_runningApps[i].exePath.c_str()).c_str(),
                     GetAppExeName(pinned.path.c_str()).c_str()) == 0) {
          alreadyPinned = true;
          break;
        }
      }

      if (!alreadyPinned) {
        if (runningAppsX + iconSize > rcClient.right - 150)
          break;

        int y = (g_taskbarHeight - iconSize) / 2;

        if (g_runningApps[i].hIcon) {
          DrawIconEx(hdcMem, runningAppsX, y, g_runningApps[i].hIcon, iconSize,
                     iconSize, 0, NULL, DI_NORMAL);
        } else {
          Gdiplus::SolidBrush colorBrush(Gdiplus::Color(255, 100, 150, 200));
          g.FillRectangle(&colorBrush, runningAppsX, y, iconSize, iconSize);
        }

        g_runningApps[i].visible = true;

        HWND foreground = GetForegroundWindow();
        bool isMinimized = IsIconic(g_runningApps[i].hwnd);
        bool isActive = (foreground == g_runningApps[i].hwnd);

        Gdiplus::Pen *indicatorPen = nullptr;

        if (isActive) {
          indicatorPen =
              new Gdiplus::Pen(Gdiplus::Color(255, 255, 200, 0), 3.0f);
        } else if (isMinimized) {
          indicatorPen =
              new Gdiplus::Pen(Gdiplus::Color(150, 100, 100, 100), 2.0f);
        } else {
          indicatorPen =
              new Gdiplus::Pen(Gdiplus::Color(255, 0, 180, 255), 2.5f);
        }

        int indicatorY = y + iconSize - 4;
        g.DrawLine(indicatorPen, runningAppsX + 8, indicatorY,
                   runningAppsX + iconSize - 8, indicatorY);

        delete indicatorPen;

        runningAppsX += iconSize + iconSpacing;
      }
    }

    // ==================== SYSTEM STATUS INDICATORS ====================
    {
      SYSTEM_POWER_STATUS sps;
      GetSystemPowerStatus(&sps);
      std::wstring batStr = L"Bat: --%";
      if (sps.BatteryLifePercent != 255) {
        batStr = L"Bat: " + std::to_wstring((int)sps.BatteryLifePercent) + L"%";
      }

      Gdiplus::FontFamily utilFamily(L"Segoe UI");
      Gdiplus::Font utilFont(&utilFamily, 14, Gdiplus::FontStyleBold,
                             Gdiplus::UnitPixel);
      Gdiplus::SolidBrush textBrush(Gdiplus::Color(255, 210, 210, 210));

      Gdiplus::StringFormat fmt;
      fmt.SetAlignment(Gdiplus::StringAlignmentCenter);
      fmt.SetLineAlignment(Gdiplus::StringAlignmentCenter);

      int indTotalW = 160;
      int indX = rcClient.right - 90 - 6 - indTotalW - 10;
      int h = rcClient.bottom;

      int acW = 80;  // Action Center button width (replaces Vol+Net)
      int batW = 80;

      // Draw Action Center button — gray rounded pill
      int acBtnMargin = 4;
      Gdiplus::RectF acBtnRect((float)(indX + acBtnMargin),
                               (float)acBtnMargin,
                               (float)(acW - acBtnMargin * 2),
                               (float)(h - acBtnMargin * 2));
      Gdiplus::SolidBrush acBrush(Gdiplus::Color(180, 90, 90, 94));
      int acR = 6;
      Gdiplus::GraphicsPath acPath;
      acPath.AddArc(acBtnRect.X, acBtnRect.Y, (float)(acR * 2), (float)(acR * 2), 180, 90);
      acPath.AddArc(acBtnRect.X + acBtnRect.Width - acR * 2, acBtnRect.Y, (float)(acR * 2), (float)(acR * 2), 270, 90);
      acPath.AddArc(acBtnRect.X + acBtnRect.Width - acR * 2, acBtnRect.Y + acBtnRect.Height - acR * 2, (float)(acR * 2), (float)(acR * 2), 0, 90);
      acPath.AddArc(acBtnRect.X, acBtnRect.Y + acBtnRect.Height - acR * 2, (float)(acR * 2), (float)(acR * 2), 90, 90);
      acPath.CloseFigure();
      g.FillPath(&acBrush, &acPath);

      // Draw "⊞" or a simple notification bell label centered in the button
      Gdiplus::RectF acLabelRect((float)indX, 0.0f, (float)acW, (float)h);
      g.DrawString(L"🔔", -1, &utilFont, acLabelRect, &fmt, &textBrush);

      Gdiplus::RectF batRect((float)(indX + acW), 0.0f, (float)batW, (float)h);
      g.DrawString(batStr.c_str(), -1, &utilFont, batRect, &fmt, &textBrush);
    }

    // ==================== CLOCK + DATE WIDGET ====================
    // Simple, clean clock and date on the right side — no tray icons.
    {
      SYSTEMTIME st;
      GetLocalTime(&st);

      // Format time: HH:MM
      wchar_t timeStr[16];
      wsprintfW(timeStr, L"%02d:%02d", st.wHour, st.wMinute);

      // Format date: DD.MM.YYYY
      wchar_t dateStr[16];
      wsprintfW(dateStr, L"%02d.%02d.%04d", st.wDay, st.wMonth, st.wYear);

      Gdiplus::FontFamily clockFamily(L"Segoe UI");
      Gdiplus::Font timeFont(&clockFamily, 15, Gdiplus::FontStyleBold,
                             Gdiplus::UnitPixel);
      Gdiplus::Font dateFont(&clockFamily, 11, Gdiplus::FontStyleRegular,
                             Gdiplus::UnitPixel);
      Gdiplus::SolidBrush timeBrush(Gdiplus::Color(255, 240, 240, 240));
      Gdiplus::SolidBrush dateBrush(Gdiplus::Color(255, 180, 180, 180));

      Gdiplus::StringFormat fmt;
      fmt.SetAlignment(Gdiplus::StringAlignmentCenter);
      fmt.SetLineAlignment(Gdiplus::StringAlignmentCenter);

      // Widget occupies the rightmost 90px, vertically split: time top half,
      // date bottom half
      int widgetW = 90;
      int widgetX = rcClient.right - widgetW - 6;
      int halfH = rcClient.bottom / 2;

      Gdiplus::RectF timeRect((float)widgetX, 2.0f, (float)widgetW,
                              (float)(halfH - 2));
      Gdiplus::RectF dateRect((float)widgetX, (float)halfH, (float)widgetW,
                              (float)(rcClient.bottom - halfH - 2));

      g.DrawString(timeStr, -1, &timeFont, timeRect, &fmt, &timeBrush);
      g.DrawString(dateStr, -1, &dateFont, dateRect, &fmt, &dateBrush);
    }

    // Blit buffer
    BitBlt(hdc, 0, 0, rcClient.right, rcClient.bottom, hdcMem, 0, 0, SRCCOPY);
    SelectObject(hdcMem, hbmOld);
    DeleteObject(hbmMem);
    DeleteDC(hdcMem);

    EndPaint(hwnd, &ps);
    return 0;
  }
  case WM_RBUTTONDOWN: {
    int clickX = GET_X_LPARAM(lParam);
    int clickY = GET_Y_LPARAM(lParam);

    // Taskbar right-click menu
    HMENU hMenu = CreatePopupMenu();
    AppendMenuW(hMenu, MF_STRING, 40010, L"Pin another app to taskbar");
    AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL);
    AppendMenuW(hMenu, MF_STRING, IDM_RESTART_SHELL, L"Restart Shell");
    AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL);

    // Check if click is over a pinned icon — offer Unpin
    for (size_t i = 0; i < g_taskbarIcons.size() && i < 10; ++i) {
      if (g_taskbarIcons[i].visible && clickX >= g_taskbarIcons[i].x &&
          clickX < g_taskbarIcons[i].x + g_taskbarIcons[i].width &&
          clickY >= g_taskbarIcons[i].y &&
          clickY < g_taskbarIcons[i].y + g_taskbarIcons[i].height) {

        std::wstring appPath = g_taskbarIcons[i].path;
        size_t lastSlash = appPath.find_last_of(L"\\");
        std::wstring appName = (lastSlash != std::wstring::npos)
                                   ? appPath.substr(lastSlash + 1)
                                   : appPath;

        AppendMenuW(hMenu, MF_STRING, 40000 + i,
                    (L"Unpin \"" + appName + L"\" from taskbar").c_str());

        // If the pinned app is running, also offer Kill
        for (const auto &app : g_runningApps) {
          if (_wcsicmp(GetAppExeName(app.exePath.c_str()).c_str(),
                       GetAppExeName(appPath.c_str()).c_str()) == 0) {
            AppendMenuW(hMenu, MF_STRING, 40020 + i,
                        (L"Kill \"" + appName + L"\"").c_str());
            break;
          }
        }
        break;
      }
    }

    // Check if click is over an unpinned running app — offer Kill
    {
      int iconSize = 40, iconSpacing = 10;
      int runningStartX = 6 + 55 + 10;
      for (size_t i = 0; i < g_taskbarIcons.size(); ++i)
        if (g_taskbarIcons[i].visible) runningStartX += iconSize + iconSpacing;
      runningStartX += 20;

      int rx = runningStartX;
      for (size_t i = 0; i < g_runningApps.size(); ++i) {
        bool pinned = false;
        for (const auto &p : g_taskbarIcons)
          if (_wcsicmp(GetAppExeName(g_runningApps[i].exePath.c_str()).c_str(),
                       GetAppExeName(p.path.c_str()).c_str()) == 0)
            { pinned = true; break; }
        if (!pinned) {
          int y = (g_taskbarHeight - iconSize) / 2;
          if (clickX >= rx && clickX < rx + iconSize &&
              clickY >= y && clickY < y + iconSize) {
            std::wstring &exePath = g_runningApps[i].exePath;
            size_t sl = exePath.find_last_of(L"\\");
            std::wstring name = (sl != std::wstring::npos)
                                    ? exePath.substr(sl + 1) : exePath;
            AppendMenuW(hMenu, MF_STRING, 40030 + i,
                        (L"Kill \"" + name + L"\"").c_str());
            break;
          }
          rx += iconSize + iconSpacing;
        }
      }
    }

    POINT pt;
    pt.x = clickX;
    pt.y = clickY;
    ClientToScreen(hwnd, &pt);

    int cmd = TrackPopupMenu(hMenu, TPM_RETURNCMD, pt.x, pt.y, 0, hwnd, NULL);

    if (cmd >= 40000 && cmd < 40010) {
      // Unpin pinned icon
      int idx = cmd - 40000;
      if (idx >= 0 && idx < (int)g_taskbarIcons.size()) {
        g_taskbarPinned.erase(std::remove(g_taskbarPinned.begin(),
                                          g_taskbarPinned.end(),
                                          g_taskbarIcons[idx].path),
                              g_taskbarPinned.end());
        SaveTaskbarConfig();
        PopulateTaskbarIcons();
        InvalidateRect(hwnd, NULL, TRUE);
      }
    } else if (cmd >= 40020 && cmd < 40030) {
      // Kill a pinned-but-running app
      int idx = cmd - 40020;
      if (idx >= 0 && idx < (int)g_taskbarIcons.size()) {
        std::wstring &appPath = g_taskbarIcons[idx].path;
        for (const auto &app : g_runningApps) {
          if (_wcsicmp(GetAppExeName(app.exePath.c_str()).c_str(),
                       GetAppExeName(appPath.c_str()).c_str()) == 0) {
            HANDLE hProc = OpenProcess(PROCESS_TERMINATE, FALSE, app.processId);
            if (hProc) { TerminateProcess(hProc, 1); CloseHandle(hProc); }
            break;
          }
        }
      }
    } else if (cmd >= 40030 && cmd < 40030 + (int)g_runningApps.size()) {
      // Kill an unpinned running app
      int idx = cmd - 40030;
      if (idx >= 0 && idx < (int)g_runningApps.size()) {
        HANDLE hProc = OpenProcess(PROCESS_TERMINATE, FALSE,
                                   g_runningApps[idx].processId);
        if (hProc) { TerminateProcess(hProc, 1); CloseHandle(hProc); }
      }
    } else if (cmd == 40010) {
      ShowWindow(g_hStartMenuWnd,
                 IsWindowVisible(g_hStartMenuWnd) ? SW_HIDE : SW_SHOW);
    } else if (cmd == IDM_RESTART_SHELL) {
      wchar_t exePath[MAX_PATH];
      GetModuleFileNameW(NULL, exePath, MAX_PATH);
      ShellExecuteW(NULL, L"open", exePath, NULL, NULL, SW_SHOW);
      PostQuitMessage(0);
    }

    DestroyMenu(hMenu);
    return 0;
  }
  case WM_LBUTTONDOWN: {
    int clickX = GET_X_LPARAM(lParam);
    int clickY = GET_Y_LPARAM(lParam);

    // ==================== SYSTEM STATUS CLICKS ====================
    {
      RECT rcClient;
      GetClientRect(hwnd, &rcClient);
      int indTotalW = 160;
      int indX = rcClient.right - 90 - 6 - indTotalW - 10;
      int acW = 80;  // Action Center button (replaces Vol+Net)
      int batW = 80;
      if (clickY >= 0 && clickY < rcClient.bottom) {
        if (clickX >= indX && clickX < indX + acW) {
          // Suppress our Win key hook so the injected Win+A reaches Windows
          // as the Action Center shortcut, not our start menu toggle.
          g_suppressWinKeyHook = true;
          INPUT inputs[4] = {};
          inputs[0].type = INPUT_KEYBOARD;
          inputs[0].ki.wVk = VK_LWIN;
          inputs[1].type = INPUT_KEYBOARD;
          inputs[1].ki.wVk = 'A';
          inputs[2].type = INPUT_KEYBOARD;
          inputs[2].ki.wVk = 'A';
          inputs[2].ki.dwFlags = KEYEVENTF_KEYUP;
          inputs[3].type = INPUT_KEYBOARD;
          inputs[3].ki.wVk = VK_LWIN;
          inputs[3].ki.dwFlags = KEYEVENTF_KEYUP;
          SendInput(4, inputs, sizeof(INPUT));
          // Re-enable the hook after the keystrokes have been processed
          SetTimer(hwnd, 9901, 300, [](HWND, UINT, UINT_PTR id, DWORD) {
            KillTimer(NULL, id);
            g_suppressWinKeyHook = false;
          });
          return 0;
        }
        if (clickX >= indX + acW &&
            clickX < indX + acW + batW) {
          ShellExecuteW(NULL, L"open", L"ms-settings:batterysaver", NULL, NULL,
                        SW_SHOW);
          return 0;
        }
      }
    }

    // ==================== START BUTTON ====================
    // Check Start button clicked — toggle start menu open/closed.
    // This is the ONLY place (besides the Windows key hook) that
    // opens or closes the start menu. Desktop clicks no longer do this.
    if (clickX >= 6 && clickX < 61 && clickY >= 6 &&
        clickY < g_taskbarHeight - 6) {
      bool isVisible = IsWindowVisible(g_hStartMenuWnd) != FALSE;
      if (isVisible) {
        // Close the start menu and restore normal Z-order
        RestoreShellZOrder();
      } else {
        // Open the start menu on top of ALL windows (including fullscreen apps)
        BringShellToTopmost();
      }
      // Repaint taskbar so button highlight updates immediately
      InvalidateRect(hwnd, NULL, TRUE);
      return 0;
    }

    // WINDOWS 11 TASK BEHAVIOR FOR PINNED APPS
    for (size_t i = 0; i < g_taskbarIcons.size(); ++i) {
      if (g_taskbarIcons[i].visible && clickX >= g_taskbarIcons[i].x &&
          clickX < g_taskbarIcons[i].x + g_taskbarIcons[i].width &&
          clickY >= g_taskbarIcons[i].y &&
          clickY < g_taskbarIcons[i].y + g_taskbarIcons[i].height) {

        HWND targetWindow = NULL;
        bool isRunning = false;

        for (const auto &app : g_runningApps) {
          if (_wcsicmp(GetAppExeName(app.exePath.c_str()).c_str(),
                       GetAppExeName(g_taskbarIcons[i].path.c_str()).c_str()) ==
              0) {
            targetWindow = app.hwnd;
            isRunning = true;
            break;
          }
        }

        if (isRunning && targetWindow && IsWindow(targetWindow)) {
          bool isMinimized = IsIconic(targetWindow);
          HWND foregroundWindow = GetForegroundWindow();

          if (isMinimized) {
            ShowWindow(targetWindow, SW_RESTORE);
            SetForegroundWindow(targetWindow);
            SetWindowPos(targetWindow, HWND_TOP, 0, 0, 0, 0,
                         SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
            FlashWindowIfMinimized(targetWindow);
          } else if (foregroundWindow == targetWindow) {
            ShowWindow(targetWindow, SW_MINIMIZE);
            FlashWindowIfMinimized(targetWindow);
          } else {
            SetForegroundWindow(targetWindow);
            SetWindowPos(targetWindow, HWND_TOP, 0, 0, 0, 0,
                         SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);

            FLASHWINFO fwi;
            fwi.cbSize = sizeof(FLASHWINFO);
            fwi.hwnd = targetWindow;
            fwi.dwFlags = FLASHW_TRAY;
            fwi.uCount = 1;
            fwi.dwTimeout = 0;
            FlashWindowEx(&fwi);
          }
        } else {
          LaunchApp(g_taskbarIcons[i].path.c_str());
        }
        return 0;
      }
    }

    // WINDOWS 11 BEHAVIOR FOR RUNNING APPS (NOT PINNED)
    int iconSize = 40;
    int iconSpacing = 10;
    int runningAppsStartX = 6 + 55 + 10;

    for (size_t i = 0; i < g_taskbarIcons.size(); ++i) {
      if (g_taskbarIcons[i].visible) {
        runningAppsStartX += iconSize + iconSpacing;
      }
    }
    runningAppsStartX += 20;

    int currentX = runningAppsStartX;
    for (size_t i = 0; i < g_runningApps.size(); ++i) {
      bool alreadyPinned = false;
      for (const auto &pinned : g_taskbarIcons) {
        if (_wcsicmp(GetAppExeName(g_runningApps[i].exePath.c_str()).c_str(),
                     GetAppExeName(pinned.path.c_str()).c_str()) == 0) {
          alreadyPinned = true;
          break;
        }
      }

      if (!alreadyPinned) {
        int y = (g_taskbarHeight - iconSize) / 2;

        if (clickX >= currentX && clickX < currentX + iconSize && clickY >= y &&
            clickY < y + iconSize) {

          HWND targetWindow = g_runningApps[i].hwnd;
          bool isMinimized = IsIconic(targetWindow);
          HWND foregroundWindow = GetForegroundWindow();

          if (isMinimized) {
            ShowWindow(targetWindow, SW_RESTORE);
            SetForegroundWindow(targetWindow);
            SetWindowPos(targetWindow, HWND_TOP, 0, 0, 0, 0,
                         SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
          } else if (foregroundWindow == targetWindow) {
            ShowWindow(targetWindow, SW_MINIMIZE);
            FlashWindowIfMinimized(targetWindow);
          } else {
            SetForegroundWindow(targetWindow);
            SetWindowPos(targetWindow, HWND_TOP, 0, 0, 0, 0,
                         SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
          }
          return 0;
        }
        currentX += iconSize + iconSpacing;
      }
    }

    return 0;
  }
  case WM_TIMER: {
    // Update window activation — only repaint if foreground changed
    HWND currentForeground = GetForegroundWindow();
    bool needsRepaint = false;
    if (currentForeground != g_lastForegroundWindow) {
      g_lastForegroundWindow = currentForeground;
      needsRepaint = true;
    }

    // Update running apps — only repaint if the list actually changed
    size_t prevCount = g_runningApps.size();
    UpdateRunningAppsList();
    if (g_runningApps.size() != prevCount) {
      needsRepaint = true;
    }

    // Always repaint clock (time changes every minute)
    static DWORD lastClockMinute = 0xFFFFFFFF;
    SYSTEMTIME st;
    GetLocalTime(&st);
    DWORD thisMinute = st.wHour * 60 + st.wMinute;
    if (thisMinute != lastClockMinute) {
      lastClockMinute = thisMinute;
      needsRepaint = true;
    }

    // Periodically verify work area is correct (WE can reset it silently)
    static DWORD lastWorkAreaCheck = 0;
    DWORD currentTime = GetTickCount();
    if (currentTime - lastWorkAreaCheck > 2000) {
      lastWorkAreaCheck = currentTime;
      RECT currentWork;
      SystemParametersInfoW(SPI_GETWORKAREA, 0, &currentWork, 0);
      int screenH = GetSystemMetrics(SM_CYSCREEN);
      int expectedBottom = screenH - g_taskbarHeight;
      if (currentWork.bottom != expectedBottom) {
        RECT workArea = {0, 0, GetSystemMetrics(SM_CXSCREEN), expectedBottom};
        SystemParametersInfoW(SPI_SETWORKAREA, 0, &workArea, SPIF_SENDCHANGE);
      }
    }

    // Poll for real fullscreen — ABN_FULLSCREENAPP is unreliable for
    // browsers (YouTube) and some games (CS2). Hide taskbar when a
    // fullscreen window is detected, restore when it's gone.
    if (!IsWindowVisible(g_hStartMenuWnd)) {
      bool nowFullscreen = AnyWindowFullscreen();
      if (nowFullscreen != g_fullscreenActive) {
        g_fullscreenActive = nowFullscreen;
        if (nowFullscreen) {
          ShowWindow(hwnd, SW_HIDE);
        } else {
          ShowWindow(hwnd, SW_SHOW);
          SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0,
                       SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_SHOWWINDOW);
        }
        needsRepaint = true;
      }
    }

    if (needsRepaint) {
      InvalidateRect(hwnd, NULL, FALSE);
    }

    return 0;
  }
  case WM_SETTINGCHANGE: {
    // WE or another app reset the work area — restore it silently.
    // Only act on SPI_SETWORKAREA, not every setting change.
    // Use a flag to avoid re-entrancy (our own SetAppBarPos broadcasts this).
    static bool s_restoringWorkArea = false;
    if (!s_restoringWorkArea && wParam == SPI_SETWORKAREA) {
      RECT currentWork;
      SystemParametersInfoW(SPI_GETWORKAREA, 0, &currentWork, 0);
      int screenH = GetSystemMetrics(SM_CYSCREEN);
      int expectedBottom = screenH - g_taskbarHeight;
      if (currentWork.bottom != expectedBottom) {
        s_restoringWorkArea = true;
        RECT workArea = {0, 0, GetSystemMetrics(SM_CXSCREEN), expectedBottom};
        SystemParametersInfoW(SPI_SETWORKAREA, 0, &workArea, SPIF_SENDCHANGE);
        s_restoringWorkArea = false;
      }
    }
    return 0;
  }
  case APPBAR_CALLBACK: {
    switch (wParam) {
    case ABN_FULLSCREENAPP: {
      // ABN_FULLSCREENAPP is unreliable (browsers/some games skip it).
      // The 500ms timer polls AnyWindowFullscreen() for reliable detection.
      // We still handle it here as a fast-path to react immediately.
      HWND fgWnd = GetForegroundWindow();
      HWND fgRoot = GetAncestor(fgWnd, GA_ROOTOWNER);
      bool isOurWindow = (fgWnd == g_hWeWorkerW || fgRoot == g_hWeWorkerW ||
                          fgWnd == g_hDesktopWnd || fgWnd == g_hTaskbarWnd ||
                          fgWnd == g_hStartMenuWnd);
      if (isOurWindow)
        break;
      if (IsWindowVisible(g_hStartMenuWnd))
        break;

      if (lParam) {
        g_fullscreenActive = true;
        ShowWindow(hwnd, SW_HIDE);
      } else {
        g_fullscreenActive = false;
        ShowWindow(hwnd, SW_SHOW);
        SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0,
                     SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_SHOWWINDOW);
      }
      break;
    }
    case ABN_POSCHANGED:
      SetAppBarPos(hwnd);
      break;
    }
    return 0;
  }
  }
  return DefWindowProc(hwnd, msg, wParam, lParam);
}

// ==================== START MENU (unchanged) ====================

LRESULT CALLBACK StartMenuWndProc(HWND hwnd, UINT msg, WPARAM wParam,
                                  LPARAM lParam) {
  switch (msg) {
  case WM_PAINT: {
    PAINTSTRUCT ps;
    HDC hdc = BeginPaint(hwnd, &ps);
    RECT rcClient;
    GetClientRect(hwnd, &rcClient);

    HDC hdcMem = CreateCompatibleDC(hdc);
    HBITMAP hbmMem =
        CreateCompatibleBitmap(hdc, rcClient.right, rcClient.bottom);
    HBITMAP hbmOld = (HBITMAP)SelectObject(hdcMem, hbmMem);

    HBRUSH br = CreateSolidBrush(g_startMenuColor);
    FillRect(hdcMem, &rcClient, br);
    DeleteObject(br);

    Gdiplus::Graphics g(hdcMem);
    g.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
    g.SetTextRenderingHint(Gdiplus::TextRenderingHintAntiAlias);

    g_sidebarItems.clear();

    int sidebarWidth = 350;
    // Use the same color as start menu background
    BYTE r = GetRValue(g_startMenuColor);
    BYTE g_val = GetGValue(g_startMenuColor);
    BYTE b = GetBValue(g_startMenuColor);
    Gdiplus::SolidBrush sidebarBrush(Gdiplus::Color(255, r, g_val, b));
    g.FillRectangle(&sidebarBrush, 0, 0, sidebarWidth, rcClient.bottom);

    int sidebarY = 15 - g_sidebarScrollOffset;

    if (g_currentSidebarFolder !=
        L"C:\\ProgramData\\Microsoft\\Windows\\Start Menu\\Programs") {
      if (sidebarY >= 0 && sidebarY < rcClient.bottom) {
        SidebarItemInfo backBtn;
        backBtn.isFolder = true;
        backBtn.name = L"..";
        backBtn.fullPath = L"PARENT";
        backBtn.yPos = sidebarY;
        backBtn.height = 32;
        g_sidebarItems.push_back(backBtn);

        Gdiplus::RectF backRect(10, sidebarY, 24, 24);
        Gdiplus::SolidBrush backBrush(Gdiplus::Color(255, 180, 180, 180));
        g.FillRectangle(&backBrush, backRect);

        Gdiplus::FontFamily fontFamily(L"Segoe UI");
        Gdiplus::Font sidebarFont(&fontFamily, 11, Gdiplus::FontStyleRegular,
                                  Gdiplus::UnitPixel);
        Gdiplus::SolidBrush textBrush(Gdiplus::Color(255, 220, 220, 220));

        Gdiplus::RectF backTextRect(10, sidebarY, sidebarWidth - 20, 24);
        Gdiplus::StringFormat centerFormat;
        centerFormat.SetAlignment(Gdiplus::StringAlignmentCenter);
        centerFormat.SetLineAlignment(Gdiplus::StringAlignmentCenter);
        g.DrawString(L"..", -1, &sidebarFont, backTextRect, &centerFormat,
                     &textBrush);
      }
      sidebarY += 32;
    }

    // Each entry: (filename, isFolder, sourceFolder)
    std::vector<std::tuple<std::wstring, bool, std::wstring>> items;
    WIN32_FIND_DATAW findData;

    // Collect items from current folder plus per-user Start Menu if we're at
    // root
    std::vector<std::wstring> foldersToMerge = {g_currentSidebarFolder};
    if (g_currentSidebarFolder ==
        L"C:\\ProgramData\\Microsoft\\Windows\\Start Menu\\Programs") {
      PWSTR pszUser = NULL;
      if (SUCCEEDED(
              SHGetKnownFolderPath(FOLDERID_Programs, 0, NULL, &pszUser))) {
        foldersToMerge.push_back(pszUser);
        CoTaskMemFree(pszUser);
      }
    }

    for (const auto &scanFolder : foldersToMerge) {
      HANDLE hFindF = FindFirstFileW((scanFolder + L"\\*").c_str(), &findData);
      if (hFindF == INVALID_HANDLE_VALUE)
        continue;
      do {
        if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) &&
            wcscmp(findData.cFileName, L".") != 0 &&
            wcscmp(findData.cFileName, L"..") != 0) {

          bool isFolder =
              (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
          std::wstring name = findData.cFileName;

          if (isFolder || wcsstr(findData.cFileName, L".lnk")) {
            // Deduplicate by name — keep whichever source folder we found first
            bool dup = false;
            for (const auto &existing : items)
              if (_wcsicmp(std::get<0>(existing).c_str(), name.c_str()) == 0) {
                dup = true;
                break;
              }
            if (!dup)
              items.push_back({name, isFolder, scanFolder});
          }
        }
      } while (FindNextFileW(hFindF, &findData));
      FindClose(hFindF);
    }

    std::sort(items.begin(), items.end(),
              [](const std::tuple<std::wstring, bool, std::wstring> &a,
                 const std::tuple<std::wstring, bool, std::wstring> &b) {
                return _wcsicmp(std::get<0>(a).c_str(), std::get<0>(b).c_str()) < 0;
              });

    Gdiplus::FontFamily fontFamily(L"Segoe UI");
    Gdiplus::Font sidebarFont(&fontFamily, 11, Gdiplus::FontStyleRegular,
                              Gdiplus::UnitPixel);
    Gdiplus::SolidBrush textBrush(Gdiplus::Color(255, 220, 220, 220));
    Gdiplus::SolidBrush folderBrush(Gdiplus::Color(255, 150, 150, 200));

    for (const auto &item : items) {
      if (sidebarY > rcClient.bottom)
        break;
      if (sidebarY + 32 < 0) {
        sidebarY += 32;
        continue;
      }

      // Use the actual source folder this item came from, not g_currentSidebarFolder.
      // This fixes shortcuts from the per-user Start Menu being given the wrong
      // ProgramData path (which doesn't exist) and triggering "cannot find" errors.
      std::wstring fullPath = std::get<2>(item) + L"\\" + std::get<0>(item);

      SidebarItemInfo info;
      info.isFolder = std::get<1>(item);
      info.name = std::get<0>(item);
      info.fullPath = fullPath;
      info.yPos = sidebarY;
      info.height = 32;
      g_sidebarItems.push_back(info);

      HICON hIcon = GetIconForPath(fullPath, 48);

      if (hIcon) {
        DrawIconWithGDIPlus(&g, hIcon, 10, sidebarY, std::get<1>(item) ? 20 : 24);
        DestroyIcon(hIcon);
      }

      if (std::get<1>(item)) {
        Gdiplus::RectF folderIndicator(34, sidebarY + 8, 4, 4);
        Gdiplus::SolidBrush indicatorBrush(Gdiplus::Color(255, 100, 200, 255));
        g.FillEllipse(&indicatorBrush, folderIndicator);
      }

      std::wstring displayName = std::get<0>(item);
      if (std::get<1>(item) == false &&
          displayName.find(L".lnk") != std::wstring::npos) {
        displayName = displayName.substr(0, displayName.length() - 4);
      }
      if (displayName.length() > 18) {
        displayName = displayName.substr(0, 15) + L"...";
      }

      Gdiplus::RectF textRect(40, sidebarY, sidebarWidth - 50, 24);
      Gdiplus::StringFormat format;
      format.SetAlignment(Gdiplus::StringAlignmentNear);
      format.SetLineAlignment(Gdiplus::StringAlignmentCenter);

      Gdiplus::SolidBrush *brush = std::get<1>(item) ? &folderBrush : &textBrush;
      g.DrawString(displayName.c_str(), -1, &sidebarFont, textRect, &format,
                   brush);

      sidebarY += 32;
    }

    // Draw power buttons at the bottom of sidebar
    int powerButtonY = rcClient.bottom - 60; // 60 pixels from bottom
    int powerButtonWidth = 100;
    int powerButtonHeight = 40;
    int powerButtonSpacing = 10;
    int totalButtonWidth = (powerButtonWidth * 3) + (powerButtonSpacing * 2);
    int powerButtonStartX =
        (sidebarWidth - totalButtonWidth) / 2; // Center buttons

    Gdiplus::Font powerFont(&fontFamily, 10, Gdiplus::FontStyleBold,
                            Gdiplus::UnitPixel);
    Gdiplus::SolidBrush powerTextBrush(Gdiplus::Color(255, 255, 255, 255));
    Gdiplus::StringFormat centerFormat;
    centerFormat.SetAlignment(Gdiplus::StringAlignmentCenter);
    centerFormat.SetLineAlignment(Gdiplus::StringAlignmentCenter);

    // Shutdown button
    Gdiplus::RectF shutdownRect(powerButtonStartX, powerButtonY,
                                powerButtonWidth, powerButtonHeight);
    Gdiplus::SolidBrush shutdownBrush(Gdiplus::Color(255, 200, 50, 50));
    g.FillRectangle(&shutdownBrush, shutdownRect);
    Gdiplus::Pen shutdownPen(Gdiplus::Color(255, 150, 30, 30), 2);
    g.DrawRectangle(&shutdownPen, shutdownRect);
    g.DrawString(L"Shutdown", -1, &powerFont, shutdownRect, &centerFormat,
                 &powerTextBrush);

    // Restart button
    Gdiplus::RectF restartRect(
        powerButtonStartX + powerButtonWidth + powerButtonSpacing, powerButtonY,
        powerButtonWidth, powerButtonHeight);
    Gdiplus::SolidBrush restartBrush(Gdiplus::Color(255, 50, 150, 200));
    g.FillRectangle(&restartBrush, restartRect);
    Gdiplus::Pen restartPen(Gdiplus::Color(255, 30, 100, 150), 2);
    g.DrawRectangle(&restartPen, restartRect);
    g.DrawString(L"Restart", -1, &powerFont, restartRect, &centerFormat,
                 &powerTextBrush);

    // Sleep button
    Gdiplus::RectF sleepRect(powerButtonStartX +
                                 (powerButtonWidth + powerButtonSpacing) * 2,
                             powerButtonY, powerButtonWidth, powerButtonHeight);
    Gdiplus::SolidBrush sleepBrush(Gdiplus::Color(255, 100, 100, 100));
    g.FillRectangle(&sleepBrush, sleepRect);
    Gdiplus::Pen sleepPen(Gdiplus::Color(255, 60, 60, 60), 2);
    g.DrawRectangle(&sleepPen, sleepRect);
    g.DrawString(L"Sleep", -1, &powerFont, sleepRect, &centerFormat,
                 &powerTextBrush);

    int contentX = sidebarWidth + 20;
    int contentWidth = rcClient.right - contentX - 20;

    int tileSize = 100;
    int tileSpacing = 120;
    int tilesPerRow = contentWidth / tileSpacing;
    if (tilesPerRow < 1)
      tilesPerRow = 1;

    Gdiplus::Font appNameFont(&fontFamily, 10, Gdiplus::FontStyleRegular,
                              Gdiplus::UnitPixel);
    Gdiplus::SolidBrush tileTextBrush(Gdiplus::Color(255, 240, 240, 240));

    g_tilePositionsX.clear();
    g_tilePositionsY.clear();

    for (size_t i = 0; i < g_pinnedApps.size(); ++i) {
      int row = i / tilesPerRow;
      int col = i % tilesPerRow;
      int tileX = contentX + col * tileSpacing;
      int tileRectY = 30 + row * tileSpacing - g_startMenuScrollOffset;

      g_tilePositionsX.push_back(tileX);
      g_tilePositionsY.push_back(tileRectY);

      if (tileRectY + tileSize < 0 || tileRectY > rcClient.bottom)
        continue;

      Gdiplus::RectF tileRect(tileX, tileRectY, tileSize, tileSize);
      Gdiplus::Color bgColor = (g_startMenuDragIndex == (int)i)
                                   ? Gdiplus::Color(100, 120, 180, 240)
                                   : Gdiplus::Color(50, 100, 150, 200);
      Gdiplus::SolidBrush tileBgBrush(bgColor);
      g.FillRectangle(&tileBgBrush, tileRect);

      Gdiplus::Pen borderPen(Gdiplus::Color(100, 150, 200, 250), 1);
      g.DrawRectangle(&borderPen, tileRect);

      HICON hIcon = GetIconForPath(g_pinnedApps[i], 48);

      if (hIcon) {
        DrawIconWithGDIPlus(&g, hIcon, tileX + 10, tileRectY + 10, 60);
        DestroyIcon(hIcon);
      } else {
        Gdiplus::Color colors[] = {Gdiplus::Color(200, 52, 152, 219),
                                   Gdiplus::Color(200, 230, 126, 34),
                                   Gdiplus::Color(200, 46, 204, 113),
                                   Gdiplus::Color(200, 231, 76, 60),
                                   Gdiplus::Color(200, 155, 89, 182),
                                   Gdiplus::Color(200, 22, 160, 133)};
        Gdiplus::SolidBrush colorBrush(colors[i % 6]);
        g.FillRectangle(&colorBrush,
                        Gdiplus::RectF(tileX + 10, tileRectY + 10, 60, 60));
      }

      std::wstring appName = g_pinnedApps[i];
      size_t lastSlash = appName.find_last_of(L"\\");
      if (lastSlash != std::wstring::npos) {
        appName = appName.substr(lastSlash + 1);
      }
      size_t dotPos = appName.find_last_of(L".");
      if (dotPos != std::wstring::npos) {
        appName = appName.substr(0, dotPos);
      }

      Gdiplus::RectF textRect(tileX, tileRectY + 75, tileSize, 20);
      Gdiplus::StringFormat format;
      format.SetAlignment(Gdiplus::StringAlignmentCenter);
      format.SetLineAlignment(Gdiplus::StringAlignmentCenter);
      format.SetFormatFlags(Gdiplus::StringFormatFlagsNoWrap);
      g.DrawString(appName.c_str(), -1, &appNameFont, textRect, &format,
                   &tileTextBrush);
    }

    BitBlt(hdc, 0, 0, rcClient.right, rcClient.bottom, hdcMem, 0, 0, SRCCOPY);
    SelectObject(hdcMem, hbmOld);
    DeleteObject(hbmMem);
    DeleteDC(hdcMem);

    EndPaint(hwnd, &ps);
    return 0;
  }
  case WM_MOUSEWHEEL: {
    int clickX = LOWORD(lParam);
    int clickY = HIWORD(lParam);
    int zDelta = GET_WHEEL_DELTA_WPARAM(wParam);
    int scrollAmount = 36;
    int sidebarWidth = 350;

    if (clickX < sidebarWidth) {
      if (zDelta > 0) {
        g_sidebarScrollOffset -= scrollAmount;
        if (g_sidebarScrollOffset < 0)
          g_sidebarScrollOffset = 0;
      } else {
        g_sidebarScrollOffset += scrollAmount;
      }
      InvalidateRect(hwnd, NULL, FALSE);
      return 0;
    }

    RECT rcClient;
    GetClientRect(hwnd, &rcClient);
    int contentWidth = rcClient.right - sidebarWidth - 40;
    int tilesPerRow = contentWidth / 120;
    if (tilesPerRow < 1)
      tilesPerRow = 1;
    int totalTiles = g_pinnedApps.size();
    int totalRows = (totalTiles + tilesPerRow - 1) / tilesPerRow;
    int totalHeight = totalRows * 120;
    int contentHeight = rcClient.bottom - 60;
    int maxScroll =
        (totalHeight > contentHeight) ? (totalHeight - contentHeight) : 0;

    if (zDelta > 0) {
      g_startMenuScrollOffset -= scrollAmount;
      if (g_startMenuScrollOffset < 0)
        g_startMenuScrollOffset = 0;
    } else {
      g_startMenuScrollOffset += scrollAmount;
      if (g_startMenuScrollOffset > maxScroll)
        g_startMenuScrollOffset = maxScroll;
    }
    InvalidateRect(hwnd, NULL, FALSE);
    return 0;
  }
  case WM_LBUTTONDOWN: {
    int clickX = LOWORD(lParam);
    int clickY = HIWORD(lParam);
    int sidebarWidth = 350;

    if (clickX < sidebarWidth) {
      RECT rcClient;
      GetClientRect(hwnd, &rcClient);

      // Check if clicking on power buttons
      int powerButtonY = rcClient.bottom - 60;
      int powerButtonWidth = 100;
      int powerButtonHeight = 40;
      int powerButtonSpacing = 10;
      int totalButtonWidth = (powerButtonWidth * 3) + (powerButtonSpacing * 2);
      int powerButtonStartX = (sidebarWidth - totalButtonWidth) / 2;

      // Shutdown button
      if (clickX >= powerButtonStartX &&
          clickX < powerButtonStartX + powerButtonWidth &&
          clickY >= powerButtonY && clickY < powerButtonY + powerButtonHeight) {
        // Shutdown the computer
        system("shutdown /s /t 0");
        return 0;
      }

      // Restart button
      int restartX = powerButtonStartX + powerButtonWidth + powerButtonSpacing;
      if (clickX >= restartX && clickX < restartX + powerButtonWidth &&
          clickY >= powerButtonY && clickY < powerButtonY + powerButtonHeight) {
        // Restart the computer
        system("shutdown /r /t 0");
        return 0;
      }

      // Sleep button
      int sleepX =
          powerButtonStartX + (powerButtonWidth + powerButtonSpacing) * 2;
      if (clickX >= sleepX && clickX < sleepX + powerButtonWidth &&
          clickY >= powerButtonY && clickY < powerButtonY + powerButtonHeight) {
        // Put computer to sleep
        SetSuspendState(FALSE, FALSE, FALSE);
        return 0;
      }

      // Handle sidebar item clicks
      for (const auto &item : g_sidebarItems) {
        if (clickY >= item.yPos && clickY < item.yPos + item.height) {
          if (item.name == L"..") {
            size_t lastSlash = g_currentSidebarFolder.find_last_of(L"\\");
            if (lastSlash != std::wstring::npos) {
              g_currentSidebarFolder =
                  g_currentSidebarFolder.substr(0, lastSlash);
            }
          } else if (item.isFolder) {
            g_currentSidebarFolder = item.fullPath;
          } else {
            LaunchApp(item.fullPath.c_str());
            // Do NOT close the start menu here — user must use the
            // blue button or Windows key to dismiss it.
          }
          InvalidateRect(hwnd, NULL, FALSE);
          return 0;
        }
      }
      return 0;
    }

    RECT rcClient;
    GetClientRect(hwnd, &rcClient);
    int contentX = sidebarWidth + 20;
    int contentWidth = rcClient.right - contentX - 20;
    int tileSize = 100;
    int tileSpacing = 120;
    int tilesPerRow = contentWidth / tileSpacing;
    if (tilesPerRow < 1)
      tilesPerRow = 1;

    for (size_t i = 0; i < g_pinnedApps.size(); ++i) {
      int row = i / tilesPerRow;
      int col = i % tilesPerRow;
      int tileX = contentX + col * tileSpacing;
      int tileY = 30 + row * tileSpacing - g_startMenuScrollOffset;

      if (clickX >= tileX && clickX < tileX + tileSize && clickY >= tileY &&
          clickY < tileY + tileSize) {
        LaunchApp(g_pinnedApps[i].c_str());
        // Do NOT close the start menu here — user must use the
        // blue button or Windows key to dismiss it.
        return 0;
      }
    }
    return 0;
  }
  case WM_RBUTTONDOWN: {
    int clickX = LOWORD(lParam);
    int clickY = HIWORD(lParam);
    int sidebarWidth = 350;

    if (clickX < sidebarWidth) {
      for (const auto &item : g_sidebarItems) {
        if (clickY >= item.yPos && clickY < item.yPos + item.height &&
            !item.isFolder && item.name != L"..") {
          HMENU hMenu = CreatePopupMenu();

          bool inStartMenu = false;
          bool inTaskbar = false;

          for (const auto &app : g_pinnedApps) {
            if (_wcsicmp(app.c_str(), item.fullPath.c_str()) == 0) {
              inStartMenu = true;
              break;
            }
          }

          for (const auto &app : g_taskbarPinned) {
            if (_wcsicmp(app.c_str(), item.fullPath.c_str()) == 0) {
              inTaskbar = true;
              break;
            }
          }

          if (inStartMenu) {
            AppendMenuW(hMenu, MF_STRING, 51000, L"Remove from Start Menu");
          } else {
            AppendMenuW(hMenu, MF_STRING, 51001, L"Pin to Start Menu");
          }

          AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL);
          AppendMenuW(hMenu, MF_STRING, 51004, L"Open");
          AppendMenuW(hMenu, MF_STRING, 51005, L"Run as administrator");
          AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL);

          if (inTaskbar) {
            AppendMenuW(hMenu, MF_STRING, 51002, L"Unpin from Taskbar");
          } else {
            AppendMenuW(hMenu, MF_STRING, 51003, L"Pin to Taskbar");
          }

          POINT pt;
          GetCursorPos(&pt);

          int cmd =
              TrackPopupMenu(hMenu, TPM_RETURNCMD, pt.x, pt.y, 0, hwnd, NULL);

          if (cmd == 51000) {
            g_pinnedApps.erase(
                std::remove_if(g_pinnedApps.begin(), g_pinnedApps.end(),
                               [&item](const std::wstring &app) {
                                 return _wcsicmp(app.c_str(),
                                                 item.fullPath.c_str()) == 0;
                               }),
                g_pinnedApps.end());
            SaveStartMenuPositions();
            InvalidateRect(hwnd, NULL, FALSE);
          } else if (cmd == 51001) {
            g_pinnedApps.push_back(item.fullPath);
            SaveStartMenuPositions();
            InvalidateRect(hwnd, NULL, FALSE);
          } else if (cmd == 51002) {
            g_taskbarPinned.erase(
                std::remove_if(g_taskbarPinned.begin(), g_taskbarPinned.end(),
                               [&item](const std::wstring &app) {
                                 return _wcsicmp(app.c_str(),
                                                 item.fullPath.c_str()) == 0;
                               }),
                g_taskbarPinned.end());
            SaveTaskbarConfig();
            PopulateTaskbarIcons();
            InvalidateRect(g_hTaskbarWnd, NULL, TRUE);
          } else if (cmd == 51003) {
            g_taskbarPinned.push_back(item.fullPath);
            SaveTaskbarConfig();
            PopulateTaskbarIcons();
            InvalidateRect(g_hTaskbarWnd, NULL, TRUE);
          } else if (cmd == 51004) {
            LaunchApp(item.fullPath.c_str());
          } else if (cmd == 51005) {
            SHELLEXECUTEINFOW sei = {};
            sei.cbSize = sizeof(sei);
            sei.fMask = SEE_MASK_NOCLOSEPROCESS;
            sei.lpVerb = L"runas";
            sei.lpFile = item.fullPath.c_str();
            sei.nShow = SW_SHOWNORMAL;
            ShellExecuteExW(&sei);
            if (sei.hProcess) CloseHandle(sei.hProcess);
          }

          DestroyMenu(hMenu);
          return 0;
        }
      }
      return 0;
    }

    RECT rcClient;
    GetClientRect(hwnd, &rcClient);
    int contentX = sidebarWidth + 20;
    int contentWidth = rcClient.right - contentX - 20;
    int tileSize = 100;
    int tileSpacing = 120;
    int tilesPerRow = contentWidth / tileSpacing;
    if (tilesPerRow < 1)
      tilesPerRow = 1;

    for (size_t i = 0; i < g_pinnedApps.size(); ++i) {
      int row = i / tilesPerRow;
      int col = i % tilesPerRow;
      int tileX = contentX + col * tileSpacing;
      int tileY = 30 + row * tileSpacing - g_startMenuScrollOffset;

      if (clickX >= tileX && clickX < tileX + tileSize && clickY >= tileY &&
          clickY < tileY + tileSize) {

        HMENU hMenu = CreatePopupMenu();

        bool alreadyPinned =
            std::find(g_taskbarPinned.begin(), g_taskbarPinned.end(),
                      g_pinnedApps[i]) != g_taskbarPinned.end();

        if (alreadyPinned) {
          AppendMenuW(hMenu, MF_STRING, 50000, L"Unpin from taskbar");
        } else {
          AppendMenuW(hMenu, MF_STRING, 50000, L"Pin to taskbar");
        }

        AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL);
        AppendMenuW(hMenu, MF_STRING, 50002, L"Open");
        AppendMenuW(hMenu, MF_STRING, 50003, L"Run as administrator");
        AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL);
        AppendMenuW(hMenu, MF_STRING, 50001, L"Remove from Start");

        POINT pt;
        GetCursorPos(&pt);

        int cmd =
            TrackPopupMenu(hMenu, TPM_RETURNCMD, pt.x, pt.y, 0, hwnd, NULL);

        if (cmd == 50000) {
          if (alreadyPinned) {
            g_taskbarPinned.erase(std::remove(g_taskbarPinned.begin(),
                                              g_taskbarPinned.end(),
                                              g_pinnedApps[i]),
                                  g_taskbarPinned.end());
          } else {
            g_taskbarPinned.push_back(g_pinnedApps[i]);
          }
          SaveTaskbarConfig();
          PopulateTaskbarIcons();
          InvalidateRect(g_hTaskbarWnd, NULL, TRUE);
        } else if (cmd == 50001) {
          g_pinnedApps.erase(g_pinnedApps.begin() + i);
          SaveStartMenuPositions();
          InvalidateRect(hwnd, NULL, FALSE);
        } else if (cmd == 50002) {
          LaunchApp(g_pinnedApps[i].c_str());
        } else if (cmd == 50003) {
          SHELLEXECUTEINFOW sei = {};
          sei.cbSize = sizeof(sei);
          sei.fMask = SEE_MASK_NOCLOSEPROCESS;
          sei.lpVerb = L"runas";
          sei.lpFile = g_pinnedApps[i].c_str();
          sei.nShow = SW_SHOWNORMAL;
          ShellExecuteExW(&sei);
          if (sei.hProcess) CloseHandle(sei.hProcess);
        }

        DestroyMenu(hMenu);
        return 0;
      }
    }
    return 0;
  }
  case WM_MOUSEMOVE: {
    if (g_startMenuDragging && g_startMenuDragIndex >= 0) {
      InvalidateRect(hwnd, NULL, FALSE);
    }
    return 0;
  }
  case WM_LBUTTONUP: {
    if (g_startMenuDragging && g_startMenuDragIndex >= 0) {
      g_startMenuDragging = false;
      g_startMenuDragIndex = -1;
      InvalidateRect(hwnd, NULL, FALSE);
    }
    return 0;
  }
  }
  return DefWindowProc(hwnd, msg, wParam, lParam);
}

void DestroyTaskbar() {
  if (g_hTaskbarWnd && IsWindow(g_hTaskbarWnd)) {
    // Kill the timer first
    KillTimer(g_hTaskbarWnd, 1);
    // Destroy the window
    DestroyWindow(g_hTaskbarWnd);
    g_hTaskbarWnd = NULL;

    // Resize desktop to take full screen
    ResizeShellWindows();
  }
}

void RecreateTaskbar() {
  if (!g_hTaskbarWnd) {
    // Recreate taskbar window
    g_hTaskbarWnd = CreateWindowEx(WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE,
                                   L"CustomTaskbarClass", L"Taskbar", WS_POPUP,
                                   0, 0, 0, 0, NULL, NULL, g_hInst, NULL);

    if (g_hTaskbarWnd) {
      // Restore timer
      SetTimer(g_hTaskbarWnd, 1, 500, NULL);

      // Set TOPMOST so it appears above all windows
      SetWindowPos(g_hTaskbarWnd, HWND_TOPMOST, 0, 0, 0, 0,
                   SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);

      // Resize to proper position
      ResizeShellWindows();

      // Show the taskbar
      ShowWindow(g_hTaskbarWnd, SW_SHOW);

      // Force redraw
      InvalidateRect(g_hTaskbarWnd, NULL, TRUE);
    }
  }
}

void ResizeShellWindows(int dpi) {
  int w = GetSystemMetrics(SM_CXSCREEN);
  int h = GetSystemMetrics(SM_CYSCREEN);

  int tb = g_taskbarHeight * std::max(1, dpi / 96);

  // Resize WE's render target
  if (g_hWeWorkerW && IsWindow(g_hWeWorkerW)) {
    SetWindowPos(g_hWeWorkerW, NULL, 0, 0, w, h - tb,
                 SWP_NOZORDER | SWP_NOACTIVATE);
  }

  // Resize icon layer and redraw
  if (g_hDesktopWnd && IsWindow(g_hDesktopWnd)) {
    SetWindowPos(g_hDesktopWnd, NULL, 0, 0, w, h - tb,
                 SWP_NOZORDER | SWP_NOACTIVATE);
    InvalidateRect(g_hDesktopWnd, NULL, TRUE);
  }

  // Resize taskbar — keep TOPMOST so it always sits above other windows
  if (g_hTaskbarWnd && IsWindow(g_hTaskbarWnd)) {
    SetWindowPos(g_hTaskbarWnd, HWND_TOPMOST, 0, h - tb, w, tb,
                 SWP_NOACTIVATE | SWP_SHOWWINDOW);
  }

  // Resize start menu — keep TOPMOST; visibility is controlled separately
  int smW = (w * 45) / 100;
  int smY = 50;
  int smH = h - (g_hTaskbarWnd && IsWindow(g_hTaskbarWnd) ? tb : 0) - smY;
  SetWindowPos(g_hStartMenuWnd, HWND_TOPMOST, 0, smY, smW, smH,
               SWP_NOACTIVATE);
}

// ==================== TOPMOST HELPERS ====================

// Bring both the taskbar and start menu above every other window, including
// fullscreen apps, by temporarily promoting them to HWND_TOPMOST.
// Call this whenever the start menu is opened (blue button OR Windows key).
static void BringShellToTopmost() {
  // Taskbar: set TOPMOST so it sits above all normal and always-on-top windows
  if (g_hTaskbarWnd && IsWindow(g_hTaskbarWnd)) {
    SetWindowPos(g_hTaskbarWnd, HWND_TOPMOST, 0, 0, 0, 0,
                 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_SHOWWINDOW);
  }
  // Start menu: TOPMOST + bring to front + activate so it receives input
  if (g_hStartMenuWnd && IsWindow(g_hStartMenuWnd)) {
    SetWindowPos(g_hStartMenuWnd, HWND_TOPMOST, 0, 0, 0, 0,
                 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
    // Force focus so keyboard input works immediately
    DWORD fgThread = GetWindowThreadProcessId(GetForegroundWindow(), NULL);
    DWORD ourThread = GetCurrentThreadId();
    if (fgThread && fgThread != ourThread)
      AttachThreadInput(ourThread, fgThread, TRUE);
    SetForegroundWindow(g_hStartMenuWnd);
    SetActiveWindow(g_hStartMenuWnd);
    if (fgThread && fgThread != ourThread)
      AttachThreadInput(ourThread, fgThread, FALSE);
  }
}

// When the start menu is closed, demote both windows back to HWND_NOTOPMOST
// so they don't permanently sit above all other apps.
static void RestoreShellZOrder() {
  if (g_hStartMenuWnd && IsWindow(g_hStartMenuWnd)) {
    SetWindowPos(g_hStartMenuWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
                 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_HIDEWINDOW);
  }
  // Taskbar stays HWND_TOPMOST always — demoting it lets overlay apps
  // (Discord, game overlays, etc.) permanently cover it.
}

// Low-level keyboard hook to capture Windows key
LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
  if (nCode == HC_ACTION) {
    KBDLLHOOKSTRUCT *pKeyboard = (KBDLLHOOKSTRUCT *)lParam;

    // If we're injecting a Win+combo (e.g. Win+A for Action Center),
    // let it pass straight through to Windows — don't intercept.
    if (g_suppressWinKeyHook) {
      return CallNextHookEx(g_keyboardHook, nCode, wParam, lParam);
    }

    // Check for Windows key (left or right)
    if (pKeyboard->vkCode == VK_LWIN || pKeyboard->vkCode == VK_RWIN) {
      if (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) {
        // Only trigger on key down, not repeat
        if (!g_winKeyPressed) {
          g_winKeyPressed = true;

          // Toggle start menu (and ensure taskbar is visible)
          bool startMenuCurrentlyVisible = IsWindowVisible(g_hStartMenuWnd);

          if (!startMenuCurrentlyVisible) {
            // Opening start menu - save current taskbar state and show both
            g_taskbarVisibleBeforeWinKey = g_taskbarVisible;

            // Make sure taskbar exists
            if (!g_taskbarVisible) {
              RecreateTaskbar();
              g_taskbarVisible = true;
            }

            // Bring start menu + taskbar above ALL other windows
            BringShellToTopmost();
            g_startMenuOpenedByWinKey = true;
          } else {
            // Closing start menu — restore normal Z-order
            RestoreShellZOrder();

            // Restore taskbar visibility to state before Windows key was
            // pressed
            if (!g_taskbarVisibleBeforeWinKey && g_taskbarVisible) {
              DestroyTaskbar();
              g_taskbarVisible = false;
            }
            g_startMenuOpenedByWinKey = false;
          }

          // Repaint taskbar button highlight
          if (g_hTaskbarWnd && IsWindow(g_hTaskbarWnd)) {
            InvalidateRect(g_hTaskbarWnd, NULL, TRUE);
          }

          // Block the Windows key from reaching Windows
          return 1;
        }
      } else if (wParam == WM_KEYUP || wParam == WM_SYSKEYUP) {
        g_winKeyPressed = false;
        // Don't block key up — let Windows see it so it clears its
        // internal modifier state. Without this the OS thinks Win is
        // still held and every subsequent key becomes Win+<key>.
      }
    }
  }

  return CallNextHookEx(g_keyboardHook, nCode, wParam, lParam);
}

// Register taskbar as AppBar
void RegisterAppBar(HWND hwnd) {
  APPBARDATA abd = {0};
  abd.cbSize = sizeof(APPBARDATA);
  abd.hWnd = hwnd;
  abd.uCallbackMessage = APPBAR_CALLBACK;
  SHAppBarMessage(ABM_NEW, &abd);
}

// Set AppBar position
void SetAppBarPos(HWND hwnd) {
  RECT rc;
  GetWindowRect(hwnd, &rc);
  APPBARDATA abd = {0};
  abd.cbSize = sizeof(APPBARDATA);
  abd.hWnd = hwnd;
  abd.uEdge = ABE_BOTTOM;
  abd.rc.left = 0;
  abd.rc.right = GetSystemMetrics(SM_CXSCREEN);
  abd.rc.bottom = GetSystemMetrics(SM_CYSCREEN);
  abd.rc.top = abd.rc.bottom - (rc.bottom - rc.top);
  SHAppBarMessage(ABM_QUERYPOS, &abd);
  SHAppBarMessage(ABM_SETPOS, &abd);
  MoveWindow(hwnd, abd.rc.left, abd.rc.top, abd.rc.right - abd.rc.left,
             abd.rc.bottom - abd.rc.top, TRUE);

  // Also manually set the work area
  RECT workArea;
  workArea.left = 0;
  workArea.top = 0;
  workArea.right = abd.rc.right;
  workArea.bottom = abd.rc.top; // Top of taskbar = bottom of work area
  SystemParametersInfoW(SPI_SETWORKAREA, 0, &workArea,
                        SPIF_SENDCHANGE | SPIF_UPDATEINIFILE);

  // Broadcast the change to all top-level windows
  SendMessageTimeoutW(HWND_BROADCAST, WM_SETTINGCHANGE, SPI_SETWORKAREA, 0,
                      SMTO_ABORTIFHUNG, 1000, NULL);
}

// Unregister AppBar
void UnregisterAppBar(HWND hwnd) {
  APPBARDATA abd = {0};
  abd.cbSize = sizeof(APPBARDATA);
  abd.hWnd = hwnd;
  SHAppBarMessage(ABM_REMOVE, &abd);

  // Restore work area to full screen
  int w = GetSystemMetrics(SM_CXSCREEN);
  int h = GetSystemMetrics(SM_CYSCREEN);
  RECT workArea = {0, 0, w, h};
  SystemParametersInfoW(SPI_SETWORKAREA, 0, &workArea, SPIF_SENDCHANGE);
}

// Called whenever any window's parent changes. We use this to catch WE
// reparenting its render window into g_hWeWorkerW and immediately strip
// it from Alt+Tab by adding WS_EX_TOOLWINDOW.
// Force g_hDesktopWnd to become the foreground window even when Windows
// blocks SetForegroundWindow due to the foreground lock.
static void ForceFocusToDesktop() {
  if (!g_hDesktopWnd || !IsWindow(g_hDesktopWnd))
    return;
  HWND fg = GetForegroundWindow();
  if (fg == g_hDesktopWnd)
    return;

  // WS_EX_NOACTIVATE was set at creation to avoid stealing focus at startup;
  // remove it here so SetForegroundWindow can actually transfer focus to us.
  LONG_PTR ex = GetWindowLongPtrW(g_hDesktopWnd, GWL_EXSTYLE);
  if (ex & WS_EX_NOACTIVATE) {
    SetWindowLongPtrW(g_hDesktopWnd, GWL_EXSTYLE, ex & ~WS_EX_NOACTIVATE);
  }

  DWORD fgThread = fg ? GetWindowThreadProcessId(fg, NULL) : 0;
  DWORD ourThread = GetCurrentThreadId();

  if (fgThread && fgThread != ourThread)
    AttachThreadInput(ourThread, fgThread, TRUE);

  SetForegroundWindow(g_hDesktopWnd);
  SetActiveWindow(g_hDesktopWnd);

  if (fgThread && fgThread != ourThread)
    AttachThreadInput(ourThread, fgThread, FALSE);
}

// Keep g_hDesktopWnd just above g_hWeWorkerW — never above real app windows.
static void PinDesktopToWorkerW() {
  if (g_hDesktopWnd && g_hWeWorkerW && IsWindow(g_hDesktopWnd) &&
      IsWindow(g_hWeWorkerW)) {
    SetWindowPos(g_hDesktopWnd, g_hWeWorkerW, 0, 0, 0, 0,
                 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
  }
}

void CALLBACK WinEventProc(HWINEVENTHOOK hHook, DWORD event, HWND hwnd,
                           LONG idObject, LONG idChild, DWORD dwEventThread,
                           DWORD dwmsEventTime) {
  (void)hHook;
  (void)idChild;
  (void)dwEventThread;
  (void)dwmsEventTime;
  if (idObject != OBJID_WINDOW)
    return;

  if (event == EVENT_OBJECT_PARENTCHANGE) {
    if (!hwnd || !g_hWeWorkerW)
      return;
    if (GetParent(hwnd) == g_hWeWorkerW ||
        GetAncestor(hwnd, GA_ROOTOWNER) == g_hWeWorkerW) {
      LONG_PTR ex = GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
      ex |= WS_EX_TOOLWINDOW;
      ex &= ~WS_EX_APPWINDOW;
      SetWindowLongPtrW(hwnd, GWL_EXSTYLE, ex);
      if (g_hDesktopWnd && IsWindow(g_hDesktopWnd))
        ForceFocusToDesktop();
    }
  } else if (event == EVENT_SYSTEM_FOREGROUND) {
    if (!hwnd || !g_hWeWorkerW || !g_hDesktopWnd)
      return;
    // Re-pin desktop below all app windows on every foreground change
    PinDesktopToWorkerW();
    // If taskbar got hidden by a fullscreen app that's now gone, restore it
    if (!g_fullscreenActive && g_hTaskbarWnd && IsWindow(g_hTaskbarWnd) &&
        !IsWindowVisible(g_hTaskbarWnd)) {
      ShowWindow(g_hTaskbarWnd, SW_SHOW);
      SetWindowPos(g_hTaskbarWnd, HWND_TOPMOST, 0, 0, 0, 0,
                   SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
    }
    // Already where we want to be — nothing to do
    if (hwnd == g_hDesktopWnd)
      return;
    // If the wallpaper WorkerW somehow grabbed focus, steal it back
    if (hwnd == g_hWeWorkerW || GetParent(hwnd) == g_hWeWorkerW ||
        GetAncestor(hwnd, GA_ROOT) == g_hWeWorkerW)
      ForceFocusToDesktop();
  } else if (event == EVENT_SYSTEM_MINIMIZEEND) {
    if (g_hDesktopWnd && IsWindow(g_hDesktopWnd)) {
      PinDesktopToWorkerW();
      HWND fg = GetForegroundWindow();
      if (!fg || fg == g_hWeWorkerW || GetParent(fg) == g_hWeWorkerW ||
          GetAncestor(fg, GA_ROOT) == g_hWeWorkerW) {
        ForceFocusToDesktop();
      }
    }
  }
}

int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR, int) {
  // Hide console window if it exists
  HWND hConsole = GetConsoleWindow();
  if (hConsole) {
    ShowWindow(hConsole, SW_HIDE);
  }

  // HIDE THE REAL WINDOWS TASKBAR
  HWND hRealTaskbar = FindWindowW(L"Shell_TrayWnd", NULL);
  if (hRealTaskbar) {
    ShowWindow(hRealTaskbar, SW_HIDE);
  }

  // HIDE THE START MENU BUTTON AREA
  HWND hStartButton = FindWindowW(L"Button", L"Start");
  if (hStartButton) {
    ShowWindow(hStartButton, SW_HIDE);
  }

  g_hInst = hInstance;

  CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);

  // Initialize GDI+
  Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);

  INITCOMMONCONTROLSEX icex = {};
  icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
  icex.dwICC = ICC_WIN95_CLASSES;
  InitCommonControlsEx(&icex);

  HMODULE user32 = LoadLibraryW(L"user32.dll");
  if (user32) {
    typedef BOOL(WINAPI *
                 SetProcessDpiAwarenessContextFn)(DPI_AWARENESS_CONTEXT);
    SetProcessDpiAwarenessContextFn f =
        (SetProcessDpiAwarenessContextFn)GetProcAddress(
            user32, "SetProcessDpiAwarenessContext");
    if (f) {
      f(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
    } else {
      SetProcessDPIAware();
    }
    FreeLibrary(user32);
  }

  // Desktop window class registration removed - we'll subclass Progman instead

  WNDCLASS wc = {};
  wc.lpfnWndProc = TaskbarWndProc;
  wc.hInstance = hInstance;
  wc.lpszClassName = L"CustomTaskbarClass";
  wc.hbrBackground = (HBRUSH)CreateSolidBrush(RGB(45, 45, 48));
  RegisterClass(&wc);

  wc = {};
  wc.lpfnWndProc = StartMenuWndProc;
  wc.hInstance = hInstance;
  wc.lpszClassName = L"CustomStartMenuClass";
  wc.hbrBackground = (HBRUSH)CreateSolidBrush(RGB(40, 40, 40));
  RegisterClass(&wc);

  // -----------------------------------------------------------------------
  // Build the exact window hierarchy that Wallpaper Engine expects.
  // -----------------------------------------------------------------------

  int screenW = GetSystemMetrics(SM_CXSCREEN);
  int screenH = GetSystemMetrics(SM_CYSCREEN);

  // --- Register window classes ---

  // Progman: top-level shell anchor, handles WE's 0x052C spawn message
  WNDCLASS progmanWc = {};
  progmanWc.lpfnWndProc = ProgmanWndProc;
  progmanWc.hInstance = hInstance;
  progmanWc.lpszClassName = L"Progman";
  progmanWc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
  RegisterClass(&progmanWc);

  // SHELLDLL_DefView: WE searches for this class inside each top-level window
  WNDCLASS defViewWc = {};
  defViewWc.lpfnWndProc = DefWindowProcW;
  defViewWc.hInstance = hInstance;
  defViewWc.lpszClassName = L"SHELLDLL_DefView";
  defViewWc.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);
  RegisterClass(&defViewWc);

  // WorkerW: shared class for all three WorkerW windows
  WNDCLASS workerWc = {};
  workerWc.lpfnWndProc =
      DesktopWndProc; // guarded inside to only act on g_hDesktopWnd
  workerWc.style = CS_DBLCLKS;
  workerWc.hInstance = hInstance;
  workerWc.lpszClassName = L"WorkerW";
  workerWc.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);
  RegisterClass(&workerWc);

  // --- Step 1: Create Progman at the very bottom ---
  HWND progman =
      CreateWindowExW(WS_EX_TOOLWINDOW, L"Progman", L"Program Manager",
                      WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                      0, 0, screenW, screenH, NULL, NULL, hInstance, NULL);
  if (!progman) {
    MessageBoxW(NULL, L"Could not create Progman window!", L"Error",
                MB_OK | MB_ICONERROR);
    return 1;
  }
  SetWindowPos(progman, HWND_BOTTOM, 0, 0, 0, 0,
               SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);

  // --- Step 2: Create a WorkerW as a CHILD of Progman ---
  HWND progmanWorkerW =
      CreateWindowExW(0, L"WorkerW", L"",
                      WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                      0, 0, screenW, screenH, progman, NULL, hInstance, NULL);

  // --- Step 3: Create SHELLDLL_DefView inside that child WorkerW ---
  HWND shellDefView =
      CreateWindowExW(0, L"SHELLDLL_DefView", L"", WS_CHILD | WS_VISIBLE, 0, 0,
                      screenW, screenH, progmanWorkerW, NULL, hInstance, NULL);
  (void)shellDefView;
  (void)progmanWorkerW;

  // --- Step 4: Create WE's render-target WorkerW (top-level, after Progman)
  // ---
  g_hWeWorkerW = CreateWindowExW(
      WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE | WS_EX_TRANSPARENT, L"WorkerW", L"",
      WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, 0, 0, screenW,
      screenH - g_taskbarHeight, NULL, NULL, hInstance, NULL);
  SetWindowPos(g_hWeWorkerW, progman, 0, 0, 0, 0,
               SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);

  // Hook parent-change events so we can immediately hide WE's render window
  // from Alt+Tab the moment it gets reparented into g_hWeWorkerW
  g_hWinEventHook = SetWinEventHook(
      EVENT_SYSTEM_FOREGROUND, EVENT_SYSTEM_FOREGROUND, NULL, WinEventProc, 0,
      0, WINEVENT_OUTOFCONTEXT | WINEVENT_SKIPOWNPROCESS);
  static HWINEVENTHOOK g_hWinEventHook2 = SetWinEventHook(
      EVENT_OBJECT_PARENTCHANGE, EVENT_OBJECT_PARENTCHANGE, NULL, WinEventProc,
      0, 0, WINEVENT_OUTOFCONTEXT | WINEVENT_SKIPOWNPROCESS);
  static HWINEVENTHOOK g_hWinEventHook3 = SetWinEventHook(
      EVENT_SYSTEM_MINIMIZEEND, EVENT_SYSTEM_MINIMIZEEND, NULL, WinEventProc, 0,
      0, WINEVENT_OUTOFCONTEXT | WINEVENT_SKIPOWNPROCESS);

  // --- Step 5: Icon layer — top-level WS_EX_LAYERED with per-pixel alpha ---
  g_hDesktopWnd = CreateWindowExW(
      WS_EX_LAYERED | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE, L"WorkerW", L"Desktop",
      WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, 0, 0, screenW,
      screenH - g_taskbarHeight, NULL, NULL, hInstance, NULL);
  if (!g_hDesktopWnd) {
    MessageBoxW(NULL, L"Could not create desktop icon layer!", L"Error",
                MB_OK | MB_ICONERROR);
    return 1;
  }
  // Pin just above WE's WorkerW — below all real app windows
  SetWindowPos(g_hDesktopWnd, g_hWeWorkerW, 0, 0, 0, 0,
               SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);

  g_realDesktopProc = NULL; // We created it, not subclassing

  // Taskbar as normal window (can be covered by fullscreen apps)
  g_hTaskbarWnd = CreateWindowEx(WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE,
                                 L"CustomTaskbarClass", L"Taskbar", WS_POPUP, 0,
                                 0, 0, 0, NULL, NULL, hInstance, NULL);

  g_hStartMenuWnd = CreateWindowEx(WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE,
                                   L"CustomStartMenuClass", L"StartMenu",
                                   WS_POPUP, 10, 10, 300, 300,
                                   NULL, // NO parent
                                   NULL, hInstance, NULL);

  // Load window positions from config
  LoadWindowPositions();

  // Don't call ShowWindow - Progman is already visible
  // ShowWindow(g_hDesktopWnd, SW_SHOW);
  ShowWindow(g_hTaskbarWnd, SW_SHOW);
  ShowWindow(g_hStartMenuWnd, SW_HIDE);

  // Set timer to refresh taskbar for running app indicators (every 500ms)
  SetTimer(g_hTaskbarWnd, 1, 500, NULL);

  // Register taskbar as AppBar and set position
  RegisterAppBar(g_hTaskbarWnd);
  SetAppBarPos(g_hTaskbarWnd);

  ResizeShellWindows();

  PopulateDesktopIcons();

  // Load Start Menu apps from Windows
  PopulateStartMenuApps();

  // Clean up explorer and shell from lists
  CleanupExplorerAndShellFromLists();

  // Load taskbar configuration and icons
  LoadTaskbarConfig();
  PopulateTaskbarIcons();

  // apply default view mode (large)
  UpdateViewMode(g_viewMode);

  if (!RegisterHotKey(NULL, 9001, MOD_CONTROL | MOD_ALT, 'E')) {
    // Failed to register Ctrl+Alt+E
  }

  // Register Ctrl + Alt + T hotkey for toggling taskbar visibility (Windows+T
  // is reserved by Windows)
  if (!RegisterHotKey(NULL, 9002, MOD_CONTROL | MOD_ALT, 'T')) {
    // Failed to register Ctrl+Alt+T
  }

  // Install low-level keyboard hook to capture Windows key
  g_keyboardHook =
      SetWindowsHookEx(WH_KEYBOARD_LL, LowLevelKeyboardProc, hInstance, 0);
  if (!g_keyboardHook) {
    // Failed to install keyboard hook
  }

  // Make the desktop icon layer the active foreground window so it's
  // on top of g_hWeWorkerW from the very start — no clicking needed.
  ForceFocusToDesktop();

  MSG msg;
  while (GetMessage(&msg, NULL, 0, 0)) {
    if (msg.message == WM_HOTKEY && msg.wParam == 9001) {
      LaunchExplorer();
      continue;
    } else if (msg.message == WM_HOTKEY && msg.wParam == 9002) {
      // Toggle taskbar by destroying/recreating it
      g_taskbarVisible = !g_taskbarVisible;
      if (g_taskbarVisible) {
        RecreateTaskbar();
      } else {
        DestroyTaskbar();
      }
      continue;
    }
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }

  UnregisterHotKey(NULL, 9001);
  UnregisterHotKey(NULL, 9002); // Unregister Ctrl+Alt+T hotkey

  // Unhook keyboard hook
  if (g_keyboardHook) {
    UnhookWindowsHookEx(g_keyboardHook);
    g_keyboardHook = NULL;
  }
  if (g_hWinEventHook) {
    UnhookWinEvent(g_hWinEventHook);
    g_hWinEventHook = NULL;
  }
  if (g_hWinEventHook2) {
    UnhookWinEvent(g_hWinEventHook2);
    g_hWinEventHook2 = NULL;
  }
  if (g_hWinEventHook3) {
    UnhookWinEvent(g_hWinEventHook3);
    g_hWinEventHook3 = NULL;
  }

  // Unregister AppBar
  if (g_hTaskbarWnd) {
    UnregisterAppBar(g_hTaskbarWnd);
  }

  // Save window positions before closing
  SaveTaskbarConfig();

  // Save Start Menu positions
  SaveStartMenuPositions();

  // Restore original window proc if we subclassed WorkerW
  if (g_hDesktopWnd && g_realDesktopProc) {
    SetWindowLongPtrW(g_hDesktopWnd, GWLP_WNDPROC, (LONG_PTR)g_realDesktopProc);
  } else if (g_hDesktopWnd && IsWindow(g_hDesktopWnd)) {
    // We created our own window, destroy it
    DestroyWindow(g_hDesktopWnd);
  }

  // Clean up tray icons
  for (auto &icon : g_trayIcons) {
    if (icon.hIcon && !icon.isRealIcon) {
      DestroyIcon(icon.hIcon);
    }
  }
  g_trayIcons.clear();

  for (auto &icon : g_realTrayIcons) {
    if (icon.hIcon) {
      DestroyIcon(icon.hIcon);
    }
  }
  g_realTrayIcons.clear();

  // SHOW THE REAL TASKBAR AGAIN ON EXIT
  if (hRealTaskbar) {
    ShowWindow(hRealTaskbar, SW_SHOW);
  }

  // SHOW START BUTTON AGAIN
  if (hStartButton) {
    ShowWindow(hStartButton, SW_SHOW);
  }

  for (auto &it : g_desktopItems) {
    if (it.hIcon) {
      DestroyIcon(it.hIcon);
      it.hIcon = NULL;
    }
  }

  // Clean up background image
  if (g_backgroundImage) {
    delete g_backgroundImage;
    g_backgroundImage = NULL;
  }

  Gdiplus::GdiplusShutdown(gdiplusToken);

  CoUninitialize();

  return 0;
}

// Show the native Explorer context menu for a file path at screen point `pt`.
void ShowShellContextMenu(HWND hwnd, POINT pt, LPCWSTR pszPath) {
  PIDLIST_ABSOLUTE pidl = NULL;
  HRESULT hr = SHParseDisplayName(pszPath, NULL, &pidl, 0, NULL);
  if (SUCCEEDED(hr) && pidl) {
    IShellFolder *psfParent = NULL;
    PCUITEMID_CHILD pidlChild = NULL;
    hr =
        SHBindToParent(pidl, IID_IShellFolder, (void **)&psfParent, &pidlChild);
    if (SUCCEEDED(hr) && psfParent && pidlChild) {
      IContextMenu *pcm = NULL;
      hr = psfParent->GetUIObjectOf(hwnd, 1, &pidlChild, IID_IContextMenu, NULL,
                                    (void **)&pcm);
      if (SUCCEEDED(hr) && pcm) {
        IContextMenu2 *pcm2 = NULL;
        IContextMenu3 *pcm3 = NULL;
        pcm->QueryInterface(IID_IContextMenu2, (void **)&pcm2);
        pcm->QueryInterface(IID_IContextMenu3, (void **)&pcm3);

        IContextMenu2 *prev_pcm2 = g_pcm2;
        IContextMenu3 *prev_pcm3 = g_pcm3;
        WNDPROC prev_proc = g_origDesktopProc;

        g_pcm2 = pcm2;
        g_pcm3 = pcm3;

        // Only subclass if not already subclassed
        WNDPROC currentProc = (WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
        if (currentProc != Desktop_SubclassProc) {
          g_origDesktopProc = (WNDPROC)SetWindowLongPtrW(
              hwnd, GWLP_WNDPROC, (LONG_PTR)Desktop_SubclassProc);
        }

        HMENU hMenu = CreatePopupMenu();
        if (hMenu) {
          hr = pcm->QueryContextMenu(hMenu, 0, 1, 0x7fff, CMF_NORMAL);
          if (SUCCEEDED(hr)) {
            int baseId = 1;
            int count = GetMenuItemCount(hMenu);
            UINT refreshId = (UINT)(baseId + count);
            InsertMenuW(hMenu, -1, MF_BYPOSITION, refreshId, L"Refresh");
            InsertMenuW(hMenu, -1, MF_BYPOSITION, IDM_ITEM_RENAME, L"Rename");

            ReleaseCapture();
            SetForegroundWindow(hwnd);
            int id = TrackPopupMenu(hMenu, TPM_RIGHTBUTTON | TPM_RETURNCMD,
                                    pt.x, pt.y, 0, hwnd, NULL);
            if (id) {
              if ((UINT)id == refreshId) {
                PopulateDesktopIcons();
                InvalidateRect(hwnd, NULL, TRUE);
              } else if ((UINT)id == IDM_ITEM_RENAME) {
                std::wstring oldPath = pszPath;
                size_t slash = oldPath.find_last_of(L"\\/");
                std::wstring dir = (slash != std::wstring::npos)
                                       ? oldPath.substr(0, slash)
                                       : L"";
                std::wstring oldName = (slash != std::wstring::npos)
                                           ? oldPath.substr(slash + 1)
                                           : oldPath;
                wchar_t newName[MAX_PATH];
                wcsncpy_s(newName, oldName.c_str(), _TRUNCATE);

                std::wstring prompt = L"Rename \"" + oldName + L"\" to:";
                HWND hDlg = CreateWindowExW(
                    WS_EX_DLGMODALFRAME | WS_EX_TOPMOST, L"#32770", L"Rename",
                    WS_POPUP | WS_CAPTION | WS_SYSMENU, 0, 0, 360, 120, hwnd,
                    NULL, g_hInst, NULL);
                if (hDlg) {
                  CreateWindowExW(0, L"STATIC", prompt.c_str(),
                                  WS_CHILD | WS_VISIBLE | SS_LEFT, 10, 10, 340,
                                  20, hDlg, NULL, g_hInst, NULL);
                  HWND hEdit = CreateWindowExW(
                      WS_EX_CLIENTEDGE, L"EDIT", newName,
                      WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL, 10, 36, 340, 24,
                      hDlg, (HMENU)1001, g_hInst, NULL);
                  CreateWindowExW(0, L"BUTTON", L"OK",
                                  WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON, 130,
                                  72, 80, 28, hDlg, (HMENU)IDOK, g_hInst, NULL);
                  CreateWindowExW(0, L"BUTTON", L"Cancel",
                                  WS_CHILD | WS_VISIBLE, 220, 72, 80, 28, hDlg,
                                  (HMENU)IDCANCEL, g_hInst, NULL);
                  HFONT hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
                  EnumChildWindows(
                      hDlg,
                      [](HWND h, LPARAM lp) -> BOOL {
                        SendMessageW(h, WM_SETFONT, lp, TRUE);
                        return TRUE;
                      },
                      (LPARAM)hFont);
                  int sw = GetSystemMetrics(SM_CXSCREEN),
                      sh = GetSystemMetrics(SM_CYSCREEN);
                  RECT rc;
                  GetWindowRect(hDlg, &rc);
                  SetWindowPos(hDlg, HWND_TOP, (sw - (rc.right - rc.left)) / 2,
                               (sh - (rc.bottom - rc.top)) / 2, 0, 0,
                               SWP_NOSIZE);
                  ShowWindow(hDlg, SW_SHOW);
                  SetForegroundWindow(hDlg);
                  SetFocus(hEdit);
                  SendMessageW(hEdit, EM_SETSEL, 0, -1);
                  MSG msgR;
                  bool accepted = false;
                  while (IsWindow(hDlg) && GetMessageW(&msgR, hDlg, 0, 0)) {
                    if (msgR.message == WM_KEYDOWN &&
                        msgR.wParam == VK_RETURN) {
                      GetWindowTextW(hEdit, newName, MAX_PATH);
                      accepted = true;
                      DestroyWindow(hDlg);
                      break;
                    }
                    if (msgR.message == WM_KEYDOWN &&
                        msgR.wParam == VK_ESCAPE) {
                      DestroyWindow(hDlg);
                      break;
                    }
                    if (msgR.message == WM_COMMAND) {
                      if (LOWORD(msgR.wParam) == IDOK) {
                        GetWindowTextW(hEdit, newName, MAX_PATH);
                        accepted = true;
                        DestroyWindow(hDlg);
                        break;
                      }
                      if (LOWORD(msgR.wParam) == IDCANCEL) {
                        DestroyWindow(hDlg);
                        break;
                      }
                    }
                    TranslateMessage(&msgR);
                    DispatchMessageW(&msgR);
                  }
                  if (accepted && wcslen(newName) > 0 &&
                      _wcsicmp(newName, oldName.c_str()) != 0) {
                    std::wstring newPath = dir + L"\\" + newName;
                    if (!MoveFileW(oldPath.c_str(), newPath.c_str()))
                      MessageBoxW(hwnd, L"Rename failed.", L"Error",
                                  MB_OK | MB_ICONERROR);
                    PopulateDesktopIcons();
                    InvalidateRect(hwnd, NULL, TRUE);
                  }
                }
              } else {
                CMINVOKECOMMANDINFOEX ici = {};
                ici.cbSize = sizeof(ici);
                ici.fMask = CMIC_MASK_UNICODE;
                ici.hwnd = hwnd;
                ici.lpVerb = MAKEINTRESOURCEA(id - baseId);
                ici.lpVerbW = MAKEINTRESOURCEW(id - baseId);
                ici.nShow = SW_SHOWNORMAL;
                pcm->InvokeCommand((LPCMINVOKECOMMANDINFO)&ici);
                // Don't auto-refresh - let user manually refresh if needed
              }
            }
          }
          DestroyMenu(hMenu);
        }

        // Always restore to the real desktop window proc
        SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONG_PTR)g_realDesktopProc);
        g_origDesktopProc = NULL;

        if (g_pcm3) {
          g_pcm3->Release();
          g_pcm3 = NULL;
        }
        if (g_pcm2) {
          g_pcm2->Release();
          g_pcm2 = NULL;
        }

        g_pcm2 = prev_pcm2;
        g_pcm3 = prev_pcm3;

        pcm->Release();
      }
      psfParent->Release();
    }
    CoTaskMemFree(pidl);
  }
}

// Show the native Explorer context menu for the desktop background at screen
// point `pt`.
void ShowDesktopContextMenu(HWND hwnd, POINT pt) {
  IShellFolder *psfDesktop = NULL;
  if (SUCCEEDED(SHGetDesktopFolder(&psfDesktop)) && psfDesktop) {
    IContextMenu *pcm = NULL;
    HRESULT hr = psfDesktop->GetUIObjectOf(hwnd, 0, NULL, IID_IContextMenu,
                                           NULL, (void **)&pcm);
    if (SUCCEEDED(hr) && pcm) {
      pcm->QueryInterface(IID_IContextMenu2, (void **)&g_pcm2);
      pcm->QueryInterface(IID_IContextMenu3, (void **)&g_pcm3);

      // Only subclass if not already subclassed
      WNDPROC currentProc = (WNDPROC)GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
      if (currentProc != Desktop_SubclassProc) {
        g_origDesktopProc = (WNDPROC)SetWindowLongPtrW(
            hwnd, GWLP_WNDPROC, (LONG_PTR)Desktop_SubclassProc);
      }

      HMENU hMenu = CreatePopupMenu();
      if (hMenu) {
        hr = pcm->QueryContextMenu(hMenu, 0, 1, 0x7fff,
                                   CMF_NORMAL | CMF_EXPLORE);
        if (SUCCEEDED(hr)) {

          AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL);
          AppendMenuW(hMenu, MF_STRING, IDM_DESKTOP_REFRESH, L"Refresh");
          AppendMenuW(hMenu, MF_STRING, IDM_RESTART_SHELL, L"Restart Shell");

          HMENU hView = CreatePopupMenu();
          AppendMenuW(hView, MF_STRING | (g_viewMode == 2 ? MF_CHECKED : 0),
                      IDM_VIEW_LARGE, L"Large icons");
          AppendMenuW(hView, MF_STRING | (g_viewMode == 1 ? MF_CHECKED : 0),
                      IDM_VIEW_MEDIUM, L"Medium icons");
          AppendMenuW(hView, MF_STRING | (g_viewMode == 0 ? MF_CHECKED : 0),
                      IDM_VIEW_SMALL, L"Small icons");
          AppendMenuW(hMenu, MF_POPUP, (UINT_PTR)hView, L"View");

          HMENU hSort = CreatePopupMenu();
          AppendMenuW(hSort, MF_STRING, IDM_SORT_NAME, L"Name");
          AppendMenuW(hSort, MF_STRING, IDM_SORT_TYPE, L"Type");
          AppendMenuW(hSort, MF_STRING, IDM_SORT_DATE, L"Date modified");
          AppendMenuW(hMenu, MF_POPUP, (UINT_PTR)hSort, L"Sort by");

          AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL);
          AppendMenuW(hMenu, MF_STRING | (g_showIcons ? MF_CHECKED : 0),
                      IDM_TOGGLE_SHOW_ICONS, L"Show desktop icons");
          AppendMenuW(hMenu, MF_STRING | (g_autoArrange ? MF_CHECKED : 0),
                      IDM_AUTO_ARRANGE, L"Auto arrange icons");
          AppendMenuW(hMenu, MF_STRING, IDM_ALIGN_TO_GRID,
                      L"Align icons to grid");
          AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL);
          AppendMenuW(hMenu, MF_STRING, IDM_CHANGE_TASKBAR_COLOR,
                      L"Change Taskbar Color...");
          AppendMenuW(hMenu, MF_STRING, IDM_CHANGE_STARTMENU_COLOR,
                      L"Change Start Menu Color...");
          AppendMenuW(hMenu, MF_STRING, IDM_CHANGE_BACKGROUND,
                      L"Change Background...");

          ReleaseCapture();
          SetForegroundWindow(hwnd);
          int cmd = TrackPopupMenu(hMenu, TPM_RIGHTBUTTON | TPM_RETURNCMD, pt.x,
                                   pt.y, 0, hwnd, NULL);
          PostMessage(hwnd, WM_NULL, 0, 0);
          if (cmd) {
            if (cmd == IDM_DESKTOP_REFRESH) {
              PopulateDesktopIcons();
              InvalidateRect(hwnd, NULL, TRUE);
            } else if (cmd == IDM_RESTART_SHELL) {
              wchar_t exePath[MAX_PATH];
              GetModuleFileNameW(NULL, exePath, MAX_PATH);
              ShellExecuteW(NULL, L"open", exePath, NULL, NULL, SW_SHOW);
              PostQuitMessage(0);
            } else if (cmd == IDM_VIEW_LARGE) {
              UpdateViewMode(2);
            } else if (cmd == IDM_VIEW_MEDIUM) {
              UpdateViewMode(1);
            } else if (cmd == IDM_VIEW_SMALL) {
              UpdateViewMode(0);
            } else if (cmd == IDM_SORT_NAME) {
              SortByName();
              InvalidateRect(hwnd, NULL, TRUE);
            } else if (cmd == IDM_SORT_TYPE) {
              SortByTypeThenName();
              InvalidateRect(hwnd, NULL, TRUE);
            } else if (cmd == IDM_SORT_DATE) {
              SortByDateDesc();
              InvalidateRect(hwnd, NULL, TRUE);
            } else if (cmd == IDM_TOGGLE_SHOW_ICONS) {
              g_showIcons = !g_showIcons;
              InvalidateRect(hwnd, NULL, TRUE);
            } else if (cmd == IDM_AUTO_ARRANGE) {
              g_autoArrange = !g_autoArrange;
              if (g_autoArrange)
                SortByName();
              InvalidateRect(hwnd, NULL, TRUE);
            } else if (cmd == IDM_ALIGN_TO_GRID) {
              AlignIconsToGrid();
            } else if (cmd == IDM_CHANGE_TASKBAR_COLOR) {
              CHOOSECOLORW cc = {};
              static COLORREF customColors[16] = {0};
              cc.lStructSize = sizeof(cc);
              cc.hwndOwner = hwnd;
              cc.lpCustColors = customColors;
              cc.rgbResult = g_taskbarColor;
              cc.Flags = CC_FULLOPEN | CC_RGBINIT;
              if (ChooseColorW(&cc)) {
                g_taskbarColor = cc.rgbResult;
                SaveTaskbarConfig();
                InvalidateRect(g_hTaskbarWnd, NULL, TRUE);
              }
            } else if (cmd == IDM_CHANGE_STARTMENU_COLOR) {
              CHOOSECOLORW cc = {};
              static COLORREF customColors2[16] = {0};
              cc.lStructSize = sizeof(cc);
              cc.hwndOwner = hwnd;
              cc.lpCustColors = customColors2;
              cc.rgbResult = g_startMenuColor;
              cc.Flags = CC_FULLOPEN | CC_RGBINIT;
              if (ChooseColorW(&cc)) {
                g_startMenuColor = cc.rgbResult;
                SaveTaskbarConfig();
                InvalidateRect(g_hStartMenuWnd, NULL, TRUE);
              }
            } else if (cmd == IDM_CHANGE_BACKGROUND) {
              OPENFILENAMEW ofn = {};
              wchar_t szFile[MAX_PATH] = L"";
              ofn.lStructSize = sizeof(ofn);
              ofn.hwndOwner = hwnd;
              ofn.lpstrFile = szFile;
              ofn.nMaxFile = MAX_PATH;
              ofn.lpstrFilter =
                  L"Image Files\0*.jpg;*.jpeg;*.png;*.bmp;*.gif\0All "
                  L"Files\0*.*\0";
              ofn.nFilterIndex = 1;
              ofn.lpstrTitle = L"Select Background Image";
              ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
              if (GetOpenFileNameW(&ofn)) {
                if (g_backgroundImage) {
                  delete g_backgroundImage;
                  g_backgroundImage = NULL;
                }
                g_backgroundImage = Gdiplus::Bitmap::FromFile(szFile);
                if (g_backgroundImage &&
                    g_backgroundImage->GetLastStatus() == Gdiplus::Ok) {
                  g_backgroundPath = szFile;
                  SaveTaskbarConfig();
                  InvalidateRect(hwnd, NULL, TRUE);
                } else {
                  if (g_backgroundImage) {
                    delete g_backgroundImage;
                    g_backgroundImage = NULL;
                  }
                  MessageBoxW(hwnd, L"Failed to load image file.", L"Error",
                              MB_OK | MB_ICONERROR);
                }
              }
            } else {
              CMINVOKECOMMANDINFOEX ici = {};
              ici.cbSize = sizeof(ici);
              ici.fMask = CMIC_MASK_UNICODE;
              ici.hwnd = hwnd;
              ici.lpVerb = MAKEINTRESOURCEA(cmd - 1);
              ici.lpVerbW = MAKEINTRESOURCEW(cmd - 1);
              ici.nShow = SW_SHOWNORMAL;
              pcm->InvokeCommand((LPCMINVOKECOMMANDINFO)&ici);
              // Don't auto-refresh - let user manually refresh if needed
            }
          }

          DestroyMenu(hView);
          DestroyMenu(hSort);
        }
        DestroyMenu(hMenu);
      }

      // Always restore to the real desktop window proc
      SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONG_PTR)g_realDesktopProc);
      g_origDesktopProc = NULL;

      if (g_pcm3) {
        g_pcm3->Release();
        g_pcm3 = NULL;
      }
      if (g_pcm2) {
        g_pcm2->Release();
        g_pcm2 = NULL;
      }

      pcm->Release();
    }
    psfDesktop->Release();
  }
}