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