dll/win32/browseui/internettoolbar.cpp

   1 /*
   2  * ReactOS Explorer
   3  *
   4  * Copyright 2009 Andrew Hill <ash77 at domain reactos.org>
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 /*
  22 Implements a class that knows how to hold and manage the menu band, brand band,
  23 toolbar, and address band for an explorer window
  24 */
  25
  26 #include "precomp.h"
  27
  28 #if 1
  29
  30 interface IAugmentedShellFolder : public IShellFolder
  31 {
  32     STDMETHOD(AddNameSpace)(LPGUID, IShellFolder *, LPCITEMIDLIST, ULONG) PURE;
  33     STDMETHOD(GetNameSpaceID)(LPCITEMIDLIST, LPGUID) PURE;
  34     STDMETHOD(QueryNameSpace)(ULONG, LPGUID, IShellFolder **) PURE;
  35     STDMETHOD(EnumNameSpace)(ULONG, PULONG) PURE;
  36 };
  37
  38 #endif
  39
  40 // navigation controls and menubar just send a message to parent window
  41 /*
  42 TODO:
  43 ****Implement BandProxy methods
  44 ****Add QueryStatus handler for built-in bands
  45 ****Enable/Disable up, search, and folders commands appropriately
  46   **Why are explorer toolbar separators a nonstandard width?
  47   **Remove "(Empty)" item from Favorites menu. Probably something missing in CMenuCallback::CallbackSM
  48   **Chevron menu on menuband doesn't work
  49   **Fix CInternetToolbar::QueryBand to be generic
  50
  51 ****Fix context menu to strip divider when menu shown for menu band
  52 ****Fix context menu to have items checked appropriately
  53 ****Implement -1 command id update
  54 ****When bands are rearranged, resize the internet toolbar and fix height of brand band
  55 ****Right clicking on the browse back and forward toolbar buttons displays the same as pulldown menus
  56     Implement show/hide of bands
  57     Why is the background color of my toolbars different from explorer?
  58     Internet Toolbar command handler should get the target for the command and call Exec on the target.
  59         For commands built in to the Internet Toolbar, its Exec handles the command
  60     When window width is changed, brand band flashes badly
  61     Add all bands with correct ids (system bands now add with correct ids)
  62     Implement IBandSite
  63     Implement remaining IExplorerToolbar methods
  64     Fix toolbar buttons to enable/disable correctly
  65     After toolbar is customized, it may be necessary to patch the widths of separators
  66     Add theme support
  67     Check sizes and spacing of toolbars against Explorer
  68     Implement resizing of the dock bar
  69     Add missing icons for toolbar items
  70     Draw History item in forward/back dropdown menus with icon
  71     Fix toolbar customize dialog to not include separators as possible selections
  72     Implement save/restore of toolbar state
  73     Refactor drop down menu code to use a common function since code is so similar
  74 */
  75
  76 extern HRESULT WINAPI SHBindToFolder(LPCITEMIDLIST path, IShellFolder **newFolder);
  77
  78 HRESULT IUnknown_RelayWinEvent(IUnknown * punk, HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult)
  79 {
  80     CComPtr<IWinEventHandler> menuWinEventHandler;
  81     HRESULT hResult = punk->QueryInterface(IID_PPV_ARG(IWinEventHandler, &menuWinEventHandler));
  82     if (FAILED_UNEXPECTEDLY(hResult))
  83         return hResult;
  84     hResult = menuWinEventHandler->IsWindowOwner(hWnd);
  85     if (FAILED_UNEXPECTEDLY(hResult))
  86         return hResult;
  87     if (hResult == S_OK)
  88         return menuWinEventHandler->OnWinEvent(hWnd, uMsg, wParam, lParam, theResult);
  89     return S_FALSE;
  90 }
  91
  92 HRESULT IUnknown_ShowDW(IUnknown * punk, BOOL fShow)
  93 {
  94     CComPtr<IDockingWindow> dockingWindow;
  95     HRESULT hResult = punk->QueryInterface(IID_PPV_ARG(IDockingWindow, &dockingWindow));
  96     if (FAILED_UNEXPECTEDLY(hResult))
  97         return hResult;
  98     hResult = dockingWindow->ShowDW(fShow);
  99     if (FAILED_UNEXPECTEDLY(hResult))
 100         return hResult;
 101     return S_OK;
 102 }
 103
 104 HRESULT IUnknown_CloseDW(IUnknown * punk, DWORD dwReserved)
 105 {
 106     CComPtr<IDockingWindow> dockingWindow;
 107     HRESULT hResult = punk->QueryInterface(IID_PPV_ARG(IDockingWindow, &dockingWindow));
 108     if (FAILED_UNEXPECTEDLY(hResult))
 109         return hResult;
 110     hResult = dockingWindow->CloseDW(dwReserved);
 111     if (FAILED_UNEXPECTEDLY(hResult))
 112         return hResult;
 113     return S_OK;
 114 }
 115
 116 class CInternetToolbar;
 117
 118 class CDockSite :
 119     public CComObjectRootEx<CComMultiThreadModelNoCS>,
 120     public IDockingWindowSite,
 121     public IInputObjectSite,
 122     public IOleCommandTarget,
 123     public IServiceProvider
 124 {
 125 public:
 126     enum {
 127         ITF_NOGRIPPER = 1,
 128         ITF_NOTITLE = 2,
 129         ITF_NEWBANDALWAYS = 4,
 130         ITF_GRIPPERALWAYS = 8,
 131         ITF_FIXEDSIZE = 16
 132     };
 133 private:
 134     CComPtr<IUnknown>                       fContainedBand;         // the band inside us
 135     CInternetToolbar                        *fToolbar;              // our browser
 136     HWND                                    fRebarWindow;
 137     HWND                                    fChildWindow;
 138     int                                     fBandID;
 139 public:
 140     int                                     fFlags;
 141 private:
 142     bool                                    fInitialized;
 143     // fields of DESKBANDINFO must be preserved between calls to GetBandInfo
 144     DESKBANDINFO                            fDeskBandInfo;
 145 public:
 146     CDockSite();
 147     ~CDockSite();
 148     HRESULT Initialize(IUnknown *containedBand, CInternetToolbar *browser, HWND hwnd, int bandID, int flags);
 149     HRESULT GetRBBandInfo(REBARBANDINFOW &bandInfo);
 150 private:
 151
 152     // *** IOleWindow methods ***
 153     STDMETHOD(GetWindow)(HWND *lphwnd) override;
 154     STDMETHOD(ContextSensitiveHelp)(BOOL fEnterMode) override;
 155
 156     // *** IDockingWindow methods ***
 157     STDMETHOD(GetBorderDW)(IUnknown* punkObj, LPRECT prcBorder) override;
 158     STDMETHOD(RequestBorderSpaceDW)(IUnknown* punkObj, LPCBORDERWIDTHS pbw) override;
 159     STDMETHOD(SetBorderSpaceDW)(IUnknown* punkObj, LPCBORDERWIDTHS pbw) override;
 160
 161     // *** IInputObjectSite specific methods ***
 162     STDMETHOD(OnFocusChangeIS)(IUnknown *punkObj, BOOL fSetFocus) override;
 163
 164     // *** IOleCommandTarget specific methods ***
 165     STDMETHOD(QueryStatus)(const GUID *pguidCmdGroup, ULONG cCmds,
 166         OLECMD prgCmds[  ], OLECMDTEXT *pCmdText) override;
 167     STDMETHOD(Exec)(const GUID *pguidCmdGroup, DWORD nCmdID,
 168         DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut) override;
 169
 170     // *** IServiceProvider methods ***
 171     STDMETHOD(QueryService)(REFGUID guidService, REFIID riid, void **ppvObject) override;
 172
 173 BEGIN_COM_MAP(CDockSite)
 174     COM_INTERFACE_ENTRY_IID(IID_IOleWindow, IOleWindow)
 175     COM_INTERFACE_ENTRY_IID(IID_IDockingWindowSite, IDockingWindowSite)
 176     COM_INTERFACE_ENTRY_IID(IID_IInputObjectSite, IInputObjectSite)
 177     COM_INTERFACE_ENTRY_IID(IID_IOleCommandTarget, IOleCommandTarget)
 178     COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider)
 179 END_COM_MAP()
 180 };
 181
 182 CDockSite::CDockSite()
 183 {
 184     fToolbar = NULL;
 185     fRebarWindow = NULL;
 186     fChildWindow = NULL;
 187     fBandID = 0;
 188     fFlags = 0;
 189     fInitialized = false;
 190     memset(&fDeskBandInfo, 0, sizeof(fDeskBandInfo));
 191 }
 192
 193 CDockSite::~CDockSite()
 194 {
 195 }
 196
 197 HRESULT CDockSite::Initialize(IUnknown *containedBand, CInternetToolbar *browser, HWND hwnd, int bandID, int flags)
 198 {
 199     TCHAR                                   textBuffer[40];
 200     REBARBANDINFOW                          bandInfo;
 201     HRESULT                                 hResult;
 202
 203     fContainedBand = containedBand;
 204     fToolbar = browser;
 205     fRebarWindow = hwnd;
 206     fBandID = bandID;
 207     fFlags = flags;
 208     hResult = IUnknown_SetSite(containedBand, static_cast<IOleWindow *>(this));
 209     if (FAILED_UNEXPECTEDLY(hResult))
 210         return hResult;
 211     hResult = IUnknown_GetWindow(containedBand, &fChildWindow);
 212     if (FAILED_UNEXPECTEDLY(hResult))
 213         return hResult;
 214
 215     memset(&bandInfo, 0, sizeof(bandInfo));
 216     bandInfo.cbSize = sizeof(bandInfo);
 217     bandInfo.lpText = textBuffer;
 218     bandInfo.cch = sizeof(textBuffer) / sizeof(TCHAR);
 219     hResult = GetRBBandInfo(bandInfo);
 220
 221     SendMessage(fRebarWindow, RB_GETBANDCOUNT, 0, 0);
 222     SendMessage(fRebarWindow, RB_INSERTBANDW, -1, (LPARAM)&bandInfo);
 223     fInitialized = true;
 224     return S_OK;
 225 }
 226
 227 HRESULT CDockSite::GetRBBandInfo(REBARBANDINFOW &bandInfo)
 228 {
 229     CComPtr<IDeskBand>                      deskBand;
 230     HRESULT                                 hResult;
 231
 232     hResult = fContainedBand->QueryInterface(IID_PPV_ARG(IDeskBand, &deskBand));
 233     if (FAILED_UNEXPECTEDLY(hResult))
 234         return hResult;
 235
 236     fDeskBandInfo.dwMask = DBIM_BKCOLOR | DBIM_MODEFLAGS | DBIM_TITLE | DBIM_ACTUAL |
 237         DBIM_INTEGRAL | DBIM_MAXSIZE | DBIM_MINSIZE;
 238     hResult = deskBand->GetBandInfo(fBandID, 0, &fDeskBandInfo);
 239     // result of call is ignored
 240
 241     bandInfo.fMask = RBBIM_LPARAM | RBBIM_IDEALSIZE | RBBIM_ID | RBBIM_CHILDSIZE | RBBIM_CHILD |
 242         RBBIM_TEXT | RBBIM_STYLE;
 243
 244     bandInfo.fStyle = RBBS_FIXEDBMP;
 245     if (fDeskBandInfo.dwModeFlags & DBIMF_VARIABLEHEIGHT)
 246         bandInfo.fStyle |= RBBS_VARIABLEHEIGHT;
 247     if (fDeskBandInfo.dwModeFlags & DBIMF_USECHEVRON)
 248         bandInfo.fStyle |= RBBS_USECHEVRON;
 249     if (fDeskBandInfo.dwModeFlags & DBIMF_BREAK)
 250         bandInfo.fStyle |= RBBS_BREAK;
 251     if (fDeskBandInfo.dwModeFlags & DBIMF_TOPALIGN)
 252         bandInfo.fStyle |= RBBS_TOPALIGN;
 253     if ((fFlags & ITF_NOGRIPPER) || fToolbar->pSettings->fLocked)
 254         bandInfo.fStyle |= RBBS_NOGRIPPER;
 255     if (fFlags & ITF_NOTITLE)
 256         bandInfo.fStyle |= RBBS_HIDETITLE;
 257     if ((fFlags & ITF_GRIPPERALWAYS) && !fToolbar->pSettings->fLocked)
 258         bandInfo.fStyle |= RBBS_GRIPPERALWAYS;
 259     if (fFlags & ITF_FIXEDSIZE)
 260         bandInfo.fStyle |= RBBS_FIXEDSIZE;
 261
 262     if (fDeskBandInfo.dwModeFlags & DBIMF_BKCOLOR)
 263     {
 264         bandInfo.fMask |= RBBIM_COLORS;
 265         bandInfo.clrFore = CLR_DEFAULT;
 266         bandInfo.clrBack = fDeskBandInfo.crBkgnd;
 267     }
 268     wcsncpy(bandInfo.lpText, fDeskBandInfo.wszTitle, bandInfo.cch);
 269     bandInfo.hwndChild = fChildWindow;
 270     bandInfo.cxMinChild = fDeskBandInfo.ptMinSize.x;
 271     bandInfo.cyMinChild = fDeskBandInfo.ptMinSize.y;
 272     bandInfo.wID = fBandID;
 273     bandInfo.cyChild = fDeskBandInfo.ptActual.y;
 274     bandInfo.cyMaxChild = fDeskBandInfo.ptMaxSize.y;
 275     bandInfo.cyIntegral = fDeskBandInfo.ptIntegral.y;
 276     bandInfo.cxIdeal = fDeskBandInfo.ptActual.x;
 277     bandInfo.lParam = reinterpret_cast<LPARAM>(this);
 278     return S_OK;
 279 }
 280
 281 HRESULT STDMETHODCALLTYPE CDockSite::GetWindow(HWND *lphwnd)
 282 {
 283     if (lphwnd == NULL)
 284         return E_POINTER;
 285     *lphwnd = fRebarWindow;
 286     return S_OK;
 287 }
 288
 289 HRESULT STDMETHODCALLTYPE CDockSite::ContextSensitiveHelp(BOOL fEnterMode)
 290 {
 291     return E_NOTIMPL;
 292 }
 293
 294 HRESULT STDMETHODCALLTYPE CDockSite::GetBorderDW(IUnknown* punkObj, LPRECT prcBorder)
 295 {
 296     return E_NOTIMPL;
 297 }
 298
 299 HRESULT STDMETHODCALLTYPE CDockSite::RequestBorderSpaceDW(IUnknown* punkObj, LPCBORDERWIDTHS pbw)
 300 {
 301     return E_NOTIMPL;
 302 }
 303
 304 HRESULT STDMETHODCALLTYPE CDockSite::SetBorderSpaceDW(IUnknown* punkObj, LPCBORDERWIDTHS pbw)
 305 {
 306     return E_NOTIMPL;
 307 }
 308
 309 HRESULT STDMETHODCALLTYPE CDockSite::OnFocusChangeIS (IUnknown *punkObj, BOOL fSetFocus)
 310 {
 311     return E_NOTIMPL;
 312 }
 313
 314 HRESULT STDMETHODCALLTYPE CDockSite::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds,
 315     OLECMD prgCmds[  ], OLECMDTEXT *pCmdText)
 316 {
 317     return E_NOTIMPL;
 318 }
 319
 320 HRESULT STDMETHODCALLTYPE CDockSite::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt,
 321     VARIANT *pvaIn, VARIANT *pvaOut)
 322 {
 323     TCHAR                                   textBuffer[40];
 324     REBARBANDINFOW                          bandInfo;
 325     int                                     index;
 326     HRESULT                                 hResult;
 327
 328     if (IsEqualIID(*pguidCmdGroup, CGID_DeskBand))
 329     {
 330         switch (nCmdID)
 331         {
 332             case DBID_BANDINFOCHANGED:
 333                 if (fInitialized == false)
 334                     return S_OK;
 335                 if (V_VT(pvaIn) != VT_I4)
 336                     return E_INVALIDARG;
 337                 if (V_I4(pvaIn) != fBandID)
 338                     return E_FAIL;
 339                 // deskband information changed
 340                 // call GetBandInfo and refresh information in rebar
 341                 memset(&bandInfo, 0, sizeof(bandInfo));
 342                 bandInfo.cbSize = sizeof(bandInfo);
 343                 bandInfo.lpText = textBuffer;
 344                 bandInfo.cch = sizeof(textBuffer) / sizeof(TCHAR);
 345                 hResult = GetRBBandInfo(bandInfo);
 346                 if (FAILED_UNEXPECTEDLY(hResult))
 347                     return hResult;
 348                 index = (int)SendMessage(fRebarWindow, RB_IDTOINDEX, fBandID, 0);
 349                 SendMessage(fRebarWindow, RB_SETBANDINFOW, index, (LPARAM)&bandInfo);
 350                 return S_OK;
 351         }
 352     }
 353     return E_FAIL;
 354 }
 355
 356 HRESULT STDMETHODCALLTYPE CDockSite::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
 357 {
 358     if (IsEqualIID(guidService, SID_SMenuBandParent))
 359         return this->QueryInterface(riid, ppvObject);
 360
 361     return fToolbar->QueryService(guidService, riid, ppvObject);
 362 }
 363
 364 CMenuCallback::CMenuCallback()
 365 {
 366 }
 367
 368 CMenuCallback::~CMenuCallback()
 369 {
 370 }
 371
 372 static HRESULT BindToDesktop(LPCITEMIDLIST pidl, IShellFolder ** ppsfResult)
 373 {
 374     HRESULT hr;
 375     CComPtr<IShellFolder> psfDesktop;
 376
 377     *ppsfResult = NULL;
 378
 379     hr = SHGetDesktopFolder(&psfDesktop);
 380     if (FAILED(hr))
 381         return hr;
 382
 383     hr = psfDesktop->BindToObject(pidl, NULL, IID_PPV_ARG(IShellFolder, ppsfResult));
 384
 385     return hr;
 386 }
 387
 388 static HRESULT GetFavoritesFolder(IShellFolder ** ppsfFavorites, LPITEMIDLIST * ppidl)
 389 {
 390     HRESULT hr;
 391     LPITEMIDLIST pidlUserFavorites;
 392     LPITEMIDLIST pidlCommonFavorites;
 393     CComPtr<IShellFolder> psfUserFavorites;
 394     CComPtr<IShellFolder> psfCommonFavorites;
 395     CComPtr<IAugmentedShellFolder> pasf;
 396
 397     if (ppsfFavorites)
 398         *ppsfFavorites = NULL;
 399
 400     if (ppidl)
 401         *ppidl = NULL;
 402
 403     hr = SHGetSpecialFolderLocation(NULL, CSIDL_FAVORITES, &pidlUserFavorites);
 404     if (FAILED(hr))
 405     {
 406         WARN("Failed to get the USER favorites folder. Trying to run with just the COMMON one.\n");
 407
 408         hr = SHGetSpecialFolderLocation(NULL, CSIDL_COMMON_FAVORITES, &pidlCommonFavorites);
 409         if (FAILED_UNEXPECTEDLY(hr))
 410             return hr;
 411
 412         TRACE("COMMON favorites obtained.\n");
 413         *ppidl = pidlCommonFavorites;
 414         hr = BindToDesktop(pidlCommonFavorites, ppsfFavorites);
 415         return hr;
 416     }
 417
 418     hr = SHGetSpecialFolderLocation(NULL, CSIDL_COMMON_FAVORITES, &pidlCommonFavorites);
 419     if (FAILED_UNEXPECTEDLY(hr))
 420     {
 421         WARN("Failed to get the COMMON favorites folder. Will use only the USER contents.\n");
 422         *ppidl = pidlCommonFavorites;
 423         hr = BindToDesktop(pidlUserFavorites, ppsfFavorites);
 424         return hr;
 425     }
 426
 427     TRACE("Both COMMON and USER favorites folders obtained, merging them...\n");
 428
 429     hr = BindToDesktop(pidlUserFavorites, &psfUserFavorites);
 430     if (FAILED_UNEXPECTEDLY(hr))
 431         return hr;
 432
 433     hr = BindToDesktop(pidlCommonFavorites, &psfCommonFavorites);
 434     if (FAILED_UNEXPECTEDLY(hr))
 435         return hr;
 436
 437     hr = CMergedFolder_CreateInstance(IID_PPV_ARG(IAugmentedShellFolder, &pasf));
 438     if (FAILED_UNEXPECTEDLY(hr))
 439     {
 440         *ppsfFavorites = psfUserFavorites.Detach();
 441         *ppidl = pidlUserFavorites;
 442         ILFree(pidlCommonFavorites);
 443         return hr;
 444     }
 445
 446     hr = pasf->AddNameSpace(NULL, psfUserFavorites, pidlUserFavorites, 0xFF00);
 447     if (FAILED_UNEXPECTEDLY(hr))
 448         return hr;
 449
 450     hr = pasf->AddNameSpace(NULL, psfCommonFavorites, pidlCommonFavorites, 0);
 451     if (FAILED_UNEXPECTEDLY(hr))
 452         return hr;
 453
 454     hr = pasf->QueryInterface(IID_PPV_ARG(IShellFolder, ppsfFavorites));
 455     pasf.Release();
 456
 457     // TODO: obtain the folder's PIDL
 458
 459     ILFree(pidlCommonFavorites);
 460     ILFree(pidlUserFavorites);
 461
 462     return hr;
 463 }
 464
 465 HRESULT STDMETHODCALLTYPE CMenuCallback::GetObject(LPSMDATA psmd, REFIID riid, void **ppvObject)
 466 {
 467     CComPtr<IShellMenu>                     parentMenu;
 468     CComPtr<IShellMenu>                     newMenu;
 469     CComPtr<IShellFolder>                   favoritesFolder;
 470     LPITEMIDLIST                            favoritesPIDL;
 471     HWND                                    ownerWindow;
 472     HMENU                                   parentHMenu;
 473     HMENU                                   favoritesHMenu;
 474     HKEY                                    orderRegKey;
 475     DWORD                                   disposition;
 476     HRESULT                                 hResult;
 477     static const TCHAR szFavoritesKey[] =
 478         _T("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\MenuOrder\\Favorites");
 479
 480     if (!IsEqualIID(riid, IID_IShellMenu))
 481         return E_FAIL;
 482     if (psmd->uId != FCIDM_MENU_FAVORITES)
 483         return E_FAIL;
 484
 485     // create favorites menu
 486     hResult = psmd->punk->QueryInterface(IID_PPV_ARG(IShellMenu, &parentMenu));
 487     if (FAILED_UNEXPECTEDLY(hResult))
 488         return hResult;
 489     hResult = parentMenu->GetMenu(&parentHMenu, &ownerWindow, NULL);
 490     if (FAILED_UNEXPECTEDLY(hResult))
 491         return hResult;
 492     favoritesHMenu = GetSubMenu(parentHMenu, 3);
 493     if (favoritesHMenu == NULL)
 494         return E_FAIL;
 495
 496     if (fFavoritesMenu.p == NULL)
 497     {
 498         hResult = CMenuBand_CreateInstance(IID_PPV_ARG(IShellMenu, &newMenu));
 499         if (FAILED_UNEXPECTEDLY(hResult))
 500             return hResult;
 501         hResult = newMenu->Initialize(this, FCIDM_MENU_FAVORITES, -1, SMINIT_VERTICAL | SMINIT_CACHED);
 502         if (FAILED_UNEXPECTEDLY(hResult))
 503             return hResult;
 504
 505         RegCreateKeyEx(HKEY_CURRENT_USER, szFavoritesKey,
 506                 0, NULL, 0, KEY_READ | KEY_WRITE, NULL, &orderRegKey, &disposition);
 507
 508         hResult = GetFavoritesFolder(&favoritesFolder, &favoritesPIDL);
 509         if (FAILED_UNEXPECTEDLY(hResult))
 510             return hResult;
 511
 512         hResult = newMenu->SetShellFolder(favoritesFolder, favoritesPIDL, orderRegKey, SMSET_BOTTOM | SMINIT_CACHED | SMINV_ID);
 513         if (favoritesPIDL)
 514             ILFree(favoritesPIDL);
 515
 516         if (FAILED(hResult))
 517             return hResult;
 518
 519         fFavoritesMenu = newMenu;
 520     }
 521
 522     hResult = fFavoritesMenu->SetMenu(favoritesHMenu, ownerWindow, SMSET_TOP | SMSET_DONTOWN);
 523     if (FAILED_UNEXPECTEDLY(hResult))
 524         return hResult;
 525
 526     return fFavoritesMenu->QueryInterface(riid, ppvObject);
 527 }
 528
 529 HRESULT STDMETHODCALLTYPE CMenuCallback::CallbackSM(LPSMDATA psmd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 530 {
 531     switch (uMsg)
 532     {
 533         case SMC_INITMENU:
 534             break;
 535         case SMC_CREATE:
 536             break;
 537         case SMC_EXITMENU:
 538             break;
 539         case SMC_GETINFO:
 540         {
 541             SMINFO *infoPtr = reinterpret_cast<SMINFO *>(lParam);
 542             if ((infoPtr->dwMask & SMIM_FLAGS) != 0)
 543             {
 544                 if (psmd->uId == FCIDM_MENU_FAVORITES)
 545                 {
 546                     infoPtr->dwFlags |= SMIF_DROPCASCADE;
 547                 }
 548                 else
 549                 {
 550                     infoPtr->dwFlags |= SMIF_TRACKPOPUP;
 551                 }
 552             }
 553             if ((infoPtr->dwMask & SMIM_ICON) != 0)
 554                 infoPtr->iIcon = -1;
 555             return S_OK;
 556         }
 557         case SMC_GETSFINFO:
 558             break;
 559         case SMC_GETOBJECT:
 560             return GetObject(psmd, *reinterpret_cast<IID *>(wParam), reinterpret_cast<void **>(lParam));
 561         case SMC_GETSFOBJECT:
 562             break;
 563         case SMC_EXEC:
 564             PostMessageW(psmd->hwnd, WM_COMMAND, psmd->uId, 0);
 565             break;
 566         case SMC_SFEXEC:
 567             SHInvokeDefaultCommand(psmd->hwnd, psmd->psf, psmd->pidlItem);
 568             break;
 569         case SMC_SFSELECTITEM:
 570             break;
 571         case 13:
 572             // return tooltip
 573             break;
 574         case SMC_REFRESH:
 575             break;
 576         case SMC_DEMOTE:
 577             break;
 578         case SMC_PROMOTE:
 579             break;
 580         case 0x13:
 581             break;
 582         case SMC_DEFAULTICON:
 583             break;
 584         case SMC_NEWITEM:
 585             break;
 586         case SMC_CHEVRONEXPAND:
 587             break;
 588         case SMC_DISPLAYCHEVRONTIP:
 589             break;
 590         case SMC_SETSFOBJECT:
 591             break;
 592         case SMC_SHCHANGENOTIFY:
 593             break;
 594         case SMC_CHEVRONGETTIP:
 595             break;
 596         case SMC_SFDDRESTRICTED:
 597             break;
 598         case 0x35:
 599             break;
 600         case 49:
 601             break;
 602         case 0x10000000:
 603             break;
 604     }
 605     return S_FALSE;
 606 }
 607
 608 CInternetToolbar::CInternetToolbar()
 609 {
 610     fMainReBar = NULL;
 611     fMenuBandWindow = NULL;
 612     fNavigationWindow = NULL;
 613     fMenuCallback = new CComObject<CMenuCallback>();
 614     fToolbarWindow = NULL;
 615     fAdviseCookie = 0;
 616     pSettings = NULL;
 617 }
 618
 619 CInternetToolbar::~CInternetToolbar()
 620 {
 621 }
 622
 623 void CInternetToolbar::AddDockItem(IUnknown *newItem, int bandID, int flags)
 624 {
 625     CComPtr<CDockSite> newSite;
 626
 627     newSite = new CComObject<CDockSite>;
 628     newSite->Initialize(newItem, this, fMainReBar, bandID, flags);
 629 }
 630
 631 HRESULT CInternetToolbar::ReserveBorderSpace(LONG maxHeight)
 632 {
 633     CComPtr<IDockingWindowSite>             dockingWindowSite;
 634     RECT                                    availableBorderSpace;
 635
 636     HRESULT hResult = fSite->QueryInterface(IID_PPV_ARG(IDockingWindowSite, &dockingWindowSite));
 637     if (FAILED_UNEXPECTEDLY(hResult))
 638         return hResult;
 639     hResult = dockingWindowSite->GetBorderDW(static_cast<IDockingWindow *>(this), &availableBorderSpace);
 640     if (FAILED_UNEXPECTEDLY(hResult))
 641         return hResult;
 642
 643     if (maxHeight && availableBorderSpace.bottom - availableBorderSpace.top > maxHeight)
 644     {
 645         availableBorderSpace.bottom = availableBorderSpace.top + maxHeight;
 646     }
 647
 648     return ResizeBorderDW(&availableBorderSpace, fSite, FALSE);
 649 }
 650
 651 HRESULT CInternetToolbar::CreateMenuBar(IShellMenu **pMenuBar)
 652 {
 653     CComPtr<IShellMenu>                     menubar;
 654     CComPtr<IShellMenuCallback>             callback;
 655     VARIANT                                 menuOut;
 656     HWND                                    ownerWindow;
 657     HRESULT                                 hResult;
 658
 659     if (!pMenuBar)
 660         return E_POINTER;
 661
 662     *pMenuBar = NULL;
 663
 664     hResult = CMenuBand_CreateInstance(IID_PPV_ARG(IShellMenu, &menubar));
 665     if (FAILED_UNEXPECTEDLY(hResult))
 666         return hResult;
 667
 668     hResult = fMenuCallback->QueryInterface(IID_PPV_ARG(IShellMenuCallback, &callback));
 669     if (FAILED_UNEXPECTEDLY(hResult))
 670         return hResult;
 671
 672     hResult = menubar->Initialize(callback, -1, ANCESTORDEFAULT, SMINIT_HORIZONTAL | SMINIT_TOPLEVEL);
 673     if (FAILED_UNEXPECTEDLY(hResult))
 674         return hResult;
 675
 676     // Set Menu
 677     {
 678         hResult = IUnknown_Exec(fSite, CGID_Explorer, 0x35, 0, NULL, &menuOut);
 679         if (FAILED_UNEXPECTEDLY(hResult))
 680             return hResult;
 681
 682         if (V_VT(&menuOut) != VT_INT_PTR || V_INTREF(&menuOut) == NULL)
 683             return E_FAIL;
 684
 685         hResult = IUnknown_GetWindow(fSite, &ownerWindow);
 686         if (FAILED_UNEXPECTEDLY(hResult))
 687             return hResult;
 688
 689         HMENU hMenuBar = (HMENU) V_INTREF(&menuOut);
 690
 691         // FIXME: Figure out the proper way to do this.
 692         HMENU hMenuFavs = GetSubMenu(hMenuBar, 3);
 693         if (hMenuFavs)
 694         {
 695             DeleteMenu(hMenuFavs, IDM_FAVORITES_EMPTY, MF_BYCOMMAND);
 696         }
 697
 698         hResult = menubar->SetMenu(hMenuBar, ownerWindow, SMSET_DONTOWN);
 699         if (FAILED_UNEXPECTEDLY(hResult))
 700             return hResult;
 701     }
 702
 703     hResult = IUnknown_Exec(menubar, CGID_MenuBand, 3, 1, NULL, NULL);
 704     if (FAILED_UNEXPECTEDLY(hResult))
 705         return hResult;
 706
 707     *pMenuBar = menubar.Detach();
 708
 709     return S_OK;
 710 }
 711
 712 HRESULT CInternetToolbar::LockUnlockToolbars(bool locked)
 713 {
 714     if (locked != !!pSettings->fLocked)
 715     {
 716         pSettings->fLocked = (BOOL)locked;
 717         pSettings->Save();
 718         RefreshLockedToolbarState();
 719     }
 720     return S_OK;
 721 }
 722
 723 void CInternetToolbar::RefreshLockedToolbarState()
 724 {
 725     REBARBANDINFOW                          rebarBandInfo;
 726     int                                     bandCount;
 727     CDockSite                               *dockSite;
 728
 729     rebarBandInfo.cbSize = sizeof(rebarBandInfo);
 730     rebarBandInfo.fMask = RBBIM_STYLE | RBBIM_LPARAM;
 731     bandCount = (int)SendMessage(fMainReBar, RB_GETBANDCOUNT, 0, 0);
 732     for (INT x  = 0; x < bandCount; x++)
 733     {
 734         SendMessage(fMainReBar, RB_GETBANDINFOW, x, (LPARAM)&rebarBandInfo);
 735         dockSite = reinterpret_cast<CDockSite *>(rebarBandInfo.lParam);
 736         if (dockSite != NULL)
 737         {
 738             rebarBandInfo.fStyle &= ~(RBBS_NOGRIPPER | RBBS_GRIPPERALWAYS);
 739             if ((dockSite->fFlags & CDockSite::ITF_NOGRIPPER) || pSettings->fLocked)
 740                 rebarBandInfo.fStyle |= RBBS_NOGRIPPER;
 741             if ((dockSite->fFlags & CDockSite::ITF_GRIPPERALWAYS) && !pSettings->fLocked)
 742                 rebarBandInfo.fStyle |= RBBS_GRIPPERALWAYS;
 743             SendMessage(fMainReBar, RB_SETBANDINFOW, x, (LPARAM)&rebarBandInfo);
 744         }
 745     }
 746     ReserveBorderSpace(0);
 747 }
 748
 749 HRESULT CInternetToolbar::SetState(const GUID *pguidCmdGroup, long commandID, OLECMD* pcmd)
 750 {
 751     long state = 0;
 752     if (pcmd->cmdf & OLECMDF_ENABLED)
 753         state |= TBSTATE_ENABLED;
 754     if (pcmd->cmdf & OLECMDF_LATCHED)
 755         state |= TBSTATE_CHECKED;
 756     return SetState(pguidCmdGroup, commandID, state);
 757 }
 758
 759 HRESULT CInternetToolbar::CommandStateChanged(bool newValue, int commandID)
 760 {
 761     HRESULT                                 hResult;
 762
 763     hResult = S_OK;
 764     switch (commandID)
 765     {
 766         case -1:
 767             // loop through buttons
 768             //for buttons in CLSID_CommonButtons
 769             //    if up, QueryStatus for up state and update it
 770             //
 771             //for buttons in fCommandCategory, update with QueryStatus of fCommandTarget
 772
 773             OLECMD commandList[4];
 774             commandList[0].cmdID = 0x1c;
 775             commandList[1].cmdID = 0x1d;
 776             commandList[2].cmdID = 0x1e;
 777             commandList[3].cmdID = 0x23;
 778             IUnknown_QueryStatus(fSite, CGID_Explorer, 4, commandList, NULL);
 779             SetState(&CLSID_CommonButtons, gSearchCommandID, &commandList[0]);
 780             SetState(&CLSID_CommonButtons, gFoldersCommandID, &commandList[3]);
 781             //SetState(&CLSID_CommonButtons, gFavoritesCommandID, &commandList[2]);
 782             //SetState(&CLSID_CommonButtons, gHistoryCommandID, &commandList[1]);
 783
 784             break;
 785         case 1:
 786             // forward
 787             hResult = SetState(&CLSID_CommonButtons, IDM_GOTO_FORWARD, newValue ? TBSTATE_ENABLED : 0);
 788             break;
 789         case 2:
 790             // back
 791             hResult = SetState(&CLSID_CommonButtons, IDM_GOTO_BACK, newValue ? TBSTATE_ENABLED : 0);
 792             break;
 793         case 3:
 794             // up
 795             hResult = SetState(&CLSID_CommonButtons, IDM_GOTO_UPONELEVEL, newValue ? TBSTATE_ENABLED : 0);
 796             break;
 797     }
 798     return hResult;
 799 }
 800
 801 HRESULT CInternetToolbar::CreateAndInitBandProxy()
 802 {
 803     CComPtr<IServiceProvider>               serviceProvider;
 804     HRESULT                                 hResult;
 805
 806     hResult = fSite->QueryInterface(IID_PPV_ARG(IServiceProvider, &serviceProvider));
 807     if (FAILED_UNEXPECTEDLY(hResult))
 808         return hResult;
 809     hResult = serviceProvider->QueryService(SID_IBandProxy, IID_PPV_ARG(IBandProxy, &fBandProxy));
 810     if (FAILED_UNEXPECTEDLY(hResult))
 811     {
 812         hResult = CBandProxy_CreateInstance(IID_PPV_ARG(IBandProxy, &fBandProxy));
 813         if (FAILED_UNEXPECTEDLY(hResult))
 814             return hResult;
 815         hResult = fBandProxy->SetSite(fSite);
 816         if (FAILED_UNEXPECTEDLY(hResult))
 817             return hResult;
 818     }
 819     return S_OK;
 820 }
 821
 822 HRESULT STDMETHODCALLTYPE CInternetToolbar::UIActivateIO(BOOL fActivate, LPMSG lpMsg)
 823 {
 824     return E_NOTIMPL;
 825 }
 826
 827 HRESULT STDMETHODCALLTYPE CInternetToolbar::HasFocusIO()
 828 {
 829     HRESULT hr = S_FALSE;
 830
 831     if (fMenuBar)
 832         hr = IUnknown_HasFocusIO(fMenuBar);
 833     if (hr != S_FALSE)
 834         return hr;
 835
 836     if (fControlsBar)
 837         hr = IUnknown_HasFocusIO(fControlsBar);
 838     if (hr != S_FALSE)
 839         return hr;
 840
 841     if (fNavigationBar)
 842         hr = IUnknown_HasFocusIO(fNavigationBar);
 843     if (hr != S_FALSE)
 844         return hr;
 845
 846     return S_FALSE;
 847 }
 848
 849 HRESULT STDMETHODCALLTYPE CInternetToolbar::TranslateAcceleratorIO(LPMSG lpMsg)
 850 {
 851     HRESULT hr = S_FALSE;
 852
 853     if (fMenuBar)
 854         hr = IUnknown_TranslateAcceleratorIO(fMenuBar, lpMsg);
 855     if (hr == S_OK)
 856         return hr;
 857
 858     if (fControlsBar)
 859         hr = IUnknown_TranslateAcceleratorIO(fControlsBar, lpMsg);
 860     if (hr == S_OK)
 861         return hr;
 862
 863     if (fNavigationBar)
 864         hr = IUnknown_TranslateAcceleratorIO(fNavigationBar, lpMsg);
 865     if (hr == S_OK)
 866         return hr;
 867
 868     return S_FALSE;
 869 }
 870
 871 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetWindow(HWND *lphwnd)
 872 {
 873     if (lphwnd == NULL)
 874         return E_POINTER;
 875     *lphwnd = m_hWnd;
 876     return S_OK;
 877 }
 878
 879 HRESULT STDMETHODCALLTYPE CInternetToolbar::ContextSensitiveHelp(BOOL fEnterMode)
 880 {
 881     return E_NOTIMPL;
 882 }
 883
 884 HRESULT STDMETHODCALLTYPE CInternetToolbar::ShowDW(BOOL fShow)
 885 {
 886     HRESULT                     hResult;
 887
 888     // show the bar here
 889     if (fShow)
 890     {
 891         hResult = ReserveBorderSpace();
 892         if (FAILED_UNEXPECTEDLY(hResult))
 893             return hResult;
 894     }
 895
 896     if (fMenuBar)
 897     {
 898         hResult = IUnknown_ShowDW(fMenuBar, fShow);
 899         if (FAILED_UNEXPECTEDLY(hResult))
 900             return hResult;
 901     }
 902
 903     if (fControlsBar)
 904     {
 905         hResult = IUnknown_ShowDW(fControlsBar, fShow);
 906         if (FAILED_UNEXPECTEDLY(hResult))
 907             return hResult;
 908     }
 909     if (fNavigationBar)
 910     {
 911         hResult = IUnknown_ShowDW(fNavigationBar, fShow);
 912         if (FAILED_UNEXPECTEDLY(hResult))
 913             return hResult;
 914     }
 915     if (fLogoBar)
 916     {
 917         hResult = IUnknown_ShowDW(fLogoBar, fShow);
 918         if (FAILED_UNEXPECTEDLY(hResult))
 919             return hResult;
 920     }
 921     return S_OK;
 922 }
 923
 924 HRESULT STDMETHODCALLTYPE CInternetToolbar::CloseDW(DWORD dwReserved)
 925 {
 926     HRESULT                     hResult;
 927
 928     if (fMenuBar)
 929     {
 930         hResult = IUnknown_CloseDW(fMenuBar, dwReserved);
 931         if (FAILED_UNEXPECTEDLY(hResult))
 932             return hResult;
 933         ReleaseCComPtrExpectZero(fMenuBar);
 934     }
 935     if (fControlsBar)
 936     {
 937         hResult = IUnknown_CloseDW(fControlsBar, dwReserved);
 938         if (FAILED_UNEXPECTEDLY(hResult))
 939             return hResult;
 940         ReleaseCComPtrExpectZero(fControlsBar);
 941     }
 942     if (fNavigationBar)
 943     {
 944         hResult = IUnknown_CloseDW(fNavigationBar, dwReserved);
 945         if (FAILED_UNEXPECTEDLY(hResult))
 946             return hResult;
 947         ReleaseCComPtrExpectZero(fNavigationBar);
 948     }
 949     if (fLogoBar)
 950     {
 951         hResult = IUnknown_CloseDW(fLogoBar, dwReserved);
 952         if (FAILED_UNEXPECTEDLY(hResult))
 953             return hResult;
 954         ReleaseCComPtrExpectZero(fLogoBar);
 955     }
 956
 957     SetSite(NULL);
 958     return S_OK;
 959 }
 960
 961 HRESULT STDMETHODCALLTYPE CInternetToolbar::ResizeBorderDW(LPCRECT prcBorder,
 962     IUnknown *punkToolbarSite, BOOL fReserved)
 963 {
 964     RECT neededBorderSpace;
 965     RECT availableBorderSpace = *prcBorder;
 966
 967     SendMessage(fMainReBar, RB_SIZETORECT, RBSTR_CHANGERECT, reinterpret_cast<LPARAM>(&availableBorderSpace));
 968
 969     // RBSTR_CHANGERECT does not seem to set the proper size in the rect.
 970     // Let's make sure we fetch the actual size properly.
 971     ::GetWindowRect(fMainReBar, &availableBorderSpace);
 972     neededBorderSpace.left = 0;
 973     neededBorderSpace.top = availableBorderSpace.bottom - availableBorderSpace.top;
 974     if (!pSettings->fLocked)
 975         neededBorderSpace.top += 3;
 976     neededBorderSpace.right = 0;
 977     neededBorderSpace.bottom = 0;
 978
 979     CComPtr<IDockingWindowSite> dockingWindowSite;
 980
 981     HRESULT hResult = fSite->QueryInterface(IID_PPV_ARG(IDockingWindowSite, &dockingWindowSite));
 982     if (FAILED_UNEXPECTEDLY(hResult))
 983         return hResult;
 984
 985     hResult = dockingWindowSite->RequestBorderSpaceDW(static_cast<IDockingWindow *>(this), &neededBorderSpace);
 986     if (FAILED_UNEXPECTEDLY(hResult))
 987         return hResult;
 988
 989     hResult = dockingWindowSite->SetBorderSpaceDW(static_cast<IDockingWindow *>(this), &neededBorderSpace);
 990     if (FAILED_UNEXPECTEDLY(hResult))
 991         return hResult;
 992
 993     return S_OK;
 994 }
 995
 996 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetClassID(CLSID *pClassID)
 997 {
 998     if (pClassID == NULL)
 999         return E_POINTER;
1000     *pClassID = CLSID_InternetToolbar;
1001     return S_OK;
1002 }
1003
1004 HRESULT STDMETHODCALLTYPE CInternetToolbar::IsDirty()
1005 {
1006     return E_NOTIMPL;
1007 }
1008
1009 HRESULT STDMETHODCALLTYPE CInternetToolbar::Load(IStream *pStm)
1010 {
1011     return E_NOTIMPL;
1012 }
1013
1014 HRESULT STDMETHODCALLTYPE CInternetToolbar::Save(IStream *pStm, BOOL fClearDirty)
1015 {
1016     return E_NOTIMPL;
1017 }
1018
1019 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetSizeMax(ULARGE_INTEGER *pcbSize)
1020 {
1021     return E_NOTIMPL;
1022 }
1023
1024 HRESULT STDMETHODCALLTYPE CInternetToolbar::InitNew()
1025 {
1026     CComPtr<IShellMenu>                     menuBar;
1027     CComPtr<IUnknown>                       logoBar;
1028     CComPtr<IUnknown>                       toolsBar;
1029     CComPtr<IUnknown>                       navigationBar;
1030     HRESULT                                 hResult;
1031
1032     /* Create and attach the menubar to the rebar */
1033     hResult = CreateMenuBar(&menuBar);
1034     if (FAILED_UNEXPECTEDLY(hResult))
1035         return hResult;
1036     AddDockItem(menuBar, ITBBID_MENUBAND, CDockSite::ITF_NOTITLE | CDockSite::ITF_NEWBANDALWAYS | CDockSite::ITF_GRIPPERALWAYS);
1037
1038     hResult = IUnknown_GetWindow(menuBar, &fMenuBandWindow);
1039     fMenuBar.Attach(menuBar.Detach());                  // transfer the ref count
1040
1041     // FIXME: The ROS Rebar does not properly support fixed-size items such as the brandband,
1042     // and it will put them in their own row, sized to take up the whole row.
1043 #if 0
1044     /* Create and attach the brand/logo to the rebar */
1045     hResult = CBrandBand_CreateInstance(IID_PPV_ARG(IUnknown, &logoBar));
1046     if (FAILED_UNEXPECTEDLY(hResult))
1047         return hResult;
1048     AddDockItem(logoBar, ITBBID_BRANDBAND, CDockSite::ITF_NOGRIPPER | CDockSite::ITF_NOTITLE | CDockSite::ITF_FIXEDSIZE);
1049     fLogoBar.Attach(logoBar.Detach());                  // transfer the ref count
1050 #endif
1051
1052     /* Create and attach the standard toolbar to the rebar */
1053     hResult = CToolsBand_CreateInstance(IID_PPV_ARG(IUnknown, &toolsBar));
1054     if (FAILED_UNEXPECTEDLY(hResult))
1055         return hResult;
1056     AddDockItem(toolsBar, ITBBID_TOOLSBAND, CDockSite::ITF_NOTITLE | CDockSite::ITF_NEWBANDALWAYS | CDockSite::ITF_GRIPPERALWAYS);
1057     fControlsBar.Attach(toolsBar.Detach());             // transfer the ref count
1058     hResult = IUnknown_GetWindow(fControlsBar, &fToolbarWindow);
1059     if (FAILED_UNEXPECTEDLY(hResult))
1060         return hResult;
1061
1062     /* Create and attach the address/navigation toolbar to the rebar */
1063     hResult = CAddressBand_CreateInstance(IID_PPV_ARG(IUnknown, &navigationBar));
1064     if (FAILED_UNEXPECTEDLY(hResult))
1065         return hResult;
1066     AddDockItem(navigationBar, ITBBID_ADDRESSBAND, CDockSite::ITF_NEWBANDALWAYS | CDockSite::ITF_GRIPPERALWAYS);
1067     fNavigationBar.Attach(navigationBar.Detach());
1068     hResult = IUnknown_GetWindow(fNavigationBar, &fNavigationWindow);
1069
1070     return S_OK;
1071 }
1072
1073 HRESULT CInternetToolbar::IsBandVisible(int BandID)
1074 {
1075     int index = (int)SendMessage(fMainReBar, RB_IDTOINDEX, BandID, 0);
1076
1077     REBARBANDINFOW bandInfo = {sizeof(REBARBANDINFOW), RBBIM_STYLE};
1078     SendMessage(fMainReBar, RB_GETBANDINFOW, index, (LPARAM)&bandInfo);
1079
1080     return (bandInfo.fStyle & RBBS_HIDDEN) ? S_FALSE : S_OK;
1081 }
1082
1083 HRESULT CInternetToolbar::ToggleBandVisibility(int BandID)
1084 {
1085     int index = (int)SendMessage(fMainReBar, RB_IDTOINDEX, BandID, 0);
1086
1087     REBARBANDINFOW bandInfo = {sizeof(REBARBANDINFOW), RBBIM_STYLE};
1088     SendMessage(fMainReBar, RB_GETBANDINFOW, index, (LPARAM)&bandInfo);
1089
1090     if (bandInfo.fStyle & RBBS_HIDDEN)
1091         bandInfo.fStyle &= ~RBBS_HIDDEN;
1092     else
1093         bandInfo.fStyle |= RBBS_HIDDEN;
1094
1095     SendMessage(fMainReBar, RB_SETBANDINFOW, index, (LPARAM)&bandInfo);
1096
1097     ReserveBorderSpace(0);
1098     return S_OK;
1099 }
1100
1101 HRESULT STDMETHODCALLTYPE CInternetToolbar::QueryStatus(const GUID *pguidCmdGroup,
1102     ULONG cCmds, OLECMD prgCmds[  ], OLECMDTEXT *pCmdText)
1103 {
1104     if (IsEqualIID(*pguidCmdGroup, CGID_PrivCITCommands))
1105     {
1106         while (cCmds != 0)
1107         {
1108             switch (prgCmds->cmdID)
1109             {
1110                 case ITID_TEXTLABELS:       // Text Labels state
1111                     prgCmds->cmdf = OLECMDF_SUPPORTED;
1112                     break;
1113                 case ITID_TOOLBARBANDSHOWN: // toolbar visibility
1114                     prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1115                     if (IsBandVisible(ITBBID_TOOLSBAND) == S_OK)
1116                         prgCmds->cmdf |= OLECMDF_LATCHED;
1117                     break;
1118                 case ITID_ADDRESSBANDSHOWN: // address bar visibility
1119                     prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1120                     if (IsBandVisible(ITBBID_ADDRESSBAND) == S_OK)
1121                         prgCmds->cmdf |= OLECMDF_LATCHED;
1122                     break;
1123                 case ITID_LINKSBANDSHOWN:   // links bar visibility
1124                     prgCmds->cmdf = 0;
1125                     break;
1126                 case ITID_MENUBANDSHOWN:    // Menubar band visibility
1127                     prgCmds->cmdf = OLECMDF_SUPPORTED;
1128                     if (fMenuBar)
1129                         prgCmds->cmdf |= OLECMDF_LATCHED;
1130                     break;
1131                 case ITID_AUTOHIDEENABLED:  // Auto hide enabled/disabled
1132                     prgCmds->cmdf = 0;
1133                     break;
1134                 case ITID_CUSTOMIZEENABLED: // customize enabled
1135                     prgCmds->cmdf = OLECMDF_SUPPORTED;
1136                     break;
1137                 case ITID_TOOLBARLOCKED:    // lock toolbars
1138                     prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1139                     if (pSettings->fLocked)
1140                         prgCmds->cmdf |= OLECMDF_LATCHED;
1141                     break;
1142                 default:
1143                     prgCmds->cmdf = 0;
1144                     break;
1145             }
1146             prgCmds++;
1147             cCmds--;
1148         }
1149         return S_OK;
1150     }
1151     return E_FAIL;
1152 }
1153
1154 HRESULT STDMETHODCALLTYPE CInternetToolbar::Exec(const GUID *pguidCmdGroup, DWORD nCmdID,
1155     DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
1156 {
1157     if (IsEqualIID(*pguidCmdGroup, CGID_PrivCITCommands))
1158     {
1159         switch (nCmdID)
1160         {
1161             case 1:
1162                 // what do I do here?
1163                 return S_OK;
1164             case ITID_TEXTLABELS:
1165                 // toggle text labels
1166                 return S_OK;
1167             case ITID_TOOLBARBANDSHOWN:
1168                 return ToggleBandVisibility(ITBBID_TOOLSBAND);
1169             case ITID_ADDRESSBANDSHOWN:
1170                 return ToggleBandVisibility(ITBBID_ADDRESSBAND);
1171             case ITID_LINKSBANDSHOWN:
1172                 // toggle links band visibility
1173                 return S_OK;
1174             case ITID_CUSTOMIZEENABLED:
1175                 // run customize
1176                 return S_OK;
1177             case ITID_TOOLBARLOCKED:
1178                 return LockUnlockToolbars(!pSettings->fLocked);
1179         }
1180     }
1181     return E_FAIL;
1182 }
1183
1184 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetTypeInfoCount(UINT *pctinfo)
1185 {
1186     return E_NOTIMPL;
1187 }
1188
1189 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1190 {
1191     return E_NOTIMPL;
1192 }
1193
1194 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames,
1195     LCID lcid, DISPID *rgDispId)
1196 {
1197     return E_NOTIMPL;
1198 }
1199
1200 HRESULT STDMETHODCALLTYPE CInternetToolbar::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
1201     WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1202 {
1203     HRESULT                                 hResult;
1204
1205     switch(dispIdMember)
1206     {
1207         case DISPID_BEFORENAVIGATE:
1208             hResult = S_OK;
1209             break;
1210         case DISPID_DOWNLOADCOMPLETE:
1211             hResult = S_OK;
1212             break;
1213         case DISPID_COMMANDSTATECHANGE:
1214             if (pDispParams->cArgs != 2)
1215                 return E_INVALIDARG;
1216             if (V_VT(&pDispParams->rgvarg[0]) != VT_BOOL || V_VT(&pDispParams->rgvarg[1]) != VT_I4)
1217                 return E_INVALIDARG;
1218             return CommandStateChanged(V_BOOL(&pDispParams->rgvarg[0]) != VARIANT_FALSE,
1219                 V_I4(&pDispParams->rgvarg[1]));
1220         case DISPID_DOWNLOADBEGIN:
1221             hResult = S_OK;
1222             break;
1223         case DISPID_NAVIGATECOMPLETE2:
1224             hResult = S_OK;
1225             break;
1226         case DISPID_DOCUMENTCOMPLETE:
1227             hResult = S_OK;
1228             break;
1229     }
1230     return S_OK;
1231 }
1232
1233 HRESULT STDMETHODCALLTYPE CInternetToolbar::SetCommandTarget(IUnknown *theTarget, GUID *category, long param14)
1234 {
1235     HRESULT                                 hResult;
1236
1237     TRACE("SetCommandTarget %p category %s param %d\n", theTarget, wine_dbgstr_guid(category), param14);
1238
1239     fCommandTarget.Release();
1240     hResult = theTarget->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &fCommandTarget));
1241     if (FAILED_UNEXPECTEDLY(hResult))
1242         return hResult;
1243     fCommandCategory = *category;
1244     return S_OK;
1245 }
1246
1247 HRESULT STDMETHODCALLTYPE CInternetToolbar::Unknown1()
1248 {
1249     return E_NOTIMPL;
1250 }
1251
1252 HRESULT STDMETHODCALLTYPE CInternetToolbar::AddButtons(const GUID *pguidCmdGroup, long buttonCount, TBBUTTON *buttons)
1253 {
1254     return E_NOTIMPL;
1255 }
1256
1257 HRESULT STDMETHODCALLTYPE CInternetToolbar::AddString(const GUID *pguidCmdGroup,
1258     HINSTANCE param10, LPCTSTR param14, long *param18)
1259 {
1260     long                                    result;
1261
1262     result = (long)::SendMessage(fToolbarWindow, TB_ADDSTRINGW,
1263             reinterpret_cast<WPARAM>(param10), reinterpret_cast<LPARAM>(param14));
1264     *param18 = result;
1265     if (result == -1)
1266         return E_FAIL;
1267     return S_OK;
1268 }
1269
1270 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetButton(const GUID *pguidCmdGroup, long param10, long param14)
1271 {
1272     return E_NOTIMPL;
1273 }
1274
1275 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetState(const GUID *pguidCmdGroup, long commandID, long *theState)
1276 {
1277     if (theState == NULL)
1278         return E_POINTER;
1279     // map the command id
1280     *theState = (long)::SendMessage(fToolbarWindow, TB_GETSTATE, commandID, 0);
1281     return S_OK;
1282 }
1283
1284 HRESULT STDMETHODCALLTYPE CInternetToolbar::SetState(const GUID *pguidCmdGroup, long commandID, long theState)
1285 {
1286     // map the command id
1287     ::SendMessage(fToolbarWindow, TB_SETSTATE, commandID, MAKELONG(theState, 0));
1288     return S_OK;
1289 }
1290
1291 HRESULT STDMETHODCALLTYPE CInternetToolbar::AddBitmap(const GUID *pguidCmdGroup, long param10, long buttonCount,
1292     TBADDBITMAP *lParam, long *newIndex, COLORREF param20)
1293 {
1294     return E_NOTIMPL;
1295 }
1296
1297 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetBitmapSize(long *paramC)
1298 {
1299     if (paramC == NULL)
1300         return E_POINTER;
1301     *paramC = MAKELONG(24, 24);
1302     return S_OK;
1303 }
1304
1305 HRESULT STDMETHODCALLTYPE CInternetToolbar::SendToolbarMsg(const GUID *pguidCmdGroup, UINT uMsg,
1306     WPARAM wParam, LPARAM lParam, LRESULT *result)
1307 {
1308     return E_NOTIMPL;
1309 }
1310
1311 HRESULT STDMETHODCALLTYPE CInternetToolbar::SetImageList(const GUID *pguidCmdGroup, HIMAGELIST param10,
1312     HIMAGELIST param14, HIMAGELIST param18)
1313 {
1314     return E_NOTIMPL;
1315 }
1316
1317 HRESULT STDMETHODCALLTYPE CInternetToolbar::ModifyButton(const GUID *pguidCmdGroup, long param10, long param14)
1318 {
1319     return E_NOTIMPL;
1320 }
1321
1322 HRESULT STDMETHODCALLTYPE CInternetToolbar::OnChange(LONG lEvent, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
1323 {
1324     return E_NOTIMPL;
1325 }
1326
1327 HRESULT STDMETHODCALLTYPE CInternetToolbar::SetSite(IUnknown *pUnkSite)
1328 {
1329     CComPtr<IBrowserService>                browserService;
1330     HWND                                    ownerWindow;
1331     HWND                                    dockContainer;
1332     HRESULT                                 hResult;
1333
1334     if (pUnkSite == NULL)
1335     {
1336         hResult = AtlUnadvise(fSite, DIID_DWebBrowserEvents, fAdviseCookie);
1337         ::DestroyWindow(fMainReBar);
1338         DestroyWindow();
1339         fSite.Release();
1340     }
1341     else
1342     {
1343         // get window handle of owner
1344         hResult = IUnknown_GetWindow(pUnkSite, &ownerWindow);
1345         if (FAILED_UNEXPECTEDLY(hResult))
1346             return hResult;
1347         if (ownerWindow == NULL)
1348             return E_FAIL;
1349
1350         // Get settings from owner window
1351         ::SendMessageW(ownerWindow, BWM_GETSETTINGSPTR, 0, (LPARAM)&pSettings);
1352
1353         // create dock container
1354         fSite = pUnkSite;
1355         dockContainer = SHCreateWorkerWindowW(0, ownerWindow, 0,
1356             WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, NULL, 0);
1357         if (dockContainer == NULL)
1358             return E_FAIL;
1359         SubclassWindow(dockContainer);
1360
1361         // create rebar in dock container
1362         DWORD style = WS_VISIBLE | WS_BORDER | WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
1363                       RBS_VARHEIGHT | RBS_BANDBORDERS | RBS_REGISTERDROP | RBS_AUTOSIZE | RBS_DBLCLKTOGGLE |
1364                       CCS_NODIVIDER | CCS_NOPARENTALIGN | CCS_TOP;
1365         DWORD exStyle = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR | WS_EX_TOOLWINDOW;
1366         fMainReBar = CreateWindowEx(exStyle, REBARCLASSNAMEW, NULL, style,
1367                             0, 0, 700, 60, dockContainer, NULL, _AtlBaseModule.GetModuleInstance(), NULL);
1368         if (fMainReBar == NULL)
1369             return E_FAIL;
1370
1371         // take advice to watch events
1372         hResult = IUnknown_QueryService(pUnkSite, SID_SShellBrowser, IID_PPV_ARG(IBrowserService, &browserService));
1373         hResult = AtlAdvise(browserService, static_cast<IDispatch *>(this), DIID_DWebBrowserEvents, &fAdviseCookie);
1374     }
1375     return S_OK;
1376 }
1377
1378 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetSite(REFIID riid, void **ppvSite)
1379 {
1380     if (ppvSite == NULL)
1381         return E_POINTER;
1382     if (fSite.p != NULL)
1383         return fSite->QueryInterface(riid, ppvSite);
1384     *ppvSite = NULL;
1385     return S_OK;
1386 }
1387
1388 HRESULT STDMETHODCALLTYPE CInternetToolbar::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
1389 {
1390     HRESULT                                 hResult;
1391
1392     if (IsEqualIID(guidService, IID_IBandSite))
1393         return this->QueryInterface(riid, ppvObject);
1394     if (IsEqualIID(guidService, SID_IBandProxy))
1395     {
1396         if (fBandProxy.p == NULL)
1397         {
1398             hResult = CreateAndInitBandProxy();
1399             if (FAILED_UNEXPECTEDLY(hResult))
1400                 return hResult;
1401         }
1402         return fBandProxy->QueryInterface(riid, ppvObject);
1403     }
1404     return IUnknown_QueryService(fSite, guidService, riid, ppvObject);
1405 }
1406
1407 HRESULT STDMETHODCALLTYPE CInternetToolbar::OnWinEvent(
1408     HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult)
1409 {
1410     HRESULT                                 hResult;
1411
1412     if (fMenuBar)
1413     {
1414         hResult = IUnknown_RelayWinEvent(fMenuBar, hWnd, uMsg, wParam, lParam, theResult);
1415         if (hResult != S_FALSE)
1416             return hResult;
1417     }
1418
1419     if (fNavigationBar)
1420     {
1421         hResult = IUnknown_RelayWinEvent(fNavigationBar, hWnd, uMsg, wParam, lParam, theResult);
1422         if (hResult != S_FALSE)
1423             return hResult;
1424     }
1425
1426     if (fLogoBar)
1427     {
1428         hResult = IUnknown_RelayWinEvent(fLogoBar, hWnd, uMsg, wParam, lParam, theResult);
1429         if (hResult != S_FALSE)
1430             return hResult;
1431     }
1432
1433     return S_FALSE;
1434 }
1435
1436 HRESULT STDMETHODCALLTYPE CInternetToolbar::IsWindowOwner(HWND hWnd)
1437 {
1438     UNIMPLEMENTED;
1439     return E_NOTIMPL;
1440 }
1441
1442 HRESULT STDMETHODCALLTYPE CInternetToolbar::AddBand(IUnknown *punk)
1443 {
1444     UNIMPLEMENTED;
1445     return E_NOTIMPL;
1446 }
1447
1448 HRESULT STDMETHODCALLTYPE CInternetToolbar::EnumBands(UINT uBand, DWORD *pdwBandID)
1449 {
1450     UNIMPLEMENTED;
1451     return E_NOTIMPL;
1452 }
1453
1454 HRESULT STDMETHODCALLTYPE CInternetToolbar::QueryBand(DWORD dwBandID,
1455     IDeskBand **ppstb, DWORD *pdwState, LPWSTR pszName, int cchName)
1456 {
1457     if (ppstb == NULL)
1458         return E_POINTER;
1459     if (dwBandID == ITBBID_MENUBAND && fMenuBar.p != NULL)
1460         return fMenuBar->QueryInterface(IID_PPV_ARG(IDeskBand, ppstb));
1461     //if (dwBandID == ITBBID_BRANDBAND && fLogoBar.p != NULL)
1462     //    return fLogoBar->QueryInterface(IID_PPV_ARG(IDeskBand, ppstb));
1463     *ppstb = NULL;
1464     return E_FAIL;
1465 }
1466
1467 HRESULT STDMETHODCALLTYPE CInternetToolbar::SetBandState(DWORD dwBandID, DWORD dwMask, DWORD dwState)
1468 {
1469     UNIMPLEMENTED;
1470     return E_NOTIMPL;
1471 }
1472
1473 HRESULT STDMETHODCALLTYPE CInternetToolbar::RemoveBand(DWORD dwBandID)
1474 {
1475     UNIMPLEMENTED;
1476     return E_NOTIMPL;
1477 }
1478
1479 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetBandObject(DWORD dwBandID, REFIID riid, void **ppv)
1480 {
1481     UNIMPLEMENTED;
1482     return E_NOTIMPL;
1483 }
1484
1485 HRESULT STDMETHODCALLTYPE CInternetToolbar::SetBandSiteInfo(const BANDSITEINFO *pbsinfo)
1486 {
1487     UNIMPLEMENTED;
1488     return E_NOTIMPL;
1489 }
1490
1491 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetBandSiteInfo(BANDSITEINFO *pbsinfo)
1492 {
1493     UNIMPLEMENTED;
1494     return E_NOTIMPL;
1495 }
1496
1497 LRESULT CInternetToolbar::OnTravelBack(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
1498 {
1499     CComPtr<IWebBrowser>                    webBrowser;
1500     HRESULT                                 hResult;
1501
1502     hResult = IUnknown_QueryService(fSite, SID_SShellBrowser, IID_PPV_ARG(IWebBrowser, &webBrowser));
1503     if (FAILED_UNEXPECTEDLY(hResult))
1504         return 0;
1505     hResult = webBrowser->GoBack();
1506     return 1;
1507 }
1508
1509 LRESULT CInternetToolbar::OnTravelForward(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
1510 {
1511     CComPtr<IWebBrowser>                    webBrowser;
1512     HRESULT                                 hResult;
1513
1514     hResult = IUnknown_QueryService(fSite, SID_SShellBrowser, IID_PPV_ARG(IWebBrowser, &webBrowser));
1515     if (FAILED_UNEXPECTEDLY(hResult))
1516         return 0;
1517     hResult = webBrowser->GoForward();
1518     return 1;
1519 }
1520
1521 LRESULT CInternetToolbar::OnUpLevel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
1522 {
1523     IUnknown_Exec(fSite, CGID_ShellBrowser, IDM_GOTO_UPONELEVEL, 0, NULL, NULL);
1524     return 1;
1525 }
1526
1527 LRESULT CInternetToolbar::OnSearch(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
1528 {
1529     IUnknown_Exec(fSite, CGID_Explorer, 0x1c, 1, NULL, NULL);
1530     return 1;
1531 }
1532
1533 LRESULT CInternetToolbar::OnFolders(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
1534 {
1535     IUnknown_Exec(fSite, CGID_Explorer, 0x23, 0, NULL, NULL);
1536     return 1;
1537 }
1538
1539 LRESULT CInternetToolbar::OnForwardToCommandTarget(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
1540 {
1541     HRESULT                                 hResult;
1542
1543     if (fCommandTarget.p != NULL)
1544     {
1545         hResult = fCommandTarget->Exec(&fCommandCategory, wID, 0, NULL, NULL);
1546         if (FAILED(hResult))
1547         {
1548             ::SendMessageW(::GetParent(m_hWnd), WM_COMMAND, wID, 0);
1549         }
1550     }
1551     return 1;
1552 }
1553
1554 LRESULT CInternetToolbar::OnMenuDropDown(UINT idControl, NMHDR *pNMHDR, BOOL &bHandled)
1555 {
1556     CComPtr<IBrowserService>                browserService;
1557     CComPtr<IOleCommandTarget>              commandTarget;
1558     CComPtr<ITravelLog>                     travelLog;
1559     NMTOOLBARW                              *notifyInfo;
1560     RECT                                    bounds;
1561     HMENU                                   newMenu;
1562     TPMPARAMS                               params;
1563     int                                     selectedItem;
1564     VARIANT                                 parmIn;
1565     OLECMD                                  commandInfo;
1566     HRESULT                                 hResult;
1567     wchar_t                                 templateString[200];
1568
1569     notifyInfo = (NMTOOLBARW *)pNMHDR;
1570     if (notifyInfo->hdr.hwndFrom != fToolbarWindow)
1571     {
1572         // not from the toolbar, keep looking for a message handler
1573         bHandled = FALSE;
1574         return 0;
1575     }
1576     SendMessage(fToolbarWindow, TB_GETRECT, notifyInfo->iItem, reinterpret_cast<LPARAM>(&bounds));
1577     ::MapWindowPoints(fToolbarWindow, NULL, reinterpret_cast<POINT *>(&bounds), 2);
1578     switch (notifyInfo->iItem)
1579     {
1580         case IDM_GOTO_BACK:
1581             newMenu = CreatePopupMenu();
1582             hResult = IUnknown_QueryService(fSite, SID_SShellBrowser, IID_PPV_ARG(IBrowserService, &browserService));
1583             hResult = browserService->GetTravelLog(&travelLog);
1584             hResult = travelLog->InsertMenuEntries(browserService, newMenu, 0, 1, 9, TLMENUF_BACK);
1585             commandInfo.cmdID = 0x1d;
1586             hResult = IUnknown_QueryStatus(browserService, CGID_Explorer, 1, &commandInfo, NULL);
1587             if ((commandInfo.cmdf & (OLECMDF_ENABLED | OLECMDF_LATCHED)) == OLECMDF_ENABLED &&
1588                 travelLog->CountEntries(browserService) > 1)
1589             {
1590                 AppendMenuW(newMenu, MF_SEPARATOR, -1, L"");
1591
1592                 if (LoadStringW(_AtlBaseModule.GetResourceInstance(),
1593                                 IDS_HISTORYTEXT, templateString, sizeof(templateString) / sizeof(wchar_t)) == 0)
1594                     StringCbCopyW(templateString, sizeof(templateString), L"&History\tCtrl+H");
1595
1596                 AppendMenuW(newMenu, MF_STRING /* | MF_OWNERDRAW */, IDM_EXPLORERBAR_HISTORY, templateString);
1597             }
1598             params.cbSize = sizeof(params);
1599             params.rcExclude = bounds;
1600             selectedItem = TrackPopupMenuEx(newMenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD,
1601                                     bounds.left, bounds.bottom, m_hWnd, &params);
1602             if (selectedItem == IDM_EXPLORERBAR_HISTORY)
1603             {
1604                 V_VT(&parmIn) = VT_I4;
1605                 V_I4(&parmIn) = 1;
1606                 Exec(&CGID_Explorer, 0x1d, 2, &parmIn, NULL);
1607             }
1608             else if (selectedItem != 0)
1609                 hResult = travelLog->Travel(browserService, -selectedItem);
1610             DestroyMenu(newMenu);
1611             break;
1612         case IDM_GOTO_FORWARD:
1613             newMenu = CreatePopupMenu();
1614             hResult = IUnknown_QueryService(fSite, SID_SShellBrowser, IID_PPV_ARG(IBrowserService, &browserService));
1615             hResult = browserService->GetTravelLog(&travelLog);
1616             hResult = travelLog->InsertMenuEntries(browserService, newMenu, 0, 1, 9, TLMENUF_FORE);
1617             commandInfo.cmdID = 0x1d;
1618             hResult = IUnknown_QueryStatus(browserService, CGID_Explorer, 1, &commandInfo, NULL);
1619             if ((commandInfo.cmdf & (OLECMDF_ENABLED | OLECMDF_LATCHED)) == OLECMDF_ENABLED &&
1620                 travelLog->CountEntries(browserService) > 1)
1621             {
1622                 AppendMenuW(newMenu, MF_SEPARATOR, -1, L"");
1623
1624                 if (LoadStringW(_AtlBaseModule.GetResourceInstance(),
1625                                 IDS_HISTORYTEXT, templateString, sizeof(templateString) / sizeof(wchar_t)) == 0)
1626                     StringCbCopyW(templateString, sizeof(templateString), L"&History\tCtrl+H");
1627
1628                 AppendMenuW(newMenu, MF_STRING /* | MF_OWNERDRAW */, IDM_EXPLORERBAR_HISTORY, templateString);
1629             }
1630             params.cbSize = sizeof(params);
1631             params.rcExclude = bounds;
1632             selectedItem = TrackPopupMenuEx(newMenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD,
1633                                     bounds.left, bounds.bottom, m_hWnd, &params);
1634             if (selectedItem == IDM_EXPLORERBAR_HISTORY)
1635             {
1636                 V_VT(&parmIn) = VT_I4;
1637                 V_I4(&parmIn) = 1;
1638                 Exec(&CGID_Explorer, 0x1d, 2, &parmIn, NULL);
1639             }
1640             else if (selectedItem != 0)
1641                 hResult = travelLog->Travel(browserService, selectedItem);
1642             DestroyMenu(newMenu);
1643             break;
1644         case gViewsCommandID:
1645             VARIANT                     inValue;
1646             CComVariant                 outValue;
1647             HRESULT                     hResult;
1648
1649             V_VT(&inValue) = VT_INT_PTR;
1650             V_INTREF(&inValue) = reinterpret_cast<INT *>(&bounds);
1651
1652             if (fCommandTarget.p != NULL)
1653                 hResult = fCommandTarget->Exec(&fCommandCategory, FCIDM_SHVIEW_AUTOARRANGE, 1, &inValue, &outValue);
1654             // pvaOut is VT_I4 with value 0x403
1655             break;
1656     }
1657     return TBDDRET_DEFAULT;
1658 }
1659
1660 LRESULT CInternetToolbar::OnQueryInsert(UINT idControl, NMHDR *pNMHDR, BOOL &bHandled)
1661 {
1662     return 1;
1663 }
1664
1665 LRESULT CInternetToolbar::OnQueryDelete(UINT idControl, NMHDR *pNMHDR, BOOL &bHandled)
1666 {
1667     return 1;
1668 }
1669
1670 LRESULT CInternetToolbar::OnContextMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1671 {
1672     HMENU                                   contextMenuBar;
1673     HMENU                                   contextMenu;
1674     POINT                                   clickLocation;
1675     int                                     command;
1676     RBHITTESTINFO                           hitTestInfo;
1677     REBARBANDINFOW                          rebarBandInfo;
1678     int                                     bandID;
1679
1680     clickLocation.x = LOWORD(lParam);
1681     clickLocation.y = HIWORD(lParam);
1682     hitTestInfo.pt = clickLocation;
1683     ScreenToClient(&hitTestInfo.pt);
1684     SendMessage(fMainReBar, RB_HITTEST, 0, (LPARAM)&hitTestInfo);
1685     if (hitTestInfo.iBand == -1)
1686         return 0;
1687
1688     pSettings->Load();
1689     rebarBandInfo.cbSize = sizeof(rebarBandInfo);
1690     rebarBandInfo.fMask = RBBIM_ID;
1691     SendMessage(fMainReBar, RB_GETBANDINFOW, hitTestInfo.iBand, (LPARAM)&rebarBandInfo);
1692     bandID = rebarBandInfo.wID;
1693     contextMenuBar = LoadMenu(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(IDM_CABINET_CONTEXTMENU));
1694     contextMenu = GetSubMenu(contextMenuBar, 0);
1695     switch (bandID)
1696     {
1697         case ITBBID_MENUBAND:   // menu band
1698             DeleteMenu(contextMenu, IDM_TOOLBARS_CUSTOMIZE, MF_BYCOMMAND);
1699             DeleteMenu(contextMenu, IDM_TOOLBARS_TEXTLABELS, MF_BYCOMMAND);
1700             DeleteMenu(contextMenu, IDM_TOOLBARS_GOBUTTON, MF_BYCOMMAND);
1701             break;
1702         case ITBBID_BRANDBAND:  // brand band
1703             DeleteMenu(contextMenu, IDM_TOOLBARS_CUSTOMIZE, MF_BYCOMMAND);
1704             DeleteMenu(contextMenu, IDM_TOOLBARS_TEXTLABELS, MF_BYCOMMAND);
1705             DeleteMenu(contextMenu, IDM_TOOLBARS_GOBUTTON, MF_BYCOMMAND);
1706             break;
1707         case ITBBID_TOOLSBAND:  // tools band
1708             DeleteMenu(contextMenu, IDM_TOOLBARS_TEXTLABELS, MF_BYCOMMAND);
1709             DeleteMenu(contextMenu, IDM_TOOLBARS_GOBUTTON, MF_BYCOMMAND);
1710             break;
1711         case ITBBID_ADDRESSBAND:    // navigation band
1712             DeleteMenu(contextMenu, IDM_TOOLBARS_CUSTOMIZE, MF_BYCOMMAND);
1713             DeleteMenu(contextMenu, IDM_TOOLBARS_TEXTLABELS, MF_BYCOMMAND);
1714             break;
1715         default:
1716             break;
1717     }
1718
1719     SHEnableMenuItem(contextMenu, IDM_TOOLBARS_LINKSBAR, FALSE);
1720
1721     SHCheckMenuItem(contextMenu, IDM_TOOLBARS_STANDARDBUTTONS, IsBandVisible(ITBBID_TOOLSBAND) == S_OK);
1722     SHCheckMenuItem(contextMenu, IDM_TOOLBARS_ADDRESSBAR, IsBandVisible(ITBBID_ADDRESSBAND) == S_OK);
1723     SHCheckMenuItem(contextMenu, IDM_TOOLBARS_LINKSBAR, FALSE);
1724     SHCheckMenuItem(contextMenu, IDM_TOOLBARS_CUSTOMIZE, FALSE);
1725     SHCheckMenuItem(contextMenu, IDM_TOOLBARS_LOCKTOOLBARS, pSettings->fLocked);
1726     SHCheckMenuItem(contextMenu, IDM_TOOLBARS_GOBUTTON, pSettings->fShowGoButton);
1727
1728     // TODO: use GetSystemMetrics(SM_MENUDROPALIGNMENT) to determine menu alignment
1729     command = TrackPopupMenu(contextMenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD,
1730                 clickLocation.x, clickLocation.y, 0, m_hWnd, NULL);
1731     switch (command)
1732     {
1733         case IDM_TOOLBARS_STANDARDBUTTONS:  // standard buttons
1734             ToggleBandVisibility(ITBBID_TOOLSBAND);
1735             break;
1736         case IDM_TOOLBARS_ADDRESSBAR:   // address bar
1737             ToggleBandVisibility(ITBBID_ADDRESSBAND);
1738             break;
1739         case IDM_TOOLBARS_LINKSBAR: // links
1740             break;
1741         case IDM_TOOLBARS_LOCKTOOLBARS: // lock the toolbars
1742             LockUnlockToolbars(!pSettings->fLocked);
1743             break;
1744         case IDM_TOOLBARS_CUSTOMIZE:    // customize
1745             SendMessage(fToolbarWindow, TB_CUSTOMIZE, 0, 0);
1746             break;
1747         case IDM_TOOLBARS_GOBUTTON:
1748             SendMessage(fNavigationWindow, WM_COMMAND, IDM_TOOLBARS_GOBUTTON, 0);
1749             break;
1750     }
1751
1752     DestroyMenu(contextMenuBar);
1753     return 1;
1754 }
1755
1756 LRESULT CInternetToolbar::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1757 {
1758     if (wParam != SIZE_MINIMIZED)
1759     {
1760         ::SetWindowPos(fMainReBar, NULL, 0, 0, LOWORD(lParam), HIWORD(lParam),
1761             SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_NOMOVE);
1762     }
1763     return 1;
1764 }
1765
1766 LRESULT CInternetToolbar::OnSetCursor(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1767 {
1768     if ((short)lParam != HTCLIENT || (HWND)wParam != m_hWnd)
1769     {
1770         bHandled = FALSE;
1771         return 0;
1772     }
1773     SetCursor(LoadCursor(NULL, IDC_SIZENS));
1774     return 1;
1775 }
1776
1777 LRESULT CInternetToolbar::OnTipText(UINT idControl, NMHDR *pNMHDR, BOOL &bHandled)
1778 {
1779     CComPtr<IBrowserService>                browserService;
1780     CComPtr<ITravelLog>                     travelLog;
1781     TOOLTIPTEXTW                            *pTTTW;
1782     UINT                                    nID;
1783     HRESULT                                 hResult;
1784     wchar_t                                 tempString[300];
1785
1786     pTTTW = reinterpret_cast<TOOLTIPTEXTW *>(pNMHDR);
1787     if ((pTTTW->uFlags & TTF_IDISHWND) != 0)
1788         nID = ::GetDlgCtrlID((HWND)pNMHDR->idFrom);
1789     else
1790         nID = (UINT)pNMHDR->idFrom;
1791
1792     if (nID != 0)
1793     {
1794         if (nID == (UINT)IDM_GOTO_BACK || nID == (UINT)IDM_GOTO_FORWARD)
1795         {
1796             // TODO: Should this call QueryService?
1797             hResult = fSite->QueryInterface(IID_PPV_ARG(IBrowserService, &browserService));
1798             hResult = browserService->GetTravelLog(&travelLog);
1799             hResult = travelLog->GetToolTipText(browserService,
1800                 (nID == (UINT)IDM_GOTO_BACK) ? TLOG_BACK : TLOG_FORE,
1801                 0, tempString, 299);
1802             if (FAILED_UNEXPECTEDLY(hResult))
1803             {
1804                 bHandled = FALSE;
1805                 return 0;
1806             }
1807         }
1808         else
1809             tempString[0] = 0;
1810         wcsncpy (pTTTW->szText, tempString, sizeof(pTTTW->szText) / sizeof(wchar_t));
1811         ::SetWindowPos(pNMHDR->hwndFrom, HWND_TOP, 0, 0, 0, 0,
1812             SWP_NOOWNERZORDER | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
1813         return 0;
1814     }
1815     return 0;
1816 }
1817
1818 LRESULT CInternetToolbar::OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1819 {
1820     LRESULT theResult;
1821     HRESULT hResult;
1822
1823     hResult = OnWinEvent((HWND) lParam, uMsg, wParam, lParam, &theResult);
1824
1825     bHandled = hResult == S_OK;
1826
1827     return FAILED_UNEXPECTEDLY(hResult) ? 0 : theResult;
1828 }
1829 LRESULT CInternetToolbar::OnNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1830 {
1831     NMHDR   *notifyHeader;
1832     LRESULT theResult;
1833     HRESULT hResult;
1834
1835     notifyHeader = reinterpret_cast<NMHDR *>(lParam);
1836
1837     hResult = OnWinEvent(notifyHeader->hwndFrom, uMsg, wParam, lParam, &theResult);
1838
1839     bHandled = hResult == S_OK;
1840
1841     return FAILED_UNEXPECTEDLY(hResult) ? 0 : theResult;
1842 }
1843
1844 LRESULT CInternetToolbar::OnLDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1845 {
1846     bHandled = FALSE;
1847     if (pSettings->fLocked)
1848         return 0;
1849
1850     if (wParam & MK_CONTROL)
1851         return 0;
1852
1853     fSizing = TRUE;
1854
1855     DWORD msgp = GetMessagePos();
1856
1857     fStartPosition.x = GET_X_LPARAM(msgp);
1858     fStartPosition.y = GET_Y_LPARAM(msgp);
1859
1860     RECT rc;
1861     GetWindowRect(&rc);
1862
1863     fStartHeight = rc.bottom - rc.top;
1864
1865     SetCapture();
1866
1867     bHandled = TRUE;
1868     return 0;
1869 }
1870
1871 LRESULT CInternetToolbar::OnMouseMove(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1872 {
1873     bHandled = FALSE;
1874     if (!fSizing)
1875         return 0;
1876
1877     DWORD msgp = GetMessagePos();
1878
1879     POINT pt;
1880     pt.x = GET_X_LPARAM(msgp);
1881     pt.y = GET_Y_LPARAM(msgp);
1882
1883     ReserveBorderSpace(fStartHeight - fStartPosition.y + pt.y);
1884
1885     bHandled = TRUE;
1886     return 0;
1887 }
1888
1889 LRESULT CInternetToolbar::OnLUp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1890 {
1891     bHandled = FALSE;
1892     if (!fSizing)
1893         return 0;
1894
1895     OnMouseMove(uMsg, wParam, lParam, bHandled);
1896
1897     fSizing = FALSE;
1898
1899     ReleaseCapture();
1900
1901     return 0;
1902 }
1903
1904 LRESULT CInternetToolbar::OnWinIniChange(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1905 {
1906     HRESULT hr;
1907     HWND hwndMenu;
1908
1909     hr = IUnknown_GetWindow(fMenuBar, &hwndMenu);
1910     if (FAILED_UNEXPECTEDLY(hr))
1911         return 0;
1912
1913     CComPtr<IWinEventHandler> menuWinEventHandler;
1914     hr = fMenuBar->QueryInterface(IID_PPV_ARG(IWinEventHandler, &menuWinEventHandler));
1915     if (FAILED_UNEXPECTEDLY(hr))
1916         return 0;
1917
1918     LRESULT lres;
1919     hr = menuWinEventHandler->OnWinEvent(hwndMenu, uMsg, wParam, lParam, &lres);
1920     if (FAILED_UNEXPECTEDLY(hr))
1921         return 0;
1922
1923     return lres;
1924 }
1925
1926 LRESULT CInternetToolbar::OnSettingsChange(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1927 {
1928     /* Refresh toolbar locked state */
1929     RefreshLockedToolbarState();
1930
1931     return 0;
1932 }