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)

VOID	SendPulseToTray (BOOL bDelete, HWND hwndActive)

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)

STDMETHODIMP	GetWindow (HWND *phwnd) override

STDMETHODIMP	ContextSensitiveHelp (BOOL fEnterMode) override

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< TBase, TWinTraits >
	CWindowImplBaseT ()

virtual void	OnFinalMessage (HWND)

BOOL	SubclassWindow (HWND hWnd)

HWND	UnsubclassWindow (BOOL bForce=FALSE)

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< TBase >
	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 (_In_ int nID) const

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

UINT	GetDlgItemText (_In_ int nID, _Out_writes_to_(nMaxCount, return+1) LPTSTR lpStr, _In_ int nMaxCount) const

BOOL	GetDlgItemText (_In_ int nID, _Inout_ _Outref_result_maybenull_ _Post_z_ 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 (_Out_writes_to_(nMaxCount, return+1) LPTSTR lpszStringBuf, _In_ int nMaxCount) const

BOOL	GetWindowText (_Inout_ _Outref_result_maybenull_ _Post_z_ BSTR &bstrText) const

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

HRESULT	GetWindow ([out] HWND *phwnd)

HRESULT	ContextSensitiveHelp ([in] BOOL fEnterMode)

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 BOOL	InvokeRegistryAppKeyCommand (UINT uAppCmd)

static VOID CALLBACK	SendAsyncProc (HWND hwnd, UINT uMsg, DWORD_PTR dwData, LRESULT lResult)

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< TBase, TWinTraits >
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< TBase >
enum	{ WINSTATE_DESTROYED = 0x00000001 }

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< TBase, TWinTraits >
WNDPROC	m_pfnSuperWindowProc

Public Attributes inherited from ATL::CWindowImplRoot< TBase >
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 297 of file taskswnd.cpp.

Constructor & Destructor Documentation

◆ CTaskSwitchWnd()

CTaskSwitchWnd::CTaskSwitchWnd ( )

inline

Definition at line 331 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 348 of file taskswnd.cpp.

348{ }

Member Function Documentation

◆ ActivateTask()

BOOL CTaskSwitchWnd::ActivateTask ( IN HWND hWnd )

inline

Definition at line 1141 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 1130 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 1101 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 682 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 777 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 925 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 638 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 1010 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()

STDMETHODIMP CTaskSwitchWnd::ContextSensitiveHelp ( BOOL fEnterMode )

inlineoverride

Implements IOleWindow.

Definition at line 2031 of file taskswnd.cpp.

    {
        return E_NOTIMPL;
    }

◆ DeleteAllTasks()

VOID CTaskSwitchWnd::DeleteAllTasks ( )

inline

Definition at line 1182 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 1165 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 995 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 742 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 1391 of file taskswnd.cpp.

    {
        if (m_Tray->IsTaskWnd(hWnd))
        {
            TRACE("Adding task for %p...\n", hWnd);
            AddTask(hWnd);
        }
        return TRUE;
    }

◆ ExpandTaskGroup()

VOID CTaskSwitchWnd::ExpandTaskGroup ( IN PTASK_GROUP TaskGroup )

inline

Definition at line 482 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 600 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 884 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 1085 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 867 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 1068 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 1202 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 1196 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 977 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()

STDMETHODIMP CTaskSwitchWnd::GetWindow ( HWND * phwnd )

inlineoverride

Implements IOleWindow.

Definition at line 2022 of file taskswnd.cpp.

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

◆ GetWndIcon()

HICON CTaskSwitchWnd::GetWndIcon ( HWND hwnd )

inline

Definition at line 491 of file taskswnd.cpp.

    {
        HICON hIcon = NULL;
 
        /* Retrieve icon by sending a message */
#define GET_ICON(type) \
    SendMessageTimeout(hwnd, WM_GETICON, (type), 0, SMTO_NOTIMEOUTIFNOTHUNG, 100, (PDWORD_PTR)&hIcon)
 
        LRESULT bAlive = GET_ICON(g_TaskbarSettings.bSmallIcons ? ICON_SMALL2 : ICON_BIG);
        if (hIcon)
            return hIcon;
 
        if (bAlive)
        {
            bAlive = GET_ICON(ICON_SMALL);
            if (hIcon)
                return hIcon;
        }
 
        if (bAlive)
        {
            GET_ICON(g_TaskbarSettings.bSmallIcons ? ICON_BIG : ICON_SMALL2);
            if (hIcon)
                return hIcon;
        }
#undef GET_ICON
 
        /* If we failed, retrieve icon from the window class */
        hIcon = (HICON)GetClassLongPtr(hwnd, g_TaskbarSettings.bSmallIcons ? GCLP_HICONSM : GCLP_HICON);
        if (hIcon)
            return hIcon;
 
        return (HICON)GetClassLongPtr(hwnd, g_TaskbarSettings.bSmallIcons ? GCLP_HICON : GCLP_HICONSM);
    }

Referenced by AddTaskItemButton(), and UpdateTaskItemButton().

◆ GetWndTextFromTaskItem()

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

inline

Definition at line 350 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 1518 of file taskswnd.cpp.

    {
        const UINT uAppCmd = GET_APPCOMMAND_LPARAM(lParam);
        if (InvokeRegistryAppKeyCommand(uAppCmd))
            return TRUE;
        switch (uAppCmd)
        {
            case APPCOMMAND_VOLUME_MUTE:
            case APPCOMMAND_VOLUME_DOWN:
            case APPCOMMAND_VOLUME_UP:
                // TODO: Try IMMDeviceEnumerator::GetDefaultAudioEndpoint first and then fall back to mixer.
                FIXME("Call the mixer API to change the global volume\n");
                return TRUE;
            case APPCOMMAND_BROWSER_SEARCH:
                return SHFindFiles(NULL, NULL);
        }
        return FALSE;
    }

Referenced by OnShellHook().

◆ HandleButtonClick()

BOOL CTaskSwitchWnd::HandleButtonClick ( IN WORD wIndex )

inline

Definition at line 1659 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)
        {
            SendPulseToTray(FALSE, TaskItem->hWnd);
            HandleTaskItemClick(TaskItem);
            return TRUE;
        }
 
        return FALSE;
    }

