base/shell/rshell/CMenuBand.cpp

   1 /*
   2 * Shell Menu Band
   3 *
   4 * Copyright 2014 David Quintana
   5 *
   6 * This library is free software; you can redistribute it and/or
   7 * modify it under the terms of the GNU Lesser General Public
   8 * License as published by the Free Software Foundation; either
   9 * version 2.1 of the License, or (at your option) any later version.
  10 *
  11 * This library is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 * Lesser General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU Lesser General Public
  17 * License along with this library; if not, write to the Free Software
  18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19 */
  20 #include "precomp.h"
  21 #include "wraplog.h"
  22 #include <windowsx.h>
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(CMenuBand);
  25
  26 #define WRAP_LOG 1
  27
  28 #define TBSTYLE_EX_VERTICAL 4
  29
  30 #define TIMERID_HOTTRACK 1
  31 #define SUBCLASS_ID_MENUBAND 1
  32
  33 extern "C" BOOL WINAPI Shell_GetImageLists(HIMAGELIST * lpBigList, HIMAGELIST * lpSmallList);
  34
  35 class CMenuBand;
  36
  37 class CMenuToolbarBase
  38 {
  39 public:
  40     CMenuToolbarBase(CMenuBand *menuBand);
  41     virtual ~CMenuToolbarBase() {}
  42
  43     HRESULT CreateToolbar(HWND hwndParent, DWORD dwFlags);
  44     HRESULT GetWindow(HWND *phwnd);
  45     HRESULT ShowWindow(BOOL fShow);
  46     HRESULT Close();
  47
  48     BOOL IsWindowOwner(HWND hwnd) { return m_hwnd && m_hwnd == hwnd; }
  49
  50     virtual HRESULT FillToolbar() = 0;
  51     virtual HRESULT PopupItem(UINT uItem) = 0;
  52     virtual HRESULT HasSubMenu(UINT uItem) = 0;
  53     virtual HRESULT OnCommand(WPARAM wParam, LPARAM lParam, LRESULT *theResult);
  54     virtual HRESULT OnContextMenu(NMMOUSE * rclick) = 0;
  55
  56     HRESULT OnHotItemChange(const NMTBHOTITEM * hot);
  57
  58     HRESULT PopupSubMenu(UINT index, IShellMenu* childShellMenu);
  59     HRESULT DoContextMenu(IContextMenu* contextMenu);
  60
  61     static LRESULT CALLBACK s_SubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  62 protected:
  63
  64     static const UINT WM_USER_SHOWPOPUPMENU = WM_USER + 1;
  65
  66     LRESULT CALLBACK SubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  67
  68     CMenuBand *m_menuBand;
  69     HWND m_hwnd;
  70     DWORD m_dwMenuFlags;
  71     UINT m_hotItem;
  72     WNDPROC m_SubclassOld;
  73 };
  74
  75 class CMenuStaticToolbar : public CMenuToolbarBase
  76 {
  77 public:
  78     CMenuStaticToolbar(CMenuBand *menuBand);
  79     virtual ~CMenuStaticToolbar() {}
  80
  81     HRESULT SetMenu(HMENU hmenu, HWND hwnd, DWORD dwFlags);
  82     HRESULT GetMenu(HMENU *phmenu, HWND *phwnd, DWORD *pdwFlags);
  83
  84     virtual HRESULT FillToolbar();
  85     virtual HRESULT PopupItem(UINT uItem);
  86     virtual HRESULT HasSubMenu(UINT uItem);
  87     virtual HRESULT OnCommand(WPARAM wParam, LPARAM lParam, LRESULT *theResult);
  88     virtual HRESULT OnContextMenu(NMMOUSE * rclick);
  89
  90 private:
  91     HMENU m_hmenu;
  92 };
  93
  94 class CMenuSFToolbar : public CMenuToolbarBase
  95 {
  96 public:
  97     CMenuSFToolbar(CMenuBand *menuBand);
  98     virtual ~CMenuSFToolbar();
  99
 100     HRESULT SetShellFolder(IShellFolder *psf, LPCITEMIDLIST pidlFolder, HKEY hKey, DWORD dwFlags);
 101     HRESULT GetShellFolder(DWORD *pdwFlags, LPITEMIDLIST *ppidl, REFIID riid, void **ppv);
 102
 103     virtual HRESULT FillToolbar();
 104     virtual HRESULT PopupItem(UINT uItem);
 105     virtual HRESULT HasSubMenu(UINT uItem);
 106     virtual HRESULT OnCommand(WPARAM wParam, LPARAM lParam, LRESULT *theResult);
 107     virtual HRESULT OnContextMenu(NMMOUSE * rclick);
 108
 109 private:
 110     LPITEMIDLIST GetPidlFromId(UINT uItem, INT* pIndex);
 111
 112     IShellFolder * m_shellFolder;
 113     LPCITEMIDLIST m_idList;
 114     HKEY m_hKey;
 115 };
 116
 117 class CMenuBand :
 118     public CComCoClass<CMenuBand>,
 119     public CComObjectRootEx<CComMultiThreadModelNoCS>,
 120     public IDeskBand,
 121     public IObjectWithSite,
 122     public IInputObject,
 123     public IPersistStream,
 124     public IOleCommandTarget,
 125     public IServiceProvider,
 126     public IMenuPopup,
 127     public IMenuBand,
 128     public IShellMenu2,
 129     public IWinEventHandler,
 130     public IShellMenuAcc
 131 {
 132 public:
 133     CMenuBand();
 134     ~CMenuBand();
 135
 136 private:
 137 #if WRAP_LOG
 138     IUnknown          * m_IUnknown;
 139     IDeskBand         * m_IDeskBand;
 140     IDockingWindow    * m_IDockingWindow;
 141     IOleWindow        * m_IOleWindow;
 142     IObjectWithSite   * m_IObjectWithSite;
 143     IInputObject      * m_IInputObject;
 144     IPersistStream    * m_IPersistStream;
 145     IPersist          * m_IPersist;
 146     IOleCommandTarget * m_IOleCommandTarget;
 147     IServiceProvider  * m_IServiceProvider;
 148     IMenuPopup        * m_IMenuPopup;
 149     IDeskBar          * m_IDeskBar;
 150     IMenuBand         * m_IMenuBand;
 151     IShellMenu2       * m_IShellMenu2;
 152     IShellMenu        * m_IShellMenu;
 153     IWinEventHandler  * m_IWinEventHandler;
 154     IShellMenuAcc     * m_IShellMenuAcc;
 155 #else
 156     IOleWindow *m_site;
 157     IShellMenuCallback *m_psmc;
 158
 159     CMenuStaticToolbar *m_staticToolbar;
 160     CMenuSFToolbar *m_SFToolbar;
 161
 162     UINT m_uId;
 163     UINT m_uIdAncestor;
 164     DWORD m_dwFlags;
 165     PVOID m_UserData;
 166     HMENU m_hmenu;
 167 #endif
 168
 169     BOOL m_useBigIcons;
 170
 171 public:
 172
 173     // *** IDeskBand methods ***
 174     virtual HRESULT STDMETHODCALLTYPE GetBandInfo(DWORD dwBandID, DWORD dwViewMode, DESKBANDINFO *pdbi);
 175
 176     // *** IDockingWindow methods ***
 177     virtual HRESULT STDMETHODCALLTYPE ShowDW(BOOL fShow);
 178     virtual HRESULT STDMETHODCALLTYPE CloseDW(DWORD dwReserved);
 179     virtual HRESULT STDMETHODCALLTYPE ResizeBorderDW(LPCRECT prcBorder, IUnknown *punkToolbarSite, BOOL fReserved);
 180
 181     // *** IOleWindow methods ***
 182     virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND *phwnd);
 183     virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode);
 184
 185     // *** IObjectWithSite methods ***
 186     virtual HRESULT STDMETHODCALLTYPE SetSite(IUnknown *pUnkSite);
 187     virtual HRESULT STDMETHODCALLTYPE GetSite(REFIID riid, PVOID *ppvSite);
 188
 189     // *** IInputObject methods ***
 190     virtual HRESULT STDMETHODCALLTYPE UIActivateIO(BOOL fActivate, LPMSG lpMsg);
 191     virtual HRESULT STDMETHODCALLTYPE HasFocusIO();
 192     virtual HRESULT STDMETHODCALLTYPE TranslateAcceleratorIO(LPMSG lpMsg);
 193
 194     // *** IPersistStream methods ***
 195     virtual HRESULT STDMETHODCALLTYPE IsDirty();
 196     virtual HRESULT STDMETHODCALLTYPE Load(IStream *pStm);
 197     virtual HRESULT STDMETHODCALLTYPE Save(IStream *pStm, BOOL fClearDirty);
 198     virtual HRESULT STDMETHODCALLTYPE GetSizeMax(ULARGE_INTEGER *pcbSize);
 199
 200     // *** IPersist methods ***
 201     virtual HRESULT STDMETHODCALLTYPE GetClassID(CLSID *pClassID);
 202
 203     // *** IOleCommandTarget methods ***
 204     virtual HRESULT STDMETHODCALLTYPE QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds [], OLECMDTEXT *pCmdText);
 205     virtual HRESULT STDMETHODCALLTYPE Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut);
 206
 207     // *** IServiceProvider methods ***
 208     virtual HRESULT STDMETHODCALLTYPE QueryService(REFGUID guidService, REFIID riid, void **ppvObject);
 209
 210     // *** IMenuPopup methods ***
 211     virtual HRESULT STDMETHODCALLTYPE Popup(POINTL *ppt, RECTL *prcExclude, MP_POPUPFLAGS dwFlags);
 212     virtual HRESULT STDMETHODCALLTYPE OnSelect(DWORD dwSelectType);
 213     virtual HRESULT STDMETHODCALLTYPE SetSubMenu(IMenuPopup *pmp, BOOL fSet);
 214
 215     // *** IDeskBar methods ***
 216     virtual HRESULT STDMETHODCALLTYPE SetClient(IUnknown *punkClient);
 217     virtual HRESULT STDMETHODCALLTYPE GetClient(IUnknown **ppunkClient);
 218     virtual HRESULT STDMETHODCALLTYPE OnPosRectChangeDB(RECT *prc);
 219
 220     // *** IMenuBand methods ***
 221     virtual HRESULT STDMETHODCALLTYPE IsMenuMessage(MSG *pmsg);
 222     virtual HRESULT STDMETHODCALLTYPE TranslateMenuMessage(MSG *pmsg, LRESULT *plRet);
 223
 224     // *** IShellMenu methods ***
 225     virtual HRESULT STDMETHODCALLTYPE Initialize(IShellMenuCallback *psmc, UINT uId, UINT uIdAncestor, DWORD dwFlags);
 226     virtual HRESULT STDMETHODCALLTYPE GetMenuInfo(IShellMenuCallback **ppsmc, UINT *puId, UINT *puIdAncestor, DWORD *pdwFlags);
 227     virtual HRESULT STDMETHODCALLTYPE SetShellFolder(IShellFolder *psf, LPCITEMIDLIST pidlFolder, HKEY hKey, DWORD dwFlags);
 228     virtual HRESULT STDMETHODCALLTYPE GetShellFolder(DWORD *pdwFlags, LPITEMIDLIST *ppidl, REFIID riid, void **ppv);
 229     virtual HRESULT STDMETHODCALLTYPE SetMenu(HMENU hmenu, HWND hwnd, DWORD dwFlags);
 230     virtual HRESULT STDMETHODCALLTYPE GetMenu(HMENU *phmenu, HWND *phwnd, DWORD *pdwFlags);
 231     virtual HRESULT STDMETHODCALLTYPE InvalidateItem(LPSMDATA psmd, DWORD dwFlags);
 232     virtual HRESULT STDMETHODCALLTYPE GetState(LPSMDATA psmd);
 233     virtual HRESULT STDMETHODCALLTYPE SetMenuToolbar(IUnknown *punk, DWORD dwFlags);
 234
 235     // *** IWinEventHandler methods ***
 236     virtual HRESULT STDMETHODCALLTYPE OnWinEvent(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult);
 237     virtual HRESULT STDMETHODCALLTYPE IsWindowOwner(HWND hWnd);
 238
 239     // *** IShellMenu2 methods ***
 240     virtual HRESULT STDMETHODCALLTYPE GetSubMenu(THIS);
 241     virtual HRESULT STDMETHODCALLTYPE SetToolbar(THIS);
 242     virtual HRESULT STDMETHODCALLTYPE SetMinWidth(THIS);
 243     virtual HRESULT STDMETHODCALLTYPE SetNoBorder(THIS);
 244     virtual HRESULT STDMETHODCALLTYPE SetTheme(THIS);
 245
 246     // *** IShellMenuAcc methods ***
 247     virtual HRESULT STDMETHODCALLTYPE GetTop(THIS);
 248     virtual HRESULT STDMETHODCALLTYPE GetBottom(THIS);
 249     virtual HRESULT STDMETHODCALLTYPE GetTracked(THIS);
 250     virtual HRESULT STDMETHODCALLTYPE GetParentSite(THIS);
 251     virtual HRESULT STDMETHODCALLTYPE GetState(THIS);
 252     virtual HRESULT STDMETHODCALLTYPE DoDefaultAction(THIS);
 253     virtual HRESULT STDMETHODCALLTYPE IsEmpty(THIS);
 254
 255     HRESULT CallCBWithId(UINT Id, UINT uMsg, WPARAM wParam, LPARAM lParam);
 256     HRESULT CallCBWithPidl(LPITEMIDLIST pidl, UINT uMsg, WPARAM wParam, LPARAM lParam);
 257
 258     BOOL UseBigIcons() {
 259         return m_useBigIcons;
 260     }
 261
 262     DECLARE_NOT_AGGREGATABLE(CMenuBand)
 263     DECLARE_PROTECT_FINAL_CONSTRUCT()
 264
 265     BEGIN_COM_MAP(CMenuBand)
 266         COM_INTERFACE_ENTRY_IID(IID_IDeskBar, IMenuPopup)
 267         COM_INTERFACE_ENTRY_IID(IID_IShellMenu, IShellMenu)
 268         COM_INTERFACE_ENTRY_IID(IID_IOleCommandTarget, IOleCommandTarget)
 269         COM_INTERFACE_ENTRY_IID(IID_IOleWindow, IDeskBand)
 270         COM_INTERFACE_ENTRY_IID(IID_IDockingWindow, IDockingWindow)
 271         COM_INTERFACE_ENTRY_IID(IID_IDeskBand, IDeskBand)
 272         COM_INTERFACE_ENTRY_IID(IID_IObjectWithSite, IObjectWithSite)
 273         COM_INTERFACE_ENTRY_IID(IID_IInputObject, IInputObject)
 274         COM_INTERFACE_ENTRY_IID(IID_IPersistStream, IPersistStream)
 275         COM_INTERFACE_ENTRY_IID(IID_IPersist, IPersistStream)
 276         COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider)
 277         COM_INTERFACE_ENTRY_IID(IID_IMenuPopup, IMenuPopup)
 278         COM_INTERFACE_ENTRY_IID(IID_IMenuBand, IMenuBand)
 279         COM_INTERFACE_ENTRY_IID(IID_IShellMenu2, IShellMenu2)
 280         COM_INTERFACE_ENTRY_IID(IID_IWinEventHandler, IWinEventHandler)
 281         COM_INTERFACE_ENTRY_IID(IID_IShellMenuAcc, IShellMenuAcc)
 282     END_COM_MAP()
 283
 284 private:
 285     HRESULT _CallCB(UINT uMsg, WPARAM wParam, LPARAM lParam, UINT id = 0, LPITEMIDLIST pidl = NULL);
 286 };
 287
 288 extern "C"
 289 HRESULT CMenuBand_Constructor(REFIID riid, LPVOID *ppv)
 290 {
 291     *ppv = NULL;
 292
 293     CMenuBand * site = new CComObject<CMenuBand>();
 294
 295     if (!site)
 296         return E_OUTOFMEMORY;
 297
 298     HRESULT hr = site->QueryInterface(riid, ppv);
 299
 300     if (FAILED(hr))
 301         site->Release();
 302
 303     return hr;
 304 }
 305
 306
 307 #if WRAP_LOG
 308 CMenuBand::CMenuBand()
 309 {
 310     HRESULT hr;
 311     WrapLogOpen();
 312
 313     hr = CoCreateInstance(CLSID_MenuBand, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IShellMenu, &m_IShellMenu));
 314     hr = m_IShellMenu->QueryInterface(IID_PPV_ARG(IUnknown, &m_IUnknown));
 315     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IDeskBand, &m_IDeskBand));
 316     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IDockingWindow, &m_IDockingWindow));
 317     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IOleWindow, &m_IOleWindow));
 318     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IObjectWithSite, &m_IObjectWithSite));
 319     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IInputObject, &m_IInputObject));
 320     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IPersistStream, &m_IPersistStream));
 321     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IPersist, &m_IPersist));
 322     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &m_IOleCommandTarget));
 323     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IServiceProvider, &m_IServiceProvider));
 324     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IMenuPopup, &m_IMenuPopup));
 325     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IDeskBar, &m_IDeskBar));
 326     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IMenuBand, &m_IMenuBand));
 327     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IShellMenu2, &m_IShellMenu2));
 328     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IWinEventHandler, &m_IWinEventHandler));
 329     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IShellMenuAcc, &m_IShellMenuAcc));
 330 }
 331
 332 CMenuBand::~CMenuBand()
 333 {
 334     m_IUnknown->Release();
 335     m_IDeskBand->Release();
 336     m_IDockingWindow->Release();
 337     m_IOleWindow->Release();
 338     m_IObjectWithSite->Release();
 339     m_IInputObject->Release();
 340     m_IPersistStream->Release();
 341     m_IPersist->Release();
 342     m_IOleCommandTarget->Release();
 343     m_IServiceProvider->Release();
 344     m_IMenuPopup->Release();
 345     m_IDeskBar->Release();
 346     m_IMenuBand->Release();
 347     m_IShellMenu2->Release();
 348     m_IShellMenu->Release();
 349     m_IWinEventHandler->Release();
 350     m_IShellMenuAcc->Release();
 351     WrapLogClose();
 352 }
 353
 354
 355 // *** IShellMenu2 methods ***
 356 HRESULT STDMETHODCALLTYPE CMenuBand::GetSubMenu(THIS)
 357 {
 358     WrapLogEnter("CMenuBand<%p>::GetSubMenu()\n", this);
 359     HRESULT hr = m_IShellMenu2->GetSubMenu();
 360     WrapLogExit("CMenuBand::GetSubMenu() = %08x\n", hr);
 361     return hr;
 362 }
 363
 364 HRESULT STDMETHODCALLTYPE CMenuBand::SetToolbar(THIS)
 365 {
 366     WrapLogEnter("CMenuBand<%p>::SetToolbar()\n", this);
 367     HRESULT hr = m_IShellMenu2->SetToolbar();
 368     WrapLogExit("CMenuBand::SetToolbar() = %08x\n", hr);
 369     return hr;
 370 }
 371
 372 HRESULT STDMETHODCALLTYPE CMenuBand::SetMinWidth(THIS)
 373 {
 374     WrapLogEnter("CMenuBand<%p>::SetMinWidth()\n", this);
 375     HRESULT hr = m_IShellMenu2->SetMinWidth();
 376     WrapLogExit("CMenuBand::SetMinWidth() = %08x\n", hr);
 377     return hr;
 378 }
 379
 380 HRESULT STDMETHODCALLTYPE CMenuBand::SetNoBorder(THIS)
 381 {
 382     WrapLogEnter("CMenuBand<%p>::SetNoBorder()\n", this);
 383     HRESULT hr = m_IShellMenu2->SetNoBorder();
 384     WrapLogExit("CMenuBand::SetNoBorder() = %08x\n", hr);
 385     return hr;
 386 }
 387
 388 HRESULT STDMETHODCALLTYPE CMenuBand::SetTheme(THIS)
 389 {
 390     WrapLogEnter("CMenuBand<%p>::SetTheme()\n", this);
 391     HRESULT hr = m_IShellMenu2->SetTheme();
 392     WrapLogExit("CMenuBand::SetTheme() = %08x\n", hr);
 393     return hr;
 394 }
 395
 396
 397 // *** IShellMenuAcc methods ***
 398 HRESULT STDMETHODCALLTYPE CMenuBand::GetTop(THIS)
 399 {
 400     WrapLogEnter("CMenuBand<%p>::GetTop()\n", this);
 401     HRESULT hr = m_IShellMenuAcc->GetTop();
 402     WrapLogExit("CMenuBand::GetTop() = %08x\n", hr);
 403     return hr;
 404 }
 405
 406 HRESULT STDMETHODCALLTYPE CMenuBand::GetBottom(THIS)
 407 {
 408     WrapLogEnter("CMenuBand<%p>::GetBottom()\n", this);
 409     HRESULT hr = m_IShellMenuAcc->GetBottom();
 410     WrapLogExit("CMenuBand::GetBottom() = %08x\n", hr);
 411     return hr;
 412 }
 413
 414 HRESULT STDMETHODCALLTYPE CMenuBand::GetTracked(THIS)
 415 {
 416     WrapLogEnter("CMenuBand<%p>::GetBottom()\n", this);
 417     HRESULT hr = m_IShellMenuAcc->GetBottom();
 418     WrapLogExit("CMenuBand::GetBottom() = %08x\n", hr);
 419     return hr;
 420 }
 421
 422 HRESULT STDMETHODCALLTYPE CMenuBand::GetParentSite(THIS)
 423 {
 424     WrapLogEnter("CMenuBand<%p>::GetBottom()\n", this);
 425     HRESULT hr = m_IShellMenuAcc->GetBottom();
 426     WrapLogExit("CMenuBand::GetBottom() = %08x\n", hr);
 427     return hr;
 428 }
 429
 430 HRESULT STDMETHODCALLTYPE CMenuBand::GetState(THIS)
 431 {
 432     WrapLogEnter("CMenuBand<%p>::GetBottom()\n", this);
 433     HRESULT hr = m_IShellMenuAcc->GetBottom();
 434     WrapLogExit("CMenuBand::GetBottom() = %08x\n", hr);
 435     return hr;
 436 }
 437
 438 HRESULT STDMETHODCALLTYPE CMenuBand::DoDefaultAction(THIS)
 439 {
 440     WrapLogEnter("CMenuBand<%p>::GetBottom()\n", this);
 441     HRESULT hr = m_IShellMenuAcc->GetBottom();
 442     WrapLogExit("CMenuBand::GetBottom() = %08x\n", hr);
 443     return hr;
 444 }
 445
 446 HRESULT STDMETHODCALLTYPE CMenuBand::IsEmpty(THIS)
 447 {
 448     WrapLogEnter("CMenuBand<%p>::GetBottom()\n", this);
 449     HRESULT hr = m_IShellMenuAcc->GetBottom();
 450     WrapLogExit("CMenuBand::GetBottom() = %08x\n", hr);
 451     return hr;
 452 }
 453
 454 // *** IDeskBand methods ***
 455 HRESULT STDMETHODCALLTYPE CMenuBand::GetBandInfo(DWORD dwBandID, DWORD dwViewMode, DESKBANDINFO *pdbi)
 456 {
 457     WrapLogEnter("CMenuBand<%p>::GetBandInfo(DWORD dwBandID=%d, DWORD dwViewMode=%d, DESKBANDINFO *pdbi=%p)\n", this, dwBandID, dwViewMode, pdbi);
 458     HRESULT hr = m_IDeskBand->GetBandInfo(dwBandID, dwViewMode, pdbi);
 459     WrapLogExit("CMenuBand::GetBandInfo() = %08x\n", hr);
 460     return hr;
 461 }
 462
 463 // *** IDockingWindow methods ***
 464 HRESULT STDMETHODCALLTYPE CMenuBand::ShowDW(BOOL fShow)
 465 {
 466     WrapLogEnter("CMenuBand<%p>::ShowDW(BOOL fShow=%d)\n", this, fShow);
 467     HRESULT hr = m_IDockingWindow->ShowDW(fShow);
 468     WrapLogExit("CMenuBand::ShowDW() = %08x\n", hr);
 469     return hr;
 470 }
 471
 472 HRESULT STDMETHODCALLTYPE CMenuBand::CloseDW(DWORD dwReserved)
 473 {
 474     WrapLogEnter("CMenuBand<%p>::CloseDW(DWORD dwReserved=%d)\n", this, dwReserved);
 475     HRESULT hr = m_IDockingWindow->CloseDW(dwReserved);
 476     WrapLogExit("CMenuBand::CloseDW() = %08x\n", hr);
 477     return hr;
 478 }
 479
 480 HRESULT STDMETHODCALLTYPE CMenuBand::ResizeBorderDW(LPCRECT prcBorder, IUnknown *punkToolbarSite, BOOL fReserved)
 481 {
 482     WrapLogEnter("CMenuBand<%p>::ResizeBorderDW(LPCRECT prcBorder=%p, IUnknown *punkToolbarSite=%p, BOOL fReserved=%d)\n", this, prcBorder, punkToolbarSite, fReserved);
 483     if (prcBorder) WrapLogMsg("*prcBorder=%s\n", Wrap(*prcBorder));
 484     HRESULT hr = m_IDockingWindow->ResizeBorderDW(prcBorder, punkToolbarSite, fReserved);
 485     if (prcBorder) WrapLogMsg("*prcBorder=%s\n", Wrap(*prcBorder));
 486     WrapLogExit("CMenuBand::ResizeBorderDW() = %08x\n", hr);
 487     return hr;
 488 }
 489
 490 // *** IOleWindow methods ***
 491 HRESULT STDMETHODCALLTYPE CMenuBand::GetWindow(HWND *phwnd)
 492 {
 493     WrapLogEnter("CMenuBand<%p>::GetWindow(HWND *phwnd=%p)\n", this, phwnd);
 494     HRESULT hr = m_IOleWindow->GetWindow(phwnd);
 495     if (phwnd) WrapLogMsg("*phwnd=%p\n", *phwnd);
 496     WrapLogExit("CMenuBand::GetWindow() = %08x\n", hr);
 497     return hr;
 498 }
 499 HRESULT STDMETHODCALLTYPE CMenuBand::ContextSensitiveHelp(BOOL fEnterMode)
 500 {
 501     WrapLogEnter("CMenuBand<%p>::ContextSensitiveHelp(BOOL fEnterMode=%d)\n", this, fEnterMode);
 502     HRESULT hr = m_IOleWindow->ContextSensitiveHelp(fEnterMode);
 503     WrapLogExit("CMenuBand::ContextSensitiveHelp() = %08x\n", hr);
 504     return hr;
 505 }
 506
 507 // *** IWinEventHandler methods ***
 508 HRESULT STDMETHODCALLTYPE CMenuBand::OnWinEvent(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult)
 509 {
 510     //WrapLogEnter("CMenuBand<%p>::OnWinEvent(HWND hWnd=%p, UINT uMsg=%u, WPARAM wParam=%08x, LPARAM lParam=%08x, LRESULT *theResult=%p)\n", this, hWnd, uMsg, wParam, lParam, theResult);
 511     HRESULT hr = m_IWinEventHandler->OnWinEvent(hWnd, uMsg, wParam, lParam, theResult);
 512     //WrapLogExit("CMenuBand::OnWinEvent() = %08x\n", hr);
 513     return hr;
 514 }
 515
 516 HRESULT STDMETHODCALLTYPE CMenuBand::IsWindowOwner(HWND hWnd)
 517 {
 518     //WrapLogEnter("CMenuBand<%p>::IsWindowOwner(HWND hWnd=%08x)\n", this, hWnd);
 519     HRESULT hr = m_IWinEventHandler->IsWindowOwner(hWnd);
 520     //WrapLogExit("CMenuBand::IsWindowOwner() = %08x\n", hr);
 521     return hr;
 522 }
 523
 524 // *** IObjectWithSite methods ***
 525 HRESULT STDMETHODCALLTYPE CMenuBand::SetSite(IUnknown *pUnkSite)
 526 {
 527     WrapLogEnter("CMenuBand<%p>::SetSite(IUnknown *pUnkSite=%p)\n", this, pUnkSite);
 528     HRESULT hr = m_IObjectWithSite->SetSite(pUnkSite);
 529     WrapLogExit("CMenuBand::SetSite() = %08x\n", hr);
 530     return hr;
 531 }
 532
 533 HRESULT STDMETHODCALLTYPE CMenuBand::GetSite(REFIID riid, PVOID *ppvSite)
 534 {
 535     WrapLogEnter("CMenuBand<%p>::GetSite(REFIID riid=%s, PVOID *ppvSite=%p)\n", this, Wrap(riid), ppvSite);
 536     HRESULT hr = m_IObjectWithSite->GetSite(riid, ppvSite);
 537     if (ppvSite) WrapLogMsg("*ppvSite=%p\n", *ppvSite);
 538     WrapLogExit("CMenuBand::GetSite() = %08x\n", hr);
 539     return hr;
 540 }
 541
 542 // *** IInputObject methods ***
 543 HRESULT STDMETHODCALLTYPE CMenuBand::UIActivateIO(BOOL fActivate, LPMSG lpMsg)
 544 {
 545     WrapLogEnter("CMenuBand<%p>::UIActivateIO(BOOL fActivate=%d, LPMSG lpMsg=%p)\n", this, fActivate, lpMsg);
 546     HRESULT hr = m_IInputObject->UIActivateIO(fActivate, lpMsg);
 547     WrapLogExit("CMenuBand::UIActivateIO() = %08x\n", hr);
 548     return hr;
 549 }
 550
 551 HRESULT STDMETHODCALLTYPE CMenuBand::HasFocusIO()
 552 {
 553     WrapLogEnter("CMenuBand<%p>::HasFocusIO()\n", this);
 554     HRESULT hr = m_IInputObject->HasFocusIO();
 555     WrapLogExit("CMenuBand::HasFocusIO() = %08x\n", hr);
 556     return hr;
 557 }
 558
 559 HRESULT STDMETHODCALLTYPE CMenuBand::TranslateAcceleratorIO(LPMSG lpMsg)
 560 {
 561     WrapLogEnter("CMenuBand<%p>::TranslateAcceleratorIO(LPMSG lpMsg=%p)\n", this, lpMsg);
 562     if (lpMsg) WrapLogMsg("*lpMsg=%s\n", Wrap(*lpMsg));
 563     HRESULT hr = m_IInputObject->TranslateAcceleratorIO(lpMsg);
 564     WrapLogExit("CMenuBand::TranslateAcceleratorIO() = %08x\n", hr);
 565     return hr;
 566 }
 567
 568 // *** IPersistStream methods ***
 569 HRESULT STDMETHODCALLTYPE CMenuBand::IsDirty()
 570 {
 571     WrapLogEnter("CMenuBand<%p>::IsDirty()\n", this);
 572     HRESULT hr = m_IPersistStream->IsDirty();
 573     WrapLogExit("CMenuBand::IsDirty() = %08x\n", hr);
 574     return hr;
 575 }
 576 HRESULT STDMETHODCALLTYPE CMenuBand::Load(IStream *pStm)
 577 {
 578     WrapLogEnter("CMenuBand<%p>::Load(IStream *pStm=%p)\n", this, pStm);
 579     HRESULT hr = m_IPersistStream->Load(pStm);
 580     WrapLogExit("CMenuBand::Load() = %08x\n", hr);
 581     return hr;
 582 }
 583 HRESULT STDMETHODCALLTYPE CMenuBand::Save(IStream *pStm, BOOL fClearDirty)
 584 {
 585     WrapLogEnter("CMenuBand<%p>::Save(IStream *pStm=%p, BOOL fClearDirty=%d)\n", this, pStm, fClearDirty);
 586     HRESULT hr = m_IPersistStream->Save(pStm, fClearDirty);
 587     WrapLogExit("CMenuBand::Save() = %08x\n", hr);
 588     return hr;
 589 }
 590 HRESULT STDMETHODCALLTYPE CMenuBand::GetSizeMax(ULARGE_INTEGER *pcbSize)
 591 {
 592     WrapLogEnter("CMenuBand<%p>::GetSizeMax(ULARGE_INTEGER *pcbSize=%p)\n", this, pcbSize);
 593     HRESULT hr = m_IPersistStream->GetSizeMax(pcbSize);
 594     WrapLogExit("CMenuBand::GetSizeMax() = %08x\n", hr);
 595     return hr;
 596 }
 597
 598 // *** IPersist methods ***
 599 HRESULT STDMETHODCALLTYPE CMenuBand::GetClassID(CLSID *pClassID)
 600 {
 601     WrapLogEnter("CMenuBand<%p>::GetClassID(CLSID *pClassID=%p)\n", this, pClassID);
 602     HRESULT hr = m_IPersist->GetClassID(pClassID);
 603     if (pClassID) WrapLogMsg("*pClassID=%s\n", Wrap(*pClassID));
 604     WrapLogExit("CMenuBand::GetClassID() = %08x\n", hr);
 605     return hr;
 606 }
 607
 608 // *** IOleCommandTarget methods ***
 609 HRESULT STDMETHODCALLTYPE CMenuBand::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds [], OLECMDTEXT *pCmdText)
 610 {
 611     WrapLogEnter("CMenuBand<%p>::QueryStatus(const GUID *pguidCmdGroup=%p, ULONG cCmds=%u, prgCmds=%p, pCmdText=%p)\n", this, pguidCmdGroup, cCmds, prgCmds, pCmdText);
 612     HRESULT hr = m_IOleCommandTarget->QueryStatus(pguidCmdGroup, cCmds, prgCmds, pCmdText);
 613     if (pguidCmdGroup) WrapLogMsg("*pguidCmdGroup=%s\n", Wrap(*pguidCmdGroup));
 614     WrapLogExit("CMenuBand::QueryStatus() = %08x\n", hr);
 615     return hr;
 616 }
 617
 618 HRESULT STDMETHODCALLTYPE CMenuBand::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 619 {
 620     bool b;
 621
 622     WrapLogEnter("CMenuBand<%p>::Exec(const GUID *pguidCmdGroup=%p, DWORD nCmdID=%d, DWORD nCmdexecopt=%d, VARIANT *pvaIn=%p, VARIANT *pvaOut=%p)\n", this, pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
 623
 624     if (pguidCmdGroup && IsEqualGUID(*pguidCmdGroup, CLSID_MenuBand))
 625     {
 626         if (nCmdID == 19) // popup
 627         {
 628             b = true;
 629         }
 630     }
 631
 632
 633     if (pguidCmdGroup) WrapLogMsg("*pguidCmdGroup=%s\n", Wrap(*pguidCmdGroup));
 634     HRESULT hr = m_IOleCommandTarget->Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
 635     WrapLogExit("CMenuBand::Exec() = %08x\n", hr);
 636     return hr;
 637 }
 638
 639 // *** IServiceProvider methods ***
 640 HRESULT STDMETHODCALLTYPE CMenuBand::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
 641 {
 642     WrapLogEnter("CMenuBand<%p>::QueryService(REFGUID guidService=%s, REFIID riid=%s, void **ppvObject=%p)\n", this, Wrap(guidService), Wrap(riid), ppvObject);
 643
 644     if (IsEqualIID(guidService, SID_SMenuBandChild))
 645     {
 646         WrapLogMsg("SID is SID_SMenuBandChild. Using QueryInterface of self instead of wrapped object.\n");
 647         HRESULT hr = this->QueryInterface(riid, ppvObject);
 648         if (ppvObject) WrapLogMsg("*ppvObject=%p\n", *ppvObject);
 649         if (SUCCEEDED(hr))
 650         {
 651             WrapLogExit("CMenuBand::QueryService() = %08x\n", hr);
 652             return hr;
 653         }
 654         else
 655         {
 656             WrapLogMsg("QueryInterface on wrapper failed. Handing over to innter object.\n");
 657         }
 658     }
 659     else if (IsEqualIID(guidService, SID_SMenuBandBottom))
 660     {
 661         WrapLogMsg("SID is SID_SMenuBandBottom. Using QueryInterface of self instead of wrapped object.\n");
 662         HRESULT hr = this->QueryInterface(riid, ppvObject);
 663         if (ppvObject) WrapLogMsg("*ppvObject=%p\n", *ppvObject);
 664         if (SUCCEEDED(hr))
 665         {
 666             WrapLogExit("CMenuBand::QueryService() = %08x\n", hr);
 667             return hr;
 668         }
 669         else
 670         {
 671             WrapLogMsg("QueryInterface on wrapper failed. Handing over to innter object.\n");
 672         }
 673     }
 674     else if (IsEqualIID(guidService, SID_SMenuBandBottomSelected))
 675     {
 676         WrapLogMsg("SID is SID_SMenuBandBottomSelected. Using QueryInterface of self instead of wrapped object.\n");
 677         HRESULT hr = this->QueryInterface(riid, ppvObject);
 678         if (ppvObject) WrapLogMsg("*ppvObject=%p\n", *ppvObject);
 679         if (SUCCEEDED(hr))
 680         {
 681             WrapLogExit("CMenuBand::QueryService() = %08x\n", hr);
 682             return hr;
 683         }
 684         else
 685         {
 686             WrapLogMsg("QueryInterface on wrapper failed. Handing over to innter object.\n");
 687         }
 688     }
 689     else
 690     {
 691         WrapLogMsg("SID not identified.\n");
 692     }
 693     HRESULT hr = m_IServiceProvider->QueryService(guidService, riid, ppvObject);
 694     if (ppvObject) WrapLogMsg("*ppvObject=%p\n", *ppvObject);
 695     WrapLogExit("CMenuBand::QueryService() = %08x\n", hr);
 696     return hr;
 697 }
 698
 699
 700 // *** IMenuPopup methods ***
 701 HRESULT STDMETHODCALLTYPE CMenuBand::Popup(POINTL *ppt, RECTL *prcExclude, MP_POPUPFLAGS dwFlags)
 702 {
 703     WrapLogEnter("CMenuBand<%p>::Popup(POINTL *ppt=%p, RECTL *prcExclude=%p, MP_POPUPFLAGS dwFlags=%08x)\n", this, ppt, prcExclude, dwFlags);
 704     HRESULT hr = m_IMenuPopup->Popup(ppt, prcExclude, dwFlags);
 705     WrapLogExit("CMenuBand::Popup() = %08x\n", hr);
 706     return hr;
 707 }
 708
 709 HRESULT STDMETHODCALLTYPE CMenuBand::OnSelect(DWORD dwSelectType)
 710 {
 711     WrapLogEnter("CMenuBand<%p>::OnSelect(DWORD dwSelectType=%08x)\n", this, dwSelectType);
 712     HRESULT hr = m_IMenuPopup->OnSelect(dwSelectType);
 713     WrapLogExit("CMenuBand::OnSelect() = %08x\n", hr);
 714     return hr;
 715 }
 716
 717 HRESULT STDMETHODCALLTYPE CMenuBand::SetSubMenu(IMenuPopup *pmp, BOOL fSet)
 718 {
 719     WrapLogEnter("CMenuBand<%p>::SetSubMenu(IMenuPopup *pmp=%p, BOOL fSet=%d)\n", this, pmp, fSet);
 720     HRESULT hr = m_IMenuPopup->SetSubMenu(pmp, fSet);
 721     WrapLogExit("CMenuBand::SetSubMenu() = %08x\n", hr);
 722     return hr;
 723 }
 724
 725
 726 // *** IDeskBar methods ***
 727 HRESULT STDMETHODCALLTYPE CMenuBand::SetClient(IUnknown *punkClient)
 728 {
 729     WrapLogEnter("CMenuBand<%p>::SetClient(IUnknown *punkClient=%p)\n", this, punkClient);
 730     HRESULT hr = m_IDeskBar->SetClient(punkClient);
 731     WrapLogExit("CMenuBand::SetClient() = %08x\n", hr);
 732     return hr;
 733 }
 734
 735 HRESULT STDMETHODCALLTYPE CMenuBand::GetClient(IUnknown **ppunkClient)
 736 {
 737     WrapLogEnter("CMenuBand<%p>::GetClient(IUnknown **ppunkClient=%p)\n", this, ppunkClient);
 738     HRESULT hr = m_IDeskBar->GetClient(ppunkClient);
 739     if (ppunkClient) WrapLogMsg("*ppunkClient=%p\n", *ppunkClient);
 740     WrapLogExit("CMenuBand::GetClient() = %08x\n", hr);
 741     return hr;
 742 }
 743
 744 HRESULT STDMETHODCALLTYPE CMenuBand::OnPosRectChangeDB(RECT *prc)
 745 {
 746     WrapLogEnter("CMenuBand<%p>::OnPosRectChangeDB(RECT *prc=%p)\n", this, prc);
 747     HRESULT hr = m_IDeskBar->OnPosRectChangeDB(prc);
 748     if (prc) WrapLogMsg("*prc=%s\n", Wrap(*prc));
 749     WrapLogExit("CMenuBand::OnPosRectChangeDB() = %08x\n", hr);
 750     return hr;
 751 }
 752
 753
 754 // *** IMenuBand methods ***
 755 HRESULT STDMETHODCALLTYPE CMenuBand::IsMenuMessage(MSG *pmsg)
 756 {
 757     //WrapLogEnter("CMenuBand<%p>::IsMenuMessage(MSG *pmsg=%p)\n", this, pmsg);
 758     HRESULT hr = m_IMenuBand->IsMenuMessage(pmsg);
 759     //WrapLogExit("CMenuBand::IsMenuMessage() = %08x\n", hr);
 760     return hr;
 761 }
 762
 763 HRESULT STDMETHODCALLTYPE CMenuBand::TranslateMenuMessage(MSG *pmsg, LRESULT *plRet)
 764 {
 765     //WrapLogEnter("CMenuBand<%p>::TranslateMenuMessage(MSG *pmsg=%p, LRESULT *plRet=%p)\n", this, pmsg, plRet);
 766     HRESULT hr = m_IMenuBand->TranslateMenuMessage(pmsg, plRet);
 767     //WrapLogExit("CMenuBand::TranslateMenuMessage(*plRet=%d) = %08x\n", *plRet, hr);
 768     return hr;
 769 }
 770
 771 // *** IShellMenu methods ***
 772 HRESULT STDMETHODCALLTYPE CMenuBand::Initialize(IShellMenuCallback *psmc, UINT uId, UINT uIdAncestor, DWORD dwFlags)
 773 {
 774     WrapLogEnter("CMenuBand<%p>::Initialize(IShellMenuCallback *psmc=%p, UINT uId=%u, UINT uIdAncestor=%u, DWORD dwFlags=%08x)\n", this, psmc, uId, uIdAncestor, dwFlags);
 775     HRESULT hr = m_IShellMenu->Initialize(psmc, uId, uIdAncestor, dwFlags);
 776     WrapLogExit("CMenuBand::Initialize() = %08x\n", hr);
 777     return hr;
 778 }
 779
 780 HRESULT STDMETHODCALLTYPE CMenuBand::GetMenuInfo(IShellMenuCallback **ppsmc, UINT *puId, UINT *puIdAncestor, DWORD *pdwFlags)
 781 {
 782     WrapLogEnter("CMenuBand<%p>::GetMenuInfo(IShellMenuCallback **ppsmc=%p, UINT *puId=%p, UINT *puIdAncestor=%p, DWORD *pdwFlags=%p)\n", this, ppsmc, puId, puIdAncestor, pdwFlags);
 783     HRESULT hr = m_IShellMenu->GetMenuInfo(ppsmc, puId, puIdAncestor, pdwFlags);
 784     if (ppsmc) WrapLogMsg("*ppsmc=%p\n", *ppsmc);
 785     if (puId) WrapLogMsg("*puId=%u\n", *puId);
 786     if (puIdAncestor) WrapLogMsg("*puIdAncestor=%u\n", *puIdAncestor);
 787     if (pdwFlags) WrapLogMsg("*pdwFlags=%08x\n", *pdwFlags);
 788     WrapLogExit("CMenuBand::GetMenuInfo() = %08x\n", hr);
 789     return hr;
 790 }
 791
 792 HRESULT STDMETHODCALLTYPE CMenuBand::SetShellFolder(IShellFolder *psf, LPCITEMIDLIST pidlFolder, HKEY hKey, DWORD dwFlags)
 793 {
 794     WrapLogEnter("CMenuBand<%p>::SetShellFolder(IShellFolder *psf=%p, LPCITEMIDLIST pidlFolder=%p, HKEY hKey=%p, DWORD dwFlags=%08x)\n", this, psf, pidlFolder, hKey, dwFlags);
 795     HRESULT hr = m_IShellMenu->SetShellFolder(psf, pidlFolder, hKey, dwFlags);
 796     WrapLogExit("CMenuBand::SetShellFolder() = %08x\n", hr);
 797     return hr;
 798 }
 799
 800 HRESULT STDMETHODCALLTYPE CMenuBand::GetShellFolder(DWORD *pdwFlags, LPITEMIDLIST *ppidl, REFIID riid, void **ppv)
 801 {
 802     WrapLogEnter("CMenuBand<%p>::GetShellFolder(DWORD *pdwFlags=%p, LPITEMIDLIST *ppidl=%p, REFIID riid=%s, void **ppv=%p)\n", this, pdwFlags, ppidl, Wrap(riid), ppv);
 803     HRESULT hr = m_IShellMenu->GetShellFolder(pdwFlags, ppidl, riid, ppv);
 804     if (pdwFlags) WrapLogMsg("*pdwFlags=%08x\n", *pdwFlags);
 805     if (ppidl) WrapLogMsg("*ppidl=%p\n", *ppidl);
 806     if (ppv) WrapLogMsg("*ppv=%p\n", *ppv);
 807     WrapLogExit("CMenuBand::GetShellFolder() = %08x\n", hr);
 808     return hr;
 809 }
 810
 811 HRESULT STDMETHODCALLTYPE CMenuBand::SetMenu(HMENU hmenu, HWND hwnd, DWORD dwFlags)
 812 {
 813     WrapLogEnter("CMenuBand<%p>::SetMenu(HMENU hmenu=%p, HWND hwnd=%p, DWORD dwFlags=%08x)\n", this, hmenu, hwnd, dwFlags);
 814     HRESULT hr = m_IShellMenu->SetMenu(hmenu, hwnd, dwFlags);
 815     WrapLogExit("CMenuBand::SetMenu() = %08x\n", hr);
 816     return hr;
 817 }
 818
 819 HRESULT STDMETHODCALLTYPE CMenuBand::GetMenu(HMENU *phmenu, HWND *phwnd, DWORD *pdwFlags)
 820 {
 821     WrapLogEnter("CMenuBand<%p>::GetMenu(HMENU *phmenu=%p, HWND *phwnd=%p, DWORD *pdwFlags=%p)\n", this, phmenu, phwnd, pdwFlags);
 822     HRESULT hr = m_IShellMenu->GetMenu(phmenu, phwnd, pdwFlags);
 823     if (phmenu) WrapLogMsg("*phmenu=%p\n", *phmenu);
 824     if (phwnd) WrapLogMsg("*phwnd=%p\n", *phwnd);
 825     if (pdwFlags) WrapLogMsg("*pdwFlags=%08x\n", *pdwFlags);
 826     WrapLogExit("CMenuBand::GetMenu() = %08x\n", hr);
 827     return hr;
 828 }
 829
 830 HRESULT STDMETHODCALLTYPE CMenuBand::InvalidateItem(LPSMDATA psmd, DWORD dwFlags)
 831 {
 832     WrapLogEnter("CMenuBand<%p>::InvalidateItem(LPSMDATA psmd=%p, DWORD dwFlags=%08x)\n", this, psmd, dwFlags);
 833     HRESULT hr = m_IShellMenu->InvalidateItem(psmd, dwFlags);
 834     WrapLogExit("CMenuBand::InvalidateItem() = %08x\n", hr);
 835     return hr;
 836 }
 837
 838 HRESULT STDMETHODCALLTYPE CMenuBand::GetState(LPSMDATA psmd)
 839 {
 840     WrapLogEnter("CMenuBand<%p>::GetState(LPSMDATA psmd=%p)\n", this, psmd);
 841     HRESULT hr = m_IShellMenu->GetState(psmd);
 842     WrapLogExit("CMenuBand::GetState() = %08x\n", hr);
 843     return hr;
 844 }
 845
 846 HRESULT STDMETHODCALLTYPE CMenuBand::SetMenuToolbar(IUnknown *punk, DWORD dwFlags)
 847 {
 848     WrapLogEnter("CMenuBand<%p>::SetMenuToolbar(IUnknown *punk=%p, DWORD dwFlags=%08x)\n", this, punk, dwFlags);
 849     HRESULT hr = m_IShellMenu->SetMenuToolbar(punk, dwFlags);
 850     WrapLogExit("CMenuBand::SetMenuToolbar() = %08x\n", hr);
 851     return hr;
 852 }
 853 #else
 854
 855 CMenuToolbarBase::CMenuToolbarBase(CMenuBand *menuBand) :
 856     m_menuBand(menuBand),
 857     m_hwnd(NULL),
 858     m_dwMenuFlags(0)
 859 {
 860 }
 861
 862 HRESULT CMenuToolbarBase::ShowWindow(BOOL fShow)
 863 {
 864     ::ShowWindow(m_hwnd, fShow ? SW_SHOW : SW_HIDE);
 865
 866     HIMAGELIST ilBig, ilSmall;
 867     Shell_GetImageLists(&ilBig, &ilSmall);
 868
 869     if (m_menuBand->UseBigIcons())
 870     {
 871         SendMessageW(m_hwnd, TB_SETIMAGELIST, 0, (LPARAM) ilBig);
 872     }
 873     else
 874     {
 875         SendMessageW(m_hwnd, TB_SETIMAGELIST, 0, (LPARAM) ilSmall);
 876     }
 877
 878     return S_OK;
 879 }
 880
 881 HRESULT CMenuToolbarBase::Close()
 882 {
 883     DestroyWindow(m_hwnd);
 884     m_hwnd = NULL;
 885     return S_OK;
 886 }
 887
 888 HRESULT CMenuToolbarBase::CreateToolbar(HWND hwndParent, DWORD dwFlags)
 889 {
 890     LONG tbStyles = WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
 891         TBSTYLE_TOOLTIPS | TBSTYLE_TRANSPARENT | TBSTYLE_REGISTERDROP | TBSTYLE_LIST | TBSTYLE_FLAT | TBSTYLE_CUSTOMERASE |
 892         CCS_NODIVIDER | CCS_NOPARENTALIGN | CCS_NORESIZE | CCS_TOP;
 893     LONG tbExStyles = TBSTYLE_EX_DOUBLEBUFFER;
 894
 895     if (dwFlags & SMINIT_VERTICAL)
 896     {
 897         tbStyles |= CCS_VERT;
 898         tbExStyles |= TBSTYLE_EX_VERTICAL | WS_EX_TOOLWINDOW;
 899     }
 900
 901     RECT rc;
 902
 903     if (!::GetClientRect(hwndParent, &rc) || (rc.left == rc.right) || (rc.top == rc.bottom))
 904     {
 905         rc.left = 0;
 906         rc.top = 0;
 907         rc.right = 1;
 908         rc.bottom = 1;
 909     }
 910
 911     HWND hwndToolbar = CreateWindowEx(
 912         tbExStyles, TOOLBARCLASSNAMEW, NULL,
 913         tbStyles, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
 914         hwndParent, NULL, _AtlBaseModule.GetModuleInstance(), 0);
 915
 916     if (hwndToolbar == NULL)
 917         return E_FAIL;
 918
 919     ::SetParent(hwndToolbar, hwndParent);
 920
 921     m_hwnd = hwndToolbar;
 922
 923     /* Identify the version of the used Common Controls DLL by sending the size of the TBBUTTON structure */
 924     SendMessageW(m_hwnd, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
 925
 926     HIMAGELIST ilBig, ilSmall;
 927     Shell_GetImageLists(&ilBig, &ilSmall);
 928
 929     //if (dwFlags & SMINIT_TOPLEVEL)
 930     //{
 931     //    /* Hide the placeholders for the button images */
 932     //    SendMessageW(m_hwnd, TB_SETIMAGELIST, 0, 0);
 933     //}
 934     //else
 935     if (m_menuBand->UseBigIcons())
 936     {
 937         SendMessageW(m_hwnd, TB_SETIMAGELIST, 0, (LPARAM) ilBig);
 938     }
 939     else
 940     {
 941         SendMessageW(m_hwnd, TB_SETIMAGELIST, 0, (LPARAM) ilSmall);
 942     }
 943
 944     SetWindowLongPtr(m_hwnd, GWLP_USERDATA, (LONG_PTR)this);
 945     m_SubclassOld = (WNDPROC) SetWindowLongPtr(m_hwnd, GWLP_WNDPROC, (LONG_PTR) CMenuToolbarBase::s_SubclassProc);
 946
 947     return S_OK;
 948 }
 949
 950 HRESULT CMenuToolbarBase::GetWindow(HWND *phwnd)
 951 {
 952     if (!phwnd)
 953         return E_FAIL;
 954
 955     *phwnd = m_hwnd;
 956
 957     return S_OK;
 958 }
 959
 960 LRESULT CALLBACK CMenuToolbarBase::s_SubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 961 {
 962     CMenuToolbarBase * pthis = reinterpret_cast<CMenuToolbarBase *>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
 963     return pthis->SubclassProc(hWnd, uMsg, wParam, lParam);
 964 }
 965
 966 LRESULT CMenuToolbarBase::SubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 967 {
 968     switch (uMsg)
 969     {
 970     case WM_TIMER:
 971         if (wParam == TIMERID_HOTTRACK)
 972         {
 973             PopupItem(m_hotItem);
 974             KillTimer(hWnd, TIMERID_HOTTRACK);
 975         }
 976     }
 977
 978     return m_SubclassOld(hWnd, uMsg, wParam, lParam);
 979 }
 980
 981 HRESULT CMenuToolbarBase::OnHotItemChange(const NMTBHOTITEM * hot)
 982 {
 983     if (hot->dwFlags & HICF_LEAVING)
 984     {
 985         KillTimer(m_hwnd, TIMERID_HOTTRACK);
 986     }
 987     else if (m_hotItem != hot->idNew)
 988     {
 989         if (HasSubMenu(hot->idNew) == S_OK)
 990         {
 991             DWORD elapsed;
 992             SystemParametersInfo(SPI_GETMENUSHOWDELAY, 0, &elapsed, 0);
 993
 994             m_hotItem = hot->idNew;
 995
 996             SetTimer(m_hwnd, TIMERID_HOTTRACK, elapsed, NULL);
 997         }
 998     }
 999
1000     m_menuBand->OnSelect(MPOS_CHILDTRACKING);
1001     return S_OK;
1002 }
1003
1004 HRESULT CMenuToolbarBase::PopupSubMenu(UINT index, IShellMenu* childShellMenu)
1005 {
1006     IBandSite* pBandSite;
1007     IDeskBar* pDeskBar;
1008
1009     HRESULT hr;
1010
1011     RECT rc;
1012     if (!SendMessage(m_hwnd, TB_GETITEMRECT, index, (LPARAM) &rc))
1013         return E_FAIL;
1014
1015     POINT a = { rc.left, rc.top };
1016     POINT b = { rc.right, rc.bottom };
1017
1018     ClientToScreen(m_hwnd, &a);
1019     ClientToScreen(m_hwnd, &b);
1020
1021     POINTL pt = { b.x, b.y };
1022     RECTL rcl = { a.x, a.y, b.x, b.y }; // maybe-TODO: fetch client area of deskbar?
1023
1024
1025 #ifndef USE_BUILTIN_MENUSITE
1026     hr = CoCreateInstance(CLSID_MenuBandSite,
1027         NULL,
1028         CLSCTX_INPROC_SERVER,
1029         IID_PPV_ARG(IBandSite, &pBandSite));
1030 #else
1031     hr = CMenuSite_Constructor(IID_PPV_ARG(IBandSite, &pBandSite));
1032 #endif
1033     if (FAILED(hr))
1034         return hr;
1035
1036 #ifndef USE_BUILTIN_MENUDESKBAR
1037     hr = CoCreateInstance(CLSID_MenuDeskBar,
1038         NULL,
1039         CLSCTX_INPROC_SERVER,
1040         IID_PPV_ARG(IDeskBar, &pDeskBar));
1041 #else
1042     hr = CMenuDeskBar_Constructor(IID_PPV_ARG(IDeskBar, &pDeskBar));
1043 #endif
1044     if (FAILED(hr))
1045         return hr;
1046
1047     hr = pDeskBar->SetClient(pBandSite);
1048     if (FAILED(hr))
1049         return hr;
1050
1051     hr = pBandSite->AddBand(childShellMenu);
1052     if (FAILED(hr))
1053         return hr;
1054
1055     CComPtr<IMenuPopup> popup;
1056     hr = pDeskBar->QueryInterface(IID_PPV_ARG(IMenuPopup, &popup));
1057     if (FAILED(hr))
1058         return hr;
1059
1060     popup->Popup(&pt, &rcl, MPPF_TOP | MPPF_RIGHT);
1061
1062     return S_OK;
1063 }
1064
1065 HRESULT CMenuToolbarBase::DoContextMenu(IContextMenu* contextMenu)
1066 {
1067     HRESULT hr;
1068     HMENU hPopup = CreatePopupMenu();
1069
1070     if (hPopup == NULL)
1071         return E_FAIL;
1072
1073     hr = contextMenu->QueryContextMenu(hPopup, 0, 0, UINT_MAX, CMF_NORMAL);
1074     if (FAILED(hr))
1075     {
1076         DestroyMenu(hPopup);
1077         return hr;
1078     }
1079
1080     DWORD dwPos = GetMessagePos();
1081     UINT uCommand = ::TrackPopupMenu(hPopup, TPM_RETURNCMD, GET_X_LPARAM(dwPos), GET_Y_LPARAM(dwPos), 0, m_hwnd, NULL);
1082     if (uCommand == 0)
1083         return S_FALSE;
1084
1085     CMINVOKECOMMANDINFO cmi = { 0 };
1086     cmi.cbSize = sizeof(cmi);
1087     cmi.lpVerb = MAKEINTRESOURCEA(uCommand);
1088     cmi.hwnd = m_hwnd;
1089     hr = contextMenu->InvokeCommand(&cmi);
1090
1091     DestroyMenu(hPopup);
1092     return hr;
1093 }
1094
1095 HRESULT CMenuToolbarBase::OnCommand(WPARAM wParam, LPARAM lParam, LRESULT *theResult)
1096 {
1097     m_menuBand->OnSelect(MPOS_EXECUTE);
1098     return S_OK;
1099 }
1100
1101 BOOL
1102 AllocAndGetMenuString(HMENU hMenu, UINT ItemIDByPosition, WCHAR** String)
1103 {
1104     int Length;
1105
1106     Length = GetMenuStringW(hMenu, ItemIDByPosition, NULL, 0, MF_BYPOSITION);
1107
1108     if (!Length)
1109         return FALSE;
1110
1111     /* Also allocate space for the terminating NULL character */
1112     ++Length;
1113     *String = (PWSTR) HeapAlloc(GetProcessHeap(), 0, Length * sizeof(WCHAR));
1114
1115     GetMenuStringW(hMenu, ItemIDByPosition, *String, Length, MF_BYPOSITION);
1116
1117     return TRUE;
1118 }
1119
1120 CMenuStaticToolbar::CMenuStaticToolbar(CMenuBand *menuBand) :
1121     CMenuToolbarBase(menuBand),
1122     m_hmenu(NULL)
1123 {
1124 }
1125
1126 HRESULT  CMenuStaticToolbar::GetMenu(
1127     HMENU *phmenu,
1128     HWND *phwnd,
1129     DWORD *pdwFlags)
1130 {
1131     *phmenu = m_hmenu;
1132     *phwnd = NULL;
1133     *pdwFlags = m_dwMenuFlags;
1134
1135     return S_OK;
1136 }
1137
1138 HRESULT  CMenuStaticToolbar::SetMenu(
1139     HMENU hmenu,
1140     HWND hwnd,
1141     DWORD dwFlags)
1142 {
1143     m_hmenu = hmenu;
1144     m_dwMenuFlags = dwFlags;
1145
1146     return S_OK;
1147 }
1148
1149 HRESULT CMenuStaticToolbar::FillToolbar()
1150 {
1151     int i;
1152     int ic = GetMenuItemCount(m_hmenu);
1153
1154     for (i = 0; i < ic; i++)
1155     {
1156         MENUITEMINFOW info;
1157         TBBUTTON tbb = { 0 };
1158         PWSTR MenuString = NULL;
1159
1160         tbb.fsState = TBSTATE_ENABLED;
1161         tbb.fsStyle = 0;
1162
1163         info.cbSize = sizeof(info);
1164         info.fMask = MIIM_FTYPE | MIIM_ID;
1165
1166         GetMenuItemInfoW(m_hmenu, i, TRUE, &info);
1167
1168         if (info.fType == MFT_STRING)
1169         {
1170             if (!AllocAndGetMenuString(m_hmenu, i, &MenuString))
1171                 return E_OUTOFMEMORY;
1172             if (::GetSubMenu(m_hmenu, i) != NULL)
1173                 tbb.fsStyle |= BTNS_DROPDOWN;
1174             tbb.iString = (INT_PTR) MenuString;
1175             tbb.idCommand = info.wID;
1176
1177             SMINFO sminfo = { 0 };
1178             sminfo.dwMask = SMIM_ICON;
1179             if (info.wID >= 0 && SUCCEEDED(m_menuBand->CallCBWithId(info.wID, SMC_GETINFO, 0, (LPARAM) &sminfo)))
1180             {
1181                 tbb.iBitmap = sminfo.iIcon;
1182             }
1183         }
1184         else
1185         {
1186             tbb.fsStyle |= BTNS_SEP;
1187         }
1188
1189         SendMessageW(m_hwnd, TB_ADDBUTTONS, 1, (LPARAM) (LPTBBUTTON) &tbb);
1190
1191         if (MenuString)
1192             HeapFree(GetProcessHeap(), 0, MenuString);
1193     }
1194
1195     return S_OK;
1196 }
1197
1198 HRESULT CMenuStaticToolbar::OnContextMenu(NMMOUSE * rclick)
1199 {
1200     CComPtr<IContextMenu> contextMenu;
1201     HRESULT hr = m_menuBand->CallCBWithId(rclick->dwItemSpec, SMC_GETOBJECT, (WPARAM) &IID_IContextMenu, (LPARAM) &contextMenu);
1202     if (hr != S_OK)
1203         return hr;
1204
1205     return DoContextMenu(contextMenu);
1206 }
1207
1208 HRESULT CMenuStaticToolbar::OnCommand(WPARAM wParam, LPARAM lParam, LRESULT *theResult)
1209 {
1210     HRESULT hr = m_menuBand->CallCBWithId(wParam, SMC_EXEC, 0, 0);
1211     if (FAILED(hr))
1212         return hr;
1213
1214     return CMenuToolbarBase::OnCommand(wParam, lParam, theResult);
1215 }
1216
1217 HRESULT CMenuStaticToolbar::PopupItem(UINT uItem)
1218 {
1219     CComPtr<IShellMenu> shellMenu;
1220     HRESULT hr = m_menuBand->CallCBWithId(uItem, SMC_GETOBJECT, (WPARAM) &IID_IShellMenu, (LPARAM) &shellMenu);
1221     if (FAILED(hr))
1222         return hr;
1223
1224     TBBUTTONINFO info = { 0 };
1225     info.cbSize = sizeof(TBBUTTONINFO);
1226     info.dwMask = 0;
1227     int index = SendMessage(m_hwnd, TB_GETBUTTONINFO, uItem, (LPARAM) &info);
1228     if (index < 0)
1229         return E_FAIL;
1230
1231     return PopupSubMenu(index, shellMenu);
1232 }
1233
1234 HRESULT CMenuStaticToolbar::HasSubMenu(UINT uItem)
1235 {
1236     TBBUTTONINFO info = { 0 };
1237     info.cbSize = sizeof(TBBUTTONINFO);
1238     info.dwMask = 0;
1239     int index = SendMessage(m_hwnd, TB_GETBUTTONINFO, uItem, (LPARAM) &info);
1240     if (index < 0)
1241         return E_FAIL;
1242     return ::GetSubMenu(m_hmenu, index) ? S_OK : S_FALSE;
1243 }
1244
1245 CMenuSFToolbar::CMenuSFToolbar(CMenuBand * menuBand) :
1246     CMenuToolbarBase(menuBand),
1247     m_shellFolder(NULL)
1248 {
1249 }
1250
1251 CMenuSFToolbar::~CMenuSFToolbar()
1252 {
1253 }
1254
1255 HRESULT CMenuSFToolbar::FillToolbar()
1256 {
1257     HRESULT hr;
1258     TBBUTTON tbb = { 0 };
1259     int i = 0;
1260     PWSTR MenuString;
1261
1262     tbb.fsState = TBSTATE_ENABLED;
1263     tbb.fsStyle = 0;
1264
1265     IEnumIDList * eidl;
1266     m_shellFolder->EnumObjects(m_hwnd, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS, &eidl);
1267
1268     LPITEMIDLIST item = (LPITEMIDLIST) CoTaskMemAlloc(sizeof(ITEMIDLIST));
1269     ULONG fetched;
1270     while ((hr = eidl->Next(1, &item, &fetched)) == S_OK)
1271     {
1272         INT index = 0;
1273         INT indexOpen = 0;
1274
1275         CComPtr<IShellItem> psi;
1276         SHCreateShellItem(NULL, m_shellFolder, item, &psi);
1277
1278         hr = psi->GetDisplayName(SIGDN_NORMALDISPLAY, &MenuString);
1279         if (FAILED(hr))
1280             return hr;
1281
1282         index = SHMapPIDLToSystemImageListIndex(m_shellFolder, item, &indexOpen);
1283
1284         SFGAOF attrs;
1285         hr = psi->GetAttributes(SFGAO_FOLDER, &attrs);
1286
1287         if (attrs != 0)
1288         {
1289             tbb.fsStyle |= BTNS_DROPDOWN;
1290         }
1291
1292         tbb.idCommand = i++;
1293         tbb.iString = (INT_PTR) MenuString;
1294         tbb.iBitmap = index;
1295         tbb.dwData = (DWORD_PTR) ILClone(item);
1296
1297         SendMessageW(m_hwnd, TB_ADDBUTTONS, 1, (LPARAM) (LPTBBUTTON) &tbb);
1298         HeapFree(GetProcessHeap(), 0, MenuString);
1299
1300     }
1301     CoTaskMemFree(item);
1302
1303     return hr;
1304 }
1305
1306 HRESULT CMenuSFToolbar::SetShellFolder(IShellFolder *psf, LPCITEMIDLIST pidlFolder, HKEY hKey, DWORD dwFlags)
1307 {
1308     m_shellFolder = psf;
1309     m_idList = pidlFolder;
1310     m_hKey = hKey;
1311     m_dwMenuFlags = dwFlags;
1312     return S_OK;
1313 }
1314
1315 HRESULT CMenuSFToolbar::GetShellFolder(DWORD *pdwFlags, LPITEMIDLIST *ppidl, REFIID riid, void **ppv)
1316 {
1317     HRESULT hr;
1318
1319     hr = m_shellFolder->QueryInterface(riid, ppv);
1320     if (FAILED(hr))
1321         return hr;
1322
1323     if (pdwFlags)
1324         *pdwFlags = m_dwMenuFlags;
1325
1326     if (ppidl)
1327     {
1328         LPITEMIDLIST pidl = NULL;
1329
1330         if (m_idList)
1331         {
1332             pidl = ILClone(m_idList);
1333             if (!pidl)
1334             {
1335                 (*(IUnknown**) ppv)->Release();
1336                 return E_FAIL;
1337             }
1338         }
1339
1340         *ppidl = pidl;
1341     }
1342
1343     return hr;
1344 }
1345
1346 LPITEMIDLIST CMenuSFToolbar::GetPidlFromId(UINT uItem, INT* pIndex)
1347 {
1348     TBBUTTONINFO info = { 0 };
1349     info.cbSize = sizeof(TBBUTTONINFO);
1350     info.dwMask = 0;
1351     int index = SendMessage(m_hwnd, TB_GETBUTTONINFO, uItem, (LPARAM) &info);
1352     if (index < 0)
1353         return NULL;
1354
1355     if (pIndex)
1356         *pIndex = index;
1357
1358     TBBUTTON btn = { 0 };
1359     if (!SendMessage(m_hwnd, TB_GETBUTTON, index, (LPARAM) &btn))
1360         return NULL;
1361
1362     return (LPITEMIDLIST) btn.dwData;
1363 }
1364
1365 HRESULT CMenuSFToolbar::OnContextMenu(NMMOUSE * rclick)
1366 {
1367     HRESULT hr;
1368     CComPtr<IContextMenu> contextMenu;
1369     LPCITEMIDLIST pidl = reinterpret_cast<LPCITEMIDLIST>(rclick->dwItemData);
1370
1371     hr = m_shellFolder->GetUIObjectOf(m_hwnd, 1, &pidl, IID_IContextMenu, NULL, reinterpret_cast<VOID **>(&contextMenu));
1372     if (hr != S_OK)
1373         return hr;
1374
1375     return DoContextMenu(contextMenu);
1376 }
1377
1378 HRESULT CMenuSFToolbar::OnCommand(WPARAM wParam, LPARAM lParam, LRESULT *theResult)
1379 {
1380     return m_menuBand->CallCBWithPidl(GetPidlFromId(wParam, NULL), SMC_SFEXEC, 0, 0);
1381 }
1382
1383 HRESULT CMenuSFToolbar::PopupItem(UINT uItem)
1384 {
1385     HRESULT hr;
1386     UINT uId;
1387     UINT uIdAncestor;
1388     DWORD flags;
1389     int index;
1390     CComPtr<IShellMenuCallback> psmc;
1391     CComPtr<IShellMenu> shellMenu;
1392
1393     LPITEMIDLIST pidl = GetPidlFromId(uItem, &index);
1394
1395     if (!pidl)
1396         return E_FAIL;
1397
1398 #ifndef USE_BUILTIN_MENUBAND
1399     hr = CoCreateInstance(CLSID_MenuBand,
1400         NULL,
1401         CLSCTX_INPROC_SERVER,
1402         IID_PPV_ARG(IShellMenu, &pShellMenu));
1403 #else
1404     hr = CMenuBand_Constructor(IID_PPV_ARG(IShellMenu, &shellMenu));
1405 #endif
1406     if (FAILED(hr))
1407         return hr;
1408
1409     m_menuBand->GetMenuInfo(&psmc, &uId, &uIdAncestor, &flags);
1410
1411     // FIXME: not sure waht to use as uId/uIdAncestor here
1412     hr = shellMenu->Initialize(psmc, 0, uId, SMINIT_VERTICAL);
1413     if (FAILED(hr))
1414         return hr;
1415
1416     CComPtr<IShellFolder> childFolder;
1417     hr = m_shellFolder->BindToObject(pidl, NULL, IID_PPV_ARG(IShellFolder, &childFolder));
1418     if (FAILED(hr))
1419         return hr;
1420
1421     hr = shellMenu->SetShellFolder(childFolder, NULL, NULL, 0);
1422     if (FAILED(hr))
1423         return hr;
1424
1425     return PopupSubMenu(index, shellMenu);
1426 }
1427
1428 HRESULT CMenuSFToolbar::HasSubMenu(UINT uItem)
1429 {
1430     HRESULT hr;
1431     CComPtr<IShellItem> psi;
1432     SHCreateShellItem(NULL, m_shellFolder, GetPidlFromId(uItem, NULL), &psi);
1433
1434     SFGAOF attrs;
1435     hr = psi->GetAttributes(SFGAO_FOLDER, &attrs);
1436
1437     return (attrs != 0) ? S_OK : S_FALSE;
1438 }
1439
1440 CMenuBand::CMenuBand() :
1441     m_site(NULL),
1442     m_psmc(NULL),
1443     m_staticToolbar(NULL),
1444     m_SFToolbar(NULL),
1445     m_useBigIcons(FALSE)
1446 {
1447 }
1448
1449 CMenuBand::~CMenuBand()
1450 {
1451     if (m_site)
1452         m_site->Release();
1453
1454     if (m_psmc)
1455         m_psmc->Release();
1456
1457     if (m_staticToolbar)
1458         delete m_staticToolbar;
1459
1460     if (m_SFToolbar)
1461         delete m_SFToolbar;
1462 }
1463
1464 HRESULT STDMETHODCALLTYPE  CMenuBand::Initialize(
1465     IShellMenuCallback *psmc,
1466     UINT uId,
1467     UINT uIdAncestor,
1468     DWORD dwFlags)
1469 {
1470     if (m_psmc)
1471         m_psmc->Release();
1472
1473     m_psmc = psmc;
1474     m_uId = uId;
1475     m_uIdAncestor = uIdAncestor;
1476     m_dwFlags = dwFlags;
1477
1478     if (m_psmc)
1479     {
1480         m_psmc->AddRef();
1481
1482         _CallCB(SMC_CREATE, 0, (LPARAM) &m_UserData);
1483     }
1484
1485     return S_OK;
1486 }
1487
1488 HRESULT STDMETHODCALLTYPE  CMenuBand::GetMenuInfo(
1489     IShellMenuCallback **ppsmc,
1490     UINT *puId,
1491     UINT *puIdAncestor,
1492     DWORD *pdwFlags)
1493 {
1494     if (!pdwFlags) // maybe?
1495         return E_INVALIDARG;
1496
1497     if (ppsmc)
1498         *ppsmc = m_psmc;
1499
1500     if (puId)
1501         *puId = m_uId;
1502
1503     if (puIdAncestor)
1504         *puIdAncestor = m_uIdAncestor;
1505
1506     *pdwFlags = m_dwFlags;
1507
1508     return S_OK;
1509 }
1510
1511 HRESULT STDMETHODCALLTYPE  CMenuBand::SetMenu(
1512     HMENU hmenu,
1513     HWND hwnd,
1514     DWORD dwFlags)
1515 {
1516     if (m_staticToolbar == NULL)
1517     {
1518         m_staticToolbar = new CMenuStaticToolbar(this);
1519     }
1520     m_hmenu = hmenu;
1521
1522     HRESULT hResult = m_staticToolbar->SetMenu(hmenu, hwnd, dwFlags);
1523     if (FAILED(hResult))
1524         return hResult;
1525
1526     if (m_site)
1527     {
1528         HWND hwndParent;
1529
1530         hResult = m_site->GetWindow(&hwndParent);
1531         if (FAILED(hResult))
1532             return hResult;
1533
1534         hResult = m_staticToolbar->CreateToolbar(hwndParent, m_dwFlags);
1535         if (FAILED(hResult))
1536             return hResult;
1537
1538         hResult = m_staticToolbar->FillToolbar();
1539     }
1540
1541     return hResult;
1542 }
1543
1544 HRESULT STDMETHODCALLTYPE  CMenuBand::GetMenu(
1545     HMENU *phmenu,
1546     HWND *phwnd,
1547     DWORD *pdwFlags)
1548 {
1549     if (m_staticToolbar == NULL)
1550         return E_FAIL;
1551
1552     return m_staticToolbar->GetMenu(phmenu, phwnd, pdwFlags);
1553 }
1554
1555 HRESULT STDMETHODCALLTYPE  CMenuBand::SetSite(IUnknown *pUnkSite)
1556 {
1557     HWND                    hwndParent;
1558     HRESULT                 hResult;
1559
1560     if (m_site != NULL)
1561         m_site->Release();
1562
1563     if (pUnkSite == NULL)
1564         return S_OK;
1565
1566     hwndParent = NULL;
1567     hResult = pUnkSite->QueryInterface(IID_PPV_ARG(IOleWindow, &m_site));
1568     if (SUCCEEDED(hResult))
1569     {
1570         m_site->GetWindow(&hwndParent);
1571         m_site->Release();
1572     }
1573     if (!::IsWindow(hwndParent))
1574         return E_FAIL;
1575
1576     if (m_staticToolbar != NULL)
1577     {
1578         hResult = m_staticToolbar->CreateToolbar(hwndParent, m_dwFlags);
1579         if (FAILED(hResult))
1580             return hResult;
1581
1582         hResult = m_staticToolbar->FillToolbar();
1583     }
1584
1585     if (m_SFToolbar != NULL)
1586     {
1587         hResult = m_SFToolbar->CreateToolbar(hwndParent, m_dwFlags);
1588         if (FAILED(hResult))
1589             return hResult;
1590
1591         hResult = m_SFToolbar->FillToolbar();
1592     }
1593
1594     return S_OK;
1595 }
1596
1597 HRESULT STDMETHODCALLTYPE  CMenuBand::GetSite(REFIID riid, PVOID *ppvSite)
1598 {
1599     if (m_site == NULL)
1600         return E_FAIL;
1601
1602     return m_site->QueryInterface(riid, ppvSite);
1603 }
1604
1605 HRESULT STDMETHODCALLTYPE CMenuBand::GetWindow(
1606     HWND *phwnd)
1607 {
1608     if (m_SFToolbar != NULL)
1609         return m_SFToolbar->GetWindow(phwnd);
1610
1611     if (m_staticToolbar != NULL)
1612         return m_staticToolbar->GetWindow(phwnd);
1613
1614     return E_FAIL;
1615 }
1616
1617 HRESULT STDMETHODCALLTYPE CMenuBand::OnPosRectChangeDB(RECT *prc)
1618 {
1619     SIZE sizeStaticY = { 0 };
1620     SIZE sizeShlFldY = { 0 };
1621     HWND hwndStatic = NULL;
1622     HWND hwndShlFld = NULL;
1623     HRESULT hResult = S_OK;
1624
1625     if (m_staticToolbar != NULL)
1626         hResult = m_staticToolbar->GetWindow(&hwndStatic);
1627     if (FAILED(hResult))
1628         return hResult;
1629
1630     if (m_SFToolbar != NULL)
1631         hResult = m_SFToolbar->GetWindow(&hwndShlFld);
1632     if (FAILED(hResult))
1633         return hResult;
1634
1635     if (hwndStatic == NULL && hwndShlFld == NULL)
1636         return E_FAIL;
1637
1638     if (hwndStatic) SendMessageW(hwndStatic, TB_GETIDEALSIZE, TRUE, (LPARAM) &sizeStaticY);
1639     if (hwndShlFld) SendMessageW(hwndShlFld, TB_GETIDEALSIZE, TRUE, (LPARAM) &sizeShlFldY);
1640
1641     int sy = max(prc->bottom - prc->top, sizeStaticY.cy + sizeShlFldY.cy);
1642
1643     if (hwndShlFld)
1644     {
1645         SetWindowPos(hwndShlFld, NULL,
1646             prc->left,
1647             prc->top,
1648             prc->right - prc->left,
1649             sizeShlFldY.cy,
1650             0);
1651         DWORD btnSize = SendMessage(hwndShlFld, TB_GETBUTTONSIZE, 0, 0);
1652         SendMessage(hwndShlFld, TB_SETBUTTONSIZE, 0, MAKELPARAM(prc->right - prc->left, HIWORD(btnSize)));
1653     }
1654     if (hwndStatic)
1655     {
1656         SetWindowPos(hwndStatic, hwndShlFld,
1657             prc->left,
1658             prc->top + sizeShlFldY.cy,
1659             prc->right - prc->left,
1660             sy - sizeShlFldY.cy,
1661             0);
1662         DWORD btnSize = SendMessage(hwndStatic, TB_GETBUTTONSIZE, 0, 0);
1663         SendMessage(hwndStatic, TB_SETBUTTONSIZE, 0, MAKELPARAM(prc->right - prc->left, HIWORD(btnSize)));
1664     }
1665
1666     return S_OK;
1667 }
1668
1669 HRESULT STDMETHODCALLTYPE  CMenuBand::GetBandInfo(
1670     DWORD dwBandID,
1671     DWORD dwViewMode,
1672     DESKBANDINFO *pdbi)
1673 {
1674     HWND hwndStatic = NULL;
1675     HWND hwndShlFld = NULL;
1676     HRESULT hResult = S_OK;
1677
1678     if (m_staticToolbar != NULL)
1679         hResult = m_staticToolbar->GetWindow(&hwndStatic);
1680     if (FAILED(hResult))
1681         return hResult;
1682
1683     if (m_SFToolbar != NULL)
1684         hResult = m_SFToolbar->GetWindow(&hwndShlFld);
1685     if (FAILED(hResult))
1686         return hResult;
1687
1688     if (hwndStatic == NULL && hwndShlFld == NULL)
1689         return E_FAIL;
1690
1691     // HACK (?)
1692     if (pdbi->dwMask == 0)
1693     {
1694         pdbi->dwMask = DBIM_MINSIZE | DBIM_MAXSIZE | DBIM_INTEGRAL | DBIM_ACTUAL | DBIM_TITLE | DBIM_MODEFLAGS | DBIM_BKCOLOR;
1695     }
1696
1697     if (pdbi->dwMask & DBIM_MINSIZE)
1698     {
1699         SIZE sizeStatic = { 0 };
1700         SIZE sizeShlFld = { 0 };
1701
1702         if (hwndStatic) SendMessageW(hwndStatic, TB_GETIDEALSIZE, TRUE, (LPARAM) &sizeStatic);
1703         if (hwndShlFld) SendMessageW(hwndShlFld, TB_GETIDEALSIZE, TRUE, (LPARAM) &sizeShlFld);
1704
1705         pdbi->ptMinSize.x = 0;
1706         pdbi->ptMinSize.y = sizeStatic.cy + sizeShlFld.cy;
1707     }
1708     if (pdbi->dwMask & DBIM_MAXSIZE)
1709     {
1710         SIZE sizeStatic = { 0 };
1711         SIZE sizeShlFld = { 0 };
1712
1713         if (hwndStatic) SendMessageW(hwndStatic, TB_GETMAXSIZE, 0, (LPARAM) &sizeStatic);
1714         if (hwndShlFld) SendMessageW(hwndShlFld, TB_GETMAXSIZE, 0, (LPARAM) &sizeShlFld);
1715
1716         pdbi->ptMaxSize.x = max(sizeStatic.cx, sizeShlFld.cx); // ignored
1717         pdbi->ptMaxSize.y = sizeStatic.cy + sizeShlFld.cy;
1718     }
1719     if (pdbi->dwMask & DBIM_INTEGRAL)
1720     {
1721         pdbi->ptIntegral.x = 0;
1722         pdbi->ptIntegral.y = 0;
1723     }
1724     if (pdbi->dwMask & DBIM_ACTUAL)
1725     {
1726         SIZE sizeStatic = { 0 };
1727         SIZE sizeShlFld = { 0 };
1728
1729         if (hwndStatic) SendMessageW(hwndStatic, TB_GETIDEALSIZE, FALSE, (LPARAM) &sizeStatic);
1730         if (hwndShlFld) SendMessageW(hwndShlFld, TB_GETIDEALSIZE, FALSE, (LPARAM) &sizeShlFld);
1731         pdbi->ptActual.x = max(sizeStatic.cx, sizeShlFld.cx);
1732
1733         if (hwndStatic) SendMessageW(hwndStatic, TB_GETIDEALSIZE, TRUE, (LPARAM) &sizeStatic);
1734         if (hwndShlFld) SendMessageW(hwndShlFld, TB_GETIDEALSIZE, TRUE, (LPARAM) &sizeShlFld);
1735         pdbi->ptActual.y = sizeStatic.cy + sizeShlFld.cy;
1736     }
1737     if (pdbi->dwMask & DBIM_TITLE)
1738         wcscpy(pdbi->wszTitle, L"");
1739     if (pdbi->dwMask & DBIM_MODEFLAGS)
1740         pdbi->dwModeFlags = DBIMF_UNDELETEABLE;
1741     if (pdbi->dwMask & DBIM_BKCOLOR)
1742         pdbi->crBkgnd = 0;
1743     return S_OK;
1744 }
1745
1746 /* IDockingWindow */
1747 HRESULT STDMETHODCALLTYPE  CMenuBand::ShowDW(BOOL fShow)
1748 {
1749     HRESULT hr = S_OK;
1750
1751     if (m_staticToolbar != NULL)
1752         hr = m_staticToolbar->ShowWindow(fShow);
1753     if (FAILED(hr))
1754         return hr;
1755     if (m_SFToolbar != NULL)
1756         hr = m_SFToolbar->ShowWindow(fShow);
1757     if (FAILED(hr))
1758         return hr;
1759
1760     if (fShow)
1761         return _CallCB(SMC_INITMENU, 0, 0);
1762
1763     return S_OK;
1764 }
1765
1766 HRESULT STDMETHODCALLTYPE CMenuBand::CloseDW(DWORD dwReserved)
1767 {
1768     ShowDW(FALSE);
1769
1770     if (m_staticToolbar != NULL)
1771         return m_staticToolbar->Close();
1772
1773     if (m_SFToolbar != NULL)
1774         return m_SFToolbar->Close();
1775
1776     return S_OK;
1777 }
1778 HRESULT STDMETHODCALLTYPE CMenuBand::ResizeBorderDW(LPCRECT prcBorder, IUnknown *punkToolbarSite, BOOL fReserved)
1779 {
1780     UNIMPLEMENTED;
1781     return S_OK;
1782 }
1783
1784 HRESULT STDMETHODCALLTYPE CMenuBand::ContextSensitiveHelp(BOOL fEnterMode)
1785 {
1786     UNIMPLEMENTED;
1787     return S_OK;
1788 }
1789
1790 HRESULT STDMETHODCALLTYPE CMenuBand::UIActivateIO(BOOL fActivate, LPMSG lpMsg)
1791 {
1792     UNIMPLEMENTED;
1793     return S_OK;
1794 }
1795
1796 HRESULT STDMETHODCALLTYPE CMenuBand::HasFocusIO()
1797 {
1798     UNIMPLEMENTED;
1799     return S_OK;
1800 }
1801
1802 HRESULT STDMETHODCALLTYPE CMenuBand::TranslateAcceleratorIO(LPMSG lpMsg)
1803 {
1804     UNIMPLEMENTED;
1805     return S_OK;
1806 }
1807
1808 HRESULT STDMETHODCALLTYPE CMenuBand::IsDirty()
1809 {
1810     UNIMPLEMENTED;
1811     return S_OK;
1812 }
1813
1814 HRESULT STDMETHODCALLTYPE CMenuBand::Load(IStream *pStm)
1815 {
1816     UNIMPLEMENTED;
1817     return S_OK;
1818 }
1819
1820 HRESULT STDMETHODCALLTYPE CMenuBand::Save(IStream *pStm, BOOL fClearDirty)
1821 {
1822     UNIMPLEMENTED;
1823     return S_OK;
1824 }
1825
1826 HRESULT STDMETHODCALLTYPE CMenuBand::GetSizeMax(ULARGE_INTEGER *pcbSize)
1827 {
1828     UNIMPLEMENTED;
1829     return S_OK;
1830 }
1831
1832 HRESULT STDMETHODCALLTYPE CMenuBand::GetClassID(CLSID *pClassID)
1833 {
1834     UNIMPLEMENTED;
1835     return S_OK;
1836 }
1837
1838 HRESULT STDMETHODCALLTYPE CMenuBand::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds [], OLECMDTEXT *pCmdText)
1839 {
1840     UNIMPLEMENTED;
1841     return S_OK;
1842 }
1843
1844 HRESULT STDMETHODCALLTYPE CMenuBand::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
1845 {
1846     if (!pguidCmdGroup)
1847         return E_FAIL;
1848
1849     if (IsEqualGUID(*pguidCmdGroup, CLSID_MenuBand))
1850     {
1851         if (nCmdID == 16) // set (big) icon size
1852         {
1853             this->m_useBigIcons = TRUE;
1854             return S_OK;
1855         }
1856         else if (nCmdID == 19) // popup-related
1857         {
1858             return S_FALSE;
1859         }
1860     }
1861
1862     UNIMPLEMENTED;
1863     return S_OK;
1864 }
1865
1866 HRESULT STDMETHODCALLTYPE CMenuBand::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
1867 {
1868     if (IsEqualIID(guidService, SID_SMenuBandChild) ||
1869         IsEqualIID(guidService, SID_SMenuBandBottom) ||
1870         IsEqualIID(guidService, SID_SMenuBandBottomSelected))
1871         return this->QueryInterface(riid, ppvObject);
1872     WARN("Unknown service requested %s\n", wine_dbgstr_guid(&guidService));
1873     return E_NOINTERFACE;
1874 }
1875
1876 HRESULT STDMETHODCALLTYPE CMenuBand::Popup(POINTL *ppt, RECTL *prcExclude, MP_POPUPFLAGS dwFlags)
1877 {
1878     UNIMPLEMENTED;
1879     return S_OK;
1880 }
1881
1882 HRESULT STDMETHODCALLTYPE CMenuBand::OnSelect(DWORD dwSelectType)
1883 {
1884     CComPtr<IMenuPopup> pmp;
1885     HRESULT hr = IUnknown_QueryService(m_site, SID_SMenuPopup, IID_PPV_ARG(IMenuPopup, &pmp));
1886     if (FAILED(hr))
1887         return hr;
1888     pmp->OnSelect(dwSelectType);
1889     return S_OK;
1890 }
1891
1892 HRESULT STDMETHODCALLTYPE CMenuBand::SetSubMenu(IMenuPopup *pmp, BOOL fSet)
1893 {
1894     UNIMPLEMENTED;
1895     return S_OK;
1896 }
1897
1898 HRESULT STDMETHODCALLTYPE CMenuBand::SetClient(IUnknown *punkClient)
1899 {
1900     UNIMPLEMENTED;
1901     return S_OK;
1902 }
1903
1904 HRESULT STDMETHODCALLTYPE CMenuBand::GetClient(IUnknown **ppunkClient)
1905 {
1906     UNIMPLEMENTED;
1907     return S_OK;
1908 }
1909
1910 HRESULT STDMETHODCALLTYPE CMenuBand::IsMenuMessage(MSG *pmsg)
1911 {
1912     //UNIMPLEMENTED;
1913     //return S_OK;
1914     return S_FALSE;
1915     //return E_NOTIMPL;
1916 }
1917
1918 HRESULT STDMETHODCALLTYPE CMenuBand::TranslateMenuMessage(MSG *pmsg, LRESULT *plRet)
1919 {
1920     //UNIMPLEMENTED;
1921     return S_FALSE;
1922 }
1923
1924 HRESULT STDMETHODCALLTYPE CMenuBand::SetShellFolder(IShellFolder *psf, LPCITEMIDLIST pidlFolder, HKEY hKey, DWORD dwFlags)
1925 {
1926     if (m_SFToolbar == NULL)
1927     {
1928         m_SFToolbar = new CMenuSFToolbar(this);
1929     }
1930
1931     HRESULT hResult = m_SFToolbar->SetShellFolder(psf, pidlFolder, hKey, dwFlags);
1932     if (FAILED(hResult))
1933         return hResult;
1934
1935     if (m_site)
1936     {
1937         HWND hwndParent;
1938
1939         hResult = m_site->GetWindow(&hwndParent);
1940         if (FAILED(hResult))
1941             return hResult;
1942
1943         hResult = m_SFToolbar->CreateToolbar(hwndParent, m_dwFlags);
1944         if (FAILED(hResult))
1945             return hResult;
1946
1947         hResult = m_SFToolbar->FillToolbar();
1948     }
1949
1950     return hResult;
1951 }
1952
1953 HRESULT STDMETHODCALLTYPE CMenuBand::GetShellFolder(DWORD *pdwFlags, LPITEMIDLIST *ppidl, REFIID riid, void **ppv)
1954 {
1955     if (m_SFToolbar)
1956         return m_SFToolbar->GetShellFolder(pdwFlags, ppidl, riid, ppv);
1957     return E_FAIL;
1958 }
1959
1960 HRESULT STDMETHODCALLTYPE CMenuBand::InvalidateItem(LPSMDATA psmd, DWORD dwFlags)
1961 {
1962     UNIMPLEMENTED;
1963     return S_OK;
1964 }
1965
1966 HRESULT STDMETHODCALLTYPE CMenuBand::GetState(LPSMDATA psmd)
1967 {
1968     UNIMPLEMENTED;
1969     return S_OK;
1970 }
1971
1972 HRESULT STDMETHODCALLTYPE CMenuBand::SetMenuToolbar(IUnknown *punk, DWORD dwFlags)
1973 {
1974     UNIMPLEMENTED;
1975     return S_OK;
1976 }
1977
1978 HRESULT STDMETHODCALLTYPE CMenuBand::OnWinEvent(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult)
1979 {
1980     *theResult = 0;
1981     switch (uMsg)
1982     {
1983     case WM_COMMAND:
1984
1985         if (m_staticToolbar && m_staticToolbar->IsWindowOwner(hWnd))
1986         {
1987             return m_staticToolbar->OnCommand(wParam, lParam, theResult);
1988         }
1989
1990         if (m_SFToolbar && m_SFToolbar->IsWindowOwner(hWnd))
1991         {
1992             return m_SFToolbar->OnCommand(wParam, lParam, theResult);
1993         }
1994
1995         return S_OK;
1996
1997     case WM_NOTIFY:
1998         NMHDR * hdr = reinterpret_cast<LPNMHDR>(lParam);
1999         NMTBCUSTOMDRAW * cdraw;
2000         NMTBHOTITEM * hot;
2001         NMMOUSE * rclick;
2002         switch (hdr->code)
2003         {
2004         case TBN_HOTITEMCHANGE:
2005             hot = reinterpret_cast<LPNMTBHOTITEM>(hdr);
2006
2007             if (m_staticToolbar && m_staticToolbar->IsWindowOwner(hWnd))
2008             {
2009                 return m_staticToolbar->OnHotItemChange(hot);
2010             }
2011
2012             if (m_SFToolbar && m_SFToolbar->IsWindowOwner(hWnd))
2013             {
2014                 return m_SFToolbar->OnHotItemChange(hot);
2015             }
2016
2017             return S_OK;
2018
2019         case NM_RCLICK:
2020             rclick = reinterpret_cast<LPNMMOUSE>(hdr);
2021
2022             if (m_staticToolbar && m_staticToolbar->IsWindowOwner(hWnd))
2023             {
2024                 return m_staticToolbar->OnContextMenu(rclick);
2025             }
2026
2027             if (m_SFToolbar && m_SFToolbar->IsWindowOwner(hWnd))
2028             {
2029                 return m_SFToolbar->OnContextMenu(rclick);
2030             }
2031
2032             return S_OK;
2033         case NM_CUSTOMDRAW:
2034             cdraw = reinterpret_cast<LPNMTBCUSTOMDRAW>(hdr);
2035             switch (cdraw->nmcd.dwDrawStage)
2036             {
2037             case CDDS_PREPAINT:
2038                 *theResult = CDRF_NOTIFYITEMDRAW;
2039                 return S_OK;
2040
2041             case CDDS_ITEMPREPAINT:
2042
2043                 cdraw->clrBtnFace = GetSysColor(COLOR_MENU);
2044                 cdraw->clrBtnHighlight = GetSysColor(COLOR_MENUHILIGHT);
2045
2046                 cdraw->clrText = GetSysColor(COLOR_MENUTEXT);
2047                 cdraw->clrTextHighlight = GetSysColor(COLOR_HIGHLIGHTTEXT);
2048                 cdraw->clrHighlightHotTrack = GetSysColor(COLOR_HIGHLIGHTTEXT);
2049
2050                 RECT rc = cdraw->nmcd.rc;
2051                 HDC hdc = cdraw->nmcd.hdc;
2052
2053                 HBRUSH bgBrush = GetSysColorBrush(COLOR_MENU);
2054                 HBRUSH hotBrush = GetSysColorBrush(COLOR_MENUHILIGHT);
2055
2056                 switch (cdraw->nmcd.uItemState)
2057                 {
2058                 case CDIS_HOT:
2059                 case CDIS_FOCUS:
2060                     FillRect(hdc, &rc, hotBrush);
2061                     break;
2062                 default:
2063                     FillRect(hdc, &rc, bgBrush);
2064                     break;
2065                 }
2066
2067                 *theResult = TBCDRF_NOBACKGROUND | TBCDRF_NOEDGES | TBCDRF_NOETCHEDEFFECT | TBCDRF_HILITEHOTTRACK | TBCDRF_NOOFFSET;
2068                 return S_OK;
2069             }
2070             return S_OK;
2071         }
2072         return S_OK;
2073     }
2074
2075     return S_FALSE;
2076 }
2077
2078 HRESULT STDMETHODCALLTYPE CMenuBand::IsWindowOwner(HWND hWnd)
2079 {
2080     if (m_staticToolbar && m_staticToolbar->IsWindowOwner(hWnd))
2081         return S_OK;
2082
2083     if (m_SFToolbar && m_SFToolbar->IsWindowOwner(hWnd))
2084         return S_OK;
2085
2086     return S_FALSE;
2087 }
2088
2089 HRESULT STDMETHODCALLTYPE CMenuBand::GetSubMenu(THIS)
2090 {
2091     UNIMPLEMENTED;
2092     return S_OK;
2093 }
2094
2095 HRESULT STDMETHODCALLTYPE CMenuBand::SetToolbar(THIS)
2096 {
2097     UNIMPLEMENTED;
2098     return S_OK;
2099 }
2100
2101 HRESULT STDMETHODCALLTYPE CMenuBand::SetMinWidth(THIS)
2102 {
2103     UNIMPLEMENTED;
2104     return S_OK;
2105 }
2106
2107 HRESULT STDMETHODCALLTYPE CMenuBand::SetNoBorder(THIS)
2108 {
2109     UNIMPLEMENTED;
2110     return S_OK;
2111 }
2112
2113 HRESULT STDMETHODCALLTYPE CMenuBand::SetTheme(THIS)
2114 {
2115     UNIMPLEMENTED;
2116     return S_OK;
2117 }
2118
2119 HRESULT STDMETHODCALLTYPE CMenuBand::GetTop(THIS)
2120 {
2121     UNIMPLEMENTED;
2122     return S_OK;
2123 }
2124
2125 HRESULT STDMETHODCALLTYPE CMenuBand::GetBottom(THIS)
2126 {
2127     UNIMPLEMENTED;
2128     return S_OK;
2129 }
2130
2131 HRESULT STDMETHODCALLTYPE CMenuBand::GetTracked(THIS)
2132 {
2133     UNIMPLEMENTED;
2134     return S_OK;
2135 }
2136
2137 HRESULT STDMETHODCALLTYPE CMenuBand::GetParentSite(THIS)
2138 {
2139     UNIMPLEMENTED;
2140     return S_OK;
2141 }
2142
2143 HRESULT STDMETHODCALLTYPE CMenuBand::GetState(THIS)
2144 {
2145     UNIMPLEMENTED;
2146     return S_OK;
2147 }
2148
2149 HRESULT STDMETHODCALLTYPE CMenuBand::DoDefaultAction(THIS)
2150 {
2151     UNIMPLEMENTED;
2152     return S_OK;
2153 }
2154
2155 HRESULT STDMETHODCALLTYPE CMenuBand::IsEmpty(THIS)
2156 {
2157     UNIMPLEMENTED;
2158     return S_OK;
2159 }
2160
2161 HRESULT CMenuBand::CallCBWithId(UINT id, UINT uMsg, WPARAM wParam, LPARAM lParam)
2162 {
2163     return _CallCB(uMsg, wParam, lParam, id);
2164 }
2165
2166 HRESULT CMenuBand::CallCBWithPidl(LPITEMIDLIST pidl, UINT uMsg, WPARAM wParam, LPARAM lParam)
2167 {
2168     return _CallCB(uMsg, wParam, lParam, 0, pidl);
2169 }
2170
2171 HRESULT CMenuBand::_CallCB(UINT uMsg, WPARAM wParam, LPARAM lParam, UINT id, LPITEMIDLIST pidl)
2172 {
2173     if (!m_psmc)
2174         return S_FALSE;
2175
2176     HWND hwnd;
2177     GetWindow(&hwnd);
2178
2179     SMDATA smData = { 0 };
2180     smData.punk = static_cast<IShellMenu2*>(this);
2181     smData.uId = id;
2182     smData.uIdParent = m_uId;
2183     smData.uIdAncestor = m_uIdAncestor;
2184     smData.hwnd = hwnd;
2185     smData.pidlItem = pidl;
2186     if (m_staticToolbar)
2187     {
2188         smData.hmenu = m_hmenu;
2189     }
2190     smData.pvUserData = NULL;
2191     if (m_SFToolbar)
2192         m_SFToolbar->GetShellFolder(NULL, &smData.pidlFolder, IID_PPV_ARG(IShellFolder, &smData.psf));
2193     HRESULT hr = m_psmc->CallbackSM(&smData, uMsg, wParam, lParam);
2194     ILFree(smData.pidlFolder);
2195     if (smData.psf)
2196         smData.psf->Release();
2197     return hr;
2198 }
2199 #endif