Inheritance diagram for CTrayWindow:

[legend]

Collaboration diagram for CTrayWindow:

[legend]

Classes
struct	MINIMIZE_INFO

Public Member Functions
	CTrayWindow ()

virtual	~CTrayWindow ()

HRESULT	ExecResourceCmd (int id)

void	SaveState ()

LRESULT	DoExitWindows ()

DWORD WINAPI	RunFileDlgThread ()

void	DisplayRunFileDlg ()

DWORD WINAPI	TrayPropertiesThread ()

HWND STDMETHODCALLTYPE	DisplayProperties ()

VOID	OpenCommonStartMenuDirectory (IN HWND hWndOwner, IN LPCTSTR lpOperation)

VOID	OpenTaskManager (IN HWND hWndOwner)

VOID	ToggleDesktop ()

BOOL STDMETHODCALLTYPE	ExecContextMenuCmd (IN UINT uiCmd)

VOID	HideStartMenu ()

LRESULT	HandleHotKey (DWORD id)

LRESULT	HandleCommand (UINT uCommand)

UINT	TrackMenu (IN HMENU hMenu, IN POINT *ppt OPTIONAL, IN HWND hwndExclude OPTIONAL, IN BOOL TrackUp, IN BOOL IsContextMenu)

HRESULT	TrackCtxMenu (IN IContextMenu contextMenu, IN POINT ppt OPTIONAL, IN HWND hwndExclude OPTIONAL, IN BOOL TrackUp, IN PVOID Context OPTIONAL)

void	UpdateFonts ()

HMONITOR	GetScreenRectFromRect (IN OUT RECT *pRect, IN DWORD dwFlags)

HMONITOR	GetMonitorFromRect (IN const RECT *pRect)

HMONITOR	GetScreenRect (IN HMONITOR hMonitor, IN OUT RECT *pRect)

VOID	AdjustSizerRect (RECT *rc, DWORD pos)

VOID	MakeTrayRectWithSize (IN DWORD Position, IN const SIZE pTraySize, IN OUT RECT pRect)

VOID	GetTrayRectFromScreenRect (IN DWORD Position, IN const RECT pScreen, IN const SIZE pTraySize OPTIONAL, OUT RECT *pRect)

BOOL	IsPosHorizontal ()

HMONITOR	CalculateValidSize (IN DWORD Position, IN OUT RECT *pRect)

DWORD	GetDraggingRectFromPt (IN POINT pt, OUT RECT pRect, OUT HMONITOR phMonitor)

DWORD	GetDraggingRectFromRect (IN OUT RECT pRect, OUT HMONITOR phMonitor)

VOID	ChangingWinPos (IN OUT LPWINDOWPOS pwp)

VOID	ApplyClipping (IN BOOL Clip)

VOID	ResizeWorkArea ()

VOID	CheckTrayWndPosition ()

VOID	RegLoadSettings ()

VOID	AlignControls (IN PRECT prcClient OPTIONAL)

void	FitToRebar (PRECT pRect)

void	PopupStartMenu ()

void	ProcessMouseTracking ()

void	ProcessAutoHide ()

LRESULT	EraseBackgroundWithTheme (HDC hdc)

int	DrawSizerWithTheme (IN HRGN hRgn)

HRESULT STDMETHODCALLTYPE	Open ()

HRESULT STDMETHODCALLTYPE	Close ()

HWND STDMETHODCALLTYPE	GetHWND ()

BOOL STDMETHODCALLTYPE	IsSpecialHWND (IN HWND hWnd)

BOOL STDMETHODCALLTYPE	IsHorizontal ()

BOOL STDMETHODCALLTYPE	Lock (IN BOOL bLock)

BOOL STDMETHODCALLTYPE	IsTaskWnd (HWND hWnd)

HRESULT STDMETHODCALLTYPE	QueryContextMenu (HMENU hPopup, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)

HRESULT STDMETHODCALLTYPE	InvokeCommand (LPCMINVOKECOMMANDINFO lpici)

HRESULT STDMETHODCALLTYPE	GetCommandString (UINT_PTR idCmd, UINT uType, UINT *pwReserved, LPSTR pszName, UINT cchMax)

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

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

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

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

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

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

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

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

void	DrawShowDesktopButton ()

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

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

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

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

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

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

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

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

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

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

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

BOOL	IsPointWithinStartButton (LPPOINT ppt, LPRECT prcStartBtn, PWINDOWINFO pwi)

BOOL	IsPointWithinShowDesktopButton (LPPOINT ppt, LPRECT prcShowDesktopBtn, PWINDOWINFO pwi)

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

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

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

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

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

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

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

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

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

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

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

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

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

STDMETHODIMP	NotifyFullScreenToAppBars (HMONITOR hMonitor, BOOL bFullOpening) override

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

VOID	MinimizeAll (BOOL bShowDesktop=FALSE)

VOID	ShowDesktop ()

VOID	RestoreAll ()

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

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

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

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

