6475 lines
186 KiB
C++
6475 lines
186 KiB
C++
#include "cabinet.h"
|
||
#include "taskband.h"
|
||
#include <shguidp.h>
|
||
#include "bandsite.h"
|
||
#include "util.h"
|
||
#include "tray.h"
|
||
#include "rcids.h"
|
||
#include "bandsite.h"
|
||
#include "startmnu.h"
|
||
#include "mixer.h"
|
||
|
||
#include <regstr.h>
|
||
#include "uemapp.h"
|
||
|
||
#define TIF_RENDERFLASHED 0x000000001
|
||
#define TIF_SHOULDTIP 0x000000002
|
||
#define TIF_ACTIVATEALT 0x000000004
|
||
#define TIF_EVERACTIVEALT 0x000000008
|
||
#define TIF_FLASHING 0x000000010
|
||
#define TIF_TRANSPARENT 0x000000020
|
||
#define TIF_CHECKED 0x000000040
|
||
#define TIF_ISGLOMMING 0x000000080
|
||
#define TIF_NEEDSREDRAW 0x000000100
|
||
|
||
|
||
#define IDT_SYSMENU 2
|
||
#define IDT_ASYNCANIMATION 3
|
||
#define IDT_REDRAW 4
|
||
#define IDT_RECHECKRUDEAPP1 5
|
||
#define IDT_RECHECKRUDEAPP2 6
|
||
#define IDT_RECHECKRUDEAPP3 7
|
||
#define IDT_RECHECKRUDEAPP4 8
|
||
#define IDT_RECHECKRUDEAPP5 9
|
||
|
||
#define TIMEOUT_SYSMENU 2000
|
||
#define TIMEOUT_SYSMENU_HUNG 125
|
||
|
||
#define GLOM_OLDEST 0
|
||
#define GLOM_BIGGEST 1
|
||
#define GLOM_SIZE 2
|
||
|
||
#define ANIMATE_INSERT 0
|
||
#define ANIMATE_DELETE 1
|
||
#define ANIMATE_GLOM 2
|
||
|
||
#define IL_NORMAL 0
|
||
#define IL_SHIL 1
|
||
|
||
#define MAX_WNDTEXT 80 // arbitrary, matches NMTTDISPINFO.szText
|
||
|
||
#define INVALID_PRIORITY (THREAD_PRIORITY_LOWEST - 1)
|
||
|
||
const TCHAR c_szTaskSwClass[] = TEXT("MSTaskSwWClass");
|
||
const TCHAR c_wzTaskBandTheme[] = TEXT("TaskBand");
|
||
const TCHAR c_wzTaskBandThemeVert[] = TEXT("TaskBandVert");
|
||
const TCHAR c_wzTaskBandGroupMenuTheme[] = TEXT("TaskBandGroupMenu");
|
||
|
||
typedef struct
|
||
{
|
||
WCHAR szExeName[MAX_PATH];
|
||
} EXCLUDELIST;
|
||
|
||
static const EXCLUDELIST g_rgNoGlom[] =
|
||
{
|
||
{ L"rundll32.exe" }
|
||
// Add any future apps that shouldn't be glommed
|
||
};
|
||
|
||
void _RestoreWindow(HWND hwnd, DWORD dwFlags);
|
||
HMENU _GetSystemMenu(HWND hwnd);
|
||
BOOL _IsRudeWindowActive(HWND hwnd);
|
||
|
||
////////////////////////////////////////////////////////////////////////////
|
||
//
|
||
// BEGIN CTaskBandSMC
|
||
//
|
||
// CTaskBand can't implement IShellMenuCallback itself because menuband
|
||
// sets itself as the callback's site. Hence this class.
|
||
//
|
||
//
|
||
////////////////////////////////////////////////////////////////////////////
|
||
|
||
class CTaskBandSMC : public IShellMenuCallback
|
||
, public IContextMenu
|
||
, public IObjectWithSite
|
||
{
|
||
public:
|
||
// *** IUnknown methods ***
|
||
STDMETHODIMP QueryInterface(REFIID riid, LPVOID * ppvObj)
|
||
{
|
||
static const QITAB qit[] =
|
||
{
|
||
QITABENT(CTaskBandSMC, IShellMenuCallback),
|
||
QITABENT(CTaskBandSMC, IContextMenu),
|
||
QITABENT(CTaskBandSMC, IObjectWithSite),
|
||
{ 0 },
|
||
};
|
||
return QISearch(this, qit, riid, ppvObj);
|
||
}
|
||
|
||
STDMETHODIMP_(ULONG) AddRef() { return ++_cRef; }
|
||
STDMETHODIMP_(ULONG) Release()
|
||
{
|
||
ASSERT(_cRef > 0);
|
||
if (--_cRef > 0)
|
||
{
|
||
return _cRef;
|
||
}
|
||
delete this;
|
||
return 0;
|
||
}
|
||
|
||
// *** IShellMenuCallback methods ***
|
||
STDMETHODIMP CallbackSM(LPSMDATA smd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
||
|
||
// *** IContextMenu methods ***
|
||
STDMETHODIMP QueryContextMenu(HMENU hmenu, UINT iIndexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags);
|
||
STDMETHODIMP InvokeCommand(LPCMINVOKECOMMANDINFO lpici);
|
||
STDMETHODIMP GetCommandString(UINT_PTR idCmd, UINT uType, UINT *pRes, LPSTR pszName, UINT cchMax) { return E_NOTIMPL; }
|
||
|
||
// *** IObjectWithSite methods ***
|
||
STDMETHODIMP SetSite(IUnknown* punkSite)
|
||
{
|
||
ATOMICRELEASE(_punkSite);
|
||
if (punkSite != NULL)
|
||
{
|
||
_punkSite = punkSite;
|
||
_punkSite->AddRef();
|
||
}
|
||
return S_OK;
|
||
}
|
||
STDMETHODIMP GetSite(REFIID riid, void** ppvSite) { return E_NOTIMPL; };
|
||
|
||
CTaskBandSMC(CTaskBand* ptb) : _cRef(1)
|
||
{
|
||
_ptb = ptb;
|
||
_ptb->AddRef();
|
||
}
|
||
|
||
private:
|
||
|
||
virtual ~CTaskBandSMC() { ATOMICRELEASE(_ptb); }
|
||
|
||
ULONG _cRef;
|
||
CTaskBand* _ptb;
|
||
IUnknown* _punkSite;
|
||
HWND _hwndSelected;
|
||
};
|
||
|
||
STDMETHODIMP CTaskBandSMC::CallbackSM(LPSMDATA psmd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
ASSERT(_ptb);
|
||
|
||
HRESULT hres = S_FALSE;
|
||
|
||
if (!_ptb->_IsButtonChecked(_ptb->_iIndexPopup) && (SMC_EXITMENU != uMsg))
|
||
{
|
||
_ptb->_SetCurSel(_ptb->_iIndexPopup, TRUE);
|
||
}
|
||
|
||
switch (uMsg)
|
||
{
|
||
case SMC_EXEC:
|
||
{
|
||
PTASKITEM pti = _ptb->_GetItem(psmd->uId);
|
||
if (pti)
|
||
{
|
||
_ptb->_SetCurSel(psmd->uId, FALSE);
|
||
_ptb->_OnButtonPressed(psmd->uId, pti, lParam);
|
||
hres = S_OK;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case SMC_GETINFO:
|
||
{
|
||
SMINFO* psminfo = (SMINFO*)lParam;
|
||
hres = S_OK;
|
||
|
||
if (psminfo->dwMask & SMIM_TYPE)
|
||
{
|
||
psminfo->dwType = SMIT_STRING;
|
||
}
|
||
|
||
if (psminfo->dwMask & SMIM_FLAGS)
|
||
{
|
||
psminfo->dwFlags = SMIF_ICON | SMIF_DRAGNDROP;
|
||
}
|
||
|
||
if (psminfo->dwMask & SMIM_ICON)
|
||
{
|
||
TBBUTTONINFO tbbi;
|
||
tbbi.iImage = I_IMAGENONE;
|
||
PTASKITEM pti = _ptb->_GetItem(psmd->uId, &tbbi);
|
||
if (pti && tbbi.iImage == I_IMAGECALLBACK)
|
||
{
|
||
_ptb->_UpdateItemIcon(psmd->uId);
|
||
_ptb->_GetItem(psmd->uId, &tbbi);
|
||
}
|
||
psminfo->iIcon = tbbi.iImage;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case SMC_CUSTOMDRAW:
|
||
{
|
||
PTASKITEM pti = _ptb->_GetItem(psmd->uId);
|
||
if (pti)
|
||
{
|
||
*(LRESULT*)wParam = _ptb->_HandleCustomDraw((NMTBCUSTOMDRAW*)lParam, pti);
|
||
hres = S_OK;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case SMC_SELECTITEM:
|
||
{
|
||
PTASKITEM pti = _ptb->_GetItem(psmd->uId);
|
||
_hwndSelected = pti ? pti->hwnd : NULL;
|
||
}
|
||
break;
|
||
|
||
case SMC_GETOBJECT:
|
||
{
|
||
GUID *pguid = (GUID*)wParam;
|
||
if (IsEqualIID(*pguid, IID_IContextMenu) && !SHRestricted(REST_NOTRAYCONTEXTMENU))
|
||
{
|
||
hres = QueryInterface(*pguid, (void **)lParam);
|
||
}
|
||
else
|
||
{
|
||
hres = E_FAIL;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case SMC_GETINFOTIP:
|
||
{
|
||
PTASKITEM pti = _ptb->_GetItem(psmd->uId);
|
||
if (pti)
|
||
{
|
||
_ptb->_GetItemTitle(psmd->uId, (TCHAR*)wParam, (int)lParam, TRUE);
|
||
hres = S_OK;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case SMC_GETIMAGELISTS:
|
||
{
|
||
HIMAGELIST himl = (HIMAGELIST)_ptb->_tb.SendMessage(TB_GETIMAGELIST, psmd->uId, 0);
|
||
if (himl)
|
||
{
|
||
*((HIMAGELIST*)lParam) = *((HIMAGELIST*)wParam) = himl;
|
||
hres = S_OK;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case SMC_EXITMENU:
|
||
{
|
||
_hwndSelected = NULL;
|
||
CToolTipCtrl ttc = _ptb->_tb.GetToolTips();
|
||
ttc.Activate(TRUE);
|
||
_ptb->_iIndexPopup = -1;
|
||
}
|
||
break;
|
||
}
|
||
|
||
return hres;
|
||
}
|
||
|
||
// *** IContextMenu methods ***
|
||
STDMETHODIMP CTaskBandSMC::QueryContextMenu(HMENU hmenu, UINT iIndexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
|
||
{
|
||
ASSERT(_ptb);
|
||
|
||
HRESULT hr = ResultFromShort(0);
|
||
|
||
if (_hwndSelected != NULL)
|
||
{
|
||
HMENU hmenuTemp = _GetSystemMenu(_hwndSelected);
|
||
if (hmenuTemp)
|
||
{
|
||
if (Shell_MergeMenus(hmenu, hmenuTemp, 0, iIndexMenu, idCmdLast, uFlags))
|
||
{
|
||
SetMenuDefaultItem(hmenu, 0, MF_BYPOSITION);
|
||
hr = ResultFromShort(GetMenuItemCount(hmenuTemp));
|
||
}
|
||
|
||
DestroyMenu(hmenuTemp);
|
||
}
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
STDMETHODIMP CTaskBandSMC::InvokeCommand(LPCMINVOKECOMMANDINFO lpici)
|
||
{
|
||
ASSERT(_ptb);
|
||
|
||
PTASKITEM pti = _ptb->_FindItemByHwnd(_hwndSelected);
|
||
if (pti)
|
||
{
|
||
int iCommand = LOWORD(lpici->lpVerb);
|
||
if (iCommand)
|
||
{
|
||
_RestoreWindow(pti->hwnd, pti->dwFlags);
|
||
_ptb->_ExecuteMenuOption(pti->hwnd, iCommand);
|
||
}
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
////////////////////////////////////////////////////////////////////////////
|
||
//
|
||
// END CTaskBandSMC
|
||
//
|
||
////////////////////////////////////////////////////////////////////////////
|
||
|
||
|
||
ULONG CTaskBand::AddRef()
|
||
{
|
||
_cRef++;
|
||
return _cRef;
|
||
}
|
||
|
||
ULONG CTaskBand::Release()
|
||
{
|
||
ASSERT(_cRef > 0);
|
||
_cRef--;
|
||
|
||
if (_cRef > 0)
|
||
return _cRef;
|
||
|
||
delete this;
|
||
return 0;
|
||
}
|
||
|
||
HRESULT CTaskBand::GetWindow(HWND * lphwnd)
|
||
{
|
||
*lphwnd = _hwnd;
|
||
if (_hwnd)
|
||
return S_OK;
|
||
return E_FAIL;
|
||
|
||
}
|
||
|
||
CTaskBand::CTaskBand() : _dwBandID((DWORD)-1), _iDropItem(-2), _iIndexActiveAtLDown(-1), _cRef(1), _iOldPriority(INVALID_PRIORITY)
|
||
{
|
||
}
|
||
|
||
CTaskBand::~CTaskBand()
|
||
{
|
||
ATOMICRELEASE(_punkSite);
|
||
ATOMICRELEASE(_pimlSHIL);
|
||
|
||
if (_dsaAII)
|
||
_dsaAII.Destroy();
|
||
|
||
if (_hfontCapNormal)
|
||
DeleteFont(_hfontCapNormal);
|
||
|
||
if (_hfontCapBold)
|
||
DeleteFont(_hfontCapBold);
|
||
}
|
||
|
||
HRESULT CTaskBand::QueryInterface(REFIID riid, LPVOID* ppvObj)
|
||
{
|
||
static const QITAB qit[] =
|
||
{
|
||
QITABENTMULTI(CTaskBand, IDockingWindow, IDeskBand),
|
||
QITABENTMULTI(CTaskBand, IOleWindow, IDeskBand),
|
||
QITABENT(CTaskBand, IDeskBand),
|
||
QITABENT(CTaskBand, IObjectWithSite),
|
||
QITABENT(CTaskBand, IDropTarget),
|
||
QITABENT(CTaskBand, IInputObject),
|
||
QITABENTMULTI(CTaskBand, IPersist, IPersistStream),
|
||
QITABENT(CTaskBand, IPersistStream),
|
||
QITABENT(CTaskBand, IWinEventHandler),
|
||
QITABENT(CTaskBand, IOleCommandTarget),
|
||
{ 0 },
|
||
};
|
||
|
||
return QISearch(this, qit, riid, ppvObj);
|
||
}
|
||
|
||
HRESULT CTaskBand::Init(CTray* ptray)
|
||
{
|
||
HRESULT hr = E_OUTOFMEMORY;
|
||
|
||
if (_dsaAII.Create(2))
|
||
{
|
||
_ptray = ptray;
|
||
hr = S_OK;
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
// *** IPersistStream methods ***
|
||
|
||
HRESULT CTaskBand::GetClassID(LPCLSID pClassID)
|
||
{
|
||
*pClassID = CLSID_TaskBand;
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT CTaskBand::_BandInfoChanged()
|
||
{
|
||
if (_dwBandID != (DWORD)-1)
|
||
{
|
||
VARIANTARG var = {0};
|
||
var.vt = VT_I4;
|
||
var.lVal = _dwBandID;
|
||
|
||
return IUnknown_Exec(_punkSite, &CGID_DeskBand, DBID_BANDINFOCHANGED, 0, &var, NULL);
|
||
}
|
||
else
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT CTaskBand::Load(IStream *ps)
|
||
{
|
||
return S_OK;
|
||
}
|
||
|
||
// *** IOleCommandTarget ***
|
||
|
||
STDMETHODIMP CTaskBand::Exec(const GUID *pguidCmdGroup,DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
|
||
{
|
||
HRESULT hr = OLECMDERR_E_NOTSUPPORTED;
|
||
return hr;
|
||
}
|
||
|
||
STDMETHODIMP CTaskBand::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD rgCmds[], OLECMDTEXT *pcmdtext)
|
||
{
|
||
if (pguidCmdGroup)
|
||
{
|
||
if (IsEqualIID(*pguidCmdGroup, IID_IDockingWindow))
|
||
{
|
||
for (UINT i = 0; i < cCmds; i++)
|
||
{
|
||
switch (rgCmds[i].cmdID)
|
||
{
|
||
case DBID_PERMITAUTOHIDE:
|
||
rgCmds[i].cmdf = OLECMDF_SUPPORTED;
|
||
if (!_fFlashing)
|
||
{
|
||
rgCmds[i].cmdf |= OLECMDF_ENABLED;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
return S_OK;
|
||
}
|
||
}
|
||
return OLECMDERR_E_UNKNOWNGROUP;
|
||
}
|
||
|
||
//*** IInputObject methods ***
|
||
|
||
HRESULT CTaskBand::HasFocusIO()
|
||
{
|
||
BOOL f;
|
||
HWND hwndFocus = GetFocus();
|
||
|
||
f = IsChildOrHWND(_hwnd, hwndFocus);
|
||
ASSERT(hwndFocus != NULL || !f);
|
||
ASSERT(_hwnd != NULL || !f);
|
||
|
||
return f ? S_OK : S_FALSE;
|
||
}
|
||
|
||
HRESULT CTaskBand::UIActivateIO(BOOL fActivate, LPMSG lpMsg)
|
||
{
|
||
ASSERT(NULL == lpMsg || IS_VALID_WRITE_PTR(lpMsg, MSG));
|
||
|
||
if (fActivate)
|
||
{
|
||
// don't show a hot item if we weren't properly tabbed
|
||
// into/clicked on, in which case we have a NULL lpMsg,
|
||
// e.g. if the tray just decided to activate us for lack of
|
||
// anyone better.
|
||
|
||
_fDenyHotItemChange = !lpMsg;
|
||
|
||
IUnknown_OnFocusChangeIS(_punkSite, SAFECAST(this, IInputObject*), TRUE);
|
||
::SetFocus(_hwnd);
|
||
|
||
_fDenyHotItemChange = FALSE;
|
||
}
|
||
else
|
||
{
|
||
// if we don't have focus, we're fine;
|
||
// if we do have focus, there's nothing we can do about it...
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT CTaskBand::SetSite(IUnknown* punk)
|
||
{
|
||
if (punk && !_hwnd)
|
||
{
|
||
_LoadSettings();
|
||
|
||
_RegisterWindowClass();
|
||
|
||
HWND hwndParent;
|
||
IUnknown_GetWindow(punk, &hwndParent);
|
||
|
||
HWND hwnd = CreateWindowEx(0, c_szTaskSwClass, NULL,
|
||
WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
|
||
0, 0, 0, 0, hwndParent, NULL, hinstCabinet, (void*)(CImpWndProc*)this);
|
||
|
||
SetWindowTheme(hwnd, c_wzTaskBandTheme, NULL);
|
||
}
|
||
|
||
ATOMICRELEASE(_punkSite);
|
||
if (punk)
|
||
{
|
||
_punkSite = punk;
|
||
punk->AddRef();
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
HRESULT CTaskBand::GetBandInfo(DWORD dwBandID, DWORD fViewMode,
|
||
DESKBANDINFO* pdbi)
|
||
{
|
||
_dwBandID = dwBandID;
|
||
|
||
pdbi->ptMaxSize.y = -1;
|
||
pdbi->ptActual.y = g_cySize + 2*g_cyEdge;
|
||
|
||
LONG lButHeight = _GetCurButtonHeight();
|
||
|
||
if (fViewMode & DBIF_VIEWMODE_VERTICAL)
|
||
{
|
||
pdbi->ptMinSize.x = lButHeight;
|
||
// The 1.2 gives us enough space for the dropdown arrow
|
||
pdbi->ptMinSize.y = lButHeight * (_fGlom ? 1.2 : 1);
|
||
pdbi->ptIntegral.y = 1;
|
||
}
|
||
else
|
||
{
|
||
TBMETRICS tbm;
|
||
_GetToolbarMetrics(&tbm);
|
||
|
||
pdbi->ptMinSize.x = lButHeight * 3;
|
||
pdbi->ptMinSize.y = lButHeight;
|
||
pdbi->ptIntegral.y = lButHeight + tbm.cyButtonSpacing;
|
||
}
|
||
|
||
pdbi->dwModeFlags = DBIMF_VARIABLEHEIGHT | DBIMF_UNDELETEABLE | DBIMF_TOPALIGN;
|
||
pdbi->dwMask &= ~DBIM_TITLE; // no title for us (ever)
|
||
|
||
DWORD dwOldViewMode = _dwViewMode;
|
||
_dwViewMode = fViewMode;
|
||
|
||
if (_tb && (_dwViewMode != dwOldViewMode))
|
||
{
|
||
SendMessage(_tb, TB_SETWINDOWTHEME, 0, (LPARAM)(_IsHorizontal() ? c_wzTaskBandTheme : c_wzTaskBandThemeVert));
|
||
_CheckSize();
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
void _RaiseDesktop(BOOL fRaise)
|
||
{
|
||
SendMessage(v_hwndTray, TM_RAISEDESKTOP, fRaise, 0);
|
||
}
|
||
|
||
// *** IDropTarget methods ***
|
||
|
||
STDMETHODIMP CTaskBand::DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
|
||
{
|
||
_DragEnter(_hwnd, ptl, pdtobj);
|
||
|
||
IUnknown_DragEnter(_punkSite, pdtobj, grfKeyState, ptl, pdwEffect);
|
||
|
||
_iDropItem = -2; // reset to no target
|
||
|
||
*pdwEffect = DROPEFFECT_LINK;
|
||
return S_OK;
|
||
}
|
||
|
||
STDMETHODIMP CTaskBand::DragLeave()
|
||
{
|
||
IUnknown_DragLeave(_punkSite);
|
||
DAD_DragLeave();
|
||
return S_OK;
|
||
}
|
||
|
||
STDMETHODIMP CTaskBand::DragOver(DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
|
||
{
|
||
int iHitNew = _HitTest(ptl);
|
||
if (iHitNew == -1)
|
||
{
|
||
DWORD dwEffect = *pdwEffect;
|
||
IUnknown_DragOver(_punkSite, grfKeyState, ptl, &dwEffect);
|
||
}
|
||
|
||
*pdwEffect = DROPEFFECT_LINK;
|
||
|
||
_DragMove(_hwnd, ptl);
|
||
|
||
if (_iDropItem != iHitNew)
|
||
{
|
||
_iDropItem = iHitNew;
|
||
_dwTriggerStart = GetTickCount();
|
||
_dwTriggerDelay = 250;
|
||
if (iHitNew == -1)
|
||
{
|
||
_dwTriggerDelay += 250; // make a little longer for minimize all
|
||
}
|
||
}
|
||
else if (GetTickCount() - _dwTriggerStart > _dwTriggerDelay)
|
||
{
|
||
DAD_ShowDragImage(FALSE); // unlock the drag sink if we are dragging.
|
||
|
||
if (_iDropItem == -1)
|
||
{
|
||
_RaiseDesktop(TRUE);
|
||
}
|
||
else if (_iDropItem >= 0 && _iDropItem < _tb.GetButtonCount())
|
||
{
|
||
_iIndexLastPopup = -1;
|
||
_SwitchToItem(_iDropItem, _GetItem(_iDropItem)->hwnd, TRUE);
|
||
UpdateWindow(v_hwndTray);
|
||
}
|
||
|
||
DAD_ShowDragImage(TRUE); // restore the lock state.
|
||
|
||
_dwTriggerDelay += 10000; // don't let this happen again for 10 seconds
|
||
// simulate a single shot event
|
||
}
|
||
|
||
if (_iDropItem != -1)
|
||
*pdwEffect = DROPEFFECT_MOVE; // try to get the move cursor
|
||
else
|
||
*pdwEffect = DROPEFFECT_NONE;
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
STDMETHODIMP CTaskBand::Drop(IDataObject *pdtobj, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
|
||
{
|
||
IUnknown_DragLeave(_punkSite);
|
||
DAD_DragLeave();
|
||
|
||
//
|
||
// post ourselves a message to put up a message box to explain that you
|
||
// can't drag to the taskbar. we need to return from the Drop method
|
||
// now so the DragSource isn't hung while our box is up
|
||
//
|
||
PostMessage(_hwnd, TBC_WARNNODROP, 0, 0L);
|
||
|
||
// be sure to clear DROPEFFECT_MOVE so apps don't delete their data
|
||
*pdwEffect = DROPEFFECT_NONE;
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
// *** IWinEventHandler methods ***
|
||
HRESULT CTaskBand::OnWinEvent(HWND hwnd, UINT dwMsg, WPARAM wParam, LPARAM lParam, LRESULT* plres)
|
||
{
|
||
*plres = 0;
|
||
|
||
switch (dwMsg)
|
||
{
|
||
case WM_WININICHANGE:
|
||
_HandleWinIniChange(wParam, lParam, FALSE);
|
||
break;
|
||
|
||
case WM_NOTIFY:
|
||
if (lParam)
|
||
{
|
||
switch (((LPNMHDR)lParam)->code)
|
||
{
|
||
case NM_SETFOCUS:
|
||
IUnknown_OnFocusChangeIS(_punkSite, SAFECAST(this, IInputObject*), TRUE);
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT CTaskBand::IsWindowOwner(HWND hwnd)
|
||
{
|
||
BOOL bRet = IsChildOrHWND(_hwnd, hwnd);
|
||
ASSERT (_hwnd || !bRet);
|
||
ASSERT (hwnd || !bRet);
|
||
return bRet ? S_OK : S_FALSE;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Returns whether or not the button is hidden
|
||
//
|
||
// PARAMETERS: 1. hwndToolBar - handle to the toolbar window
|
||
// 2. iIndex - item index
|
||
//
|
||
// RETURN: TRUE = Item is visible, FALSE = Item is hidden.
|
||
//-----------------------------------------------------------------------------
|
||
BOOL ToolBar_IsVisible(HWND hwndToolBar, int iIndex)
|
||
{
|
||
TBBUTTONINFO tbbi;
|
||
tbbi.cbSize = sizeof(tbbi);
|
||
tbbi.dwMask = TBIF_STATE | TBIF_BYINDEX;
|
||
SendMessage(hwndToolBar, TB_GETBUTTONINFO, iIndex, (LPARAM) &tbbi);
|
||
|
||
return !(tbbi.fsState & TBSTATE_HIDDEN);
|
||
}
|
||
|
||
//*****************************************************************************
|
||
//
|
||
// ITEM ANIMATION FUNCTIONS
|
||
//
|
||
//*****************************************************************************
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Inserts item(s) into the animation list
|
||
//
|
||
// PARAMETERS: 1. iIndex - index for item, group index for a group
|
||
// 2. fExpand - TRUE = Insert or Unglom, FALSE = Delete or Glom
|
||
// 3. fGlomAnimation - TRUE = this is a glom or unglom animation
|
||
//-----------------------------------------------------------------------------
|
||
BOOL CTaskBand::_AnimateItems(int iIndex, BOOL fExpand, BOOL fGlomAnimation)
|
||
{
|
||
ANIMATIONITEMINFO aii;
|
||
_SetAnimationState(&aii, fExpand, fGlomAnimation);
|
||
|
||
// Is item being inserted into glomming group?
|
||
if (aii.fState == ANIMATE_INSERT)
|
||
{
|
||
int iIndexGroup = _GetGroupIndex(iIndex);
|
||
if (_GetItem(iIndexGroup)->dwFlags & TIF_ISGLOMMING)
|
||
{
|
||
aii.fState = ANIMATE_GLOM;
|
||
}
|
||
}
|
||
else if (aii.fState == ANIMATE_GLOM)
|
||
{
|
||
_GetItem(iIndex)->dwFlags |= TIF_ISGLOMMING;
|
||
}
|
||
|
||
// Number of items to animate
|
||
int cItems = 1;
|
||
if (fGlomAnimation)
|
||
{
|
||
// insert the group
|
||
cItems = _GetGroupSize(iIndex);
|
||
iIndex++;
|
||
}
|
||
|
||
// Insert items into animation list
|
||
while(cItems)
|
||
{
|
||
aii.iIndex = iIndex;
|
||
aii.pti = _GetItem(iIndex);
|
||
if (aii.fState == ANIMATE_DELETE)
|
||
{
|
||
// NOTE: HWND_TOPMOST is used here to indicate that the deleted
|
||
// button is being animated. This allows the button to stay
|
||
// around after its hwnd becomes invalid
|
||
aii.pti->hwnd = HWND_TOPMOST;
|
||
aii.pti->dwFlags |= TIF_TRANSPARENT;
|
||
}
|
||
|
||
//sorts left to right && removes redundant items
|
||
int iAnimationPos = _GetAnimationInsertPos(iIndex);
|
||
_dsaAII.InsertItem(iAnimationPos++, &aii);
|
||
|
||
cItems--;
|
||
iIndex++;
|
||
}
|
||
|
||
SetTimer(_hwnd, IDT_ASYNCANIMATION, 100, NULL);
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Animates the items in the animtation list by one step.
|
||
//-----------------------------------------------------------------------------
|
||
void CTaskBand::_AsyncAnimateItems()
|
||
{
|
||
BOOL fRedraw = (BOOL)SendMessage(_tb, WM_SETREDRAW, FALSE, 0);
|
||
// Glomming is turned off here because in the middle of the animation we
|
||
// may call _DeleteItem which could cause an unglom\glom.
|
||
// This is bad because it would modify the contents of animation list that
|
||
// we are in the middle of processing.
|
||
BOOL fGlom = _fGlom;
|
||
_fGlom = FALSE;
|
||
|
||
_UpdateAnimationIndices();
|
||
_ResizeAnimationItems();
|
||
int iDistanceLeft = _CheckAnimationSize();
|
||
|
||
_fGlom = fGlom;
|
||
|
||
_CheckSize();
|
||
SendMessage(_tb, WM_SETREDRAW, fRedraw, 0);
|
||
UpdateWindow(_tb);
|
||
|
||
if (_dsaAII.GetItemCount())
|
||
{
|
||
SetTimer(_hwnd, IDT_ASYNCANIMATION, _GetStepTime(iDistanceLeft), NULL);
|
||
}
|
||
else
|
||
{
|
||
KillTimer(_hwnd, IDT_ASYNCANIMATION);
|
||
|
||
if (_ptray->_hwndLastActive)
|
||
{
|
||
int iIndex = _FindIndexByHwnd(_ptray->_hwndLastActive);
|
||
if ((iIndex != -1) && (_IsButtonChecked(iIndex)))
|
||
{
|
||
_ScrollIntoView(iIndex);
|
||
}
|
||
}
|
||
|
||
_RestoreThreadPriority();
|
||
|
||
// Make sure no one was glommed into a group of one
|
||
// there are certain race conditions where this can happen
|
||
for (int i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
if (!pti->hwnd)
|
||
{
|
||
int iSize = _GetGroupSize(i);
|
||
if ((iSize < 2) && (!_IsHidden(i)))
|
||
{
|
||
_Glom(i, FALSE);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Adjusts the widths of the animating items by the animation
|
||
// step.
|
||
//
|
||
// RETURN: The Total width of all animating items.
|
||
//-----------------------------------------------------------------------------
|
||
void CTaskBand::_ResizeAnimationItems()
|
||
{
|
||
int cxStep = _GetAnimationStep();
|
||
|
||
for (int i = _dsaAII.GetItemCount() - 1; i >= 0; i--)
|
||
{
|
||
PANIMATIONITEMINFO paii = _dsaAII.GetItemPtr(i);
|
||
_SetAnimationItemWidth(paii, cxStep);
|
||
}
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Checks if animation items have reached their target animation
|
||
// width
|
||
//
|
||
// RETURN: The total distance left to animate
|
||
//-----------------------------------------------------------------------------
|
||
int CTaskBand::_CheckAnimationSize()
|
||
{
|
||
PANIMATIONITEMINFO paii;
|
||
int iTotDistLeft = 0;
|
||
int iRemainder = 0;
|
||
int iNormalWidth = _GetIdealWidth(&iRemainder);
|
||
int cAnimatingItems = _dsaAII.GetItemCount();
|
||
|
||
for (int i = cAnimatingItems - 1; i >= 0; i--)
|
||
{
|
||
paii = _dsaAII.GetItemPtr(i);
|
||
|
||
if (paii)
|
||
{
|
||
int iDistLeft = _GetAnimationDistLeft(paii, iNormalWidth);
|
||
if (!iDistLeft)
|
||
{
|
||
ANIMATIONITEMINFO aiiTemp = *paii;
|
||
_dsaAII.DeleteItem(i);
|
||
_FinishAnimation(&aiiTemp);
|
||
}
|
||
else
|
||
{
|
||
iTotDistLeft += iDistLeft;
|
||
}
|
||
}
|
||
#ifdef DEBUG
|
||
else
|
||
{
|
||
int nCurrentCount = _dsaAII.GetItemCount();
|
||
if (i >= nCurrentCount)
|
||
TraceMsg(TF_ERROR, "Invalid counter %x in the loop, size = %x", i, nCurrentCount);
|
||
else
|
||
TraceMsg(TF_ERROR, "NULL paii for %x.", i);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
return iTotDistLeft;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Sets the animation state for an ANIMATIONITEMINFO struct.
|
||
//
|
||
// PARAMETERS: 1. paii - PANIMATIONITEMINFO for the animation item
|
||
// 2. fExpand - TRUE = Insert or Unglom, FALSE = Delete or Glom
|
||
// 3. fGlomAnimation - TRUE = this is a glom or unglom animation
|
||
//-----------------------------------------------------------------------------
|
||
void CTaskBand::_SetAnimationState(PANIMATIONITEMINFO paii, BOOL fExpand,
|
||
BOOL fGlomAnimation)
|
||
{
|
||
if (fExpand)
|
||
{
|
||
paii->fState = ANIMATE_INSERT;
|
||
}
|
||
else
|
||
{
|
||
if (fGlomAnimation)
|
||
{
|
||
paii->fState = ANIMATE_GLOM;
|
||
}
|
||
else
|
||
{
|
||
paii->fState = ANIMATE_DELETE;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Determines the animation list index that keeps the list in the
|
||
// same order as the toolbar indexes.
|
||
// (Duplicate toolbar items are removed from the animation list.)
|
||
//
|
||
// PARAMETERS: 1. iIndex - item's index in the toolbar
|
||
//
|
||
// RETURN: The position the item should be inserted into the animation list
|
||
//-----------------------------------------------------------------------------
|
||
int CTaskBand::_GetAnimationInsertPos(int iIndex)
|
||
{
|
||
int iPos = 0;
|
||
|
||
if (_dsaAII.GetItemCount())
|
||
{
|
||
_UpdateAnimationIndices();
|
||
|
||
for (int i = _dsaAII.GetItemCount() - 1; i >= 0; i--)
|
||
{
|
||
PANIMATIONITEMINFO paii = _dsaAII.GetItemPtr(i);
|
||
|
||
if (paii->iIndex == iIndex)
|
||
{
|
||
// remove duplicate
|
||
_dsaAII.DeleteItem(i);
|
||
iPos = i;
|
||
break;
|
||
}
|
||
else if (paii->iIndex < iIndex)
|
||
{
|
||
iPos = i + 1;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return iPos;
|
||
}
|
||
|
||
void CTaskBand::_RemoveItemFromAnimationList(PTASKITEM ptiRemove)
|
||
{
|
||
for (int i = _dsaAII.GetItemCount() - 1; i >= 0; i--)
|
||
{
|
||
PANIMATIONITEMINFO paii = _dsaAII.GetItemPtr(i);
|
||
if (paii->pti == ptiRemove)
|
||
{
|
||
_dsaAII.DeleteItem(i);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Adjusts the width of the animating item by the animation step.
|
||
//
|
||
// PARAMETERS: 1. paii - PANIMATIONITEMINFO for the animation item
|
||
// 2. cxStep - animation step used to adjust the item's width
|
||
//
|
||
// RETURN: the new width
|
||
//-----------------------------------------------------------------------------
|
||
#define ANIM_SLOWSTEPS 3
|
||
#define ANIM_SLOWZONE 15
|
||
void CTaskBand::_SetAnimationItemWidth(PANIMATIONITEMINFO paii, int cxStep)
|
||
{
|
||
int iWidth = _GetItemWidth(paii->iIndex);
|
||
|
||
switch (paii->fState)
|
||
{
|
||
case ANIMATE_INSERT:
|
||
iWidth += cxStep;
|
||
break;
|
||
case ANIMATE_DELETE:
|
||
//slow animation towards end
|
||
if (((iWidth / cxStep) <= ANIM_SLOWSTEPS) &&
|
||
((iWidth - cxStep) < ANIM_SLOWZONE - _GetVisibleItemCount()))
|
||
{
|
||
// The last step takes 3 times as long
|
||
cxStep = cxStep / 3;
|
||
}
|
||
iWidth -= cxStep;
|
||
iWidth = max(iWidth, 0);
|
||
break;
|
||
case ANIMATE_GLOM:
|
||
iWidth -= cxStep;
|
||
iWidth = max(iWidth, 1); //toolbar sizes 0 width to full size
|
||
break;
|
||
}
|
||
|
||
_SetItemWidth(paii->iIndex, iWidth);
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Returns the distance the items must travel to end the
|
||
// animation
|
||
//
|
||
// PARAMETERS: 1. paii - pointer to the ANIMATIONITEMINFO for the item
|
||
// 2. iNormalWidth - width of a non-animation item
|
||
//
|
||
// RETURN: the distance the items must travel to end the animation
|
||
//-----------------------------------------------------------------------------
|
||
int CTaskBand::_GetAnimationDistLeft(PANIMATIONITEMINFO paii, int iNormalWidth)
|
||
{
|
||
int cxDistLeft = 0;
|
||
int iWidth = _GetItemWidth(paii->iIndex);
|
||
|
||
switch (paii->fState)
|
||
{
|
||
case ANIMATE_INSERT:
|
||
cxDistLeft = max(0, iNormalWidth - iWidth);
|
||
break;
|
||
|
||
case ANIMATE_DELETE:
|
||
if ((paii->iIndex == _GetLastVisibleItem()) && (iNormalWidth == g_cxMinimized))
|
||
{
|
||
cxDistLeft = 0;
|
||
}
|
||
else
|
||
{
|
||
cxDistLeft = max(0, iWidth);
|
||
}
|
||
break;
|
||
|
||
case ANIMATE_GLOM:
|
||
{
|
||
int iGroupIndex = _GetGroupIndex(paii->iIndex);
|
||
|
||
if (!ToolBar_IsVisible(_tb, iGroupIndex))
|
||
{
|
||
int cGroupSize = _GetGroupSize(iGroupIndex);
|
||
if (cGroupSize)
|
||
{
|
||
int iGroupWidth = _GetGroupWidth(iGroupIndex);
|
||
cxDistLeft = max(0, iGroupWidth - iNormalWidth);
|
||
if (iGroupWidth == cGroupSize)
|
||
{
|
||
cxDistLeft = 0;
|
||
}
|
||
cxDistLeft = cxDistLeft/cGroupSize;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
}
|
||
return cxDistLeft;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Completes tasks to finish an animation
|
||
//
|
||
// PARAMETERS: 1. paii - pointer to the ANIMATIONITEMINFO for the item
|
||
//
|
||
// RETURN: the distance the items must travel to end the animation
|
||
//-----------------------------------------------------------------------------
|
||
void CTaskBand::_FinishAnimation(PANIMATIONITEMINFO paii)
|
||
{
|
||
switch (paii->fState)
|
||
{
|
||
case ANIMATE_DELETE:
|
||
_DeleteItem(NULL, paii->iIndex);
|
||
break;
|
||
|
||
case ANIMATE_GLOM:
|
||
{
|
||
int iGroupIndex = _GetGroupIndex(paii->iIndex);
|
||
|
||
if (!ToolBar_IsVisible(_tb, iGroupIndex))
|
||
{
|
||
// Turn off glomming flag
|
||
_GetItem(iGroupIndex)->dwFlags &= ~TIF_ISGLOMMING;
|
||
_HideGroup(iGroupIndex, TRUE);
|
||
}
|
||
|
||
// NOTE: HWND_TOPMOST is used to indicate that the deleted button
|
||
// is being animated. This allows the button to stay around after
|
||
// its real hwnd becomes invalid
|
||
if (paii->pti->hwnd == HWND_TOPMOST)
|
||
{
|
||
// The button was deleting before it was glommed
|
||
// Now that the glomming is done, delete it.
|
||
_DeleteItem(NULL, paii->iIndex);
|
||
}
|
||
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Returns the width of all the animating buttons
|
||
//
|
||
// RETURN: The total animation width
|
||
//-----------------------------------------------------------------------------
|
||
int CTaskBand::_GetAnimationWidth()
|
||
{
|
||
int iTotAnimationWidth = 0;
|
||
|
||
_UpdateAnimationIndices();
|
||
|
||
for (int i = _dsaAII.GetItemCount() - 1; i >= 0; i--)
|
||
{
|
||
PANIMATIONITEMINFO paii = _dsaAII.GetItemPtr(i);
|
||
iTotAnimationWidth += _GetItemWidth(paii->iIndex);
|
||
}
|
||
|
||
return iTotAnimationWidth;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Synchronizes the indexes held by the animating items to the
|
||
// true toolbar indexes.
|
||
// Note: This function may cause the number of animating items to
|
||
// change.
|
||
//-----------------------------------------------------------------------------
|
||
void CTaskBand::_UpdateAnimationIndices()
|
||
{
|
||
int cAnimatingItems = _dsaAII.GetItemCount();
|
||
|
||
if (cAnimatingItems)
|
||
{
|
||
// NOTE: items in the animation list are in the same order as the
|
||
// toolbar
|
||
int iCurrAnimationItem = cAnimatingItems - 1;
|
||
PANIMATIONITEMINFO paii = _dsaAII.GetItemPtr(iCurrAnimationItem);
|
||
|
||
for (int i = _tb.GetButtonCount() - 1; i >=0 ; i--)
|
||
{
|
||
if (_GetItem(i) == paii->pti)
|
||
{
|
||
paii->iIndex = i;
|
||
iCurrAnimationItem--;
|
||
if (iCurrAnimationItem < 0)
|
||
{
|
||
break;
|
||
}
|
||
paii = _dsaAII.GetItemPtr(iCurrAnimationItem);
|
||
}
|
||
}
|
||
|
||
// If animation items are not in the same order as the items in the
|
||
// toolbar then iCurrAnimationItem not be -1
|
||
//ASSERT(iCurrAnimationItem == -1);
|
||
if (iCurrAnimationItem != -1)
|
||
{
|
||
_UpdateAnimationIndicesSlow();
|
||
}
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_UpdateAnimationIndicesSlow()
|
||
{
|
||
#ifdef DEBUG
|
||
int cAnimatingItems = _dsaAII.GetItemCount();
|
||
TraceMsg(TF_WARNING, "CTaskBand::_UpdateAnimationIndicesSlow: enter");
|
||
#endif
|
||
|
||
for (int i = _dsaAII.GetItemCount() - 1; i >= 0; i--)
|
||
{
|
||
PANIMATIONITEMINFO paii = _dsaAII.GetItemPtr(i);
|
||
int iIndex = _FindItem(paii->pti);
|
||
if (iIndex == -1)
|
||
{
|
||
_dsaAII.DeleteItem(i);
|
||
}
|
||
else
|
||
{
|
||
paii->iIndex = i;
|
||
}
|
||
}
|
||
|
||
#ifdef DEBUG
|
||
// Being in this function means that either an animating item is no longer in the
|
||
// toolbar, or that the animating items are in a different order than the toolbar.
|
||
// If the animating items are only in a different order (bad), the number of animating
|
||
// items will remain the same.
|
||
if (cAnimatingItems == _dsaAII.GetItemCount())
|
||
{
|
||
TraceMsg(TF_WARNING, "CTaskBand::_UpdateAnimationIndicesSlow: Animating items are in diff order than toolbar");
|
||
}
|
||
#endif
|
||
|
||
}
|
||
|
||
int CTaskBand::_FindItem(PTASKITEM pti)
|
||
{
|
||
int iIndex = -1;
|
||
|
||
if (pti)
|
||
{
|
||
for (int i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
if (pti == _GetItem(i))
|
||
{
|
||
iIndex = i;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return iIndex;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Animation Step Constants
|
||
//-----------------------------------------------------------------------------
|
||
#define ANIM_STEPFACTOR 9
|
||
#define ANIM_STEPMAX 40 // max size of an animation step
|
||
#define ANIM_STEPMIN 11 // min size of an animation step
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Determines an animation step based on the number of items
|
||
// visible in the toolbar.
|
||
//
|
||
// PARAMETERS: 1. iTotalItems - number of visible items in toolbar
|
||
//
|
||
// RETURN: The animation step
|
||
//-----------------------------------------------------------------------------
|
||
int CTaskBand::_GetAnimationStep()
|
||
{
|
||
DWORD dwStep;
|
||
int iVisibleItems = _GetVisibleItemCount();
|
||
|
||
int iRows;
|
||
_GetNumberOfRowsCols(&iRows, NULL, TRUE); // _GetNumberOfRows will never return < 1
|
||
int iTotalItems = iVisibleItems - _dsaAII.GetItemCount();
|
||
|
||
// The step must be large when there are many items, but can be very small
|
||
// when there are few items. This is achieved by cubing the total items.
|
||
dwStep = (DWORD)(iTotalItems * iTotalItems * iTotalItems) / ANIM_STEPFACTOR;
|
||
dwStep = min(dwStep, ANIM_STEPMAX);
|
||
dwStep = max(dwStep, ANIM_STEPMIN);
|
||
|
||
return dwStep;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Animation Sleep Constants
|
||
//-----------------------------------------------------------------------------
|
||
#define ANIM_PAUSE 1000
|
||
#define ANIM_MAXPAUSE 30
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Returns the amount of time to sleep
|
||
//
|
||
// PARAMETERS: 1. iStep - current animation step
|
||
// 2. cSteps - total animation steps
|
||
// 3. iStepSize - step size for the animation
|
||
//
|
||
// RETURN: time to sleep
|
||
//-----------------------------------------------------------------------------
|
||
DWORD CTaskBand::_GetStepTime(int cx)
|
||
{
|
||
// NOTE: The cx is decrementing to ZERO.
|
||
// As the cx gets smaller we want to
|
||
// increment the sleep time.
|
||
|
||
// don't let cx be zero
|
||
cx = max(1, cx);
|
||
cx = min(32767, cx);
|
||
|
||
// x^2 curve gives a larger pause at the end.
|
||
int iDenominator = cx * cx;
|
||
|
||
return min(ANIM_MAXPAUSE, ANIM_PAUSE / iDenominator);
|
||
}
|
||
|
||
//*****************************************************************************
|
||
// END OF ANIMATION FUNCTIONS
|
||
//*****************************************************************************
|
||
|
||
void CTaskBand::_SetItemWidth(int iItem, int iWidth)
|
||
{
|
||
TBBUTTONINFO tbbi;
|
||
tbbi.cbSize = sizeof(tbbi);
|
||
tbbi.dwMask = TBIF_SIZE | TBIF_BYINDEX;
|
||
|
||
tbbi.cx = (WORD)iWidth;
|
||
|
||
_tb.SetButtonInfo(iItem, &tbbi);
|
||
}
|
||
|
||
|
||
int CTaskBand::_GetItemWidth(int iItem)
|
||
{
|
||
TBBUTTONINFO tbbi;
|
||
tbbi.cbSize = sizeof(tbbi);
|
||
tbbi.dwMask = TBIF_SIZE | TBIF_BYINDEX;
|
||
|
||
_tb.GetButtonInfo(iItem, &tbbi);
|
||
|
||
return tbbi.cx;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Retrives the index of the last visible button on the toolbar
|
||
//
|
||
// RETURN: Index of the last visible item on the toolbar.
|
||
//-----------------------------------------------------------------------------
|
||
int CTaskBand::_GetLastVisibleItem()
|
||
{
|
||
int iLastIndex = -1;
|
||
|
||
for (int i = _tb.GetButtonCount() - 1; i >=0 ; i--)
|
||
{
|
||
if (ToolBar_IsVisible(_tb, i))
|
||
{
|
||
iLastIndex = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
return iLastIndex;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Retrives the total width of all buttons in the group
|
||
//
|
||
// PARAMETERS: 1. iIndexGroup - the index of the group
|
||
//
|
||
// RETURN: the total width of all buttons in the group
|
||
//-----------------------------------------------------------------------------
|
||
int CTaskBand::_GetGroupWidth(int iIndexGroup)
|
||
{
|
||
int iGroupWidth = 0;
|
||
|
||
int cButtons = _tb.GetButtonCount();
|
||
for (int i = iIndexGroup + 1; i < cButtons; i++)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
if (!pti->hwnd)
|
||
{
|
||
break;
|
||
}
|
||
iGroupWidth += _GetItemWidth(i);
|
||
}
|
||
|
||
return iGroupWidth;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Retrives the number of visible buttons on the toolbar
|
||
|
||
// RETURN: the number of visible buttons on the toolbar
|
||
//-----------------------------------------------------------------------------
|
||
int CTaskBand::_GetVisibleItemCount()
|
||
{
|
||
int cItems = 0;
|
||
|
||
// Count the number of visible buttons before the animated item(s)
|
||
for (int i = _tb.GetButtonCount() - 1; i >=0 ; i--)
|
||
{
|
||
if (ToolBar_IsVisible(_tb, i))
|
||
{
|
||
cItems++;
|
||
}
|
||
}
|
||
|
||
return cItems;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Retrives the ideal width of a non-animating button
|
||
//
|
||
// PARAMETERS: 1. iRemainder[OUT] - width needed for the total item width
|
||
// to equal the window width. (set to zero unless the ideal
|
||
// width is less than the maximum button width.
|
||
//
|
||
// RETURN: the total width of all buttons in the group
|
||
//-----------------------------------------------------------------------------
|
||
int CTaskBand::_GetIdealWidth(int *iRemainder)
|
||
{
|
||
int iIdeal = 0;
|
||
*iRemainder = 0;
|
||
|
||
RECT rcWin;
|
||
GetWindowRect(_hwnd, &rcWin);
|
||
int iWinWidth = RECTWIDTH(rcWin);
|
||
int iRows;
|
||
_GetNumberOfRowsCols(&iRows, NULL, TRUE);
|
||
int cItems = _GetVisibleItemCount();
|
||
|
||
// button spacing
|
||
TBMETRICS tbm;
|
||
_GetToolbarMetrics(&tbm);
|
||
|
||
if (iRows == 1)
|
||
{
|
||
// window width that can be used for non-animating items
|
||
iWinWidth -= (_GetAnimationWidth() + (_dsaAII.GetItemCount() * tbm.cxButtonSpacing));
|
||
iWinWidth = max(0, iWinWidth);
|
||
|
||
// find number of non-animating items
|
||
cItems -= _dsaAII.GetItemCount();
|
||
cItems = max(1, cItems);
|
||
}
|
||
|
||
// We need to round up so that iCols is the smallest number such that
|
||
// iCols*iRows >= cItems
|
||
int iCols = (cItems + iRows - 1) / iRows;
|
||
iCols = max(1, iCols);
|
||
|
||
// calculate the ideal width
|
||
iIdeal = (iWinWidth / iCols);
|
||
if (iCols > 1)
|
||
{
|
||
iIdeal -= tbm.cxButtonSpacing;
|
||
}
|
||
|
||
// adjust ideal width
|
||
int iMax = _IsHorizontal() ? g_cxMinimized : iWinWidth;
|
||
int iMin = g_cySize + 2*g_cxEdge;
|
||
if (_IsHorizontal())
|
||
{
|
||
iMin *= 1.8;
|
||
}
|
||
iMin += _GetTextSpace();
|
||
iIdeal = min(iMax, iIdeal);
|
||
|
||
// calculate the remainder
|
||
if (_IsHorizontal() && (iIdeal != iMax) && (iRows == 1) && (iIdeal >= iMin))
|
||
{
|
||
*iRemainder = iWinWidth - (iCols * (iIdeal + tbm.cxButtonSpacing));
|
||
*iRemainder = max(0, *iRemainder);
|
||
}
|
||
|
||
return iIdeal;
|
||
}
|
||
|
||
|
||
void CTaskBand::_GetNumberOfRowsCols(int* piRows, int* piCols, BOOL fCurrentSize)
|
||
{
|
||
RECT rcWin;
|
||
RECT rcItem;
|
||
RECT rcTB;
|
||
int iIndexVisible = _GetLastVisibleItem();
|
||
|
||
GetWindowRect(_hwnd, &rcWin);
|
||
int cxTB = RECTWIDTH(rcWin);
|
||
int cyTB = RECTHEIGHT(rcWin);
|
||
|
||
if (fCurrentSize)
|
||
{
|
||
GetWindowRect(_tb, &rcTB);
|
||
DWORD dwStyle = GetWindowLong(_hwnd, GWL_STYLE);
|
||
if (dwStyle & WS_HSCROLL)
|
||
{
|
||
cyTB = RECTHEIGHT(rcTB);
|
||
}
|
||
else if (dwStyle & WS_VSCROLL)
|
||
{
|
||
cxTB = RECTWIDTH(rcTB);
|
||
}
|
||
}
|
||
|
||
_tb.GetItemRect(iIndexVisible, &rcItem);
|
||
|
||
TBMETRICS tbm;
|
||
_GetToolbarMetrics(&tbm);
|
||
|
||
if (piRows)
|
||
{
|
||
int cyRow = RECTHEIGHT(rcItem) + tbm.cyButtonSpacing;
|
||
*piRows = (cyTB + tbm.cyButtonSpacing) / cyRow;
|
||
*piRows = max(*piRows, 1);
|
||
}
|
||
|
||
if (piCols && RECTWIDTH(rcItem))
|
||
{
|
||
int cxCol = RECTWIDTH(rcItem) + tbm.cxButtonSpacing;
|
||
*piCols = (cxTB + tbm.cxButtonSpacing) / cxCol;
|
||
*piCols = max(*piCols, 1);
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Retrives the minimum text width for a button. (used only to
|
||
// determine when task items should be glommed.)
|
||
//
|
||
// RETURN: the minimum text width for a button
|
||
//-----------------------------------------------------------------------------
|
||
int CTaskBand::_GetTextSpace()
|
||
{
|
||
int iTextSpace = 0;
|
||
|
||
if (_fGlom && _IsHorizontal() && (_iGroupSize < GLOM_SIZE))
|
||
{
|
||
if (!_iTextSpace)
|
||
{
|
||
HFONT hfont = (HFONT)SendMessage(_tb, WM_GETFONT, 0, 0);
|
||
if (hfont)
|
||
{
|
||
HDC hdc = GetDC(_tb);
|
||
TEXTMETRIC tm;
|
||
GetTextMetrics(hdc, &tm);
|
||
|
||
_iTextSpace = tm.tmAveCharWidth * 8;
|
||
ReleaseDC(_tb, hdc);
|
||
}
|
||
}
|
||
iTextSpace = _iTextSpace;
|
||
}
|
||
return iTextSpace;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Retrieves the toolbar metrics requested by the mask
|
||
//
|
||
// RETURN: toolbar metrics
|
||
//-----------------------------------------------------------------------------
|
||
void CTaskBand::_GetToolbarMetrics(TBMETRICS *ptbm)
|
||
{
|
||
ptbm->cbSize = sizeof(*ptbm);
|
||
ptbm->dwMask = TBMF_PAD | TBMF_BARPAD | TBMF_BUTTONSPACING;
|
||
_tb.SendMessage(TB_GETMETRICS, 0, (LPARAM)ptbm);
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Sizes the non-animating buttons to the taskbar. Shrinks
|
||
// and/or gloms items so that all visible items fit on window.
|
||
//-----------------------------------------------------------------------------
|
||
void CTaskBand::_CheckSize()
|
||
{
|
||
if (_dsaAII)
|
||
{
|
||
int cItems = _GetVisibleItemCount();
|
||
// Check for non-animating buttons to size
|
||
if (cItems > _dsaAII.GetItemCount())
|
||
{
|
||
// Handle grouping by size
|
||
if (_fGlom && (_iGroupSize >= GLOM_SIZE))
|
||
{
|
||
_AutoGlomGroup(TRUE, 0);
|
||
}
|
||
|
||
RECT rc;
|
||
GetWindowRect(_hwnd, &rc);
|
||
if (!IsRectEmpty(&rc) && (_tb.GetWindowLong(GWL_STYLE) & WS_VISIBLE))
|
||
{
|
||
int iRemainder = 0;
|
||
int iIdeal = _GetIdealWidth(&iRemainder);
|
||
BOOL fHoriz = _IsHorizontal();
|
||
|
||
int iMin = g_cySize + 2*g_cxEdge;
|
||
if (fHoriz)
|
||
{
|
||
iMin *= 1.8;
|
||
}
|
||
iMin += _GetTextSpace();
|
||
iIdeal = max(iIdeal, iMin);
|
||
|
||
_SizeItems(iIdeal, iRemainder);
|
||
_tb.SetButtonWidth(iIdeal, iIdeal);
|
||
|
||
int iRows;
|
||
int iCols;
|
||
_GetNumberOfRowsCols(&iRows, &iCols, FALSE);
|
||
|
||
BOOL fAllowUnGlom = TRUE;
|
||
|
||
if (_fGlom && fHoriz && (iIdeal == iMin))
|
||
{
|
||
_AutoGlomGroup(TRUE, 0);
|
||
|
||
iMin = (g_cySize + 2*g_cxEdge) * 1.8;
|
||
iIdeal = _GetIdealWidth(&iRemainder);
|
||
iIdeal = max(iIdeal, iMin);
|
||
|
||
_SizeItems(iIdeal, iRemainder);
|
||
_tb.SetButtonWidth(iIdeal, iIdeal);
|
||
|
||
fAllowUnGlom = FALSE;
|
||
}
|
||
|
||
// if we're forced to the minimum size, then we may need some scrollbars
|
||
if ((fHoriz && (iIdeal == iMin)) || (!fHoriz && (cItems > (iRows * iCols))))
|
||
{
|
||
if (!(_fGlom && _AutoGlomGroup(TRUE, 0)))
|
||
{
|
||
TBMETRICS tbm;
|
||
_GetToolbarMetrics(&tbm);
|
||
|
||
RECT rcItem;
|
||
_tb.GetItemRect(_GetLastVisibleItem(), &rcItem);
|
||
int cyRow = RECTHEIGHT(rcItem) + tbm.cyButtonSpacing;
|
||
int iColsInner = (cItems + iRows - 1) / iRows;
|
||
|
||
_CheckNeedScrollbars(cyRow, cItems, iColsInner, iRows, iIdeal + tbm.cxButtonSpacing, &rc);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
int cOpenSlots = fHoriz ? ((RECTWIDTH(rc) - _GetAnimationWidth()) -
|
||
(iMin * (cItems - _dsaAII.GetItemCount()))) / iMin : iRows - cItems;
|
||
if (!(_fGlom && (cOpenSlots >= 2) && fAllowUnGlom && _AutoGlomGroup(FALSE, cOpenSlots)))
|
||
{
|
||
_NukeScrollbar(SB_HORZ);
|
||
_NukeScrollbar(SB_VERT);
|
||
_tb.SetWindowPos(0, 0, 0, RECTWIDTH(rc), RECTHEIGHT(rc), SWP_NOACTIVATE | SWP_NOZORDER);
|
||
}
|
||
}
|
||
|
||
// force wrap recalc
|
||
_tb.AutoSize();
|
||
}
|
||
else
|
||
{
|
||
_SizeItems(g_cxMinimized);
|
||
_tb.SetButtonWidth(g_cxMinimized, g_cxMinimized);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// DESCRIPTION: Set the sizes of non-animating buttons
|
||
//
|
||
// PARAMETERS: 1. iButtonWidth - width to assign each non-animating item
|
||
// 2. IRemainder - extra width to keep total width constant.
|
||
//
|
||
//-----------------------------------------------------------------------------
|
||
void CTaskBand::_SizeItems(int iButtonWidth, int iRemainder)
|
||
{
|
||
|
||
TBBUTTONINFO tbbi;
|
||
tbbi.cbSize = sizeof(tbbi);
|
||
tbbi.dwMask = TBIF_SIZE | TBIF_BYINDEX;
|
||
|
||
int iAnimCount = _dsaAII.GetItemCount();
|
||
|
||
for (int i = _tb.GetButtonCount() - 1; i >=0 ; i--)
|
||
{
|
||
if (ToolBar_IsVisible(_tb, i))
|
||
{
|
||
BOOL fResize = TRUE;
|
||
|
||
if (iAnimCount)
|
||
{
|
||
for (int j = 0; (j < iAnimCount) && fResize; j++)
|
||
{
|
||
PANIMATIONITEMINFO paii = _dsaAII.GetItemPtr(j);
|
||
if (paii->iIndex == i)
|
||
{
|
||
fResize = FALSE;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (fResize)
|
||
{
|
||
tbbi.cx = (WORD) iButtonWidth;
|
||
|
||
if (iRemainder)
|
||
{
|
||
tbbi.cx++;
|
||
iRemainder--;
|
||
}
|
||
|
||
_tb.SetButtonInfo(i, &tbbi);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
//---------------------------------------------------------------------------
|
||
|
||
//
|
||
// Track which shortcut launched a particular task.
|
||
// Every so often, we tickle the file's entry in the UEM database
|
||
// to indicate that the program has been running for a long time.
|
||
//
|
||
// These structures are used only by the taskbar thread, hence do
|
||
// not need to be thread-safe.
|
||
//
|
||
class TaskShortcut
|
||
{
|
||
public:
|
||
|
||
TaskShortcut(LPCTSTR pszExeName, DWORD pid);
|
||
|
||
void AddRef() { _cRef++; }
|
||
void Release() { if (--_cRef == 0) delete this; }
|
||
void Tickle();
|
||
void Promote();
|
||
static BOOL _PromotePidl(LPCITEMIDLIST pidl, BOOL fForce);
|
||
inline BOOL MatchesCachedPid(PTASKITEM pti)
|
||
{
|
||
return _pid == s_pidCache;
|
||
}
|
||
static BOOL MatchesCachedExe(PTASKITEM pti)
|
||
{
|
||
return pti->pszExeName &&
|
||
lstrcmpiW(pti->pszExeName, s_szTargetNameCache) == 0;
|
||
}
|
||
inline BOOL MatchesPid(DWORD pid) const { return pid == _pid; }
|
||
void SetInfoFromCache();
|
||
static BOOL _HandleShortcutInvoke(LPSHShortcutInvokeAsIDList psidl);
|
||
|
||
//
|
||
// Note that the session time is now hard-coded to 4 hours and is not
|
||
// affected by the browseui session time.
|
||
//
|
||
enum {
|
||
s_msSession = 4 * 3600 * 1000 // 4 hours - per DCR
|
||
};
|
||
|
||
private:
|
||
static DWORD s_pidCache;
|
||
static int s_csidlCache;
|
||
static WCHAR s_szShortcutNameCache[MAX_PATH];
|
||
static WCHAR s_szTargetNameCache[MAX_PATH];
|
||
|
||
private:
|
||
~TaskShortcut() { SHFree(_pszShortcutName); }
|
||
|
||
ULONG _cRef; // reference count
|
||
DWORD _pid; // process id
|
||
DWORD _tmTickle; // time of last tickle
|
||
int _csidl; // csidl we are a child of
|
||
LPWSTR _pszShortcutName; // Which shortcut launched us? (NULL = don't know)
|
||
};
|
||
|
||
//---------------------------------------------------------------------------
|
||
//
|
||
DWORD TaskShortcut::s_pidCache;
|
||
int TaskShortcut::s_csidlCache;
|
||
WCHAR TaskShortcut::s_szShortcutNameCache[MAX_PATH];
|
||
WCHAR TaskShortcut::s_szTargetNameCache[MAX_PATH];
|
||
|
||
TaskShortcut::TaskShortcut(LPCTSTR pszExeName, DWORD pid)
|
||
: _cRef(1), _pid(pid), _tmTickle(GetTickCount()), _pszShortcutName(NULL)
|
||
{
|
||
// If this app was recently launched from a shortcut,
|
||
// save the shortcut name.
|
||
if (s_pidCache == pid &&
|
||
pszExeName &&
|
||
pszExeName[0] &&
|
||
lstrcmpi(pszExeName, s_szTargetNameCache) == 0)
|
||
{
|
||
SetInfoFromCache();
|
||
}
|
||
}
|
||
|
||
void TaskShortcut::SetInfoFromCache()
|
||
{
|
||
_csidl = s_csidlCache;
|
||
SHStrDup(s_szShortcutNameCache, &_pszShortcutName);
|
||
}
|
||
|
||
|
||
//---------------------------------------------------------------------------
|
||
|
||
void CTaskBand::_AttachTaskShortcut(PTASKITEM pti, LPCTSTR pszExeName)
|
||
{
|
||
DWORD pid = 0;
|
||
GetWindowThreadProcessId(pti->hwnd, &pid);
|
||
|
||
int i;
|
||
for (i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
PTASKITEM ptiT = _GetItem(i);
|
||
if (ptiT->ptsh && ptiT->ptsh->MatchesPid(pid))
|
||
{
|
||
pti->ptsh = ptiT->ptsh;
|
||
pti->ptsh->AddRef();
|
||
return;
|
||
}
|
||
}
|
||
|
||
// Wow, the first window associated with this pid. Need to create
|
||
// a new entry.
|
||
|
||
// Make sure nobody tries to do this in a multithreaded way
|
||
// since we're not protecting the cache with a critical section
|
||
ASSERT(GetCurrentThreadId() == GetWindowThreadProcessId(_hwnd, NULL));
|
||
|
||
pti->ptsh = new TaskShortcut(pszExeName, pid);
|
||
}
|
||
|
||
//
|
||
// There is a race condition between app startup and our receiving the
|
||
// change notification. If the app starts up first, the
|
||
// _AttachTaskShortcut will fail because we haven't received the change
|
||
// notification yet.
|
||
//
|
||
// _ReattachTaskShortcut looks back through the taskbar and checks if
|
||
// the program for which we received the change notification is already
|
||
// on the taskbar, in which case we update his information retroactively.
|
||
//
|
||
void CTaskBand::_ReattachTaskShortcut()
|
||
{
|
||
// Make sure nobody tries to do this in a multithreaded way
|
||
// since we're not protecting the cache with a critical section
|
||
ASSERT(GetCurrentThreadId() == GetWindowThreadProcessId(_hwnd, NULL));
|
||
|
||
int i;
|
||
for (i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
PTASKITEM ptiT = _GetItem(i);
|
||
if (ptiT->ptsh && ptiT->ptsh->MatchesCachedPid(ptiT))
|
||
{
|
||
int iIndexGroup = _GetGroupIndex(i);
|
||
PTASKITEM ptiGroup = _GetItem(iIndexGroup);
|
||
if (ptiT->ptsh->MatchesCachedExe(ptiGroup))
|
||
{
|
||
ptiT->ptsh->SetInfoFromCache();
|
||
// Stop after finding the first match, since all apps
|
||
// with the same pid share the same TaskShortcut, so
|
||
// updating one entry fixes them all.
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
|
||
void TaskShortcut::Tickle()
|
||
{
|
||
if (_pszShortcutName)
|
||
{
|
||
DWORD tmNow = GetTickCount();
|
||
if (tmNow - _tmTickle > s_msSession)
|
||
{
|
||
_tmTickle = tmNow;
|
||
|
||
// Note that we promote only once, even if multiple tickle intervals
|
||
// have elapsed. That way, if you leave Outlook running while you
|
||
// go on a two-week vacation, then click on Outlook when you get
|
||
// back, we treat this as one usage, not dozens.
|
||
//
|
||
Promote();
|
||
}
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
// Returns whether or not we actually promoted anybody
|
||
|
||
BOOL TaskShortcut::_PromotePidl(LPCITEMIDLIST pidl, BOOL fForce)
|
||
{
|
||
BOOL fPromoted = FALSE;
|
||
IShellFolder *psf;
|
||
LPCITEMIDLIST pidlChild;
|
||
if (SUCCEEDED(SHBindToFolderIDListParent(NULL, pidl,
|
||
IID_PPV_ARG(IShellFolder, &psf), &pidlChild)))
|
||
{
|
||
if (!fForce)
|
||
{
|
||
// Don't fire the event if somebody else ran the
|
||
// shortcut within the last session. We want to bump
|
||
// the usage count only once per session even if there
|
||
// are multiple apps running that use the shortcut.
|
||
|
||
FILETIME ftSession; // start of current session
|
||
GetSystemTimeAsFileTime(&ftSession);
|
||
DecrementFILETIME(&ftSession, (__int64)10000 * s_msSession);
|
||
|
||
UEMINFO uei;
|
||
uei.cbSize = sizeof(uei);
|
||
uei.dwMask = UEIM_FILETIME;
|
||
SetFILETIMEfromInt64(&uei.ftExecute, 0);
|
||
|
||
// If this query fails, then uei.ftExecute stays 0
|
||
UEMQueryEvent(&UEMIID_SHELL, UEME_RUNPIDL,
|
||
(WPARAM)psf, (LPARAM)pidlChild, &uei);
|
||
|
||
fForce = CompareFileTime(&uei.ftExecute, &ftSession) < 0;
|
||
}
|
||
|
||
if (fForce)
|
||
{
|
||
UEMFireEvent(&UEMIID_SHELL, UEME_RUNPIDL, UEMF_XEVENT,
|
||
(WPARAM)psf, (LPARAM)pidlChild);
|
||
fPromoted = TRUE;
|
||
}
|
||
psf->Release();
|
||
}
|
||
return fPromoted;
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
|
||
void TaskShortcut::Promote()
|
||
{
|
||
// Use SHSimpleIDListFromPath so we don't spin up drives or
|
||
// hang Explorer if the drive is unavailable
|
||
LPITEMIDLIST pidl = SHSimpleIDListFromPath(_pszShortcutName);
|
||
if (pidl)
|
||
{
|
||
if (_PromotePidl(pidl, FALSE))
|
||
{
|
||
// Now we have to walk back up the tree to the root of our
|
||
// csidl, because that's what the Start Menu does.
|
||
// (Promoting a child entails promoting all his parents.
|
||
// Otherwise you can get into a weird state where a child
|
||
// has been promoted but his ancestors haven't.)
|
||
|
||
LPITEMIDLIST pidlParent;
|
||
if (SUCCEEDED(SHGetSpecialFolderLocation(NULL, _csidl, &pidlParent)))
|
||
{
|
||
for (ILRemoveLastID(pidl);
|
||
ILIsParent(pidlParent, pidl, FALSE); ILRemoveLastID(pidl))
|
||
{
|
||
_PromotePidl(pidl, TRUE);
|
||
}
|
||
}
|
||
}
|
||
ILFree(pidl);
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
|
||
BOOL _IsChildOfCsidl(int csidl, LPCWSTR pwszPath)
|
||
{
|
||
WCHAR wszCsidl[MAX_PATH];
|
||
|
||
// Explicitly check S_OK. S_FALSE means directory doesn't exist,
|
||
// so no point in checking for prefix.
|
||
if (S_OK == SHGetFolderPathW(NULL, csidl, NULL, SHGFP_TYPE_CURRENT, wszCsidl))
|
||
{
|
||
return PathIsPrefixW(wszCsidl, pwszPath);
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
const int c_rgCsidlShortcutInvoke[] = {
|
||
CSIDL_DESKTOPDIRECTORY,
|
||
CSIDL_PROGRAMS,
|
||
CSIDL_COMMON_DESKTOPDIRECTORY,
|
||
CSIDL_COMMON_PROGRAMS,
|
||
};
|
||
|
||
BOOL TaskShortcut::_HandleShortcutInvoke(LPSHShortcutInvokeAsIDList psidl)
|
||
{
|
||
// The shortcut must reside in one of the directories that the Start Page
|
||
// cares about
|
||
int i;
|
||
for (i = 0; i < ARRAYSIZE(c_rgCsidlShortcutInvoke); i++)
|
||
{
|
||
if (_IsChildOfCsidl(c_rgCsidlShortcutInvoke[i], psidl->szShortcutName))
|
||
{
|
||
// Yes it is -- cache it
|
||
s_pidCache = psidl->dwPid;
|
||
s_csidlCache = c_rgCsidlShortcutInvoke[i];
|
||
lstrcpynW(s_szShortcutNameCache, psidl->szShortcutName,ARRAYSIZE(s_szShortcutNameCache));
|
||
lstrcpynW(s_szTargetNameCache, psidl->szTargetName,ARRAYSIZE(s_szTargetNameCache));
|
||
return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
TASKITEM::TASKITEM(TASKITEM* pti)
|
||
{
|
||
hwnd = pti->hwnd;
|
||
dwFlags = pti->dwFlags;
|
||
ptsh = NULL;
|
||
dwTimeLastClicked = pti->dwTimeLastClicked;
|
||
dwTimeFirstOpened = pti->dwTimeFirstOpened;
|
||
|
||
if (pti->pszExeName)
|
||
{
|
||
pszExeName = new WCHAR[lstrlen(pti->pszExeName) +1];
|
||
if (pszExeName)
|
||
{
|
||
lstrcpy(pszExeName, pti->pszExeName);
|
||
}
|
||
}
|
||
}
|
||
|
||
TASKITEM::~TASKITEM()
|
||
{
|
||
if (ptsh) ptsh->Release();
|
||
if (pszExeName)
|
||
{
|
||
delete [] pszExeName;
|
||
}
|
||
}
|
||
|
||
BOOL IsSmallerThanScreen(HWND hwnd)
|
||
{
|
||
HMONITOR hMonitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTOPRIMARY);
|
||
MONITORINFO mi;
|
||
mi.cbSize = sizeof(mi);
|
||
GetMonitorInfo(hMonitor, &mi);
|
||
|
||
WINDOWINFO wi;
|
||
wi.cbSize = sizeof(wi);
|
||
GetWindowInfo(hwnd, &wi);
|
||
|
||
int dxMax = mi.rcWork.right - mi.rcWork.left;
|
||
int dyMax = mi.rcWork.bottom - mi.rcWork.top;
|
||
|
||
return ((wi.rcWindow.right - wi.rcWindow.left < dxMax) ||
|
||
(wi.rcWindow.bottom - wi.rcWindow.top < dyMax));
|
||
}
|
||
|
||
HMENU _GetSystemMenu(HWND hwnd)
|
||
{
|
||
// We have to make a copy of the menu because the documentation for
|
||
// GetSystemMenu blatantly lies, it does not give you a copy of the hmenu
|
||
// and you are not at liberty to alter said menu
|
||
HMENU hmenu = CreatePopupMenu();
|
||
|
||
Shell_MergeMenus(hmenu, GetSystemMenu(hwnd, FALSE), 0, 0, 0xffff, 0);
|
||
|
||
if (hmenu)
|
||
{
|
||
/* Stolen from Core\ntuser\kernel\mnsys.c xxxSetSysMenu */
|
||
UINT wSize;
|
||
UINT wMinimize;
|
||
UINT wMaximize;
|
||
UINT wMove;
|
||
UINT wRestore;
|
||
UINT wDefault;
|
||
LONG lStyle = GetWindowLong(hwnd, GWL_STYLE);
|
||
|
||
/*
|
||
* System modal window: no size, icon, zoom, or move.
|
||
*/
|
||
|
||
wSize = wMaximize = wMinimize = wMove = 0;
|
||
wRestore = MFS_GRAYED;
|
||
|
||
//
|
||
// Default menu command is close.
|
||
//
|
||
wDefault = SC_CLOSE;
|
||
|
||
/*
|
||
* Minimized exceptions: no minimize, restore.
|
||
*/
|
||
|
||
// we need to reverse these because VB has a "special" window
|
||
// that is both minimized but without a minbox.
|
||
if (IsIconic(hwnd))
|
||
{
|
||
wRestore = 0;
|
||
wMinimize = MFS_GRAYED;
|
||
wSize = MFS_GRAYED;
|
||
wDefault = SC_RESTORE;
|
||
}
|
||
else if (!(lStyle & WS_MINIMIZEBOX))
|
||
wMinimize = MFS_GRAYED;
|
||
|
||
/*
|
||
* Maximized exceptions: no maximize, restore.
|
||
*/
|
||
if (!(lStyle & WS_MAXIMIZEBOX))
|
||
wMaximize = MFS_GRAYED;
|
||
else if (IsZoomed(hwnd)) {
|
||
wRestore = 0;
|
||
|
||
/*
|
||
* If the window is maximized but it isn't larger than the
|
||
* screen, we allow the user to move the window around the
|
||
* desktop (but we don't allow resizing).
|
||
*/
|
||
wMove = MFS_GRAYED;
|
||
if (!(lStyle & WS_CHILD)) {
|
||
if (IsSmallerThanScreen(hwnd)) {
|
||
wMove = 0;
|
||
}
|
||
}
|
||
|
||
wSize = MFS_GRAYED;
|
||
wMaximize = MFS_GRAYED;
|
||
}
|
||
|
||
if (!(lStyle & WS_SIZEBOX))
|
||
wSize = MFS_GRAYED;
|
||
|
||
/*
|
||
* Are we dealing with a framed dialog box with a sys menu?
|
||
* Dialogs with min/max/size boxes get a regular system menu
|
||
* (as opposed to the dialog menu)
|
||
*/
|
||
if (!(lStyle & WS_DLGFRAME) || (lStyle & (WS_SIZEBOX | WS_MINIMIZEBOX | WS_MAXIMIZEBOX))) {
|
||
EnableMenuItem(hmenu, (UINT)SC_SIZE, wSize);
|
||
EnableMenuItem(hmenu, (UINT)SC_MINIMIZE, wMinimize);
|
||
EnableMenuItem(hmenu, (UINT)SC_MAXIMIZE, wMaximize);
|
||
EnableMenuItem(hmenu, (UINT)SC_RESTORE, wRestore);
|
||
}
|
||
|
||
EnableMenuItem(hmenu, (UINT)SC_MOVE, wMove);
|
||
|
||
SetMenuDefaultItem(hmenu, wDefault, MF_BYCOMMAND);
|
||
}
|
||
|
||
return hmenu;
|
||
}
|
||
|
||
void CTaskBand::_ExecuteMenuOption(HWND hwnd, int iCmd)
|
||
{
|
||
if (iCmd == SC_SIZE || iCmd == SC_MOVE)
|
||
{
|
||
_FreePopupMenu();
|
||
SwitchToThisWindow(hwnd, TRUE);
|
||
}
|
||
|
||
PostMessage(hwnd, WM_SYSCOMMAND, iCmd, 0);
|
||
}
|
||
|
||
BOOL _IsWindowNormal(HWND hwnd)
|
||
{
|
||
return (hwnd != v_hwndTray) && (hwnd != v_hwndDesktop) && IsWindow(hwnd);
|
||
}
|
||
|
||
void _RestoreWindow(HWND hwnd, DWORD dwFlags)
|
||
{
|
||
HWND hwndTask = hwnd;
|
||
HWND hwndProxy = hwndTask;
|
||
if (g_fDesktopRaised)
|
||
{
|
||
_RaiseDesktop(FALSE);
|
||
}
|
||
|
||
// set foreground first so that we'll switch to it.
|
||
if (IsIconic(hwndTask) &&
|
||
(dwFlags & TIF_EVERACTIVEALT))
|
||
{
|
||
HWND hwndProxyT = (HWND) GetWindowLongPtr(hwndTask, 0);
|
||
if (hwndProxyT != NULL && IsWindow(hwndProxyT))
|
||
hwndProxy = hwndProxyT;
|
||
}
|
||
|
||
SetForegroundWindow(GetLastActivePopup(hwndProxy));
|
||
if (hwndProxy != hwndTask)
|
||
SendMessage(hwndTask, WM_SYSCOMMAND, SC_RESTORE, -2);
|
||
}
|
||
|
||
PTASKITEM CTaskBand::_GetItem(int i, TBBUTTONINFO* ptbb /*= NULL*/, BOOL fByIndex /*= TRUE*/)
|
||
{
|
||
if (i >= 0 && i < _tb.GetButtonCount())
|
||
{
|
||
TBBUTTONINFO tbb;
|
||
|
||
if (ptbb == NULL)
|
||
{
|
||
ptbb = &tbb;
|
||
ptbb->dwMask = TBIF_LPARAM;
|
||
}
|
||
else
|
||
{
|
||
ptbb->dwMask = TBIF_COMMAND | TBIF_IMAGE | TBIF_LPARAM |
|
||
TBIF_SIZE | TBIF_STATE | TBIF_STYLE;
|
||
}
|
||
|
||
if (fByIndex)
|
||
{
|
||
ptbb->dwMask |= TBIF_BYINDEX;
|
||
}
|
||
|
||
ptbb->cbSize = sizeof(*ptbb);
|
||
|
||
_tb.GetButtonInfo(i, ptbb);
|
||
|
||
ASSERT(ptbb->lParam); // we check for NULL before insertion, so shouldn't be NULL here
|
||
|
||
return (PTASKITEM)ptbb->lParam;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
int CTaskBand::_FindIndexByHwnd(HWND hwnd)
|
||
{
|
||
if (hwnd)
|
||
{
|
||
for (int i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
|
||
if (pti && pti->hwnd == hwnd)
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
|
||
void CTaskBand::_CheckNeedScrollbars(int cyRow, int cItems, int iCols, int iRows,
|
||
int iItemWidth, LPRECT prcView)
|
||
{
|
||
int cxRow = iItemWidth;
|
||
int iVisibleColumns = RECTWIDTH(*prcView) / cxRow;
|
||
int iVisibleRows = RECTHEIGHT(*prcView) / cyRow;
|
||
|
||
int x,y, cx,cy;
|
||
|
||
RECT rcTabs;
|
||
rcTabs = *prcView;
|
||
|
||
iVisibleColumns = max(iVisibleColumns, 1);
|
||
iVisibleRows = max(iVisibleRows, 1);
|
||
|
||
SCROLLINFO si;
|
||
si.cbSize = sizeof(si);
|
||
si.fMask = SIF_PAGE | SIF_RANGE;
|
||
si.nMin = 0;
|
||
si.nPage = 0;
|
||
si.nPos = 0;
|
||
|
||
if (_IsHorizontal())
|
||
{
|
||
// do vertical scrollbar
|
||
// -1 because it's 0 based.
|
||
si.nMax = (cItems + iVisibleColumns - 1) / iVisibleColumns -1 ;
|
||
si.nPage = iVisibleRows;
|
||
|
||
// we're actually going to need the scrollbars
|
||
if (si.nPage <= (UINT)si.nMax)
|
||
{
|
||
// this effects the vis columns and therefore nMax and nPage
|
||
rcTabs.right -= g_cxVScroll;
|
||
iVisibleColumns = RECTWIDTH(rcTabs) / cxRow;
|
||
if (!iVisibleColumns)
|
||
iVisibleColumns = 1;
|
||
si.nMax = (cItems + iVisibleColumns - 1) / iVisibleColumns -1 ;
|
||
}
|
||
|
||
SetScrollInfo(_hwnd, SB_VERT, &si, TRUE);
|
||
si.fMask = SIF_POS | SIF_PAGE | SIF_RANGE;
|
||
GetScrollInfo(_hwnd, SB_VERT, &si);
|
||
x = 0;
|
||
y = -si.nPos * cyRow;
|
||
if (iRows == 1)
|
||
{
|
||
cx = RECTWIDTH(rcTabs);
|
||
}
|
||
else
|
||
{
|
||
cx = cxRow * iVisibleColumns;
|
||
}
|
||
// +1 because si.nMax is zero based
|
||
cy = cyRow * (si.nMax +1);
|
||
|
||
// nuke the other scroll bar
|
||
_NukeScrollbar(SB_HORZ);
|
||
}
|
||
else
|
||
{
|
||
// do horz scrollbar
|
||
si.nMax = iCols -1;
|
||
si.nPage = iVisibleColumns;
|
||
|
||
// we're actually going to need the scrollbars
|
||
if (si.nPage <= (UINT)si.nMax)
|
||
{
|
||
// this effects the vis columns and therefore nMax and nPage
|
||
rcTabs.bottom -= g_cyHScroll;
|
||
iVisibleRows = RECTHEIGHT(rcTabs) / cyRow;
|
||
if (!iVisibleRows)
|
||
iVisibleRows = 1;
|
||
si.nMax = (cItems + iVisibleRows - 1) / iVisibleRows -1 ;
|
||
}
|
||
|
||
SetScrollInfo(_hwnd, SB_HORZ, &si, TRUE);
|
||
si.fMask = SIF_POS | SIF_PAGE | SIF_RANGE;
|
||
GetScrollInfo(_hwnd, SB_HORZ, &si);
|
||
y = 0;
|
||
x = -si.nPos * cxRow;
|
||
|
||
cx = cxRow * (si.nMax + 1);
|
||
cy = cyRow * iVisibleRows;
|
||
|
||
// nuke the other scroll bar
|
||
_NukeScrollbar(SB_VERT);
|
||
}
|
||
|
||
_tb.SetWindowPos(0, x,y, cx, cy, SWP_NOACTIVATE| SWP_NOZORDER);
|
||
}
|
||
|
||
void CTaskBand::_NukeScrollbar(int fnBar)
|
||
{
|
||
SCROLLINFO si;
|
||
si.fMask = SIF_PAGE | SIF_RANGE | SIF_POS;
|
||
si.cbSize = sizeof(si);
|
||
si.nMin = 0;
|
||
si.nMax = 0;
|
||
si.nPage = 0;
|
||
si.nPos = 0;
|
||
|
||
SetScrollInfo(_hwnd, fnBar, &si, TRUE);
|
||
}
|
||
|
||
BOOL CTaskBand::_IsHidden(int i)
|
||
{
|
||
TBBUTTONINFO tbbi;
|
||
tbbi.cbSize = sizeof(tbbi);
|
||
tbbi.dwMask = TBIF_STATE | TBIF_BYINDEX;
|
||
_tb.GetButtonInfo(i, &tbbi);
|
||
if (tbbi.fsState & TBSTATE_HIDDEN)
|
||
{
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
int CTaskBand::_GetGroupIndexFromExeName(WCHAR* pszExeName)
|
||
{
|
||
for (int i = _tb.GetButtonCount() - 1; i >=0; i--)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
if ((!pti->hwnd) && (lstrcmpi(pti->pszExeName, pszExeName) == 0))
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
|
||
DWORD CTaskBand::_GetGroupAge(int iIndexGroup)
|
||
{
|
||
int iGroupSize = _GetGroupSize(iIndexGroup);
|
||
DWORD dwTimeLastClicked = _GetItem(iIndexGroup + 1)->dwTimeLastClicked;
|
||
|
||
for (int i = iIndexGroup + 2; i <= iIndexGroup + iGroupSize; i++)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
if (pti->dwTimeLastClicked > dwTimeLastClicked)
|
||
{
|
||
dwTimeLastClicked = pti->dwTimeLastClicked;
|
||
}
|
||
}
|
||
|
||
return dwTimeLastClicked;
|
||
}
|
||
|
||
//
|
||
// _GetGroupSize: returns size of group *not including* the group button
|
||
//
|
||
int CTaskBand::_GetGroupSize(int iIndexGroup)
|
||
{
|
||
int iGroupSize = 0;
|
||
|
||
PTASKITEM ptiGroup = _GetItem(iIndexGroup);
|
||
if (ptiGroup)
|
||
{
|
||
ASSERT(!ptiGroup->hwnd);
|
||
int cButtons = _tb.GetButtonCount();
|
||
for (int i = iIndexGroup + 1; i < cButtons; i++)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
if (!pti->hwnd)
|
||
{
|
||
break;
|
||
}
|
||
|
||
iGroupSize++;
|
||
}
|
||
}
|
||
|
||
return iGroupSize;
|
||
}
|
||
|
||
int CTaskBand::_GetGroupIndex(int iIndexApp)
|
||
{
|
||
int i = iIndexApp;
|
||
while ((i > 0) && (_GetItem(i)->hwnd))
|
||
{
|
||
i--;
|
||
}
|
||
|
||
return i;
|
||
}
|
||
|
||
void CTaskBand::_UpdateFlashingFlag()
|
||
{
|
||
// Loop through the tab items, see if any have TIF_FLASHING
|
||
// set, and update the flashing flag.
|
||
_fFlashing = FALSE;
|
||
|
||
int iCount = _tb.GetButtonCount();
|
||
for (int i = 0; i < iCount; i++)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
|
||
if (!pti->hwnd)
|
||
{
|
||
pti->dwFlags &= ~(TIF_FLASHING | TIF_RENDERFLASHED);
|
||
}
|
||
else
|
||
{
|
||
int iGroupIndex = _GetGroupIndex(i);
|
||
PTASKITEM ptiGroup = _GetItem(iGroupIndex);
|
||
|
||
if (pti->dwFlags & TIF_FLASHING)
|
||
{
|
||
ptiGroup->dwFlags |= TIF_FLASHING;
|
||
_fFlashing = TRUE;
|
||
}
|
||
|
||
if (pti->dwFlags & TIF_RENDERFLASHED)
|
||
{
|
||
ptiGroup->dwFlags |= TIF_RENDERFLASHED;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_RealityCheck()
|
||
{
|
||
//
|
||
// Delete any buttons corresponding to non-existent windows.
|
||
//
|
||
for (int i = 0; i < _tb.GetButtonCount(); i++)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
// NOTE: HWND_TOPMOST is used to indicate that the deleted button
|
||
// is being animated. This allows the button to stay around after
|
||
// its real hwnd becomes invalid
|
||
if (pti->hwnd && !IsWindow(pti->hwnd) &&
|
||
((pti->hwnd != HWND_TOPMOST) || !_dsaAII.GetItemCount()))
|
||
{
|
||
#ifdef DEBUG
|
||
PTASKITEM ptiGroup = _GetItem(_GetGroupIndex(i));
|
||
TraceMsg(TF_WARNING, "CTaskBand::_RealityCheck: window %x (%s) no longer valid", pti->hwnd, ptiGroup->pszExeName);
|
||
#endif
|
||
_DeleteItem(pti->hwnd, i);
|
||
}
|
||
}
|
||
}
|
||
|
||
class ICONDATA
|
||
{
|
||
public:
|
||
ICONDATA(int i, CTaskBand* p) : iPref(i), ptb(p) { ptb->AddRef(); }
|
||
virtual ~ICONDATA() { ptb->Release(); }
|
||
|
||
int iPref;
|
||
CTaskBand* ptb;
|
||
};
|
||
|
||
typedef ICONDATA* PICONDATA;
|
||
|
||
void CALLBACK CTaskBand::IconAsyncProc(HWND hwnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult)
|
||
{
|
||
PICONDATA pid = (PICONDATA)dwData;
|
||
if (pid)
|
||
{
|
||
pid->ptb->_SetWindowIcon(hwnd, (HICON)lResult, pid->iPref);
|
||
delete pid;
|
||
}
|
||
}
|
||
|
||
int CTaskBand::GetIconCB(CTaskBand* ptb, PICONCBPARAM pip, LPARAM lParam, int iPref)
|
||
{
|
||
int iRet = I_IMAGENONE;
|
||
|
||
if (IsWindow(pip->hwnd))
|
||
{
|
||
PICONDATA pid = new ICONDATA(iPref, ptb);
|
||
if (pid)
|
||
{
|
||
if (!SendMessageCallback(pip->hwnd, WM_GETICON, lParam, 0, CTaskBand::IconAsyncProc, (ULONG_PTR)pid))
|
||
{
|
||
delete pid;
|
||
}
|
||
}
|
||
}
|
||
|
||
return iRet;
|
||
}
|
||
|
||
int CTaskBand::GetSHILIconCB(CTaskBand* ptb, PICONCBPARAM pip, LPARAM lParam, int)
|
||
{
|
||
int iRet = I_IMAGENONE;
|
||
TCHAR szIcon[MAX_PATH];
|
||
DWORD cb = sizeof(szIcon);
|
||
|
||
HKEY hkeyApp;
|
||
if (SUCCEEDED(AssocQueryKey(ASSOCF_OPEN_BYEXENAME | ASSOCF_VERIFY, ASSOCKEY_APP, pip->pszExeName, NULL, &hkeyApp)))
|
||
{
|
||
if (ERROR_SUCCESS == SHGetValue(hkeyApp, NULL, TEXT("TaskbarGroupIcon"), NULL, szIcon, &cb))
|
||
{
|
||
int iIcon = PathParseIconLocation(szIcon);
|
||
int iIndex = Shell_GetCachedImageIndex(szIcon, iIcon, 0);
|
||
if (iIndex >= 0)
|
||
{
|
||
iRet = MAKELONG(iIndex, IL_SHIL);
|
||
}
|
||
}
|
||
RegCloseKey(hkeyApp);
|
||
}
|
||
|
||
if (iRet == I_IMAGENONE)
|
||
{
|
||
int iIndex = Shell_GetCachedImageIndex(pip->pszExeName, 0, 0);
|
||
if (iIndex >= 0)
|
||
{
|
||
iRet = MAKELONG(iIndex, IL_SHIL);
|
||
}
|
||
}
|
||
|
||
return iRet;
|
||
}
|
||
|
||
int CTaskBand::GetDefaultIconCB(CTaskBand* ptb, PICONCBPARAM pip, LPARAM, int)
|
||
{
|
||
HICON hicon = LoadIcon(NULL, IDI_WINLOGO);
|
||
return ptb->_AddIconToNormalImageList(hicon, pip->iImage);
|
||
}
|
||
|
||
int CTaskBand::GetClassIconCB(CTaskBand* ptb, PICONCBPARAM pip, LPARAM lParam, int)
|
||
{
|
||
if (IsWindow(pip->hwnd))
|
||
{
|
||
HICON hicon = (HICON)GetClassLongPtr(pip->hwnd, (int)lParam);
|
||
return ptb->_AddIconToNormalImageList(hicon, pip->iImage);
|
||
}
|
||
return I_IMAGENONE;
|
||
}
|
||
|
||
void CTaskBand::_UpdateItemIcon(int iIndex)
|
||
{
|
||
static const struct
|
||
{
|
||
PICONCALLBACK pfnCB;
|
||
LPARAM lParam;
|
||
}
|
||
c_IconCallbacks[] =
|
||
{
|
||
{ CTaskBand::GetIconCB, ICON_SMALL2 },
|
||
{ CTaskBand::GetIconCB, ICON_SMALL },
|
||
{ CTaskBand::GetIconCB, ICON_BIG },
|
||
{ CTaskBand::GetClassIconCB, GCLP_HICONSM },
|
||
{ CTaskBand::GetClassIconCB, GCLP_HICON },
|
||
{ CTaskBand::GetSHILIconCB, 0, },
|
||
{ CTaskBand::GetDefaultIconCB, 0, },
|
||
};
|
||
|
||
TBBUTTONINFO tbbi;
|
||
PTASKITEM pti = _GetItem(iIndex, &tbbi);
|
||
|
||
if (pti)
|
||
{
|
||
int iIndexGroup = _GetGroupIndex(iIndex);
|
||
PTASKITEM ptiGroup = _GetItem(iIndexGroup);
|
||
if (ptiGroup)
|
||
{
|
||
ICONCBPARAM ip;
|
||
ip.hwnd = pti->hwnd;
|
||
ip.pszExeName = ptiGroup->pszExeName;
|
||
ip.iImage = tbbi.iImage;
|
||
|
||
for (int i = 0; i < ARRAYSIZE(c_IconCallbacks); i++)
|
||
{
|
||
int iPref = (ARRAYSIZE(c_IconCallbacks) - i) + 1;
|
||
if (iPref >= pti->iIconPref)
|
||
{
|
||
PTASKITEM ptiTemp = _GetItem(iIndex);
|
||
if (ptiTemp == pti)
|
||
{
|
||
int iImage = c_IconCallbacks[i].pfnCB(this, &ip, c_IconCallbacks[i].lParam, iPref);
|
||
if (iImage != I_IMAGENONE)
|
||
{
|
||
_SetItemImage(iIndex, iImage, iPref);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
BOOL IsValidHICON(HICON hicon)
|
||
{
|
||
BOOL fIsValid = FALSE;
|
||
|
||
if (hicon)
|
||
{
|
||
// Check validity of icon returned
|
||
ICONINFO ii = {0};
|
||
fIsValid = GetIconInfo(hicon, &ii);
|
||
|
||
if (ii.hbmMask)
|
||
{
|
||
DeleteObject(ii.hbmMask);
|
||
}
|
||
|
||
if (ii.hbmColor)
|
||
{
|
||
DeleteObject(ii.hbmColor);
|
||
}
|
||
}
|
||
|
||
return fIsValid;
|
||
}
|
||
|
||
void CTaskBand::_MoveGroup(HWND hwnd, WCHAR* szNewExeName)
|
||
{
|
||
BOOL fRedraw = (BOOL)_tb.SendMessage(WM_SETREDRAW, FALSE, 0);
|
||
|
||
int iIndexNewGroup = _GetGroupIndexFromExeName(szNewExeName);
|
||
int iIndexOld = _FindIndexByHwnd(hwnd);
|
||
int iIndexOldGroup = _GetGroupIndex(iIndexOld);
|
||
|
||
if (iIndexNewGroup != iIndexOldGroup)
|
||
{
|
||
if (iIndexOld >= 0)
|
||
{
|
||
PTASKITEM pti = _GetItem(iIndexOld);
|
||
|
||
if (iIndexNewGroup < 0)
|
||
{
|
||
PTASKITEM ptiGroup = new TASKITEM;
|
||
if (ptiGroup)
|
||
{
|
||
ptiGroup->hwnd = NULL;
|
||
ptiGroup->dwTimeLastClicked = 0;
|
||
ptiGroup->pszExeName = new WCHAR[lstrlen(szNewExeName) + 1];
|
||
if (ptiGroup->pszExeName)
|
||
{
|
||
lstrcpy(ptiGroup->pszExeName, szNewExeName);
|
||
|
||
iIndexNewGroup = _AddToTaskbar(ptiGroup, -1, FALSE, FALSE);
|
||
if (iIndexNewGroup < 0)
|
||
{
|
||
delete[] ptiGroup->pszExeName;
|
||
delete ptiGroup;
|
||
}
|
||
else if (iIndexNewGroup <= iIndexOldGroup)
|
||
{
|
||
iIndexOld++;
|
||
iIndexOldGroup++;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
delete ptiGroup;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (iIndexNewGroup >= 0)
|
||
{
|
||
int iIndexNew = _AddToTaskbar(pti, iIndexNewGroup + _GetGroupSize(iIndexNewGroup) + 1, _IsHidden(iIndexNewGroup), FALSE);
|
||
|
||
if (iIndexNew >= 0)
|
||
{
|
||
_CheckButton(iIndexNew, pti->dwFlags & TIF_CHECKED);
|
||
|
||
if (iIndexNew <= iIndexOldGroup)
|
||
{
|
||
iIndexOld++;
|
||
iIndexOldGroup++;
|
||
}
|
||
|
||
// Copy the old icon to prevent re-getting the icon
|
||
TBBUTTONINFO tbbiOld;
|
||
_GetItem(iIndexOld, &tbbiOld);
|
||
|
||
TBBUTTONINFO tbbiNew;
|
||
_GetItem(iIndexNew, &tbbiNew);
|
||
|
||
tbbiNew.iImage = tbbiOld.iImage;
|
||
tbbiNew.dwMask = TBIF_BYINDEX | TBIF_IMAGE;
|
||
_tb.SetButtonInfo(iIndexNew, &tbbiNew);
|
||
|
||
tbbiOld.iImage = I_IMAGENONE;
|
||
tbbiOld.dwMask = TBIF_BYINDEX | TBIF_IMAGE;
|
||
_tb.SetButtonInfo(iIndexOld, &tbbiOld);
|
||
|
||
_DeleteTaskItem(iIndexOld, FALSE);
|
||
int iSize = _GetGroupSize(iIndexOldGroup);
|
||
if (iSize == 0)
|
||
{
|
||
_DeleteTaskItem(iIndexOldGroup, TRUE);
|
||
}
|
||
else if (iSize == 1)
|
||
{
|
||
_Glom(iIndexOldGroup, FALSE);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
_tb.SetRedraw(fRedraw);
|
||
|
||
_CheckSize();
|
||
}
|
||
|
||
void CTaskBand::_SetWindowIcon(HWND hwnd, HICON hicon, int iPref)
|
||
{
|
||
int iIndex = _FindIndexByHwnd(hwnd);
|
||
if (iIndex >= 0)
|
||
{
|
||
TBBUTTONINFO tbbi;
|
||
PTASKITEM pti = _GetItem(iIndex, &tbbi);
|
||
if (iPref >= pti->iIconPref && IsValidHICON(hicon))
|
||
{
|
||
int iImage = _AddIconToNormalImageList(hicon, tbbi.iImage);
|
||
if (iImage >= 0)
|
||
{
|
||
_SetItemImage(iIndex, iImage, iPref);
|
||
|
||
if (pti->hwnd)
|
||
{
|
||
int iIndexGroup = _GetGroupIndex(iIndex);
|
||
PTASKITEM ptiGroup = _GetItem(iIndexGroup);
|
||
|
||
HKEY hkeyApp;
|
||
if (SUCCEEDED(AssocQueryKey(ASSOCF_OPEN_BYEXENAME | ASSOCF_VERIFY, ASSOCKEY_APP, ptiGroup->pszExeName, NULL, &hkeyApp)))
|
||
{
|
||
HKEY hkeyIcons;
|
||
if (ERROR_SUCCESS == RegOpenKeyEx(hkeyApp, TEXT("TaskbarExceptionsIcons"), 0, KEY_READ, &hkeyIcons))
|
||
{
|
||
int iKey = 0;
|
||
WCHAR szIconName[MAX_PATH];
|
||
DWORD cchIconName = ARRAYSIZE(szIconName);
|
||
FILETIME ftBogus;
|
||
while (ERROR_SUCCESS == RegEnumKeyEx(hkeyIcons, iKey, szIconName, &cchIconName, NULL, NULL, NULL, &ftBogus))
|
||
{
|
||
HICON hiconDll = NULL;
|
||
|
||
{
|
||
WCHAR szTempIconName[MAX_PATH];
|
||
lstrcpy(szTempIconName, szIconName);
|
||
int iIconIndex = PathParseIconLocation(szTempIconName);
|
||
ExtractIconEx(szTempIconName, iIconIndex, NULL, &hiconDll, 1);
|
||
}
|
||
|
||
if (hiconDll)
|
||
{
|
||
if (SHAreIconsEqual(hiconDll, hicon))
|
||
{
|
||
HKEY hkeyNewGroup;
|
||
if (ERROR_SUCCESS == RegOpenKeyEx(hkeyIcons, szIconName, 0, KEY_READ, &hkeyNewGroup))
|
||
{
|
||
WCHAR szNewGroup[MAX_PATH];
|
||
DWORD cchNewGroup = ARRAYSIZE(szNewGroup);
|
||
if (ERROR_SUCCESS == RegQueryValueEx(hkeyNewGroup, NULL, NULL, NULL, (LPBYTE)szNewGroup, &cchNewGroup))
|
||
{
|
||
WCHAR szNewGroupExpanded[MAX_PATH];
|
||
SHExpandEnvironmentStrings(szNewGroup, szNewGroupExpanded, MAX_PATH);
|
||
|
||
WCHAR* pszNewGroupExe = PathFindFileName(szNewGroupExpanded);
|
||
if (pszNewGroupExe)
|
||
{
|
||
for (int i = _tb.GetButtonCount() - 1; i >=0; i--)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
if (!pti->hwnd)
|
||
{
|
||
WCHAR* pszGroupExe = PathFindFileName(pti->pszExeName);
|
||
if (pszGroupExe && (lstrcmpi(pszGroupExe, pszNewGroupExe) == 0))
|
||
{
|
||
lstrcpyn(szNewGroupExpanded, pti->pszExeName, ARRAYSIZE(szNewGroupExpanded));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
DWORD dwType;
|
||
// Make it is an exe and that it exists
|
||
if (GetBinaryType(szNewGroupExpanded, &dwType))
|
||
{
|
||
_MoveGroup(hwnd, szNewGroupExpanded);
|
||
}
|
||
}
|
||
RegCloseKey(hkeyNewGroup);
|
||
}
|
||
}
|
||
DestroyIcon(hiconDll);
|
||
}
|
||
|
||
cchIconName = ARRAYSIZE(szIconName);
|
||
iKey++;
|
||
}
|
||
RegCloseKey(hkeyIcons);
|
||
}
|
||
RegCloseKey(hkeyApp);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_Glom(int iIndexGroup, BOOL fGlom)
|
||
{
|
||
BOOL fRedraw = (BOOL)_tb.SendMessage(WM_SETREDRAW, FALSE, 0);
|
||
|
||
if ((!fGlom) && (iIndexGroup == _iIndexPopup))
|
||
{
|
||
_FreePopupMenu();
|
||
}
|
||
|
||
if (fGlom == _IsHidden(iIndexGroup))
|
||
{
|
||
if (_fAnimate && _IsHorizontal())
|
||
{
|
||
int iGroupSize = _GetGroupSize(iIndexGroup);
|
||
|
||
if (!fGlom)
|
||
{
|
||
_HideGroup(iIndexGroup, FALSE);
|
||
|
||
if (iGroupSize)
|
||
{
|
||
int iWidth = _GetItemWidth(iIndexGroup) / iGroupSize;
|
||
iWidth = max(iWidth, 1);
|
||
for(int i = iIndexGroup + iGroupSize; i > iIndexGroup; i--)
|
||
{
|
||
_SetItemWidth(i, iWidth);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!(fGlom && (_GetItem(iIndexGroup)->dwFlags & TIF_ISGLOMMING)))
|
||
{
|
||
_AnimateItems(iIndexGroup, !fGlom, TRUE);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
_HideGroup(iIndexGroup, fGlom);
|
||
_CheckSize();
|
||
}
|
||
}
|
||
|
||
_tb.SetRedraw(fRedraw);
|
||
}
|
||
|
||
|
||
void CTaskBand::_HideGroup(int iIndexGroup, BOOL fHide)
|
||
{
|
||
int iGroupSize = _GetGroupSize(iIndexGroup);
|
||
|
||
TBBUTTONINFO tbbi;
|
||
tbbi.cbSize = sizeof(tbbi);
|
||
tbbi.dwMask = TBIF_STATE | TBIF_BYINDEX;
|
||
|
||
// Glom button
|
||
_tb.GetButtonInfo(iIndexGroup, &tbbi);
|
||
tbbi.fsState = fHide ? (tbbi.fsState & ~TBSTATE_HIDDEN) : (tbbi.fsState | TBSTATE_HIDDEN);
|
||
_tb.SetButtonInfo(iIndexGroup, &tbbi);
|
||
|
||
// Group buttons
|
||
for (int i = iIndexGroup + iGroupSize; i > iIndexGroup; i--)
|
||
{
|
||
_tb.GetButtonInfo(i, &tbbi);
|
||
tbbi.fsState = fHide ? (tbbi.fsState | TBSTATE_HIDDEN) : (tbbi.fsState & ~TBSTATE_HIDDEN);
|
||
_tb.SetButtonInfo(i, &tbbi);
|
||
}
|
||
}
|
||
|
||
BOOL CTaskBand::_AutoGlomGroup(BOOL fGlom, int iOpenSlots)
|
||
{
|
||
int iIndex = -1;
|
||
DWORD dwTimeLastClicked = 0;
|
||
int iSize = 0;
|
||
|
||
int i = 0;
|
||
while (i < _tb.GetButtonCount())
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
int iGroupSize = _GetGroupSize(i);
|
||
// Don't mess with the blank group
|
||
if ((pti->pszExeName && (pti->pszExeName[0] != 0)) &&
|
||
(fGlom || (!fGlom && ((_iGroupSize >= GLOM_SIZE) || (iGroupSize <= iOpenSlots)))) &&
|
||
((iGroupSize > 1) && (fGlom == _IsHidden(i))))
|
||
{
|
||
BOOL fMatch;
|
||
DWORD dwGroupTime = 0;
|
||
|
||
switch (_iGroupSize)
|
||
{
|
||
case GLOM_OLDEST:
|
||
dwGroupTime = _GetGroupAge(i);
|
||
fMatch = (dwTimeLastClicked == 0) ||
|
||
(fGlom && (dwGroupTime < dwTimeLastClicked)) ||
|
||
(!fGlom && (dwGroupTime > dwTimeLastClicked));
|
||
break;
|
||
case GLOM_BIGGEST:
|
||
fMatch = (fGlom && (iGroupSize > iSize)) ||
|
||
(!fGlom && ((iGroupSize < iSize) || (iSize == 0)));
|
||
break;
|
||
default:
|
||
fMatch = (fGlom && (iGroupSize >= _iGroupSize)) ||
|
||
(!fGlom && (iGroupSize < _iGroupSize));
|
||
break;
|
||
}
|
||
|
||
if (fMatch)
|
||
{
|
||
dwTimeLastClicked = dwGroupTime;
|
||
iSize = iGroupSize;
|
||
iIndex = i;
|
||
}
|
||
}
|
||
i += iGroupSize + 1;
|
||
}
|
||
|
||
if ((iIndex != -1) &&
|
||
(fGlom || (!fGlom && (iSize <= iOpenSlots))))
|
||
{
|
||
_Glom(iIndex, fGlom);
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
void CTaskBand::_GetItemTitle(int iIndex, WCHAR* pszTitle, int cchTitle, BOOL fCustom)
|
||
{
|
||
PTASKITEM pti = _GetItem(iIndex);
|
||
|
||
if (pti->hwnd)
|
||
{
|
||
if (InternalGetWindowText(pti->hwnd, pszTitle, cchTitle))
|
||
{
|
||
if (fCustom)
|
||
{
|
||
WCHAR szGrpText[MAX_PATH] = L" - ";
|
||
int iIndexGroup = _GetGroupIndex(iIndex);
|
||
_GetItemTitle(iIndexGroup, &szGrpText[3], MAX_PATH - 3, TRUE);
|
||
int iLenGrp = lstrlen(szGrpText);
|
||
int iLenWnd = lstrlen(pszTitle);
|
||
|
||
if (iLenWnd > iLenGrp)
|
||
{
|
||
if (StrCmp(&pszTitle[iLenWnd - iLenGrp], szGrpText) == 0)
|
||
{
|
||
pszTitle[iLenWnd - iLenGrp] = 0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if ((pti->pszExeName) && (pti->pszExeName[0] != 0))
|
||
{
|
||
DWORD cchOut = cchTitle;
|
||
|
||
AssocQueryString(ASSOCF_INIT_BYEXENAME | ASSOCF_VERIFY, ASSOCSTR_FRIENDLYAPPNAME, pti->pszExeName, NULL, pszTitle, &cchOut);
|
||
}
|
||
else
|
||
{
|
||
pszTitle[0] = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
int CTaskBand::_AddToTaskbar(PTASKITEM pti, int iIndexTaskbar, BOOL fVisible, BOOL fForceGetIcon)
|
||
{
|
||
ASSERT(IS_VALID_WRITE_PTR(pti, TASKITEM));
|
||
|
||
int iIndex = -1;
|
||
TBBUTTON tbb = {0};
|
||
BOOL fRedraw = (BOOL)_tb.SendMessage(WM_SETREDRAW, FALSE, 0);
|
||
|
||
if (fForceGetIcon)
|
||
{
|
||
tbb.iBitmap = I_IMAGENONE;
|
||
}
|
||
else
|
||
{
|
||
tbb.iBitmap = I_IMAGECALLBACK;
|
||
}
|
||
tbb.fsState = TBSTATE_ENABLED;
|
||
if (!fVisible)
|
||
tbb.fsState |= TBSTATE_HIDDEN;
|
||
tbb.fsStyle = BTNS_CHECK | BTNS_NOPREFIX;
|
||
if (!pti->hwnd)
|
||
tbb.fsStyle |= BTNS_DROPDOWN | BTNS_WHOLEDROPDOWN;
|
||
tbb.dwData = (DWORD_PTR)pti;
|
||
tbb.idCommand = Toolbar_GetUniqueID(_tb);
|
||
|
||
if (_tb.InsertButton(iIndexTaskbar, &tbb))
|
||
{
|
||
iIndex = iIndexTaskbar;
|
||
if (iIndex == -1)
|
||
{
|
||
iIndex = _tb.GetButtonCount() - 1;
|
||
}
|
||
|
||
if (fForceGetIcon)
|
||
{
|
||
_UpdateItemIcon(iIndex);
|
||
}
|
||
|
||
_UpdateItemText(iIndex);
|
||
}
|
||
|
||
_tb.SetRedraw(fRedraw);
|
||
return (iIndex);
|
||
}
|
||
|
||
void CTaskBand::_DeleteTaskItem(int iIndex, BOOL fDeletePTI)
|
||
{
|
||
if (iIndex >= 0 && iIndex < _tb.GetButtonCount())
|
||
{
|
||
TBBUTTONINFO tbbi;
|
||
PTASKITEM pti = _GetItem(iIndex, &tbbi);
|
||
|
||
_tb.DeleteButton(iIndex);
|
||
|
||
_RemoveItemFromAnimationList(pti);
|
||
|
||
if (fDeletePTI)
|
||
{
|
||
delete pti;
|
||
}
|
||
|
||
_RemoveImage(tbbi.iImage);
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_SetThreadPriority(int iPriority, DWORD dwWakeupTime)
|
||
{
|
||
if (_iOldPriority == INVALID_PRIORITY)
|
||
{
|
||
HANDLE hThread = GetCurrentThread();
|
||
|
||
int iCurPriority = GetThreadPriority(hThread);
|
||
// Make sure we are actually changed the thread priority
|
||
if (iCurPriority != iPriority)
|
||
{
|
||
_iOldPriority = iCurPriority;
|
||
_iNewPriority = iPriority;
|
||
|
||
|
||
if (dwWakeupTime)
|
||
{
|
||
// Make sure that we are guaranteed to wakeup, by having the desktop thread up our thread priority
|
||
SendMessage(GetShellWindow(), CWM_TASKBARWAKEUP, GetCurrentThreadId(), MAKELONG(dwWakeupTime, _iOldPriority));
|
||
}
|
||
|
||
SetThreadPriority(hThread, _iNewPriority);
|
||
TraceMsg(TF_WARNING, "CTaskBand:: Thread Priority was changed from %d to %d", _iOldPriority, _iNewPriority);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_RestoreThreadPriority()
|
||
{
|
||
if (_iOldPriority != INVALID_PRIORITY)
|
||
{
|
||
HANDLE hThread = GetCurrentThread();
|
||
|
||
int iCurPriority = GetThreadPriority(hThread);
|
||
// Make sure no one has changed our priority since that last time we did
|
||
if (iCurPriority == _iNewPriority)
|
||
{
|
||
SetThreadPriority(hThread, _iOldPriority);
|
||
SendMessage(GetShellWindow(), CWM_TASKBARWAKEUP, 0, 0);
|
||
TraceMsg(TF_WARNING, "CTaskBand:: Thread Priority was restored from %d to %d", _iNewPriority, _iOldPriority);
|
||
}
|
||
|
||
_iOldPriority = INVALID_PRIORITY;
|
||
_iNewPriority = INVALID_PRIORITY;
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_UpdateProgramCount()
|
||
{
|
||
DWORD dwDisposition;
|
||
HKEY hKey;
|
||
|
||
if (ERROR_SUCCESS == RegCreateKeyEx(HKEY_CURRENT_USER, TEXT("SessionInformation"),
|
||
0, NULL, REG_OPTION_VOLATILE, KEY_SET_VALUE,
|
||
NULL, &hKey, &dwDisposition))
|
||
{
|
||
DWORD dwProgramCount = _ptray->CountOfRunningPrograms();
|
||
RegSetValueEx(hKey, TEXT("ProgramCount"),
|
||
0, REG_DWORD, reinterpret_cast<LPBYTE>(&dwProgramCount),
|
||
sizeof(dwProgramCount));
|
||
RegCloseKey(hKey);
|
||
}
|
||
}
|
||
|
||
int CTaskBand::_InsertItem(HWND hwndTask, PTASKITEM pti, BOOL fForceGetIcon)
|
||
{
|
||
_SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL, 5000);
|
||
|
||
BOOL fRestoreThreadPriority = TRUE;
|
||
PTASKITEM ptiGroup = NULL;
|
||
WCHAR szExeName[MAX_PATH];
|
||
int iRet = _FindIndexByHwnd(hwndTask);
|
||
int iIndexGroup = -1;
|
||
|
||
if (iRet != -1)
|
||
return iRet;
|
||
|
||
SHExeNameFromHWND(hwndTask, szExeName, ARRAYSIZE(szExeName));
|
||
|
||
WCHAR* pszNoPath = PathFindFileName(szExeName);
|
||
if (pszNoPath)
|
||
{
|
||
for (int i = 0; i < ARRAYSIZE(g_rgNoGlom); i++)
|
||
{
|
||
if (lstrcmpi(pszNoPath, g_rgNoGlom[i].szExeName) == 0)
|
||
{
|
||
wsprintf(szExeName, L"HWND%x", hwndTask);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Initialize Taskbar entry, this entry will go into a group on the taskbar or onto the taskbar
|
||
if (!pti)
|
||
{
|
||
pti = new TASKITEM;
|
||
if (!pti)
|
||
goto Failure;
|
||
pti->hwnd = hwndTask;
|
||
pti->dwTimeFirstOpened = pti->dwTimeLastClicked = GetTickCount();
|
||
}
|
||
|
||
_AttachTaskShortcut(pti, szExeName);
|
||
|
||
// Find the last taskbar entry with a given Exe Name
|
||
if (_fGlom)
|
||
{
|
||
iIndexGroup = _GetGroupIndexFromExeName(szExeName);
|
||
}
|
||
|
||
if (iIndexGroup == -1)
|
||
{
|
||
ptiGroup = new TASKITEM;
|
||
if (!ptiGroup)
|
||
goto Failure;
|
||
ptiGroup->hwnd = NULL;
|
||
ptiGroup->dwTimeLastClicked = 0;
|
||
ptiGroup->pszExeName = new WCHAR[lstrlen(szExeName) + 1];
|
||
if (!ptiGroup->pszExeName)
|
||
goto Failure;
|
||
lstrcpy(ptiGroup->pszExeName, szExeName);
|
||
|
||
iRet = _AddToTaskbar(ptiGroup, -1, FALSE, fForceGetIcon);
|
||
if (iRet == -1)
|
||
goto Failure;
|
||
int iRetLast = iRet;
|
||
iRet = _AddToTaskbar(pti, -1, TRUE, fForceGetIcon);
|
||
if (iRet == -1)
|
||
{
|
||
_DeleteTaskItem(iRetLast, TRUE);
|
||
ptiGroup = NULL;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
iRet = _AddToTaskbar(pti, iIndexGroup + _GetGroupSize(iIndexGroup) + 1, _IsHidden(iIndexGroup), fForceGetIcon);
|
||
}
|
||
|
||
// If _AddToTaskbar fails (iRet == -1) don't try to add this item anywhere else
|
||
if ((iIndexGroup == _iIndexPopup) && (iRet != -1))
|
||
{
|
||
_AddItemToDropDown(iRet);
|
||
}
|
||
|
||
Failure:
|
||
if (iRet == -1)
|
||
{
|
||
if (ptiGroup)
|
||
{
|
||
delete ptiGroup;
|
||
}
|
||
if (pti)
|
||
{
|
||
delete pti;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (_fAnimate && _IsHorizontal() &&
|
||
ToolBar_IsVisible(_tb, iRet) && !c_tray.IsTaskbarFading())
|
||
{
|
||
_SetItemWidth(iRet, 1); // cannot be zero or toolbar will resize it.
|
||
|
||
// If this operation is successful then _AsyncAnimateItems will raise thread priority
|
||
// after the animation is complete
|
||
fRestoreThreadPriority = !_AnimateItems(iRet, TRUE, FALSE);
|
||
}
|
||
}
|
||
|
||
_UpdateProgramCount();
|
||
|
||
_CheckSize();
|
||
|
||
if (fRestoreThreadPriority)
|
||
{
|
||
_RestoreThreadPriority();
|
||
}
|
||
|
||
return iRet;
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
// Delete an item from the listbox but resize the buttons if needed.
|
||
void CTaskBand::_DeleteItem(HWND hwnd, int iIndex)
|
||
{
|
||
if (iIndex == -1)
|
||
iIndex = _FindIndexByHwnd(hwnd);
|
||
|
||
if (iIndex != -1)
|
||
{
|
||
int iIndexGroup = _GetGroupIndex(iIndex);
|
||
int iGroupSize = _GetGroupSize(iIndexGroup) - 1;
|
||
|
||
if (iGroupSize == 0)
|
||
{
|
||
_FreePopupMenu();
|
||
_DeleteTaskItem(iIndex, TRUE);
|
||
_DeleteTaskItem(iIndexGroup, TRUE);
|
||
}
|
||
else if ((iGroupSize == 1) || (_fGlom && (_iGroupSize >= GLOM_SIZE) && (iGroupSize < _iGroupSize)))
|
||
{
|
||
_FreePopupMenu();
|
||
_DeleteTaskItem(iIndex, TRUE);
|
||
_Glom(iIndexGroup, FALSE);
|
||
}
|
||
else
|
||
{
|
||
if (iIndexGroup == _iIndexPopup)
|
||
_RemoveItemFromDropDown(iIndex);
|
||
_DeleteTaskItem(iIndex, TRUE);
|
||
}
|
||
|
||
_CheckSize();
|
||
// Update the flag that says, "There is an item flashing."
|
||
_UpdateFlashingFlag();
|
||
|
||
_UpdateProgramCount();
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
// Adds the given window to the task list.
|
||
// Returns TRUE/FALSE depending on whether the window was actually added.
|
||
// NB No check is made to see if it's already in the list.
|
||
BOOL CTaskBand::_AddWindow(HWND hwnd)
|
||
{
|
||
if (_IsWindowNormal(hwnd))
|
||
{
|
||
return _InsertItem(hwnd);
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL CTaskBand::_CheckButton(int iIndex, BOOL fCheck)
|
||
{
|
||
TBBUTTONINFO tbbi;
|
||
tbbi.cbSize = sizeof(tbbi);
|
||
tbbi.dwMask = TBIF_STATE | TBIF_BYINDEX;
|
||
_tb.GetButtonInfo(iIndex, &tbbi);
|
||
if (fCheck)
|
||
tbbi.fsState |= TBSTATE_CHECKED;
|
||
else
|
||
tbbi.fsState &= ~TBSTATE_CHECKED;
|
||
return _tb.SetButtonInfo(iIndex, &tbbi);
|
||
}
|
||
|
||
BOOL CTaskBand::_IsButtonChecked(int iIndex)
|
||
{
|
||
TBBUTTONINFO tbbi;
|
||
tbbi.cbSize = sizeof(tbbi);
|
||
tbbi.dwMask = TBIF_STATE | TBIF_BYINDEX;
|
||
_tb.GetButtonInfo(iIndex, &tbbi);
|
||
return BOOLIFY(tbbi.fsState & TBSTATE_CHECKED);
|
||
}
|
||
|
||
int CTaskBand::_GetCurSel()
|
||
{
|
||
for (int i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
if (_IsButtonChecked(i))
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
void CTaskBand::_SetCurSel(int iIndex, BOOL fIgnoreCtrlKey)
|
||
{
|
||
// Under certain very rare circumstances someone will call us with an invalid index
|
||
// Case #1: CallbackSM is called with a no longer valid uID with maps to a bogus index
|
||
// Case #2: _SelectWindow creates a new button, but before calling this function another button is removed causing
|
||
// the index of the new button to be invalid
|
||
if (iIndex == -1 || (iIndex >= 0 && iIndex < _tb.GetButtonCount()))
|
||
{
|
||
int iIndexGroup = (iIndex == -1) ? -1 : _GetGroupIndex(iIndex);
|
||
BOOL fControlKey = (GetKeyState(VK_CONTROL) < 0) && (!fIgnoreCtrlKey);
|
||
|
||
if (fControlKey)
|
||
{
|
||
if (GetForegroundWindow() != (HWND)_tb)
|
||
{
|
||
_fIgnoreTaskbarActivate = TRUE;
|
||
_tb.SetFocus();
|
||
}
|
||
}
|
||
|
||
for (int i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
if (fControlKey)
|
||
{
|
||
if ((i == iIndex) || (i == iIndexGroup))
|
||
{
|
||
pti->dwFlags = (pti->dwFlags & TIF_CHECKED) ? (pti->dwFlags & (~TIF_CHECKED)) : pti->dwFlags | TIF_CHECKED;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
pti->dwFlags = ((i == iIndex) || (i == iIndexGroup)) ? pti->dwFlags | TIF_CHECKED : (pti->dwFlags & (~TIF_CHECKED));
|
||
}
|
||
|
||
_CheckButton(i, pti->dwFlags & TIF_CHECKED);
|
||
}
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
// If the given window is in the task list then it is selected.
|
||
// If it's not in the list then it is added.
|
||
int CTaskBand::_SelectWindow(HWND hwnd)
|
||
{
|
||
int i; // Initialize to zero for the empty case
|
||
int iCurSel;
|
||
|
||
// Are there any items?
|
||
|
||
// Some item has the focus, is it selected?
|
||
iCurSel = _GetCurSel();
|
||
i = -1;
|
||
|
||
// We aren't highlighting the correct task. Find it.
|
||
if (IsWindow(hwnd))
|
||
{
|
||
i = _FindIndexByHwnd(hwnd);
|
||
|
||
if ( i == -1 )
|
||
{
|
||
// Didn't find it - better add it now.
|
||
i = _InsertItem(hwnd);
|
||
}
|
||
else if (i == iCurSel)
|
||
{
|
||
return i; // the current one is already selected
|
||
}
|
||
}
|
||
|
||
// passing -1 is ok
|
||
_SetCurSel(i, TRUE);
|
||
if (i != -1)
|
||
{
|
||
_ScrollIntoView(i);
|
||
}
|
||
|
||
return i;
|
||
}
|
||
|
||
|
||
//---------------------------------------------------------------------------
|
||
// Set the focus to the given window
|
||
// If fAutomin is set the old task will be re-minimising if it was restored
|
||
// during the last switch_to.
|
||
void CTaskBand::_SwitchToWindow(HWND hwnd)
|
||
{
|
||
// use GetLastActivePopup (if it's a visible window) so we don't change
|
||
// what child had focus all the time
|
||
HWND hwndLastActive = GetLastActivePopup(hwnd);
|
||
|
||
if ((hwndLastActive) && (IsWindowVisible(hwndLastActive)))
|
||
hwnd = hwndLastActive;
|
||
|
||
int iIndex = _FindIndexByHwnd(hwnd);
|
||
if (iIndex != -1)
|
||
{
|
||
PTASKITEM pti = _GetItem(iIndex);
|
||
if (pti)
|
||
{
|
||
pti->dwTimeLastClicked = GetTickCount();
|
||
}
|
||
}
|
||
|
||
SwitchToThisWindow(hwnd, TRUE);
|
||
}
|
||
|
||
int CTaskBand::_GetSelectedItems(CDSA<PTASKITEM>* pdsa)
|
||
{
|
||
int cSelected = 0;
|
||
for (int i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
TBBUTTONINFO tbbi;
|
||
PTASKITEM pti = _GetItem(i, &tbbi);
|
||
if ((tbbi.fsState & TBSTATE_CHECKED) && !(tbbi.fsState & TBSTATE_HIDDEN))
|
||
{
|
||
if (pti->hwnd)
|
||
{
|
||
cSelected++;
|
||
if (pdsa)
|
||
pdsa->AppendItem(&pti);
|
||
}
|
||
else
|
||
{
|
||
cSelected += _GetGroupItems(i, pdsa);
|
||
}
|
||
}
|
||
}
|
||
|
||
return cSelected;
|
||
}
|
||
|
||
void CTaskBand::_OnGroupCommand(int iRet, CDSA<PTASKITEM>* pdsa)
|
||
{
|
||
// turn off animations during this
|
||
ANIMATIONINFO ami;
|
||
ami.cbSize = sizeof(ami);
|
||
SystemParametersInfo(SPI_GETANIMATION, sizeof(ami), &ami, FALSE);
|
||
LONG iAnimate = ami.iMinAnimate;
|
||
ami.iMinAnimate = FALSE;
|
||
SystemParametersInfo(SPI_SETANIMATION, sizeof(ami), &ami, FALSE);
|
||
|
||
switch (iRet)
|
||
{
|
||
case IDM_CASCADE:
|
||
case IDM_VERTTILE:
|
||
case IDM_HORIZTILE:
|
||
{
|
||
int cbHWND = pdsa->GetItemCount();
|
||
HWND* prgHWND = new HWND[cbHWND];
|
||
|
||
if (prgHWND)
|
||
{
|
||
for (int i = 0; i < cbHWND; i++)
|
||
{
|
||
PTASKITEM pti;
|
||
pdsa->GetItem(i, &pti);
|
||
prgHWND[i] = pti->hwnd;
|
||
|
||
if (IsIconic(pti->hwnd))
|
||
{
|
||
// this needs to by synchronous with the arrange
|
||
ShowWindow(prgHWND[i], SW_RESTORE);
|
||
}
|
||
|
||
BringWindowToTop(pti->hwnd);
|
||
}
|
||
|
||
if (iRet == IDM_CASCADE)
|
||
{
|
||
CascadeWindows(GetDesktopWindow(), MDITILE_ZORDER, NULL, cbHWND, prgHWND);
|
||
}
|
||
else
|
||
{
|
||
UINT wHow = (iRet == IDM_VERTTILE ? MDITILE_VERTICAL : MDITILE_HORIZONTAL);
|
||
TileWindows(GetDesktopWindow(), wHow, NULL, cbHWND, prgHWND);
|
||
}
|
||
SetForegroundWindow(prgHWND[cbHWND - 1]);
|
||
|
||
delete[] prgHWND;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case IDM_CLOSE:
|
||
case IDM_MINIMIZE:
|
||
{
|
||
int idCmd;
|
||
switch (iRet)
|
||
{
|
||
case IDM_MINIMIZE: idCmd = SC_MINIMIZE; break;
|
||
case IDM_CLOSE: idCmd = SC_CLOSE; break;
|
||
}
|
||
|
||
for (int i = pdsa->GetItemCount() - 1; i >= 0; i--)
|
||
{
|
||
PTASKITEM pti;
|
||
pdsa->GetItem(i, &pti);
|
||
PostMessage(pti->hwnd, WM_SYSCOMMAND, idCmd, 0L);
|
||
}
|
||
|
||
_SetCurSel(-1, TRUE);
|
||
}
|
||
break;
|
||
}
|
||
|
||
// restore animations state
|
||
ami.iMinAnimate = iAnimate;
|
||
SystemParametersInfo(SPI_SETANIMATION, sizeof(ami), &ami, FALSE);
|
||
}
|
||
|
||
int CTaskBand::_GetGroupItems(int iIndexGroup, CDSA<PTASKITEM>* pdsa)
|
||
{
|
||
int iGroupSize = _GetGroupSize(iIndexGroup);
|
||
|
||
if (pdsa)
|
||
{
|
||
for (int i = iIndexGroup + 1; i < iIndexGroup + iGroupSize + 1; i++)
|
||
{
|
||
PTASKITEM ptiTemp = _GetItem(i);
|
||
pdsa->AppendItem(&ptiTemp);
|
||
}
|
||
}
|
||
|
||
return iGroupSize;
|
||
}
|
||
|
||
void CTaskBand::_SysMenuForItem(int i, int x, int y)
|
||
{
|
||
_iSysMenuCount++;
|
||
CDSA<PTASKITEM> dsa;
|
||
dsa.Create(4);
|
||
PTASKITEM pti = _GetItem(i);
|
||
int cSelectedItems = _GetSelectedItems(&dsa);
|
||
|
||
if (((cSelectedItems > 1) && _IsButtonChecked(i)) || !pti->hwnd)
|
||
{
|
||
HMENU hmenu = LoadMenuPopup(MAKEINTRESOURCE(MENU_GROUPCONTEXT));
|
||
|
||
if (cSelectedItems <= 1)
|
||
{
|
||
dsa.Destroy();
|
||
dsa.Create(4);
|
||
_GetGroupItems(i, &dsa);
|
||
}
|
||
|
||
// OFFICESDI: Is this an office app doing its taskbar fakery
|
||
BOOL fMinimize = FALSE;
|
||
BOOL fOfficeApp = FALSE;
|
||
|
||
for (int iIndex = (int)(dsa.GetItemCount()) - 1; iIndex >= 0; iIndex--)
|
||
{
|
||
PTASKITEM pti;
|
||
dsa.GetItem(iIndex, &pti);
|
||
if (pti->dwFlags & TIF_EVERACTIVEALT)
|
||
{
|
||
fOfficeApp = TRUE;
|
||
}
|
||
|
||
if (_ShouldMinimize(pti->hwnd))
|
||
fMinimize = TRUE;
|
||
}
|
||
|
||
// OFFICESDI: If it is an office app disable pretty much everything
|
||
if (fOfficeApp)
|
||
{
|
||
EnableMenuItem(hmenu, IDM_CLOSE, MF_DISABLED | MF_GRAYED | MF_BYCOMMAND);
|
||
EnableMenuItem(hmenu, IDM_CASCADE, MF_DISABLED | MF_GRAYED | MF_BYCOMMAND);
|
||
EnableMenuItem(hmenu, IDM_HORIZTILE, MF_DISABLED | MF_GRAYED | MF_BYCOMMAND);
|
||
EnableMenuItem(hmenu, IDM_VERTTILE, MF_DISABLED | MF_GRAYED | MF_BYCOMMAND);
|
||
EnableMenuItem(hmenu, IDM_MINIMIZE, MF_DISABLED | MF_GRAYED | MF_BYCOMMAND);
|
||
}
|
||
else if (!fMinimize)
|
||
{
|
||
EnableMenuItem(hmenu, IDM_MINIMIZE, MF_DISABLED | MF_GRAYED | MF_BYCOMMAND);
|
||
}
|
||
|
||
CToolTipCtrl ttc = _tb.GetToolTips();
|
||
ttc.Activate(FALSE);
|
||
int iRet = TrackPopupMenuEx(hmenu, TPM_RETURNCMD | TPM_RIGHTBUTTON,
|
||
x, y, _tb, NULL);
|
||
ttc.Activate(TRUE);
|
||
|
||
_OnGroupCommand(iRet, &dsa);
|
||
}
|
||
else
|
||
{
|
||
LPARAM lParam = MAKELPARAM(x, y);
|
||
_RestoreWindow(pti->hwnd, pti->dwFlags);
|
||
_SelectWindow(pti->hwnd);
|
||
PostMessage(_hwnd, TBC_POSTEDRCLICK, (WPARAM)pti->hwnd, (LPARAM)lParam);
|
||
}
|
||
|
||
dsa.Destroy();
|
||
_iSysMenuCount--;
|
||
}
|
||
|
||
void CALLBACK CTaskBand::FakeSystemMenuCB(HWND hwnd, UINT uMsg, ULONG_PTR dwData, LRESULT lres)
|
||
{
|
||
CTaskBand* ptasks = (CTaskBand*)dwData;
|
||
KillTimer(ptasks->_hwnd, IDT_SYSMENU);
|
||
|
||
if (uMsg == WM_GETICON)
|
||
{
|
||
SendMessageCallback(hwnd, WM_SYSMENU, 0, ptasks->_dwPos, (SENDASYNCPROC)CTaskBand::FakeSystemMenuCB, (ULONG_PTR)ptasks);
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// Since we fake system menu's sometimes, we can come through here
|
||
// 1 or 2 times per system menu request (once for the real one and
|
||
// once for the fake one). Only decrement it down to 0. Don't go neg.
|
||
//
|
||
if (ptasks->_iSysMenuCount) // Decrement it if any outstanding...
|
||
ptasks->_iSysMenuCount--;
|
||
|
||
ptasks->_dwPos = 0; // Indicates that we aren't doing a menu now
|
||
if (ptasks->_iSysMenuCount <= 0)
|
||
{
|
||
CToolTipCtrl ttc = ptasks->_tb.GetToolTips();
|
||
ttc.Activate(TRUE);
|
||
}
|
||
}
|
||
}
|
||
|
||
HWND CTaskBand::_CreateFakeWindow(HWND hwndOwner)
|
||
{
|
||
WNDCLASSEX wc;
|
||
|
||
if (!GetClassInfoEx(hinstCabinet, TEXT("_ExplorerFakeWindow"), &wc))
|
||
{
|
||
ZeroMemory(&wc, sizeof(wc));
|
||
wc.cbSize = sizeof(wc);
|
||
wc.lpfnWndProc = DefWindowProc;
|
||
wc.hInstance = hinstCabinet;
|
||
wc.lpszClassName = TEXT("_ExplorerFakeWindow");
|
||
RegisterClassEx(&wc);
|
||
}
|
||
return CreateWindow(TEXT("_ExplorerFakeWindow"), NULL, WS_POPUP | WS_SYSMENU,
|
||
0, 0, 0, 0, hwndOwner, NULL, hinstCabinet, NULL);
|
||
}
|
||
|
||
void CTaskBand::_HandleSysMenuTimeout()
|
||
{
|
||
HWND hwndTask = _hwndSysMenu;
|
||
DWORD dwPos = _dwPos;
|
||
HWND hwndFake = NULL;
|
||
|
||
KillTimer(_hwnd, IDT_SYSMENU);
|
||
|
||
HMENU hPopup = GetSystemMenu(hwndTask, FALSE);
|
||
|
||
// This window doesn't have the system menu. Since this window
|
||
// is hung, let's fake one so the user can still close it.
|
||
if (hPopup == NULL)
|
||
{
|
||
if ((hwndFake = _CreateFakeWindow(_hwnd)) != NULL)
|
||
{
|
||
hPopup = GetSystemMenu(hwndFake, FALSE);
|
||
}
|
||
}
|
||
|
||
if (hPopup)
|
||
{
|
||
// Disable everything on the popup menu _except_ close
|
||
|
||
int cItems = GetMenuItemCount(hPopup);
|
||
BOOL fMinimize = _ShouldMinimize(hwndTask);
|
||
for (int iItem = 0; iItem < cItems; iItem++)
|
||
{
|
||
UINT ID = GetMenuItemID(hPopup, iItem);
|
||
// Leave the minimize item as is. NT allows
|
||
// hung-window minimization.
|
||
|
||
if (ID == SC_MINIMIZE && fMinimize)
|
||
{
|
||
continue;
|
||
}
|
||
if (ID != SC_CLOSE)
|
||
{
|
||
EnableMenuItem(hPopup, iItem, MF_BYPOSITION | MF_GRAYED);
|
||
}
|
||
|
||
}
|
||
|
||
// workaround for user bug, we must be the foreground window
|
||
SetForegroundWindow(_hwnd);
|
||
::SetFocus(_hwnd);
|
||
|
||
if (SC_CLOSE == TrackPopupMenu(hPopup,
|
||
TPM_RIGHTBUTTON | TPM_RETURNCMD,
|
||
GET_X_LPARAM(dwPos), GET_Y_LPARAM(dwPos),
|
||
0,
|
||
_hwnd,
|
||
NULL))
|
||
{
|
||
EndTask(hwndTask, NULL, NULL);
|
||
}
|
||
|
||
}
|
||
|
||
// Destroy the fake window
|
||
if (hwndFake != NULL)
|
||
{
|
||
DestroyWindow(hwndFake);
|
||
}
|
||
|
||
// Turn back on tooltips
|
||
FakeSystemMenuCB(hwndTask, WM_SYSMENU, (ULONG_PTR)this, 0);
|
||
}
|
||
|
||
void CTaskBand::_HandleSysMenu(HWND hwnd)
|
||
{
|
||
//
|
||
// At this point, USER32 just told us that the app is now about to bring
|
||
// up its own system menu. We can therefore put away our fake system
|
||
// menu.
|
||
//
|
||
DefWindowProc(_hwnd, WM_CANCELMODE, 0, 0); // Close menu
|
||
KillTimer(_hwnd, IDT_SYSMENU);
|
||
}
|
||
|
||
void CTaskBand::_FakeSystemMenu(HWND hwndTask, DWORD dwPos)
|
||
{
|
||
if (_iSysMenuCount <= 0)
|
||
{
|
||
CToolTipCtrl ttc = _tb.GetToolTips();
|
||
ttc.Activate(FALSE);
|
||
}
|
||
|
||
// HACKHACK: sleep to give time to switch to them. (user needs this... )
|
||
Sleep(20);
|
||
|
||
DWORD dwTimeout = TIMEOUT_SYSMENU;
|
||
|
||
//
|
||
// ** Advanced System Menu functionality **
|
||
//
|
||
// If the app doesn't put up its system menu within a reasonable timeout,
|
||
// then we popup a fake menu for it anyway. Suppport for this is required
|
||
// in USER32 (basically it needs to tell us when to turn off our timeout
|
||
// timer).
|
||
//
|
||
// If the user-double right-clicks on the task bar, they get a really
|
||
// short timeout. If the app is already hung, then they get a really
|
||
// short timeout. Otherwise, they get the relatively long timeout.
|
||
//
|
||
if (_dwPos != 0) // 2nd right-click (on a double-right click)
|
||
dwTimeout = TIMEOUT_SYSMENU_HUNG;
|
||
|
||
//
|
||
// We check to see if the app in question is hung, and if so, simulate
|
||
// speed up the timeout process. It will happen soon enough.
|
||
//
|
||
_hwndSysMenu = hwndTask;
|
||
_dwPos = dwPos;
|
||
_iSysMenuCount++;
|
||
|
||
PTASKITEM pti = NULL;
|
||
int iIndex = _FindIndexByHwnd(hwndTask);
|
||
if (iIndex != -1)
|
||
{
|
||
pti = _GetItem(iIndex);
|
||
}
|
||
|
||
if (IsHungAppWindow(hwndTask) || (pti && pti->fHungApp))
|
||
{
|
||
_HandleSysMenuTimeout();
|
||
}
|
||
else
|
||
{
|
||
SetTimer(_hwnd, IDT_SYSMENU, dwTimeout, NULL);
|
||
if (!SendMessageCallback(hwndTask, WM_GETICON, 0, ICON_SMALL2, (SENDASYNCPROC)FakeSystemMenuCB, (ULONG_PTR)this))
|
||
{
|
||
_HandleSysMenuTimeout();
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
BOOL CTaskBand::_ContextMenu(DWORD dwPos)
|
||
{
|
||
int i, x, y;
|
||
|
||
if (dwPos != (DWORD)-1)
|
||
{
|
||
x = GET_X_LPARAM(dwPos);
|
||
y = GET_Y_LPARAM(dwPos);
|
||
POINT pt = {x, y};
|
||
_tb.ScreenToClient(&pt);
|
||
i = _tb.HitTest(&pt);
|
||
}
|
||
else
|
||
{
|
||
RECT rc;
|
||
i = _tb.GetHotItem();
|
||
_tb.GetItemRect(i, &rc);
|
||
_tb.ClientToScreen((POINT*)&rc);
|
||
x = rc.left;
|
||
y = rc.top;
|
||
}
|
||
|
||
if ((i >= 0) && (i < _tb.GetButtonCount()))
|
||
{
|
||
if (!_IsButtonChecked(i))
|
||
{
|
||
_SetCurSel(i, FALSE);
|
||
}
|
||
_SysMenuForItem(i, x, y);
|
||
}
|
||
|
||
return (i >= 0);
|
||
}
|
||
|
||
void CTaskBand::_HandleCommand(WORD wCmd, WORD wID, HWND hwnd)
|
||
{
|
||
if (hwnd != _tb)
|
||
{
|
||
switch (wCmd)
|
||
{
|
||
case SC_CLOSE:
|
||
{
|
||
BOOL fForce = (GetKeyState(VK_CONTROL) < 0) ? TRUE : FALSE;
|
||
EndTask(_hwndSysMenu, FALSE , fForce);
|
||
}
|
||
break;
|
||
|
||
case SC_MINIMIZE:
|
||
ShowWindow(_hwndSysMenu, SW_FORCEMINIMIZE);
|
||
break;
|
||
}
|
||
}
|
||
else if (wCmd == BN_CLICKED)
|
||
{
|
||
int iIndex = _tb.CommandToIndex(wID);
|
||
|
||
if (GetKeyState(VK_CONTROL) < 0)
|
||
{
|
||
_SetCurSel(iIndex, FALSE);
|
||
}
|
||
else
|
||
{
|
||
PTASKITEM pti = _GetItem(iIndex);
|
||
if (pti->hwnd)
|
||
{
|
||
_OnButtonPressed(iIndex, pti, FALSE);
|
||
}
|
||
else
|
||
{
|
||
if (_iIndexPopup == -1)
|
||
{
|
||
_SetCurSel(iIndex, FALSE);
|
||
_HandleDropDown(iIndex);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
BOOL _IsChineseLanguage()
|
||
{
|
||
WORD wLang = GetUserDefaultLangID();
|
||
return (PRIMARYLANGID(wLang) == LANG_CHINESE &&
|
||
((SUBLANGID(wLang) == SUBLANG_CHINESE_TRADITIONAL) ||
|
||
(SUBLANGID(wLang) == SUBLANG_CHINESE_SIMPLIFIED)));
|
||
}
|
||
|
||
void CTaskBand::_DrawNumber(HDC hdc, int iValue, BOOL fCalcRect, LPRECT prc)
|
||
{
|
||
DWORD uiStyle = DT_LEFT | DT_VCENTER | DT_SINGLELINE | DT_NOPREFIX | DT_CENTER;
|
||
WCHAR szCount[14];
|
||
_itow(iValue, szCount, 10);
|
||
if (fCalcRect)
|
||
{
|
||
StrCat(szCount, L"0");
|
||
}
|
||
|
||
uiStyle |= fCalcRect ? DT_CALCRECT : 0;
|
||
|
||
if (_hTheme)
|
||
{
|
||
if (fCalcRect)
|
||
{
|
||
GetThemeTextExtent(_hTheme, hdc, TDP_GROUPCOUNT, 0, szCount, -1, uiStyle, NULL, prc);
|
||
}
|
||
else
|
||
{
|
||
DrawThemeText(_hTheme, hdc, TDP_GROUPCOUNT, 0, szCount, -1, uiStyle, 0, prc);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
HFONT hfont = SelectFont(hdc, _hfontCapBold);
|
||
SetTextColor(hdc, GetSysColor(COLOR_BTNTEXT));
|
||
SetBkMode(hdc, TRANSPARENT);
|
||
DrawText(hdc, (LPTSTR)szCount, -1, prc, uiStyle);
|
||
SelectFont(hdc, hfont);
|
||
}
|
||
}
|
||
|
||
LRESULT CTaskBand::_HandleCustomDraw(LPNMTBCUSTOMDRAW ptbcd, PTASKITEM pti)
|
||
{
|
||
if (!pti)
|
||
{
|
||
pti = (PTASKITEM)ptbcd->nmcd.lItemlParam;
|
||
}
|
||
|
||
LRESULT lres = CDRF_DODEFAULT;
|
||
switch (ptbcd->nmcd.dwDrawStage)
|
||
{
|
||
case CDDS_PREPAINT:
|
||
lres = CDRF_NOTIFYITEMDRAW;
|
||
break;
|
||
|
||
case CDDS_ITEMPREPAINT:
|
||
{
|
||
if (ptbcd->nmcd.uItemState & CDIS_CHECKED)
|
||
{
|
||
// set bold text, unless on chinese language system (where bold text is illegible)
|
||
if (!_IsChineseLanguage())
|
||
{
|
||
_hfontSave = SelectFont(ptbcd->nmcd.hdc, _hfontCapBold);
|
||
lres |= CDRF_NOTIFYPOSTPAINT | CDRF_NEWFONT;
|
||
}
|
||
}
|
||
|
||
if (pti->dwFlags & TIF_RENDERFLASHED)
|
||
{
|
||
if (_hTheme)
|
||
{
|
||
DrawThemeBackground(_hTheme, ptbcd->nmcd.hdc, (ptbcd->nmcd.hdr.hwndFrom == _tb) ? TDP_FLASHBUTTON : TDP_FLASHBUTTONGROUPMENU, 0, &(ptbcd->nmcd.rc), 0);
|
||
lres |= TBCDRF_NOBACKGROUND;
|
||
}
|
||
else
|
||
{
|
||
// set blue background
|
||
ptbcd->clrHighlightHotTrack = GetSysColor(COLOR_HIGHLIGHT);
|
||
ptbcd->clrBtnFace = GetSysColor(COLOR_HIGHLIGHT);
|
||
ptbcd->clrText = GetSysColor(COLOR_HIGHLIGHTTEXT);
|
||
if (!(ptbcd->nmcd.uItemState & CDIS_HOT))
|
||
{
|
||
ptbcd->nmcd.uItemState |= CDIS_HOT;
|
||
lres |= TBCDRF_NOEDGES;
|
||
}
|
||
lres |= TBCDRF_HILITEHOTTRACK;
|
||
}
|
||
}
|
||
|
||
if (pti->dwFlags & TIF_TRANSPARENT)
|
||
{
|
||
lres = CDRF_SKIPDEFAULT;
|
||
}
|
||
|
||
if (!pti->hwnd)
|
||
{
|
||
|
||
lres |= CDRF_NOTIFYPOSTPAINT;
|
||
|
||
RECT rc;
|
||
int iIndex = _tb.CommandToIndex((int)ptbcd->nmcd.dwItemSpec);
|
||
_DrawNumber(ptbcd->nmcd.hdc, _GetGroupSize(iIndex), TRUE, &rc);
|
||
ptbcd->iListGap = RECTWIDTH(rc);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case CDDS_ITEMPOSTPAINT:
|
||
{
|
||
if (!pti->hwnd)
|
||
{
|
||
int iIndex = _tb.CommandToIndex((int)ptbcd->nmcd.dwItemSpec);
|
||
|
||
if (ptbcd->nmcd.rc.right >= ptbcd->rcText.left)
|
||
{
|
||
RECT rc = ptbcd->rcText;
|
||
rc.right = rc.left;
|
||
rc.left -= ptbcd->iListGap;
|
||
_DrawNumber(ptbcd->nmcd.hdc, _GetGroupSize(iIndex), FALSE, &rc);
|
||
}
|
||
}
|
||
|
||
if (ptbcd->nmcd.uItemState & CDIS_CHECKED)
|
||
{
|
||
// restore font
|
||
ASSERT(!_IsChineseLanguage());
|
||
SelectFont(ptbcd->nmcd.hdc, _hfontSave);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
return lres;
|
||
}
|
||
|
||
void CTaskBand::_RemoveImage(int iImage)
|
||
{
|
||
if (iImage >= 0 && HIWORD(iImage) == IL_NORMAL)
|
||
{
|
||
CImageList il = CImageList(_tb.GetImageList());
|
||
if (il)
|
||
{
|
||
BOOL fRedraw = (BOOL)_tb.SendMessage(WM_SETREDRAW, FALSE, 0);
|
||
|
||
il.Remove(iImage);
|
||
|
||
// Removing image bumps all subsequent indices down by 1. Iterate
|
||
// through the buttons and patch up their indices as necessary.
|
||
|
||
TBBUTTONINFO tbbi;
|
||
tbbi.cbSize = sizeof(tbbi);
|
||
tbbi.dwMask = TBIF_BYINDEX | TBIF_IMAGE;
|
||
for (int i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
_tb.GetButtonInfo(i, &tbbi);
|
||
if (tbbi.iImage > iImage && HIWORD(tbbi.iImage) == IL_NORMAL)
|
||
{
|
||
--tbbi.iImage;
|
||
_tb.SetButtonInfo(i, &tbbi);
|
||
}
|
||
}
|
||
|
||
_tb.SetRedraw(fRedraw);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_OnButtonPressed(int iIndex, PTASKITEM pti, BOOL fForceRestore)
|
||
{
|
||
ASSERT(pti);
|
||
|
||
if (iIndex == _iIndexActiveAtLDown)
|
||
{
|
||
if (pti->dwFlags & TIF_EVERACTIVEALT)
|
||
{
|
||
PostMessage(pti->hwnd, WM_SYSCOMMAND, SC_RESTORE, -1);
|
||
_SetCurSel(-1, FALSE);
|
||
}
|
||
else if (IsIconic(pti->hwnd) || fForceRestore)
|
||
{
|
||
if (pti->hwnd == GetForegroundWindow())
|
||
{
|
||
ShowWindowAsync(pti->hwnd, SW_RESTORE);
|
||
}
|
||
else
|
||
{
|
||
_SwitchToItem(iIndex, pti->hwnd, TRUE);
|
||
}
|
||
}
|
||
else if (_ShouldMinimize(pti->hwnd))
|
||
{
|
||
SHAllowSetForegroundWindow(pti->hwnd);
|
||
PostMessage(pti->hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 0);
|
||
_SetCurSel(-1, FALSE);
|
||
|
||
}
|
||
}
|
||
else
|
||
{
|
||
_SwitchToItem(iIndex, pti->hwnd, TRUE);
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_GetDispInfo(LPNMTBDISPINFO lptbdi)
|
||
{
|
||
if (lptbdi->dwMask & TBNF_IMAGE)
|
||
{
|
||
int iIndex = _tb.CommandToIndex(lptbdi->idCommand);
|
||
_UpdateItemIcon(iIndex);
|
||
|
||
TBBUTTONINFO tbbi;
|
||
tbbi.cbSize = sizeof(tbbi);
|
||
tbbi.dwMask = TBIF_BYINDEX | TBIF_IMAGE;
|
||
_tb.GetButtonInfo(iIndex, &tbbi);
|
||
|
||
lptbdi->iImage = tbbi.iImage;
|
||
lptbdi->dwMask |= TBNF_DI_SETITEM;
|
||
}
|
||
}
|
||
|
||
LRESULT CTaskBand::_HandleNotify(LPNMHDR lpnm)
|
||
{
|
||
switch (lpnm->code)
|
||
{
|
||
case NM_LDOWN:
|
||
{
|
||
int iIndex = _tb.CommandToIndex(((LPNMTOOLBAR)lpnm)->iItem);
|
||
PTASKITEM pti = _GetItem(iIndex);
|
||
if (pti && pti->hwnd)
|
||
{
|
||
_iIndexActiveAtLDown = _GetCurSel();
|
||
}
|
||
}
|
||
break;
|
||
|
||
|
||
case NM_KEYDOWN:
|
||
{
|
||
LPNMKEY pnmk = (LPNMKEY)lpnm;
|
||
switch (pnmk->nVKey)
|
||
{
|
||
case VK_SPACE:
|
||
case VK_RETURN:
|
||
// need to toggle checked state, toolbar doesn't do it for us
|
||
{
|
||
int iItem = _tb.GetHotItem();
|
||
if (iItem >= 0)
|
||
{
|
||
TBBUTTONINFO tbbi;
|
||
tbbi.cbSize = sizeof(tbbi);
|
||
tbbi.dwMask = TBIF_BYINDEX | TBIF_STATE;
|
||
_tb.GetButtonInfo(iItem, &tbbi);
|
||
tbbi.fsState ^= TBSTATE_CHECKED;
|
||
_tb.SetButtonInfo(iItem, &tbbi);
|
||
|
||
PTASKITEM pti = _GetItem(iItem);
|
||
_OnButtonPressed(iItem, pti, FALSE);
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case TBN_DELETINGBUTTON:
|
||
break;
|
||
|
||
case TBN_HOTITEMCHANGE:
|
||
if (_fDenyHotItemChange)
|
||
{
|
||
return 1;
|
||
}
|
||
else
|
||
{
|
||
LPNMTBHOTITEM pnmhot = (LPNMTBHOTITEM)lpnm;
|
||
if (pnmhot->dwFlags & HICF_ARROWKEYS)
|
||
{
|
||
// If this change came from a mouse then the hot item is already in view
|
||
_ScrollIntoView(_tb.CommandToIndex(pnmhot->idNew));
|
||
}
|
||
}
|
||
break;
|
||
|
||
case TBN_DROPDOWN:
|
||
{
|
||
int iIndex = _tb.CommandToIndex(((LPNMTOOLBAR)lpnm)->iItem);
|
||
int iCurIndex = _GetCurSel();
|
||
_iIndexActiveAtLDown = iCurIndex;
|
||
|
||
if ((iCurIndex == -1) || (_GetGroupIndex(iCurIndex) != iIndex) || (GetKeyState(VK_CONTROL) < 0))
|
||
{
|
||
_SetCurSel(iIndex, FALSE);
|
||
}
|
||
|
||
if (!(GetKeyState(VK_CONTROL) < 0))
|
||
{
|
||
_SetCurSel(iIndex, FALSE);
|
||
_HandleDropDown(iIndex);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case TBN_GETDISPINFO:
|
||
{
|
||
LPNMTBDISPINFO lptbdi = (LPNMTBDISPINFO)lpnm;
|
||
_GetDispInfo(lptbdi);
|
||
}
|
||
break;
|
||
|
||
case NM_CUSTOMDRAW:
|
||
return _HandleCustomDraw((LPNMTBCUSTOMDRAW)lpnm);
|
||
|
||
case TTN_NEEDTEXT:
|
||
{
|
||
int iIndex = _tb.CommandToIndex((int)lpnm->idFrom);
|
||
LPTOOLTIPTEXT pttt = (LPTOOLTIPTEXT)lpnm;
|
||
|
||
int cchLen = 0;
|
||
PTASKITEM pti = _GetItem(iIndex);
|
||
if (pti && !pti->hwnd)
|
||
{
|
||
wnsprintf(pttt->szText, ARRAYSIZE(pttt->szText), L"(%d) ", _GetGroupSize(iIndex));
|
||
cchLen = lstrlen(pttt->szText);
|
||
}
|
||
_GetItemTitle(iIndex, &(pttt->szText[cchLen]), ARRAYSIZE(pttt->szText) - cchLen, FALSE);
|
||
}
|
||
break;
|
||
|
||
case NM_THEMECHANGED:
|
||
{
|
||
_VerifyButtonHeight();
|
||
}
|
||
break;
|
||
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
void CTaskBand::_SwitchToItem(int iItem, HWND hwnd, BOOL fIgnoreCtrlKey)
|
||
{
|
||
if (_IsWindowNormal(hwnd))
|
||
{
|
||
_RaiseDesktop(FALSE);
|
||
|
||
if (_pmpPopup)
|
||
_pmpPopup->OnSelect(MPOS_FULLCANCEL);
|
||
|
||
_SetCurSel(iItem, fIgnoreCtrlKey);
|
||
if (!(GetKeyState(VK_CONTROL) < 0) || fIgnoreCtrlKey)
|
||
{
|
||
_SwitchToWindow(hwnd);
|
||
}
|
||
}
|
||
else if (!hwnd)
|
||
{
|
||
// I know what you are thinking, why would we ever get a NM_CLICK message for a dropdown button.
|
||
// Ok, sit back and enjoy
|
||
// 1) Click on a group button
|
||
// 2) All window messages are funnelled through the menuband currently being used for the group menu
|
||
// 3) User clicks on another group button
|
||
// 4) The WM_LBUTTONDOWN message is captured and eaten by menuband, then menuband dismisses itself causing a TBC_FREEPOPUPMENU
|
||
// 5) Then the toolbar button for the other group button gets an WM_LBUTTONUP message
|
||
// 6) Guess what, dropdown button notifications are sent during WM_LBUTTONDOWN not UP
|
||
// 7) Thus we don't get an TBN_DROPDOWN we get an NM_CLICK
|
||
// 8) We need to make sure the user didn't click on the same group button as before
|
||
// 9) However, the previous group menu has been dismissed, so I create _iIndexLastPopup which persists after a group menu is dismissed
|
||
|
||
if (iItem != _iIndexLastPopup)
|
||
{
|
||
_SetCurSel(iItem, fIgnoreCtrlKey);
|
||
if (!(GetKeyState(VK_CONTROL) < 0) || fIgnoreCtrlKey)
|
||
{
|
||
_HandleDropDown(iItem);
|
||
}
|
||
}
|
||
}
|
||
// NOTE: HWND_TOPMOST is used to indicate that the deleted button
|
||
// is being animated. This allows the button to stay around after
|
||
// its real hwnd becomes invalid
|
||
else if (hwnd != HWND_TOPMOST)
|
||
{
|
||
// Window went away?
|
||
_DeleteItem(hwnd);
|
||
_SetCurSel(-1, fIgnoreCtrlKey);
|
||
}
|
||
}
|
||
|
||
BOOL WINAPI CTaskBand::BuildEnumProc(HWND hwnd, LPARAM lParam)
|
||
{
|
||
CTaskBand* ptasks = (CTaskBand*)lParam;
|
||
if (IsWindow(hwnd) && IsWindowVisible(hwnd) && !::GetWindow(hwnd, GW_OWNER) &&
|
||
(!(GetWindowLong(hwnd, GWL_EXSTYLE) & WS_EX_TOOLWINDOW)))
|
||
{
|
||
ptasks->_AddWindow(hwnd);
|
||
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
// Work around a toolbar bug where it goes wacko if you press both mouse
|
||
// buttons. The reason is that the second mouse button doing down tries
|
||
// to reassert capture. This causes the toolbar to receive WM_CAPTURECHANGED
|
||
// with its own hwnd as lParam. Toolbar doesn't realize that it's being told
|
||
// that it is stealing capture from itself and thinks somebody else is
|
||
// trying to steal capture, so it posts a message to itself to clean up.
|
||
// The posted message arrives, and toolbar cleans up the capture, thinking
|
||
// it's cleaning up the old capture that it lost, but in fact it's cleaning
|
||
// up the NEW capture it just finished setting!
|
||
//
|
||
// So filter out WM_CAPTURECHANGED messages that are effectively NOPs.
|
||
//
|
||
|
||
LRESULT CALLBACK s_FilterCaptureSubclassProc(
|
||
HWND hwnd,
|
||
UINT uMsg,
|
||
WPARAM wParam,
|
||
LPARAM lParam,
|
||
UINT_PTR uIdSubclass,
|
||
DWORD_PTR dwRefData)
|
||
{
|
||
switch (uMsg)
|
||
{
|
||
|
||
case WM_CAPTURECHANGED:
|
||
if (hwnd == (HWND)lParam)
|
||
{
|
||
// Don't let toolbar be fooled into cleaning up capture
|
||
// when it shouldn't.
|
||
return 0;
|
||
}
|
||
break;
|
||
|
||
case WM_NCDESTROY:
|
||
RemoveWindowSubclass(hwnd, s_FilterCaptureSubclassProc, uIdSubclass);
|
||
break;
|
||
}
|
||
|
||
return DefSubclassProc(hwnd, uMsg, wParam, lParam);
|
||
}
|
||
|
||
|
||
//---------------------------------------------------------------------------
|
||
LRESULT CTaskBand::_HandleCreate()
|
||
{
|
||
ASSERT(_hwnd);
|
||
|
||
_uCDHardError = RegisterWindowMessage( TEXT(COPYDATA_HARDERROR) );
|
||
|
||
RegisterDragDrop(_hwnd, this);
|
||
|
||
_tb.Create(_hwnd, NULL, NULL, WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE | CCS_NODIVIDER |
|
||
TBSTYLE_LIST | TBSTYLE_TOOLTIPS | TBSTYLE_WRAPABLE | CCS_NORESIZE | TBSTYLE_TRANSPARENT);
|
||
if (_tb)
|
||
{
|
||
SendMessage(_tb, TB_ADDSTRING, (WPARAM)hinstCabinet, (LPARAM)IDS_BOGUSLABELS);
|
||
|
||
_OpenTheme();
|
||
SendMessage(_tb, TB_SETWINDOWTHEME, 0, (LPARAM)(_IsHorizontal() ? c_wzTaskBandTheme : c_wzTaskBandThemeVert));
|
||
|
||
SetWindowSubclass(_tb, s_FilterCaptureSubclassProc, 0, 0);
|
||
|
||
_tb.SetButtonStructSize();
|
||
|
||
// initial size
|
||
SIZE size = {0, 0};
|
||
_tb.SetButtonSize(size);
|
||
|
||
_tb.SetExtendedStyle( TBSTYLE_EX_TRANSPARENTDEADAREA |
|
||
TBSTYLE_EX_FIXEDDROPDOWN |
|
||
TBSTYLE_EX_DOUBLEBUFFER |
|
||
TBSTYLE_EX_TOOLTIPSEXCLUDETOOLBAR);
|
||
|
||
// version info
|
||
_tb.SendMessage(CCM_SETVERSION, COMCTL32_VERSION, 0);
|
||
|
||
_CreateTBImageLists();
|
||
|
||
HWND hwndTT = _tb.GetToolTips();
|
||
if (hwndTT)
|
||
{
|
||
SHSetWindowBits(hwndTT, GWL_STYLE, TTS_ALWAYSTIP | TTS_NOPREFIX,
|
||
TTS_ALWAYSTIP | TTS_NOPREFIX);
|
||
}
|
||
|
||
// set shell hook
|
||
WM_ShellHook = RegisterWindowMessage(TEXT("SHELLHOOK"));
|
||
RegisterShellHook(_hwnd, 3); // 3 = magic flag
|
||
|
||
// force getting of font, calc of metrics
|
||
_HandleWinIniChange(0, 0, TRUE);
|
||
|
||
// populate the toolbar
|
||
EnumWindows(BuildEnumProc, (LPARAM)this);
|
||
|
||
SHChangeNotifyEntry fsne;
|
||
fsne.fRecursive = FALSE;
|
||
fsne.pidl = NULL;
|
||
_uShortcutInvokeNotify = SHChangeNotifyRegister(_hwnd,
|
||
SHCNRF_NewDelivery | SHCNRF_ShellLevel,
|
||
SHCNE_ASSOCCHANGED |
|
||
SHCNE_EXTENDED_EVENT | SHCNE_UPDATEIMAGE,
|
||
TBC_CHANGENOTIFY,
|
||
1, &fsne);
|
||
|
||
// set window text to give accessibility apps something to read
|
||
TCHAR szTitle[80];
|
||
LoadString(hinstCabinet, IDS_TASKBANDTITLE, szTitle, ARRAYSIZE(szTitle));
|
||
SetWindowText(_hwnd, szTitle);
|
||
SetWindowText(_tb, szTitle);
|
||
|
||
return 0; // success
|
||
}
|
||
|
||
// Failure.
|
||
return -1;
|
||
}
|
||
|
||
void CTaskBand::_FreePopupMenu()
|
||
{
|
||
_iIndexPopup = -1;
|
||
|
||
ATOMICRELEASE(_psmPopup);
|
||
if (_pmpPopup)
|
||
{
|
||
IUnknown_SetSite(_pmpPopup, NULL);
|
||
_pmpPopup->OnSelect(MPOS_FULLCANCEL);
|
||
}
|
||
ATOMICRELEASE(_pmpPopup);
|
||
ATOMICRELEASE(_pmbPopup);
|
||
|
||
SendMessage(v_hwndTray, TM_SETPUMPHOOK, NULL, NULL);
|
||
|
||
_menuPopup.Detach();
|
||
}
|
||
|
||
HRESULT CTaskBand::_CreatePopupMenu(POINTL* ppt, RECTL* prcl)
|
||
{
|
||
HRESULT hr = E_FAIL;
|
||
|
||
CToolTipCtrl ttc = _tb.GetToolTips();
|
||
ttc.Activate(FALSE);
|
||
SetActiveWindow(v_hwndTray);
|
||
|
||
CTaskBandSMC* ptbc = new CTaskBandSMC(this);
|
||
if (ptbc)
|
||
{
|
||
if (SUCCEEDED(CoCreateInstance(CLSID_MenuBand, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IShellMenu2, &_psmPopup))) &&
|
||
SUCCEEDED(_psmPopup->Initialize(ptbc, 0, 0, SMINIT_CUSTOMDRAW | SMINIT_VERTICAL | SMINIT_TOPLEVEL | SMINIT_USEMESSAGEFILTER)) &&
|
||
SUCCEEDED(CoCreateInstance(CLSID_MenuDeskBar, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IMenuPopup, &_pmpPopup))) &&
|
||
SUCCEEDED(_psmPopup->SetMenu(_menuPopup, _hwnd, SMSET_USEPAGER | SMSET_NOPREFIX)) &&
|
||
SUCCEEDED(_psmPopup->QueryInterface(IID_PPV_ARG(IMenuBand, &_pmbPopup))))
|
||
{
|
||
_psmPopup->SetMinWidth(RECTWIDTH(*prcl));
|
||
|
||
IBandSite* pbs;
|
||
if (SUCCEEDED(CoCreateInstance(CLSID_MenuBandSite, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IBandSite, &pbs))))
|
||
{
|
||
if (SUCCEEDED(_pmpPopup->SetClient(pbs)))
|
||
{
|
||
IDeskBand* pdb;
|
||
if (SUCCEEDED(_psmPopup->QueryInterface(IID_PPV_ARG(IDeskBand, &pdb))))
|
||
{
|
||
pbs->AddBand(pdb);
|
||
pdb->Release();
|
||
|
||
SendMessage(v_hwndTray, TM_SETPUMPHOOK, (WPARAM)_pmbPopup, (LPARAM)_pmpPopup);
|
||
|
||
if (_hTheme)
|
||
{
|
||
HWND hwndTB;
|
||
IUnknown_GetWindow(_psmPopup, &hwndTB);
|
||
if (hwndTB)
|
||
{
|
||
SendMessage(hwndTB, TB_SETWINDOWTHEME, 0, (LPARAM)c_wzTaskBandGroupMenuTheme);
|
||
}
|
||
_psmPopup->SetNoBorder(TRUE);
|
||
}
|
||
|
||
hr = _pmpPopup->Popup(ppt, prcl, MPPF_BOTTOM);
|
||
}
|
||
}
|
||
pbs->Release();
|
||
}
|
||
}
|
||
ptbc->Release();
|
||
}
|
||
|
||
if (FAILED(hr))
|
||
{
|
||
ttc.Activate(TRUE);
|
||
_FreePopupMenu();
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
void CTaskBand::_AddItemToDropDown(int iIndex)
|
||
{
|
||
PTASKITEM pti = _GetItem(iIndex);
|
||
|
||
WCHAR szWndText[MAX_WNDTEXT];
|
||
_GetItemTitle(iIndex, szWndText, ARRAYSIZE(szWndText), TRUE);
|
||
|
||
if ((HMENU)_menuPopup)
|
||
{
|
||
_menuPopup.InsertMenu(0, MF_BYCOMMAND, iIndex, szWndText);
|
||
}
|
||
|
||
if (_psmPopup)
|
||
{
|
||
_psmPopup->InvalidateItem(NULL, SMINV_REFRESH);
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_RemoveItemFromDropDown(int iIndex)
|
||
{
|
||
_menuPopup.DeleteMenu(iIndex, MF_BYCOMMAND);
|
||
int iGroupSize = _GetGroupSize(_iIndexPopup);
|
||
|
||
for (int i = iIndex + 1; i <= _iIndexPopup + iGroupSize + 1; i++)
|
||
{
|
||
_RefreshItemFromDropDown(i, i - 1, FALSE);
|
||
}
|
||
|
||
if (_psmPopup)
|
||
{
|
||
_psmPopup->InvalidateItem(NULL, SMINV_REFRESH);
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_RefreshItemFromDropDown(int iIndex, int iNewIndex, BOOL fRefresh)
|
||
{
|
||
PTASKITEM pti = _GetItem(iNewIndex);
|
||
WCHAR szWndText[MAX_WNDTEXT];
|
||
_GetItemTitle(iNewIndex, szWndText, ARRAYSIZE(szWndText), TRUE);
|
||
_menuPopup.ModifyMenu(iIndex, MF_BYCOMMAND, iNewIndex, szWndText);
|
||
|
||
if (fRefresh && _psmPopup)
|
||
{
|
||
if (iIndex == iNewIndex)
|
||
{
|
||
SMDATA smd;
|
||
smd.uId = iIndex;
|
||
_psmPopup->InvalidateItem(&smd, SMINV_REFRESH | SMINV_POSITION);
|
||
}
|
||
else
|
||
_psmPopup->InvalidateItem(NULL, SMINV_REFRESH);
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_ClosePopupMenus()
|
||
{
|
||
SendMessage(v_hwndTray, SBM_CANCELMENU, 0, 0);
|
||
_FreePopupMenu();
|
||
}
|
||
|
||
void CTaskBand::_HandleDropDown(int iIndex)
|
||
{
|
||
_ClosePopupMenus();
|
||
|
||
PTASKITEM pti = _GetItem(iIndex);
|
||
|
||
if (pti)
|
||
{
|
||
_iIndexLastPopup = _iIndexPopup = iIndex;
|
||
_menuPopup.CreatePopupMenu();
|
||
|
||
for (int i = _GetGroupSize(iIndex) + iIndex; i > iIndex; i--)
|
||
{
|
||
_AddItemToDropDown(i);
|
||
}
|
||
|
||
RECT rc;
|
||
_tb.GetItemRect(iIndex, &rc);
|
||
MapWindowPoints(_tb, HWND_DESKTOP, (LPPOINT)&rc, 2);
|
||
|
||
POINTL pt = {rc.left, rc.top};
|
||
RECTL rcl;
|
||
RECTtoRECTL(&rc, &rcl);
|
||
|
||
CToolTipCtrl ttc = _tb.GetToolTips();
|
||
ttc.Activate(FALSE);
|
||
_CreatePopupMenu(&pt, &rcl);
|
||
}
|
||
}
|
||
|
||
LRESULT CTaskBand::_HandleDestroy()
|
||
{
|
||
_UnregisterNotify(_uShortcutInvokeNotify);
|
||
|
||
RevokeDragDrop(_hwnd);
|
||
|
||
RegisterShellHook(_hwnd, FALSE);
|
||
|
||
_hwnd = NULL;
|
||
|
||
if (_hTheme)
|
||
{
|
||
CloseThemeData(_hTheme);
|
||
_hTheme = NULL;
|
||
}
|
||
|
||
if (_tb)
|
||
{
|
||
ASSERT(_tb.IsWindow());
|
||
|
||
for (int i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
if (pti)
|
||
{
|
||
delete pti;
|
||
}
|
||
}
|
||
CImageList il = CImageList(_tb.GetImageList());
|
||
if (il)
|
||
{
|
||
il.Destroy();
|
||
}
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
LRESULT CTaskBand::_HandleScroll(BOOL fHoriz, UINT code, int nPos)
|
||
{
|
||
TBMETRICS tbm;
|
||
_GetToolbarMetrics(&tbm);
|
||
|
||
SCROLLINFO si;
|
||
si.cbSize = sizeof(si);
|
||
si.fMask = SIF_PAGE | SIF_RANGE | SIF_POS;
|
||
GetScrollInfo(_hwnd, fHoriz ? SB_HORZ : SB_VERT, &si);
|
||
si.nMax -= (si.nPage -1);
|
||
|
||
switch (code)
|
||
{
|
||
case SB_BOTTOM: nPos = si.nMax; break;
|
||
case SB_TOP: nPos = 0; break;
|
||
case SB_ENDSCROLL: nPos = si.nPos; break;
|
||
case SB_LINEDOWN: nPos = si.nPos + 1; break;
|
||
case SB_LINEUP: nPos = si.nPos - 1; break;
|
||
case SB_PAGEDOWN: nPos = si.nPos + si.nPage; break;
|
||
case SB_PAGEUP: nPos = si.nPos - si.nPage; break;
|
||
case SB_THUMBPOSITION:
|
||
case SB_THUMBTRACK: break;
|
||
}
|
||
|
||
if (nPos > (int)(si.nMax))
|
||
nPos = si.nMax;
|
||
if (nPos < 0 )
|
||
nPos = 0;
|
||
|
||
SetScrollPos(_hwnd, fHoriz ? SB_HORZ : SB_VERT, nPos, TRUE);
|
||
|
||
DWORD dwSize = _tb.GetButtonSize();
|
||
if (fHoriz)
|
||
{
|
||
int cxRow = LOWORD(dwSize) + tbm.cxButtonSpacing;
|
||
_tb.SetWindowPos(0, -nPos * cxRow, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE |SWP_NOZORDER);
|
||
}
|
||
else
|
||
{
|
||
int cyRow = HIWORD(dwSize) + tbm.cyButtonSpacing;
|
||
_tb.SetWindowPos(0, 0, -nPos * cyRow , 0, 0, SWP_NOACTIVATE | SWP_NOSIZE |SWP_NOZORDER);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
// after a selection is made, scroll it into view
|
||
void CTaskBand::_ScrollIntoView(int iItem)
|
||
{
|
||
DWORD dwStyle = GetWindowLong(_hwnd, GWL_STYLE);
|
||
if (dwStyle & (WS_HSCROLL | WS_VSCROLL))
|
||
{
|
||
int cVisible = 0;
|
||
for (int i = 0; i < iItem; i++)
|
||
{
|
||
if (!_IsHidden(i))
|
||
cVisible++;
|
||
}
|
||
|
||
if (_IsHidden(i))
|
||
{
|
||
PTASKITEM pti = _GetItem(iItem);
|
||
if (pti->hwnd)
|
||
{
|
||
cVisible--;
|
||
}
|
||
}
|
||
|
||
int iRows, iCols;
|
||
_GetNumberOfRowsCols(&iRows, &iCols, TRUE);
|
||
_HandleScroll((dwStyle & WS_HSCROLL), SB_THUMBPOSITION, (dwStyle & WS_HSCROLL) ? cVisible / iRows : cVisible / iCols);
|
||
}
|
||
}
|
||
|
||
|
||
//---------------------------------------------------------------------------
|
||
LRESULT CTaskBand::_HandleSize(WPARAM fwSizeType)
|
||
{
|
||
// Make the listbox fill the parent;
|
||
if (fwSizeType != SIZE_MINIMIZED)
|
||
{
|
||
_CheckSize();
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
// Have the task list show the given window.
|
||
// NB Ignore taskman itself.
|
||
LRESULT CTaskBand::_HandleActivate(HWND hwndActive)
|
||
{
|
||
//
|
||
// App-window activation change is a good time to do a reality
|
||
// check (make sure there are no ghost buttons, etc).
|
||
//
|
||
_RealityCheck();
|
||
|
||
if (hwndActive && _IsWindowNormal(hwndActive))
|
||
{
|
||
_RaiseDesktop(FALSE);
|
||
|
||
int i = _SelectWindow(hwndActive);
|
||
if (i != -1)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
|
||
if (pti)
|
||
{
|
||
// Strip off TIF_FLASHING
|
||
pti->dwFlags &= ~TIF_FLASHING;
|
||
|
||
// Update the flag that says, "There is an item flashing."
|
||
_UpdateFlashingFlag();
|
||
|
||
// if it's flashed blue, turn it off.
|
||
if (pti->dwFlags & TIF_RENDERFLASHED)
|
||
_RedrawItem(hwndActive, HSHELL_REDRAW);
|
||
|
||
// Switching to an application counts as "usage"
|
||
// similar to launching it. This solves the "long-running
|
||
// app treated as if it is rarely run" problem
|
||
if (pti->ptsh)
|
||
{
|
||
pti->ptsh->Tickle();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// Activate taskbar
|
||
if (!(_fIgnoreTaskbarActivate && GetForegroundWindow() == v_hwndTray) && (_iIndexPopup == -1))
|
||
{
|
||
_SetCurSel(-1, TRUE);
|
||
}
|
||
else
|
||
{
|
||
_fIgnoreTaskbarActivate = FALSE;
|
||
}
|
||
}
|
||
|
||
if (hwndActive)
|
||
_ptray->_hwndLastActive = hwndActive;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
void CTaskBand::_HandleOtherWindowDestroyed(HWND hwndDestroyed)
|
||
{
|
||
int i;
|
||
|
||
// Look for the destoyed window.
|
||
int iItemIndex = _FindIndexByHwnd(hwndDestroyed);
|
||
if (iItemIndex >= 0)
|
||
{
|
||
if (_fAnimate && _IsHorizontal() &&
|
||
ToolBar_IsVisible(_tb, iItemIndex))
|
||
{
|
||
_AnimateItems(iItemIndex, FALSE, FALSE);
|
||
}
|
||
else
|
||
{
|
||
_DeleteItem(hwndDestroyed, iItemIndex);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// If the item doesn't exist in the task list, make sure it isn't part
|
||
// of somebody's fake SDI implementation. Otherwise Minimize All will
|
||
// break.
|
||
for (i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
if ((pti->dwFlags & TIF_EVERACTIVEALT) &&
|
||
(HWND) GetWindowLongPtr(pti->hwnd, 0) ==
|
||
hwndDestroyed)
|
||
{
|
||
goto NoDestroy;
|
||
}
|
||
}
|
||
}
|
||
|
||
_ptray->HandleWindowDestroyed(hwndDestroyed);
|
||
|
||
NoDestroy:
|
||
// This might have been a rude app. Figure out if we've
|
||
// got one now and have the tray sync up.
|
||
HWND hwndRudeApp = _FindRudeApp(NULL);
|
||
_ptray->HandleFullScreenApp(hwndRudeApp);
|
||
if (hwndRudeApp)
|
||
{
|
||
DWORD dwStyleEx = GetWindowLongPtr(hwndRudeApp, GWL_EXSTYLE);
|
||
if (!(dwStyleEx & WS_EX_TOPMOST) && !_IsRudeWindowActive(hwndRudeApp))
|
||
{
|
||
SwitchToThisWindow(hwndRudeApp, TRUE);
|
||
}
|
||
}
|
||
|
||
if (_ptray->_hwndLastActive == hwndDestroyed)
|
||
{
|
||
if (_ptray->_hwndLastActive == hwndDestroyed)
|
||
_ptray->_hwndLastActive = NULL;
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_HandleGetMinRect(HWND hwndShell, POINTS * prc)
|
||
{
|
||
RECT rc;
|
||
RECT rcTask;
|
||
|
||
int i = _FindIndexByHwnd(hwndShell);
|
||
if (i == -1)
|
||
return;
|
||
|
||
// Is this button grouped
|
||
if (_IsHidden(i))
|
||
{
|
||
// Yes, get the index for the group button and use its size
|
||
i = _GetGroupIndex(i);
|
||
}
|
||
|
||
// Found it in our list.
|
||
_tb.GetItemRect(i, &rc);
|
||
|
||
//
|
||
// If the Tab is mirrored then let's retreive the screen coordinates
|
||
// by calculating from the left edge of the screen since screen coordinates
|
||
// are not mirrored so that minRect will prserve its location. [samera]
|
||
//
|
||
if (IS_WINDOW_RTL_MIRRORED(GetDesktopWindow()))
|
||
{
|
||
RECT rcTab;
|
||
|
||
_tb.GetWindowRect(&rcTab);
|
||
rc.left += rcTab.left;
|
||
rc.right += rcTab.left;
|
||
rc.top += rcTab.top;
|
||
rc.bottom += rcTab.top;
|
||
}
|
||
else
|
||
{
|
||
_tb.MapWindowPoints(HWND_DESKTOP, (LPPOINT)&rc, 2);
|
||
}
|
||
|
||
prc[0].x = (short)rc.left;
|
||
prc[0].y = (short)rc.top;
|
||
prc[1].x = (short)rc.right;
|
||
prc[1].y = (short)rc.bottom;
|
||
|
||
// make sure the rect is within out client area
|
||
GetClientRect(_hwnd, &rcTask);
|
||
MapWindowPoints(_hwnd, HWND_DESKTOP, (LPPOINT)&rcTask, 2);
|
||
if (prc[0].x < rcTask.left)
|
||
{
|
||
prc[1].x = prc[0].x = (short)rcTask.left;
|
||
prc[1].x++;
|
||
}
|
||
if (prc[0].x > rcTask.right)
|
||
{
|
||
prc[1].x = prc[0].x = (short)rcTask.right;
|
||
prc[1].x++;
|
||
}
|
||
if (prc[0].y < rcTask.top)
|
||
{
|
||
prc[1].y = prc[0].y = (short)rcTask.top;
|
||
prc[1].y++;
|
||
}
|
||
if (prc[0].y > rcTask.bottom)
|
||
{
|
||
prc[1].y = prc[0].y = (short)rcTask.bottom;
|
||
prc[1].y++;
|
||
}
|
||
}
|
||
|
||
BOOL CTaskBand::_IsItemActive(HWND hwndItem)
|
||
{
|
||
HWND hwnd = GetForegroundWindow();
|
||
|
||
return (hwnd && hwnd == hwndItem);
|
||
}
|
||
|
||
void CTaskBand::_CreateTBImageLists()
|
||
{
|
||
CImageList il = CImageList(_tb.GetImageList());
|
||
|
||
ATOMICRELEASE(_pimlSHIL);
|
||
SHGetImageList(SHIL_SYSSMALL, IID_PPV_ARG(IImageList, &_pimlSHIL));
|
||
|
||
il.Destroy();
|
||
int cx = GetSystemMetrics(SM_CXSMICON);
|
||
int cy = GetSystemMetrics(SM_CYSMICON);
|
||
|
||
il.Create(cx, cy, SHGetImageListFlags(_tb), 4, 4);
|
||
|
||
_tb.SendMessage(TB_SETIMAGELIST, IL_NORMAL, (LPARAM)(HIMAGELIST)il);
|
||
_tb.SendMessage(TB_SETIMAGELIST, IL_SHIL, (LPARAM)IImageListToHIMAGELIST(_pimlSHIL));
|
||
}
|
||
|
||
int CTaskBand::_AddIconToNormalImageList(HICON hicon, int iImage)
|
||
{
|
||
if (hicon)
|
||
{
|
||
CImageList il = CImageList(_tb.GetImageList());
|
||
if (il)
|
||
{
|
||
int iRet;
|
||
|
||
if (iImage < 0 || HIWORD(iImage) != IL_NORMAL)
|
||
iRet = il.ReplaceIcon(-1, hicon);
|
||
else
|
||
iRet = il.ReplaceIcon(iImage, hicon);
|
||
|
||
if (iRet == -1)
|
||
{
|
||
TraceMsg(TF_WARNING, "ReplaceIcon failed for iImage %x hicon %x", iImage, hicon);
|
||
iRet = iImage;
|
||
}
|
||
|
||
return MAKELONG(iRet, IL_NORMAL);
|
||
}
|
||
}
|
||
return I_IMAGENONE;
|
||
}
|
||
|
||
void CTaskBand::_UpdateItemText(int iItem)
|
||
{
|
||
TBBUTTONINFO tbbi;
|
||
tbbi.cbSize = sizeof(tbbi);
|
||
tbbi.dwMask = TBIF_BYINDEX | TBIF_TEXT;
|
||
|
||
// get current button text
|
||
TCHAR szWndText[MAX_WNDTEXT];
|
||
*szWndText = 0;
|
||
_GetItemTitle(iItem, szWndText, ARRAYSIZE(szWndText), FALSE);
|
||
tbbi.pszText = szWndText;
|
||
|
||
_tb.SetButtonInfo(iItem, &tbbi);
|
||
}
|
||
|
||
void CTaskBand::_DoRedrawWhereNeeded()
|
||
{
|
||
int i;
|
||
for (i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
if (pti->dwFlags & TIF_NEEDSREDRAW)
|
||
{
|
||
pti->dwFlags &= ~TIF_NEEDSREDRAW;
|
||
_RedrawItem(pti->hwnd, HSHELL_REDRAW, i);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_RedrawItem(HWND hwndShell, WPARAM code, int i)
|
||
{
|
||
if (i == -1)
|
||
{
|
||
i = _FindIndexByHwnd(hwndShell);
|
||
}
|
||
|
||
if (i != -1)
|
||
{
|
||
TOOLINFO ti;
|
||
ti.cbSize = sizeof(ti);
|
||
|
||
PTASKITEM pti = _GetItem(i);
|
||
// set the bit saying whether we should flash or not
|
||
if ((code == HSHELL_FLASH) != BOOLIFY(pti->dwFlags & TIF_RENDERFLASHED))
|
||
{
|
||
// only do the set if this bit changed.
|
||
if (code == HSHELL_FLASH)
|
||
{
|
||
// TIF_RENDERFLASHED means, "Paint the background blue."
|
||
// TIF_FLASHING means, "This item is flashing."
|
||
|
||
pti->dwFlags |= TIF_RENDERFLASHED;
|
||
|
||
// Only set TIF_FLASHING and unhide the tray if the app is inactive.
|
||
// Some apps (e.g., freecell) flash themselves while active just for
|
||
// fun. It's annoying for the autohid tray to pop out in that case.
|
||
|
||
if (!_IsItemActive(pti->hwnd))
|
||
{
|
||
pti->dwFlags |= TIF_FLASHING;
|
||
|
||
// unhide the tray whenever we get a flashing app.
|
||
_ptray->Unhide();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// Don't clear TIF_FLASHING. We clear that only when the app
|
||
// is activated.
|
||
pti->dwFlags &= ~TIF_RENDERFLASHED;
|
||
}
|
||
|
||
// Update the flag that says, "There is an item flashing."
|
||
_UpdateFlashingFlag();
|
||
}
|
||
|
||
// Don't change the name of a group button
|
||
if (pti->hwnd)
|
||
{
|
||
// update text and icon
|
||
_UpdateItemText(i);
|
||
_UpdateItemIcon(i);
|
||
}
|
||
|
||
int iGroupIndex = _GetGroupIndex(i);
|
||
if ((iGroupIndex == _iIndexPopup) && hwndShell)
|
||
{
|
||
_RefreshItemFromDropDown(i, i, TRUE);
|
||
}
|
||
|
||
RECT rc;
|
||
if (_tb.GetItemRect(i, &rc))
|
||
{
|
||
InvalidateRect(_tb, &rc, TRUE);
|
||
}
|
||
|
||
if (_tb.GetItemRect(iGroupIndex, &rc))
|
||
{
|
||
InvalidateRect(_tb, &rc, TRUE);
|
||
}
|
||
|
||
ti.hwnd = _tb;
|
||
ti.uId = i;
|
||
ti.lpszText = LPSTR_TEXTCALLBACK;
|
||
SendMessage(_ptray->GetTrayTips(), TTM_UPDATETIPTEXT, 0, (LPARAM)&ti);
|
||
}
|
||
}
|
||
|
||
|
||
void CTaskBand::_SetActiveAlt(HWND hwndAlt)
|
||
{
|
||
int iMax;
|
||
int i;
|
||
|
||
iMax = _tb.GetButtonCount();
|
||
for ( i = 0; i < iMax; i++)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
|
||
if (pti->hwnd == hwndAlt)
|
||
pti->dwFlags |= TIF_ACTIVATEALT | TIF_EVERACTIVEALT;
|
||
else
|
||
pti->dwFlags &= ~TIF_ACTIVATEALT;
|
||
}
|
||
}
|
||
|
||
BOOL _IsRudeWindowActive(HWND hwnd)
|
||
{
|
||
// A rude window is considered "active" if it is:
|
||
// - in the same thread as the foreground window, or
|
||
// - in the same window hierarchy as the foreground window
|
||
//
|
||
HWND hwndFore = GetForegroundWindow();
|
||
|
||
DWORD dwID = GetWindowThreadProcessId(hwnd, NULL);
|
||
DWORD dwIDFore = GetWindowThreadProcessId(hwndFore, NULL);
|
||
|
||
if (dwID == dwIDFore)
|
||
return TRUE;
|
||
else if (SHIsParentOwnerOrSelf(hwnd, hwndFore) == S_OK)
|
||
return TRUE;
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
// _IsRudeWindow -- is given HWND 'rude' (fullscreen) on given monitor
|
||
//
|
||
BOOL _IsRudeWindow(HMONITOR hmon, HWND hwnd, HMONITOR hmonTask, BOOL fSkipActiveCheck)
|
||
{
|
||
ASSERT(hmon);
|
||
ASSERT(hwnd);
|
||
|
||
//
|
||
// Don't count the desktop as rude
|
||
// also filter out hidden windows (such as the desktop browser's raised window)
|
||
//
|
||
if (IsWindowVisible(hwnd) && hwnd != v_hwndDesktop)
|
||
{
|
||
RECT rcMon, rcApp, rcTmp;
|
||
DWORD dwStyle;
|
||
|
||
//
|
||
// NB: User32 will sometimes send us spurious HSHELL_RUDEAPPACTIVATED
|
||
// messages. When this happens, and we happen to have a maximized
|
||
// app up, the old version of this code would think there was a rude app
|
||
// up. This mistake would break tray always-on-top and autohide.
|
||
//
|
||
//
|
||
// The old logic was:
|
||
//
|
||
// If the app's window rect takes up the whole monitor, then it's rude.
|
||
// (This check could mistake normal maximized apps for rude apps.)
|
||
//
|
||
//
|
||
// The new logic is:
|
||
//
|
||
// If the app window does not have WS_DLGFRAME and WS_THICKFRAME,
|
||
// then do the old check. Rude apps typically lack one of these bits
|
||
// (while normal apps usually have them), so do the old check in
|
||
// this case to avoid potential compat issues with rude apps that
|
||
// have non-fullscreen client areas.
|
||
//
|
||
// Otherwise, get the client rect rather than the window rect
|
||
// and compare that rect against the monitor rect.
|
||
//
|
||
|
||
// If (mon U app) == app, then app is filling up entire monitor
|
||
GetMonitorRect(hmon, &rcMon);
|
||
|
||
dwStyle = GetWindowLong(hwnd, GWL_STYLE);
|
||
if ((dwStyle & (WS_CAPTION | WS_THICKFRAME)) == (WS_CAPTION | WS_THICKFRAME))
|
||
{
|
||
// Doesn't match rude app profile; use client rect
|
||
GetClientRect(hwnd, &rcApp);
|
||
MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT)&rcApp, 2);
|
||
}
|
||
else
|
||
{
|
||
// Matches rude app profile; use window rect
|
||
GetWindowRect(hwnd, &rcApp);
|
||
}
|
||
UnionRect(&rcTmp, &rcApp, &rcMon);
|
||
if (EqualRect(&rcTmp, &rcApp))
|
||
{
|
||
// Looks like a rude app. Is it active?
|
||
if ((hmonTask == hmon) && (fSkipActiveCheck || _IsRudeWindowActive(hwnd)))
|
||
{
|
||
return TRUE;
|
||
}
|
||
}
|
||
}
|
||
|
||
// No, not rude
|
||
return FALSE;
|
||
}
|
||
|
||
struct iradata
|
||
{
|
||
HMONITOR hmon; // IN hmon we're checking against
|
||
HWND hwnd; // INOUT hwnd of 1st rude app found
|
||
HMONITOR hmonTask;
|
||
HWND hwndSelected;
|
||
};
|
||
|
||
BOOL WINAPI CTaskBand::IsRudeEnumProc(HWND hwnd, LPARAM lParam)
|
||
{
|
||
struct iradata *pira = (struct iradata *)lParam;
|
||
HMONITOR hmon = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
|
||
|
||
if (hmon && (pira->hmon == NULL || pira->hmon == hmon))
|
||
{
|
||
if (_IsRudeWindow(hmon, hwnd, pira->hmonTask, (hwnd == pira->hwndSelected)))
|
||
{
|
||
// We're done
|
||
pira->hwnd = hwnd;
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
// Keep going
|
||
return TRUE;
|
||
}
|
||
|
||
HWND CTaskBand::_EnumForRudeWindow(HWND hwndSelected)
|
||
{
|
||
struct iradata irad = { NULL, 0, MonitorFromWindow(_hwnd, MONITOR_DEFAULTTONEAREST), hwndSelected };
|
||
// First try our cache
|
||
if (IsWindow(_hwndLastRude))
|
||
{
|
||
if (!IsRudeEnumProc(_hwndLastRude, (LPARAM)&irad))
|
||
{
|
||
// Cache hit
|
||
return irad.hwnd;
|
||
}
|
||
}
|
||
|
||
// No luck, gotta do it the hard way
|
||
EnumWindows(IsRudeEnumProc, (LPARAM)&irad);
|
||
|
||
// Cache it for next time
|
||
_hwndLastRude = irad.hwnd;
|
||
|
||
return irad.hwnd;
|
||
}
|
||
|
||
HWND CTaskBand::_FindRudeApp(HWND hwndPossible)
|
||
{
|
||
//
|
||
// Search through:
|
||
//
|
||
// (a) the toplevel windows for an "active" one that "looks" fullscreen, and
|
||
// (b) the task items for one that is "active" and is marked fullscreen
|
||
//
|
||
|
||
HWND hwndSelected = hwndPossible;
|
||
|
||
if (!hwndSelected)
|
||
{
|
||
int iCurSel = _GetCurSel();
|
||
if (iCurSel != -1)
|
||
{
|
||
PTASKITEM pti = _GetItem(iCurSel);
|
||
hwndSelected = pti->hwnd;
|
||
}
|
||
}
|
||
|
||
HWND hwnd = _EnumForRudeWindow(hwndSelected);
|
||
for (int i = _tb.GetButtonCount() - 1; hwnd == NULL && i >= 0; i--)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
if (pti->fMarkedFullscreen && ((pti->hwnd == hwndSelected) || _IsRudeWindowActive(pti->hwnd)))
|
||
{
|
||
hwnd = pti->hwnd;
|
||
}
|
||
}
|
||
|
||
return hwnd;
|
||
}
|
||
|
||
// handle WM_APPCOMMAND, special case off those that we know are global
|
||
// to the system, these really are not "App" commands ;-)
|
||
|
||
LRESULT CTaskBand::_OnAppCommand(int cmd)
|
||
{
|
||
BOOL bHandled = FALSE;
|
||
switch (cmd)
|
||
{
|
||
// skip all of these, they are either handled by the system volume control
|
||
// or by the media player, don't let these fall through to the registry
|
||
// based app command handling
|
||
case APPCOMMAND_MEDIA_NEXTTRACK:
|
||
case APPCOMMAND_MEDIA_PREVIOUSTRACK:
|
||
case APPCOMMAND_MEDIA_STOP:
|
||
case APPCOMMAND_MEDIA_PLAY_PAUSE:
|
||
break;
|
||
|
||
case APPCOMMAND_VOLUME_MUTE:
|
||
Mixer_ToggleMute();
|
||
return 0;
|
||
case APPCOMMAND_VOLUME_DOWN:
|
||
Mixer_SetVolume(-MIXER_DEFAULT_STEP);
|
||
return 0;
|
||
case APPCOMMAND_VOLUME_UP:
|
||
Mixer_SetVolume(MIXER_DEFAULT_STEP);
|
||
return 0;
|
||
case APPCOMMAND_BASS_BOOST:
|
||
Mixer_ToggleBassBoost();
|
||
return 0;
|
||
case APPCOMMAND_BASS_DOWN:
|
||
Mixer_SetBass(-MIXER_DEFAULT_STEP);
|
||
return 0;
|
||
case APPCOMMAND_BASS_UP:
|
||
Mixer_SetBass(MIXER_DEFAULT_STEP);
|
||
return 0;
|
||
case APPCOMMAND_TREBLE_DOWN:
|
||
Mixer_SetTreble(-MIXER_DEFAULT_STEP);
|
||
return 0;
|
||
case APPCOMMAND_TREBLE_UP:
|
||
Mixer_SetTreble(MIXER_DEFAULT_STEP);
|
||
return 0;
|
||
|
||
default:
|
||
bHandled = AppCommandTryRegistry(cmd);
|
||
if (!bHandled)
|
||
{
|
||
switch (cmd)
|
||
{
|
||
case APPCOMMAND_BROWSER_SEARCH:
|
||
SHFindFiles(NULL, NULL);
|
||
bHandled = TRUE;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return bHandled;
|
||
}
|
||
|
||
PTASKITEM CTaskBand::_FindItemByHwnd(HWND hwnd)
|
||
{
|
||
int iIndex = _FindIndexByHwnd(hwnd);
|
||
return _GetItem(iIndex);
|
||
}
|
||
|
||
void CTaskBand::_OnWindowActivated(HWND hwnd, BOOL fSuspectFullscreen)
|
||
{
|
||
//
|
||
// First see if we consider this window fullscreen
|
||
//
|
||
HWND hwndRude;
|
||
|
||
PTASKITEM pti = _FindItemByHwnd(hwnd);
|
||
if (pti && pti->fMarkedFullscreen)
|
||
{
|
||
//
|
||
// Yes, marked by the app as fullscreen
|
||
//
|
||
hwndRude = hwnd;
|
||
}
|
||
else if (fSuspectFullscreen)
|
||
{
|
||
//
|
||
// Possibly, but we need to double-check for ourselves
|
||
//
|
||
|
||
//
|
||
// We shouldn't need to do this but we're getting rude-app activation
|
||
// msgs when there aren't any.
|
||
//
|
||
// Also, the hwnd that user tells us about is just the foreground window --
|
||
// _FindRudeApp will return the window that's actually sized fullscreen.
|
||
//
|
||
|
||
hwndRude = _FindRudeApp(hwnd);
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// No, not fullscreen
|
||
//
|
||
hwndRude = NULL;
|
||
}
|
||
|
||
SetTimer(_hwnd, IDT_RECHECKRUDEAPP1, 1000, NULL);
|
||
|
||
//
|
||
// Okay, now do that weird hwnd futzing for ACTIVEALT apps
|
||
//
|
||
if (pti == NULL)
|
||
{
|
||
BOOL fFoundBackup = FALSE;
|
||
BOOL fDone = FALSE;
|
||
|
||
int iMax = _tb.GetButtonCount();
|
||
for (int i = 0; (i < iMax) && (!fDone); i++)
|
||
{
|
||
PTASKITEM ptiT = _GetItem(i);
|
||
if (ptiT->hwnd)
|
||
{
|
||
DWORD dwFlags = ptiT->dwFlags;
|
||
if ((dwFlags & TIF_ACTIVATEALT) ||
|
||
(!fFoundBackup && (dwFlags & TIF_EVERACTIVEALT)))
|
||
{
|
||
DWORD dwpid1, dwpid2;
|
||
|
||
GetWindowThreadProcessId(hwnd, &dwpid1);
|
||
GetWindowThreadProcessId(ptiT->hwnd, &dwpid2);
|
||
|
||
// Only change if they're in the same process
|
||
if (dwpid1 == dwpid2)
|
||
{
|
||
hwnd = ptiT->hwnd;
|
||
if (dwFlags & TIF_ACTIVATEALT)
|
||
{
|
||
fDone = TRUE;
|
||
break;
|
||
}
|
||
else
|
||
fFoundBackup = TRUE;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// Now do the actual check/uncheck the button stuff
|
||
//
|
||
_HandleActivate(hwnd);
|
||
|
||
//
|
||
// Finally, let the tray know about any fullscreen windowage
|
||
//
|
||
_ptray->HandleFullScreenApp(hwndRude);
|
||
}
|
||
|
||
// We get notification about activation etc here. This saves having
|
||
// a fine-grained timer.
|
||
LRESULT CTaskBand::_HandleShellHook(int iCode, LPARAM lParam)
|
||
{
|
||
HWND hwnd = (HWND)lParam;
|
||
|
||
switch (iCode)
|
||
{
|
||
case HSHELL_GETMINRECT:
|
||
{
|
||
SHELLHOOKINFO * pshi = (SHELLHOOKINFO *)lParam;
|
||
_HandleGetMinRect(pshi->hwnd, (POINTS *)&pshi->rc);
|
||
}
|
||
return TRUE;
|
||
|
||
case HSHELL_RUDEAPPACTIVATED:
|
||
case HSHELL_WINDOWACTIVATED:
|
||
_OnWindowActivated(hwnd, TRUE);
|
||
break;
|
||
|
||
case HSHELL_WINDOWREPLACING:
|
||
_hwndReplacing = hwnd;
|
||
break;
|
||
|
||
case HSHELL_WINDOWREPLACED:
|
||
if (_hwndReplacing)
|
||
{
|
||
// If we already created a button for this dude, remove it now.
|
||
// We might have one if user sent an HSHELL_WINDOWACTIVATED before
|
||
// the HSHELL_WINDOWREPLACING/HSHELL_WINDOWREPLACED pair.
|
||
_DeleteItem(_hwndReplacing, -1);
|
||
|
||
// Swap in _hwndReplacing for hwnd in hwnd's button
|
||
int iItem = _FindIndexByHwnd(hwnd);
|
||
if (iItem != -1)
|
||
{
|
||
PTASKITEM pti = _GetItem(iItem);
|
||
pti->hwnd = _hwndReplacing;
|
||
|
||
WCHAR szExeName[MAX_PATH];
|
||
SHExeNameFromHWND(_hwndReplacing, szExeName, ARRAYSIZE(szExeName));
|
||
int iIndexGroup = _GetGroupIndex(iItem);
|
||
PTASKITEM ptiGroup = _GetItem(iIndexGroup);
|
||
pti->fHungApp = (lstrcmpi(ptiGroup->pszExeName, szExeName) != 0);
|
||
}
|
||
_hwndReplacing = NULL;
|
||
}
|
||
break;
|
||
|
||
case HSHELL_WINDOWCREATED:
|
||
_AddWindow(hwnd);
|
||
break;
|
||
|
||
case HSHELL_WINDOWDESTROYED:
|
||
_HandleOtherWindowDestroyed(hwnd);
|
||
break;
|
||
|
||
case HSHELL_ACTIVATESHELLWINDOW:
|
||
SwitchToThisWindow(v_hwndTray, TRUE);
|
||
SetForegroundWindow(v_hwndTray);
|
||
break;
|
||
|
||
case HSHELL_TASKMAN:
|
||
|
||
// winlogon/user send a -1 lParam to indicate that the
|
||
// task list should be displayed (normally the lParam is the hwnd)
|
||
|
||
if (-1 == lParam)
|
||
{
|
||
RunSystemMonitor();
|
||
}
|
||
else
|
||
{
|
||
// if it wasn't invoked via control escape, then it was the win key
|
||
if (!_ptray->_fStuckRudeApp && GetAsyncKeyState(VK_CONTROL) >= 0)
|
||
{
|
||
HWND hwndForeground = GetForegroundWindow();
|
||
BOOL fIsTrayForeground = hwndForeground == v_hwndTray;
|
||
if (v_hwndStartPane && hwndForeground == v_hwndStartPane)
|
||
{
|
||
fIsTrayForeground = TRUE;
|
||
}
|
||
if (!_hwndPrevFocus)
|
||
{
|
||
if (!fIsTrayForeground)
|
||
{
|
||
_hwndPrevFocus = hwndForeground;
|
||
}
|
||
}
|
||
else if (fIsTrayForeground)
|
||
{
|
||
// _hwndPrevFocus will be wiped out by the MPOS_FULLCANCEL
|
||
// so save it before we lose it
|
||
HWND hwndPrevFocus = _hwndPrevFocus;
|
||
|
||
_ClosePopupMenus();
|
||
|
||
// otherwise they're just hitting the key again.
|
||
// set focus away
|
||
SHAllowSetForegroundWindow(hwndPrevFocus);
|
||
SetForegroundWindow(hwndPrevFocus);
|
||
_hwndPrevFocus = NULL;
|
||
return TRUE;
|
||
}
|
||
}
|
||
PostMessage(v_hwndTray, TM_ACTASTASKSW, 0, 0L);
|
||
}
|
||
return TRUE;
|
||
|
||
case HSHELL_REDRAW:
|
||
{
|
||
int i = _FindIndexByHwnd(hwnd);
|
||
if (i != -1)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
pti->dwFlags |= TIF_NEEDSREDRAW;
|
||
SetTimer(_hwnd, IDT_REDRAW, 100, 0);
|
||
}
|
||
}
|
||
break;
|
||
case HSHELL_FLASH:
|
||
_RedrawItem(hwnd, iCode);
|
||
break;
|
||
|
||
case HSHELL_ENDTASK:
|
||
EndTask(hwnd, FALSE, FALSE);
|
||
break;
|
||
|
||
case HSHELL_APPCOMMAND:
|
||
// shell gets last shot at WM_APPCOMMAND messages via our shell hook
|
||
// RegisterShellHookWindow() is called in shell32/.RegisterShellHook()
|
||
return _OnAppCommand(GET_APPCOMMAND_LPARAM(lParam));
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
void CTaskBand::_InitFonts()
|
||
{
|
||
HFONT hfont;
|
||
NONCLIENTMETRICS ncm;
|
||
|
||
ncm.cbSize = sizeof(ncm);
|
||
if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0))
|
||
{
|
||
// Create the bold font
|
||
ncm.lfCaptionFont.lfWeight = FW_BOLD;
|
||
hfont = CreateFontIndirect(&ncm.lfCaptionFont);
|
||
if (hfont)
|
||
{
|
||
if (_hfontCapBold)
|
||
DeleteFont(_hfontCapBold);
|
||
|
||
_hfontCapBold = hfont;
|
||
}
|
||
|
||
// Create the normal font
|
||
ncm.lfCaptionFont.lfWeight = FW_NORMAL;
|
||
hfont = CreateFontIndirect(&ncm.lfCaptionFont);
|
||
if (hfont)
|
||
{
|
||
if (_hfontCapNormal)
|
||
DeleteFont(_hfontCapNormal);
|
||
|
||
_hfontCapNormal = hfont;
|
||
}
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_SetItemImage(int iItem, int iImage, int iPref)
|
||
{
|
||
TBBUTTONINFO tbbi;
|
||
|
||
tbbi.cbSize = sizeof(tbbi);
|
||
tbbi.dwMask = TBIF_BYINDEX | TBIF_IMAGE;
|
||
tbbi.iImage = iImage;
|
||
|
||
_tb.SetButtonInfo(iItem, &tbbi);
|
||
|
||
PTASKITEM pti = _GetItem(iItem);
|
||
pti->iIconPref = iPref;
|
||
}
|
||
|
||
void CTaskBand::_UpdateAllIcons()
|
||
{
|
||
BOOL fRedraw = (BOOL)_tb.SendMessage(WM_SETREDRAW, FALSE, 0);
|
||
|
||
// Set all of icon indices in the toolbar to image none
|
||
for (int i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
_SetItemImage(i, I_IMAGENONE, 0);
|
||
}
|
||
|
||
// Create a new image list
|
||
_CreateTBImageLists();
|
||
|
||
for (i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
_UpdateItemIcon(i);
|
||
}
|
||
|
||
_tb.SetRedraw(fRedraw);
|
||
}
|
||
|
||
//---------------------------------------------------------------------------
|
||
LRESULT CTaskBand::_HandleWinIniChange(WPARAM wParam, LPARAM lParam, BOOL fOnCreate)
|
||
{
|
||
_tb.SendMessage(WM_WININICHANGE, wParam, lParam);
|
||
|
||
if (wParam == SPI_SETNONCLIENTMETRICS ||
|
||
((!wParam) && (!lParam || (lstrcmpi((LPTSTR)lParam, TEXT("WindowMetrics")) == 0))))
|
||
{
|
||
//
|
||
// On creation, don't bother creating the fonts if someone else
|
||
// (such as the clock control) has already done it for us.
|
||
//
|
||
if (!fOnCreate || !_hfontCapNormal)
|
||
_InitFonts();
|
||
|
||
if (_tb)
|
||
{
|
||
_tb.SetFont(_hfontCapNormal);
|
||
}
|
||
|
||
// force _TextSpace to be recalculated
|
||
_iTextSpace = 0;
|
||
|
||
if (fOnCreate)
|
||
{
|
||
//
|
||
// On creation, we haven't been inserted into bandsite yet,
|
||
// so we need to defer size validation.
|
||
//
|
||
PostMessage(_hwnd, TBC_VERIFYBUTTONHEIGHT, 0, 0);
|
||
}
|
||
else
|
||
{
|
||
_VerifyButtonHeight();
|
||
}
|
||
}
|
||
|
||
if (lParam == SPI_SETMENUANIMATION || lParam == SPI_SETUIEFFECTS || (!wParam &&
|
||
(!lParam || (lstrcmpi((LPTSTR)lParam, TEXT("Windows")) == 0) ||
|
||
(lstrcmpi((LPTSTR)lParam, TEXT("VisualEffects")) == 0))))
|
||
{
|
||
_fAnimate = ShouldTaskbarAnimate();
|
||
}
|
||
|
||
if (!wParam && (!lParam || (0 == lstrcmpi((LPCTSTR)lParam, TEXT("TraySettings")))))
|
||
{
|
||
_RefreshSettings();
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
void CTaskBand::_VerifyButtonHeight()
|
||
{
|
||
// force toolbar to get new sizes
|
||
SIZE size = {0, 0};
|
||
_tb.SetButtonSize(size);
|
||
|
||
_BandInfoChanged();
|
||
}
|
||
|
||
int CTaskBand::_GetCurButtonHeight()
|
||
{
|
||
TBMETRICS tbm;
|
||
_GetToolbarMetrics(&tbm);
|
||
|
||
int cyButtonHeight = HIWORD(_tb.GetButtonSize());
|
||
if (!cyButtonHeight)
|
||
cyButtonHeight = tbm.cyPad + g_cySize;
|
||
|
||
return cyButtonHeight;
|
||
}
|
||
|
||
void CTaskBand::_HandleChangeNotify(WPARAM wParam, LPARAM lParam)
|
||
{
|
||
LPITEMIDLIST *ppidl;
|
||
LONG lEvent;
|
||
LPSHChangeNotificationLock pshcnl;
|
||
|
||
pshcnl = SHChangeNotification_Lock((HANDLE)wParam, (DWORD)lParam, &ppidl, &lEvent);
|
||
|
||
if (pshcnl)
|
||
{
|
||
switch (lEvent)
|
||
{
|
||
case SHCNE_EXTENDED_EVENT:
|
||
{
|
||
LPSHShortcutInvokeAsIDList psidl = (LPSHShortcutInvokeAsIDList)ppidl[0];
|
||
if (psidl && psidl->dwItem1 == SHCNEE_SHORTCUTINVOKE)
|
||
{
|
||
// Make sure nobody tries to do this in a multithreaded way
|
||
// since we're not protecting the cache with a critical section
|
||
ASSERT(GetCurrentThreadId() == GetWindowThreadProcessId(_hwnd, NULL));
|
||
if (TaskShortcut::_HandleShortcutInvoke(psidl))
|
||
{
|
||
_ReattachTaskShortcut();
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case SHCNE_UPDATEIMAGE:
|
||
{
|
||
int iImage = ppidl[0] ? *(int UNALIGNED *)((BYTE *)ppidl[0] + 2) : -1;
|
||
if (iImage == -1)
|
||
{
|
||
_UpdateAllIcons();
|
||
}
|
||
}
|
||
break;
|
||
|
||
// The tray doesn't have a changenotify registered so we piggyback
|
||
// off this one. If associations change, icons may have changed,
|
||
// so we have to go rebuild. (Also if the user changes between
|
||
// small and large system icons we will get an AssocChanged.)
|
||
case SHCNE_ASSOCCHANGED:
|
||
PostMessage(v_hwndTray, SBM_REBUILDMENU, 0, 0);
|
||
break;
|
||
}
|
||
|
||
SHChangeNotification_Unlock(pshcnl);
|
||
}
|
||
}
|
||
|
||
DWORD WINAPI HardErrorBalloonThread(PVOID pv)
|
||
{
|
||
HARDERRORDATA *phed = (HARDERRORDATA *)pv;
|
||
DWORD dwError;
|
||
WCHAR *pwszTitle = NULL;
|
||
WCHAR *pwszText = NULL;
|
||
|
||
ASSERT(NULL != phed);
|
||
dwError = phed->dwError;
|
||
|
||
if (phed->uOffsetTitleW != 0)
|
||
{
|
||
pwszTitle = (WCHAR *)((BYTE *)phed + phed->uOffsetTitleW);
|
||
}
|
||
if (phed->uOffsetTextW != 0)
|
||
{
|
||
pwszText = (WCHAR *)((BYTE *)phed + phed->uOffsetTextW);
|
||
}
|
||
|
||
TCHAR szMutexName[32];
|
||
HANDLE hMutex;
|
||
wsprintf(szMutexName,TEXT("HardError_%08lX"), dwError);
|
||
hMutex = CreateMutex(NULL, FALSE, szMutexName);
|
||
|
||
if (NULL != hMutex)
|
||
{
|
||
DWORD dwWaitResult = WaitForSingleObject(hMutex, 0); // Just test it
|
||
if (dwWaitResult == WAIT_OBJECT_0)
|
||
{
|
||
IUserNotification *pun;
|
||
HRESULT hr;
|
||
hr = CoCreateInstance(CLSID_UserNotification, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IUserNotification, &pun));
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
pun->SetBalloonRetry(120 * 1000, 0, 0);
|
||
pun->SetBalloonInfo(pwszTitle, pwszText, NIIF_WARNING);
|
||
pun->SetIconInfo(NULL, pwszTitle);
|
||
|
||
hr = pun->Show(NULL, 0);
|
||
|
||
pun->Release();
|
||
}
|
||
ReleaseMutex(hMutex);
|
||
}
|
||
CloseHandle(hMutex);
|
||
}
|
||
LocalFree(pv);
|
||
return 0;
|
||
}
|
||
|
||
LRESULT CTaskBand::_HandleHardError(HARDERRORDATA *phed, DWORD cbData)
|
||
{
|
||
DWORD dwError;
|
||
BOOL fHandled;
|
||
BOOL fBalloon;
|
||
|
||
dwError = phed->dwError;
|
||
fHandled = FALSE;
|
||
fBalloon = TRUE;
|
||
|
||
// Check if we're on the right desktop
|
||
HDESK hdeskInput = OpenInputDesktop(0, FALSE, STANDARD_RIGHTS_REQUIRED | DESKTOP_READOBJECTS);
|
||
if (NULL == hdeskInput)
|
||
{
|
||
// Couldn't open desktop, we must not be getting the hard error while on
|
||
// the default desktop. Lets not handle that case. Its silly to have
|
||
// balloons on the wrong desktop, or not where the user can see them.
|
||
fBalloon = FALSE;
|
||
}
|
||
else
|
||
{
|
||
CloseDesktop(hdeskInput);
|
||
}
|
||
|
||
if (fBalloon)
|
||
{
|
||
HARDERRORDATA *phedCopy;
|
||
|
||
phedCopy = (HARDERRORDATA *)LocalAlloc(LPTR, cbData);
|
||
if (NULL != phedCopy)
|
||
{
|
||
CopyMemory(phedCopy,phed,cbData);
|
||
if (SHCreateThread(HardErrorBalloonThread,phedCopy,CTF_COINIT,NULL))
|
||
{
|
||
fHandled = TRUE;
|
||
}
|
||
else
|
||
{
|
||
LocalFree(phedCopy);
|
||
}
|
||
}
|
||
}
|
||
|
||
return fHandled;
|
||
}
|
||
|
||
void CTaskBand::_OnSetFocus()
|
||
{
|
||
NMHDR nmhdr;
|
||
|
||
_tb.SetFocus();
|
||
|
||
nmhdr.hwndFrom = _hwnd;
|
||
nmhdr.code = NM_SETFOCUS;
|
||
SendMessage(GetParent(_hwnd), WM_NOTIFY, (WPARAM)NULL, (LPARAM)&nmhdr);
|
||
}
|
||
|
||
void CTaskBand::_OpenTheme()
|
||
{
|
||
if (_hTheme)
|
||
{
|
||
CloseThemeData(_hTheme);
|
||
_hTheme = NULL;
|
||
}
|
||
|
||
_hTheme = OpenThemeData(_hwnd, c_wzTaskBandTheme);
|
||
|
||
TBMETRICS tbm;
|
||
_GetToolbarMetrics(&tbm);
|
||
tbm.cxPad = _hTheme ? 20 : 8;
|
||
tbm.cyBarPad = 0;
|
||
tbm.cxButtonSpacing = _hTheme ? 0 : 3;
|
||
tbm.cyButtonSpacing = _hTheme ? 0 : 3;
|
||
_tb.SendMessage(TB_SETMETRICS, 0, (LPARAM)&tbm);
|
||
|
||
_CheckSize();
|
||
}
|
||
|
||
LRESULT CTaskBand::v_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
LRESULT lres;
|
||
|
||
INSTRUMENT_WNDPROC(SHCNFI_MAIN_WNDPROC, hwnd, uMsg, wParam, lParam);
|
||
|
||
switch (uMsg)
|
||
{
|
||
case WM_CREATE:
|
||
return _HandleCreate();
|
||
|
||
case WM_DESTROY:
|
||
return _HandleDestroy();
|
||
|
||
case WM_WINDOWPOSCHANGED:
|
||
{
|
||
LRESULT lres = _HandleSize(wParam);
|
||
SetTimer(_hwnd, IDT_RECHECKRUDEAPP1, 1000, NULL);
|
||
return lres;
|
||
}
|
||
|
||
case WM_PAINT:
|
||
case WM_PRINTCLIENT:
|
||
{
|
||
PAINTSTRUCT ps;
|
||
LPRECT prc = NULL;
|
||
HDC hdc = (HDC)wParam;
|
||
|
||
if (uMsg == WM_PAINT)
|
||
{
|
||
BeginPaint(hwnd, &ps);
|
||
prc = &ps.rcPaint;
|
||
hdc = ps.hdc;
|
||
}
|
||
|
||
if (_hTheme)
|
||
{
|
||
DrawThemeParentBackground(hwnd, hdc, prc);
|
||
}
|
||
else
|
||
{
|
||
RECT rc;
|
||
GetClientRect(hwnd, &rc);
|
||
FillRect(hdc, &rc, (HBRUSH)(COLOR_3DFACE + 1));
|
||
}
|
||
|
||
if (uMsg == WM_PAINT)
|
||
{
|
||
EndPaint(hwnd, &ps);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case WM_ERASEBKGND:
|
||
{
|
||
if (_hTheme)
|
||
{
|
||
return 1;
|
||
}
|
||
else
|
||
{
|
||
RECT rc;
|
||
GetClientRect(hwnd, &rc);
|
||
FillRect((HDC)wParam, &rc, (HBRUSH)(COLOR_3DFACE + 1));
|
||
}
|
||
}
|
||
|
||
// this keeps our window from comming to the front on button down
|
||
// instead, we activate the window on the up click
|
||
// we only want this for the tree and the view window
|
||
// (the view window does this itself)
|
||
case WM_MOUSEACTIVATE:
|
||
{
|
||
POINT pt;
|
||
RECT rc;
|
||
|
||
GetCursorPos(&pt);
|
||
GetWindowRect(_hwnd, &rc);
|
||
|
||
if ((LOWORD(lParam) == HTCLIENT) && PtInRect(&rc, pt))
|
||
return MA_NOACTIVATE;
|
||
else
|
||
goto DoDefault;
|
||
}
|
||
|
||
case WM_SETFOCUS:
|
||
_OnSetFocus();
|
||
break;
|
||
|
||
case WM_VSCROLL:
|
||
return _HandleScroll(FALSE, LOWORD(wParam), HIWORD(wParam));
|
||
|
||
case WM_HSCROLL:
|
||
return _HandleScroll(TRUE, LOWORD(wParam), HIWORD(wParam));
|
||
|
||
case WM_NOTIFY:
|
||
return _HandleNotify((LPNMHDR)lParam);
|
||
|
||
case WM_NCHITTEST:
|
||
lres = DefWindowProc(hwnd, uMsg, wParam, lParam);
|
||
if (lres == HTVSCROLL || lres == HTHSCROLL)
|
||
return lres;
|
||
else
|
||
return HTTRANSPARENT;
|
||
|
||
case WM_TIMER:
|
||
switch (wParam)
|
||
{
|
||
case IDT_RECHECKRUDEAPP1:
|
||
case IDT_RECHECKRUDEAPP2:
|
||
case IDT_RECHECKRUDEAPP3:
|
||
case IDT_RECHECKRUDEAPP4:
|
||
case IDT_RECHECKRUDEAPP5:
|
||
{
|
||
HWND hwnd = _FindRudeApp(NULL);
|
||
_ptray->HandleFullScreenApp(hwnd);
|
||
if (hwnd)
|
||
{
|
||
DWORD dwStyleEx = GetWindowLongPtr(hwnd, GWL_EXSTYLE);
|
||
if (!(dwStyleEx & WS_EX_TOPMOST) && !_IsRudeWindowActive(hwnd))
|
||
{
|
||
SwitchToThisWindow(hwnd, TRUE);
|
||
}
|
||
}
|
||
|
||
KillTimer(_hwnd, wParam);
|
||
if (!hwnd && (wParam <= IDT_RECHECKRUDEAPP5))
|
||
{
|
||
SetTimer(_hwnd, wParam + 1, 1000, NULL);
|
||
}
|
||
}
|
||
break;
|
||
case IDT_ASYNCANIMATION:
|
||
_AsyncAnimateItems();
|
||
break;
|
||
case IDT_REDRAW:
|
||
_DoRedrawWhereNeeded();
|
||
KillTimer(hwnd, IDT_REDRAW);
|
||
break;
|
||
case IDT_SYSMENU:
|
||
KillTimer(_hwnd, IDT_SYSMENU);
|
||
_HandleSysMenuTimeout();
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case WM_COMMAND:
|
||
_HandleCommand(GET_WM_COMMAND_CMD(wParam, lParam), GET_WM_COMMAND_ID(wParam, lParam), GET_WM_COMMAND_HWND(wParam, lParam));
|
||
break;
|
||
|
||
case WM_THEMECHANGED:
|
||
_OpenTheme();
|
||
break;
|
||
|
||
case TBC_POSTEDRCLICK:
|
||
_FakeSystemMenu((HWND)wParam, (DWORD)lParam);
|
||
break;
|
||
|
||
case TBC_BUTTONHEIGHT:
|
||
return _GetCurButtonHeight();
|
||
|
||
case WM_CONTEXTMENU:
|
||
if (SHRestricted(REST_NOTRAYCONTEXTMENU))
|
||
{
|
||
break;
|
||
}
|
||
|
||
// if we didn't find an item to put the sys menu up for, then
|
||
// pass on the WM_CONTExTMENU message
|
||
if (!_ContextMenu((DWORD)lParam))
|
||
goto DoDefault;
|
||
break;
|
||
|
||
case TBC_SYSMENUCOUNT:
|
||
return _iSysMenuCount;
|
||
|
||
case TBC_CHANGENOTIFY:
|
||
_HandleChangeNotify(wParam, lParam);
|
||
break;
|
||
|
||
case TBC_VERIFYBUTTONHEIGHT:
|
||
_VerifyButtonHeight();
|
||
break;
|
||
|
||
case TBC_SETACTIVEALT:
|
||
_SetActiveAlt((HWND) lParam);
|
||
break;
|
||
|
||
case TBC_CANMINIMIZEALL:
|
||
return _CanMinimizeAll();
|
||
|
||
case TBC_MINIMIZEALL:
|
||
return _MinimizeAll((HWND) wParam, (BOOL) lParam);
|
||
break;
|
||
|
||
case TBC_WARNNODROP:
|
||
//
|
||
// tell the user they can't drop objects on the taskbar
|
||
//
|
||
ShellMessageBox(hinstCabinet, _hwnd,
|
||
MAKEINTRESOURCE(IDS_TASKDROP_ERROR), MAKEINTRESOURCE(IDS_TASKBAR),
|
||
MB_ICONHAND | MB_OK);
|
||
break;
|
||
|
||
case TBC_SETPREVFOCUS:
|
||
_hwndPrevFocus = (HWND)lParam;
|
||
break;
|
||
|
||
case TBC_FREEPOPUPMENUS:
|
||
DAD_ShowDragImage(FALSE);
|
||
_FreePopupMenu();
|
||
_SetCurSel(-1, TRUE);
|
||
DAD_ShowDragImage(TRUE);
|
||
break;
|
||
|
||
case TBC_MARKFULLSCREEN:
|
||
{
|
||
HWND hwndFS = (HWND)lParam;
|
||
if (IsWindow(hwndFS))
|
||
{
|
||
//
|
||
// look for the item they're talking about
|
||
//
|
||
PTASKITEM pti = _FindItemByHwnd(hwndFS);
|
||
if (pti == NULL)
|
||
{
|
||
//
|
||
// we didn't find it, so insert it now
|
||
//
|
||
pti = _GetItem(_InsertItem(hwndFS));
|
||
}
|
||
if (pti)
|
||
{
|
||
//
|
||
// mark it fullscreen/not fullscreen
|
||
//
|
||
pti->fMarkedFullscreen = BOOLIFY(wParam);
|
||
if (_IsRudeWindowActive(hwndFS))
|
||
{
|
||
//
|
||
// it's active, so tell the tray to hide/show
|
||
//
|
||
HWND hwndRude = pti->fMarkedFullscreen ? hwndFS : NULL;
|
||
_ptray->HandleFullScreenApp(hwndRude);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case TBC_TASKTAB:
|
||
{
|
||
_tb.SetFocus();
|
||
|
||
int iNewIndex = 0;
|
||
int iCurIndex = max(_tb.GetHotItem(), 0);
|
||
int iCount = _tb.GetButtonCount();
|
||
if (iCount >= 2)
|
||
{
|
||
iNewIndex = iCurIndex;
|
||
|
||
do
|
||
{
|
||
iNewIndex += (int)wParam;
|
||
if (iNewIndex >= iCount)
|
||
{
|
||
iNewIndex = 0;
|
||
}
|
||
if (iNewIndex < 0)
|
||
{
|
||
iNewIndex = iCount - 1;
|
||
}
|
||
} while (_IsHidden(iNewIndex));
|
||
}
|
||
|
||
_tb.SetHotItem(iNewIndex);
|
||
}
|
||
break;
|
||
|
||
case WM_COPYDATA:
|
||
{
|
||
COPYDATASTRUCT *pcd;
|
||
|
||
pcd = (PCOPYDATASTRUCT)lParam;
|
||
if (pcd && pcd->dwData == _uCDHardError)
|
||
{
|
||
HARDERRORDATA *phed = (HARDERRORDATA *)pcd->lpData;;
|
||
if (phed)
|
||
{
|
||
return _HandleHardError(phed, pcd->cbData);
|
||
}
|
||
return 0; // 0 = not handled
|
||
}
|
||
}
|
||
//
|
||
// If its not our hard error data, then just
|
||
// fall through to default processing
|
||
//
|
||
|
||
default:
|
||
DoDefault:
|
||
|
||
if (uMsg == WM_ShellHook)
|
||
return _HandleShellHook((int)wParam, lParam);
|
||
else
|
||
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
BOOL CTaskBand::_RegisterWindowClass()
|
||
{
|
||
WNDCLASSEX wc = {0};
|
||
wc.cbSize = sizeof(wc);
|
||
|
||
if (GetClassInfoEx(hinstCabinet, c_szTaskSwClass, &wc))
|
||
return TRUE;
|
||
|
||
wc.lpszClassName = c_szTaskSwClass;
|
||
wc.lpfnWndProc = s_WndProc;
|
||
wc.cbWndExtra = sizeof(LONG_PTR);
|
||
wc.hInstance = hinstCabinet;
|
||
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
||
wc.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
|
||
|
||
return RegisterClassEx(&wc);
|
||
}
|
||
|
||
int TimeSortCB(PTASKITEM p1, PTASKITEM p2, LPARAM lParam)
|
||
{
|
||
if (p1->dwTimeFirstOpened > p2->dwTimeFirstOpened)
|
||
return -1;
|
||
else
|
||
return 1;
|
||
}
|
||
|
||
int DestroyCB(PTASKITEM pti, LPVOID pData)
|
||
{
|
||
if (pti)
|
||
delete pti;
|
||
|
||
return 0;
|
||
}
|
||
|
||
void CTaskBand::_RefreshSettings()
|
||
{
|
||
BOOL fOldGlom = _fGlom;
|
||
int iOldGroupSize = _iGroupSize;
|
||
_LoadSettings();
|
||
|
||
if ((fOldGlom != _fGlom) || (iOldGroupSize != _iGroupSize))
|
||
{
|
||
CDPA<TASKITEM> dpa;
|
||
_BuildTaskList(&dpa);
|
||
|
||
if (dpa)
|
||
{
|
||
int i;
|
||
|
||
dpa.Sort(TimeSortCB, 0);
|
||
|
||
BOOL fRedraw = (BOOL)_tb.SendMessage(WM_SETREDRAW, FALSE, 0);
|
||
BOOL fAnimate = _fAnimate;
|
||
_fAnimate = FALSE;
|
||
|
||
for (i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
_DeleteTaskItem(i, TRUE);
|
||
}
|
||
|
||
for (i = dpa.GetPtrCount() - 1; i >= 0 ; i--)
|
||
{
|
||
PTASKITEM pti = dpa.FastGetPtr(i);
|
||
// NOTE: HWND_TOPMOST is used to indicate that the deleted button
|
||
// is being animated. This allows the button to stay around after
|
||
// its real hwnd becomes invalid.
|
||
// Don't re-insert a button that was deleting.
|
||
if (pti->hwnd != HWND_TOPMOST)
|
||
{
|
||
_InsertItem(pti->hwnd, pti, TRUE);
|
||
}
|
||
}
|
||
dpa.Destroy();
|
||
|
||
_tb.SendMessage(WM_SETREDRAW, fRedraw, 0);
|
||
_fAnimate = fAnimate;
|
||
}
|
||
|
||
_BandInfoChanged();
|
||
}
|
||
}
|
||
|
||
void CTaskBand::_LoadSettings()
|
||
{
|
||
if (SHRestricted(REST_NOTASKGROUPING) == 0)
|
||
{
|
||
_fGlom = SHRegGetBoolUSValue(REGSTR_EXPLORER_ADVANCED, TEXT("TaskbarGlomming"),
|
||
FALSE, TRUE);
|
||
if (_fGlom)
|
||
{
|
||
DWORD cbSize = sizeof(_fGlom);
|
||
DWORD dwDefault = GLOM_OLDEST;
|
||
SHRegGetUSValue(REGSTR_EXPLORER_ADVANCED, TEXT("TaskbarGroupSize"),
|
||
NULL, &_iGroupSize, &cbSize, FALSE, (LPBYTE)&dwDefault, sizeof(dwDefault));
|
||
|
||
}
|
||
}
|
||
else
|
||
{
|
||
_fGlom = FALSE;
|
||
}
|
||
}
|
||
|
||
|
||
BOOL CTaskBand::_ShouldMinimize(HWND hwnd)
|
||
{
|
||
BOOL fRet = FALSE;
|
||
|
||
DWORD dwStyle = GetWindowLong(hwnd, GWL_STYLE);
|
||
if (IsWindowVisible(hwnd) &&
|
||
!IsMinimized(hwnd) && IsWindowEnabled(hwnd))
|
||
{
|
||
if (dwStyle & WS_MINIMIZEBOX)
|
||
{
|
||
if ((dwStyle & (WS_CAPTION | WS_SYSMENU)) == (WS_CAPTION | WS_SYSMENU))
|
||
{
|
||
HMENU hmenu = GetSystemMenu(hwnd, FALSE);
|
||
if (hmenu)
|
||
{
|
||
// is there a sys menu and is the sc_min/maximize part enabled?
|
||
fRet = !(GetMenuState(hmenu, SC_MINIMIZE, MF_BYCOMMAND) & MF_DISABLED);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
fRet = TRUE;
|
||
}
|
||
}
|
||
}
|
||
|
||
return fRet;
|
||
}
|
||
|
||
BOOL CTaskBand::_CanMinimizeAll()
|
||
{
|
||
int i;
|
||
|
||
for ( i = _tb.GetButtonCount() - 1; i >= 0; i--)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
if (_ShouldMinimize(pti->hwnd) || (pti->dwFlags & TIF_EVERACTIVEALT))
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
typedef struct MINALLDATAtag
|
||
{
|
||
CDPA<TASKITEM> dpa;
|
||
CTray* pTray;
|
||
HWND hwndDesktop;
|
||
HWND hwndTray;
|
||
BOOL fPostRaiseDesktop;
|
||
} MINALLDATA;
|
||
|
||
DWORD WINAPI CTaskBand::MinimizeAllThreadProc(void* pv)
|
||
{
|
||
LONG iAnimate;
|
||
ANIMATIONINFO ami;
|
||
MINALLDATA* pminData = (MINALLDATA*)pv;
|
||
|
||
if (pminData)
|
||
{
|
||
// turn off animiations during this
|
||
ami.cbSize = sizeof(ami);
|
||
SystemParametersInfo(SPI_GETANIMATION, sizeof(ami), &ami, FALSE);
|
||
iAnimate = ami.iMinAnimate;
|
||
ami.iMinAnimate = FALSE;
|
||
SystemParametersInfo(SPI_SETANIMATION, sizeof(ami), &ami, FALSE);
|
||
|
||
//
|
||
//EnumWindows(MinimizeEnumProc, 0);
|
||
// go through the tab control and minimize them.
|
||
// don't do enumwindows because we only want to minimize windows
|
||
// that are restorable via the tray
|
||
|
||
for (int i = pminData->dpa.GetPtrCount() - 1; i >= 0 ; i--)
|
||
{
|
||
PTASKITEM pti = pminData->dpa.FastGetPtr(i);
|
||
if (pti)
|
||
{
|
||
// we do the whole minimize on its own thread, so we don't do the showwindow
|
||
// async. this allows animation to be off for the full minimize.
|
||
if (_ShouldMinimize(pti->hwnd))
|
||
{
|
||
ShowWindow(pti->hwnd, SW_SHOWMINNOACTIVE);
|
||
}
|
||
else if (pti->dwFlags & TIF_EVERACTIVEALT)
|
||
{
|
||
SHAllowSetForegroundWindow(pti->hwnd);
|
||
SendMessage(pti->hwnd, WM_SYSCOMMAND, SC_MINIMIZE, -1);
|
||
}
|
||
}
|
||
}
|
||
|
||
pminData->pTray->CheckWindowPositions();
|
||
pminData->dpa.DestroyCallback(DestroyCB, NULL);
|
||
|
||
if (pminData->fPostRaiseDesktop)
|
||
{
|
||
PostMessage(pminData->hwndDesktop, DTM_RAISE, (WPARAM)pminData->hwndTray, DTRF_RAISE);
|
||
}
|
||
|
||
delete pminData;
|
||
|
||
// restore animations state
|
||
ami.iMinAnimate = iAnimate;
|
||
SystemParametersInfo(SPI_SETANIMATION, sizeof(ami), &ami, FALSE);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
void CTaskBand::_BuildTaskList(CDPA<TASKITEM>* pdpa )
|
||
{
|
||
if (pdpa && _tb)
|
||
{
|
||
if (pdpa->Create(5))
|
||
{
|
||
for (int i = _tb.GetButtonCount() - 1; (i >= 0) && ((HDPA)pdpa); i--)
|
||
{
|
||
PTASKITEM pti = _GetItem(i);
|
||
if (pti->hwnd)
|
||
{
|
||
PTASKITEM ptiNew = new TASKITEM(pti);
|
||
if (ptiNew)
|
||
{
|
||
pdpa->AppendPtr(ptiNew);
|
||
}
|
||
else
|
||
{
|
||
pdpa->DestroyCallback(DestroyCB, NULL);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
pdpa->Destroy();
|
||
}
|
||
}
|
||
}
|
||
|
||
BOOL CTaskBand::_MinimizeAll(HWND hwndTray, BOOL fPostRaiseDesktop)
|
||
{
|
||
BOOL fFreeMem = TRUE;
|
||
// might want to move this into MinimizeAllThreadProc (to match
|
||
// _ptray->CheckWindowPositions). but what if CreateThread fails?
|
||
|
||
_ptray->SaveWindowPositions(IDS_MINIMIZEALL);
|
||
|
||
MINALLDATA* pminData = new MINALLDATA;
|
||
if (pminData)
|
||
{
|
||
_BuildTaskList(&(pminData->dpa));
|
||
if (pminData->dpa)
|
||
{
|
||
pminData->pTray = _ptray;
|
||
pminData->fPostRaiseDesktop = fPostRaiseDesktop;
|
||
pminData->hwndDesktop = v_hwndDesktop;
|
||
pminData->hwndTray = hwndTray;
|
||
// MinimizeAllThreadProc is responsible for freeing this data
|
||
fFreeMem = !SHCreateThread(MinimizeAllThreadProc, (void*)pminData, CTF_INSIST, NULL);
|
||
}
|
||
}
|
||
|
||
if (fFreeMem)
|
||
{
|
||
if (pminData)
|
||
{
|
||
pminData->dpa.DestroyCallback(DestroyCB, NULL);
|
||
delete pminData;
|
||
}
|
||
}
|
||
|
||
return !fFreeMem;
|
||
}
|
||
|
||
int CTaskBand::_HitTest(POINTL ptl)
|
||
{
|
||
POINT pt = {ptl.x,ptl.y};
|
||
_tb.ScreenToClient(&pt);
|
||
|
||
int iIndex = _tb.HitTest(&pt);
|
||
|
||
if ((iIndex >= _tb.GetButtonCount()) || (iIndex < 0))
|
||
iIndex = -1;
|
||
|
||
return iIndex;
|
||
}
|
||
|
||
HRESULT CTaskBand_CreateInstance(IUnknown* punkOuter, IUnknown** ppunk)
|
||
{
|
||
HRESULT hr = E_OUTOFMEMORY;
|
||
|
||
if (punkOuter)
|
||
return CLASS_E_NOAGGREGATION;
|
||
|
||
CTaskBand* ptb = new CTaskBand();
|
||
if (ptb)
|
||
{
|
||
hr = ptb->Init(&c_tray);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
*ppunk = static_cast<IDeskBand*>(ptb);
|
||
hr = S_OK;
|
||
}
|
||
}
|
||
|
||
return hr;
|
||
}
|