Referenced by OnCommand().

◆ HandleButtonRightClick()

BOOL CTaskSwitchWnd::HandleButtonRightClick ( IN WORD wIndex )

inline

Definition at line 1712 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 1738 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 1654 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 1707 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 1622 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)
            {
                if (!::IsHungAppWindow(TaskItem->hWnd))
                    ::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 1691 of file taskswnd.cpp.

    {
        POINT pt;
        GetCursorPos(&pt);
 
        SetForegroundWindow(TaskItem->hWnd);
 
        ActivateTask(TaskItem->hWnd);
 
        if (GetForegroundWindow() != TaskItem->hWnd)
            ERR("HandleTaskItemRightClick detected the window did not become foreground\n");
 
        ::SendMessageCallbackW(TaskItem->hWnd, WM_POPUPSYSTEMMENU, 0, MAKELPARAM(pt.x, pt.y),
                               SendAsyncProc, (ULONG_PTR)TaskItem);
    }

Referenced by HandleButtonRightClick().

◆ HandleToolbarNotification()

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

inline

Definition at line 1781 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 2009 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;
    }

◆ InvokeRegistryAppKeyCommand()

static BOOL CTaskSwitchWnd::InvokeRegistryAppKeyCommand ( UINT uAppCmd )

inlinestatic