LRESULT	OnNcCalcSize (INT code, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnInitMenuPopup (INT code, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnActivate (INT code, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnSetFocus (INT code, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnGetMinMaxInfo (INT code, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

LRESULT	OnRebarAutoSize (INT code, LPNMHDR nmhdr, BOOL &bHandled)

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

	if (m_StartMenuBand !=NULL)

VOID	TrayProcessMessages ()

VOID	TrayMessageLoop ()

	GetState () override

STDMETHODIMP	GetTrayWindow (OUT HWND *phWndTray) override

STDMETHODIMP	RegisterDesktopWindow (IN HWND hWndDesktop) override

STDMETHODIMP	Unknown (IN DWORD dwUnknown1, IN DWORD dwUnknown2) override

virtual HRESULT	RaiseStartButton ()

STDMETHODIMP	GetWindow (HWND *phwnd) override

STDMETHODIMP	ContextSensitiveHelp (BOOL fEnterMode) override

void	_Init ()

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< CTrayWindow, 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

Public Member Functions inherited from CAppBarManager
	CAppBarManager ()

virtual	~CAppBarManager ()

LRESULT	OnAppBarMessage (_Inout_ PCOPYDATASTRUCT pCopyData)

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

HRESULT	QueryContextMenu ([in] HMENU hmenu, [in] UINT indexMenu, [in] UINT idCmdFirst, [in] UINT idCmdLast, [in] UINT uFlags)

HRESULT	InvokeCommand ([in] LPCMINVOKECOMMANDINFO lpici)

HRESULT	GetCommandString ([in] UINT_PTR idCmd, [in] UINT uType, [out] UINT *pwReserved, [out, size_is(cchMax)] LPSTR pszName, [in] UINT cchMax)

Static Public Member Functions
static DWORD WINAPI	s_RunFileDlgThread (IN OUT PVOID pParam)

static DWORD WINAPI	s_TrayPropertiesThread (IN OUT PVOID pParam)

static BOOL	IsDialog (HWND hwnd)

static BOOL CALLBACK	MinimizeWindowsProc (HWND hwnd, LPARAM lParam)

Static Public Member Functions inherited from ATL::CComCoClass< CTrayWindow >
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< CTrayWindow, 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)

Public Attributes
CComPtr< ITrayBandSite >	m_TrayBandSite

union {
DWORD Flags

struct {
DWORD InSizeMove: 1

DWORD IsDragging: 1

DWORD NewPosSize: 1

}

};

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

Protected Member Functions
BOOL	IsAutoHideState () const override

BOOL	IsHidingState () const override

BOOL	IsAlwaysOnTop () const override

HMONITOR &	GetMonitor () override

HMONITOR &	GetPreviousMonitor () override

INT	GetPosition () const override

const RECT *	GetTrayRect () override

HWND	GetTrayWnd () const override

HWND	GetDesktopWnd () const override

void	SetAutoHideState (_In_ BOOL bAutoHide) override

void	UpdateAlwaysOnTop (_In_ BOOL bAlwaysOnTop) override

Protected Member Functions inherited from CAppBarManager
PAPPBAR	FindAppBar (_In_ HWND hwndAppBar) const

void	EliminateAppBar (_In_ INT iItem)

void	DestroyAppBarDPA ()

void	AppBarSubtractRect (_In_ PAPPBAR pAppBar, _Inout_ PRECT prc)

BOOL	AppBarOutsideOf (_In_ const APPBAR pAppBar1, _In_ const APPBAR pAppBar2)

void	ComputeHiddenRect (_Inout_ PRECT prc, _In_ UINT uSide)

PAPPBAR_COMMAND	GetAppBarMessage (_Inout_ PCOPYDATASTRUCT pCopyData)

void	GetDockedRect (_Out_ PRECT prcDocked)

BOOL	SetAutoHideBar (_In_ HWND hwndTarget, _In_ BOOL bSetOrReset, _In_ UINT uSide)

void	OnAppBarActivationChange2 (_In_ HWND hwndNewAutoHide, _In_ UINT uSide)

BOOL	OnAppBarNew (_In_ const APPBAR_COMMAND *pData)

void	OnAppBarRemove (_In_ const APPBAR_COMMAND *pData)

void	OnAppBarQueryPos (_Inout_ PAPPBAR_COMMAND pData)

void	OnAppBarSetPos (_Inout_ PAPPBAR_COMMAND pData)

UINT	OnAppBarGetState ()

BOOL	OnAppBarGetTaskbarPos (_Inout_ PAPPBAR_COMMAND pData)

void	OnAppBarActivationChange (_In_ const APPBAR_COMMAND *pData)

HWND	OnAppBarGetAutoHideBar (_In_ UINT uSide)

BOOL	OnAppBarSetAutoHideBar (_In_ const APPBAR_COMMAND *pData)

void	OnAppBarSetState (_In_ UINT uState)

void	OnAppBarNotifyAll (_In_opt_ HMONITOR hMon, _In_opt_ HWND hwndIgnore, _In_ DWORD dwNotify, _In_opt_ LPARAM lParam)

WORKAREA_TYPE	RecomputeWorkArea (_In_ const RECT *prcTray, _In_ HMONITOR hMonitor, _Out_ PRECT prcWorkArea)

void	RecomputeAllWorkareas ()

void	StuckAppChange (_In_opt_ HWND hwndTarget, _In_opt_ const RECT prcOld, _In_opt_ const RECT prcNew, _In_ BOOL bTray)

void	RedrawDesktop (_In_ HWND hwndDesktop, _Inout_ PRECT prc)

virtual BOOL	IsAutoHideState () const =0

virtual BOOL	IsHidingState () const =0

virtual BOOL	IsAlwaysOnTop () const =0

virtual HMONITOR &	GetMonitor ()=0

virtual HMONITOR &	GetPreviousMonitor ()=0

virtual INT	GetPosition () const =0

virtual const RECT *	GetTrayRect ()=0

virtual HWND	GetTrayWnd () const =0

virtual HWND	GetDesktopWnd () const =0

virtual void	SetAutoHideState (_In_ BOOL bAutoHide)=0

virtual void	UpdateAlwaysOnTop (_In_ BOOL bAlwaysOnTop)=0

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 Types inherited from IContextMenu
typedef IContextMenu *	LPCONTEXTMENU

typedef struct IContextMenu::tagCMINVOKECOMMANDINFO	CMINVOKECOMMANDINFO

typedef struct IContextMenu::tagCMINVOKECOMMANDINFO *	LPCMINVOKECOMMANDINFO

typedef struct IContextMenu::tagCMInvokeCommandInfoEx	CMINVOKECOMMANDINFOEX

typedef struct IContextMenu::tagCMInvokeCommandInfoEx *	LPCMINVOKECOMMANDINFOEX

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

Static Public Attributes inherited from IContextMenu
static const WCHAR	CMDSTR_NEWFOLDERW [] = {'N','e','w','F','o','l','d','e','r',0}

static const WCHAR	CMDSTR_VIEWLISTW [] = {'V','i','e','w','L','i','s','t',0}

static const WCHAR	CMDSTR_VIEWDETAILSW [] = {'V','i','e','w','D','e','t','a','i','l','s',0}

Static Protected Member Functions inherited from CAppBarManager
static BOOL CALLBACK	MonitorEnumProc (_In_ HMONITOR hMonitor, _In_ HDC hDC, _In_ LPRECT prc, _Inout_ LPARAM lParam)

Protected Attributes inherited from CAppBarManager
HDPA	m_hAppBarDPA

HWND	m_ahwndAutoHideBars [4]

Detailed Description

Definition at line 305 of file traywnd.cpp.

Constructor & Destructor Documentation

◆ CTrayWindow()

CTrayWindow::CTrayWindow ( )

inline

Definition at line 368 of file traywnd.cpp.

                  :
        m_StartButton(),
        m_pShowDesktopButton(NULL),
        m_Theme(NULL),
        m_Font(NULL),
        m_DesktopWnd(NULL),
        m_Rebar(NULL),
        m_TaskSwitch(NULL),
        m_TrayNotify(NULL),
        m_Position(0),
        m_Monitor(NULL),
        m_PreviousMonitor(NULL),
        m_DraggingPosition(0),
        m_DraggingMonitor(NULL),
        m_TrayPropertiesOwner(NULL),
        m_RunFileDlgOwner(NULL),
        m_AutoHideState(NULL),
        m_ShellServices(NULL),
        Flags(0)
    {
        ZeroMemory(&m_TrayRects, sizeof(m_TrayRects));
        ZeroMemory(&m_TraySize, sizeof(m_TraySize));
        ZeroMemory(&m_AutoHideOffset, sizeof(m_AutoHideOffset));
        ZeroMemory(&m_MouseTrackingInfo, sizeof(m_MouseTrackingInfo));
    }

◆ ~CTrayWindow()

virtual CTrayWindow::~CTrayWindow ( )

inlinevirtual

Definition at line 394 of file traywnd.cpp.

    {
        if (m_ShellServices != NULL)
        {
            ShutdownShellServices(m_ShellServices);
            m_ShellServices = NULL;
        }
 
        if (m_Font != NULL)
        {
            DeleteObject(m_Font);
            m_Font = NULL;
        }
 
        if (m_Theme)
        {
            CloseThemeData(m_Theme);
            m_Theme = NULL;
        }
 
        PostQuitMessage(0);
    }

Member Function Documentation

◆ _Init()

void CTrayWindow::_Init ( )

inline

Definition at line 3527 of file traywnd.cpp.

    {
        m_Position = (DWORD) -1;
    }

◆ AdjustSizerRect()

VOID CTrayWindow::AdjustSizerRect	(	RECT *	rc,
		DWORD	pos
	)

inline

Definition at line 1133 of file traywnd.cpp.

    {
        int iSizerPart[4] = {TBP_SIZINGBARLEFT, TBP_SIZINGBARTOP, TBP_SIZINGBARRIGHT, TBP_SIZINGBARBOTTOM};
        SIZE size;
 
        if (pos > ABE_BOTTOM)
            pos = ABE_BOTTOM;
 
        HRESULT hr = GetThemePartSize(m_Theme, NULL, iSizerPart[pos], 0, NULL, TS_TRUE, &size);
        if (FAILED_UNEXPECTEDLY(hr))
            return;
 
        switch (pos)
        {
            case ABE_TOP:
                rc->bottom -= size.cy;
                break;
            case ABE_BOTTOM:
                rc->top += size.cy;
                break;
            case ABE_LEFT:
                rc->right -= size.cx;
                break;
            case ABE_RIGHT:
                rc->left += size.cx;
                break;
        }
    }

Referenced by Lock(), and OnNcCalcSize().

◆ AlignControls()

VOID CTrayWindow::AlignControls ( IN PRECT prcClient OPTIONAL )

inline

Definition at line 1672 of file traywnd.cpp.

    {
        RECT rcClient;
        SIZE TraySize, StartSize;
        POINT ptTrayNotify = { 0, 0 };
        BOOL Horizontal;
        HDWP dwp;
 
        m_StartButton.UpdateSize();
        if (prcClient != NULL)
        {
            rcClient = *prcClient;
        }
        else
        {
            if (!GetClientRect(&rcClient))
            {
                ERR("Could not get client rect lastErr=%d\n", GetLastError());
                return;
            }
        }
 
        Horizontal = IsPosHorizontal();
 
        /* We're about to resize/move the start button, the rebar control and
           the tray notification control */
        dwp = BeginDeferWindowPos(4);
        if (dwp == NULL)
        {
            ERR("BeginDeferWindowPos failed. lastErr=%d\n", GetLastError());
            return;
        }
 
        /* Limit the Start button width to the client width, if necessary */
        StartSize = m_StartButton.GetSize();
        if (StartSize.cx > rcClient.right)
            StartSize.cx = rcClient.right;
 
        HWND hwndTaskToolbar = ::GetWindow(m_TaskSwitch, GW_CHILD);
        if (hwndTaskToolbar)
        {
            DWORD size = SendMessageW(hwndTaskToolbar, TB_GETBUTTONSIZE, 0, 0);
 
            /* Themed button covers Edge area as well */
            StartSize.cy = HIWORD(size) + (m_Theme ? GetSystemMetrics(SM_CYEDGE) : 0);
        }
 
        if (m_StartButton.m_hWnd != NULL)
        {
            /* Resize and reposition the button */
            dwp = m_StartButton.DeferWindowPos(dwp,
                                               NULL,
                                               0,
                                               0,
                                               StartSize.cx,
                                               StartSize.cy,
                                               SWP_NOZORDER | SWP_NOACTIVATE);
            if (dwp == NULL)
            {
                ERR("DeferWindowPos for start button failed. lastErr=%d\n", GetLastError());
                return;
            }
        }
 
        /* Determine the size that the tray notification window needs */
        if (Horizontal)
        {
            TraySize.cx = 0;
            TraySize.cy = rcClient.bottom;
        }
        else
        {
            TraySize.cx = rcClient.right;
            TraySize.cy = 0;
        }
 
        if (m_TrayNotify != NULL &&
            SendMessage(m_TrayNotify,
                        TNWM_GETMINIMUMSIZE,
                        (WPARAM)Horizontal,
                        (LPARAM)&TraySize))
        {
            /* Move the tray notification window to the desired location */
            if (Horizontal)
                ptTrayNotify.x = rcClient.right - TraySize.cx;
            else
                ptTrayNotify.y = rcClient.bottom - TraySize.cy;
 
            dwp = ::DeferWindowPos(dwp,
                                   m_TrayNotify,
                                   NULL,
                                   ptTrayNotify.x,
                                   ptTrayNotify.y,
                                   TraySize.cx,
                                   TraySize.cy,
                                   SWP_NOZORDER | SWP_NOACTIVATE);
            if (dwp == NULL)
            {
                ERR("DeferWindowPos for notification area failed. lastErr=%d\n", GetLastError());
                return;
            }
        }
 
        /* Resize/Move the rebar control */
        if (m_Rebar != NULL)
        {
            POINT ptRebar = { 0, 0 };
            SIZE szRebar;
 
            SetWindowStyle(m_Rebar, CCS_VERT, Horizontal ? 0 : CCS_VERT);
 
            if (Horizontal)
            {
                ptRebar.x = StartSize.cx + GetSystemMetrics(SM_CXSIZEFRAME);
                szRebar.cx = ptTrayNotify.x - ptRebar.x;
                szRebar.cy = rcClient.bottom;
            }
            else
            {
                ptRebar.y = StartSize.cy + GetSystemMetrics(SM_CYSIZEFRAME);
                szRebar.cx = rcClient.right;
                szRebar.cy = ptTrayNotify.y - ptRebar.y;
            }
 
            dwp = ::DeferWindowPos(dwp,
                                   m_Rebar,
                                   NULL,
                                   ptRebar.x,
                                   ptRebar.y,
                                   szRebar.cx,
                                   szRebar.cy,
                                   SWP_NOZORDER | SWP_NOACTIVATE);
        }
 
        if (dwp != NULL)
            EndDeferWindowPos(dwp);
 
        if (m_TaskSwitch != NULL)
        {
            /* Update the task switch window configuration */
            SendMessage(m_TaskSwitch, TSWM_UPDATETASKBARPOS, 0, 0);
        }
    }

Referenced by OnSettingChanged(), OnSize(), and Open().

◆ ApplyClipping()

VOID CTrayWindow::ApplyClipping ( IN BOOL Clip )

inline

Definition at line 1483 of file traywnd.cpp.

    {
        RECT rcClip, rcWindow;
        HRGN hClipRgn;
 
        if (GetWindowRect(&rcWindow))
        {
            /* Disable clipping on systems with only one monitor */
            if (GetSystemMetrics(SM_CMONITORS) <= 1)
                Clip = FALSE;
 
            if (Clip)
            {
                rcClip = rcWindow;
 
                GetScreenRect(m_Monitor, &rcClip);
 
                if (!IntersectRect(&rcClip, &rcClip, &rcWindow))
                {
                    rcClip = rcWindow;
                }
 
                OffsetRect(&rcClip,
                           -rcWindow.left,
                           -rcWindow.top);
 
                hClipRgn = CreateRectRgnIndirect(&rcClip);
            }
            else
                hClipRgn = NULL;
 
            /* Set the clipping region or make sure the window isn't clipped
               by disabling it explicitly. */
            SetWindowRgn(hClipRgn, TRUE);
        }
    }

Referenced by CheckTrayWndPosition(), Lock(), OnEnterSizeMove(), and OnSize().

◆ CalculateValidSize()

HMONITOR CTrayWindow::CalculateValidSize	(	IN DWORD	Position,
		IN OUT RECT *	pRect
	)

inline

Definition at line 1213 of file traywnd.cpp.

    {
        RECT rcScreen;
        //BOOL Horizontal;
        HMONITOR hMon;
        SIZE szMax, szWnd;
 
        //Horizontal = IsPosHorizontal();
 
        szWnd.cx = pRect->right - pRect->left;
        szWnd.cy = pRect->bottom - pRect->top;
 
        rcScreen = *pRect;
        hMon = GetScreenRectFromRect(
            &rcScreen,
            MONITOR_DEFAULTTONEAREST);
 
        /* Calculate the maximum size of the tray window and limit the window
           size to half of the screen's size. */
        szMax.cx = (rcScreen.right - rcScreen.left) / 2;
        szMax.cy = (rcScreen.bottom - rcScreen.top) / 2;
        if (szWnd.cx > szMax.cx)
            szWnd.cx = szMax.cx;
        if (szWnd.cy > szMax.cy)
            szWnd.cy = szMax.cy;
 
        /* FIXME - calculate */
 
        GetTrayRectFromScreenRect(Position,
                                  &rcScreen,
                                  &szWnd,
                                  pRect);
 
        return hMon;
    }

Referenced by FitToRebar().

◆ ChangingWinPos()

VOID CTrayWindow::ChangingWinPos ( IN OUT LPWINDOWPOS pwp )

inline

Definition at line 1390 of file traywnd.cpp.

    {
        RECT rcTray;
 
        if (IsDragging)
        {
            rcTray.left = pwp->x;
            rcTray.top = pwp->y;
            rcTray.right = rcTray.left + pwp->cx;
            rcTray.bottom = rcTray.top + pwp->cy;
 
            if (!EqualRect(&rcTray,
                &m_TrayRects[m_DraggingPosition]))
            {
                /* Recalculate the rectangle, the user dragged the tray
                   window to another monitor or the window was somehow else
                   moved or resized */
                m_DraggingPosition = GetDraggingRectFromRect(
                    &rcTray,
                    &m_DraggingMonitor);
                //m_TrayRects[DraggingPosition] = rcTray;
            }
 
            //Monitor = CalculateValidSize(DraggingPosition,
            //                             &rcTray);
 
            m_Monitor = m_DraggingMonitor;
            m_Position = m_DraggingPosition;
            g_TaskbarSettings.sr.Position = m_Position;
            g_TaskbarSettings.Save();
            IsDragging = FALSE;
 
            m_TrayRects[m_Position] = rcTray;
            goto ChangePos;
        }
        else if (GetWindowRect(&rcTray))
        {
            if (InSizeMove)
            {
                if (!(pwp->flags & SWP_NOMOVE))
                {
                    rcTray.left = pwp->x;
                    rcTray.top = pwp->y;
                }
 
                if (!(pwp->flags & SWP_NOSIZE))
                {
                    rcTray.right = rcTray.left + pwp->cx;
                    rcTray.bottom = rcTray.top + pwp->cy;
                }
 
                m_Position = GetDraggingRectFromRect(&rcTray, &m_Monitor);
 
                if (!(pwp->flags & (SWP_NOMOVE | SWP_NOSIZE)))
                {
                    SIZE szWnd;
 
                    szWnd.cx = pwp->cx;
                    szWnd.cy = pwp->cy;
 
                    MakeTrayRectWithSize(m_Position, &szWnd, &rcTray);
                }
 
                m_TrayRects[m_Position] = rcTray;
            }
            else if (m_Position != (DWORD)-1)
            {
                /* If the user isn't resizing the tray window we need to make sure the
                   new size or position is valid. this is to prevent changes to the window
                   without user interaction. */
                rcTray = m_TrayRects[m_Position];
 
                if (IsAutoHideState())
                {
                    rcTray.left += m_AutoHideOffset.cx;
                    rcTray.right += m_AutoHideOffset.cx;
                    rcTray.top += m_AutoHideOffset.cy;
                    rcTray.bottom += m_AutoHideOffset.cy;
                }
            }
 
ChangePos:
            m_TraySize.cx = rcTray.right - rcTray.left;
            m_TraySize.cy = rcTray.bottom - rcTray.top;
 
            pwp->flags &= ~(SWP_NOMOVE | SWP_NOSIZE);
            pwp->x = rcTray.left;
            pwp->y = rcTray.top;
            pwp->cx = m_TraySize.cx;
            pwp->cy = m_TraySize.cy;
        }
    }

Referenced by OnWindowPosChanging().

◆ CheckTrayWndPosition()

VOID CTrayWindow::CheckTrayWndPosition ( )

inline

Definition at line 1572 of file traywnd.cpp.

    {
        /* Force the rebar bands to resize */
        IUnknown_Exec(m_TrayBandSite,
                      IID_IDeskBand,
                      DBID_BANDINFOCHANGED,
                      0,
                      NULL,
                      NULL);
 
        /* Calculate the size of the taskbar based on the rebar */
        FitToRebar(&m_TrayRects[m_Position]);
 
        /* Move the tray window */
        /* The handler of WM_WINDOWPOSCHANGING will override whatever size
         * and position we use here with m_TrayRects */
        SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOZORDER | SWP_NOACTIVATE);
        ResizeWorkArea();
        ApplyClipping(TRUE);
        RedrawWindow(NULL, NULL, RDW_ERASE | RDW_FRAME | RDW_INTERNALPAINT | RDW_INVALIDATE | RDW_ALLCHILDREN);
    }

Referenced by OnDisplayChange(), OnSettingChanged(), OnTaskbarSettingsChanged(), and Open().

◆ Close()

HRESULT STDMETHODCALLTYPE CTrayWindow::Close ( )

inline

Definition at line 2158 of file traywnd.cpp.

    {
        if (m_hWnd != NULL)
        {
            SendMessage(m_hWnd,
                        WM_APP_TRAYDESTROY,
                        0,
                        0);
        }
 
        return S_OK;
    }

◆ ContextSensitiveHelp()

STDMETHODIMP CTrayWindow::ContextSensitiveHelp ( BOOL fEnterMode )

inlineoverride

Implements IOleWindow.

Definition at line 3522 of file traywnd.cpp.

    {
        return E_NOTIMPL;
    }

◆ DisplayProperties()

HWND STDMETHODCALLTYPE CTrayWindow::DisplayProperties ( )

inline

Definition at line 575 of file traywnd.cpp.

    {
        HWND hTrayProp;
 
        if (m_TrayPropertiesOwner)
        {
            hTrayProp = ::GetLastActivePopup(m_TrayPropertiesOwner);
            if (hTrayProp != NULL &&
                hTrayProp != m_TrayPropertiesOwner)
            {
                SetForegroundWindow(hTrayProp);
                return NULL;
            }
        }
 
        CloseHandle(CreateThread(NULL, 0, s_TrayPropertiesThread, this, 0, NULL));
        return NULL;
    }

Referenced by ExecContextMenuCmd(), and HandleCommand().

◆ DisplayRunFileDlg()

void CTrayWindow::DisplayRunFileDlg ( )

inline

Definition at line 522 of file traywnd.cpp.

    {
        HWND hRunDlg;
        if (m_RunFileDlgOwner)
        {
            hRunDlg = ::GetLastActivePopup(m_RunFileDlgOwner);
            if (hRunDlg != NULL &&
                hRunDlg != m_RunFileDlgOwner)
            {
                SetForegroundWindow(hRunDlg);
                return;
            }
        }
 
        CloseHandle(CreateThread(NULL, 0, s_RunFileDlgThread, this, 0, NULL));
    }

Referenced by HandleCommand(), and HandleHotKey().

◆ DoExitWindows()

LRESULT CTrayWindow::DoExitWindows ( )

inline

Definition at line 460 of file traywnd.cpp.

    {
        SaveState();
 
        /* Display the ReactOS Shutdown Dialog */
        ExitWindowsDialog(m_hWnd);
 
        /*
         * If the user presses CTRL+ALT+SHIFT while exiting
         * the shutdown dialog, exit the shell cleanly.
         */
        if ((GetKeyState(VK_CONTROL) & 0x8000) &&
            (GetKeyState(VK_SHIFT)   & 0x8000) &&
            (GetKeyState(VK_MENU)    & 0x8000))
        {
            PostMessage(WM_QUIT, 0, 0);
        }
        return 0;
    }

Referenced by HandleCommand(), OnDoExitWindows(), and OnSysCommand().

◆ DrawShowDesktopButton()

void CTrayWindow::DrawShowDesktopButton ( )

inline

Definition at line 2504 of file traywnd.cpp.

    {
        if (!m_pShowDesktopButton || !m_pShowDesktopButton->IsWindow())
            return;
        ::RedrawWindow(m_TrayNotify, NULL, NULL, RDW_INVALIDATE | RDW_ERASENOW | RDW_UPDATENOW);
    }

Referenced by OnNcActivate(), and OnNcPaint().

◆ DrawSizerWithTheme()

int CTrayWindow::DrawSizerWithTheme ( IN HRGN hRgn )

inline

Definition at line 2077 of file traywnd.cpp.

    {
        HDC hdc;
        RECT rect;
        int iSizerPart[4] = {TBP_SIZINGBARLEFT, TBP_SIZINGBARTOP, TBP_SIZINGBARRIGHT, TBP_SIZINGBARBOTTOM};
        SIZE size;
 
        ASSERT(m_Position <= ABE_BOTTOM);
 
        HRESULT hr = GetThemePartSize(m_Theme, NULL, iSizerPart[m_Position], 0, NULL, TS_TRUE, &size);
        if (FAILED_UNEXPECTEDLY(hr))
            return 0;
 
        GetWindowRect(&rect);
        OffsetRect(&rect, -rect.left, -rect.top);
 
        hdc = GetWindowDC();
 
        switch (m_Position)
        {
        case ABE_LEFT:
            rect.left = rect.right - size.cx;
            break;
        case ABE_TOP:
            rect.top = rect.bottom - size.cy;
            break;
        case ABE_RIGHT:
            rect.right = rect.left + size.cx;
            break;
        case ABE_BOTTOM:
        default:
            rect.bottom = rect.top + size.cy;
            break;
        }
 
        DrawThemeBackground(m_Theme, hdc, iSizerPart[m_Position], 0, &rect, 0);
 
        ReleaseDC(hdc);
        return 0;
    }

Referenced by OnNcPaint().

◆ EraseBackgroundWithTheme()

LRESULT CTrayWindow::EraseBackgroundWithTheme ( HDC hdc )

inline

Definition at line 2061 of file traywnd.cpp.

    {
        RECT rect;
        int iSBkgndPart[4] = {TBP_BACKGROUNDLEFT, TBP_BACKGROUNDTOP, TBP_BACKGROUNDRIGHT, TBP_BACKGROUNDBOTTOM};
 
        ASSERT(m_Position <= ABE_BOTTOM);
 
        if (m_Theme)
        {
            GetClientRect(&rect);
            DrawThemeBackground(m_Theme, hdc, iSBkgndPart[m_Position], 0, &rect, 0);
        }
 
        return 0;
    }

Referenced by OnEraseBackground().

◆ ExecContextMenuCmd()

BOOL STDMETHODCALLTYPE CTrayWindow::ExecContextMenuCmd ( IN UINT uiCmd )

inline

Definition at line 634 of file traywnd.cpp.

    {
        switch (uiCmd)
        {
        case ID_SHELL_CMD_PROPERTIES:
            DisplayProperties();
            break;
 
        case ID_SHELL_CMD_OPEN_ALL_USERS:
            OpenCommonStartMenuDirectory(m_hWnd,
                                         TEXT("open"));
            break;
 
        case ID_SHELL_CMD_EXPLORE_ALL_USERS:
            OpenCommonStartMenuDirectory(m_hWnd,
                                         TEXT("explore"));
            break;
 
        case ID_LOCKTASKBAR:
            HandleCommand(TRAYCMD_LOCK_TASKBAR);
            break;
 
        case ID_SHELL_CMD_OPEN_TASKMGR:
            OpenTaskManager(m_hWnd);
            break;
 
        case ID_SHELL_CMD_UNDO_ACTION:
            RestoreWindowPos();
            break;
 
        case ID_SHELL_CMD_SHOW_DESKTOP:
            ShowDesktop();
            break;
 
        case ID_SHELL_CMD_TILE_WND_H:
            OnAppBarNotifyAll(NULL, NULL, ABN_WINDOWARRANGE, TRUE);
            if (g_Arrangement == NONE)
            {
                BackupWindowPos();
            }
            TileWindows(NULL, MDITILE_HORIZONTAL, NULL, 0, NULL);
            OnAppBarNotifyAll(NULL, NULL, ABN_WINDOWARRANGE, FALSE);
            g_Arrangement = TILED;
            break;
 
        case ID_SHELL_CMD_TILE_WND_V:
            OnAppBarNotifyAll(NULL, NULL, ABN_WINDOWARRANGE, TRUE);
            if (g_Arrangement == NONE)
            {
                BackupWindowPos();
            }
            TileWindows(NULL, MDITILE_VERTICAL, NULL, 0, NULL);
            OnAppBarNotifyAll(NULL, NULL, ABN_WINDOWARRANGE, FALSE);
            g_Arrangement = TILED;
            break;
 
        case ID_SHELL_CMD_CASCADE_WND:
            OnAppBarNotifyAll(NULL, NULL, ABN_WINDOWARRANGE, TRUE);
            if (g_Arrangement == NONE)
            {
                BackupWindowPos();
            }
            CascadeWindows(NULL, MDITILE_SKIPDISABLED, NULL, 0, NULL);
            OnAppBarNotifyAll(NULL, NULL, ABN_WINDOWARRANGE, FALSE);
            g_Arrangement = CASCADED;
            break;
 
        case ID_SHELL_CMD_CUST_NOTIF:
            ShowCustomizeNotifyIcons(hExplorerInstance, m_hWnd);
            break;
 
        case ID_SHELL_CMD_ADJUST_DAT:
            //FIXME: Use SHRunControlPanel
            ShellExecuteW(m_hWnd, NULL, L"timedate.cpl", NULL, NULL, SW_NORMAL);
            break;
 
        case ID_SHELL_CMD_RESTORE_ALL:
            RestoreAll();
            break;
 
        default:
            TRACE("ITrayWindow::ExecContextMenuCmd(%u): Unhandled Command ID!\n", uiCmd);
            return FALSE;
        }
 
        return TRUE;
    }

◆ ExecResourceCmd()

HRESULT CTrayWindow::ExecResourceCmd ( int id )

inline

Definition at line 425 of file traywnd.cpp.

    {
        WCHAR szCommand[256];
        WCHAR *pszParameters;
 
        if (!LoadStringW(hExplorerInstance,
                         id,
                         szCommand,
                         _countof(szCommand)))
        {
            return E_FAIL;
        }
 
        pszParameters = wcschr(szCommand, L'>');
        if (pszParameters)
        {
            *pszParameters = 0;
            pszParameters++;
        }
 
        ShellExecuteW(m_hWnd, NULL, szCommand, pszParameters, NULL, SW_SHOWNORMAL);
        return S_OK;
    }

Referenced by HandleCommand(), and HandleHotKey().

◆ FitToRebar()

void CTrayWindow::FitToRebar ( PRECT pRect )

inline

Definition at line 1816 of file traywnd.cpp.

    {
        /* Get the rect of the rebar */
        RECT rebarRect, taskbarRect, clientRect;
        ::GetWindowRect(m_Rebar, &rebarRect);
        ::GetWindowRect(m_hWnd, &taskbarRect);
        ::GetClientRect(m_hWnd, &clientRect);
        OffsetRect(&rebarRect, -taskbarRect.left, -taskbarRect.top);
 
        /* Calculate the difference of size of the taskbar and the rebar */
        SIZE margins;
        margins.cx = taskbarRect.right - taskbarRect.left - clientRect.right + clientRect.left;
        margins.cy = taskbarRect.bottom - taskbarRect.top - clientRect.bottom + clientRect.top;
 
        /* Calculate the new size of the rebar and make it resize, then change the new taskbar size */
        switch (m_Position)
        {
        case ABE_TOP:
            rebarRect.bottom = rebarRect.top + pRect->bottom - pRect->top - margins.cy;
            ::SendMessageW(m_Rebar, RB_SIZETORECT, RBSTR_CHANGERECT,  (LPARAM)&rebarRect);
            pRect->bottom = pRect->top + rebarRect.bottom - rebarRect.top + margins.cy;
            break;
        case ABE_BOTTOM:
            rebarRect.top = rebarRect.bottom - (pRect->bottom - pRect->top - margins.cy);
            ::SendMessageW(m_Rebar, RB_SIZETORECT, RBSTR_CHANGERECT,  (LPARAM)&rebarRect);
            pRect->top = pRect->bottom - (rebarRect.bottom - rebarRect.top + margins.cy);
            break;
        case ABE_LEFT:
            rebarRect.right = rebarRect.left + (pRect->right - pRect->left - margins.cx);
            ::SendMessageW(m_Rebar, RB_SIZETORECT, RBSTR_CHANGERECT,  (LPARAM)&rebarRect);
            pRect->right = pRect->left + (rebarRect.right - rebarRect.left + margins.cx);
            break;
        case ABE_RIGHT:
            rebarRect.left = rebarRect.right - (pRect->right - pRect->left - margins.cx);
            ::SendMessageW(m_Rebar, RB_SIZETORECT, RBSTR_CHANGERECT,  (LPARAM)&rebarRect);
            pRect->left = pRect->right - (rebarRect.right - rebarRect.left + margins.cx);
            break;
        }
 
        CalculateValidSize(m_Position, pRect);
    }

Referenced by CheckTrayWndPosition(), OnExitSizeMove(), and OnSizing().

◆ GetCommandString()

HRESULT STDMETHODCALLTYPE CTrayWindow::GetCommandString	(	UINT_PTR	idCmd,
		UINT	uType,
		UINT *	pwReserved,
		LPSTR	pszName,
		UINT	cchMax
	)

inline

Implements IContextMenu.

Definition at line 2281 of file traywnd.cpp.

    {
        if (!m_ContextMenu)
            return E_INVALIDARG;
 
        return m_ContextMenu->GetCommandString(idCmd, uType, pwReserved, pszName, cchMax);
    }

◆ GetDesktopWnd()

HWND CTrayWindow::GetDesktopWnd ( ) const

inlineoverrideprotectedvirtual

Implements CAppBarManager.

Definition at line 3559 of file traywnd.cpp.

3559{ return m_DesktopWnd; }

◆ GetDraggingRectFromPt()

DWORD CTrayWindow::GetDraggingRectFromPt	(	IN POINT	pt,
		OUT RECT *	pRect,
		OUT HMONITOR *	phMonitor
	)

inline

Definition at line 1270 of file traywnd.cpp.

    {
        HMONITOR hMon, hMonNew;
        DWORD PosH, PosV, Pos;
        SIZE DeltaPt, ScreenOffset;
        RECT rcScreen;
 
        rcScreen.left = 0;
        rcScreen.top = 0;
 
        /* Determine the screen rectangle */
        hMon = MonitorFromPoint(pt, MONITOR_DEFAULTTONULL);
        if (hMon != NULL)
        {
            MONITORINFO mi;
 
            mi.cbSize = sizeof(mi);
            if (!GetMonitorInfo(hMon, &mi))
            {
                hMon = NULL;
                goto GetPrimaryScreenRect;
            }
 
            /* make left top corner of the screen zero based to
               make calculations easier */
            pt.x -= mi.rcMonitor.left;
            pt.y -= mi.rcMonitor.top;
 
            ScreenOffset.cx = mi.rcMonitor.left;
            ScreenOffset.cy = mi.rcMonitor.top;
            rcScreen.right = mi.rcMonitor.right - mi.rcMonitor.left;
            rcScreen.bottom = mi.rcMonitor.bottom - mi.rcMonitor.top;
        }
        else
        {
GetPrimaryScreenRect:
            ScreenOffset.cx = 0;
            ScreenOffset.cy = 0;
            rcScreen.right = GetSystemMetrics(SM_CXSCREEN);
            rcScreen.bottom = GetSystemMetrics(SM_CYSCREEN);
        }
 
        /* Calculate the nearest screen border */
        if (pt.x < rcScreen.right / 2)
        {
            DeltaPt.cx = pt.x;
            PosH = ABE_LEFT;
        }
        else
        {
            DeltaPt.cx = rcScreen.right - pt.x;
            PosH = ABE_RIGHT;
        }
 
        if (pt.y < rcScreen.bottom / 2)
        {
            DeltaPt.cy = pt.y;
            PosV = ABE_TOP;
        }
        else
        {
            DeltaPt.cy = rcScreen.bottom - pt.y;
            PosV = ABE_BOTTOM;
        }
 
        Pos = (DeltaPt.cx * rcScreen.bottom < DeltaPt.cy * rcScreen.right) ? PosH : PosV;
 
        /* Fix the screen origin to be relative to the primary monitor again */
        OffsetRect(&rcScreen,
                   ScreenOffset.cx,
                   ScreenOffset.cy);
 
        RECT rcPos = m_TrayRects[Pos];
 
        hMonNew = GetMonitorFromRect(&rcPos);
        if (hMon != hMonNew)
        {
            SIZE szTray;
 
            /* Recalculate the rectangle, we're dragging to another monitor.
               We don't need to recalculate the rect on single monitor systems. */
            szTray.cx = rcPos.right - rcPos.left;
            szTray.cy = rcPos.bottom - rcPos.top;
 
            GetTrayRectFromScreenRect(Pos, &rcScreen, &szTray, pRect);
            hMon = hMonNew;
        }
        else
        {
            /* The user is dragging the tray window on the same monitor. We don't need
               to recalculate the rectangle */
            *pRect = rcPos;
        }
 
        *phMonitor = hMon;
 
        return Pos;
    }

Referenced by GetDraggingRectFromRect(), and OnMoving().

◆ GetDraggingRectFromRect()

DWORD CTrayWindow::GetDraggingRectFromRect	(	IN OUT RECT *	pRect,
		OUT HMONITOR *	phMonitor
	)

inline

Definition at line 1372 of file traywnd.cpp.

    {
        POINT pt;
 
        /* Calculate the center of the rectangle. We call
           GetDraggingRectFromPt to calculate a valid
           dragging rectangle */
        pt.x = pRect->left + ((pRect->right - pRect->left) / 2);
        pt.y = pRect->top + ((pRect->bottom - pRect->top) / 2);
 
        return GetDraggingRectFromPt(
            pt,
            pRect,
            phMonitor);
    }

Referenced by ChangingWinPos().

◆ GetHWND()

HWND STDMETHODCALLTYPE CTrayWindow::GetHWND ( )

inline

Definition at line 2171 of file traywnd.cpp.

    {
        return m_hWnd;
    }

◆ GetMonitor()

HMONITOR & CTrayWindow::GetMonitor ( )

inlineoverrideprotectedvirtual

Implements CAppBarManager.

Definition at line 3554 of file traywnd.cpp.

3554{ return m_Monitor; }

◆ GetMonitorFromRect()

HMONITOR CTrayWindow::GetMonitorFromRect ( IN const RECT * pRect )

inline

Definition at line 1070 of file traywnd.cpp.

    {
        HMONITOR hMon;
 
        /* In case the monitor sizes or saved sizes differ a bit (probably
           not a lot, only so the tray window overlaps into another monitor
           now), minimize the risk that we determine a wrong monitor by
           using the center point of the tray window if we can't determine
           it using the rectangle. */
        hMon = MonitorFromRect(pRect, MONITOR_DEFAULTTONULL);
        if (hMon == NULL)
        {
            POINT pt;
 
            pt.x = pRect->left + ((pRect->right - pRect->left) / 2);
            pt.y = pRect->top + ((pRect->bottom - pRect->top) / 2);
 
            /* be less error-prone, find the nearest monitor */
            hMon = MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST);
        }
 
        return hMon;
    }

Referenced by GetDraggingRectFromPt(), GetScreenRect(), and RegLoadSettings().

◆ GetPosition()

INT CTrayWindow::GetPosition ( ) const

inlineoverrideprotectedvirtual

Implements CAppBarManager.

Definition at line 3556 of file traywnd.cpp.

3556{ return m_Position; }

◆ GetPreviousMonitor()

HMONITOR & CTrayWindow::GetPreviousMonitor ( )

inlineoverrideprotectedvirtual

Implements CAppBarManager.

Definition at line 3555 of file traywnd.cpp.

3555{ return m_PreviousMonitor; }

◆ GetScreenRect()

HMONITOR CTrayWindow::GetScreenRect	(	IN HMONITOR	hMonitor,
		IN OUT RECT *	pRect
	)

inline

Definition at line 1095 of file traywnd.cpp.

    {
        HMONITOR hMon = NULL;
 
        if (hMonitor != NULL)
        {
            MONITORINFO mi;
 
            mi.cbSize = sizeof(mi);
            if (!GetMonitorInfo(hMonitor, &mi))
            {
                /* Hm, the monitor is gone? Try to find a monitor where it
                   could be located now */
                hMon = GetMonitorFromRect(pRect);
                if (hMon == NULL ||
                    !GetMonitorInfo(hMon, &mi))
                {
                    hMon = NULL;
                    goto GetPrimaryRect;
                }
            }
 
            *pRect = mi.rcMonitor;
        }
        else
        {
GetPrimaryRect:
            pRect->left = 0;
            pRect->top = 0;
            pRect->right = GetSystemMetrics(SM_CXSCREEN);
            pRect->bottom = GetSystemMetrics(SM_CYSCREEN);
        }
 
        return hMon;
    }

Referenced by ApplyClipping(), and ResizeWorkArea().

◆ GetScreenRectFromRect()

HMONITOR CTrayWindow::GetScreenRectFromRect	(	IN OUT RECT *	pRect,
		IN DWORD	dwFlags
	)

inline

Definition at line 1043 of file traywnd.cpp.

    {
        MONITORINFO mi;
        HMONITOR hMon;
 
        mi.cbSize = sizeof(mi);
        hMon = MonitorFromRect(pRect, dwFlags);
        if (hMon != NULL &&
            GetMonitorInfo(hMon, &mi))
        {
            *pRect = mi.rcMonitor;
        }
        else
        {
            pRect->left = 0;
            pRect->top = 0;
            pRect->right = GetSystemMetrics(SM_CXSCREEN);
            pRect->bottom = GetSystemMetrics(SM_CYSCREEN);
 
            hMon = NULL;
        }
 
        return hMon;
    }

Referenced by CalculateValidSize(), and RegLoadSettings().

◆ GetState()

CTrayWindow::GetState ( )

inlineoverride

Definition at line 3473 of file traywnd.cpp.

    {
        /* FIXME: Return ABS_ flags? */
        TRACE("IShellDesktopTray::GetState() unimplemented!\n");
        return 0;
    }

◆ GetTrayRect()

const RECT * CTrayWindow::GetTrayRect ( )

inlineoverrideprotectedvirtual

Implements CAppBarManager.

Definition at line 3557 of file traywnd.cpp.

3557{ return &m_TrayRects[m_Position]; }

◆ GetTrayRectFromScreenRect()

VOID CTrayWindow::GetTrayRectFromScreenRect	(	IN DWORD	Position,
		IN const RECT *	pScreen,
		IN const SIZE *pTraySize	OPTIONAL,
		OUT RECT *	pRect
	)

inline

Definition at line 1187 of file traywnd.cpp.

    {
        if (pTraySize == NULL)
            pTraySize = &m_TraySize;
 
        *pRect = *pScreen;
 
        if(!m_Theme)
        {
            /* Move the border outside of the screen */
            InflateRect(pRect,
                        GetSystemMetrics(SM_CXEDGE),
                        GetSystemMetrics(SM_CYEDGE));
        }
 
        MakeTrayRectWithSize(Position, pTraySize, pRect);
    }

Referenced by CalculateValidSize(), GetDraggingRectFromPt(), and RegLoadSettings().

◆ GetTrayWindow()

STDMETHODIMP CTrayWindow::GetTrayWindow ( OUT HWND * phWndTray )

inlineoverride

Definition at line 3481 of file traywnd.cpp.

    {
        TRACE("IShellDesktopTray::GetTrayWindow(0x%p)\n", phWndTray);
        *phWndTray = m_hWnd;
        return S_OK;
    }

◆ GetTrayWnd()

HWND CTrayWindow::GetTrayWnd ( ) const

inlineoverrideprotectedvirtual

Implements CAppBarManager.

Definition at line 3558 of file traywnd.cpp.

3558{ return m_hWnd; }

◆ GetWindow()

STDMETHODIMP CTrayWindow::GetWindow ( HWND * phwnd )

inlineoverride

Implements IOleWindow.

Definition at line 3513 of file traywnd.cpp.

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

Referenced by AlignControls(), IsTaskWnd(), and MinimizeWindowsProc().

◆ HandleCommand()

LRESULT CTrayWindow::HandleCommand ( UINT uCommand )

inline

Definition at line 773 of file traywnd.cpp.

    {
        switch (uCommand)
        {
            case TRAYCMD_STARTMENU:
                // TODO:
                break;
            case TRAYCMD_RUN_DIALOG:
                HideStartMenu();
                DisplayRunFileDlg();
                break;
            case TRAYCMD_LOGOFF_DIALOG:
                SaveState();
                LogoffWindowsDialog(m_hWnd); // FIXME: Maybe handle it in a similar way as DoExitWindows?
                break;
            case TRAYCMD_CASCADE:
                CascadeWindows(NULL, MDITILE_SKIPDISABLED, NULL, 0, NULL);
                break;
            case TRAYCMD_TILE_H:
                TileWindows(NULL, MDITILE_HORIZONTAL, NULL, 0, NULL);
                break;
            case TRAYCMD_TILE_V:
                TileWindows(NULL, MDITILE_VERTICAL, NULL, 0, NULL);
                break;
            case TRAYCMD_TOGGLE_DESKTOP:
                ToggleDesktop();
                break;
            case TRAYCMD_DATE_AND_TIME:
                ShellExecuteW(m_hWnd, NULL, L"timedate.cpl", NULL, NULL, SW_NORMAL);
                break;
            case TRAYCMD_TASKBAR_PROPERTIES:
                DisplayProperties();
                break;
            case TRAYCMD_MINIMIZE_ALL:
                MinimizeAll();
                break;
            case TRAYCMD_RESTORE_ALL:
                RestoreAll();
                break;
            case TRAYCMD_SHOW_DESKTOP:
                ShowDesktop();
                break;
            case TRAYCMD_SHOW_TASK_MGR:
                OpenTaskManager(m_hWnd);
                break;
            case TRAYCMD_CUSTOMIZE_TASKBAR:
                break;
            case TRAYCMD_LOCK_TASKBAR:
                if (SHRestricted(REST_CLASSICSHELL) == 0)
                {
                    Lock(!g_TaskbarSettings.bLock);
                    g_TaskbarSettings.Save();
                }
                break;
            case TRAYCMD_HELP_AND_SUPPORT:
                ExecResourceCmd(IDS_HELP_COMMAND);
                break;
            case TRAYCMD_CONTROL_PANEL:
                // TODO:
                break;
            case TRAYCMD_SHUTDOWN_DIALOG:
                DoExitWindows();
                break;
            case TRAYCMD_PRINTERS_AND_FAXES:
                // TODO:
                break;
            case TRAYCMD_LOCK_DESKTOP:
                // TODO:
                break;
            case TRAYCMD_SWITCH_USER_DIALOG:
                // TODO:
                break;
            case IDM_SEARCH:
            case TRAYCMD_SEARCH_FILES:
                SHFindFiles(NULL, NULL);
                break;
            case TRAYCMD_SEARCH_COMPUTERS:
                SHFindComputer(NULL, NULL);
                break;
 
            default:
                break;
        }
 
        return FALSE;
    }

Referenced by ExecContextMenuCmd(), and OnCommand().

◆ HandleHotKey()

LRESULT CTrayWindow::HandleHotKey ( DWORD id )

inline

Definition at line 727 of file traywnd.cpp.

    {
        switch (id)
        {
        case IDHK_RUN:
            HideStartMenu();
            DisplayRunFileDlg();
            break;
        case IDHK_HELP:
            ExecResourceCmd(IDS_HELP_COMMAND);
            break;
        case IDHK_EXPLORE:
            //FIXME: We don't support this yet:
            //ShellExecuteW(0, L"explore", NULL, NULL, NULL, 1);
            ShellExecuteW(0, NULL, L"explorer.exe", L"/e ,", NULL, 1);
            break;
        case IDHK_FIND:
            SHFindFiles(NULL, NULL);
            break;
        case IDHK_FIND_COMPUTER:
            SHFindComputer(NULL, NULL);
            break;
        case IDHK_SYS_PROPERTIES:
            //FIXME: Use SHRunControlPanel
            ShellExecuteW(m_hWnd, NULL, L"sysdm.cpl", NULL, NULL, SW_NORMAL);
            break;
        case IDHK_NEXT_TASK:
            break;
        case IDHK_PREV_TASK:
            break;
        case IDHK_MINIMIZE_ALL:
            MinimizeAll();
            break;
        case IDHK_RESTORE_ALL:
            RestoreAll();
            break;
        case IDHK_DESKTOP:
            ToggleDesktop();
            break;
        case IDHK_PAGER:
            break;
        }
 
        return 0;
    }

Referenced by OnHotkey().

◆ HideStartMenu()

VOID CTrayWindow::HideStartMenu ( )

inline

Definition at line 722 of file traywnd.cpp.

    {
        m_StartMenuPopup->OnSelect(MPOS_CANCELLEVEL);
    }

Referenced by HandleCommand(), HandleHotKey(), OnOpenStartMenu(), and OnSettingChanged().

◆ if()

CTrayWindow::if ( m_StartMenuBand ! = NULL )

inline

Definition at line 3350 of file traywnd.cpp.

        {
            MSG Msg;
            LRESULT lRet;
 
            Msg.hwnd = m_hWnd;
            Msg.message = uMsg;
            Msg.wParam = wParam;
            Msg.lParam = lParam;
 
            if (m_StartMenuBand->TranslateMenuMessage(&Msg, &lRet) == S_OK)
            {
                return lRet;
            }
 
            wParam = Msg.wParam;
            lParam = Msg.lParam;
        }

◆ InvokeCommand()

HRESULT STDMETHODCALLTYPE CTrayWindow::InvokeCommand ( LPCMINVOKECOMMANDINFO lpici )

inline

Implements IContextMenu.

Definition at line 2273 of file traywnd.cpp.

    {
        if (!m_ContextMenu)
            return E_INVALIDARG;
 
        return m_ContextMenu->InvokeCommand(lpici);
    }

◆ IsAlwaysOnTop()

BOOL CTrayWindow::IsAlwaysOnTop ( ) const

inlineoverrideprotectedvirtual

Implements CAppBarManager.

Definition at line 3553 of file traywnd.cpp.

3553{ return g_TaskbarSettings.sr.AlwaysOnTop; }

_TW_STUCKRECTS2::AlwaysOnTop

DWORD AlwaysOnTop

Definition: precomp.h:208

◆ IsAutoHideState()

BOOL CTrayWindow::IsAutoHideState ( ) const

inlineoverrideprotectedvirtual

Implements CAppBarManager.

Definition at line 3551 of file traywnd.cpp.

3551{ return g_TaskbarSettings.sr.AutoHide; }

_TW_STUCKRECTS2::AutoHide

DWORD AutoHide

Definition: precomp.h:207

Referenced by ChangingWinPos(), OnCreate(), OnMouseMove(), and ResizeWorkArea().

◆ IsDialog()

static BOOL CTrayWindow::IsDialog ( HWND hwnd )

inlinestatic

Definition at line 3058 of file traywnd.cpp.

    {
        WCHAR szClass[32];
        GetClassNameW(hwnd, szClass, _countof(szClass));
        return wcscmp(szClass, L"#32770") == 0;
    }

Referenced by MinimizeWindowsProc().

◆ IsHidingState()

BOOL CTrayWindow::IsHidingState ( ) const

inlineoverrideprotectedvirtual

Implements CAppBarManager.

Definition at line 3552 of file traywnd.cpp.

3552{ return m_AutoHideState == AUTOHIDE_HIDING; }

AUTOHIDE_HIDING

#define AUTOHIDE_HIDING

Definition: traywnd.cpp:30

◆ IsHorizontal()

BOOL STDMETHODCALLTYPE CTrayWindow::IsHorizontal ( )

inline

Definition at line 2182 of file traywnd.cpp.

    {
        return IsPosHorizontal();
    }

◆ IsPointWithinShowDesktopButton()

BOOL CTrayWindow::IsPointWithinShowDesktopButton	(	LPPOINT	ppt,
		LPRECT	prcShowDesktopBtn,
		PWINDOWINFO	pwi
	)

inline

Definition at line 2794 of file traywnd.cpp.

    {
        if (!ppt || !prcShowDesktopBtn)
            return FALSE;
        UNREFERENCED_PARAMETER(pwi);
 
        switch (m_Position)
        {
            case ABE_LEFT:
                return !(ppt->x > prcShowDesktopBtn->right || ppt->y < prcShowDesktopBtn->top);
            case ABE_TOP:
                return !(ppt->x < prcShowDesktopBtn->left || ppt->y > prcShowDesktopBtn->bottom);
            case ABE_RIGHT:
                return !(ppt->x < prcShowDesktopBtn->left || ppt->y < prcShowDesktopBtn->top);
            case ABE_BOTTOM:
                return !(ppt->x < prcShowDesktopBtn->left || ppt->y < prcShowDesktopBtn->top);
        }
        return FALSE;
    }

◆ IsPointWithinStartButton()

BOOL CTrayWindow::IsPointWithinStartButton	(	LPPOINT	ppt,
		LPRECT	prcStartBtn,
		PWINDOWINFO	pwi
	)

inline

Definition at line 2751 of file traywnd.cpp.

    {
        if (!ppt || !prcStartBtn || !pwi)
            return FALSE;
 
        switch (m_Position)
        {
            case ABE_TOP:
            case ABE_LEFT:
            {
                if (ppt->x > prcStartBtn->right || ppt->y > prcStartBtn->bottom)
                    return FALSE;
                break;
            }
            case ABE_RIGHT:
            {
                if (ppt->x < prcStartBtn->left || ppt->y > prcStartBtn->bottom)
                    return FALSE;
 
                if (prcStartBtn->right + (int)pwi->cxWindowBorders * 2 + 1 < pwi->rcWindow.right &&
                    ppt->x > prcStartBtn->right)
                {
                    return FALSE;
                }
                break;
            }
            case ABE_BOTTOM:
            {
                if (ppt->x > prcStartBtn->right || ppt->y < prcStartBtn->top)
                    return FALSE;
 
                if (prcStartBtn->bottom + (int)pwi->cyWindowBorders * 2 + 1 < pwi->rcWindow.bottom &&
                    ppt->y > prcStartBtn->bottom)
                {
                    return FALSE;
                }
 
                break;
            }
        }
        return TRUE;
    }

Referenced by OnNcLButtonDown().

◆ IsPosHorizontal()

BOOL CTrayWindow::IsPosHorizontal ( )

inline

Definition at line 1208 of file traywnd.cpp.

    {
        return m_Position == ABE_TOP || m_Position == ABE_BOTTOM;
    }

Referenced by AlignControls(), and IsHorizontal().

◆ IsSpecialHWND()

BOOL STDMETHODCALLTYPE CTrayWindow::IsSpecialHWND ( IN HWND hWnd )

inline

Definition at line 2176 of file traywnd.cpp.

    {
        return (m_hWnd == hWnd ||
                (m_DesktopWnd != NULL && m_hWnd == m_DesktopWnd));
    }

Referenced by IsTaskWnd().

◆ IsTaskWnd()

BOOL STDMETHODCALLTYPE CTrayWindow::IsTaskWnd ( HWND hWnd )

inline

Definition at line 2240 of file traywnd.cpp.

    {
        if (::IsWindow(hWnd) && ::IsWindowVisible(hWnd) && !IsSpecialHWND(hWnd))
        {
            DWORD exStyle = (DWORD)::GetWindowLongPtr(hWnd, GWL_EXSTYLE);
            if (((exStyle & WS_EX_APPWINDOW) || ::GetWindow(hWnd, GW_OWNER) == NULL) &&
                !(exStyle & WS_EX_TOOLWINDOW))
            {
                return TRUE;
            }
        }
        return FALSE;
    }

◆ Lock()

BOOL STDMETHODCALLTYPE CTrayWindow::Lock ( IN BOOL bLock )

inline

Definition at line 2187 of file traywnd.cpp.

    {
        BOOL bPrevLock = g_TaskbarSettings.bLock;
 
        if (g_TaskbarSettings.bLock != bLock)
        {
            g_TaskbarSettings.bLock = bLock;
 
            if (m_TrayBandSite != NULL)
            {
                if (!SUCCEEDED(m_TrayBandSite->Lock(bLock)))
                {
                    /* Reset?? */
                    g_TaskbarSettings.bLock = bPrevLock;
                    return bPrevLock;
                }
            }
 
            if (m_Theme)
            {
                /* Update cached tray sizes */
                for(DWORD Pos = ABE_LEFT; Pos <= ABE_BOTTOM; Pos++)
                {
                    RECT rcGripper = {0};
                    AdjustSizerRect(&rcGripper, Pos);
 
                    if(g_TaskbarSettings.bLock)
                    {
                        m_TrayRects[Pos].top += rcGripper.top;
                        m_TrayRects[Pos].left += rcGripper.left;
                        m_TrayRects[Pos].bottom += rcGripper.bottom;
                        m_TrayRects[Pos].right += rcGripper.right;
                    }
                    else
                    {
                        m_TrayRects[Pos].top -= rcGripper.top;
                        m_TrayRects[Pos].left -= rcGripper.left;
                        m_TrayRects[Pos].bottom -= rcGripper.bottom;
                        m_TrayRects[Pos].right -= rcGripper.right;
                    }
                }
            }
            SetWindowPos(NULL, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOOWNERZORDER);
            ResizeWorkArea();
            ApplyClipping(TRUE);
        }
 
        return bPrevLock;
    }

◆ MakeTrayRectWithSize()

VOID CTrayWindow::MakeTrayRectWithSize	(	IN DWORD	Position,
		IN const SIZE *	pTraySize,
		IN OUT RECT *	pRect
	)

inline

Definition at line 1162 of file traywnd.cpp.

    {
        switch (Position)
        {
        case ABE_LEFT:
            pRect->right = pRect->left + pTraySize->cx;
            break;
 
        case ABE_TOP:
            pRect->bottom = pRect->top + pTraySize->cy;
            break;
 
        case ABE_RIGHT:
            pRect->left = pRect->right - pTraySize->cx;
            break;
 
        case ABE_BOTTOM:
        default:
            pRect->top = pRect->bottom - pTraySize->cy;
            break;
        }
    }

Referenced by ChangingWinPos(), and GetTrayRectFromScreenRect().

◆ MinimizeAll()

VOID CTrayWindow::MinimizeAll ( BOOL bShowDesktop = FALSE )

inline

Definition at line 3093 of file traywnd.cpp.

    {
        MINIMIZE_INFO info;
        info.hwndDesktop = GetDesktopWindow();;
        info.hTrayWnd = FindWindowW(L"Shell_TrayWnd", NULL);
        info.hwndProgman = FindWindowW(L"Progman", NULL);
        info.pMinimizedAll = &g_MinimizedAll;
        info.bShowDesktop = bShowDesktop;
        EnumWindows(MinimizeWindowsProc, (LPARAM)&info);
 
        ::SetForegroundWindow(m_DesktopWnd);
        ::SetFocus(m_DesktopWnd);
    }

Referenced by HandleCommand(), HandleHotKey(), and ShowDesktop().

◆ MinimizeWindowsProc()

static BOOL CALLBACK CTrayWindow::MinimizeWindowsProc	(	HWND	hwnd,
		LPARAM	lParam
	)

inlinestatic

Definition at line 3065 of file traywnd.cpp.

    {
        MINIMIZE_INFO *info = (MINIMIZE_INFO *)lParam;
        if (hwnd == info->hwndDesktop || hwnd == info->hTrayWnd || hwnd == info->hwndProgman)
            return TRUE; // Ignore special windows
 
        if (!info->bShowDesktop)
        {
            if (!::IsWindowEnabled(hwnd) || IsDialog(hwnd))
                return TRUE;
            HWND hwndOwner = ::GetWindow(hwnd, GW_OWNER);
            if (hwndOwner && !::IsWindowEnabled(hwndOwner))
                return TRUE;
        }
 
        if (CanBeMinimized(hwnd))
        {
            MINWNDPOS mwp = { hwnd, { sizeof(mwp.wndpl) } };
            if (::GetWindowPlacement(hwnd, &mwp.wndpl) && // Save the position and status
                ::ShowWindowAsync(hwnd, SW_SHOWMINNOACTIVE)) // Minimize
            {
                info->pMinimizedAll->Add(mwp);
            }
        }
 
        return TRUE;
    }

Referenced by MinimizeAll().

◆ NotifyFullScreenToAppBars()

STDMETHODIMP CTrayWindow::NotifyFullScreenToAppBars	(	HMONITOR	hMonitor,
		BOOL	bFullOpening
	)

inlineoverride

Definition at line 3038 of file traywnd.cpp.

    {
        OnAppBarNotifyAll(hMonitor, NULL, ABN_FULLSCREENAPP, bFullOpening);
        return S_OK;
    }

◆ OnActivate()

LRESULT CTrayWindow::OnActivate	(	INT	code,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 3244 of file traywnd.cpp.

    {
        OnAppBarActivationChange2(m_hWnd, m_Position);
        if (!wParam) // !(Activate || Minimized)
        {
            SendMessage(WM_CHANGEUISTATE, MAKELONG(UIS_SET, UISF_HIDEACCEL | UISF_HIDEFOCUS), 0);
            IUnknown_UIActivateIO(m_TrayBandSite, FALSE, NULL);
        }
        return 0;
    }

◆ OnAppTrayDestroy()

LRESULT CTrayWindow::OnAppTrayDestroy	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2983 of file traywnd.cpp.

    {
        DestroyWindow();
        return TRUE;
    }

◆ OnCommand()

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

inline

Definition at line 3124 of file traywnd.cpp.

    {
        LRESULT Ret = FALSE;
 
        if ((HWND) lParam == m_StartButton.m_hWnd)
        {
            return FALSE;
        }
 
        if (m_TrayBandSite == NULL || FAILED_UNEXPECTEDLY(m_TrayBandSite->ProcessMessage(m_hWnd, uMsg, wParam, lParam, &Ret)))
        {
            return HandleCommand(LOWORD(wParam));
        }
        return Ret;
    }

◆ OnContextMenu()

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

inline

Definition at line 2852 of file traywnd.cpp.

    {
        LRESULT Ret = FALSE;
        POINT pt, *ppt = NULL;
        HWND hWndExclude = NULL;
 
        /* Check if the administrator has forbidden access to context menus */
        if (SHRestricted(REST_NOTRAYCONTEXTMENU))
            return FALSE;
 
        pt.x = (SHORT) LOWORD(lParam);
        pt.y = (SHORT) HIWORD(lParam);
 
        if (pt.x != -1 || pt.y != -1)
            ppt = &pt;
        else
            hWndExclude = m_StartButton.m_hWnd;
 
        if ((HWND) wParam == m_StartButton.m_hWnd)
        {
            /* Make sure we can't track the context menu if the start
            menu is currently being shown */
            if (!(m_StartButton.SendMessage(BM_GETSTATE, 0, 0) & BST_PUSHED))
            {
                CComPtr<IContextMenu> ctxMenu;
                CStartMenuBtnCtxMenu_CreateInstance(this, m_hWnd, &ctxMenu);
                TrackCtxMenu(ctxMenu, ppt, hWndExclude, m_Position == ABE_BOTTOM, this);
            }
        }
        else
        {
            /* See if the context menu should be handled by the task band site */
            if (ppt != NULL && m_TrayBandSite != NULL)
            {
                HWND hWndAtPt;
                POINT ptClient = *ppt;
 
                /* Convert the coordinates to client-coordinates */
                ::MapWindowPoints(NULL, m_hWnd, &ptClient, 1);
 
                hWndAtPt = ChildWindowFromPoint(ptClient);
                if (hWndAtPt != NULL &&
                    (hWndAtPt == m_Rebar || ::IsChild(m_Rebar, hWndAtPt)))
                {
                    /* Check if the user clicked on the task switch window */
                    ptClient = *ppt;
                    ::MapWindowPoints(NULL, m_Rebar, &ptClient, 1);
 
                    hWndAtPt = ::ChildWindowFromPointEx(m_Rebar, ptClient, CWP_SKIPINVISIBLE | CWP_SKIPDISABLED);
                    if (hWndAtPt == m_TaskSwitch)
                        goto HandleTrayContextMenu;
 
                    /* Forward the message to the task band site */
                    m_TrayBandSite->ProcessMessage(m_hWnd, uMsg, wParam, lParam, &Ret);
                }
                else
                    goto HandleTrayContextMenu;
            }
            else
            {
HandleTrayContextMenu:
                /* Tray the default tray window context menu */
                TrackCtxMenu(this, ppt, NULL, FALSE, this);
            }
        }
        return Ret;
    }

Referenced by OnNcRButtonUp().

◆ OnCopyData()

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

inline

Definition at line 2486 of file traywnd.cpp.

    {
        PCOPYDATASTRUCT pCopyData = (PCOPYDATASTRUCT)lParam;
        if (!pCopyData)
            return FALSE;
 
        switch (pCopyData->dwData)
        {
            case TABDMC_APPBAR:
                return OnAppBarMessage(pCopyData);
            case TABDMC_NOTIFY:
            case TABDMC_LOADINPROC:
                return ::SendMessageW(m_TrayNotify, uMsg, wParam, lParam);
        }
        return FALSE;
    }

◆ OnCreate()

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

inline

Definition at line 2297 of file traywnd.cpp.

    {
        HRESULT hRet;
 
        ((ITrayWindow*)this)->AddRef();
 
        SetWindowTheme(m_hWnd, L"TaskBar", NULL);
 
        /* Create the Start button */
        m_StartButton.Create(m_hWnd);
 
        /* Load the saved tray window settings */
        RegLoadSettings();
 
        /* Create and initialize the start menu */
        HBITMAP hbmBanner = LoadBitmapW(hExplorerInstance, MAKEINTRESOURCEW(IDB_STARTMENU));
        m_StartMenuPopup = CreateStartMenu(this, &m_StartMenuBand, hbmBanner,
                                           g_TaskbarSettings.sr.SmSmallIcons);
 
        /* Create the task band */
        hRet = CTaskBand_CreateInstance(this, m_StartButton.m_hWnd, IID_PPV_ARG(IDeskBand, &m_TaskBand));
        if (FAILED_UNEXPECTEDLY(hRet))
            return FALSE;
 
        /* Create the rebar band site. This actually creates the rebar and the tasks toolbar. */
        hRet = CTrayBandSite_CreateInstance(this, m_TaskBand, &m_TrayBandSite);
        if (FAILED_UNEXPECTEDLY(hRet))
            return FALSE;
 
        /* Create the tray notification window */
        hRet = CTrayNotifyWnd_CreateInstance(m_hWnd, IID_PPV_ARG(IUnknown, &m_TrayNotifyInstance));
        if (FAILED_UNEXPECTEDLY(hRet))
            return FALSE;
 
        /* Get the hwnd of the rebar */
        hRet = IUnknown_GetWindow(m_TrayBandSite, &m_Rebar);
        if (FAILED_UNEXPECTEDLY(hRet))
            return FALSE;
 
        /* Get the hwnd of the tasks toolbar */
        hRet = IUnknown_GetWindow(m_TaskBand, &m_TaskSwitch);
        if (FAILED_UNEXPECTEDLY(hRet))
            return FALSE;
 
        /* Get the hwnd of the tray notification window */
        hRet = IUnknown_GetWindow(m_TrayNotifyInstance, &m_TrayNotify);
        if (FAILED_UNEXPECTEDLY(hRet))
            return FALSE;
 
        ::SendMessage(m_TrayNotify, TNWM_GETSHOWDESKTOPBUTTON, (WPARAM)&m_pShowDesktopButton, 0);
        if (!m_pShowDesktopButton)
            return FALSE;
 
        SetWindowTheme(m_Rebar, L"TaskBar", NULL);
 
        UpdateFonts();
 
        InitShellServices(&m_ShellServices);
 
        if (IsAutoHideState())
        {
            m_AutoHideState = AUTOHIDE_HIDING;
            SetTimer(TIMER_ID_AUTOHIDE, AUTOHIDE_DELAY_HIDE, NULL);
        }
 
        /* Set the initial lock state in the band site */
        m_TrayBandSite->Lock(g_TaskbarSettings.bLock);
 
        static const UINT winkeys[] =
        {
            MAKELONG(IDHK_RUN,            MAKEWORD('R', MOD_WIN)),
            MAKELONG(IDHK_MINIMIZE_ALL,   MAKEWORD('M', MOD_WIN)),
            MAKELONG(IDHK_RESTORE_ALL,    MAKEWORD('M', MOD_WIN|MOD_SHIFT)),
            MAKELONG(IDHK_HELP,           MAKEWORD(VK_F1, MOD_WIN)),
            MAKELONG(IDHK_EXPLORE,        MAKEWORD('E', MOD_WIN)),
            MAKELONG(IDHK_FIND,           MAKEWORD('F', MOD_WIN)),
            MAKELONG(IDHK_FIND_COMPUTER,  MAKEWORD('F', MOD_WIN|MOD_CONTROL)),
            MAKELONG(IDHK_NEXT_TASK,      MAKEWORD(VK_TAB, MOD_WIN)),
            MAKELONG(IDHK_PREV_TASK,      MAKEWORD(VK_TAB, MOD_WIN|MOD_SHIFT)),
            MAKELONG(IDHK_SYS_PROPERTIES, MAKEWORD(VK_PAUSE, MOD_WIN)),
            MAKELONG(IDHK_DESKTOP,        MAKEWORD('D', MOD_WIN)),
            MAKELONG(IDHK_PAGER,          MAKEWORD('B', MOD_WIN)),
        };
        if (!SHRestricted(REST_NOWINKEYS))
        {
            for (UINT i = 0; i < _countof(winkeys); ++i)
            {
                UINT mod = HIBYTE(HIWORD(winkeys[i])), key = LOBYTE(HIWORD(winkeys[i]));
                RegisterHotKey(m_hWnd, LOWORD(winkeys[i]), mod, key);
            }
        }
 
        return TRUE;
    }

◆ OnCtlColorBtn()

LRESULT CTrayWindow::OnCtlColorBtn	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2527 of file traywnd.cpp.

    {
        SetBkMode((HDC) wParam, TRANSPARENT);
        return (LRESULT) GetStockObject(HOLLOW_BRUSH);
    }

◆ OnDestroy()

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

inline

Definition at line 2392 of file traywnd.cpp.

    {
        return 0;
    }

◆ OnDisplayChange()

LRESULT CTrayWindow::OnDisplayChange	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2472 of file traywnd.cpp.

    {
        /* Refresh workareas */
        RecomputeAllWorkareas();
 
        /* Load the saved tray window settings */
        RegLoadSettings();
 
        /* Move the tray window to the right position and resize it if necessary */
        CheckTrayWndPosition();
 
        return TRUE;
    }

◆ OnDoExitWindows()

LRESULT CTrayWindow::OnDoExitWindows	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 3004 of file traywnd.cpp.

    {
        /*
         * TWM_DOEXITWINDOWS is send by the CDesktopBrowser to us
         * to show the shutdown dialog. Also a WM_CLOSE message sent
         * by apps should show the dialog.
         */
        return DoExitWindows();
    }

◆ OnEndSession()

LRESULT CTrayWindow::OnEndSession	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2397 of file traywnd.cpp.

    {
        if (wParam)
            SaveState();
        return 0;
    }

◆ OnEnterSizeMove()

LRESULT CTrayWindow::OnEnterSizeMove	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2662 of file traywnd.cpp.

    {
        InSizeMove = TRUE;
        IsDragging = FALSE;
        if (!g_TaskbarSettings.bLock)
        {
            /* Remove the clipping on multi monitor systems while dragging around */
            ApplyClipping(FALSE);
        }
        m_PreviousMonitor = m_Monitor;
        return TRUE;
    }

◆ OnEraseBackground()

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

inline

Definition at line 2459 of file traywnd.cpp.

    {
        HDC hdc = (HDC) wParam;
 
        if (!m_Theme)
        {
            bHandled = FALSE;
            return 0;
        }
 
        return EraseBackgroundWithTheme(hdc);
    }

◆ OnExitSizeMove()

LRESULT CTrayWindow::OnExitSizeMove	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2675 of file traywnd.cpp.

    {
        InSizeMove = FALSE;
        if (!g_TaskbarSettings.bLock)
        {
            FitToRebar(&m_TrayRects[m_Position]);
 
            /* Apply clipping */
            PostMessage(WM_SIZE, SIZE_RESTORED, 0);
        }
        return TRUE;
    }

◆ OnGetMinMaxInfo()

LRESULT CTrayWindow::OnGetMinMaxInfo	(	INT	code,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 3263 of file traywnd.cpp.

    {
        PMINMAXINFO pInfo = (PMINMAXINFO)lParam;
        SIZE StartSize = m_StartButton.GetSize();
        pInfo->ptMinTrackSize.x = StartSize.cx + 2 * GetSystemMetrics(SM_CXFRAME);
        pInfo->ptMinTrackSize.y = StartSize.cy + 2 * GetSystemMetrics(SM_CYFRAME);
        return 0;
    }

◆ OnGetTaskSwitch()

LRESULT CTrayWindow::OnGetTaskSwitch	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 3025 of file traywnd.cpp.

    {
        bHandled = TRUE;
        return (LRESULT)m_TaskSwitch;
    }

◆ OnHotkey()

LRESULT CTrayWindow::OnHotkey	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 3044 of file traywnd.cpp.

    {
        return HandleHotKey(wParam);
    }

◆ OnInitMenuPopup()

LRESULT CTrayWindow::OnInitMenuPopup	(	INT	code,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 3207 of file traywnd.cpp.

    {
        HMENU hMenu = (HMENU)wParam;
        if (::IsThereAnyEffectiveWindow(FALSE))
        {
            ::EnableMenuItem(hMenu, ID_SHELL_CMD_CASCADE_WND, MF_BYCOMMAND | MF_ENABLED);
            ::EnableMenuItem(hMenu, ID_SHELL_CMD_TILE_WND_H, MF_BYCOMMAND | MF_ENABLED);
            ::EnableMenuItem(hMenu, ID_SHELL_CMD_TILE_WND_V, MF_BYCOMMAND | MF_ENABLED);
            if (g_Arrangement != NONE)
            {
                CStringW strCaption((g_Arrangement == TILED) ? MAKEINTRESOURCEW(IDS_TRAYWND_UNDO_TILE)
                                                             : MAKEINTRESOURCEW(IDS_TRAYWND_UNDO_CASCADE));
                MENUITEMINFOW mii = { sizeof(mii) };
                ::GetMenuItemInfoW(hMenu, ID_SHELL_CMD_UNDO_ACTION, FALSE, &mii);
                mii.fMask = MIIM_TYPE;
                mii.fType = MFT_STRING;
                mii.dwTypeData = const_cast<LPWSTR>(&strCaption[0]);
                ::SetMenuItemInfoW(hMenu, ID_SHELL_CMD_UNDO_ACTION, FALSE, &mii);
            }
            else
            {
                ::DeleteMenu(hMenu, ID_SHELL_CMD_UNDO_ACTION, MF_BYCOMMAND);
            }
        }
        else
        {
            ::EnableMenuItem(hMenu, ID_SHELL_CMD_CASCADE_WND, MF_BYCOMMAND | MF_GRAYED);
            ::EnableMenuItem(hMenu, ID_SHELL_CMD_TILE_WND_H, MF_BYCOMMAND | MF_GRAYED);
            ::EnableMenuItem(hMenu, ID_SHELL_CMD_TILE_WND_V, MF_BYCOMMAND | MF_GRAYED);
            ::DeleteMenu(hMenu, ID_SHELL_CMD_UNDO_ACTION, MF_BYCOMMAND);
            g_Arrangement = NONE;
            g_WindowPosBackup.RemoveAll();
        }
        return 0;
    }

◆ OnLButtonUp()

LRESULT CTrayWindow::OnLButtonUp	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2976 of file traywnd.cpp.

    {
        if (m_pShowDesktopButton)
            m_pShowDesktopButton->OnLButtonUp(uMsg, wParam, lParam, bHandled);
        return FALSE;
    }

◆ OnMouseMove()

LRESULT CTrayWindow::OnMouseMove	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 3140 of file traywnd.cpp.

    {
        SendMessage(m_TrayNotify, uMsg, wParam, lParam);
 
        if (IsAutoHideState())
        {
            SetTimer(TIMER_ID_MOUSETRACK, MOUSETRACK_INTERVAL, NULL);
        }
 
        return TRUE;
    }

◆ OnMoving()

LRESULT CTrayWindow::OnMoving	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2593 of file traywnd.cpp.

    {
        POINT ptCursor;
        PRECT pRect = (PRECT) lParam;
 
        /* We need to ensure that an application can not accidently
        move the tray window (using SetWindowPos). However, we still
        need to be able to move the window in case the user wants to
        drag the tray window to another position or in case the user
        wants to resize the tray window. */
        if (!g_TaskbarSettings.bLock && GetCursorPos(&ptCursor))
        {
            IsDragging = TRUE;
            m_DraggingPosition = GetDraggingRectFromPt(ptCursor, pRect, &m_DraggingMonitor);
        }
        else
        {
            *pRect = m_TrayRects[m_Position];
        }
        return TRUE;
    }

◆ OnNcActivate()

LRESULT CTrayWindow::OnNcActivate	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 3170 of file traywnd.cpp.

    {
        LRESULT ret = DefWindowProc(uMsg, wParam, lParam);
        DrawShowDesktopButton(); // We have to draw non-client area
        bHandled = TRUE;
        return ret;
    }

◆ OnNcCalcSize()

LRESULT CTrayWindow::OnNcCalcSize	(	INT	code,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 3178 of file traywnd.cpp.

    {
        RECT *rc = NULL;
        /* Ignore WM_NCCALCSIZE if we are not themed or locked */
        if(!m_Theme || g_TaskbarSettings.bLock)
        {
            bHandled = FALSE;
            return 0;
        }
        if(!wParam)
        {
            rc = (RECT*)wParam;
        }
        else
        {
            NCCALCSIZE_PARAMS *prms = (NCCALCSIZE_PARAMS*)lParam;
            if(prms->lppos->flags & SWP_NOSENDCHANGING)
            {
                bHandled = FALSE;
                return 0;
            }
            rc = &prms->rgrc[0];
        }
 
        AdjustSizerRect(rc, m_Position);
 
        return 0;
    }

◆ OnNcHitTest()

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

inline

Definition at line 2538 of file traywnd.cpp.

    {
        RECT rcClient;
        POINT pt;
 
        if (g_TaskbarSettings.bLock)
        {
            /* The user may not be able to resize the tray window.
            Pretend like the window is not sizeable when the user
            clicks on the border. */
            return HTBORDER;
        }
 
        SetLastError(ERROR_SUCCESS);
        if (GetClientRect(&rcClient) &&
            (MapWindowPoints(NULL, (LPPOINT) &rcClient, 2) != 0 || GetLastError() == ERROR_SUCCESS))
        {
            pt.x = GET_X_LPARAM(lParam);
            pt.y = GET_Y_LPARAM(lParam);
 
            if (m_pShowDesktopButton && ::IsWindow(m_pShowDesktopButton->m_hWnd) && m_pShowDesktopButton->PtInButton(&pt))
                return HTBORDER;
 
            if (PtInRect(&rcClient, pt))
            {
                /* The user is trying to drag the tray window */
                return HTCAPTION;
            }
 
            /* Depending on the position of the tray window, allow only
            changing the border next to the monitor working area */
            switch (m_Position)
            {
            case ABE_TOP:
                if (pt.y > rcClient.bottom)
                    return HTBOTTOM;
                break;
            case ABE_LEFT:
                if (pt.x > rcClient.right)
                    return HTRIGHT;
                break;
            case ABE_RIGHT:
                if (pt.x < rcClient.left)
                    return HTLEFT;
                break;
            case ABE_BOTTOM:
            default:
                if (pt.y < rcClient.top)
                    return HTTOP;
                break;
            }
        }
        return HTBORDER;
    }

◆ OnNcLButtonDblClick()

LRESULT CTrayWindow::OnNcLButtonDblClick	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2954 of file traywnd.cpp.

    {
        /* Let the clock handle the double-click */
        ::SendMessageW(m_TrayNotify, uMsg, wParam, lParam);
 
        /* We "handle" this message so users can't cause a weird maximize/restore
        window animation when double-clicking the tray window! */
        return TRUE;
    }

◆ OnNcLButtonDown()

LRESULT CTrayWindow::OnNcLButtonDown	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

This handler implements the trick that makes the start button to get pressed when the user clicked left or below the button.

Definition at line 2818 of file traywnd.cpp.

    {
        POINT pt = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
        WINDOWINFO wi = {sizeof(WINDOWINFO)};
 
        bHandled = FALSE;
 
        RECT rcStartBtn;
        m_StartButton.GetWindowRect(&rcStartBtn);
        GetWindowInfo(m_hWnd, &wi);
 
        if (IsPointWithinStartButton(&pt, &rcStartBtn, &wi))
        {
            bHandled = TRUE;
            PopupStartMenu();
            return 0;
        }
 
        if (m_pShowDesktopButton && m_pShowDesktopButton->PtInButton(&pt))
            m_pShowDesktopButton->OnLButtonDown(WM_LBUTTONDOWN, 0, 0, bHandled);
 
        return 0;
    }

◆ OnNcLButtonUp()

LRESULT CTrayWindow::OnNcLButtonUp	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2964 of file traywnd.cpp.

    {
        if (m_pShowDesktopButton && m_pShowDesktopButton->m_bPressed) // Did you click the button?
        {
            m_pShowDesktopButton->Click();
            m_pShowDesktopButton->OnLButtonUp(WM_LBUTTONUP, 0, 0, bHandled);
            bHandled = TRUE;
        }
 
        return FALSE;
    }

◆ OnNcPaint()

LRESULT CTrayWindow::OnNcPaint	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2511 of file traywnd.cpp.

    {
        DefWindowProc(uMsg, wParam, lParam);
        bHandled = TRUE;
 
        if (!m_Theme || g_TaskbarSettings.bLock)
        {
            DrawShowDesktopButton(); // We have to draw non-client area
            return 0;
        }
 
        DrawSizerWithTheme((HRGN) wParam);
        DrawShowDesktopButton(); // We have to draw non-client area
        return 0;
    }

◆ OnNcRButtonUp()

LRESULT CTrayWindow::OnNcRButtonUp	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2842 of file traywnd.cpp.

    {
        /* We want the user to be able to get a context menu even on the nonclient
        area (including the sizing border)! */
        uMsg = WM_CONTEXTMENU;
        wParam = (WPARAM) m_hWnd;
 
        return OnContextMenu(uMsg, wParam, lParam, bHandled);
    }

◆ OnNotify()

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

inline

Definition at line 2920 of file traywnd.cpp.

    {
        LRESULT Ret = FALSE;
        /* FIXME: We can't check with IsChild whether the hwnd is somewhere inside
        the rebar control! But we shouldn't forward messages that the band
        site doesn't handle, such as other controls (start button, tray window) */
 
        HRESULT hr = E_FAIL;
 
        if (m_TrayBandSite)
        {
            hr = m_TrayBandSite->ProcessMessage(m_hWnd, uMsg, wParam, lParam, &Ret);
            if (SUCCEEDED(hr))
                return Ret;
        }
 
        if (m_TrayBandSite == NULL || FAILED(hr))
        {
            const NMHDR *nmh = (const NMHDR *) lParam;
 
            if (nmh->hwndFrom == m_TrayNotify)
            {
                switch (nmh->code)
                {
                case NTNWM_REALIGN:
                    /* Cause all controls to be aligned */
                    PostMessage(WM_SIZE, SIZE_RESTORED, 0);
                    break;
                }
            }
        }
        return Ret;
    }

◆ OnOpenStartMenu()

LRESULT CTrayWindow::OnOpenStartMenu	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2989 of file traywnd.cpp.

    {
        HWND hwndStartMenu;
        HRESULT hr = IUnknown_GetWindow(m_StartMenuPopup, &hwndStartMenu);
        if (FAILED_UNEXPECTEDLY(hr))
            return FALSE;
 
        if (::IsWindowVisible(hwndStartMenu))
            HideStartMenu();
        else
            PopupStartMenu();
 
        return TRUE;
    }

◆ OnRebarAutoSize()

LRESULT CTrayWindow::OnRebarAutoSize	(	INT	code,
		LPNMHDR	nmhdr,
		BOOL &	bHandled
	)

inline

Definition at line 3272 of file traywnd.cpp.

    {
#if 0
        LPNMRBAUTOSIZE as = (LPNMRBAUTOSIZE) nmhdr;
 
        if (!as->fChanged)
            return 0;
 
        RECT rc;
        ::GetWindowRect(m_hWnd, &rc);
 
        SIZE szWindow = {
            rc.right - rc.left,
            rc.bottom - rc.top };
        SIZE szTarget = {
            as->rcTarget.right - as->rcTarget.left,
            as->rcTarget.bottom - as->rcTarget.top };
        SIZE szActual = {
            as->rcActual.right - as->rcActual.left,
            as->rcActual.bottom - as->rcActual.top };
 
        SIZE borders = {
            szWindow.cx - szTarget.cx,
            szWindow.cy - szTarget.cx,
        };
 
        switch (m_Position)
        {
        case ABE_LEFT:
            szWindow.cx = szActual.cx + borders.cx;
            break;
        case ABE_TOP:
            szWindow.cy = szActual.cy + borders.cy;
            break;
        case ABE_RIGHT:
            szWindow.cx = szActual.cx + borders.cx;
            rc.left = rc.right - szWindow.cy;
            break;
        case ABE_BOTTOM:
            szWindow.cy = szActual.cy + borders.cy;
            rc.top = rc.bottom - szWindow.cy;
            break;
        }
 
        SetWindowPos(NULL, rc.left, rc.top, szWindow.cx, szWindow.cy, SWP_NOACTIVATE | SWP_NOZORDER);
#else
        bHandled = FALSE;
#endif
        return 0;
    }

◆ OnSetFocus()

LRESULT CTrayWindow::OnSetFocus	(	INT	code,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 3256 of file traywnd.cpp.

    {
        IUnknown_UIActivateIO(m_TrayBandSite, TRUE, NULL);
        return 0;
    }

◆ OnSettingChanged()

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

inline

Definition at line 2424 of file traywnd.cpp.

    {
        if (wParam == SPI_SETNONCLIENTMETRICS)
        {
            SendMessage(m_TrayNotify, uMsg, wParam, lParam);
            SendMessage(m_TaskSwitch, uMsg, wParam, lParam);
            UpdateFonts();
            AlignControls(NULL);
            CheckTrayWndPosition();
        }
 
        // Note: We rely on CDesktopBrowser to get this message and call SHSettingsChanged
        if (m_DesktopWnd)
            ::SendMessageW(m_DesktopWnd, uMsg, wParam, lParam);
 
        if (m_StartMenuPopup && lstrcmpiW((LPCWSTR)lParam, L"TraySettings") == 0)
        {
            HideStartMenu();
 
            HBITMAP hbmBanner = LoadBitmapW(hExplorerInstance, MAKEINTRESOURCEW(IDB_STARTMENU));
#if 1 // FIXME: Please re-use the start menu
            /* Re-create the start menu */
            m_StartMenuBand.Release();
            m_StartMenuPopup = CreateStartMenu(this, &m_StartMenuBand, hbmBanner,
                                               g_TaskbarSettings.sr.SmSmallIcons);
            FIXME("Use UpdateStartMenu\n");
#else
            // Update the start menu
            UpdateStartMenu(m_StartMenuPopup, hbmBanner, g_TaskbarSettings.sr.SmSmallIcons, TRUE);
#endif
        }
 
        return 0;
    }

◆ OnSetZOrder()

LRESULT CTrayWindow::OnSetZOrder	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 3032 of file traywnd.cpp.

    {
        return ::SetWindowPos(m_hWnd, (HWND)wParam, 0, 0, 0, 0,
                              SWP_NOOWNERZORDER | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
    }

◆ OnSize()

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

inline

Definition at line 2636 of file traywnd.cpp.

    {
        RECT rcClient;
        if (wParam == SIZE_RESTORED && lParam == 0)
        {
            ResizeWorkArea();
            /* Clip the tray window on multi monitor systems so the edges can't
            overlap into another monitor */
            ApplyClipping(TRUE);
 
            if (!GetClientRect(&rcClient))
            {
                return FALSE;
            }
        }
        else
        {
            rcClient.left = rcClient.top = 0;
            rcClient.right = LOWORD(lParam);
            rcClient.bottom = HIWORD(lParam);
        }
 
        AlignControls(&rcClient);
        return TRUE;
    }

◆ OnSizing()

LRESULT CTrayWindow::OnSizing	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2615 of file traywnd.cpp.

    {
        PRECT pRect = (PRECT) lParam;
 
        if (!g_TaskbarSettings.bLock)
        {
            FitToRebar(pRect);
        }
        else
        {
            *pRect = m_TrayRects[m_Position];
        }
        return TRUE;
    }

◆ OnSysChar()

LRESULT CTrayWindow::OnSysChar	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2688 of file traywnd.cpp.

    {
        switch (wParam)
        {
        case TEXT(' '):
        {
            /* The user pressed Alt+Space, this usually brings up the system menu of a window.
            The tray window needs to handle this specially, since it normally doesn't have
            a system menu. */
 
            static const UINT uidDisableItem [] = {
                SC_RESTORE,
                SC_MOVE,
                SC_SIZE,
                SC_MAXIMIZE,
                SC_MINIMIZE,
            };
            HMENU hSysMenu;
            UINT i, uId;
 
            /* temporarily enable the system menu */
            SetWindowStyle(m_hWnd, WS_SYSMENU, WS_SYSMENU);
 
            hSysMenu = GetSystemMenu(FALSE);
            if (hSysMenu != NULL)
            {
                /* Disable all items that are not relevant */
                for (i = 0; i < _countof(uidDisableItem); i++)
                {
                    EnableMenuItem(hSysMenu,
                                   uidDisableItem[i],
                                   MF_BYCOMMAND | MF_GRAYED);
                }
 
                EnableMenuItem(hSysMenu,
                               SC_CLOSE,
                               MF_BYCOMMAND |
                               (SHRestricted(REST_NOCLOSE) ? MF_GRAYED : MF_ENABLED));
 
                /* Display the system menu */
                uId = TrackMenu(
                    hSysMenu,
                    NULL,
                    m_StartButton.m_hWnd,
                    m_Position != ABE_TOP,
                    FALSE);
                if (uId != 0)
                {
                    SendMessage(m_hWnd, WM_SYSCOMMAND, (WPARAM) uId, 0);
                }
            }
 
            /* revert the system menu window style */
            SetWindowStyle(m_hWnd, WS_SYSMENU, 0);
            break;
        }
 
        default:
            bHandled = FALSE;
        }
        return TRUE;
    }

◆ OnSysColorChange()

LRESULT CTrayWindow::OnSysColorChange	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2533 of file traywnd.cpp.

    {
        return SendMessageW(m_Rebar, uMsg, wParam, lParam);
    }

◆ OnSysCommand()

LRESULT CTrayWindow::OnSysCommand	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 3014 of file traywnd.cpp.

    {
        if (wParam == SC_CLOSE)
        {
            return DoExitWindows();
        }
 
        bHandled = FALSE;
        return TRUE;
    }

◆ OnTaskbarSettingsChanged()

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

inline

Definition at line 3323 of file traywnd.cpp.

    {
        TaskbarSettings* newSettings = (TaskbarSettings*)lParam;
 
        /* Propagate the new settings to the children */
        ::SendMessageW(m_TaskSwitch, uMsg, wParam, lParam);
        ::SendMessageW(m_TrayNotify, uMsg, wParam, lParam);
 
        /* Toggle autohide */
        SetAutoHideState(newSettings->sr.AutoHide);
 
        /* Toggle lock state */
        Lock(newSettings->bLock);
 
        /* Toggle OnTop state */
        UpdateAlwaysOnTop(newSettings->sr.AlwaysOnTop);
 
        /* Adjust taskbar size */
        CheckTrayWndPosition();
 
        g_TaskbarSettings.Save();
        return 0;
    }

◆ OnThemeChanged()

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

inline

Definition at line 2404 of file traywnd.cpp.

    {
        if (m_Theme)
            CloseThemeData(m_Theme);
 
        m_Theme = OpenThemeData(m_hWnd, L"TaskBar");
 
        if (m_Theme)
        {
            SetWindowStyle(m_hWnd, WS_THICKFRAME | WS_BORDER, 0);
        }
        else
        {
            SetWindowStyle(m_hWnd, WS_THICKFRAME | WS_BORDER, WS_THICKFRAME | WS_BORDER);
        }
        SetWindowPos(NULL, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER);
 
        return TRUE;
    }

◆ OnTimer()

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

inline

Definition at line 3152 of file traywnd.cpp.

    {
        switch (wParam)
        {
            case TIMER_ID_MOUSETRACK:
                ProcessMouseTracking();
                break;
            case TIMER_ID_AUTOHIDE:
                ProcessAutoHide();
                break;
            default:
                WARN("Invalid timer ID: %u\n", (UINT)wParam);
                bHandled = FALSE;
                break;
        }
        return 0;
    }

◆ OnWindowPosChanging()

LRESULT CTrayWindow::OnWindowPosChanging	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL &	bHandled
	)

inline

Definition at line 2630 of file traywnd.cpp.

    {
        ChangingWinPos((LPWINDOWPOS) lParam);
        return TRUE;
    }

◆ Open()

HRESULT STDMETHODCALLTYPE CTrayWindow::Open ( )

inline

Definition at line 2121 of file traywnd.cpp.

    {
        RECT rcWnd;
 
        /* Check if there's already a window created and try to show it.
           If it was somehow destroyed just create a new tray window. */
        if (m_hWnd != NULL && IsWindow())
        {
            return S_OK;
        }
 
        DWORD dwExStyle = WS_EX_TOOLWINDOW | WS_EX_WINDOWEDGE;
        if (g_TaskbarSettings.sr.AlwaysOnTop)
            dwExStyle |= WS_EX_TOPMOST;
 
        DWORD dwStyle = WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
        if(!m_Theme)
        {
            dwStyle |= WS_THICKFRAME | WS_BORDER;
        }
 
        ZeroMemory(&rcWnd, sizeof(rcWnd));
        if (m_Position != (DWORD) -1)
            rcWnd = m_TrayRects[m_Position];
 
        if (!Create(NULL, rcWnd, NULL, dwStyle, dwExStyle))
            return E_FAIL;
 
        /* Align all controls on the tray window */
        AlignControls(NULL);
 
        /* Move the tray window to the right position and resize it if necessary */
        CheckTrayWndPosition();
 
        return S_OK;
    }

◆ OpenCommonStartMenuDirectory()

VOID CTrayWindow::OpenCommonStartMenuDirectory	(	IN HWND	hWndOwner,
		IN LPCTSTR	lpOperation
	)

inline

Definition at line 594 of file traywnd.cpp.

    {
        WCHAR szDir[MAX_PATH];
 
        if (SHGetSpecialFolderPath(hWndOwner,
            szDir,
            CSIDL_COMMON_STARTMENU,
            FALSE))
        {
            ShellExecute(hWndOwner,
                         lpOperation,
                         szDir,
                         NULL,
                         NULL,
                         SW_SHOWNORMAL);
        }
    }

Referenced by ExecContextMenuCmd().

◆ OpenTaskManager()

VOID CTrayWindow::OpenTaskManager ( IN HWND hWndOwner )

inline

Definition at line 612 of file traywnd.cpp.

    {
        ShellExecute(hWndOwner,
                     TEXT("open"),
                     TEXT("taskmgr.exe"),
                     NULL,
                     NULL,
                     SW_SHOWNORMAL);
    }

Referenced by ExecContextMenuCmd(), and HandleCommand().

◆ PopupStartMenu()

void CTrayWindow::PopupStartMenu ( )

inline

Definition at line 1858 of file traywnd.cpp.

    {
        if (m_StartMenuPopup != NULL)
        {
            POINTL pt;
            RECTL rcExclude;
            DWORD dwFlags = 0;
 
            if (m_StartButton.GetWindowRect((RECT*) &rcExclude))
            {
                switch (m_Position)
                {
                case ABE_BOTTOM:
                    pt.x = rcExclude.left;
                    pt.y = rcExclude.top;
                    dwFlags |= MPPF_TOP;
                    break;
                case ABE_TOP:
                    pt.x = rcExclude.left;
                    pt.y = rcExclude.bottom;
                    dwFlags |= MPPF_BOTTOM;
                    break;
                case ABE_LEFT:
                    pt.x = rcExclude.right;
                    pt.y = rcExclude.top;
                    dwFlags |= MPPF_RIGHT;
                    break;
                case ABE_RIGHT:
                    pt.x = rcExclude.left;
                    pt.y = rcExclude.top;
                    dwFlags |= MPPF_LEFT;
                    break;
                }
 
                m_StartMenuPopup->Popup(&pt, &rcExclude, dwFlags);
 
                m_StartButton.SendMessageW(BM_SETSTATE, TRUE, 0);
            }
        }
    }

Referenced by OnNcLButtonDown(), and OnOpenStartMenu().

◆ ProcessAutoHide()

void CTrayWindow::ProcessAutoHide ( )

inline

Definition at line 1946 of file traywnd.cpp.

    {
        INT w = m_TraySize.cx - GetSystemMetrics(SM_CXSIZEFRAME);
        INT h = m_TraySize.cy - GetSystemMetrics(SM_CYSIZEFRAME);
 
        switch (m_AutoHideState)
        {
        case AUTOHIDE_HIDING:
            switch (m_Position)
            {
            case ABE_LEFT:
                m_AutoHideOffset.cy = 0;
                m_AutoHideOffset.cx -= AUTOHIDE_SPEED_HIDE;
                if (m_AutoHideOffset.cx < -w)
                    m_AutoHideOffset.cx = w;
                break;
            case ABE_TOP:
                m_AutoHideOffset.cx = 0;
                m_AutoHideOffset.cy -= AUTOHIDE_SPEED_HIDE;
                if (m_AutoHideOffset.cy < -h)
                    m_AutoHideOffset.cy = h;
                break;
            case ABE_RIGHT:
                m_AutoHideOffset.cy = 0;
                m_AutoHideOffset.cx += AUTOHIDE_SPEED_HIDE;
                if (m_AutoHideOffset.cx > w)
                    m_AutoHideOffset.cx = w;
                break;
            case ABE_BOTTOM:
                m_AutoHideOffset.cx = 0;
                m_AutoHideOffset.cy += AUTOHIDE_SPEED_HIDE;
                if (m_AutoHideOffset.cy > h)
                    m_AutoHideOffset.cy = h;
                break;
            }
 
            if (m_AutoHideOffset.cx != w && m_AutoHideOffset.cy != h)
            {
                SetTimer(TIMER_ID_AUTOHIDE, AUTOHIDE_INTERVAL_ANIMATING, NULL);
                break;
            }
 
            /* fallthrough */
        case AUTOHIDE_HIDDEN:
            switch (m_Position)
            {
            case ABE_LEFT:
                m_AutoHideOffset.cx = -w;
                m_AutoHideOffset.cy = 0;
                break;
            case ABE_TOP:
                m_AutoHideOffset.cx = 0;
                m_AutoHideOffset.cy = -h;
                break;
            case ABE_RIGHT:
                m_AutoHideOffset.cx = w;
                m_AutoHideOffset.cy = 0;
                break;
            case ABE_BOTTOM:
                m_AutoHideOffset.cx = 0;
                m_AutoHideOffset.cy = h;
                break;
            }
 
            KillTimer(TIMER_ID_AUTOHIDE);
            m_AutoHideState = AUTOHIDE_HIDDEN;
            break;
 
        case AUTOHIDE_SHOWING:
            if (m_AutoHideOffset.cx >= AUTOHIDE_SPEED_SHOW)
            {
                m_AutoHideOffset.cx -= AUTOHIDE_SPEED_SHOW;
            }
            else if (m_AutoHideOffset.cx <= -AUTOHIDE_SPEED_SHOW)
            {
                m_AutoHideOffset.cx += AUTOHIDE_SPEED_SHOW;
            }
            else
            {
                m_AutoHideOffset.cx = 0;
            }
 
            if (m_AutoHideOffset.cy >= AUTOHIDE_SPEED_SHOW)
            {
                m_AutoHideOffset.cy -= AUTOHIDE_SPEED_SHOW;
            }
            else if (m_AutoHideOffset.cy <= -AUTOHIDE_SPEED_SHOW)
            {
                m_AutoHideOffset.cy += AUTOHIDE_SPEED_SHOW;
            }
            else
            {
                m_AutoHideOffset.cy = 0;
            }
 
            if (m_AutoHideOffset.cx != 0 || m_AutoHideOffset.cy != 0)
            {
                SetTimer(TIMER_ID_AUTOHIDE, AUTOHIDE_INTERVAL_ANIMATING, NULL);
                break;
            }
 
            /* fallthrough */
        case AUTOHIDE_SHOWN:
            KillTimer(TIMER_ID_AUTOHIDE);
            m_AutoHideState = AUTOHIDE_SHOWN;
            break;
        }
 
        SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOZORDER);
    }

Referenced by OnTimer().

◆ ProcessMouseTracking()

void CTrayWindow::ProcessMouseTracking ( )

inline

Definition at line 1899 of file traywnd.cpp.

    {
        POINT pt;
        GetCursorPos(&pt);
 
        RECT rcCurrent;
        GetWindowRect(&rcCurrent);
 
        BOOL over = PtInRect(&rcCurrent, pt);
        if (m_StartButton.SendMessage(BM_GETSTATE, 0, 0) != BST_UNCHECKED)
            over = TRUE;
 
        UINT state = m_AutoHideState;
        if (over)
        {
            if (state == AUTOHIDE_HIDING)
            {
                TRACE("AutoHide cancelling hide.\n");
                m_AutoHideState = AUTOHIDE_SHOWING;
                SetTimer(TIMER_ID_AUTOHIDE, AUTOHIDE_INTERVAL_ANIMATING, NULL);
            }
            else if (state == AUTOHIDE_HIDDEN)
            {
                TRACE("AutoHide starting show.\n");
                m_AutoHideState = AUTOHIDE_SHOWING;
                SetTimer(TIMER_ID_AUTOHIDE, AUTOHIDE_DELAY_SHOW, NULL);
            }
        }
        else
        {
            if (state == AUTOHIDE_SHOWING)
            {
                TRACE("AutoHide cancelling show.\n");
                m_AutoHideState = AUTOHIDE_HIDING;
                SetTimer(TIMER_ID_AUTOHIDE, AUTOHIDE_INTERVAL_ANIMATING, NULL);
            }
            else if (state == AUTOHIDE_SHOWN)
            {
                TRACE("AutoHide starting hide.\n");
                m_AutoHideState = AUTOHIDE_HIDING;
                SetTimer(TIMER_ID_AUTOHIDE, AUTOHIDE_DELAY_HIDE, NULL);
            }
 
            KillTimer(TIMER_ID_MOUSETRACK);
        }
    }

Referenced by OnTimer().

◆ QueryContextMenu()

HRESULT STDMETHODCALLTYPE CTrayWindow::QueryContextMenu	(	HMENU	hPopup,
		UINT	indexMenu,
		UINT	idCmdFirst,
		UINT	idCmdLast,
		UINT	uFlags
	)

inline

Implements IContextMenu.

Definition at line 2257 of file traywnd.cpp.

    {
        if (!m_ContextMenu)
        {
            HRESULT hr = TrayWindowCtxMenuCreator(this, m_hWnd, &m_ContextMenu);
            if (FAILED_UNEXPECTEDLY(hr))
                return hr;
        }
 
        return m_ContextMenu->QueryContextMenu(hPopup, indexMenu, idCmdFirst, idCmdLast, uFlags);
    }

◆ RaiseStartButton()

virtual HRESULT CTrayWindow::RaiseStartButton ( )

inlinevirtual

Definition at line 3504 of file traywnd.cpp.

    {
        m_StartButton.SendMessageW(BM_SETSTATE, FALSE, 0);
        return S_OK;
    }

Referenced by Tray_OnStartMenuDismissed().

◆ RegisterDesktopWindow()

STDMETHODIMP CTrayWindow::RegisterDesktopWindow ( IN HWND hWndDesktop )

inlineoverride

Definition at line 3489 of file traywnd.cpp.

    {
        TRACE("IShellDesktopTray::RegisterDesktopWindow(0x%p)\n", hWndDesktop);
 
        m_DesktopWnd = hWndDesktop;
        return S_OK;
    }

◆ RegLoadSettings()

VOID CTrayWindow::RegLoadSettings ( )

inline

Definition at line 1594 of file traywnd.cpp.

    {
        DWORD Pos;
        RECT rcScreen;
        SIZE WndSize, EdgeSize, DlgFrameSize;
        SIZE StartBtnSize = m_StartButton.GetSize();
 
        EdgeSize.cx = GetSystemMetrics(SM_CXEDGE);
        EdgeSize.cy = GetSystemMetrics(SM_CYEDGE);
        DlgFrameSize.cx = GetSystemMetrics(SM_CXDLGFRAME);
        DlgFrameSize.cy = GetSystemMetrics(SM_CYDLGFRAME);
 
        m_Position = g_TaskbarSettings.sr.Position;
        rcScreen = g_TaskbarSettings.sr.Rect;
        GetScreenRectFromRect(&rcScreen, MONITOR_DEFAULTTONEAREST);
 
        if (!g_TaskbarSettings.sr.Size.cx || !g_TaskbarSettings.sr.Size.cy)
        {
            /* Use the minimum size of the taskbar, we'll use the start
               button as a minimum for now. Make sure we calculate the
               entire window size, not just the client size. However, we
               use a thinner border than a standard thick border, so that
               the start button and bands are not stuck to the screen border. */
            if(!m_Theme)
            {
                g_TaskbarSettings.sr.Size.cx = StartBtnSize.cx + (2 * (EdgeSize.cx + DlgFrameSize.cx));
                g_TaskbarSettings.sr.Size.cy = StartBtnSize.cy + (2 * (EdgeSize.cy + DlgFrameSize.cy));
            }
            else
            {
                g_TaskbarSettings.sr.Size.cx = StartBtnSize.cx - EdgeSize.cx;
                g_TaskbarSettings.sr.Size.cy = StartBtnSize.cy - EdgeSize.cy;
                if(!g_TaskbarSettings.bLock)
                    g_TaskbarSettings.sr.Size.cy += GetSystemMetrics(SM_CYSIZEFRAME);
            }
        }
        /* Determine a minimum tray window rectangle. The "client" height is
           zero here since we cannot determine an optimal minimum width when
           loaded as a vertical tray window. We just need to make sure the values
           loaded from the registry are at least. The windows explorer behaves
           the same way, it allows the user to save a zero width vertical tray
           window, but not a zero height horizontal tray window. */
        if(!m_Theme)
        {
            WndSize.cx = 2 * (EdgeSize.cx + DlgFrameSize.cx);
            WndSize.cy = StartBtnSize.cy + (2 * (EdgeSize.cy + DlgFrameSize.cy));
        }
        else
        {
            WndSize.cx = StartBtnSize.cx;
            WndSize.cy = StartBtnSize.cy - EdgeSize.cy;
        }
 
        if (WndSize.cx < g_TaskbarSettings.sr.Size.cx)
            WndSize.cx = g_TaskbarSettings.sr.Size.cx;
        if (WndSize.cy < g_TaskbarSettings.sr.Size.cy)
            WndSize.cy = g_TaskbarSettings.sr.Size.cy;
 
        /* Save the calculated size */
        m_TraySize = WndSize;
 
        /* Calculate all docking rectangles. We need to do this here so they're
           initialized and dragging the tray window to another position gives
           usable results */
        for (Pos = ABE_LEFT; Pos <= ABE_BOTTOM; Pos++)
        {
            GetTrayRectFromScreenRect(Pos,
                                      &rcScreen,
                                      &m_TraySize,
                                      &m_TrayRects[Pos]);
            // TRACE("m_TrayRects[%d(%d)]: %d,%d,%d,%d\n", Pos, Position, m_TrayRects[Pos].left, m_TrayRects[Pos].top, m_TrayRects[Pos].right, m_TrayRects[Pos].bottom);
        }
 
        /* Determine which monitor we are on. It shouldn't matter which docked
           position rectangle we use */
        m_Monitor = GetMonitorFromRect(&m_TrayRects[ABE_LEFT]);
    }

Referenced by OnCreate(), and OnDisplayChange().

◆ ResizeWorkArea()

VOID CTrayWindow::ResizeWorkArea ( )

inline

Definition at line 1520 of file traywnd.cpp.

    {
#if !WIN7_DEBUG_MODE
        RECT rcTray, rcWorkArea;
 
        /* If monitor has changed then fix the previous monitors work area */
        if (m_PreviousMonitor != m_Monitor)
        {
            GetScreenRect(m_PreviousMonitor, &rcWorkArea);
            SystemParametersInfoW(SPI_SETWORKAREA,
                                  1,
                                  &rcWorkArea,
                                  SPIF_SENDCHANGE);
        }
 
        rcTray = m_TrayRects[m_Position];
 
        GetScreenRect(m_Monitor, &rcWorkArea);
        m_PreviousMonitor = m_Monitor;
 
        /* If AutoHide is false then change the workarea to exclude
           the area that the taskbar covers. */
        if (!IsAutoHideState())
        {
            switch (m_Position)
            {
            case ABE_TOP:
                rcWorkArea.top = rcTray.bottom;
                break;
            case ABE_LEFT:
                rcWorkArea.left = rcTray.right;
                break;
            case ABE_RIGHT:
                rcWorkArea.right = rcTray.left;
                break;
            case ABE_BOTTOM:
                rcWorkArea.bottom = rcTray.top;
                break;
            }
        }
 
        /*
         * Resize the current monitor work area. Win32k will also send
         * a WM_SIZE message to automatically resize the desktop.
         */
        SystemParametersInfoW(SPI_SETWORKAREA,
                              1,
                              &rcWorkArea,
                              SPIF_SENDCHANGE);
#endif
    }

Referenced by CheckTrayWndPosition(), Lock(), and OnSize().

◆ RestoreAll()

VOID CTrayWindow::RestoreAll ( )

inline

Definition at line 3112 of file traywnd.cpp.

    {
        for (INT i = g_MinimizedAll.GetSize() - 1; i >= 0; --i)
        {
            HWND hwnd = g_MinimizedAll[i].hwnd;
            if (::IsWindowVisible(hwnd) && ::IsIconic(hwnd))
                ::SetWindowPlacement(hwnd, &g_MinimizedAll[i].wndpl);
        }
 
        g_MinimizedAll.RemoveAll();
    }

Referenced by ExecContextMenuCmd(), HandleCommand(), HandleHotKey(), and ToggleDesktop().

◆ RunFileDlgThread()

DWORD WINAPI CTrayWindow::RunFileDlgThread ( )

inline

Definition at line 480 of file traywnd.cpp.

    {
        HWND hwnd;
        RECT posRect;
 
        m_StartButton.GetWindowRect(&posRect);
 
        hwnd = CreateWindowEx(0,
                              WC_STATIC,
                              NULL,
                              WS_OVERLAPPED | WS_DISABLED | WS_CLIPSIBLINGS | WS_BORDER | SS_LEFT,
                              posRect.left,
                              posRect.top,
                              posRect.right - posRect.left,
                              posRect.bottom - posRect.top,
                              NULL,
                              NULL,
                              NULL,
                              NULL);
 
        m_RunFileDlgOwner = hwnd;
 
        // build the default directory from two environment variables
        CStringW strDefaultDir, strHomePath;
        strDefaultDir.GetEnvironmentVariable(L"HOMEDRIVE");
        strHomePath.GetEnvironmentVariable(L"HOMEPATH");
        strDefaultDir += strHomePath;
 
        RunFileDlg(hwnd, NULL, (LPCWSTR)strDefaultDir, NULL, NULL, RFF_CALCDIRECTORY);
 
        m_RunFileDlgOwner = NULL;
        ::DestroyWindow(hwnd);
 
        return 0;
    }

◆ s_RunFileDlgThread()

static DWORD WINAPI CTrayWindow::s_RunFileDlgThread ( IN OUT PVOID pParam )

inlinestatic

Definition at line 516 of file traywnd.cpp.

    {
        CTrayWindow * This = (CTrayWindow*) pParam;
        return This->RunFileDlgThread();
    }

Referenced by DisplayRunFileDlg().

◆ s_TrayPropertiesThread()

static DWORD WINAPI CTrayWindow::s_TrayPropertiesThread ( IN OUT PVOID pParam )

inlinestatic

Definition at line 568 of file traywnd.cpp.

    {
        CTrayWindow *This = (CTrayWindow*) pParam;
 
        return This->TrayPropertiesThread();
    }

Referenced by DisplayProperties().

◆ SaveState()

void CTrayWindow::SaveState ( )

inline

Definition at line 449 of file traywnd.cpp.

    {
        if (SHRestricted(REST_NOSAVESET))
            return;
 
        SendMessage(m_DesktopWnd, WM_PROGMAN_SAVESTATE, 0, 0);
 
        if (SHRestricted(REST_CLEARRECENTDOCSONEXIT))
            ClearRecentAndMru();
    }

Referenced by DoExitWindows(), HandleCommand(), and OnEndSession().

◆ SetAutoHideState()

void CTrayWindow::SetAutoHideState ( _In_ BOOL bAutoHide )

inlineoverrideprotectedvirtual

Implements CAppBarManager.

Definition at line 3561 of file traywnd.cpp.

    {
        g_TaskbarSettings.sr.AutoHide = bAutoHide;
        ZeroMemory(&m_AutoHideOffset, sizeof(m_AutoHideOffset));
 
        m_AutoHideState = AUTOHIDE_SHOWN;
        if (bAutoHide)
            SetTimer(TIMER_ID_MOUSETRACK, MOUSETRACK_INTERVAL, NULL);
        else
            SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOZORDER);
    }

Referenced by OnTaskbarSettingsChanged().

◆ ShowDesktop()

VOID CTrayWindow::ShowDesktop ( )

inline

Definition at line 3107 of file traywnd.cpp.

    {
        MinimizeAll(TRUE);
    }

Referenced by ExecContextMenuCmd(), HandleCommand(), and ToggleDesktop().

◆ ToggleDesktop()

VOID CTrayWindow::ToggleDesktop ( )

inline

Definition at line 622 of file traywnd.cpp.

    {
        if (::IsThereAnyEffectiveWindow(TRUE))
        {
            ShowDesktop();
        }
        else
        {
            RestoreAll();
        }
    }

Referenced by HandleCommand(), and HandleHotKey().

◆ TrackCtxMenu()

HRESULT CTrayWindow::TrackCtxMenu	(	IN IContextMenu *	contextMenu,
		IN POINT *ppt	OPTIONAL,
		IN HWND hwndExclude	OPTIONAL,
		IN BOOL	TrackUp,
		IN PVOID Context	OPTIONAL
	)

inline

Definition at line 932 of file traywnd.cpp.

    {
        POINT pt;
        TPMPARAMS params;
        RECT rc;
        HRESULT hr;
        UINT uCommand;
        HMENU popup = CreatePopupMenu();
 
        if (popup == NULL)
            return E_FAIL;
 
        if (ppt)
        {
            pt = *ppt;
        }
        else
        {
            ::GetWindowRect(m_hWnd, &rc);
            pt.x = rc.left;
            pt.y = rc.top;
        }
 
        TRACE("Before Query\n");
        hr = contextMenu->QueryContextMenu(popup, 0, 0, UINT_MAX, CMF_NORMAL);
        if (FAILED_UNEXPECTEDLY(hr))
        {
            TRACE("Query failed\n");
            DestroyMenu(popup);
            return hr;
        }
 
        TRACE("Before Tracking\n");
        ::SetForegroundWindow(m_hWnd);
        if (hwndExclude)
        {
            ::GetWindowRect(hwndExclude, &rc);
            ZeroMemory(&params, sizeof(params));
            params.cbSize = sizeof(params);
            params.rcExclude = rc;
            uCommand = ::TrackPopupMenuEx(popup, TPM_RETURNCMD, pt.x, pt.y, m_hWnd, &params);
        }
        else
        {
            uCommand = ::TrackPopupMenuEx(popup, TPM_RETURNCMD, pt.x, pt.y, m_hWnd, NULL);
        }
        ::PostMessage(m_hWnd, WM_NULL, 0, 0);
 
        if (uCommand != 0)
        {
            TRACE("Before InvokeCommand\n");
            CMINVOKECOMMANDINFO cmi = { 0 };
            cmi.cbSize = sizeof(cmi);
            cmi.lpVerb = MAKEINTRESOURCEA(uCommand);
            cmi.hwnd = m_hWnd;
            hr = contextMenu->InvokeCommand(&cmi);
        }
        else
        {
            TRACE("TrackPopupMenu failed. Code=%d, LastError=%d\n", uCommand, GetLastError());
            hr = S_FALSE;
        }
 
        DestroyMenu(popup);
        return hr;
    }

Referenced by OnContextMenu().

◆ TrackMenu()

UINT CTrayWindow::TrackMenu	(	IN HMENU	hMenu,
		IN POINT *ppt	OPTIONAL,
		IN HWND hwndExclude	OPTIONAL,
		IN BOOL	TrackUp,
		IN BOOL	IsContextMenu
	)

inline

Definition at line 861 of file traywnd.cpp.

    {
        TPMPARAMS tmp, *ptmp = NULL;
        POINT pt;
        UINT cmdId;
        UINT fuFlags;
 
        if (hwndExclude != NULL)
        {
            /* Get the client rectangle and map it to screen coordinates */
            if (::GetClientRect(hwndExclude,
                &tmp.rcExclude) &&
                ::MapWindowPoints(hwndExclude,
                NULL,
                (LPPOINT) &tmp.rcExclude,
                2) != 0)
            {
                ptmp = &tmp;
            }
        }
 
        if (ppt == NULL)
        {
            if (ptmp == NULL &&
                GetClientRect(&tmp.rcExclude) &&
                MapWindowPoints(
                NULL,
                (LPPOINT) &tmp.rcExclude,
                2) != 0)
            {
                ptmp = &tmp;
            }
 
            if (ptmp != NULL)
            {
                /* NOTE: TrackPopupMenuEx will eventually align the track position
                         for us, no need to take care of it here as long as the
                         coordinates are somewhere within the exclusion rectangle */
                pt.x = ptmp->rcExclude.left;
                pt.y = ptmp->rcExclude.top;
            }
            else
                pt.x = pt.y = 0;
        }
        else
            pt = *ppt;
 
        tmp.cbSize = sizeof(tmp);
 
        fuFlags = TPM_RETURNCMD | TPM_VERTICAL;
        fuFlags |= (TrackUp ? TPM_BOTTOMALIGN : TPM_TOPALIGN);
        if (IsContextMenu)
            fuFlags |= TPM_RIGHTBUTTON;
        else
            fuFlags |= (TrackUp ? TPM_VERNEGANIMATION : TPM_VERPOSANIMATION);
 
        cmdId = TrackPopupMenuEx(hMenu,
                                 fuFlags,
                                 pt.x,
                                 pt.y,
                                 m_hWnd,
                                 ptmp);
 
        return cmdId;
    }

Referenced by OnSysChar().

◆ TrayMessageLoop()

VOID CTrayWindow::TrayMessageLoop ( )

inline

Definition at line 3439 of file traywnd.cpp.

    {
        MSG Msg;
        BOOL Ret;
 
        /* FIXME: We should keep a reference here... */
 
        while (true)
        {
            Ret = GetMessage(&Msg, NULL, 0, 0);
 
            if (!Ret || Ret == -1)
                break;
 
            if (m_StartMenuBand == NULL ||
                m_StartMenuBand->IsMenuMessage(&Msg) != S_OK)
            {
                TranslateMessage(&Msg);
                DispatchMessage(&Msg);
            }
        }
    }

Referenced by TrayMessageLoop().

◆ TrayProcessMessages()

VOID CTrayWindow::TrayProcessMessages ( )

inline

Definition at line 3419 of file traywnd.cpp.

    {
        MSG Msg;
 
        /* FIXME: We should keep a reference here... */
 
        while (PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE))
        {
            if (Msg.message == WM_QUIT)
                break;
 
            if (m_StartMenuBand == NULL ||
                m_StartMenuBand->IsMenuMessage(&Msg) != S_OK)
            {
                TranslateMessage(&Msg);
                DispatchMessage(&Msg);
            }
        }
    }

Referenced by TrayProcessMessages().

◆ TrayPropertiesThread()

DWORD WINAPI CTrayWindow::TrayPropertiesThread ( )

inline

Definition at line 539 of file traywnd.cpp.

    {
        HWND hwnd;
        RECT posRect;
 
        m_StartButton.GetWindowRect(&posRect);
        hwnd = CreateWindowEx(0,
                              WC_STATIC,
                              NULL,
                              WS_OVERLAPPED | WS_DISABLED | WS_CLIPSIBLINGS | WS_BORDER | SS_LEFT,
                              posRect.left,
                              posRect.top,
                              posRect.right - posRect.left,
                              posRect.bottom - posRect.top,
                              NULL,
                              NULL,
                              NULL,
                              NULL);
 
        m_TrayPropertiesOwner = hwnd;
 
        DisplayTrayProperties(hwnd, m_hWnd);
 
        m_TrayPropertiesOwner = NULL;
        ::DestroyWindow(hwnd);
 
        return 0;
    }

◆ Unknown()

STDMETHODIMP CTrayWindow::Unknown	(	IN DWORD	dwUnknown1,
		IN DWORD	dwUnknown2
	)

inlineoverride

Definition at line 3498 of file traywnd.cpp.

    {
        TRACE("IShellDesktopTray::Unknown(%u,%u) unimplemented!\n", dwUnknown1, dwUnknown2);
        return S_OK;
    }

◆ UpdateAlwaysOnTop()

void CTrayWindow::UpdateAlwaysOnTop ( _In_ BOOL bAlwaysOnTop )

inlineoverrideprotectedvirtual

Implements CAppBarManager.

Definition at line 3573 of file traywnd.cpp.

    {
        g_TaskbarSettings.sr.AlwaysOnTop = bAlwaysOnTop;
        HWND hwndInsertAfter = (bAlwaysOnTop ? HWND_TOPMOST : HWND_NOTOPMOST);
        SetWindowPos(hwndInsertAfter, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
    }

Referenced by OnTaskbarSettingsChanged().

◆ UpdateFonts()

void CTrayWindow::UpdateFonts ( )

inline

Definition at line 1012 of file traywnd.cpp.

    {
        /* There is nothing to do if themes are enabled */
        if (m_Theme)
            return;
 
        m_StartButton.UpdateFont();
 
        NONCLIENTMETRICS ncm = {sizeof(ncm)};
        if (!SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, FALSE))
        {
            ERR("SPI_GETNONCLIENTMETRICS failed\n");
            return;
        }
 
        if (m_Font != NULL)
            DeleteObject(m_Font);
 
        ncm.lfCaptionFont.lfWeight = FW_NORMAL;
        m_Font = CreateFontIndirect(&ncm.lfCaptionFont);
        if (!m_Font)
        {
            ERR("CreateFontIndirect failed\n");
            return;
        }
 
        SendMessage(m_Rebar, WM_SETFONT, (WPARAM) m_Font, TRUE);
        SendMessage(m_TaskSwitch, WM_SETFONT, (WPARAM) m_Font, TRUE);
        SendMessage(m_TrayNotify, WM_SETFONT, (WPARAM) m_Font, TRUE);
    }

Referenced by OnCreate(), and OnSettingChanged().

Member Data Documentation

◆

union { ... } CTrayWindow::@124

◆ Flags

DWORD CTrayWindow::Flags

Definition at line 357 of file traywnd.cpp.

◆ InSizeMove

DWORD CTrayWindow::InSizeMove

Definition at line 361 of file traywnd.cpp.

Referenced by ChangingWinPos(), OnEnterSizeMove(), and OnExitSizeMove().

◆ IsDragging

DWORD CTrayWindow::IsDragging

Definition at line 362 of file traywnd.cpp.

Referenced by ChangingWinPos(), OnEnterSizeMove(), and OnMoving().

◆ m_AutoHideOffset

SIZE CTrayWindow::m_AutoHideOffset

private

Definition at line 347 of file traywnd.cpp.

Referenced by ChangingWinPos(), CTrayWindow(), ProcessAutoHide(), and SetAutoHideState().

◆ m_AutoHideState

UINT CTrayWindow::m_AutoHideState

private

Definition at line 346 of file traywnd.cpp.

Referenced by IsHidingState(), OnCreate(), ProcessAutoHide(), ProcessMouseTracking(), and SetAutoHideState().

◆ m_ContextMenu

CComPtr<IContextMenu> CTrayWindow::m_ContextMenu

private

Definition at line 322 of file traywnd.cpp.

Referenced by GetCommandString(), InvokeCommand(), and QueryContextMenu().

◆ m_DesktopWnd

HWND CTrayWindow::m_DesktopWnd

private

Definition at line 327 of file traywnd.cpp.

Referenced by GetDesktopWnd(), IsSpecialHWND(), MinimizeAll(), OnSettingChanged(), RegisterDesktopWindow(), and SaveState().

◆ m_DraggingMonitor

HMONITOR CTrayWindow::m_DraggingMonitor

private

Definition at line 338 of file traywnd.cpp.

Referenced by ChangingWinPos(), and OnMoving().

◆ m_DraggingPosition

DWORD CTrayWindow::m_DraggingPosition

private

Definition at line 337 of file traywnd.cpp.

Referenced by ChangingWinPos(), and OnMoving().

◆ m_Font

HFONT CTrayWindow::m_Font

private

Definition at line 325 of file traywnd.cpp.

Referenced by UpdateFonts(), and ~CTrayWindow().

◆ m_Monitor

HMONITOR CTrayWindow::m_Monitor

private

Definition at line 335 of file traywnd.cpp.

Referenced by ApplyClipping(), ChangingWinPos(), GetMonitor(), OnEnterSizeMove(), RegLoadSettings(), and ResizeWorkArea().

◆ m_MouseTrackingInfo

TRACKMOUSEEVENT CTrayWindow::m_MouseTrackingInfo

private

Definition at line 348 of file traywnd.cpp.

Referenced by CTrayWindow().

◆ m_Position

DWORD CTrayWindow::m_Position

private

◆ m_PreviousMonitor

HMONITOR CTrayWindow::m_PreviousMonitor

private

Definition at line 336 of file traywnd.cpp.

Referenced by GetPreviousMonitor(), OnEnterSizeMove(), and ResizeWorkArea().

◆ m_pShowDesktopButton

CTrayShowDesktopButton* CTrayWindow::m_pShowDesktopButton

private

Definition at line 316 of file traywnd.cpp.

Referenced by DrawShowDesktopButton(), OnCreate(), OnLButtonUp(), OnNcHitTest(), OnNcLButtonDown(), and OnNcLButtonUp().

◆ m_Rebar

HWND CTrayWindow::m_Rebar

private

Definition at line 328 of file traywnd.cpp.

Referenced by AlignControls(), FitToRebar(), OnContextMenu(), OnCreate(), OnSysColorChange(), and UpdateFonts().

◆ m_RunFileDlgOwner

HWND CTrayWindow::m_RunFileDlgOwner

private

Definition at line 344 of file traywnd.cpp.

Referenced by DisplayRunFileDlg(), and RunFileDlgThread().

◆ m_ShellServices

HDPA CTrayWindow::m_ShellServices

private

Definition at line 350 of file traywnd.cpp.

Referenced by OnCreate(), and ~CTrayWindow().

◆ m_StartButton

CStartButton CTrayWindow::m_StartButton

private

Definition at line 315 of file traywnd.cpp.

Referenced by AlignControls(), OnCommand(), OnContextMenu(), OnCreate(), OnGetMinMaxInfo(), OnNcLButtonDown(), OnSysChar(), PopupStartMenu(), ProcessMouseTracking(), RaiseStartButton(), RegLoadSettings(), RunFileDlgThread(), TrayPropertiesThread(), and UpdateFonts().

◆ m_StartMenuBand

CComPtr<IMenuBand> CTrayWindow::m_StartMenuBand

private

Definition at line 318 of file traywnd.cpp.

Referenced by if(), OnCreate(), OnSettingChanged(), TrayMessageLoop(), and TrayProcessMessages().

◆ m_StartMenuPopup

CComPtr<IMenuPopup> CTrayWindow::m_StartMenuPopup

private

Definition at line 319 of file traywnd.cpp.

Referenced by HideStartMenu(), OnCreate(), OnOpenStartMenu(), OnSettingChanged(), and PopupStartMenu().

◆ m_TaskBand

CComPtr<IDeskBand> CTrayWindow::m_TaskBand

private

Definition at line 321 of file traywnd.cpp.

Referenced by OnCreate().

◆ m_TaskSwitch

HWND CTrayWindow::m_TaskSwitch

private

Definition at line 329 of file traywnd.cpp.

Referenced by AlignControls(), OnContextMenu(), OnCreate(), OnGetTaskSwitch(), OnSettingChanged(), OnTaskbarSettingsChanged(), and UpdateFonts().

◆ m_Theme

HTHEME CTrayWindow::m_Theme

private

Definition at line 323 of file traywnd.cpp.

Referenced by AdjustSizerRect(), AlignControls(), DrawSizerWithTheme(), EraseBackgroundWithTheme(), GetTrayRectFromScreenRect(), Lock(), OnEraseBackground(), OnNcCalcSize(), OnNcPaint(), OnThemeChanged(), Open(), RegLoadSettings(), UpdateFonts(), and ~CTrayWindow().

◆ m_TrayBandSite

CComPtr<ITrayBandSite> CTrayWindow::m_TrayBandSite

Definition at line 353 of file traywnd.cpp.

Referenced by CheckTrayWndPosition(), Lock(), OnActivate(), OnCommand(), OnContextMenu(), OnCreate(), OnNotify(), and OnSetFocus().

◆ m_TrayNotify

HWND CTrayWindow::m_TrayNotify

private

Definition at line 330 of file traywnd.cpp.

Referenced by AlignControls(), DrawShowDesktopButton(), OnCopyData(), OnCreate(), OnMouseMove(), OnNcLButtonDblClick(), OnNotify(), OnSettingChanged(), OnTaskbarSettingsChanged(), and UpdateFonts().

◆ m_TrayNotifyInstance

CComPtr<IUnknown> CTrayWindow::m_TrayNotifyInstance

private

Definition at line 332 of file traywnd.cpp.

Referenced by OnCreate().

◆ m_TrayPropertiesOwner

HWND CTrayWindow::m_TrayPropertiesOwner

private

Definition at line 343 of file traywnd.cpp.

Referenced by DisplayProperties(), and TrayPropertiesThread().

◆ m_TrayRects

RECT CTrayWindow::m_TrayRects[4]

private

Definition at line 340 of file traywnd.cpp.

Referenced by ChangingWinPos(), CheckTrayWndPosition(), CTrayWindow(), GetDraggingRectFromPt(), GetTrayRect(), Lock(), OnExitSizeMove(), OnMoving(), OnSizing(), Open(), RegLoadSettings(), and ResizeWorkArea().

◆ m_TraySize

SIZE CTrayWindow::m_TraySize

private

Definition at line 341 of file traywnd.cpp.

Referenced by ChangingWinPos(), CTrayWindow(), GetTrayRectFromScreenRect(), ProcessAutoHide(), and RegLoadSettings().

◆ NewPosSize

DWORD CTrayWindow::NewPosSize

Definition at line 363 of file traywnd.cpp.

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

base/shell/explorer/traywnd.cpp

Private Attributes
CStartButton	m_StartButton

CTrayShowDesktopButton *	m_pShowDesktopButton

CComPtr< IMenuBand >	m_StartMenuBand

CComPtr< IMenuPopup >	m_StartMenuPopup

CComPtr< IDeskBand >	m_TaskBand

CComPtr< IContextMenu >	m_ContextMenu

HTHEME	m_Theme

HFONT	m_Font

HWND	m_DesktopWnd

HWND	m_Rebar

HWND	m_TaskSwitch

HWND	m_TrayNotify

CComPtr< IUnknown >	m_TrayNotifyInstance

DWORD	m_Position

HMONITOR	m_Monitor

HMONITOR	m_PreviousMonitor

DWORD	m_DraggingPosition

HMONITOR	m_DraggingMonitor

RECT	m_TrayRects [4]

SIZE	m_TraySize

HWND	m_TrayPropertiesOwner

HWND	m_RunFileDlgOwner

UINT	m_AutoHideState

SIZE	m_AutoHideOffset

TRACKMOUSEEVENT	m_MouseTrackingInfo

HDPA	m_ShellServices

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CTrayWindow()

◆ ~CTrayWindow()

Member Function Documentation

◆ _Init()

◆ AdjustSizerRect()

◆ AlignControls()

◆ ApplyClipping()

◆ CalculateValidSize()

◆ ChangingWinPos()

◆ CheckTrayWndPosition()

◆ Close()

◆ ContextSensitiveHelp()

◆ DisplayProperties()

◆ DisplayRunFileDlg()

◆ DoExitWindows()

◆ DrawShowDesktopButton()

◆ DrawSizerWithTheme()

◆ EraseBackgroundWithTheme()

◆ ExecContextMenuCmd()

◆ ExecResourceCmd()

◆ FitToRebar()

◆ GetCommandString()

◆ GetDesktopWnd()

◆ GetDraggingRectFromPt()

◆ GetDraggingRectFromRect()

◆ GetHWND()

◆ GetMonitor()

◆ GetMonitorFromRect()

◆ GetPosition()

◆ GetPreviousMonitor()

◆ GetScreenRect()

◆ GetScreenRectFromRect()

◆ GetState()

◆ GetTrayRect()

◆ GetTrayRectFromScreenRect()

◆ GetTrayWindow()

◆ GetTrayWnd()

◆ GetWindow()

◆ HandleCommand()

◆ HandleHotKey()

◆ HideStartMenu()

◆ if()

◆ InvokeCommand()

◆ IsAlwaysOnTop()

◆ IsAutoHideState()

◆ IsDialog()

◆ IsHidingState()

◆ IsHorizontal()

◆ IsPointWithinShowDesktopButton()

◆ IsPointWithinStartButton()

◆ IsPosHorizontal()

◆ IsSpecialHWND()

◆ IsTaskWnd()

◆ Lock()

◆ MakeTrayRectWithSize()

◆ MinimizeAll()

◆ MinimizeWindowsProc()

◆ NotifyFullScreenToAppBars()

◆ OnActivate()

◆ OnAppTrayDestroy()

◆ OnCommand()

◆ OnContextMenu()

◆ OnCopyData()

◆ OnCreate()

◆ OnCtlColorBtn()

◆ OnDestroy()

◆ OnDisplayChange()

◆ OnDoExitWindows()

◆ OnEndSession()

◆ OnEnterSizeMove()

◆ OnEraseBackground()