CTaskSwitchWnd Class Reference

Inheritance diagram for CTaskSwitchWnd:

Collaboration diagram for CTaskSwitchWnd:

Classes
struct	tagFULLSCREENDATA
struct	tagRUDEAPPDATA

Public Types
typedef struct CTaskSwitchWnd::tagRUDEAPPDATA	RUDEAPPDATA
typedef struct CTaskSwitchWnd::tagRUDEAPPDATA *	PRUDEAPPDATA
typedef struct CTaskSwitchWnd::tagFULLSCREENDATA	FULLSCREENDATA
typedef struct CTaskSwitchWnd::tagFULLSCREENDATA *	PFULLSCREENDATA
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 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)
void	HandleFullScreenApp (_In_opt_ HWND hwndRude)
HWND	FindRudeApp (_In_opt_ HWND hwndFirstCheck)
LRESULT	OnWindowPosChanged (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
void	OnWindowActivated (_In_ HWND hwndTarget)
void	OnWindowDestroyed (_In_ HWND hwndTarget)
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 BOOL CALLBACK	IsRudeEnumProc (_In_ HWND hwnd, _In_ LPARAM lParam)
static BOOL CALLBACK	FullScreenEnumProc (_In_ HMONITOR hMonitor, _In_opt_ HDC hDC, _In_ LPRECT prc, _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< 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)

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
INT	m_nRudeAppValidationCounter
SIZE	m_ButtonSize
UINT	m_uHardErrorMsg
CHardErrorThread	m_HardErrorThread

Additional Inherited Members
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 379 of file taskswnd.cpp.

Member Typedef Documentation

FULLSCREENDATA

typedef struct CTaskSwitchWnd::tagFULLSCREENDATA CTaskSwitchWnd::FULLSCREENDATA

PFULLSCREENDATA

typedef struct CTaskSwitchWnd::tagFULLSCREENDATA * CTaskSwitchWnd::PFULLSCREENDATA

PRUDEAPPDATA

typedef struct CTaskSwitchWnd::tagRUDEAPPDATA * CTaskSwitchWnd::PRUDEAPPDATA

RUDEAPPDATA

typedef struct CTaskSwitchWnd::tagRUDEAPPDATA CTaskSwitchWnd::RUDEAPPDATA

Constructor & Destructor Documentation

CTaskSwitchWnd()

CTaskSwitchWnd::CTaskSwitchWnd ( )

inline

Definition at line 415 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),
        m_nRudeAppValidationCounter(0)
    {
        ZeroMemory(&m_ButtonSize, sizeof(m_ButtonSize));
        m_uHardErrorMsg = RegisterWindowMessageW(L"HardError");
    }

~CTaskSwitchWnd()

virtual CTaskSwitchWnd::~CTaskSwitchWnd ( )

inlinevirtual

Definition at line 433 of file taskswnd.cpp.

{ }

Member Function Documentation

ActivateTask()

BOOL CTaskSwitchWnd::ActivateTask ( IN HWND  hWnd )

inline

Definition at line 1226 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 1215 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 1186 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 767 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 862 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 1010 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 723 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 1095 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 2259 of file taskswnd.cpp.

    {
        return E_NOTIMPL;
    }

DeleteAllTasks()

VOID CTaskSwitchWnd::DeleteAllTasks ( )

inline

Definition at line 1267 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 1250 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 1080 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 827 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 1476 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 567 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 685 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 969 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().

FindRudeApp()

HWND CTaskSwitchWnd::FindRudeApp ( _In_opt_ HWND  hwndFirstCheck )

inline

Definition at line 1980 of file taskswnd.cpp.

    {
        // Quick check
        HMONITOR hMon = MonitorFromWindow(hwndFirstCheck, MONITOR_DEFAULTTONEAREST);
        RUDEAPPDATA data = { hMon, NULL, hwndFirstCheck };
        if (::IsWindow(hwndFirstCheck) && !IsRudeEnumProc(hwndFirstCheck, (LPARAM)&data))
            return hwndFirstCheck;
 
        // Slow check
        ::EnumWindows(IsRudeEnumProc, (LPARAM)&data);
 
        return data.hwndFound;
    }

Referenced by OnTimer(), and OnWindowDestroyed().

FindTaskGroupByIndex()

PTASK_GROUP CTaskSwitchWnd::FindTaskGroupByIndex ( IN INT  Index )

inline

Definition at line 1170 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 952 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(), OnWindowDestroyed(), and RedrawTask().

FindTaskItemByIndex()

PTASK_ITEM CTaskSwitchWnd::FindTaskItemByIndex ( IN INT  Index )

inline

Definition at line 1153 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 1287 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 1281 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 1062 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().

FullScreenEnumProc()

static BOOL CALLBACK CTaskSwitchWnd::FullScreenEnumProc ( _In_ HMONITOR  hMonitor, _In_opt_ HDC  hDC, _In_ LPRECT  prc, _In_ LPARAM  lParam  )

inlinestatic

