xref: /reactos/base/applications/clipbrd/clipbrd.c (revision b2d2e343) 
1 /*
2  * PROJECT:     ReactOS Clipboard Viewer
3  * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
4  * PURPOSE:     Provides a view of the contents of the ReactOS clipboard.
5  * COPYRIGHT:   Copyright 2015-2018 Ricardo Hanke
6  *              Copyright 2015-2018 Hermes Belusca-Maito
7  */
8 
9 #include "precomp.h"
10 
11 static const WCHAR szClassName[] = L"ClipBookWClass";
12 
13 CLIPBOARD_GLOBALS Globals;
14 SCROLLSTATE Scrollstate;
15 
16 static void SaveClipboardToFile(void)
17 {
18     OPENFILENAMEW sfn;
19     LPWSTR c;
20     WCHAR szFileName[MAX_PATH];
21     WCHAR szFilterMask[MAX_STRING_LEN + 10];
22 
23     ZeroMemory(&szFilterMask, sizeof(szFilterMask));
24     c = szFilterMask + LoadStringW(Globals.hInstance, STRING_FORMAT_NT, szFilterMask, MAX_STRING_LEN) + 1;
25     wcscpy(c, L"*.clp");
26 
27     ZeroMemory(&szFileName, sizeof(szFileName));
28     ZeroMemory(&sfn, sizeof(sfn));
29     sfn.lStructSize = sizeof(sfn);
30     sfn.hwndOwner = Globals.hMainWnd;
31     sfn.hInstance = Globals.hInstance;
32     sfn.lpstrFilter = szFilterMask;
33     sfn.lpstrFile = szFileName;
34     sfn.nMaxFile = ARRAYSIZE(szFileName);
35     sfn.Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
36     sfn.lpstrDefExt = L"clp";
37 
38     if (!GetSaveFileNameW(&sfn))
39         return;
40 
41     if (!OpenClipboard(Globals.hMainWnd))
42     {
43         ShowLastWin32Error(Globals.hMainWnd);
44         return;
45     }
46 
47     WriteClipboardFile(szFileName, CLIP_FMT_NT /* CLIP_FMT_31 */);
48 
49     CloseClipboard();
50 }
51 
52 static void LoadClipboardDataFromFile(LPWSTR lpszFileName)
53 {
54     if (MessageBoxRes(Globals.hMainWnd, Globals.hInstance,
55                       STRING_DELETE_MSG, STRING_DELETE_TITLE,
56                       MB_ICONWARNING | MB_YESNO) != IDYES)
57     {
58         return;
59     }
60 
61     if (!OpenClipboard(Globals.hMainWnd))
62     {
63         ShowLastWin32Error(Globals.hMainWnd);
64         return;
65     }
66 
67     EmptyClipboard();
68     ReadClipboardFile(lpszFileName);
69 
70     CloseClipboard();
71 }
72 
73 static void LoadClipboardFromFile(void)
74 {
75     OPENFILENAMEW ofn;
76     LPWSTR c;
77     WCHAR szFileName[MAX_PATH];
78     WCHAR szFilterMask[MAX_STRING_LEN + 10];
79 
80     ZeroMemory(&szFilterMask, sizeof(szFilterMask));
81     c = szFilterMask + LoadStringW(Globals.hInstance, STRING_FORMAT_GEN, szFilterMask, MAX_STRING_LEN) + 1;
82     wcscpy(c, L"*.clp");
83 
84     ZeroMemory(&szFileName, sizeof(szFileName));
85     ZeroMemory(&ofn, sizeof(ofn));
86     ofn.lStructSize = sizeof(ofn);
87     ofn.hwndOwner = Globals.hMainWnd;
88     ofn.hInstance = Globals.hInstance;
89     ofn.lpstrFilter = szFilterMask;
90     ofn.lpstrFile = szFileName;
91     ofn.nMaxFile = ARRAYSIZE(szFileName);
92     ofn.Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_FILEMUSTEXIST;
93 
94     if (!GetOpenFileNameW(&ofn))
95         return;
96 
97     LoadClipboardDataFromFile(szFileName);
98 }
99 
100 static void LoadClipboardFromDrop(HDROP hDrop)
101 {
102     WCHAR szFileName[MAX_PATH];
103 
104     DragQueryFileW(hDrop, 0, szFileName, ARRAYSIZE(szFileName));
105     DragFinish(hDrop);
106 
107     LoadClipboardDataFromFile(szFileName);
108 }
109 
110 static void SetDisplayFormat(UINT uFormat)
111 {
112     RECT rc;
113 
114     CheckMenuItem(Globals.hMenu, Globals.uCheckedItem, MF_BYCOMMAND | MF_UNCHECKED);
115     Globals.uCheckedItem = uFormat + CMD_AUTOMATIC;
116     CheckMenuItem(Globals.hMenu, Globals.uCheckedItem, MF_BYCOMMAND | MF_CHECKED);
117 
118     if (uFormat == 0)
119     {
120         Globals.uDisplayFormat = GetAutomaticClipboardFormat();
121     }
122     else
123     {
124         Globals.uDisplayFormat = uFormat;
125     }
126 
127     GetClipboardDataDimensions(Globals.uDisplayFormat, &rc);
128     Scrollstate.CurrentX = Scrollstate.CurrentY = 0;
129     Scrollstate.iWheelCarryoverX = Scrollstate.iWheelCarryoverY = 0;
130     UpdateWindowScrollState(Globals.hMainWnd, rc.right, rc.bottom, &Scrollstate);
131 
132     InvalidateRect(Globals.hMainWnd, NULL, TRUE);
133 }
134 
135 static void InitMenuPopup(HMENU hMenu, LPARAM index)
136 {
137     if ((GetMenuItemID(hMenu, 0) == CMD_DELETE) || (GetMenuItemID(hMenu, 1) == CMD_SAVE_AS))
138     {
139         if (CountClipboardFormats() == 0)
140         {
141             EnableMenuItem(hMenu, CMD_DELETE, MF_GRAYED);
142             EnableMenuItem(hMenu, CMD_SAVE_AS, MF_GRAYED);
143         }
144         else
145         {
146             EnableMenuItem(hMenu, CMD_DELETE, MF_ENABLED);
147             EnableMenuItem(hMenu, CMD_SAVE_AS, MF_ENABLED);
148         }
149     }
150 
151     DrawMenuBar(Globals.hMainWnd);
152 }
153 
154 static void UpdateDisplayMenu(void)
155 {
156     UINT uFormat;
157     HMENU hMenu;
158     WCHAR szFormatName[MAX_FMT_NAME_LEN + 1];
159 
160     hMenu = GetSubMenu(Globals.hMenu, DISPLAY_MENU_POS);
161 
162     while (GetMenuItemCount(hMenu) > 1)
163     {
164         DeleteMenu(hMenu, 1, MF_BYPOSITION);
165     }
166 
167     if (CountClipboardFormats() == 0)
168         return;
169 
170     if (!OpenClipboard(Globals.hMainWnd))
171         return;
172 
173     AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL);
174 
175     /* Display the supported clipboard formats first */
176     for (uFormat = EnumClipboardFormats(0); uFormat;
177          uFormat = EnumClipboardFormats(uFormat))
178     {
179         if (IsClipboardFormatSupported(uFormat))
180         {
181             RetrieveClipboardFormatName(Globals.hInstance, uFormat, TRUE,
182                                         szFormatName, ARRAYSIZE(szFormatName));
183             AppendMenuW(hMenu, MF_STRING, CMD_AUTOMATIC + uFormat, szFormatName);
184         }
185     }
186 
187     /* Now display the unsupported clipboard formats */
188     for (uFormat = EnumClipboardFormats(0); uFormat;
189          uFormat = EnumClipboardFormats(uFormat))
190     {
191         if (!IsClipboardFormatSupported(uFormat))
192         {
193             RetrieveClipboardFormatName(Globals.hInstance, uFormat, TRUE,
194                                         szFormatName, ARRAYSIZE(szFormatName));
195             AppendMenuW(hMenu, MF_STRING | MF_GRAYED, 0, szFormatName);
196         }
197     }
198 
199     CloseClipboard();
200 }
201 
202 static int OnCommand(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
203 {
204     switch (LOWORD(wParam))
205     {
206         case CMD_OPEN:
207         {
208             LoadClipboardFromFile();
209             break;
210         }
211 
212         case CMD_SAVE_AS:
213         {
214             SaveClipboardToFile();
215             break;
216         }
217 
218         case CMD_EXIT:
219         {
220             PostMessageW(Globals.hMainWnd, WM_CLOSE, 0, 0);
221             break;
222         }
223 
224         case CMD_DELETE:
225         {
226             if (MessageBoxRes(Globals.hMainWnd, Globals.hInstance,
227                               STRING_DELETE_MSG, STRING_DELETE_TITLE,
228                               MB_ICONWARNING | MB_YESNO) != IDYES)
229             {
230                 break;
231             }
232 
233             DeleteClipboardContent();
234             break;
235         }
236 
237         case CMD_AUTOMATIC:
238         {
239             SetDisplayFormat(0);
240             break;
241         }
242 
243         case CMD_HELP:
244         {
245             HtmlHelpW(Globals.hMainWnd, L"clipbrd.chm", 0, 0);
246             break;
247         }
248 
249         case CMD_ABOUT:
250         {
251             HICON hIcon;
252             WCHAR szTitle[MAX_STRING_LEN];
253 
254             hIcon = LoadIconW(Globals.hInstance, MAKEINTRESOURCE(CLIPBRD_ICON));
255             LoadStringW(Globals.hInstance, STRING_CLIPBOARD, szTitle, ARRAYSIZE(szTitle));
256             ShellAboutW(Globals.hMainWnd, szTitle, NULL, hIcon);
257             DeleteObject(hIcon);
258             break;
259         }
260 
261         default:
262         {
263             break;
264         }
265     }
266     return 0;
267 }
268 
269 static void OnPaint(HWND hWnd, WPARAM wParam, LPARAM lParam)
270 {
271     HDC hdc;
272     PAINTSTRUCT ps;
273     COLORREF crOldBkColor, crOldTextColor;
274     RECT rc;
275 
276     if (!OpenClipboard(Globals.hMainWnd))
277         return;
278 
279     hdc = BeginPaint(hWnd, &ps);
280 
281     /* Erase the background if needed */
282     if (ps.fErase)
283         FillRect(ps.hdc, &ps.rcPaint, (HBRUSH)(COLOR_WINDOW + 1));
284 
285     /* Set the correct background and text colors */
286     crOldBkColor   = SetBkColor(ps.hdc, GetSysColor(COLOR_WINDOW));
287     crOldTextColor = SetTextColor(ps.hdc, GetSysColor(COLOR_WINDOWTEXT));
288 
289     /* Realize the clipboard palette if there is one */
290     RealizeClipboardPalette(ps.hdc);
291 
292     switch (Globals.uDisplayFormat)
293     {
294         case CF_NONE:
295         {
296             /* The clipboard is empty */
297             break;
298         }
299 
300         case CF_DSPTEXT:
301         case CF_TEXT:
302         case CF_OEMTEXT:
303         case CF_UNICODETEXT:
304         {
305             DrawTextFromClipboard(Globals.uDisplayFormat, ps, Scrollstate);
306             break;
307         }
308 
309         case CF_DSPBITMAP:
310         case CF_BITMAP:
311         {
312             BitBltFromClipboard(ps, Scrollstate, SRCCOPY);
313             break;
314         }
315 
316         case CF_DIB:
317         case CF_DIBV5:
318         {
319             SetDIBitsToDeviceFromClipboard(Globals.uDisplayFormat, ps, Scrollstate, DIB_RGB_COLORS);
320             break;
321         }
322 
323         case CF_DSPMETAFILEPICT:
324         case CF_METAFILEPICT:
325         {
326             GetClientRect(hWnd, &rc);
327             PlayMetaFileFromClipboard(hdc, &rc);
328             break;
329         }
330 
331         case CF_DSPENHMETAFILE:
332         case CF_ENHMETAFILE:
333         {
334             GetClientRect(hWnd, &rc);
335             PlayEnhMetaFileFromClipboard(hdc, &rc);
336             break;
337         }
338 
339         // case CF_PALETTE:
340             // TODO: Draw a palette with squares filled with colors.
341             // break;
342 
343         case CF_OWNERDISPLAY:
344         {
345             HGLOBAL hglb;
346             PPAINTSTRUCT pps;
347 
348             hglb = GlobalAlloc(GMEM_MOVEABLE, sizeof(ps));
349             if (hglb)
350             {
351                 pps = GlobalLock(hglb);
352                 CopyMemory(pps, &ps, sizeof(ps));
353                 GlobalUnlock(hglb);
354 
355                 SendClipboardOwnerMessage(TRUE, WM_PAINTCLIPBOARD,
356                                           (WPARAM)hWnd, (LPARAM)hglb);
357 
358                 GlobalFree(hglb);
359             }
360             break;
361         }
362 
363         default:
364         {
365             GetClientRect(hWnd, &rc);
366             DrawTextFromResource(Globals.hInstance, ERROR_UNSUPPORTED_FORMAT,
367                                  hdc, &rc, DT_CENTER | DT_WORDBREAK | DT_NOPREFIX);
368             break;
369         }
370     }
371 
372     /* Restore the original colors */
373     SetTextColor(ps.hdc, crOldTextColor);
374     SetBkColor(ps.hdc, crOldBkColor);
375 
376     EndPaint(hWnd, &ps);
377 
378     CloseClipboard();
379 }
380 
381 static LRESULT WINAPI MainWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
382 {
383     switch(uMsg)
384     {
385         case WM_CREATE:
386         {
387             TEXTMETRICW tm;
388             HDC hDC = GetDC(hWnd);
389 
390             /*
391              * Note that the method with GetObjectW just returns
392              * the original parameters with which the font was created.
393              */
394             if (GetTextMetricsW(hDC, &tm))
395             {
396                 Globals.CharWidth  = tm.tmMaxCharWidth; // tm.tmAveCharWidth;
397                 Globals.CharHeight = tm.tmHeight + tm.tmExternalLeading;
398             }
399             ReleaseDC(hWnd, hDC);
400 
401 
402             Globals.hMenu = GetMenu(hWnd);
403             Globals.hWndNext = SetClipboardViewer(hWnd);
404 
405             // For now, the Help dialog item is disabled because of lacking of HTML support
406             EnableMenuItem(Globals.hMenu, CMD_HELP, MF_BYCOMMAND | MF_GRAYED);
407 
408             UpdateLinesToScroll(&Scrollstate);
409 
410             UpdateDisplayMenu();
411             SetDisplayFormat(0);
412 
413             DragAcceptFiles(hWnd, TRUE);
414             break;
415         }
416 
417         case WM_CLOSE:
418         {
419             DestroyWindow(hWnd);
420             break;
421         }
422 
423         case WM_DESTROY:
424         {
425             ChangeClipboardChain(hWnd, Globals.hWndNext);
426 
427             if (Globals.uDisplayFormat == CF_OWNERDISPLAY)
428             {
429                 HGLOBAL hglb;
430                 PRECT prc;
431 
432                 hglb = GlobalAlloc(GMEM_MOVEABLE, sizeof(*prc));
433                 if (hglb)
434                 {
435                     prc = GlobalLock(hglb);
436                     SetRectEmpty(prc);
437                     GlobalUnlock(hglb);
438 
439                     SendClipboardOwnerMessage(TRUE, WM_SIZECLIPBOARD,
440                                               (WPARAM)hWnd, (LPARAM)hglb);
441 
442                     GlobalFree(hglb);
443                 }
444             }
445 
446             PostQuitMessage(0);
447             break;
448         }
449 
450         case WM_PAINT:
451         {
452             OnPaint(hWnd, wParam, lParam);
453             break;
454         }
455 
456         case WM_KEYDOWN:
457         {
458             OnKeyScroll(hWnd, wParam, lParam, &Scrollstate);
459             break;
460         }
461 
462         case WM_MOUSEWHEEL:
463         case WM_MOUSEHWHEEL:
464         {
465             OnMouseScroll(hWnd, uMsg, wParam, lParam, &Scrollstate);
466             break;
467         }
468 
469         case WM_HSCROLL:
470         {
471             // NOTE: Windows uses an offset of 16 pixels
472             OnScroll(hWnd, SB_HORZ, wParam, 5, &Scrollstate);
473             break;
474         }
475 
476         case WM_VSCROLL:
477         {
478             // NOTE: Windows uses an offset of 16 pixels
479             OnScroll(hWnd, SB_VERT, wParam, 5, &Scrollstate);
480             break;
481         }
482 
483         case WM_SIZE:
484         {
485             RECT rc;
486 
487             if (Globals.uDisplayFormat == CF_OWNERDISPLAY)
488             {
489                 HGLOBAL hglb;
490                 PRECT prc;
491 
492                 hglb = GlobalAlloc(GMEM_MOVEABLE, sizeof(*prc));
493                 if (hglb)
494                 {
495                     prc = GlobalLock(hglb);
496                     if (wParam == SIZE_MINIMIZED)
497                         SetRectEmpty(prc);
498                     else
499                         GetClientRect(hWnd, prc);
500                     GlobalUnlock(hglb);
501 
502                     SendClipboardOwnerMessage(TRUE, WM_SIZECLIPBOARD,
503                                               (WPARAM)hWnd, (LPARAM)hglb);
504 
505                     GlobalFree(hglb);
506                 }
507                 break;
508             }
509 
510             GetClipboardDataDimensions(Globals.uDisplayFormat, &rc);
511             UpdateWindowScrollState(hWnd, rc.right, rc.bottom, &Scrollstate);
512 
513             // NOTE: There still are little problems drawing
514             // the background when displaying clipboard text.
515             if (!IsClipboardFormatSupported(Globals.uDisplayFormat) ||
516                 Globals.uDisplayFormat == CF_DSPTEXT ||
517                 Globals.uDisplayFormat == CF_TEXT    ||
518                 Globals.uDisplayFormat == CF_OEMTEXT ||
519                 Globals.uDisplayFormat == CF_UNICODETEXT)
520             {
521                 InvalidateRect(Globals.hMainWnd, NULL, TRUE);
522             }
523             else
524             {
525                 InvalidateRect(Globals.hMainWnd, NULL, FALSE);
526             }
527 
528             break;
529         }
530 
531         case WM_CHANGECBCHAIN:
532         {
533             /* Transmit through the clipboard viewer chain */
534             if ((HWND)wParam == Globals.hWndNext)
535             {
536                 Globals.hWndNext = (HWND)lParam;
537             }
538             else if (Globals.hWndNext != NULL)
539             {
540                 SendMessageW(Globals.hWndNext, uMsg, wParam, lParam);
541             }
542 
543             break;
544         }
545 
546         case WM_DESTROYCLIPBOARD:
547             break;
548 
549         case WM_RENDERALLFORMATS:
550         {
551             /*
552              * When the user has cleared the clipboard via the DELETE command,
553              * we (clipboard viewer) become the clipboard owner. When we are
554              * subsequently closed, this message is then sent to us so that
555              * we get a chance to render everything we can. Since we don't have
556              * anything to render, just empty the clipboard.
557              */
558             DeleteClipboardContent();
559             break;
560         }
561 
562         case WM_RENDERFORMAT:
563             // TODO!
564             break;
565 
566         case WM_DRAWCLIPBOARD:
567         {
568             UpdateDisplayMenu();
569             SetDisplayFormat(0);
570 
571             /* Pass the message to the next window in clipboard viewer chain */
572             SendMessageW(Globals.hWndNext, uMsg, wParam, lParam);
573             break;
574         }
575 
576         case WM_COMMAND:
577         {
578             if ((LOWORD(wParam) > CMD_AUTOMATIC))
579             {
580                 SetDisplayFormat(LOWORD(wParam) - CMD_AUTOMATIC);
581             }
582             else
583             {
584                 OnCommand(hWnd, uMsg, wParam, lParam);
585             }
586             break;
587         }
588 
589         case WM_INITMENUPOPUP:
590         {
591             InitMenuPopup((HMENU)wParam, lParam);
592             break;
593         }
594 
595         case WM_DROPFILES:
596         {
597             LoadClipboardFromDrop((HDROP)wParam);
598             break;
599         }
600 
601         case WM_PALETTECHANGED:
602         {
603             /* Ignore if this comes from ourselves */
604             if ((HWND)wParam == hWnd)
605                 break;
606 
607             /* Fall back to WM_QUERYNEWPALETTE */
608         }
609 
610         case WM_QUERYNEWPALETTE:
611         {
612             BOOL Success;
613             HDC hDC;
614 
615             if (!OpenClipboard(Globals.hMainWnd))
616                 return FALSE;
617 
618             hDC = GetDC(hWnd);
619             if (!hDC)
620             {
621                 CloseClipboard();
622                 return FALSE;
623             }
624 
625             Success = RealizeClipboardPalette(hDC);
626 
627             ReleaseDC(hWnd, hDC);
628             CloseClipboard();
629 
630             if (Success)
631             {
632                 InvalidateRect(hWnd, NULL, TRUE);
633                 UpdateWindow(hWnd);
634                 return TRUE;
635             }
636             return FALSE;
637         }
638 
639         case WM_SYSCOLORCHANGE:
640         {
641             SetDisplayFormat(Globals.uDisplayFormat);
642             break;
643         }
644 
645         case WM_SETTINGCHANGE:
646         {
647             if (wParam == SPI_SETWHEELSCROLLLINES)
648             {
649                 UpdateLinesToScroll(&Scrollstate);
650             }
651             break;
652         }
653 
654         default:
655         {
656             return DefWindowProc(hWnd, uMsg, wParam, lParam);
657         }
658     }
659 
660     return 0;
661 }
662 
663 int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow)
664 {
665     MSG msg;
666     HACCEL hAccel;
667     HWND hPrevWindow;
668     WNDCLASSEXW wndclass;
669     WCHAR szBuffer[MAX_STRING_LEN];
670 
671     hPrevWindow = FindWindowW(szClassName, NULL);
672     if (hPrevWindow)
673     {
674         BringWindowToFront(hPrevWindow);
675         return 0;
676     }
677 
678     switch (GetUserDefaultUILanguage())
679     {
680         case MAKELANGID(LANG_HEBREW, SUBLANG_DEFAULT):
681             SetProcessDefaultLayout(LAYOUT_RTL);
682             break;
683 
684         default:
685             break;
686     }
687 
688     ZeroMemory(&Globals, sizeof(Globals));
689     Globals.hInstance = hInstance;
690 
691     ZeroMemory(&wndclass, sizeof(wndclass));
692     wndclass.cbSize = sizeof(wndclass);
693     wndclass.lpfnWndProc = MainWndProc;
694     wndclass.hInstance = hInstance;
695     wndclass.hIcon = LoadIconW(hInstance, MAKEINTRESOURCEW(CLIPBRD_ICON));
696     wndclass.hCursor = LoadCursorW(0, IDC_ARROW);
697     wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
698     wndclass.lpszMenuName = MAKEINTRESOURCEW(MAIN_MENU);
699     wndclass.lpszClassName = szClassName;
700 
701     if (!RegisterClassExW(&wndclass))
702     {
703         ShowLastWin32Error(NULL);
704         return 0;
705     }
706 
707     ZeroMemory(&Scrollstate, sizeof(Scrollstate));
708 
709     LoadStringW(hInstance, STRING_CLIPBOARD, szBuffer, ARRAYSIZE(szBuffer));
710     Globals.hMainWnd = CreateWindowExW(WS_EX_CLIENTEDGE | WS_EX_ACCEPTFILES,
711                                        szClassName,
712                                        szBuffer,
713                                        WS_OVERLAPPEDWINDOW | WS_HSCROLL | WS_VSCROLL,
714                                        CW_USEDEFAULT,
715                                        CW_USEDEFAULT,
716                                        CW_USEDEFAULT,
717                                        CW_USEDEFAULT,
718                                        NULL,
719                                        NULL,
720                                        Globals.hInstance,
721                                        NULL);
722     if (!Globals.hMainWnd)
723     {
724         ShowLastWin32Error(NULL);
725         return 0;
726     }
727 
728     ShowWindow(Globals.hMainWnd, nCmdShow);
729     UpdateWindow(Globals.hMainWnd);
730 
731     hAccel = LoadAcceleratorsW(Globals.hInstance, MAKEINTRESOURCEW(ID_ACCEL));
732     if (!hAccel)
733     {
734         ShowLastWin32Error(Globals.hMainWnd);
735     }
736 
737     /* If the user provided a path to a clipboard data file, try to open it */
738     if (__argc >= 2)
739         LoadClipboardDataFromFile(__wargv[1]);
740 
741     while (GetMessageW(&msg, 0, 0, 0))
742     {
743         if (!TranslateAcceleratorW(Globals.hMainWnd, hAccel, &msg))
744         {
745             TranslateMessage(&msg);
746             DispatchMessageW(&msg);
747         }
748     }
749 
750     return (int)msg.wParam;
751 }
752