src/ClearClipboard.c

   1 /* ---------------------------------------------------------------------------------------------- */
   2 /* Clear Clipboard                                                                                */
   3 /* Copyright(c) 2019 LoRd_MuldeR <mulder2@gmx.de>                                                 */
   4 /*                                                                                                */
   5 /* Permission is hereby granted, free of charge, to any person obtaining a copy of this software  */
   6 /* and associated documentation files (the "Software"), to deal in the Software without           */
   7 /* restriction, including without limitation the rights to use, copy, modify, merge, publish,     */
   8 /* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the  */
   9 /* Software is furnished to do so, subject to the following conditions:                           */
  10 /*                                                                                                */
  11 /* The above copyright notice and this permission notice shall be included in all copies or       */
  12 /* substantial portions of the Software.                                                          */
  13 /*                                                                                                */
  14 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING  */
  15 /* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND     */
  16 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   */
  17 /* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, */
  18 /* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.        */
  19 /* ---------------------------------------------------------------------------------------------- */
  20
  21 #define WIN32_LEAN_AND_MEAN 1
  22 #include <windows.h>
  23 #include <shellapi.h>
  24 #include <MMSystem.h>
  25
  26 #include "Version.h"
  27
  28 // Options
  29 #define ENABLE_DEBUG_OUTPOUT 1
  30 #define DEFAULT_TIMEOUT 30000U
  31 #define DEFAULT_SOUND_LEVEL 1U
  32
  33 // Const
  34 #define MUTEX_NAME L"{E19E5CE1-5EF2-4C10-843D-E79460920A4A}"
  35 #define CLASS_NAME L"{6D6CB8E6-BFEE-40A1-A6B2-2FF34C43F3F8}"
  36 #define TIMER_ID 0x5281CC36
  37 #define ID_NOTIFYICON 0x8EF73CE1
  38 #define WM_NOTIFYICON (WM_APP+101U)
  39 #define MENU1_ID 0x1A5C
  40 #define MENU2_ID 0x6810
  41 #define MENU3_ID 0x46C3
  42 #define MENU4_ID 0x38D6
  43
  44 // Debug output
  45 #if defined(ENABLE_DEBUG_OUTPOUT) && ENABLE_DEBUG_OUTPOUT
  46 #define PRINT(TEXT) do \
  47 { \
  48         if (g_debug) \
  49                 OutputDebugStringA("ClearClipboard -- " TEXT "\n"); \
  50 } \
  51 while(0)
  52 #else
  53 #define PRINT(TEXT) __noop((X))
  54 #endif
  55
  56 // Play sound
  57 #define PLAY_SOUND(X) do \
  58 { \
  59         if(g_sound_enabled >= (X)) \
  60                 play_sound_effect(); \
  61 } \
  62 while(0)
  63
  64 // Helper macro
  65 #define ERROR_EXIT(X) do \
  66 { \
  67         result = (X); goto clean_up; \
  68 } \
  69 while(0)
  70
  71 // Wide string wrapper macro
  72 #define _WTEXT_(X) L##X
  73 #define WTEXT(X) _WTEXT_(X)
  74
  75 // Global variables
  76 static UINT g_taskbar_created = 0U;
  77 static HICON g_app_icon = NULL;
  78 static HMENU g_context_menu = NULL;
  79 static UINT g_timeout = DEFAULT_TIMEOUT;
  80 static UINT g_sound_enabled = DEFAULT_SOUND_LEVEL;
  81 static BOOL g_suspended = FALSE;
  82 static ULONGLONG g_tickCount = 0U;
  83 #ifndef _DEBUG
  84 static BOOL g_debug = FALSE;
  85 #else
  86 static const BOOL g_debug = TRUE;
  87 #endif
  88
  89 // Forward declaration
  90 static LRESULT CALLBACK my_wnd_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
  91 static BOOL clear_clipboard(void);
  92 static UINT parse_arguments(const WCHAR *const command_line);
  93 static BOOL update_autorun_entry(const BOOL remove);
  94 static BOOL create_shell_notify_icon(const HWND hwnd, const BOOL remove);
  95 static BOOL update_shell_notify_icon(const HWND hwnd, const BOOL suspended);
  96 static BOOL about_screen(const BOOL first_run);
  97 static BOOL show_disclaimer(void);
  98 static BOOL play_sound_effect(void);
  99 static WCHAR *get_configuration_path(void);
 100 static WCHAR *get_executable_path(void);
 101 static UINT get_config_value(const WCHAR *const path, const WCHAR *const name, const UINT default_value, const UINT min_value, const UINT max_value);
 102 static DWORD reg_read_value(const HKEY root, const WCHAR *const path, const WCHAR *const name, const DWORD default_value);
 103 static WCHAR *reg_read_string(const HKEY root, const WCHAR *const path, const WCHAR *const name);
 104 static BOOL reg_write_value(const HKEY root, const WCHAR *const path, const WCHAR *const name, const DWORD value);
 105 static BOOL reg_write_string(const HKEY root, const WCHAR *const path, const WCHAR *const name, const WCHAR *const text);
 106 static BOOL reg_delete_value(const HKEY root, const WCHAR *const path, const WCHAR *const name);
 107
 108 // ==========================================================================
 109 // Entry point function
 110 // ==========================================================================
 111
 112 #ifndef _DEBUG
 113
 114 extern IMAGE_DOS_HEADER __ImageBase;
 115 int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow);
 116
 117 int startup(void)
 118 {
 119         const int exit_code =  wWinMain((HINSTANCE)&__ImageBase, NULL, GetCommandLineW(), SW_SHOWDEFAULT);
 120         ExitProcess((UINT)exit_code);
 121         return exit_code;
 122 }
 123
 124 #endif //_DEBUG
 125
 126 // ==========================================================================
 127 // MAIN
 128 // ==========================================================================
 129
 130 int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow)
 131 {
 132         int result = 0, status = -1;
 133         UINT mode = 0U;
 134         HANDLE mutex = NULL;
 135         HWND hwnd = NULL;
 136         BOOL have_listener = FALSE, have_timer = FALSE;
 137         const WCHAR *config_path = NULL;
 138         WNDCLASSW wcl;
 139         MSG msg;
 140
 141         // Initialize variables
 142         SecureZeroMemory(&wcl, sizeof(WNDCLASSW));
 143         SecureZeroMemory(&msg, sizeof(MSG));
 144
 145         // Parse CLI arguments
 146         mode = parse_arguments(lpCmdLine);
 147         PRINT("ClearClipboard v" VERSION_STR " [" __DATE__ "]");
 148
 149         // Check argument
 150         if(mode > 4U)
 151         {
 152                 MessageBoxW(NULL, L"Invalid command-line argument(s). Exiting!", L"ClearClipboard v" WTEXT(VERSION_STR), MB_ICONERROR | MB_TOPMOST);
 153                 return -1;
 154         }
 155
 156         // Close running instances, if it was requested
 157         if((mode == 1U) || (mode == 2U))
 158         {
 159                 PRINT("closing all running instances...");
 160                 while(hwnd = FindWindowExW(NULL, hwnd, CLASS_NAME, NULL))
 161                 {
 162                         PRINT("sending WM_CLOSE");
 163                         SendMessageW(hwnd, WM_CLOSE, 0U, 0U);
 164                 }
 165                 if(mode == 1U)
 166                 {
 167                         PRINT("goodbye.");
 168                         return 0;
 169                 }
 170         }
 171
 172         // Add or remove autorun entry, if it was requested
 173         if((mode == 3U) || (mode == 4U))
 174         {
 175                 const BOOL success = update_autorun_entry(mode > 3U);
 176                 PRINT("goodbye.");
 177                 return success ? 0 : 1;
 178         }
 179
 180         // Lock single instance mutex
 181         if(mutex = CreateMutexW(NULL, FALSE, MUTEX_NAME))
 182         {
 183                 const DWORD ret = WaitForSingleObject(mutex, (mode > 1U) ? 5000U : 250U);
 184                 if((ret != WAIT_OBJECT_0) && (ret != WAIT_ABANDONED))
 185                 {
 186                         PRINT("already running, exiting!");
 187                         ERROR_EXIT(1);
 188                 }
 189         }
 190
 191         // Show disclaimer message
 192         if(!show_disclaimer())
 193         {
 194                 ERROR_EXIT(2);
 195         }
 196
 197         // Print status
 198         PRINT("starting up...");
 199
 200         // Register "TaskbarCreated" window message
 201         if(g_taskbar_created = RegisterWindowMessageW(L"TaskbarCreated"))
 202         {
 203                 ChangeWindowMessageFilter(g_taskbar_created, MSGFLT_ADD);
 204         }
 205
 206         // Read config from INI file
 207         if(config_path = get_configuration_path())
 208         {
 209                 g_timeout = get_config_value(config_path, L"Timeout", DEFAULT_TIMEOUT, 1000U, USER_TIMER_MAXIMUM);
 210                 g_sound_enabled = get_config_value(config_path, L"SoundEnabled", DEFAULT_SOUND_LEVEL, 0U, 2U);
 211                 LocalFree((HLOCAL)config_path);
 212         }
 213
 214         // Load icon resources
 215         if(!(g_app_icon = LoadIconW(hInstance, MAKEINTRESOURCEW(101))))
 216         {
 217                 PRINT("failed to load icon resource!");
 218                 ERROR_EXIT(3);
 219         }
 220
 221         // Create context menu
 222         if(g_context_menu = CreatePopupMenu())
 223         {
 224                 AppendMenuW(g_context_menu, MF_STRING, MENU1_ID, L"ClearClipboard v" WTEXT(VERSION_STR));
 225                 AppendMenuW(g_context_menu, MF_SEPARATOR, 0, NULL);
 226                 AppendMenuW(g_context_menu, MF_STRING, MENU2_ID, L"Clear now!");
 227                 AppendMenuW(g_context_menu, MF_STRING, MENU3_ID, L"Suspend auto-clearing");
 228                 AppendMenuW(g_context_menu, MF_SEPARATOR, 0, NULL);
 229                 AppendMenuW(g_context_menu, MF_STRING, MENU4_ID, L"Quit");
 230                 SetMenuDefaultItem(g_context_menu, MENU1_ID, FALSE);
 231         }
 232         else
 233         {
 234                 PRINT("failed to create context menu!");
 235                 ERROR_EXIT(4);
 236         }
 237
 238         // Register window class
 239         wcl.lpfnWndProc   = my_wnd_proc;
 240         wcl.hInstance     = hInstance;
 241         wcl.hbrBackground = (HBRUSH)(COLOR_BACKGROUND);
 242         wcl.lpszClassName = CLASS_NAME;
 243         if(!RegisterClassW(&wcl))
 244         {
 245                 PRINT("failed to register window class!");
 246                 ERROR_EXIT(5);
 247         }
 248
 249         // Create the message-only window
 250         if(!(hwnd = CreateWindowExW(0L, CLASS_NAME, L"ClearClipboard window", WS_OVERLAPPEDWINDOW/*|WS_VISIBLE*/, 0, 0, 0, 0, NULL, 0, hInstance, NULL)))
 251         {
 252                 PRINT("failed to create the window!");
 253                 ERROR_EXIT(6);
 254         }
 255
 256         // Create notification icon
 257         create_shell_notify_icon(hwnd, FALSE);
 258         update_shell_notify_icon(hwnd, FALSE);
 259
 260         // Add clipboard listener
 261         if(!(have_listener = AddClipboardFormatListener(hwnd)))
 262         {
 263                 PRINT("failed to install clipboard listener!");
 264                 ERROR_EXIT(7);
 265         }
 266
 267         // Set up window timer
 268         g_tickCount = GetTickCount64();
 269         if(!(have_timer = SetTimer(hwnd, TIMER_ID, min(max(g_timeout / 50U, USER_TIMER_MINIMUM), USER_TIMER_MAXIMUM), NULL)))
 270         {
 271                 PRINT("failed to install the window timer!");
 272                 ERROR_EXIT(8);
 273         }
 274
 275         PRINT("clipboard monitoring started.");
 276
 277         // Message loop
 278         while(status = GetMessageW(&msg, NULL, 0, 0) != 0)
 279         {
 280                 if(status == -1)
 281                 {
 282                         PRINT("failed to fetch next message!");
 283                         ERROR_EXIT(9);
 284                 }
 285                 TranslateMessage(&msg);
 286                 DispatchMessage(&msg);
 287         }
 288
 289         PRINT("shutting down now...");
 290
 291 clean_up:
 292
 293         // Kill timer
 294         if(hwnd && have_timer)
 295         {
 296                 KillTimer(hwnd, TIMER_ID);
 297         }
 298
 299         // Delete notification icon
 300         if(hwnd)
 301         {
 302                 create_shell_notify_icon(hwnd, TRUE);
 303         }
 304
 305         // Remove clipboard listener
 306         if(hwnd && have_listener)
 307         {
 308                 RemoveClipboardFormatListener(hwnd);
 309         }
 310
 311         // Free icon resource
 312         if(g_context_menu)
 313         {
 314                 DestroyMenu(g_context_menu);
 315         }
 316
 317         // Free icon resource
 318         if(g_app_icon)
 319         {
 320                 DestroyIcon(g_app_icon);
 321         }
 322
 323         // Close mutex
 324         if(mutex)
 325         {
 326                 CloseHandle(mutex);
 327         }
 328
 329         PRINT("goodbye.");
 330         return result;
 331 }
 332
 333 // ==========================================================================
 334 // Window Procedure
 335 // ==========================================================================
 336
 337 static LRESULT CALLBACK my_wnd_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 338 {
 339         switch(message)
 340         {
 341         case WM_CLOSE:
 342                 PostQuitMessage(0);
 343                 break;
 344         case WM_CLIPBOARDUPDATE:
 345                 PRINT("WM_CLIPBOARDUPDATE");
 346                 g_tickCount = GetTickCount64();
 347                 break;
 348         case WM_TIMER:
 349                 PRINT("WM_TIMER");
 350                 {
 351                         const ULONGLONG tickCount = GetTickCount64();
 352                         if((tickCount > g_tickCount) && ((tickCount - g_tickCount) > g_timeout))
 353                         {
 354                                 if(!g_suspended)
 355                                 {
 356                                         if(clear_clipboard())
 357                                         {
 358                                                 g_tickCount = tickCount;
 359                                                 PLAY_SOUND(2U);
 360                                         }
 361                                 }
 362                                 else
 363                                 {
 364                                         PRINT("skipped.");
 365                                         g_tickCount = tickCount;
 366                                 }
 367                         }
 368                 }
 369                 break;
 370         case WM_NOTIFYICON:
 371                 switch(LOWORD(lParam))
 372                 {
 373                 case WM_CONTEXTMENU:
 374                         PRINT("WM_NOTIFYICON --> WM_CONTEXTMENU");
 375                         if(g_context_menu)
 376                         {
 377                                 SetForegroundWindow(hWnd);
 378                                 TrackPopupMenu(g_context_menu, TPM_BOTTOMALIGN | TPM_LEFTALIGN, LOWORD(wParam), HIWORD(wParam), 0, hWnd, NULL);
 379                         }
 380                         break;
 381                 case WM_LBUTTONDBLCLK:
 382                         PRINT("WM_LBUTTONDBLCLK");
 383                         if(clear_clipboard())
 384                         {
 385                                 g_tickCount = GetTickCount64();
 386                                 PLAY_SOUND(1U);
 387                         }
 388                         break;
 389                 }
 390                 break;
 391         case WM_COMMAND:
 392                 PRINT("WM_COMMAND");
 393                 if(HIWORD(wParam) == 0)
 394                 {
 395                         switch(LOWORD(wParam))
 396                         {
 397                         case MENU1_ID:
 398                                 PRINT("menu item #1 triggered");
 399                                 about_screen(FALSE);
 400                                 break;
 401                         case MENU2_ID:
 402                                 PRINT("menu item #2 triggered");
 403                                 if(clear_clipboard())
 404                                 {
 405                                         g_tickCount = GetTickCount64();
 406                                         PLAY_SOUND(1U);
 407                                 }
 408                                 break;
 409                         case MENU3_ID:
 410                                 PRINT("menu item #3 triggered");
 411                                 g_suspended = !g_suspended;
 412                                 CheckMenuItem(g_context_menu, MENU3_ID, g_suspended ? MF_CHECKED : MF_UNCHECKED);
 413                                 update_shell_notify_icon(hWnd, g_suspended);
 414                                 if(!g_suspended)
 415                                 {
 416                                         g_tickCount = GetTickCount64();
 417                                 }
 418                                 break;
 419                         case MENU4_ID:
 420                                 PRINT("menu item #4 triggered");
 421                                 PostMessageW(hWnd, WM_CLOSE, 0, 0);
 422                                 break;
 423                         }
 424                 }
 425                 break;
 426         default:
 427                 if(message == g_taskbar_created)
 428                 {
 429                         PRINT("TaskbarCreated");
 430                         create_shell_notify_icon(hWnd, FALSE);
 431                         update_shell_notify_icon(hWnd, g_suspended);
 432                 }
 433                 else
 434                 {
 435                         return DefWindowProc(hWnd, message, wParam, lParam);
 436                 }
 437         }
 438
 439         return 0;
 440 }
 441
 442 // ==========================================================================
 443 // Clear Clipboard
 444 // ==========================================================================
 445
 446 static BOOL clear_clipboard(void)
 447 {
 448         int retry;
 449         BOOL success = FALSE;
 450
 451         PRINT("clearing clipboard...");
 452
 453         for(retry = 0; retry < 32; ++retry)
 454         {
 455                 if(retry > 0)
 456                 {
 457                         PRINT("retry!");
 458                         Sleep(1); /*yield*/
 459                 }
 460                 if(OpenClipboard(NULL))
 461                 {
 462                         success = EmptyClipboard();
 463                         CloseClipboard();
 464                 }
 465                 if(success)
 466                 {
 467                         break; /*successful*/
 468                 }
 469         }
 470
 471         if(success)
 472         {
 473                 PRINT("cleared.");
 474         }
 475         else
 476         {
 477                 PRINT("failed to clean clipboard!");
 478         }
 479
 480         return success;
 481 }
 482
 483 // ==========================================================================
 484 // Process CLI arguments
 485 // ==========================================================================
 486
 487 static UINT parse_arguments(const WCHAR *const command_line)
 488 {
 489         const WCHAR **argv;
 490         int i, argc;
 491         UINT mode = 0U;
 492
 493         argv = CommandLineToArgvW(command_line, &argc);
 494         if(argv)
 495         {
 496                 for(i = 1; i < argc; ++i)
 497                 {
 498                         const WCHAR *value = argv[i];
 499                         while((*value) && (*value <= 0x20))
 500                         {
 501                                 ++value;
 502                         }
 503                         if(*value)
 504                         {
 505                                 if(!lstrcmpiW(value, L"--close"))
 506                                 {
 507                                         mode = 1U;
 508                                 }
 509                                 else if(!lstrcmpiW(value, L"--restart"))
 510                                 {
 511                                         mode = 2U;
 512                                 }
 513                                 else if(!lstrcmpiW(value, L"--install"))
 514                                 {
 515                                         mode = 3U;
 516                                 }
 517                                 else if(!lstrcmpiW(value, L"--uninstall"))
 518                                 {
 519                                         mode = 4U;
 520                                 }
 521 #ifndef _DEBUG
 522                                 else if(!lstrcmpiW(value, L"--debug"))
 523                                 {
 524                                         g_debug = TRUE;
 525                                 }
 526 #endif //_DEBUG
 527                                 else if(!lstrcmpiW(value, L"--slunk"))
 528                                 {
 529                                         ShellExecuteW(NULL, NULL, L"https://youtu.be/n4bply6Ibqw", NULL, NULL, SW_SHOW);
 530                                 }
 531                                 else
 532                                 {
 533                                         mode = MAXUINT;
 534                                         break; /*bad argument*/
 535                                 }
 536                         }
 537                 }
 538                 LocalFree((HLOCAL)argv);
 539         }
 540
 541         return mode;
 542 }
 543
 544 // ==========================================================================
 545 // Autorun support
 546 // ==========================================================================
 547
 548 static BOOL update_autorun_entry(const BOOL remove)
 549 {
 550         static const WCHAR *const REG_VALUE_NAME = L"com.muldersoft.clear_clipboard";
 551         static const WCHAR *const REG_VALUE_PATH = L"Software\\Microsoft\\Windows\\CurrentVersion\\Run";
 552
 553         BOOL success = FALSE;
 554
 555         if(!remove)
 556         {
 557                 const WCHAR *const executable_path = get_executable_path();
 558                 if(executable_path)
 559                 {
 560                         WCHAR *const buffer = (WCHAR*) LocalAlloc(LPTR, (lstrlenW(executable_path) + 3U) * sizeof(WCHAR));
 561                         if(buffer)
 562                         {
 563                                 PRINT("adding autorun entry to registry...");
 564                                 lstrcpyW(buffer, L"\"");
 565                                 lstrcatW(buffer, executable_path);
 566                                 lstrcatW(buffer, L"\"");
 567                                 if(reg_write_string(HKEY_CURRENT_USER, REG_VALUE_PATH, REG_VALUE_NAME, buffer))
 568                                 {
 569                                         PRINT("succeeded.");
 570                                         success = TRUE;
 571                                 }
 572                                 else
 573                                 {
 574                                         PRINT("failed to add autorun entry to registry!");
 575                                 }
 576                                 LocalFree((HLOCAL)buffer);
 577                         }
 578                         else
 579                         {
 580                                 PRINT("failed to allocate string buffer!");
 581                         }
 582                         LocalFree((HLOCAL)executable_path);
 583                 }
 584                 else
 585                 {
 586                         PRINT("failed to determine executable path!");
 587                 }
 588         }
 589         else
 590         {
 591                 PRINT("removing autorun entry from registry...");
 592                 if(reg_delete_value(HKEY_CURRENT_USER, REG_VALUE_PATH, REG_VALUE_NAME))
 593                 {
 594                         PRINT("succeeded.");
 595                         success = TRUE;
 596                 }
 597                 else
 598                 {
 599                         PRINT("failed to remove autorun entry from registry!");
 600                 }
 601         }
 602
 603         return success;
 604 }
 605
 606 // ==========================================================================
 607 // Shell notification icon
 608 // ==========================================================================
 609
 610 static BOOL create_shell_notify_icon(const HWND hwnd, const BOOL remove)
 611 {
 612         NOTIFYICONDATAW shell_icon_data;
 613         SecureZeroMemory(&shell_icon_data, sizeof(NOTIFYICONDATAW));
 614
 615         shell_icon_data.cbSize = sizeof(NOTIFYICONDATAW);
 616         shell_icon_data.hWnd = hwnd;
 617         shell_icon_data.uID = ID_NOTIFYICON;
 618
 619         if(!remove)
 620         {
 621                 shell_icon_data.hIcon = g_app_icon;
 622                 shell_icon_data.uCallbackMessage = WM_NOTIFYICON;
 623                 shell_icon_data.uFlags = NIF_ICON | NIF_MESSAGE;
 624         }
 625
 626         if(Shell_NotifyIconW(remove ? NIM_DELETE : NIM_ADD, &shell_icon_data))
 627         {
 628                 if(!remove)
 629                 {
 630                         shell_icon_data.uVersion = NOTIFYICON_VERSION_4;
 631                         Shell_NotifyIconW(NIM_SETVERSION, &shell_icon_data);
 632                 }
 633         }
 634         else
 635         {
 636                 PRINT("failed to create/remove shell notification icon!");
 637                 return FALSE;
 638         }
 639
 640         return TRUE;
 641 }
 642
 643 static BOOL update_shell_notify_icon(const HWND hwnd, const BOOL suspended)
 644 {
 645         NOTIFYICONDATAW shell_icon_data;
 646         SecureZeroMemory(&shell_icon_data, sizeof(NOTIFYICONDATAW));
 647
 648         shell_icon_data.cbSize = sizeof(NOTIFYICONDATAW);
 649         shell_icon_data.hWnd = hwnd;
 650         shell_icon_data.uID = ID_NOTIFYICON;
 651         lstrcpyW(shell_icon_data.szTip, L"ClearClipboard v" WTEXT(VERSION_STR));
 652         if(suspended)
 653         {
 654                 lstrcatW(shell_icon_data.szTip, L" - suspended");
 655         }
 656         shell_icon_data.uFlags = NIF_TIP | NIF_SHOWTIP;
 657
 658         if(!Shell_NotifyIconW(NIM_MODIFY, &shell_icon_data))
 659         {
 660                 PRINT("failed to modify shell notification icon!");
 661                 return FALSE;
 662         }
 663
 664         return TRUE;
 665 }
 666
 667 // ==========================================================================
 668 // About dialog
 669 // ==========================================================================
 670
 671 static BOOL about_screen(const BOOL first_run)
 672 {
 673         const int resut = MessageBoxW(
 674                 NULL,
 675                 L"ClearClipboard v" WTEXT(VERSION_STR) L" [" WTEXT(__DATE__) L"]\n"
 676                 L"Copyright(\x24B8) 2019 LoRd_MuldeR <mulder2@gmx.de>\n\n"
 677                 L"This software is released under the MIT License.\n"
 678                 L"(https://opensource.org/licenses/MIT)\n\n"
 679                 L"For news and updates please check the website at:\n"
 680                 L"\x2022 http://muldersoft.com/\n"
 681                 L"\x2022 https://github.com/lordmulder/ClearClipboard\n\n"
 682                 L"DISCLAIMER: "
 683                 L"The software is provided \"as is\", without warranty of any kind, express or implied, including"
 684                 L"but not limited to the warranties of merchantability, fitness for a particular purpose and"
 685                 L"noninfringement. In no event shall the authors or copyright holders be liable for any claim,"
 686                 L"damages or other liability, whether in an action of contract, tort or otherwise, arising from,"
 687                 L"out of or in connection with the software or the use or other dealings in the software.",
 688                 L"About...",
 689                 MB_ICONINFORMATION | MB_TOPMOST | (first_run ? MB_OKCANCEL|MB_DEFBUTTON2 : MB_OK)
 690         );
 691
 692         return (resut == IDOK);
 693 }
 694
 695 static BOOL show_disclaimer(void)
 696 {
 697         static const DWORD REG_VALUE_DATA = (((DWORD)VERSION_MAJOR) << 16) | (((DWORD)VERSION_MINOR_HI) << 8) | ((DWORD)VERSION_MINOR_LO);
 698         static const WCHAR *const REG_VALUE_NAME = L"DisclaimerAccepted";
 699         static const WCHAR *const REG_VALUE_PATH = L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\{7816D5D9-5D9D-4B3A-B5A8-DD7A7F4C44A3}";
 700
 701         if(reg_read_value(HKEY_CURRENT_USER, REG_VALUE_PATH, REG_VALUE_NAME, 0U) != REG_VALUE_DATA)
 702         {
 703                 if(about_screen(TRUE))
 704                 {
 705                         reg_write_value(HKEY_CURRENT_USER, REG_VALUE_PATH, REG_VALUE_NAME, REG_VALUE_DATA);
 706                 }
 707                 else
 708                 {
 709                         return FALSE; /*rejected*/
 710                 }
 711         }
 712
 713         return TRUE;
 714 }
 715
 716 // ==========================================================================
 717 // Play sound effect
 718 // ==========================================================================
 719
 720 static BOOL play_sound_effect(void)
 721 {
 722         BOOL success = FALSE;
 723
 724         const WCHAR *const sound_file = reg_read_string(HKEY_CURRENT_USER, L"AppEvents\\Schemes\\Apps\\Explorer\\EmptyRecycleBin\\.Current", L"");
 725         if(sound_file)
 726         {
 727                 if(sound_file[0] && (GetFileAttributesW(sound_file) != INVALID_FILE_ATTRIBUTES))
 728                 {
 729                         success = PlaySoundW(sound_file, NULL, SND_ASYNC);
 730                 }
 731                 LocalFree((HLOCAL)sound_file);
 732         }
 733
 734         if(!success)
 735         {
 736                 success = PlaySoundW(L"SystemAsterisk", NULL, SND_ALIAS | SND_ASYNC);
 737         }
 738
 739         return success;
 740 }
 741
 742 // ==========================================================================
 743 // File path routines
 744 // ==========================================================================
 745
 746 static WCHAR *get_configuration_path(void)
 747 {
 748         static const WCHAR *const DEFAULT_PATH = L"ClearClipboard.ini";
 749         WCHAR *buffer = NULL;
 750         WCHAR *const path = get_executable_path();
 751
 752         if(path)
 753         {
 754                 const DWORD path_len = lstrlenW(path);
 755                 if(path_len > 1U)
 756                 {
 757                         DWORD pos, last_sep = 0U;
 758                         for(pos = 0U; pos < path_len; ++pos)
 759                         {
 760                                 if((path[pos] == L'/') || (path[pos] == L'\\') || (path[pos] == L'.'))
 761                                 {
 762                                         last_sep = pos;
 763                                 }
 764                         }
 765                         if(last_sep > 1U)
 766                         {
 767                                 const DWORD copy_len = (path[last_sep] == '.') ? last_sep : path_len;
 768                                 buffer = (WCHAR*) LocalAlloc(LPTR, (5U + copy_len) * sizeof(WCHAR));
 769                                 if(buffer)
 770                                 {
 771                                         lstrcpynW(buffer, path, last_sep + 1U);
 772                                         lstrcatW(buffer, L".ini");
 773                                 }
 774                         }
 775                 }
 776                 LocalFree((HLOCAL)path);
 777         }
 778
 779         if(!buffer)
 780         {
 781                 buffer = (WCHAR*) LocalAlloc(LPTR, (1U + lstrlenW(DEFAULT_PATH)) * sizeof(WCHAR));
 782                 if(buffer)
 783                 {
 784                         lstrcpyW(buffer, DEFAULT_PATH);
 785                 }
 786         }
 787
 788         return buffer;
 789 }
 790
 791 static WCHAR *get_executable_path(void)
 792 {
 793         DWORD size = 256U;
 794
 795         WCHAR *buffer = (WCHAR*) LocalAlloc(LPTR, size * sizeof(WCHAR));
 796         if(!buffer)
 797         {
 798                 return NULL; /*malloc failed*/
 799         }
 800
 801         for(;;)
 802         {
 803                 const DWORD result = GetModuleFileNameW(NULL, buffer, size);
 804                 if((result > 0) && (result < size))
 805                 {
 806                         return buffer;
 807                 }
 808                 if((size < MAXWORD) && (result >= size))
 809                 {
 810                         LocalFree((HLOCAL)buffer);
 811                         size *= 2U;
 812                         if(!(buffer = (WCHAR*) LocalAlloc(LPTR, size * sizeof(WCHAR))))
 813                         {
 814                                 return NULL; /*malloc failed*/
 815                         }
 816                 }
 817                 else
 818                 {
 819                         break; /*something else went wrong*/
 820                 }
 821         }
 822
 823         LocalFree((HLOCAL)buffer);
 824         return NULL;
 825 }
 826
 827 // ==========================================================================
 828 // Configuration routines
 829 // ==========================================================================
 830
 831 static UINT get_config_value(const WCHAR *const path, const WCHAR *const name, const UINT default_value, const UINT min_value, const UINT max_value)
 832 {
 833         static const WCHAR *const SECTION_NAME = L"ClearClipboard";
 834         const UINT value = GetPrivateProfileIntW(SECTION_NAME, name , default_value, path);
 835         return max(min_value, min(max_value, value));
 836 }
 837
 838 // ==========================================================================
 839 // Registry routines
 840 // ==========================================================================
 841
 842 static DWORD reg_read_value(const HKEY root, const WCHAR *const path, const WCHAR *const name, const DWORD default_value)
 843 {
 844         HKEY hkey = NULL;
 845         DWORD result = 0U, type = REG_NONE, size = sizeof(DWORD);
 846
 847         if(RegOpenKeyExW(root, path, 0U, KEY_READ, &hkey) != ERROR_SUCCESS)
 848         {
 849                 PRINT("failed to open registry key for reading!");
 850                 return default_value;
 851         }
 852
 853         if(RegQueryValueExW(hkey, name, NULL, &type, (BYTE*)&result, &size) == ERROR_SUCCESS)
 854         {
 855                 if((type == REG_DWORD) || (type == REG_DWORD_BIG_ENDIAN))
 856                 {
 857                         RegCloseKey(hkey);
 858                         return result;
 859                 }
 860         }
 861
 862         RegCloseKey(hkey);
 863         PRINT("failed to read registry value!");
 864         return default_value;
 865 }
 866
 867 static WCHAR *reg_read_string(const HKEY root, const WCHAR *const path, const WCHAR *const name)
 868 {
 869         HKEY hkey = NULL;
 870         DWORD capacity;
 871
 872         if(RegOpenKeyExW(root, path, 0U, KEY_READ, &hkey) != ERROR_SUCCESS)
 873         {
 874                 PRINT("failed to open registry key for reading!");
 875                 return NULL;
 876         }
 877
 878         for(capacity = 4096U; capacity <= 65536U; capacity *= 2U)
 879         {
 880                 WCHAR *const buffer = (WCHAR*) LocalAlloc(LPTR, capacity);
 881                 if(buffer)
 882                 {
 883                         DWORD type = REG_NONE, size = capacity;
 884                         const LSTATUS error = RegQueryValueExW(hkey, name, NULL, &type, (BYTE*)buffer, &size);
 885                         if((error == ERROR_SUCCESS) && ((type == REG_SZ) || (type == REG_EXPAND_SZ)))
 886                         {
 887                                 RegCloseKey(hkey);
 888                                 return buffer;
 889                         }
 890                         LocalFree((HLOCAL)buffer);
 891                         if(error != ERROR_MORE_DATA)
 892                         {
 893                                 break; /*failure*/
 894                         }
 895                 }
 896                 else
 897                 {
 898                         RegCloseKey(hkey);
 899                         PRINT("failed to allocate buffer!");
 900                         return NULL;
 901                 }
 902         }
 903
 904         RegCloseKey(hkey);
 905         PRINT("failed to read registry value!");
 906         return NULL;
 907 }
 908
 909 static BOOL reg_write_value(const HKEY root, const WCHAR *const path, const WCHAR *const name, const DWORD value)
 910 {
 911         HKEY hkey = NULL;
 912
 913         if(RegCreateKeyExW(root, path, 0U, NULL, 0U, KEY_WRITE, NULL, &hkey, NULL) != ERROR_SUCCESS)
 914         {
 915                 PRINT("failed to open registry key for writing!");
 916                 return FALSE;
 917         }
 918
 919         if(RegSetValueExW(hkey, name, 0U, REG_DWORD, (BYTE*)&value, sizeof(DWORD)) != ERROR_SUCCESS)
 920         {
 921                 RegCloseKey(hkey);
 922                 PRINT("failed to write registry value!");
 923                 return FALSE;
 924         }
 925
 926         RegCloseKey(hkey);
 927         return TRUE;
 928 }
 929
 930 static BOOL reg_write_string(const HKEY root, const WCHAR *const path, const WCHAR *const name, const WCHAR *const text)
 931 {
 932         HKEY hkey = NULL;
 933
 934         if(RegCreateKeyExW(root, path, 0U, NULL, 0U, KEY_WRITE, NULL, &hkey, NULL) != ERROR_SUCCESS)
 935         {
 936                 RegCloseKey(hkey);
 937                 PRINT("failed to open registry key for writing!");
 938                 return FALSE;
 939         }
 940
 941         if(RegSetValueExW(hkey, name, 0U, REG_SZ, (BYTE*)&text, (lstrlenW(text) + 1U) * sizeof(WCHAR)) != ERROR_SUCCESS)
 942         {
 943                 RegCloseKey(hkey);
 944                 PRINT("failed to write registry value!");
 945                 return FALSE;
 946         }
 947
 948         RegCloseKey(hkey);
 949         return TRUE;
 950 }
 951
 952 static BOOL reg_delete_value(const HKEY root, const WCHAR *const path, const WCHAR *const name)
 953 {
 954         HKEY hkey = NULL;
 955         LSTATUS error = 0U;
 956
 957         if((error = RegOpenKeyExW(root, path, 0U, KEY_WRITE, &hkey)) != ERROR_SUCCESS)
 958         {
 959                 if(error != ERROR_FILE_NOT_FOUND)
 960                 {
 961                         PRINT("failed to open registry key for writing!");
 962                         return FALSE;
 963                 }
 964                 return TRUE;
 965         }
 966
 967         if((error = RegDeleteValueW(hkey, name)) != ERROR_SUCCESS)
 968         {
 969                 if(error != ERROR_FILE_NOT_FOUND)
 970                 {
 971                         RegCloseKey(hkey);
 972                         PRINT("failed to write registry value!");
 973                         return FALSE;
 974                 }
 975         }
 976
 977         RegCloseKey(hkey);
 978         return TRUE;
 979 }