ReactOS 0.4.16-dev-1338-g8aab5a9
taskswnd.cpp
Go to the documentation of this file.
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 <commoncontrols.h>
23#include <regstr.h>
24#include <shlwapi_undoc.h>
25
26/* Set DUMP_TASKS to 1 to enable a dump of the tasks and task groups every
27 5 seconds */
28#define DUMP_TASKS 0
29#define DEBUG_SHELL_HOOK 0
30
31#define MAX_TASKS_COUNT (0x7FFF)
32#define TASK_ITEM_ARRAY_ALLOC 64
33
34//************************************************************************
35// Fullscreen windows (a.k.a. rude apps) checker
36
37#define TIMER_ID_VALIDATE_RUDE_APP 5
38#define VALIDATE_RUDE_INTERVAL 1000
39#define VALIDATE_RUDE_MAX_COUNT 5
40
41static BOOL
43 _In_opt_ HMONITOR hMonitor,
44 _Out_opt_ PRECT prcDest,
45 _In_ BOOL bWorkAreaOnly)
46{
47 MONITORINFO mi = { sizeof(mi) };
48 if (!hMonitor || !::GetMonitorInfoW(hMonitor, &mi))
49 {
50 if (!prcDest)
51 return FALSE;
52
53 if (bWorkAreaOnly)
54 ::SystemParametersInfoW(SPI_GETWORKAREA, 0, prcDest, 0);
55 else
56 ::SetRect(prcDest, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
57
58 return FALSE;
59 }
60
61 if (prcDest)
62 *prcDest = (bWorkAreaOnly ? mi.rcWork : mi.rcMonitor);
63 return TRUE;
64}
65
66static BOOL
68{
69 for (; hWnd; hWnd = ::GetParent(hWnd))
70 {
71 if (hWnd == hwndTarget)
72 return TRUE;
73 }
74 return FALSE;
75}
76
77static BOOL
79{
80 HWND hwndFore = ::GetForegroundWindow();
82 return dwThreadId == ::GetWindowThreadProcessId(hwndFore, NULL) ||
84}
85
86static BOOL
88{
90 return FALSE;
91
92 RECT rcMonitor;
93 SHELL_GetMonitorRect(hMonitor, &rcMonitor, FALSE);
94
96
97 RECT rcWnd;
98 enum { CHECK_STYLE = WS_THICKFRAME | WS_DLGFRAME | WS_BORDER };
99 if ((style & CHECK_STYLE) == CHECK_STYLE)
100 {
101 ::GetClientRect(hWnd, &rcWnd); // Ignore frame
102 ::MapWindowPoints(hWnd, NULL, (PPOINT)&rcWnd, sizeof(RECT) / sizeof(POINT));
103 }
104 else
105 {
106 ::GetWindowRect(hWnd, &rcWnd);
107 }
108
109 RECT rcUnion;
110 ::UnionRect(&rcUnion, &rcWnd, &rcMonitor);
111
112 return ::EqualRect(&rcUnion, &rcWnd) && (bDontCheckActive || SHELL_IsRudeWindowActive(hWnd));
113}
114
116
117const WCHAR szTaskSwitchWndClass[] = L"MSTaskSwWClass";
118const WCHAR szRunningApps[] = L"Running Applications";
119
120#if DEBUG_SHELL_HOOK
121const struct {
122 INT msg;
123 LPCWSTR msg_name;
124} hshell_msg [] = {
125 { HSHELL_WINDOWCREATED, L"HSHELL_WINDOWCREATED" },
126 { HSHELL_WINDOWDESTROYED, L"HSHELL_WINDOWDESTROYED" },
127 { HSHELL_ACTIVATESHELLWINDOW, L"HSHELL_ACTIVATESHELLWINDOW" },
128 { HSHELL_WINDOWACTIVATED, L"HSHELL_WINDOWACTIVATED" },
129 { HSHELL_GETMINRECT, L"HSHELL_GETMINRECT" },
130 { HSHELL_REDRAW, L"HSHELL_REDRAW" },
131 { HSHELL_TASKMAN, L"HSHELL_TASKMAN" },
132 { HSHELL_LANGUAGE, L"HSHELL_LANGUAGE" },
133 { HSHELL_SYSMENU, L"HSHELL_SYSMENU" },
134 { HSHELL_ENDTASK, L"HSHELL_ENDTASK" },
135 { HSHELL_ACCESSIBILITYSTATE, L"HSHELL_ACCESSIBILITYSTATE" },
136 { HSHELL_APPCOMMAND, L"HSHELL_APPCOMMAND" },
137 { HSHELL_WINDOWREPLACED, L"HSHELL_WINDOWREPLACED" },
138 { HSHELL_WINDOWREPLACING, L"HSHELL_WINDOWREPLACING" },
139 { HSHELL_RUDEAPPACTIVATED, L"HSHELL_RUDEAPPACTIVATED" },
140};
141#endif
142
143typedef struct _TASK_GROUP
144{
145 /* We have to use a linked list instead of an array so we don't have to
146 update all pointers to groups in the task item array when removing
147 groups. */
149
153 union
154 {
156 struct
157 {
158
160 };
161 };
163
164typedef struct _TASK_ITEM
165{
170
171 union
172 {
174 struct
175 {
176
177 /* IsFlashing is TRUE when the task bar item should be flashing. */
179
180 /* RenderFlashed is only TRUE if the task bar item should be
181 drawn with a flash. */
183 };
184 };
186
187
189{
197public:
198
200 m_ThreadId(0),
203 m_Status(NULL),
205 {
206 }
207
209 {
211 {
212 /* Try to unstuck Show */
215 if (ret == WAIT_TIMEOUT)
218 }
219 }
220
222 {
223 HRESULT hr;
224 CComPtr<IUserNotification> pnotification;
225
228 return hr;
229
230 hr = CoCreateInstance(CLSID_UserNotification,
231 NULL,
232 CLSCTX_INPROC_SERVER,
233 IID_PPV_ARG(IUserNotification, &pnotification));
235 return hr;
236
237 hr = pnotification->SetBalloonInfo(m_Title, m_Text, NIIF_WARNING);
239 return hr;
240
241 hr = pnotification->SetIconInfo(NULL, NULL);
243 return hr;
244
245 /* Show will block until the balloon closes */
246 hr = pnotification->Show(NULL, 0);
248 return hr;
249
250 return S_OK;
251 }
252
254 {
255 CHardErrorThread* pThis = reinterpret_cast<CHardErrorThread*>(lpParameter);
256 pThis->ThreadProc();
257 CloseHandle(pThis->m_hThread);
260 return 0;
261 }
262
264 {
266
267 /* Ignore the new message if we are already showing one */
268 if (bIsRunning)
269 return;
270
271 m_Status = pData->Status;
272 m_dwType = pData->dwType;
273 m_Title = (PWCHAR)((ULONG_PTR)pData + pData->TitleOffset);
274 m_Text = (PWCHAR)((ULONG_PTR)pData + pData->MessageOffset);
276 if (!m_hThread)
277 {
280 }
281 }
282};
283
285 public CWindowImplBaseT< CToolbar<TASK_ITEM>, CControlWinTraits >
286{
287public:
288 INT UpdateTbButtonSpacing(IN BOOL bHorizontal, IN BOOL bThemed, IN UINT uiRows = 0, IN UINT uiBtnsPerLine = 0)
289 {
290 TBMETRICS tbm;
291
292 tbm.cbSize = sizeof(tbm);
294
295 tbm.cxBarPad = tbm.cyBarPad = 0;
296
297 if (bThemed)
298 {
299 tbm.cxButtonSpacing = 0;
300 tbm.cyButtonSpacing = 0;
301 }
302 else
303 {
304 if (bHorizontal || uiBtnsPerLine > 1)
306 else
307 tbm.cxButtonSpacing = 0;
308
309 if (!bHorizontal || uiRows > 1)
311 else
312 tbm.cyButtonSpacing = 0;
313 }
314
315 SetMetrics(&tbm);
316
317 return tbm.cxButtonSpacing;
318 }
319
321 {
323 }
324
326 {
329 }
330
331 BOOL SetButtonCommandId(IN INT iButtonIndex, IN INT iCommandId)
332 {
333 TBBUTTONINFO tbbi;
334
335 tbbi.cbSize = sizeof(tbbi);
336 tbbi.dwMask = TBIF_BYINDEX | TBIF_COMMAND;
337 tbbi.idCommand = iCommandId;
338
339 return SetButtonInfo(iButtonIndex, &tbbi) != 0;
340 }
341
343 {
344 POINT pt;
345
346 /* See if the mouse is on a button */
350
351 INT index = HitTest(&pt);
352 if (index < 0)
353 {
354 /* Make the control appear to be transparent outside of any buttons */
355 return HTTRANSPARENT;
356 }
357
358 bHandled = FALSE;
359 return 0;
360 }
361
362public:
366
368 {
372
373 // HACK & FIXME: CORE-18016
374 HWND toolbar = CToolbar::Create(hWndParent, styles);
375 m_hWnd = NULL;
376 return SubclassWindow(toolbar);
377 }
378};
379
381 public CComCoClass<CTaskSwitchWnd>,
382 public CComObjectRootEx<CComMultiThreadModelNoCS>,
383 public CWindowImpl < CTaskSwitchWnd, CWindow, CControlWinTraits >,
384 public IOleWindow
385{
387
389
391
394
398
402
404
407
409
411
414
415public:
423 m_Theme(NULL),
425 m_ButtonCount(0),
430 {
433 }
434 virtual ~CTaskSwitchWnd() { }
435
437 {
438 /* Get the window text without sending a message so we don't hang if an
439 application isn't responding! */
440 return InternalGetWindowText(TaskItem->hWnd, szBuf, cchBuf);
441 }
442
443
444#if DUMP_TASKS != 0
445 VOID DumpTasks()
446 {
447 PTASK_GROUP CurrentGroup;
448 PTASK_ITEM CurrentTaskItem, LastTaskItem;
449
450 TRACE("Tasks dump:\n");
452 {
453 CurrentGroup = m_TaskGroups;
454 while (CurrentGroup != NULL)
455 {
456 TRACE("- Group PID: 0x%p Tasks: %d Index: %d\n", CurrentGroup->dwProcessId, CurrentGroup->dwTaskCount, CurrentGroup->Index);
457
458 CurrentTaskItem = m_TaskItems;
459 LastTaskItem = CurrentTaskItem + m_TaskItemCount;
460 while (CurrentTaskItem != LastTaskItem)
461 {
462 if (CurrentTaskItem->Group == CurrentGroup)
463 {
464 TRACE(" + Task hwnd: 0x%p Index: %d\n", CurrentTaskItem->hWnd, CurrentTaskItem->Index);
465 }
466 CurrentTaskItem++;
467 }
468
469 CurrentGroup = CurrentGroup->Next;
470 }
471
472 CurrentTaskItem = m_TaskItems;
473 LastTaskItem = CurrentTaskItem + m_TaskItemCount;
474 while (CurrentTaskItem != LastTaskItem)
475 {
476 if (CurrentTaskItem->Group == NULL)
477 {
478 TRACE("- Task hwnd: 0x%p Index: %d\n", CurrentTaskItem->hWnd, CurrentTaskItem->Index);
479 }
480 CurrentTaskItem++;
481 }
482 }
483 else
484 {
485 CurrentTaskItem = m_TaskItems;
486 LastTaskItem = CurrentTaskItem + m_TaskItemCount;
487 while (CurrentTaskItem != LastTaskItem)
488 {
489 TRACE("- Task hwnd: 0x%p Index: %d\n", CurrentTaskItem->hWnd, CurrentTaskItem->Index);
490 CurrentTaskItem++;
491 }
492 }
493 }
494#endif
495
496 VOID UpdateIndexesAfter(IN INT iIndex, BOOL bInserted)
497 {
498 PTASK_GROUP CurrentGroup;
499 PTASK_ITEM CurrentTaskItem, LastTaskItem;
500 INT NewIndex;
501
502 int offset = bInserted ? +1 : -1;
503
505 {
506 /* Update all affected groups */
507 CurrentGroup = m_TaskGroups;
508 while (CurrentGroup != NULL)
509 {
510 if (CurrentGroup->IsCollapsed &&
511 CurrentGroup->Index >= iIndex)
512 {
513 /* Update the toolbar buttons */
514 NewIndex = CurrentGroup->Index + offset;
515 if (m_TaskBar.SetButtonCommandId(CurrentGroup->Index + offset, NewIndex))
516 {
517 CurrentGroup->Index = NewIndex;
518 }
519 else
520 CurrentGroup->Index = -1;
521 }
522
523 CurrentGroup = CurrentGroup->Next;
524 }
525 }
526
527 /* Update all affected task items */
528 CurrentTaskItem = m_TaskItems;
529 LastTaskItem = CurrentTaskItem + m_TaskItemCount;
530 while (CurrentTaskItem != LastTaskItem)
531 {
532 CurrentGroup = CurrentTaskItem->Group;
533 if (CurrentGroup != NULL)
534 {
535 if (!CurrentGroup->IsCollapsed &&
536 CurrentTaskItem->Index >= iIndex)
537 {
538 goto UpdateTaskItemBtn;
539 }
540 }
541 else if (CurrentTaskItem->Index >= iIndex)
542 {
543 UpdateTaskItemBtn:
544 /* Update the toolbar buttons */
545 NewIndex = CurrentTaskItem->Index + offset;
546 if (m_TaskBar.SetButtonCommandId(CurrentTaskItem->Index + offset, NewIndex))
547 {
548 CurrentTaskItem->Index = NewIndex;
549 }
550 else
551 CurrentTaskItem->Index = -1;
552 }
553
554 CurrentTaskItem++;
555 }
556 }
557
558
560 {
561 ASSERT(TaskGroup->Index >= 0);
562
563 /* FIXME: Implement */
564
565 return TaskGroup->Index;
566 }
567
569 {
570 ASSERT(TaskGroup->dwTaskCount > 0);
571 ASSERT(TaskGroup->IsCollapsed);
572 ASSERT(TaskGroup->Index >= 0);
573
574 /* FIXME: Implement */
575 }
576
578 {
579 HICON hIcon = NULL;
580
581 /* Retrieve icon by sending a message */
582#define GET_ICON(type) \
583 SendMessageTimeout(hwnd, WM_GETICON, (type), 0, SMTO_NOTIMEOUTIFNOTHUNG, 100, (PDWORD_PTR)&hIcon)
584
585 LRESULT bAlive = GET_ICON(g_TaskbarSettings.bSmallIcons ? ICON_SMALL2 : ICON_BIG);
586 if (hIcon)
587 return hIcon;
588
589 if (bAlive)
590 {
591 bAlive = GET_ICON(ICON_SMALL);
592 if (hIcon)
593 return hIcon;
594 }
595
596 if (bAlive)
597 {
599 if (hIcon)
600 return hIcon;
601 }
602#undef GET_ICON
603
604 /* If we failed, retrieve icon from the window class */
606 if (hIcon)
607 return hIcon;
608
610 }
611
613 {
614 TBBUTTONINFO tbbi = { 0 };
615 HICON icon;
616 WCHAR windowText[255];
617
618 ASSERT(TaskItem->Index >= 0);
619
620 tbbi.cbSize = sizeof(tbbi);
621 tbbi.dwMask = TBIF_BYINDEX | TBIF_STATE | TBIF_TEXT | TBIF_IMAGE;
622 tbbi.fsState = TBSTATE_ENABLED;
623 if (m_ActiveTaskItem == TaskItem)
624 tbbi.fsState |= TBSTATE_CHECKED;
625
626 if (TaskItem->RenderFlashed)
627 tbbi.fsState |= TBSTATE_MARKED;
628
629 /* Check if we're updating a button that is the last one in the
630 line. If so, we need to set the TBSTATE_WRAP flag! */
631 if (!m_Tray->IsHorizontal() || (m_ButtonsPerLine != 0 &&
632 (TaskItem->Index + 1) % m_ButtonsPerLine == 0))
633 {
634 tbbi.fsState |= TBSTATE_WRAP;
635 }
636
638 {
639 tbbi.pszText = windowText;
640 }
641
642 icon = GetWndIcon(TaskItem->hWnd);
643 if (!icon)
644 icon = static_cast<HICON>(LoadImageW(NULL, MAKEINTRESOURCEW(OIC_SAMPLE), IMAGE_ICON, 0, 0, LR_SHARED | LR_DEFAULTSIZE));
645 TaskItem->IconIndex = ImageList_ReplaceIcon(m_ImageList, TaskItem->IconIndex, icon);
646 tbbi.iImage = TaskItem->IconIndex;
647
648 if (!m_TaskBar.SetButtonInfo(TaskItem->Index, &tbbi))
649 {
650 TaskItem->Index = -1;
651 return -1;
652 }
653
654 TRACE("Updated button %d for hwnd 0x%p\n", TaskItem->Index, TaskItem->hWnd);
655 return TaskItem->Index;
656 }
657
659 {
660 TBBUTTONINFO tbbi;
661 PTASK_ITEM currentTaskItem, LastItem;
662
663 if (TaskItem->IconIndex == -1)
664 return;
665
666 tbbi.cbSize = sizeof(tbbi);
667 tbbi.dwMask = TBIF_IMAGE;
668
669 currentTaskItem = m_TaskItems;
670 LastItem = currentTaskItem + m_TaskItemCount;
671 while (currentTaskItem != LastItem)
672 {
673 if (currentTaskItem->IconIndex > TaskItem->IconIndex)
674 {
675 currentTaskItem->IconIndex--;
676 tbbi.iImage = currentTaskItem->IconIndex;
677
678 m_TaskBar.SetButtonInfo(currentTaskItem->Index, &tbbi);
679 }
680 currentTaskItem++;
681 }
682
683 ImageList_Remove(m_ImageList, TaskItem->IconIndex);
684 }
685
687 IN PTASK_GROUP TaskGroup OPTIONAL,
688 IN PTASK_ITEM NewTaskItem OPTIONAL)
689 {
690 PTASK_ITEM TaskItem, LastTaskItem, FoundTaskItem = NULL;
691 DWORD dwTaskCount;
692
694
695 TaskItem = m_TaskItems;
696 LastTaskItem = TaskItem + m_TaskItemCount;
697
698 dwTaskCount = (TaskGroup != NULL ? TaskGroup->dwTaskCount : MAX_TASKS_COUNT);
699
700 ASSERT(dwTaskCount > 0);
701
702 while (TaskItem != LastTaskItem)
703 {
704 if (TaskItem->Group == TaskGroup)
705 {
706 if ((NewTaskItem != NULL && TaskItem != NewTaskItem) || NewTaskItem == NULL)
707 {
708 FoundTaskItem = TaskItem;
709 }
710
711 if (--dwTaskCount == 0)
712 {
713 /* We found the last task item in the group! */
714 break;
715 }
716 }
717
718 TaskItem++;
719 }
720
721 return FoundTaskItem;
722 }
723
725 {
726 PTASK_GROUP TaskGroup;
727 PTASK_ITEM LastTaskItem;
728
729 /* NOTE: This routine assumes that the group is *not* collapsed! */
730
731 TaskGroup = TaskItem->Group;
733 {
734 if (TaskGroup != NULL)
735 {
736 ASSERT(TaskGroup->Index < 0);
737 ASSERT(!TaskGroup->IsCollapsed);
738
739 if (TaskGroup->dwTaskCount > 1)
740 {
741 LastTaskItem = FindLastTaskItemOfGroup(TaskGroup, TaskItem);
742 if (LastTaskItem != NULL)
743 {
744 /* Since the group is expanded the task items must have an index */
745 ASSERT(LastTaskItem->Index >= 0);
746
747 return LastTaskItem->Index + 1;
748 }
749 }
750 }
751 else
752 {
753 /* Find the last NULL group button. NULL groups are added at the end of the
754 task item list when grouping is enabled */
755 LastTaskItem = FindLastTaskItemOfGroup(NULL, TaskItem);
756 if (LastTaskItem != NULL)
757 {
758 ASSERT(LastTaskItem->Index >= 0);
759
760 return LastTaskItem->Index + 1;
761 }
762 }
763 }
764
765 return m_ButtonCount;
766 }
767
769 {
770 WCHAR windowText[255];
771 TBBUTTON tbBtn = { 0 };
772 INT iIndex;
773 HICON icon;
774
775 if (TaskItem->Index >= 0)
776 {
777 return UpdateTaskItemButton(TaskItem);
778 }
779
780 if (TaskItem->Group != NULL &&
781 TaskItem->Group->IsCollapsed)
782 {
783 /* The task group is collapsed, we only need to update the group button */
784 return UpdateTaskGroupButton(TaskItem->Group);
785 }
786
787 icon = GetWndIcon(TaskItem->hWnd);
788 if (!icon)
789 icon = static_cast<HICON>(LoadImageW(NULL, MAKEINTRESOURCEW(OIC_SAMPLE), IMAGE_ICON, 0, 0, LR_SHARED | LR_DEFAULTSIZE));
790 TaskItem->IconIndex = ImageList_ReplaceIcon(m_ImageList, -1, icon);
791
792 tbBtn.iBitmap = TaskItem->IconIndex;
795 tbBtn.dwData = TaskItem->Index;
796
798 {
799 tbBtn.iString = (DWORD_PTR) windowText;
800 }
801
802 /* Find out where to insert the new button */
803 iIndex = CalculateTaskItemNewButtonIndex(TaskItem);
804 ASSERT(iIndex >= 0);
805 tbBtn.idCommand = iIndex;
806
808
809 if (m_TaskBar.InsertButton(iIndex, &tbBtn))
810 {
811 UpdateIndexesAfter(iIndex, TRUE);
812
813 TRACE("Added button %d for hwnd 0x%p\n", iIndex, TaskItem->hWnd);
814
815 TaskItem->Index = iIndex;
817
818 /* Update button sizes and fix the button wrapping */
820 return iIndex;
821 }
822
824
825 return -1;
826 }
827
829 {
830 PTASK_GROUP TaskGroup;
831 INT iIndex;
832
833 TaskGroup = TaskItem->Group;
834
835 if (TaskItem->Index >= 0)
836 {
837 if ((TaskGroup != NULL && !TaskGroup->IsCollapsed) ||
838 TaskGroup == NULL)
839 {
841
842 RemoveIcon(TaskItem);
843 iIndex = TaskItem->Index;
844 if (m_TaskBar.DeleteButton(iIndex))
845 {
846 TaskItem->Index = -1;
848
849 UpdateIndexesAfter(iIndex, FALSE);
850
851 /* Update button sizes and fix the button wrapping */
853 return TRUE;
854 }
855
857 }
858 }
859
860 return FALSE;
861 }
862
864 {
865 DWORD dwProcessId;
866 PTASK_GROUP TaskGroup, *PrevLink;
867
869 &dwProcessId))
870 {
871 TRACE("Cannot get process id of hwnd 0x%p\n", hWnd);
872 return NULL;
873 }
874
875 /* Try to find an existing task group */
876 TaskGroup = m_TaskGroups;
877 PrevLink = &m_TaskGroups;
878 while (TaskGroup != NULL)
879 {
880 if (TaskGroup->dwProcessId == dwProcessId)
881 {
882 TaskGroup->dwTaskCount++;
883 return TaskGroup;
884 }
885
886 PrevLink = &TaskGroup->Next;
887 TaskGroup = TaskGroup->Next;
888 }
889
890 /* Allocate a new task group */
891 TaskGroup = (PTASK_GROUP) HeapAlloc(hProcessHeap,
893 sizeof(*TaskGroup));
894 if (TaskGroup != NULL)
895 {
896 TaskGroup->dwTaskCount = 1;
897 TaskGroup->dwProcessId = dwProcessId;
898 TaskGroup->Index = -1;
899
900 /* Add the task group to the list */
901 *PrevLink = TaskGroup;
902 }
903
904 return TaskGroup;
905 }
906
908 {
909 PTASK_GROUP TaskGroup, CurrentGroup, *PrevLink;
910
911 TaskGroup = TaskItem->Group;
912 if (TaskGroup != NULL)
913 {
914 DWORD dwNewTaskCount = --TaskGroup->dwTaskCount;
915 if (dwNewTaskCount == 0)
916 {
917 /* Find the previous pointer in the chain */
918 CurrentGroup = m_TaskGroups;
919 PrevLink = &m_TaskGroups;
920 while (CurrentGroup != TaskGroup)
921 {
922 PrevLink = &CurrentGroup->Next;
923 CurrentGroup = CurrentGroup->Next;
924 }
925
926 /* Remove the group from the list */
927 ASSERT(TaskGroup == CurrentGroup);
928 *PrevLink = TaskGroup->Next;
929
930 /* Free the task group */
932 0,
933 TaskGroup);
934 }
935 else if (TaskGroup->IsCollapsed &&
936 TaskGroup->Index >= 0)
937 {
938 if (dwNewTaskCount > 1)
939 {
940 /* FIXME: Check if we should expand the group */
941 /* Update the task group button */
942 UpdateTaskGroupButton(TaskGroup);
943 }
944 else
945 {
946 /* Expand the group of one task button to a task button */
947 ExpandTaskGroup(TaskGroup);
948 }
949 }
950 }
951 }
952
954 {
955 PTASK_ITEM TaskItem, LastItem;
956
957 TaskItem = m_TaskItems;
958 LastItem = TaskItem + m_TaskItemCount;
959 while (TaskItem != LastItem)
960 {
961 if (TaskItem->hWnd == hWnd)
962 return TaskItem;
963
964 TaskItem++;
965 }
966
967 return NULL;
968 }
969
971 {
972 PTASK_ITEM LastItem, TaskItem;
973 PTASK_GROUP TaskGroup;
974 DWORD dwProcessId;
975
976 if (!GetWindowThreadProcessId(hWnd, &dwProcessId))
977 {
978 return NULL;
979 }
980
981 /* Try to find another task that belongs to the same
982 process as the given window */
983 TaskItem = m_TaskItems;
984 LastItem = TaskItem + m_TaskItemCount;
985 while (TaskItem != LastItem)
986 {
987 TaskGroup = TaskItem->Group;
988 if (TaskGroup != NULL)
989 {
990 if (TaskGroup->dwProcessId == dwProcessId)
991 return TaskItem;
992 }
993 else
994 {
995 DWORD dwProcessIdTask;
996
997 if (GetWindowThreadProcessId(TaskItem->hWnd,
998 &dwProcessIdTask) &&
999 dwProcessIdTask == dwProcessId)
1000 {
1001 return TaskItem;
1002 }
1003 }
1004
1005 TaskItem++;
1006 }
1007
1008 return NULL;
1009 }
1010
1012 {
1014 {
1015 /* We need the most significant bit in 16 bit command IDs to indicate whether it
1016 is a task group or task item. WM_COMMAND limits command IDs to 16 bits! */
1017 return NULL;
1018 }
1019
1021
1022 if (m_TaskItemCount == 0)
1023 {
1025 0,
1027 if (m_TaskItems != NULL)
1028 {
1030 }
1031 else
1032 return NULL;
1033 }
1035 {
1036 PTASK_ITEM NewArray;
1037 SIZE_T NewArrayLength, ActiveTaskItemIndex;
1038
1040
1041 NewArray = (PTASK_ITEM) HeapReAlloc(hProcessHeap,
1042 0,
1044 NewArrayLength * sizeof(*m_TaskItems));
1045 if (NewArray != NULL)
1046 {
1047 if (m_ActiveTaskItem != NULL)
1048 {
1049 /* Fixup the ActiveTaskItem pointer */
1050 ActiveTaskItemIndex = m_ActiveTaskItem - m_TaskItems;
1051 m_ActiveTaskItem = NewArray + ActiveTaskItemIndex;
1052 }
1053 m_AllocatedTaskItems = (WORD) NewArrayLength;
1054 m_TaskItems = NewArray;
1055 }
1056 else
1057 return NULL;
1058 }
1059
1060 return m_TaskItems + m_TaskItemCount++;
1061 }
1062
1064 {
1065 WORD wIndex;
1066
1067 if (TaskItem == m_ActiveTaskItem)
1069
1070 wIndex = (WORD) (TaskItem - m_TaskItems);
1071 if (wIndex + 1 < m_TaskItemCount)
1072 {
1073 MoveMemory(TaskItem,
1074 TaskItem + 1,
1075 (m_TaskItemCount - wIndex - 1) * sizeof(*TaskItem));
1076 }
1077
1079 }
1080
1082 {
1083 if (!m_IsDestroying)
1084 {
1085 /* Delete the task button from the toolbar */
1086 DeleteTaskItemButton(TaskItem);
1087 }
1088
1089 /* Remove the task from it's group */
1090 RemoveTaskFromTaskGroup(TaskItem);
1091
1092 /* Free the task item */
1093 FreeTaskItem(TaskItem);
1094 }
1095
1097 {
1098 PTASK_ITEM CurrentTaskItem;
1099 PTASK_GROUP TaskGroup = NULL;
1100
1101 CurrentTaskItem = m_ActiveTaskItem;
1102
1103 if (TaskItem != NULL)
1104 TaskGroup = TaskItem->Group;
1105
1106 if (m_IsGroupingEnabled &&
1107 TaskGroup != NULL &&
1108 TaskGroup->IsCollapsed)
1109 {
1110 /* FIXME */
1111 return;
1112 }
1113
1114 if (CurrentTaskItem != NULL)
1115 {
1116 PTASK_GROUP CurrentTaskGroup;
1117
1118 if (CurrentTaskItem == TaskItem)
1119 return;
1120
1121 CurrentTaskGroup = CurrentTaskItem->Group;
1122
1123 if (m_IsGroupingEnabled &&
1124 CurrentTaskGroup != NULL &&
1125 CurrentTaskGroup->IsCollapsed)
1126 {
1127 if (CurrentTaskGroup == TaskGroup)
1128 return;
1129
1130 /* FIXME */
1131 }
1132 else
1133 {
1135 if (CurrentTaskItem->Index >= 0)
1136 {
1137 UpdateTaskItemButton(CurrentTaskItem);
1138 }
1139 }
1140 }
1141
1142 m_ActiveTaskItem = TaskItem;
1143
1144 if (TaskItem != NULL && TaskItem->Index >= 0)
1145 {
1146 UpdateTaskItemButton(TaskItem);
1147 }
1148 else if (TaskItem == NULL)
1149 {
1150 TRACE("Active TaskItem now NULL\n");
1151 }
1152 }
1153
1155 {
1156 PTASK_ITEM TaskItem, LastItem;
1157
1158 TaskItem = m_TaskItems;
1159 LastItem = TaskItem + m_TaskItemCount;
1160 while (TaskItem != LastItem)
1161 {
1162 if (TaskItem->Index == Index)
1163 return TaskItem;
1164
1165 TaskItem++;
1166 }
1167
1168 return NULL;
1169 }
1170
1172 {
1173 PTASK_GROUP CurrentGroup;
1174
1175 CurrentGroup = m_TaskGroups;
1176 while (CurrentGroup != NULL)
1177 {
1178 if (CurrentGroup->Index == Index)
1179 break;
1180
1181 CurrentGroup = CurrentGroup->Next;
1182 }
1183
1184 return CurrentGroup;
1185 }
1186
1188 {
1189 PTASK_ITEM TaskItem;
1190
1191 if (!::IsWindow(hWnd) || m_Tray->IsSpecialHWND(hWnd))
1192 return FALSE;
1193
1194 TaskItem = FindTaskItem(hWnd);
1195 if (TaskItem == NULL)
1196 {
1197 TRACE("Add window 0x%p\n", hWnd);
1198 TaskItem = AllocTaskItem();
1199 if (TaskItem != NULL)
1200 {
1201 ZeroMemory(TaskItem, sizeof(*TaskItem));
1202 TaskItem->hWnd = hWnd;
1203 TaskItem->Index = -1;
1204 TaskItem->Group = AddToTaskGroup(hWnd);
1205
1206 if (!m_IsDestroying)
1207 {
1208 AddTaskItemButton(TaskItem);
1209 }
1210 }
1211 }
1212
1213 return TaskItem != NULL;
1214 }
1215
1217 {
1218 if (TaskItem != NULL)
1219 {
1220 TRACE("Activate window 0x%p on button %d\n", TaskItem->hWnd, TaskItem->Index);
1221 }
1222
1223 CheckActivateTaskItem(TaskItem);
1224 return FALSE;
1225 }
1226
1228 {
1229 PTASK_ITEM TaskItem;
1230
1231 if (!hWnd)
1232 {
1233 return ActivateTaskItem(NULL);
1234 }
1235
1236 TaskItem = FindTaskItem(hWnd);
1237 if (TaskItem == NULL)
1238 {
1239 TaskItem = FindOtherTaskItem(hWnd);
1240 }
1241
1242 if (TaskItem == NULL)
1243 {
1244 WARN("Activate window 0x%p, could not find task\n", hWnd);
1246 }
1247
1248 return ActivateTaskItem(TaskItem);
1249 }
1250
1252 {
1253 PTASK_ITEM TaskItem;
1254
1255 TaskItem = FindTaskItem(hWnd);
1256 if (TaskItem != NULL)
1257 {
1258 TRACE("Delete window 0x%p on button %d\n", hWnd, TaskItem->Index);
1259 DeleteTaskItem(TaskItem);
1260 return TRUE;
1261 }
1262 //else
1263 //TRACE("Failed to delete window 0x%p\n", hWnd);
1264
1265 return FALSE;
1266 }
1267
1269 {
1270 PTASK_ITEM CurrentTask;
1271
1272 if (m_TaskItemCount > 0)
1273 {
1274 CurrentTask = m_TaskItems + m_TaskItemCount;
1275 do
1276 {
1277 DeleteTaskItem(--CurrentTask);
1278 } while (CurrentTask != m_TaskItems);
1279 }
1280 }
1281
1283 {
1284 TaskItem->RenderFlashed = 1;
1285 UpdateTaskItemButton(TaskItem);
1286 }
1287
1289 {
1290 PTASK_ITEM TaskItem;
1291
1292 TaskItem = FindTaskItem(hWnd);
1293 if (TaskItem != NULL)
1294 {
1295 TRACE("Flashing window 0x%p on button %d\n", hWnd, TaskItem->Index);
1296 FlashTaskItem(TaskItem);
1297 return TRUE;
1298 }
1299
1300 return FALSE;
1301 }
1302
1304 {
1305 PTASK_GROUP TaskGroup;
1306
1307 TaskGroup = TaskItem->Group;
1308 if (m_IsGroupingEnabled && TaskGroup != NULL)
1309 {
1310 if (TaskGroup->IsCollapsed && TaskGroup->Index >= 0)
1311 {
1312 UpdateTaskGroupButton(TaskGroup);
1313 }
1314 else if (TaskItem->Index >= 0)
1315 {
1316 goto UpdateTaskItem;
1317 }
1318 }
1319 else if (TaskItem->Index >= 0)
1320 {
1321 UpdateTaskItem:
1322 TaskItem->RenderFlashed = 0;
1323 UpdateTaskItemButton(TaskItem);
1324 }
1325 }
1326
1327
1329 {
1330 PTASK_ITEM TaskItem;
1331
1332 TaskItem = FindTaskItem(hWnd);
1333 if (TaskItem != NULL)
1334 {
1335 RedrawTaskItem(TaskItem);
1336 return TRUE;
1337 }
1338
1339 return FALSE;
1340 }
1341
1343 {
1344 RECT rcClient;
1345 UINT uiRows, uiMax, uiMin, uiBtnsPerLine, ui;
1346 LONG NewBtnSize;
1347 BOOL Horizontal;
1348
1349 /* Update the size of the image list if needed */
1350 int cx, cy;
1354 {
1358
1359 /* SetIconSize removes all icons so we have to reinsert them */
1360 PTASK_ITEM TaskItem = m_TaskItems;
1361 PTASK_ITEM LastTaskItem = m_TaskItems + m_TaskItemCount;
1362 while (TaskItem != LastTaskItem)
1363 {
1364 TaskItem->IconIndex = -1;
1365 UpdateTaskItemButton(TaskItem);
1366
1367 TaskItem++;
1368 }
1369 m_TaskBar.SetImageList(m_ImageList);
1370 }
1371
1372 if (GetClientRect(&rcClient) && !IsRectEmpty(&rcClient))
1373 {
1374 if (m_ButtonCount > 0)
1375 {
1376 Horizontal = m_Tray->IsHorizontal();
1377
1378 if (Horizontal)
1379 {
1380 TBMETRICS tbm = { 0 };
1381 tbm.cbSize = sizeof(tbm);
1383 m_TaskBar.GetMetrics(&tbm);
1384
1385 if (m_ButtonSize.cy + tbm.cyButtonSpacing != 0)
1386 uiRows = (rcClient.bottom + tbm.cyButtonSpacing) / (m_ButtonSize.cy + tbm.cyButtonSpacing);
1387 else
1388 uiRows = 1;
1389
1390 if (uiRows == 0)
1391 uiRows = 1;
1392
1393 uiBtnsPerLine = (m_ButtonCount + uiRows - 1) / uiRows;
1394 }
1395 else
1396 {
1397 uiBtnsPerLine = 1;
1398 uiRows = m_ButtonCount;
1399 }
1400
1401 if (!bRedrawDisabled)
1403
1404 /* We might need to update the button spacing */
1405 int cxButtonSpacing = m_TaskBar.UpdateTbButtonSpacing(
1406 Horizontal, m_Theme != NULL,
1407 uiRows, uiBtnsPerLine);
1408
1409 /* Determine the minimum and maximum width of a button */
1411 if (Horizontal)
1412 {
1414
1415 /* Calculate the ideal width and make sure it's within the allowed range */
1416 NewBtnSize = (rcClient.right - (uiBtnsPerLine * cxButtonSpacing)) / uiBtnsPerLine;
1417
1418 if (NewBtnSize < (LONG) uiMin)
1419 NewBtnSize = uiMin;
1420 if (NewBtnSize >(LONG)uiMax)
1421 NewBtnSize = uiMax;
1422
1423 /* Recalculate how many buttons actually fit into one line */
1424 uiBtnsPerLine = rcClient.right / (NewBtnSize + cxButtonSpacing);
1425 if (uiBtnsPerLine == 0)
1426 uiBtnsPerLine++;
1427 }
1428 else
1429 {
1430 NewBtnSize = uiMax = rcClient.right;
1431 }
1432
1433 m_ButtonSize.cx = NewBtnSize;
1434
1435 m_ButtonsPerLine = uiBtnsPerLine;
1436
1437 for (ui = 0; ui != m_ButtonCount; ui++)
1438 {
1439 TBBUTTONINFOW tbbi = { 0 };
1440 tbbi.cbSize = sizeof(tbbi);
1442 tbbi.cx = (INT) NewBtnSize;
1443 tbbi.fsState = TBSTATE_ENABLED;
1444
1445 /* Check if we're updating a button that is the last one in the
1446 line. If so, we need to set the TBSTATE_WRAP flag! */
1447 if (Horizontal)
1448 {
1449 if ((ui + 1) % uiBtnsPerLine == 0)
1450 tbbi.fsState |= TBSTATE_WRAP;
1451 }
1452 else
1453 {
1454 tbbi.fsState |= TBSTATE_WRAP;
1455 }
1456
1457 if (m_ActiveTaskItem != NULL &&
1459 {
1460 tbbi.fsState |= TBSTATE_CHECKED;
1461 }
1462
1463 m_TaskBar.SetButtonInfo(ui, &tbbi);
1464 }
1465 }
1466 else
1467 {
1468 m_ButtonsPerLine = 0;
1469 m_ButtonSize.cx = 0;
1470 }
1471 }
1472
1473 // FIXME: This seems to be enabling redraws prematurely, but moving it to its right place doesn't work!
1475 }
1476
1478 {
1479 if (m_Tray->IsTaskWnd(hWnd))
1480 {
1481 TRACE("Adding task for %p...\n", hWnd);
1482 AddTask(hWnd);
1483 }
1484 return TRUE;
1485 }
1486
1488 {
1490
1491 return This->EnumWindowsProc(hWnd);
1492 }
1493
1495 {
1496 TRACE("Refreshing window list...\n");
1497 /* Add all windows to the toolbar */
1498 return EnumWindows(s_EnumWindowsProc, (LPARAM)this);
1499 }
1500
1502 {
1503 TRACE("OmThemeChanged\n");
1504
1505 if (m_Theme)
1507
1508 if (IsThemeActive())
1509 m_Theme = OpenThemeData(m_hWnd, L"TaskBand");
1510 else
1511 m_Theme = NULL;
1512
1513 return TRUE;
1514 }
1515
1517 {
1519 return FALSE;
1520
1521 SetWindowTheme(m_TaskBar.m_hWnd, L"TaskBand", NULL);
1522
1525 ILC_COLOR32 | ILC_MASK, 0, 1000);
1526 m_TaskBar.SetImageList(m_ImageList);
1527
1528 /* Set proper spacing between buttons */
1529 m_TaskBar.UpdateTbButtonSpacing(m_Tray->IsHorizontal(), m_Theme != NULL);
1530
1531 /* Register the shell hook */
1533
1534 TRACE("ShellHookMsg got assigned number %d\n", m_ShellHookMsg);
1535
1536 RegisterShellHook(m_hWnd, 3); /* 1 if no NT! We're targeting NT so we don't care! */
1537
1539
1540 /* Recalculate the button size */
1542
1543#if DUMP_TASKS != 0
1544 SetTimer(hwnd, 1, 5000, NULL);
1545#endif
1546 return TRUE;
1547 }
1548
1550 {
1552
1554
1555 /* Unregister the shell hook */
1557
1560 return TRUE;
1561 }
1562
1564 {
1565 BOOL bResult = FALSE;
1566 WCHAR szBuf[MAX_PATH * 2];
1567 wsprintfW(szBuf, L"%s\\AppKey\\%u", REGSTR_PATH_EXPLORER, uAppCmd);
1568 HUSKEY hKey;
1570 return bResult;
1571
1572 DWORD cb = sizeof(szBuf);
1573 if (!bResult && SHRegQueryUSValueW(hKey, L"ShellExecute", NULL, szBuf, &cb, FALSE, NULL, 0) == ERROR_SUCCESS)
1574 {
1575 bResult = TRUE;
1576 }
1577 cb = sizeof(szBuf);
1578 if (!bResult && SHRegQueryUSValueW(hKey, L"Association", NULL, szBuf, &cb, FALSE, NULL, 0) == ERROR_SUCCESS)
1579 {
1580 bResult = TRUE;
1581 cb = _countof(szBuf);
1583 *szBuf = UNICODE_NULL;
1584 }
1585 cb = sizeof(szBuf);
1586 if (!bResult && SHRegQueryUSValueW(hKey, L"RegisteredApp", NULL, szBuf, &cb, FALSE, NULL, 0) == ERROR_SUCCESS)
1587 {
1588 bResult = TRUE;
1590 *szBuf = UNICODE_NULL; // Don't execute again
1591 }
1593
1594 // Note: Tweak UI uses an empty string for its "Do nothing" option.
1595 if (bResult && *szBuf)
1597 return bResult;
1598 }
1599
1601 {
1602 const UINT uAppCmd = GET_APPCOMMAND_LPARAM(lParam);
1603 if (InvokeRegistryAppKeyCommand(uAppCmd))
1604 return TRUE;
1605 switch (uAppCmd)
1606 {
1607 case APPCOMMAND_VOLUME_MUTE:
1608 case APPCOMMAND_VOLUME_DOWN:
1609 case APPCOMMAND_VOLUME_UP:
1610 // TODO: Try IMMDeviceEnumerator::GetDefaultAudioEndpoint first and then fall back to mixer.
1611 FIXME("Call the mixer API to change the global volume\n");
1612 return TRUE;
1613 case APPCOMMAND_BROWSER_SEARCH:
1614 return SHFindFiles(NULL, NULL);
1615 }
1616 return FALSE;
1617 }
1618
1620 {
1621 BOOL Ret = FALSE;
1622
1623 /* In case the shell hook wasn't registered properly, ignore WM_NULLs*/
1624 if (uMsg == 0)
1625 {
1626 bHandled = FALSE;
1627 return 0;
1628 }
1629
1630 TRACE("Received shell hook message: wParam=%08lx, lParam=%08lx\n", wParam, lParam);
1631
1632 switch ((INT) wParam)
1633 {
1634 case HSHELL_APPCOMMAND:
1635 Ret = HandleAppCommand(0, lParam);
1636 break;
1637
1639 AddTask((HWND) lParam);
1640 break;
1641
1643 /* The window still exists! Delay destroying it a bit */
1646 break;
1647
1649 case HSHELL_WINDOWACTIVATED:
1652 break;
1653
1654 case HSHELL_FLASH:
1656 break;
1657
1658 case HSHELL_REDRAW:
1660 break;
1661
1662 case HSHELL_TASKMAN:
1663 ::PostMessage(m_Tray->GetHWND(), TWM_OPENSTARTMENU, 0, 0);
1664 break;
1665
1667 ::SwitchToThisWindow(m_Tray->GetHWND(), TRUE);
1668 ::SetForegroundWindow(m_Tray->GetHWND());
1669 break;
1670
1671 case HSHELL_LANGUAGE:
1672 case HSHELL_SYSMENU:
1673 case HSHELL_ENDTASK:
1674 case HSHELL_ACCESSIBILITYSTATE:
1675 case HSHELL_WINDOWREPLACED:
1676 case HSHELL_WINDOWREPLACING:
1677
1678 case HSHELL_GETMINRECT:
1679 default:
1680 {
1681#if DEBUG_SHELL_HOOK
1682 int i, found;
1683 for (i = 0, found = 0; i != _countof(hshell_msg); i++)
1684 {
1685 if (hshell_msg[i].msg == (INT) wParam)
1686 {
1687 TRACE("Shell message %ws unhandled (lParam = 0x%p)!\n", hshell_msg[i].msg_name, lParam);
1688 found = 1;
1689 break;
1690 }
1691 }
1692 if (found)
1693 break;
1694#endif
1695 TRACE("Shell message %d unhandled (lParam = 0x%p)!\n", (INT) wParam, lParam);
1696 break;
1697 }
1698 }
1699
1700 return Ret;
1701 }
1702
1704 {
1705 BOOL bIsMinimized;
1706 BOOL bIsActive;
1707
1708 if (::IsWindow(TaskItem->hWnd))
1709 {
1710 bIsMinimized = ::IsIconic(TaskItem->hWnd);
1711 bIsActive = (TaskItem == m_ActiveTaskItem);
1712
1713 TRACE("Active TaskItem %p, selected TaskItem %p\n", m_ActiveTaskItem, TaskItem);
1714 if (m_ActiveTaskItem)
1715 TRACE("Active TaskItem hWnd=%p, TaskItem hWnd %p\n", m_ActiveTaskItem->hWnd, TaskItem->hWnd);
1716
1717 TRACE("Valid button clicked. HWND=%p, IsMinimized=%s, IsActive=%s...\n",
1718 TaskItem->hWnd, bIsMinimized ? "Yes" : "No", bIsActive ? "Yes" : "No");
1719
1720 if (!bIsMinimized && bIsActive)
1721 {
1722 if (!::IsHungAppWindow(TaskItem->hWnd))
1723 ::ShowWindowAsync(TaskItem->hWnd, SW_MINIMIZE);
1724 TRACE("Valid button clicked. App window Minimized.\n");
1725 }
1726 else
1727 {
1728 ::SwitchToThisWindow(TaskItem->hWnd, TRUE);
1729
1730 TRACE("Valid button clicked. App window Restored.\n");
1731 }
1732 }
1733 }
1734
1736 {
1737 /* TODO: Show task group menu */
1738 }
1739
1741 {
1742 PTASK_ITEM TaskItem;
1743 PTASK_GROUP TaskGroup;
1744
1746 {
1747 TaskGroup = FindTaskGroupByIndex((INT) wIndex);
1748 if (TaskGroup != NULL && TaskGroup->IsCollapsed)
1749 {
1750 HandleTaskGroupClick(TaskGroup);
1751 return TRUE;
1752 }
1753 }
1754
1755 TaskItem = FindTaskItemByIndex((INT) wIndex);
1756 if (TaskItem != NULL)
1757 {
1758 HandleTaskItemClick(TaskItem);
1759 return TRUE;
1760 }
1761
1762 return FALSE;
1763 }
1764
1765 static VOID CALLBACK
1767 {
1768 ::PostMessageW(hwnd, WM_NULL, 0, 0);
1769 }
1770
1772 {
1773 POINT pt;
1774 GetCursorPos(&pt);
1775
1776 SetForegroundWindow(TaskItem->hWnd);
1777
1778 ActivateTask(TaskItem->hWnd);
1779
1780 if (GetForegroundWindow() != TaskItem->hWnd)
1781 ERR("HandleTaskItemRightClick detected the window did not become foreground\n");
1782
1783 ::SendMessageCallbackW(TaskItem->hWnd, WM_POPUPSYSTEMMENU, 0, MAKELPARAM(pt.x, pt.y),
1784 SendAsyncProc, (ULONG_PTR)TaskItem);
1785 }
1786
1788 {
1789 /* TODO: Show task group right click menu */
1790 }
1791
1793 {
1794 PTASK_ITEM TaskItem;
1795 PTASK_GROUP TaskGroup;
1797 {
1798 TaskGroup = FindTaskGroupByIndex((INT) wIndex);
1799 if (TaskGroup != NULL && TaskGroup->IsCollapsed)
1800 {
1801 HandleTaskGroupRightClick(TaskGroup);
1802 return TRUE;
1803 }
1804 }
1805
1806 TaskItem = FindTaskItemByIndex((INT) wIndex);
1807
1808 if (TaskItem != NULL)
1809 {
1810 HandleTaskItemRightClick(TaskItem);
1811 return TRUE;
1812 }
1813
1814 return FALSE;
1815 }
1816
1817
1819 {
1820 LRESULT Ret = CDRF_DODEFAULT;
1821 PTASK_GROUP TaskGroup;
1822 PTASK_ITEM TaskItem;
1823
1824 TaskItem = FindTaskItemByIndex((INT) nmtbcd->nmcd.dwItemSpec);
1825 TaskGroup = FindTaskGroupByIndex((INT) nmtbcd->nmcd.dwItemSpec);
1826 if (TaskGroup == NULL && TaskItem != NULL)
1827 {
1828 ASSERT(TaskItem != NULL);
1829
1830 if (TaskItem != NULL && ::IsWindow(TaskItem->hWnd))
1831 {
1832 /* Make the entire button flashing if necessary */
1833 if (nmtbcd->nmcd.uItemState & CDIS_MARKED)
1834 {
1835 Ret = TBCDRF_NOBACKGROUND;
1836 if (!m_Theme)
1837 {
1838 SelectObject(nmtbcd->nmcd.hdc, GetSysColorBrush(COLOR_HIGHLIGHT));
1839 Rectangle(nmtbcd->nmcd.hdc,
1840 nmtbcd->nmcd.rc.left,
1841 nmtbcd->nmcd.rc.top,
1842 nmtbcd->nmcd.rc.right,
1843 nmtbcd->nmcd.rc.bottom);
1844 }
1845 else
1846 {
1847 DrawThemeBackground(m_Theme, nmtbcd->nmcd.hdc, TDP_FLASHBUTTON, 0, &nmtbcd->nmcd.rc, 0);
1848 }
1849 nmtbcd->clrText = GetSysColor(COLOR_HIGHLIGHTTEXT);
1850 return Ret;
1851 }
1852 }
1853 }
1854 else if (TaskGroup != NULL)
1855 {
1856 /* FIXME: Implement painting for task groups */
1857 }
1858 return Ret;
1859 }
1860
1862 {
1863 LRESULT Ret = 0;
1864
1865 switch (nmh->code)
1866 {
1867 case NM_CUSTOMDRAW:
1868 {
1869 LPNMTBCUSTOMDRAW nmtbcd = (LPNMTBCUSTOMDRAW) nmh;
1870
1871 switch (nmtbcd->nmcd.dwDrawStage)
1872 {
1873
1874 case CDDS_ITEMPREPAINT:
1875 Ret = HandleItemPaint(nmtbcd);
1876 break;
1877
1878 case CDDS_PREPAINT:
1879 Ret = CDRF_NOTIFYITEMDRAW;
1880 break;
1881
1882 default:
1883 Ret = CDRF_DODEFAULT;
1884 break;
1885 }
1886 break;
1887 }
1888 }
1889
1890 return Ret;
1891 }
1892
1893 // Internal structure for IsRudeEnumProc
1894 typedef struct tagRUDEAPPDATA
1895 {
1900
1901 // Find any rude app
1902 static BOOL CALLBACK
1904 {
1906
1907 HMONITOR hMon = ::MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
1908 if (!hMon ||
1909 (pData->hTargetMonitor && pData->hTargetMonitor != hMon) ||
1910 !SHELL_IsRudeWindow(hMon, hwnd, (hwnd == pData->hwndFirstCheck)))
1911 {
1912 return TRUE; // Continue
1913 }
1914
1915 pData->hwndFound = hwnd;
1916 return FALSE; // Finish
1917 }
1918
1919 // Internal structure for FullScreenEnumProc
1920 typedef struct tagFULLSCREENDATA
1921 {
1922 const RECT *pRect;
1924 ITrayWindow *pTray;
1926
1927 // Notify ABN_FULLSCREENAPP for each monitor
1928 static BOOL CALLBACK
1930 {
1932
1933 BOOL bFullOpening = (pData->hTargetMonitor == hMonitor);
1934 if (!bFullOpening && pData->pRect)
1935 {
1936 RECT rc, rcMon;
1937 SHELL_GetMonitorRect(hMonitor, &rcMon, FALSE);
1938 ::IntersectRect(&rc, &rcMon, pData->pRect);
1939 bFullOpening = ::EqualRect(&rc, &rcMon);
1940 }
1941
1942 // Notify ABN_FULLSCREENAPP to appbars
1943 pData->pTray->NotifyFullScreenToAppBars(hMonitor, bFullOpening);
1944 return TRUE;
1945 }
1946
1948 {
1949 // Notify ABN_FULLSCREENAPP for every monitor
1950 RECT rc;
1952 if (hwndRude && ::GetWindowRect(hwndRude, &rc))
1953 {
1954 Data.pRect = &rc;
1955 Data.hTargetMonitor = ::MonitorFromWindow(hwndRude, MONITOR_DEFAULTTONULL);
1956 }
1957 Data.pTray = m_Tray;
1959
1960 // Make the taskbar bottom or top
1962 HWND hwndTray = m_Tray->GetHWND();
1963 ::SetWindowPos(hwndTray, (hwndRude ? HWND_BOTTOM : HWND_TOP), 0, 0, 0, 0, uFlags);
1964
1965 if (hwndRude)
1966 {
1967 DWORD exstyle = (DWORD)::GetWindowLongPtrW(hwndRude, GWL_EXSTYLE);
1968 if (!(exstyle & WS_EX_TOPMOST) && !SHELL_IsRudeWindowActive(hwndRude))
1969 ::SwitchToThisWindow(hwndRude, TRUE);
1970 }
1971
1972 // FIXME: NIN_BALLOONHIDE
1973 // FIXME: NIN_POPUPCLOSE
1974 }
1975
1977 {
1978 // Quick check
1979 HMONITOR hMon = MonitorFromWindow(hwndFirstCheck, MONITOR_DEFAULTTONEAREST);
1980 RUDEAPPDATA data = { hMon, NULL, hwndFirstCheck };
1981 if (::IsWindow(hwndFirstCheck) && !IsRudeEnumProc(hwndFirstCheck, (LPARAM)&data))
1982 return hwndFirstCheck;
1983
1984 // Slow check
1986
1987 return data.hwndFound;
1988 }
1989
1990 // WM_WINDOWPOSCHANGED
1992 {
1993 // Re-start rude app validation
1997 bHandled = FALSE;
1998 return 0;
1999 }
2000
2001 // HSHELL_WINDOWACTIVATED, HSHELL_RUDEAPPACTIVATED
2002 void OnWindowActivated(_In_ HWND hwndTarget)
2003 {
2004 // Re-start rude app validation
2008 }
2009
2010 // HSHELL_WINDOWDESTROYED
2011 void OnWindowDestroyed(_In_ HWND hwndTarget)
2012 {
2013 HWND hwndRude = FindRudeApp(hwndTarget);
2014 HandleFullScreenApp(hwndRude);
2015 }
2016
2018 {
2019 HDC hdc = (HDC) wParam;
2020
2021 if (!IsAppThemed())
2022 {
2023 bHandled = FALSE;
2024 return 0;
2025 }
2026
2027 RECT rect;
2030
2031 return TRUE;
2032 }
2033
2035 {
2036 SIZE szClient;
2037
2038 szClient.cx = LOWORD(lParam);
2039 szClient.cy = HIWORD(lParam);
2040 if (m_TaskBar.m_hWnd != NULL)
2041 {
2042 m_TaskBar.SetWindowPos(NULL, 0, 0, szClient.cx, szClient.cy, SWP_NOZORDER);
2043
2045 }
2046 return TRUE;
2047 }
2048
2050 {
2051 LRESULT Ret = TRUE;
2052 /* We want the tray window to be draggable everywhere, so make the control
2053 appear transparent */
2054 Ret = DefWindowProc(uMsg, wParam, lParam);
2055 if (Ret != HTVSCROLL && Ret != HTHSCROLL)
2056 Ret = HTTRANSPARENT;
2057 return Ret;
2058 }
2059
2061 {
2062 LRESULT Ret = TRUE;
2063 if (lParam != 0 && (HWND) lParam == m_TaskBar.m_hWnd)
2064 {
2066 }
2067 return Ret;
2068 }
2069
2071 {
2072 LRESULT Ret = TRUE;
2073 const NMHDR *nmh = (const NMHDR *) lParam;
2074
2075 if (nmh->hwndFrom == m_TaskBar.m_hWnd)
2076 {
2077 Ret = HandleToolbarNotification(nmh);
2078 }
2079 return Ret;
2080 }
2081
2083 {
2084 /* Update the button spacing */
2085 m_TaskBar.UpdateTbButtonSpacing(m_Tray->IsHorizontal(), m_Theme != NULL);
2086 return TRUE;
2087 }
2088
2090 {
2091 BOOL bSettingsChanged = FALSE;
2092 TaskbarSettings* newSettings = (TaskbarSettings*)lParam;
2093
2094 if (newSettings->bGroupButtons != g_TaskbarSettings.bGroupButtons)
2095 {
2096 bSettingsChanged = TRUE;
2099 }
2100
2101 if (newSettings->bSmallIcons != g_TaskbarSettings.bSmallIcons)
2102 {
2103 bSettingsChanged = TRUE;
2105 }
2106
2107 if (bSettingsChanged)
2108 {
2109 /* Refresh each task item view */
2112 }
2113
2114 return 0;
2115 }
2116
2118 {
2119 LRESULT Ret = 0;
2120 INT_PTR iBtn = -1;
2121
2122 if (m_TaskBar.m_hWnd != NULL)
2123 {
2124 POINT pt;
2125
2126 pt.x = GET_X_LPARAM(lParam);
2127 pt.y = GET_Y_LPARAM(lParam);
2128
2130
2131 iBtn = m_TaskBar.HitTest(&pt);
2132 if (iBtn >= 0)
2133 {
2135 }
2136 }
2137 if (iBtn < 0)
2138 {
2139 /* Not on a taskbar button, so forward message to tray */
2140 Ret = SendMessage(m_Tray->GetHWND(), uMsg, wParam, lParam);
2141 }
2142 return Ret;
2143 }
2144
2146 {
2147 PTASK_ITEM TaskItem = FindTaskItem((HWND) wParam);
2148 if (TaskItem)
2149 {
2150 RECT* prcMinRect = (RECT*) lParam;
2151 RECT rcItem, rcToolbar;
2152 m_TaskBar.GetItemRect(TaskItem->Index, &rcItem);
2153 m_TaskBar.GetWindowRect(&rcToolbar);
2154
2155 OffsetRect(&rcItem, rcToolbar.left, rcToolbar.top);
2156
2157 *prcMinRect = rcItem;
2158 return TRUE;
2159 }
2160 return FALSE;
2161 }
2162
2164 {
2165 return MA_NOACTIVATE;
2166 }
2167
2169 {
2170 switch (wParam)
2171 {
2172#if DUMP_TASKS != 0
2173 case 1:
2174 DumpTasks();
2175 break;
2176#endif
2178 {
2179 // Real activation of rude app might take some time after HSHELL_...ACTIVATED.
2180 // Wait up to 5 seconds with validating the rude app at each second.
2181 HWND hwndRude = FindRudeApp(NULL);
2182 HandleFullScreenApp(hwndRude);
2183
2188 break;
2189 }
2190 default:
2191 {
2192 WARN("Unknown timer ID: %p\n", wParam);
2193 break;
2194 }
2195 }
2196 return TRUE;
2197 }
2198
2200 {
2201 return m_TaskBar.SendMessageW(uMsg, wParam, lParam);
2202 }
2203
2205 {
2206 if (wParam == SPI_SETNONCLIENTMETRICS)
2207 {
2208 /* Don't update the font, this will be done when we get a WM_SETFONT from our parent */
2210 }
2211
2212 return 0;
2213 }
2214
2216 {
2218 if (cpData->dwData == m_uHardErrorMsg)
2219 {
2220 /* A hard error balloon message */
2222 ERR("Got balloon data 0x%x, 0x%x, '%S', '%S'\n", pData->Status, pData->dwType, (WCHAR*)((ULONG_PTR)pData + pData->TitleOffset), (WCHAR*)((ULONG_PTR)pData + pData->MessageOffset));
2223 if (pData->cbHeaderSize == sizeof(BALLOON_HARD_ERROR_DATA))
2225 return TRUE;
2226 }
2227
2228 return FALSE;
2229 }
2230
2232 {
2233 m_Tray = tray;
2236 if (!m_hWnd)
2237 return E_FAIL;
2238 return S_OK;
2239 }
2240
2241 // *** IOleWindow methods ***
2242
2244 GetWindow(HWND* phwnd) override
2245 {
2246 if (!phwnd)
2247 return E_INVALIDARG;
2248 *phwnd = m_hWnd;
2249 return S_OK;
2250 }
2251
2253 ContextSensitiveHelp(BOOL fEnterMode) override
2254 {
2255 return E_NOTIMPL;
2256 }
2257
2259
2261 MESSAGE_HANDLER(WM_THEMECHANGED, OnThemeChanged)
2280 END_MSG_MAP()
2281
2283
2287 END_COM_MAP()
2288};
2289
2291{
2292 return ShellObjectCreatorInit<CTaskSwitchWnd>(hWndParent, Tray, riid, ppv);
2293}
static HDC hDC
Definition: 3dtext.c:33
Arabic default style
Definition: afstyles.h:94
WCHAR windowText[1024]
Definition: appswitch.c:48
#define InterlockedExchange
Definition: armddk.h:54
#define msg(x)
Definition: auth_time.c:54
HWND hWnd
Definition: settings.c:17
@ Create
Definition: registry.c:563
#define FIXME(fmt,...)
Definition: precomp.h:53
#define WARN(fmt,...)
Definition: precomp.h:61
#define ERR(fmt,...)
Definition: precomp.h:57
HANDLE hProcessHeap
Definition: explorer.cpp:25
#define TWM_OPENSTARTMENU
Definition: precomp.h:133
#define TSWM_UPDATETASKBARPOS
Definition: precomp.h:397
TaskbarSettings g_TaskbarSettings
Definition: settings.cpp:23
#define TWM_SETTINGSCHANGED
Definition: precomp.h:134
#define STDMETHODIMP
Definition: basetyps.h:43
BOOL IsIconic() const
Definition: atlwin.h:932
BOOL SetWindowPos(HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT nFlags)
Definition: atlwin.h:1288
BOOL ScreenToClient(LPPOINT lpPoint) const
Definition: atlwin.h:1092
void SetRedraw(BOOL bRedraw=TRUE)
Definition: atlwin.h:1234
BOOL GetWindowRect(LPRECT lpRect) const
Definition: atlwin.h:816
HWND m_hWnd
Definition: atlwin.h:273
BOOL InvalidateRect(LPCRECT lpRect, BOOL bErase=TRUE)
Definition: atlwin.h:902
BOOL IsWindow() const
Definition: atlwin.h:947
CStringW m_Title
Definition: taskswnd.cpp:195
static DWORD CALLBACK s_HardErrorThreadProc(IN OUT LPVOID lpParameter)
Definition: taskswnd.cpp:253
CStringW m_Text
Definition: taskswnd.cpp:196
HRESULT ThreadProc()
Definition: taskswnd.cpp:221
void StartThread(PBALLOON_HARD_ERROR_DATA pData)
Definition: taskswnd.cpp:263
BOOL HandleAppCommand(IN WPARAM wParam, IN LPARAM lParam)
Definition: taskswnd.cpp:1600
UINT m_ShellHookMsg
Definition: taskswnd.cpp:390
static BOOL CALLBACK s_EnumWindowsProc(IN HWND hWnd, IN LPARAM lParam)
Definition: taskswnd.cpp:1487
VOID RedrawTaskItem(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:1303
LRESULT OnTaskbarSettingsChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:2089
INT UpdateTaskItemButton(IN PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:612
INT GetWndTextFromTaskItem(IN PTASK_ITEM TaskItem, LPWSTR szBuf, DWORD cchBuf)
Definition: taskswnd.cpp:436
LRESULT OnNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:2070
LRESULT OnContextMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:2117
LRESULT OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:2168
PTASK_ITEM FindOtherTaskItem(IN HWND hWnd)
Definition: taskswnd.cpp:970
VOID UpdateButtonsSize(IN BOOL bRedrawDisabled)
Definition: taskswnd.cpp:1342
BOOL HandleButtonClick(IN WORD wIndex)
Definition: taskswnd.cpp:1740
virtual ~CTaskSwitchWnd()
Definition: taskswnd.cpp:434
PTASK_ITEM m_ActiveTaskItem
Definition: taskswnd.cpp:397
VOID ExpandTaskGroup(IN PTASK_GROUP TaskGroup)
Definition: taskswnd.cpp:568
PTASK_ITEM m_TaskItems
Definition: taskswnd.cpp:396
STDMETHODIMP ContextSensitiveHelp(BOOL fEnterMode) override
Definition: taskswnd.cpp:2253
PTASK_GROUP AddToTaskGroup(IN HWND hWnd)
Definition: taskswnd.cpp:863
INT m_nRudeAppValidationCounter
Definition: taskswnd.cpp:408
VOID RemoveIcon(IN PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:658
CComPtr< ITrayWindow > m_Tray
Definition: taskswnd.cpp:388
VOID CheckActivateTaskItem(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:1096
CTaskToolbar m_TaskBar
Definition: taskswnd.cpp:386
UINT m_uHardErrorMsg
Definition: taskswnd.cpp:412
VOID UpdateIndexesAfter(IN INT iIndex, BOOL bInserted)
Definition: taskswnd.cpp:496
LRESULT OnWindowPosChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1991
BOOL m_IsDestroying
Definition: taskswnd.cpp:406
VOID FreeTaskItem(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:1063
LRESULT OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:2060
WORD m_ButtonCount
Definition: taskswnd.cpp:401
PTASK_ITEM AllocTaskItem()
Definition: taskswnd.cpp:1011
LRESULT OnSettingChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:2204
static BOOL CALLBACK IsRudeEnumProc(_In_ HWND hwnd, _In_ LPARAM lParam)
Definition: taskswnd.cpp:1903
HTHEME m_Theme
Definition: taskswnd.cpp:399
CHardErrorThread m_HardErrorThread
Definition: taskswnd.cpp:413
static BOOL CALLBACK FullScreenEnumProc(_In_ HMONITOR hMonitor, _In_opt_ HDC hDC, _In_ LPRECT prc, _In_ LPARAM lParam)
Definition: taskswnd.cpp:1929
VOID FlashTaskItem(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:1282
VOID RemoveTaskFromTaskGroup(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:907
BOOL FlashTask(IN HWND hWnd)
Definition: taskswnd.cpp:1288
PTASK_ITEM FindLastTaskItemOfGroup(IN PTASK_GROUP TaskGroup OPTIONAL, IN PTASK_ITEM NewTaskItem OPTIONAL)
Definition: taskswnd.cpp:686
LRESULT OnShellHook(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1619
struct CTaskSwitchWnd::tagRUDEAPPDATA RUDEAPPDATA
INT AddTaskItemButton(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:768
LRESULT OnMouseActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:2163
BOOL ActivateTask(IN HWND hWnd)
Definition: taskswnd.cpp:1227
INT UpdateTaskGroupButton(IN PTASK_GROUP TaskGroup)
Definition: taskswnd.cpp:559
VOID DeleteTaskItem(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:1081
BOOL ActivateTaskItem(IN OUT PTASK_ITEM TaskItem OPTIONAL)
Definition: taskswnd.cpp:1216
VOID DeleteAllTasks()
Definition: taskswnd.cpp:1268
BOOL RefreshWindowList()
Definition: taskswnd.cpp:1494
LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:2034
BOOL RedrawTask(IN HWND hWnd)
Definition: taskswnd.cpp:1328
PTASK_GROUP m_TaskGroups
Definition: taskswnd.cpp:395
PTASK_GROUP FindTaskGroupByIndex(IN INT Index)
Definition: taskswnd.cpp:1171
BOOL m_IsGroupingEnabled
Definition: taskswnd.cpp:405
LRESULT OnKludgeItemRect(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:2145
struct CTaskSwitchWnd::tagFULLSCREENDATA FULLSCREENDATA
BOOL DeleteTaskItemButton(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:828
HICON GetWndIcon(HWND hwnd)
Definition: taskswnd.cpp:577
LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1549
static BOOL InvokeRegistryAppKeyCommand(UINT uAppCmd)
Definition: taskswnd.cpp:1563
VOID HandleTaskGroupRightClick(IN OUT PTASK_GROUP TaskGroup)
Definition: taskswnd.cpp:1787
BOOL CALLBACK EnumWindowsProc(IN HWND hWnd)
Definition: taskswnd.cpp:1477
LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1516
WORD m_AllocatedTaskItems
Definition: taskswnd.cpp:393
HWND FindRudeApp(_In_opt_ HWND hwndFirstCheck)
Definition: taskswnd.cpp:1976
struct CTaskSwitchWnd::tagRUDEAPPDATA * PRUDEAPPDATA
LRESULT OnThemeChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1501
LRESULT OnSetFont(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:2199
VOID HandleTaskGroupClick(IN OUT PTASK_GROUP TaskGroup)
Definition: taskswnd.cpp:1735
void HandleFullScreenApp(_In_opt_ HWND hwndRude)
Definition: taskswnd.cpp:1947
LRESULT OnEraseBackground(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:2017
PTASK_ITEM FindTaskItem(IN HWND hWnd)
Definition: taskswnd.cpp:953
LRESULT HandleItemPaint(IN OUT NMTBCUSTOMDRAW *nmtbcd)
Definition: taskswnd.cpp:1818
STDMETHODIMP GetWindow(HWND *phwnd) override
Definition: taskswnd.cpp:2244
void OnWindowDestroyed(_In_ HWND hwndTarget)
Definition: taskswnd.cpp:2011
HIMAGELIST m_ImageList
Definition: taskswnd.cpp:403
PTASK_ITEM FindTaskItemByIndex(IN INT Index)
Definition: taskswnd.cpp:1154
VOID HandleTaskItemClick(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:1703
LRESULT OnNcHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:2049
static VOID CALLBACK SendAsyncProc(HWND hwnd, UINT uMsg, DWORD_PTR dwData, LRESULT lResult)
Definition: taskswnd.cpp:1766
VOID HandleTaskItemRightClick(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:1771
BOOL DeleteTask(IN HWND hWnd)
Definition: taskswnd.cpp:1251
HRESULT Initialize(IN HWND hWndParent, IN OUT ITrayWindow *tray)
Definition: taskswnd.cpp:2231
INT CalculateTaskItemNewButtonIndex(IN PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:724
LRESULT OnUpdateTaskbarPos(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:2082
WORD m_TaskItemCount
Definition: taskswnd.cpp:392
LRESULT OnCopyData(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:2215
LRESULT HandleToolbarNotification(IN const NMHDR *nmh)
Definition: taskswnd.cpp:1861
void OnWindowActivated(_In_ HWND hwndTarget)
Definition: taskswnd.cpp:2002
BOOL HandleButtonRightClick(IN WORD wIndex)
Definition: taskswnd.cpp:1792
struct CTaskSwitchWnd::tagFULLSCREENDATA * PFULLSCREENDATA
UINT m_ButtonsPerLine
Definition: taskswnd.cpp:400
BOOL AddTask(IN HWND hWnd)
Definition: taskswnd.cpp:1187
BOOL SetButtonCommandId(IN INT iButtonIndex, IN INT iCommandId)
Definition: taskswnd.cpp:331
INT UpdateTbButtonSpacing(IN BOOL bHorizontal, IN BOOL bThemed, IN UINT uiRows=0, IN UINT uiBtnsPerLine=0)
Definition: taskswnd.cpp:288
VOID BeginUpdate()
Definition: taskswnd.cpp:320
LRESULT OnNcHitTestToolbar(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:342
VOID EndUpdate()
Definition: taskswnd.cpp:325
BOOL Initialize(HWND hWndParent)
Definition: taskswnd.cpp:367
HWND Create(HWND hWndParent, DWORD dwStyles=0, DWORD dwExStyles=0)
Definition: rosctrls.h:256
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
#define WAIT_TIMEOUT
Definition: dderror.h:14
#define E_INVALIDARG
Definition: ddrawi.h:101
#define E_NOTIMPL
Definition: ddrawi.h:99
#define E_FAIL
Definition: ddrawi.h:102
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
UINT uFlags
Definition: api.c:59
BOOL WINAPI ImageList_SetIconSize(HIMAGELIST himl, INT cx, INT cy)
Definition: imagelist.c:3132
BOOL WINAPI ImageList_Remove(HIMAGELIST himl, INT i)
Definition: imagelist.c:2628
INT WINAPI ImageList_ReplaceIcon(HIMAGELIST himl, INT nIndex, HICON hIcon)
Definition: imagelist.c:2839
HIMAGELIST WINAPI ImageList_Create(INT cx, INT cy, UINT flags, INT cInitial, INT cGrow)
Definition: imagelist.c:814
BOOL WINAPI ImageList_GetIconSize(HIMAGELIST himl, INT *cx, INT *cy)
Definition: imagelist.c:2055
#define CloseHandle
Definition: compat.h:739
#define HeapAlloc
Definition: compat.h:733
#define HeapReAlloc
Definition: compat.h:734
#define MAX_PATH
Definition: compat.h:34
#define HeapFree(x, y, z)
Definition: compat.h:735
#define CALLBACK
Definition: compat.h:35
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
BOOL WINAPI TerminateThread(IN HANDLE hThread, IN DWORD dwExitCode)
Definition: thread.c:587
LONG WINAPI SHRegCloseUSKey(HUSKEY hUSKey)
Definition: registry.c:3626
LONG WINAPI SHRegQueryUSValueW(HUSKEY hUSKey, const WCHAR *value, DWORD *type, void *data, DWORD *data_len, BOOL ignore_hkcu, void *default_data, DWORD default_data_len)
Definition: registry.c:4019
LONG WINAPI SHRegOpenUSKeyW(const WCHAR *path, REGSAM access_mask, HUSKEY relative_key, HUSKEY *uskey, BOOL ignore_hkcu)
Definition: registry.c:3747
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
HRESULT WINAPI DECLSPEC_HOTPATCH OleInitialize(LPVOID reserved)
Definition: ole2.c:169
void WINAPI DECLSPEC_HOTPATCH OleUninitialize(void)
Definition: ole2.c:230
#define FAILED_UNEXPECTEDLY
Definition: utils.cpp:30
EXTERN_C HRESULT WINAPI SHRunIndirectRegClientCommand(_In_opt_ HWND hWnd, _In_ PCWSTR pszClientType)
Definition: utils.cpp:265
HRESULT WINAPI DrawThemeBackground(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, const RECT *pClipRect)
Definition: draw.c:128
HRESULT WINAPI DrawThemeParentBackground(HWND hwnd, HDC hdc, RECT *prc)
Definition: draw.c:72
BOOL WINAPI IsThemeActive(void)
Definition: system.c:621
HRESULT WINAPI CloseThemeData(HTHEME hTheme)
Definition: system.c:1027
HTHEME WINAPI OpenThemeData(HWND hwnd, LPCWSTR pszClassList)
Definition: system.c:881
BOOL WINAPI IsAppThemed(void)
Definition: system.c:611
#define pt(x, y)
Definition: drawing.c:79
return ret
Definition: mutex.c:146
#define L(x)
Definition: resources.c:13
#define ULONG_PTR
Definition: config.h:101
DWORD dwThreadId
Definition: fdebug.c:31
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
FxAutoRegKey hKey
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLintptr offset
Definition: glext.h:5920
GLuint index
Definition: glext.h:6031
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
#define S_OK
Definition: intsafe.h:52
#define BEGIN_COM_MAP(x)
Definition: atlcom.h:581
#define COM_INTERFACE_ENTRY_IID(iid, x)
Definition: atlcom.h:601
#define DECLARE_PROTECT_FINAL_CONSTRUCT()
Definition: atlcom.h:679
#define DECLARE_NOT_AGGREGATABLE(x)
Definition: atlcom.h:651
#define END_COM_MAP()
Definition: atlcom.h:592
#define MESSAGE_HANDLER(msg, func)
Definition: atlwin.h:1926
#define BEGIN_MSG_MAP(theClass)
Definition: atlwin.h:1898
#define END_MSG_MAP()
Definition: atlwin.h:1917
#define DECLARE_WND_CLASS_EX(WndClassName, style, bkgnd)
Definition: atlwin.h:2004
#define ASSERT(a)
Definition: mode.c:44
HDC hdc
Definition: main.c:9
static HDC
Definition: imagelist.c:88
static HICON
Definition: imagelist.c:80
static HANDLE ULONG_PTR dwData
Definition: file.c:35
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
static MONITORINFO mi
Definition: win.c:7338
static HTHEME(WINAPI *pOpenThemeDataEx)(HWND
HICON hIcon
Definition: msconfig.c:44
HMONITOR WINAPI MonitorFromWindow(HWND, DWORD)
unsigned int UINT
Definition: ndis.h:50
#define _Out_opt_
Definition: no_sal2.h:214
#define _In_
Definition: no_sal2.h:158
#define _In_opt_
Definition: no_sal2.h:212
#define KEY_READ
Definition: nt_native.h:1023
#define DWORD
Definition: nt_native.h:44
#define UNICODE_NULL
_Out_ LPRECT prc
Definition: ntgdi.h:1658
UINT ui
Definition: oleauto.h:49
const GUID IID_IOleWindow
#define LOWORD(l)
Definition: pedump.c:82
#define WS_CHILD
Definition: pedump.c:617
#define WS_TABSTOP
Definition: pedump.c:634
#define WS_BORDER
Definition: pedump.c:625
#define WS_VISIBLE
Definition: pedump.c:620
#define WS_EX_TOPMOST
Definition: pedump.c:647
long LONG
Definition: pedump.c:60
#define WS_DLGFRAME
Definition: pedump.c:626
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
#define WS_CLIPCHILDREN
Definition: pedump.c:619
#define WS_THICKFRAME
Definition: pedump.c:630
#define INT
Definition: polytest.cpp:20
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:586
#define TBIF_SIZE
Definition: commctrl.h:1225
#define BTNS_SHOWTEXT
Definition: commctrl.h:1006
#define CDDS_ITEMPREPAINT
Definition: commctrl.h:285
#define TBSTATE_ELLIPSES
Definition: commctrl.h:978
#define TBIF_IMAGE
Definition: commctrl.h:1219
#define TBSTYLE_TOOLTIPS
Definition: commctrl.h:989
#define TBBUTTONINFO
Definition: commctrl.h:1254
#define CDRF_NOTIFYITEMDRAW
Definition: commctrl.h:275
#define TBSTYLE_LIST
Definition: commctrl.h:993
#define CDRF_DODEFAULT
Definition: commctrl.h:268
_Out_opt_ int * cx
Definition: commctrl.h:585
#define ILC_COLOR32
Definition: commctrl.h:358
#define NM_CUSTOMDRAW
Definition: commctrl.h:137
#define TBCDRF_NOBACKGROUND
Definition: commctrl.h:1040
#define TBSTYLE_TRANSPARENT
Definition: commctrl.h:996
#define CCS_NODIVIDER
Definition: commctrl.h:2253
#define CDIS_MARKED
Definition: commctrl.h:298
#define CCS_TOP
Definition: commctrl.h:2247
#define TBMF_BUTTONSPACING
Definition: commctrl.h:1289
#define TBIF_BYINDEX
Definition: commctrl.h:1226
#define TBSTATE_ENABLED
Definition: commctrl.h:974
#define CDDS_PREPAINT
Definition: commctrl.h:280
#define TBIF_TEXT
Definition: commctrl.h:1220
#define ILC_MASK
Definition: commctrl.h:351
#define CCS_NORESIZE
Definition: commctrl.h:2250
#define TBSTATE_WRAP
Definition: commctrl.h:977
#define BTNS_CHECK
Definition: commctrl.h:1000
#define TBSTYLE_WRAPABLE
Definition: commctrl.h:990
#define TBMF_BARPAD
Definition: commctrl.h:1288
#define BTNS_NOPREFIX
Definition: commctrl.h:1005
#define TBSTATE_MARKED
Definition: commctrl.h:979
#define TBIF_COMMAND
Definition: commctrl.h:1224
#define TBSTATE_CHECKED
Definition: commctrl.h:972
struct _NMTBCUSTOMDRAW * LPNMTBCUSTOMDRAW
#define TBIF_STATE
Definition: commctrl.h:1221
#define REFIID
Definition: guiddef.h:118
#define REGSTR_PATH_EXPLORER
Definition: regstr.h:33
#define WM_CONTEXTMENU
Definition: richedit.h:64
#define WM_NOTIFY
Definition: richedit.h:61
#define DefWindowProc
Definition: ros2win.h:31
BOOL WINAPI RegisterShellHook(HWND hWnd, DWORD dwType)
Definition: shellord.c:510
BOOL WINAPI SHFindFiles(PCIDLIST_ABSOLUTE pidlFolder, PCIDLIST_ABSOLUTE pidlSaveFile)
Definition: shellord.c:2468
EXTERN_C VOID WINAPI ShellExec_RunDLLW(_In_opt_ HWND hwnd, _In_opt_ HINSTANCE hInstance, _In_ PCWSTR pszCmdLine, _In_ INT nCmdShow)
Definition: shlexec.cpp:3259
HRESULT hr
Definition: shlfolder.c:183
@ ASSOCSTR_EXECUTABLE
Definition: shlwapi.h:613
@ ASSOCF_NOTRUNCATE
Definition: shlwapi.h:597
#define AssocQueryString
Definition: shlwapi.h:733
#define _countof(array)
Definition: sndvol32.h:70
#define TRACE(s)
Definition: solgame.cpp:4
& rect
Definition: startmenu.cpp:1413
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
DWORD dwMask
Definition: commctrl.h:1243
int cyButtonSpacing
Definition: commctrl.h:1299
int cxButtonSpacing
Definition: commctrl.h:1298
int cxBarPad
Definition: commctrl.h:1296
DWORD dwMask
Definition: commctrl.h:1293
int cyBarPad
Definition: commctrl.h:1297
UINT cbSize
Definition: commctrl.h:1292
BOOL bGroupButtons
Definition: precomp.h:221
BOOL bSmallIcons
Definition: precomp.h:225
NMCUSTOMDRAW nmcd
Definition: commctrl.h:1017
LONG cx
Definition: kdterminal.h:27
LONG cy
Definition: kdterminal.h:28
struct _TASK_GROUP * Next
Definition: taskswnd.cpp:148
DWORD IsCollapsed
Definition: taskswnd.cpp:159
DWORD dwTaskCount
Definition: taskswnd.cpp:150
DWORD dwFlags
Definition: taskswnd.cpp:155
DWORD dwProcessId
Definition: taskswnd.cpp:151
DWORD dwFlags
Definition: taskswnd.cpp:173
INT IconIndex
Definition: taskswnd.cpp:169
PTASK_GROUP Group
Definition: taskswnd.cpp:167
DWORD IsFlashing
Definition: taskswnd.cpp:178
DWORD RenderFlashed
Definition: taskswnd.cpp:182
BYTE fsState
Definition: commctrl.h:951
INT_PTR iString
Definition: commctrl.h:959
int idCommand
Definition: commctrl.h:950
DWORD_PTR dwData
Definition: commctrl.h:958
int iBitmap
Definition: commctrl.h:949
BYTE fsStyle
Definition: commctrl.h:952
ULONG_PTR dwData
Definition: winuser.h:3077
RECT rcMonitor
Definition: winuser.h:3861
HWND hwndFrom
Definition: winuser.h:3233
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
struct _TASK_ITEM * PTASK_ITEM
#define VALIDATE_RUDE_MAX_COUNT
Definition: taskswnd.cpp:39
static BOOL SHELL_IsRudeWindowActive(_In_ HWND hWnd)
Definition: taskswnd.cpp:78
static BOOL SHELL_GetMonitorRect(_In_opt_ HMONITOR hMonitor, _Out_opt_ PRECT prcDest, _In_ BOOL bWorkAreaOnly)
Definition: taskswnd.cpp:42
HRESULT CTaskSwitchWnd_CreateInstance(IN HWND hWndParent, IN OUT ITrayWindow *Tray, REFIID riid, void **ppv)
Definition: taskswnd.cpp:2290
#define TASK_ITEM_ARRAY_ALLOC
Definition: taskswnd.cpp:32
struct _TASK_GROUP TASK_GROUP
#define GET_ICON(type)
const WCHAR szTaskSwitchWndClass[]
Definition: taskswnd.cpp:117
#define TIMER_ID_VALIDATE_RUDE_APP
Definition: taskswnd.cpp:37
#define MAX_TASKS_COUNT
Definition: taskswnd.cpp:31
const WCHAR szRunningApps[]
Definition: taskswnd.cpp:118
#define VALIDATE_RUDE_INTERVAL
Definition: taskswnd.cpp:38
static BOOL SHELL_IsParentOwnerOrSelf(_In_ HWND hwndTarget, _In_ HWND hWnd)
Definition: taskswnd.cpp:67
static BOOL SHELL_IsRudeWindow(_In_opt_ HMONITOR hMonitor, _In_ HWND hWnd, _In_ BOOL bDontCheckActive)
Definition: taskswnd.cpp:87
struct _TASK_GROUP * PTASK_GROUP
struct _TASK_ITEM TASK_ITEM
#define ICON_BIG
Definition: tnclass.cpp:51
#define ICON_SMALL
Definition: tnclass.cpp:48
#define DWORD_PTR
Definition: treelist.c:76
TW_UINT32 TW_UINT16 TW_UINT16 TW_MEMREF pData
Definition: twain.h:1830
int32_t INT_PTR
Definition: typedefs.h:64
uint32_t DWORD_PTR
Definition: typedefs.h:65
ULONG_PTR SIZE_T
Definition: typedefs.h:80
int32_t INT
Definition: typedefs.h:58
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
uint16_t * PWCHAR
Definition: typedefs.h:56
#define HIWORD(l)
Definition: typedefs.h:247
#define OUT
Definition: typedefs.h:40
struct _BALLOON_HARD_ERROR_DATA * PBALLOON_HARD_ERROR_DATA
#define WM_KLUDGEMINRECT
Definition: undocuser.h:42
#define WM_POPUPSYSTEMMENU
Definition: undocuser.h:62
HRESULT WINAPI SetWindowTheme(_In_ HWND hwnd, _In_ LPCWSTR pszSubAppName, _In_ LPCWSTR pszSubIdList)
Definition: uxthemesupp.c:69
@ TDP_FLASHBUTTON
Definition: vssym32.h:578
_In_ WDFCOLLECTION _In_ ULONG Index
VOID WINAPI SwitchToThisWindow(HWND hwnd, BOOL fAltTab)
Definition: window.c:82
BOOL WINAPI IsHungAppWindow(HWND hwnd)
Definition: window.c:1845
#define ZeroMemory
Definition: winbase.h:1753
DWORD WINAPI GetWindowThreadProcessId(HWND hWnd, PDWORD lpdwProcessId)
#define MoveMemory
Definition: winbase.h:1750
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
LONG_PTR LPARAM
Definition: windef.h:208
LONG_PTR LRESULT
Definition: windef.h:209
UINT_PTR WPARAM
Definition: windef.h:207
#define SubclassWindow(hwnd, lpfn)
Definition: windowsx.h:542
#define GET_Y_LPARAM(lp)
Definition: windowsx.h:300
#define GET_X_LPARAM(lp)
Definition: windowsx.h:299
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1546
BOOL WINAPI Rectangle(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int)
#define WM_ERASEBKGND
Definition: winuser.h:1644
DWORD WINAPI GetSysColor(_In_ int)
#define HSHELL_RUDEAPPACTIVATED
Definition: winuser.h:1292
#define SM_CXMINIMIZED
Definition: winuser.h:1031
#define SWP_NOACTIVATE
Definition: winuser.h:1253
#define GetWindowLongPtrW
Definition: winuser.h:4905
#define SM_CYEDGE
Definition: winuser.h:1020
#define WM_QUIT
Definition: winuser.h:1642
#define GCLP_HICONSM
Definition: winuser.h:683
#define MAKELPARAM(l, h)
Definition: winuser.h:4084
#define HSHELL_ACTIVATESHELLWINDOW
Definition: winuser.h:1268
#define SM_CYSCREEN
Definition: winuser.h:971
HWND WINAPI GetForegroundWindow(void)
Definition: ntwrapper.h:392
#define SM_CXEDGE
Definition: winuser.h:1019
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define HSHELL_WINDOWDESTROYED
Definition: winuser.h:1267
#define IMAGE_ICON
Definition: winuser.h:212
#define GCLP_HICON
Definition: winuser.h:682
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
#define WM_CREATE
Definition: winuser.h:1627
int WINAPIV wsprintfW(_Out_ LPWSTR, _In_ _Printf_format_string_ LPCWSTR,...)
#define SW_MINIMIZE
Definition: winuser.h:787
#define HSHELL_WINDOWCREATED
Definition: winuser.h:1266
BOOL WINAPI SetWindowPos(_In_ HWND, _In_opt_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)
#define WM_SIZE
Definition: winuser.h:1630
#define COLOR_HIGHLIGHT
Definition: winuser.h:937
HBRUSH WINAPI GetSysColorBrush(_In_ int)
struct tagCOPYDATASTRUCT * PCOPYDATASTRUCT
#define SWP_NOMOVE
Definition: winuser.h:1255
#define WM_COMMAND
Definition: winuser.h:1759
#define HTVSCROLL
Definition: winuser.h:2501
BOOL WINAPI SetForegroundWindow(_In_ HWND)
HANDLE WINAPI LoadImageW(_In_opt_ HINSTANCE hInst, _In_ LPCWSTR name, _In_ UINT type, _In_ int cx, _In_ int cy, _In_ UINT fuLoad)
Definition: cursoricon.c:2540
#define HTHSCROLL
Definition: winuser.h:2500
BOOL WINAPI GetCursorPos(_Out_ LPPOINT)
Definition: cursoricon.c:3032
#define WM_NCHITTEST
Definition: winuser.h:1705
#define SM_CYSMICON
Definition: winuser.h:1024
BOOL WINAPI IsRectEmpty(_In_ LPCRECT)
BOOL WINAPI EnumDisplayMonitors(_In_opt_ HDC, _In_opt_ LPCRECT, _In_ MONITORENUMPROC, _In_ LPARAM)
#define SWP_NOSIZE
Definition: winuser.h:1256
#define GetClassLongPtr
Definition: winuser.h:5867
#define MA_NOACTIVATE
Definition: winuser.h:2522
#define CS_DBLCLKS
Definition: winuser.h:659
#define PostThreadMessage
Definition: winuser.h:5918
int WINAPI MapWindowPoints(_In_opt_ HWND hWndFrom, _In_opt_ HWND hWndTo, _Inout_updates_(cPoints) LPPOINT lpPoints, _In_ UINT cPoints)
BOOL WINAPI SendMessageCallbackW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM, _In_ SENDASYNCPROC, _In_ ULONG_PTR)
#define SM_CXSIZE
Definition: winuser.h:1002
UINT_PTR WINAPI SetTimer(_In_opt_ HWND, _In_ UINT_PTR, _In_ UINT, _In_opt_ TIMERPROC)
HWND WINAPI GetDesktopWindow(void)
Definition: window.c:628
BOOL WINAPI ShowWindowAsync(_In_ HWND, _In_ int)
#define WM_SETTINGCHANGE
Definition: winuser.h:1648
#define SM_CXSMICON
Definition: winuser.h:1023
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)
#define SM_CYICON
Definition: winuser.h:984
#define HWND_TOP
Definition: winuser.h:1218
BOOL WINAPI EnumWindows(_In_ WNDENUMPROC lpEnumFunc, _In_ LPARAM lParam)
#define WM_SETFONT
Definition: winuser.h:1669
#define WM_TIMER
Definition: winuser.h:1761
BOOL WINAPI IntersectRect(_Out_ LPRECT, _In_ LPCRECT, _In_ LPCRECT)
#define WM_COPYDATA
Definition: winuser.h:1683
#define WM_NULL
Definition: winuser.h:1626
#define SendMessage
Definition: winuser.h:5928
UINT WINAPI RegisterWindowMessageW(_In_ LPCWSTR)
#define COLOR_HIGHLIGHTTEXT
Definition: winuser.h:938
#define HSHELL_FLASH
Definition: winuser.h:1291
#define WM_MOUSEACTIVATE
Definition: winuser.h:1656
#define LR_SHARED
Definition: winuser.h:1111
BOOL WINAPI SystemParametersInfoW(_In_ UINT uiAction, _In_ UINT uiParam, _Inout_opt_ PVOID pvParam, _In_ UINT fWinIni)
#define PostMessage
Definition: winuser.h:5917
HWND WINAPI GetParent(_In_ HWND)
#define HTTRANSPARENT
Definition: winuser.h:2492
#define SWP_NOOWNERZORDER
Definition: winuser.h:1260
BOOL WINAPI OffsetRect(_Inout_ LPRECT, _In_ int, _In_ int)
#define SW_SHOW
Definition: winuser.h:786
#define WM_DESTROY
Definition: winuser.h:1628
#define LR_DEFAULTSIZE
Definition: winuser.h:1105
#define SM_CXSCREEN
Definition: winuser.h:970
BOOL WINAPI GetMonitorInfoW(_In_ HMONITOR, _Inout_ LPMONITORINFO)
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
#define SWP_NOZORDER
Definition: winuser.h:1258
BOOL WINAPI KillTimer(_In_opt_ HWND, _In_ UINT_PTR)
BOOL WINAPI UnionRect(_Out_ LPRECT, _In_ LPCRECT, _In_ LPCRECT)
INT WINAPI InternalGetWindowText(_In_ HWND hWnd, _Out_writes_to_(cchMaxCount, return+1) LPWSTR pString, _In_ int cchMaxCount)
#define GWL_STYLE
Definition: winuser.h:863
#define SM_CXICON
Definition: winuser.h:983
#define WM_WINDOWPOSCHANGED
Definition: winuser.h:1681
BOOL WINAPI IsWindowVisible(_In_ HWND)
BOOL WINAPI EqualRect(_In_ LPCRECT, _In_ LPCRECT)
int WINAPI GetSystemMetrics(_In_ int)
#define HWND_BOTTOM
Definition: winuser.h:1216
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define GWL_EXSTYLE
Definition: winuser.h:862
#define COLOR_3DFACE
Definition: winuser.h:940
#define WM_SETREDRAW
Definition: winuser.h:1635
BOOL WINAPI ScreenToClient(_In_ HWND, _Inout_ LPPOINT)
static void Initialize()
Definition: xlate.c:212
#define IID_PPV_ARG(Itype, ppType)
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185