1122 lines
29 KiB
C++
1122 lines
29 KiB
C++
#include "cabinet.h"
|
|
#define CPP_FUNCTIONS
|
|
#include <crtfree.h>
|
|
#include "rcids.h"
|
|
#include <shguidp.h>
|
|
#include "bandsite.h"
|
|
#include "shellp.h"
|
|
#include "shdguid.h"
|
|
#include "taskband.h"
|
|
#include "taskbar.h"
|
|
#include <regstr.h>
|
|
|
|
#define DM_FOCUS 0 // focus
|
|
#define DM_FOCUS2 0 // focus (verbose)
|
|
#define DM_PERSIST 0 // IPS::Load, ::Save, etc.
|
|
#define DM_SHUTDOWN DM_TRACE // shutdown
|
|
|
|
IUnknown* Tasks_CreateInstance();
|
|
|
|
|
|
extern IStream *GetDesktopViewStream(DWORD grfMode, LPCTSTR pszName);
|
|
|
|
HRESULT PersistStreamLoad(IStream *pstm, IUnknown *punk);
|
|
HRESULT PersistStreamSave(IStream *pstm, BOOL fClearDirty, IUnknown *punk);
|
|
|
|
const TCHAR c_szTaskbar[] = TEXT("Taskbar");
|
|
|
|
// {69B3F106-0F04-11d3-AE2E-00C04F8EEA99}
|
|
static const GUID CLSID_TrayBandSite =
|
|
{ 0x69b3f106, 0xf04, 0x11d3, { 0xae, 0x2e, 0x0, 0xc0, 0x4f, 0x8e, 0xea, 0x99
|
|
} };
|
|
|
|
//*** CTrayBandSite {
|
|
|
|
class CTrayBandSite: public IBandSiteHelper,
|
|
public IBandSite
|
|
{
|
|
public:
|
|
// *** IUnknown ***
|
|
virtual STDMETHODIMP QueryInterface(REFIID riid, LPVOID * ppvObj);
|
|
virtual STDMETHODIMP_(ULONG) AddRef(void) ;
|
|
virtual STDMETHODIMP_(ULONG) Release(void);
|
|
|
|
// *** IBandSiteHelper ***
|
|
virtual STDMETHODIMP LoadFromStreamBS(IStream *pstm, REFIID riid, LPVOID *ppv);
|
|
virtual STDMETHODIMP SaveToStreamBS(IUnknown *punk, IStream *pstm);
|
|
|
|
// *** IBandSite methods ***
|
|
STDMETHOD(AddBand) (THIS_ IUnknown* punk);
|
|
STDMETHOD(EnumBands) (THIS_ UINT uBand, DWORD* pdwBandID);
|
|
STDMETHOD(QueryBand) (THIS_ DWORD dwBandID, IDeskBand** ppstb, DWORD* pdwState, LPWSTR pszName, int cchName) ;
|
|
STDMETHOD(SetBandState) (THIS_ DWORD dwBandID, DWORD dwMask, DWORD dwState) ;
|
|
STDMETHOD(RemoveBand) (THIS_ DWORD dwBandID);
|
|
STDMETHOD(GetBandObject) (THIS_ DWORD dwBandID, REFIID riid, LPVOID* ppvObj);
|
|
STDMETHOD(SetBandSiteInfo) (THIS_ const BANDSITEINFO * pbsinfo);
|
|
STDMETHOD(GetBandSiteInfo) (THIS_ BANDSITEINFO * pbsinfo);
|
|
|
|
IContextMenu* GetContextMenu();
|
|
void SetInner(IUnknown* punk);
|
|
void SetLoaded(BOOL fLoaded) {_fLoaded = fLoaded;}
|
|
BOOL HandleMessage(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *plres);
|
|
|
|
protected:
|
|
CTrayBandSite();
|
|
virtual ~CTrayBandSite();
|
|
|
|
BOOL _CreateBandSiteMenu(IUnknown* punk);
|
|
BOOL _IsTaskBand(IUnknown* punk);
|
|
BOOL _IsTaskBandId(DWORD idBand);
|
|
void _BroadcastExec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut);
|
|
friend IUnknown* Tray_CreateView();
|
|
friend HRESULT BandSite_AddRequiredBands(CTrayBandSite* pbs);
|
|
friend HRESULT BandSite_CheckBands(CTrayBandSite* pbs);
|
|
friend void BandSite_HandleDelayBootStuff(IUnknown* punk);
|
|
|
|
UINT _cRef;
|
|
IUnknown *_punkInner;
|
|
IBandSite *_pbsInner;
|
|
IUnknown* _punkTasks;
|
|
|
|
// bandsite context menu
|
|
IContextMenu* _pcm;
|
|
HWND _hwnd;
|
|
BOOL _fLoaded;
|
|
BOOL _fDelayBootStuffHandled;
|
|
};
|
|
|
|
CTrayBandSite* IUnknownToCTrayBandSite(IUnknown* punk)
|
|
{
|
|
CTrayBandSite* ptbs;
|
|
|
|
punk->QueryInterface(CLSID_TrayBandSite, (LPVOID*)&ptbs);
|
|
ASSERT(ptbs);
|
|
punk->Release();
|
|
|
|
return ptbs;
|
|
}
|
|
|
|
CTrayBandSite::CTrayBandSite() : _cRef(1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CTrayBandSite::~CTrayBandSite()
|
|
{
|
|
if (_punkTasks)
|
|
_punkTasks->Release();
|
|
|
|
if (_pcm)
|
|
_pcm->Release();
|
|
|
|
return;
|
|
}
|
|
|
|
ULONG CTrayBandSite::AddRef()
|
|
{
|
|
_cRef++;
|
|
return _cRef;
|
|
}
|
|
|
|
ULONG CTrayBandSite::Release()
|
|
{
|
|
ASSERT(_cRef > 0);
|
|
_cRef--;
|
|
|
|
if (_cRef > 0)
|
|
return _cRef;
|
|
|
|
_cRef = 1000; // guard against recursion
|
|
|
|
if (_pbsInner) {
|
|
AddRef();
|
|
_pbsInner->Release();
|
|
}
|
|
|
|
// this must come last
|
|
if (_punkInner)
|
|
_punkInner->Release(); // paired w/ CCI aggregation
|
|
|
|
ASSERT(_cRef == 1000);
|
|
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
HRESULT CTrayBandSite::QueryInterface(REFIID riid, LPVOID * ppvObj)
|
|
{
|
|
if (IsEqualIID(riid, IID_IUnknown) ||
|
|
IsEqualIID(riid, IID_IBandSiteHelper))
|
|
{
|
|
// BUGBUG make IBandSite be the preferred iface
|
|
*ppvObj = SAFECAST(this, IBandSiteHelper*);
|
|
}
|
|
else if (IsEqualIID(riid, IID_IBandSite))
|
|
{
|
|
*ppvObj = SAFECAST(this, IBandSite*);
|
|
}
|
|
else if (IsEqualIID(riid, CLSID_TrayBandSite))
|
|
{
|
|
*ppvObj = this;
|
|
}
|
|
else if (_punkInner)
|
|
{
|
|
return _punkInner->QueryInterface(riid, ppvObj);
|
|
}
|
|
else
|
|
{
|
|
*ppvObj = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
AddRef();
|
|
return S_OK;
|
|
}
|
|
|
|
//*** CTrayBandSite::IBandSite::* {
|
|
|
|
HRESULT CTrayBandSite::AddBand(IUnknown* punk)
|
|
{
|
|
if (!_fDelayBootStuffHandled)
|
|
{
|
|
|
|
// Tell the band to go into "delay init" mode. When the tray
|
|
// timer goes off we'll tell the band to finish up. (See
|
|
// BandSite_HandleDelayBootStuff).
|
|
|
|
IUnknown_Exec(punk, &CGID_DeskBand, DBID_DELAYINIT, 0, NULL, NULL);
|
|
}
|
|
|
|
return _pbsInner->AddBand(punk);
|
|
}
|
|
|
|
HRESULT CTrayBandSite::EnumBands(UINT uBand, DWORD* pdwBandID)
|
|
{
|
|
return _pbsInner->EnumBands(uBand, pdwBandID);
|
|
}
|
|
|
|
|
|
HRESULT _IsSameObject(IUnknown* punk1, IUnknown* punk2)
|
|
{
|
|
if (punk1) {
|
|
// this must never fail
|
|
punk1->QueryInterface(IID_IUnknown, (LPVOID*)&punk1);
|
|
ASSERT(punk1);
|
|
punk1->Release();
|
|
|
|
}
|
|
|
|
if (punk2) {
|
|
// this must never fail
|
|
punk2->QueryInterface(IID_IUnknown, (LPVOID*)&punk2);
|
|
ASSERT(punk2);
|
|
punk2->Release();
|
|
}
|
|
|
|
return (punk1 == punk2) ? S_OK : S_FALSE;
|
|
}
|
|
|
|
BOOL CTrayBandSite::_IsTaskBand(IUnknown* punk)
|
|
{
|
|
return _IsSameObject(punk, _punkTasks) == S_OK;
|
|
}
|
|
|
|
HRESULT CTrayBandSite::QueryBand( DWORD dwBandID, IDeskBand** ppstb, DWORD* pdwState, LPWSTR pszName, int cchName)
|
|
{
|
|
IDeskBand *pstb = NULL;
|
|
if (!ppstb)
|
|
ppstb = &pstb;
|
|
|
|
HRESULT hres = _pbsInner->QueryBand( dwBandID, ppstb, pdwState, pszName, cchName);
|
|
|
|
if (SUCCEEDED(hres) && pdwState) {
|
|
// if this is the taskbar band, return undeleteable
|
|
if (_IsTaskBand(*ppstb)) {
|
|
*pdwState |= BSSF_UNDELETEABLE;
|
|
}
|
|
}
|
|
|
|
if ((ppstb == &pstb) && (NULL != pstb))
|
|
pstb->Release(); // We have a ref on the object but the caller can't free it.
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
HRESULT CTrayBandSite::SetBandState( DWORD dwBandID, DWORD dwMask, DWORD dwState)
|
|
{
|
|
HRESULT hres = _pbsInner->SetBandState( dwBandID, dwMask, dwState);
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
HRESULT CTrayBandSite::RemoveBand( DWORD dwBandID)
|
|
{
|
|
return _pbsInner->RemoveBand( dwBandID);
|
|
}
|
|
|
|
|
|
HRESULT CTrayBandSite::GetBandObject(DWORD dwBandID, REFIID riid, LPVOID* ppvObj)
|
|
{
|
|
return _pbsInner->GetBandObject(dwBandID, riid, ppvObj);
|
|
}
|
|
|
|
HRESULT CTrayBandSite::SetBandSiteInfo (const BANDSITEINFO * pbsinfo)
|
|
{
|
|
return _pbsInner->SetBandSiteInfo(pbsinfo);
|
|
}
|
|
|
|
HRESULT CTrayBandSite::GetBandSiteInfo (BANDSITEINFO * pbsinfo)
|
|
{
|
|
return _pbsInner->GetBandSiteInfo(pbsinfo);
|
|
}
|
|
|
|
// }
|
|
|
|
//*** CTrayBandSite::IBandSiteHelper::* {
|
|
|
|
//*** LoadFromStreamBS -- special OLFS
|
|
// DESCRIPTION
|
|
// like OLFS, but special handling for TrayBand (which can't be CCI'ed).
|
|
// also, takes an IUnknown not an IPersistStream.
|
|
|
|
HRESULT CTrayBandSite::LoadFromStreamBS(IStream *pstm, REFIID riid, LPVOID *ppv)
|
|
{
|
|
static const LARGE_INTEGER c_li0 = { 0, 0 };
|
|
HRESULT hres;
|
|
ULONG cbRead;
|
|
ULARGE_INTEGER liCur;
|
|
CLSID clsid;
|
|
|
|
// save current position
|
|
hres = pstm->Seek(c_li0, STREAM_SEEK_CUR, &liCur);
|
|
if (FAILED(hres))
|
|
return hres;
|
|
|
|
hres = pstm->Read(&clsid, SIZEOF(clsid), &cbRead);
|
|
if (FAILED(hres))
|
|
return hres;
|
|
if (cbRead != SIZEOF(clsid))
|
|
return E_FAIL;
|
|
|
|
if (IsEqualGUID(clsid, CLSID_TaskBand)) {
|
|
// special case
|
|
|
|
DebugMsg(DM_PERSIST, TEXT("ctbs.bsolfs: intercept!"));
|
|
|
|
// CoCreateInstance (sort of...)
|
|
_punkTasks = Tasks_CreateInstance();
|
|
ASSERT(_punkTasks != NULL);
|
|
ASSERT(_IsTaskBand(_punkTasks));
|
|
hres = _punkTasks->QueryInterface(riid, ppv);
|
|
if (FAILED(hres))
|
|
goto Lerr1;
|
|
|
|
// Load
|
|
hres = PersistStreamLoad(pstm, _punkTasks);
|
|
if (FAILED(hres))
|
|
goto Lerr1;
|
|
|
|
// that's all!
|
|
#ifdef DEBUG
|
|
if (hres != S_OK)
|
|
DebugMsg(DM_WARNING, TEXT("ctbs.bsolfs: hres=%x (!=S_OK)"), hres);
|
|
#endif
|
|
// tell BandSite we handled it
|
|
hres = S_OK;
|
|
|
|
Lerr1:
|
|
// dtor does _punkTasks->Release();
|
|
//Lerr0:
|
|
return hres;
|
|
}
|
|
else {
|
|
// not special case
|
|
|
|
// restore position
|
|
LARGE_INTEGER liTmp = { 0, 0 };
|
|
|
|
liTmp.LowPart = liCur.LowPart;
|
|
ASSERT(liCur.HighPart == 0);
|
|
hres = pstm->Seek(liTmp, STREAM_SEEK_SET, NULL);
|
|
if (FAILED(hres))
|
|
return hres;
|
|
|
|
// call the standard guy
|
|
return OleLoadFromStream(pstm, riid, ppv);
|
|
}
|
|
}
|
|
|
|
HRESULT CTrayBandSite::SaveToStreamBS(IUnknown *punk, IStream *pstm)
|
|
{
|
|
HRESULT hres;
|
|
|
|
if (_IsTaskBand(punk)) {
|
|
ULONG cbRead;
|
|
|
|
hres = pstm->Write(&CLSID_TaskBand, SIZEOF(CLSID_TaskBand), &cbRead);
|
|
if (SUCCEEDED(hres) && cbRead != SIZEOF(CLSID_TaskBand))
|
|
hres = E_FAIL;
|
|
return hres;
|
|
}
|
|
else {
|
|
IPersistStream *ppstm;
|
|
|
|
hres = punk->QueryInterface(IID_IPersistStream, (LPVOID*)&ppstm);
|
|
if (SUCCEEDED(hres)) {
|
|
hres = OleSaveToStream(ppstm, pstm);
|
|
ppstm->Release();
|
|
}
|
|
return hres;
|
|
}
|
|
}
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
|
|
HRESULT BandSite_AddRequiredBands(CTrayBandSite* pbs)
|
|
{
|
|
IUnknown *punk = Tasks_CreateInstance();
|
|
|
|
if (g_ts.fCoolTaskbar) {
|
|
|
|
pbs->AddBand(punk);
|
|
pbs->_punkTasks = punk;
|
|
|
|
#ifdef DEBUG
|
|
static int fInit = FALSE;
|
|
|
|
if (fInit) {
|
|
HKEY hkey;
|
|
TCHAR szID[160]; // enough for ID
|
|
if (RegCreateKey(g_hkeyExplorer, TEXT("Taskbar\\Bands"), &hkey) == ERROR_SUCCESS) {
|
|
|
|
// add all the reg supplied bands
|
|
for (int iKey = 0;
|
|
RegEnumKey(hkey, iKey, szID, SIZEOF(szID))==ERROR_SUCCESS;
|
|
iKey++)
|
|
{
|
|
CLSID clsid;
|
|
if (SUCCEEDED(SHCLSIDFromString(szID, &clsid))) {
|
|
|
|
if (SUCCEEDED(CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, IID_IUnknown, (LPVOID*)&punk))) {
|
|
pbs->AddBand(punk);
|
|
punk->Release();
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hkey);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
} else {
|
|
IObjectWithSite *pitb;
|
|
CTaskBar *pow = new CTaskBar();
|
|
if (pow) {
|
|
punk->QueryInterface(IID_IObjectWithSite, (LPVOID*)&pitb);
|
|
if (pitb) {
|
|
pitb->SetSite(SAFECAST(pow, IOleWindow*));
|
|
}
|
|
pow->Release();
|
|
|
|
}
|
|
punk->Release();
|
|
g_ts.hwndRebar = g_ts.hwndView;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
BOOL CTrayBandSite::_IsTaskBandId(DWORD idBand)
|
|
{
|
|
IDeskBand *pstb;
|
|
BOOL fRet = FALSE;
|
|
|
|
if (SUCCEEDED(QueryBand(idBand, &pstb, NULL, NULL, 0))) {
|
|
if (_IsTaskBand(pstb)) {
|
|
fRet = TRUE;
|
|
}
|
|
pstb->Release();
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
//*** BandSite_CheckBands -- see if minimal set of bands are there
|
|
// ENTRY/EXIT
|
|
// hres returns S_OK if bands are present.
|
|
// DESCRIPTION
|
|
// 'minimal' means TaskBand.
|
|
HRESULT BandSite_CheckBands(CTrayBandSite* pbs)
|
|
{
|
|
int cBand, iBand;
|
|
DWORD idBand;
|
|
|
|
if (!g_ts.fCoolTaskbar) {
|
|
// Shell restriction ClassicShell is enabled so no bands.
|
|
return S_FALSE;
|
|
}
|
|
|
|
cBand = pbs->EnumBands((UINT)-1, NULL);
|
|
for (iBand = 0; iBand < cBand; ++iBand) {
|
|
if (EVAL(SUCCEEDED(pbs->EnumBands(iBand, &idBand)))) {
|
|
if (pbs->_IsTaskBandId(idBand))
|
|
return S_OK;
|
|
}
|
|
}
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
void BandSite_Initialize(IBandSite* pbs)
|
|
{
|
|
HWND hwnd = v_hwndTray;
|
|
// should we use coolbar?
|
|
|
|
if (g_ts.fCoolTaskbar) {
|
|
IDeskBarClient* pdbc;
|
|
CTaskBar *pow = new CTaskBar();
|
|
|
|
if (pow) {
|
|
pbs->QueryInterface(IID_IDeskBarClient, (LPVOID*)&pdbc);
|
|
if (pdbc) {
|
|
// we need to set a dummy tray IOleWindow
|
|
pdbc->SetDeskBarSite(SAFECAST(pow, IOleWindow*));
|
|
|
|
pdbc->GetWindow(&hwnd);
|
|
|
|
pdbc->Release();
|
|
}
|
|
pow->Release();
|
|
}
|
|
}
|
|
|
|
g_ts.hwndRebar = hwnd;
|
|
|
|
}
|
|
|
|
IContextMenu* CTrayBandSite::GetContextMenu()
|
|
{
|
|
if (!_pcm) {
|
|
CoCreateInstance(CLSID_BandSiteMenu, NULL,CLSCTX_INPROC_SERVER, IID_IContextMenu, (LPVOID*)&_pcm);
|
|
if (_pcm) {
|
|
IShellService* pss;
|
|
|
|
_pcm->QueryInterface(IID_IShellService, (LPVOID*)&pss);
|
|
if (pss) {
|
|
pss->SetOwner((IBandSite*)this);
|
|
pss->Release();
|
|
}
|
|
}
|
|
}
|
|
if (_pcm)
|
|
_pcm->AddRef();
|
|
|
|
return _pcm;
|
|
}
|
|
|
|
void BandSite_AddMenus(IUnknown* punk, HMENU hmenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast)
|
|
{
|
|
CTrayBandSite* ptbs = IUnknownToCTrayBandSite(punk);
|
|
|
|
IContextMenu* pcm = ptbs->GetContextMenu();
|
|
|
|
if (!pcm)
|
|
return;
|
|
|
|
pcm->QueryContextMenu(hmenu, indexMenu, idCmdFirst, idCmdLast, 0);
|
|
pcm->Release();
|
|
|
|
}
|
|
|
|
void BandSite_HandleMenuCommand(IUnknown* punk, UINT idCmd)
|
|
{
|
|
CTrayBandSite* ptbs = IUnknownToCTrayBandSite(punk);
|
|
|
|
IContextMenu* pcm = ptbs->GetContextMenu();
|
|
|
|
if (!pcm)
|
|
return;
|
|
|
|
CMINVOKECOMMANDINFOEX ici = {
|
|
SIZEOF(CMINVOKECOMMANDINFOEX),
|
|
0L,
|
|
NULL,
|
|
(LPSTR)MAKEINTRESOURCE(idCmd),
|
|
NULL, NULL,
|
|
SW_NORMAL,
|
|
};
|
|
|
|
pcm->InvokeCommand((LPCMINVOKECOMMANDINFO)&ici);
|
|
pcm->Release();
|
|
}
|
|
|
|
void CTrayBandSite::SetInner(IUnknown* punk)
|
|
{
|
|
_punkInner = punk;
|
|
|
|
_punkInner->QueryInterface(IID_IBandSite, (LPVOID*)&_pbsInner);
|
|
Release();
|
|
|
|
ASSERT(_pbsInner);
|
|
|
|
}
|
|
|
|
STDAPI_(IUnknown*) Tray_CreateView()
|
|
{
|
|
HWND hwndParent = v_hwndTray;
|
|
IUnknown *punk;
|
|
HRESULT hres;
|
|
|
|
if (SHRestricted(REST_CLASSICSHELL))
|
|
g_ts.fCoolTaskbar = FALSE;
|
|
else
|
|
{
|
|
g_ts.fCoolTaskbar = TRUE;
|
|
}
|
|
|
|
// aggregate a TrayBandSite (from a RebarBandSite)
|
|
CTrayBandSite *ptbs = new CTrayBandSite;
|
|
ASSERT(ptbs != NULL);
|
|
hres = CoCreateInstance(CLSID_RebarBandSite, (IBandSite*)ptbs, CLSCTX_INPROC_SERVER, IID_IUnknown, (LPVOID*)&punk);
|
|
if (!punk)
|
|
{
|
|
// where is my tray?!?
|
|
TraceMsg(TF_ERROR, "(Tray) Could not CoCreate CLSID_RebarBandSite. Where is my tray?!?");
|
|
return NULL;
|
|
}
|
|
|
|
ptbs->SetInner(punk); // paired w/ Release in outer (TBS::Release)
|
|
|
|
|
|
BandSite_Initialize(ptbs);
|
|
|
|
return (IBandSite*)ptbs;
|
|
}
|
|
|
|
STDAPI Tray_SaveView(IUnknown *pbs)
|
|
{
|
|
HRESULT hres;
|
|
IStream *pstm;
|
|
|
|
if (g_ts.fCoolTaskbar) {
|
|
hres = E_FAIL;
|
|
|
|
pstm = GetDesktopViewStream(STGM_WRITE, c_szTaskbar);
|
|
if (pstm) {
|
|
hres = PersistStreamSave(pstm, TRUE, pbs);
|
|
pstm->Release();
|
|
}
|
|
TraceMsg(DM_SHUTDOWN, "t_sv: hr=%x", hres);
|
|
}
|
|
else {
|
|
// Shell restriction for no cool task bar (Win95 ClassicShell)
|
|
TraceMsg(DM_SHUTDOWN, "t_sv: !fCoolTaskbar");
|
|
hres = S_OK;
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
BOOL CTrayBandSite::HandleMessage(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *plres)
|
|
{
|
|
if (!_hwnd) {
|
|
// BUGBUG should use IUnknown_GetWindow
|
|
IOleWindow *pow;
|
|
QueryInterface(IID_IOleWindow, (LPVOID*)&pow);
|
|
if (pow) {
|
|
pow->GetWindow(&_hwnd);
|
|
pow->Release();
|
|
}
|
|
}
|
|
|
|
switch (uMsg) {
|
|
|
|
case WM_NOTIFY:
|
|
switch (((LPNMHDR)lParam)->code) {
|
|
case NM_NCHITTEST:
|
|
{
|
|
NMMOUSE *pnm = (LPNMMOUSE)lParam;
|
|
if (_hwnd == pnm->hdr.hwndFrom) {
|
|
if (pnm->dwHitInfo == RBHT_CLIENT || pnm->dwItemSpec == -1)
|
|
if (plres)
|
|
*plres = HTTRANSPARENT;
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case RBN_CHILDSIZE :
|
|
{
|
|
// We want the running task list to always line up with the Start button.
|
|
// The deal is, the Start button is exactly even with the top of the 1st
|
|
// rebar band (so we want zero additional space on the first row). But,
|
|
// on any row but the top row, we want to line up with the gripper, not
|
|
// the top of the band (gripper is 2 pixels (g_cyEdge?) below the top).
|
|
// Ideally, the rebar would include a g_cyEdge border between each row,
|
|
// not just its top edge and the first row.
|
|
|
|
NMREBARCHILDSIZE *pnm = (NMREBARCHILDSIZE*)lParam;
|
|
|
|
if (!_IsTaskBandId(pnm->wID))
|
|
break;
|
|
|
|
int cy = pnm->rcChild.top - pnm->rcBand.top;
|
|
|
|
// But that pushes us below the screen... and we can't simply increase band size...
|
|
#if 0
|
|
if (pnm->rcBand.top >= g_cyEdge) // If this band is not the top band
|
|
cy -= g_cyEdge; // move us 1 edgewidth down from the top
|
|
#endif
|
|
// Make child always start at top of rebar
|
|
pnm->rcChild.bottom -= cy;
|
|
pnm->rcChild.top -= cy;
|
|
|
|
if (_fLoaded)
|
|
Tray_AsyncSaveSettings();
|
|
break;
|
|
}
|
|
|
|
case RBN_MINMAX:
|
|
*plres = SHRestricted(REST_NOMOVINGBAND);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
IWinEventHandler *pweh;
|
|
QueryInterface(IID_IWinEventHandler, (LPVOID*)&pweh);
|
|
ASSERT(pweh); // Don't want aggregation to fail.
|
|
if (pweh) {
|
|
HRESULT hres = pweh->OnWinEvent(hwnd, uMsg, wParam, lParam, plres);
|
|
pweh->Release();
|
|
|
|
return SUCCEEDED(hres);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void CTrayBandSite::_BroadcastExec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
|
|
{
|
|
// Broadcast an Exec to all child bands
|
|
|
|
DWORD dwBandID;
|
|
UINT uBand = 0;
|
|
while (SUCCEEDED(EnumBands(uBand, &dwBandID)))
|
|
{
|
|
IOleCommandTarget* pct;
|
|
if (SUCCEEDED(GetBandObject(dwBandID, IID_IOleCommandTarget, (void**)&pct)))
|
|
{
|
|
pct->Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
|
|
pct->Release();
|
|
}
|
|
uBand++;
|
|
}
|
|
}
|
|
|
|
void BandSite_HandleDelayBootStuff(IUnknown* punk)
|
|
{
|
|
if (punk)
|
|
{
|
|
CTrayBandSite* pbs = IUnknownToCTrayBandSite(punk);
|
|
pbs->_fDelayBootStuffHandled = TRUE;
|
|
pbs->_BroadcastExec(&CGID_DeskBand, DBID_FINISHINIT, 0, NULL, NULL);
|
|
}
|
|
}
|
|
|
|
// returns true or false whether it handled it
|
|
BOOL BandSite_HandleMessage(IUnknown *punk, HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *plres)
|
|
{
|
|
if (punk)
|
|
{
|
|
CTrayBandSite* pbs = IUnknownToCTrayBandSite(punk);
|
|
return pbs->HandleMessage(hwnd, uMsg, wParam, lParam, plres);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void BandSite_SetMode(IUnknown *punk, DWORD dwMode)
|
|
{
|
|
IBandSite* pbs = (IBandSite*)punk;
|
|
|
|
if (pbs)
|
|
{
|
|
IDeskBarClient *pdbc;
|
|
pbs->QueryInterface(IID_IDeskBarClient, (LPVOID*)&pdbc);
|
|
if (pdbc)
|
|
{
|
|
pdbc->SetModeDBC(dwMode);
|
|
pdbc->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
void BandSite_Update(IUnknown *punk)
|
|
{
|
|
IBandSite* pbs = (IBandSite*)punk;
|
|
if (pbs)
|
|
{
|
|
IOleCommandTarget *pct;
|
|
pbs->QueryInterface(IID_IOleCommandTarget, (LPVOID*)&pct);
|
|
if (pct)
|
|
{
|
|
pct->Exec(&CGID_DeskBand, DBID_BANDINFOCHANGED, 0, NULL, NULL);
|
|
pct->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
void BandSite_UIActivateDBC(IUnknown *punk, DWORD dwState)
|
|
{
|
|
IBandSite* pbs = (IBandSite*)punk;
|
|
if (pbs)
|
|
{
|
|
IDeskBarClient *pdbc;
|
|
pbs->QueryInterface(IID_IDeskBarClient, (LPVOID*)&pdbc);
|
|
if (pdbc)
|
|
{
|
|
pdbc->UIActivateDBC(dwState);
|
|
pdbc->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
//*** PersistStreamLoad, PersistStreamSave
|
|
// NOTES
|
|
// we don't insist on finding IPersistStream iface; absence of it is
|
|
// assumed to mean there's nothing to init.
|
|
HRESULT PersistStreamLoad(IStream *pstm, IUnknown *punk)
|
|
{
|
|
HRESULT hres;
|
|
IPersistStream *pps;
|
|
|
|
hres = punk->QueryInterface(IID_IPersistStream, (LPVOID*) &pps);
|
|
if (FAILED(hres))
|
|
return S_OK; // n.b. S_OK not hres (don't insist on IID_IPS)
|
|
|
|
hres = pps->Load(pstm);
|
|
|
|
pps->Release();
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT PersistStreamSave(IStream *pstm, BOOL fClearDirty, IUnknown *punk)
|
|
{
|
|
HRESULT hres;
|
|
IPersistStream *pps;
|
|
|
|
hres = punk->QueryInterface(IID_IPersistStream, (LPVOID*) &pps);
|
|
if (FAILED(hres))
|
|
return S_OK; // n.b. S_OK not hres (don't insist on IID_IPS)
|
|
|
|
hres = pps->Save(pstm, fClearDirty);
|
|
|
|
pps->Release();
|
|
|
|
return hres;
|
|
}
|
|
|
|
// BUGBUG: these functions duplicated in shdocvw and browseui,
|
|
// should move to shlwapi.
|
|
|
|
HRESULT UnkTranslateAcceleratorIO(IUnknown* punk, LPMSG lpMsg)
|
|
{
|
|
HRESULT hres;
|
|
IInputObject *pio;
|
|
|
|
hres = punk->QueryInterface(IID_IInputObject, (LPVOID*)&pio);
|
|
if (SUCCEEDED(hres)) {
|
|
hres = pio->TranslateAcceleratorIO(lpMsg);
|
|
pio->Release();
|
|
}
|
|
return hres;
|
|
}
|
|
|
|
HRESULT UnkUIActivateIO(IUnknown *punkThis, BOOL fActivate, LPMSG lpMsg)
|
|
{
|
|
HRESULT hres = E_FAIL;
|
|
|
|
if (punkThis != NULL) {
|
|
IInputObject *pio;
|
|
|
|
hres = punkThis->QueryInterface(IID_IInputObject, (LPVOID*)&pio);
|
|
if (SUCCEEDED(hres)) {
|
|
hres = pio->UIActivateIO(fActivate, lpMsg);
|
|
pio->Release();
|
|
}
|
|
}
|
|
|
|
if (FAILED(hres))
|
|
TraceMsg(DM_FOCUS2, "uiaio(fActivate=%d) hres=%x (FAILED)", fActivate, hres);
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT UnkOnFocusChangeIS(IUnknown *punkThis, IUnknown *punkSrc, BOOL fSetFocus)
|
|
{
|
|
HRESULT hres = E_FAIL;
|
|
|
|
if (punkThis != NULL) {
|
|
IInputObjectSite *pis;
|
|
|
|
hres = punkThis->QueryInterface(IID_IInputObjectSite, (LPVOID*)&pis);
|
|
if (SUCCEEDED(hres)) {
|
|
hres = pis->OnFocusChangeIS(punkSrc, fSetFocus);
|
|
pis->Release();
|
|
}
|
|
}
|
|
|
|
if (FAILED(hres))
|
|
TraceMsg(DM_FOCUS, "ofcis(punk=%x fSetFocus=%d) hres=%x (FAILED)", punkSrc, fSetFocus, hres);
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT BandSite_DragEnter(IUnknown* punk, IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
|
|
{
|
|
HRESULT hres;
|
|
IDropTarget* pdt;
|
|
|
|
hres = punk->QueryInterface(IID_IDropTarget, (LPVOID*)&pdt);
|
|
if (pdt) {
|
|
hres = pdt->DragEnter(pdtobj, grfKeyState, pt, pdwEffect);
|
|
pdt->Release();
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT BandSite_DragOver(IUnknown* punk, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
|
|
{
|
|
HRESULT hres;
|
|
IDropTarget* pdt;
|
|
|
|
hres = punk->QueryInterface(IID_IDropTarget, (LPVOID*)&pdt);
|
|
if (pdt) {
|
|
hres = pdt->DragOver(grfKeyState, pt, pdwEffect);
|
|
pdt->Release();
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT BandSite_DragLeave(IUnknown* punk)
|
|
{
|
|
HRESULT hres;
|
|
IDropTarget* pdt;
|
|
|
|
hres = punk->QueryInterface(IID_IDropTarget, (LPVOID*)&pdt);
|
|
if (pdt) {
|
|
hres = pdt->DragLeave();
|
|
pdt->Release();
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
HRESULT BandSite_SimulateDrop(IUnknown* punk, IDataObject* pdtobj, DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect)
|
|
{
|
|
HRESULT hres;
|
|
IDropTarget* pdt;
|
|
|
|
hres = punk->QueryInterface(IID_IDropTarget, (LPVOID*)&pdt);
|
|
if (pdt) {
|
|
hres = pdt->DragEnter(pdtobj, grfKeyState, pt, pdwEffect);
|
|
if (*pdwEffect)
|
|
{
|
|
hres = pdt->Drop(pdtobj, grfKeyState, pt, pdwEffect);
|
|
}
|
|
else
|
|
{
|
|
pdt->DragLeave();
|
|
}
|
|
pdt->Release();
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
STDAPI_(LRESULT) Tray_OnMarshalBS(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
GUID *riid = (GUID *) wParam;
|
|
HRESULT hr;
|
|
IStream *pstm;
|
|
|
|
// paired w/ matching Unmarshal in shdocvw (TM_MARSHALBS)
|
|
hr = CoMarshalInterThreadInterfaceInStream(*riid, g_ts.ptbs, &pstm);
|
|
ASSERT(SUCCEEDED(hr));
|
|
|
|
return (LRESULT) pstm;
|
|
}
|
|
|
|
// {
|
|
//*** clone.cpp -- cloned (vs. imported) stuff
|
|
// DESCRIPTION
|
|
// rather than make explorer link to (e.g.) shdocvw and thus load it,
|
|
// we clone routines here.
|
|
|
|
// of course if the amount of cloning grows much it might be worth biting
|
|
// the bullet and doing a delayed load of it.
|
|
|
|
//*** shdocvw clones {
|
|
|
|
IStream *GetDesktopViewStream(DWORD grfMode, LPCTSTR pszName)
|
|
{
|
|
HKEY hkStreams;
|
|
|
|
ASSERT(g_hkeyExplorer);
|
|
|
|
if (RegCreateKey(g_hkeyExplorer, TEXT("Streams"), &hkStreams) == ERROR_SUCCESS)
|
|
{
|
|
IStream *pstm = OpenRegStream(hkStreams, TEXT("Desktop"), pszName, grfMode);
|
|
RegCloseKey(hkStreams);
|
|
return pstm;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// BUGBUG adp 980123: [SH]IsTempDisplayMode cloned from shdocvw
|
|
// for sp1 we'd have to export it from shdocvw. however for ie5
|
|
// we'd move it to shell32 and need a fwder which is silly. so
|
|
// for now we just clone it.
|
|
|
|
// for ie5 it should live in shell32 and be imported from explorer
|
|
// and shdocvw. this version has an extra TraceMsg so use it not
|
|
// shdocvw's.
|
|
|
|
|
|
BOOL Reg_GetString(HKEY hkey, LPCTSTR pszSubKey, LPCTSTR pszValue, LPTSTR psz, DWORD cb)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
if (!g_fCleanBoot)
|
|
{
|
|
fRet = ERROR_SUCCESS == SHGetValue(hkey, pszSubKey, pszValue, NULL, psz, &cb);
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
STDAPI_(BOOL) SHIsTempDisplayMode()
|
|
{
|
|
BOOL fTempMode = FALSE;
|
|
|
|
// BUGBUG (scotth): the original code in explorer was #ifdef WINNT or MEMPHIS.
|
|
// We're just checking for NT right now.
|
|
// adp: cloned from shdocvw/desktop2.cpp so we don't add a new
|
|
// export just for sp1. for ie5 we should put this in shell32
|
|
// and have both explorer and shdocvw import it from there.
|
|
if (g_bRunOnNT || g_bRunOnMemphis)
|
|
{
|
|
DEVMODE dm;
|
|
|
|
ZeroMemory(&dm, sizeof(dm));
|
|
dm.dmSize = sizeof(dm);
|
|
|
|
if (EnumDisplaySettings(NULL, ENUM_REGISTRY_SETTINGS, &dm) &&
|
|
dm.dmPelsWidth > 0 && dm.dmPelsHeight > 0)
|
|
{
|
|
HDC hdc = GetDC(NULL);
|
|
int xres = GetDeviceCaps(hdc, HORZRES);
|
|
int yres = GetDeviceCaps(hdc, VERTRES);
|
|
ReleaseDC(NULL, hdc);
|
|
|
|
if (xres != (int)dm.dmPelsWidth || yres != (int)dm.dmPelsHeight)
|
|
fTempMode = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TCHAR ach[80];
|
|
|
|
if (Reg_GetString(HKEY_CURRENT_CONFIG, REGSTR_PATH_DISPLAYSETTINGS, REGSTR_VAL_RESOLUTION, ach, SIZEOF(ach)))
|
|
{
|
|
int xres = StrToInt(ach);
|
|
HDC hdc = GetDC(NULL);
|
|
|
|
if ((GetDeviceCaps(hdc, CAPS1) & C1_REINIT_ABLE) &&
|
|
(xres > 0) && (xres != GetDeviceCaps(hdc, HORZRES))) {
|
|
fTempMode = TRUE;
|
|
}
|
|
ReleaseDC(NULL, hdc);
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
// if somebody's calling us they're probably doing something
|
|
// semi-weird when we return TRUE
|
|
if (fTempMode)
|
|
TraceMsg(DM_TRACE, "SHitdm: SHIsTempDisplayMode ret=1 (!)");
|
|
#endif
|
|
return fTempMode;
|
|
}
|
|
|
|
// }
|
|
|
|
|
|
void BandSite_Load()
|
|
{
|
|
CTrayBandSite* ptbs = IUnknownToCTrayBandSite(g_ts.ptbs);
|
|
HRESULT hres = E_FAIL;
|
|
|
|
if (g_ts.fCoolTaskbar) {
|
|
IStream *pstm;
|
|
|
|
// 1st, try persisted state
|
|
pstm = GetDesktopViewStream(STGM_READ, c_szTaskbar);
|
|
if (pstm) {
|
|
hres = PersistStreamLoad(pstm, (IBandSite*)ptbs);
|
|
pstm->Release();
|
|
}
|
|
|
|
// 2nd, if there is none (or if version mismatch or other failure),
|
|
// try settings from setup
|
|
// BUGBUG n.b. this works fine for ie4 where we have no old toolbars,
|
|
// but for future releases we'll need some kind of merging scheme,
|
|
// so we probably want to change this after ie4-beta-1.
|
|
if (FAILED(hres)) {
|
|
// n.b. HKLM not HKCU
|
|
// like GetDesktopViewStream but for HKLM
|
|
pstm = OpenRegStream(HKEY_LOCAL_MACHINE,
|
|
REGSTR_PATH_EXPLORER TEXT("\\Streams\\Desktop"),
|
|
TEXT("Default Taskbar"), STGM_READ);
|
|
if (pstm) {
|
|
hres = PersistStreamLoad(pstm, (IBandSite *)ptbs);
|
|
pstm->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
// o.w., throw up our hands and force some hard-coded defaults
|
|
// this is needed for a) unexpected failures; b) debug bootstrap;
|
|
// and c) people who don't have g_ts.fCoolTaskbar set (old mode)
|
|
if (FAILED(hres) || BandSite_CheckBands(ptbs) != S_OK) {
|
|
// but for debug, need a way to bootstrap the entire process
|
|
// failiure is normal case if REST_CLASSICSHELL is set so
|
|
// change DF_ERROR to TF_WARNING...
|
|
TraceMsg(TF_WARNING, "tcv: load failed, reverting to last-chance defaults");
|
|
|
|
|
|
// note that for the CheckBands case, we're assuming that
|
|
// a) AddBands adds only the missing guys (for now there's
|
|
// only 1 [TaskBand] so we're ok); and b) AddBands doesn't
|
|
// create dups if only some are missing (again for now there's
|
|
// only 1 so no pblm)
|
|
BandSite_AddRequiredBands(ptbs);
|
|
}
|
|
ptbs->SetLoaded(TRUE);
|
|
}
|
|
|
|
|
|
// }
|
|
|
|
// }
|