[EXPLORER] Fix a Clang-Cl warning about Icon->ProcessId
[reactos.git] / base / shell / explorer / syspager.cpp
1 /*
2 * ReactOS Explorer
3 *
4 * Copyright 2006 - 2007 Thomas Weidenmueller <w3seek@reactos.org>
5 * Copyright 2018 Ged Murphy <gedmurphy@reactos.org>
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include "precomp.h"
23
24 struct InternalIconData : NOTIFYICONDATA
25 {
26 // Must keep a separate copy since the original is unioned with uTimeout.
27 UINT uVersionCopy;
28 };
29
30 struct IconWatcherData
31 {
32 HANDLE hProcess;
33 DWORD ProcessId;
34 NOTIFYICONDATA IconData;
35
36 IconWatcherData(CONST NOTIFYICONDATA *iconData) :
37 hProcess(NULL), ProcessId(0)
38 {
39 IconData.cbSize = sizeof(NOTIFYICONDATA);
40 IconData.hWnd = iconData->hWnd;
41 IconData.uID = iconData->uID;
42 IconData.guidItem = iconData->guidItem;
43 }
44
45 ~IconWatcherData()
46 {
47 if (hProcess)
48 {
49 CloseHandle(hProcess);
50 }
51 }
52 };
53
54 class CIconWatcher
55 {
56 CAtlList<IconWatcherData *> m_WatcherList;
57 CRITICAL_SECTION m_ListLock;
58 HANDLE m_hWatcherThread;
59 HANDLE m_WakeUpEvent;
60 HWND m_hwndSysTray;
61 bool m_Loop;
62
63 public:
64 CIconWatcher();
65
66 virtual ~CIconWatcher();
67
68 bool Initialize(_In_ HWND hWndParent);
69 void Uninitialize();
70
71 bool AddIconToWatcher(_In_ CONST NOTIFYICONDATA *iconData);
72 bool RemoveIconFromWatcher(_In_ CONST NOTIFYICONDATA *iconData);
73
74 IconWatcherData* GetListEntry(_In_opt_ CONST NOTIFYICONDATA *iconData, _In_opt_ HANDLE hProcess, _In_ bool Remove);
75
76 private:
77
78 static UINT WINAPI WatcherThread(_In_opt_ LPVOID lpParam);
79 };
80
81 class CNotifyToolbar;
82
83 class CBalloonQueue
84 {
85 public:
86 static const int TimerInterval = 2000;
87 static const int BalloonsTimerId = 1;
88 static const int MinTimeout = 10000;
89 static const int MaxTimeout = 30000;
90 static const int CooldownBetweenBalloons = 2000;
91
92 private:
93 struct Info
94 {
95 InternalIconData * pSource;
96 WCHAR szInfo[256];
97 WCHAR szInfoTitle[64];
98 WPARAM uIcon;
99 UINT uTimeout;
100
101 Info(InternalIconData * source)
102 {
103 pSource = source;
104 StringCchCopy(szInfo, _countof(szInfo), source->szInfo);
105 StringCchCopy(szInfoTitle, _countof(szInfoTitle), source->szInfoTitle);
106 uIcon = source->dwInfoFlags & NIIF_ICON_MASK;
107 if (source->dwInfoFlags == NIIF_USER)
108 uIcon = reinterpret_cast<WPARAM>(source->hIcon);
109 uTimeout = source->uTimeout;
110 }
111 };
112
113 HWND m_hwndParent;
114
115 CTooltips * m_tooltips;
116
117 CAtlList<Info> m_queue;
118
119 CNotifyToolbar * m_toolbar;
120
121 InternalIconData * m_current;
122 bool m_currentClosed;
123
124 int m_timer;
125
126 public:
127 CBalloonQueue();
128
129 void Init(HWND hwndParent, CNotifyToolbar * toolbar, CTooltips * balloons);
130 void Deinit();
131
132 bool OnTimer(int timerId);
133 void UpdateInfo(InternalIconData * notifyItem);
134 void RemoveInfo(InternalIconData * notifyItem);
135 void CloseCurrent();
136
137 private:
138
139 int IndexOf(InternalIconData * pdata);
140 void SetTimer(int length);
141 void Show(Info& info);
142 void Close(IN OUT InternalIconData * notifyItem, IN UINT uReason);
143 };
144
145 class CNotifyToolbar :
146 public CWindowImplBaseT< CToolbar<InternalIconData>, CControlWinTraits >
147 {
148 HIMAGELIST m_ImageList;
149 int m_VisibleButtonCount;
150
151 CBalloonQueue * m_BalloonQueue;
152
153 public:
154 CNotifyToolbar();
155 virtual ~CNotifyToolbar();
156
157 int GetVisibleButtonCount();
158 int FindItem(IN HWND hWnd, IN UINT uID, InternalIconData ** pdata);
159 int FindExistingSharedIcon(HICON handle);
160 BOOL AddButton(IN CONST NOTIFYICONDATA *iconData);
161 BOOL SwitchVersion(IN CONST NOTIFYICONDATA *iconData);
162 BOOL UpdateButton(IN CONST NOTIFYICONDATA *iconData);
163 BOOL RemoveButton(IN CONST NOTIFYICONDATA *iconData);
164 VOID ResizeImagelist();
165 bool SendNotifyCallback(InternalIconData* notifyItem, UINT uMsg);
166
167 private:
168 VOID SendMouseEvent(IN WORD wIndex, IN UINT uMsg, IN WPARAM wParam);
169 LRESULT OnMouseEvent(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
170 LRESULT OnTooltipShow(INT uCode, LPNMHDR hdr, BOOL& bHandled);
171
172 public:
173 BEGIN_MSG_MAP(CNotifyToolbar)
174 MESSAGE_RANGE_HANDLER(WM_MOUSEFIRST, WM_MOUSELAST, OnMouseEvent)
175 NOTIFY_CODE_HANDLER(TTN_SHOW, OnTooltipShow)
176 END_MSG_MAP()
177
178 void Initialize(HWND hWndParent, CBalloonQueue * queue);
179 };
180
181 extern const WCHAR szSysPagerWndClass[];
182
183 class CSysPagerWnd :
184 public CComCoClass<CSysPagerWnd>,
185 public CComObjectRootEx<CComMultiThreadModelNoCS>,
186 public CWindowImpl < CSysPagerWnd, CWindow, CControlWinTraits >,
187 public IOleWindow,
188 public CIconWatcher
189 {
190 CNotifyToolbar Toolbar;
191 CTooltips m_Balloons;
192 CBalloonQueue m_BalloonQueue;
193
194 public:
195 CSysPagerWnd();
196 virtual ~CSysPagerWnd();
197
198 LRESULT DrawBackground(HDC hdc);
199 LRESULT OnEraseBackground(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
200 LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
201 LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
202 LRESULT OnGetInfoTip(INT uCode, LPNMHDR hdr, BOOL& bHandled);
203 LRESULT OnCustomDraw(INT uCode, LPNMHDR hdr, BOOL& bHandled);
204 LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
205 LRESULT OnCtxMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
206 LRESULT OnBalloonPop(UINT uCode, LPNMHDR hdr, BOOL& bHandled);
207 LRESULT OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
208 LRESULT OnCopyData(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
209 LRESULT OnSettingChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
210 LRESULT OnGetMinimumSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
211
212 public:
213
214 HRESULT WINAPI GetWindow(HWND* phwnd)
215 {
216 if (!phwnd)
217 return E_INVALIDARG;
218 *phwnd = m_hWnd;
219 return S_OK;
220 }
221
222 HRESULT WINAPI ContextSensitiveHelp(BOOL fEnterMode)
223 {
224 return E_NOTIMPL;
225 }
226
227 DECLARE_NOT_AGGREGATABLE(CSysPagerWnd)
228
229 DECLARE_PROTECT_FINAL_CONSTRUCT()
230 BEGIN_COM_MAP(CSysPagerWnd)
231 COM_INTERFACE_ENTRY_IID(IID_IOleWindow, IOleWindow)
232 END_COM_MAP()
233
234 BOOL NotifyIcon(DWORD dwMessage, _In_ CONST NOTIFYICONDATA *iconData);
235 void GetSize(IN BOOL IsHorizontal, IN PSIZE size);
236
237 DECLARE_WND_CLASS_EX(szSysPagerWndClass, CS_DBLCLKS, COLOR_3DFACE)
238
239 BEGIN_MSG_MAP(CSysPagerWnd)
240 MESSAGE_HANDLER(WM_CREATE, OnCreate)
241 MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
242 MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
243 MESSAGE_HANDLER(WM_SIZE, OnSize)
244 MESSAGE_HANDLER(WM_CONTEXTMENU, OnCtxMenu)
245 MESSAGE_HANDLER(WM_TIMER, OnTimer)
246 MESSAGE_HANDLER(WM_COPYDATA, OnCopyData)
247 MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChanged)
248 MESSAGE_HANDLER(TNWM_GETMINIMUMSIZE, OnGetMinimumSize)
249 NOTIFY_CODE_HANDLER(TTN_POP, OnBalloonPop)
250 NOTIFY_CODE_HANDLER(TBN_GETINFOTIPW, OnGetInfoTip)
251 NOTIFY_CODE_HANDLER(NM_CUSTOMDRAW, OnCustomDraw)
252 END_MSG_MAP()
253
254 HRESULT Initialize(IN HWND hWndParent);
255 };
256
257 CIconWatcher::CIconWatcher() :
258 m_hWatcherThread(NULL),
259 m_WakeUpEvent(NULL),
260 m_hwndSysTray(NULL),
261 m_Loop(false)
262 {
263 }
264
265 CIconWatcher::~CIconWatcher()
266 {
267 Uninitialize();
268 DeleteCriticalSection(&m_ListLock);
269
270 if (m_WakeUpEvent)
271 CloseHandle(m_WakeUpEvent);
272 if (m_hWatcherThread)
273 CloseHandle(m_hWatcherThread);
274 }
275
276 bool CIconWatcher::Initialize(_In_ HWND hWndParent)
277 {
278 m_hwndSysTray = hWndParent;
279
280 InitializeCriticalSection(&m_ListLock);
281 m_WakeUpEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
282 if (m_WakeUpEvent == NULL)
283 return false;
284
285 m_hWatcherThread = (HANDLE)_beginthreadex(NULL,
286 0,
287 WatcherThread,
288 (LPVOID)this,
289 0,
290 NULL);
291 if (m_hWatcherThread == NULL)
292 return false;
293
294 return true;
295 }
296
297 void CIconWatcher::Uninitialize()
298 {
299 m_Loop = false;
300 if (m_WakeUpEvent)
301 SetEvent(m_WakeUpEvent);
302
303 EnterCriticalSection(&m_ListLock);
304
305 POSITION Pos;
306 for (size_t i = 0; i < m_WatcherList.GetCount(); i++)
307 {
308 Pos = m_WatcherList.FindIndex(i);
309 if (Pos)
310 {
311 IconWatcherData *Icon;
312 Icon = m_WatcherList.GetAt(Pos);
313 delete Icon;
314 }
315 }
316 m_WatcherList.RemoveAll();
317
318 LeaveCriticalSection(&m_ListLock);
319 }
320
321 bool CIconWatcher::AddIconToWatcher(_In_ CONST NOTIFYICONDATA *iconData)
322 {
323 DWORD ProcessId;
324 (void)GetWindowThreadProcessId(iconData->hWnd, &ProcessId);
325
326 HANDLE hProcess;
327 hProcess = OpenProcess(SYNCHRONIZE, FALSE, ProcessId);
328 if (hProcess == NULL)
329 {
330 return false;
331 }
332
333 IconWatcherData *Icon = new IconWatcherData(iconData);
334 Icon->hProcess = hProcess;
335 Icon->ProcessId = ProcessId;
336
337 bool Added = false;
338 EnterCriticalSection(&m_ListLock);
339
340 // The likelyhood of someone having more than 64 icons in their tray is
341 // pretty slim. We could spin up a new thread for each multiple of 64, but
342 // it's not worth the effort, so we just won't bother watching those icons
343 if (m_WatcherList.GetCount() < MAXIMUM_WAIT_OBJECTS)
344 {
345 m_WatcherList.AddTail(Icon);
346 SetEvent(m_WakeUpEvent);
347 Added = true;
348 }
349
350 LeaveCriticalSection(&m_ListLock);
351
352 if (!Added)
353 {
354 delete Icon;
355 }
356
357 return Added;
358 }
359
360 bool CIconWatcher::RemoveIconFromWatcher(_In_ CONST NOTIFYICONDATA *iconData)
361 {
362 EnterCriticalSection(&m_ListLock);
363
364 IconWatcherData *Icon;
365 Icon = GetListEntry(iconData, NULL, true);
366
367 SetEvent(m_WakeUpEvent);
368 LeaveCriticalSection(&m_ListLock);
369
370 delete Icon;
371 return true;
372 }
373
374 IconWatcherData* CIconWatcher::GetListEntry(_In_opt_ CONST NOTIFYICONDATA *iconData, _In_opt_ HANDLE hProcess, _In_ bool Remove)
375 {
376 IconWatcherData *Entry = NULL;
377 POSITION NextPosition = m_WatcherList.GetHeadPosition();
378 POSITION Position;
379 do
380 {
381 Position = NextPosition;
382
383 Entry = m_WatcherList.GetNext(NextPosition);
384 if (Entry)
385 {
386 if ((iconData && ((Entry->IconData.hWnd == iconData->hWnd) && (Entry->IconData.uID == iconData->uID))) ||
387 (hProcess && (Entry->hProcess == hProcess)))
388 {
389 if (Remove)
390 m_WatcherList.RemoveAt(Position);
391 break;
392 }
393 }
394 Entry = NULL;
395
396 } while (NextPosition != NULL);
397
398 return Entry;
399 }
400
401 UINT WINAPI CIconWatcher::WatcherThread(_In_opt_ LPVOID lpParam)
402 {
403 CIconWatcher* This = reinterpret_cast<CIconWatcher *>(lpParam);
404 HANDLE *WatchList = NULL;
405
406 This->m_Loop = true;
407 while (This->m_Loop)
408 {
409 EnterCriticalSection(&This->m_ListLock);
410
411 DWORD Size;
412 Size = This->m_WatcherList.GetCount() + 1;
413 ASSERT(Size <= MAXIMUM_WAIT_OBJECTS);
414
415 if (WatchList)
416 delete[] WatchList;
417 WatchList = new HANDLE[Size];
418 WatchList[0] = This->m_WakeUpEvent;
419
420 POSITION Pos;
421 for (size_t i = 0; i < This->m_WatcherList.GetCount(); i++)
422 {
423 Pos = This->m_WatcherList.FindIndex(i);
424 if (Pos)
425 {
426 IconWatcherData *Icon;
427 Icon = This->m_WatcherList.GetAt(Pos);
428 WatchList[i + 1] = Icon->hProcess;
429 }
430 }
431
432 LeaveCriticalSection(&This->m_ListLock);
433
434 DWORD Status;
435 Status = WaitForMultipleObjects(Size,
436 WatchList,
437 FALSE,
438 INFINITE);
439 if (Status == WAIT_OBJECT_0)
440 {
441 // We've been kicked, we have updates to our list (or we're exiting the thread)
442 if (This->m_Loop)
443 TRACE("Updating watched icon list");
444 }
445 else if ((Status >= WAIT_OBJECT_0 + 1) && (Status < Size))
446 {
447 IconWatcherData *Icon;
448 Icon = This->GetListEntry(NULL, WatchList[Status], false);
449
450 TRACE("Pid %lu owns a notification icon and has stopped without deleting it. We'll cleanup on its behalf", Icon->ProcessId);
451
452 TRAYNOTIFYDATAW tnid = {0};
453 tnid.dwSignature = NI_NOTIFY_SIG;
454 tnid.dwMessage = NIM_DELETE;
455 CopyMemory(&tnid.nid, &Icon->IconData, Icon->IconData.cbSize);
456
457 COPYDATASTRUCT data;
458 data.dwData = 1;
459 data.cbData = sizeof(tnid);
460 data.lpData = &tnid;
461
462 BOOL Success = ::SendMessage(This->m_hwndSysTray, WM_COPYDATA,
463 (WPARAM)&Icon->IconData, (LPARAM)&data);
464 if (!Success)
465 {
466 // If we failed to handle the delete message, forcibly remove it
467 This->RemoveIconFromWatcher(&Icon->IconData);
468 }
469 }
470 else
471 {
472 if (Status == WAIT_FAILED)
473 {
474 Status = GetLastError();
475 }
476 ERR("Failed to wait on process handles : %lu\n", Status);
477 This->Uninitialize();
478 }
479 }
480
481 if (WatchList)
482 delete[] WatchList;
483
484 return 0;
485 }
486
487 /*
488 * NotifyToolbar
489 */
490
491 CBalloonQueue::CBalloonQueue() :
492 m_hwndParent(NULL),
493 m_tooltips(NULL),
494 m_toolbar(NULL),
495 m_current(NULL),
496 m_currentClosed(false),
497 m_timer(-1)
498 {
499 }
500
501 void CBalloonQueue::Init(HWND hwndParent, CNotifyToolbar * toolbar, CTooltips * balloons)
502 {
503 m_hwndParent = hwndParent;
504 m_toolbar = toolbar;
505 m_tooltips = balloons;
506 }
507
508 void CBalloonQueue::Deinit()
509 {
510 if (m_timer >= 0)
511 {
512 ::KillTimer(m_hwndParent, m_timer);
513 }
514 }
515
516 bool CBalloonQueue::OnTimer(int timerId)
517 {
518 if (timerId != m_timer)
519 return false;
520
521 ::KillTimer(m_hwndParent, m_timer);
522 m_timer = -1;
523
524 if (m_current && !m_currentClosed)
525 {
526 Close(m_current, NIN_BALLOONTIMEOUT);
527 }
528 else
529 {
530 m_current = NULL;
531 m_currentClosed = false;
532 if (!m_queue.IsEmpty())
533 {
534 Info info = m_queue.RemoveHead();
535 Show(info);
536 }
537 }
538
539 return true;
540 }
541
542 void CBalloonQueue::UpdateInfo(InternalIconData * notifyItem)
543 {
544 size_t len = 0;
545 HRESULT hr = StringCchLength(notifyItem->szInfo, _countof(notifyItem->szInfo), &len);
546 if (SUCCEEDED(hr) && len > 0)
547 {
548 Info info(notifyItem);
549
550 // If m_current == notifyItem, we want to replace the previous balloon even if there is a queue.
551 if (m_current != notifyItem && (m_current != NULL || !m_queue.IsEmpty()))
552 {
553 m_queue.AddTail(info);
554 }
555 else
556 {
557 Show(info);
558 }
559 }
560 else
561 {
562 Close(notifyItem, NIN_BALLOONHIDE);
563 }
564 }
565
566 void CBalloonQueue::RemoveInfo(InternalIconData * notifyItem)
567 {
568 Close(notifyItem, NIN_BALLOONHIDE);
569
570 POSITION position = m_queue.GetHeadPosition();
571 while(position != NULL)
572 {
573 Info& info = m_queue.GetNext(position);
574 if (info.pSource == notifyItem)
575 {
576 m_queue.RemoveAt(position);
577 }
578 }
579 }
580
581 void CBalloonQueue::CloseCurrent()
582 {
583 if (m_current != NULL)
584 {
585 Close(m_current, NIN_BALLOONTIMEOUT);
586 }
587 }
588
589 int CBalloonQueue::IndexOf(InternalIconData * pdata)
590 {
591 int count = m_toolbar->GetButtonCount();
592 for (int i = 0; i < count; i++)
593 {
594 if (m_toolbar->GetItemData(i) == pdata)
595 return i;
596 }
597 return -1;
598 }
599
600 void CBalloonQueue::SetTimer(int length)
601 {
602 m_timer = ::SetTimer(m_hwndParent, BalloonsTimerId, length, NULL);
603 }
604
605 void CBalloonQueue::Show(Info& info)
606 {
607 TRACE("ShowBalloonTip called for flags=%x text=%ws; title=%ws\n", info.uIcon, info.szInfo, info.szInfoTitle);
608
609 // TODO: NIF_REALTIME, NIIF_NOSOUND, other Vista+ flags
610
611 const int index = IndexOf(info.pSource);
612 RECT rc;
613 m_toolbar->GetItemRect(index, &rc);
614 m_toolbar->ClientToScreen(&rc);
615 const WORD x = (rc.left + rc.right) / 2;
616 const WORD y = (rc.top + rc.bottom) / 2;
617
618 m_tooltips->SetTitle(info.szInfoTitle, info.uIcon);
619 m_tooltips->TrackPosition(x, y);
620 m_tooltips->UpdateTipText(m_hwndParent, reinterpret_cast<LPARAM>(m_toolbar->m_hWnd), info.szInfo);
621 m_tooltips->TrackActivate(m_hwndParent, reinterpret_cast<LPARAM>(m_toolbar->m_hWnd));
622
623 m_current = info.pSource;
624 int timeout = info.uTimeout;
625 if (timeout < MinTimeout) timeout = MinTimeout;
626 if (timeout > MaxTimeout) timeout = MaxTimeout;
627
628 SetTimer(timeout);
629
630 m_toolbar->SendNotifyCallback(m_current, NIN_BALLOONSHOW);
631 }
632
633 void CBalloonQueue::Close(IN OUT InternalIconData * notifyItem, IN UINT uReason)
634 {
635 TRACE("HideBalloonTip called\n");
636
637 if (m_current == notifyItem && !m_currentClosed)
638 {
639 m_toolbar->SendNotifyCallback(m_current, uReason);
640
641 // Prevent Re-entry
642 m_currentClosed = true;
643 m_tooltips->TrackDeactivate();
644 SetTimer(CooldownBetweenBalloons);
645 }
646 }
647
648 /*
649 * NotifyToolbar
650 */
651
652 CNotifyToolbar::CNotifyToolbar() :
653 m_ImageList(NULL),
654 m_VisibleButtonCount(0),
655 m_BalloonQueue(NULL)
656 {
657 }
658
659 CNotifyToolbar::~CNotifyToolbar()
660 {
661 }
662
663 int CNotifyToolbar::GetVisibleButtonCount()
664 {
665 return m_VisibleButtonCount;
666 }
667
668 int CNotifyToolbar::FindItem(IN HWND hWnd, IN UINT uID, InternalIconData ** pdata)
669 {
670 int count = GetButtonCount();
671
672 for (int i = 0; i < count; i++)
673 {
674 InternalIconData * data = GetItemData(i);
675
676 if (data->hWnd == hWnd &&
677 data->uID == uID)
678 {
679 if (pdata)
680 *pdata = data;
681 return i;
682 }
683 }
684
685 return -1;
686 }
687
688 int CNotifyToolbar::FindExistingSharedIcon(HICON handle)
689 {
690 int count = GetButtonCount();
691 for (int i = 0; i < count; i++)
692 {
693 InternalIconData * data = GetItemData(i);
694 if (data->hIcon == handle)
695 {
696 TBBUTTON btn;
697 GetButton(i, &btn);
698 return btn.iBitmap;
699 }
700 }
701
702 return -1;
703 }
704
705 BOOL CNotifyToolbar::AddButton(_In_ CONST NOTIFYICONDATA *iconData)
706 {
707 TBBUTTON tbBtn = { 0 };
708 InternalIconData * notifyItem;
709 WCHAR text[] = L"";
710
711 TRACE("Adding icon %d from hWnd %08x flags%s%s state%s%s",
712 iconData->uID, iconData->hWnd,
713 (iconData->uFlags & NIF_ICON) ? " ICON" : "",
714 (iconData->uFlags & NIF_STATE) ? " STATE" : "",
715 (iconData->dwState & NIS_HIDDEN) ? " HIDDEN" : "",
716 (iconData->dwState & NIS_SHAREDICON) ? " SHARED" : "");
717
718 int index = FindItem(iconData->hWnd, iconData->uID, &notifyItem);
719 if (index >= 0)
720 {
721 TRACE("Icon %d from hWnd %08x ALREADY EXISTS!", iconData->uID, iconData->hWnd);
722 return FALSE;
723 }
724
725 notifyItem = new InternalIconData();
726 ZeroMemory(notifyItem, sizeof(*notifyItem));
727
728 notifyItem->hWnd = iconData->hWnd;
729 notifyItem->uID = iconData->uID;
730
731 tbBtn.fsState = TBSTATE_ENABLED;
732 tbBtn.fsStyle = BTNS_NOPREFIX;
733 tbBtn.dwData = (DWORD_PTR)notifyItem;
734 tbBtn.iString = (INT_PTR) text;
735 tbBtn.idCommand = GetButtonCount();
736
737 if (iconData->uFlags & NIF_STATE)
738 {
739 notifyItem->dwState = iconData->dwState & iconData->dwStateMask;
740 }
741
742 if (iconData->uFlags & NIF_MESSAGE)
743 {
744 notifyItem->uCallbackMessage = iconData->uCallbackMessage;
745 }
746
747 if (iconData->uFlags & NIF_ICON)
748 {
749 notifyItem->hIcon = iconData->hIcon;
750 BOOL hasSharedIcon = notifyItem->dwState & NIS_SHAREDICON;
751 if (hasSharedIcon)
752 {
753 INT iIcon = FindExistingSharedIcon(notifyItem->hIcon);
754 if (iIcon < 0)
755 {
756 notifyItem->hIcon = NULL;
757 TRACE("Shared icon requested, but HICON not found!!!");
758 }
759 tbBtn.iBitmap = iIcon;
760 }
761 else
762 {
763 tbBtn.iBitmap = ImageList_AddIcon(m_ImageList, notifyItem->hIcon);
764 }
765 }
766
767 if (iconData->uFlags & NIF_TIP)
768 {
769 StringCchCopy(notifyItem->szTip, _countof(notifyItem->szTip), iconData->szTip);
770 }
771
772 if (iconData->uFlags & NIF_INFO)
773 {
774 // NOTE: In Vista+, the uTimeout value is disregarded, and the accessibility settings are used always.
775 StringCchCopy(notifyItem->szInfo, _countof(notifyItem->szInfo), iconData->szInfo);
776 StringCchCopy(notifyItem->szInfoTitle, _countof(notifyItem->szInfoTitle), iconData->szInfoTitle);
777 notifyItem->dwInfoFlags = iconData->dwInfoFlags;
778 notifyItem->uTimeout = iconData->uTimeout;
779 }
780
781 if (notifyItem->dwState & NIS_HIDDEN)
782 {
783 tbBtn.fsState |= TBSTATE_HIDDEN;
784 }
785 else
786 {
787 m_VisibleButtonCount++;
788 }
789
790 /* TODO: support VERSION_4 (NIF_GUID, NIF_REALTIME, NIF_SHOWTIP) */
791
792 CToolbar::AddButton(&tbBtn);
793 SetButtonSize(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON));
794
795 if (iconData->uFlags & NIF_INFO)
796 {
797 m_BalloonQueue->UpdateInfo(notifyItem);
798 }
799
800 return TRUE;
801 }
802
803 BOOL CNotifyToolbar::SwitchVersion(_In_ CONST NOTIFYICONDATA *iconData)
804 {
805 InternalIconData * notifyItem;
806 int index = FindItem(iconData->hWnd, iconData->uID, &notifyItem);
807 if (index < 0)
808 {
809 WARN("Icon %d from hWnd %08x DOES NOT EXIST!", iconData->uID, iconData->hWnd);
810 return FALSE;
811 }
812
813 if (iconData->uVersion != 0 && iconData->uVersion != NOTIFYICON_VERSION)
814 {
815 WARN("Tried to set the version of icon %d from hWnd %08x, to an unknown value %d. Vista+ program?", iconData->uID, iconData->hWnd, iconData->uVersion);
816 return FALSE;
817 }
818
819 // We can not store the version in the uVersion field, because it's union'd with uTimeout,
820 // which we also need to keep track of.
821 notifyItem->uVersionCopy = iconData->uVersion;
822
823 return TRUE;
824 }
825
826 BOOL CNotifyToolbar::UpdateButton(_In_ CONST NOTIFYICONDATA *iconData)
827 {
828 InternalIconData * notifyItem;
829 TBBUTTONINFO tbbi = { 0 };
830
831 TRACE("Updating icon %d from hWnd %08x flags%s%s state%s%s",
832 iconData->uID, iconData->hWnd,
833 (iconData->uFlags & NIF_ICON) ? " ICON" : "",
834 (iconData->uFlags & NIF_STATE) ? " STATE" : "",
835 (iconData->dwState & NIS_HIDDEN) ? " HIDDEN" : "",
836 (iconData->dwState & NIS_SHAREDICON) ? " SHARED" : "");
837
838 int index = FindItem(iconData->hWnd, iconData->uID, &notifyItem);
839 if (index < 0)
840 {
841 WARN("Icon %d from hWnd %08x DOES NOT EXIST!", iconData->uID, iconData->hWnd);
842 return AddButton(iconData);
843 }
844
845 TBBUTTON btn;
846 GetButton(index, &btn);
847 int oldIconIndex = btn.iBitmap;
848
849 tbbi.cbSize = sizeof(tbbi);
850 tbbi.dwMask = TBIF_BYINDEX | TBIF_COMMAND;
851 tbbi.idCommand = index;
852
853 if (iconData->uFlags & NIF_STATE)
854 {
855 if (iconData->dwStateMask & NIS_HIDDEN &&
856 (notifyItem->dwState & NIS_HIDDEN) != (iconData->dwState & NIS_HIDDEN))
857 {
858 tbbi.dwMask |= TBIF_STATE;
859 if (iconData->dwState & NIS_HIDDEN)
860 {
861 tbbi.fsState |= TBSTATE_HIDDEN;
862 m_VisibleButtonCount--;
863 }
864 else
865 {
866 tbbi.fsState &= ~TBSTATE_HIDDEN;
867 m_VisibleButtonCount++;
868 }
869 }
870
871 notifyItem->dwState &= ~iconData->dwStateMask;
872 notifyItem->dwState |= (iconData->dwState & iconData->dwStateMask);
873 }
874
875 if (iconData->uFlags & NIF_MESSAGE)
876 {
877 notifyItem->uCallbackMessage = iconData->uCallbackMessage;
878 }
879
880 if (iconData->uFlags & NIF_ICON)
881 {
882 BOOL hasSharedIcon = notifyItem->dwState & NIS_SHAREDICON;
883 if (hasSharedIcon)
884 {
885 INT iIcon = FindExistingSharedIcon(iconData->hIcon);
886 if (iIcon >= 0)
887 {
888 notifyItem->hIcon = iconData->hIcon;
889 tbbi.dwMask |= TBIF_IMAGE;
890 tbbi.iImage = iIcon;
891 }
892 else
893 {
894 TRACE("Shared icon requested, but HICON not found!!! IGNORING!");
895 }
896 }
897 else
898 {
899 notifyItem->hIcon = iconData->hIcon;
900 tbbi.dwMask |= TBIF_IMAGE;
901 tbbi.iImage = ImageList_ReplaceIcon(m_ImageList, oldIconIndex, notifyItem->hIcon);
902 }
903 }
904
905 if (iconData->uFlags & NIF_TIP)
906 {
907 StringCchCopy(notifyItem->szTip, _countof(notifyItem->szTip), iconData->szTip);
908 }
909
910 if (iconData->uFlags & NIF_INFO)
911 {
912 // NOTE: In Vista+, the uTimeout value is disregarded, and the accessibility settings are used always.
913 StringCchCopy(notifyItem->szInfo, _countof(notifyItem->szInfo), iconData->szInfo);
914 StringCchCopy(notifyItem->szInfoTitle, _countof(notifyItem->szInfoTitle), iconData->szInfoTitle);
915 notifyItem->dwInfoFlags = iconData->dwInfoFlags;
916 notifyItem->uTimeout = iconData->uTimeout;
917 }
918
919 /* TODO: support VERSION_4 (NIF_GUID, NIF_REALTIME, NIF_SHOWTIP) */
920
921 SetButtonInfo(index, &tbbi);
922
923 if (iconData->uFlags & NIF_INFO)
924 {
925 m_BalloonQueue->UpdateInfo(notifyItem);
926 }
927
928 return TRUE;
929 }
930
931 BOOL CNotifyToolbar::RemoveButton(_In_ CONST NOTIFYICONDATA *iconData)
932 {
933 InternalIconData * notifyItem;
934
935 TRACE("Removing icon %d from hWnd %08x", iconData->uID, iconData->hWnd);
936
937 int index = FindItem(iconData->hWnd, iconData->uID, &notifyItem);
938 if (index < 0)
939 {
940 TRACE("Icon %d from hWnd %08x ALREADY MISSING!", iconData->uID, iconData->hWnd);
941
942 return FALSE;
943 }
944
945 if (!(notifyItem->dwState & NIS_HIDDEN))
946 {
947 m_VisibleButtonCount--;
948 }
949
950 if (!(notifyItem->dwState & NIS_SHAREDICON))
951 {
952 TBBUTTON btn;
953 GetButton(index, &btn);
954 int oldIconIndex = btn.iBitmap;
955 ImageList_Remove(m_ImageList, oldIconIndex);
956
957 // Update other icons!
958 int count = GetButtonCount();
959 for (int i = 0; i < count; i++)
960 {
961 TBBUTTON btn;
962 GetButton(i, &btn);
963
964 if (btn.iBitmap > oldIconIndex)
965 {
966 TBBUTTONINFO tbbi2 = { 0 };
967 tbbi2.cbSize = sizeof(tbbi2);
968 tbbi2.dwMask = TBIF_BYINDEX | TBIF_IMAGE;
969 tbbi2.iImage = btn.iBitmap-1;
970 SetButtonInfo(i, &tbbi2);
971 }
972 }
973 }
974
975 m_BalloonQueue->RemoveInfo(notifyItem);
976
977 DeleteButton(index);
978
979 delete notifyItem;
980
981 return TRUE;
982 }
983
984 VOID CNotifyToolbar::ResizeImagelist()
985 {
986 int cx, cy;
987 HIMAGELIST iml;
988
989 if (!ImageList_GetIconSize(m_ImageList, &cx, &cy))
990 return;
991
992 if (cx == GetSystemMetrics(SM_CXSMICON) && cy == GetSystemMetrics(SM_CYSMICON))
993 return;
994
995 iml = ImageList_Create(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), ILC_COLOR32 | ILC_MASK, 0, 1000);
996 if (!iml)
997 return;
998
999 ImageList_Destroy(m_ImageList);
1000 m_ImageList = iml;
1001 SetImageList(m_ImageList);
1002
1003 int count = GetButtonCount();
1004 for (int i = 0; i < count; i++)
1005 {
1006 InternalIconData * data = GetItemData(i);
1007 BOOL hasSharedIcon = data->dwState & NIS_SHAREDICON;
1008 INT iIcon = hasSharedIcon ? FindExistingSharedIcon(data->hIcon) : -1;
1009 if (iIcon < 0)
1010 iIcon = ImageList_AddIcon(iml, data->hIcon);
1011 TBBUTTONINFO tbbi = { sizeof(tbbi), TBIF_BYINDEX | TBIF_IMAGE, 0, iIcon};
1012 SetButtonInfo(i, &tbbi);
1013 }
1014
1015 SetButtonSize(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON));
1016 }
1017
1018 bool CNotifyToolbar::SendNotifyCallback(InternalIconData* notifyItem, UINT uMsg)
1019 {
1020 if (!::IsWindow(notifyItem->hWnd))
1021 {
1022 // We detect and destroy icons with invalid handles only on mouse move over systray, same as MS does.
1023 // Alternatively we could search for them periodically (would waste more resources).
1024 TRACE("Destroying icon %d with invalid handle hWnd=%08x\n", notifyItem->uID, notifyItem->hWnd);
1025
1026 RemoveButton(notifyItem);
1027
1028 /* Ask the parent to resize */
1029 NMHDR nmh = {GetParent(), 0, NTNWM_REALIGN};
1030 GetParent().SendMessage(WM_NOTIFY, 0, (LPARAM) &nmh);
1031
1032 return true;
1033 }
1034
1035 DWORD pid;
1036 GetWindowThreadProcessId(notifyItem->hWnd, &pid);
1037
1038 if (pid == GetCurrentProcessId() ||
1039 (uMsg >= WM_MOUSEFIRST && uMsg <= WM_MOUSELAST))
1040 {
1041 ::PostMessage(notifyItem->hWnd,
1042 notifyItem->uCallbackMessage,
1043 notifyItem->uID,
1044 uMsg);
1045 }
1046 else
1047 {
1048 SendMessage(notifyItem->hWnd,
1049 notifyItem->uCallbackMessage,
1050 notifyItem->uID,
1051 uMsg);
1052 }
1053 return false;
1054 }
1055
1056 VOID CNotifyToolbar::SendMouseEvent(IN WORD wIndex, IN UINT uMsg, IN WPARAM wParam)
1057 {
1058 static LPCWSTR eventNames [] = {
1059 L"WM_MOUSEMOVE",
1060 L"WM_LBUTTONDOWN",
1061 L"WM_LBUTTONUP",
1062 L"WM_LBUTTONDBLCLK",
1063 L"WM_RBUTTONDOWN",
1064 L"WM_RBUTTONUP",
1065 L"WM_RBUTTONDBLCLK",
1066 L"WM_MBUTTONDOWN",
1067 L"WM_MBUTTONUP",
1068 L"WM_MBUTTONDBLCLK",
1069 L"WM_MOUSEWHEEL",
1070 L"WM_XBUTTONDOWN",
1071 L"WM_XBUTTONUP",
1072 L"WM_XBUTTONDBLCLK"
1073 };
1074
1075 InternalIconData * notifyItem = GetItemData(wIndex);
1076
1077 if (uMsg >= WM_MOUSEFIRST && uMsg <= WM_MOUSELAST)
1078 {
1079 TRACE("Sending message %S from button %d to %p (msg=%x, w=%x, l=%x)...\n",
1080 eventNames[uMsg - WM_MOUSEFIRST], wIndex,
1081 notifyItem->hWnd, notifyItem->uCallbackMessage, notifyItem->uID, uMsg);
1082 }
1083
1084 SendNotifyCallback(notifyItem, uMsg);
1085 }
1086
1087 LRESULT CNotifyToolbar::OnMouseEvent(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1088 {
1089 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
1090
1091 INT iBtn = HitTest(&pt);
1092
1093 if (iBtn >= 0)
1094 {
1095 SendMouseEvent(iBtn, uMsg, wParam);
1096 }
1097
1098 bHandled = FALSE;
1099 return FALSE;
1100 }
1101
1102 static VOID GetTooltipText(LPARAM data, LPTSTR szTip, DWORD cchTip)
1103 {
1104 InternalIconData * notifyItem = reinterpret_cast<InternalIconData *>(data);
1105 if (notifyItem)
1106 {
1107 StringCchCopy(szTip, cchTip, notifyItem->szTip);
1108 }
1109 else
1110 {
1111 StringCchCopy(szTip, cchTip, L"");
1112 }
1113 }
1114
1115 LRESULT CNotifyToolbar::OnTooltipShow(INT uCode, LPNMHDR hdr, BOOL& bHandled)
1116 {
1117 RECT rcTip, rcItem;
1118 ::GetWindowRect(hdr->hwndFrom, &rcTip);
1119
1120 SIZE szTip = { rcTip.right - rcTip.left, rcTip.bottom - rcTip.top };
1121
1122 INT iBtn = GetHotItem();
1123
1124 if (iBtn >= 0)
1125 {
1126 MONITORINFO monInfo = { 0 };
1127 HMONITOR hMon = MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST);
1128
1129 monInfo.cbSize = sizeof(monInfo);
1130
1131 if (hMon)
1132 GetMonitorInfo(hMon, &monInfo);
1133 else
1134 ::GetWindowRect(GetDesktopWindow(), &monInfo.rcMonitor);
1135
1136 GetItemRect(iBtn, &rcItem);
1137
1138 POINT ptItem = { rcItem.left, rcItem.top };
1139 SIZE szItem = { rcItem.right - rcItem.left, rcItem.bottom - rcItem.top };
1140 ClientToScreen(&ptItem);
1141
1142 ptItem.x += szItem.cx / 2;
1143 ptItem.y -= szTip.cy;
1144
1145 if (ptItem.x + szTip.cx > monInfo.rcMonitor.right)
1146 ptItem.x = monInfo.rcMonitor.right - szTip.cx;
1147
1148 if (ptItem.y + szTip.cy > monInfo.rcMonitor.bottom)
1149 ptItem.y = monInfo.rcMonitor.bottom - szTip.cy;
1150
1151 if (ptItem.x < monInfo.rcMonitor.left)
1152 ptItem.x = monInfo.rcMonitor.left;
1153
1154 if (ptItem.y < monInfo.rcMonitor.top)
1155 ptItem.y = monInfo.rcMonitor.top;
1156
1157 TRACE("ptItem { %d, %d }\n", ptItem.x, ptItem.y);
1158
1159 ::SetWindowPos(hdr->hwndFrom, NULL, ptItem.x, ptItem.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
1160
1161 return TRUE;
1162 }
1163
1164 bHandled = FALSE;
1165 return 0;
1166 }
1167
1168 void CNotifyToolbar::Initialize(HWND hWndParent, CBalloonQueue * queue)
1169 {
1170 m_BalloonQueue = queue;
1171
1172 DWORD styles =
1173 WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN |
1174 TBSTYLE_FLAT | TBSTYLE_TOOLTIPS | TBSTYLE_WRAPABLE | TBSTYLE_TRANSPARENT |
1175 CCS_TOP | CCS_NORESIZE | CCS_NOPARENTALIGN | CCS_NODIVIDER;
1176
1177 SubclassWindow(CToolbar::Create(hWndParent, styles));
1178
1179 // Force the toolbar tooltips window to always show tooltips even if not foreground
1180 HWND tooltipsWnd = (HWND)SendMessageW(TB_GETTOOLTIPS);
1181 if (tooltipsWnd)
1182 {
1183 ::SetWindowLong(tooltipsWnd, GWL_STYLE, ::GetWindowLong(tooltipsWnd, GWL_STYLE) | TTS_ALWAYSTIP);
1184 }
1185
1186 SetWindowTheme(m_hWnd, L"TrayNotify", NULL);
1187
1188 m_ImageList = ImageList_Create(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), ILC_COLOR32 | ILC_MASK, 0, 1000);
1189 SetImageList(m_ImageList);
1190
1191 TBMETRICS tbm = {sizeof(tbm)};
1192 tbm.dwMask = TBMF_BARPAD | TBMF_BUTTONSPACING | TBMF_PAD;
1193 tbm.cxPad = 1;
1194 tbm.cyPad = 1;
1195 tbm.cxBarPad = 1;
1196 tbm.cyBarPad = 1;
1197 tbm.cxButtonSpacing = 1;
1198 tbm.cyButtonSpacing = 1;
1199 SetMetrics(&tbm);
1200
1201 SetButtonSize(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON));
1202 }
1203
1204 /*
1205 * SysPagerWnd
1206 */
1207 const WCHAR szSysPagerWndClass[] = L"SysPager";
1208
1209 CSysPagerWnd::CSysPagerWnd() {}
1210 CSysPagerWnd::~CSysPagerWnd() {}
1211
1212 LRESULT CSysPagerWnd::OnEraseBackground(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1213 {
1214 HDC hdc = (HDC) wParam;
1215
1216 if (!IsAppThemed())
1217 {
1218 bHandled = FALSE;
1219 return 0;
1220 }
1221
1222 RECT rect;
1223 GetClientRect(&rect);
1224 DrawThemeParentBackground(m_hWnd, hdc, &rect);
1225
1226 return TRUE;
1227 }
1228
1229 LRESULT CSysPagerWnd::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1230 {
1231 Toolbar.Initialize(m_hWnd, &m_BalloonQueue);
1232 CIconWatcher::Initialize(m_hWnd);
1233
1234 HWND hWndTop = GetAncestor(m_hWnd, GA_ROOT);
1235
1236 m_Balloons.Create(hWndTop, TTS_NOPREFIX | TTS_BALLOON | TTS_CLOSE);
1237
1238 TOOLINFOW ti = { 0 };
1239 ti.cbSize = TTTOOLINFOW_V1_SIZE;
1240 ti.uFlags = TTF_TRACK | TTF_IDISHWND;
1241 ti.uId = reinterpret_cast<UINT_PTR>(Toolbar.m_hWnd);
1242 ti.hwnd = m_hWnd;
1243 ti.lpszText = NULL;
1244 ti.lParam = NULL;
1245
1246 BOOL ret = m_Balloons.AddTool(&ti);
1247 if (!ret)
1248 {
1249 WARN("AddTool failed, LastError=%d (probably meaningless unless non-zero)\n", GetLastError());
1250 }
1251
1252 m_BalloonQueue.Init(m_hWnd, &Toolbar, &m_Balloons);
1253
1254 // Explicitly request running applications to re-register their systray icons
1255 ::SendNotifyMessageW(HWND_BROADCAST,
1256 RegisterWindowMessageW(L"TaskbarCreated"),
1257 0, 0);
1258
1259 return TRUE;
1260 }
1261
1262 LRESULT CSysPagerWnd::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1263 {
1264 m_BalloonQueue.Deinit();
1265 CIconWatcher::Uninitialize();
1266 return TRUE;
1267 }
1268
1269 BOOL CSysPagerWnd::NotifyIcon(DWORD dwMessage, _In_ CONST NOTIFYICONDATA *iconData)
1270 {
1271 BOOL ret = FALSE;
1272
1273 int VisibleButtonCount = Toolbar.GetVisibleButtonCount();
1274
1275 TRACE("NotifyIcon received. Code=%d\n", dwMessage);
1276 switch (dwMessage)
1277 {
1278 case NIM_ADD:
1279 ret = Toolbar.AddButton(iconData);
1280 if (ret == TRUE)
1281 {
1282 (void)AddIconToWatcher(iconData);
1283 }
1284 break;
1285 case NIM_MODIFY:
1286 ret = Toolbar.UpdateButton(iconData);
1287 break;
1288 case NIM_DELETE:
1289 ret = Toolbar.RemoveButton(iconData);
1290 if (ret == TRUE)
1291 {
1292 (void)RemoveIconFromWatcher(iconData);
1293 }
1294 break;
1295 case NIM_SETFOCUS:
1296 Toolbar.SetFocus();
1297 ret = TRUE;
1298 case NIM_SETVERSION:
1299 ret = Toolbar.SwitchVersion(iconData);
1300 default:
1301 TRACE("NotifyIcon received with unknown code %d.\n", dwMessage);
1302 return FALSE;
1303 }
1304
1305 if (VisibleButtonCount != Toolbar.GetVisibleButtonCount())
1306 {
1307 /* Ask the parent to resize */
1308 NMHDR nmh = {GetParent(), 0, NTNWM_REALIGN};
1309 GetParent().SendMessage(WM_NOTIFY, 0, (LPARAM) &nmh);
1310 }
1311
1312 return ret;
1313 }
1314
1315 void CSysPagerWnd::GetSize(IN BOOL IsHorizontal, IN PSIZE size)
1316 {
1317 /* Get the ideal height or width */
1318 #if 0
1319 /* Unfortunately this doens't work correctly in ros */
1320 Toolbar.GetIdealSize(!IsHorizontal, size);
1321
1322 /* Make the reference dimension an exact multiple of the icon size */
1323 if (IsHorizontal)
1324 size->cy -= size->cy % GetSystemMetrics(SM_CYSMICON);
1325 else
1326 size->cx -= size->cx % GetSystemMetrics(SM_CXSMICON);
1327
1328 #else
1329 INT rows = 0;
1330 INT columns = 0;
1331 INT cyButton = GetSystemMetrics(SM_CYSMICON) + 2;
1332 INT cxButton = GetSystemMetrics(SM_CXSMICON) + 2;
1333 int VisibleButtonCount = Toolbar.GetVisibleButtonCount();
1334
1335 if (IsHorizontal)
1336 {
1337 rows = max(size->cy / cyButton, 1);
1338 columns = (VisibleButtonCount + rows - 1) / rows;
1339 }
1340 else
1341 {
1342 columns = max(size->cx / cxButton, 1);
1343 rows = (VisibleButtonCount + columns - 1) / columns;
1344 }
1345 size->cx = columns * cxButton;
1346 size->cy = rows * cyButton;
1347 #endif
1348 }
1349
1350 LRESULT CSysPagerWnd::OnGetInfoTip(INT uCode, LPNMHDR hdr, BOOL& bHandled)
1351 {
1352 NMTBGETINFOTIPW * nmtip = (NMTBGETINFOTIPW *) hdr;
1353 GetTooltipText(nmtip->lParam, nmtip->pszText, nmtip->cchTextMax);
1354 return TRUE;
1355 }
1356
1357 LRESULT CSysPagerWnd::OnCustomDraw(INT uCode, LPNMHDR hdr, BOOL& bHandled)
1358 {
1359 NMCUSTOMDRAW * cdraw = (NMCUSTOMDRAW *) hdr;
1360 switch (cdraw->dwDrawStage)
1361 {
1362 case CDDS_PREPAINT:
1363 return CDRF_NOTIFYITEMDRAW;
1364
1365 case CDDS_ITEMPREPAINT:
1366 return TBCDRF_NOBACKGROUND | TBCDRF_NOEDGES | TBCDRF_NOOFFSET | TBCDRF_NOMARK | TBCDRF_NOETCHEDEFFECT;
1367 }
1368 return TRUE;
1369 }
1370
1371 LRESULT CSysPagerWnd::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1372 {
1373 LRESULT Ret = TRUE;
1374 SIZE szClient;
1375 szClient.cx = LOWORD(lParam);
1376 szClient.cy = HIWORD(lParam);
1377
1378 Ret = DefWindowProc(uMsg, wParam, lParam);
1379
1380 if (Toolbar)
1381 {
1382 Toolbar.SetWindowPos(NULL, 0, 0, szClient.cx, szClient.cy, SWP_NOZORDER);
1383 Toolbar.AutoSize();
1384
1385 RECT rc;
1386 Toolbar.GetClientRect(&rc);
1387
1388 SIZE szBar = { rc.right - rc.left, rc.bottom - rc.top };
1389
1390 INT xOff = (szClient.cx - szBar.cx) / 2;
1391 INT yOff = (szClient.cy - szBar.cy) / 2;
1392
1393 Toolbar.SetWindowPos(NULL, xOff, yOff, szBar.cx, szBar.cy, SWP_NOZORDER);
1394 }
1395 return Ret;
1396 }
1397
1398 LRESULT CSysPagerWnd::OnCtxMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1399 {
1400 bHandled = TRUE;
1401 return 0;
1402 }
1403
1404 LRESULT CSysPagerWnd::OnBalloonPop(UINT uCode, LPNMHDR hdr , BOOL& bHandled)
1405 {
1406 m_BalloonQueue.CloseCurrent();
1407 bHandled = TRUE;
1408 return 0;
1409 }
1410
1411 LRESULT CSysPagerWnd::OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1412 {
1413 if (m_BalloonQueue.OnTimer(wParam))
1414 {
1415 bHandled = TRUE;
1416 }
1417
1418 return 0;
1419 }
1420
1421 LRESULT CSysPagerWnd::OnCopyData(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1422 {
1423 PCOPYDATASTRUCT cpData = (PCOPYDATASTRUCT)lParam;
1424 if (cpData->dwData == 1)
1425 {
1426 /* A taskbar NotifyIcon notification */
1427 PTRAYNOTIFYDATAW pData = (PTRAYNOTIFYDATAW)cpData->lpData;
1428 if (pData->dwSignature == NI_NOTIFY_SIG)
1429 return NotifyIcon(pData->dwMessage, &pData->nid);
1430 }
1431 // TODO: Handle other types of taskbar notifications
1432
1433 return FALSE;
1434 }
1435
1436 LRESULT CSysPagerWnd::OnSettingChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1437 {
1438 if (wParam == SPI_SETNONCLIENTMETRICS)
1439 {
1440 Toolbar.ResizeImagelist();
1441 }
1442 return 0;
1443 }
1444
1445 LRESULT CSysPagerWnd::OnGetMinimumSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1446 {
1447 GetSize((BOOL)wParam, (PSIZE)lParam);
1448 return 0;
1449 }
1450
1451 HRESULT CSysPagerWnd::Initialize(IN HWND hWndParent)
1452 {
1453 /* Create the window. The tray window is going to move it to the correct
1454 position and resize it as needed. */
1455 DWORD dwStyle = WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE;
1456 Create(hWndParent, 0, NULL, dwStyle);
1457 if (!m_hWnd)
1458 return E_FAIL;
1459
1460 SetWindowTheme(m_hWnd, L"TrayNotify", NULL);
1461
1462 return S_OK;
1463 }
1464
1465 HRESULT CSysPagerWnd_CreateInstance(HWND hwndParent, REFIID riid, void **ppv)
1466 {
1467 return ShellObjectCreatorInit<CSysPagerWnd>(hwndParent, riid, ppv);
1468 }