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)
LRESULT	OnWinMMDeviceChange (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	OnActivateTaskIndex (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
UINT	m_WinMMDevChgMsg
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
CMultimediaBackend	m_Mixer

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 386 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 424 of file taskswnd.cpp.

                     :
        m_ShellHookMsg(NULL),
        m_WinMMDevChgMsg(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 443 of file taskswnd.cpp.

{ }

Member Function Documentation

ActivateTask()

BOOL CTaskSwitchWnd::ActivateTask ( IN HWND  hWnd )

inline

Definition at line 1236 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 1225 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 1196 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 777 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 872 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 1020 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 733 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 1105 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 2347 of file taskswnd.cpp.

    {
        return E_NOTIMPL;
    }

DeleteAllTasks()

VOID CTaskSwitchWnd::DeleteAllTasks ( )

inline

Definition at line 1277 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 1260 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 1090 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 837 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 1486 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 577 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 695 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 979 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 2002 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 1180 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 962 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 1163 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(), HandleItemPaint(), and OnActivateTaskIndex().

FlashTask()

BOOL CTaskSwitchWnd::FlashTask ( IN HWND  hWnd )

inline

Definition at line 1297 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 1291 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 1072 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 1957 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 2338 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 586 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 445 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 1621 of file taskswnd.cpp.

    {
        const UINT uAppCmd = GET_APPCOMMAND_LPARAM(lParam);
        if (InvokeRegistryAppKeyCommand(uAppCmd))
            return TRUE;
        switch (uAppCmd)
        {
            // TODO: When MMDevAPI arrives, try IMMDeviceEnumerator::GetDefaultAudioEndpoint first and then fall back to WinMM.
            case APPCOMMAND_VOLUME_MUTE:
                return m_Mixer.Mute();
            case APPCOMMAND_VOLUME_DOWN:
            case APPCOMMAND_VOLUME_UP:
                return m_Mixer.AdjustVolume(uAppCmd, hProcessHeap);
            case APPCOMMAND_BROWSER_SEARCH:
                return SHFindFiles(NULL, NULL);
        }
        return FALSE;
    }

Referenced by OnShellHook().

HandleButtonClick()

BOOL CTaskSwitchWnd::HandleButtonClick ( IN WORD  wIndex )

inline

Definition at line 1768 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 1820 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 1975 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 1846 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 1763 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 1815 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 1731 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 1799 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 1889 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 2325 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 1584 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 1931 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().

OnActivateTaskIndex()

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

inline

Definition at line 2117 of file taskswnd.cpp.

    {
        DWORD dwAccelerators = HIWORD(wParam);
        WCHAR szExecutablePath[MAX_PATH];
 
        PTASK_ITEM pTaskItem = FindTaskItemByIndex(LOWORD(wParam));
        if (pTaskItem && ::IsWindow(pTaskItem->hWnd))
        {
            // Win+Shift: New instance
            if ((dwAccelerators & MOD_SHIFT) == MOD_SHIFT)
            {
                if (!SHELL_GetImageFileNameByWindow(pTaskItem->hWnd,
                                                    szExecutablePath,
                                                    _countof(szExecutablePath)))
                {
                    return FALSE;
                }
                // Win+Shift+Ctrl is used for creating a new instance of a task as Administrator
                LPCWSTR szVerb = L"open";
                if ((dwAccelerators & MOD_CONTROL) == MOD_CONTROL)
                    szVerb = L"runas";
                ShellExecuteW(NULL, szVerb, szExecutablePath, NULL, NULL, SW_SHOWNORMAL);
                return TRUE;
            }
            // Win+Alt: Jump list
            else if ((dwAccelerators & MOD_ALT) == MOD_ALT)
            {
                // TODO: Use JumpList once implemented
 
                // Find TaskItem's position on the screen
                RECT rcItem, rcToolbar;
                m_TaskBar.GetItemRect(pTaskItem->Index, &rcItem);
                m_TaskBar.GetWindowRect(&rcToolbar);
                OffsetRect(&rcItem, rcToolbar.left, rcToolbar.top);
 
                ::SendMessageCallbackW(pTaskItem->hWnd, WM_POPUPSYSTEMMENU, 0, MAKELPARAM(rcItem.left, rcItem.top),
                               SendAsyncProc, (ULONG_PTR)pTaskItem);
            }
            // Win+Ctrl: Switch to last window of a task
            else if ((dwAccelerators & MOD_CONTROL) == MOD_CONTROL)
            {
                // TODO: Implement once Superbar is implemented.
                return FALSE;
            }
            // No modifier: just switch to the task
            else
            {
                // TODO: This should launch a pinned task once Superbar is implemented
 
                BOOL bIsMinimized = ::IsIconic(pTaskItem->hWnd);
                BOOL bIsActive = (pTaskItem == m_ActiveTaskItem);
 
                if (!bIsMinimized && bIsActive)
                {
                    if (!::IsHungAppWindow(pTaskItem->hWnd))
                        ::ShowWindowAsync(pTaskItem->hWnd, SW_MINIMIZE);
                }
                else
                {
                    ::SwitchToThisWindow(pTaskItem->hWnd, TRUE);
                }
            }
        }
        return TRUE;
    }

OnCommand()

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

inline

Definition at line 2088 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 2211 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 2309 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 1525 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
 
        /* WinMM is needed to change system volume via media buttons */
        m_WinMMDevChgMsg = RegisterWindowMessageW(L"winmm_devicechange");
        m_Mixer.Initialize();
 
        return TRUE;
    }

OnDestroy()

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

inline

Definition at line 1563 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 2045 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 2239 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 2257 of file taskswnd.cpp.

    {
        return MA_NOACTIVATE;
    }

OnNcHitTest()

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

inline

Definition at line 2077 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 2098 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 2293 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 2298 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 1640 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 2062 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 2183 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 1510 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 2262 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 2110 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 2028 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 2037 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 2017 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;
    }

OnWinMMDeviceChange()

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

inline

Definition at line 1724 of file taskswnd.cpp.

    {
        TRACE("Audio device was added or removed, invalidating mixer\n");
        m_Mixer.Initialize();
        return TRUE;
    }

RedrawTask()

BOOL CTaskSwitchWnd::RedrawTask ( IN HWND  hWnd )

inline

Definition at line 1337 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 1312 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 1503 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 667 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 916 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 1496 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 1794 of file taskswnd.cpp.

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

Referenced by HandleTaskItemRightClick(), and OnActivateTaskIndex().

UpdateButtonsSize()

VOID CTaskSwitchWnd::UpdateButtonsSize ( IN BOOL  bRedrawDisabled )

inline

Definition at line 1351 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 505 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 568 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 621 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 404 of file taskswnd.cpp.

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

m_AllocatedTaskItems

WORD CTaskSwitchWnd::m_AllocatedTaskItems

private

Definition at line 400 of file taskswnd.cpp.

Referenced by AllocTaskItem().

m_ButtonCount

WORD CTaskSwitchWnd::m_ButtonCount

private

Definition at line 408 of file taskswnd.cpp.

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

m_ButtonSize

SIZE CTaskSwitchWnd::m_ButtonSize

private

Definition at line 417 of file taskswnd.cpp.

Referenced by CTaskSwitchWnd(), and UpdateButtonsSize().

m_ButtonsPerLine

UINT CTaskSwitchWnd::m_ButtonsPerLine

private

Definition at line 407 of file taskswnd.cpp.

Referenced by UpdateButtonsSize(), and UpdateTaskItemButton().

m_HardErrorThread

CHardErrorThread CTaskSwitchWnd::m_HardErrorThread

private

Definition at line 420 of file taskswnd.cpp.

Referenced by OnCopyData().

m_ImageList

HIMAGELIST CTaskSwitchWnd::m_ImageList

private

Definition at line 410 of file taskswnd.cpp.

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

m_IsDestroying

BOOL CTaskSwitchWnd::m_IsDestroying

private

Definition at line 413 of file taskswnd.cpp.

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

m_IsGroupingEnabled

BOOL CTaskSwitchWnd::m_IsGroupingEnabled

private

Definition at line 412 of file taskswnd.cpp.

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

m_Mixer

CMultimediaBackend CTaskSwitchWnd::m_Mixer

private

Definition at line 421 of file taskswnd.cpp.

Referenced by HandleAppCommand(), OnCreate(), and OnWinMMDeviceChange().

m_nRudeAppValidationCounter

INT CTaskSwitchWnd::m_nRudeAppValidationCounter

private

Definition at line 415 of file taskswnd.cpp.

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

m_ShellHookMsg

UINT CTaskSwitchWnd::m_ShellHookMsg

private

Definition at line 396 of file taskswnd.cpp.

Referenced by OnCreate().

m_TaskBar

CTaskToolbar CTaskSwitchWnd::m_TaskBar

private

Definition at line 392 of file taskswnd.cpp.

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

m_TaskGroups

PTASK_GROUP CTaskSwitchWnd::m_TaskGroups

private

Definition at line 402 of file taskswnd.cpp.

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

m_TaskItemCount

WORD CTaskSwitchWnd::m_TaskItemCount

private

Definition at line 399 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 403 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 406 of file taskswnd.cpp.

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

m_Tray

CComPtr<ITrayWindow> CTaskSwitchWnd::m_Tray

private

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

Referenced by CTaskSwitchWnd(), and OnCopyData().

m_WinMMDevChgMsg

UINT CTaskSwitchWnd::m_WinMMDevChgMsg

private

Definition at line 397 of file taskswnd.cpp.

Referenced by OnCreate().

---

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

• base/shell/explorer/taskswnd.cpp