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