Inheritance diagram for CTaskSwitchWnd:

[legend]

Collaboration diagram for CTaskSwitchWnd:

[legend]

Public Member Functions
	CTaskSwitchWnd ()

virtual	~CTaskSwitchWnd ()

INT	GetWndTextFromTaskItem (IN PTASK_ITEM TaskItem, LPWSTR szBuf, DWORD cchBuf)

VOID	UpdateIndexesAfter (IN INT iIndex, BOOL bInserted)

INT	UpdateTaskGroupButton (IN PTASK_GROUP TaskGroup)

VOID	ExpandTaskGroup (IN PTASK_GROUP TaskGroup)

HICON	GetWndIcon (HWND hwnd)

INT	UpdateTaskItemButton (IN PTASK_ITEM TaskItem)

VOID	RemoveIcon (IN PTASK_ITEM TaskItem)

PTASK_ITEM	FindLastTaskItemOfGroup (IN PTASK_GROUP TaskGroup OPTIONAL, IN PTASK_ITEM NewTaskItem OPTIONAL)

INT	CalculateTaskItemNewButtonIndex (IN PTASK_ITEM TaskItem)

INT	AddTaskItemButton (IN OUT PTASK_ITEM TaskItem)

BOOL	DeleteTaskItemButton (IN OUT PTASK_ITEM TaskItem)

PTASK_GROUP	AddToTaskGroup (IN HWND hWnd)

VOID	RemoveTaskFromTaskGroup (IN OUT PTASK_ITEM TaskItem)

PTASK_ITEM	FindTaskItem (IN HWND hWnd)

PTASK_ITEM	FindOtherTaskItem (IN HWND hWnd)

PTASK_ITEM	AllocTaskItem ()

VOID	FreeTaskItem (IN OUT PTASK_ITEM TaskItem)

VOID	DeleteTaskItem (IN OUT PTASK_ITEM TaskItem)

VOID	CheckActivateTaskItem (IN OUT PTASK_ITEM TaskItem)

PTASK_ITEM	FindTaskItemByIndex (IN INT Index)

PTASK_GROUP	FindTaskGroupByIndex (IN INT Index)

BOOL	AddTask (IN HWND hWnd)

BOOL	ActivateTaskItem (IN OUT PTASK_ITEM TaskItem OPTIONAL)

BOOL	ActivateTask (IN HWND hWnd)

BOOL	DeleteTask (IN HWND hWnd)

VOID	DeleteAllTasks ()

VOID	FlashTaskItem (IN OUT PTASK_ITEM TaskItem)

BOOL	FlashTask (IN HWND hWnd)

VOID	RedrawTaskItem (IN OUT PTASK_ITEM TaskItem)

BOOL	RedrawTask (IN HWND hWnd)

VOID	UpdateButtonsSize (IN BOOL bRedrawDisabled)

BOOL CALLBACK	EnumWindowsProc (IN HWND hWnd)

BOOL	RefreshWindowList ()