Definition at line 1481 of file taskswnd.cpp.

    {
        BOOL bResult = FALSE;
        WCHAR szBuf[MAX_PATH * 2];
        wsprintfW(szBuf, L"%s\\AppKey\\%u", REGSTR_PATH_EXPLORER, uAppCmd);
        HUSKEY hKey;
        if (SHRegOpenUSKeyW(szBuf, KEY_READ, NULL, &hKey, FALSE) != ERROR_SUCCESS)
            return bResult;
 
        DWORD cb = sizeof(szBuf);
        if (!bResult && SHRegQueryUSValueW(hKey, L"ShellExecute", NULL, szBuf, &cb, FALSE, NULL, 0) == ERROR_SUCCESS)
        {
            bResult = TRUE;
        }
        cb = sizeof(szBuf);
        if (!bResult && SHRegQueryUSValueW(hKey, L"Association", NULL, szBuf, &cb, FALSE, NULL, 0) == ERROR_SUCCESS)
        {
            bResult = TRUE;
            cb = _countof(szBuf);
            if (AssocQueryString(ASSOCF_NOTRUNCATE, ASSOCSTR_EXECUTABLE, szBuf, NULL, szBuf, &cb) != S_OK)
                *szBuf = UNICODE_NULL;
        }
        cb = sizeof(szBuf);
        if (!bResult && SHRegQueryUSValueW(hKey, L"RegisteredApp", NULL, szBuf, &cb, FALSE, NULL, 0) == ERROR_SUCCESS)
        {
            bResult = TRUE;
            SHRunIndirectRegClientCommand(NULL, szBuf);
            *szBuf = UNICODE_NULL; // Don't execute again
        }
        SHRegCloseUSKey(hKey);
 
        // Note: Tweak UI uses an empty string for its "Do nothing" option.
        if (bResult && *szBuf)
            ShellExec_RunDLLW(NULL, NULL, szBuf, SW_SHOW);
        return bResult;
    }

Referenced by HandleAppCommand().

◆ OnCommand()

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

inline

Definition at line 1856 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 1913 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 1993 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 1430 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(g_TaskbarSettings.bSmallIcons ? SM_CXSMICON : SM_CXICON),
                                       GetSystemMetrics(g_TaskbarSettings.bSmallIcons ? SM_CYSMICON : SM_CYICON),
                                       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 1463 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 1813 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 1941 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 1959 of file taskswnd.cpp.

    {
        return MA_NOACTIVATE;
    }

◆ OnNcHitTest()

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

inline

Definition at line 1845 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 1866 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 1977 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 1982 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 1537 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(0, lParam);
            break;
 
        case HSHELL_WINDOWCREATED:
            SendPulseToTray(FALSE, (HWND)lParam);
            AddTask((HWND) lParam);
            break;
 
        case HSHELL_WINDOWDESTROYED:
            /* The window still exists! Delay destroying it a bit */
            SendPulseToTray(TRUE, (HWND)lParam);
            DeleteTask((HWND)lParam);
            break;
 
        case HSHELL_RUDEAPPACTIVATED:
        case HSHELL_WINDOWACTIVATED:
            SendPulseToTray(FALSE, (HWND)lParam);
            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 1830 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 1885 of file taskswnd.cpp.

    {
        BOOL bSettingsChanged = FALSE;
        TaskbarSettings* newSettings = (TaskbarSettings*)lParam;
 
        if (newSettings->bGroupButtons != g_TaskbarSettings.bGroupButtons)
        {
            bSettingsChanged = TRUE;
            g_TaskbarSettings.bGroupButtons = newSettings->bGroupButtons;
            m_IsGroupingEnabled = g_TaskbarSettings.bGroupButtons;
        }
 
        if (newSettings->bSmallIcons != g_TaskbarSettings.bSmallIcons)
        {
            bSettingsChanged = TRUE;
            g_TaskbarSettings.bSmallIcons = newSettings->bSmallIcons;
        }
 
        if (bSettingsChanged)
        {
            /* Refresh each task item view */
            RefreshWindowList();
            UpdateButtonsSize(FALSE);
        }
 
        return 0;
    }

◆ OnThemeChanged()

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

inline

Definition at line 1415 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 1964 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 1878 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 1242 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 1217 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 1408 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 572 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 821 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 1401 of file taskswnd.cpp.

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

Referenced by RefreshWindowList().

◆ SendAsyncProc()

static VOID CALLBACK CTaskSwitchWnd::SendAsyncProc	(	HWND	hwnd,
		UINT	uMsg,
		DWORD_PTR	dwData,
		LRESULT	lResult
	)

inlinestatic

