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     virtual HRESULT STDMETHODCALLTYPE AddNameSpace(LPGUID, IShellFolder *, LPCITEMIDLIST, ULONG) = 0;
  33     virtual HRESULT STDMETHODCALLTYPE GetNameSpaceID(LPCITEMIDLIST, LPGUID) = 0;
  34     virtual HRESULT STDMETHODCALLTYPE QueryNameSpace(ULONG, LPGUID, IShellFolder **) = 0;
  35     virtual HRESULT STDMETHODCALLTYPE EnumNameSpace(ULONG, PULONG) = 0;
  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     virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND *lphwnd);
 154     virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode);
 155
 156     // *** IDockingWindow methods ***
 157     virtual HRESULT STDMETHODCALLTYPE GetBorderDW(IUnknown* punkObj, LPRECT prcBorder);
 158     virtual HRESULT STDMETHODCALLTYPE RequestBorderSpaceDW(IUnknown* punkObj, LPCBORDERWIDTHS pbw);
 159     virtual HRESULT STDMETHODCALLTYPE SetBorderSpaceDW(IUnknown* punkObj, LPCBORDERWIDTHS pbw);
 160
 161     // *** IInputObjectSite specific methods ***
 162     virtual HRESULT STDMETHODCALLTYPE OnFocusChangeIS(IUnknown *punkObj, BOOL fSetFocus);
 163
 164     // *** IOleCommandTarget specific methods ***
 165     virtual HRESULT STDMETHODCALLTYPE QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds,
 166         OLECMD prgCmds[  ], OLECMDTEXT *pCmdText);
 167     virtual HRESULT STDMETHODCALLTYPE Exec(const GUID *pguidCmdGroup, DWORD nCmdID,
 168         DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut);
 169
 170     // *** IServiceProvider methods ***
 171     virtual HRESULT STDMETHODCALLTYPE QueryService(REFGUID guidService, REFIID riid, void **ppvObject);
 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->fLocked)
 254         bandInfo.fStyle |= RBBS_NOGRIPPER;
 255     if (fFlags & ITF_NOTITLE)
 256         bandInfo.fStyle |= RBBS_HIDETITLE;
 257     if (fFlags & ITF_GRIPPERALWAYS && !fToolbar->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     fLocked = false;
 612     fMenuBandWindow = NULL;
 613     fNavigationWindow = NULL;
 614     fMenuCallback = new CComObject<CMenuCallback>();
 615     fToolbarWindow = NULL;
 616     fAdviseCookie = 0;
 617
 618     fMenuCallback->AddRef();
 619 }
 620
 621 CInternetToolbar::~CInternetToolbar()
 622 {
 623 }
 624
 625 void CInternetToolbar::AddDockItem(IUnknown *newItem, int bandID, int flags)
 626 {
 627     CComPtr<CDockSite> newSite;
 628
 629     newSite = new CComObject<CDockSite>;
 630     newSite->Initialize(newItem, this, fMainReBar, bandID, flags);
 631 }
 632
 633 HRESULT CInternetToolbar::ReserveBorderSpace(LONG maxHeight)
 634 {
 635     CComPtr<IDockingWindowSite>             dockingWindowSite;
 636     RECT                                    availableBorderSpace;
 637
 638     HRESULT hResult = fSite->QueryInterface(IID_PPV_ARG(IDockingWindowSite, &dockingWindowSite));
 639     if (FAILED_UNEXPECTEDLY(hResult))
 640         return hResult;
 641     hResult = dockingWindowSite->GetBorderDW(static_cast<IDockingWindow *>(this), &availableBorderSpace);
 642     if (FAILED_UNEXPECTEDLY(hResult))
 643         return hResult;
 644
 645     if (maxHeight && availableBorderSpace.bottom - availableBorderSpace.top > maxHeight)
 646     {
 647         availableBorderSpace.bottom = availableBorderSpace.top + maxHeight;
 648     }
 649
 650     return ResizeBorderDW(&availableBorderSpace, fSite, FALSE);
 651 }
 652
 653 HRESULT CInternetToolbar::CreateMenuBar(IShellMenu **pMenuBar)
 654 {
 655     CComPtr<IShellMenu>                     menubar;
 656     CComPtr<IShellMenuCallback>             callback;
 657     VARIANT                                 menuOut;
 658     HWND                                    ownerWindow;
 659     HRESULT                                 hResult;
 660
 661     if (!pMenuBar)
 662         return E_POINTER;
 663
 664     *pMenuBar = NULL;
 665
 666     hResult = CMenuBand_CreateInstance(IID_PPV_ARG(IShellMenu, &menubar));
 667     if (FAILED_UNEXPECTEDLY(hResult))
 668         return hResult;
 669
 670     hResult = fMenuCallback->QueryInterface(IID_PPV_ARG(IShellMenuCallback, &callback));
 671     if (FAILED_UNEXPECTEDLY(hResult))
 672         return hResult;
 673
 674     hResult = menubar->Initialize(callback, -1, ANCESTORDEFAULT, SMINIT_HORIZONTAL | SMINIT_TOPLEVEL);
 675     if (FAILED_UNEXPECTEDLY(hResult))
 676         return hResult;
 677
 678     // Set Menu
 679     {
 680         hResult = IUnknown_Exec(fSite, CGID_Explorer, 0x35, 0, NULL, &menuOut);
 681         if (FAILED_UNEXPECTEDLY(hResult))
 682             return hResult;
 683
 684         if (V_VT(&menuOut) != VT_INT_PTR || V_INTREF(&menuOut) == NULL)
 685             return E_FAIL;
 686
 687         hResult = IUnknown_GetWindow(fSite, &ownerWindow);
 688         if (FAILED_UNEXPECTEDLY(hResult))
 689             return hResult;
 690
 691         HMENU hMenuBar = (HMENU) V_INTREF(&menuOut);
 692
 693         // FIXME: Figure out the proper way to do this.
 694         HMENU hMenuFavs = GetSubMenu(hMenuBar, 3);
 695         if (hMenuFavs)
 696         {
 697             DeleteMenu(hMenuFavs, IDM_FAVORITES_EMPTY, MF_BYCOMMAND);
 698         }
 699
 700         hResult = menubar->SetMenu(hMenuBar, ownerWindow, SMSET_DONTOWN);
 701         if (FAILED_UNEXPECTEDLY(hResult))
 702             return hResult;
 703     }
 704
 705     hResult = IUnknown_Exec(menubar, CGID_MenuBand, 3, 1, NULL, NULL);
 706     if (FAILED_UNEXPECTEDLY(hResult))
 707         return hResult;
 708
 709     *pMenuBar = menubar.Detach();
 710
 711     return S_OK;
 712 }
 713
 714 HRESULT CInternetToolbar::LockUnlockToolbars(bool locked)
 715 {
 716     REBARBANDINFOW                          rebarBandInfo;
 717     int                                     bandCount;
 718     CDockSite                               *dockSite;
 719     HRESULT                                 hResult;
 720
 721     if (locked != fLocked)
 722     {
 723         fLocked = locked;
 724         rebarBandInfo.cbSize = sizeof(rebarBandInfo);
 725         rebarBandInfo.fMask = RBBIM_STYLE | RBBIM_LPARAM;
 726         bandCount = (int)SendMessage(fMainReBar, RB_GETBANDCOUNT, 0, 0);
 727         for (INT x  = 0; x < bandCount; x++)
 728         {
 729             SendMessage(fMainReBar, RB_GETBANDINFOW, x, (LPARAM)&rebarBandInfo);
 730             dockSite = reinterpret_cast<CDockSite *>(rebarBandInfo.lParam);
 731             if (dockSite != NULL)
 732             {
 733                 rebarBandInfo.fStyle &= ~(RBBS_NOGRIPPER | RBBS_GRIPPERALWAYS);
 734                 if (dockSite->fFlags & CDockSite::ITF_NOGRIPPER || fLocked)
 735                     rebarBandInfo.fStyle |= RBBS_NOGRIPPER;
 736                 if (dockSite->fFlags & CDockSite::ITF_GRIPPERALWAYS && !fLocked)
 737                     rebarBandInfo.fStyle |= RBBS_GRIPPERALWAYS;
 738                 SendMessage(fMainReBar, RB_SETBANDINFOW, x, (LPARAM)&rebarBandInfo);
 739             }
 740         }
 741         hResult = ReserveBorderSpace(0);
 742
 743         // TODO: refresh view menu?
 744     }
 745     return S_OK;
 746 }
 747
 748 HRESULT CInternetToolbar::SetState(const GUID *pguidCmdGroup, long commandID, OLECMD* pcmd)
 749 {
 750     long state = 0;
 751     if (pcmd->cmdf & OLECMDF_ENABLED)
 752         state |= TBSTATE_ENABLED;
 753     if (pcmd->cmdf & OLECMDF_LATCHED)
 754         state |= TBSTATE_CHECKED;
 755     return SetState(pguidCmdGroup, commandID, state);
 756 }
 757
 758 HRESULT CInternetToolbar::CommandStateChanged(bool newValue, int commandID)
 759 {
 760     HRESULT                                 hResult;
 761
 762     hResult = S_OK;
 763     switch (commandID)
 764     {
 765         case -1:
 766             // loop through buttons
 767             //for buttons in CLSID_CommonButtons
 768             //    if up, QueryStatus for up state and update it
 769             //
 770             //for buttons in fCommandCategory, update with QueryStatus of fCommandTarget
 771
 772             OLECMD commandList[4];
 773             commandList[0].cmdID = 0x1c;
 774             commandList[1].cmdID = 0x1d;
 775             commandList[2].cmdID = 0x1e;
 776             commandList[3].cmdID = 0x23;
 777             IUnknown_QueryStatus(fSite, CGID_Explorer, 4, commandList, NULL);
 778             SetState(&CLSID_CommonButtons, gSearchCommandID, &commandList[0]);
 779             SetState(&CLSID_CommonButtons, gFoldersCommandID, &commandList[3]);
 780             //SetState(&CLSID_CommonButtons, gFavoritesCommandID, &commandList[2]);
 781             //SetState(&CLSID_CommonButtons, gHistoryCommandID, &commandList[1]);
 782
 783             break;
 784         case 1:
 785             // forward
 786             hResult = SetState(&CLSID_CommonButtons, IDM_GOTO_FORWARD, newValue ? TBSTATE_ENABLED : 0);
 787             break;
 788         case 2:
 789             // back
 790             hResult = SetState(&CLSID_CommonButtons, IDM_GOTO_BACK, newValue ? TBSTATE_ENABLED : 0);
 791             break;
 792         case 3:
 793             // up
 794             hResult = SetState(&CLSID_CommonButtons, IDM_GOTO_UPONELEVEL, newValue ? TBSTATE_ENABLED : 0);
 795             break;
 796     }
 797     return hResult;
 798 }
 799
 800 HRESULT CInternetToolbar::CreateAndInitBandProxy()
 801 {
 802     CComPtr<IServiceProvider>               serviceProvider;
 803     HRESULT                                 hResult;
 804
 805     hResult = fSite->QueryInterface(IID_PPV_ARG(IServiceProvider, &serviceProvider));
 806     if (FAILED_UNEXPECTEDLY(hResult))
 807         return hResult;
 808     hResult = serviceProvider->QueryService(SID_IBandProxy, IID_PPV_ARG(IBandProxy, &fBandProxy));
 809     if (FAILED_UNEXPECTEDLY(hResult))
 810     {
 811         hResult = CBandProxy_CreateInstance(IID_PPV_ARG(IBandProxy, &fBandProxy));
 812         if (FAILED_UNEXPECTEDLY(hResult))
 813             return hResult;
 814         hResult = fBandProxy->SetSite(fSite);
 815         if (FAILED_UNEXPECTEDLY(hResult))
 816             return hResult;
 817     }
 818     return S_OK;
 819 }
 820
 821 HRESULT STDMETHODCALLTYPE CInternetToolbar::UIActivateIO(BOOL fActivate, LPMSG lpMsg)
 822 {
 823     return E_NOTIMPL;
 824 }
 825
 826 HRESULT STDMETHODCALLTYPE CInternetToolbar::HasFocusIO()
 827 {
 828     HRESULT hr = S_FALSE;
 829
 830     if (fMenuBar)
 831         hr = IUnknown_HasFocusIO(fMenuBar);
 832     if (hr != S_FALSE)
 833         return hr;
 834
 835     if (fControlsBar)
 836         hr = IUnknown_HasFocusIO(fControlsBar);
 837     if (hr != S_FALSE)
 838         return hr;
 839
 840     if (fNavigationBar)
 841         hr = IUnknown_HasFocusIO(fNavigationBar);
 842     if (hr != S_FALSE)
 843         return hr;
 844
 845     return S_FALSE;
 846 }
 847
 848 HRESULT STDMETHODCALLTYPE CInternetToolbar::TranslateAcceleratorIO(LPMSG lpMsg)
 849 {
 850     HRESULT hr = S_FALSE;
 851
 852     if (fMenuBar)
 853         hr = IUnknown_TranslateAcceleratorIO(fMenuBar, lpMsg);
 854     if (hr == S_OK)
 855         return hr;
 856
 857     if (fControlsBar)
 858         hr = IUnknown_TranslateAcceleratorIO(fControlsBar, lpMsg);
 859     if (hr == S_OK)
 860         return hr;
 861
 862     if (fNavigationBar)
 863         hr = IUnknown_TranslateAcceleratorIO(fNavigationBar, lpMsg);
 864     if (hr == S_OK)
 865         return hr;
 866
 867     return S_FALSE;
 868 }
 869
 870 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetWindow(HWND *lphwnd)
 871 {
 872     if (lphwnd == NULL)
 873         return E_POINTER;
 874     *lphwnd = m_hWnd;
 875     return S_OK;
 876 }
 877
 878 HRESULT STDMETHODCALLTYPE CInternetToolbar::ContextSensitiveHelp(BOOL fEnterMode)
 879 {
 880     return E_NOTIMPL;
 881 }
 882
 883 HRESULT STDMETHODCALLTYPE CInternetToolbar::ShowDW(BOOL fShow)
 884 {
 885     HRESULT                     hResult;
 886
 887     // show the bar here
 888     if (fShow)
 889     {
 890         hResult = ReserveBorderSpace();
 891         if (FAILED_UNEXPECTEDLY(hResult))
 892             return hResult;
 893     }
 894
 895     if (fMenuBar)
 896     {
 897         hResult = IUnknown_ShowDW(fMenuBar, fShow);
 898         if (FAILED_UNEXPECTEDLY(hResult))
 899             return hResult;
 900     }
 901
 902     if (fControlsBar)
 903     {
 904         hResult = IUnknown_ShowDW(fControlsBar, fShow);
 905         if (FAILED_UNEXPECTEDLY(hResult))
 906             return hResult;
 907     }
 908     if (fNavigationBar)
 909     {
 910         hResult = IUnknown_ShowDW(fNavigationBar, fShow);
 911         if (FAILED_UNEXPECTEDLY(hResult))
 912             return hResult;
 913     }
 914     if (fLogoBar)
 915     {
 916         hResult = IUnknown_ShowDW(fLogoBar, fShow);
 917         if (FAILED_UNEXPECTEDLY(hResult))
 918             return hResult;
 919     }
 920     return S_OK;
 921 }
 922
 923 HRESULT STDMETHODCALLTYPE CInternetToolbar::CloseDW(DWORD dwReserved)
 924 {
 925     HRESULT                     hResult;
 926
 927     if (fMenuBar)
 928     {
 929         hResult = IUnknown_CloseDW(fMenuBar, dwReserved);
 930         if (FAILED_UNEXPECTEDLY(hResult))
 931             return hResult;
 932         ReleaseCComPtrExpectZero(fMenuBar);
 933     }
 934     if (fControlsBar)
 935     {
 936         hResult = IUnknown_CloseDW(fControlsBar, dwReserved);
 937         if (FAILED_UNEXPECTEDLY(hResult))
 938             return hResult;
 939         ReleaseCComPtrExpectZero(fControlsBar);
 940     }
 941     if (fNavigationBar)
 942     {
 943         hResult = IUnknown_CloseDW(fNavigationBar, dwReserved);
 944         if (FAILED_UNEXPECTEDLY(hResult))
 945             return hResult;
 946         ReleaseCComPtrExpectZero(fNavigationBar);
 947     }
 948     if (fLogoBar)
 949     {
 950         hResult = IUnknown_CloseDW(fLogoBar, dwReserved);
 951         if (FAILED_UNEXPECTEDLY(hResult))
 952             return hResult;
 953         ReleaseCComPtrExpectZero(fLogoBar);
 954     }
 955
 956     SetSite(NULL);
 957     return S_OK;
 958 }
 959
 960 HRESULT STDMETHODCALLTYPE CInternetToolbar::ResizeBorderDW(LPCRECT prcBorder,
 961     IUnknown *punkToolbarSite, BOOL fReserved)
 962 {
 963     RECT neededBorderSpace;
 964     RECT availableBorderSpace = *prcBorder;
 965
 966     SendMessage(fMainReBar, RB_SIZETORECT, RBSTR_CHANGERECT, reinterpret_cast<LPARAM>(&availableBorderSpace));
 967
 968     // RBSTR_CHANGERECT does not seem to set the proper size in the rect.
 969     // Let's make sure we fetch the actual size properly.
 970     ::GetWindowRect(fMainReBar, &availableBorderSpace);
 971     neededBorderSpace.left = 0;
 972     neededBorderSpace.top = availableBorderSpace.bottom - availableBorderSpace.top;
 973     if (!fLocked)
 974         neededBorderSpace.top += 3;
 975     neededBorderSpace.right = 0;
 976     neededBorderSpace.bottom = 0;
 977
 978     CComPtr<IDockingWindowSite> dockingWindowSite;
 979
 980     HRESULT hResult = fSite->QueryInterface(IID_PPV_ARG(IDockingWindowSite, &dockingWindowSite));
 981     if (FAILED_UNEXPECTEDLY(hResult))
 982         return hResult;
 983
 984     hResult = dockingWindowSite->RequestBorderSpaceDW(static_cast<IDockingWindow *>(this), &neededBorderSpace);
 985     if (FAILED_UNEXPECTEDLY(hResult))
 986         return hResult;
 987
 988     hResult = dockingWindowSite->SetBorderSpaceDW(static_cast<IDockingWindow *>(this), &neededBorderSpace);
 989     if (FAILED_UNEXPECTEDLY(hResult))
 990         return hResult;
 991
 992     return S_OK;
 993 }
 994
 995 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetClassID(CLSID *pClassID)
 996 {
 997     if (pClassID == NULL)
 998         return E_POINTER;
 999     *pClassID = CLSID_InternetToolbar;
1000     return S_OK;
1001 }
1002
1003 HRESULT STDMETHODCALLTYPE CInternetToolbar::IsDirty()
1004 {
1005     return E_NOTIMPL;
1006 }
1007
1008 HRESULT STDMETHODCALLTYPE CInternetToolbar::Load(IStream *pStm)
1009 {
1010     return E_NOTIMPL;
1011 }
1012
1013 HRESULT STDMETHODCALLTYPE CInternetToolbar::Save(IStream *pStm, BOOL fClearDirty)
1014 {
1015     return E_NOTIMPL;
1016 }
1017
1018 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetSizeMax(ULARGE_INTEGER *pcbSize)
1019 {
1020     return E_NOTIMPL;
1021 }
1022
1023 HRESULT STDMETHODCALLTYPE CInternetToolbar::InitNew()
1024 {
1025     CComPtr<IShellMenu>                     menuBar;
1026     CComPtr<IUnknown>                       logoBar;
1027     CComPtr<IUnknown>                       toolsBar;
1028     CComPtr<IUnknown>                       navigationBar;
1029     HRESULT                                 hResult;
1030
1031     /* Create and attach the menubar to the rebar */
1032     hResult = CreateMenuBar(&menuBar);
1033     if (FAILED_UNEXPECTEDLY(hResult))
1034         return hResult;
1035     AddDockItem(menuBar, ITBBID_MENUBAND, CDockSite::ITF_NOTITLE | CDockSite::ITF_NEWBANDALWAYS | CDockSite::ITF_GRIPPERALWAYS);
1036
1037     hResult = IUnknown_GetWindow(menuBar, &fMenuBandWindow);
1038     fMenuBar.Attach(menuBar.Detach());                  // transfer the ref count
1039
1040     // FIXME: The ros Rebar does not properly support fixed-size items such as the brandband,
1041     // and it will put them in their own row, sized to take up the whole row.
1042 #if 0
1043     /* Create and attach the brand/logo to the rebar */
1044     hResult = CBrandBand_CreateInstance(IID_PPV_ARG(IUnknown, &logoBar));
1045     if (FAILED_UNEXPECTEDLY(hResult))
1046         return hResult;
1047     AddDockItem(logoBar, ITBBID_BRANDBAND, CDockSite::ITF_NOGRIPPER | CDockSite::ITF_NOTITLE | CDockSite::ITF_FIXEDSIZE);
1048     fLogoBar.Attach(logoBar.Detach());                  // transfer the ref count
1049 #endif
1050
1051     /* Create and attach the standard toolbar to the rebar */
1052     hResult = CToolsBand_CreateInstance(IID_PPV_ARG(IUnknown, &toolsBar));
1053     if (FAILED_UNEXPECTEDLY(hResult))
1054         return hResult;
1055     AddDockItem(toolsBar, ITBBID_TOOLSBAND, CDockSite::ITF_NOTITLE | CDockSite::ITF_NEWBANDALWAYS | CDockSite::ITF_GRIPPERALWAYS);
1056     fControlsBar.Attach(toolsBar.Detach());             // transfer the ref count
1057     hResult = IUnknown_GetWindow(fControlsBar, &fToolbarWindow);
1058     if (FAILED_UNEXPECTEDLY(hResult))
1059         return hResult;
1060
1061     /* Create and attach the address/navigation toolbar to the rebar */
1062     hResult = CAddressBand_CreateInstance(IID_PPV_ARG(IUnknown, &navigationBar));
1063     if (FAILED_UNEXPECTEDLY(hResult))
1064         return hResult;
1065     AddDockItem(navigationBar, ITBBID_ADDRESSBAND, CDockSite::ITF_NEWBANDALWAYS | CDockSite::ITF_GRIPPERALWAYS);
1066     fNavigationBar.Attach(navigationBar.Detach());
1067     hResult = IUnknown_GetWindow(fNavigationBar, &fNavigationWindow);
1068
1069     return S_OK;
1070 }
1071
1072 HRESULT CInternetToolbar::IsBandVisible(int BandID)
1073 {
1074     int index = (int)SendMessage(fMainReBar, RB_IDTOINDEX, BandID, 0);
1075
1076     REBARBANDINFOW bandInfo = {sizeof(REBARBANDINFOW), RBBIM_STYLE};
1077     SendMessage(fMainReBar, RB_GETBANDINFOW, index, (LPARAM)&bandInfo);
1078
1079     return (bandInfo.fStyle & RBBS_HIDDEN) ? S_FALSE : S_OK;
1080 }
1081
1082 HRESULT CInternetToolbar::ToggleBandVisibility(int BandID)
1083 {
1084     int index = (int)SendMessage(fMainReBar, RB_IDTOINDEX, BandID, 0);
1085
1086     REBARBANDINFOW bandInfo = {sizeof(REBARBANDINFOW), RBBIM_STYLE};
1087     SendMessage(fMainReBar, RB_GETBANDINFOW, index, (LPARAM)&bandInfo);
1088
1089     if (bandInfo.fStyle & RBBS_HIDDEN)
1090         bandInfo.fStyle &= ~RBBS_HIDDEN;
1091     else
1092         bandInfo.fStyle |= RBBS_HIDDEN;
1093
1094     SendMessage(fMainReBar, RB_SETBANDINFOW, index, (LPARAM)&bandInfo);
1095
1096     ReserveBorderSpace(0);
1097     return S_OK;
1098 }
1099
1100 HRESULT STDMETHODCALLTYPE CInternetToolbar::QueryStatus(const GUID *pguidCmdGroup,
1101     ULONG cCmds, OLECMD prgCmds[  ], OLECMDTEXT *pCmdText)
1102 {
1103     if (IsEqualIID(*pguidCmdGroup, CGID_PrivCITCommands))
1104     {
1105         while (cCmds != 0)
1106         {
1107             switch (prgCmds->cmdID)
1108             {
1109                 case ITID_TEXTLABELS:       // Text Labels state
1110                     prgCmds->cmdf = OLECMDF_SUPPORTED;
1111                     break;
1112                 case ITID_TOOLBARBANDSHOWN: // toolbar visibility
1113                     prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1114                     if (IsBandVisible(ITBBID_TOOLSBAND) == S_OK)
1115                         prgCmds->cmdf |= OLECMDF_LATCHED;
1116                     break;
1117                 case ITID_ADDRESSBANDSHOWN: // address bar visibility
1118                     prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1119                     if (IsBandVisible(ITBBID_ADDRESSBAND) == S_OK)
1120                         prgCmds->cmdf |= OLECMDF_LATCHED;
1121                     break;
1122                 case ITID_LINKSBANDSHOWN:   // links bar visibility
1123                     prgCmds->cmdf = 0;
1124                     break;
1125                 case ITID_MENUBANDSHOWN:    // Menubar band visibility
1126                     prgCmds->cmdf = OLECMDF_SUPPORTED;
1127                     if (fMenuBar)
1128                         prgCmds->cmdf |= OLECMDF_LATCHED;
1129                     break;
1130                 case ITID_AUTOHIDEENABLED:  // Auto hide enabled/disabled
1131                     prgCmds->cmdf = 0;
1132                     break;
1133                 case ITID_CUSTOMIZEENABLED: // customize enabled
1134                     prgCmds->cmdf = OLECMDF_SUPPORTED;
1135                     break;
1136                 case ITID_TOOLBARLOCKED:    // lock toolbars
1137                     prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1138                     if (fLocked)
1139                         prgCmds->cmdf |= OLECMDF_LATCHED;
1140                     break;
1141                 default:
1142                     prgCmds->cmdf = 0;
1143                     break;
1144             }
1145             prgCmds++;
1146             cCmds--;
1147         }
1148         return S_OK;
1149     }
1150     return E_FAIL;
1151 }
1152
1153 HRESULT STDMETHODCALLTYPE CInternetToolbar::Exec(const GUID *pguidCmdGroup, DWORD nCmdID,
1154     DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
1155 {
1156     if (IsEqualIID(*pguidCmdGroup, CGID_PrivCITCommands))
1157     {
1158         switch (nCmdID)
1159         {
1160             case 1:
1161                 // what do I do here?
1162                 return S_OK;
1163             case ITID_TEXTLABELS:
1164                 // toggle text labels
1165                 return S_OK;
1166             case ITID_TOOLBARBANDSHOWN:
1167                 return ToggleBandVisibility(ITBBID_TOOLSBAND);
1168             case ITID_ADDRESSBANDSHOWN:
1169                 return ToggleBandVisibility(ITBBID_ADDRESSBAND);
1170             case ITID_LINKSBANDSHOWN:
1171                 // toggle links band visibility
1172                 return S_OK;
1173             case ITID_CUSTOMIZEENABLED:
1174                 // run customize
1175                 return S_OK;
1176             case ITID_TOOLBARLOCKED:
1177                 return LockUnlockToolbars(!fLocked);
1178         }
1179     }
1180     return E_FAIL;
1181 }
1182
1183 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetTypeInfoCount(UINT *pctinfo)
1184 {
1185     return E_NOTIMPL;
1186 }
1187
1188 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1189 {
1190     return E_NOTIMPL;
1191 }
1192
1193 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames,
1194     LCID lcid, DISPID *rgDispId)
1195 {
1196     return E_NOTIMPL;
1197 }
1198
1199 HRESULT STDMETHODCALLTYPE CInternetToolbar::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
1200     WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1201 {
1202     HRESULT                                 hResult;
1203
1204     switch(dispIdMember)
1205     {
1206         case DISPID_BEFORENAVIGATE:
1207             hResult = S_OK;
1208             break;
1209         case DISPID_DOWNLOADCOMPLETE:
1210             hResult = S_OK;
1211             break;
1212         case DISPID_COMMANDSTATECHANGE:
1213             if (pDispParams->cArgs != 2)
1214                 return E_INVALIDARG;
1215             if (V_VT(&pDispParams->rgvarg[0]) != VT_BOOL || V_VT(&pDispParams->rgvarg[1]) != VT_I4)
1216                 return E_INVALIDARG;
1217             return CommandStateChanged(V_BOOL(&pDispParams->rgvarg[0]) != VARIANT_FALSE,
1218                 V_I4(&pDispParams->rgvarg[1]));
1219         case DISPID_DOWNLOADBEGIN:
1220             hResult = S_OK;
1221             break;
1222         case DISPID_NAVIGATECOMPLETE2:
1223             hResult = S_OK;
1224             break;
1225         case DISPID_DOCUMENTCOMPLETE:
1226             hResult = S_OK;
1227             break;
1228     }
1229     return S_OK;
1230 }
1231
1232 HRESULT STDMETHODCALLTYPE CInternetToolbar::SetCommandTarget(IUnknown *theTarget, GUID *category, long param14)
1233 {
1234     HRESULT                                 hResult;
1235
1236     TRACE("SetCommandTarget %p category %s param %d\n", theTarget, wine_dbgstr_guid(category), param14);
1237
1238     fCommandTarget.Release();
1239     hResult = theTarget->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &fCommandTarget));
1240     if (FAILED_UNEXPECTEDLY(hResult))
1241         return hResult;
1242     fCommandCategory = *category;
1243     return S_OK;
1244 }
1245
1246 HRESULT STDMETHODCALLTYPE CInternetToolbar::Unknown1()
1247 {
1248     return E_NOTIMPL;
1249 }
1250
1251 HRESULT STDMETHODCALLTYPE CInternetToolbar::AddButtons(const GUID *pguidCmdGroup, long buttonCount, TBBUTTON *buttons)
1252 {
1253     return E_NOTIMPL;
1254 }
1255
1256 HRESULT STDMETHODCALLTYPE CInternetToolbar::AddString(const GUID *pguidCmdGroup,
1257     HINSTANCE param10, LPCTSTR param14, long *param18)
1258 {
1259     long                                    result;
1260
1261     result = (long)::SendMessage(fToolbarWindow, TB_ADDSTRINGW,
1262             reinterpret_cast<WPARAM>(param10), reinterpret_cast<LPARAM>(param14));
1263     *param18 = result;
1264     if (result == -1)
1265         return E_FAIL;
1266     return S_OK;
1267 }
1268
1269 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetButton(const GUID *pguidCmdGroup, long param10, long param14)
1270 {
1271     return E_NOTIMPL;
1272 }
1273
1274 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetState(const GUID *pguidCmdGroup, long commandID, long *theState)
1275 {
1276     if (theState == NULL)
1277         return E_POINTER;
1278     // map the command id
1279     *theState = (long)::SendMessage(fToolbarWindow, TB_GETSTATE, commandID, 0);
1280     return S_OK;
1281 }
1282
1283 HRESULT STDMETHODCALLTYPE CInternetToolbar::SetState(const GUID *pguidCmdGroup, long commandID, long theState)
1284 {
1285     // map the command id
1286     ::SendMessage(fToolbarWindow, TB_SETSTATE, commandID, MAKELONG(theState, 0));
1287     return S_OK;
1288 }
1289
1290 HRESULT STDMETHODCALLTYPE CInternetToolbar::AddBitmap(const GUID *pguidCmdGroup, long param10, long buttonCount,
1291     TBADDBITMAP *lParam, long *newIndex, COLORREF param20)
1292 {
1293     return E_NOTIMPL;
1294 }
1295
1296 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetBitmapSize(long *paramC)
1297 {
1298     if (paramC == NULL)
1299         return E_POINTER;
1300     *paramC = MAKELONG(24, 24);
1301     return S_OK;
1302 }
1303
1304 HRESULT STDMETHODCALLTYPE CInternetToolbar::SendToolbarMsg(const GUID *pguidCmdGroup, UINT uMsg,
1305     WPARAM wParam, LPARAM lParam, LRESULT *result)
1306 {
1307     return E_NOTIMPL;
1308 }
1309
1310 HRESULT STDMETHODCALLTYPE CInternetToolbar::SetImageList(const GUID *pguidCmdGroup, HIMAGELIST param10,
1311     HIMAGELIST param14, HIMAGELIST param18)
1312 {
1313     return E_NOTIMPL;
1314 }
1315
1316 HRESULT STDMETHODCALLTYPE CInternetToolbar::ModifyButton(const GUID *pguidCmdGroup, long param10, long param14)
1317 {
1318     return E_NOTIMPL;
1319 }
1320
1321 HRESULT STDMETHODCALLTYPE CInternetToolbar::OnChange(LONG lEvent, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
1322 {
1323     return E_NOTIMPL;
1324 }
1325
1326 HRESULT STDMETHODCALLTYPE CInternetToolbar::SetSite(IUnknown *pUnkSite)
1327 {
1328     CComPtr<IBrowserService>                browserService;
1329     HWND                                    ownerWindow;
1330     HWND                                    dockContainer;
1331     HRESULT                                 hResult;
1332
1333     if (pUnkSite == NULL)
1334     {
1335         hResult = AtlUnadvise(fSite, DIID_DWebBrowserEvents, fAdviseCookie);
1336         ::DestroyWindow(fMainReBar);
1337         DestroyWindow();
1338         fSite.Release();
1339     }
1340     else
1341     {
1342         // get window handle of owner
1343         hResult = IUnknown_GetWindow(pUnkSite, &ownerWindow);
1344         if (FAILED_UNEXPECTEDLY(hResult))
1345             return hResult;
1346         if (ownerWindow == NULL)
1347             return E_FAIL;
1348
1349         // create dock container
1350         fSite = pUnkSite;
1351         dockContainer = SHCreateWorkerWindowW(0, ownerWindow, 0,
1352             WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, NULL, 0);
1353         if (dockContainer == NULL)
1354             return E_FAIL;
1355         SubclassWindow(dockContainer);
1356
1357         // create rebar in dock container
1358         DWORD style = WS_VISIBLE | WS_BORDER | WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
1359                       RBS_VARHEIGHT | RBS_BANDBORDERS | RBS_REGISTERDROP | RBS_AUTOSIZE | RBS_DBLCLKTOGGLE |
1360                       CCS_NODIVIDER | CCS_NOPARENTALIGN | CCS_TOP;
1361         DWORD exStyle = WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR | WS_EX_TOOLWINDOW;
1362         fMainReBar = CreateWindowEx(exStyle, REBARCLASSNAMEW, NULL, style,
1363                             0, 0, 700, 60, dockContainer, NULL, _AtlBaseModule.GetModuleInstance(), NULL);
1364         if (fMainReBar == NULL)
1365             return E_FAIL;
1366
1367         // take advice to watch events
1368         hResult = IUnknown_QueryService(pUnkSite, SID_SShellBrowser, IID_PPV_ARG(IBrowserService, &browserService));
1369         hResult = AtlAdvise(browserService, static_cast<IDispatch *>(this), DIID_DWebBrowserEvents, &fAdviseCookie);
1370     }
1371     return S_OK;
1372 }
1373
1374 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetSite(REFIID riid, void **ppvSite)
1375 {
1376     if (ppvSite == NULL)
1377         return E_POINTER;
1378     if (fSite.p != NULL)
1379         return fSite->QueryInterface(riid, ppvSite);
1380     *ppvSite = NULL;
1381     return S_OK;
1382 }
1383
1384 HRESULT STDMETHODCALLTYPE CInternetToolbar::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
1385 {
1386     HRESULT                                 hResult;
1387
1388     if (IsEqualIID(guidService, IID_IBandSite))
1389         return this->QueryInterface(riid, ppvObject);
1390     if (IsEqualIID(guidService, SID_IBandProxy))
1391     {
1392         if (fBandProxy.p == NULL)
1393         {
1394             hResult = CreateAndInitBandProxy();
1395             if (FAILED_UNEXPECTEDLY(hResult))
1396                 return hResult;
1397         }
1398         return fBandProxy->QueryInterface(riid, ppvObject);
1399     }
1400     return IUnknown_QueryService(fSite, guidService, riid, ppvObject);
1401 }
1402
1403 HRESULT STDMETHODCALLTYPE CInternetToolbar::OnWinEvent(
1404     HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult)
1405 {
1406     HRESULT                                 hResult;
1407
1408     if (fMenuBar)
1409     {
1410         hResult = IUnknown_RelayWinEvent(fMenuBar, hWnd, uMsg, wParam, lParam, theResult);
1411         if (hResult != S_FALSE)
1412             return hResult;
1413     }
1414
1415     if (fNavigationBar)
1416     {
1417         hResult = IUnknown_RelayWinEvent(fNavigationBar, hWnd, uMsg, wParam, lParam, theResult);
1418         if (hResult != S_FALSE)
1419             return hResult;
1420     }
1421
1422     if (fLogoBar)
1423     {
1424         hResult = IUnknown_RelayWinEvent(fLogoBar, hWnd, uMsg, wParam, lParam, theResult);
1425         if (hResult != S_FALSE)
1426             return hResult;
1427     }
1428
1429     return S_FALSE;
1430 }
1431
1432 HRESULT STDMETHODCALLTYPE CInternetToolbar::IsWindowOwner(HWND hWnd)
1433 {
1434     UNIMPLEMENTED;
1435     return E_NOTIMPL;
1436 }
1437
1438 HRESULT STDMETHODCALLTYPE CInternetToolbar::AddBand(IUnknown *punk)
1439 {
1440     UNIMPLEMENTED;
1441     return E_NOTIMPL;
1442 }
1443
1444 HRESULT STDMETHODCALLTYPE CInternetToolbar::EnumBands(UINT uBand, DWORD *pdwBandID)
1445 {
1446     UNIMPLEMENTED;
1447     return E_NOTIMPL;
1448 }
1449
1450 HRESULT STDMETHODCALLTYPE CInternetToolbar::QueryBand(DWORD dwBandID,
1451     IDeskBand **ppstb, DWORD *pdwState, LPWSTR pszName, int cchName)
1452 {
1453     if (ppstb == NULL)
1454         return E_POINTER;
1455     if (dwBandID == ITBBID_MENUBAND && fMenuBar.p != NULL)
1456         return fMenuBar->QueryInterface(IID_PPV_ARG(IDeskBand, ppstb));
1457     //if (dwBandID == ITBBID_BRANDBAND && fLogoBar.p != NULL)
1458     //    return fLogoBar->QueryInterface(IID_PPV_ARG(IDeskBand, ppstb));
1459     *ppstb = NULL;
1460     return E_FAIL;
1461 }
1462
1463 HRESULT STDMETHODCALLTYPE CInternetToolbar::SetBandState(DWORD dwBandID, DWORD dwMask, DWORD dwState)
1464 {
1465     UNIMPLEMENTED;
1466     return E_NOTIMPL;
1467 }
1468
1469 HRESULT STDMETHODCALLTYPE CInternetToolbar::RemoveBand(DWORD dwBandID)
1470 {
1471     UNIMPLEMENTED;
1472     return E_NOTIMPL;
1473 }
1474
1475 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetBandObject(DWORD dwBandID, REFIID riid, void **ppv)
1476 {
1477     UNIMPLEMENTED;
1478     return E_NOTIMPL;
1479 }
1480
1481 HRESULT STDMETHODCALLTYPE CInternetToolbar::SetBandSiteInfo(const BANDSITEINFO *pbsinfo)
1482 {
1483     UNIMPLEMENTED;
1484     return E_NOTIMPL;
1485 }
1486
1487 HRESULT STDMETHODCALLTYPE CInternetToolbar::GetBandSiteInfo(BANDSITEINFO *pbsinfo)
1488 {
1489     UNIMPLEMENTED;
1490     return E_NOTIMPL;
1491 }
1492
1493 LRESULT CInternetToolbar::OnTravelBack(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
1494 {
1495     CComPtr<IWebBrowser>                    webBrowser;
1496     HRESULT                                 hResult;
1497
1498     hResult = IUnknown_QueryService(fSite, SID_SShellBrowser, IID_PPV_ARG(IWebBrowser, &webBrowser));
1499     if (FAILED_UNEXPECTEDLY(hResult))
1500         return 0;
1501     hResult = webBrowser->GoBack();
1502     return 1;
1503 }
1504
1505 LRESULT CInternetToolbar::OnTravelForward(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
1506 {
1507     CComPtr<IWebBrowser>                    webBrowser;
1508     HRESULT                                 hResult;
1509
1510     hResult = IUnknown_QueryService(fSite, SID_SShellBrowser, IID_PPV_ARG(IWebBrowser, &webBrowser));
1511     if (FAILED_UNEXPECTEDLY(hResult))
1512         return 0;
1513     hResult = webBrowser->GoForward();
1514     return 1;
1515 }
1516
1517 LRESULT CInternetToolbar::OnUpLevel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
1518 {
1519     IUnknown_Exec(fSite, CGID_ShellBrowser, IDM_GOTO_UPONELEVEL, 0, NULL, NULL);
1520     return 1;
1521 }
1522
1523 LRESULT CInternetToolbar::OnSearch(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
1524 {
1525     IUnknown_Exec(fSite, CGID_Explorer, 0x1c, 1, NULL, NULL);
1526     return 1;
1527 }
1528
1529 LRESULT CInternetToolbar::OnFolders(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
1530 {
1531     IUnknown_Exec(fSite, CGID_Explorer, 0x23, 0, NULL, NULL);
1532     return 1;
1533 }
1534
1535 LRESULT CInternetToolbar::OnForwardToCommandTarget(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
1536 {
1537     HRESULT                                 hResult;
1538
1539     if (fCommandTarget.p != NULL)
1540     {
1541         hResult = fCommandTarget->Exec(&fCommandCategory, wID, 0, NULL, NULL);
1542     }
1543     return 1;
1544 }
1545
1546 LRESULT CInternetToolbar::OnMenuDropDown(UINT idControl, NMHDR *pNMHDR, BOOL &bHandled)
1547 {
1548     CComPtr<IBrowserService>                browserService;
1549     CComPtr<IOleCommandTarget>              commandTarget;
1550     CComPtr<ITravelLog>                     travelLog;
1551     NMTOOLBARW                              *notifyInfo;
1552     RECT                                    bounds;
1553     HMENU                                   newMenu;
1554     TPMPARAMS                               params;
1555     int                                     selectedItem;
1556     VARIANT                                 parmIn;
1557     OLECMD                                  commandInfo;
1558     HRESULT                                 hResult;
1559     wchar_t                                 templateString[200];
1560
1561     notifyInfo = (NMTOOLBARW *)pNMHDR;
1562     if (notifyInfo->hdr.hwndFrom != fToolbarWindow)
1563     {
1564         // not from the toolbar, keep looking for a message handler
1565         bHandled = FALSE;
1566         return 0;
1567     }
1568     SendMessage(fToolbarWindow, TB_GETRECT, notifyInfo->iItem, reinterpret_cast<LPARAM>(&bounds));
1569     ::MapWindowPoints(fToolbarWindow, NULL, reinterpret_cast<POINT *>(&bounds), 2);
1570     switch (notifyInfo->iItem)
1571     {
1572         case IDM_GOTO_BACK:
1573             newMenu = CreatePopupMenu();
1574             hResult = IUnknown_QueryService(fSite, SID_SShellBrowser, IID_PPV_ARG(IBrowserService, &browserService));
1575             hResult = browserService->GetTravelLog(&travelLog);
1576             hResult = travelLog->InsertMenuEntries(browserService, newMenu, 0, 1, 9, TLMENUF_BACK);
1577             commandInfo.cmdID = 0x1d;
1578             hResult = IUnknown_QueryStatus(browserService, CGID_Explorer, 1, &commandInfo, NULL);
1579             if ((commandInfo.cmdf & (OLECMDF_ENABLED | OLECMDF_LATCHED)) == OLECMDF_ENABLED &&
1580                 travelLog->CountEntries(browserService) > 1)
1581             {
1582                 AppendMenuW(newMenu, MF_SEPARATOR, -1, L"");
1583
1584                 if (LoadStringW(_AtlBaseModule.GetResourceInstance(),
1585                                 IDS_HISTORYTEXT, templateString, sizeof(templateString) / sizeof(wchar_t)) == 0)
1586                     StringCbCopyW(templateString, sizeof(templateString), L"&History\tCtrl+H");
1587
1588                 AppendMenuW(newMenu, MF_STRING /* | MF_OWNERDRAW */, IDM_EXPLORERBAR_HISTORY, templateString);
1589             }
1590             params.cbSize = sizeof(params);
1591             params.rcExclude = bounds;
1592             selectedItem = TrackPopupMenuEx(newMenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD,
1593                                     bounds.left, bounds.bottom, m_hWnd, &params);
1594             if (selectedItem == IDM_EXPLORERBAR_HISTORY)
1595             {
1596                 V_VT(&parmIn) = VT_I4;
1597                 V_I4(&parmIn) = 1;
1598                 Exec(&CGID_Explorer, 0x1d, 2, &parmIn, NULL);
1599             }
1600             else if (selectedItem != 0)
1601                 hResult = travelLog->Travel(browserService, -selectedItem);
1602             DestroyMenu(newMenu);
1603             break;
1604         case IDM_GOTO_FORWARD:
1605             newMenu = CreatePopupMenu();
1606             hResult = IUnknown_QueryService(fSite, SID_SShellBrowser, IID_PPV_ARG(IBrowserService, &browserService));
1607             hResult = browserService->GetTravelLog(&travelLog);
1608             hResult = travelLog->InsertMenuEntries(browserService, newMenu, 0, 1, 9, TLMENUF_FORE);
1609             commandInfo.cmdID = 0x1d;
1610             hResult = IUnknown_QueryStatus(browserService, CGID_Explorer, 1, &commandInfo, NULL);
1611             if ((commandInfo.cmdf & (OLECMDF_ENABLED | OLECMDF_LATCHED)) == OLECMDF_ENABLED &&
1612                 travelLog->CountEntries(browserService) > 1)
1613             {
1614                 AppendMenuW(newMenu, MF_SEPARATOR, -1, L"");
1615
1616                 if (LoadStringW(_AtlBaseModule.GetResourceInstance(),
1617                                 IDS_HISTORYTEXT, templateString, sizeof(templateString) / sizeof(wchar_t)) == 0)
1618                     StringCbCopyW(templateString, sizeof(templateString), L"&History\tCtrl+H");
1619
1620                 AppendMenuW(newMenu, MF_STRING /* | MF_OWNERDRAW */, IDM_EXPLORERBAR_HISTORY, templateString);
1621             }
1622             params.cbSize = sizeof(params);
1623             params.rcExclude = bounds;
1624             selectedItem = TrackPopupMenuEx(newMenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD,
1625                                     bounds.left, bounds.bottom, m_hWnd, &params);
1626             if (selectedItem == IDM_EXPLORERBAR_HISTORY)
1627             {
1628                 V_VT(&parmIn) = VT_I4;
1629                 V_I4(&parmIn) = 1;
1630                 Exec(&CGID_Explorer, 0x1d, 2, &parmIn, NULL);
1631             }
1632             else if (selectedItem != 0)
1633                 hResult = travelLog->Travel(browserService, selectedItem);
1634             DestroyMenu(newMenu);
1635             break;
1636         case gViewsCommandID:
1637             VARIANT                     inValue;
1638             CComVariant                 outValue;
1639             HRESULT                     hResult;
1640
1641             V_VT(&inValue) = VT_INT_PTR;
1642             V_INTREF(&inValue) = reinterpret_cast<INT *>(&bounds);
1643
1644             if (fCommandTarget.p != NULL)
1645                 hResult = fCommandTarget->Exec(&fCommandCategory, FCIDM_SHVIEW_AUTOARRANGE, 1, &inValue, &outValue);
1646             // pvaOut is VT_I4 with value 0x403
1647             break;
1648     }
1649     return TBDDRET_DEFAULT;
1650 }
1651
1652 LRESULT CInternetToolbar::OnQueryInsert(UINT idControl, NMHDR *pNMHDR, BOOL &bHandled)
1653 {
1654     return 1;
1655 }
1656
1657 LRESULT CInternetToolbar::OnQueryDelete(UINT idControl, NMHDR *pNMHDR, BOOL &bHandled)
1658 {
1659     return 1;
1660 }
1661
1662 LRESULT CInternetToolbar::OnContextMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1663 {
1664     HMENU                                   contextMenuBar;
1665     HMENU                                   contextMenu;
1666     POINT                                   clickLocation;
1667     int                                     command;
1668     RBHITTESTINFO                           hitTestInfo;
1669     REBARBANDINFOW                          rebarBandInfo;
1670     int                                     bandID;
1671     BOOL                                    goButtonChecked;
1672
1673     clickLocation.x = LOWORD(lParam);
1674     clickLocation.y = HIWORD(lParam);
1675     hitTestInfo.pt = clickLocation;
1676     ScreenToClient(&hitTestInfo.pt);
1677     SendMessage(fMainReBar, RB_HITTEST, 0, (LPARAM)&hitTestInfo);
1678     if (hitTestInfo.iBand == -1)
1679         return 0;
1680     rebarBandInfo.cbSize = sizeof(rebarBandInfo);
1681     rebarBandInfo.fMask = RBBIM_ID;
1682     SendMessage(fMainReBar, RB_GETBANDINFOW, hitTestInfo.iBand, (LPARAM)&rebarBandInfo);
1683     bandID = rebarBandInfo.wID;
1684     contextMenuBar = LoadMenu(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(IDM_CABINET_CONTEXTMENU));
1685     contextMenu = GetSubMenu(contextMenuBar, 0);
1686     switch (bandID)
1687     {
1688         case ITBBID_MENUBAND:   // menu band
1689             DeleteMenu(contextMenu, IDM_TOOLBARS_CUSTOMIZE, MF_BYCOMMAND);
1690             DeleteMenu(contextMenu, IDM_TOOLBARS_TEXTLABELS, MF_BYCOMMAND);
1691             DeleteMenu(contextMenu, IDM_TOOLBARS_GOBUTTON, MF_BYCOMMAND);
1692             break;
1693         case ITBBID_BRANDBAND:  // brand band
1694             DeleteMenu(contextMenu, IDM_TOOLBARS_CUSTOMIZE, MF_BYCOMMAND);
1695             DeleteMenu(contextMenu, IDM_TOOLBARS_TEXTLABELS, MF_BYCOMMAND);
1696             DeleteMenu(contextMenu, IDM_TOOLBARS_GOBUTTON, MF_BYCOMMAND);
1697             break;
1698         case ITBBID_TOOLSBAND:  // tools band
1699             DeleteMenu(contextMenu, IDM_TOOLBARS_TEXTLABELS, MF_BYCOMMAND);
1700             DeleteMenu(contextMenu, IDM_TOOLBARS_GOBUTTON, MF_BYCOMMAND);
1701             break;
1702         case ITBBID_ADDRESSBAND:    // navigation band
1703             DeleteMenu(contextMenu, IDM_TOOLBARS_CUSTOMIZE, MF_BYCOMMAND);
1704             DeleteMenu(contextMenu, IDM_TOOLBARS_TEXTLABELS, MF_BYCOMMAND);
1705             break;
1706         default:
1707             break;
1708     }
1709
1710     SHEnableMenuItem(contextMenu, IDM_TOOLBARS_LINKSBAR, FALSE);
1711
1712     SHCheckMenuItem(contextMenu, IDM_TOOLBARS_STANDARDBUTTONS, IsBandVisible(ITBBID_TOOLSBAND) == S_OK);
1713     SHCheckMenuItem(contextMenu, IDM_TOOLBARS_ADDRESSBAR, IsBandVisible(ITBBID_ADDRESSBAND) == S_OK);
1714     SHCheckMenuItem(contextMenu, IDM_TOOLBARS_LINKSBAR, FALSE);
1715     SHCheckMenuItem(contextMenu, IDM_TOOLBARS_CUSTOMIZE, FALSE);
1716     SHCheckMenuItem(contextMenu, IDM_TOOLBARS_LOCKTOOLBARS, fLocked);
1717     goButtonChecked = SHRegGetBoolUSValueW(L"Software\\Microsoft\\Internet Explorer\\Main", L"ShowGoButton", FALSE, TRUE);
1718     SHCheckMenuItem(contextMenu, IDM_TOOLBARS_GOBUTTON, goButtonChecked);
1719
1720     // TODO: use GetSystemMetrics(SM_MENUDROPALIGNMENT) to determine menu alignment
1721     command = TrackPopupMenu(contextMenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD,
1722                 clickLocation.x, clickLocation.y, 0, m_hWnd, NULL);
1723     switch (command)
1724     {
1725         case IDM_TOOLBARS_STANDARDBUTTONS:  // standard buttons
1726             ToggleBandVisibility(ITBBID_TOOLSBAND);
1727             break;
1728         case IDM_TOOLBARS_ADDRESSBAR:   // address bar
1729             ToggleBandVisibility(ITBBID_ADDRESSBAND);
1730             break;
1731         case IDM_TOOLBARS_LINKSBAR: // links
1732             break;
1733         case IDM_TOOLBARS_LOCKTOOLBARS: // lock the toolbars
1734             LockUnlockToolbars(!fLocked);
1735             break;
1736         case IDM_TOOLBARS_CUSTOMIZE:    // customize
1737             SendMessage(fToolbarWindow, TB_CUSTOMIZE, 0, 0);
1738             break;
1739         case IDM_TOOLBARS_GOBUTTON:
1740             SendMessage(fNavigationWindow, WM_COMMAND, IDM_TOOLBARS_GOBUTTON, 0);
1741             break;
1742     }
1743
1744     DestroyMenu(contextMenuBar);
1745     return 1;
1746 }
1747
1748 LRESULT CInternetToolbar::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1749 {
1750     if (wParam != SIZE_MINIMIZED)
1751     {
1752         ::SetWindowPos(fMainReBar, NULL, 0, 0, LOWORD(lParam), HIWORD(lParam),
1753             SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_NOMOVE);
1754     }
1755     return 1;
1756 }
1757
1758 LRESULT CInternetToolbar::OnSetCursor(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1759 {
1760     if ((short)lParam != HTCLIENT || (HWND)wParam != m_hWnd)
1761     {
1762         bHandled = FALSE;
1763         return 0;
1764     }
1765     SetCursor(LoadCursor(NULL, IDC_SIZENS));
1766     return 1;
1767 }
1768
1769 LRESULT CInternetToolbar::OnTipText(UINT idControl, NMHDR *pNMHDR, BOOL &bHandled)
1770 {
1771     CComPtr<IBrowserService>                browserService;
1772     CComPtr<ITravelLog>                     travelLog;
1773     TOOLTIPTEXTW                            *pTTTW;
1774     UINT                                    nID;
1775     HRESULT                                 hResult;
1776     wchar_t                                 tempString[300];
1777
1778     pTTTW = reinterpret_cast<TOOLTIPTEXTW *>(pNMHDR);
1779     if ((pTTTW->uFlags & TTF_IDISHWND) != 0)
1780         nID = ::GetDlgCtrlID((HWND)pNMHDR->idFrom);
1781     else
1782         nID = (UINT)pNMHDR->idFrom;
1783
1784     if (nID != 0)
1785     {
1786         if (nID == (UINT)IDM_GOTO_BACK || nID == (UINT)IDM_GOTO_FORWARD)
1787         {
1788             // TODO: Should this call QueryService?
1789             hResult = fSite->QueryInterface(IID_PPV_ARG(IBrowserService, &browserService));
1790             hResult = browserService->GetTravelLog(&travelLog);
1791             hResult = travelLog->GetToolTipText(browserService,
1792                 (nID == (UINT)IDM_GOTO_BACK) ? TLOG_BACK : TLOG_FORE,
1793                 0, tempString, 299);
1794             if (FAILED_UNEXPECTEDLY(hResult))
1795             {
1796                 bHandled = FALSE;
1797                 return 0;
1798             }
1799         }
1800         else
1801             tempString[0] = 0;
1802         wcsncpy (pTTTW->szText, tempString, sizeof(pTTTW->szText) / sizeof(wchar_t));
1803         ::SetWindowPos(pNMHDR->hwndFrom, HWND_TOP, 0, 0, 0, 0,
1804             SWP_NOOWNERZORDER | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
1805         return 0;
1806     }
1807     return 0;
1808 }
1809
1810 LRESULT CInternetToolbar::OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1811 {
1812     LRESULT theResult;
1813     HRESULT hResult;
1814
1815     hResult = OnWinEvent((HWND) lParam, uMsg, wParam, lParam, &theResult);
1816
1817     bHandled = hResult == S_OK;
1818
1819     return FAILED_UNEXPECTEDLY(hResult) ? 0 : theResult;
1820 }
1821 LRESULT CInternetToolbar::OnNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1822 {
1823     NMHDR   *notifyHeader;
1824     LRESULT theResult;
1825     HRESULT hResult;
1826
1827     notifyHeader = reinterpret_cast<NMHDR *>(lParam);
1828
1829     hResult = OnWinEvent(notifyHeader->hwndFrom, uMsg, wParam, lParam, &theResult);
1830
1831     bHandled = hResult == S_OK;
1832
1833     return FAILED_UNEXPECTEDLY(hResult) ? 0 : theResult;
1834 }
1835
1836 LRESULT CInternetToolbar::OnLDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1837 {
1838     bHandled = FALSE;
1839     if (fLocked)
1840         return 0;
1841
1842     if (wParam & MK_CONTROL)
1843         return 0;
1844
1845     fSizing = TRUE;
1846
1847     DWORD msgp = GetMessagePos();
1848
1849     fStartPosition.x = GET_X_LPARAM(msgp);
1850     fStartPosition.y = GET_Y_LPARAM(msgp);
1851
1852     RECT rc;
1853     GetWindowRect(&rc);
1854
1855     fStartHeight = rc.bottom - rc.top;
1856
1857     SetCapture();
1858
1859     bHandled = TRUE;
1860     return 0;
1861 }
1862
1863 LRESULT CInternetToolbar::OnMouseMove(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1864 {
1865     bHandled = FALSE;
1866     if (!fSizing)
1867         return 0;
1868
1869     DWORD msgp = GetMessagePos();
1870
1871     POINT pt;
1872     pt.x = GET_X_LPARAM(msgp);
1873     pt.y = GET_Y_LPARAM(msgp);
1874
1875     ReserveBorderSpace(fStartHeight - fStartPosition.y + pt.y);
1876
1877     bHandled = TRUE;
1878     return 0;
1879 }
1880
1881 LRESULT CInternetToolbar::OnLUp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1882 {
1883     bHandled = FALSE;
1884     if (!fSizing)
1885         return 0;
1886
1887     OnMouseMove(uMsg, wParam, lParam, bHandled);
1888
1889     fSizing = FALSE;
1890
1891     ReleaseCapture();
1892
1893     return 0;
1894 }
1895
1896 LRESULT CInternetToolbar::OnWinIniChange(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
1897 {
1898     HRESULT hr;
1899     HWND hwndMenu;
1900
1901     hr = IUnknown_GetWindow(fMenuBar, &hwndMenu);
1902     if (FAILED_UNEXPECTEDLY(hr))
1903         return 0;
1904
1905     CComPtr<IWinEventHandler> menuWinEventHandler;
1906     hr = fMenuBar->QueryInterface(IID_PPV_ARG(IWinEventHandler, &menuWinEventHandler));
1907     if (FAILED_UNEXPECTEDLY(hr))
1908         return 0;
1909
1910     LRESULT lres;
1911     hr = menuWinEventHandler->OnWinEvent(hwndMenu, uMsg, wParam, lParam, &lres);
1912     if (FAILED_UNEXPECTEDLY(hr))
1913         return 0;
1914
1915     return lres;
1916 }