CTaskSwitchWnd Class Reference

Inheritance diagram for CTaskSwitchWnd:

Collaboration diagram for CTaskSwitchWnd:

Public Member Functions
	CTaskSwitchWnd ()
virtual	~CTaskSwitchWnd ()
INT	GetWndTextFromTaskItem (IN PTASK_ITEM TaskItem, LPWSTR szBuf, DWORD cchBuf)
VOID	UpdateIndexesAfter (IN INT iIndex, BOOL bInserted)
INT	UpdateTaskGroupButton (IN PTASK_GROUP TaskGroup)
VOID	ExpandTaskGroup (IN PTASK_GROUP TaskGroup)
HICON	GetWndIcon (HWND hwnd)
INT	UpdateTaskItemButton (IN PTASK_ITEM TaskItem)
VOID	RemoveIcon (IN PTASK_ITEM TaskItem)
PTASK_ITEM	FindLastTaskItemOfGroup (IN PTASK_GROUP TaskGroup OPTIONAL, IN PTASK_ITEM NewTaskItem OPTIONAL)
INT	CalculateTaskItemNewButtonIndex (IN PTASK_ITEM TaskItem)
INT	AddTaskItemButton (IN OUT PTASK_ITEM TaskItem)
BOOL	DeleteTaskItemButton (IN OUT PTASK_ITEM TaskItem)
PTASK_GROUP	AddToTaskGroup (IN HWND hWnd)
VOID	RemoveTaskFromTaskGroup (IN OUT PTASK_ITEM TaskItem)
PTASK_ITEM	FindTaskItem (IN HWND hWnd)
PTASK_ITEM	FindOtherTaskItem (IN HWND hWnd)
PTASK_ITEM	AllocTaskItem ()
VOID	FreeTaskItem (IN OUT PTASK_ITEM TaskItem)
VOID	DeleteTaskItem (IN OUT PTASK_ITEM TaskItem)
VOID	CheckActivateTaskItem (IN OUT PTASK_ITEM TaskItem)
PTASK_ITEM	FindTaskItemByIndex (IN INT Index)
PTASK_GROUP	FindTaskGroupByIndex (IN INT Index)
BOOL	AddTask (IN HWND hWnd)
BOOL	ActivateTaskItem (IN OUT PTASK_ITEM TaskItem OPTIONAL)
BOOL	ActivateTask (IN HWND hWnd)
BOOL	DeleteTask (IN HWND hWnd)
VOID	DeleteAllTasks ()
VOID	FlashTaskItem (IN OUT PTASK_ITEM TaskItem)
BOOL	FlashTask (IN HWND hWnd)
VOID	RedrawTaskItem (IN OUT PTASK_ITEM TaskItem)
BOOL	RedrawTask (IN HWND hWnd)
VOID	UpdateButtonsSize (IN BOOL bRedrawDisabled)
BOOL CALLBACK	EnumWindowsProc (IN HWND hWnd)
BOOL	RefreshWindowList ()
LRESULT	OnThemeChanged (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnCreate (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnDestroy (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
VOID	SendPulseToTray (BOOL bDelete, HWND hwndActive)
BOOL	HandleAppCommand (IN WPARAM wParam, IN LPARAM lParam)
LRESULT	OnShellHook (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
VOID	HandleTaskItemClick (IN OUT PTASK_ITEM TaskItem)
VOID	HandleTaskGroupClick (IN OUT PTASK_GROUP TaskGroup)
BOOL	HandleButtonClick (IN WORD wIndex)
VOID	HandleTaskItemRightClick (IN OUT PTASK_ITEM TaskItem)
VOID	HandleTaskGroupRightClick (IN OUT PTASK_GROUP TaskGroup)
BOOL	HandleButtonRightClick (IN WORD wIndex)
LRESULT	HandleItemPaint (IN OUT NMTBCUSTOMDRAW *nmtbcd)
LRESULT	HandleToolbarNotification (IN const NMHDR *nmh)
LRESULT	OnEraseBackground (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnSize (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnNcHitTest (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnCommand (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnNotify (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnUpdateTaskbarPos (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnTaskbarSettingsChanged (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnContextMenu (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnKludgeItemRect (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnMouseActivate (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnTimer (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnSetFont (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnSettingChanged (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnCopyData (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
HRESULT	Initialize (IN HWND hWndParent, IN OUT ITrayWindow *tray)
HRESULT WINAPI	GetWindow (HWND *phwnd)
HRESULT WINAPI	ContextSensitiveHelp (BOOL fEnterMode)
Public Member Functions inherited from ATL::CComObjectRootEx< CComMultiThreadModelNoCS >
	~CComObjectRootEx ()
ULONG	InternalAddRef ()
ULONG	InternalRelease ()
void	Lock ()
void	Unlock ()
HRESULT	_AtlInitialConstruct ()
Public Member Functions inherited from ATL::CComObjectRootBase
	CComObjectRootBase ()
	~CComObjectRootBase ()
void	SetVoid (void *)
HRESULT	_AtlFinalConstruct ()
HRESULT	FinalConstruct ()
void	InternalFinalConstructAddRef ()
void	InternalFinalConstructRelease ()
void	FinalRelease ()
Public Member Functions inherited from ATL::CWindowImpl< CTaskSwitchWnd, CWindow, CControlWinTraits >
HWND	Create (HWND hWndParent, _U_RECT rect=NULL, LPCTSTR szWindowName=NULL, DWORD dwStyle=0, DWORD dwExStyle=0, _U_MENUorID MenuOrID=0U, LPVOID lpCreateParam=NULL)
Public Member Functions inherited from ATL::CWindowImplBaseT< 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 VOID CALLBACK	SendAsyncProc (HWND hwnd, UINT uMsg, DWORD_PTR dwData, LRESULT lResult)
Static Public Member Functions inherited from ATL::CComCoClass< CTaskSwitchWnd >
static LPCTSTR WINAPI	GetObjectDescription ()
Static Public Member Functions inherited from ATL::CComObjectRootBase
static void WINAPI	ObjectMain (bool)
static const struct _ATL_CATMAP_ENTRY *	GetCategoryMap ()
static HRESULT WINAPI	InternalQueryInterface (void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject)
Static Public Member Functions inherited from ATL::CWindowImpl< CTaskSwitchWnd, CWindow, CControlWinTraits >
static LPCTSTR	GetWndCaption ()
Static Public Member Functions inherited from ATL::CWindowImplBaseT< TBase, TWinTraits >
static DWORD	GetWndStyle (DWORD dwStyle)
static DWORD	GetWndExStyle (DWORD dwExStyle)
static LRESULT CALLBACK	StartWindowProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
static LRESULT CALLBACK	WindowProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
Static Public Member Functions inherited from ATL::CWindow
static LPCTSTR	GetWndClassName ()
static LRESULT	SendMessage (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

Private Attributes
CTaskToolbar	m_TaskBar
CComPtr< ITrayWindow >	m_Tray
UINT	m_ShellHookMsg
WORD	m_TaskItemCount
WORD	m_AllocatedTaskItems
PTASK_GROUP	m_TaskGroups
PTASK_ITEM	m_TaskItems
PTASK_ITEM	m_ActiveTaskItem
HTHEME	m_Theme
UINT	m_ButtonsPerLine
WORD	m_ButtonCount
HIMAGELIST	m_ImageList
BOOL	m_IsGroupingEnabled
BOOL	m_IsDestroying
SIZE	m_ButtonSize
UINT	m_uHardErrorMsg
CHardErrorThread	m_HardErrorThread

Additional Inherited Members
Public Types inherited from ATL::CWindowImplRoot< TBase >
enum	{ WINSTATE_DESTROYED = 0x00000001 }
Public Types inherited from IOleWindow
typedef IOleWindow *	LPOLEWINDOW
Public Types inherited from IUnknown
typedef IUnknown *	LPUNKNOWN
Public Attributes inherited from ATL::CComObjectRootBase
LONG	m_dwRef
Public Attributes inherited from ATL::CWindowImplBaseT< TBase, TWinTraits >
WNDPROC	m_pfnSuperWindowProc
Public Attributes inherited from ATL::CWindowImplRoot< TBase >
CWndProcThunk	m_thunk
const _ATL_MSG *	m_pCurrentMsg
DWORD	m_dwState
Public Attributes inherited from ATL::CWindow
HWND	m_hWnd
Static Public Attributes inherited from ATL::CWindow
static RECT	rcDefault

Detailed Description

Definition at line 296 of file taskswnd.cpp.

Constructor & Destructor Documentation

CTaskSwitchWnd()

CTaskSwitchWnd::CTaskSwitchWnd ( )

inline

Definition at line 330 of file taskswnd.cpp.

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

~CTaskSwitchWnd()

virtual CTaskSwitchWnd::~CTaskSwitchWnd ( )

inlinevirtual

Definition at line 347 of file taskswnd.cpp.

{ }

Member Function Documentation

ActivateTask()

BOOL CTaskSwitchWnd::ActivateTask ( IN HWND  hWnd )

inline

Definition at line 1140 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 1129 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 1100 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 681 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 776 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 924 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 637 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 1009 of file taskswnd.cpp.

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

Referenced by ActivateTaskItem().

ContextSensitiveHelp()

HRESULT WINAPI CTaskSwitchWnd::ContextSensitiveHelp ( BOOL  fEnterMode )

inline

Implements IOleWindow.

Definition at line 1990 of file taskswnd.cpp.

    {
        return E_NOTIMPL;
    }

DeleteAllTasks()

VOID CTaskSwitchWnd::DeleteAllTasks ( )

inline

Definition at line 1181 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 1164 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 994 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 741 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 1390 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 481 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 599 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 883 of file taskswnd.cpp.

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

Referenced by ActivateTask().

FindTaskGroupByIndex()

PTASK_GROUP CTaskSwitchWnd::FindTaskGroupByIndex ( IN INT  Index )

inline

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

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

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

FindTaskItemByIndex()

PTASK_ITEM CTaskSwitchWnd::FindTaskItemByIndex ( IN INT  Index )

inline

Definition at line 1067 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 1201 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 1195 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 976 of file taskswnd.cpp.

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

Referenced by DeleteTaskItem().

GetWindow()

HRESULT WINAPI CTaskSwitchWnd::GetWindow ( HWND *  phwnd )

inline

Implements IOleWindow.

Definition at line 1982 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 490 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 349 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 1480 of file taskswnd.cpp.

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

Referenced by OnShellHook().

HandleButtonClick()

BOOL CTaskSwitchWnd::HandleButtonClick ( IN WORD  wIndex )

inline

Definition at line 1622 of file taskswnd.cpp.

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

Referenced by OnCommand().

HandleButtonRightClick()

BOOL CTaskSwitchWnd::HandleButtonRightClick ( IN WORD  wIndex )

inline

Definition at line 1675 of file taskswnd.cpp.

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

Referenced by OnContextMenu().

HandleItemPaint()

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

inline

Definition at line 1701 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 1617 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 1670 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 1586 of file taskswnd.cpp.

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

Referenced by HandleButtonClick().

HandleTaskItemRightClick()

VOID CTaskSwitchWnd::HandleTaskItemRightClick ( IN OUT PTASK_ITEM  TaskItem )

inline

Definition at line 1654 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 1744 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 1972 of file taskswnd.cpp.

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

OnCommand()

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

inline

Definition at line 1819 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 1876 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 1956 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 1429 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 1462 of file taskswnd.cpp.

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

OnEraseBackground()

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

inline

Definition at line 1776 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 1904 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 1922 of file taskswnd.cpp.

    {
        return MA_NOACTIVATE;
    }

OnNcHitTest()

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

inline

Definition at line 1808 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 1829 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 1940 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 1945 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 1501 of file taskswnd.cpp.

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

OnSize()

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

inline

Definition at line 1793 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 1848 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 1414 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 1927 of file taskswnd.cpp.

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

OnUpdateTaskbarPos()

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

inline

Definition at line 1841 of file taskswnd.cpp.

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

RedrawTask()

BOOL CTaskSwitchWnd::RedrawTask ( IN HWND  hWnd )

inline

Definition at line 1241 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 1216 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 1407 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 571 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 820 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 1400 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 1649 of file taskswnd.cpp.

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

Referenced by HandleTaskItemRightClick().

SendPulseToTray()

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

inline

Definition at line 1474 of file taskswnd.cpp.

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

Referenced by HandleButtonClick(), and OnShellHook().

UpdateButtonsSize()

VOID CTaskSwitchWnd::UpdateButtonsSize ( IN BOOL  bRedrawDisabled )

inline

Definition at line 1255 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 409 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 472 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 525 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 313 of file taskswnd.cpp.

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

m_AllocatedTaskItems

WORD CTaskSwitchWnd::m_AllocatedTaskItems

private

Definition at line 309 of file taskswnd.cpp.

Referenced by AllocTaskItem().

m_ButtonCount

WORD CTaskSwitchWnd::m_ButtonCount

private

Definition at line 317 of file taskswnd.cpp.

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

m_ButtonSize

SIZE CTaskSwitchWnd::m_ButtonSize

private

Definition at line 324 of file taskswnd.cpp.

Referenced by CTaskSwitchWnd(), and UpdateButtonsSize().

m_ButtonsPerLine

UINT CTaskSwitchWnd::m_ButtonsPerLine

private

Definition at line 316 of file taskswnd.cpp.

Referenced by UpdateButtonsSize(), and UpdateTaskItemButton().

m_HardErrorThread

CHardErrorThread CTaskSwitchWnd::m_HardErrorThread

private

Definition at line 327 of file taskswnd.cpp.

Referenced by OnCopyData().

m_ImageList

HIMAGELIST CTaskSwitchWnd::m_ImageList

private

Definition at line 319 of file taskswnd.cpp.

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

m_IsDestroying

BOOL CTaskSwitchWnd::m_IsDestroying

private

Definition at line 322 of file taskswnd.cpp.

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

m_IsGroupingEnabled

BOOL CTaskSwitchWnd::m_IsGroupingEnabled

private

Definition at line 321 of file taskswnd.cpp.

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

m_ShellHookMsg

UINT CTaskSwitchWnd::m_ShellHookMsg

private

Definition at line 306 of file taskswnd.cpp.

Referenced by OnCreate().

m_TaskBar

CTaskToolbar CTaskSwitchWnd::m_TaskBar

private

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

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

m_TaskItemCount

WORD CTaskSwitchWnd::m_TaskItemCount

private

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

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

m_Tray

CComPtr<ITrayWindow> CTaskSwitchWnd::m_Tray

private

Definition at line 304 of file taskswnd.cpp.

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

m_uHardErrorMsg

UINT CTaskSwitchWnd::m_uHardErrorMsg

private

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