[BROWSEUI]

* Add a stubbed CExplorerBand, which I will be using to investigate how the windows shell implements the sidebar panels.
This will never be called in ReactOS because our shell view doesn't handle the buttons for opening the sidebars, so it never asks the shell browser to open one.

CORE-8815

svn path=/trunk/; revision=65554

reactos/dll/win32/browseui/CMakeLists.txt

@@ -22,6 +22,7 @@ list(APPEND SOURCE
     browseuiord.cpp
     commonbrowser.cpp
     desktopipc.cpp
+    explorerband.cpp
     globalfoldersettings.cpp
     internettoolbar.cpp
     parsecmdline.cpp

reactos/dll/win32/browseui/browseui.cpp

@@ -38,6 +38,7 @@ OBJECT_ENTRY(CLSID_CCommonBrowser, CCommonBrowser)
 OBJECT_ENTRY(CLSID_GlobalFolderSettings, CGlobalFolderSettings)
 OBJECT_ENTRY(CLSID_InternetToolbar, CInternetToolbar)
 OBJECT_ENTRY(CLSID_CRegTreeOptions, CRegTreeOptions)
+OBJECT_ENTRY(CLSID_ExplorerBand, CExplorerBand)
 END_OBJECT_MAP()
 
 CBrowseUIModule                             gModule;

reactos/dll/win32/browseui/browseui.rc

@@ -41,6 +41,7 @@ IDR_COMMONBROWSER REGISTRY "res/commonbrowser.rgs"
 IDR_GLOBALFOLDERSETTINGS REGISTRY "res/globalfoldersettings.rgs"
 IDR_INTERNETTOOLBAR REGISTRY "res/internettoolbar.rgs"
 IDR_REGTREEOPTIONS REGISTRY "res/regtreeoptions.rgs"
+IDR_EXPLORERBAND REGISTRY "res/explorerband.rgs"
 
 /*
  * Everything specific to any language goes

reactos/dll/win32/browseui/explorerband.cpp

@@ -0,0 +1,698 @@
+#include "precomp.h"
+
+#if 1
+#undef UNIMPLEMENTED
+
+#define UNIMPLEMENTED DbgPrint("%s is UNIMPLEMENTED!\n", __FUNCTION__)
+#endif
+
+extern "C"
+HRESULT WINAPI CExplorerBand_Constructor(REFIID riid, LPVOID *ppv)
+{
+    return ShellObjectCreator<CExplorerBand>(riid, ppv);
+}
+
+CExplorerBand::CExplorerBand() :
+    m_internalBand(NULL),
+    m_internalDeskBand(NULL),
+    m_internalObjectWithSite(NULL),
+    m_internalInputObject(NULL),
+    m_internalPersistStream(NULL),
+    m_internalOleCommandTarget(NULL),
+    m_internalServiceProvider(NULL),
+    m_internalBandNavigate(NULL),
+    m_internalWinEventHandler(NULL),
+    m_internalNamespaceProxy(NULL),
+    m_internalDispatch(NULL),
+    m_OnWinEventShown(FALSE)
+{
+    HRESULT hResult = CoCreateInstance(CLSID_ExplorerBand, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IUnknown, &m_internalBand));
+    if (FAILED(hResult))
+    {
+        ERR("Could not create internal band (hr=%08lx).\n", hResult);
+        m_internalBand = NULL;
+        return;
+    }
+    hResult = m_internalBand->QueryInterface(IID_PPV_ARG(IDeskBand, &m_internalDeskBand));
+    if (FAILED(hResult))
+    {
+        ERR("Could not obtain interface IDeskBand from internal band (hr=%08lx).\n", hResult);
+        m_internalBand = NULL;
+        m_internalDeskBand = NULL;
+        return;
+    }
+    hResult = m_internalBand->QueryInterface(IID_PPV_ARG(IObjectWithSite, &m_internalObjectWithSite));
+    if (FAILED(hResult))
+    {
+        ERR("Could not obtain interface IObjectWithSite from internal band (hr=%08lx).\n", hResult);
+        m_internalBand = NULL;
+        m_internalDeskBand = NULL;
+        m_internalObjectWithSite = NULL;
+        return;
+    }
+    hResult = m_internalBand->QueryInterface(IID_PPV_ARG(IInputObject, &m_internalInputObject));
+    if (FAILED(hResult))
+    {
+        ERR("Could not obtain interface IInputObject from internal band (hr=%08lx).\n", hResult);
+        m_internalBand = NULL;
+        m_internalDeskBand = NULL;
+        m_internalObjectWithSite = NULL;
+        m_internalInputObject = NULL;
+        return;
+    }
+    hResult = m_internalBand->QueryInterface(IID_PPV_ARG(IPersistStream, &m_internalPersistStream));
+    if (FAILED(hResult))
+    {
+        ERR("Could not obtain interface IPersistStream from internal band (hr=%08lx).\n", hResult);
+        m_internalBand = NULL;
+        m_internalDeskBand = NULL;
+        m_internalObjectWithSite = NULL;
+        m_internalInputObject = NULL;
+        m_internalPersistStream = NULL;
+        return;
+    }
+    hResult = m_internalBand->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &m_internalOleCommandTarget));
+    if (FAILED(hResult))
+    {
+        ERR("Could not obtain interface IOleCommandTarget from internal band (hr=%08lx).\n", hResult);
+        m_internalBand = NULL;
+        m_internalDeskBand = NULL;
+        m_internalObjectWithSite = NULL;
+        m_internalInputObject = NULL;
+        m_internalPersistStream = NULL;
+        m_internalOleCommandTarget = NULL;
+        return;
+    }
+    hResult = m_internalBand->QueryInterface(IID_PPV_ARG(IServiceProvider, &m_internalServiceProvider));
+    if (FAILED(hResult))
+    {
+        ERR("Could not obtain interface IServiceProvider from internal band (hr=%08lx).\n", hResult);
+        m_internalBand = NULL;
+        m_internalDeskBand = NULL;
+        m_internalObjectWithSite = NULL;
+        m_internalInputObject = NULL;
+        m_internalPersistStream = NULL;
+        m_internalOleCommandTarget = NULL;
+        m_internalServiceProvider = NULL;
+        return;
+    }
+    hResult = m_internalBand->QueryInterface(IID_PPV_ARG(IBandNavigate, &m_internalBandNavigate));
+    if (FAILED(hResult))
+    {
+        ERR("Could not obtain interface IBandNavigate from internal band (hr=%08lx).\n", hResult);
+        m_internalBand = NULL;
+        m_internalDeskBand = NULL;
+        m_internalObjectWithSite = NULL;
+        m_internalInputObject = NULL;
+        m_internalPersistStream = NULL;
+        m_internalOleCommandTarget = NULL;
+        m_internalServiceProvider = NULL;
+        m_internalBandNavigate = NULL;
+        return;
+    }
+    hResult = m_internalBand->QueryInterface(IID_PPV_ARG(IWinEventHandler, &m_internalWinEventHandler));
+    if (FAILED(hResult))
+    {
+        ERR("Could not obtain interface IWinEventHandler from internal band (hr=%08lx).\n", hResult);
+        m_internalBand = NULL;
+        m_internalDeskBand = NULL;
+        m_internalObjectWithSite = NULL;
+        m_internalInputObject = NULL;
+        m_internalPersistStream = NULL;
+        m_internalOleCommandTarget = NULL;
+        m_internalServiceProvider = NULL;
+        m_internalBandNavigate = NULL;
+        m_internalWinEventHandler = NULL;
+        return;
+    }
+    hResult = m_internalBand->QueryInterface(IID_PPV_ARG(INamespaceProxy, &m_internalNamespaceProxy));
+    if (FAILED(hResult))
+    {
+        ERR("Could not obtain interface INamespaceProxy from internal band (hr=%08lx).\n", hResult);
+        m_internalBand = NULL;
+        m_internalDeskBand = NULL;
+        m_internalObjectWithSite = NULL;
+        m_internalInputObject = NULL;
+        m_internalPersistStream = NULL;
+        m_internalOleCommandTarget = NULL;
+        m_internalServiceProvider = NULL;
+        m_internalBandNavigate = NULL;
+        m_internalWinEventHandler = NULL;
+        m_internalNamespaceProxy = NULL;
+        return;
+    }
+    hResult = m_internalBand->QueryInterface(IID_PPV_ARG(IDispatch, &m_internalDispatch));
+    if (FAILED(hResult))
+    {
+        ERR("Could not obtain interface INamespaceProxy from internal band (hr=%08lx).\n", hResult);
+        m_internalBand = NULL;
+        m_internalDeskBand = NULL;
+        m_internalObjectWithSite = NULL;
+        m_internalInputObject = NULL;
+        m_internalPersistStream = NULL;
+        m_internalOleCommandTarget = NULL;
+        m_internalServiceProvider = NULL;
+        m_internalBandNavigate = NULL;
+        m_internalWinEventHandler = NULL;
+        m_internalNamespaceProxy = NULL;
+        m_internalDispatch = NULL;
+        return;
+    }
+}
+
+CExplorerBand::~CExplorerBand()
+{
+}
+
+// *** IOleWindow methods ***
+HRESULT STDMETHODCALLTYPE CExplorerBand::GetWindow(HWND *lphwnd)
+{
+    HRESULT hr;
+    if (m_internalDeskBand)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::GetWindow(HWND *lphwnd=%p)\n", lphwnd);
+        hr = m_internalDeskBand->GetWindow(lphwnd);
+        if (lphwnd)
+            DbgPrint("\t*lphwnd=%p\n", *lphwnd);
+        DbgPrint("CExplorerBand::GetWindow returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::ContextSensitiveHelp(BOOL fEnterMode)
+{
+    HRESULT hr;
+    if (m_internalDeskBand)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::ContextSensitiveHelp(BOOL fEnterMode=%s)\n", fEnterMode ? "TRUE" : "FALSE");
+        hr = m_internalDeskBand->ContextSensitiveHelp(fEnterMode);
+        DbgPrint("CExplorerBand::ContextSensitiveHelp returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+
+// *** IDockingWindow methods ***
+HRESULT STDMETHODCALLTYPE CExplorerBand::CloseDW(DWORD dwReserved)
+{
+    HRESULT hr;
+    if (m_internalDeskBand)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::CloseDW(DWORD dwReserved=%u)\n", dwReserved);
+        hr = m_internalDeskBand->CloseDW(dwReserved);
+        DbgPrint("CExplorerBand::CloseDW returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::ResizeBorderDW(const RECT *prcBorder, IUnknown *punkToolbarSite, BOOL fReserved)
+{
+    HRESULT hr;
+    if (m_internalDeskBand)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::ResizeBorderDW(const RECT *prcBorder=%p, IUnknown *punkToolbarSite=%p, BOOL fReserved=%s)\n",
+                 prcBorder, punkToolbarSite, fReserved ? "TRUE" : "FALSE");
+        if (prcBorder)
+            DbgPrint("\t*prcBorder={%u, %u, %u, %u}\n", prcBorder->left, prcBorder->top, prcBorder->right, prcBorder->bottom);
+        hr = m_internalDeskBand->ResizeBorderDW(prcBorder, punkToolbarSite, fReserved);
+        DbgPrint("CExplorerBand::ResizeBorderDW returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::ShowDW(BOOL fShow)
+{
+    HRESULT hr;
+    if (m_internalDeskBand)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::ShowDW(BOOL fShow=%s)\n", fShow ? "TRUE" : "FALSE");
+        hr = m_internalDeskBand->ShowDW(fShow);
+        DbgPrint("CExplorerBand::ShowDW returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+
+// *** IDeskBand methods ***
+HRESULT STDMETHODCALLTYPE CExplorerBand::GetBandInfo(DWORD dwBandID, DWORD dwViewMode, DESKBANDINFO *pdbi)
+{
+    HRESULT hr;
+    if (m_internalDeskBand)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::GetBandInfo(DWORD dwBandID=%u, DWORD dwViewMode=%u, DESKBANDINFO *pdbi=%p)\n", 
+                 dwBandID, dwViewMode, pdbi);
+        if (pdbi)
+            DbgPrint("\t*pdbi={dwMask=%u, ...}\n", pdbi->dwMask);
+        hr = m_internalDeskBand->GetBandInfo(dwBandID, dwViewMode, pdbi);
+        if (pdbi)
+            DbgPrint("\t*pdbi={dwMask=%u, crBkgnd=%u, ...}\n", pdbi->dwMask, pdbi->crBkgnd);
+        DbgPrint("CExplorerBand::GetBandInfo returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+
+// *** IObjectWithSite methods ***
+HRESULT STDMETHODCALLTYPE CExplorerBand::SetSite(IUnknown *pUnkSite)
+{
+    HRESULT hr;
+    if (m_internalObjectWithSite)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::SetSite(IUnknown *pUnkSite=%p)\n", pUnkSite);
+        hr = m_internalObjectWithSite->SetSite(pUnkSite);
+        DbgPrint("CExplorerBand::SetSite returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::GetSite(REFIID riid, void **ppvSite)
+{
+    HRESULT hr;
+    if (m_internalObjectWithSite)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::GetSite(REFIID riid=%s, void **ppvSite=%p)\n", wine_dbgstr_guid(&riid), ppvSite);
+        hr = m_internalObjectWithSite->GetSite(riid, ppvSite);
+        if (ppvSite)
+            DbgPrint("\t*ppvSite=%p\n", *ppvSite);
+        DbgPrint("CExplorerBand::GetSite returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+
+// *** IOleCommandTarget methods ***
+HRESULT STDMETHODCALLTYPE CExplorerBand::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds [], OLECMDTEXT *pCmdText)
+{
+    HRESULT hr;
+    if (m_internalOleCommandTarget)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::QueryStatus(const GUID *pguidCmdGroup=%s, ULONG cCmds=%08x, OLECMD prgCmds []=%p, OLECMDTEXT *pCmdText=%p)\n",
+                 wine_dbgstr_guid(pguidCmdGroup), cCmds, prgCmds, pCmdText);
+        hr = m_internalOleCommandTarget->QueryStatus(pguidCmdGroup, cCmds, prgCmds, pCmdText);
+        DbgPrint("CExplorerBand::QueryStatus returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
+{
+    HRESULT hr;
+    if (m_internalOleCommandTarget)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::Exec(const GUID *pguidCmdGroup=%s, DWORD nCmdID=%u, DWORD nCmdexecopt=%u, VARIANT *pvaIn=%p, VARIANT *pvaOut=%p)\n",
+                 wine_dbgstr_guid(pguidCmdGroup), nCmdID, nCmdexecopt, pvaIn, pvaOut);
+        hr = m_internalOleCommandTarget->Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
+        DbgPrint("CExplorerBand::Exec returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+
+// *** IServiceProvider methods ***
+HRESULT STDMETHODCALLTYPE CExplorerBand::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
+{
+    HRESULT hr;
+    if (m_internalServiceProvider)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::QueryService(REFGUID guidService=%s, REFIID riid=%s, void **ppvObject=%p)\n",
+                 wine_dbgstr_guid(&guidService), wine_dbgstr_guid(&riid), ppvObject);
+        hr = m_internalServiceProvider->QueryService(guidService, riid, ppvObject);
+        if (ppvObject)
+            DbgPrint("\t*ppvObject=%p\n", *ppvObject);
+        DbgPrint("CExplorerBand::QueryService returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+
+// *** IInputObject methods ***
+HRESULT STDMETHODCALLTYPE CExplorerBand::UIActivateIO(BOOL fActivate, LPMSG lpMsg)
+{
+    HRESULT hr;
+    if (m_internalInputObject)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::UIActivateIO(BOOL fActivate=%s, LPMSG lpMsg=%p)\n",
+                 fActivate ? "TRUE" : "FALSE", lpMsg);
+        hr = m_internalInputObject->UIActivateIO(fActivate, lpMsg);
+        if (lpMsg)
+            DbgPrint("\t*lpMsg={hwnd=%p, message=%x, wParam=%x, lParam=%x, time=%x, pt={%u %u}}\n",
+            lpMsg->hwnd, lpMsg->message, lpMsg->wParam, lpMsg->lParam, lpMsg->time, lpMsg->pt.x, lpMsg->pt.y);
+        DbgPrint("CExplorerBand::UIActivateIO returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::HasFocusIO()
+{
+    HRESULT hr;
+    if (m_internalInputObject)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::HasFocusIO()\n");
+        hr = m_internalInputObject->HasFocusIO();
+        DbgPrint("CExplorerBand::HasFocusIO returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::TranslateAcceleratorIO(LPMSG lpMsg)
+{
+    HRESULT hr;
+    if (m_internalInputObject)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::TranslateAcceleratorIO(LPMSG lpMsg=%p)\n", lpMsg);
+        hr = m_internalInputObject->TranslateAcceleratorIO(lpMsg);
+        if (lpMsg)
+            DbgPrint("\t*lpMsg={hwnd=%p, message=%x, wParam=%x, lParam=%x, time=%x, pt={%u %u}}\n",
+            lpMsg->hwnd, lpMsg->message, lpMsg->wParam, lpMsg->lParam, lpMsg->time, lpMsg->pt.x, lpMsg->pt.y);
+        DbgPrint("CExplorerBand::TranslateAcceleratorIO returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+
+// *** IPersist methods ***
+HRESULT STDMETHODCALLTYPE CExplorerBand::GetClassID(CLSID *pClassID)
+{
+    HRESULT hr;
+    if (m_internalPersistStream)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::GetClassID(CLSID *pClassID=%p)\n", pClassID);
+        hr = m_internalPersistStream->GetClassID(pClassID);
+        if (pClassID)
+            DbgPrint("\t*pClassID=%s\n", wine_dbgstr_guid(pClassID));
+        DbgPrint("CExplorerBand::GetClassID returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+
+// *** IPersistStream methods ***
+HRESULT STDMETHODCALLTYPE CExplorerBand::IsDirty()
+{
+    HRESULT hr;
+    if (m_internalPersistStream)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::IsDirty()\n");
+        hr = m_internalPersistStream->IsDirty();
+        DbgPrint("CExplorerBand::IsDirty returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::Load(IStream *pStm)
+{
+    HRESULT hr;
+    if (m_internalPersistStream)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::Load(IStream *pStm=%p)\n", pStm);
+        hr = m_internalPersistStream->Load(pStm);
+        DbgPrint("CExplorerBand::Load returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::Save(IStream *pStm, BOOL fClearDirty)
+{
+    HRESULT hr;
+    if (m_internalPersistStream)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::Save(IStream *pStm=%p, BOOL fClearDirty=%s)\n",
+                 pStm, fClearDirty ? "TRUE" : "FALSE");
+        hr = m_internalPersistStream->Save(pStm, fClearDirty);
+        DbgPrint("CExplorerBand::Save returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::GetSizeMax(ULARGE_INTEGER *pcbSize)
+{
+    HRESULT hr;
+    if (m_internalPersistStream)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::GetSizeMax(ULARGE_INTEGER *pcbSize=%p)\n", pcbSize);
+        hr = m_internalPersistStream->GetSizeMax(pcbSize);
+        if (pcbSize)
+            DbgPrint("\t*pcbSize=%llx\n", pcbSize->QuadPart);
+        DbgPrint("CExplorerBand::GetSizeMax returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+
+// *** IWinEventHandler methods ***
+HRESULT STDMETHODCALLTYPE CExplorerBand::OnWinEvent(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult)
+{
+    HRESULT hr;
+    if (m_internalWinEventHandler)
+    {
+        if (m_OnWinEventShown)
+            return m_internalWinEventHandler->OnWinEvent(hWnd, uMsg, wParam, lParam, theResult);
+        m_OnWinEventShown = TRUE;
+
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::OnWinEvent(HWND hWnd=%x, UINT uMsg=%x, WPARAM wParam=%x, LPARAM lParam=%x, LRESULT *theResult=%p)\n",
+                 hWnd, uMsg, wParam, lParam, theResult);
+        hr = m_internalWinEventHandler->OnWinEvent(hWnd, uMsg, wParam, lParam, theResult);
+        if (theResult)
+            DbgPrint("\t*theResult=%x\n", *theResult);
+        DbgPrint("CExplorerBand::OnWinEvent returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::IsWindowOwner(HWND hWnd)
+{
+    HRESULT hr;
+    if (m_internalWinEventHandler)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::IsWindowOwner(HWND hWnd=%x)\n", hWnd);
+        hr = m_internalWinEventHandler->IsWindowOwner(hWnd);
+        DbgPrint("CExplorerBand::IsWindowOwner returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+
+// *** IBandNavigate methods ***
+HRESULT STDMETHODCALLTYPE CExplorerBand::Select(long paramC)
+{
+    HRESULT hr;
+    if (m_internalBandNavigate)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::Select(long paramC=%x)\n", paramC);
+        hr = m_internalBandNavigate->Select(paramC);
+        DbgPrint("CExplorerBand::Select returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+
+// *** INamespaceProxy ***
+HRESULT STDMETHODCALLTYPE CExplorerBand::GetNavigateTarget(long paramC, long param10, long param14)
+{
+    HRESULT hr;
+    if (m_internalNamespaceProxy)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::GetNavigateTarget(long paramC=%08x, long param10=%08x, long param14=%08x)\n",
+                 paramC, param10, param14);
+        hr = m_internalNamespaceProxy->GetNavigateTarget(paramC, param10, param14);
+        DbgPrint("CExplorerBand::GetNavigateTarget returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::Invoke(long paramC)
+{
+    HRESULT hr;
+    if (m_internalNamespaceProxy)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::Invoke(long paramC=%08x)\n", paramC);
+        hr = m_internalNamespaceProxy->Invoke(paramC);
+        DbgPrint("CExplorerBand::Invoke returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::OnSelectionChanged(long paramC)
+{
+    HRESULT hr;
+    if (m_internalNamespaceProxy)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::OnSelectionChanged(long paramC=%08x)\n", paramC);
+        hr = m_internalNamespaceProxy->OnSelectionChanged(paramC);
+        DbgPrint("CExplorerBand::OnSelectionChanged returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::RefreshFlags(long paramC, long param10, long param14)
+{
+    HRESULT hr;
+    if (m_internalNamespaceProxy)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::RefreshFlags(long paramC=%08x, long param10=%08x, long param14=%08x)\n",
+                 paramC, param10, param14);
+        hr = m_internalNamespaceProxy->RefreshFlags(paramC, param10, param14);
+        DbgPrint("CExplorerBand::RefreshFlags returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::CacheItem(long paramC)
+{
+    HRESULT hr;
+    if (m_internalNamespaceProxy)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::CacheItem(long paramC=%08x)\n", paramC);
+        hr = m_internalNamespaceProxy->CacheItem(paramC);
+        DbgPrint("CExplorerBand::CacheItem returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+
+// *** IDispatch methods ***
+HRESULT STDMETHODCALLTYPE CExplorerBand::GetTypeInfoCount(UINT *pctinfo)
+{
+    HRESULT hr;
+    if (m_internalDispatch)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::GetTypeInfoCount(UINT *pctinfo=%p)\n", pctinfo);
+        hr = m_internalDispatch->GetTypeInfoCount(pctinfo);
+        if (pctinfo)
+            DbgPrint("\t*pctinfo=%08x\n", *pctinfo);
+        DbgPrint("CExplorerBand::GetTypeInfoCount returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
+{
+    HRESULT hr;
+    if (m_internalDispatch)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::GetTypeInfo(UINT iTInfo=%u, LCID lcid=%08x, ITypeInfo **ppTInfo=%p)\n",
+                 iTInfo, lcid, ppTInfo);
+        hr = m_internalDispatch->GetTypeInfo(iTInfo, lcid, ppTInfo);
+        if (ppTInfo)
+            DbgPrint("\t*ppTInfo=%08x\n", *ppTInfo);
+        DbgPrint("CExplorerBand::GetTypeInfo returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
+{
+    HRESULT hr;
+    if (m_internalDispatch)
+    {
+        DbgPrint("HRESULT STDMETHODCALLTYPE CExplorerBand::GetIDsOfNames(REFIID riid=%s, LPOLESTR *rgszNames=%S, UINT cNames=%u, LCID lcid=%08x, DISPID *rgDispId=%p)\n",
+                 wine_dbgstr_guid(&riid), rgszNames, cNames, lcid, rgDispId);
+        hr = m_internalDispatch->GetIDsOfNames(riid, rgszNames, cNames, lcid, rgDispId);
+        if (rgDispId && SUCCEEDED(hr))
+        {
+            for (UINT i = 0; i < cNames; i++)
+            {
+                DbgPrint("\trgDispId[%d]=%08x\n", rgDispId[i]);
+            }
+        }
+        DbgPrint("CExplorerBand::GetTypeInfo returning %08lx\n", hr);
+        return hr;
+    }
+
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+
+HRESULT STDMETHODCALLTYPE CExplorerBand::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
+{
+    UNIMPLEMENTED;
+    return E_NOTIMPL;
+}
+

reactos/dll/win32/browseui/explorerband.h

@@ -0,0 +1,227 @@
+#pragma once
+
+#if 0
+// Is this a CToolsBand that implements a toolbar?
+class CToolBand :
+    public CComObjectRootEx<CComMultiThreadModelNoCS>,
+    public IDeskBand,
+    public IObjectWithSite,
+    public IInputObject,
+    public IPersistStream,
+    public IOleCommandTarget,
+    public IServiceProvider
+{
+public:
+    // *** IOleWindow methods ***
+    virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND *lphwnd);
+    virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode);
+
+    // *** IDockingWindow methods ***
+    virtual HRESULT STDMETHODCALLTYPE CloseDW(DWORD dwReserved);
+    virtual HRESULT STDMETHODCALLTYPE ResizeBorderDW(const RECT *prcBorder, IUnknown *punkToolbarSite, BOOL fReserved);
+    virtual HRESULT STDMETHODCALLTYPE ShowDW(BOOL fShow);
+
+    // *** IDeskBand methods ***
+    virtual HRESULT STDMETHODCALLTYPE GetBandInfo(DWORD dwBandID, DWORD dwViewMode, DESKBANDINFO *pdbi);
+
+    // *** IObjectWithSite methods ***
+    virtual HRESULT STDMETHODCALLTYPE SetSite(IUnknown *pUnkSite);
+    virtual HRESULT STDMETHODCALLTYPE GetSite(REFIID riid, void **ppvSite);
+
+    // *** IOleCommandTarget methods ***
+    virtual HRESULT STDMETHODCALLTYPE QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds [], OLECMDTEXT *pCmdText);
+    virtual HRESULT STDMETHODCALLTYPE Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut);
+
+    // *** IServiceProvider methods ***
+    virtual HRESULT STDMETHODCALLTYPE QueryService(REFGUID guidService, REFIID riid, void **ppvObject);
+
+    // *** IInputObject methods ***
+    virtual HRESULT STDMETHODCALLTYPE UIActivateIO(BOOL fActivate, LPMSG lpMsg);
+    virtual HRESULT STDMETHODCALLTYPE HasFocusIO();
+    virtual HRESULT STDMETHODCALLTYPE TranslateAcceleratorIO(LPMSG lpMsg);
+
+    // *** IPersist methods ***
+    virtual HRESULT STDMETHODCALLTYPE GetClassID(CLSID *pClassID);
+
+    // *** IPersistStream methods ***
+    virtual HRESULT STDMETHODCALLTYPE IsDirty();
+    virtual HRESULT STDMETHODCALLTYPE Load(IStream *pStm);
+    virtual HRESULT STDMETHODCALLTYPE Save(IStream *pStm, BOOL fClearDirty);
+    virtual HRESULT STDMETHODCALLTYPE GetSizeMax(ULARGE_INTEGER *pcbSize);
+
+    BEGIN_COM_MAP(CToolBand)
+        COM_INTERFACE_ENTRY2_IID(IID_IOleWindow, IOleWindow, IDeskBand)
+        COM_INTERFACE_ENTRY2_IID(IID_IDockingWindow, IDockingWindow, IDeskBand)
+        COM_INTERFACE_ENTRY_IID(IID_IDeskBand, IDeskBand)
+        COM_INTERFACE_ENTRY_IID(IID_IObjectWithSite, IObjectWithSite)
+        COM_INTERFACE_ENTRY_IID(IID_IOleCommandTarget, IOleCommandTarget)
+        COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider)
+        COM_INTERFACE_ENTRY_IID(IID_IInputObject, IInputObject)
+        COM_INTERFACE_ENTRY2_IID(IID_IPersist, IPersist, IPersistStream)
+        COM_INTERFACE_ENTRY_IID(IID_IPersistStream, IPersistStream)
+    END_COM_MAP()
+};
+
+class CNSCBand :
+    public CToolBand,
+    public IDeskBand,
+    public IObjectWithSite,
+    public IInputObject,
+    public IPersistStream,
+    public IOleCommandTarget,
+    public IServiceProvider,
+    public IBandNavigate,
+    public IWinEventHandler,
+    public INamespaceProxy
+{
+public:
+    // *** IWinEventHandler methods ***
+    virtual HRESULT STDMETHODCALLTYPE OnWinEvent(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult);
+    virtual HRESULT STDMETHODCALLTYPE IsWindowOwner(HWND hWnd);
+
+    // *** IBandNavigate methods ***
+    virtual HRESULT STDMETHODCALLTYPE Select(long paramC);
+
+    // *** INamespaceProxy ***
+    virtual HRESULT STDMETHODCALLTYPE GetNavigateTarget(long paramC, long param10, long param14);
+    virtual HRESULT STDMETHODCALLTYPE Invoke(long paramC);
+    virtual HRESULT STDMETHODCALLTYPE OnSelectionChanged(long paramC);
+    virtual HRESULT STDMETHODCALLTYPE RefreshFlags(long paramC, long param10, long param14);
+    virtual HRESULT STDMETHODCALLTYPE CacheItem(long paramC);
+
+    BEGIN_COM_MAP(CNSCBand)
+        COM_INTERFACE_ENTRY_IID(IID_IWinEventHandler, IWinEventHandler)
+        COM_INTERFACE_ENTRY_IID(IID_IBandNavigate, IBandNavigate)
+        COM_INTERFACE_ENTRY_IID(IID_INamespaceProxy, INamespaceProxy)
+#if 0
+        COM_INTERFACE_ENTRY_CHAIN(CToolBand)
+#else
+        COM_INTERFACE_ENTRY2_IID(IID_IOleWindow, IOleWindow, IDeskBand)
+        COM_INTERFACE_ENTRY2_IID(IID_IDockingWindow, IDockingWindow, IDeskBand)
+        COM_INTERFACE_ENTRY_IID(IID_IInputObject, IInputObject)
+        COM_INTERFACE_ENTRY_IID(IID_IOleCommandTarget, IOleCommandTarget)
+        COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider)
+        COM_INTERFACE_ENTRY_IID(IID_IPersistStream, IPersistStream)
+        COM_INTERFACE_ENTRY2_IID(IID_IPersist, IPersist, IPersistStream)
+        COM_INTERFACE_ENTRY_IID(IID_IObjectWithSite, IObjectWithSite)
+#endif
+    END_COM_MAP()
+};
+#endif
+
+class CExplorerBand :
+    public CComCoClass<CExplorerBand, &CLSID_ExplorerBand>,
+#if 0
+    public CNSCBand,
+#else
+    public CComObjectRootEx<CComMultiThreadModelNoCS>,
+#endif
+    public IDeskBand,
+    public IObjectWithSite,
+    public IInputObject,
+    public IPersistStream,
+    public IOleCommandTarget,
+    public IServiceProvider,
+    public IBandNavigate,
+    public IWinEventHandler,
+    public INamespaceProxy
+{
+    CComPtr<IUnknown> m_internalBand;
+
+    CComPtr<IDeskBand> m_internalDeskBand;
+    CComPtr<IObjectWithSite> m_internalObjectWithSite;
+    CComPtr<IInputObject> m_internalInputObject;
+    CComPtr<IPersistStream> m_internalPersistStream;
+    CComPtr<IOleCommandTarget> m_internalOleCommandTarget;
+    CComPtr<IServiceProvider> m_internalServiceProvider;
+    CComPtr<IBandNavigate> m_internalBandNavigate;
+    CComPtr<IWinEventHandler> m_internalWinEventHandler;
+    CComPtr<INamespaceProxy> m_internalNamespaceProxy;
+    CComPtr<IDispatch> m_internalDispatch;
+
+    bool m_OnWinEventShown;
+public:
+    CExplorerBand();
+    virtual ~CExplorerBand();
+
+    // *** IOleWindow methods ***
+    virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND *lphwnd);
+    virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode);
+
+    // *** IDockingWindow methods ***
+    virtual HRESULT STDMETHODCALLTYPE CloseDW(DWORD dwReserved);
+    virtual HRESULT STDMETHODCALLTYPE ResizeBorderDW(const RECT *prcBorder, IUnknown *punkToolbarSite, BOOL fReserved);
+    virtual HRESULT STDMETHODCALLTYPE ShowDW(BOOL fShow);
+
+    // *** IDeskBand methods ***
+    virtual HRESULT STDMETHODCALLTYPE GetBandInfo(DWORD dwBandID, DWORD dwViewMode, DESKBANDINFO *pdbi);
+
+    // *** IObjectWithSite methods ***
+    virtual HRESULT STDMETHODCALLTYPE SetSite(IUnknown *pUnkSite);
+    virtual HRESULT STDMETHODCALLTYPE GetSite(REFIID riid, void **ppvSite);
+
+    // *** IOleCommandTarget methods ***
+    virtual HRESULT STDMETHODCALLTYPE QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds [], OLECMDTEXT *pCmdText);
+    virtual HRESULT STDMETHODCALLTYPE Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut);
+
+    // *** IServiceProvider methods ***
+    virtual HRESULT STDMETHODCALLTYPE QueryService(REFGUID guidService, REFIID riid, void **ppvObject);
+
+    // *** IInputObject methods ***
+    virtual HRESULT STDMETHODCALLTYPE UIActivateIO(BOOL fActivate, LPMSG lpMsg);
+    virtual HRESULT STDMETHODCALLTYPE HasFocusIO();
+    virtual HRESULT STDMETHODCALLTYPE TranslateAcceleratorIO(LPMSG lpMsg);
+
+    // *** IPersist methods ***
+    virtual HRESULT STDMETHODCALLTYPE GetClassID(CLSID *pClassID);
+
+    // *** IPersistStream methods ***
+    virtual HRESULT STDMETHODCALLTYPE IsDirty();
+    virtual HRESULT STDMETHODCALLTYPE Load(IStream *pStm);
+    virtual HRESULT STDMETHODCALLTYPE Save(IStream *pStm, BOOL fClearDirty);
+    virtual HRESULT STDMETHODCALLTYPE GetSizeMax(ULARGE_INTEGER *pcbSize);
+
+    // *** IWinEventHandler methods ***
+    virtual HRESULT STDMETHODCALLTYPE OnWinEvent(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult);
+    virtual HRESULT STDMETHODCALLTYPE IsWindowOwner(HWND hWnd);
+
+    // *** IBandNavigate methods ***
+    virtual HRESULT STDMETHODCALLTYPE Select(long paramC);
+
+    // *** INamespaceProxy ***
+    virtual HRESULT STDMETHODCALLTYPE GetNavigateTarget(long paramC, long param10, long param14);
+    virtual HRESULT STDMETHODCALLTYPE Invoke(long paramC);
+    virtual HRESULT STDMETHODCALLTYPE OnSelectionChanged(long paramC);
+    virtual HRESULT STDMETHODCALLTYPE RefreshFlags(long paramC, long param10, long param14);
+    virtual HRESULT STDMETHODCALLTYPE CacheItem(long paramC);
+
+    // *** IDispatch methods ***
+    virtual HRESULT STDMETHODCALLTYPE GetTypeInfoCount(UINT *pctinfo);
+    virtual HRESULT STDMETHODCALLTYPE GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo);
+    virtual HRESULT STDMETHODCALLTYPE GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId);
+    virtual HRESULT STDMETHODCALLTYPE Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr);
+
+    DECLARE_REGISTRY_RESOURCEID(IDR_EXPLORERBAND)
+    DECLARE_NOT_AGGREGATABLE(CExplorerBand)
+
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+    BEGIN_COM_MAP(CExplorerBand)
+        COM_INTERFACE_ENTRY_IID(IID_IDispatch, IDeskBand)
+        COM_INTERFACE_ENTRY_IID(IID_IWinEventHandler, IWinEventHandler)
+        COM_INTERFACE_ENTRY_IID(IID_IBandNavigate, IBandNavigate)
+        COM_INTERFACE_ENTRY_IID(IID_INamespaceProxy, INamespaceProxy)
+        COM_INTERFACE_ENTRY2_IID(IID_IOleWindow, IOleWindow, IDeskBand)
+        COM_INTERFACE_ENTRY2_IID(IID_IDockingWindow, IDockingWindow, IDeskBand)
+        COM_INTERFACE_ENTRY_IID(IID_IDeskBand, IDeskBand)
+        COM_INTERFACE_ENTRY_IID(IID_IObjectWithSite, IObjectWithSite)
+        COM_INTERFACE_ENTRY_IID(IID_IOleCommandTarget, IOleCommandTarget)
+        COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider)
+        COM_INTERFACE_ENTRY_IID(IID_IInputObject, IInputObject)
+        COM_INTERFACE_ENTRY2_IID(IID_IPersist, IPersist, IPersistStream)
+        COM_INTERFACE_ENTRY_IID(IID_IPersistStream, IPersistStream)
+    END_COM_MAP()
+};
+
+extern "C"
+HRESULT WINAPI CExplorerBand_Constructor(REFIID riid, LPVOID *ppv);

reactos/dll/win32/browseui/precomp.h

@@ -41,6 +41,7 @@
 #include "commonbrowser.h"
 #include "globalfoldersettings.h"
 #include "regtreeoptions.h"
+#include "explorerband.h"
 #include <stdio.h>
 
 WINE_DEFAULT_DEBUG_CHANNEL(browseui);

reactos/dll/win32/browseui/res/explorerband.rgs

@@ -0,0 +1,13 @@
+HKCR
+{
+	NoRemove CLSID
+	{
+		ForceRemove {EFA24E64-B078-11D0-89E4-00C04FC9E26E} = s 'Explorer TreeView Band'
+		{
+			InprocServer32 = s '%MODULE%'
+			{
+				val ThreadingModel = s 'Apartment'
+			}
+		}
+	}
+}

reactos/dll/win32/browseui/resource.h

@@ -77,6 +77,7 @@
 #define IDR_INTERNETTOOLBAR      136
 #define IDR_GLOBALFOLDERSETTINGS 137
 #define IDR_REGTREEOPTIONS       138
+#define IDR_EXPLORERBAND         139
 
 #define IDS_SMALLICONS           12301
 #define IDS_LARGEICONS           12302

reactos/dll/win32/browseui/shellbrowser.cpp

@@ -24,6 +24,8 @@
 #include <htiframe.h>
 #include <strsafe.h>
 
+#define USE_CUSTOM_EXPLORERBAND 1
+
 extern "C"
 BOOL WINAPI Shell_GetImageLists(
     _Out_  HIMAGELIST *phiml,
@@ -1179,9 +1181,24 @@ HRESULT CShellBrowser::ShowBand(const CLSID &classID, bool vertical)
     hResult = GetBaseBar(vertical, (IUnknown **)&theBaseBar);
     if (FAILED_UNEXPECTEDLY(hResult))
         return hResult;
-    hResult = CoCreateInstance(classID, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IUnknown, &newBand));
-    if (FAILED_UNEXPECTEDLY(hResult))
-        return hResult;
+
+#if USE_CUSTOM_EXPLORERBAND
+    TRACE("ShowBand called for CLSID %s, vertical=%d...\n", wine_dbgstr_guid(&classID), vertical);
+    if (IsEqualCLSID(CLSID_ExplorerBand, classID))
+    {
+        TRACE("CLSID_ExplorerBand requested, building internal band.\n");
+        hResult = CExplorerBand_Constructor(IID_PPV_ARG(IUnknown, &newBand));
+        if (FAILED_UNEXPECTEDLY(hResult))
+            return hResult;
+    }
+    else
+#endif
+    {
+        TRACE("A different CLSID requested, using CoCreateInstance.\n");
+        hResult = CoCreateInstance(classID, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IUnknown, &newBand));
+        if (FAILED_UNEXPECTEDLY(hResult))
+            return hResult;
+    }
     hResult = theBaseBar->QueryInterface(IID_PPV_ARG(IDeskBar, &deskBar));
     if (FAILED_UNEXPECTEDLY(hResult))
         return hResult;
@@ -1199,6 +1216,7 @@ HRESULT CShellBrowser::ShowBand(const CLSID &classID, bool vertical)
     hResult = dockingWindow->ShowDW(TRUE);
     if (FAILED_UNEXPECTEDLY(hResult))
         return hResult;
+
     return S_OK;
 }