Definition at line 1935 of file taskswnd.cpp.

    {
        PFULLSCREENDATA pData = (PFULLSCREENDATA)lParam;
 
        BOOL bFullOpening = (pData->hTargetMonitor == hMonitor);
        if (!bFullOpening && pData->pRect)
        {
            RECT rc, rcMon;
            SHELL_GetMonitorRect(hMonitor, &rcMon, FALSE);
            ::IntersectRect(&rc, &rcMon, pData->pRect);
            bFullOpening = ::EqualRect(&rc, &rcMon);
        }
 
        // Notify ABN_FULLSCREENAPP to appbars
        pData->pTray->NotifyFullScreenToAppBars(hMonitor, bFullOpening);
        return TRUE;
    }

Referenced by HandleFullScreenApp().

GetWindow()

STDMETHODIMP CTaskSwitchWnd::GetWindow ( HWND *  phwnd )

inlineoverride

Implements IOleWindow.

Definition at line 2250 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 576 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 435 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 1606 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 1746 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 1798 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().

HandleFullScreenApp()

void CTaskSwitchWnd::HandleFullScreenApp ( _In_opt_ HWND  hwndRude )

inline

Definition at line 1953 of file taskswnd.cpp.

    {
        // Notify ABN_FULLSCREENAPP for every monitor
        RECT rc;
        FULLSCREENDATA Data = { NULL, NULL, NULL };
        if (hwndRude && ::GetWindowRect(hwndRude, &rc))
        {
            Data.pRect = &rc;
            Data.hTargetMonitor = ::MonitorFromWindow(hwndRude, MONITOR_DEFAULTTONULL);
        }
        Data.pTray = m_Tray;
        ::EnumDisplayMonitors(NULL, NULL, FullScreenEnumProc, (LPARAM)&Data);
 
        if (hwndRude)
        {
            // Make the taskbar bottom
            UINT uFlags = SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER;
            HWND hwndTray = m_Tray->GetHWND();
            ::SetWindowPos(hwndTray, HWND_BOTTOM, 0, 0, 0, 0, uFlags);
 
            // Switch to the rude app if necessary
            DWORD exstyle = (DWORD)::GetWindowLongPtrW(hwndRude, GWL_EXSTYLE);
            if (!(exstyle & WS_EX_TOPMOST) && !SHELL_IsRudeWindowActive(hwndRude))
                ::SwitchToThisWindow(hwndRude, TRUE);
        }
    }

Referenced by OnTimer(), and OnWindowDestroyed().

HandleItemPaint()

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

inline

Definition at line 1824 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 1741 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 1793 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 1709 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 1777 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 1867 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 2237 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 1569 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().

IsRudeEnumProc()

static BOOL CALLBACK CTaskSwitchWnd::IsRudeEnumProc ( _In_ HWND  hwnd, _In_ LPARAM  lParam  )

inlinestatic

Definition at line 1909 of file taskswnd.cpp.

    {
        PRUDEAPPDATA pData = (PRUDEAPPDATA)lParam;
 
        HMONITOR hMon = ::MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
        if (!hMon ||
            (pData->hTargetMonitor && pData->hTargetMonitor != hMon) ||
            !SHELL_IsRudeWindow(hMon, hwnd, (hwnd == pData->hwndFirstCheck)))
        {
            return TRUE; // Continue
        }
 
        pData->hwndFound = hwnd;
        return FALSE; // Finish
    }

Referenced by FindRudeApp().

OnCommand()

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

inline

Definition at line 2066 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 2123 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 2221 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 1515 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 1548 of file taskswnd.cpp.

    {
        m_IsDestroying = TRUE;
 
        KillTimer(TIMER_ID_VALIDATE_RUDE_APP);
 
        /* Unregister the shell hook */
        RegisterShellHook(m_hWnd, FALSE);
 
        CloseThemeData(m_Theme);
        DeleteAllTasks();
 
        if (m_ImageList)
        {
            ImageList_Destroy(m_ImageList);
            m_ImageList = NULL;
        }
 
        return TRUE;
    }

OnEraseBackground()

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

inline

Definition at line 2023 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 2151 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 2169 of file taskswnd.cpp.

    {
        return MA_NOACTIVATE;
    }

OnNcHitTest()

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

inline