Definition at line 1686 of file taskswnd.cpp.

    {
        ::PostMessageW(hwnd, WM_NULL, 0, 0);
    }

Referenced by HandleTaskItemRightClick().

◆ SendPulseToTray()

VOID CTaskSwitchWnd::SendPulseToTray	(	BOOL	bDelete,
		HWND	hwndActive
	)

inline

Definition at line 1475 of file taskswnd.cpp.

    {
        HWND hwndTray = m_Tray->GetHWND();
        ::SendMessage(hwndTray, TWM_PULSE, bDelete, (LPARAM)hwndActive);
    }

Referenced by HandleButtonClick(), and OnShellHook().

◆ UpdateButtonsSize()

VOID CTaskSwitchWnd::UpdateButtonsSize ( IN BOOL bRedrawDisabled )

inline

Definition at line 1256 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(g_TaskbarSettings.bSmallIcons ? SM_CXSMICON : SM_CXICON) ||
            cy != GetSystemMetrics(g_TaskbarSettings.bSmallIcons ? SM_CYSMICON : SM_CYICON))
        {
            ImageList_SetIconSize(m_ImageList,
                                  GetSystemMetrics(g_TaskbarSettings.bSmallIcons ? SM_CXSMICON : SM_CXICON),
                                  GetSystemMetrics(g_TaskbarSettings.bSmallIcons ? SM_CYSMICON : SM_CYICON));
 
            /* 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 410 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 473 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 526 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 314 of file taskswnd.cpp.

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

◆ m_AllocatedTaskItems

WORD CTaskSwitchWnd::m_AllocatedTaskItems

private

Definition at line 310 of file taskswnd.cpp.

Referenced by AllocTaskItem().

◆ m_ButtonCount

WORD CTaskSwitchWnd::m_ButtonCount

private

Definition at line 318 of file taskswnd.cpp.

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

◆ m_ButtonSize

SIZE CTaskSwitchWnd::m_ButtonSize

private

Definition at line 325 of file taskswnd.cpp.

Referenced by CTaskSwitchWnd(), and UpdateButtonsSize().

◆ m_ButtonsPerLine

UINT CTaskSwitchWnd::m_ButtonsPerLine

private

Definition at line 317 of file taskswnd.cpp.

Referenced by UpdateButtonsSize(), and UpdateTaskItemButton().

◆ m_HardErrorThread

CHardErrorThread CTaskSwitchWnd::m_HardErrorThread

private

Definition at line 328 of file taskswnd.cpp.

Referenced by OnCopyData().

◆ m_ImageList

HIMAGELIST CTaskSwitchWnd::m_ImageList

private

Definition at line 320 of file taskswnd.cpp.

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

◆ m_IsDestroying

BOOL CTaskSwitchWnd::m_IsDestroying

private

Definition at line 323 of file taskswnd.cpp.

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

◆ m_IsGroupingEnabled

BOOL CTaskSwitchWnd::m_IsGroupingEnabled

private

Definition at line 322 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 307 of file taskswnd.cpp.

Referenced by OnCreate().

◆ m_TaskBar

CTaskToolbar CTaskSwitchWnd::m_TaskBar

private

Definition at line 303 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 312 of file taskswnd.cpp.

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

◆ m_TaskItemCount

WORD CTaskSwitchWnd::m_TaskItemCount

private

Definition at line 309 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 313 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 316 of file taskswnd.cpp.

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

◆ m_Tray

CComPtr<ITrayWindow> CTaskSwitchWnd::m_Tray

private

Definition at line 305 of file taskswnd.cpp.

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

◆ m_uHardErrorMsg

UINT CTaskSwitchWnd::m_uHardErrorMsg

private

Definition at line 327 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()

◆ InvokeRegistryAppKeyCommand()

◆ 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()

◆ SendAsyncProc()

◆ SendPulseToTray()

◆ UpdateButtonsSize()

◆ UpdateIndexesAfter()

◆ UpdateTaskGroupButton()

◆ UpdateTaskItemButton()

Member Data Documentation

◆ m_ActiveTaskItem

◆ m_AllocatedTaskItems

◆ m_ButtonCount