base/shell/rshell/CMenuDeskBar.cpp

   1 /*
   2 * Shell Menu Desk Bar
   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 <atlwin.h>
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(CMenuDeskBar);
  25
  26 #define WRAP_LOG 1
  27
  28 typedef CWinTraits<
  29     WS_POPUP | WS_DLGFRAME | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
  30     WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR | WS_EX_PALETTEWINDOW
  31 > CMenuWinTraits;
  32
  33 class CMenuDeskBar :
  34 #if !WRAP_LOG
  35     public CWindowImpl<CMenuDeskBar, CWindow, CMenuWinTraits>,
  36 #endif
  37     public CComCoClass<CMenuDeskBar>,
  38     public CComObjectRootEx<CComMultiThreadModelNoCS>,
  39     public IOleCommandTarget,
  40     public IServiceProvider,
  41     public IInputObjectSite,
  42     public IInputObject,
  43     public IMenuPopup,
  44     public IObjectWithSite,
  45     public IBanneredBar,
  46     public IInitializeObject
  47 {
  48 public:
  49     CMenuDeskBar();
  50     ~CMenuDeskBar();
  51
  52 private:
  53 #if WRAP_LOG
  54     IUnknown * m_IUnknown;
  55     IMenuPopup * m_IMenuPopup;
  56     IOleCommandTarget * m_IOleCommandTarget;
  57     IServiceProvider * m_IServiceProvider;
  58     IDeskBar * m_IDeskBar;
  59     IOleWindow * m_IOleWindow;
  60     IInputObjectSite * m_IInputObjectSite;
  61     IInputObject * m_IInputObject;
  62     IObjectWithSite * m_IObjectWithSite;
  63     IBanneredBar * m_IBanneredBar;
  64     IInitializeObject * m_IInitializeObject;
  65 #else
  66
  67     CComPtr<IUnknown>                       m_Site;
  68     CComPtr<IUnknown>                       m_Client;
  69     HWND                                    m_ClientWindow;
  70     bool                                    m_Vertical;
  71     bool                                    m_Visible;
  72     int                                     m_NeededSize;        // width or height
  73
  74     DWORD m_IconSize;
  75     HBITMAP m_Banner;
  76
  77     // used by resize tracking loop
  78     bool                                    m_Tracking;
  79     POINT                                   m_LastLocation;
  80 #endif
  81
  82 public:
  83     // *** IMenuPopup methods ***
  84     virtual HRESULT STDMETHODCALLTYPE Popup(POINTL *ppt, RECTL *prcExclude, MP_POPUPFLAGS dwFlags);
  85     virtual HRESULT STDMETHODCALLTYPE OnSelect(DWORD dwSelectType);
  86     virtual HRESULT STDMETHODCALLTYPE SetSubMenu(IMenuPopup *pmp, BOOL fSet);
  87
  88     // *** IOleWindow methods ***
  89     virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND *phwnd);
  90     virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode);
  91
  92     // *** IObjectWithSite methods ***
  93     virtual HRESULT STDMETHODCALLTYPE SetSite(IUnknown *pUnkSite);
  94     virtual HRESULT STDMETHODCALLTYPE GetSite(REFIID riid, PVOID *ppvSite);
  95
  96     // *** IBanneredBar methods ***
  97     virtual HRESULT STDMETHODCALLTYPE SetIconSize(DWORD iIcon);
  98     virtual HRESULT STDMETHODCALLTYPE GetIconSize(DWORD* piIcon);
  99     virtual HRESULT STDMETHODCALLTYPE SetBitmap(HBITMAP hBitmap);
 100     virtual HRESULT STDMETHODCALLTYPE GetBitmap(HBITMAP* phBitmap);
 101
 102     // *** IInitializeObject methods ***
 103     virtual HRESULT STDMETHODCALLTYPE Initialize(THIS);
 104
 105     // *** IOleCommandTarget methods ***
 106     virtual HRESULT STDMETHODCALLTYPE QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds [], OLECMDTEXT *pCmdText);
 107     virtual HRESULT STDMETHODCALLTYPE Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut);
 108
 109     // *** IServiceProvider methods ***
 110     virtual HRESULT STDMETHODCALLTYPE QueryService(REFGUID guidService, REFIID riid, void **ppvObject);
 111
 112     // *** IInputObjectSite methods ***
 113     virtual HRESULT STDMETHODCALLTYPE OnFocusChangeIS(LPUNKNOWN lpUnknown, BOOL bFocus);
 114
 115     // *** IInputObject methods ***
 116     virtual HRESULT STDMETHODCALLTYPE UIActivateIO(BOOL bActivating, LPMSG lpMsg);
 117     virtual HRESULT STDMETHODCALLTYPE HasFocusIO(THIS);
 118     virtual HRESULT STDMETHODCALLTYPE TranslateAcceleratorIO(LPMSG lpMsg);
 119
 120     // *** IDeskBar methods ***
 121     virtual HRESULT STDMETHODCALLTYPE SetClient(IUnknown *punkClient);
 122     virtual HRESULT STDMETHODCALLTYPE GetClient(IUnknown **ppunkClient);
 123     virtual HRESULT STDMETHODCALLTYPE OnPosRectChangeDB(LPRECT prc);
 124
 125     // message handlers
 126     LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 127     LRESULT OnNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 128     LRESULT OnLButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 129     LRESULT OnLButtonUp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 130     LRESULT OnMouseMove(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 131     LRESULT OnCancelMode(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 132     LRESULT OnCaptureChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 133     LRESULT OnWindowPosChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 134     LRESULT OnActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 135     LRESULT OnPaint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 136
 137     DECLARE_NOT_AGGREGATABLE(CMenuDeskBar)
 138     DECLARE_PROTECT_FINAL_CONSTRUCT()
 139
 140 #if !WRAP_LOG
 141     DECLARE_WND_CLASS_EX(_T("BaseBar"), 0, COLOR_3DFACE)
 142 #endif
 143
 144     BEGIN_MSG_MAP(CMenuDeskBar)
 145         MESSAGE_HANDLER(WM_SIZE, OnSize)
 146         MESSAGE_HANDLER(WM_NOTIFY, OnNotify)
 147         MESSAGE_HANDLER(WM_LBUTTONDOWN, OnLButtonDown)
 148         MESSAGE_HANDLER(WM_LBUTTONUP, OnLButtonUp)
 149         MESSAGE_HANDLER(WM_MOUSEMOVE, OnMouseMove)
 150         MESSAGE_HANDLER(WM_CANCELMODE, OnCancelMode)
 151         MESSAGE_HANDLER(WM_CAPTURECHANGED, OnCaptureChanged)
 152         MESSAGE_HANDLER(WM_WINDOWPOSCHANGED, OnWindowPosChanged)
 153         MESSAGE_HANDLER(WM_ACTIVATE, OnActivate)
 154 /*        MESSAGE_HANDLER(WM_PAINT, OnPaint) */
 155     END_MSG_MAP()
 156
 157     BEGIN_COM_MAP(CMenuDeskBar)
 158         COM_INTERFACE_ENTRY_IID(IID_IMenuPopup, IMenuPopup)
 159         COM_INTERFACE_ENTRY_IID(IID_IOleCommandTarget, IOleCommandTarget)
 160         COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider)
 161         COM_INTERFACE_ENTRY_IID(IID_IInputObjectSite, IInputObjectSite)
 162         COM_INTERFACE_ENTRY_IID(IID_IInputObject, IInputObject)
 163         COM_INTERFACE_ENTRY_IID(IID_IDeskBar, IMenuPopup)
 164         COM_INTERFACE_ENTRY_IID(IID_IOleWindow, IMenuPopup)
 165         COM_INTERFACE_ENTRY_IID(IID_IObjectWithSite, IObjectWithSite)
 166         COM_INTERFACE_ENTRY_IID(IID_IBanneredBar, IBanneredBar)
 167         COM_INTERFACE_ENTRY_IID(IID_IInitializeObject, IInitializeObject)
 168     END_COM_MAP()
 169 };
 170
 171 extern "C"
 172 HRESULT CMenuDeskBar_Constructor(REFIID riid, LPVOID *ppv)
 173 {
 174     *ppv = NULL;
 175
 176     CMenuDeskBar * deskbar = new CComObject<CMenuDeskBar>();
 177
 178     if (!deskbar)
 179         return E_OUTOFMEMORY;
 180
 181     HRESULT hr = deskbar->QueryInterface(riid, ppv);
 182
 183     if (FAILED(hr))
 184         deskbar->Release();
 185
 186     return hr;
 187 }
 188
 189 #if WRAP_LOG
 190 CMenuDeskBar::CMenuDeskBar()
 191 {
 192     HRESULT hr;
 193     WrapLogOpen();
 194
 195     hr = CoCreateInstance(CLSID_MenuDeskBar, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IMenuPopup, &m_IMenuPopup));
 196     hr = m_IMenuPopup->QueryInterface(IID_PPV_ARG(IUnknown, &m_IUnknown));
 197
 198     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &m_IOleCommandTarget));
 199     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IServiceProvider, &m_IServiceProvider));
 200     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IDeskBar, &m_IDeskBar));
 201     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IOleWindow, &m_IOleWindow));
 202     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IInputObjectSite, &m_IInputObjectSite));
 203     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IInputObject, &m_IInputObject));
 204     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IObjectWithSite, &m_IObjectWithSite));
 205     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IBanneredBar, &m_IBanneredBar));
 206     hr = m_IUnknown->QueryInterface(IID_PPV_ARG(IInitializeObject, &m_IInitializeObject));
 207 }
 208
 209 CMenuDeskBar::~CMenuDeskBar()
 210 {
 211     m_IUnknown->Release();
 212     m_IMenuPopup->Release();
 213     m_IOleCommandTarget->Release();
 214     m_IServiceProvider->Release();
 215     m_IDeskBar->Release();
 216     m_IOleWindow->Release();
 217     m_IInputObjectSite->Release();
 218     m_IInputObject->Release();
 219     m_IObjectWithSite->Release();
 220     m_IBanneredBar->Release();
 221     m_IInitializeObject->Release();
 222
 223     WrapLogClose();
 224 }
 225
 226 // *** IMenuPopup methods ***
 227 HRESULT STDMETHODCALLTYPE CMenuDeskBar::Popup(POINTL *ppt, RECTL *prcExclude, MP_POPUPFLAGS dwFlags)
 228 {
 229     WrapLogEnter("CMenuDeskBar<%p>::Popup(POINTL *ppt=%p, RECTL *prcExclude=%p, MP_POPUPFLAGS dwFlags=%08x)\n", this, ppt, prcExclude, dwFlags);
 230     HRESULT hr = m_IMenuPopup->Popup(ppt, prcExclude, dwFlags);
 231     WrapLogExit("CMenuDeskBar::Popup() = %08x\n", hr);
 232     return hr;
 233 }
 234
 235 HRESULT STDMETHODCALLTYPE CMenuDeskBar::OnSelect(DWORD dwSelectType)
 236 {
 237     WrapLogEnter("CMenuDeskBar<%p>::OnSelect(DWORD dwSelectType=%08x)\n", this, dwSelectType);
 238     HRESULT hr = m_IMenuPopup->OnSelect(dwSelectType);
 239     WrapLogExit("CMenuDeskBar::OnSelect() = %08x\n", hr);
 240     return hr;
 241 }
 242
 243 HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetSubMenu(IMenuPopup *pmp, BOOL fSet)
 244 {
 245     WrapLogEnter("CMenuDeskBar<%p>::SetSubMenu(IMenuPopup *pmp=%p, BOOL fSet=%d)\n", this, pmp, fSet);
 246     HRESULT hr = m_IMenuPopup->SetSubMenu(pmp, fSet);
 247     WrapLogExit("CMenuDeskBar::SetSubMenu() = %08x\n", hr);
 248     return hr;
 249 }
 250
 251 // *** IOleWindow methods ***
 252 HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetWindow(HWND *phwnd)
 253 {
 254     WrapLogEnter("CMenuDeskBar<%p>::GetWindow(HWND *phwnd=%p)\n", this, phwnd);
 255     HRESULT hr = m_IOleWindow->GetWindow(phwnd);
 256     if (phwnd) WrapLogMsg("*phwnd=%p\n", *phwnd);
 257     WrapLogExit("CMenuDeskBar::GetWindow() = %08x\n", hr);
 258     return hr;
 259 }
 260
 261 HRESULT STDMETHODCALLTYPE CMenuDeskBar::ContextSensitiveHelp(BOOL fEnterMode)
 262 {
 263     WrapLogEnter("CMenuDeskBar<%p>::ContextSensitiveHelp(BOOL fEnterMode=%d)\n", this, fEnterMode);
 264     HRESULT hr = m_IOleWindow->ContextSensitiveHelp(fEnterMode);
 265     WrapLogExit("CMenuDeskBar::ContextSensitiveHelp() = %08x\n", hr);
 266     return hr;
 267 }
 268
 269 // *** IObjectWithSite methods ***
 270 HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetSite(IUnknown *pUnkSite)
 271 {
 272     WrapLogEnter("CMenuDeskBar<%p>::SetSite(IUnknown *pUnkSite=%p)\n", this, pUnkSite);
 273     HRESULT hr = m_IObjectWithSite->SetSite(pUnkSite);
 274     WrapLogExit("CMenuDeskBar::SetSite() = %08x\n", hr);
 275     return hr;
 276 }
 277
 278 HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetSite(REFIID riid, PVOID *ppvSite)
 279 {
 280     WrapLogEnter("CMenuDeskBar<%p>::GetSite(REFIID riid=%s, PVOID *ppvSite=%p)\n", this, Wrap(riid), ppvSite);
 281     HRESULT hr = m_IObjectWithSite->GetSite(riid, ppvSite);
 282     if (ppvSite) WrapLogMsg("*ppvSite=%p\n", *ppvSite);
 283     WrapLogExit("CMenuDeskBar::GetSite() = %08x\n", hr);
 284     return hr;
 285 }
 286
 287 // *** IBanneredBar methods ***
 288 HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetIconSize(DWORD iIcon)
 289 {
 290     WrapLogEnter("CMenuDeskBar<%p>::SetIconSize(DWORD iIcon=%d)\n", this, iIcon);
 291     HRESULT hr = m_IBanneredBar->SetIconSize(iIcon);
 292     WrapLogExit("CMenuDeskBar::SetIconSize() = %08x\n", hr);
 293     return hr;
 294 }
 295
 296 HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetIconSize(DWORD* piIcon)
 297 {
 298     WrapLogEnter("CMenuDeskBar<%p>::GetIconSize(DWORD* piIcon=%p)\n", this, piIcon);
 299     HRESULT hr = m_IBanneredBar->GetIconSize(piIcon);
 300     if (piIcon) WrapLogMsg("*piIcon=%d\n", *piIcon);
 301     WrapLogExit("CMenuDeskBar::GetIconSize() = %08x\n", hr);
 302     return hr;
 303 }
 304
 305 HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetBitmap(HBITMAP hBitmap)
 306 {
 307     WrapLogEnter("CMenuDeskBar<%p>::SetBitmap(HBITMAP hBitmap=%p)\n", this, hBitmap);
 308     HRESULT hr = m_IBanneredBar->SetBitmap(hBitmap);
 309     WrapLogExit("CMenuDeskBar::SetBitmap() = %08x\n", hr);
 310     return hr;
 311 }
 312
 313 HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetBitmap(HBITMAP* phBitmap)
 314 {
 315     WrapLogEnter("CMenuDeskBar<%p>::GetBitmap(HBITMAP* phBitmap=%p)\n", this, phBitmap);
 316     HRESULT hr = m_IBanneredBar->GetBitmap(phBitmap);
 317     if (phBitmap) WrapLogMsg("*phBitmap=%p\n", *phBitmap);
 318     WrapLogExit("CMenuDeskBar::GetBitmap() = %08x\n", hr);
 319     return hr;
 320 }
 321
 322
 323 // *** IInitializeObject methods ***
 324 HRESULT STDMETHODCALLTYPE CMenuDeskBar::Initialize(THIS)
 325 {
 326     WrapLogEnter("CMenuDeskBar<%p>::Initialize()\n", this);
 327     HRESULT hr = m_IInitializeObject->Initialize();
 328     WrapLogExit("CMenuDeskBar::Initialize() = %08x\n", hr);
 329     return hr;
 330 }
 331
 332 // *** IOleCommandTarget methods ***
 333 HRESULT STDMETHODCALLTYPE CMenuDeskBar::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds [], OLECMDTEXT *pCmdText)
 334 {
 335     WrapLogEnter("CMenuDeskBar<%p>::QueryStatus(const GUID *pguidCmdGroup=%p, ULONG cCmds=%u, prgCmds=%p, pCmdText=%p)\n", this, pguidCmdGroup, cCmds, prgCmds, pCmdText);
 336     HRESULT hr = m_IOleCommandTarget->QueryStatus(pguidCmdGroup, cCmds, prgCmds, pCmdText);
 337     if (pguidCmdGroup) WrapLogMsg("*pguidCmdGroup=%s\n", Wrap(*pguidCmdGroup));
 338     WrapLogExit("CMenuDeskBar::QueryStatus() = %08x\n", hr);
 339     return hr;
 340 }
 341
 342 HRESULT STDMETHODCALLTYPE CMenuDeskBar::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 343 {
 344     //bool b;
 345
 346     WrapLogEnter("CMenuDeskBar<%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);
 347
 348     //if (pguidCmdGroup && IsEqualGUID(*pguidCmdGroup, CLSID_MenuBand))
 349     //{
 350     //    if (nCmdID == 19) // popup
 351     //    {
 352     //        b = true;
 353     //    }
 354     //}
 355
 356
 357     if (pguidCmdGroup) WrapLogMsg("*pguidCmdGroup=%s\n", Wrap(*pguidCmdGroup));
 358     HRESULT hr = m_IOleCommandTarget->Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
 359     WrapLogExit("CMenuDeskBar::Exec() = %08x\n", hr);
 360     return hr;
 361 }
 362
 363 // *** IServiceProvider methods ***
 364 HRESULT STDMETHODCALLTYPE CMenuDeskBar::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
 365 {
 366     WrapLogEnter("CMenuDeskBar<%p>::QueryService(REFGUID guidService=%s, REFIID riid=%s, void **ppvObject=%p)\n", this, Wrap(guidService), Wrap(riid), ppvObject);
 367
 368     //if (IsEqualIID(guidService, SID_SMenuBandChild))
 369     //{
 370     //    WrapLogMsg("SID is SID_SMenuBandChild. Using QueryInterface of self instead of wrapped object.\n");
 371     //    HRESULT hr = this->QueryInterface(riid, ppvObject);
 372     //    if (ppvObject) WrapLogMsg("*ppvObject=%p\n", *ppvObject);
 373     //    WrapLogExit("CMenuDeskBar::QueryService() = %08x\n", hr);
 374     //    return hr;
 375     //}
 376     //else
 377     {
 378         WrapLogMsg("SID not identified.\n");
 379     }
 380     HRESULT hr = m_IServiceProvider->QueryService(guidService, riid, ppvObject);
 381     if (ppvObject) WrapLogMsg("*ppvObject=%p\n", *ppvObject);
 382     WrapLogExit("CMenuDeskBar::QueryService() = %08x\n", hr);
 383     return hr;
 384 }
 385
 386 // *** IInputObjectSite methods ***
 387 HRESULT STDMETHODCALLTYPE CMenuDeskBar::OnFocusChangeIS(LPUNKNOWN lpUnknown, BOOL bFocus)
 388 {
 389     WrapLogEnter("CMenuDeskBar<%p>::OnFocusChangeIS(LPUNKNOWN lpUnknown=%p, BOOL bFocus=%d)\n", this, lpUnknown, bFocus);
 390     HRESULT hr = m_IInputObjectSite->OnFocusChangeIS(lpUnknown, bFocus);
 391     WrapLogExit("CMenuDeskBar::OnFocusChangeIS() = %08x\n", hr);
 392     return hr;
 393 }
 394
 395 // *** IInputObject methods ***
 396 HRESULT STDMETHODCALLTYPE CMenuDeskBar::UIActivateIO(BOOL bActivating, LPMSG lpMsg)
 397 {
 398     WrapLogEnter("CMenuDeskBar<%p>::UIActivateIO(BOOL bActivating=%d, LPMSG lpMsg=%p)\n", this, bActivating, lpMsg);
 399     HRESULT hr = m_IInputObject->UIActivateIO(bActivating, lpMsg);
 400     WrapLogExit("CMenuDeskBar::UIActivateIO() = %08x\n", hr);
 401     return hr;
 402 }
 403
 404 HRESULT STDMETHODCALLTYPE CMenuDeskBar::HasFocusIO(THIS)
 405 {
 406     WrapLogEnter("CMenuDeskBar<%p>::HasFocusIO()\n", this);
 407     HRESULT hr = m_IInputObject->HasFocusIO();
 408     WrapLogExit("CMenuDeskBar::HasFocusIO() = %08x\n", hr);
 409     return hr;
 410 }
 411
 412 HRESULT STDMETHODCALLTYPE CMenuDeskBar::TranslateAcceleratorIO(LPMSG lpMsg)
 413 {
 414     WrapLogEnter("CMenuDeskBar<%p>::TranslateAcceleratorIO(LPMSG lpMsg=%p)\n", this, lpMsg);
 415     if (lpMsg) WrapLogMsg("*lpMsg=%s\n", Wrap(*lpMsg));
 416     HRESULT hr = m_IInputObject->TranslateAcceleratorIO(lpMsg);
 417     WrapLogExit("CMenuDeskBar::TranslateAcceleratorIO() = %08x\n", hr);
 418     return hr;
 419 }
 420
 421 // *** IDeskBar methods ***
 422 HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetClient(IUnknown *punkClient)
 423 {
 424     WrapLogEnter("CMenuDeskBar<%p>::SetClient(IUnknown *punkClient=%p)\n", this, punkClient);
 425     HRESULT hr = m_IDeskBar->SetClient(punkClient);
 426     WrapLogExit("CMenuDeskBar::SetClient() = %08x\n", hr);
 427     return hr;
 428 }
 429
 430 HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetClient(IUnknown **ppunkClient)
 431 {
 432     WrapLogEnter("CMenuDeskBar<%p>::GetClient(IUnknown **ppunkClient=%p)\n", this, ppunkClient);
 433     HRESULT hr = m_IDeskBar->GetClient(ppunkClient);
 434     if (ppunkClient) WrapLogMsg("*ppunkClient=%p\n", *ppunkClient);
 435     WrapLogExit("CMenuDeskBar::GetClient() = %08x\n", hr);
 436     return hr;
 437 }
 438
 439 HRESULT STDMETHODCALLTYPE CMenuDeskBar::OnPosRectChangeDB(LPRECT prc)
 440 {
 441     WrapLogEnter("CMenuDeskBar<%p>::OnPosRectChangeDB(RECT *prc=%p)\n", this, prc);
 442     HRESULT hr = m_IDeskBar->OnPosRectChangeDB(prc);
 443     if (prc) WrapLogMsg("*prc=%s\n", Wrap(*prc));
 444     WrapLogExit("CMenuDeskBar::OnPosRectChangeDB() = %08x\n", hr);
 445     return hr;
 446 }
 447 #else
 448
 449 CMenuDeskBar::CMenuDeskBar() :
 450     m_ClientWindow(NULL),
 451     m_Vertical(true),
 452     m_Visible(false),
 453     m_NeededSize(200),
 454     m_Tracking(false)
 455 {
 456 }
 457
 458 CMenuDeskBar::~CMenuDeskBar()
 459 {
 460 }
 461
 462 HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetWindow(HWND *lphwnd)
 463 {
 464     if (lphwnd == NULL)
 465         return E_POINTER;
 466     *lphwnd = m_hWnd;
 467     return S_OK;
 468 }
 469
 470 HRESULT STDMETHODCALLTYPE CMenuDeskBar::ContextSensitiveHelp(BOOL fEnterMode)
 471 {
 472     return E_NOTIMPL;
 473 }
 474
 475 HRESULT STDMETHODCALLTYPE CMenuDeskBar::OnFocusChangeIS(IUnknown *punkObj, BOOL fSetFocus)
 476 {
 477     // forward to owner
 478     return E_NOTIMPL;
 479 }
 480
 481 HRESULT STDMETHODCALLTYPE CMenuDeskBar::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds,
 482     OLECMD prgCmds[], OLECMDTEXT *pCmdText)
 483 {
 484     return E_NOTIMPL;
 485 }
 486
 487 HRESULT STDMETHODCALLTYPE CMenuDeskBar::Exec(const GUID *pguidCmdGroup, DWORD nCmdID,
 488     DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 489 {
 490     if (IsEqualIID(*pguidCmdGroup, CGID_Explorer))
 491     {
 492     }
 493     else if (IsEqualIID(*pguidCmdGroup, IID_IDeskBarClient))
 494     {
 495         switch (nCmdID)
 496         {
 497         case 0:
 498             // hide current band
 499             break;
 500         case 2:
 501             break;
 502         case 3:
 503             break;
 504         }
 505     }
 506     return E_NOTIMPL;
 507 }
 508
 509 HRESULT STDMETHODCALLTYPE CMenuDeskBar::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
 510 {
 511     CComPtr<IServiceProvider>               serviceProvider;
 512     HRESULT                                 hResult;
 513
 514     if (m_Site == NULL)
 515         return E_FAIL;
 516     hResult = m_Site->QueryInterface(IID_IServiceProvider, reinterpret_cast<void **>(&serviceProvider));
 517     if (FAILED(hResult))
 518         return hResult;
 519     // called for SID_STopLevelBrowser, IID_IBrowserService to find top level browser
 520     // called for SID_IWebBrowserApp, IID_IConnectionPointContainer
 521     // connection point called for DIID_DWebBrowserEvents2 to establish connection
 522     return serviceProvider->QueryService(guidService, riid, ppvObject);
 523 }
 524
 525 HRESULT STDMETHODCALLTYPE CMenuDeskBar::UIActivateIO(BOOL fActivate, LPMSG lpMsg)
 526 {
 527     // forward to contained bar
 528     return S_OK;
 529 }
 530
 531 HRESULT STDMETHODCALLTYPE CMenuDeskBar::HasFocusIO()
 532 {
 533     // forward to contained bar
 534     return S_OK;
 535 }
 536
 537 HRESULT STDMETHODCALLTYPE CMenuDeskBar::TranslateAcceleratorIO(LPMSG lpMsg)
 538 {
 539     // forward to contained bar
 540     return S_OK;
 541 }
 542
 543 HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetClient(IUnknown *punkClient)
 544 {
 545     CComPtr<IDeskBarClient>                 pDeskBandClient;
 546     HRESULT                                 hResult;
 547
 548     if (m_hWnd == NULL)
 549     {
 550         HWND ownerWindow = NULL;
 551         if (m_Site)
 552         {
 553             IOleWindow * oleWindow;
 554
 555             hResult = m_Site->QueryInterface(IID_IOleWindow, reinterpret_cast<void **>(&oleWindow));
 556             if (SUCCEEDED(hResult))
 557                 hResult = oleWindow->GetWindow(&ownerWindow);
 558
 559             if (!::IsWindow(ownerWindow))
 560                 return E_FAIL;
 561         }
 562
 563         Create(ownerWindow);
 564     }
 565
 566     if (punkClient == NULL)
 567         m_Client.Release();
 568     else
 569     {
 570         hResult = punkClient->QueryInterface(IID_IUnknown, reinterpret_cast<void **>(&m_Client));
 571         if (FAILED(hResult))
 572             return hResult;
 573
 574         hResult = m_Client->QueryInterface(IID_IDeskBarClient, (VOID**) &pDeskBandClient);
 575         if (FAILED(hResult))
 576             return hResult;
 577
 578         hResult = pDeskBandClient->SetDeskBarSite(static_cast<IDeskBar*>(this));
 579         if (FAILED(hResult))
 580             return hResult;
 581
 582     }
 583
 584     return S_OK;
 585 }
 586
 587 HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetClient(IUnknown **ppunkClient)
 588 {
 589     if (ppunkClient == NULL)
 590         return E_POINTER;
 591     *ppunkClient = m_Client;
 592     if (m_Client.p != NULL)
 593         m_Client.p->AddRef();
 594     return S_OK;
 595 }
 596
 597 HRESULT STDMETHODCALLTYPE CMenuDeskBar::OnPosRectChangeDB(LPRECT prc)
 598 {
 599     if (prc == NULL)
 600         return E_POINTER;
 601     return S_OK;
 602 }
 603
 604 HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetSite(IUnknown *pUnkSite)
 605 {
 606     return S_OK;
 607     CComPtr<IServiceProvider>               serviceProvider;
 608     CComPtr<IProfferService>                profferService;
 609     HRESULT                                 hResult;
 610     CComPtr<IOleWindow>                     oleWindow;
 611     HWND                                    ownerWindow;
 612
 613
 614     m_Site.Release();
 615     if (pUnkSite == NULL)
 616     {
 617         return S_OK;
 618     }
 619
 620     if (m_hWnd == NULL)
 621     {
 622         // get window handle of parent
 623         hResult = pUnkSite->QueryInterface(IID_ITrayPriv, reinterpret_cast<void **>(&m_Site));
 624         if (FAILED(hResult))
 625             return hResult;
 626
 627         hResult = pUnkSite->QueryInterface(IID_IOleWindow, reinterpret_cast<void **>(&oleWindow));
 628         if (SUCCEEDED(hResult))
 629             hResult = oleWindow->GetWindow(&ownerWindow);
 630
 631         if (!::IsWindow(ownerWindow))
 632             return E_FAIL;
 633
 634         Create(ownerWindow);
 635     }
 636     else
 637     {
 638         //Set Owner ?
 639     }
 640
 641     return S_OK;
 642 }
 643
 644 HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetSite(REFIID riid, void **ppvSite)
 645 {
 646     if (ppvSite == NULL)
 647         return E_POINTER;
 648     *ppvSite = m_Site;
 649     if (m_Site.p != NULL)
 650         m_Site.p->AddRef();
 651     return S_OK;
 652 }
 653
 654 LRESULT CMenuDeskBar::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
 655 {
 656     HRESULT hr;
 657
 658     if (m_Client)
 659     {
 660         CComPtr<IOleWindow> pOw;
 661         hr = m_Client->QueryInterface(IID_PPV_ARG(IOleWindow, &pOw));
 662         if (FAILED(hr))
 663         {
 664             ERR("IUnknown_QueryInterface pBs failed: %x\n", hr);
 665             return 0;
 666         }
 667
 668         HWND clientWnd;
 669         pOw->GetWindow(&clientWnd);
 670
 671         RECT rc;
 672
 673         GetClientRect(&rc);
 674
 675         if (m_Banner != NULL)
 676         {
 677             SIZE sz;
 678             ::GetBitmapDimensionEx(m_Banner, &sz);
 679             rc.left += sz.cx;
 680         }
 681
 682         ::SetWindowPos(clientWnd, NULL, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, 0);
 683     }
 684
 685     return 0;
 686 }
 687
 688 LRESULT CMenuDeskBar::OnNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
 689 {
 690     CComPtr<IWinEventHandler>               winEventHandler;
 691     LRESULT                                 result;
 692     HRESULT                                 hResult;
 693
 694     result = 0;
 695     if (m_Client.p != NULL)
 696     {
 697         hResult = m_Client->QueryInterface(IID_IWinEventHandler, reinterpret_cast<void **>(&winEventHandler));
 698         if (SUCCEEDED(hResult) && winEventHandler.p != NULL)
 699             hResult = winEventHandler->OnWinEvent(NULL, uMsg, wParam, lParam, &result);
 700     }
 701     return result;
 702 }
 703
 704 LRESULT CMenuDeskBar::OnLButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
 705 {
 706     SetCapture();
 707     m_Tracking = true;
 708     m_LastLocation.x = LOWORD(lParam);
 709     m_LastLocation.y = HIWORD(lParam);
 710     return 0;
 711 }
 712
 713 LRESULT CMenuDeskBar::OnLButtonUp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
 714 {
 715     ReleaseCapture();
 716     m_Tracking = false;
 717     return 0;
 718 }
 719
 720 LRESULT CMenuDeskBar::OnMouseMove(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
 721 {
 722     POINT                                   newLocation;
 723     //int                                     delta;
 724
 725     if (m_Tracking)
 726     {
 727         newLocation.x = (short) LOWORD(lParam);
 728         newLocation.y = (short) HIWORD(lParam);
 729         m_LastLocation = newLocation;
 730     }
 731     return 0;
 732 }
 733
 734 LRESULT CMenuDeskBar::OnCancelMode(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
 735 {
 736     m_Tracking = false;
 737     return 0;
 738 }
 739
 740 LRESULT CMenuDeskBar::OnCaptureChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
 741 {
 742     m_Tracking = false;
 743     return 0;
 744 }
 745
 746 LRESULT CMenuDeskBar::OnWindowPosChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
 747 {
 748     return 0;
 749 }
 750
 751 LRESULT CMenuDeskBar::OnActivate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
 752 {
 753     if (LOWORD(wParam) == WA_INACTIVE)
 754     {
 755         //DestroyWindow();
 756         //ShowWindow(SW_HIDE);
 757     }
 758     return 0;
 759 }
 760
 761 LRESULT CMenuDeskBar::OnPaint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
 762 {
 763     TRACE("OnPaint\n");
 764
 765     if (m_Banner && !m_IconSize)
 766     {
 767         BITMAP bm;
 768         PAINTSTRUCT ps;
 769         HDC hdc = BeginPaint(&ps);
 770
 771         HDC hdcMem = ::CreateCompatibleDC(hdc);
 772         HGDIOBJ hbmOld = ::SelectObject(hdcMem, m_Banner);
 773
 774         ::GetObject(m_Banner, sizeof(bm), &bm);
 775
 776         TRACE("Painting banner: %d by %d\n", bm.bmWidth, bm.bmHeight);
 777
 778         if (!::BitBlt(hdc, 0, 0, bm.bmWidth, bm.bmHeight, hdcMem, 0, 0, SRCCOPY))
 779             WARN("BitBlt failed\n");
 780
 781         ::SelectObject(hdcMem, hbmOld);
 782         ::DeleteDC(hdcMem);
 783
 784         EndPaint(&ps);
 785     }
 786
 787     return 0;
 788 }
 789
 790 HRESULT STDMETHODCALLTYPE CMenuDeskBar::Popup(POINTL *ppt, RECTL *prcExclude, MP_POPUPFLAGS dwFlags)
 791 {
 792     //ENTER >> CMenuDeskBar<03901CC0>::Popup(POINTL *ppt=00B3F428, RECTL *prcExclude=00B3F418, MP_POPUPFLAGS dwFlags=80000000)
 793     //  ENTER >> CMenuBand<00D2CCF8>::QueryService
 794
 795     //  ENTER >> CMenuBand<00D2CCF8>::ShowDW(BOOL fShow=1)
 796     //    ENTER >> CMenuDeskBar<03901CC0>::GetSite(REFIID riid={4622AD10-FF23-11D0-8D34-00A0C90F2719}, PVOID *ppvSite=03901D4C)
 797     //      -- *ppvSite=00BDEA90
 798     //    EXIT <<< CMenuDeskBar::GetSite() = 00000000
 799     //    ENTER >> CMenuBand<00D2CCF8>::SetMenu(HMENU hmenu=593F0A07, HWND hwnd=00000000, DWORD dwFlags=20000000)
 800     //    EXIT <<< CMenuBand::SetMenu() = 00000000
 801     //  EXIT <<< CMenuBand::ShowDW() = 00000000
 802     //  ENTER >> CMenuBand<00D2CCF8>::GetBandInfo(DWORD dwBandID=0, DWORD dwViewMode=0, DESKBANDINFO *pdbi=00B3F0F0)
 803     //  EXIT <<< CMenuBand::GetBandInfo() = 00000000
 804     //  ENTER >> CMenuBand<00D2CCF8>::QueryService(REFGUID guidService={ED9CC020-08B9-11D1-9823-00C04FD91972}, REFIID riid={B722BCCB-4E68-101B-A2BC-00AA00404770}, void **ppvObject=00B3F304)
 805     //    -- SID is SID_SMenuBandChild. Using QueryInterface of self instead of wrapped object.
 806     //    -- *ppvObject=00D2CD08
 807     //  EXIT <<< CMenuBand::QueryService() = 00000000
 808     //  ENTER >> CMenuBand<00D2CCF8>::Exec(const GUID *pguidCmdGroup=76BAE1FC, DWORD nCmdID=19, DWORD nCmdexecopt=0, VARIANT *pvaIn=00000000, VARIANT *pvaOut=00000000)
 809     //    -- *pguidCmdGroup={5B4DAE26-B807-11D0-9815-00C04FD91972}
 810     //  EXIT <<< CMenuBand::Exec() = 00000001
 811     //  ENTER >> CMenuBand<00D2CCF8>::OnPosRectChangeDB(RECT *prc=00B3E630)
 812     //    -- *prc={L: 0, T: 0, R: 218, B: 305}
 813     //  EXIT <<< CMenuBand::OnPosRectChangeDB() = 00000000
 814     //  ENTER >> CMenuBand<00D2CCF8>::UIActivateIO(BOOL fActivate=1, LPMSG lpMsg=00000000)
 815     //  EXIT <<< CMenuBand::UIActivateIO() = 00000001
 816     //EXIT <<< CMenuDeskBar::Popup() = 00000000
 817     HRESULT hr;
 818     IServiceProvider * sp;
 819     IOleCommandTarget * oct;
 820     IInputObject * io;
 821
 822     hr = m_Client->QueryInterface(IID_PPV_ARG(IServiceProvider, &sp));
 823     if (FAILED(hr))
 824         return hr;
 825
 826     hr = m_Client->QueryInterface(IID_PPV_ARG(IInputObject, &io));
 827     if (FAILED(hr))
 828         return hr;
 829
 830     hr = sp->QueryService(SID_SMenuBandChild, IID_PPV_ARG(IOleCommandTarget, &oct));
 831     if (FAILED(hr))
 832     {
 833         sp->Release();
 834         return hr;
 835     }
 836
 837     // Unknown meaning
 838     const int CMD = 19;
 839     const int CMD_EXEC_OPT = 0;
 840
 841     hr = oct->Exec(&CLSID_MenuBand, CMD, CMD_EXEC_OPT, NULL, NULL);
 842
 843     oct->Release();
 844     sp->Release();
 845     return hr;
 846
 847     // FIXME: everything!
 848     const int hackWidth = 200;
 849     const int hackHeight = 400;
 850     RECT r = { ppt->x, ppt->y - hackHeight, ppt->x + hackWidth, ppt->y };
 851     if (this->m_hWnd == NULL)
 852     {
 853         this->Create(NULL, &r);
 854     }
 855     this->SetWindowPos(NULL, r.left, r.top, r.right - r.left, r.bottom - r.top, SWP_SHOWWINDOW);
 856     return S_OK;
 857 }
 858
 859 HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetIconSize(THIS_ DWORD iIcon)
 860 {
 861     HRESULT hr;
 862     IServiceProvider * sp;
 863     IOleCommandTarget * oct;
 864
 865     m_IconSize = iIcon;
 866
 867     hr = m_Client->QueryInterface(IID_PPV_ARG(IServiceProvider, &sp));
 868     if (FAILED(hr))
 869         return hr;
 870
 871     hr = sp->QueryService(SID_SMenuBandChild, IID_PPV_ARG(IOleCommandTarget, &oct));
 872     if (FAILED(hr))
 873     {
 874         sp->Release();
 875         return hr;
 876     }
 877
 878     // Unknown meaning
 879     const int CMD = 16;
 880     const int CMD_EXEC_OPT = 2;
 881
 882     hr = oct->Exec(&CLSID_MenuBand, CMD, CMD_EXEC_OPT, NULL, NULL);
 883
 884     oct->Release();
 885     sp->Release();
 886     return hr;
 887 }
 888
 889 HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetIconSize(THIS_ DWORD* piIcon)
 890 {
 891     if (piIcon)
 892         *piIcon = m_IconSize;
 893     return S_OK;
 894 }
 895
 896 HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetBitmap(THIS_ HBITMAP hBitmap)
 897 {
 898     m_Banner = hBitmap;
 899     return S_OK;
 900 }
 901
 902 HRESULT STDMETHODCALLTYPE CMenuDeskBar::GetBitmap(THIS_ HBITMAP* phBitmap)
 903 {
 904     if (phBitmap)
 905         *phBitmap = m_Banner;
 906     return S_OK;
 907 }
 908
 909 HRESULT STDMETHODCALLTYPE CMenuDeskBar::OnSelect(
 910     DWORD dwSelectType)
 911 {
 912     return S_OK;
 913 }
 914
 915 HRESULT STDMETHODCALLTYPE CMenuDeskBar::SetSubMenu(
 916     IMenuPopup *pmp,
 917     BOOL fSet)
 918 {
 919     return S_OK;
 920 }
 921
 922 HRESULT STDMETHODCALLTYPE CMenuDeskBar::Initialize(THIS)
 923 {
 924     return S_OK;
 925 }
 926
 927 #endif