[EXPLORER_NEW]
[reactos.git] / base / shell / explorer-new / trayntfy.cpp
1 /*
2 * ReactOS Explorer
3 *
4 * Copyright 2006 - 2007 Thomas Weidenmueller <w3seek@reactos.org>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include "precomp.h"
22 //#include <docobj.h>
23
24 typedef unsigned short USHORT;
25
26 /*
27 * SysPagerWnd
28 */
29 static const WCHAR szSysPagerWndClass [] = TEXT("SysPager");
30
31 // Data comes from shell32/systray.cpp -> TrayNotifyCDS_Dummy
32 typedef struct _SYS_PAGER_COPY_DATA
33 {
34 DWORD cookie;
35 DWORD notify_code;
36 NOTIFYICONDATA nicon_data;
37 } SYS_PAGER_COPY_DATA, *PSYS_PAGER_COPY_DATA;
38
39 template<typename TItemData>
40 class CToolbar :
41 public CWindowImpl < CToolbar<TItemData>, CWindow, CControlWinTraits>
42 {
43
44 public:
45 int GetItemCount()
46 {
47 return SendMessage(TB_BUTTONCOUNT);
48 }
49
50 DWORD GetButton(int index, TBBUTTON * btn)
51 {
52 return SendMessage(TB_GETBUTTON, index, (LPARAM)btn);
53 }
54
55 DWORD AddButton(TBBUTTON * btn)
56 {
57 return SendMessage(TB_ADDBUTTONS, 1, (LPARAM) btn);
58 }
59
60 DWORD AddButtons(int count, TBBUTTON * buttons)
61 {
62 return SendMessage(TB_ADDBUTTONS, count, (LPARAM) btn);
63 }
64
65 DWORD InsertButton(int insertAt, TBBUTTON * btn)
66 {
67 return SendMessage(TB_INSERTBUTTON, insertAt, (LPARAM) btn);
68 }
69
70 DWORD MoveButton(int oldIndex, int newIndex)
71 {
72 return SendMessage(TB_MOVEBUTTON, oldIndex, newIndex);
73 }
74
75 DWORD DeleteButton(int index)
76 {
77 return SendMessage(TB_DELETEBUTTON, index, 0);
78 }
79
80 DWORD GetButtonInfo(int cmdId, TBBUTTONINFO * info)
81 {
82 return SendMessage(TB_GETBUTTONINFO, cmdId, (LPARAM) info);
83 }
84
85 DWORD SetButtonInfo(int cmdId, TBBUTTONINFO * info)
86 {
87 return SendMessage(TB_SETBUTTONINFO, cmdId, (LPARAM) info);
88 }
89
90 public:
91 DWORD SetButtonSize(int w, int h)
92 {
93 return SendMessage(TB_SETBUTTONSIZE, 0, MAKELONG(w, h));
94 }
95
96 public:
97 DWORD AutoSize()
98 {
99 return SendMessage(TB_AUTOSIZE);
100 }
101
102 public:
103 TItemData * GetItemData(int index)
104 {
105 TBBUTTON btn;
106 GetButton(index, &btn);
107 return (TItemData*) btn.dwData;
108 }
109
110 DWORD SetItemData(int index, TItemData * data)
111 {
112 TBBUTTONINFO info = { 0 };
113 info.cbSize = sizeof(info);
114 info.dwMask = TBIF_BYINDEX | TBIF_LPARAM;
115 info.lParam = (DWORD_PTR) data;
116 return SetButtonInfo(index, &info);
117 }
118 };
119
120 class CNotifyToolbar :
121 public CToolbar<NOTIFYICONDATA>
122 {
123 static const int ICON_SIZE = 16;
124
125 HIMAGELIST SysIcons;
126 int VisibleButtonCount;
127
128 public:
129 CNotifyToolbar() :
130 SysIcons(NULL),
131 VisibleButtonCount(0)
132 {
133 }
134
135 ~CNotifyToolbar()
136 {
137 }
138
139 int GetVisibleItemCount()
140 {
141 return VisibleButtonCount;
142 }
143
144 int FindItemByIconData(IN CONST NOTIFYICONDATA *iconData, NOTIFYICONDATA ** pdata)
145 {
146 int count = GetItemCount();
147
148 for (int i = 0; i < count; i++)
149 {
150 NOTIFYICONDATA * data;
151
152 data = GetItemData(i);
153
154 if (data->hWnd == iconData->hWnd &&
155 data->uID == iconData->uID)
156 {
157 if (pdata)
158 *pdata = data;
159 return i;
160 }
161 }
162
163 return -1;
164 }
165
166 VOID AddButton(IN CONST NOTIFYICONDATA *iconData)
167 {
168 TBBUTTON tbBtn;
169 NOTIFYICONDATA * notifyItem;
170 WCHAR text [] = TEXT("");
171
172 notifyItem = new NOTIFYICONDATA();
173 ZeroMemory(notifyItem, sizeof(*notifyItem));
174
175 notifyItem->hWnd = iconData->hWnd;
176 notifyItem->uID = iconData->uID;
177
178 tbBtn.fsState = TBSTATE_ENABLED;
179 tbBtn.fsStyle = BTNS_NOPREFIX;
180 tbBtn.dwData = (DWORD_PTR)notifyItem;
181 tbBtn.iString = (INT_PTR) text;
182 tbBtn.idCommand = GetItemCount();
183
184 if (iconData->uFlags & NIF_MESSAGE)
185 {
186 notifyItem->uCallbackMessage = iconData->uCallbackMessage;
187 }
188
189 if (iconData->uFlags & NIF_ICON)
190 {
191 tbBtn.iBitmap = ImageList_AddIcon(SysIcons, iconData->hIcon);
192 }
193
194 if (iconData->uFlags & NIF_TIP)
195 {
196 StringCchCopy(notifyItem->szTip, _countof(notifyItem->szTip), iconData->szTip);
197 }
198
199 VisibleButtonCount++;
200 if (iconData->uFlags & NIF_STATE)
201 {
202 notifyItem->dwState &= ~iconData->dwStateMask;
203 notifyItem->dwState |= (iconData->dwState & iconData->dwStateMask);
204 if (notifyItem->dwState & NIS_HIDDEN)
205 {
206 tbBtn.fsState |= TBSTATE_HIDDEN;
207 VisibleButtonCount--;
208 }
209
210 }
211
212 /* TODO: support NIF_INFO, NIF_GUID, NIF_REALTIME, NIF_SHOWTIP */
213
214 CToolbar::AddButton(&tbBtn);
215 SetButtonSize(ICON_SIZE, ICON_SIZE);
216 }
217
218 VOID UpdateButton(IN CONST NOTIFYICONDATA *iconData)
219 {
220 NOTIFYICONDATA * notifyItem;
221 TBBUTTONINFO tbbi = { 0 };
222
223 int index = FindItemByIconData(iconData, &notifyItem);
224 if (index < 0)
225 {
226 AddButton(iconData);
227 return;
228 }
229
230 tbbi.cbSize = sizeof(tbbi);
231 tbbi.dwMask = TBIF_BYINDEX | TBIF_STATE;
232 GetButtonInfo(index, &tbbi);
233
234 tbbi.dwMask = TBIF_BYINDEX | TBIF_COMMAND;
235 tbbi.idCommand = index;
236
237 if (iconData->uFlags & NIF_MESSAGE)
238 {
239 notifyItem->uCallbackMessage = iconData->uCallbackMessage;
240 }
241
242 if (iconData->uFlags & NIF_ICON)
243 {
244 tbbi.dwMask |= TBIF_IMAGE;
245 tbbi.iImage = ImageList_AddIcon(SysIcons, iconData->hIcon);
246 }
247
248 if (iconData->uFlags & NIF_TIP)
249 {
250 StringCchCopy(notifyItem->szTip, _countof(notifyItem->szTip), iconData->szTip);
251 }
252
253 if (iconData->uFlags & NIF_STATE)
254 {
255 if (iconData->dwStateMask & NIS_HIDDEN &&
256 (notifyItem->dwState & NIS_HIDDEN) != (iconData->dwState & NIS_HIDDEN))
257 {
258 tbbi.dwMask |= TBIF_STATE;
259 if (iconData->dwState & NIS_HIDDEN)
260 {
261 if ((tbbi.fsState & TBSTATE_HIDDEN) == 0)
262 {
263 tbbi.fsState |= TBSTATE_HIDDEN;
264 VisibleButtonCount--;
265 }
266 }
267 else
268 {
269 if ((tbbi.fsState & TBSTATE_HIDDEN) != 0)
270 {
271 tbbi.fsState &= ~TBSTATE_HIDDEN;
272 VisibleButtonCount++;
273 }
274 }
275 }
276
277 notifyItem->dwState &= ~iconData->dwStateMask;
278 notifyItem->dwState |= (iconData->dwState & iconData->dwStateMask);
279 }
280
281 /* TODO: support NIF_INFO, NIF_GUID, NIF_REALTIME, NIF_SHOWTIP */
282
283 SetButtonInfo(index, &tbbi);
284 }
285
286 VOID RemoveButton(IN CONST NOTIFYICONDATA *iconData)
287 {
288 NOTIFYICONDATA * notifyItem;
289 TBBUTTONINFO tbbi = { 0 };
290
291 int index = FindItemByIconData(iconData, &notifyItem);
292 if (index < 0)
293 return;
294
295 DeleteButton(index);
296 delete notifyItem;
297 }
298
299 VOID GetTooltip(int index, LPTSTR szTip, DWORD cchTip)
300 {
301 NOTIFYICONDATA * notifyItem;
302 notifyItem = GetItemData(index);
303
304 if (notifyItem)
305 {
306 StringCchCopy(szTip, cchTip, notifyItem->szTip);
307 }
308 }
309
310 private:
311
312 VOID SendMouseEvent(IN WORD wIndex, IN UINT uMsg, IN WPARAM wParam)
313 {
314 static LPCWSTR eventNames [] = {
315 L"WM_MOUSEMOVE",
316 L"WM_LBUTTONDOWN",
317 L"WM_LBUTTONUP",
318 L"WM_LBUTTONDBLCLK",
319 L"WM_RBUTTONDOWN",
320 L"WM_RBUTTONUP",
321 L"WM_RBUTTONDBLCLK",
322 L"WM_MBUTTONDOWN",
323 L"WM_MBUTTONUP",
324 L"WM_MBUTTONDBLCLK",
325 L"WM_MOUSEWHEEL",
326 L"WM_XBUTTONDOWN",
327 L"WM_XBUTTONUP",
328 L"WM_XBUTTONDBLCLK"
329 };
330
331 NOTIFYICONDATA * notifyItem = GetItemData(wIndex);
332
333 if (!::IsWindow(notifyItem->hWnd))
334 return;
335
336 if (uMsg >= WM_MOUSEFIRST && uMsg <= WM_MOUSELAST)
337 {
338 DbgPrint("Sending message %S from button %d to %p (msg=%x, w=%x, l=%x)...\n",
339 eventNames[uMsg - WM_MOUSEFIRST], wIndex,
340 notifyItem->hWnd, notifyItem->uCallbackMessage, notifyItem->uID, uMsg);
341 }
342
343 DWORD pid;
344 GetWindowThreadProcessId(notifyItem->hWnd, &pid);
345
346 if (pid == GetCurrentProcessId() ||
347 (uMsg >= WM_MOUSEFIRST && uMsg <= WM_MOUSELAST))
348 {
349 PostMessage(notifyItem->hWnd,
350 notifyItem->uCallbackMessage,
351 notifyItem->uID,
352 uMsg);
353 }
354 else
355 {
356 SendMessage(notifyItem->hWnd,
357 notifyItem->uCallbackMessage,
358 notifyItem->uID,
359 uMsg);
360 }
361 }
362
363 LRESULT OnMouseEvent(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
364 {
365 POINT pt;
366 INT iBtn;
367
368 pt.x = LOWORD(lParam);
369 pt.y = HIWORD(lParam);
370
371 iBtn = (INT) SendMessageW(TB_HITTEST, 0, (LPARAM) &pt);
372
373 if (iBtn >= 0)
374 {
375 SendMouseEvent(iBtn, uMsg, wParam);
376 }
377
378 bHandled = FALSE;
379 return FALSE;
380 }
381
382 public:
383 BEGIN_MSG_MAP(CNotifyToolbar)
384 MESSAGE_RANGE_HANDLER(WM_MOUSEFIRST, WM_MOUSELAST, OnMouseEvent)
385 END_MSG_MAP()
386
387 void Initialize(HWND hWndParent)
388 {
389 DWORD styles =
390 WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN |
391 TBSTYLE_FLAT | TBSTYLE_TOOLTIPS | TBSTYLE_WRAPABLE | TBSTYLE_TRANSPARENT |
392 CCS_TOP | CCS_NORESIZE | CCS_NOPARENTALIGN | CCS_NODIVIDER;
393 DWORD exStyles = WS_EX_TOOLWINDOW;
394
395 HWND hWndToolbar = CreateWindowEx(exStyles,
396 TOOLBARCLASSNAME,
397 NULL,
398 styles,
399 0,
400 0,
401 0,
402 0,
403 hWndParent,
404 NULL,
405 hExplorerInstance,
406 NULL);
407 if (hWndToolbar != NULL)
408 {
409 SubclassWindow(hWndToolbar);
410
411 SetWindowTheme(hWndToolbar, L"TrayNotify", NULL);
412
413 /* Identify the version we're using */
414 SendMessageW(TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
415
416 SysIcons = ImageList_Create(16, 16, ILC_COLOR32 | ILC_MASK, 0, 1000);
417 SendMessageW(TB_SETIMAGELIST, 0, (LPARAM) SysIcons);
418
419 SetButtonSize(ICON_SIZE, ICON_SIZE);
420 }
421 }
422 };
423
424 class CSysPagerWnd :
425 public CComObjectRootEx<CComMultiThreadModelNoCS>,
426 public CWindowImpl < CSysPagerWnd, CWindow, CControlWinTraits >
427 {
428 CNotifyToolbar * Toolbar;
429
430 public:
431 CSysPagerWnd() :
432 Toolbar(NULL)
433 {
434 }
435 virtual ~CSysPagerWnd() { }
436
437 LRESULT DrawBackground(HDC hdc)
438 {
439 RECT rect;
440
441 GetClientRect(&rect);
442 DrawThemeParentBackground(m_hWnd, hdc, &rect);
443
444 return TRUE;
445 }
446
447 LRESULT OnEraseBackground(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
448 {
449 HDC hdc = (HDC) wParam;
450
451 if (!IsAppThemed())
452 {
453 bHandled = FALSE;
454 return 0;
455 }
456
457 return DrawBackground(hdc);
458 }
459
460 LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
461 {
462 Toolbar = new CNotifyToolbar();
463 Toolbar->Initialize(m_hWnd);
464 return TRUE;
465 }
466
467 LRESULT NotifyMsg(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
468 {
469 PCOPYDATASTRUCT cpData = (PCOPYDATASTRUCT) lParam;
470 if (cpData->dwData == 1)
471 {
472 SYS_PAGER_COPY_DATA * data;
473 NOTIFYICONDATA *iconData;
474 HWND parentHWND;
475 RECT windowRect;
476 parentHWND = GetParent();
477 parentHWND = ::GetParent(parentHWND);
478 ::GetClientRect(parentHWND, &windowRect);
479
480 data = (PSYS_PAGER_COPY_DATA) cpData->lpData;
481 iconData = &data->nicon_data;
482
483 switch (data->notify_code)
484 {
485 case NIM_ADD:
486 {
487 Toolbar->AddButton(iconData);
488 break;
489 }
490 case NIM_MODIFY:
491 {
492 Toolbar->UpdateButton(iconData);
493 break;
494 }
495 case NIM_DELETE:
496 {
497 Toolbar->RemoveButton(iconData);
498 break;
499 }
500 default:
501 TRACE("NotifyMessage received with unknown code %d.\n", data->notify_code);
502 break;
503 }
504 SendMessage(parentHWND,
505 WM_SIZE,
506 0,
507 MAKELONG(windowRect.right - windowRect.left,
508 windowRect.bottom - windowRect.top));
509 }
510
511 return TRUE;
512 }
513
514 void GetSize(IN WPARAM wParam, IN PSIZE size)
515 {
516 INT rows = 0;
517 TBMETRICS tbm;
518 int VisibleButtonCount = Toolbar->GetVisibleItemCount();
519
520 if (wParam) /* horizontal */
521 {
522 rows = size->cy / 24;
523 if (rows == 0)
524 rows++;
525 size->cx = (VisibleButtonCount + rows - 1) / rows * 24;
526 }
527 else
528 {
529 rows = size->cx / 24;
530 if (rows == 0)
531 rows++;
532 size->cy = (VisibleButtonCount + rows - 1) / rows * 24;
533 }
534
535 tbm.cbSize = sizeof(tbm);
536 tbm.dwMask = TBMF_BARPAD | TBMF_BUTTONSPACING;
537 tbm.cxBarPad = tbm.cyBarPad = 0;
538 tbm.cxButtonSpacing = 0;
539 tbm.cyButtonSpacing = 0;
540
541 Toolbar->SendMessageW(TB_SETMETRICS, 0, (LPARAM) &tbm);
542 }
543
544 LRESULT OnGetInfoTip(INT uCode, LPNMHDR hdr, BOOL& bHandled)
545 {
546 NMTBGETINFOTIPW * nmtip = (NMTBGETINFOTIPW *) hdr;
547 Toolbar->GetTooltip(nmtip->iItem, nmtip->pszText, nmtip->cchTextMax);
548 return TRUE;
549 }
550
551 LRESULT OnCustomDraw(INT uCode, LPNMHDR hdr, BOOL& bHandled)
552 {
553 NMCUSTOMDRAW * cdraw = (NMCUSTOMDRAW *) hdr;
554 switch (cdraw->dwDrawStage)
555 {
556 case CDDS_PREPAINT:
557 return CDRF_NOTIFYITEMDRAW;
558
559 case CDDS_ITEMPREPAINT:
560 return TBCDRF_NOBACKGROUND | TBCDRF_NOEDGES | TBCDRF_NOOFFSET | TBCDRF_NOMARK | TBCDRF_NOETCHEDEFFECT;
561 }
562 return TRUE;
563 }
564
565 LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
566 {
567 LRESULT Ret = TRUE;
568 SIZE szClient;
569 szClient.cx = LOWORD(lParam);
570 szClient.cy = HIWORD(lParam);
571
572 Ret = DefWindowProc(uMsg, wParam, lParam);
573
574 if (Toolbar)
575 {
576 Toolbar->SetWindowPos(NULL, 0, 0, szClient.cx, szClient.cy, SWP_NOZORDER);
577
578 Toolbar->AutoSize();
579
580 RECT rc;
581 Toolbar->GetClientRect(&rc);
582
583 SIZE szBar = { rc.right - rc.left, rc.bottom - rc.top };
584
585 INT xOff = (szClient.cx - szBar.cx) / 2;
586 INT yOff = (szClient.cy - szBar.cy) / 2;
587
588 Toolbar->SetWindowPos(NULL, xOff, yOff, szBar.cx, szBar.cy, SWP_NOZORDER);
589 }
590 return Ret;
591 }
592
593 DECLARE_WND_CLASS_EX(szSysPagerWndClass, CS_DBLCLKS, COLOR_3DFACE)
594
595 BEGIN_MSG_MAP(CTaskSwitchWnd)
596 MESSAGE_HANDLER(WM_CREATE, OnCreate)
597 MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
598 MESSAGE_HANDLER(WM_SIZE, OnSize)
599 NOTIFY_CODE_HANDLER(TBN_GETINFOTIPW, OnGetInfoTip)
600 NOTIFY_CODE_HANDLER(NM_CUSTOMDRAW, OnCustomDraw)
601 END_MSG_MAP()
602
603 HWND _Init(IN HWND hWndParent, IN BOOL bVisible)
604 {
605 DWORD dwStyle;
606
607 /* Create the window. The tray window is going to move it to the correct
608 position and resize it as needed. */
609 dwStyle = WS_CHILD | WS_CLIPSIBLINGS;
610 if (bVisible)
611 dwStyle |= WS_VISIBLE;
612
613 Create(hWndParent, 0, NULL, dwStyle);
614
615 if (!m_hWnd)
616 {
617 return NULL;
618 }
619
620 SetWindowTheme(m_hWnd, L"TrayNotify", NULL);
621
622 return m_hWnd;
623 }
624 };
625
626 /*
627 * TrayClockWnd
628 */
629
630 static const WCHAR szTrayClockWndClass [] = TEXT("TrayClockWClass");
631
632 #define ID_TRAYCLOCK_TIMER 0
633 #define ID_TRAYCLOCK_TIMER_INIT 1
634
635 static const struct
636 {
637 BOOL IsTime;
638 DWORD dwFormatFlags;
639 LPCTSTR lpFormat;
640 } ClockWndFormats [] = {
641 { TRUE, 0, NULL },
642 { FALSE, 0, TEXT("dddd") },
643 { FALSE, DATE_SHORTDATE, NULL }
644 };
645
646 #define CLOCKWND_FORMAT_COUNT (sizeof(ClockWndFormats) / sizeof(ClockWndFormats[0]))
647
648 #define TRAY_CLOCK_WND_SPACING_X 0
649 #define TRAY_CLOCK_WND_SPACING_Y 0
650
651 class CTrayClockWnd :
652 public CComObjectRootEx<CComMultiThreadModelNoCS>,
653 public CWindowImpl < CTrayClockWnd, CWindow, CControlWinTraits >
654 {
655 HWND hWndNotify;
656 HFONT hFont;
657 COLORREF textColor;
658 RECT rcText;
659 SYSTEMTIME LocalTime;
660
661 union
662 {
663 DWORD dwFlags;
664 struct
665 {
666 DWORD IsTimerEnabled : 1;
667 DWORD IsInitTimerEnabled : 1;
668 DWORD LinesMeasured : 1;
669 DWORD IsHorizontal : 1;
670 };
671 };
672 DWORD LineSpacing;
673 SIZE CurrentSize;
674 WORD VisibleLines;
675 SIZE LineSizes[CLOCKWND_FORMAT_COUNT];
676 WCHAR szLines[CLOCKWND_FORMAT_COUNT][48];
677
678 public:
679 CTrayClockWnd() :
680 hWndNotify(NULL),
681 hFont(NULL),
682 dwFlags(0),
683 LineSpacing(0),
684 VisibleLines(0)
685 {
686 ZeroMemory(&textColor, sizeof(textColor));
687 ZeroMemory(&rcText, sizeof(rcText));
688 ZeroMemory(&LocalTime, sizeof(LocalTime));
689 ZeroMemory(&CurrentSize, sizeof(CurrentSize));
690 ZeroMemory(LineSizes, sizeof(LineSizes));
691 ZeroMemory(szLines, sizeof(LineSizes));
692 }
693 virtual ~CTrayClockWnd() { }
694
695 LRESULT OnThemeChanged()
696 {
697 LOGFONTW clockFont;
698 HTHEME clockTheme;
699 HFONT hFont;
700
701 clockTheme = OpenThemeData(m_hWnd, L"Clock");
702
703 if (clockTheme)
704 {
705 GetThemeFont(clockTheme,
706 NULL,
707 CLP_TIME,
708 0,
709 TMT_FONT,
710 &clockFont);
711
712 hFont = CreateFontIndirectW(&clockFont);
713
714 GetThemeColor(clockTheme,
715 CLP_TIME,
716 0,
717 TMT_TEXTCOLOR,
718 &textColor);
719 }
720 else
721 {
722 NONCLIENTMETRICS ncm = { 0 };
723 ncm.cbSize = sizeof(ncm);
724 SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, FALSE);
725
726 hFont = CreateFontIndirectW(&ncm.lfMessageFont);
727
728 textColor = RGB(0, 0, 0);
729 }
730
731 SetFont(hFont, FALSE);
732
733 CloseThemeData(clockTheme);
734
735 return TRUE;
736 }
737
738 LRESULT OnThemeChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
739 {
740 return OnThemeChanged();
741 }
742
743 BOOL MeasureLines()
744 {
745 HDC hDC;
746 HFONT hPrevFont;
747 INT c, i;
748 BOOL bRet = TRUE;
749
750 hDC = GetDC(m_hWnd);
751 if (hDC != NULL)
752 {
753 if (hFont)
754 hPrevFont = (HFONT) SelectObject(hDC, hFont);
755
756 for (i = 0; i != CLOCKWND_FORMAT_COUNT && bRet; i++)
757 {
758 if (szLines[i][0] != TEXT('\0') &&
759 !GetTextExtentPoint(hDC, szLines[i], _tcslen(szLines[i]),
760 &LineSizes[i]))
761 {
762 bRet = FALSE;
763 break;
764 }
765 }
766
767 if (hFont)
768 SelectObject(hDC, hPrevFont);
769
770 ReleaseDC(m_hWnd, hDC);
771
772 if (bRet)
773 {
774 LineSpacing = 0;
775
776 /* calculate the line spacing */
777 for (i = 0, c = 0; i != CLOCKWND_FORMAT_COUNT; i++)
778 {
779 if (LineSizes[i].cx > 0)
780 {
781 LineSpacing += LineSizes[i].cy;
782 c++;
783 }
784 }
785
786 if (c > 0)
787 {
788 /* We want a spaceing of 1/2 line */
789 LineSpacing = (LineSpacing / c) / 2;
790 }
791
792 return TRUE;
793 }
794 }
795
796 return FALSE;
797 }
798
799 WORD GetMinimumSize(IN BOOL Horizontal, IN OUT PSIZE pSize)
800 {
801 WORD iLinesVisible = 0;
802 INT i;
803 SIZE szMax = { 0, 0 };
804
805 if (!LinesMeasured)
806 LinesMeasured = MeasureLines();
807
808 if (!LinesMeasured)
809 return 0;
810
811 for (i = 0;
812 i != CLOCKWND_FORMAT_COUNT;
813 i++)
814 {
815 if (LineSizes[i].cx != 0)
816 {
817 if (iLinesVisible > 0)
818 {
819 if (Horizontal)
820 {
821 if (szMax.cy + LineSizes[i].cy + (LONG) LineSpacing >
822 pSize->cy - (2 * TRAY_CLOCK_WND_SPACING_Y))
823 {
824 break;
825 }
826 }
827 else
828 {
829 if (LineSizes[i].cx > pSize->cx - (2 * TRAY_CLOCK_WND_SPACING_X))
830 break;
831 }
832
833 /* Add line spacing */
834 szMax.cy += LineSpacing;
835 }
836
837 iLinesVisible++;
838
839 /* Increase maximum rectangle */
840 szMax.cy += LineSizes[i].cy;
841 if (LineSizes[i].cx > szMax.cx - (2 * TRAY_CLOCK_WND_SPACING_X))
842 szMax.cx = LineSizes[i].cx + (2 * TRAY_CLOCK_WND_SPACING_X);
843 }
844 }
845
846 szMax.cx += 2 * TRAY_CLOCK_WND_SPACING_X;
847 szMax.cy += 2 * TRAY_CLOCK_WND_SPACING_Y;
848
849 *pSize = szMax;
850
851 return iLinesVisible;
852 }
853
854
855 VOID UpdateWnd()
856 {
857 SIZE szPrevCurrent;
858 INT BufSize, iRet, i;
859 RECT rcClient;
860
861 ZeroMemory(LineSizes,
862 sizeof(LineSizes));
863
864 szPrevCurrent = CurrentSize;
865
866 for (i = 0;
867 i != CLOCKWND_FORMAT_COUNT;
868 i++)
869 {
870 szLines[i][0] = TEXT('\0');
871 BufSize = sizeof(szLines[0]) / sizeof(szLines[0][0]);
872
873 if (ClockWndFormats[i].IsTime)
874 {
875 iRet = GetTimeFormat(LOCALE_USER_DEFAULT,
876 AdvancedSettings.bShowSeconds ? ClockWndFormats[i].dwFormatFlags : TIME_NOSECONDS,
877 &LocalTime,
878 ClockWndFormats[i].lpFormat,
879 szLines[i],
880 BufSize);
881 }
882 else
883 {
884 iRet = GetDateFormat(LOCALE_USER_DEFAULT,
885 ClockWndFormats[i].dwFormatFlags,
886 &LocalTime,
887 ClockWndFormats[i].lpFormat,
888 szLines[i],
889 BufSize);
890 }
891
892 if (iRet != 0 && i == 0)
893 {
894 /* Set the window text to the time only */
895 SetWindowText(szLines[i]);
896 }
897 }
898
899 LinesMeasured = MeasureLines();
900
901 if (LinesMeasured &&
902 GetClientRect(&rcClient))
903 {
904 SIZE szWnd;
905
906 szWnd.cx = rcClient.right;
907 szWnd.cy = rcClient.bottom;
908
909 VisibleLines = GetMinimumSize(IsHorizontal, &szWnd);
910 CurrentSize = szWnd;
911 }
912
913 if (IsWindowVisible(m_hWnd))
914 {
915 InvalidateRect(NULL, TRUE);
916
917 if (hWndNotify != NULL &&
918 (szPrevCurrent.cx != CurrentSize.cx ||
919 szPrevCurrent.cy != CurrentSize.cy))
920 {
921 NMHDR nmh;
922
923 nmh.hwndFrom = m_hWnd;
924 nmh.idFrom = GetWindowLongPtr(m_hWnd, GWLP_ID);
925 nmh.code = NTNWM_REALIGN;
926
927 SendMessage(hWndNotify,
928 WM_NOTIFY,
929 (WPARAM) nmh.idFrom,
930 (LPARAM) &nmh);
931 }
932 }
933 }
934
935 VOID Update()
936 {
937 GetLocalTime(&LocalTime);
938 UpdateWnd();
939 }
940
941 UINT CalculateDueTime()
942 {
943 UINT uiDueTime;
944
945 /* Calculate the due time */
946 GetLocalTime(&LocalTime);
947 uiDueTime = 1000 - (UINT) LocalTime.wMilliseconds;
948 if (AdvancedSettings.bShowSeconds)
949 uiDueTime += (UINT) LocalTime.wSecond * 100;
950 else
951 uiDueTime += (59 - (UINT) LocalTime.wSecond) * 1000;
952
953 if (uiDueTime < USER_TIMER_MINIMUM || uiDueTime > USER_TIMER_MAXIMUM)
954 uiDueTime = 1000;
955 else
956 {
957 /* Add an artificial delay of 0.05 seconds to make sure the timer
958 doesn't fire too early*/
959 uiDueTime += 50;
960 }
961
962 return uiDueTime;
963 }
964
965 BOOL ResetTime()
966 {
967 UINT uiDueTime;
968 BOOL Ret;
969
970 /* Disable all timers */
971 if (IsTimerEnabled)
972 {
973 KillTimer(ID_TRAYCLOCK_TIMER);
974 IsTimerEnabled = FALSE;
975 }
976
977 if (IsInitTimerEnabled)
978 {
979 KillTimer(ID_TRAYCLOCK_TIMER_INIT);
980 }
981
982 uiDueTime = CalculateDueTime();
983
984 /* Set the new timer */
985 Ret = SetTimer(ID_TRAYCLOCK_TIMER_INIT, uiDueTime, NULL) != 0;
986 IsInitTimerEnabled = Ret;
987
988 /* Update the time */
989 Update();
990
991 return Ret;
992 }
993
994 VOID CalibrateTimer()
995 {
996 UINT uiDueTime;
997 BOOL Ret;
998 UINT uiWait1, uiWait2;
999
1000 /* Kill the initialization timer */
1001 KillTimer(ID_TRAYCLOCK_TIMER_INIT);
1002 IsInitTimerEnabled = FALSE;
1003
1004 uiDueTime = CalculateDueTime();
1005
1006 if (AdvancedSettings.bShowSeconds)
1007 {
1008 uiWait1 = 1000 - 200;
1009 uiWait2 = 1000;
1010 }
1011 else
1012 {
1013 uiWait1 = 60 * 1000 - 200;
1014 uiWait2 = 60 * 1000;
1015 }
1016
1017 if (uiDueTime > uiWait1)
1018 {
1019 /* The update of the clock will be up to 200 ms late, but that's
1020 acceptable. We're going to setup a timer that fires depending
1021 uiWait2. */
1022 Ret = SetTimer(ID_TRAYCLOCK_TIMER, uiWait2, NULL) != 0;
1023 IsTimerEnabled = Ret;
1024
1025 /* Update the time */
1026 Update();
1027 }
1028 else
1029 {
1030 /* Recalibrate the timer and recalculate again when the current
1031 minute/second ends. */
1032 ResetTime();
1033 }
1034 }
1035
1036 LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1037 {
1038 /* Disable all timers */
1039 if (IsTimerEnabled)
1040 {
1041 KillTimer(ID_TRAYCLOCK_TIMER);
1042 }
1043
1044 if (IsInitTimerEnabled)
1045 {
1046 KillTimer(ID_TRAYCLOCK_TIMER_INIT);
1047 }
1048
1049 return TRUE;
1050 }
1051
1052 LRESULT OnPaint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1053 {
1054 RECT rcClient;
1055 HFONT hPrevFont;
1056 int iPrevBkMode, i, line;
1057
1058 PAINTSTRUCT ps;
1059 HDC hDC = (HDC) wParam;
1060
1061 if (wParam == 0)
1062 {
1063 hDC = BeginPaint(&ps);
1064 }
1065
1066 if (hDC == NULL)
1067 return FALSE;
1068
1069 if (LinesMeasured &&
1070 GetClientRect(&rcClient))
1071 {
1072 iPrevBkMode = SetBkMode(hDC, TRANSPARENT);
1073
1074 SetTextColor(hDC, textColor);
1075
1076 hPrevFont = (HFONT) SelectObject(hDC, hFont);
1077
1078 rcClient.left = (rcClient.right / 2) - (CurrentSize.cx / 2);
1079 rcClient.top = (rcClient.bottom / 2) - (CurrentSize.cy / 2);
1080 rcClient.right = rcClient.left + CurrentSize.cx;
1081 rcClient.bottom = rcClient.top + CurrentSize.cy;
1082
1083 for (i = 0, line = 0;
1084 i != CLOCKWND_FORMAT_COUNT && line < VisibleLines;
1085 i++)
1086 {
1087 if (LineSizes[i].cx != 0)
1088 {
1089 TextOut(hDC,
1090 rcClient.left + (CurrentSize.cx / 2) - (LineSizes[i].cx / 2) +
1091 TRAY_CLOCK_WND_SPACING_X,
1092 rcClient.top + TRAY_CLOCK_WND_SPACING_Y,
1093 szLines[i],
1094 _tcslen(szLines[i]));
1095
1096 rcClient.top += LineSizes[i].cy + LineSpacing;
1097 line++;
1098 }
1099 }
1100
1101 SelectObject(hDC, hPrevFont);
1102
1103 SetBkMode(hDC, iPrevBkMode);
1104 }
1105
1106 if (wParam == 0)
1107 {
1108 EndPaint(&ps);
1109 }
1110
1111 return TRUE;
1112 }
1113
1114 VOID SetFont(IN HFONT hNewFont, IN BOOL bRedraw)
1115 {
1116 hFont = hNewFont;
1117 LinesMeasured = MeasureLines();
1118 if (bRedraw)
1119 {
1120 InvalidateRect(NULL, TRUE);
1121 }
1122 }
1123
1124 LRESULT DrawBackground(HDC hdc)
1125 {
1126 RECT rect;
1127
1128 GetClientRect(&rect);
1129 DrawThemeParentBackground(m_hWnd, hdc, &rect);
1130
1131 return TRUE;
1132 }
1133
1134 LRESULT OnEraseBackground(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1135 {
1136 HDC hdc = (HDC) wParam;
1137
1138 if (!IsAppThemed())
1139 {
1140 bHandled = FALSE;
1141 return 0;
1142 }
1143
1144 return DrawBackground(hdc);
1145 }
1146
1147 LRESULT OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1148 {
1149 switch (wParam)
1150 {
1151 case ID_TRAYCLOCK_TIMER:
1152 Update();
1153 break;
1154
1155 case ID_TRAYCLOCK_TIMER_INIT:
1156 CalibrateTimer();
1157 break;
1158 }
1159 return TRUE;
1160 }
1161
1162 LRESULT OnGetMinimumSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1163 {
1164 IsHorizontal = (BOOL) wParam;
1165
1166 return (LRESULT) GetMinimumSize((BOOL) wParam, (PSIZE) lParam) != 0;
1167 }
1168
1169 LRESULT OnUpdateTime(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1170 {
1171 return (LRESULT) ResetTime();
1172 }
1173
1174 LRESULT OnNcHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1175 {
1176 return HTTRANSPARENT;
1177 }
1178
1179 LRESULT OnSetFont(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1180 {
1181 SetFont((HFONT) wParam, (BOOL) LOWORD(lParam));
1182 return TRUE;
1183 }
1184
1185 LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1186 {
1187 ResetTime();
1188 return TRUE;
1189 }
1190
1191 LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1192 {
1193 SIZE szClient;
1194
1195 szClient.cx = LOWORD(lParam);
1196 szClient.cy = HIWORD(lParam);
1197
1198 VisibleLines = GetMinimumSize(IsHorizontal, &szClient);
1199 CurrentSize = szClient;
1200
1201 InvalidateRect(NULL, TRUE);
1202 return TRUE;
1203 }
1204
1205 DECLARE_WND_CLASS_EX(szTrayClockWndClass, CS_DBLCLKS, COLOR_3DFACE)
1206
1207 BEGIN_MSG_MAP(CTaskSwitchWnd)
1208 MESSAGE_HANDLER(WM_CREATE, OnCreate)
1209 MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
1210 MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
1211 MESSAGE_HANDLER(WM_SIZE, OnSize)
1212 MESSAGE_HANDLER(WM_PAINT, OnPaint)
1213 MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)
1214 MESSAGE_HANDLER(WM_TIMER, OnTimer)
1215 MESSAGE_HANDLER(WM_NCHITTEST, OnNcHitTest)
1216 MESSAGE_HANDLER(TCWM_GETMINIMUMSIZE, OnGetMinimumSize)
1217 MESSAGE_HANDLER(TCWM_UPDATETIME, OnUpdateTime)
1218
1219 END_MSG_MAP()
1220
1221 HWND _Init(IN HWND hWndParent, IN BOOL bVisible)
1222 {
1223 IsHorizontal = TRUE;
1224
1225 hWndNotify = hWndParent;
1226
1227 /* Create the window. The tray window is going to move it to the correct
1228 position and resize it as needed. */
1229 DWORD dwStyle = WS_CHILD | WS_CLIPSIBLINGS;
1230 if (bVisible)
1231 dwStyle |= WS_VISIBLE;
1232
1233 Create(hWndParent, 0, NULL, dwStyle);
1234
1235 if (m_hWnd != NULL)
1236 {
1237 SetWindowTheme(m_hWnd, L"TrayNotify", NULL);
1238 OnThemeChanged();
1239 }
1240
1241 return m_hWnd;
1242
1243 }
1244 };
1245
1246 /*
1247 * TrayNotifyWnd
1248 */
1249
1250 static const WCHAR szTrayNotifyWndClass [] = TEXT("TrayNotifyWnd");
1251
1252 #define TRAY_NOTIFY_WND_SPACING_X 2
1253 #define TRAY_NOTIFY_WND_SPACING_Y 2
1254
1255 class CTrayNotifyWnd :
1256 public CComObjectRootEx<CComMultiThreadModelNoCS>,
1257 public CWindowImpl < CTrayNotifyWnd, CWindow, CControlWinTraits >
1258 {
1259 HWND hWndNotify;
1260
1261 CSysPagerWnd * m_pager;
1262 CTrayClockWnd * m_clock;
1263
1264 CComPtr<ITrayWindow> TrayWindow;
1265
1266 HTHEME TrayTheme;
1267 SIZE szTrayClockMin;
1268 SIZE szTrayNotify;
1269 MARGINS ContentMargin;
1270 HFONT hFontClock;
1271 union
1272 {
1273 DWORD dwFlags;
1274 struct
1275 {
1276 DWORD HideClock : 1;
1277 DWORD IsHorizontal : 1;
1278 };
1279 };
1280
1281 public:
1282 CTrayNotifyWnd() :
1283 hWndNotify(NULL),
1284 m_pager(NULL),
1285 m_clock(NULL),
1286 TrayTheme(NULL),
1287 hFontClock(NULL),
1288 dwFlags(0)
1289 {
1290 ZeroMemory(&szTrayClockMin, sizeof(szTrayClockMin));
1291 ZeroMemory(&szTrayNotify, sizeof(szTrayNotify));
1292 ZeroMemory(&ContentMargin, sizeof(ContentMargin));
1293 }
1294 virtual ~CTrayNotifyWnd() { }
1295
1296 LRESULT OnThemeChanged()
1297 {
1298 if (TrayTheme)
1299 CloseThemeData(TrayTheme);
1300
1301 if (IsThemeActive())
1302 TrayTheme = OpenThemeData(m_hWnd, L"TrayNotify");
1303 else
1304 TrayTheme = NULL;
1305
1306 if (TrayTheme)
1307 {
1308 SetWindowExStyle(m_hWnd, WS_EX_STATICEDGE, 0);
1309
1310 GetThemeMargins(TrayTheme,
1311 NULL,
1312 TNP_BACKGROUND,
1313 0,
1314 TMT_CONTENTMARGINS,
1315 NULL,
1316 &ContentMargin);
1317 }
1318 else
1319 {
1320 SetWindowExStyle(m_hWnd, WS_EX_STATICEDGE, WS_EX_STATICEDGE);
1321
1322 ContentMargin.cxLeftWidth = 0;
1323 ContentMargin.cxRightWidth = 0;
1324 ContentMargin.cyTopHeight = 0;
1325 ContentMargin.cyBottomHeight = 0;
1326 }
1327
1328 return TRUE;
1329 }
1330
1331 LRESULT OnThemeChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1332 {
1333 return OnThemeChanged();
1334 }
1335
1336 LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1337 {
1338 m_clock = new CTrayClockWnd();
1339 m_clock->_Init(m_hWnd, !HideClock);
1340
1341 m_pager = new CSysPagerWnd();
1342 m_pager->_Init(m_hWnd, !HideClock);
1343
1344 OnThemeChanged();
1345
1346 return TRUE;
1347 }
1348
1349 BOOL GetMinimumSize(IN BOOL Horizontal, IN OUT PSIZE pSize)
1350 {
1351 SIZE szClock = { 0, 0 };
1352 SIZE szTray = { 0, 0 };
1353
1354 IsHorizontal = Horizontal;
1355 if (IsHorizontal)
1356 SetWindowTheme(m_hWnd, L"TrayNotifyHoriz", NULL);
1357 else
1358 SetWindowTheme(m_hWnd, L"TrayNotifyVert", NULL);
1359
1360 if (!HideClock)
1361 {
1362 if (Horizontal)
1363 {
1364 szClock.cy = pSize->cy - 2 * TRAY_NOTIFY_WND_SPACING_Y;
1365 if (szClock.cy <= 0)
1366 goto NoClock;
1367 }
1368 else
1369 {
1370 szClock.cx = pSize->cx - 2 * TRAY_NOTIFY_WND_SPACING_X;
1371 if (szClock.cx <= 0)
1372 goto NoClock;
1373 }
1374
1375 m_clock->SendMessage(TCWM_GETMINIMUMSIZE, (WPARAM) Horizontal, (LPARAM) &szClock);
1376
1377 szTrayClockMin = szClock;
1378 }
1379 else
1380 NoClock:
1381 szTrayClockMin = szClock;
1382
1383 if (Horizontal)
1384 {
1385 szTray.cy = pSize->cy - 2 * TRAY_NOTIFY_WND_SPACING_Y;
1386 }
1387 else
1388 {
1389 szTray.cx = pSize->cx - 2 * TRAY_NOTIFY_WND_SPACING_X;
1390 }
1391
1392 m_pager->GetSize(Horizontal, &szTray);
1393
1394 szTrayNotify = szTray;
1395
1396 if (Horizontal)
1397 {
1398 pSize->cx = 2 * TRAY_NOTIFY_WND_SPACING_X;
1399
1400 if (!HideClock)
1401 pSize->cx += TRAY_NOTIFY_WND_SPACING_X + szTrayClockMin.cx;
1402
1403 pSize->cx += szTray.cx;
1404 }
1405 else
1406 {
1407 pSize->cy = 2 * TRAY_NOTIFY_WND_SPACING_Y;
1408
1409 if (!HideClock)
1410 pSize->cy += TRAY_NOTIFY_WND_SPACING_Y + szTrayClockMin.cy;
1411
1412 pSize->cy += szTray.cy;
1413 }
1414
1415 pSize->cy += ContentMargin.cyTopHeight + ContentMargin.cyBottomHeight;
1416 pSize->cx += ContentMargin.cxLeftWidth + ContentMargin.cxRightWidth;
1417
1418 return TRUE;
1419 }
1420
1421 VOID Size(IN const SIZE *pszClient)
1422 {
1423 if (!HideClock)
1424 {
1425 POINT ptClock;
1426 SIZE szClock;
1427
1428 if (IsHorizontal)
1429 {
1430 ptClock.x = pszClient->cx - TRAY_NOTIFY_WND_SPACING_X - szTrayClockMin.cx;
1431 ptClock.y = TRAY_NOTIFY_WND_SPACING_Y;
1432 szClock.cx = szTrayClockMin.cx;
1433 szClock.cy = pszClient->cy - (2 * TRAY_NOTIFY_WND_SPACING_Y);
1434 }
1435 else
1436 {
1437 ptClock.x = TRAY_NOTIFY_WND_SPACING_X;
1438 ptClock.y = pszClient->cy - TRAY_NOTIFY_WND_SPACING_Y - szTrayClockMin.cy;
1439 szClock.cx = pszClient->cx - (2 * TRAY_NOTIFY_WND_SPACING_X);
1440 szClock.cy = szTrayClockMin.cy;
1441 }
1442
1443 m_clock->SetWindowPos(
1444 NULL,
1445 ptClock.x,
1446 ptClock.y,
1447 szClock.cx,
1448 szClock.cy,
1449 SWP_NOZORDER);
1450
1451 if (IsHorizontal)
1452 {
1453 ptClock.x -= szTrayNotify.cx;
1454 }
1455 else
1456 {
1457 ptClock.y -= szTrayNotify.cy;
1458 }
1459
1460 m_pager->SetWindowPos(
1461 NULL,
1462 ptClock.x,
1463 ptClock.y,
1464 szTrayNotify.cx,
1465 szTrayNotify.cy,
1466 SWP_NOZORDER);
1467 }
1468 }
1469
1470 LRESULT DrawBackground(HDC hdc)
1471 {
1472 RECT rect;
1473
1474 GetClientRect(&rect);
1475
1476 if (TrayTheme)
1477 {
1478 if (IsThemeBackgroundPartiallyTransparent(TrayTheme, TNP_BACKGROUND, 0))
1479 {
1480 DrawThemeParentBackground(m_hWnd, hdc, &rect);
1481 }
1482
1483 DrawThemeBackground(TrayTheme, hdc, TNP_BACKGROUND, 0, &rect, 0);
1484 }
1485
1486 return TRUE;
1487 }
1488
1489 LRESULT OnEraseBackground(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1490 {
1491 HDC hdc = (HDC) wParam;
1492
1493 if (!TrayTheme)
1494 {
1495 bHandled = FALSE;
1496 return 0;
1497 }
1498
1499 return DrawBackground(hdc);
1500 }
1501
1502 LRESULT NotifyMsg(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1503 {
1504 if (m_pager)
1505 {
1506 m_pager->NotifyMsg(uMsg, wParam, lParam, bHandled);
1507 }
1508
1509 return TRUE;
1510 }
1511
1512 BOOL GetClockRect(OUT PRECT rcClock)
1513 {
1514 if (!IsWindowVisible(m_clock->m_hWnd))
1515 return FALSE;
1516
1517 return GetWindowRect(m_clock->m_hWnd, rcClock);
1518 }
1519
1520 LRESULT OnGetMinimumSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1521 {
1522 return (LRESULT) GetMinimumSize((BOOL) wParam, (PSIZE) lParam);
1523 }
1524
1525 LRESULT OnUpdateTime(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1526 {
1527 if (m_clock != NULL)
1528 {
1529 /* Forward the message to the tray clock window procedure */
1530 return m_clock->OnUpdateTime(uMsg, wParam, lParam, bHandled);
1531 }
1532 return FALSE;
1533 }
1534
1535 LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1536 {
1537 SIZE szClient;
1538
1539 szClient.cx = LOWORD(lParam);
1540 szClient.cy = HIWORD(lParam);
1541
1542 Size(&szClient);
1543
1544 return TRUE;
1545 }
1546
1547 LRESULT OnNcHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1548 {
1549 return HTTRANSPARENT;
1550 }
1551
1552 LRESULT OnShowClock(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1553 {
1554 BOOL PrevHidden = HideClock;
1555 HideClock = (wParam == 0);
1556
1557 if (m_clock != NULL && PrevHidden != HideClock)
1558 {
1559 m_clock->ShowWindow(HideClock ? SW_HIDE : SW_SHOW);
1560 }
1561
1562 return (LRESULT) (!PrevHidden);
1563 }
1564
1565 LRESULT OnNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1566 {
1567 const NMHDR *nmh = (const NMHDR *) lParam;
1568
1569 if (nmh->hwndFrom == m_clock->m_hWnd)
1570 {
1571 /* Pass down notifications */
1572 return m_clock->SendMessage(WM_NOTIFY, wParam, lParam);
1573 }
1574
1575 return FALSE;
1576 }
1577
1578 LRESULT OnSetFont(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1579 {
1580 if (m_clock != NULL)
1581 {
1582 m_clock->SendMessageW(WM_SETFONT, wParam, lParam);
1583 }
1584
1585 bHandled = FALSE;
1586 return FALSE;
1587 }
1588
1589 DECLARE_WND_CLASS_EX(szTrayNotifyWndClass, CS_DBLCLKS, COLOR_3DFACE)
1590
1591 BEGIN_MSG_MAP(CTaskSwitchWnd)
1592 MESSAGE_HANDLER(WM_CREATE, OnCreate)
1593 MESSAGE_HANDLER(WM_THEMECHANGED, OnThemeChanged)
1594 MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
1595 MESSAGE_HANDLER(WM_SIZE, OnSize)
1596 MESSAGE_HANDLER(WM_NCHITTEST, OnNcHitTest)
1597 MESSAGE_HANDLER(WM_NOTIFY, OnNotify)
1598 MESSAGE_HANDLER(WM_SETFONT, OnSetFont)
1599 MESSAGE_HANDLER(TNWM_GETMINIMUMSIZE, OnGetMinimumSize)
1600 MESSAGE_HANDLER(TNWM_UPDATETIME, OnUpdateTime)
1601 MESSAGE_HANDLER(TNWM_SHOWCLOCK, OnShowClock)
1602 END_MSG_MAP()
1603
1604 HWND _Init(IN OUT ITrayWindow *TrayWindow, IN BOOL bHideClock)
1605 {
1606 HWND hWndTrayWindow;
1607
1608 hWndTrayWindow = TrayWindow->GetHWND();
1609 if (hWndTrayWindow == NULL)
1610 return NULL;
1611
1612 this->TrayWindow = TrayWindow;
1613 this->HideClock = bHideClock;
1614 this->hWndNotify = hWndTrayWindow;
1615
1616 DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
1617 return Create(hWndTrayWindow, 0, NULL, dwStyle, WS_EX_STATICEDGE);
1618 }
1619 };
1620
1621 static CTrayNotifyWnd * g_Instance;
1622
1623 HWND CreateTrayNotifyWnd(IN OUT ITrayWindow *Tray, BOOL bHideClock)
1624 {
1625 // TODO: Destroy after the window is destroyed
1626 g_Instance = new CTrayNotifyWnd();
1627
1628 return g_Instance->_Init(Tray, bHideClock);
1629 }
1630
1631 VOID
1632 TrayNotify_NotifyMsg(WPARAM wParam, LPARAM lParam)
1633 {
1634 BOOL bDummy;
1635 g_Instance->NotifyMsg(0, wParam, lParam, bDummy);
1636 }
1637
1638 BOOL
1639 TrayNotify_GetClockRect(OUT PRECT rcClock)
1640 {
1641 return g_Instance->GetClockRect(rcClock);
1642 }