LRESULT	OnThemeChanged (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnCreate (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnDestroy (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

BOOL	HandleAppCommand (IN WPARAM wParam, IN LPARAM lParam)

LRESULT	OnShellHook (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

VOID	HandleTaskItemClick (IN OUT PTASK_ITEM TaskItem)

VOID	HandleTaskGroupClick (IN OUT PTASK_GROUP TaskGroup)

BOOL	HandleButtonClick (IN WORD wIndex)

VOID	HandleTaskItemRightClick (IN OUT PTASK_ITEM TaskItem)

VOID	HandleTaskGroupRightClick (IN OUT PTASK_GROUP TaskGroup)

BOOL	HandleButtonRightClick (IN WORD wIndex)

LRESULT	HandleItemPaint (IN OUT NMTBCUSTOMDRAW *nmtbcd)

LRESULT	HandleToolbarNotification (IN const NMHDR *nmh)

LRESULT	OnEraseBackground (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnSize (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnNcHitTest (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnCommand (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnNotify (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnUpdateTaskbarPos (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnTaskbarSettingsChanged (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnContextMenu (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnKludgeItemRect (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnMouseActivate (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnTimer (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnSetFont (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnSettingChanged (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnCopyData (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

HRESULT	Initialize (IN HWND hWndParent, IN OUT ITrayWindow *tray)

HRESULT WINAPI	GetWindow (HWND *phwnd)

HRESULT WINAPI	ContextSensitiveHelp (BOOL fEnterMode)

Public Member Functions inherited from ATL::CComObjectRootEx< CComMultiThreadModelNoCS >
	~CComObjectRootEx ()

ULONG	InternalAddRef ()

ULONG	InternalRelease ()

void	Lock ()

void	Unlock ()

HRESULT	_AtlInitialConstruct ()

Public Member Functions inherited from ATL::CComObjectRootBase
	CComObjectRootBase ()

	~CComObjectRootBase ()

void	SetVoid (void *)

HRESULT	_AtlFinalConstruct ()

HRESULT	FinalConstruct ()

void	InternalFinalConstructAddRef ()

void	InternalFinalConstructRelease ()

void	FinalRelease ()

Public Member Functions inherited from ATL::CWindowImpl< CTaskSwitchWnd, CWindow, CControlWinTraits >
HWND	Create (HWND hWndParent, _U_RECT rect=NULL, LPCTSTR szWindowName=NULL, DWORD dwStyle=0, DWORD dwExStyle=0, _U_MENUorID MenuOrID=0U, LPVOID lpCreateParam=NULL)

Public Member Functions inherited from ATL::CWindowImplBaseT< CWindow, CControlWinTraits >
	CWindowImplBaseT ()

virtual void	OnFinalMessage (HWND)

BOOL	SubclassWindow (HWND hWnd)

virtual WNDPROC	GetWindowProc ()

LRESULT	DefWindowProc (UINT uMsg, WPARAM wParam, LPARAM lParam)

HWND	Create (HWND hWndParent, _U_RECT rect, LPCTSTR szWindowName, DWORD dwStyle, DWORD dwExStyle, _U_MENUorID MenuOrID, ATOM atom, LPVOID lpCreateParam)

Public Member Functions inherited from ATL::CWindowImplRoot< CWindow >
	CWindowImplRoot ()

virtual	~CWindowImplRoot ()

Public Member Functions inherited from ATL::CWindow
	CWindow (HWND hWnd=NULL)

	operator HWND () const

UINT	ArrangeIconicWindows ()

void	Attach (HWND hWndNew)

HDC	BeginPaint (LPPAINTSTRUCT lpPaint)

BOOL	BringWindowToTop ()

BOOL	CenterWindow (HWND hWndCenter=NULL)

BOOL	ChangeClipboardChain (HWND hWndNewNext)

BOOL	CheckDlgButton (int nIDButton, UINT nCheck)

BOOL	CheckRadioButton (int nIDFirstButton, int nIDLastButton, int nIDCheckButton)

HWND	ChildWindowFromPoint (POINT point) const

HWND	ChildWindowFromPointEx (POINT point, UINT uFlags) const

BOOL	ClientToScreen (LPPOINT lpPoint) const

BOOL	ClientToScreen (LPRECT lpRect) const

HWND	Create (LPCTSTR lpstrWndClass, HWND hWndParent, _U_RECT rect=NULL, LPCTSTR szWindowName=NULL, DWORD dwStyle=0, DWORD dwExStyle=0, _U_MENUorID MenuOrID=0U, LPVOID lpCreateParam=NULL)

BOOL	CreateCaret (HBITMAP pBitmap)

BOOL	CreateGrayCaret (int nWidth, int nHeight)

BOOL	CreateSolidCaret (int nWidth, int nHeight)

HDWP	DeferWindowPos (HDWP hWinPosInfo, HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT uFlags)

BOOL	DestroyWindow ()

HWND	Detach ()

int	DlgDirList (LPTSTR lpPathSpec, int nIDListBox, int nIDStaticPath, UINT nFileType)

int	DlgDirListComboBox (LPTSTR lpPathSpec, int nIDComboBox, int nIDStaticPath, UINT nFileType)

BOOL	DlgDirSelect (LPTSTR lpString, int nCount, int nIDListBox)

BOOL	DlgDirSelectComboBox (LPTSTR lpString, int nCount, int nIDComboBox)

void	DragAcceptFiles (BOOL bAccept=TRUE)

BOOL	DrawMenuBar ()

BOOL	EnableScrollBar (UINT uSBFlags, UINT uArrowFlags=ESB_ENABLE_BOTH)

BOOL	EnableWindow (BOOL bEnable=TRUE)

void	EndPaint (LPPAINTSTRUCT lpPaint)

BOOL	FlashWindow (BOOL bInvert)

BOOL	GetClientRect (LPRECT lpRect) const

HDC	GetDC ()

HDC	GetDCEx (HRGN hRgnClip, DWORD flags)

HWND	GetDescendantWindow (int nID) const

HRESULT	GetDlgControl (int nID, REFIID iid, void **ppCtrl)

int	GetDlgCtrlID () const

HRESULT	GetDlgHost (int nID, REFIID iid, void **ppHost)

HWND	GetDlgItem (int nID)

UINT	GetDlgItemInt (int nID, BOOL *lpTrans=NULL, BOOL bSigned=TRUE) const

UINT	GetDlgItemText (int nID, LPTSTR lpStr, int nMaxCount) const

BOOL	GetDlgItemText (int nID, BSTR &bstrText) const

DWORD	GetExStyle () const

HFONT	GetFont () const

DWORD	GetHotKey () const

HICON	GetIcon (BOOL bBigIcon=TRUE) const

HWND	GetLastActivePopup () const

HMENU	GetMenu () const

HWND	GetNextDlgGroupItem (HWND hWndCtl, BOOL bPrevious=FALSE) const

HWND	GetNextDlgTabItem (HWND hWndCtl, BOOL bPrevious=FALSE) const

CWindow	GetParent () const

BOOL	GetScrollInfo (int nBar, LPSCROLLINFO lpScrollInfo)

BOOL	GetScrollPos (int nBar)

BOOL	GetScrollRange (int nBar, LPINT lpMinPos, LPINT lpMaxPos) const

DWORD	GetStyle () const

HMENU	GetSystemMenu (BOOL bRevert)

HWND	GetTopLevelParent () const

HWND	GetTopLevelWindow () const

HWND	GetTopWindow () const

BOOL	GetUpdateRect (LPRECT lpRect, BOOL bErase=FALSE)

int	GetUpdateRgn (HRGN hRgn, BOOL bErase=FALSE)

HWND	GetWindow (UINT nCmd) const

DWORD	GetWindowContextHelpId () const

HDC	GetWindowDC ()

LONG	GetWindowLong (int nIndex) const

LONG_PTR	GetWindowLongPtr (int nIndex) const

BOOL	GetWindowPlacement (WINDOWPLACEMENT *lpwndpl) const

DWORD	GetWindowProcessID ()

BOOL	GetWindowRect (LPRECT lpRect) const

int	GetWindowRgn (HRGN hRgn)

int	GetWindowText (LPTSTR lpszStringBuf, int nMaxCount) const

BOOL	GetWindowText (BSTR &bstrText)

int	GetWindowTextLength () const

DWORD	GetWindowThreadID ()

WORD	GetWindowWord (int nIndex) const

void	GotoDlgCtrl (HWND hWndCtrl) const

BOOL	HideCaret ()

BOOL	HiliteMenuItem (HMENU hMenu, UINT uHiliteItem, UINT uHilite)

BOOL	Invalidate (BOOL bErase=TRUE)

BOOL	InvalidateRect (LPCRECT lpRect, BOOL bErase=TRUE)

void	InvalidateRgn (HRGN hRgn, BOOL bErase=TRUE)

BOOL	IsChild (const HWND hWnd) const

BOOL	IsDialogMessage (LPMSG lpMsg)

UINT	IsDlgButtonChecked (int nIDButton) const

BOOL	IsIconic () const

BOOL	IsParentDialog ()

BOOL	IsWindow () const

BOOL	IsWindowEnabled () const

BOOL	IsWindowVisible () const

BOOL	IsWindowUnicode ()

BOOL	IsZoomed () const

BOOL	KillTimer (UINT_PTR nIDEvent)

BOOL	LockWindowUpdate (BOOL bLock=TRUE)

int	MapWindowPoints (HWND hWndTo, LPPOINT lpPoint, UINT nCount) const

int	MapWindowPoints (HWND hWndTo, LPRECT lpRect) const

int	MessageBox (LPCTSTR lpszText, LPCTSTR lpszCaption=NULL, UINT nType=MB_OK)

BOOL	ModifyStyle (DWORD dwRemove, DWORD dwAdd, UINT nFlags=0)

BOOL	ModifyStyleEx (DWORD dwRemove, DWORD dwAdd, UINT nFlags=0)

BOOL	MoveWindow (int x, int y, int nWidth, int nHeight, BOOL bRepaint=TRUE)

void	NextDlgCtrl () const

BOOL	OpenClipboard ()

BOOL	PostMessage (UINT message, WPARAM wParam=0, LPARAM lParam=0)

void	PrevDlgCtrl () const

void	Print (HDC hDC, DWORD dwFlags) const

void	PrintClient (HDC hDC, DWORD dwFlags) const

BOOL	RedrawWindow (LPCRECT lpRectUpdate=NULL, HRGN hRgnUpdate=NULL, UINT flags=RDW_INVALIDATE\|RDW_UPDATENOW\|RDW_ERASE)

int	ReleaseDC (HDC hDC)

BOOL	ResizeClient (int nWidth, int nHeight, BOOL bRedraw=FALSE)

BOOL	ScreenToClient (LPPOINT lpPoint) const

BOOL	ScrollWindow (int xAmount, int yAmount, LPCRECT lpRect=NULL, LPCRECT lpClipRect=NULL)

int	ScrollWindowEx (int dx, int dy, LPCRECT lpRectScroll, LPCRECT lpRectClip, HRGN hRgnUpdate, LPRECT lpRectUpdate, UINT flags)

LRESULT	SendDlgItemMessage (int nID, UINT message, WPARAM wParam=0, LPARAM lParam=0)

LRESULT	SendMessage (UINT message, WPARAM wParam=0, LPARAM lParam=0)

void	SendMessageToDescendants (UINT message, WPARAM wParam=0, LPARAM lParam=0, BOOL bDeep=TRUE)

BOOL	SendNotifyMessage (UINT message, WPARAM wParam=0, LPARAM lParam=0)

HWND	SetActiveWindow ()

HWND	SetCapture ()

HWND	SetClipboardViewer ()

int	SetDlgCtrlID (int nID)

BOOL	SetDlgItemInt (int nID, UINT nValue, BOOL bSigned=TRUE)

BOOL	SetDlgItemText (int nID, LPCTSTR lpszString)

HWND	SetFocus ()

void	SetFont (HFONT hFont, BOOL bRedraw=TRUE)

int	SetHotKey (WORD wVirtualKeyCode, WORD wModifiers)

HICON	SetIcon (HICON hIcon, BOOL bBigIcon=TRUE)

BOOL	SetMenu (HMENU hMenu)

HWND	SetParent (HWND hWndNewParent)

void	SetRedraw (BOOL bRedraw=TRUE)

int	SetScrollInfo (int nBar, LPSCROLLINFO lpScrollInfo, BOOL bRedraw=TRUE)

int	SetScrollPos (int nBar, int nPos, BOOL bRedraw=TRUE)

BOOL	SetScrollRange (int nBar, int nMinPos, int nMaxPos, BOOL bRedraw=TRUE)

UINT_PTR	SetTimer (UINT_PTR nIDEvent, UINT nElapse, void(CALLBACK *lpfnTimer)(HWND, UINT, UINT_PTR, DWORD)=NULL)

BOOL	SetWindowContextHelpId (DWORD dwContextHelpId)

LONG	SetWindowLong (int nIndex, LONG dwNewLong)

LONG_PTR	SetWindowLongPtr (int nIndex, LONG_PTR dwNewLong)

BOOL	SetWindowPlacement (const WINDOWPLACEMENT *lpwndpl)

BOOL	SetWindowPos (HWND hWndInsertAfter, int x, int y, int cx, int cy, UINT nFlags)

int	SetWindowRgn (HRGN hRgn, BOOL bRedraw=FALSE)

BOOL	SetWindowText (LPCTSTR lpszString)

WORD	SetWindowWord (int nIndex, WORD wNewWord)

BOOL	ShowCaret ()

BOOL	ShowOwnedPopups (BOOL bShow=TRUE)

BOOL	ShowScrollBar (UINT nBar, BOOL bShow=TRUE)

BOOL	ShowWindow (int nCmdShow)

BOOL	ShowWindowAsync (int nCmdShow)

BOOL	UpdateWindow ()

BOOL	ValidateRect (LPCRECT lpRect)

BOOL	ValidateRgn (HRGN hRgn)

BOOL	WinHelp (LPCTSTR lpszHelp, UINT nCmd=HELP_CONTEXT, DWORD dwData=0)

Public Member Functions inherited from ATL::CMessageMap
virtual BOOL	ProcessWindowMessage (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT &lResult, DWORD dwMsgMapID)=0

Public Member Functions inherited from IUnknown
HRESULT	QueryInterface ([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)

ULONG	AddRef ()

ULONG	Release ()

Static Public Member Functions
static BOOL CALLBACK	s_EnumWindowsProc (IN HWND hWnd, IN LPARAM lParam)

Static Public Member Functions inherited from ATL::CComCoClass< CTaskSwitchWnd >
static LPCTSTR WINAPI	GetObjectDescription ()

Static Public Member Functions inherited from ATL::CComObjectRootBase
static void WINAPI	ObjectMain (bool)

static const struct _ATL_CATMAP_ENTRY *	GetCategoryMap ()

static HRESULT WINAPI	InternalQueryInterface (void pThis, const _ATL_INTMAP_ENTRY pEntries, REFIID iid, void **ppvObject)

Static Public Member Functions inherited from ATL::CWindowImpl< CTaskSwitchWnd, CWindow, CControlWinTraits >
static LPCTSTR	GetWndCaption ()

Static Public Member Functions inherited from ATL::CWindowImplBaseT< CWindow, CControlWinTraits >
static DWORD	GetWndStyle (DWORD dwStyle)

static DWORD	GetWndExStyle (DWORD dwExStyle)

static LRESULT CALLBACK	StartWindowProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

static LRESULT CALLBACK	WindowProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

Static Public Member Functions inherited from ATL::CWindow
static LPCTSTR	GetWndClassName ()

static LRESULT	SendMessage (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

Additional Inherited Members
Public Types inherited from ATL::CWindowImplRoot< CWindow >
enum

Public Types inherited from IOleWindow
typedef IOleWindow *	LPOLEWINDOW

Public Types inherited from IUnknown
typedef IUnknown *	LPUNKNOWN

Public Attributes inherited from ATL::CComObjectRootBase
LONG	m_dwRef

Public Attributes inherited from ATL::CWindowImplBaseT< CWindow, CControlWinTraits >
WNDPROC	m_pfnSuperWindowProc

Public Attributes inherited from ATL::CWindowImplRoot< CWindow >
CWndProcThunk	m_thunk

const _ATL_MSG *	m_pCurrentMsg

DWORD	m_dwState

Public Attributes inherited from ATL::CWindow
HWND	m_hWnd

Static Public Attributes inherited from ATL::CWindow
static RECT	rcDefault

Detailed Description

Definition at line 294 of file taskswnd.cpp.

Constructor & Destructor Documentation

◆ CTaskSwitchWnd()

CTaskSwitchWnd::CTaskSwitchWnd ( )

inline

Definition at line 328 of file taskswnd.cpp.

                      :
         m_ShellHookMsg(NULL),
         m_TaskItemCount(0),
         m_AllocatedTaskItems(0),
         m_TaskGroups(NULL),
         m_TaskItems(NULL),
         m_ActiveTaskItem(NULL),
         m_Theme(NULL),
         m_ButtonsPerLine(0),
         m_ButtonCount(0),
         m_ImageList(NULL),
         m_IsGroupingEnabled(FALSE),
         m_IsDestroying(FALSE)
     {
         ZeroMemory(&m_ButtonSize, sizeof(m_ButtonSize));
         m_uHardErrorMsg = RegisterWindowMessageW(L"HardError");
     }

◆ ~CTaskSwitchWnd()

virtual CTaskSwitchWnd::~CTaskSwitchWnd ( )

inlinevirtual

Definition at line 345 of file taskswnd.cpp.

345 { }

Member Function Documentation

◆ ActivateTask()

BOOL CTaskSwitchWnd::ActivateTask ( IN HWND hWnd )

inline

Definition at line 1129 of file taskswnd.cpp.

     {
         PTASK_ITEM TaskItem;
 
         if (!hWnd)
         {
             return ActivateTaskItem(NULL);
         }
 
         TaskItem = FindTaskItem(hWnd);
         if (TaskItem == NULL)
         {
             TaskItem = FindOtherTaskItem(hWnd);
         }
 
         if (TaskItem == NULL)
         {
             WARN("Activate window 0x%p, could not find task\n", hWnd);
             RefreshWindowList();
         }
 
         return ActivateTaskItem(TaskItem);
     }

Referenced by HandleTaskItemRightClick(), and OnShellHook().

◆ ActivateTaskItem()

BOOL CTaskSwitchWnd::ActivateTaskItem ( IN OUT PTASK_ITEM TaskItem OPTIONAL )

inline

Definition at line 1117 of file taskswnd.cpp.

     {
         if (TaskItem != NULL)
         {
             TRACE("Activate window 0x%p on button %d\n", TaskItem->hWnd, TaskItem->Index);
         }
 
         CheckActivateTaskItem(TaskItem);
 
         return FALSE;
     }

Referenced by ActivateTask().

◆ AddTask()

BOOL CTaskSwitchWnd::AddTask ( IN HWND hWnd )

inline

Definition at line 1088 of file taskswnd.cpp.

     {
         PTASK_ITEM TaskItem;
 
         if (!::IsWindow(hWnd) || m_Tray->IsSpecialHWND(hWnd))
             return FALSE;
 
         TaskItem = FindTaskItem(hWnd);
         if (TaskItem == NULL)
         {
             TRACE("Add window 0x%p\n", hWnd);
             TaskItem = AllocTaskItem();
             if (TaskItem != NULL)
             {
                 ZeroMemory(TaskItem, sizeof(*TaskItem));
                 TaskItem->hWnd = hWnd;
                 TaskItem->Index = -1;
                 TaskItem->Group = AddToTaskGroup(hWnd);
 
                 if (!m_IsDestroying)
                 {
                     AddTaskItemButton(TaskItem);
                 }
             }
         }
 
         return TaskItem != NULL;
     }

Referenced by EnumWindowsProc(), and OnShellHook().

◆ AddTaskItemButton()

INT CTaskSwitchWnd::AddTaskItemButton ( IN OUT PTASK_ITEM TaskItem )

inline

Definition at line 669 of file taskswnd.cpp.

     {
         WCHAR windowText[255];
         TBBUTTON tbBtn = { 0 };
         INT iIndex;
         HICON icon;
 
         if (TaskItem->Index >= 0)
         {
             return UpdateTaskItemButton(TaskItem);
         }
 
         if (TaskItem->Group != NULL &&
             TaskItem->Group->IsCollapsed)
         {
             /* The task group is collapsed, we only need to update the group button */
             return UpdateTaskGroupButton(TaskItem->Group);
         }
 
         icon = GetWndIcon(TaskItem->hWnd);
         if (!icon)
             icon = static_cast<HICON>(LoadImageW(NULL, MAKEINTRESOURCEW(OIC_SAMPLE), IMAGE_ICON, 0, 0, LR_SHARED | LR_DEFAULTSIZE));
         TaskItem->IconIndex = ImageList_ReplaceIcon(m_ImageList, -1, icon);
 
         tbBtn.iBitmap = TaskItem->IconIndex;
         tbBtn.fsState = TBSTATE_ENABLED | TBSTATE_ELLIPSES;
         tbBtn.fsStyle = BTNS_CHECK | BTNS_NOPREFIX | BTNS_SHOWTEXT;
         tbBtn.dwData = TaskItem->Index;
 
         if (GetWndTextFromTaskItem(TaskItem, windowText, _countof(windowText)) > 0)
         {
             tbBtn.iString = (DWORD_PTR) windowText;
         }
 
         /* Find out where to insert the new button */
         iIndex = CalculateTaskItemNewButtonIndex(TaskItem);
         ASSERT(iIndex >= 0);
         tbBtn.idCommand = iIndex;
 
         m_TaskBar.BeginUpdate();
 
         if (m_TaskBar.InsertButton(iIndex, &tbBtn))
         {
             UpdateIndexesAfter(iIndex, TRUE);
 
             TRACE("Added button %d for hwnd 0x%p\n", iIndex, TaskItem->hWnd);
 
             TaskItem->Index = iIndex;
             m_ButtonCount++;
 
             /* Update button sizes and fix the button wrapping */
             UpdateButtonsSize(TRUE);
             return iIndex;
         }
 
         m_TaskBar.EndUpdate();
 
         return -1;
     }

Referenced by AddTask().

◆ AddToTaskGroup()

PTASK_GROUP CTaskSwitchWnd::AddToTaskGroup ( IN HWND hWnd )

inline

Definition at line 764 of file taskswnd.cpp.

     {
         DWORD dwProcessId;
         PTASK_GROUP TaskGroup, *PrevLink;
 
         if (!GetWindowThreadProcessId(hWnd,
             &dwProcessId))
         {
             TRACE("Cannot get process id of hwnd 0x%p\n", hWnd);
             return NULL;
         }
 
         /* Try to find an existing task group */
         TaskGroup = m_TaskGroups;
         PrevLink = &m_TaskGroups;
         while (TaskGroup != NULL)
         {
             if (TaskGroup->dwProcessId == dwProcessId)
             {
                 TaskGroup->dwTaskCount++;
                 return TaskGroup;
             }
 
             PrevLink = &TaskGroup->Next;
             TaskGroup = TaskGroup->Next;
         }
 
         /* Allocate a new task group */
         TaskGroup = (PTASK_GROUP) HeapAlloc(hProcessHeap,
             HEAP_ZERO_MEMORY,
             sizeof(*TaskGroup));
         if (TaskGroup != NULL)
         {
             TaskGroup->dwTaskCount = 1;
             TaskGroup->dwProcessId = dwProcessId;
             TaskGroup->Index = -1;
 
             /* Add the task group to the list */
             *PrevLink = TaskGroup;
         }
 
         return TaskGroup;
     }

Referenced by AddTask().

◆ AllocTaskItem()

PTASK_ITEM CTaskSwitchWnd::AllocTaskItem ( )

inline

Definition at line 912 of file taskswnd.cpp.

     {
         if (m_TaskItemCount >= MAX_TASKS_COUNT)
         {
             /* We need the most significant bit in 16 bit command IDs to indicate whether it
                is a task group or task item. WM_COMMAND limits command IDs to 16 bits! */
             return NULL;
         }
 
         ASSERT(m_AllocatedTaskItems >= m_TaskItemCount);
 
         if (m_TaskItemCount == 0)
         {
             m_TaskItems = (PTASK_ITEM) HeapAlloc(hProcessHeap,
                 0,
                 TASK_ITEM_ARRAY_ALLOC * sizeof(*m_TaskItems));
             if (m_TaskItems != NULL)
             {
                 m_AllocatedTaskItems = TASK_ITEM_ARRAY_ALLOC;
             }
             else
                 return NULL;
         }
         else if (m_TaskItemCount >= m_AllocatedTaskItems)
         {
             PTASK_ITEM NewArray;
             SIZE_T NewArrayLength, ActiveTaskItemIndex;
 
             NewArrayLength = m_AllocatedTaskItems + TASK_ITEM_ARRAY_ALLOC;
 
             NewArray = (PTASK_ITEM) HeapReAlloc(hProcessHeap,
                 0,
                 m_TaskItems,
                 NewArrayLength * sizeof(*m_TaskItems));
             if (NewArray != NULL)
             {
                 if (m_ActiveTaskItem != NULL)
                 {
                     /* Fixup the ActiveTaskItem pointer */
                     ActiveTaskItemIndex = m_ActiveTaskItem - m_TaskItems;
                     m_ActiveTaskItem = NewArray + ActiveTaskItemIndex;
                 }
                 m_AllocatedTaskItems = (WORD) NewArrayLength;
                 m_TaskItems = NewArray;
             }
             else
                 return NULL;
         }
 
         return m_TaskItems + m_TaskItemCount++;
     }

Referenced by AddTask().

◆ CalculateTaskItemNewButtonIndex()

INT CTaskSwitchWnd::CalculateTaskItemNewButtonIndex ( IN PTASK_ITEM TaskItem )

inline

Definition at line 625 of file taskswnd.cpp.

     {
         PTASK_GROUP TaskGroup;
         PTASK_ITEM LastTaskItem;
 
         /* NOTE: This routine assumes that the group is *not* collapsed! */
 
         TaskGroup = TaskItem->Group;
         if (m_IsGroupingEnabled)
         {
             if (TaskGroup != NULL)
             {
                 ASSERT(TaskGroup->Index < 0);
                 ASSERT(!TaskGroup->IsCollapsed);
 
                 if (TaskGroup->dwTaskCount > 1)
                 {
                     LastTaskItem = FindLastTaskItemOfGroup(TaskGroup, TaskItem);
                     if (LastTaskItem != NULL)
                     {
                         /* Since the group is expanded the task items must have an index */
                         ASSERT(LastTaskItem->Index >= 0);
 
                         return LastTaskItem->Index + 1;
                     }
                 }
             }
             else
             {
                 /* Find the last NULL group button. NULL groups are added at the end of the
                    task item list when grouping is enabled */
                 LastTaskItem = FindLastTaskItemOfGroup(NULL, TaskItem);
                 if (LastTaskItem != NULL)
                 {
                     ASSERT(LastTaskItem->Index >= 0);
 
                     return LastTaskItem->Index + 1;
                 }
             }
         }
 
         return m_ButtonCount;
     }

Referenced by AddTaskItemButton().

◆ CheckActivateTaskItem()

VOID CTaskSwitchWnd::CheckActivateTaskItem ( IN OUT PTASK_ITEM TaskItem )

inline

Definition at line 997 of file taskswnd.cpp.

     {
         PTASK_ITEM CurrentTaskItem;
         PTASK_GROUP TaskGroup = NULL;
 
         CurrentTaskItem = m_ActiveTaskItem;
 
         if (TaskItem != NULL)
             TaskGroup = TaskItem->Group;
 
         if (m_IsGroupingEnabled &&
             TaskGroup != NULL &&
             TaskGroup->IsCollapsed)
         {
             /* FIXME */
             return;
         }
 
         if (CurrentTaskItem != NULL)
         {
             PTASK_GROUP CurrentTaskGroup;
 
             if (CurrentTaskItem == TaskItem)
                 return;
 
             CurrentTaskGroup = CurrentTaskItem->Group;
 
             if (m_IsGroupingEnabled &&
                 CurrentTaskGroup != NULL &&
                 CurrentTaskGroup->IsCollapsed)
             {
                 if (CurrentTaskGroup == TaskGroup)
                     return;
 
                 /* FIXME */
             }
             else
             {
                 m_ActiveTaskItem = NULL;
                 if (CurrentTaskItem->Index >= 0)
                 {
                     UpdateTaskItemButton(CurrentTaskItem);
                 }
             }
         }
 
         m_ActiveTaskItem = TaskItem;
 
         if (TaskItem != NULL && TaskItem->Index >= 0)
         {
             UpdateTaskItemButton(TaskItem);
         }
         else if (TaskItem == NULL)
         {
             TRACE("Active TaskItem now NULL\n");
         }
     }

Referenced by ActivateTaskItem().

◆ ContextSensitiveHelp()

HRESULT WINAPI CTaskSwitchWnd::ContextSensitiveHelp ( BOOL fEnterMode )

inline

Implements IOleWindow.

Definition at line 1960 of file taskswnd.cpp.

     {
         return E_NOTIMPL;
     }

◆ DeleteAllTasks()

VOID CTaskSwitchWnd::DeleteAllTasks ( )

inline

Definition at line 1170 of file taskswnd.cpp.

     {
         PTASK_ITEM CurrentTask;
 
         if (m_TaskItemCount > 0)
         {
             CurrentTask = m_TaskItems + m_TaskItemCount;
             do
             {
                 DeleteTaskItem(--CurrentTask);
             } while (CurrentTask != m_TaskItems);
         }
     }

Referenced by OnDestroy().

◆ DeleteTask()

BOOL CTaskSwitchWnd::DeleteTask ( IN HWND hWnd )

inline

Definition at line 1153 of file taskswnd.cpp.

     {
         PTASK_ITEM TaskItem;
 
         TaskItem = FindTaskItem(hWnd);
         if (TaskItem != NULL)
         {
             TRACE("Delete window 0x%p on button %d\n", hWnd, TaskItem->Index);
             DeleteTaskItem(TaskItem);
             return TRUE;
         }
         //else
         //TRACE("Failed to delete window 0x%p\n", hWnd);
 
         return FALSE;
     }

Referenced by OnShellHook().

◆ DeleteTaskItem()

VOID CTaskSwitchWnd::DeleteTaskItem ( IN OUT PTASK_ITEM TaskItem )

inline

Definition at line 982 of file taskswnd.cpp.

     {
         if (!m_IsDestroying)
         {
             /* Delete the task button from the toolbar */
             DeleteTaskItemButton(TaskItem);
         }
 
         /* Remove the task from it's group */
         RemoveTaskFromTaskGroup(TaskItem);
 
         /* Free the task item */
         FreeTaskItem(TaskItem);
     }

Referenced by DeleteAllTasks(), and DeleteTask().

◆ DeleteTaskItemButton()

BOOL CTaskSwitchWnd::DeleteTaskItemButton ( IN OUT PTASK_ITEM TaskItem )

inline

Definition at line 729 of file taskswnd.cpp.

     {
         PTASK_GROUP TaskGroup;
         INT iIndex;
 
         TaskGroup = TaskItem->Group;
 
         if (TaskItem->Index >= 0)
         {
             if ((TaskGroup != NULL && !TaskGroup->IsCollapsed) ||
                 TaskGroup == NULL)
             {
                 m_TaskBar.BeginUpdate();
 
                 RemoveIcon(TaskItem);
                 iIndex = TaskItem->Index;
                 if (m_TaskBar.DeleteButton(iIndex))
                 {
                     TaskItem->Index = -1;
                     m_ButtonCount--;
 
                     UpdateIndexesAfter(iIndex, FALSE);
 
                     /* Update button sizes and fix the button wrapping */
                     UpdateButtonsSize(TRUE);
                     return TRUE;
                 }
 
                 m_TaskBar.EndUpdate();
             }
         }
 
         return FALSE;
     }

Referenced by DeleteTaskItem().

◆ EnumWindowsProc()

BOOL CALLBACK CTaskSwitchWnd::EnumWindowsProc ( IN HWND hWnd )

inline

Definition at line 1376 of file taskswnd.cpp.

     {
         /* Only show windows that still exist and are visible and none of explorer's
         special windows (such as the desktop or the tray window) */
         if (::IsWindow(hWnd) && ::IsWindowVisible(hWnd) &&
             !m_Tray->IsSpecialHWND(hWnd))
         {
             DWORD exStyle = ::GetWindowLong(hWnd, GWL_EXSTYLE);
             /* Don't list popup windows and also no tool windows */
             if ((::GetWindow(hWnd, GW_OWNER) == NULL || exStyle & WS_EX_APPWINDOW) &&
                 !(exStyle & WS_EX_TOOLWINDOW))
             {
                 TRACE("Adding task for %p...\n", hWnd);
                 AddTask(hWnd);
             }
 
         }
 
         return TRUE;
     }

◆ ExpandTaskGroup()

VOID CTaskSwitchWnd::ExpandTaskGroup ( IN PTASK_GROUP TaskGroup )

inline

Definition at line 479 of file taskswnd.cpp.

     {
         ASSERT(TaskGroup->dwTaskCount > 0);
         ASSERT(TaskGroup->IsCollapsed);
         ASSERT(TaskGroup->Index >= 0);
 
         /* FIXME: Implement */
     }

Referenced by RemoveTaskFromTaskGroup().

◆ FindLastTaskItemOfGroup()

PTASK_ITEM CTaskSwitchWnd::FindLastTaskItemOfGroup	(	IN PTASK_GROUP TaskGroup	OPTIONAL,
		IN PTASK_ITEM NewTaskItem	OPTIONAL
	)

inline

Definition at line 587 of file taskswnd.cpp.

     {
         PTASK_ITEM TaskItem, LastTaskItem, FoundTaskItem = NULL;
         DWORD dwTaskCount;
 
         ASSERT(m_IsGroupingEnabled);
 
         TaskItem = m_TaskItems;
         LastTaskItem = TaskItem + m_TaskItemCount;
 
         dwTaskCount = (TaskGroup != NULL ? TaskGroup->dwTaskCount : MAX_TASKS_COUNT);
 
         ASSERT(dwTaskCount > 0);
 
         while (TaskItem != LastTaskItem)
         {
             if (TaskItem->Group == TaskGroup)
             {
                 if ((NewTaskItem != NULL && TaskItem != NewTaskItem) || NewTaskItem == NULL)
                 {
                     FoundTaskItem = TaskItem;
                 }
 
                 if (--dwTaskCount == 0)
                 {
                     /* We found the last task item in the group! */
                     break;
                 }
             }
 
             TaskItem++;
         }
 
         return FoundTaskItem;
     }

Referenced by CalculateTaskItemNewButtonIndex().

◆ FindOtherTaskItem()

PTASK_ITEM CTaskSwitchWnd::FindOtherTaskItem ( IN HWND hWnd )

inline

Definition at line 871 of file taskswnd.cpp.

     {
         PTASK_ITEM LastItem, TaskItem;
         PTASK_GROUP TaskGroup;
         DWORD dwProcessId;
 
         if (!GetWindowThreadProcessId(hWnd, &dwProcessId))
         {
             return NULL;
         }
 
         /* Try to find another task that belongs to the same
            process as the given window */
         TaskItem = m_TaskItems;
         LastItem = TaskItem + m_TaskItemCount;
         while (TaskItem != LastItem)
         {
             TaskGroup = TaskItem->Group;
             if (TaskGroup != NULL)
             {
                 if (TaskGroup->dwProcessId == dwProcessId)
                     return TaskItem;
             }
             else
             {
                 DWORD dwProcessIdTask;
 
                 if (GetWindowThreadProcessId(TaskItem->hWnd,
                     &dwProcessIdTask) &&
                     dwProcessIdTask == dwProcessId)
                 {
                     return TaskItem;
                 }
             }
 
             TaskItem++;
         }
 
         return NULL;
     }

Referenced by ActivateTask().

◆ FindTaskGroupByIndex()

PTASK_GROUP CTaskSwitchWnd::FindTaskGroupByIndex ( IN INT Index )

inline

Definition at line 1072 of file taskswnd.cpp.

     {
         PTASK_GROUP CurrentGroup;
 
         CurrentGroup = m_TaskGroups;
         while (CurrentGroup != NULL)
         {
             if (CurrentGroup->Index == Index)
                 break;
 
             CurrentGroup = CurrentGroup->Next;
         }
 
         return CurrentGroup;
     }

Referenced by HandleButtonClick(), HandleButtonRightClick(), and HandleItemPaint().

◆ FindTaskItem()

PTASK_ITEM CTaskSwitchWnd::FindTaskItem ( IN HWND hWnd )

inline

Definition at line 854 of file taskswnd.cpp.

     {
         PTASK_ITEM TaskItem, LastItem;
 
         TaskItem = m_TaskItems;
         LastItem = TaskItem + m_TaskItemCount;
         while (TaskItem != LastItem)
         {
             if (TaskItem->hWnd == hWnd)
                 return TaskItem;
 
             TaskItem++;
         }
 
         return NULL;
     }

Referenced by ActivateTask(), AddTask(), DeleteTask(), FlashTask(), OnKludgeItemRect(), and RedrawTask().

◆ FindTaskItemByIndex()

PTASK_ITEM CTaskSwitchWnd::FindTaskItemByIndex ( IN INT Index )

inline

Definition at line 1055 of file taskswnd.cpp.

     {
         PTASK_ITEM TaskItem, LastItem;
 
         TaskItem = m_TaskItems;
         LastItem = TaskItem + m_TaskItemCount;
         while (TaskItem != LastItem)
         {
             if (TaskItem->Index == Index)
                 return TaskItem;
 
             TaskItem++;
         }
 
         return NULL;
     }

Referenced by HandleButtonClick(), HandleButtonRightClick(), and HandleItemPaint().

◆ FlashTask()

BOOL CTaskSwitchWnd::FlashTask ( IN HWND hWnd )

inline

Definition at line 1190 of file taskswnd.cpp.

     {
         PTASK_ITEM TaskItem;
 
         TaskItem = FindTaskItem(hWnd);
         if (TaskItem != NULL)
         {
             TRACE("Flashing window 0x%p on button %d\n", hWnd, TaskItem->Index);
             FlashTaskItem(TaskItem);
             return TRUE;
         }
 
         return FALSE;
     }

Referenced by OnShellHook().

◆ FlashTaskItem()

VOID CTaskSwitchWnd::FlashTaskItem ( IN OUT PTASK_ITEM TaskItem )

inline

Definition at line 1184 of file taskswnd.cpp.

     {
         TaskItem->RenderFlashed = 1;
         UpdateTaskItemButton(TaskItem);
     }

Referenced by FlashTask().

◆ FreeTaskItem()

VOID CTaskSwitchWnd::FreeTaskItem ( IN OUT PTASK_ITEM TaskItem )

inline

Definition at line 964 of file taskswnd.cpp.

     {
         WORD wIndex;
 
         if (TaskItem == m_ActiveTaskItem)
             m_ActiveTaskItem = NULL;
 
         wIndex = (WORD) (TaskItem - m_TaskItems);
         if (wIndex + 1 < m_TaskItemCount)
         {
             MoveMemory(TaskItem,
                 TaskItem + 1,
                 (m_TaskItemCount - wIndex - 1) * sizeof(*TaskItem));
         }
 
         m_TaskItemCount--;
     }

Referenced by DeleteTaskItem().

◆ GetWindow()

HRESULT WINAPI CTaskSwitchWnd::GetWindow ( HWND * phwnd )

inline

Implements IOleWindow.

Definition at line 1952 of file taskswnd.cpp.

     {
         if (!phwnd)
             return E_INVALIDARG;
         *phwnd = m_hWnd;
         return S_OK;
     }

Referenced by EnumWindowsProc().

◆ GetWndIcon()

HICON CTaskSwitchWnd::GetWndIcon ( HWND hwnd )

inline

Definition at line 488 of file taskswnd.cpp.

     {
         HICON hIcon = 0;
 
         SendMessageTimeout(hwnd, WM_GETICON, ICON_SMALL2, 0, SMTO_ABORTIFHUNG, 1000, (PDWORD_PTR) &hIcon);
         if (hIcon)
             return hIcon;
 
         SendMessageTimeout(hwnd, WM_GETICON, ICON_SMALL, 0, SMTO_ABORTIFHUNG, 1000, (PDWORD_PTR) &hIcon);
         if (hIcon)
             return hIcon;
 
         SendMessageTimeout(hwnd, WM_GETICON, ICON_BIG, 0, SMTO_ABORTIFHUNG, 1000, (PDWORD_PTR) &hIcon);
         if (hIcon)
             return hIcon;
 
         hIcon = (HICON) GetClassLongPtr(hwnd, GCL_HICONSM);
         if (hIcon)
             return hIcon;
 
         hIcon = (HICON) GetClassLongPtr(hwnd, GCL_HICON);
 
         return hIcon;
     }

Referenced by AddTaskItemButton(), and UpdateTaskItemButton().

◆ GetWndTextFromTaskItem()

INT CTaskSwitchWnd::GetWndTextFromTaskItem	(	IN PTASK_ITEM	TaskItem,
		LPWSTR	szBuf,
		DWORD	cchBuf
	)

inline

Definition at line 347 of file taskswnd.cpp.

     {
         /* Get the window text without sending a message so we don't hang if an
            application isn't responding! */
         return InternalGetWindowText(TaskItem->hWnd, szBuf, cchBuf);
     }

Referenced by AddTaskItemButton(), and UpdateTaskItemButton().

◆ HandleAppCommand()

BOOL CTaskSwitchWnd::HandleAppCommand	(	IN WPARAM	wParam,
		IN LPARAM	lParam
	)

inline

Definition at line 1469 of file taskswnd.cpp.

     {
         BOOL Ret = FALSE;
 
         switch (GET_APPCOMMAND_LPARAM(lParam))
         {
         case APPCOMMAND_BROWSER_SEARCH:
             Ret = SHFindFiles(NULL,
                 NULL);
             break;
 
         case APPCOMMAND_BROWSER_HOME:
         case APPCOMMAND_LAUNCH_MAIL:
         default:
             TRACE("Shell app command %d unhandled!\n", (INT) GET_APPCOMMAND_LPARAM(lParam));
             break;
         }
 
         return Ret;
     }

Referenced by OnShellHook().

◆ HandleButtonClick()

BOOL CTaskSwitchWnd::HandleButtonClick ( IN WORD wIndex )

inline

Definition at line 1607 of file taskswnd.cpp.

     {
         PTASK_ITEM TaskItem;
         PTASK_GROUP TaskGroup;
 
         if (m_IsGroupingEnabled)
         {
             TaskGroup = FindTaskGroupByIndex((INT) wIndex);
             if (TaskGroup != NULL && TaskGroup->IsCollapsed)
             {
                 HandleTaskGroupClick(TaskGroup);
                 return TRUE;
             }
         }
 
         TaskItem = FindTaskItemByIndex((INT) wIndex);
         if (TaskItem != NULL)
         {
             HandleTaskItemClick(TaskItem);
             return TRUE;
         }
 
         return FALSE;
     }

Referenced by OnCommand().

◆ HandleButtonRightClick()

BOOL CTaskSwitchWnd::HandleButtonRightClick ( IN WORD wIndex )

inline

Definition at line 1657 of file taskswnd.cpp.

     {
         PTASK_ITEM TaskItem;
         PTASK_GROUP TaskGroup;
         if (m_IsGroupingEnabled)
         {
             TaskGroup = FindTaskGroupByIndex((INT) wIndex);
             if (TaskGroup != NULL && TaskGroup->IsCollapsed)
             {
                 HandleTaskGroupRightClick(TaskGroup);
                 return TRUE;
             }
         }
 
         TaskItem = FindTaskItemByIndex((INT) wIndex);
 
         if (TaskItem != NULL)
         {
             HandleTaskItemRightClick(TaskItem);
             return TRUE;
         }
 
         return FALSE;
     }

Referenced by OnContextMenu().

◆ HandleItemPaint()

LRESULT CTaskSwitchWnd::HandleItemPaint ( IN OUT NMTBCUSTOMDRAW * nmtbcd )

inline

Definition at line 1683 of file taskswnd.cpp.

     {
         LRESULT Ret = CDRF_DODEFAULT;
         PTASK_GROUP TaskGroup;
         PTASK_ITEM TaskItem;
 
         TaskItem = FindTaskItemByIndex((INT) nmtbcd->nmcd.dwItemSpec);
         TaskGroup = FindTaskGroupByIndex((INT) nmtbcd->nmcd.dwItemSpec);
         if (TaskGroup == NULL && TaskItem != NULL)
         {
             ASSERT(TaskItem != NULL);
 
             if (TaskItem != NULL && ::IsWindow(TaskItem->hWnd))
             {
                 /* Make the entire button flashing if necessary */
                 if (nmtbcd->nmcd.uItemState & CDIS_MARKED)
                 {
                     Ret = TBCDRF_NOBACKGROUND;
                     if (!m_Theme)
                     {
                         SelectObject(nmtbcd->nmcd.hdc, GetSysColorBrush(COLOR_HIGHLIGHT));
                         Rectangle(nmtbcd->nmcd.hdc,
                             nmtbcd->nmcd.rc.left,
                             nmtbcd->nmcd.rc.top,
                             nmtbcd->nmcd.rc.right,
                             nmtbcd->nmcd.rc.bottom);
                     }
                     else
                     {
                         DrawThemeBackground(m_Theme, nmtbcd->nmcd.hdc, TDP_FLASHBUTTON, 0, &nmtbcd->nmcd.rc, 0);
                     }
                     nmtbcd->clrText = GetSysColor(COLOR_HIGHLIGHTTEXT);
                     return Ret;
                 }
             }
         }
         else if (TaskGroup != NULL)
         {
             /* FIXME: Implement painting for task groups */
         }
         return Ret;
     }

Referenced by HandleToolbarNotification().

◆ HandleTaskGroupClick()

VOID CTaskSwitchWnd::HandleTaskGroupClick ( IN OUT PTASK_GROUP TaskGroup )

inline

Definition at line 1602 of file taskswnd.cpp.

     {
         /* TODO: Show task group menu */
     }

Referenced by HandleButtonClick().

◆ HandleTaskGroupRightClick()

VOID CTaskSwitchWnd::HandleTaskGroupRightClick ( IN OUT PTASK_GROUP TaskGroup )

inline

Definition at line 1652 of file taskswnd.cpp.

     {
         /* TODO: Show task group right click menu */
     }

Referenced by HandleButtonRightClick().

◆ HandleTaskItemClick()

VOID CTaskSwitchWnd::HandleTaskItemClick ( IN OUT PTASK_ITEM TaskItem )

inline

Definition at line 1572 of file taskswnd.cpp.

     {
         BOOL bIsMinimized;
         BOOL bIsActive;
 
         if (::IsWindow(TaskItem->hWnd))
         {
             bIsMinimized = ::IsIconic(TaskItem->hWnd);
             bIsActive = (TaskItem == m_ActiveTaskItem);
 
             TRACE("Active TaskItem %p, selected TaskItem %p\n", m_ActiveTaskItem, TaskItem);
             if (m_ActiveTaskItem)
                 TRACE("Active TaskItem hWnd=%p, TaskItem hWnd %p\n", m_ActiveTaskItem->hWnd, TaskItem->hWnd);
 
             TRACE("Valid button clicked. HWND=%p, IsMinimized=%s, IsActive=%s...\n",
                 TaskItem->hWnd, bIsMinimized ? "Yes" : "No", bIsActive ? "Yes" : "No");
 
             if (!bIsMinimized && bIsActive)
             {
                 ::ShowWindowAsync(TaskItem->hWnd, SW_MINIMIZE);
                 TRACE("Valid button clicked. App window Minimized.\n");
             }
             else
             {
                 ::SwitchToThisWindow(TaskItem->hWnd, TRUE);
                 TRACE("Valid button clicked. App window Restored.\n");
             }
         }
     }

Referenced by HandleButtonClick().

◆ HandleTaskItemRightClick()

VOID CTaskSwitchWnd::HandleTaskItemRightClick ( IN OUT PTASK_ITEM TaskItem )

inline

Definition at line 1633 of file taskswnd.cpp.

     {
         POINT pt;
         GetCursorPos(&pt);
 
         SetForegroundWindow(TaskItem->hWnd);
 
         ActivateTask(TaskItem->hWnd);
 
        /* Wait up to 2 seconds for the window to process the foreground notification. */
         DWORD_PTR resultDummy;
         if (!SendMessageTimeout(TaskItem->hWnd, WM_NULL, 0, 0, 0, 2000, &resultDummy))
             ERR("HandleTaskItemRightClick detected the window was unresponsive for 2 seconds, or was destroyed\n");
         if (GetForegroundWindow() != TaskItem->hWnd)
             ERR("HandleTaskItemRightClick detected the window did not become foreground\n");
 
         ::SendMessageW(TaskItem->hWnd, WM_POPUPSYSTEMMENU, 0, MAKELPARAM(pt.x, pt.y));
     }

Referenced by HandleButtonRightClick().

◆ HandleToolbarNotification()

LRESULT CTaskSwitchWnd::HandleToolbarNotification ( IN const NMHDR * nmh )

inline

Definition at line 1726 of file taskswnd.cpp.

     {
         LRESULT Ret = 0;
 
         switch (nmh->code)
         {
         case NM_CUSTOMDRAW:
         {
             LPNMTBCUSTOMDRAW nmtbcd = (LPNMTBCUSTOMDRAW) nmh;
 
             switch (nmtbcd->nmcd.dwDrawStage)
             {
 
             case CDDS_ITEMPREPAINT:
                 Ret = HandleItemPaint(nmtbcd);
                 break;
 
             case CDDS_PREPAINT:
                 Ret = CDRF_NOTIFYITEMDRAW;
                 break;
 
             default:
                 Ret = CDRF_DODEFAULT;
                 break;
             }
             break;
         }
         }
 
         return Ret;
     }

Referenced by OnNotify().

◆ Initialize()

HRESULT CTaskSwitchWnd::Initialize	(	IN HWND	hWndParent,
		IN OUT ITrayWindow *	tray
	)

inline

Definition at line 1942 of file taskswnd.cpp.

     {
         m_Tray = tray;
         m_IsGroupingEnabled = g_TaskbarSettings.bGroupButtons;
         Create(hWndParent, 0, szRunningApps, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_TABSTOP);
         if (!m_hWnd)
             return E_FAIL;
         return S_OK;
     }

◆ OnCommand()

LRESULT CTaskSwitchWnd::OnCommand	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1801 of file taskswnd.cpp.

     {
         LRESULT Ret = TRUE;
         if (lParam != 0 && (HWND) lParam == m_TaskBar.m_hWnd)
         {
             HandleButtonClick(LOWORD(wParam));
         }
         return Ret;
     }

◆ OnContextMenu()

LRESULT CTaskSwitchWnd::OnContextMenu	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1846 of file taskswnd.cpp.

     {
         LRESULT Ret = 0;
         INT_PTR iBtn = -1;
 
         if (m_TaskBar.m_hWnd != NULL)
         {
             POINT pt;
 
             pt.x = GET_X_LPARAM(lParam);
             pt.y = GET_Y_LPARAM(lParam);
 
             ::ScreenToClient(m_TaskBar.m_hWnd, &pt);
 
             iBtn = m_TaskBar.HitTest(&pt);
             if (iBtn >= 0)
             {
                 HandleButtonRightClick(iBtn);
             }
         }
         if (iBtn < 0)
         {
             /* Not on a taskbar button, so forward message to tray */
             Ret = SendMessage(m_Tray->GetHWND(), uMsg, wParam, lParam);
         }
         return Ret;
     }

◆ OnCopyData()

LRESULT CTaskSwitchWnd::OnCopyData	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1926 of file taskswnd.cpp.

     {
         PCOPYDATASTRUCT cpData = (PCOPYDATASTRUCT)lParam;
         if (cpData->dwData == m_uHardErrorMsg)
         {
             /* A hard error balloon message */
             PBALLOON_HARD_ERROR_DATA pData = (PBALLOON_HARD_ERROR_DATA)cpData->lpData;
             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));
             if (pData->cbHeaderSize == sizeof(BALLOON_HARD_ERROR_DATA))
                 m_HardErrorThread.StartThread(pData);
             return TRUE;
         }
 
         return FALSE;
     }

◆ OnCreate()

LRESULT CTaskSwitchWnd::OnCreate	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1426 of file taskswnd.cpp.

     {
         if (!m_TaskBar.Initialize(m_hWnd))
             return FALSE;
 
         SetWindowTheme(m_TaskBar.m_hWnd, L"TaskBand", NULL);
 
         m_ImageList = ImageList_Create(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), ILC_COLOR32 | ILC_MASK, 0, 1000);
         m_TaskBar.SetImageList(m_ImageList);
 
         /* Set proper spacing between buttons */
         m_TaskBar.UpdateTbButtonSpacing(m_Tray->IsHorizontal(), m_Theme != NULL);
 
         /* Register the shell hook */
         m_ShellHookMsg = RegisterWindowMessageW(L"SHELLHOOK");
 
         TRACE("ShellHookMsg got assigned number %d\n", m_ShellHookMsg);
 
         RegisterShellHook(m_hWnd, 3); /* 1 if no NT! We're targeting NT so we don't care! */
 
         RefreshWindowList();
 
         /* Recalculate the button size */
         UpdateButtonsSize(FALSE);
 
 #if DUMP_TASKS != 0
         SetTimer(hwnd, 1, 5000, NULL);
 #endif
         return TRUE;
     }

◆ OnDestroy()

LRESULT CTaskSwitchWnd::OnDestroy	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1457 of file taskswnd.cpp.

     {
         m_IsDestroying = TRUE;
 
         /* Unregister the shell hook */
         RegisterShellHook(m_hWnd, FALSE);
 
         CloseThemeData(m_Theme);
         DeleteAllTasks();
         return TRUE;
     }

◆ OnEraseBackground()

LRESULT CTaskSwitchWnd::OnEraseBackground	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1758 of file taskswnd.cpp.

     {
         HDC hdc = (HDC) wParam;
 
         if (!IsAppThemed())
         {
             bHandled = FALSE;
             return 0;
         }
 
         RECT rect;
         GetClientRect(&rect);
         DrawThemeParentBackground(m_hWnd, hdc, &rect);
 
         return TRUE;
     }

◆ OnKludgeItemRect()

LRESULT CTaskSwitchWnd::OnKludgeItemRect	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1874 of file taskswnd.cpp.

     {
         PTASK_ITEM TaskItem = FindTaskItem((HWND) wParam);
         if (TaskItem)
         {
             RECT* prcMinRect = (RECT*) lParam;
             RECT rcItem, rcToolbar;
             m_TaskBar.GetItemRect(TaskItem->Index, &rcItem);
             m_TaskBar.GetWindowRect(&rcToolbar);
 
             OffsetRect(&rcItem, rcToolbar.left, rcToolbar.top);
 
             *prcMinRect = rcItem;
             return TRUE;
         }
         return FALSE;
     }

◆ OnMouseActivate()

LRESULT CTaskSwitchWnd::OnMouseActivate	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1892 of file taskswnd.cpp.

     {
         return MA_NOACTIVATE;
     }

◆ OnNcHitTest()

LRESULT CTaskSwitchWnd::OnNcHitTest	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1790 of file taskswnd.cpp.

     {
         LRESULT Ret = TRUE;
         /* We want the tray window to be draggable everywhere, so make the control
         appear transparent */
         Ret = DefWindowProc(uMsg, wParam, lParam);
         if (Ret != HTVSCROLL && Ret != HTHSCROLL)
             Ret = HTTRANSPARENT;
         return Ret;
     }

◆ OnNotify()

LRESULT CTaskSwitchWnd::OnNotify	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1811 of file taskswnd.cpp.

     {
         LRESULT Ret = TRUE;
         const NMHDR *nmh = (const NMHDR *) lParam;
 
         if (nmh->hwndFrom == m_TaskBar.m_hWnd)
         {
             Ret = HandleToolbarNotification(nmh);
         }
         return Ret;
     }

◆ OnSetFont()

LRESULT CTaskSwitchWnd::OnSetFont	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1910 of file taskswnd.cpp.

     {
         return m_TaskBar.SendMessageW(uMsg, wParam, lParam);
     }

◆ OnSettingChanged()

LRESULT CTaskSwitchWnd::OnSettingChanged	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1915 of file taskswnd.cpp.

     {
         if (wParam == SPI_SETNONCLIENTMETRICS)
         {
             /*  Don't update the font, this will be done when we get a WM_SETFONT from our parent */
             UpdateButtonsSize(FALSE);
         }
 
         return 0;
     }

◆ OnShellHook()

LRESULT CTaskSwitchWnd::OnShellHook	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1490 of file taskswnd.cpp.

     {
         BOOL Ret = FALSE;
 
         /* In case the shell hook wasn't registered properly, ignore WM_NULLs*/
         if (uMsg == 0)
         {
             bHandled = FALSE;
             return 0;
         }
 
         TRACE("Received shell hook message: wParam=%08lx, lParam=%08lx\n", wParam, lParam);
 
         switch ((INT) wParam)
         {
         case HSHELL_APPCOMMAND:
             Ret = HandleAppCommand(wParam, lParam);
             break;
 
         case HSHELL_WINDOWCREATED:
             AddTask((HWND) lParam);
             break;
 
         case HSHELL_WINDOWDESTROYED:
             /* The window still exists! Delay destroying it a bit */
             DeleteTask((HWND) lParam);
             break;
 
         case HSHELL_RUDEAPPACTIVATED:
         case HSHELL_WINDOWACTIVATED:
             ActivateTask((HWND) lParam);
             break;
 
         case HSHELL_FLASH:
             FlashTask((HWND) lParam);
             break;
 
         case HSHELL_REDRAW:
             RedrawTask((HWND) lParam);
             break;
 
         case HSHELL_TASKMAN:
             ::PostMessage(m_Tray->GetHWND(), TWM_OPENSTARTMENU, 0, 0);
             break;
 
         case HSHELL_ACTIVATESHELLWINDOW:
             ::SwitchToThisWindow(m_Tray->GetHWND(), TRUE);
             ::SetForegroundWindow(m_Tray->GetHWND());
             break;
 
         case HSHELL_LANGUAGE:
         case HSHELL_SYSMENU:
         case HSHELL_ENDTASK:
         case HSHELL_ACCESSIBILITYSTATE:
         case HSHELL_WINDOWREPLACED:
         case HSHELL_WINDOWREPLACING:
 
         case HSHELL_GETMINRECT:
         default:
         {
 #if DEBUG_SHELL_HOOK
             int i, found;
             for (i = 0, found = 0; i != _countof(hshell_msg); i++)
             {
                 if (hshell_msg[i].msg == (INT) wParam)
                 {
                     TRACE("Shell message %ws unhandled (lParam = 0x%p)!\n", hshell_msg[i].msg_name, lParam);
                     found = 1;
                     break;
                 }
             }
             if (found)
                 break;
 #endif
             TRACE("Shell message %d unhandled (lParam = 0x%p)!\n", (INT) wParam, lParam);
             break;
         }
         }
 
         return Ret;
     }

◆ OnSize()

LRESULT CTaskSwitchWnd::OnSize	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1775 of file taskswnd.cpp.

     {
         SIZE szClient;
 
         szClient.cx = LOWORD(lParam);
         szClient.cy = HIWORD(lParam);
         if (m_TaskBar.m_hWnd != NULL)
         {
             m_TaskBar.SetWindowPos(NULL, 0, 0, szClient.cx, szClient.cy, SWP_NOZORDER);
 
             UpdateButtonsSize(FALSE);
         }
         return TRUE;
     }

◆ OnTaskbarSettingsChanged()

LRESULT CTaskSwitchWnd::OnTaskbarSettingsChanged	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1830 of file taskswnd.cpp.

     {
         TaskbarSettings* newSettings = (TaskbarSettings*)lParam;
         if (newSettings->bGroupButtons != g_TaskbarSettings.bGroupButtons)
         {
             g_TaskbarSettings.bGroupButtons = newSettings->bGroupButtons;
             m_IsGroupingEnabled = g_TaskbarSettings.bGroupButtons;
 
             /* Collapse or expand groups if necessary */
             RefreshWindowList();
             UpdateButtonsSize(FALSE);
         }
 
         return 0;
     }

◆ OnThemeChanged()

LRESULT CTaskSwitchWnd::OnThemeChanged	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1411 of file taskswnd.cpp.

     {
         TRACE("OmThemeChanged\n");
 
         if (m_Theme)
             CloseThemeData(m_Theme);
 
         if (IsThemeActive())
             m_Theme = OpenThemeData(m_hWnd, L"TaskBand");
         else
             m_Theme = NULL;
 
         return TRUE;
     }

◆ OnTimer()

LRESULT CTaskSwitchWnd::OnTimer	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1897 of file taskswnd.cpp.

     {
 #if DUMP_TASKS != 0
         switch (wParam)
         {
         case 1:
             DumpTasks();
             break;
         }
 #endif
         return TRUE;
     }

◆ OnUpdateTaskbarPos()

LRESULT CTaskSwitchWnd::OnUpdateTaskbarPos	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 1823 of file taskswnd.cpp.

     {
         /* Update the button spacing */
         m_TaskBar.UpdateTbButtonSpacing(m_Tray->IsHorizontal(), m_Theme != NULL);
         return TRUE;
     }

◆ RedrawTask()

BOOL CTaskSwitchWnd::RedrawTask ( IN HWND hWnd )

inline

Definition at line 1230 of file taskswnd.cpp.

     {
         PTASK_ITEM TaskItem;
 
         TaskItem = FindTaskItem(hWnd);
         if (TaskItem != NULL)
         {
             RedrawTaskItem(TaskItem);
             return TRUE;
         }
 
         return FALSE;
     }

Referenced by OnShellHook().

◆ RedrawTaskItem()

VOID CTaskSwitchWnd::RedrawTaskItem ( IN OUT PTASK_ITEM TaskItem )

inline

Definition at line 1205 of file taskswnd.cpp.

     {
         PTASK_GROUP TaskGroup;
 
         TaskGroup = TaskItem->Group;
         if (m_IsGroupingEnabled && TaskGroup != NULL)
         {
             if (TaskGroup->IsCollapsed && TaskGroup->Index >= 0)
             {
                 UpdateTaskGroupButton(TaskGroup);
             }
             else if (TaskItem->Index >= 0)
             {
                 goto UpdateTaskItem;
             }
         }
         else if (TaskItem->Index >= 0)
         {
         UpdateTaskItem:
             TaskItem->RenderFlashed = 0;
             UpdateTaskItemButton(TaskItem);
         }
     }

Referenced by RedrawTask().

◆ RefreshWindowList()

BOOL CTaskSwitchWnd::RefreshWindowList ( )

inline

Definition at line 1404 of file taskswnd.cpp.

     {
         TRACE("Refreshing window list...\n");
         /* Add all windows to the toolbar */
         return EnumWindows(s_EnumWindowsProc, (LPARAM)this);
     }

Referenced by ActivateTask(), OnCreate(), and OnTaskbarSettingsChanged().

◆ RemoveIcon()

VOID CTaskSwitchWnd::RemoveIcon ( IN PTASK_ITEM TaskItem )

inline

Definition at line 559 of file taskswnd.cpp.

     {
         TBBUTTONINFO tbbi;
         PTASK_ITEM currentTaskItem, LastItem;
 
         if (TaskItem->IconIndex == -1)
             return;
 
         tbbi.cbSize = sizeof(tbbi);
         tbbi.dwMask = TBIF_IMAGE;
 
         currentTaskItem = m_TaskItems;
         LastItem = currentTaskItem + m_TaskItemCount;
         while (currentTaskItem != LastItem)
         {
             if (currentTaskItem->IconIndex > TaskItem->IconIndex)
             {
                 currentTaskItem->IconIndex--;
                 tbbi.iImage = currentTaskItem->IconIndex;
 
                 m_TaskBar.SetButtonInfo(currentTaskItem->Index, &tbbi);
             }
             currentTaskItem++;
         }
 
         ImageList_Remove(m_ImageList, TaskItem->IconIndex);
     }

Referenced by DeleteTaskItemButton().

◆ RemoveTaskFromTaskGroup()

VOID CTaskSwitchWnd::RemoveTaskFromTaskGroup ( IN OUT PTASK_ITEM TaskItem )

inline

Definition at line 808 of file taskswnd.cpp.

     {
         PTASK_GROUP TaskGroup, CurrentGroup, *PrevLink;
 
         TaskGroup = TaskItem->Group;
         if (TaskGroup != NULL)
         {
             DWORD dwNewTaskCount = --TaskGroup->dwTaskCount;
             if (dwNewTaskCount == 0)
             {
                 /* Find the previous pointer in the chain */
                 CurrentGroup = m_TaskGroups;
                 PrevLink = &m_TaskGroups;
                 while (CurrentGroup != TaskGroup)
                 {
                     PrevLink = &CurrentGroup->Next;
                     CurrentGroup = CurrentGroup->Next;
                 }
 
                 /* Remove the group from the list */
                 ASSERT(TaskGroup == CurrentGroup);
                 *PrevLink = TaskGroup->Next;
 
                 /* Free the task group */
                 HeapFree(hProcessHeap,
                     0,
                     TaskGroup);
             }
             else if (TaskGroup->IsCollapsed &&
                 TaskGroup->Index >= 0)
             {
                 if (dwNewTaskCount > 1)
                 {
                     /* FIXME: Check if we should expand the group */
                     /* Update the task group button */
                     UpdateTaskGroupButton(TaskGroup);
                 }
                 else
                 {
                     /* Expand the group of one task button to a task button */
                     ExpandTaskGroup(TaskGroup);
                 }
             }
         }
     }

Referenced by DeleteTaskItem().

◆ s_EnumWindowsProc()

static BOOL CALLBACK CTaskSwitchWnd::s_EnumWindowsProc	(	IN HWND	hWnd,
		IN LPARAM	lParam
	)

inlinestatic

Definition at line 1397 of file taskswnd.cpp.

     {
         CTaskSwitchWnd * This = (CTaskSwitchWnd *) lParam;
 
         return This->EnumWindowsProc(hWnd);
     }

Referenced by RefreshWindowList().

◆ UpdateButtonsSize()

VOID CTaskSwitchWnd::UpdateButtonsSize ( IN BOOL bRedrawDisabled )

inline

Definition at line 1244 of file taskswnd.cpp.

     {
         RECT rcClient;
         UINT uiRows, uiMax, uiMin, uiBtnsPerLine, ui;
         LONG NewBtnSize;
         BOOL Horizontal;
 
         /* Update the size of the image list if needed */
         int cx, cy;
         ImageList_GetIconSize(m_ImageList, &cx, &cy);
         if (cx != GetSystemMetrics(SM_CXSMICON) || cy != GetSystemMetrics(SM_CYSMICON))
         {
             ImageList_SetIconSize(m_ImageList, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON));
 
             /* SetIconSize removes all icons so we have to reinsert them */
             PTASK_ITEM TaskItem = m_TaskItems;
             PTASK_ITEM LastTaskItem = m_TaskItems + m_TaskItemCount;
             while (TaskItem != LastTaskItem)
             {
                 TaskItem->IconIndex = -1;
                 UpdateTaskItemButton(TaskItem);
 
                 TaskItem++;
             }
             m_TaskBar.SetImageList(m_ImageList);
         }
 
         if (GetClientRect(&rcClient) && !IsRectEmpty(&rcClient))
         {
             if (m_ButtonCount > 0)
             {
                 Horizontal = m_Tray->IsHorizontal();
 
                 if (Horizontal)
                 {
                     TBMETRICS tbm = { 0 };
                     tbm.cbSize = sizeof(tbm);
                     tbm.dwMask = TBMF_BUTTONSPACING;
                     m_TaskBar.GetMetrics(&tbm);
 
                     if (m_ButtonSize.cy + tbm.cyButtonSpacing != 0)
                         uiRows = (rcClient.bottom + tbm.cyButtonSpacing) / (m_ButtonSize.cy + tbm.cyButtonSpacing);
                     else
                         uiRows = 1;
 
                     if (uiRows == 0)
                         uiRows = 1;
 
                     uiBtnsPerLine = (m_ButtonCount + uiRows - 1) / uiRows;
                 }
                 else
                 {
                     uiBtnsPerLine = 1;
                     uiRows = m_ButtonCount;
                 }
 
                 if (!bRedrawDisabled)
                     m_TaskBar.BeginUpdate();
 
                 /* We might need to update the button spacing */
                 int cxButtonSpacing = m_TaskBar.UpdateTbButtonSpacing(
                     Horizontal, m_Theme != NULL,
                     uiRows, uiBtnsPerLine);
 
                 /* Determine the minimum and maximum width of a button */
                 uiMin = GetSystemMetrics(SM_CXSIZE) + (2 * GetSystemMetrics(SM_CXEDGE));
                 if (Horizontal)
                 {
                     uiMax = GetSystemMetrics(SM_CXMINIMIZED);
 
                     /* Calculate the ideal width and make sure it's within the allowed range */
                     NewBtnSize = (rcClient.right - (uiBtnsPerLine * cxButtonSpacing)) / uiBtnsPerLine;
 
                     if (NewBtnSize < (LONG) uiMin)
                         NewBtnSize = uiMin;
                     if (NewBtnSize >(LONG)uiMax)
                         NewBtnSize = uiMax;
 
                     /* Recalculate how many buttons actually fit into one line */
                     uiBtnsPerLine = rcClient.right / (NewBtnSize + cxButtonSpacing);
                     if (uiBtnsPerLine == 0)
                         uiBtnsPerLine++;
                 }
                 else
                 {
                     NewBtnSize = uiMax = rcClient.right;
                 }
 
                 m_ButtonSize.cx = NewBtnSize;
 
                 m_ButtonsPerLine = uiBtnsPerLine;
 
                 for (ui = 0; ui != m_ButtonCount; ui++)
                 {
                     TBBUTTONINFOW tbbi = { 0 };
                     tbbi.cbSize = sizeof(tbbi);
                     tbbi.dwMask = TBIF_BYINDEX | TBIF_SIZE | TBIF_STATE;
                     tbbi.cx = (INT) NewBtnSize;
                     tbbi.fsState = TBSTATE_ENABLED;
 
                     /* Check if we're updating a button that is the last one in the
                        line. If so, we need to set the TBSTATE_WRAP flag! */
                     if (Horizontal)
                     {
                         if ((ui + 1) % uiBtnsPerLine == 0)
                             tbbi.fsState |= TBSTATE_WRAP;
                     }
                     else
                     {
                         tbbi.fsState |= TBSTATE_WRAP;
                     }
 
                     if (m_ActiveTaskItem != NULL &&
                         m_ActiveTaskItem->Index == (INT)ui)
                     {
                         tbbi.fsState |= TBSTATE_CHECKED;
                     }
 
                     m_TaskBar.SetButtonInfo(ui, &tbbi);
                 }
             }
             else
             {
                 m_ButtonsPerLine = 0;
                 m_ButtonSize.cx = 0;
             }
         }
 
         // FIXME: This seems to be enabling redraws prematurely, but moving it to its right place doesn't work!
         m_TaskBar.EndUpdate();
     }

Referenced by AddTaskItemButton(), DeleteTaskItemButton(), OnCreate(), OnSettingChanged(), OnSize(), and OnTaskbarSettingsChanged().

◆ UpdateIndexesAfter()

VOID CTaskSwitchWnd::UpdateIndexesAfter	(	IN INT	iIndex,
		BOOL	bInserted
	)

inline

Definition at line 407 of file taskswnd.cpp.

     {
         PTASK_GROUP CurrentGroup;
         PTASK_ITEM CurrentTaskItem, LastTaskItem;
         INT NewIndex;
 
         int offset = bInserted ? +1 : -1;
 
         if (m_IsGroupingEnabled)
         {
             /* Update all affected groups */
             CurrentGroup = m_TaskGroups;
             while (CurrentGroup != NULL)
             {
                 if (CurrentGroup->IsCollapsed &&
                     CurrentGroup->Index >= iIndex)
                 {
                     /* Update the toolbar buttons */
                     NewIndex = CurrentGroup->Index + offset;
                     if (m_TaskBar.SetButtonCommandId(CurrentGroup->Index + offset, NewIndex))
                     {
                         CurrentGroup->Index = NewIndex;
                     }
                     else
                         CurrentGroup->Index = -1;
                 }
 
                 CurrentGroup = CurrentGroup->Next;
             }
         }
 
         /* Update all affected task items */
         CurrentTaskItem = m_TaskItems;
         LastTaskItem = CurrentTaskItem + m_TaskItemCount;
         while (CurrentTaskItem != LastTaskItem)
         {
             CurrentGroup = CurrentTaskItem->Group;
             if (CurrentGroup != NULL)
             {
                 if (!CurrentGroup->IsCollapsed &&
                     CurrentTaskItem->Index >= iIndex)
                 {
                     goto UpdateTaskItemBtn;
                 }
             }
             else if (CurrentTaskItem->Index >= iIndex)
             {
             UpdateTaskItemBtn:
                 /* Update the toolbar buttons */
                 NewIndex = CurrentTaskItem->Index + offset;
                 if (m_TaskBar.SetButtonCommandId(CurrentTaskItem->Index + offset, NewIndex))
                 {
                     CurrentTaskItem->Index = NewIndex;
                 }
                 else
                     CurrentTaskItem->Index = -1;
             }
 
             CurrentTaskItem++;
         }
     }

Referenced by AddTaskItemButton(), and DeleteTaskItemButton().

◆ UpdateTaskGroupButton()

INT CTaskSwitchWnd::UpdateTaskGroupButton ( IN PTASK_GROUP TaskGroup )

inline

Definition at line 470 of file taskswnd.cpp.

     {
         ASSERT(TaskGroup->Index >= 0);
 
         /* FIXME: Implement */
 
         return TaskGroup->Index;
     }

Referenced by AddTaskItemButton(), RedrawTaskItem(), and RemoveTaskFromTaskGroup().

◆ UpdateTaskItemButton()

INT CTaskSwitchWnd::UpdateTaskItemButton ( IN PTASK_ITEM TaskItem )

inline

Definition at line 513 of file taskswnd.cpp.

     {
         TBBUTTONINFO tbbi = { 0 };
         HICON icon;
         WCHAR windowText[255];
 
         ASSERT(TaskItem->Index >= 0);
 
         tbbi.cbSize = sizeof(tbbi);
         tbbi.dwMask = TBIF_BYINDEX | TBIF_STATE | TBIF_TEXT | TBIF_IMAGE;
         tbbi.fsState = TBSTATE_ENABLED;
         if (m_ActiveTaskItem == TaskItem)
             tbbi.fsState |= TBSTATE_CHECKED;
 
         if (TaskItem->RenderFlashed)
             tbbi.fsState |= TBSTATE_MARKED;
 
         /* Check if we're updating a button that is the last one in the
            line. If so, we need to set the TBSTATE_WRAP flag! */
         if (!m_Tray->IsHorizontal() || (m_ButtonsPerLine != 0 &&
             (TaskItem->Index + 1) % m_ButtonsPerLine == 0))
         {
             tbbi.fsState |= TBSTATE_WRAP;
         }
 
         if (GetWndTextFromTaskItem(TaskItem, windowText, _countof(windowText)) > 0)
         {
             tbbi.pszText = windowText;
         }
 
         icon = GetWndIcon(TaskItem->hWnd);
         if (!icon)
             icon = static_cast<HICON>(LoadImageW(NULL, MAKEINTRESOURCEW(OIC_SAMPLE), IMAGE_ICON, 0, 0, LR_SHARED | LR_DEFAULTSIZE));
         TaskItem->IconIndex = ImageList_ReplaceIcon(m_ImageList, TaskItem->IconIndex, icon);
         tbbi.iImage = TaskItem->IconIndex;
 
         if (!m_TaskBar.SetButtonInfo(TaskItem->Index, &tbbi))
         {
             TaskItem->Index = -1;
             return -1;
         }
 
         TRACE("Updated button %d for hwnd 0x%p\n", TaskItem->Index, TaskItem->hWnd);
         return TaskItem->Index;
     }

Referenced by AddTaskItemButton(), CheckActivateTaskItem(), FlashTaskItem(), RedrawTaskItem(), and UpdateButtonsSize().

Member Data Documentation

◆ m_ActiveTaskItem

PTASK_ITEM CTaskSwitchWnd::m_ActiveTaskItem

private

Definition at line 311 of file taskswnd.cpp.

Referenced by AllocTaskItem(), CheckActivateTaskItem(), FreeTaskItem(), HandleTaskItemClick(), UpdateButtonsSize(), and UpdateTaskItemButton().

◆ m_AllocatedTaskItems

WORD CTaskSwitchWnd::m_AllocatedTaskItems

private

Definition at line 307 of file taskswnd.cpp.

Referenced by AllocTaskItem().

◆ m_ButtonCount

WORD CTaskSwitchWnd::m_ButtonCount

private

Definition at line 315 of file taskswnd.cpp.

Referenced by AddTaskItemButton(), CalculateTaskItemNewButtonIndex(), DeleteTaskItemButton(), and UpdateButtonsSize().

◆ m_ButtonSize

SIZE CTaskSwitchWnd::m_ButtonSize

private

Definition at line 322 of file taskswnd.cpp.

Referenced by CTaskSwitchWnd(), and UpdateButtonsSize().

◆ m_ButtonsPerLine

UINT CTaskSwitchWnd::m_ButtonsPerLine

private

Definition at line 314 of file taskswnd.cpp.

Referenced by UpdateButtonsSize(), and UpdateTaskItemButton().

◆ m_HardErrorThread

CHardErrorThread CTaskSwitchWnd::m_HardErrorThread

private

Definition at line 325 of file taskswnd.cpp.

Referenced by OnCopyData().

◆ m_ImageList

HIMAGELIST CTaskSwitchWnd::m_ImageList

private

Definition at line 317 of file taskswnd.cpp.

Referenced by AddTaskItemButton(), OnCreate(), RemoveIcon(), UpdateButtonsSize(), and UpdateTaskItemButton().

◆ m_IsDestroying

BOOL CTaskSwitchWnd::m_IsDestroying

private

Definition at line 320 of file taskswnd.cpp.

Referenced by AddTask(), DeleteTaskItem(), and OnDestroy().

◆ m_IsGroupingEnabled

BOOL CTaskSwitchWnd::m_IsGroupingEnabled

private

Definition at line 319 of file taskswnd.cpp.

Referenced by CalculateTaskItemNewButtonIndex(), CheckActivateTaskItem(), FindLastTaskItemOfGroup(), HandleButtonClick(), HandleButtonRightClick(), Initialize(), OnTaskbarSettingsChanged(), RedrawTaskItem(), and UpdateIndexesAfter().

◆ m_ShellHookMsg

UINT CTaskSwitchWnd::m_ShellHookMsg

private

Definition at line 304 of file taskswnd.cpp.

Referenced by OnCreate().

◆ m_TaskBar

CTaskToolbar CTaskSwitchWnd::m_TaskBar

private

Definition at line 300 of file taskswnd.cpp.

Referenced by AddTaskItemButton(), DeleteTaskItemButton(), OnCommand(), OnContextMenu(), OnCreate(), OnKludgeItemRect(), OnNotify(), OnSetFont(), OnSize(), OnUpdateTaskbarPos(), RemoveIcon(), UpdateButtonsSize(), UpdateIndexesAfter(), and UpdateTaskItemButton().

◆ m_TaskGroups

PTASK_GROUP CTaskSwitchWnd::m_TaskGroups

private

Definition at line 309 of file taskswnd.cpp.

Referenced by AddToTaskGroup(), FindTaskGroupByIndex(), RemoveTaskFromTaskGroup(), and UpdateIndexesAfter().

◆ m_TaskItemCount

WORD CTaskSwitchWnd::m_TaskItemCount

private

Definition at line 306 of file taskswnd.cpp.

Referenced by AllocTaskItem(), DeleteAllTasks(), FindLastTaskItemOfGroup(), FindOtherTaskItem(), FindTaskItem(), FindTaskItemByIndex(), FreeTaskItem(), RemoveIcon(), UpdateButtonsSize(), and UpdateIndexesAfter().

◆ m_TaskItems

PTASK_ITEM CTaskSwitchWnd::m_TaskItems

private

Definition at line 310 of file taskswnd.cpp.

Referenced by AllocTaskItem(), DeleteAllTasks(), FindLastTaskItemOfGroup(), FindOtherTaskItem(), FindTaskItem(), FindTaskItemByIndex(), FreeTaskItem(), RemoveIcon(), UpdateButtonsSize(), and UpdateIndexesAfter().

◆ m_Theme

HTHEME CTaskSwitchWnd::m_Theme

private

Definition at line 313 of file taskswnd.cpp.

Referenced by HandleItemPaint(), OnCreate(), OnDestroy(), OnThemeChanged(), OnUpdateTaskbarPos(), and UpdateButtonsSize().

◆ m_Tray

CComPtr<ITrayWindow> CTaskSwitchWnd::m_Tray

private

Definition at line 302 of file taskswnd.cpp.

Referenced by AddTask(), EnumWindowsProc(), Initialize(), OnContextMenu(), OnCreate(), OnShellHook(), OnUpdateTaskbarPos(), UpdateButtonsSize(), and UpdateTaskItemButton().

◆ m_uHardErrorMsg

UINT CTaskSwitchWnd::m_uHardErrorMsg

private

Definition at line 324 of file taskswnd.cpp.

Referenced by CTaskSwitchWnd(), and OnCopyData().

The documentation for this class was generated from the following file:

base/shell/explorer/taskswnd.cpp

Private Attributes
CTaskToolbar	m_TaskBar

CComPtr< ITrayWindow >	m_Tray

UINT	m_ShellHookMsg

WORD	m_TaskItemCount

WORD	m_AllocatedTaskItems

PTASK_GROUP	m_TaskGroups

PTASK_ITEM	m_TaskItems

PTASK_ITEM	m_ActiveTaskItem

HTHEME	m_Theme

UINT	m_ButtonsPerLine

WORD	m_ButtonCount

HIMAGELIST	m_ImageList

BOOL	m_IsGroupingEnabled

BOOL	m_IsDestroying

SIZE	m_ButtonSize

UINT	m_uHardErrorMsg

CHardErrorThread	m_HardErrorThread

Public Member Functions

Static Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CTaskSwitchWnd()

◆ ~CTaskSwitchWnd()

Member Function Documentation

◆ ActivateTask()

◆ ActivateTaskItem()

◆ AddTask()

◆ AddTaskItemButton()

◆ AddToTaskGroup()

◆ AllocTaskItem()

◆ CalculateTaskItemNewButtonIndex()

◆ CheckActivateTaskItem()

◆ ContextSensitiveHelp()

◆ DeleteAllTasks()

◆ DeleteTask()

◆ DeleteTaskItem()

◆ DeleteTaskItemButton()

◆ EnumWindowsProc()

◆ ExpandTaskGroup()

◆ FindLastTaskItemOfGroup()

◆ FindOtherTaskItem()

◆ FindTaskGroupByIndex()

◆ FindTaskItem()

◆ FindTaskItemByIndex()

◆ FlashTask()

◆ FlashTaskItem()

◆ FreeTaskItem()

◆ GetWindow()

◆ GetWndIcon()

◆ GetWndTextFromTaskItem()

◆ HandleAppCommand()

◆ HandleButtonClick()

◆ HandleButtonRightClick()

◆ HandleItemPaint()

◆ HandleTaskGroupClick()

◆ HandleTaskGroupRightClick()

◆ HandleTaskItemClick()

◆ HandleTaskItemRightClick()

◆ HandleToolbarNotification()

◆ Initialize()

◆ OnCommand()

◆ OnContextMenu()

◆ OnCopyData()

◆ OnCreate()

◆ OnDestroy()

◆ OnEraseBackground()

◆ OnKludgeItemRect()

◆ OnMouseActivate()

◆ OnNcHitTest()

◆ OnNotify()

◆ OnSetFont()

◆ OnSettingChanged()

◆ OnShellHook()

◆ OnSize()

◆ OnTaskbarSettingsChanged()

◆ OnThemeChanged()

◆ OnTimer()

◆ OnUpdateTaskbarPos()

◆ RedrawTask()

◆ RedrawTaskItem()

◆ RefreshWindowList()

◆ RemoveIcon()

◆ RemoveTaskFromTaskGroup()

◆ s_EnumWindowsProc()

◆ UpdateButtonsSize()

◆ UpdateIndexesAfter()

◆ UpdateTaskGroupButton()

◆ UpdateTaskItemButton()

Member Data Documentation

◆ m_ActiveTaskItem

◆ m_AllocatedTaskItems

◆ m_ButtonCount

◆ m_ButtonSize

◆ m_ButtonsPerLine

◆ m_HardErrorThread