ReactOS 0.4.15-dev-7897-g78dc504
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
24/* Set DUMP_TASKS to 1 to enable a dump of the tasks and task groups every
25 5 seconds */
26#define DUMP_TASKS 0
27#define DEBUG_SHELL_HOOK 0
28
29#define MAX_TASKS_COUNT (0x7FFF)
30#define TASK_ITEM_ARRAY_ALLOC 64
31
32const WCHAR szTaskSwitchWndClass[] = L"MSTaskSwWClass";
33const WCHAR szRunningApps[] = L"Running Applications";
34
35#if DEBUG_SHELL_HOOK
36const struct {
37 INT msg;
38 LPCWSTR msg_name;
39} hshell_msg [] = {
40 { HSHELL_WINDOWCREATED, L"HSHELL_WINDOWCREATED" },
41 { HSHELL_WINDOWDESTROYED, L"HSHELL_WINDOWDESTROYED" },
42 { HSHELL_ACTIVATESHELLWINDOW, L"HSHELL_ACTIVATESHELLWINDOW" },
43 { HSHELL_WINDOWACTIVATED, L"HSHELL_WINDOWACTIVATED" },
44 { HSHELL_GETMINRECT, L"HSHELL_GETMINRECT" },
45 { HSHELL_REDRAW, L"HSHELL_REDRAW" },
46 { HSHELL_TASKMAN, L"HSHELL_TASKMAN" },
47 { HSHELL_LANGUAGE, L"HSHELL_LANGUAGE" },
48 { HSHELL_SYSMENU, L"HSHELL_SYSMENU" },
49 { HSHELL_ENDTASK, L"HSHELL_ENDTASK" },
50 { HSHELL_ACCESSIBILITYSTATE, L"HSHELL_ACCESSIBILITYSTATE" },
51 { HSHELL_APPCOMMAND, L"HSHELL_APPCOMMAND" },
52 { HSHELL_WINDOWREPLACED, L"HSHELL_WINDOWREPLACED" },
53 { HSHELL_WINDOWREPLACING, L"HSHELL_WINDOWREPLACING" },
54 { HSHELL_RUDEAPPACTIVATED, L"HSHELL_RUDEAPPACTIVATED" },
55};
56#endif
57
58typedef struct _TASK_GROUP
59{
60 /* We have to use a linked list instead of an array so we don't have to
61 update all pointers to groups in the task item array when removing
62 groups. */
64
68 union
69 {
71 struct
72 {
73
75 };
76 };
78
79typedef struct _TASK_ITEM
80{
85
86 union
87 {
89 struct
90 {
91
92 /* IsFlashing is TRUE when the task bar item should be flashing. */
94
95 /* RenderFlashed is only TRUE if the task bar item should be
96 drawn with a flash. */
98 };
99 };
101
102
104{
112public:
113
115 m_ThreadId(0),
118 m_Status(NULL),
120 {
121 }
122
124 {
126 {
127 /* Try to unstuck Show */
130 if (ret == WAIT_TIMEOUT)
133 }
134 }
135
137 {
138 HRESULT hr;
139 CComPtr<IUserNotification> pnotification;
140
143 return hr;
144
145 hr = CoCreateInstance(CLSID_UserNotification,
146 NULL,
147 CLSCTX_INPROC_SERVER,
148 IID_PPV_ARG(IUserNotification, &pnotification));
150 return hr;
151
152 hr = pnotification->SetBalloonInfo(m_Title, m_Text, NIIF_WARNING);
154 return hr;
155
156 hr = pnotification->SetIconInfo(NULL, NULL);
158 return hr;
159
160 /* Show will block until the balloon closes */
161 hr = pnotification->Show(NULL, 0);
163 return hr;
164
165 return S_OK;
166 }
167
169 {
170 CHardErrorThread* pThis = reinterpret_cast<CHardErrorThread*>(lpParameter);
171 pThis->ThreadProc();
172 CloseHandle(pThis->m_hThread);
175 return 0;
176 }
177
179 {
181
182 /* Ignore the new message if we are already showing one */
183 if (bIsRunning)
184 return;
185
186 m_Status = pData->Status;
187 m_dwType = pData->dwType;
188 m_Title = (PWCHAR)((ULONG_PTR)pData + pData->TitleOffset);
189 m_Text = (PWCHAR)((ULONG_PTR)pData + pData->MessageOffset);
191 if (!m_hThread)
192 {
195 }
196 }
197};
198
200 public CWindowImplBaseT< CToolbar<TASK_ITEM>, CControlWinTraits >
201{
202public:
203 INT UpdateTbButtonSpacing(IN BOOL bHorizontal, IN BOOL bThemed, IN UINT uiRows = 0, IN UINT uiBtnsPerLine = 0)
204 {
205 TBMETRICS tbm;
206
207 tbm.cbSize = sizeof(tbm);
209
210 tbm.cxBarPad = tbm.cyBarPad = 0;
211
212 if (bThemed)
213 {
214 tbm.cxButtonSpacing = 0;
215 tbm.cyButtonSpacing = 0;
216 }
217 else
218 {
219 if (bHorizontal || uiBtnsPerLine > 1)
221 else
222 tbm.cxButtonSpacing = 0;
223
224 if (!bHorizontal || uiRows > 1)
226 else
227 tbm.cyButtonSpacing = 0;
228 }
229
230 SetMetrics(&tbm);
231
232 return tbm.cxButtonSpacing;
233 }
234
236 {
238 }
239
241 {
244 }
245
246 BOOL SetButtonCommandId(IN INT iButtonIndex, IN INT iCommandId)
247 {
248 TBBUTTONINFO tbbi;
249
250 tbbi.cbSize = sizeof(tbbi);
251 tbbi.dwMask = TBIF_BYINDEX | TBIF_COMMAND;
252 tbbi.idCommand = iCommandId;
253
254 return SetButtonInfo(iButtonIndex, &tbbi) != 0;
255 }
256
258 {
259 POINT pt;
260
261 /* See if the mouse is on a button */
265
266 INT index = HitTest(&pt);
267 if (index < 0)
268 {
269 /* Make the control appear to be transparent outside of any buttons */
270 return HTTRANSPARENT;
271 }
272
273 bHandled = FALSE;
274 return 0;
275 }
276
277public:
281
283 {
287
288 // HACK & FIXME: CORE-18016
289 HWND toolbar = CToolbar::Create(hWndParent, styles);
290 SetDrawTextFlags(DT_NOPREFIX, DT_NOPREFIX);
291 m_hWnd = NULL;
292 return SubclassWindow(toolbar);
293 }
294};
295
297 public CComCoClass<CTaskSwitchWnd>,
298 public CComObjectRootEx<CComMultiThreadModelNoCS>,
299 public CWindowImpl < CTaskSwitchWnd, CWindow, CControlWinTraits >,
300 public IOleWindow
301{
303
305
307
310
314
318
320
323
325
328
329public:
337 m_Theme(NULL),
339 m_ButtonCount(0),
343 {
346 }
347 virtual ~CTaskSwitchWnd() { }
348
350 {
351 /* Get the window text without sending a message so we don't hang if an
352 application isn't responding! */
353 return InternalGetWindowText(TaskItem->hWnd, szBuf, cchBuf);
354 }
355
356
357#if DUMP_TASKS != 0
358 VOID DumpTasks()
359 {
360 PTASK_GROUP CurrentGroup;
361 PTASK_ITEM CurrentTaskItem, LastTaskItem;
362
363 TRACE("Tasks dump:\n");
365 {
366 CurrentGroup = m_TaskGroups;
367 while (CurrentGroup != NULL)
368 {
369 TRACE("- Group PID: 0x%p Tasks: %d Index: %d\n", CurrentGroup->dwProcessId, CurrentGroup->dwTaskCount, CurrentGroup->Index);
370
371 CurrentTaskItem = m_TaskItems;
372 LastTaskItem = CurrentTaskItem + m_TaskItemCount;
373 while (CurrentTaskItem != LastTaskItem)
374 {
375 if (CurrentTaskItem->Group == CurrentGroup)
376 {
377 TRACE(" + Task hwnd: 0x%p Index: %d\n", CurrentTaskItem->hWnd, CurrentTaskItem->Index);
378 }
379 CurrentTaskItem++;
380 }
381
382 CurrentGroup = CurrentGroup->Next;
383 }
384
385 CurrentTaskItem = m_TaskItems;
386 LastTaskItem = CurrentTaskItem + m_TaskItemCount;
387 while (CurrentTaskItem != LastTaskItem)
388 {
389 if (CurrentTaskItem->Group == NULL)
390 {
391 TRACE("- Task hwnd: 0x%p Index: %d\n", CurrentTaskItem->hWnd, CurrentTaskItem->Index);
392 }
393 CurrentTaskItem++;
394 }
395 }
396 else
397 {
398 CurrentTaskItem = m_TaskItems;
399 LastTaskItem = CurrentTaskItem + m_TaskItemCount;
400 while (CurrentTaskItem != LastTaskItem)
401 {
402 TRACE("- Task hwnd: 0x%p Index: %d\n", CurrentTaskItem->hWnd, CurrentTaskItem->Index);
403 CurrentTaskItem++;
404 }
405 }
406 }
407#endif
408
409 VOID UpdateIndexesAfter(IN INT iIndex, BOOL bInserted)
410 {
411 PTASK_GROUP CurrentGroup;
412 PTASK_ITEM CurrentTaskItem, LastTaskItem;
413 INT NewIndex;
414
415 int offset = bInserted ? +1 : -1;
416
418 {
419 /* Update all affected groups */
420 CurrentGroup = m_TaskGroups;
421 while (CurrentGroup != NULL)
422 {
423 if (CurrentGroup->IsCollapsed &&
424 CurrentGroup->Index >= iIndex)
425 {
426 /* Update the toolbar buttons */
427 NewIndex = CurrentGroup->Index + offset;
428 if (m_TaskBar.SetButtonCommandId(CurrentGroup->Index + offset, NewIndex))
429 {
430 CurrentGroup->Index = NewIndex;
431 }
432 else
433 CurrentGroup->Index = -1;
434 }
435
436 CurrentGroup = CurrentGroup->Next;
437 }
438 }
439
440 /* Update all affected task items */
441 CurrentTaskItem = m_TaskItems;
442 LastTaskItem = CurrentTaskItem + m_TaskItemCount;
443 while (CurrentTaskItem != LastTaskItem)
444 {
445 CurrentGroup = CurrentTaskItem->Group;
446 if (CurrentGroup != NULL)
447 {
448 if (!CurrentGroup->IsCollapsed &&
449 CurrentTaskItem->Index >= iIndex)
450 {
451 goto UpdateTaskItemBtn;
452 }
453 }
454 else if (CurrentTaskItem->Index >= iIndex)
455 {
456 UpdateTaskItemBtn:
457 /* Update the toolbar buttons */
458 NewIndex = CurrentTaskItem->Index + offset;
459 if (m_TaskBar.SetButtonCommandId(CurrentTaskItem->Index + offset, NewIndex))
460 {
461 CurrentTaskItem->Index = NewIndex;
462 }
463 else
464 CurrentTaskItem->Index = -1;
465 }
466
467 CurrentTaskItem++;
468 }
469 }
470
471
473 {
474 ASSERT(TaskGroup->Index >= 0);
475
476 /* FIXME: Implement */
477
478 return TaskGroup->Index;
479 }
480
482 {
483 ASSERT(TaskGroup->dwTaskCount > 0);
484 ASSERT(TaskGroup->IsCollapsed);
485 ASSERT(TaskGroup->Index >= 0);
486
487 /* FIXME: Implement */
488 }
489
491 {
492 HICON hIcon = NULL;
493
494 /* Retrieve icon by sending a message */
495#define GET_ICON(type) \
496 SendMessageTimeout(hwnd, WM_GETICON, (type), 0, SMTO_NOTIMEOUTIFNOTHUNG, 100, (PDWORD_PTR)&hIcon)
497
498 LRESULT bAlive = GET_ICON(g_TaskbarSettings.bSmallIcons ? ICON_SMALL2 : ICON_BIG);
499 if (hIcon)
500 return hIcon;
501
502 if (bAlive)
503 {
504 bAlive = GET_ICON(ICON_SMALL);
505 if (hIcon)
506 return hIcon;
507 }
508
509 if (bAlive)
510 {
512 if (hIcon)
513 return hIcon;
514 }
515#undef GET_ICON
516
517 /* If we failed, retrieve icon from the window class */
519 if (hIcon)
520 return hIcon;
521
523 }
524
526 {
527 TBBUTTONINFO tbbi = { 0 };
528 HICON icon;
529 WCHAR windowText[255];
530
531 ASSERT(TaskItem->Index >= 0);
532
533 tbbi.cbSize = sizeof(tbbi);
534 tbbi.dwMask = TBIF_BYINDEX | TBIF_STATE | TBIF_TEXT | TBIF_IMAGE;
535 tbbi.fsState = TBSTATE_ENABLED;
536 if (m_ActiveTaskItem == TaskItem)
537 tbbi.fsState |= TBSTATE_CHECKED;
538
539 if (TaskItem->RenderFlashed)
540 tbbi.fsState |= TBSTATE_MARKED;
541
542 /* Check if we're updating a button that is the last one in the
543 line. If so, we need to set the TBSTATE_WRAP flag! */
544 if (!m_Tray->IsHorizontal() || (m_ButtonsPerLine != 0 &&
545 (TaskItem->Index + 1) % m_ButtonsPerLine == 0))
546 {
547 tbbi.fsState |= TBSTATE_WRAP;
548 }
549
551 {
552 tbbi.pszText = windowText;
553 }
554
555 icon = GetWndIcon(TaskItem->hWnd);
556 if (!icon)
557 icon = static_cast<HICON>(LoadImageW(NULL, MAKEINTRESOURCEW(OIC_SAMPLE), IMAGE_ICON, 0, 0, LR_SHARED | LR_DEFAULTSIZE));
558 TaskItem->IconIndex = ImageList_ReplaceIcon(m_ImageList, TaskItem->IconIndex, icon);
559 tbbi.iImage = TaskItem->IconIndex;
560
561 if (!m_TaskBar.SetButtonInfo(TaskItem->Index, &tbbi))
562 {
563 TaskItem->Index = -1;
564 return -1;
565 }
566
567 TRACE("Updated button %d for hwnd 0x%p\n", TaskItem->Index, TaskItem->hWnd);
568 return TaskItem->Index;
569 }
570
572 {
573 TBBUTTONINFO tbbi;
574 PTASK_ITEM currentTaskItem, LastItem;
575
576 if (TaskItem->IconIndex == -1)
577 return;
578
579 tbbi.cbSize = sizeof(tbbi);
580 tbbi.dwMask = TBIF_IMAGE;
581
582 currentTaskItem = m_TaskItems;
583 LastItem = currentTaskItem + m_TaskItemCount;
584 while (currentTaskItem != LastItem)
585 {
586 if (currentTaskItem->IconIndex > TaskItem->IconIndex)
587 {
588 currentTaskItem->IconIndex--;
589 tbbi.iImage = currentTaskItem->IconIndex;
590
591 m_TaskBar.SetButtonInfo(currentTaskItem->Index, &tbbi);
592 }
593 currentTaskItem++;
594 }
595
596 ImageList_Remove(m_ImageList, TaskItem->IconIndex);
597 }
598
600 IN PTASK_GROUP TaskGroup OPTIONAL,
601 IN PTASK_ITEM NewTaskItem OPTIONAL)
602 {
603 PTASK_ITEM TaskItem, LastTaskItem, FoundTaskItem = NULL;
604 DWORD dwTaskCount;
605
607
608 TaskItem = m_TaskItems;
609 LastTaskItem = TaskItem + m_TaskItemCount;
610
611 dwTaskCount = (TaskGroup != NULL ? TaskGroup->dwTaskCount : MAX_TASKS_COUNT);
612
613 ASSERT(dwTaskCount > 0);
614
615 while (TaskItem != LastTaskItem)
616 {
617 if (TaskItem->Group == TaskGroup)
618 {
619 if ((NewTaskItem != NULL && TaskItem != NewTaskItem) || NewTaskItem == NULL)
620 {
621 FoundTaskItem = TaskItem;
622 }
623
624 if (--dwTaskCount == 0)
625 {
626 /* We found the last task item in the group! */
627 break;
628 }
629 }
630
631 TaskItem++;
632 }
633
634 return FoundTaskItem;
635 }
636
638 {
639 PTASK_GROUP TaskGroup;
640 PTASK_ITEM LastTaskItem;
641
642 /* NOTE: This routine assumes that the group is *not* collapsed! */
643
644 TaskGroup = TaskItem->Group;
646 {
647 if (TaskGroup != NULL)
648 {
649 ASSERT(TaskGroup->Index < 0);
650 ASSERT(!TaskGroup->IsCollapsed);
651
652 if (TaskGroup->dwTaskCount > 1)
653 {
654 LastTaskItem = FindLastTaskItemOfGroup(TaskGroup, TaskItem);
655 if (LastTaskItem != NULL)
656 {
657 /* Since the group is expanded the task items must have an index */
658 ASSERT(LastTaskItem->Index >= 0);
659
660 return LastTaskItem->Index + 1;
661 }
662 }
663 }
664 else
665 {
666 /* Find the last NULL group button. NULL groups are added at the end of the
667 task item list when grouping is enabled */
668 LastTaskItem = FindLastTaskItemOfGroup(NULL, TaskItem);
669 if (LastTaskItem != NULL)
670 {
671 ASSERT(LastTaskItem->Index >= 0);
672
673 return LastTaskItem->Index + 1;
674 }
675 }
676 }
677
678 return m_ButtonCount;
679 }
680
682 {
683 WCHAR windowText[255];
684 TBBUTTON tbBtn = { 0 };
685 INT iIndex;
686 HICON icon;
687
688 if (TaskItem->Index >= 0)
689 {
690 return UpdateTaskItemButton(TaskItem);
691 }
692
693 if (TaskItem->Group != NULL &&
694 TaskItem->Group->IsCollapsed)
695 {
696 /* The task group is collapsed, we only need to update the group button */
697 return UpdateTaskGroupButton(TaskItem->Group);
698 }
699
700 icon = GetWndIcon(TaskItem->hWnd);
701 if (!icon)
702 icon = static_cast<HICON>(LoadImageW(NULL, MAKEINTRESOURCEW(OIC_SAMPLE), IMAGE_ICON, 0, 0, LR_SHARED | LR_DEFAULTSIZE));
703 TaskItem->IconIndex = ImageList_ReplaceIcon(m_ImageList, -1, icon);
704
705 tbBtn.iBitmap = TaskItem->IconIndex;
708 tbBtn.dwData = TaskItem->Index;
709
711 {
712 tbBtn.iString = (DWORD_PTR) windowText;
713 }
714
715 /* Find out where to insert the new button */
716 iIndex = CalculateTaskItemNewButtonIndex(TaskItem);
717 ASSERT(iIndex >= 0);
718 tbBtn.idCommand = iIndex;
719
721
722 if (m_TaskBar.InsertButton(iIndex, &tbBtn))
723 {
724 UpdateIndexesAfter(iIndex, TRUE);
725
726 TRACE("Added button %d for hwnd 0x%p\n", iIndex, TaskItem->hWnd);
727
728 TaskItem->Index = iIndex;
730
731 /* Update button sizes and fix the button wrapping */
733 return iIndex;
734 }
735
737
738 return -1;
739 }
740
742 {
743 PTASK_GROUP TaskGroup;
744 INT iIndex;
745
746 TaskGroup = TaskItem->Group;
747
748 if (TaskItem->Index >= 0)
749 {
750 if ((TaskGroup != NULL && !TaskGroup->IsCollapsed) ||
751 TaskGroup == NULL)
752 {
754
755 RemoveIcon(TaskItem);
756 iIndex = TaskItem->Index;
757 if (m_TaskBar.DeleteButton(iIndex))
758 {
759 TaskItem->Index = -1;
761
762 UpdateIndexesAfter(iIndex, FALSE);
763
764 /* Update button sizes and fix the button wrapping */
766 return TRUE;
767 }
768
770 }
771 }
772
773 return FALSE;
774 }
775
777 {
778 DWORD dwProcessId;
779 PTASK_GROUP TaskGroup, *PrevLink;
780
782 &dwProcessId))
783 {
784 TRACE("Cannot get process id of hwnd 0x%p\n", hWnd);
785 return NULL;
786 }
787
788 /* Try to find an existing task group */
789 TaskGroup = m_TaskGroups;
790 PrevLink = &m_TaskGroups;
791 while (TaskGroup != NULL)
792 {
793 if (TaskGroup->dwProcessId == dwProcessId)
794 {
795 TaskGroup->dwTaskCount++;
796 return TaskGroup;
797 }
798
799 PrevLink = &TaskGroup->Next;
800 TaskGroup = TaskGroup->Next;
801 }
802
803 /* Allocate a new task group */
804 TaskGroup = (PTASK_GROUP) HeapAlloc(hProcessHeap,
806 sizeof(*TaskGroup));
807 if (TaskGroup != NULL)
808 {
809 TaskGroup->dwTaskCount = 1;
810 TaskGroup->dwProcessId = dwProcessId;
811 TaskGroup->Index = -1;
812
813 /* Add the task group to the list */
814 *PrevLink = TaskGroup;
815 }
816
817 return TaskGroup;
818 }
819
821 {
822 PTASK_GROUP TaskGroup, CurrentGroup, *PrevLink;
823
824 TaskGroup = TaskItem->Group;
825 if (TaskGroup != NULL)
826 {
827 DWORD dwNewTaskCount = --TaskGroup->dwTaskCount;
828 if (dwNewTaskCount == 0)
829 {
830 /* Find the previous pointer in the chain */
831 CurrentGroup = m_TaskGroups;
832 PrevLink = &m_TaskGroups;
833 while (CurrentGroup != TaskGroup)
834 {
835 PrevLink = &CurrentGroup->Next;
836 CurrentGroup = CurrentGroup->Next;
837 }
838
839 /* Remove the group from the list */
840 ASSERT(TaskGroup == CurrentGroup);
841 *PrevLink = TaskGroup->Next;
842
843 /* Free the task group */
845 0,
846 TaskGroup);
847 }
848 else if (TaskGroup->IsCollapsed &&
849 TaskGroup->Index >= 0)
850 {
851 if (dwNewTaskCount > 1)
852 {
853 /* FIXME: Check if we should expand the group */
854 /* Update the task group button */
855 UpdateTaskGroupButton(TaskGroup);
856 }
857 else
858 {
859 /* Expand the group of one task button to a task button */
860 ExpandTaskGroup(TaskGroup);
861 }
862 }
863 }
864 }
865
867 {
868 PTASK_ITEM TaskItem, LastItem;
869
870 TaskItem = m_TaskItems;
871 LastItem = TaskItem + m_TaskItemCount;
872 while (TaskItem != LastItem)
873 {
874 if (TaskItem->hWnd == hWnd)
875 return TaskItem;
876
877 TaskItem++;
878 }
879
880 return NULL;
881 }
882
884 {
885 PTASK_ITEM LastItem, TaskItem;
886 PTASK_GROUP TaskGroup;
887 DWORD dwProcessId;
888
889 if (!GetWindowThreadProcessId(hWnd, &dwProcessId))
890 {
891 return NULL;
892 }
893
894 /* Try to find another task that belongs to the same
895 process as the given window */
896 TaskItem = m_TaskItems;
897 LastItem = TaskItem + m_TaskItemCount;
898 while (TaskItem != LastItem)
899 {
900 TaskGroup = TaskItem->Group;
901 if (TaskGroup != NULL)
902 {
903 if (TaskGroup->dwProcessId == dwProcessId)
904 return TaskItem;
905 }
906 else
907 {
908 DWORD dwProcessIdTask;
909
910 if (GetWindowThreadProcessId(TaskItem->hWnd,
911 &dwProcessIdTask) &&
912 dwProcessIdTask == dwProcessId)
913 {
914 return TaskItem;
915 }
916 }
917
918 TaskItem++;
919 }
920
921 return NULL;
922 }
923
925 {
927 {
928 /* We need the most significant bit in 16 bit command IDs to indicate whether it
929 is a task group or task item. WM_COMMAND limits command IDs to 16 bits! */
930 return NULL;
931 }
932
934
935 if (m_TaskItemCount == 0)
936 {
938 0,
940 if (m_TaskItems != NULL)
941 {
943 }
944 else
945 return NULL;
946 }
948 {
949 PTASK_ITEM NewArray;
950 SIZE_T NewArrayLength, ActiveTaskItemIndex;
951
953
955 0,
957 NewArrayLength * sizeof(*m_TaskItems));
958 if (NewArray != NULL)
959 {
960 if (m_ActiveTaskItem != NULL)
961 {
962 /* Fixup the ActiveTaskItem pointer */
963 ActiveTaskItemIndex = m_ActiveTaskItem - m_TaskItems;
964 m_ActiveTaskItem = NewArray + ActiveTaskItemIndex;
965 }
966 m_AllocatedTaskItems = (WORD) NewArrayLength;
967 m_TaskItems = NewArray;
968 }
969 else
970 return NULL;
971 }
972
973 return m_TaskItems + m_TaskItemCount++;
974 }
975
977 {
978 WORD wIndex;
979
980 if (TaskItem == m_ActiveTaskItem)
982
983 wIndex = (WORD) (TaskItem - m_TaskItems);
984 if (wIndex + 1 < m_TaskItemCount)
985 {
986 MoveMemory(TaskItem,
987 TaskItem + 1,
988 (m_TaskItemCount - wIndex - 1) * sizeof(*TaskItem));
989 }
990
992 }
993
995 {
996 if (!m_IsDestroying)
997 {
998 /* Delete the task button from the toolbar */
999 DeleteTaskItemButton(TaskItem);
1000 }
1001
1002 /* Remove the task from it's group */
1003 RemoveTaskFromTaskGroup(TaskItem);
1004
1005 /* Free the task item */
1006 FreeTaskItem(TaskItem);
1007 }
1008
1010 {
1011 PTASK_ITEM CurrentTaskItem;
1012 PTASK_GROUP TaskGroup = NULL;
1013
1014 CurrentTaskItem = m_ActiveTaskItem;
1015
1016 if (TaskItem != NULL)
1017 TaskGroup = TaskItem->Group;
1018
1019 if (m_IsGroupingEnabled &&
1020 TaskGroup != NULL &&
1021 TaskGroup->IsCollapsed)
1022 {
1023 /* FIXME */
1024 return;
1025 }
1026
1027 if (CurrentTaskItem != NULL)
1028 {
1029 PTASK_GROUP CurrentTaskGroup;
1030
1031 if (CurrentTaskItem == TaskItem)
1032 return;
1033
1034 CurrentTaskGroup = CurrentTaskItem->Group;
1035
1036 if (m_IsGroupingEnabled &&
1037 CurrentTaskGroup != NULL &&
1038 CurrentTaskGroup->IsCollapsed)
1039 {
1040 if (CurrentTaskGroup == TaskGroup)
1041 return;
1042
1043 /* FIXME */
1044 }
1045 else
1046 {
1048 if (CurrentTaskItem->Index >= 0)
1049 {
1050 UpdateTaskItemButton(CurrentTaskItem);
1051 }
1052 }
1053 }
1054
1055 m_ActiveTaskItem = TaskItem;
1056
1057 if (TaskItem != NULL && TaskItem->Index >= 0)
1058 {
1059 UpdateTaskItemButton(TaskItem);
1060 }
1061 else if (TaskItem == NULL)
1062 {
1063 TRACE("Active TaskItem now NULL\n");
1064 }
1065 }
1066
1068 {
1069 PTASK_ITEM TaskItem, LastItem;
1070
1071 TaskItem = m_TaskItems;
1072 LastItem = TaskItem + m_TaskItemCount;
1073 while (TaskItem != LastItem)
1074 {
1075 if (TaskItem->Index == Index)
1076 return TaskItem;
1077
1078 TaskItem++;
1079 }
1080
1081 return NULL;
1082 }
1083
1085 {
1086 PTASK_GROUP CurrentGroup;
1087
1088 CurrentGroup = m_TaskGroups;
1089 while (CurrentGroup != NULL)
1090 {
1091 if (CurrentGroup->Index == Index)
1092 break;
1093
1094 CurrentGroup = CurrentGroup->Next;
1095 }
1096
1097 return CurrentGroup;
1098 }
1099
1101 {
1102 PTASK_ITEM TaskItem;
1103
1104 if (!::IsWindow(hWnd) || m_Tray->IsSpecialHWND(hWnd))
1105 return FALSE;
1106
1107 TaskItem = FindTaskItem(hWnd);
1108 if (TaskItem == NULL)
1109 {
1110 TRACE("Add window 0x%p\n", hWnd);
1111 TaskItem = AllocTaskItem();
1112 if (TaskItem != NULL)
1113 {
1114 ZeroMemory(TaskItem, sizeof(*TaskItem));
1115 TaskItem->hWnd = hWnd;
1116 TaskItem->Index = -1;
1117 TaskItem->Group = AddToTaskGroup(hWnd);
1118
1119 if (!m_IsDestroying)
1120 {
1121 AddTaskItemButton(TaskItem);
1122 }
1123 }
1124 }
1125
1126 return TaskItem != NULL;
1127 }
1128
1130 {
1131 if (TaskItem != NULL)
1132 {
1133 TRACE("Activate window 0x%p on button %d\n", TaskItem->hWnd, TaskItem->Index);
1134 }
1135
1136 CheckActivateTaskItem(TaskItem);
1137 return FALSE;
1138 }
1139
1141 {
1142 PTASK_ITEM TaskItem;
1143
1144 if (!hWnd)
1145 {
1146 return ActivateTaskItem(NULL);
1147 }
1148
1149 TaskItem = FindTaskItem(hWnd);
1150 if (TaskItem == NULL)
1151 {
1152 TaskItem = FindOtherTaskItem(hWnd);
1153 }
1154
1155 if (TaskItem == NULL)
1156 {
1157 WARN("Activate window 0x%p, could not find task\n", hWnd);
1159 }
1160
1161 return ActivateTaskItem(TaskItem);
1162 }
1163
1165 {
1166 PTASK_ITEM TaskItem;
1167
1168 TaskItem = FindTaskItem(hWnd);
1169 if (TaskItem != NULL)
1170 {
1171 TRACE("Delete window 0x%p on button %d\n", hWnd, TaskItem->Index);
1172 DeleteTaskItem(TaskItem);
1173 return TRUE;
1174 }
1175 //else
1176 //TRACE("Failed to delete window 0x%p\n", hWnd);
1177
1178 return FALSE;
1179 }
1180
1182 {
1183 PTASK_ITEM CurrentTask;
1184
1185 if (m_TaskItemCount > 0)
1186 {
1187 CurrentTask = m_TaskItems + m_TaskItemCount;
1188 do
1189 {
1190 DeleteTaskItem(--CurrentTask);
1191 } while (CurrentTask != m_TaskItems);
1192 }
1193 }
1194
1196 {
1197 TaskItem->RenderFlashed = 1;
1198 UpdateTaskItemButton(TaskItem);
1199 }
1200
1202 {
1203 PTASK_ITEM TaskItem;
1204
1205 TaskItem = FindTaskItem(hWnd);
1206 if (TaskItem != NULL)
1207 {
1208 TRACE("Flashing window 0x%p on button %d\n", hWnd, TaskItem->Index);
1209 FlashTaskItem(TaskItem);
1210 return TRUE;
1211 }
1212
1213 return FALSE;
1214 }
1215
1217 {
1218 PTASK_GROUP TaskGroup;
1219
1220 TaskGroup = TaskItem->Group;
1221 if (m_IsGroupingEnabled && TaskGroup != NULL)
1222 {
1223 if (TaskGroup->IsCollapsed && TaskGroup->Index >= 0)
1224 {
1225 UpdateTaskGroupButton(TaskGroup);
1226 }
1227 else if (TaskItem->Index >= 0)
1228 {
1229 goto UpdateTaskItem;
1230 }
1231 }
1232 else if (TaskItem->Index >= 0)
1233 {
1234 UpdateTaskItem:
1235 TaskItem->RenderFlashed = 0;
1236 UpdateTaskItemButton(TaskItem);
1237 }
1238 }
1239
1240
1242 {
1243 PTASK_ITEM TaskItem;
1244
1245 TaskItem = FindTaskItem(hWnd);
1246 if (TaskItem != NULL)
1247 {
1248 RedrawTaskItem(TaskItem);
1249 return TRUE;
1250 }
1251
1252 return FALSE;
1253 }
1254
1256 {
1257 RECT rcClient;
1258 UINT uiRows, uiMax, uiMin, uiBtnsPerLine, ui;
1259 LONG NewBtnSize;
1260 BOOL Horizontal;
1261
1262 /* Update the size of the image list if needed */
1263 int cx, cy;
1267 {
1271
1272 /* SetIconSize removes all icons so we have to reinsert them */
1273 PTASK_ITEM TaskItem = m_TaskItems;
1274 PTASK_ITEM LastTaskItem = m_TaskItems + m_TaskItemCount;
1275 while (TaskItem != LastTaskItem)
1276 {
1277 TaskItem->IconIndex = -1;
1278 UpdateTaskItemButton(TaskItem);
1279
1280 TaskItem++;
1281 }
1282 m_TaskBar.SetImageList(m_ImageList);
1283 }
1284
1285 if (GetClientRect(&rcClient) && !IsRectEmpty(&rcClient))
1286 {
1287 if (m_ButtonCount > 0)
1288 {
1289 Horizontal = m_Tray->IsHorizontal();
1290
1291 if (Horizontal)
1292 {
1293 TBMETRICS tbm = { 0 };
1294 tbm.cbSize = sizeof(tbm);
1296 m_TaskBar.GetMetrics(&tbm);
1297
1298 if (m_ButtonSize.cy + tbm.cyButtonSpacing != 0)
1299 uiRows = (rcClient.bottom + tbm.cyButtonSpacing) / (m_ButtonSize.cy + tbm.cyButtonSpacing);
1300 else
1301 uiRows = 1;
1302
1303 if (uiRows == 0)
1304 uiRows = 1;
1305
1306 uiBtnsPerLine = (m_ButtonCount + uiRows - 1) / uiRows;
1307 }
1308 else
1309 {
1310 uiBtnsPerLine = 1;
1311 uiRows = m_ButtonCount;
1312 }
1313
1314 if (!bRedrawDisabled)
1316
1317 /* We might need to update the button spacing */
1318 int cxButtonSpacing = m_TaskBar.UpdateTbButtonSpacing(
1319 Horizontal, m_Theme != NULL,
1320 uiRows, uiBtnsPerLine);
1321
1322 /* Determine the minimum and maximum width of a button */
1324 if (Horizontal)
1325 {
1327
1328 /* Calculate the ideal width and make sure it's within the allowed range */
1329 NewBtnSize = (rcClient.right - (uiBtnsPerLine * cxButtonSpacing)) / uiBtnsPerLine;
1330
1331 if (NewBtnSize < (LONG) uiMin)
1332 NewBtnSize = uiMin;
1333 if (NewBtnSize >(LONG)uiMax)
1334 NewBtnSize = uiMax;
1335
1336 /* Recalculate how many buttons actually fit into one line */
1337 uiBtnsPerLine = rcClient.right / (NewBtnSize + cxButtonSpacing);
1338 if (uiBtnsPerLine == 0)
1339 uiBtnsPerLine++;
1340 }
1341 else
1342 {
1343 NewBtnSize = uiMax = rcClient.right;
1344 }
1345
1346 m_ButtonSize.cx = NewBtnSize;
1347
1348 m_ButtonsPerLine = uiBtnsPerLine;
1349
1350 for (ui = 0; ui != m_ButtonCount; ui++)
1351 {
1352 TBBUTTONINFOW tbbi = { 0 };
1353 tbbi.cbSize = sizeof(tbbi);
1355 tbbi.cx = (INT) NewBtnSize;
1356 tbbi.fsState = TBSTATE_ENABLED;
1357
1358 /* Check if we're updating a button that is the last one in the
1359 line. If so, we need to set the TBSTATE_WRAP flag! */
1360 if (Horizontal)
1361 {
1362 if ((ui + 1) % uiBtnsPerLine == 0)
1363 tbbi.fsState |= TBSTATE_WRAP;
1364 }
1365 else
1366 {
1367 tbbi.fsState |= TBSTATE_WRAP;
1368 }
1369
1370 if (m_ActiveTaskItem != NULL &&
1372 {
1373 tbbi.fsState |= TBSTATE_CHECKED;
1374 }
1375
1376 m_TaskBar.SetButtonInfo(ui, &tbbi);
1377 }
1378 }
1379 else
1380 {
1381 m_ButtonsPerLine = 0;
1382 m_ButtonSize.cx = 0;
1383 }
1384 }
1385
1386 // FIXME: This seems to be enabling redraws prematurely, but moving it to its right place doesn't work!
1388 }
1389
1391 {
1392 if (m_Tray->IsTaskWnd(hWnd))
1393 {
1394 TRACE("Adding task for %p...\n", hWnd);
1395 AddTask(hWnd);
1396 }
1397 return TRUE;
1398 }
1399
1401 {
1403
1404 return This->EnumWindowsProc(hWnd);
1405 }
1406
1408 {
1409 TRACE("Refreshing window list...\n");
1410 /* Add all windows to the toolbar */
1411 return EnumWindows(s_EnumWindowsProc, (LPARAM)this);
1412 }
1413
1415 {
1416 TRACE("OmThemeChanged\n");
1417
1418 if (m_Theme)
1420
1421 if (IsThemeActive())
1422 m_Theme = OpenThemeData(m_hWnd, L"TaskBand");
1423 else
1424 m_Theme = NULL;
1425
1426 return TRUE;
1427 }
1428
1430 {
1432 return FALSE;
1433
1434 SetWindowTheme(m_TaskBar.m_hWnd, L"TaskBand", NULL);
1435
1438 ILC_COLOR32 | ILC_MASK, 0, 1000);
1439 m_TaskBar.SetImageList(m_ImageList);
1440
1441 /* Set proper spacing between buttons */
1442 m_TaskBar.UpdateTbButtonSpacing(m_Tray->IsHorizontal(), m_Theme != NULL);
1443
1444 /* Register the shell hook */
1446
1447 TRACE("ShellHookMsg got assigned number %d\n", m_ShellHookMsg);
1448
1449 RegisterShellHook(m_hWnd, 3); /* 1 if no NT! We're targeting NT so we don't care! */
1450
1452
1453 /* Recalculate the button size */
1455
1456#if DUMP_TASKS != 0
1457 SetTimer(hwnd, 1, 5000, NULL);
1458#endif
1459 return TRUE;
1460 }
1461
1463 {
1465
1466 /* Unregister the shell hook */
1468
1471 return TRUE;
1472 }
1473
1474 VOID SendPulseToTray(BOOL bDelete, HWND hwndActive)
1475 {
1476 HWND hwndTray = m_Tray->GetHWND();
1477 ::SendMessage(hwndTray, TWM_PULSE, bDelete, (LPARAM)hwndActive);
1478 }
1479
1481 {
1482 BOOL Ret = FALSE;
1483
1484 switch (GET_APPCOMMAND_LPARAM(lParam))
1485 {
1486 case APPCOMMAND_BROWSER_SEARCH:
1487 Ret = SHFindFiles(NULL,
1488 NULL);
1489 break;
1490
1491 case APPCOMMAND_BROWSER_HOME:
1492 case APPCOMMAND_LAUNCH_MAIL:
1493 default:
1494 TRACE("Shell app command %d unhandled!\n", (INT) GET_APPCOMMAND_LPARAM(lParam));
1495 break;
1496 }
1497
1498 return Ret;
1499 }
1500
1502 {
1503 BOOL Ret = FALSE;
1504
1505 /* In case the shell hook wasn't registered properly, ignore WM_NULLs*/
1506 if (uMsg == 0)
1507 {
1508 bHandled = FALSE;
1509 return 0;
1510 }
1511
1512 TRACE("Received shell hook message: wParam=%08lx, lParam=%08lx\n", wParam, lParam);
1513
1514 switch ((INT) wParam)
1515 {
1516 case HSHELL_APPCOMMAND:
1518 break;
1519
1522 AddTask((HWND) lParam);
1523 break;
1524
1526 /* The window still exists! Delay destroying it a bit */
1529 break;
1530
1532 case HSHELL_WINDOWACTIVATED:
1535 break;
1536
1537 case HSHELL_FLASH:
1539 break;
1540
1541 case HSHELL_REDRAW:
1543 break;
1544
1545 case HSHELL_TASKMAN:
1546 ::PostMessage(m_Tray->GetHWND(), TWM_OPENSTARTMENU, 0, 0);
1547 break;
1548
1550 ::SwitchToThisWindow(m_Tray->GetHWND(), TRUE);
1551 ::SetForegroundWindow(m_Tray->GetHWND());
1552 break;
1553
1554 case HSHELL_LANGUAGE:
1555 case HSHELL_SYSMENU:
1556 case HSHELL_ENDTASK:
1557 case HSHELL_ACCESSIBILITYSTATE:
1558 case HSHELL_WINDOWREPLACED:
1559 case HSHELL_WINDOWREPLACING:
1560
1561 case HSHELL_GETMINRECT:
1562 default:
1563 {
1564#if DEBUG_SHELL_HOOK
1565 int i, found;
1566 for (i = 0, found = 0; i != _countof(hshell_msg); i++)
1567 {
1568 if (hshell_msg[i].msg == (INT) wParam)
1569 {
1570 TRACE("Shell message %ws unhandled (lParam = 0x%p)!\n", hshell_msg[i].msg_name, lParam);
1571 found = 1;
1572 break;
1573 }
1574 }
1575 if (found)
1576 break;
1577#endif
1578 TRACE("Shell message %d unhandled (lParam = 0x%p)!\n", (INT) wParam, lParam);
1579 break;
1580 }
1581 }
1582
1583 return Ret;
1584 }
1585
1587 {
1588 BOOL bIsMinimized;
1589 BOOL bIsActive;
1590
1591 if (::IsWindow(TaskItem->hWnd))
1592 {
1593 bIsMinimized = ::IsIconic(TaskItem->hWnd);
1594 bIsActive = (TaskItem == m_ActiveTaskItem);
1595
1596 TRACE("Active TaskItem %p, selected TaskItem %p\n", m_ActiveTaskItem, TaskItem);
1597 if (m_ActiveTaskItem)
1598 TRACE("Active TaskItem hWnd=%p, TaskItem hWnd %p\n", m_ActiveTaskItem->hWnd, TaskItem->hWnd);
1599
1600 TRACE("Valid button clicked. HWND=%p, IsMinimized=%s, IsActive=%s...\n",
1601 TaskItem->hWnd, bIsMinimized ? "Yes" : "No", bIsActive ? "Yes" : "No");
1602
1603 if (!bIsMinimized && bIsActive)
1604 {
1605 ::ShowWindowAsync(TaskItem->hWnd, SW_MINIMIZE);
1606 TRACE("Valid button clicked. App window Minimized.\n");
1607 }
1608 else
1609 {
1610 ::SwitchToThisWindow(TaskItem->hWnd, TRUE);
1611
1612 TRACE("Valid button clicked. App window Restored.\n");
1613 }
1614 }
1615 }
1616
1618 {
1619 /* TODO: Show task group menu */
1620 }
1621
1623 {
1624 PTASK_ITEM TaskItem;
1625 PTASK_GROUP TaskGroup;
1626
1628 {
1629 TaskGroup = FindTaskGroupByIndex((INT) wIndex);
1630 if (TaskGroup != NULL && TaskGroup->IsCollapsed)
1631 {
1632 HandleTaskGroupClick(TaskGroup);
1633 return TRUE;
1634 }
1635 }
1636
1637 TaskItem = FindTaskItemByIndex((INT) wIndex);
1638 if (TaskItem != NULL)
1639 {
1640 SendPulseToTray(FALSE, TaskItem->hWnd);
1641 HandleTaskItemClick(TaskItem);
1642 return TRUE;
1643 }
1644
1645 return FALSE;
1646 }
1647
1648 static VOID CALLBACK
1650 {
1651 ::PostMessageW(hwnd, WM_NULL, 0, 0);
1652 }
1653
1655 {
1656 POINT pt;
1657 GetCursorPos(&pt);
1658
1659 SetForegroundWindow(TaskItem->hWnd);
1660
1661 ActivateTask(TaskItem->hWnd);
1662
1663 if (GetForegroundWindow() != TaskItem->hWnd)
1664 ERR("HandleTaskItemRightClick detected the window did not become foreground\n");
1665
1666 ::SendMessageCallbackW(TaskItem->hWnd, WM_POPUPSYSTEMMENU, 0, MAKELPARAM(pt.x, pt.y),
1667 SendAsyncProc, (ULONG_PTR)TaskItem);
1668 }
1669
1671 {
1672 /* TODO: Show task group right click menu */
1673 }
1674
1676 {
1677 PTASK_ITEM TaskItem;
1678 PTASK_GROUP TaskGroup;
1680 {
1681 TaskGroup = FindTaskGroupByIndex((INT) wIndex);
1682 if (TaskGroup != NULL && TaskGroup->IsCollapsed)
1683 {
1684 HandleTaskGroupRightClick(TaskGroup);
1685 return TRUE;
1686 }
1687 }
1688
1689 TaskItem = FindTaskItemByIndex((INT) wIndex);
1690
1691 if (TaskItem != NULL)
1692 {
1693 HandleTaskItemRightClick(TaskItem);
1694 return TRUE;
1695 }
1696
1697 return FALSE;
1698 }
1699
1700
1702 {
1703 LRESULT Ret = CDRF_DODEFAULT;
1704 PTASK_GROUP TaskGroup;
1705 PTASK_ITEM TaskItem;
1706
1707 TaskItem = FindTaskItemByIndex((INT) nmtbcd->nmcd.dwItemSpec);
1708 TaskGroup = FindTaskGroupByIndex((INT) nmtbcd->nmcd.dwItemSpec);
1709 if (TaskGroup == NULL && TaskItem != NULL)
1710 {
1711 ASSERT(TaskItem != NULL);
1712
1713 if (TaskItem != NULL && ::IsWindow(TaskItem->hWnd))
1714 {
1715 /* Make the entire button flashing if necessary */
1716 if (nmtbcd->nmcd.uItemState & CDIS_MARKED)
1717 {
1718 Ret = TBCDRF_NOBACKGROUND;
1719 if (!m_Theme)
1720 {
1721 SelectObject(nmtbcd->nmcd.hdc, GetSysColorBrush(COLOR_HIGHLIGHT));
1722 Rectangle(nmtbcd->nmcd.hdc,
1723 nmtbcd->nmcd.rc.left,
1724 nmtbcd->nmcd.rc.top,
1725 nmtbcd->nmcd.rc.right,
1726 nmtbcd->nmcd.rc.bottom);
1727 }
1728 else
1729 {
1730 DrawThemeBackground(m_Theme, nmtbcd->nmcd.hdc, TDP_FLASHBUTTON, 0, &nmtbcd->nmcd.rc, 0);
1731 }
1732 nmtbcd->clrText = GetSysColor(COLOR_HIGHLIGHTTEXT);
1733 return Ret;
1734 }
1735 }
1736 }
1737 else if (TaskGroup != NULL)
1738 {
1739 /* FIXME: Implement painting for task groups */
1740 }
1741 return Ret;
1742 }
1743
1745 {
1746 LRESULT Ret = 0;
1747
1748 switch (nmh->code)
1749 {
1750 case NM_CUSTOMDRAW:
1751 {
1752 LPNMTBCUSTOMDRAW nmtbcd = (LPNMTBCUSTOMDRAW) nmh;
1753
1754 switch (nmtbcd->nmcd.dwDrawStage)
1755 {
1756
1757 case CDDS_ITEMPREPAINT:
1758 Ret = HandleItemPaint(nmtbcd);
1759 break;
1760
1761 case CDDS_PREPAINT:
1762 Ret = CDRF_NOTIFYITEMDRAW;
1763 break;
1764
1765 default:
1766 Ret = CDRF_DODEFAULT;
1767 break;
1768 }
1769 break;
1770 }
1771 }
1772
1773 return Ret;
1774 }
1775
1777 {
1778 HDC hdc = (HDC) wParam;
1779
1780 if (!IsAppThemed())
1781 {
1782 bHandled = FALSE;
1783 return 0;
1784 }
1785
1786 RECT rect;
1789
1790 return TRUE;
1791 }
1792
1794 {
1795 SIZE szClient;
1796
1797 szClient.cx = LOWORD(lParam);
1798 szClient.cy = HIWORD(lParam);
1799 if (m_TaskBar.m_hWnd != NULL)
1800 {
1801 m_TaskBar.SetWindowPos(NULL, 0, 0, szClient.cx, szClient.cy, SWP_NOZORDER);
1802
1804 }
1805 return TRUE;
1806 }
1807
1809 {
1810 LRESULT Ret = TRUE;
1811 /* We want the tray window to be draggable everywhere, so make the control
1812 appear transparent */
1813 Ret = DefWindowProc(uMsg, wParam, lParam);
1814 if (Ret != HTVSCROLL && Ret != HTHSCROLL)
1815 Ret = HTTRANSPARENT;
1816 return Ret;
1817 }
1818
1820 {
1821 LRESULT Ret = TRUE;
1822 if (lParam != 0 && (HWND) lParam == m_TaskBar.m_hWnd)
1823 {
1825 }
1826 return Ret;
1827 }
1828
1830 {
1831 LRESULT Ret = TRUE;
1832 const NMHDR *nmh = (const NMHDR *) lParam;
1833
1834 if (nmh->hwndFrom == m_TaskBar.m_hWnd)
1835 {
1836 Ret = HandleToolbarNotification(nmh);
1837 }
1838 return Ret;
1839 }
1840
1842 {
1843 /* Update the button spacing */
1844 m_TaskBar.UpdateTbButtonSpacing(m_Tray->IsHorizontal(), m_Theme != NULL);
1845 return TRUE;
1846 }
1847
1849 {
1850 BOOL bSettingsChanged = FALSE;
1851 TaskbarSettings* newSettings = (TaskbarSettings*)lParam;
1852
1853 if (newSettings->bGroupButtons != g_TaskbarSettings.bGroupButtons)
1854 {
1855 bSettingsChanged = TRUE;
1858 }
1859
1860 if (newSettings->bSmallIcons != g_TaskbarSettings.bSmallIcons)
1861 {
1862 bSettingsChanged = TRUE;
1864 }
1865
1866 if (bSettingsChanged)
1867 {
1868 /* Refresh each task item view */
1871 }
1872
1873 return 0;
1874 }
1875
1877 {
1878 LRESULT Ret = 0;
1879 INT_PTR iBtn = -1;
1880
1881 if (m_TaskBar.m_hWnd != NULL)
1882 {
1883 POINT pt;
1884
1885 pt.x = GET_X_LPARAM(lParam);
1886 pt.y = GET_Y_LPARAM(lParam);
1887
1889
1890 iBtn = m_TaskBar.HitTest(&pt);
1891 if (iBtn >= 0)
1892 {
1894 }
1895 }
1896 if (iBtn < 0)
1897 {
1898 /* Not on a taskbar button, so forward message to tray */
1899 Ret = SendMessage(m_Tray->GetHWND(), uMsg, wParam, lParam);
1900 }
1901 return Ret;
1902 }
1903
1905 {
1906 PTASK_ITEM TaskItem = FindTaskItem((HWND) wParam);
1907 if (TaskItem)
1908 {
1909 RECT* prcMinRect = (RECT*) lParam;
1910 RECT rcItem, rcToolbar;
1911 m_TaskBar.GetItemRect(TaskItem->Index, &rcItem);
1912 m_TaskBar.GetWindowRect(&rcToolbar);
1913
1914 OffsetRect(&rcItem, rcToolbar.left, rcToolbar.top);
1915
1916 *prcMinRect = rcItem;
1917 return TRUE;
1918 }
1919 return FALSE;
1920 }
1921
1923 {
1924 return MA_NOACTIVATE;
1925 }
1926
1928 {
1929#if DUMP_TASKS != 0
1930 switch (wParam)
1931 {
1932 case 1:
1933 DumpTasks();
1934 break;
1935 }
1936#endif
1937 return TRUE;
1938 }
1939
1941 {
1942 return m_TaskBar.SendMessageW(uMsg, wParam, lParam);
1943 }
1944
1946 {
1947 if (wParam == SPI_SETNONCLIENTMETRICS)
1948 {
1949 /* Don't update the font, this will be done when we get a WM_SETFONT from our parent */
1951 }
1952
1953 return 0;
1954 }
1955
1957 {
1959 if (cpData->dwData == m_uHardErrorMsg)
1960 {
1961 /* A hard error balloon message */
1963 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));
1964 if (pData->cbHeaderSize == sizeof(BALLOON_HARD_ERROR_DATA))
1966 return TRUE;
1967 }
1968
1969 return FALSE;
1970 }
1971
1973 {
1974 m_Tray = tray;
1977 if (!m_hWnd)
1978 return E_FAIL;
1979 return S_OK;
1980 }
1981
1983 {
1984 if (!phwnd)
1985 return E_INVALIDARG;
1986 *phwnd = m_hWnd;
1987 return S_OK;
1988 }
1989
1991 {
1992 return E_NOTIMPL;
1993 }
1994
1996
1998 MESSAGE_HANDLER(WM_THEMECHANGED, OnThemeChanged)
2016 END_MSG_MAP()
2017
2019
2023 END_COM_MAP()
2024};
2025
2027{
2028 return ShellObjectCreatorInit<CTaskSwitchWnd>(hWndParent, Tray, riid, ppv);
2029}
WCHAR windowText[1024]
Definition: appswitch.c:49
#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 TWM_OPENSTARTMENU
Definition: precomp.h:132
#define TSWM_UPDATETASKBARPOS
Definition: precomp.h:381
TaskbarSettings g_TaskbarSettings
Definition: settings.cpp:23
#define TWM_PULSE
Definition: precomp.h:134
#define TWM_SETTINGSCHANGED
Definition: precomp.h:133
#define WARN(fmt,...)
Definition: debug.h:112
#define ERR(fmt,...)
Definition: debug.h:110
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:110
static DWORD CALLBACK s_HardErrorThreadProc(IN OUT LPVOID lpParameter)
Definition: taskswnd.cpp:168
CStringW m_Text
Definition: taskswnd.cpp:111
HRESULT ThreadProc()
Definition: taskswnd.cpp:136
void StartThread(PBALLOON_HARD_ERROR_DATA pData)
Definition: taskswnd.cpp:178
BOOL HandleAppCommand(IN WPARAM wParam, IN LPARAM lParam)
Definition: taskswnd.cpp:1480
UINT m_ShellHookMsg
Definition: taskswnd.cpp:306
static BOOL CALLBACK s_EnumWindowsProc(IN HWND hWnd, IN LPARAM lParam)
Definition: taskswnd.cpp:1400
VOID RedrawTaskItem(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:1216
LRESULT OnTaskbarSettingsChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1848
INT UpdateTaskItemButton(IN PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:525
INT GetWndTextFromTaskItem(IN PTASK_ITEM TaskItem, LPWSTR szBuf, DWORD cchBuf)
Definition: taskswnd.cpp:349
LRESULT OnNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1829
LRESULT OnContextMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1876
LRESULT OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1927
PTASK_ITEM FindOtherTaskItem(IN HWND hWnd)
Definition: taskswnd.cpp:883
VOID UpdateButtonsSize(IN BOOL bRedrawDisabled)
Definition: taskswnd.cpp:1255
BOOL HandleButtonClick(IN WORD wIndex)
Definition: taskswnd.cpp:1622
virtual ~CTaskSwitchWnd()
Definition: taskswnd.cpp:347
PTASK_ITEM m_ActiveTaskItem
Definition: taskswnd.cpp:313
VOID ExpandTaskGroup(IN PTASK_GROUP TaskGroup)
Definition: taskswnd.cpp:481
PTASK_ITEM m_TaskItems
Definition: taskswnd.cpp:312
PTASK_GROUP AddToTaskGroup(IN HWND hWnd)
Definition: taskswnd.cpp:776
VOID RemoveIcon(IN PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:571
CComPtr< ITrayWindow > m_Tray
Definition: taskswnd.cpp:304
VOID CheckActivateTaskItem(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:1009
CTaskToolbar m_TaskBar
Definition: taskswnd.cpp:302
HRESULT WINAPI GetWindow(HWND *phwnd)
Definition: taskswnd.cpp:1982
UINT m_uHardErrorMsg
Definition: taskswnd.cpp:326
VOID UpdateIndexesAfter(IN INT iIndex, BOOL bInserted)
Definition: taskswnd.cpp:409
VOID SendPulseToTray(BOOL bDelete, HWND hwndActive)
Definition: taskswnd.cpp:1474
BOOL m_IsDestroying
Definition: taskswnd.cpp:322
VOID FreeTaskItem(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:976
LRESULT OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1819
WORD m_ButtonCount
Definition: taskswnd.cpp:317
PTASK_ITEM AllocTaskItem()
Definition: taskswnd.cpp:924
LRESULT OnSettingChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1945
HTHEME m_Theme
Definition: taskswnd.cpp:315
CHardErrorThread m_HardErrorThread
Definition: taskswnd.cpp:327
VOID FlashTaskItem(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:1195
VOID RemoveTaskFromTaskGroup(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:820
BOOL FlashTask(IN HWND hWnd)
Definition: taskswnd.cpp:1201
PTASK_ITEM FindLastTaskItemOfGroup(IN PTASK_GROUP TaskGroup OPTIONAL, IN PTASK_ITEM NewTaskItem OPTIONAL)
Definition: taskswnd.cpp:599
LRESULT OnShellHook(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1501
INT AddTaskItemButton(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:681
LRESULT OnMouseActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1922
BOOL ActivateTask(IN HWND hWnd)
Definition: taskswnd.cpp:1140
INT UpdateTaskGroupButton(IN PTASK_GROUP TaskGroup)
Definition: taskswnd.cpp:472
VOID DeleteTaskItem(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:994
BOOL ActivateTaskItem(IN OUT PTASK_ITEM TaskItem OPTIONAL)
Definition: taskswnd.cpp:1129
VOID DeleteAllTasks()
Definition: taskswnd.cpp:1181
BOOL RefreshWindowList()
Definition: taskswnd.cpp:1407
LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1793
BOOL RedrawTask(IN HWND hWnd)
Definition: taskswnd.cpp:1241
PTASK_GROUP m_TaskGroups
Definition: taskswnd.cpp:311
PTASK_GROUP FindTaskGroupByIndex(IN INT Index)
Definition: taskswnd.cpp:1084
BOOL m_IsGroupingEnabled
Definition: taskswnd.cpp:321
LRESULT OnKludgeItemRect(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1904
BOOL DeleteTaskItemButton(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:741
HICON GetWndIcon(HWND hwnd)
Definition: taskswnd.cpp:490
LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1462
VOID HandleTaskGroupRightClick(IN OUT PTASK_GROUP TaskGroup)
Definition: taskswnd.cpp:1670
BOOL CALLBACK EnumWindowsProc(IN HWND hWnd)
Definition: taskswnd.cpp:1390
LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1429
WORD m_AllocatedTaskItems
Definition: taskswnd.cpp:309
HRESULT WINAPI ContextSensitiveHelp(BOOL fEnterMode)
Definition: taskswnd.cpp:1990
LRESULT OnThemeChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1414
LRESULT OnSetFont(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1940
VOID HandleTaskGroupClick(IN OUT PTASK_GROUP TaskGroup)
Definition: taskswnd.cpp:1617
LRESULT OnEraseBackground(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1776
PTASK_ITEM FindTaskItem(IN HWND hWnd)
Definition: taskswnd.cpp:866
LRESULT HandleItemPaint(IN OUT NMTBCUSTOMDRAW *nmtbcd)
Definition: taskswnd.cpp:1701
HIMAGELIST m_ImageList
Definition: taskswnd.cpp:319
PTASK_ITEM FindTaskItemByIndex(IN INT Index)
Definition: taskswnd.cpp:1067
VOID HandleTaskItemClick(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:1586
LRESULT OnNcHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1808
static VOID CALLBACK SendAsyncProc(HWND hwnd, UINT uMsg, DWORD_PTR dwData, LRESULT lResult)
Definition: taskswnd.cpp:1649
VOID HandleTaskItemRightClick(IN OUT PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:1654
BOOL DeleteTask(IN HWND hWnd)
Definition: taskswnd.cpp:1164
HRESULT Initialize(IN HWND hWndParent, IN OUT ITrayWindow *tray)
Definition: taskswnd.cpp:1972
INT CalculateTaskItemNewButtonIndex(IN PTASK_ITEM TaskItem)
Definition: taskswnd.cpp:637
LRESULT OnUpdateTaskbarPos(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1841
WORD m_TaskItemCount
Definition: taskswnd.cpp:308
LRESULT OnCopyData(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:1956
LRESULT HandleToolbarNotification(IN const NMHDR *nmh)
Definition: taskswnd.cpp:1744
BOOL HandleButtonRightClick(IN WORD wIndex)
Definition: taskswnd.cpp:1675
UINT m_ButtonsPerLine
Definition: taskswnd.cpp:316
BOOL AddTask(IN HWND hWnd)
Definition: taskswnd.cpp:1100
BOOL SetButtonCommandId(IN INT iButtonIndex, IN INT iCommandId)
Definition: taskswnd.cpp:246
INT UpdateTbButtonSpacing(IN BOOL bHorizontal, IN BOOL bThemed, IN UINT uiRows=0, IN UINT uiBtnsPerLine=0)
Definition: taskswnd.cpp:203
VOID BeginUpdate()
Definition: taskswnd.cpp:235
LRESULT OnNcHitTestToolbar(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
Definition: taskswnd.cpp:257
VOID EndUpdate()
Definition: taskswnd.cpp:240
BOOL Initialize(HWND hWndParent)
Definition: taskswnd.cpp:282
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 NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
BOOL WINAPI ImageList_SetIconSize(HIMAGELIST himl, INT cx, INT cy)
Definition: imagelist.c:3038
BOOL WINAPI ImageList_Remove(HIMAGELIST himl, INT i)
Definition: imagelist.c:2568
INT WINAPI ImageList_ReplaceIcon(HIMAGELIST himl, INT nIndex, HICON hIcon)
Definition: imagelist.c:2779
HIMAGELIST WINAPI ImageList_Create(INT cx, INT cy, UINT flags, INT cInitial, INT cGrow)
Definition: imagelist.c:804
BOOL WINAPI ImageList_GetIconSize(HIMAGELIST himl, INT *cx, INT *cy)
Definition: imagelist.c:2037
#define CloseHandle
Definition: compat.h:739
#define HeapAlloc
Definition: compat.h:733
#define HeapReAlloc
Definition: compat.h:734
#define HeapFree(x, y, z)
Definition: compat.h:735
#define CALLBACK
Definition: compat.h:35
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define FAILED_UNEXPECTEDLY(hr)
Definition: precomp.h:121
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
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
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
HTHEME WINAPI OpenThemeData(HWND hwnd, LPCWSTR classlist)
Definition: system.c:835
BOOL WINAPI IsThemeActive(void)
Definition: system.c:606
HRESULT WINAPI CloseThemeData(HTHEME hTheme)
Definition: system.c:950
BOOL WINAPI IsAppThemed(void)
Definition: system.c:596
#define pt(x, y)
Definition: drawing.c:79
#define ULONG_PTR
Definition: config.h:101
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
GLuint index
Definition: glext.h:6031
GLintptr offset
Definition: glext.h:5920
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
HANDLE hProcessHeap
Definition: kbswitch.c:37
#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:92
static HICON
Definition: imagelist.c:84
static HANDLE ULONG_PTR dwData
Definition: file.c:35
static HTHEME(WINAPI *pOpenThemeDataEx)(HWND
HICON hIcon
Definition: msconfig.c:44
unsigned int UINT
Definition: ndis.h:50
#define L(x)
Definition: ntvdm.h:50
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_VISIBLE
Definition: pedump.c:620
long LONG
Definition: pedump.c:60
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
#define WS_CLIPCHILDREN
Definition: pedump.c:619
#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:2248
#define CDIS_MARKED
Definition: commctrl.h:298
#define CCS_TOP
Definition: commctrl.h:2242
#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:2245
#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 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:312
BOOL WINAPI SHFindFiles(PCIDLIST_ABSOLUTE pidlFolder, PCIDLIST_ABSOLUTE pidlSaveFile)
Definition: shellord.c:2262
HRESULT hr
Definition: shlfolder.c:183
#define _countof(array)
Definition: sndvol32.h:68
#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:218
BOOL bSmallIcons
Definition: precomp.h:222
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:63
DWORD IsCollapsed
Definition: taskswnd.cpp:74
DWORD dwTaskCount
Definition: taskswnd.cpp:65
DWORD dwFlags
Definition: taskswnd.cpp:70
DWORD dwProcessId
Definition: taskswnd.cpp:66
DWORD dwFlags
Definition: taskswnd.cpp:88
INT IconIndex
Definition: taskswnd.cpp:84
PTASK_GROUP Group
Definition: taskswnd.cpp:82
DWORD IsFlashing
Definition: taskswnd.cpp:93
DWORD RenderFlashed
Definition: taskswnd.cpp:97
HWND hWnd
Definition: taskswnd.cpp:81
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:3001
HWND hwndFrom
Definition: winuser.h:3157
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
HRESULT CTaskSwitchWnd_CreateInstance(IN HWND hWndParent, IN OUT ITrayWindow *Tray, REFIID riid, void **ppv)
Definition: taskswnd.cpp:2026
#define TASK_ITEM_ARRAY_ALLOC
Definition: taskswnd.cpp:30
struct _TASK_GROUP TASK_GROUP
#define GET_ICON(type)
const WCHAR szTaskSwitchWndClass[]
Definition: taskswnd.cpp:32
#define MAX_TASKS_COUNT
Definition: taskswnd.cpp:29
const WCHAR szRunningApps[]
Definition: taskswnd.cpp:33
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:40
#define WM_POPUPSYSTEMMENU
Definition: undocuser.h:61
HRESULT WINAPI SetWindowTheme(_In_ HWND hwnd, _In_ LPCWSTR pszSubAppName, _In_ LPCWSTR pszSubIdList)
Definition: uxthemesupp.c:69
@ TDP_FLASHBUTTON
Definition: vssym32.h:578
int ret
_In_ WDFCOLLECTION _In_ ULONG Index
VOID WINAPI SwitchToThisWindow(HWND hwnd, BOOL fAltTab)
Definition: window.c:82
#define ZeroMemory
Definition: winbase.h:1712
DWORD WINAPI GetWindowThreadProcessId(HWND hWnd, PDWORD lpdwProcessId)
#define MoveMemory
Definition: winbase.h:1709
_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 WINAPI
Definition: msvc.h:6
#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:1539
BOOL WINAPI Rectangle(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int)
#define WM_ERASEBKGND
Definition: winuser.h:1625
DWORD WINAPI GetSysColor(_In_ int)
#define HSHELL_RUDEAPPACTIVATED
Definition: winuser.h:1281
#define SM_CXMINIMIZED
Definition: winuser.h:1020
#define DT_NOPREFIX
Definition: winuser.h:537
#define SM_CYEDGE
Definition: winuser.h:1009
#define WM_QUIT
Definition: winuser.h:1623
#define GCLP_HICONSM
Definition: winuser.h:675
#define MAKELPARAM(l, h)
Definition: winuser.h:4008
#define HSHELL_ACTIVATESHELLWINDOW
Definition: winuser.h:1257
HWND WINAPI GetForegroundWindow(void)
Definition: ntwrapper.h:392
#define SM_CXEDGE
Definition: winuser.h:1008
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define HSHELL_WINDOWDESTROYED
Definition: winuser.h:1256
#define IMAGE_ICON
Definition: winuser.h:212
#define GCLP_HICON
Definition: winuser.h:674
#define WM_CREATE
Definition: winuser.h:1608
#define SW_MINIMIZE
Definition: winuser.h:776
#define HSHELL_WINDOWCREATED
Definition: winuser.h:1255
#define WM_SIZE
Definition: winuser.h:1611
#define COLOR_HIGHLIGHT
Definition: winuser.h:926
HBRUSH WINAPI GetSysColorBrush(_In_ int)
struct tagCOPYDATASTRUCT * PCOPYDATASTRUCT
#define WM_COMMAND
Definition: winuser.h:1740
#define HTVSCROLL
Definition: winuser.h:2482
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:2203
#define HTHSCROLL
Definition: winuser.h:2481
BOOL WINAPI GetCursorPos(_Out_ LPPOINT)
Definition: cursoricon.c:2670
#define WM_NCHITTEST
Definition: winuser.h:1686
#define SM_CYSMICON
Definition: winuser.h:1013
BOOL WINAPI IsRectEmpty(_In_ LPCRECT)
#define GetClassLongPtr
Definition: winuser.h:5782
#define MA_NOACTIVATE
Definition: winuser.h:2503
#define CS_DBLCLKS
Definition: winuser.h:651
#define PostThreadMessage
Definition: winuser.h:5833
BOOL WINAPI SendMessageCallbackW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM, _In_ SENDASYNCPROC, _In_ ULONG_PTR)
#define SM_CXSIZE
Definition: winuser.h:991
UINT_PTR WINAPI SetTimer(_In_opt_ HWND, _In_ UINT_PTR, _In_ UINT, _In_opt_ TIMERPROC)
BOOL WINAPI ShowWindowAsync(_In_ HWND, _In_ int)
#define WM_SETTINGCHANGE
Definition: winuser.h:1629
#define SM_CXSMICON
Definition: winuser.h:1012
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)
#define SM_CYICON
Definition: winuser.h:973
BOOL WINAPI EnumWindows(_In_ WNDENUMPROC lpEnumFunc, _In_ LPARAM lParam)
#define WM_SETFONT
Definition: winuser.h:1650
#define WM_TIMER
Definition: winuser.h:1742
#define WM_COPYDATA
Definition: winuser.h:1664
#define WM_NULL
Definition: winuser.h:1607
#define SendMessage
Definition: winuser.h:5843
UINT WINAPI RegisterWindowMessageW(_In_ LPCWSTR)
#define COLOR_HIGHLIGHTTEXT
Definition: winuser.h:927
#define HSHELL_FLASH
Definition: winuser.h:1280
#define WM_MOUSEACTIVATE
Definition: winuser.h:1637
#define LR_SHARED
Definition: winuser.h:1100
#define PostMessage
Definition: winuser.h:5832
#define HTTRANSPARENT
Definition: winuser.h:2473
BOOL WINAPI OffsetRect(_Inout_ LPRECT, _In_ int, _In_ int)
#define WM_DESTROY
Definition: winuser.h:1609
#define LR_DEFAULTSIZE
Definition: winuser.h:1094
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
#define SWP_NOZORDER
Definition: winuser.h:1247
INT WINAPI InternalGetWindowText(_In_ HWND hWnd, _Out_writes_to_(cchMaxCount, return+1) LPWSTR pString, _In_ int cchMaxCount)
#define SM_CXICON
Definition: winuser.h:972
int WINAPI GetSystemMetrics(_In_ int)
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define COLOR_3DFACE
Definition: winuser.h:929
#define WM_SETREDRAW
Definition: winuser.h:1616
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