Definition at line 2055 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 2076 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 2205 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 2210 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 1625 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:
            AddTask((HWND) lParam);
            break;
 
        case HSHELL_WINDOWDESTROYED:
            /* The window still exists! Delay destroying it a bit */
            OnWindowDestroyed((HWND)lParam);
            DeleteTask((HWND)lParam);
            break;
 
        case HSHELL_RUDEAPPACTIVATED:
        case HSHELL_WINDOWACTIVATED:
            OnWindowActivated((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 2040 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 2095 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 1500 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 2174 of file taskswnd.cpp.

    {
        switch (wParam)
        {
#if DUMP_TASKS != 0
            case 1:
                DumpTasks();
                break;
#endif
            case TIMER_ID_VALIDATE_RUDE_APP:
            {
                // Real activation of rude app might take some time after HSHELL_...ACTIVATED.
                // Wait up to 5 seconds with validating the rude app at each second.
                HWND hwndRude = FindRudeApp(NULL);
                HandleFullScreenApp(hwndRude);
 
                KillTimer(wParam);
                ++m_nRudeAppValidationCounter;
                if (m_nRudeAppValidationCounter < VALIDATE_RUDE_MAX_COUNT && !hwndRude)
                    SetTimer(wParam, VALIDATE_RUDE_INTERVAL, NULL);
                break;
            }
            default:
            {
                WARN("Unknown timer ID: %p\n", wParam);
                break;
            }
        }
        return TRUE;
    }

OnUpdateTaskbarPos()

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

inline

Definition at line 2088 of file taskswnd.cpp.

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

OnWindowActivated()

void CTaskSwitchWnd::OnWindowActivated ( _In_ HWND  hwndTarget )

inline

Definition at line 2006 of file taskswnd.cpp.

    {
        // Re-start rude app validation
        KillTimer(TIMER_ID_VALIDATE_RUDE_APP);
        SetTimer(TIMER_ID_VALIDATE_RUDE_APP, VALIDATE_RUDE_INTERVAL, NULL);
        m_nRudeAppValidationCounter = 0;
    }

Referenced by OnShellHook().

OnWindowDestroyed()

void CTaskSwitchWnd::OnWindowDestroyed ( _In_ HWND  hwndTarget )

inline

Definition at line 2015 of file taskswnd.cpp.

    {
        if (!FindTaskItem(hwndTarget))
            return;
        HWND hwndRude = FindRudeApp(hwndTarget);
        HandleFullScreenApp(hwndRude);
    }

Referenced by OnShellHook().

OnWindowPosChanged()

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

inline

Definition at line 1995 of file taskswnd.cpp.

    {
        // Re-start rude app validation
        KillTimer(TIMER_ID_VALIDATE_RUDE_APP);
        SetTimer(TIMER_ID_VALIDATE_RUDE_APP, VALIDATE_RUDE_INTERVAL, NULL);
        m_nRudeAppValidationCounter = 0;
        bHandled = FALSE;
        return 0;
    }

RedrawTask()

BOOL CTaskSwitchWnd::RedrawTask ( IN HWND  hWnd )

inline

Definition at line 1327 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 1302 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 1493 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 657 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 906 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 1486 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 1772 of file taskswnd.cpp.

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

Referenced by HandleTaskItemRightClick().

UpdateButtonsSize()

VOID CTaskSwitchWnd::UpdateButtonsSize ( IN BOOL  bRedrawDisabled )

inline

Definition at line 1341 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 495 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 558 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 611 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 396 of file taskswnd.cpp.

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

m_AllocatedTaskItems

WORD CTaskSwitchWnd::m_AllocatedTaskItems

private

Definition at line 392 of file taskswnd.cpp.

Referenced by AllocTaskItem().

m_ButtonCount

WORD CTaskSwitchWnd::m_ButtonCount

private

Definition at line 400 of file taskswnd.cpp.

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

m_ButtonSize

SIZE CTaskSwitchWnd::m_ButtonSize

private

Definition at line 409 of file taskswnd.cpp.

Referenced by CTaskSwitchWnd(), and UpdateButtonsSize().

m_ButtonsPerLine

UINT CTaskSwitchWnd::m_ButtonsPerLine

private

Definition at line 399 of file taskswnd.cpp.

Referenced by UpdateButtonsSize(), and UpdateTaskItemButton().

m_HardErrorThread

CHardErrorThread CTaskSwitchWnd::m_HardErrorThread

private

Definition at line 412 of file taskswnd.cpp.

Referenced by OnCopyData().

m_ImageList

HIMAGELIST CTaskSwitchWnd::m_ImageList

private

Definition at line 402 of file taskswnd.cpp.

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

m_IsDestroying

BOOL CTaskSwitchWnd::m_IsDestroying

private

Definition at line 405 of file taskswnd.cpp.

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

m_IsGroupingEnabled

BOOL CTaskSwitchWnd::m_IsGroupingEnabled

private

Definition at line 404 of file taskswnd.cpp.

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

m_nRudeAppValidationCounter

INT CTaskSwitchWnd::m_nRudeAppValidationCounter

private

Definition at line 407 of file taskswnd.cpp.

Referenced by OnTimer(), OnWindowActivated(), and OnWindowPosChanged().

m_ShellHookMsg

UINT CTaskSwitchWnd::m_ShellHookMsg

private

Definition at line 389 of file taskswnd.cpp.

Referenced by OnCreate().

m_TaskBar

CTaskToolbar CTaskSwitchWnd::m_TaskBar

private

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

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

m_TaskItemCount

WORD CTaskSwitchWnd::m_TaskItemCount

private

Definition at line 391 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 395 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 398 of file taskswnd.cpp.

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

m_Tray

CComPtr<ITrayWindow> CTaskSwitchWnd::m_Tray

private

Definition at line 387 of file taskswnd.cpp.

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

m_uHardErrorMsg

UINT CTaskSwitchWnd::m_uHardErrorMsg

private

Definition at line 411 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