reactos/dll/win32/shell32/shellmenu/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 "shellmenu.h"
  21 #include <windowsx.h>
  22 #include <commoncontrols.h>
  23 #include <shlwapi_undoc.h>
  24
  25 #include "CMenuBand.h"
  26 #include "CMenuToolbars.h"
  27 #include "CMenuFocusManager.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(CMenuBand);
  30
  31 #undef UNIMPLEMENTED
  32
  33 #define UNIMPLEMENTED TRACE("%s is UNIMPLEMENTED!\n", __FUNCTION__)
  34
  35 extern "C"
  36 HRESULT WINAPI CMenuBand_Constructor(REFIID riid, LPVOID *ppv)
  37 {
  38     return ShellObjectCreator<CMenuBand>(riid, ppv);
  39 }
  40
  41 CMenuBand::CMenuBand() :
  42     m_staticToolbar(NULL),
  43     m_SFToolbar(NULL),
  44     m_site(NULL),
  45     m_psmc(NULL),
  46     m_subMenuChild(NULL),
  47     m_subMenuParent(NULL),
  48     m_childBand(NULL),
  49     m_parentBand(NULL),
  50     m_hmenu(NULL),
  51     m_menuOwner(NULL),
  52     m_useBigIcons(FALSE),
  53     m_topLevelWindow(NULL),
  54     m_hotBar(NULL),
  55     m_hotItem(-1),
  56     m_popupBar(NULL),
  57     m_popupItem(-1),
  58     m_Show(FALSE),
  59     m_shellBottom(FALSE),
  60     m_trackedPopup(NULL),
  61     m_trackedHwnd(NULL)
  62 {
  63     m_focusManager = CMenuFocusManager::AcquireManager();
  64 }
  65
  66 CMenuBand::~CMenuBand()
  67 {
  68     CMenuFocusManager::ReleaseManager(m_focusManager);
  69
  70     if (m_staticToolbar)
  71         delete m_staticToolbar;
  72
  73     if (m_SFToolbar)
  74         delete m_SFToolbar;
  75
  76     if (m_hmenu)
  77         DestroyMenu(m_hmenu);
  78 }
  79
  80 HRESULT STDMETHODCALLTYPE  CMenuBand::Initialize(
  81     IShellMenuCallback *psmc,
  82     UINT uId,
  83     UINT uIdAncestor,
  84     DWORD dwFlags)
  85 {
  86     if (m_psmc != psmc)
  87         m_psmc = psmc;
  88     m_uId = uId;
  89     m_uIdAncestor = uIdAncestor;
  90     m_dwFlags = dwFlags;
  91
  92     if (m_psmc)
  93     {
  94         _CallCB(SMC_CREATE, 0, reinterpret_cast<LPARAM>(&m_UserData));
  95     }
  96
  97     return S_OK;
  98 }
  99
 100 HRESULT STDMETHODCALLTYPE  CMenuBand::GetMenuInfo(
 101     IShellMenuCallback **ppsmc,
 102     UINT *puId,
 103     UINT *puIdAncestor,
 104     DWORD *pdwFlags)
 105 {
 106     if (!pdwFlags) // maybe?
 107         return E_INVALIDARG;
 108
 109     if (ppsmc)
 110     {
 111         m_psmc->AddRef();
 112         *ppsmc = m_psmc;
 113     }
 114
 115     if (puId)
 116         *puId = m_uId;
 117
 118     if (puIdAncestor)
 119         *puIdAncestor = m_uIdAncestor;
 120
 121     *pdwFlags = m_dwFlags;
 122
 123     return S_OK;
 124 }
 125
 126 HRESULT STDMETHODCALLTYPE  CMenuBand::SetMenu(
 127     HMENU hmenu,
 128     HWND hwnd,
 129     DWORD dwFlags)
 130 {
 131     HRESULT hr;
 132
 133     TRACE("CMenuBand::SetMenu called, hmenu=%p; hwnd=%p, flags=%x\n", hmenu, hwnd, dwFlags);
 134
 135     BOOL created = FALSE;
 136
 137     if (m_hmenu && m_hmenu != hmenu)
 138     {
 139         DestroyMenu(m_hmenu);
 140         m_hmenu = NULL;
 141     }
 142
 143     m_hmenu = hmenu;
 144     m_menuOwner = hwnd;
 145
 146     if (m_hmenu && m_staticToolbar == NULL)
 147     {
 148         m_staticToolbar = new CMenuStaticToolbar(this);
 149         created = true;
 150     }
 151
 152     if (m_staticToolbar)
 153     {
 154         hr = m_staticToolbar->SetMenu(hmenu, hwnd, dwFlags);
 155         if (FAILED_UNEXPECTEDLY(hr))
 156             return hr;
 157     }
 158
 159     if (m_site)
 160     {
 161         HWND hwndParent;
 162
 163         hr = m_site->GetWindow(&hwndParent);
 164         if (FAILED_UNEXPECTEDLY(hr))
 165             return hr;
 166
 167         if (created)
 168         {
 169             hr = m_staticToolbar->CreateToolbar(hwndParent, m_dwFlags);
 170             if (FAILED_UNEXPECTEDLY(hr))
 171                 return hr;
 172
 173             hr = m_staticToolbar->FillToolbar();
 174         }
 175         else
 176         {
 177             hr = m_staticToolbar->FillToolbar(TRUE);
 178         }
 179     }
 180
 181     return hr;
 182 }
 183
 184 HRESULT STDMETHODCALLTYPE  CMenuBand::GetMenu(
 185     HMENU *phmenu,
 186     HWND *phwnd,
 187     DWORD *pdwFlags)
 188 {
 189     if (m_staticToolbar == NULL)
 190         return E_FAIL;
 191
 192     return m_staticToolbar->GetMenu(phmenu, phwnd, pdwFlags);
 193 }
 194
 195 HRESULT STDMETHODCALLTYPE  CMenuBand::SetSite(IUnknown *pUnkSite)
 196 {
 197     HWND    hwndParent;
 198     HRESULT hr;
 199
 200     m_site = NULL;
 201
 202     if (pUnkSite == NULL)
 203         return S_OK;
 204
 205     hwndParent = NULL;
 206     hr = pUnkSite->QueryInterface(IID_PPV_ARG(IOleWindow, &m_site));
 207     if (FAILED_UNEXPECTEDLY(hr))
 208         return hr;
 209
 210     hr = m_site->GetWindow(&hwndParent);
 211     if (FAILED_UNEXPECTEDLY(hr))
 212         return hr;
 213
 214     if (!::IsWindow(hwndParent))
 215         return E_FAIL;
 216
 217     if (m_staticToolbar != NULL)
 218     {
 219         hr = m_staticToolbar->CreateToolbar(hwndParent, m_dwFlags);
 220         if (FAILED_UNEXPECTEDLY(hr))
 221             return hr;
 222
 223         hr = m_staticToolbar->FillToolbar();
 224         if (FAILED_UNEXPECTEDLY(hr))
 225             return hr;
 226     }
 227
 228     if (m_SFToolbar != NULL)
 229     {
 230         hr = m_SFToolbar->CreateToolbar(hwndParent, m_dwFlags);
 231         if (FAILED_UNEXPECTEDLY(hr))
 232             return hr;
 233
 234         hr = m_SFToolbar->FillToolbar();
 235         if (FAILED_UNEXPECTEDLY(hr))
 236             return hr;
 237     }
 238
 239     hr = IUnknown_QueryService(m_site, SID_SMenuPopup, IID_PPV_ARG(IMenuPopup, &m_subMenuParent));
 240     if (hr != E_NOINTERFACE && FAILED_UNEXPECTEDLY(hr))
 241         return hr;
 242
 243     CComPtr<IOleWindow> pTopLevelWindow;
 244     hr = IUnknown_QueryService(m_site, SID_STopLevelBrowser, IID_PPV_ARG(IOleWindow, &pTopLevelWindow));
 245     if (FAILED_UNEXPECTEDLY(hr))
 246         return hr;
 247
 248     return pTopLevelWindow->GetWindow(&m_topLevelWindow);
 249 }
 250
 251 HRESULT STDMETHODCALLTYPE  CMenuBand::GetSite(REFIID riid, PVOID *ppvSite)
 252 {
 253     if (m_site == NULL)
 254         return E_FAIL;
 255
 256     return m_site->QueryInterface(riid, ppvSite);
 257 }
 258
 259 HRESULT STDMETHODCALLTYPE CMenuBand::GetWindow(HWND *phwnd)
 260 {
 261     if (m_SFToolbar != NULL)
 262         return m_SFToolbar->GetWindow(phwnd);
 263
 264     if (m_staticToolbar != NULL)
 265         return m_staticToolbar->GetWindow(phwnd);
 266
 267     if (phwnd) *phwnd = NULL;
 268
 269     return E_FAIL;
 270 }
 271
 272 HRESULT STDMETHODCALLTYPE CMenuBand::OnPosRectChangeDB(RECT *prc)
 273 {
 274     SIZE maxStatic = { 0 };
 275     SIZE maxShlFld = { 0 };
 276     HRESULT hr = S_OK;
 277
 278     if (m_staticToolbar != NULL)
 279         hr = m_staticToolbar->GetSizes(NULL, &maxStatic, NULL);
 280     if (FAILED_UNEXPECTEDLY(hr))
 281         return hr;
 282
 283     if (m_SFToolbar != NULL)
 284         hr = m_SFToolbar->GetSizes(NULL, &maxShlFld, NULL);
 285     if (FAILED_UNEXPECTEDLY(hr))
 286         return hr;
 287
 288     if (m_staticToolbar == NULL && m_SFToolbar == NULL)
 289         return E_FAIL;
 290
 291     int sy = min(prc->bottom - prc->top, maxStatic.cy + maxShlFld.cy);
 292
 293     int syStatic = maxStatic.cy;
 294     int syShlFld = sy - syStatic;
 295
 296     // TODO: Windows has a more complex system to decide ordering.
 297     // Because we only support two toolbars at once, this is enough for us.
 298     if (m_shellBottom)
 299     {
 300         // Static menu on top
 301         if (m_SFToolbar)
 302         {
 303             m_SFToolbar->SetPosSize(
 304                 prc->left,
 305                 prc->top + syStatic,
 306                 prc->right - prc->left,
 307                 syShlFld);
 308         }
 309         if (m_staticToolbar)
 310         {
 311             m_staticToolbar->SetPosSize(
 312                 prc->left,
 313                 prc->top,
 314                 prc->right - prc->left,
 315                 syStatic);
 316         }
 317     }
 318     else
 319     {
 320         // Folder menu on top
 321         if (m_SFToolbar)
 322         {
 323             m_SFToolbar->SetPosSize(
 324                 prc->left,
 325                 prc->top,
 326                 prc->right - prc->left,
 327                 syShlFld);
 328         }
 329         if (m_staticToolbar)
 330         {
 331             m_staticToolbar->SetPosSize(
 332                 prc->left,
 333                 prc->top + syShlFld,
 334                 prc->right - prc->left,
 335                 syStatic);
 336         }
 337     }
 338
 339     return S_OK;
 340 }
 341
 342 HRESULT STDMETHODCALLTYPE  CMenuBand::GetBandInfo(
 343     DWORD dwBandID,
 344     DWORD dwViewMode,
 345     DESKBANDINFO *pdbi)
 346 {
 347     SIZE minStatic = { 0 };
 348     SIZE minShlFld = { 0 };
 349     SIZE maxStatic = { 0 };
 350     SIZE maxShlFld = { 0 };
 351     SIZE intStatic = { 0 };
 352     SIZE intShlFld = { 0 };
 353
 354     HRESULT hr = S_OK;
 355
 356     if (m_staticToolbar != NULL)
 357         hr = m_staticToolbar->GetSizes(&minStatic, &maxStatic, &intStatic);
 358     if (FAILED_UNEXPECTEDLY(hr))
 359         return hr;
 360
 361     if (m_SFToolbar != NULL)
 362         hr = m_SFToolbar->GetSizes(&minShlFld, &maxShlFld, &intShlFld);
 363     if (FAILED_UNEXPECTEDLY(hr))
 364         return hr;
 365
 366     if (m_staticToolbar == NULL && m_SFToolbar == NULL)
 367         return E_FAIL;
 368
 369     if (m_dwFlags & SMINIT_VERTICAL)
 370     {
 371         pdbi->ptMinSize.x = max(minStatic.cx, minShlFld.cx) + 20;
 372         pdbi->ptMinSize.y = minStatic.cy + minShlFld.cy;
 373         pdbi->ptMaxSize.x = max(maxStatic.cx, maxShlFld.cx) + 20;
 374         pdbi->ptMaxSize.y = maxStatic.cy + maxShlFld.cy;
 375         pdbi->dwModeFlags = DBIMF_VARIABLEHEIGHT;
 376     }
 377     else
 378     {
 379         pdbi->ptMinSize.x = minStatic.cx + minShlFld.cx;
 380         pdbi->ptMinSize.y = max(minStatic.cy, minShlFld.cy);
 381         pdbi->ptMaxSize.x = maxStatic.cx + maxShlFld.cx;
 382         pdbi->ptMaxSize.y = max(maxStatic.cy, maxShlFld.cy);
 383     }
 384     pdbi->ptIntegral.x = max(intStatic.cx, intShlFld.cx);
 385     pdbi->ptIntegral.y = max(intStatic.cy, intShlFld.cy);
 386     pdbi->ptActual = pdbi->ptMinSize;
 387
 388     return S_OK;
 389 }
 390
 391 HRESULT STDMETHODCALLTYPE  CMenuBand::ShowDW(BOOL fShow)
 392 {
 393     HRESULT hr = S_OK;
 394
 395     if (m_Show == fShow)
 396         return S_OK;
 397
 398     m_Show = fShow;
 399
 400     if (m_staticToolbar != NULL)
 401     {
 402         hr = m_staticToolbar->ShowDW(fShow);
 403         if (FAILED_UNEXPECTEDLY(hr))
 404             return hr;
 405     }
 406
 407     if (m_SFToolbar != NULL)
 408     {
 409         hr = m_SFToolbar->ShowDW(fShow);
 410         if (FAILED_UNEXPECTEDLY(hr))
 411             return hr;
 412     }
 413
 414     if (fShow)
 415     {
 416         hr = _CallCB(SMC_INITMENU, 0, 0);
 417         if (FAILED_UNEXPECTEDLY(hr))
 418             return hr;
 419     }
 420     else if (m_parentBand)
 421     {
 422         m_parentBand->SetClient(NULL);
 423     }
 424
 425     if (_IsPopup() == S_OK)
 426     {
 427         if (fShow)
 428             hr = m_focusManager->PushMenuPopup(this);
 429         else
 430             hr = m_focusManager->PopMenuPopup(this);
 431     }
 432     else
 433     {
 434         if (fShow)
 435             hr = m_focusManager->PushMenuBar(this);
 436         else
 437             hr = m_focusManager->PopMenuBar(this);
 438     }
 439
 440     return S_OK;
 441 }
 442
 443 HRESULT STDMETHODCALLTYPE CMenuBand::CloseDW(DWORD dwReserved)
 444 {
 445     if (m_subMenuChild)
 446     {
 447         m_subMenuChild->OnSelect(MPOS_CANCELLEVEL);
 448     }
 449
 450     if (m_subMenuChild)
 451     {
 452         TRACE("Child object should have removed itself.\n");
 453     }
 454
 455     ShowDW(FALSE);
 456
 457     if (m_staticToolbar != NULL)
 458     {
 459         m_staticToolbar->Close();
 460     }
 461
 462     if (m_SFToolbar != NULL)
 463     {
 464         m_SFToolbar->Close();
 465     }
 466
 467     if (m_site) m_site.Release();
 468     if (m_subMenuChild) m_subMenuChild.Release();
 469     if (m_subMenuParent) m_subMenuParent.Release();
 470     if (m_childBand) m_childBand.Release();
 471     if (m_parentBand) m_parentBand.Release();
 472
 473     return S_OK;
 474 }
 475
 476 HRESULT STDMETHODCALLTYPE CMenuBand::UIActivateIO(BOOL fActivate, LPMSG lpMsg)
 477 {
 478     HRESULT hr;
 479
 480     if (m_subMenuParent)
 481     {
 482         hr = m_subMenuParent->SetSubMenu(this, fActivate);
 483         if (FAILED_UNEXPECTEDLY(hr))
 484             return hr;
 485     }
 486
 487     if (fActivate)
 488     {
 489         CComPtr<IOleWindow> pTopLevelWindow;
 490         hr = IUnknown_QueryService(m_site, SID_SMenuPopup, IID_PPV_ARG(IOleWindow, &pTopLevelWindow));
 491         if (FAILED_UNEXPECTEDLY(hr))
 492             return hr;
 493
 494         hr = pTopLevelWindow->GetWindow(&m_topLevelWindow);
 495         if (FAILED_UNEXPECTEDLY(hr))
 496             return hr;
 497     }
 498     else
 499     {
 500         m_topLevelWindow = NULL;
 501     }
 502
 503     return S_FALSE;
 504 }
 505
 506 HRESULT STDMETHODCALLTYPE CMenuBand::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 507 {
 508     if (!pguidCmdGroup)
 509         return E_FAIL;
 510
 511     if (IsEqualGUID(*pguidCmdGroup, CLSID_MenuBand))
 512     {
 513         if (nCmdID == 16) // set (big) icon size
 514         {
 515             this->m_useBigIcons = nCmdexecopt == 2;
 516             return S_OK;
 517         }
 518         else if (nCmdID == 19) // popup-related
 519         {
 520             return S_FALSE;
 521         }
 522         else if (nCmdID == 5) // select an item
 523         {
 524             if (nCmdexecopt == 0) // first
 525             {
 526                 _KeyboardItemChange(VK_HOME);
 527             }
 528             else // last
 529             {
 530                 _KeyboardItemChange(VK_END);
 531             }
 532             return S_FALSE;
 533         }
 534
 535         return S_FALSE;
 536     }
 537
 538     UNIMPLEMENTED;
 539     return S_OK;
 540 }
 541
 542 HRESULT STDMETHODCALLTYPE CMenuBand::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
 543 {
 544     if (IsEqualIID(guidService, SID_SMenuBandChild) ||
 545         IsEqualIID(guidService, SID_SMenuBandBottom) ||
 546         IsEqualIID(guidService, SID_SMenuBandBottomSelected))
 547         return this->QueryInterface(riid, ppvObject);
 548     WARN("Unknown service requested %s\n", wine_dbgstr_guid(&guidService));
 549     return E_NOINTERFACE;
 550 }
 551
 552 HRESULT STDMETHODCALLTYPE CMenuBand::Popup(POINTL *ppt, RECTL *prcExclude, MP_POPUPFLAGS dwFlags)
 553 {
 554     UNIMPLEMENTED;
 555     return S_OK;
 556 }
 557
 558 HRESULT STDMETHODCALLTYPE CMenuBand::OnSelect(DWORD dwSelectType)
 559 {
 560     // When called from outside, this is straightforward:
 561     // Things that a submenu needs to know, are spread down, and
 562     // things that the parent needs to know, are spread up. No drama.
 563     // The fun is in _MenuItemSelect (internal method).
 564     switch (dwSelectType)
 565     {
 566     case MPOS_CHILDTRACKING:
 567         if (!m_subMenuParent)
 568             break;
 569         // TODO: Cancel timers?
 570         return m_subMenuParent->OnSelect(dwSelectType);
 571     case MPOS_SELECTLEFT:
 572         if (m_subMenuChild)
 573             m_subMenuChild->OnSelect(MPOS_CANCELLEVEL);
 574         if (!m_subMenuParent)
 575             break;
 576         return m_subMenuParent->OnSelect(dwSelectType);
 577     case MPOS_SELECTRIGHT:
 578         if (!m_subMenuParent)
 579             break;
 580         return m_subMenuParent->OnSelect(dwSelectType);
 581     case MPOS_EXECUTE:
 582     case MPOS_FULLCANCEL:
 583         if (m_subMenuChild)
 584             m_subMenuChild->OnSelect(dwSelectType);
 585         if (!m_subMenuParent)
 586             break;
 587         return m_subMenuParent->OnSelect(dwSelectType);
 588     case MPOS_CANCELLEVEL:
 589         if (m_subMenuChild)
 590             m_subMenuChild->OnSelect(dwSelectType);
 591         break;
 592     }
 593     return S_FALSE;
 594 }
 595
 596 HRESULT STDMETHODCALLTYPE CMenuBand::SetSubMenu(IMenuPopup *pmp, BOOL fSet)
 597 {
 598     UNIMPLEMENTED;
 599     return S_OK;
 600 }
 601
 602 // Used by the focus manager to update the child band pointer
 603 HRESULT CMenuBand::_SetChildBand(CMenuBand * child)
 604 {
 605     m_childBand = child;
 606     if (!child)
 607     {
 608         _ChangePopupItem(NULL, -1);
 609     }
 610     return S_OK;
 611 }
 612
 613 // User by the focus manager to update the parent band pointer
 614 HRESULT CMenuBand::_SetParentBand(CMenuBand * parent)
 615 {
 616     m_parentBand = parent;
 617     return S_OK;
 618 }
 619
 620 HRESULT CMenuBand::_IsPopup()
 621 {
 622     return !(m_dwFlags & SMINIT_VERTICAL);
 623 }
 624
 625 HRESULT CMenuBand::_IsTracking()
 626 {
 627     return m_popupBar != NULL;
 628 }
 629
 630 HRESULT STDMETHODCALLTYPE CMenuBand::SetClient(IUnknown *punkClient)
 631 {
 632     CComPtr<IMenuPopup> child = m_subMenuChild;
 633
 634     m_subMenuChild = NULL;
 635
 636     if (child)
 637     {
 638         IUnknown_SetSite(child, NULL);
 639         child.Release();
 640     }
 641
 642     if (!punkClient)
 643     {
 644         return S_OK;
 645     }
 646
 647     return punkClient->QueryInterface(IID_PPV_ARG(IMenuPopup, &m_subMenuChild));
 648 }
 649
 650 HRESULT STDMETHODCALLTYPE CMenuBand::GetClient(IUnknown **ppunkClient)
 651 {
 652     if (!ppunkClient)
 653         return E_POINTER;
 654     *ppunkClient = NULL;
 655
 656     if (m_subMenuChild)
 657     {
 658         m_subMenuChild->AddRef();
 659         *ppunkClient = m_subMenuChild;
 660     }
 661
 662     return S_OK;
 663 }
 664
 665 HRESULT STDMETHODCALLTYPE CMenuBand::IsMenuMessage(MSG *pmsg)
 666 {
 667     return S_FALSE;
 668 }
 669
 670 HRESULT STDMETHODCALLTYPE CMenuBand::TranslateMenuMessage(MSG *pmsg, LRESULT *plRet)
 671 {
 672     return S_FALSE;
 673 }
 674
 675 HRESULT STDMETHODCALLTYPE CMenuBand::SetShellFolder(IShellFolder *psf, LPCITEMIDLIST pidlFolder, HKEY hKey, DWORD dwFlags)
 676 {
 677     if (m_SFToolbar == NULL)
 678     {
 679         m_SFToolbar = new CMenuSFToolbar(this);
 680     }
 681
 682     HRESULT hr = m_SFToolbar->SetShellFolder(psf, pidlFolder, hKey, dwFlags);
 683     if (FAILED_UNEXPECTEDLY(hr))
 684         return hr;
 685
 686     m_shellBottom = (dwFlags & SMSET_BOTTOM) != 0;
 687
 688     if (m_site)
 689     {
 690         HWND hwndParent;
 691
 692         hr = m_site->GetWindow(&hwndParent);
 693         if (FAILED_UNEXPECTEDLY(hr))
 694             return hr;
 695
 696         hr = m_SFToolbar->CreateToolbar(hwndParent, m_dwFlags);
 697         if (FAILED_UNEXPECTEDLY(hr))
 698             return hr;
 699
 700         hr = m_SFToolbar->FillToolbar();
 701     }
 702
 703     return hr;
 704 }
 705
 706 HRESULT STDMETHODCALLTYPE CMenuBand::GetShellFolder(DWORD *pdwFlags, LPITEMIDLIST *ppidl, REFIID riid, void **ppv)
 707 {
 708     if (m_SFToolbar)
 709         return m_SFToolbar->GetShellFolder(pdwFlags, ppidl, riid, ppv);
 710     return E_FAIL;
 711 }
 712
 713 HRESULT STDMETHODCALLTYPE CMenuBand::OnWinEvent(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult)
 714 {
 715     *theResult = 0;
 716
 717     if (uMsg == WM_WININICHANGE && wParam == SPI_SETFLATMENU)
 718     {
 719         BOOL bFlatMenus;
 720         SystemParametersInfo(SPI_GETFLATMENU, 0, &bFlatMenus, 0);
 721         AdjustForTheme(bFlatMenus);
 722         return S_OK;
 723     }
 724
 725     if (m_staticToolbar && m_staticToolbar->IsWindowOwner(hWnd) == S_OK)
 726     {
 727         return m_staticToolbar->OnWinEvent(hWnd, uMsg, wParam, lParam, theResult);
 728     }
 729
 730     if (m_SFToolbar && m_SFToolbar->IsWindowOwner(hWnd) == S_OK)
 731     {
 732         return m_SFToolbar->OnWinEvent(hWnd, uMsg, wParam, lParam, theResult);
 733     }
 734
 735     return S_FALSE;
 736 }
 737
 738 HRESULT STDMETHODCALLTYPE CMenuBand::IsWindowOwner(HWND hWnd)
 739 {
 740     if (m_staticToolbar && m_staticToolbar->IsWindowOwner(hWnd) == S_OK)
 741         return S_OK;
 742
 743     if (m_SFToolbar && m_SFToolbar->IsWindowOwner(hWnd) == S_OK)
 744         return S_OK;
 745
 746     return S_FALSE;
 747 }
 748
 749 HRESULT CMenuBand::_CallCBWithItemId(UINT id, UINT uMsg, WPARAM wParam, LPARAM lParam)
 750 {
 751     return _CallCB(uMsg, wParam, lParam, id);
 752 }
 753
 754 HRESULT CMenuBand::_CallCBWithItemPidl(LPITEMIDLIST pidl, UINT uMsg, WPARAM wParam, LPARAM lParam)
 755 {
 756     return _CallCB(uMsg, wParam, lParam, 0, pidl);
 757 }
 758
 759 HRESULT CMenuBand::_CallCB(UINT uMsg, WPARAM wParam, LPARAM lParam, UINT id, LPITEMIDLIST pidl)
 760 {
 761     if (!m_psmc)
 762         return S_FALSE;
 763
 764     SMDATA smData = { 0 };
 765     smData.punk = static_cast<IShellMenu2*>(this);
 766     smData.uId = id;
 767     smData.uIdParent = m_uId;
 768     smData.uIdAncestor = m_uIdAncestor;
 769     smData.pidlItem = pidl;
 770     smData.hwnd = m_menuOwner ? m_menuOwner : m_topLevelWindow;
 771     smData.hmenu = m_hmenu;
 772     if (m_SFToolbar)
 773         m_SFToolbar->GetShellFolder(NULL, &smData.pidlFolder, IID_PPV_ARG(IShellFolder, &smData.psf));
 774     HRESULT hr = m_psmc->CallbackSM(&smData, uMsg, wParam, lParam);
 775     ILFree(smData.pidlFolder);
 776     if (smData.psf)
 777         smData.psf->Release();
 778     return hr;
 779 }
 780
 781 HRESULT CMenuBand::_TrackSubMenu(HMENU popup, INT x, INT y, RECT& rcExclude)
 782 {
 783     TPMPARAMS params = { sizeof(TPMPARAMS), rcExclude };
 784     UINT      flags  = TPM_VERPOSANIMATION | TPM_VERTICAL | TPM_LEFTALIGN;
 785     HWND      hwnd   = m_menuOwner ? m_menuOwner : m_topLevelWindow;
 786
 787     m_trackedPopup = popup;
 788     m_trackedHwnd = hwnd;
 789
 790     m_focusManager->PushTrackedPopup(popup);
 791     ::TrackPopupMenuEx(popup, flags, x, y, hwnd, &params);
 792     m_focusManager->PopTrackedPopup(popup);
 793
 794     m_trackedPopup = NULL;
 795     m_trackedHwnd = NULL;
 796
 797     _DisableMouseTrack(FALSE);
 798
 799     return S_OK;
 800 }
 801
 802 HRESULT CMenuBand::_TrackContextMenu(IContextMenu * contextMenu, INT x, INT y)
 803 {
 804     HRESULT hr;
 805     UINT uCommand;
 806
 807     // Ensure that the menu doesn't disappear on us
 808     CComPtr<IContextMenu> ctxMenu = contextMenu;
 809
 810     HMENU popup = CreatePopupMenu();
 811
 812     if (popup == NULL)
 813         return E_FAIL;
 814
 815     TRACE("Before Query\n");
 816     hr = contextMenu->QueryContextMenu(popup, 0, 0, UINT_MAX, CMF_NORMAL);
 817     if (FAILED_UNEXPECTEDLY(hr))
 818     {
 819         TRACE("Query failed\n");
 820         DestroyMenu(popup);
 821         return hr;
 822     }
 823
 824     HWND hwnd = m_menuOwner ? m_menuOwner : m_topLevelWindow;
 825
 826     m_focusManager->PushTrackedPopup(popup);
 827
 828     TRACE("Before Tracking\n");
 829     uCommand = ::TrackPopupMenuEx(popup, TPM_RETURNCMD, x, y, hwnd, NULL);
 830
 831     m_focusManager->PopTrackedPopup(popup);
 832
 833     if (uCommand != 0)
 834     {
 835         _MenuItemSelect(MPOS_FULLCANCEL);
 836
 837         TRACE("Before InvokeCommand\n");
 838         CMINVOKECOMMANDINFO cmi = { 0 };
 839         cmi.cbSize = sizeof(cmi);
 840         cmi.lpVerb = MAKEINTRESOURCEA(uCommand);
 841         cmi.hwnd = hwnd;
 842         hr = contextMenu->InvokeCommand(&cmi);
 843         TRACE("InvokeCommand returned hr=%08x\n", hr);
 844     }
 845     else
 846     {
 847         TRACE("TrackPopupMenu failed. Code=%d, LastError=%d\n", uCommand, GetLastError());
 848         hr = S_FALSE;
 849     }
 850
 851     DestroyMenu(popup);
 852     return hr;
 853 }
 854
 855 HRESULT CMenuBand::_GetTopLevelWindow(HWND*topLevel)
 856 {
 857     *topLevel = m_topLevelWindow;
 858     return S_OK;
 859 }
 860
 861 HRESULT CMenuBand::_ChangeHotItem(CMenuToolbarBase * tb, INT id, DWORD dwFlags)
 862 {
 863     if (m_hotBar == tb && m_hotItem == id)
 864         return S_FALSE;
 865
 866     TRACE("Hot item changed from %p %p, to %p %p\n", m_hotBar, m_hotItem, tb, id);
 867
 868     _KillPopupTimers();
 869
 870     m_hotBar = tb;
 871     m_hotItem = id;
 872     if (m_staticToolbar) m_staticToolbar->ChangeHotItem(tb, id, dwFlags);
 873     if (m_SFToolbar) m_SFToolbar->ChangeHotItem(tb, id, dwFlags);
 874
 875     _MenuItemSelect(MPOS_CHILDTRACKING);
 876
 877     return S_OK;
 878 }
 879
 880 HRESULT CMenuBand::_ChangePopupItem(CMenuToolbarBase * tb, INT id)
 881 {
 882     TRACE("Popup item changed from %p %p, to %p %p\n", m_popupBar, m_popupItem, tb, id);
 883
 884     m_popupBar = tb;
 885     m_popupItem = id;
 886     if (m_staticToolbar) m_staticToolbar->ChangePopupItem(tb, id);
 887     if (m_SFToolbar) m_SFToolbar->ChangePopupItem(tb, id);
 888
 889     return S_OK;
 890 }
 891
 892 HRESULT  CMenuBand::_KeyboardItemChange(DWORD change)
 893 {
 894     HRESULT hr;
 895     CMenuToolbarBase *tb = m_hotBar;
 896
 897     if (!tb)
 898     {
 899         // If no hot item was selected choose the appropriate toolbar
 900         if (change == VK_UP || change == VK_END)
 901         {
 902             if (m_staticToolbar)
 903                 tb = m_staticToolbar;
 904             else
 905                 tb = m_SFToolbar;
 906         }
 907         else if (change == VK_DOWN || change == VK_HOME)
 908         {
 909             if (m_SFToolbar)
 910                 tb = m_SFToolbar;
 911             else
 912                 tb = m_staticToolbar;
 913         }
 914     }
 915
 916     // Ask the first toolbar to change
 917     hr = tb->KeyboardItemChange(change);
 918
 919     if (hr != S_FALSE)
 920         return hr;
 921
 922     // Select the second toolbar based on the first
 923     if (tb == m_SFToolbar && m_staticToolbar)
 924         tb = m_staticToolbar;
 925     else if (m_SFToolbar)
 926         tb = m_SFToolbar;
 927
 928     if (!tb)
 929         return hr;
 930
 931     // Ask the second toolbar to change
 932     return tb->KeyboardItemChange(change == VK_DOWN ? VK_HOME : VK_END);
 933 }
 934
 935 HRESULT CMenuBand::_MenuItemSelect(DWORD changeType)
 936 {
 937     // Needed to prevent the this point from vanishing mid-function
 938     CComPtr<CMenuBand> safeThis = this;
 939     HRESULT hr;
 940
 941     if (m_dwFlags & SMINIT_VERTICAL)
 942     {
 943         switch (changeType)
 944         {
 945         case VK_UP:
 946         case VK_DOWN:
 947             return _KeyboardItemChange(changeType);
 948
 949             // TODO: Left/Right across multi-column menus, if they ever work.
 950         case VK_LEFT:
 951             changeType = MPOS_SELECTLEFT;
 952             break;
 953         case VK_RIGHT:
 954             changeType = MPOS_SELECTRIGHT;
 955             break;
 956         }
 957     }
 958     else
 959     {
 960         // In horizontal menubars, left/right are equivalent to vertical's up/down
 961         switch (changeType)
 962         {
 963         case VK_LEFT:
 964             hr = _KeyboardItemChange(VK_UP);
 965             if (hr != S_FALSE)
 966                 return hr;
 967         case VK_RIGHT:
 968             hr = _KeyboardItemChange(VK_DOWN);
 969             if (hr != S_FALSE)
 970                 return hr;
 971         }
 972     }
 973
 974     // In this context, the parent is the CMenuDeskBar, so when it bubbles upward,
 975     // it is notifying the deskbar, and not the the higher-level menu.
 976     // Same for the child: since it points to a CMenuDeskBar, it's not just recursing.
 977     switch (changeType)
 978     {
 979     case MPOS_EXECUTE:
 980     {
 981         CMenuToolbarBase * tb = m_hotBar;
 982         int item = m_hotItem;
 983         tb->PrepareExecuteItem(item);
 984         if (m_subMenuParent)
 985         {
 986             m_subMenuParent->OnSelect(changeType);
 987         }
 988         TRACE("Menu closed, executing item...\n");
 989         tb->ExecuteItem();
 990         break;
 991     }
 992     case MPOS_SELECTLEFT:
 993         if (m_parentBand && m_parentBand->_IsPopup()==S_FALSE)
 994             return m_parentBand->_MenuItemSelect(VK_LEFT);
 995         if (m_subMenuChild)
 996             return m_subMenuChild->OnSelect(MPOS_CANCELLEVEL);
 997         if (!m_subMenuParent)
 998             return S_OK;
 999         return m_subMenuParent->OnSelect(MPOS_CANCELLEVEL);
1000
1001     case MPOS_SELECTRIGHT:
1002         if (m_hotBar && m_hotItem >= 0 && m_hotBar->PopupItem(m_hotItem, TRUE) == S_OK)
1003             return S_FALSE;
1004         if (m_parentBand)
1005             return m_parentBand->_MenuItemSelect(VK_RIGHT);
1006         if (!m_subMenuParent)
1007             return S_OK;
1008         return m_subMenuParent->OnSelect(MPOS_SELECTRIGHT);
1009
1010     default:
1011         if (!m_subMenuParent)
1012             return S_OK;
1013         return m_subMenuParent->OnSelect(changeType);
1014     }
1015
1016     return S_OK;
1017 }
1018
1019 HRESULT CMenuBand::_CancelCurrentPopup()
1020 {
1021     if (m_subMenuChild)
1022     {
1023         HRESULT hr = m_subMenuChild->OnSelect(MPOS_CANCELLEVEL);
1024         return hr;
1025     }
1026
1027     if (m_trackedPopup)
1028     {
1029         ::SendMessage(m_trackedHwnd, WM_CANCELMODE, 0, 0);
1030         return S_OK;
1031     }
1032
1033     return S_FALSE;
1034 }
1035
1036 HRESULT CMenuBand::_OnPopupSubMenu(IShellMenu * childShellMenu, POINTL * pAt, RECTL * pExclude, BOOL keyInitiated)
1037 {
1038     HRESULT hr = 0;
1039     CComPtr<IBandSite> pBandSite;
1040     CComPtr<IDeskBar> pDeskBar;
1041
1042     // Create the necessary objects
1043 #if USE_SYSTEM_MENUSITE
1044     hr = CoCreateInstance(CLSID_MenuBandSite,
1045         NULL,
1046         CLSCTX_INPROC_SERVER,
1047         IID_PPV_ARG(IBandSite, &pBandSite));
1048 #else
1049     hr = CMenuSite_Constructor(IID_PPV_ARG(IBandSite, &pBandSite));
1050 #endif
1051     if (FAILED_UNEXPECTEDLY(hr))
1052         return hr;
1053
1054 #if USE_SYSTEM_MENUDESKBAR
1055     hr = CoCreateInstance(CLSID_MenuDeskBar,
1056         NULL,
1057         CLSCTX_INPROC_SERVER,
1058         IID_PPV_ARG(IDeskBar, &pDeskBar));
1059 #else
1060     hr = CMenuDeskBar_Constructor(IID_PPV_ARG(IDeskBar, &pDeskBar));
1061 #endif
1062     if (FAILED_UNEXPECTEDLY(hr))
1063         return hr;
1064
1065     hr = pDeskBar->SetClient(pBandSite);
1066     if (FAILED_UNEXPECTEDLY(hr))
1067         return hr;
1068
1069     hr = pBandSite->AddBand(childShellMenu);
1070     if (FAILED_UNEXPECTEDLY(hr))
1071         return hr;
1072
1073     //
1074     CComPtr<IMenuPopup> popup;
1075     hr = pDeskBar->QueryInterface(IID_PPV_ARG(IMenuPopup, &popup));
1076     if (FAILED_UNEXPECTEDLY(hr))
1077         return hr;
1078
1079     m_subMenuChild = popup;
1080
1081     if (m_subMenuParent)
1082         IUnknown_SetSite(popup, m_subMenuParent);
1083     else
1084         IUnknown_SetSite(popup, m_site);
1085
1086     DWORD flags = MPPF_RIGHT;
1087
1088     if (keyInitiated && m_dwFlags & SMINIT_VERTICAL)
1089         flags |= MPPF_INITIALSELECT;
1090
1091     popup->Popup(pAt, pExclude, flags);
1092
1093     return S_OK;
1094 }
1095
1096 HRESULT CMenuBand::_BeforeCancelPopup()
1097 {
1098     if (m_staticToolbar)
1099         m_staticToolbar->BeforeCancelPopup();
1100     if (m_SFToolbar)
1101         m_SFToolbar->BeforeCancelPopup();
1102     return S_OK;
1103 }
1104
1105 HRESULT CMenuBand::_DisableMouseTrack(BOOL bDisable)
1106 {
1107     if (m_staticToolbar)
1108         m_staticToolbar->DisableMouseTrack(bDisable);
1109     if (m_SFToolbar)
1110         m_SFToolbar->DisableMouseTrack(bDisable);
1111     return S_OK;
1112 }
1113
1114 HRESULT CMenuBand::_KillPopupTimers()
1115 {
1116     HRESULT hr = S_OK;
1117     if (m_staticToolbar)
1118         hr = m_staticToolbar->KillPopupTimer();
1119     if (FAILED(hr))
1120         return hr;
1121
1122     if (m_SFToolbar)
1123         hr = m_SFToolbar->KillPopupTimer();
1124
1125     return hr;
1126 }
1127
1128 HRESULT CMenuBand::_MenuBarMouseDown(HWND hwnd, INT item, BOOL isLButton)
1129 {
1130     if (m_staticToolbar && m_staticToolbar->IsWindowOwner(hwnd) == S_OK)
1131         m_staticToolbar->MenuBarMouseDown(item, isLButton);
1132     if (m_SFToolbar && m_SFToolbar->IsWindowOwner(hwnd) == S_OK)
1133         m_SFToolbar->MenuBarMouseDown(item, isLButton);
1134     return S_OK;
1135 }
1136
1137 HRESULT CMenuBand::_MenuBarMouseUp(HWND hwnd, INT item)
1138 {
1139     if (m_staticToolbar && m_staticToolbar->IsWindowOwner(hwnd) == S_OK)
1140         m_staticToolbar->MenuBarMouseUp(item);
1141     if (m_SFToolbar && m_SFToolbar->IsWindowOwner(hwnd) == S_OK)
1142         m_SFToolbar->MenuBarMouseUp(item);
1143     return S_OK;
1144 }
1145
1146 HRESULT CMenuBand::_HasSubMenu()
1147 {
1148     return m_popupBar ? S_OK : S_FALSE;
1149 }
1150
1151 HRESULT CMenuBand::AdjustForTheme(BOOL bFlatStyle)
1152 {
1153     return IUnknown_QueryServiceExec(m_site, SID_SMenuPopup, &CGID_MenuDeskBar, 4, bFlatStyle, NULL, NULL);
1154 }
1155
1156 HRESULT STDMETHODCALLTYPE CMenuBand::InvalidateItem(LPSMDATA psmd, DWORD dwFlags)
1157 {
1158     UNIMPLEMENTED;
1159     return S_OK;
1160 }
1161
1162 HRESULT STDMETHODCALLTYPE CMenuBand::GetState(LPSMDATA psmd)
1163 {
1164     UNIMPLEMENTED;
1165     return S_OK;
1166 }
1167
1168 HRESULT STDMETHODCALLTYPE CMenuBand::SetMenuToolbar(IUnknown *punk, DWORD dwFlags)
1169 {
1170     UNIMPLEMENTED;
1171     return S_OK;
1172 }
1173
1174 HRESULT STDMETHODCALLTYPE CMenuBand::ResizeBorderDW(LPCRECT prcBorder, IUnknown *punkToolbarSite, BOOL fReserved)
1175 {
1176     UNIMPLEMENTED;
1177     return S_OK;
1178 }
1179
1180 HRESULT STDMETHODCALLTYPE CMenuBand::ContextSensitiveHelp(BOOL fEnterMode)
1181 {
1182     UNIMPLEMENTED;
1183     return S_OK;
1184 }
1185
1186 HRESULT STDMETHODCALLTYPE CMenuBand::GetSubMenu(THIS)
1187 {
1188     UNIMPLEMENTED;
1189     return S_OK;
1190 }
1191
1192 HRESULT STDMETHODCALLTYPE CMenuBand::SetToolbar(THIS)
1193 {
1194     UNIMPLEMENTED;
1195     return S_OK;
1196 }
1197
1198 HRESULT STDMETHODCALLTYPE CMenuBand::SetMinWidth(THIS)
1199 {
1200     UNIMPLEMENTED;
1201     return S_OK;
1202 }
1203
1204 HRESULT STDMETHODCALLTYPE CMenuBand::SetNoBorder(THIS)
1205 {
1206     UNIMPLEMENTED;
1207     return S_OK;
1208 }
1209
1210 HRESULT STDMETHODCALLTYPE CMenuBand::SetTheme(THIS)
1211 {
1212     UNIMPLEMENTED;
1213     return S_OK;
1214 }
1215
1216 HRESULT STDMETHODCALLTYPE CMenuBand::GetTop(THIS)
1217 {
1218     UNIMPLEMENTED;
1219     return S_OK;
1220 }
1221
1222 HRESULT STDMETHODCALLTYPE CMenuBand::GetBottom(THIS)
1223 {
1224     UNIMPLEMENTED;
1225     return S_OK;
1226 }
1227
1228 HRESULT STDMETHODCALLTYPE CMenuBand::GetTracked(THIS)
1229 {
1230     UNIMPLEMENTED;
1231     return S_OK;
1232 }
1233
1234 HRESULT STDMETHODCALLTYPE CMenuBand::GetParentSite(THIS)
1235 {
1236     UNIMPLEMENTED;
1237     return S_OK;
1238 }
1239
1240 HRESULT STDMETHODCALLTYPE CMenuBand::GetState(THIS)
1241 {
1242     UNIMPLEMENTED;
1243     return S_OK;
1244 }
1245
1246 HRESULT STDMETHODCALLTYPE CMenuBand::DoDefaultAction(THIS)
1247 {
1248     UNIMPLEMENTED;
1249     return S_OK;
1250 }
1251
1252 HRESULT STDMETHODCALLTYPE CMenuBand::IsEmpty(THIS)
1253 {
1254     UNIMPLEMENTED;
1255     return S_OK;
1256 }
1257
1258 HRESULT STDMETHODCALLTYPE CMenuBand::HasFocusIO()
1259 {
1260     if (m_popupBar)
1261         return S_OK;
1262     return S_FALSE;
1263 }
1264
1265 HRESULT STDMETHODCALLTYPE CMenuBand::TranslateAcceleratorIO(LPMSG lpMsg)
1266 {
1267     // TODO: Alt down -> toggle menu focus
1268     return S_FALSE;
1269 }
1270
1271 HRESULT STDMETHODCALLTYPE CMenuBand::IsDirty()
1272 {
1273     UNIMPLEMENTED;
1274     return S_OK;
1275 }
1276
1277 HRESULT STDMETHODCALLTYPE CMenuBand::Load(IStream *pStm)
1278 {
1279     UNIMPLEMENTED;
1280     return S_OK;
1281 }
1282
1283 HRESULT STDMETHODCALLTYPE CMenuBand::Save(IStream *pStm, BOOL fClearDirty)
1284 {
1285     UNIMPLEMENTED;
1286     return S_OK;
1287 }
1288
1289 HRESULT STDMETHODCALLTYPE CMenuBand::GetSizeMax(ULARGE_INTEGER *pcbSize)
1290 {
1291     UNIMPLEMENTED;
1292     return S_OK;
1293 }
1294
1295 HRESULT STDMETHODCALLTYPE CMenuBand::GetClassID(CLSID *pClassID)
1296 {
1297     UNIMPLEMENTED;
1298     return S_OK;
1299 }
1300
1301 HRESULT STDMETHODCALLTYPE CMenuBand::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds [], OLECMDTEXT *pCmdText)
1302 {
1303     UNIMPLEMENTED;
1304     return S_OK;
1305 }