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