{
volatile LONG m_RefCount;
- CComPtr<ITrayWindow> Tray;
+ CComPtr<ITrayWindow> m_Tray;
- CComPtr<IUnknown> punkInner;
- CComPtr<IBandSite> BandSite;
- CComPtr<ITaskBand> TaskBand;
- CComPtr<IWinEventHandler> WindowEventHandler;
- CComPtr<IContextMenu> ContextMenu;
+ CComPtr<IUnknown> m_Inner;
+ CComPtr<IBandSite> m_BandSite;
+ CComPtr<IDeskBand> m_TaskBand;
+ CComPtr<IWinEventHandler> m_WindowEventHandler;
+ CComPtr<IContextMenu> m_ContextMenu;
- HWND hWndRebar;
+ HWND m_Rebar;
union
{
*ppvObj = NULL;
return E_NOINTERFACE;
}
- else if (punkInner != NULL)
+ else if (m_Inner != NULL)
{
- return punkInner->QueryInterface(riid, ppvObj);
+ return m_Inner->QueryInterface(riid, ppvObj);
}
else
{
public:
CTrayBandSite() :
m_RefCount(0),
- hWndRebar(NULL)
+ m_Rebar(NULL)
{
}
/* Read the current position of the stream, we'll have to reset it everytime
we read a CLSID that's not the task band... */
- ZeroMemory(&liPosZero,
- sizeof(liPosZero));
+ ZeroMemory(&liPosZero, sizeof(liPosZero));
hRet = pStm->Seek(liPosZero, STREAM_SEEK_CUR, &liCurrent);
if (SUCCEEDED(hRet))
{
if (IsEqualGUID(clsid, CLSID_ITaskBand))
{
- ASSERT(TaskBand != NULL);
+ ASSERT(m_TaskBand != NULL);
/* We're trying to load the task band! Let's create it... */
- hRet = TaskBand->QueryInterface(
+ hRet = m_TaskBand->QueryInterface(
riid,
pvObj);
if (SUCCEEDED(hRet))
return E_NOTIMPL;
}
- virtual HRESULT STDMETHODCALLTYPE IsTaskBand(
- IN IUnknown *punk)
+ virtual HRESULT STDMETHODCALLTYPE IsTaskBand(IN IUnknown *punk)
{
- return IsSameObject((IUnknown *) BandSite,
- punk);
+ return IsSameObject(m_BandSite, punk);
}
virtual HRESULT STDMETHODCALLTYPE ProcessMessage(
{
HRESULT hRet;
- ASSERT(hWndRebar != NULL);
+ ASSERT(m_Rebar != NULL);
/* Custom task band behavior */
switch (uMsg)
{
const NMHDR *nmh = (const NMHDR *) lParam;
- if (nmh->hwndFrom == hWndRebar)
+ if (nmh->hwndFrom == m_Rebar)
{
switch (nmh->code)
{
}
/* Forward to the shell's IWinEventHandler interface to get the default shell behavior! */
- if (!WindowEventHandler)
+ if (!m_WindowEventHandler)
return E_FAIL;
/*TRACE("Calling IWinEventHandler::ProcessMessage(0x%p, 0x%x, 0x%p, 0x%p, 0x%p) hWndRebar=0x%p\n", hWnd, uMsg, wParam, lParam, plResult, hWndRebar);*/
- hRet = WindowEventHandler->OnWinEvent(hWnd, uMsg, wParam, lParam, plResult);
+ hRet = m_WindowEventHandler->OnWinEvent(hWnd, uMsg, wParam, lParam, plResult);
#if 0
if (FAILED(hRet))
IN UINT uFlags,
OUT IContextMenu **ppcm)
{
- IShellService *pSs;
- HRESULT hRet;
-
- if (ContextMenu == NULL)
+ if (m_ContextMenu == NULL)
{
+ HRESULT hRet;
+ CComPtr<IShellService> pSs;
+
/* Cache the context menu so we don't need to CoCreateInstance all the time... */
hRet = CoCreateInstance(CLSID_BandSiteMenu, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IShellService, &pSs));
TRACE("CoCreateInstance(CLSID_BandSiteMenu) for IShellService returned: 0x%x\n", hRet);
hRet = pSs->SetOwner((IBandSite*)this);
if (!SUCCEEDED(hRet))
{
- pSs->Release();
return hRet;
}
- hRet = pSs->QueryInterface(IID_PPV_ARG(IContextMenu, &ContextMenu));
-
- pSs->Release();
+ hRet = pSs->QueryInterface(IID_PPV_ARG(IContextMenu, &m_ContextMenu));
if (!SUCCEEDED(hRet))
return hRet;
if (ppcm != NULL)
{
- ContextMenu->AddRef();
- *ppcm = ContextMenu;
+ m_ContextMenu->AddRef();
+ *ppcm = m_ContextMenu;
}
/* Add the menu items */
- return ContextMenu->QueryContextMenu(
- hmenu,
- indexMenu,
- idCmdFirst,
- idCmdLast,
- uFlags);
+ return m_ContextMenu->QueryContextMenu(hmenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
}
- virtual HRESULT STDMETHODCALLTYPE Lock(
- IN BOOL bLock)
+ virtual HRESULT STDMETHODCALLTYPE Lock(IN BOOL bLock)
{
BOOL bPrevLocked = Locked;
BANDSITEINFO bsi;
HRESULT hRet;
- ASSERT(BandSite != NULL);
+ ASSERT(m_BandSite != NULL);
if (bPrevLocked != bLock)
{
bsi.dwMask = BSIM_STYLE;
bsi.dwStyle = (Locked ? BSIS_LOCKED | BSIS_NOGRIPPER : BSIS_AUTOGRIPPER);
- hRet = BandSite->SetBandSiteInfo(&bsi);
+ hRet = m_BandSite->SetBandSiteInfo(&bsi);
+
+ /* HACK for CORE-9809 ! */
+ if (hRet == E_NOTIMPL)
+ hRet = S_OK;
+ else
+ ERR("HACK for CORE-9809 no longer needed!\n");
+
if (SUCCEEDED(hRet))
{
hRet = Update();
/*******************************************************************/
- virtual HRESULT STDMETHODCALLTYPE AddBand(
- IN IUnknown *punk)
+ virtual HRESULT STDMETHODCALLTYPE AddBand(IN IUnknown *punk)
{
- IOleCommandTarget *pOct;
- HRESULT hRet;
-
- hRet = punk->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &pOct));
- if (SUCCEEDED(hRet))
- {
- /* Send the DBID_DELAYINIT command to initialize the band to be added */
- /* FIXME: Should be delayed */
- pOct->Exec(
- &IID_IDeskBand,
- DBID_DELAYINIT,
- 0,
- NULL,
- NULL);
+ /* Send the DBID_DELAYINIT command to initialize the band to be added */
+ /* FIXME: Should be delayed */
+ IUnknown_Exec(punk, IID_IDeskBand, DBID_DELAYINIT, 0, NULL, NULL);
- pOct->Release();
- }
-
- return BandSite->AddBand(
- punk);
+ return m_BandSite->AddBand(punk);
}
virtual HRESULT STDMETHODCALLTYPE EnumBands(
IN UINT uBand,
OUT DWORD *pdwBandID)
{
- return BandSite->EnumBands(
- uBand,
- pdwBandID);
+ return m_BandSite->EnumBands(uBand, pdwBandID);
}
virtual HRESULT STDMETHODCALLTYPE QueryBand(
HRESULT hRet;
IDeskBand *pstb = NULL;
- hRet = BandSite->QueryBand(
+ hRet = m_BandSite->QueryBand(
dwBandID,
&pstb,
pdwState,
if (SUCCEEDED(hRet))
{
- hRet = IsSameObject(pstb, TaskBand);
+ hRet = IsSameObject(pstb, m_TaskBand);
if (hRet == S_OK)
{
/* Add the BSSF_UNDELETEABLE flag to pdwState because the task bar band shouldn't be deletable */
IN DWORD dwMask,
IN DWORD dwState)
{
- return BandSite->SetBandState(dwBandID, dwMask, dwState);
+ return m_BandSite->SetBandState(dwBandID, dwMask, dwState);
}
virtual HRESULT STDMETHODCALLTYPE RemoveBand(
IN DWORD dwBandID)
{
- return BandSite->RemoveBand(dwBandID);
+ return m_BandSite->RemoveBand(dwBandID);
}
virtual HRESULT STDMETHODCALLTYPE GetBandObject(
IN REFIID riid,
OUT VOID **ppv)
{
- return BandSite->GetBandObject(dwBandID, riid, ppv);
+ return m_BandSite->GetBandObject(dwBandID, riid, ppv);
}
virtual HRESULT STDMETHODCALLTYPE SetBandSiteInfo(
IN const BANDSITEINFO *pbsinfo)
{
- return BandSite->SetBandSiteInfo(pbsinfo);
+ return m_BandSite->SetBandSiteInfo(pbsinfo);
}
virtual HRESULT STDMETHODCALLTYPE GetBandSiteInfo(
IN OUT BANDSITEINFO *pbsinfo)
{
- return BandSite->GetBandSiteInfo(pbsinfo);
+ return m_BandSite->GetBandSiteInfo(pbsinfo);
}
virtual BOOL HasTaskBand()
{
- ASSERT(TaskBand != NULL);
-
- return SUCCEEDED(TaskBand->GetRebarBandID(
- NULL));
- }
-
- virtual HRESULT AddTaskBand()
- {
-#if 0
- /* FIXME: This is the code for the simple taskbar */
- IObjectWithSite *pOws;
- HRESULT hRet;
-
- hRet = TaskBand->QueryInterface(
- &IID_IObjectWithSite,
- (PVOID*) &pOws);
- if (SUCCEEDED(hRet))
- {
- hRet = pOws->SetSite(
- (IUnknown *)TaskBand);
-
- pOws->Release();
- }
+ CComPtr<IPersist> pBand;
+ CLSID BandCLSID;
+ DWORD dwBandID;
+ UINT uBand = 0;
- return hRet;
-#else
- if (!HasTaskBand())
+ /* Enumerate all bands */
+ while (SUCCEEDED(m_BandSite->EnumBands(uBand, &dwBandID)))
{
- return BandSite->AddBand(TaskBand);
+ if (SUCCEEDED(m_BandSite->GetBandObject(dwBandID, IID_PPV_ARG(IPersist, &pBand))))
+ {
+ if (SUCCEEDED(pBand->GetClassID(&BandCLSID)))
+ {
+ if (IsEqualGUID(BandCLSID, CLSID_ITaskBand))
+ {
+ return TRUE;
+ }
+ }
+ }
+ uBand++;
}
- return S_OK;
-#endif
+ return FALSE;
}
virtual HRESULT Update()
{
- IOleCommandTarget *pOct;
- HRESULT hRet;
-
- hRet = punkInner->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &pOct));
- if (SUCCEEDED(hRet))
- {
- /* Send the DBID_BANDINFOCHANGED command to update the band site */
- hRet = pOct->Exec(
- &IID_IDeskBand,
+ return IUnknown_Exec(m_Inner,
+ IID_IDeskBand,
DBID_BANDINFOCHANGED,
0,
NULL,
NULL);
-
- pOct->Release();
- }
-
- return hRet;
}
- virtual VOID BroadcastOleCommandExec(const GUID *pguidCmdGroup,
+ virtual VOID BroadcastOleCommandExec(REFGUID pguidCmdGroup,
DWORD nCmdID,
DWORD nCmdExecOpt,
VARIANTARG *pvaIn,
UINT uBand = 0;
/* Enumerate all bands */
- while (SUCCEEDED(BandSite->EnumBands(uBand, &dwBandID)))
+ while (SUCCEEDED(m_BandSite->EnumBands(uBand, &dwBandID)))
{
- if (SUCCEEDED(BandSite->GetBandObject(dwBandID, IID_PPV_ARG(IOleCommandTarget, &pOct))))
+ if (SUCCEEDED(m_BandSite->GetBandObject(dwBandID, IID_PPV_ARG(IOleCommandTarget, &pOct))))
{
/* Execute the command */
pOct->Exec(
- pguidCmdGroup,
+ &pguidCmdGroup,
nCmdID,
nCmdExecOpt,
pvaIn,
virtual HRESULT FinishInit()
{
/* Broadcast the DBID_FINISHINIT command */
- BroadcastOleCommandExec(&IID_IDeskBand, DBID_FINISHINIT, 0, NULL, NULL);
+ BroadcastOleCommandExec(IID_IDeskBand, DBID_FINISHINIT, 0, NULL, NULL);
return S_OK;
}
- virtual HRESULT Show(
- IN BOOL bShow)
+ virtual HRESULT Show(IN BOOL bShow)
{
- IDeskBarClient *pDbc;
+ CComPtr<IDeskBarClient> pDbc;
HRESULT hRet;
- hRet = BandSite->QueryInterface(IID_PPV_ARG(IDeskBarClient, &pDbc));
+ hRet = m_BandSite->QueryInterface(IID_PPV_ARG(IDeskBarClient, &pDbc));
if (SUCCEEDED(hRet))
{
- hRet = pDbc->UIActivateDBC(
- bShow ? DBC_SHOW : DBC_HIDE);
- pDbc->Release();
+ hRet = pDbc->UIActivateDBC(bShow ? DBC_SHOW : DBC_HIDE);
}
return hRet;
virtual HRESULT LoadFromStream(IN OUT IStream *pStm)
{
- IPersistStream *pPStm;
+ CComPtr<IPersistStream> pPStm;
HRESULT hRet;
- ASSERT(BandSite != NULL);
+ ASSERT(m_BandSite != NULL);
/* We implement the undocumented COM interface IBandSiteStreamCallback
that the shell will query so that we can intercept and custom-load
the task band when it finds the task band's CLSID (which is internal).
This way we can prevent the shell from attempting to CoCreateInstance
the (internal) task band, resulting in a failure... */
- hRet = BandSite->QueryInterface(IID_PPV_ARG(IPersistStream, &pPStm));
+ hRet = m_BandSite->QueryInterface(IID_PPV_ARG(IPersistStream, &pPStm));
if (SUCCEEDED(hRet))
{
- hRet = pPStm->Load(
- pStm);
+ hRet = pPStm->Load(pStm);
TRACE("->Load() returned 0x%x\n", hRet);
- pPStm->Release();
}
return hRet;
}
- virtual IStream *
- GetUserBandsStream(IN DWORD grfMode)
+ virtual IStream * GetUserBandsStream(IN DWORD grfMode)
{
HKEY hkStreams;
IStream *Stream = NULL;
- if (RegCreateKey(hkExplorer,
- TEXT("Streams"),
- &hkStreams) == ERROR_SUCCESS)
+ if (RegCreateKeyW(hkExplorer,
+ L"Streams",
+ &hkStreams) == ERROR_SUCCESS)
{
- Stream = SHOpenRegStream(hkStreams,
- TEXT("Desktop"),
- TEXT("TaskbarWinXP"),
- grfMode);
+ Stream = SHOpenRegStreamW(hkStreams,
+ L"Desktop",
+ L"TaskbarWinXP",
+ grfMode);
RegCloseKey(hkStreams);
}
return Stream;
}
- virtual IStream *
- GetDefaultBandsStream(IN DWORD grfMode)
+ virtual IStream * GetDefaultBandsStream(IN DWORD grfMode)
{
HKEY hkStreams;
IStream *Stream = NULL;
- if (RegCreateKey(HKEY_LOCAL_MACHINE,
- TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Streams"),
+ if (RegCreateKeyW(HKEY_LOCAL_MACHINE,
+ L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Streams",
&hkStreams) == ERROR_SUCCESS)
{
- Stream = SHOpenRegStream(hkStreams,
- TEXT("Desktop"),
- TEXT("Default Taskbar"),
- grfMode);
+ Stream = SHOpenRegStreamW(hkStreams,
+ L"Desktop",
+ L"Default Taskbar",
+ grfMode);
RegCloseKey(hkStreams);
}
return hRet;
}
- HRESULT _Init(IN OUT ITrayWindow *tray, OUT HWND *phWndRebar, OUT HWND *phwndTaskSwitch)
+ HRESULT _Init(IN ITrayWindow *tray, IN IDeskBand* pTaskBand)
{
- IDeskBarClient *pDbc;
- IDeskBand *pDb;
- IOleWindow *pOw;
+ CComPtr<IDeskBarClient> pDbc;
+ CComPtr<IDeskBand> pDb;
+ CComPtr<IOleWindow> pOw;
HRESULT hRet;
- *phWndRebar = NULL;
- *phwndTaskSwitch = NULL;
-
- Tray = tray;
+ m_Tray = tray;
+ m_TaskBand = pTaskBand;
- /* Create a RebarBandSite provided by the shell */
+ /* Create the RebarBandSite */
hRet = CoCreateInstance(CLSID_RebarBandSite,
- static_cast<IBandSite*>(this),
- CLSCTX_INPROC_SERVER,
- IID_PPV_ARG(IUnknown, &punkInner));
- if (!SUCCEEDED(hRet))
- {
+ static_cast<IBandSite*>(this),
+ CLSCTX_INPROC_SERVER,
+ IID_PPV_ARG(IUnknown, &m_Inner));
+ if (FAILED_UNEXPECTEDLY(hRet))
return hRet;
- }
- hRet = punkInner->QueryInterface(IID_PPV_ARG(IBandSite, &BandSite));
- if (!SUCCEEDED(hRet))
- {
+ hRet = m_Inner->QueryInterface(IID_PPV_ARG(IBandSite, &m_BandSite));
+ if (FAILED_UNEXPECTEDLY(hRet))
return hRet;
- }
- hRet = punkInner->QueryInterface(IID_PPV_ARG(IWinEventHandler, &WindowEventHandler));
- if (!SUCCEEDED(hRet))
- {
+ hRet = m_Inner->QueryInterface(IID_PPV_ARG(IWinEventHandler, &m_WindowEventHandler));
+ if (FAILED_UNEXPECTEDLY(hRet))
return hRet;
- }
-
- TaskBand = CreateTaskBand(Tray);
- if (TaskBand != NULL)
- {
- /* Add the task band to the site */
- hRet = BandSite->QueryInterface(IID_PPV_ARG(IDeskBarClient, &pDbc));
- if (SUCCEEDED(hRet))
- {
- hRet = TaskBand->QueryInterface(IID_PPV_ARG(IOleWindow, &pOw));
- if (SUCCEEDED(hRet))
- {
- /* We cause IDeskBarClient to create the rebar control by passing the new
- task band to it. The band reports the tray window handle as window handle
- so that IDeskBarClient knows the parent window of the Rebar control that
- it wants to create. */
- hRet = pDbc->SetDeskBarSite(pOw);
-
- if (SUCCEEDED(hRet))
- {
- /* The Rebar control is now created, we can query the window handle */
- hRet = pDbc->GetWindow(&hWndRebar);
-
- if (SUCCEEDED(hRet))
- {
- /* We need to manually remove the RBS_BANDBORDERS style! */
- SetWindowStyle(hWndRebar, RBS_BANDBORDERS, 0);
- }
- }
- pOw->Release();
- }
+ hRet = m_Inner->QueryInterface(IID_PPV_ARG(IDeskBarClient, &pDbc));
+ if (FAILED_UNEXPECTEDLY(hRet))
+ return hRet;
- if (SUCCEEDED(hRet))
- {
- DWORD dwMode = 0;
- /* Set the Desk Bar mode to the current one */
- /* FIXME: We need to set the mode (and update) whenever the user docks
- the tray window to another monitor edge! */
- if (!Tray->IsHorizontal())
- dwMode = DBIF_VIEWMODE_VERTICAL;
+ /* Crete the rebar in the tray */
+ hRet = pDbc->SetDeskBarSite(tray);
+ if (FAILED_UNEXPECTEDLY(hRet))
+ return hRet;
- hRet = pDbc->SetModeDBC(dwMode);
- }
+ hRet = pDbc->GetWindow(&m_Rebar);
+ if (FAILED_UNEXPECTEDLY(hRet))
+ return hRet;
- pDbc->Release();
- }
+ SetWindowStyle(m_Rebar, RBS_BANDBORDERS, 0);
- /* Load the saved state of the task band site */
- /* FIXME: We should delay loading shell extensions, also see DBID_DELAYINIT */
- Load();
+ /* Set the Desk Bar mode to the current one */
+ DWORD dwMode = 0;
+ /* FIXME: We need to set the mode (and update) whenever the user docks
+ the tray window to another monitor edge! */
+ if (!m_Tray->IsHorizontal())
+ dwMode = DBIF_VIEWMODE_VERTICAL;
- /* Add the task bar band if it hasn't been added already */
- hRet = AddTaskBand();
- if (SUCCEEDED(hRet))
- {
- hRet = TaskBand->QueryInterface(IID_PPV_ARG(IDeskBand, &pDb));
- if (SUCCEEDED(hRet))
- {
- hRet = pDb->GetWindow(phwndTaskSwitch);
- if (!SUCCEEDED(hRet))
- *phwndTaskSwitch = NULL;
+ hRet = pDbc->SetModeDBC(dwMode);
- pDb->Release();
- }
- }
+ /* Load the saved state of the task band site */
+ /* FIXME: We should delay loading shell extensions, also see DBID_DELAYINIT */
+ Load();
- /* Should we send this after showing it? */
- Update();
+ /* Add the task bar band if it hasn't been added while loading */
+ if (!HasTaskBand())
+ {
+ hRet = m_BandSite->AddBand(m_TaskBand);
+ if (FAILED_UNEXPECTEDLY(hRet))
+ return hRet;
+ }
- /* FIXME: When should we send this? Does anyone care anyway? */
- FinishInit();
+ /* Should we send this after showing it? */
+ Update();
- /* Activate the band site */
- Show(
- TRUE);
- }
+ /* FIXME: When should we send this? Does anyone care anyway? */
+ FinishInit();
- *phWndRebar = hWndRebar;
+ /* Activate the band site */
+ Show(TRUE);
return S_OK;
}
- };
+};
/*******************************************************************/
-ITrayBandSite *
-CreateTrayBandSite(IN OUT ITrayWindow *Tray,
-OUT HWND *phWndRebar,
-OUT HWND *phWndTaskSwitch)
+HRESULT CTrayBandSite_CreateInstance(IN ITrayWindow *tray, IN IDeskBand* pTaskBand, OUT ITrayBandSite** pBandSite)
{
HRESULT hr;
CTrayBandSite * tb = new CTrayBandSite();
-
if (!tb)
- return NULL;
+ return E_FAIL;
tb->AddRef();
- hr = tb->_Init(Tray, phWndRebar, phWndTaskSwitch);
+ hr = tb->_Init(tray, pTaskBand);
if (FAILED_UNEXPECTEDLY(hr))
+ {
tb->Release();
+ return hr;
+ }
+
+ *pBandSite = tb;
- return tb;
+ return S_OK;
}
projects / reactos.git / blobdiff