dll/win32/browseui/shellbrowser.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 #include "precomp.h"
  22
  23 #include <shellapi.h>
  24 #include <htiframe.h>
  25
  26 extern "C"
  27 BOOL WINAPI Shell_GetImageLists(
  28     _Out_  HIMAGELIST *phiml,
  29     _Out_  HIMAGELIST *phimlSmall
  30     );
  31
  32 #include "newatlinterfaces.h"
  33
  34 /*
  35 TODO:
  36   **Provide implementation of new and delete that use LocalAlloc
  37   **Persist history for shell view isn't working correctly, possibly because of the mismatch between traveling and updating the travel log. The
  38         view doesn't restore the selection correctly.
  39   **Build explorer.exe, browseui.dll, comctl32.dll, shdocvw.dll, shell32.dll, shlwapi.dll into a directory and run them for testing...
  40   **Add brand band bitmaps to shell32.dll
  41   **If Go button on address bar is clicked, each time a new duplicate entry is added to travel log
  42 ****The current entry is updated in travel log before doing the travel, which means when traveling back the update of the
  43         current state overwrites the wrong entry's contents. This needs to be changed.
  44 ****Fix close of browser window to release all objects
  45 ****Given only a GUID in ShowBrowserBar, what is the correct way to determine if the bar is vertical or horizontal?
  46   **When a new bar is added to base bar site, how is base bar told so it can resize?
  47   **Does the base bar site have a classid?
  48   **What should refresh command send to views to make them refresh?
  49   **When new bar is created, what status notifications need to be fired?
  50   **How does keyboard filtering dispatch?
  51   **For deferred persist history load, how does the view connect up and get the state?
  52     How does context menu send open, cut, rename commands to its site (the shell view)?
  53   **Fix browser to implement IProfferService and hold onto brand band correctly - this will allow animations.
  54
  55   **Route View->Toolbars commands to internet toolbar
  56   **Handle travel log items in View->Go
  57   **Fix ShowBrowserBar to pass correct size on when bar is shown
  58 ****Fix SetBorderSpaceDW to cascade resize to subsequent bars
  59 ****Make ShowToolbar check if bar is already created before creating it again
  60 ****Shell should fill in the list of explorer bars in the View submenus
  61   **Add folder menu in the file menu
  62   **Fix CShellBrowser::GetBorderDW to compute available size correctly
  63   **When a new bar is shown, re-fire the navigate event. This makes the explorer band select the correct folder
  64   **Implement support for refresh. Forward refresh to explorer bar (refresh on toolbar and in menu is dispatched different)
  65     Make folders toolbar item update state appropriately
  66     Read list of bands from registry on launch
  67     Read list of bars from registry on launch
  68     If the folders or search bars don't exist, disable the toolbar buttons
  69     If the favorites or history bars don't exist, disable the toolbar butons
  70     Fix Apply to all Folders in Folder Options
  71     Implement close command
  72     Add explorer band context menu to file menu
  73     Add code to allow restore of internet toolbar from registry
  74     Fix code that calls FireNavigateComplete to pass the correct new path
  75
  76     What are the other command ids for QueryStatus/FireCommandStateChange?
  77
  78     Add handler for cabinet settings change
  79     Add handler for system metrics change (renegotiate border space?)
  80     Add handler for theme change and forward to contained windows
  81
  82     When folders are shown, the status bar text should change
  83     Add code to save/restore shell view settings
  84     Implement tabbing between frames
  85     Fix handling of focus everywhere
  86     Most keyboard shortcuts don't work, such as F2 for rename, F5 for refresh (see list in "explorer keyboard shortcuts")
  87
  88     The status bar doesn't show help text for items owned by frame during menu tracking
  89     Stub out frame command handlers
  90     "Arrange icons by" group is not checked properly
  91
  92     When folders are hidden, icon is the same as the current shell object being displayed. When folders are shown,
  93         the icon is always an open folder with magnifying glass
  94     Fix bars to calculate height correctly
  95     Hookup policies for everything...
  96     Investigate toolbar message WM_USER+93
  97     Investigate toolbar message WM_USER+100 (Adds extra padding between parts of buttons with BTNS_DROPDOWN | BTNS_SHOWTEXT style
  98
  99     Vertical Explorer Bar               CATID_InfoBand
 100     Horizontal Explorer Bar             CATID_CommBand
 101     Desk Band                                   CATID_DeskBand
 102
 103     cache of bars
 104     HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Discardable\PostSetup\Component Categories\{00021493-0000-0000-C000-000000000046}\Enum
 105     HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Discardable\PostSetup\Component Categories\{00021494-0000-0000-C000-000000000046}\Enum
 106
 107     create key here with CLSID of bar to register tool band
 108     HKEY_LOCAL_MACHINE\Software\Microsoft\Internet Explorer\Toolbar
 109
 110 */
 111
 112 #ifndef __GNUC__
 113 #pragma comment(linker, \
 114     "\"/manifestdependency:type='Win32' "\
 115     "name='Microsoft.Windows.Common-Controls' "\
 116     "version='6.0.0.0' "\
 117     "processorArchitecture='*' "\
 118     "publicKeyToken='6595b64144ccf1df' "\
 119     "language='*'\"")
 120 #endif // __GNUC__
 121
 122 struct categoryCacheHeader
 123 {
 124     long                dwSize;         // size of header only
 125     long                version;        // currently 1
 126     SYSTEMTIME          writeTime;      // time we were written to registry
 127     long                classCount;     // number of classes following
 128 };
 129
 130 static const unsigned int                   folderOptionsPageCountMax = 20;
 131 static const long                           BTP_UPDATE_CUR_HISTORY = 1;
 132 static const long                           BTP_UPDATE_NEXT_HISTORY = 2;
 133
 134 BOOL                                        createNewStuff = false;
 135
 136
 137 // this class is private to browseui.dll and is not registered externally?
 138 //DEFINE_GUID(CLSID_ShellFldSetExt, 0x6D5313C0, 0x8C62, 0x11D1, 0xB2, 0xCD, 0x00, 0x60, 0x97, 0xDF, 0x8C, 0x11);
 139
 140
 141 extern HRESULT CreateTravelLog(REFIID riid, void **ppv);
 142 extern HRESULT CreateBaseBar(REFIID riid, void **ppv);
 143 extern HRESULT CreateBaseBarSite(REFIID riid, void **ppv);
 144
 145 // temporary
 146 extern HRESULT CreateInternetToolbar(REFIID riid, void **ppv);
 147
 148
 149 HMENU SHGetMenuFromID(HMENU topMenu, int theID)
 150 {
 151     MENUITEMINFO                            menuItemInfo;
 152
 153     menuItemInfo.cbSize = sizeof(menuItemInfo);
 154     menuItemInfo.fMask = MIIM_SUBMENU;
 155     if (!GetMenuItemInfo(topMenu, theID, FALSE, &menuItemInfo))
 156         return NULL;
 157     return menuItemInfo.hSubMenu;
 158 }
 159
 160 void SHCheckMenuItem(HMENU theMenu, int theID, BOOL checked)
 161 {
 162     MENUITEMINFO                            menuItemInfo;
 163
 164     menuItemInfo.cbSize = sizeof(menuItemInfo);
 165     menuItemInfo.fMask = MIIM_STATE;
 166     if (GetMenuItemInfo(theMenu, theID, FALSE, &menuItemInfo))
 167     {
 168         if (checked)
 169             menuItemInfo.fState |= MF_CHECKED;
 170         else
 171             menuItemInfo.fState &= ~MF_CHECKED;
 172         SetMenuItemInfo(theMenu, theID, FALSE, &menuItemInfo);
 173     }
 174 }
 175
 176 void DeleteMenuItems(HMENU theMenu, unsigned int firstIDToDelete, unsigned int lastIDToDelete)
 177 {
 178     MENUITEMINFO                            menuItemInfo;
 179     int                                     menuItemCount;
 180     int                                     curIndex;
 181
 182     menuItemCount = GetMenuItemCount(theMenu);
 183     curIndex = 0;
 184     while (curIndex < menuItemCount)
 185     {
 186         menuItemInfo.cbSize = sizeof(menuItemInfo);
 187         menuItemInfo.fMask = MIIM_ID;
 188         if (GetMenuItemInfo(theMenu, curIndex, TRUE, &menuItemInfo) &&
 189             menuItemInfo.wID >= firstIDToDelete && menuItemInfo.wID <= lastIDToDelete)
 190         {
 191             DeleteMenu(theMenu, curIndex, MF_BYPOSITION);
 192             menuItemCount--;
 193         }
 194         else
 195             curIndex++;
 196     }
 197 }
 198
 199 HRESULT WINAPI SHBindToFolder(LPCITEMIDLIST path, IShellFolder **newFolder)
 200 {
 201     CComPtr<IShellFolder>                   desktop;
 202
 203     HRESULT hr = ::SHGetDesktopFolder(&desktop);
 204     if (FAILED(hr))
 205         return E_FAIL;
 206     if (path == NULL || path->mkid.cb == 0)
 207     {
 208         *newFolder = desktop;
 209         desktop.p->AddRef ();
 210         return S_OK;
 211     }
 212     return desktop->BindToObject (path, NULL, IID_PPV_ARG(IShellFolder, newFolder));
 213 }
 214
 215 static const TCHAR szCabinetWndClass[] = TEXT("CabinetWClassX");
 216 static const TCHAR szExploreWndClass[] = TEXT("ExploreWClassX");
 217
 218 class CDockManager;
 219 class CShellBrowser;
 220
 221 class CToolbarProxy :
 222     public CWindowImpl<CToolbarProxy, CWindow, CControlWinTraits>
 223 {
 224 private:
 225     CComPtr<IExplorerToolbar>               fExplorerToolbar;
 226 public:
 227     void Initialize(HWND parent, IUnknown *explorerToolbar);
 228
 229 private:
 230
 231     // message handlers
 232     LRESULT OnAddBitmap(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 233     LRESULT OnForwardMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 234
 235     BEGIN_MSG_MAP(CToolbarProxy)
 236         MESSAGE_HANDLER(TB_ADDBITMAP, OnAddBitmap)
 237         MESSAGE_RANGE_HANDLER(WM_USER, 0x7fff, OnForwardMessage)
 238     END_MSG_MAP()
 239 };
 240
 241 void CToolbarProxy::Initialize(HWND parent, IUnknown *explorerToolbar)
 242 {
 243     HWND                                    myWindow;
 244     HRESULT                                 hResult;
 245
 246     myWindow = SHCreateWorkerWindowW(0, parent, 0, WS_CHILD, NULL, 0);
 247     if (myWindow != NULL)
 248     {
 249         SubclassWindow(myWindow);
 250         SetWindowPos(NULL, -32000, -32000, 0, 0, SWP_NOOWNERZORDER | SWP_NOZORDER);
 251         hResult = explorerToolbar->QueryInterface(
 252             IID_PPV_ARG(IExplorerToolbar, &fExplorerToolbar));
 253     }
 254 }
 255
 256 LRESULT CToolbarProxy::OnAddBitmap(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
 257 {
 258     long int                                result;
 259     HRESULT                                 hResult;
 260
 261     result = 0;
 262     if (fExplorerToolbar.p != NULL)
 263     {
 264         hResult = fExplorerToolbar->AddBitmap(&CGID_ShellBrowser, 1, (long)wParam,
 265             reinterpret_cast<TBADDBITMAP *>(lParam), &result, RGB(192, 192, 192));
 266         hResult = fExplorerToolbar->AddBitmap(&CGID_ShellBrowser, 2, (long)wParam,
 267             reinterpret_cast<TBADDBITMAP *>(lParam), &result, RGB(192, 192, 192));
 268     }
 269     return result;
 270 }
 271
 272 LRESULT CToolbarProxy::OnForwardMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
 273 {
 274     LRESULT                                 result;
 275     HRESULT                                 hResult;
 276
 277     result = 0;
 278     if (fExplorerToolbar.p != NULL)
 279         hResult = fExplorerToolbar->SendToolbarMsg(&CGID_ShellBrowser, uMsg, wParam, lParam, &result);
 280     return result;
 281 }
 282
 283 /*
 284 Switch to a new bar when it receives an Exec(CGID_IDeskBand, 1, 1, vaIn, NULL);
 285     where vaIn will be a VT_UNKNOWN with the new bar. It also sends a RB_SHOWBAND to the
 286     rebar
 287 */
 288
 289 class CShellBrowser :
 290     public CWindowImpl<CShellBrowser, CWindow, CFrameWinTraits>,
 291     public CComObjectRootEx<CComMultiThreadModelNoCS>,
 292     public IShellBrowser,
 293     public IDropTarget,
 294     public IServiceProvider,
 295     public IProfferServiceImpl<CShellBrowser>,
 296     public IShellBrowserService,
 297     public IWebBrowser2,
 298     public ITravelLogClient,
 299     public IPersistHistory,
 300     public IDockingWindowSite,
 301     public IOleCommandTarget,
 302     public IBrowserService2,
 303     public IConnectionPointContainerImpl<CShellBrowser>,
 304     public MyIConnectionPointImpl<CShellBrowser, &DIID_DWebBrowserEvents2>,
 305     public MyIConnectionPointImpl<CShellBrowser, &DIID_DWebBrowserEvents>
 306 {
 307 private:
 308     class barInfo
 309     {
 310     public:
 311         RECT                                borderSpace;
 312         CComPtr<IUnknown>                   clientBar;
 313         HWND                                hwnd;
 314     };
 315     static const int                        BIInternetToolbar = 0;
 316     static const int                        BIVerticalBaseBar = 1;
 317     static const int                        BIHorizontalBaseBar = 2;
 318
 319     HWND                                    fCurrentShellViewWindow;    // our currently hosted shell view window
 320     CComPtr<IShellFolder>                   fCurrentShellFolder;        //
 321     CComPtr<IShellView>                     fCurrentShellView;          //
 322     LPITEMIDLIST                            fCurrentDirectoryPIDL;      //
 323     HWND                                    fStatusBar;
 324     bool                                    fStatusBarVisible;
 325     CToolbarProxy                           fToolbarProxy;
 326     barInfo                                 fClientBars[3];
 327     CComPtr<ITravelLog>                     fTravelLog;
 328     HMENU                                   fCurrentMenuBar;
 329     CABINETSTATE                            fCabinetState;
 330     // The next three fields support persisted history for shell views.
 331     // They do not need to be reference counted.
 332     IOleObject                              *fHistoryObject;
 333     IStream                                 *fHistoryStream;
 334     IBindCtx                                *fHistoryBindContext;
 335 public:
 336 #if 0
 337     ULONG InternalAddRef()
 338     {
 339         OutputDebugString(_T("AddRef\n"));
 340         return CComObjectRootEx<CComMultiThreadModelNoCS>::InternalAddRef();
 341     }
 342     ULONG InternalRelease()
 343     {
 344         OutputDebugString(_T("Release\n"));
 345         return CComObjectRootEx<CComMultiThreadModelNoCS>::InternalRelease();
 346     }
 347 #endif
 348
 349     CShellBrowser();
 350     ~CShellBrowser();
 351     HRESULT Initialize(LPITEMIDLIST pidl, long b, long c, long d);
 352 public:
 353     HRESULT BrowseToPIDL(LPCITEMIDLIST pidl, long flags);
 354     HRESULT BrowseToPath(IShellFolder *newShellFolder, LPCITEMIDLIST absolutePIDL,
 355         FOLDERSETTINGS *folderSettings, long flags);
 356     HRESULT GetMenuBand(REFIID riid, void **shellMenu);
 357     HRESULT GetBaseBar(bool vertical, IUnknown **theBaseBar);
 358     HRESULT ShowBand(const CLSID &classID, bool vertical);
 359     HRESULT NavigateToParent();
 360     HRESULT DoFolderOptions();
 361     static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 362     void RepositionBars();
 363     virtual WNDPROC GetWindowProc()
 364     {
 365         return WindowProc;
 366     }
 367     HRESULT FireEvent(DISPID dispIdMember, int argCount, VARIANT *arguments);
 368     HRESULT FireNavigateComplete(const wchar_t *newDirectory);
 369     HRESULT FireCommandStateChange(bool newState, int commandID);
 370     HRESULT FireCommandStateChangeAll();
 371     HRESULT UpdateForwardBackState();
 372     void UpdateGotoMenu(HMENU theMenu);
 373     void UpdateViewMenu(HMENU theMenu);
 374
 375 /*    // *** IDockingWindowFrame methods ***
 376     virtual HRESULT STDMETHODCALLTYPE AddToolbar(IUnknown *punkSrc, LPCWSTR pwszItem, DWORD dwAddFlags);
 377     virtual HRESULT STDMETHODCALLTYPE RemoveToolbar(IUnknown *punkSrc, DWORD dwRemoveFlags);
 378     virtual HRESULT STDMETHODCALLTYPE FindToolbar(LPCWSTR pwszItem, REFIID riid, void **ppv);
 379     */
 380
 381     // *** IDockingWindowSite methods ***
 382     virtual HRESULT STDMETHODCALLTYPE GetBorderDW(IUnknown* punkObj, LPRECT prcBorder);
 383     virtual HRESULT STDMETHODCALLTYPE RequestBorderSpaceDW(IUnknown* punkObj, LPCBORDERWIDTHS pbw);
 384     virtual HRESULT STDMETHODCALLTYPE SetBorderSpaceDW(IUnknown* punkObj, LPCBORDERWIDTHS pbw);
 385
 386     // *** IOleCommandTarget methods ***
 387     virtual HRESULT STDMETHODCALLTYPE QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds,
 388         OLECMD prgCmds[  ], OLECMDTEXT *pCmdText);
 389     virtual HRESULT STDMETHODCALLTYPE Exec(const GUID *pguidCmdGroup, DWORD nCmdID,
 390         DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut);
 391
 392     // *** IOleWindow methods ***
 393     virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND *lphwnd);
 394     virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode);
 395
 396     // *** IShellBrowser methods ***
 397     virtual HRESULT STDMETHODCALLTYPE InsertMenusSB(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths);
 398     virtual HRESULT STDMETHODCALLTYPE SetMenuSB(HMENU hmenuShared, HOLEMENU holemenuRes, HWND hwndActiveObject);
 399     virtual HRESULT STDMETHODCALLTYPE RemoveMenusSB(HMENU hmenuShared);
 400     virtual HRESULT STDMETHODCALLTYPE SetStatusTextSB(LPCOLESTR pszStatusText);
 401     virtual HRESULT STDMETHODCALLTYPE EnableModelessSB(BOOL fEnable);
 402     virtual HRESULT STDMETHODCALLTYPE TranslateAcceleratorSB(MSG *pmsg, WORD wID);
 403     virtual HRESULT STDMETHODCALLTYPE BrowseObject(LPCITEMIDLIST pidl, UINT wFlags);
 404     virtual HRESULT STDMETHODCALLTYPE GetViewStateStream(DWORD grfMode, IStream **ppStrm);
 405     virtual HRESULT STDMETHODCALLTYPE GetControlWindow(UINT id, HWND *lphwnd);
 406     virtual HRESULT STDMETHODCALLTYPE SendControlMsg(UINT id, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *pret);
 407     virtual HRESULT STDMETHODCALLTYPE QueryActiveShellView(IShellView **ppshv);
 408     virtual HRESULT STDMETHODCALLTYPE OnViewWindowActive(IShellView *ppshv);
 409     virtual HRESULT STDMETHODCALLTYPE SetToolbarItems(LPTBBUTTON lpButtons, UINT nButtons, UINT uFlags);
 410
 411     // *** IDropTarget methods ***
 412     virtual HRESULT STDMETHODCALLTYPE DragEnter(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
 413     virtual HRESULT STDMETHODCALLTYPE DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
 414     virtual HRESULT STDMETHODCALLTYPE DragLeave();
 415     virtual HRESULT STDMETHODCALLTYPE Drop(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect);
 416
 417     // *** IServiceProvider methods ***
 418     virtual HRESULT STDMETHODCALLTYPE QueryService(REFGUID guidService, REFIID riid, void **ppvObject);
 419
 420     // *** IShellBowserService methods ***
 421     virtual HRESULT STDMETHODCALLTYPE GetPropertyBag(long flags, REFIID riid, void **ppvObject);
 422
 423     // *** IDispatch methods ***
 424     virtual HRESULT STDMETHODCALLTYPE GetTypeInfoCount(UINT *pctinfo);
 425     virtual HRESULT STDMETHODCALLTYPE GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo);
 426     virtual HRESULT STDMETHODCALLTYPE GetIDsOfNames(
 427         REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId);
 428     virtual HRESULT STDMETHODCALLTYPE Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
 429         DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr);
 430
 431     // *** IBrowserService methods ***
 432     virtual HRESULT STDMETHODCALLTYPE GetParentSite(IOleInPlaceSite **ppipsite);
 433     virtual HRESULT STDMETHODCALLTYPE SetTitle(IShellView *psv, LPCWSTR pszName);
 434     virtual HRESULT STDMETHODCALLTYPE GetTitle(IShellView *psv, LPWSTR pszName, DWORD cchName);
 435     virtual HRESULT STDMETHODCALLTYPE GetOleObject(IOleObject **ppobjv);
 436     virtual HRESULT STDMETHODCALLTYPE GetTravelLog(ITravelLog **pptl);
 437     virtual HRESULT STDMETHODCALLTYPE ShowControlWindow(UINT id, BOOL fShow);
 438     virtual HRESULT STDMETHODCALLTYPE IsControlWindowShown(UINT id, BOOL *pfShown);
 439     virtual HRESULT STDMETHODCALLTYPE IEGetDisplayName(LPCITEMIDLIST pidl, LPWSTR pwszName, UINT uFlags);
 440     virtual HRESULT STDMETHODCALLTYPE IEParseDisplayName(UINT uiCP, LPCWSTR pwszPath, LPITEMIDLIST *ppidlOut);
 441     virtual HRESULT STDMETHODCALLTYPE DisplayParseError(HRESULT hres, LPCWSTR pwszPath);
 442     virtual HRESULT STDMETHODCALLTYPE NavigateToPidl(LPCITEMIDLIST pidl, DWORD grfHLNF);
 443     virtual HRESULT STDMETHODCALLTYPE SetNavigateState(BNSTATE bnstate);
 444     virtual HRESULT STDMETHODCALLTYPE GetNavigateState(BNSTATE *pbnstate);
 445     virtual HRESULT STDMETHODCALLTYPE NotifyRedirect(IShellView *psv, LPCITEMIDLIST pidl, BOOL *pfDidBrowse);
 446     virtual HRESULT STDMETHODCALLTYPE UpdateWindowList();
 447     virtual HRESULT STDMETHODCALLTYPE UpdateBackForwardState();
 448     virtual HRESULT STDMETHODCALLTYPE SetFlags(DWORD dwFlags, DWORD dwFlagMask);
 449     virtual HRESULT STDMETHODCALLTYPE GetFlags(DWORD *pdwFlags);
 450     virtual HRESULT STDMETHODCALLTYPE CanNavigateNow( void);
 451     virtual HRESULT STDMETHODCALLTYPE GetPidl(LPITEMIDLIST *ppidl);
 452     virtual HRESULT STDMETHODCALLTYPE SetReferrer(LPCITEMIDLIST pidl);
 453     virtual DWORD STDMETHODCALLTYPE GetBrowserIndex();
 454     virtual HRESULT STDMETHODCALLTYPE GetBrowserByIndex(DWORD dwID, IUnknown **ppunk);
 455     virtual HRESULT STDMETHODCALLTYPE GetHistoryObject(IOleObject **ppole, IStream **pstm, IBindCtx **ppbc);
 456     virtual HRESULT STDMETHODCALLTYPE SetHistoryObject(IOleObject *pole, BOOL fIsLocalAnchor);
 457     virtual HRESULT STDMETHODCALLTYPE CacheOLEServer(IOleObject *pole);
 458     virtual HRESULT STDMETHODCALLTYPE GetSetCodePage(VARIANT *pvarIn, VARIANT *pvarOut);
 459     virtual HRESULT STDMETHODCALLTYPE OnHttpEquiv(IShellView *psv, BOOL fDone, VARIANT *pvarargIn, VARIANT *pvarargOut);
 460     virtual HRESULT STDMETHODCALLTYPE GetPalette(HPALETTE *hpal);
 461     virtual HRESULT STDMETHODCALLTYPE RegisterWindow(BOOL fForceRegister, int swc);
 462
 463     // *** IBrowserService2 methods ***
 464     virtual LRESULT STDMETHODCALLTYPE WndProcBS(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 465     virtual HRESULT STDMETHODCALLTYPE SetAsDefFolderSettings();
 466     virtual HRESULT STDMETHODCALLTYPE GetViewRect(RECT *prc);
 467     virtual HRESULT STDMETHODCALLTYPE OnSize(WPARAM wParam);
 468     virtual HRESULT STDMETHODCALLTYPE OnCreate(struct tagCREATESTRUCTW *pcs);
 469     virtual LRESULT STDMETHODCALLTYPE OnCommand(WPARAM wParam, LPARAM lParam);
 470     virtual HRESULT STDMETHODCALLTYPE OnDestroy();
 471     virtual LRESULT STDMETHODCALLTYPE OnNotify(struct tagNMHDR *pnm);
 472     virtual HRESULT STDMETHODCALLTYPE OnSetFocus();
 473     virtual HRESULT STDMETHODCALLTYPE OnFrameWindowActivateBS(BOOL fActive);
 474     virtual HRESULT STDMETHODCALLTYPE ReleaseShellView();
 475     virtual HRESULT STDMETHODCALLTYPE ActivatePendingView();
 476     virtual HRESULT STDMETHODCALLTYPE CreateViewWindow(IShellView *psvNew, IShellView *psvOld, LPRECT prcView, HWND *phwnd);
 477     virtual HRESULT STDMETHODCALLTYPE CreateBrowserPropSheetExt(REFIID riid, void **ppv);
 478     virtual HRESULT STDMETHODCALLTYPE GetViewWindow(HWND *phwndView);
 479     virtual HRESULT STDMETHODCALLTYPE GetBaseBrowserData(LPCBASEBROWSERDATA *pbbd);
 480     virtual LPBASEBROWSERDATA STDMETHODCALLTYPE PutBaseBrowserData( void);
 481     virtual HRESULT STDMETHODCALLTYPE InitializeTravelLog(ITravelLog *ptl, DWORD dw);
 482     virtual HRESULT STDMETHODCALLTYPE SetTopBrowser();
 483     virtual HRESULT STDMETHODCALLTYPE Offline(int iCmd);
 484     virtual HRESULT STDMETHODCALLTYPE AllowViewResize(BOOL f);
 485     virtual HRESULT STDMETHODCALLTYPE SetActivateState(UINT u);
 486     virtual HRESULT STDMETHODCALLTYPE UpdateSecureLockIcon(int eSecureLock);
 487     virtual HRESULT STDMETHODCALLTYPE InitializeDownloadManager();
 488     virtual HRESULT STDMETHODCALLTYPE InitializeTransitionSite();
 489     virtual HRESULT STDMETHODCALLTYPE _Initialize(HWND hwnd, IUnknown *pauto);
 490     virtual HRESULT STDMETHODCALLTYPE _CancelPendingNavigationAsync( void);
 491     virtual HRESULT STDMETHODCALLTYPE _CancelPendingView();
 492     virtual HRESULT STDMETHODCALLTYPE _MaySaveChanges();
 493     virtual HRESULT STDMETHODCALLTYPE _PauseOrResumeView(BOOL fPaused);
 494     virtual HRESULT STDMETHODCALLTYPE _DisableModeless();
 495     virtual HRESULT STDMETHODCALLTYPE _NavigateToPidl(LPCITEMIDLIST pidl, DWORD grfHLNF, DWORD dwFlags);
 496     virtual HRESULT STDMETHODCALLTYPE _TryShell2Rename(IShellView *psv, LPCITEMIDLIST pidlNew);
 497     virtual HRESULT STDMETHODCALLTYPE _SwitchActivationNow();
 498     virtual HRESULT STDMETHODCALLTYPE _ExecChildren(IUnknown *punkBar, BOOL fBroadcast, const GUID *pguidCmdGroup,
 499         DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut);
 500     virtual HRESULT STDMETHODCALLTYPE _SendChildren(
 501         HWND hwndBar, BOOL fBroadcast, UINT uMsg, WPARAM wParam, LPARAM lParam);
 502     virtual HRESULT STDMETHODCALLTYPE GetFolderSetData(struct tagFolderSetData *pfsd);
 503     virtual HRESULT STDMETHODCALLTYPE _OnFocusChange(UINT itb);
 504     virtual HRESULT STDMETHODCALLTYPE v_ShowHideChildWindows(BOOL fChildOnly);
 505     virtual UINT STDMETHODCALLTYPE _get_itbLastFocus();
 506     virtual HRESULT STDMETHODCALLTYPE _put_itbLastFocus(UINT itbLastFocus);
 507     virtual HRESULT STDMETHODCALLTYPE _UIActivateView(UINT uState);
 508     virtual HRESULT STDMETHODCALLTYPE _GetViewBorderRect(RECT *prc);
 509     virtual HRESULT STDMETHODCALLTYPE _UpdateViewRectSize();
 510     virtual HRESULT STDMETHODCALLTYPE _ResizeNextBorder(UINT itb);
 511     virtual HRESULT STDMETHODCALLTYPE _ResizeView();
 512     virtual HRESULT STDMETHODCALLTYPE _GetEffectiveClientArea(LPRECT lprectBorder, HMONITOR hmon);
 513     virtual IStream *STDMETHODCALLTYPE v_GetViewStream(LPCITEMIDLIST pidl, DWORD grfMode, LPCWSTR pwszName);
 514     virtual LRESULT STDMETHODCALLTYPE ForwardViewMsg(UINT uMsg, WPARAM wParam, LPARAM lParam);
 515     virtual HRESULT STDMETHODCALLTYPE SetAcceleratorMenu(HACCEL hacc);
 516     virtual int STDMETHODCALLTYPE _GetToolbarCount();
 517     virtual LPTOOLBARITEM STDMETHODCALLTYPE _GetToolbarItem(int itb);
 518     virtual HRESULT STDMETHODCALLTYPE _SaveToolbars(IStream *pstm);
 519     virtual HRESULT STDMETHODCALLTYPE _LoadToolbars(IStream *pstm);
 520     virtual HRESULT STDMETHODCALLTYPE _CloseAndReleaseToolbars(BOOL fClose);
 521     virtual HRESULT STDMETHODCALLTYPE v_MayGetNextToolbarFocus(LPMSG lpMsg, UINT itbNext,
 522         int citb, LPTOOLBARITEM *pptbi, HWND *phwnd);
 523     virtual HRESULT STDMETHODCALLTYPE _ResizeNextBorderHelper(UINT itb, BOOL bUseHmonitor);
 524     virtual UINT STDMETHODCALLTYPE _FindTBar(IUnknown *punkSrc);
 525     virtual HRESULT STDMETHODCALLTYPE _SetFocus(LPTOOLBARITEM ptbi, HWND hwnd, LPMSG lpMsg);
 526     virtual HRESULT STDMETHODCALLTYPE v_MayTranslateAccelerator(MSG *pmsg);
 527     virtual HRESULT STDMETHODCALLTYPE _GetBorderDWHelper(IUnknown *punkSrc, LPRECT lprectBorder, BOOL bUseHmonitor);
 528     virtual HRESULT STDMETHODCALLTYPE v_CheckZoneCrossing(LPCITEMIDLIST pidl);
 529
 530     // *** IWebBrowser methods ***
 531     virtual HRESULT STDMETHODCALLTYPE GoBack();
 532     virtual HRESULT STDMETHODCALLTYPE GoForward();
 533     virtual HRESULT STDMETHODCALLTYPE GoHome();
 534     virtual HRESULT STDMETHODCALLTYPE GoSearch();
 535     virtual HRESULT STDMETHODCALLTYPE Navigate(BSTR URL, VARIANT *Flags, VARIANT *TargetFrameName,
 536         VARIANT *PostData, VARIANT *Headers);
 537     virtual HRESULT STDMETHODCALLTYPE Refresh();
 538     virtual HRESULT STDMETHODCALLTYPE Refresh2(VARIANT *Level);
 539     virtual HRESULT STDMETHODCALLTYPE Stop();
 540     virtual HRESULT STDMETHODCALLTYPE get_Application(IDispatch **ppDisp);
 541     virtual HRESULT STDMETHODCALLTYPE get_Parent(IDispatch **ppDisp);
 542     virtual HRESULT STDMETHODCALLTYPE get_Container(IDispatch **ppDisp);
 543     virtual HRESULT STDMETHODCALLTYPE get_Document(IDispatch **ppDisp);
 544     virtual HRESULT STDMETHODCALLTYPE get_TopLevelContainer(VARIANT_BOOL *pBool);
 545     virtual HRESULT STDMETHODCALLTYPE get_Type(BSTR *Type);
 546     virtual HRESULT STDMETHODCALLTYPE get_Left(long *pl);
 547     virtual HRESULT STDMETHODCALLTYPE put_Left(long Left);
 548     virtual HRESULT STDMETHODCALLTYPE get_Top(long *pl);
 549     virtual HRESULT STDMETHODCALLTYPE put_Top(long Top);
 550     virtual HRESULT STDMETHODCALLTYPE get_Width(long *pl);
 551     virtual HRESULT STDMETHODCALLTYPE put_Width(long Width);
 552     virtual HRESULT STDMETHODCALLTYPE get_Height(long *pl);
 553     virtual HRESULT STDMETHODCALLTYPE put_Height(long Height);
 554     virtual HRESULT STDMETHODCALLTYPE get_LocationName(BSTR *LocationName);
 555     virtual HRESULT STDMETHODCALLTYPE get_LocationURL(BSTR *LocationURL);
 556     virtual HRESULT STDMETHODCALLTYPE get_Busy(VARIANT_BOOL *pBool);
 557
 558     // *** IWebBrowserApp methods ***
 559     virtual HRESULT STDMETHODCALLTYPE Quit();
 560     virtual HRESULT STDMETHODCALLTYPE ClientToWindow(int *pcx, int *pcy);
 561     virtual HRESULT STDMETHODCALLTYPE PutProperty(BSTR Property, VARIANT vtValue);
 562     virtual HRESULT STDMETHODCALLTYPE GetProperty(BSTR Property, VARIANT *pvtValue);
 563     virtual HRESULT STDMETHODCALLTYPE get_Name(BSTR *Name);
 564     virtual HRESULT STDMETHODCALLTYPE get_HWND(SHANDLE_PTR *pHWND);
 565     virtual HRESULT STDMETHODCALLTYPE get_FullName(BSTR *FullName);
 566     virtual HRESULT STDMETHODCALLTYPE get_Path(BSTR *Path);
 567     virtual HRESULT STDMETHODCALLTYPE get_Visible(VARIANT_BOOL *pBool);
 568     virtual HRESULT STDMETHODCALLTYPE put_Visible(VARIANT_BOOL Value);
 569     virtual HRESULT STDMETHODCALLTYPE get_StatusBar(VARIANT_BOOL *pBool);
 570     virtual HRESULT STDMETHODCALLTYPE put_StatusBar(VARIANT_BOOL Value);
 571     virtual HRESULT STDMETHODCALLTYPE get_StatusText(BSTR *StatusText);
 572     virtual HRESULT STDMETHODCALLTYPE put_StatusText(BSTR StatusText);
 573     virtual HRESULT STDMETHODCALLTYPE get_ToolBar(int *Value);
 574     virtual HRESULT STDMETHODCALLTYPE put_ToolBar(int Value);
 575     virtual HRESULT STDMETHODCALLTYPE get_MenuBar(VARIANT_BOOL *Value);
 576     virtual HRESULT STDMETHODCALLTYPE put_MenuBar(VARIANT_BOOL Value);
 577     virtual HRESULT STDMETHODCALLTYPE get_FullScreen(VARIANT_BOOL *pbFullScreen);
 578     virtual HRESULT STDMETHODCALLTYPE put_FullScreen(VARIANT_BOOL bFullScreen);
 579
 580     // *** IWebBrowser2 methods ***
 581     virtual HRESULT STDMETHODCALLTYPE Navigate2(VARIANT *URL, VARIANT *Flags, VARIANT *TargetFrameName,
 582         VARIANT *PostData, VARIANT *Headers);
 583     virtual HRESULT STDMETHODCALLTYPE QueryStatusWB(OLECMDID cmdID, OLECMDF *pcmdf);
 584     virtual HRESULT STDMETHODCALLTYPE ExecWB(OLECMDID cmdID, OLECMDEXECOPT cmdexecopt,
 585         VARIANT *pvaIn, VARIANT *pvaOut);
 586     virtual HRESULT STDMETHODCALLTYPE ShowBrowserBar(VARIANT *pvaClsid, VARIANT *pvarShow, VARIANT *pvarSize);
 587     virtual HRESULT STDMETHODCALLTYPE get_ReadyState(READYSTATE *plReadyState);
 588     virtual HRESULT STDMETHODCALLTYPE get_Offline(VARIANT_BOOL *pbOffline);
 589     virtual HRESULT STDMETHODCALLTYPE put_Offline(VARIANT_BOOL bOffline);
 590     virtual HRESULT STDMETHODCALLTYPE get_Silent(VARIANT_BOOL *pbSilent);
 591     virtual HRESULT STDMETHODCALLTYPE put_Silent(VARIANT_BOOL bSilent);
 592     virtual HRESULT STDMETHODCALLTYPE get_RegisterAsBrowser(VARIANT_BOOL *pbRegister);
 593     virtual HRESULT STDMETHODCALLTYPE put_RegisterAsBrowser(VARIANT_BOOL bRegister);
 594     virtual HRESULT STDMETHODCALLTYPE get_RegisterAsDropTarget(VARIANT_BOOL *pbRegister);
 595     virtual HRESULT STDMETHODCALLTYPE put_RegisterAsDropTarget(VARIANT_BOOL bRegister);
 596     virtual HRESULT STDMETHODCALLTYPE get_TheaterMode(VARIANT_BOOL *pbRegister);
 597     virtual HRESULT STDMETHODCALLTYPE put_TheaterMode(VARIANT_BOOL bRegister);
 598     virtual HRESULT STDMETHODCALLTYPE get_AddressBar(VARIANT_BOOL *Value);
 599     virtual HRESULT STDMETHODCALLTYPE put_AddressBar(VARIANT_BOOL Value);
 600     virtual HRESULT STDMETHODCALLTYPE get_Resizable(VARIANT_BOOL *Value);
 601     virtual HRESULT STDMETHODCALLTYPE put_Resizable(VARIANT_BOOL Value);
 602
 603     // *** ITravelLogClient methods ***
 604     virtual HRESULT STDMETHODCALLTYPE FindWindowByIndex(DWORD dwID, IUnknown **ppunk);
 605     virtual HRESULT STDMETHODCALLTYPE GetWindowData(IStream *pStream, LPWINDOWDATA pWinData);
 606     virtual HRESULT STDMETHODCALLTYPE LoadHistoryPosition(LPWSTR pszUrlLocation, DWORD dwPosition);
 607
 608     // *** IPersist methods ***
 609     virtual HRESULT STDMETHODCALLTYPE GetClassID(CLSID *pClassID);
 610
 611     // *** IPersistHistory methods ***
 612     virtual HRESULT STDMETHODCALLTYPE LoadHistory(IStream *pStream, IBindCtx *pbc);
 613     virtual HRESULT STDMETHODCALLTYPE SaveHistory(IStream *pStream);
 614     virtual HRESULT STDMETHODCALLTYPE SetPositionCookie(DWORD dwPositioncookie);
 615     virtual HRESULT STDMETHODCALLTYPE GetPositionCookie(DWORD *pdwPositioncookie);
 616
 617     // message handlers
 618     LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 619     LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 620     LRESULT OnInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 621     LRESULT RelayMsgToShellView(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 622     LRESULT OnClose(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 623     LRESULT OnFolderOptions(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 624     LRESULT OnMapNetworkDrive(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 625     LRESULT OnDisconnectNetworkDrive(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 626     LRESULT OnAboutReactOS(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 627     LRESULT OnGoBack(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 628     LRESULT OnGoForward(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 629     LRESULT OnGoUpLevel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 630     LRESULT OnGoHome(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 631     LRESULT OnIsThisLegal(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 632     LRESULT OnToggleStatusBarVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 633     LRESULT OnToggleToolbarLock(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 634     LRESULT OnToggleToolbarBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 635     LRESULT OnToggleAddressBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 636     LRESULT OnToggleLinksBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 637     LRESULT OnToggleTextLabels(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 638     LRESULT OnToolbarCustomize(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 639     LRESULT OnGoTravel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled);
 640     LRESULT RelayCommands(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled);
 641
 642     static ATL::CWndClassInfo& GetWndClassInfo()
 643     {
 644         static ATL::CWndClassInfo wc =
 645         {
 646             { sizeof(WNDCLASSEX), CS_DBLCLKS, StartWindowProc,
 647               0, 0, NULL, LoadIcon(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(IDI_CABINET)),
 648               LoadCursor(NULL, IDC_ARROW), (HBRUSH)(COLOR_WINDOW + 1), NULL, szCabinetWndClass, NULL },
 649             NULL, NULL, IDC_ARROW, TRUE, 0, _T("")
 650         };
 651         return wc;
 652     }
 653
 654     BEGIN_MSG_MAP(CShellBrowser)
 655         MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
 656         MESSAGE_HANDLER(WM_SIZE, OnSize)
 657         MESSAGE_HANDLER(WM_INITMENUPOPUP, OnInitMenuPopup)
 658         MESSAGE_HANDLER(WM_MEASUREITEM, RelayMsgToShellView)
 659         MESSAGE_HANDLER(WM_DRAWITEM, RelayMsgToShellView)
 660         MESSAGE_HANDLER(WM_MENUSELECT, RelayMsgToShellView)
 661         COMMAND_ID_HANDLER(IDM_FILE_CLOSE, OnClose)
 662         COMMAND_ID_HANDLER(IDM_TOOLS_FOLDEROPTIONS, OnFolderOptions)
 663         COMMAND_ID_HANDLER(IDM_TOOLS_MAPNETWORKDRIVE, OnMapNetworkDrive)
 664         COMMAND_ID_HANDLER(IDM_TOOLS_DISCONNECTNETWORKDRIVE, OnDisconnectNetworkDrive)
 665         COMMAND_ID_HANDLER(IDM_HELP_ABOUT, OnAboutReactOS)
 666         COMMAND_ID_HANDLER(IDM_GOTO_BACK, OnGoBack)
 667         COMMAND_ID_HANDLER(IDM_GOTO_FORWARD, OnGoForward)
 668         COMMAND_ID_HANDLER(IDM_GOTO_UPONELEVEL, OnGoUpLevel)
 669         COMMAND_ID_HANDLER(IDM_GOTO_HOMEPAGE, OnGoHome)
 670         COMMAND_ID_HANDLER(IDM_HELP_ISTHISCOPYLEGAL, OnIsThisLegal)
 671         COMMAND_ID_HANDLER(IDM_VIEW_STATUSBAR, OnToggleStatusBarVisible)
 672         COMMAND_ID_HANDLER(IDM_TOOLBARS_LOCKTOOLBARS, OnToggleToolbarLock)
 673         COMMAND_ID_HANDLER(IDM_TOOLBARS_STANDARDBUTTONS, OnToggleToolbarBandVisible)
 674         COMMAND_ID_HANDLER(IDM_TOOLBARS_ADDRESSBAR, OnToggleAddressBandVisible)
 675         COMMAND_ID_HANDLER(IDM_TOOLBARS_LINKSBAR, OnToggleLinksBandVisible)
 676         COMMAND_ID_HANDLER(IDM_TOOLBARS_TEXTLABELS, OnToggleTextLabels)
 677         COMMAND_ID_HANDLER(IDM_TOOLBARS_CUSTOMIZE, OnToolbarCustomize)
 678         COMMAND_RANGE_HANDLER(IDM_GOTO_TRAVEL_FIRSTTARGET, IDM_GOTO_TRAVEL_LASTTARGET, OnGoTravel)
 679         MESSAGE_HANDLER(WM_COMMAND, RelayCommands)
 680     END_MSG_MAP()
 681
 682     BEGIN_CONNECTION_POINT_MAP(CShellBrowser)
 683         CONNECTION_POINT_ENTRY(DIID_DWebBrowserEvents2)
 684         CONNECTION_POINT_ENTRY(DIID_DWebBrowserEvents)
 685     END_CONNECTION_POINT_MAP()
 686
 687     BEGIN_COM_MAP(CShellBrowser)
 688         COM_INTERFACE_ENTRY_IID(IID_IDockingWindowSite, IDockingWindowSite)
 689         COM_INTERFACE_ENTRY_IID(IID_IOleCommandTarget, IOleCommandTarget)
 690         COM_INTERFACE_ENTRY2_IID(IID_IOleWindow, IOleWindow, IDockingWindowSite)
 691         COM_INTERFACE_ENTRY_IID(IID_IShellBrowser, IShellBrowser)
 692         COM_INTERFACE_ENTRY_IID(IID_IDropTarget, IDropTarget)
 693         COM_INTERFACE_ENTRY_IID(IID_IServiceProvider, IServiceProvider)
 694         COM_INTERFACE_ENTRY_IID(IID_IProfferService, IProfferService)
 695         COM_INTERFACE_ENTRY_IID(IID_IShellBrowserService, IShellBrowserService)
 696         COM_INTERFACE_ENTRY_IID(IID_IDispatch, IDispatch)
 697         COM_INTERFACE_ENTRY_IID(IID_IConnectionPointContainer, IConnectionPointContainer)
 698         COM_INTERFACE_ENTRY_IID(IID_IWebBrowser, IWebBrowser)
 699         COM_INTERFACE_ENTRY_IID(IID_IWebBrowserApp, IWebBrowserApp)
 700         COM_INTERFACE_ENTRY_IID(IID_IWebBrowser2, IWebBrowser2)
 701         COM_INTERFACE_ENTRY_IID(IID_ITravelLogClient, ITravelLogClient)
 702         COM_INTERFACE_ENTRY_IID(IID_IPersist, IPersist)
 703         COM_INTERFACE_ENTRY_IID(IID_IPersistHistory, IPersistHistory)
 704         COM_INTERFACE_ENTRY_IID(IID_IBrowserService, IBrowserService)
 705         COM_INTERFACE_ENTRY_IID(IID_IBrowserService2, IBrowserService2)
 706     END_COM_MAP()
 707 };
 708
 709 extern HRESULT CreateProgressDialog(REFIID riid, void **ppv);
 710
 711 CShellBrowser::CShellBrowser()
 712 {
 713     fCurrentShellViewWindow = NULL;
 714     fCurrentDirectoryPIDL = NULL;
 715     fStatusBar = NULL;
 716     fStatusBarVisible = true;
 717     memset(fClientBars, 0, sizeof(fClientBars));
 718     fCurrentMenuBar = NULL;
 719     fHistoryObject = NULL;
 720     fHistoryStream = NULL;
 721     fHistoryBindContext = NULL;
 722 }
 723
 724 CShellBrowser::~CShellBrowser()
 725 {
 726 }
 727
 728 HRESULT CShellBrowser::Initialize(LPITEMIDLIST pidl, long b, long c, long d)
 729 {
 730     CComPtr<IDockingWindow>                 dockingWindow;
 731     CComPtr<IStream>                        settingsStream;
 732     CComPtr<IPersistStreamInit>             persistStreamInit;
 733     CComPtr<IOleCommandTarget>              commandTarget;
 734     CComPtr<IObjectWithSite>                objectSite;
 735     HRESULT                                 hResult;
 736
 737     _AtlInitialConstruct();
 738
 739     fCabinetState.cLength = sizeof(fCabinetState);
 740     if (ReadCabinetState(&fCabinetState, sizeof(fCabinetState)) == FALSE)
 741     {
 742     }
 743
 744     // create window
 745     Create(HWND_DESKTOP);
 746     if (m_hWnd == NULL)
 747         return E_FAIL;
 748
 749 #if 0
 750     hResult = CoCreateInstance(CLSID_InternetToolbar, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IUnknown, &fClientBars[BIInternetToolbar].clientBar));
 751     if (FAILED(hResult))
 752         return hResult;
 753 #else
 754     hResult = CreateInternetToolbar(IID_PPV_ARG(IUnknown, &fClientBars[BIInternetToolbar].clientBar));
 755     if (FAILED(hResult))
 756         return hResult;
 757 #endif
 758
 759     // create interfaces
 760     hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
 761         IID_PPV_ARG(IDockingWindow, &dockingWindow));
 762     if (FAILED(hResult))
 763         return hResult;
 764     hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
 765         IID_PPV_ARG(IPersistStreamInit, &persistStreamInit));
 766     if (FAILED(hResult))
 767         return hResult;
 768     hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
 769         IID_PPV_ARG(IOleCommandTarget, &commandTarget));
 770     if (FAILED(hResult))
 771         return hResult;
 772     hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
 773         IID_PPV_ARG(IObjectWithSite, &objectSite));
 774     if (FAILED(hResult))
 775         return hResult;
 776
 777     hResult = objectSite->SetSite(static_cast<IShellBrowser *>(this));
 778     if (FAILED(hResult))
 779         return hResult;
 780
 781     hResult = commandTarget->Exec(&CGID_PrivCITCommands, 1, 1 /* or 0 */, NULL, NULL);
 782     if (FAILED(hResult))
 783         return hResult;
 784
 785     // TODO: create settingsStream from registry entry
 786     if (settingsStream.p == NULL)
 787     {
 788         hResult = persistStreamInit->InitNew();
 789         if (FAILED(hResult))
 790             return hResult;
 791     }
 792     else
 793     {
 794         hResult = persistStreamInit->Load(settingsStream);
 795         if (FAILED(hResult))
 796             return hResult;
 797     }
 798     hResult = dockingWindow->ShowDW(TRUE);
 799     if (FAILED(hResult))
 800         return hResult;
 801
 802     fToolbarProxy.Initialize(m_hWnd, fClientBars[BIInternetToolbar].clientBar);
 803
 804     // create status bar
 805     fStatusBar = CreateWindow(STATUSCLASSNAMEW, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS |
 806                     SBT_NOBORDERS | SBT_TOOLTIPS, 0, 0, 500, 20, m_hWnd, (HMENU)0xa001,
 807                     _AtlBaseModule.GetModuleInstance(), 0);
 808     fStatusBarVisible = true;
 809
 810     // browse
 811     hResult = BrowseToPIDL(pidl, BTP_UPDATE_NEXT_HISTORY);
 812     if (FAILED(hResult))
 813         return hResult;
 814
 815     ShowWindow(SW_SHOWNORMAL);
 816
 817     return S_OK;
 818 }
 819
 820 HRESULT CShellBrowser::BrowseToPIDL(LPCITEMIDLIST pidl, long flags)
 821 {
 822     CComPtr<IShellFolder>                   newFolder;
 823     FOLDERSETTINGS                          newFolderSettings;
 824     HRESULT                                 hResult;
 825
 826     // called by shell view to browse to new folder
 827     // also called by explorer band to navigate to new folder
 828     hResult = SHBindToFolder(pidl, &newFolder);
 829     newFolderSettings.ViewMode = FVM_ICON;
 830     newFolderSettings.fFlags = 0;
 831     hResult = BrowseToPath(newFolder, pidl, &newFolderSettings, flags);
 832     if (FAILED(hResult))
 833         return hResult;
 834     return S_OK;
 835 }
 836
 837 BOOL WINAPI _ILIsDesktop(LPCITEMIDLIST pidl)
 838 {
 839     return (pidl == NULL || pidl->mkid.cb == 0);
 840 }
 841
 842 BOOL WINAPI _ILIsPidlSimple(LPCITEMIDLIST pidl)
 843 {
 844     LPCITEMIDLIST                           pidlnext;
 845     WORD                                    length;
 846     BOOL                                    ret;
 847
 848     ret = TRUE;
 849     if (! _ILIsDesktop(pidl))
 850     {
 851         length = pidl->mkid.cb;
 852         pidlnext =
 853             reinterpret_cast<LPCITEMIDLIST>(
 854                 reinterpret_cast<const BYTE *>(pidl) + length);
 855         if (pidlnext->mkid.cb != 0)
 856             ret = FALSE;
 857     }
 858     return ret;
 859 }
 860
 861 HRESULT WINAPI SHBindToFolderIDListParent(IShellFolder *unused, LPCITEMIDLIST pidl,
 862     const IID *riid, LPVOID *ppv, LPITEMIDLIST *ppidlLast)
 863 {
 864     CComPtr<IShellFolder>                   psf;
 865     LPITEMIDLIST                            pidlChild;
 866     LPITEMIDLIST                            pidlParent;
 867     HRESULT                                 hResult;
 868
 869     hResult = E_FAIL;
 870     if (ppv == NULL)
 871         return E_POINTER;
 872     *ppv = NULL;
 873     if (ppidlLast != NULL)
 874         *ppidlLast = NULL;
 875     if (_ILIsPidlSimple(pidl))
 876     {
 877         if (ppidlLast != NULL)
 878             *ppidlLast = ILClone(pidl);
 879         hResult = SHGetDesktopFolder((IShellFolder **)ppv);
 880     }
 881     else
 882     {
 883         pidlChild = ILClone(ILFindLastID(pidl));
 884         pidlParent = ILClone(pidl);
 885         ILRemoveLastID(pidlParent);
 886         hResult = SHGetDesktopFolder(&psf);
 887         if (SUCCEEDED(hResult))
 888             hResult = psf->BindToObject(pidlParent, NULL, *riid, ppv);
 889         if (SUCCEEDED(hResult) && ppidlLast != NULL)
 890             *ppidlLast = pidlChild;
 891         else
 892             ILFree(pidlChild);
 893         ILFree(pidlParent);
 894     }
 895     return hResult;
 896 }
 897
 898 HRESULT IEGetNameAndFlagsEx(LPITEMIDLIST pidl, SHGDNF uFlags, long param10,
 899     LPWSTR pszBuf, UINT cchBuf, SFGAOF *rgfInOut)
 900 {
 901     CComPtr<IShellFolder>                   parentFolder;
 902     LPITEMIDLIST                            childPIDL;
 903     STRRET                                  L108;
 904     HRESULT                                 hResult;
 905
 906     hResult = SHBindToFolderIDListParent(NULL, pidl, &IID_PPV_ARG(IShellFolder, &parentFolder), &childPIDL);
 907     hResult = parentFolder->GetDisplayNameOf(childPIDL, uFlags, &L108);
 908     StrRetToBufW(&L108, childPIDL, pszBuf, cchBuf);
 909     if (rgfInOut)
 910         hResult = parentFolder->GetAttributesOf(1, const_cast<LPCITEMIDLIST *>(&childPIDL), rgfInOut);
 911     ILFree(childPIDL);
 912     return S_OK;
 913 }
 914
 915 long IEGetNameAndFlags(LPITEMIDLIST pidl, SHGDNF uFlags, LPWSTR pszBuf, UINT cchBuf, SFGAOF *rgfInOut)
 916 {
 917     return IEGetNameAndFlagsEx(pidl, uFlags, 0, pszBuf, cchBuf, rgfInOut);
 918 }
 919
 920 HRESULT CShellBrowser::BrowseToPath(IShellFolder *newShellFolder,
 921     LPCITEMIDLIST absolutePIDL, FOLDERSETTINGS *folderSettings, long flags)
 922 {
 923     CComPtr<IObjectWithSite>                objectWithSite;
 924     CComPtr<IShellFolder>                   saveCurrentShellFolder;
 925     CComPtr<IShellView>                     saveCurrentShellView;
 926     CComPtr<IShellView>                     newShellView;
 927     CComPtr<ITravelLog>                     travelLog;
 928     HWND                                    newShellViewWindow;
 929     BOOL                                    windowUpdateIsLocked;
 930     RECT                                    shellViewWindowBounds;
 931     HWND                                    previousView;
 932     HCURSOR                                 saveCursor;
 933     wchar_t                                 newTitle[MAX_PATH];
 934     SHGDNF                                  nameFlags;
 935     HRESULT                                 hResult;
 936
 937     if (newShellFolder == NULL)
 938         return E_INVALIDARG;
 939
 940     hResult = GetTravelLog(&travelLog);
 941     if (FAILED(hResult))
 942         return hResult;
 943
 944     // update history
 945     if (flags & BTP_UPDATE_CUR_HISTORY)
 946     {
 947         if (travelLog->CountEntries(static_cast<IDropTarget *>(this)) > 0)
 948             hResult = travelLog->UpdateEntry(static_cast<IDropTarget *>(this), FALSE);
 949         // what to do with error? Do we want to halt browse because state save failed?
 950     }
 951
 952     // create view object
 953     hResult = newShellFolder->CreateViewObject(m_hWnd, IID_PPV_ARG(IShellView, &newShellView));
 954     if (FAILED(hResult))
 955         return hResult;
 956     previousView = fCurrentShellViewWindow;
 957
 958     // enter updating section
 959     saveCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
 960     windowUpdateIsLocked = LockWindowUpdate(TRUE);
 961     if (fCurrentShellView != NULL)
 962         ::SendMessage(fCurrentShellViewWindow, WM_SETREDRAW, 0, 0);
 963
 964     // set site
 965     hResult = newShellView->QueryInterface(IID_PPV_ARG(IObjectWithSite, &objectWithSite));
 966     if (SUCCEEDED(hResult) && objectWithSite.p != NULL)
 967         hResult = objectWithSite->SetSite(static_cast<IDropTarget *>(this));
 968
 969     // update folder and view
 970     saveCurrentShellFolder = fCurrentShellFolder;
 971     saveCurrentShellView = fCurrentShellView;
 972     fCurrentShellFolder = newShellFolder;
 973     fCurrentShellView = newShellView;
 974
 975     // get boundary
 976     if (previousView != NULL)
 977         ::GetWindowRect(previousView, &shellViewWindowBounds);
 978     else
 979         ZeroMemory(&shellViewWindowBounds, sizeof(shellViewWindowBounds));
 980     ::MapWindowPoints(0, m_hWnd, reinterpret_cast<POINT *>(&shellViewWindowBounds), 2);
 981
 982     // create view window
 983     hResult = newShellView->CreateViewWindow(saveCurrentShellView, folderSettings,
 984         this, &shellViewWindowBounds, &newShellViewWindow);
 985     if (FAILED(hResult) || newShellViewWindow == NULL)
 986     {
 987         fCurrentShellView = saveCurrentShellView;
 988         fCurrentShellFolder = saveCurrentShellFolder;
 989         ::SendMessage(fCurrentShellViewWindow, WM_SETREDRAW, 1, 0);
 990         if (windowUpdateIsLocked)
 991             LockWindowUpdate(FALSE);
 992         SetCursor(saveCursor);
 993         return hResult;
 994     }
 995
 996     if (objectWithSite.p != NULL)
 997         hResult = objectWithSite->SetSite(NULL);
 998
 999     // update current pidl
1000     ILFree(fCurrentDirectoryPIDL);
1001     fCurrentDirectoryPIDL = ILClone(absolutePIDL);
1002
1003     // update view window
1004     if (saveCurrentShellView != NULL)
1005         saveCurrentShellView->DestroyViewWindow();
1006     fCurrentShellViewWindow = newShellViewWindow;
1007
1008     // no use
1009     saveCurrentShellView.Release();
1010     saveCurrentShellFolder.Release();
1011
1012     hResult = newShellView->UIActivate(SVUIA_ACTIVATE_FOCUS);
1013
1014     // leave updating section
1015     if (windowUpdateIsLocked)
1016         LockWindowUpdate(FALSE);
1017     SetCursor(saveCursor);
1018
1019     // update history
1020     if (flags & BTP_UPDATE_NEXT_HISTORY)
1021     {
1022         hResult = travelLog->AddEntry(static_cast<IDropTarget *>(this), FALSE);
1023         hResult = travelLog->UpdateEntry(static_cast<IDropTarget *>(this), FALSE);
1024     }
1025
1026     // completed
1027     nameFlags = SHGDN_FORADDRESSBAR | SHGDN_FORPARSING;
1028     hResult = IEGetNameAndFlags(fCurrentDirectoryPIDL, nameFlags, newTitle,
1029         sizeof(newTitle) / sizeof(wchar_t), NULL);
1030     if (SUCCEEDED(hResult))
1031     {
1032         FireNavigateComplete(newTitle);
1033     }
1034     else
1035     {
1036         FireNavigateComplete(L"ERROR");
1037     }
1038
1039     if (fCabinetState.fFullPathTitle)
1040         nameFlags = SHGDN_FORADDRESSBAR | SHGDN_FORPARSING;
1041     else
1042         nameFlags = SHGDN_FORADDRESSBAR;
1043     hResult = IEGetNameAndFlags(fCurrentDirectoryPIDL, nameFlags, newTitle,
1044         sizeof(newTitle) / sizeof(wchar_t), NULL);
1045     if (SUCCEEDED(hResult))
1046     {
1047         SetWindowText(newTitle);
1048
1049         LPCITEMIDLIST pidlChild;
1050         INT index, indexOpen;
1051         HIMAGELIST himlSmall, himlLarge;
1052
1053         CComPtr<IShellFolder> sf;
1054         SHBindToParent(absolutePIDL, IID_PPV_ARG(IShellFolder, &sf), &pidlChild);
1055
1056         index = SHMapPIDLToSystemImageListIndex(sf, pidlChild, &indexOpen);
1057
1058         Shell_GetImageLists(&himlSmall, &himlLarge);
1059
1060         HICON icSmall = ImageList_GetIcon(himlSmall, indexOpen, 0);
1061         HICON icLarge = ImageList_GetIcon(himlLarge, indexOpen, 0);
1062
1063         SendMessage(WM_SETICON, ICON_SMALL, reinterpret_cast<LPARAM>(icSmall));
1064         SendMessage(WM_SETICON, ICON_BIG,   reinterpret_cast<LPARAM>(icLarge));
1065     }
1066
1067     // TODO: Update the window icon
1068
1069     FireCommandStateChangeAll();
1070     hResult = UpdateForwardBackState();
1071     return S_OK;
1072 }
1073
1074 HRESULT CShellBrowser::GetMenuBand(REFIID riid, void **shellMenu)
1075 {
1076     CComPtr<IServiceProvider>               serviceProvider;
1077     CComPtr<IBandSite>                      bandSite;
1078     CComPtr<IDeskBand>                      deskBand;
1079     HRESULT                                 hResult;
1080
1081     if (fClientBars[BIInternetToolbar].clientBar.p == NULL)
1082         return E_FAIL;
1083     hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
1084         IID_PPV_ARG(IServiceProvider, &serviceProvider));
1085     if (FAILED(hResult))
1086         return hResult;
1087     hResult = serviceProvider->QueryService(SID_IBandSite, IID_PPV_ARG(IBandSite, &bandSite));
1088     if (FAILED(hResult))
1089         return hResult;
1090     hResult = bandSite->QueryBand(1, &deskBand, NULL, NULL, 0);
1091     if (FAILED(hResult))
1092         return hResult;
1093     return deskBand->QueryInterface(riid, shellMenu);
1094 }
1095
1096 HRESULT CShellBrowser::GetBaseBar(bool vertical, IUnknown **theBaseBar)
1097 {
1098     CComPtr<IUnknown>                       newBaseBar;
1099     CComPtr<IDeskBar>                       deskBar;
1100     CComPtr<IUnknown>                       newBaseBarSite;
1101     CComPtr<IObjectWithSite>                objectWithSite;
1102     CComPtr<IDeskBarClient>                 deskBarClient;
1103     IUnknown                                **cache;
1104     HRESULT                                 hResult;
1105
1106     if (vertical)
1107         cache = &fClientBars[BIVerticalBaseBar].clientBar.p;
1108     else
1109         cache = &fClientBars[BIHorizontalBaseBar].clientBar.p;
1110     if (*cache == NULL)
1111     {
1112         hResult = CreateBaseBar(IID_PPV_ARG(IUnknown, &newBaseBar));
1113         if (FAILED(hResult))
1114             return hResult;
1115         hResult = CreateBaseBarSite(IID_PPV_ARG(IUnknown, &newBaseBarSite));
1116         if (FAILED(hResult))
1117             return hResult;
1118
1119         // tell the new base bar about the shell browser
1120         hResult = newBaseBar->QueryInterface(IID_PPV_ARG(IObjectWithSite, &objectWithSite));
1121         if (FAILED(hResult))
1122             return hResult;
1123         hResult = objectWithSite->SetSite(static_cast<IDropTarget *>(this));
1124         if (FAILED(hResult))
1125             return hResult;
1126
1127         // tell the new base bar about the new base bar site
1128         hResult = newBaseBar->QueryInterface(IID_PPV_ARG(IDeskBar, &deskBar));
1129         if (FAILED(hResult))
1130             return hResult;
1131         hResult = deskBar->SetClient(newBaseBarSite);
1132         if (FAILED(hResult))
1133             return hResult;
1134
1135         // tell the new base bar site about the new base bar
1136         hResult = newBaseBarSite->QueryInterface(IID_PPV_ARG(IDeskBarClient, &deskBarClient));
1137         if (FAILED(hResult))
1138             return hResult;
1139         hResult = deskBarClient->SetDeskBarSite(newBaseBar);
1140         if (FAILED(hResult))
1141             return hResult;
1142
1143         *cache = newBaseBar.Detach();
1144     }
1145     return (*cache)->QueryInterface(IID_PPV_ARG(IUnknown, theBaseBar));
1146 }
1147
1148 HRESULT CShellBrowser::ShowBand(const CLSID &classID, bool vertical)
1149 {
1150     CComPtr<IDockingWindow>                 dockingWindow;
1151     CComPtr<IOleCommandTarget>              oleCommandTarget;
1152     CComPtr<IUnknown>                       baseBarSite;
1153     CComPtr<IUnknown>                       newBand;
1154     CComPtr<IUnknown>                       theBaseBar;
1155     CComPtr<IDeskBar>                       deskBar;
1156     VARIANT                                 vaIn;
1157     HRESULT                                 hResult;
1158
1159     __debugbreak();
1160
1161     hResult = GetBaseBar(vertical, (IUnknown **)&theBaseBar);
1162     if (FAILED(hResult))
1163         return hResult;
1164     hResult = CoCreateInstance(classID, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IUnknown, &newBand));
1165     if (FAILED(hResult))
1166         return hResult;
1167     hResult = theBaseBar->QueryInterface(IID_PPV_ARG(IDeskBar, &deskBar));
1168     if (FAILED(hResult))
1169         return hResult;
1170     hResult = deskBar->GetClient(&baseBarSite);
1171     if (FAILED(hResult))
1172         return hResult;
1173     hResult = theBaseBar->QueryInterface(IID_PPV_ARG(IDockingWindow, &dockingWindow));
1174     if (FAILED(hResult))
1175         return hResult;
1176     hResult = baseBarSite->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &oleCommandTarget));
1177     if (FAILED(hResult))
1178         return hResult;
1179     V_VT(&vaIn) = VT_UNKNOWN;
1180     V_UNKNOWN(&vaIn) = newBand.p;
1181     hResult = oleCommandTarget->Exec(&CGID_IDeskBand, 1, 1, &vaIn, NULL);
1182     if (FAILED(hResult))
1183         return hResult;
1184     hResult = dockingWindow->ShowDW(TRUE);
1185     if (FAILED(hResult))
1186         return hResult;
1187     return S_OK;
1188 }
1189
1190 HRESULT CShellBrowser::NavigateToParent()
1191 {
1192     LPITEMIDLIST                            newDirectory;
1193     HRESULT                                 hResult;
1194
1195     newDirectory = ILClone(fCurrentDirectoryPIDL);
1196     if (newDirectory == NULL)
1197         return E_OUTOFMEMORY;
1198     ILRemoveLastID(newDirectory);
1199     hResult = BrowseToPIDL(newDirectory, BTP_UPDATE_CUR_HISTORY | BTP_UPDATE_NEXT_HISTORY);
1200     ILFree(newDirectory);
1201     if (FAILED(hResult))
1202         return hResult;
1203     return S_OK;
1204 }
1205
1206 BOOL CALLBACK AddFolderOptionsPage(HPROPSHEETPAGE thePage, LPARAM lParam)
1207 {
1208     PROPSHEETHEADER                         *sheetInfo;
1209
1210     sheetInfo = (PROPSHEETHEADER *)lParam;
1211     if (sheetInfo->nPages >= folderOptionsPageCountMax)
1212         return FALSE;
1213     sheetInfo->phpage[sheetInfo->nPages] = thePage;
1214     sheetInfo->nPages++;
1215     return TRUE;
1216 }
1217
1218 HRESULT CShellBrowser::DoFolderOptions()
1219 {
1220     CComPtr<IShellPropSheetExt>             folderOptionsSheet;
1221     CComPtr<IObjectWithSite>                objectWithSite;
1222     PROPSHEETHEADER                         m_PropSheet;
1223     HPROPSHEETPAGE                          m_psp[folderOptionsPageCountMax];
1224 //    CComPtr<IGlobalFolderSettings>          globalSettings;
1225 //    SHELLSTATE2                             shellState;
1226     HRESULT                                 hResult;
1227
1228     memset(m_psp, 0, sizeof(m_psp));
1229     memset(&m_PropSheet, 0, sizeof(m_PropSheet));
1230
1231     // create sheet object
1232     hResult = CoCreateInstance(CLSID_ShellFldSetExt, NULL, CLSCTX_INPROC_SERVER,
1233         IID_PPV_ARG(IShellPropSheetExt, &folderOptionsSheet));
1234     if (FAILED(hResult))
1235         return E_FAIL;
1236
1237     // must set site in order for Apply to all Folders on Advanced page to be enabled
1238     hResult = folderOptionsSheet->QueryInterface(IID_PPV_ARG(IObjectWithSite, &objectWithSite));
1239     if (SUCCEEDED(hResult) && objectWithSite.p != NULL)
1240         hResult = objectWithSite->SetSite(static_cast<IDispatch *>(this));
1241     m_PropSheet.phpage = m_psp;
1242
1243 #if 0
1244     hResult = CoCreateInstance(CLSID_GlobalFolderSettings, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IGlobalFolderSettings, &globalSettings));
1245     if (FAILED(hResult))
1246         return E_FAIL;
1247     hResult = globalSettings->Get(&shellState, sizeof(shellState));
1248     if (FAILED(hResult))
1249         return E_FAIL;
1250 #endif
1251
1252     // add pages
1253     hResult = folderOptionsSheet->AddPages(AddFolderOptionsPage, reinterpret_cast<LPARAM>(&m_PropSheet));
1254     if (FAILED(hResult))
1255         return E_FAIL;
1256
1257     if (fCurrentShellView != NULL)
1258     {
1259         hResult = fCurrentShellView->AddPropertySheetPages(
1260             0, AddFolderOptionsPage, reinterpret_cast<LPARAM>(&m_PropSheet));
1261         if (FAILED(hResult))
1262             return E_FAIL;
1263     }
1264
1265     // show sheet
1266     m_PropSheet.dwSize = sizeof(PROPSHEETHEADER);
1267     m_PropSheet.dwFlags = 0;
1268     m_PropSheet.hwndParent = m_hWnd;
1269     m_PropSheet.hInstance = _AtlBaseModule.GetResourceInstance();
1270     m_PropSheet.pszCaption = _T("Folder Options");
1271     m_PropSheet.nStartPage = 0;
1272     PropertySheet(&m_PropSheet);
1273     return S_OK;
1274 }
1275
1276 LRESULT CALLBACK CShellBrowser::WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1277 {
1278     CShellBrowser                           *pThis = reinterpret_cast<CShellBrowser *>(hWnd);
1279     _ATL_MSG                                msg(pThis->m_hWnd, uMsg, wParam, lParam);
1280     LRESULT                                 lResult;
1281     CComPtr<IMenuBand>                      menuBand;
1282     const _ATL_MSG                          *previousMessage;
1283     BOOL                                    handled;
1284     WNDPROC                                 saveWindowProc;
1285     HRESULT                                 hResult;
1286
1287     hWnd = pThis->m_hWnd;
1288     previousMessage = pThis->m_pCurrentMsg;
1289     pThis->m_pCurrentMsg = &msg;
1290
1291     hResult = pThis->GetMenuBand(IID_PPV_ARG(IMenuBand, &menuBand));
1292     if (SUCCEEDED(hResult) && menuBand.p != NULL)
1293     {
1294         hResult = menuBand->TranslateMenuMessage(&msg, &lResult);
1295         if (hResult == S_OK)
1296             return lResult;
1297         uMsg = msg.message;
1298         wParam = msg.wParam;
1299         lParam = msg.lParam;
1300     }
1301
1302     handled = pThis->ProcessWindowMessage(hWnd, uMsg, wParam, lParam, lResult, 0);
1303     ATLASSERT(pThis->m_pCurrentMsg == &msg);
1304     if (handled == FALSE)
1305     {
1306         if (uMsg == WM_NCDESTROY)
1307         {
1308             saveWindowProc = reinterpret_cast<WNDPROC>(GetWindowLongPtr(hWnd, GWL_WNDPROC));
1309             lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
1310             if (saveWindowProc == reinterpret_cast<WNDPROC>(GetWindowLongPtr(hWnd, GWL_WNDPROC)))
1311                 SetWindowLongPtr(hWnd, GWL_WNDPROC, (LONG_PTR)pThis->m_pfnSuperWindowProc);
1312             pThis->m_dwState |= WINSTATE_DESTROYED;
1313         }
1314         else
1315             lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
1316     }
1317     pThis->m_pCurrentMsg = previousMessage;
1318     if (previousMessage == NULL && (pThis->m_dwState & WINSTATE_DESTROYED) != 0)
1319     {
1320         pThis->m_dwState &= ~WINSTATE_DESTROYED;
1321         pThis->m_hWnd = NULL;
1322         pThis->OnFinalMessage(hWnd);
1323     }
1324     return lResult;
1325 }
1326
1327 void CShellBrowser::RepositionBars()
1328 {
1329     RECT                                    clientRect;
1330     RECT                                    statusRect;
1331     int                                     x;
1332
1333     GetClientRect(&clientRect);
1334
1335     if (fStatusBarVisible && fStatusBar)
1336     {
1337         ::GetWindowRect(fStatusBar, &statusRect);
1338         ::SetWindowPos(fStatusBar, NULL, clientRect.left, clientRect.bottom - (statusRect.bottom - statusRect.top),
1339                             clientRect.right - clientRect.left,
1340                             statusRect.bottom - statusRect.top, SWP_NOOWNERZORDER | SWP_NOZORDER);
1341         clientRect.bottom -= statusRect.bottom - statusRect.top;
1342     }
1343
1344     for (x = 0; x < 3; x++)
1345     {
1346         HWND hwnd = fClientBars[x].hwnd;
1347         RECT borderSpace = fClientBars[x].borderSpace;
1348         if (hwnd == NULL && fClientBars[x].clientBar != NULL)
1349         {
1350             IUnknown_GetWindow(fClientBars[x].clientBar, &hwnd);
1351             fClientBars[x].hwnd = hwnd;
1352         }
1353         if (hwnd != NULL)
1354         {
1355             RECT toolbarRect = clientRect;
1356             if (borderSpace.top != 0)
1357             {
1358                 toolbarRect.bottom = toolbarRect.top + borderSpace.top;
1359             }
1360             else if (borderSpace.bottom != 0)
1361             {
1362                 toolbarRect.top = toolbarRect.bottom - borderSpace.bottom;
1363             }
1364             else if (borderSpace.left != 0)
1365             {
1366                 toolbarRect.right = toolbarRect.left + borderSpace.left;
1367             }
1368             else if (borderSpace.right != 0)
1369             {
1370                 toolbarRect.left = toolbarRect.right - borderSpace.right;
1371             }
1372
1373             ::SetWindowPos(hwnd, NULL,
1374                 toolbarRect.left,
1375                 toolbarRect.top,
1376                 toolbarRect.right - toolbarRect.left,
1377                 toolbarRect.bottom - toolbarRect.top,
1378                 SWP_NOOWNERZORDER | SWP_NOZORDER);
1379
1380             if (borderSpace.top != 0)
1381             {
1382                 clientRect.top = toolbarRect.bottom;
1383             }
1384             else if (borderSpace.bottom != 0)
1385             {
1386                 clientRect.bottom = toolbarRect.top;
1387             }
1388             else if (borderSpace.left != 0)
1389             {
1390                 clientRect.left = toolbarRect.right;
1391             }
1392             else if (borderSpace.right != 0)
1393             {
1394                 clientRect.right = toolbarRect.left;
1395             }
1396         }
1397     }
1398     ::SetWindowPos(fCurrentShellViewWindow, NULL, clientRect.left, clientRect.top,
1399                         clientRect.right - clientRect.left,
1400                         clientRect.bottom - clientRect.top, SWP_NOOWNERZORDER | SWP_NOZORDER);
1401 }
1402
1403 HRESULT CShellBrowser::FireEvent(DISPID dispIdMember, int argCount, VARIANT *arguments)
1404 {
1405     DISPPARAMS                          params;
1406     CComDynamicUnkArray                 &vec = IConnectionPointImpl<CShellBrowser, &DIID_DWebBrowserEvents2>::m_vec;
1407     CComDynamicUnkArray                 &vec2 = IConnectionPointImpl<CShellBrowser, &DIID_DWebBrowserEvents>::m_vec;
1408     HRESULT                             hResult;
1409
1410     params.rgvarg = arguments;
1411     params.rgdispidNamedArgs = NULL;
1412     params.cArgs = argCount;
1413     params.cNamedArgs = 0;
1414     IUnknown** pp = vec.begin();
1415     while (pp < vec.end())
1416     {
1417         if (*pp != NULL)
1418         {
1419             CComPtr<IDispatch>          theDispatch;
1420
1421             hResult = (*pp)->QueryInterface(IID_PPV_ARG(IDispatch, &theDispatch));
1422             hResult = theDispatch->Invoke(dispIdMember, GUID_NULL, 0, DISPATCH_METHOD, &params, NULL, NULL, NULL);
1423         }
1424         pp++;
1425     }
1426     pp = vec2.begin();
1427     while (pp < vec2.end())
1428     {
1429         if (*pp != NULL)
1430         {
1431             CComPtr<IDispatch>          theDispatch;
1432
1433             hResult = (*pp)->QueryInterface(IID_PPV_ARG(IDispatch, &theDispatch));
1434             hResult = theDispatch->Invoke(dispIdMember, GUID_NULL, 0, DISPATCH_METHOD, &params, NULL, NULL, NULL);
1435         }
1436         pp++;
1437     }
1438     return S_OK;
1439 }
1440
1441 HRESULT CShellBrowser::FireNavigateComplete(const wchar_t *newDirectory)
1442 {
1443     // these two variants intentionally to do use CComVariant because it would double free/release
1444     // or does not need to dispose at all
1445     VARIANT                             varArg[2];
1446     VARIANT                             varArgs;
1447     CComBSTR                            tempString(newDirectory);
1448
1449     V_VT(&varArgs) = VT_BSTR;
1450     V_BSTR(&varArgs) = tempString.m_str;
1451
1452     V_VT(&varArg[0]) = VT_VARIANT | VT_BYREF;
1453     V_VARIANTREF(&varArg[0]) = &varArgs;
1454     V_VT(&varArg[1]) = VT_DISPATCH;
1455     V_DISPATCH(&varArg[1]) = (IDispatch *)this;
1456
1457     return FireEvent(DISPID_NAVIGATECOMPLETE2, 2, varArg);
1458 }
1459
1460 HRESULT CShellBrowser::FireCommandStateChange(bool newState, int commandID)
1461 {
1462     VARIANT                             varArg[2];
1463
1464     V_VT(&varArg[0]) = VT_BOOL;
1465     V_BOOL(&varArg[0]) = newState ? VARIANT_TRUE : VARIANT_FALSE;
1466     V_VT(&varArg[1]) = VT_I4;
1467     V_I4(&varArg[1]) = commandID;
1468
1469     return FireEvent(DISPID_COMMANDSTATECHANGE, 2, varArg);
1470 }
1471
1472 HRESULT CShellBrowser::FireCommandStateChangeAll()
1473 {
1474     return FireCommandStateChange(false, -1);
1475 }
1476
1477 HRESULT CShellBrowser::UpdateForwardBackState()
1478 {
1479     CComPtr<ITravelLog>                     travelLog;
1480     CComPtr<ITravelEntry>                   unusedEntry;
1481     bool                                    canGoBack;
1482     bool                                    canGoForward;
1483     HRESULT                                 hResult;
1484
1485     canGoBack = false;
1486     canGoForward = false;
1487     hResult = GetTravelLog(&travelLog);
1488     if (FAILED(hResult))
1489         return hResult;
1490     hResult = travelLog->GetTravelEntry(static_cast<IDropTarget *>(this), TLOG_BACK, &unusedEntry);
1491     if (SUCCEEDED(hResult))
1492     {
1493         canGoBack = true;
1494         unusedEntry.Release();
1495     }
1496     hResult = travelLog->GetTravelEntry(static_cast<IDropTarget *>(this), TLOG_FORE, &unusedEntry);
1497     if (SUCCEEDED(hResult))
1498     {
1499         canGoForward = true;
1500         unusedEntry.Release();
1501     }
1502     hResult = FireCommandStateChange(canGoBack, 2);
1503     hResult = FireCommandStateChange(canGoForward, 1);
1504     return S_OK;
1505 }
1506
1507 void CShellBrowser::UpdateGotoMenu(HMENU theMenu)
1508 {
1509     CComPtr<ITravelLog>                     travelLog;
1510     int                                     position;
1511     MENUITEMINFO                            menuItemInfo;
1512     HRESULT                                 hResult;
1513
1514     DeleteMenuItems(theMenu, IDM_GOTO_TRAVEL_FIRST, IDM_GOTO_TRAVEL_LAST);
1515
1516     position = GetMenuItemCount(theMenu);
1517     hResult = GetTravelLog(&travelLog);
1518     if (FAILED(hResult))
1519         return;
1520     hResult = travelLog->InsertMenuEntries(static_cast<IDropTarget *>(this), theMenu, position,
1521         IDM_GOTO_TRAVEL_FIRSTTARGET, IDM_GOTO_TRAVEL_LASTTARGET, TLMENUF_BACKANDFORTH | TLMENUF_CHECKCURRENT);
1522     if (SUCCEEDED(hResult))
1523     {
1524         menuItemInfo.cbSize = sizeof(menuItemInfo);
1525         menuItemInfo.fMask = MIIM_TYPE | MIIM_ID;
1526         menuItemInfo.fType = MF_SEPARATOR;
1527         menuItemInfo.wID = IDM_GOTO_TRAVEL_SEP;
1528         InsertMenuItem(theMenu, position, TRUE, &menuItemInfo);
1529     }
1530 }
1531
1532 void CShellBrowser::UpdateViewMenu(HMENU theMenu)
1533 {
1534     CComPtr<IOleCommandTarget>              oleCommandTarget;
1535     CComPtr<ITravelLog>                     travelLog;
1536     HMENU                                   gotoMenu;
1537     OLECMD                                  commandList[5];
1538     HMENU                                   toolbarMenuBar;
1539     HMENU                                   toolbarMenu;
1540     MENUITEMINFO                            menuItemInfo;
1541     HRESULT                                 hResult;
1542
1543     gotoMenu = SHGetMenuFromID(theMenu, FCIDM_MENU_EXPLORE);
1544     if (gotoMenu != NULL)
1545         UpdateGotoMenu(gotoMenu);
1546
1547     commandList[0].cmdID = ITID_TOOLBARBANDSHOWN;
1548     commandList[1].cmdID = ITID_ADDRESSBANDSHOWN;
1549     commandList[2].cmdID = ITID_LINKSBANDSHOWN;
1550     commandList[3].cmdID = ITID_TOOLBARLOCKED;
1551     commandList[4].cmdID = ITID_CUSTOMIZEENABLED;
1552
1553     hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
1554         IID_PPV_ARG(IOleCommandTarget, &oleCommandTarget));
1555     if (SUCCEEDED(hResult))
1556         hResult = oleCommandTarget->QueryStatus(&CGID_PrivCITCommands, 5, commandList, NULL);
1557     if (FAILED(hResult))
1558         DeleteMenu(theMenu, IDM_VIEW_TOOLBARS, MF_BYCOMMAND);
1559     else
1560     {
1561         toolbarMenuBar = LoadMenu(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(IDM_CABINET_CONTEXTMENU));
1562         toolbarMenu = GetSubMenu(toolbarMenuBar, 0);
1563
1564         SHCheckMenuItem(toolbarMenu, IDM_TOOLBARS_STANDARDBUTTONS, commandList[0].cmdf);
1565         SHCheckMenuItem(toolbarMenu, IDM_TOOLBARS_ADDRESSBAR, commandList[1].cmdf & OLECMDF_ENABLED);
1566         SHCheckMenuItem(toolbarMenu, IDM_TOOLBARS_LINKSBAR, commandList[2].cmdf & OLECMDF_ENABLED);
1567         SHCheckMenuItem(toolbarMenu, IDM_TOOLBARS_LOCKTOOLBARS, commandList[3].cmdf & OLECMDF_ENABLED);
1568         if ((commandList[4].cmdf & OLECMDF_ENABLED) == 0)
1569             DeleteMenu(toolbarMenu, IDM_TOOLBARS_CUSTOMIZE, MF_BYCOMMAND);
1570         DeleteMenu(toolbarMenu, IDM_TOOLBARS_TEXTLABELS, MF_BYCOMMAND);
1571         DeleteMenu(toolbarMenu, IDM_TOOLBARS_GOBUTTON, MF_BYCOMMAND);
1572
1573         menuItemInfo.cbSize = sizeof(menuItemInfo);
1574         menuItemInfo.fMask = MIIM_SUBMENU;
1575         menuItemInfo.hSubMenu = toolbarMenu;
1576         SetMenuItemInfo(theMenu, IDM_VIEW_TOOLBARS, FALSE, &menuItemInfo);
1577     }
1578     SHCheckMenuItem(theMenu, IDM_VIEW_STATUSBAR, fStatusBarVisible ? TRUE : FALSE);
1579 }
1580
1581 bool IUnknownIsEqual(IUnknown *int1, IUnknown *int2)
1582 {
1583     CComPtr<IUnknown>                       int1Retry;
1584     CComPtr<IUnknown>                       int2Retry;
1585     HRESULT                                 hResult;
1586
1587     if (int1 == int2)
1588         return true;
1589     if (int1 == NULL || int2 == NULL)
1590         return false;
1591     hResult = int1->QueryInterface(IID_PPV_ARG(IUnknown, &int1Retry));
1592     if (FAILED(hResult))
1593         return false;
1594     hResult = int2->QueryInterface(IID_PPV_ARG(IUnknown, &int2Retry));
1595     if (FAILED(hResult))
1596         return false;
1597     if (int1Retry == int2Retry)
1598         return true;
1599     return false;
1600 }
1601
1602 HRESULT STDMETHODCALLTYPE CShellBrowser::GetBorderDW(IUnknown *punkObj, LPRECT prcBorder)
1603 {
1604     static const INT excludeItems[] = { 1, 1, 1, 0xa001, 0, 0 };
1605
1606     RECT availableBounds;
1607
1608     GetEffectiveClientRect(m_hWnd, &availableBounds, excludeItems);
1609     for (INT x = 0; x < 3; x++)
1610     {
1611         if (fClientBars[x].clientBar.p != NULL && !IUnknownIsEqual(fClientBars[x].clientBar, punkObj))
1612         {
1613             availableBounds.top += fClientBars[x].borderSpace.top;
1614             availableBounds.left += fClientBars[x].borderSpace.left;
1615             availableBounds.bottom -= fClientBars[x].borderSpace.bottom;
1616             availableBounds.right -= fClientBars[x].borderSpace.right;
1617         }
1618     }
1619     *prcBorder = availableBounds;
1620     return S_OK;
1621 }
1622
1623 HRESULT STDMETHODCALLTYPE CShellBrowser::RequestBorderSpaceDW(IUnknown* punkObj, LPCBORDERWIDTHS pbw)
1624 {
1625     return S_OK;
1626 }
1627
1628 HRESULT STDMETHODCALLTYPE CShellBrowser::SetBorderSpaceDW(IUnknown* punkObj, LPCBORDERWIDTHS pbw)
1629 {
1630     for (INT x = 0; x < 3; x++)
1631     {
1632         if (IUnknownIsEqual(fClientBars[x].clientBar, punkObj))
1633         {
1634             fClientBars[x].borderSpace = *pbw;
1635             // if this bar changed size, it cascades and forces all subsequent bars to resize
1636             RepositionBars();
1637             return S_OK;
1638         }
1639     }
1640     return E_INVALIDARG;
1641 }
1642
1643 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryStatus(const GUID *pguidCmdGroup,
1644     ULONG cCmds, OLECMD prgCmds[  ], OLECMDTEXT *pCmdText)
1645 {
1646     CComPtr<IOleCommandTarget>              commandTarget;
1647     HRESULT                                 hResult;
1648
1649     if (prgCmds == NULL)
1650         return E_INVALIDARG;
1651     if (pguidCmdGroup == NULL)
1652     {
1653         if (fCurrentShellView.p != NULL)
1654         {
1655             hResult = fCurrentShellView->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &commandTarget));
1656             if (SUCCEEDED(hResult) && commandTarget.p != NULL)
1657                 return commandTarget->QueryStatus(NULL, 1, prgCmds, pCmdText);
1658         }
1659         while (cCmds != 0)
1660         {
1661             prgCmds->cmdf = 0;
1662             prgCmds++;
1663             cCmds--;
1664         }
1665     }
1666     else if (IsEqualIID(*pguidCmdGroup, CGID_Explorer))
1667     {
1668         while (cCmds != 0)
1669         {
1670             switch (prgCmds->cmdID)
1671             {
1672                 case 0x1c:  // search
1673                     prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1674                     break;
1675                 case 0x1d:  // history
1676                     prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1677                     break;
1678                 case 0x1e:  // favorites
1679                     prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1680                     break;
1681                 case 0x23:  // folders
1682                     prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED | OLECMDF_LATCHED;
1683                     break;
1684                 default:
1685                     prgCmds->cmdf = 0;
1686                     break;
1687             }
1688             prgCmds++;
1689             cCmds--;
1690         }
1691     }
1692     else if (IsEqualIID(*pguidCmdGroup, CGID_ShellBrowser))
1693     {
1694         while (cCmds != 0)
1695         {
1696             switch (prgCmds->cmdID)
1697             {
1698                 case 0xa022:    // up level
1699                     prgCmds->cmdf = OLECMDF_SUPPORTED;
1700                     if (fCurrentDirectoryPIDL->mkid.cb != 0)
1701                         prgCmds->cmdf |= OLECMDF_ENABLED;
1702                     break;
1703             }
1704             prgCmds++;
1705             cCmds--;
1706         }
1707     }
1708     return S_OK;
1709 }
1710
1711 HRESULT STDMETHODCALLTYPE CShellBrowser::Exec(const GUID *pguidCmdGroup, DWORD nCmdID,
1712     DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
1713 {
1714     HRESULT                                 hResult;
1715
1716     if (IsEqualIID(*pguidCmdGroup, CGID_Explorer))
1717     {
1718         switch (nCmdID)
1719         {
1720             case 0x23:
1721                 hResult = ShowBand(CLSID_ExplorerBand, true);
1722                 return S_OK;
1723             case 0x27:
1724                 if (nCmdexecopt == 1)
1725                 {
1726                     // pvaIn is a VT_UNKNOWN with a band that is being hidden
1727                 }
1728                 else
1729                 {
1730                     // update zones part of the status bar
1731                 }
1732                 return S_OK;
1733             case 0x35: // don't do this, and the internet toolbar doesn't create a menu band
1734                 V_VT(pvaOut) = VT_INT_PTR;
1735                 V_INTREF(pvaOut) = reinterpret_cast<INT *>(
1736                     LoadMenu(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(IDM_CABINET_MAINMENU)));
1737                 return S_OK;
1738             case 0x38:
1739                 // indicate if this cabinet was opened as a browser
1740                 return S_FALSE;
1741             default:
1742                 return E_NOTIMPL;
1743         }
1744     }
1745     else if (IsEqualIID(*pguidCmdGroup, CGID_InternetButtons))
1746     {
1747         switch (nCmdID)
1748         {
1749             case 0x23:
1750                 // placeholder
1751                 return S_OK;
1752         }
1753     }
1754     else if (IsEqualIID(*pguidCmdGroup, CGID_Theater))
1755     {
1756         switch (nCmdID)
1757         {
1758             case 6:
1759                 // what is theater mode and why do we receive this?
1760                 return E_NOTIMPL;
1761         }
1762     }
1763     else if (IsEqualIID(*pguidCmdGroup, CGID_MenuBand))
1764     {
1765         switch (nCmdID)
1766         {
1767             case 14:
1768                 // initialize favorites menu
1769                 return S_OK;
1770         }
1771     }
1772     else if (IsEqualIID(*pguidCmdGroup, CGID_ShellDocView))
1773     {
1774         switch (nCmdID)
1775         {
1776             case 0x12:
1777                 // refresh on toolbar clicked
1778                 return S_OK;
1779             case 0x4d:
1780                 // tell the view if it should hide the task pane or not
1781                 return (fClientBars[BIVerticalBaseBar].clientBar.p == NULL) ? S_FALSE : S_OK;
1782         }
1783     }
1784     else if (IsEqualIID(*pguidCmdGroup, CGID_ShellBrowser))
1785     {
1786         switch (nCmdID)
1787         {
1788             case 40994:
1789                 return NavigateToParent();
1790         }
1791     }
1792     else if (IsEqualIID(*pguidCmdGroup, CGID_IExplorerToolbar))
1793     {
1794         switch (nCmdID)
1795         {
1796             case 0x7063:
1797                 return DoFolderOptions();
1798         }
1799     }
1800     else if (IsEqualIID(*pguidCmdGroup, CGID_DefView))
1801     {
1802         switch (nCmdID)
1803         {
1804             case 1:
1805                 // Reset All Folders option in Folder Options
1806                 break;
1807         }
1808     }
1809     else
1810     {
1811         return E_NOTIMPL;
1812     }
1813     return E_NOTIMPL;
1814 }
1815
1816 HRESULT STDMETHODCALLTYPE CShellBrowser::GetWindow(HWND *lphwnd)
1817 {
1818     if (lphwnd == NULL)
1819         return E_POINTER;
1820     *lphwnd = m_hWnd;
1821     return S_OK;
1822 }
1823
1824 HRESULT STDMETHODCALLTYPE CShellBrowser::ContextSensitiveHelp(BOOL fEnterMode)
1825 {
1826     return E_NOTIMPL;
1827 }
1828
1829 HRESULT STDMETHODCALLTYPE CShellBrowser::InsertMenusSB(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths)
1830 {
1831     HMENU mainMenu = LoadMenu(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(IDM_CABINET_MAINMENU));
1832     Shell_MergeMenus(hmenuShared, mainMenu, 0, 0, FCIDM_BROWSERLAST, MM_SUBMENUSHAVEIDS);
1833
1834     int GCCU(itemCount3) = GetMenuItemCount(hmenuShared);
1835     Unused(itemCount3);
1836
1837     lpMenuWidths->width[0] = 2;
1838     lpMenuWidths->width[2] = 3;
1839     lpMenuWidths->width[4] = 1;
1840     return S_OK;
1841 }
1842
1843 HRESULT STDMETHODCALLTYPE CShellBrowser::SetMenuSB(HMENU hmenuShared, HOLEMENU holemenuRes, HWND hwndActiveObject)
1844 {
1845     CComPtr<IShellMenu>                     shellMenu;
1846     HRESULT                                 hResult;
1847
1848     if (IsMenu(hmenuShared) == FALSE)
1849         return E_FAIL;
1850     hResult = GetMenuBand(IID_PPV_ARG(IShellMenu, &shellMenu));
1851     if (FAILED(hResult))
1852         return hResult;
1853     hResult = shellMenu->SetMenu(hmenuShared, NULL, SMSET_DONTOWN);
1854     if (FAILED(hResult))
1855         return hResult;
1856     fCurrentMenuBar = hmenuShared;
1857     return S_OK;
1858 }
1859
1860 HRESULT STDMETHODCALLTYPE CShellBrowser::RemoveMenusSB(HMENU hmenuShared)
1861 {
1862     if (hmenuShared == fCurrentMenuBar)
1863         fCurrentMenuBar = NULL;
1864     return S_OK;
1865 }
1866
1867 HRESULT STDMETHODCALLTYPE CShellBrowser::SetStatusTextSB(LPCOLESTR pszStatusText)
1868 {
1869     //
1870     if (pszStatusText)
1871     {
1872         ::SetWindowText(fStatusBar, pszStatusText);
1873     }
1874     else
1875     {
1876
1877     }
1878     return E_NOTIMPL;
1879 }
1880
1881 HRESULT STDMETHODCALLTYPE CShellBrowser::EnableModelessSB(BOOL fEnable)
1882 {
1883     return E_NOTIMPL;
1884 }
1885
1886 HRESULT STDMETHODCALLTYPE CShellBrowser::TranslateAcceleratorSB(MSG *pmsg, WORD wID)
1887 {
1888     return E_NOTIMPL;
1889 }
1890
1891 HRESULT STDMETHODCALLTYPE CShellBrowser::BrowseObject(LPCITEMIDLIST pidl, UINT wFlags)
1892 {
1893     return BrowseToPIDL(pidl, BTP_UPDATE_CUR_HISTORY | BTP_UPDATE_NEXT_HISTORY);
1894 }
1895
1896 HRESULT STDMETHODCALLTYPE CShellBrowser::GetViewStateStream(DWORD grfMode, IStream **ppStrm)
1897 {
1898     return E_NOTIMPL;
1899 }
1900
1901 HRESULT STDMETHODCALLTYPE CShellBrowser::GetControlWindow(UINT id, HWND *lphwnd)
1902 {
1903     if (lphwnd == NULL)
1904         return E_POINTER;
1905     *lphwnd = NULL;
1906     switch(id)
1907     {
1908         case FCW_TOOLBAR:
1909             *lphwnd = fToolbarProxy.m_hWnd;
1910             return S_OK;
1911         case FCW_STATUS:
1912             *lphwnd = fStatusBar;
1913             return S_OK;
1914         case FCW_TREE:
1915             // find the directory browser and return it
1916             // this should be used only to determine if a tree is present
1917             return S_OK;
1918         case FCW_PROGRESS:
1919             // is this a progress dialog?
1920             return S_OK;
1921     }
1922     return S_OK;
1923 }
1924
1925 HRESULT STDMETHODCALLTYPE CShellBrowser::SendControlMsg(
1926     UINT id, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *pret)
1927 {
1928     LPARAM                                  result;
1929
1930     if (pret != NULL)
1931         *pret = 0;
1932     switch(id)
1933     {
1934         case FCW_TOOLBAR:
1935             result = fToolbarProxy.SendMessage(uMsg, wParam, lParam);
1936             if (pret != NULL)
1937                 *pret = result;
1938             break;
1939         case FCW_STATUS:
1940             result = SendMessage(fStatusBar, uMsg, wParam, lParam);
1941             if (pret != NULL)
1942                 *pret = result;
1943             break;
1944     }
1945     return S_OK;
1946 }
1947
1948 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryActiveShellView(IShellView **ppshv)
1949 {
1950     if (ppshv == NULL)
1951         return E_POINTER;
1952     *ppshv = fCurrentShellView;
1953     if (fCurrentShellView.p != NULL)
1954         fCurrentShellView.p->AddRef();
1955     return S_OK;
1956 }
1957
1958 HRESULT STDMETHODCALLTYPE CShellBrowser::OnViewWindowActive(IShellView *ppshv)
1959 {
1960     return E_NOTIMPL;
1961 }
1962
1963 HRESULT STDMETHODCALLTYPE CShellBrowser::SetToolbarItems(LPTBBUTTON lpButtons, UINT nButtons, UINT uFlags)
1964 {
1965     return E_NOTIMPL;
1966 }
1967
1968 HRESULT STDMETHODCALLTYPE CShellBrowser::DragEnter(
1969     IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
1970 {
1971     return E_NOTIMPL;
1972 }
1973
1974 HRESULT STDMETHODCALLTYPE CShellBrowser::DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
1975 {
1976     return E_NOTIMPL;
1977 }
1978
1979 HRESULT STDMETHODCALLTYPE CShellBrowser::DragLeave()
1980 {
1981     return E_NOTIMPL;
1982 }
1983
1984 HRESULT STDMETHODCALLTYPE CShellBrowser::Drop(
1985     IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
1986 {
1987     return E_NOTIMPL;
1988 }
1989
1990 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
1991 {
1992     // view does a query for SID_STopLevelBrowser, IID_IShellBrowserService
1993     // the returned interface has a method GetPropertyBag on it
1994     if (IsEqualIID(guidService, SID_STopLevelBrowser))
1995         return this->QueryInterface(riid, ppvObject);
1996     if (IsEqualIID(guidService, SID_SShellBrowser))
1997         return this->QueryInterface(riid, ppvObject);
1998     if (IsEqualIID(guidService, SID_ITargetFrame2))
1999         return this->QueryInterface(riid, ppvObject);
2000     if (IsEqualIID(guidService, SID_IWebBrowserApp))        // without this, the internet toolbar won't reflect notifications
2001         return this->QueryInterface(riid, ppvObject);
2002     if (IsEqualIID(guidService, SID_SProxyBrowser))
2003         return this->QueryInterface(riid, ppvObject);
2004     if (IsEqualIID(guidService, SID_IExplorerToolbar))
2005         return fClientBars[BIInternetToolbar].clientBar->QueryInterface(riid, ppvObject);
2006     if (IsEqualIID(riid, IID_IShellBrowser))
2007         return this->QueryInterface(riid, ppvObject);
2008     return E_NOINTERFACE;
2009 }
2010
2011 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPropertyBag(long flags, REFIID riid, void **ppvObject)
2012 {
2013     if (ppvObject == NULL)
2014         return E_POINTER;
2015     *ppvObject = NULL;
2016     return E_NOTIMPL;
2017 }
2018
2019 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTypeInfoCount(UINT *pctinfo)
2020 {
2021     return E_NOTIMPL;
2022 }
2023
2024 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
2025 {
2026     return E_NOTIMPL;
2027 }
2028
2029 HRESULT STDMETHODCALLTYPE CShellBrowser::GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames,
2030     UINT cNames, LCID lcid, DISPID *rgDispId)
2031 {
2032     return E_NOTIMPL;
2033 }
2034
2035 HRESULT STDMETHODCALLTYPE CShellBrowser::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
2036     WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2037 {
2038     return E_NOTIMPL;
2039 }
2040
2041 HRESULT STDMETHODCALLTYPE CShellBrowser::GetParentSite(IOleInPlaceSite **ppipsite)
2042 {
2043     return E_NOTIMPL;
2044 }
2045
2046 HRESULT STDMETHODCALLTYPE CShellBrowser::SetTitle(IShellView *psv, LPCWSTR pszName)
2047 {
2048     return E_NOTIMPL;
2049 }
2050
2051 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTitle(IShellView *psv, LPWSTR pszName, DWORD cchName)
2052 {
2053     return E_NOTIMPL;
2054 }
2055
2056 HRESULT STDMETHODCALLTYPE CShellBrowser::GetOleObject(IOleObject **ppobjv)
2057 {
2058     return E_NOTIMPL;
2059 }
2060
2061 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTravelLog(ITravelLog **pptl)
2062 {
2063     HRESULT                                 hResult;
2064
2065     // called by toolbar when displaying tooltips
2066     if (pptl == NULL)
2067         return E_FAIL;
2068
2069     *pptl = NULL;
2070     if (fTravelLog.p == NULL)
2071     {
2072         hResult = CreateTravelLog(IID_PPV_ARG(ITravelLog, &fTravelLog));
2073         if (FAILED(hResult))
2074             return hResult;
2075     }
2076     *pptl = fTravelLog.p;
2077     fTravelLog.p->AddRef();
2078     return S_OK;
2079 }
2080
2081 HRESULT STDMETHODCALLTYPE CShellBrowser::ShowControlWindow(UINT id, BOOL fShow)
2082 {
2083     return E_NOTIMPL;
2084 }
2085
2086 HRESULT STDMETHODCALLTYPE CShellBrowser::IsControlWindowShown(UINT id, BOOL *pfShown)
2087 {
2088     return E_NOTIMPL;
2089 }
2090
2091 HRESULT STDMETHODCALLTYPE CShellBrowser::IEGetDisplayName(LPCITEMIDLIST pidl, LPWSTR pwszName, UINT uFlags)
2092 {
2093     return E_NOTIMPL;
2094 }
2095
2096 HRESULT STDMETHODCALLTYPE CShellBrowser::IEParseDisplayName(UINT uiCP, LPCWSTR pwszPath, LPITEMIDLIST *ppidlOut)
2097 {
2098     return E_NOTIMPL;
2099 }
2100
2101 HRESULT STDMETHODCALLTYPE CShellBrowser::DisplayParseError(HRESULT hres, LPCWSTR pwszPath)
2102 {
2103     return E_NOTIMPL;
2104 }
2105
2106 HRESULT STDMETHODCALLTYPE CShellBrowser::NavigateToPidl(LPCITEMIDLIST pidl, DWORD grfHLNF)
2107 {
2108     return E_NOTIMPL;
2109 }
2110
2111 HRESULT STDMETHODCALLTYPE CShellBrowser::SetNavigateState(BNSTATE bnstate)
2112 {
2113     return E_NOTIMPL;
2114 }
2115
2116 HRESULT STDMETHODCALLTYPE CShellBrowser::GetNavigateState(BNSTATE *pbnstate)
2117 {
2118     return E_NOTIMPL;
2119 }
2120
2121 HRESULT STDMETHODCALLTYPE CShellBrowser::NotifyRedirect(IShellView *psv, LPCITEMIDLIST pidl, BOOL *pfDidBrowse)
2122 {
2123     return E_NOTIMPL;
2124 }
2125
2126 HRESULT STDMETHODCALLTYPE CShellBrowser::UpdateWindowList()
2127 {
2128     return E_NOTIMPL;
2129 }
2130
2131 HRESULT STDMETHODCALLTYPE CShellBrowser::UpdateBackForwardState()
2132 {
2133     return E_NOTIMPL;
2134 }
2135
2136 HRESULT STDMETHODCALLTYPE CShellBrowser::SetFlags(DWORD dwFlags, DWORD dwFlagMask)
2137 {
2138     return E_NOTIMPL;
2139 }
2140
2141 HRESULT STDMETHODCALLTYPE CShellBrowser::GetFlags(DWORD *pdwFlags)
2142 {
2143     return E_NOTIMPL;
2144 }
2145
2146 HRESULT STDMETHODCALLTYPE CShellBrowser::CanNavigateNow()
2147 {
2148     return E_NOTIMPL;
2149 }
2150
2151 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPidl(LPITEMIDLIST *ppidl)
2152 {
2153     // called by explorer bar to get current pidl
2154     if (ppidl == NULL)
2155         return E_POINTER;
2156     *ppidl = ILClone(fCurrentDirectoryPIDL);
2157     return S_OK;
2158 }
2159
2160 HRESULT STDMETHODCALLTYPE CShellBrowser::SetReferrer(LPCITEMIDLIST pidl)
2161 {
2162     return E_NOTIMPL;
2163 }
2164
2165 DWORD STDMETHODCALLTYPE CShellBrowser::GetBrowserIndex()
2166 {
2167     return -1;
2168 }
2169
2170 HRESULT STDMETHODCALLTYPE CShellBrowser::GetBrowserByIndex(DWORD dwID, IUnknown **ppunk)
2171 {
2172     return E_NOTIMPL;
2173 }
2174
2175 HRESULT STDMETHODCALLTYPE CShellBrowser::GetHistoryObject(IOleObject **ppole, IStream **pstm, IBindCtx **ppbc)
2176 {
2177     if (ppole == NULL || pstm == NULL || ppbc == NULL)
2178         return E_INVALIDARG;
2179     *ppole = fHistoryObject;
2180     if (fHistoryObject != NULL)
2181         fHistoryObject->AddRef();
2182     *pstm = fHistoryStream;
2183     if (fHistoryStream != NULL)
2184         fHistoryStream->AddRef();
2185     *ppbc = fHistoryBindContext;
2186     if (fHistoryBindContext != NULL)
2187         fHistoryBindContext->AddRef();
2188     fHistoryObject = NULL;
2189     fHistoryStream = NULL;
2190     fHistoryBindContext = NULL;
2191     if (*ppole == NULL)
2192         return E_FAIL;
2193     return S_OK;
2194 }
2195
2196 HRESULT STDMETHODCALLTYPE CShellBrowser::SetHistoryObject(IOleObject *pole, BOOL fIsLocalAnchor)
2197 {
2198     return E_NOTIMPL;
2199 }
2200
2201 HRESULT STDMETHODCALLTYPE CShellBrowser::CacheOLEServer(IOleObject *pole)
2202 {
2203     return E_NOTIMPL;
2204 }
2205
2206 HRESULT STDMETHODCALLTYPE CShellBrowser::GetSetCodePage(VARIANT *pvarIn, VARIANT *pvarOut)
2207 {
2208     return E_NOTIMPL;
2209 }
2210
2211 HRESULT STDMETHODCALLTYPE CShellBrowser::OnHttpEquiv(
2212     IShellView *psv, BOOL fDone, VARIANT *pvarargIn, VARIANT *pvarargOut)
2213 {
2214     return E_NOTIMPL;
2215 }
2216
2217 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPalette(HPALETTE *hpal)
2218 {
2219     return E_NOTIMPL;
2220 }
2221
2222 HRESULT STDMETHODCALLTYPE CShellBrowser::RegisterWindow(BOOL fForceRegister, int swc)
2223 {
2224     return E_NOTIMPL;
2225 }
2226
2227 LRESULT STDMETHODCALLTYPE CShellBrowser::WndProcBS(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
2228 {
2229     return E_NOTIMPL;
2230 }
2231
2232 HRESULT STDMETHODCALLTYPE CShellBrowser::SetAsDefFolderSettings()
2233 {
2234     return E_NOTIMPL;
2235 }
2236
2237 HRESULT STDMETHODCALLTYPE CShellBrowser::GetViewRect(RECT *prc)
2238 {
2239     return E_NOTIMPL;
2240 }
2241
2242 HRESULT STDMETHODCALLTYPE CShellBrowser::OnSize(WPARAM wParam)
2243 {
2244     return E_NOTIMPL;
2245 }
2246
2247 HRESULT STDMETHODCALLTYPE CShellBrowser::OnCreate(struct tagCREATESTRUCTW *pcs)
2248 {
2249     return E_NOTIMPL;
2250 }
2251
2252 LRESULT STDMETHODCALLTYPE CShellBrowser::OnCommand(WPARAM wParam, LPARAM lParam)
2253 {
2254     return 0;
2255 }
2256
2257 HRESULT STDMETHODCALLTYPE CShellBrowser::OnDestroy()
2258 {
2259     return E_NOTIMPL;
2260 }
2261
2262 LRESULT STDMETHODCALLTYPE CShellBrowser::OnNotify(struct tagNMHDR *pnm)
2263 {
2264     return 0;
2265 }
2266
2267 HRESULT STDMETHODCALLTYPE CShellBrowser::OnSetFocus()
2268 {
2269     return E_NOTIMPL;
2270 }
2271
2272 HRESULT STDMETHODCALLTYPE CShellBrowser::OnFrameWindowActivateBS(BOOL fActive)
2273 {
2274     return E_NOTIMPL;
2275 }
2276
2277 HRESULT STDMETHODCALLTYPE CShellBrowser::ReleaseShellView()
2278 {
2279     return E_NOTIMPL;
2280 }
2281
2282 HRESULT STDMETHODCALLTYPE CShellBrowser::ActivatePendingView()
2283 {
2284     return E_NOTIMPL;
2285 }
2286
2287 HRESULT STDMETHODCALLTYPE CShellBrowser::CreateViewWindow(
2288     IShellView *psvNew, IShellView *psvOld, LPRECT prcView, HWND *phwnd)
2289 {
2290     return E_NOTIMPL;
2291 }
2292
2293 HRESULT STDMETHODCALLTYPE CShellBrowser::CreateBrowserPropSheetExt(REFIID riid, void **ppv)
2294 {
2295     return E_NOTIMPL;
2296 }
2297
2298 HRESULT STDMETHODCALLTYPE CShellBrowser::GetViewWindow(HWND *phwndView)
2299 {
2300     return E_NOTIMPL;
2301 }
2302
2303 HRESULT STDMETHODCALLTYPE CShellBrowser::GetBaseBrowserData(LPCBASEBROWSERDATA *pbbd)
2304 {
2305     return E_NOTIMPL;
2306 }
2307
2308 LPBASEBROWSERDATA STDMETHODCALLTYPE CShellBrowser::PutBaseBrowserData()
2309 {
2310     return NULL;
2311 }
2312
2313 HRESULT STDMETHODCALLTYPE CShellBrowser::InitializeTravelLog(ITravelLog *ptl, DWORD dw)
2314 {
2315     return E_NOTIMPL;
2316 }
2317
2318 HRESULT STDMETHODCALLTYPE CShellBrowser::SetTopBrowser()
2319 {
2320     return E_NOTIMPL;
2321 }
2322
2323 HRESULT STDMETHODCALLTYPE CShellBrowser::Offline(int iCmd)
2324 {
2325     return E_NOTIMPL;
2326 }
2327
2328 HRESULT STDMETHODCALLTYPE CShellBrowser::AllowViewResize(BOOL f)
2329 {
2330     return E_NOTIMPL;
2331 }
2332
2333 HRESULT STDMETHODCALLTYPE CShellBrowser::SetActivateState(UINT u)
2334 {
2335     return E_NOTIMPL;
2336 }
2337
2338 HRESULT STDMETHODCALLTYPE CShellBrowser::UpdateSecureLockIcon(int eSecureLock)
2339 {
2340     return E_NOTIMPL;
2341 }
2342
2343 HRESULT STDMETHODCALLTYPE CShellBrowser::InitializeDownloadManager()
2344 {
2345     return E_NOTIMPL;
2346 }
2347
2348 HRESULT STDMETHODCALLTYPE CShellBrowser::InitializeTransitionSite()
2349 {
2350     return E_NOTIMPL;
2351 }
2352
2353 HRESULT STDMETHODCALLTYPE CShellBrowser::_Initialize(HWND hwnd, IUnknown *pauto)
2354 {
2355     return E_NOTIMPL;
2356 }
2357
2358 HRESULT STDMETHODCALLTYPE CShellBrowser::_CancelPendingNavigationAsync()
2359 {
2360     return E_NOTIMPL;
2361 }
2362
2363 HRESULT STDMETHODCALLTYPE CShellBrowser::_CancelPendingView()
2364 {
2365     return E_NOTIMPL;
2366 }
2367
2368 HRESULT STDMETHODCALLTYPE CShellBrowser::_MaySaveChanges()
2369 {
2370     return E_NOTIMPL;
2371 }
2372
2373 HRESULT STDMETHODCALLTYPE CShellBrowser::_PauseOrResumeView(BOOL fPaused)
2374 {
2375     return E_NOTIMPL;
2376 }
2377
2378 HRESULT STDMETHODCALLTYPE CShellBrowser::_DisableModeless()
2379 {
2380     return E_NOTIMPL;
2381 }
2382
2383 HRESULT STDMETHODCALLTYPE CShellBrowser::_NavigateToPidl(LPCITEMIDLIST pidl, DWORD grfHLNF, DWORD dwFlags)
2384 {
2385     return E_NOTIMPL;
2386 }
2387
2388 HRESULT STDMETHODCALLTYPE CShellBrowser::_TryShell2Rename(IShellView *psv, LPCITEMIDLIST pidlNew)
2389 {
2390     return E_NOTIMPL;
2391 }
2392
2393 HRESULT STDMETHODCALLTYPE CShellBrowser::_SwitchActivationNow()
2394 {
2395     return E_NOTIMPL;
2396 }
2397
2398 HRESULT STDMETHODCALLTYPE CShellBrowser::_ExecChildren(IUnknown *punkBar, BOOL fBroadcast,
2399     const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
2400 {
2401     return E_NOTIMPL;
2402 }
2403
2404 HRESULT STDMETHODCALLTYPE CShellBrowser::_SendChildren(
2405     HWND hwndBar, BOOL fBroadcast, UINT uMsg, WPARAM wParam, LPARAM lParam)
2406 {
2407     return E_NOTIMPL;
2408 }
2409
2410 HRESULT STDMETHODCALLTYPE CShellBrowser::GetFolderSetData(struct tagFolderSetData *pfsd)
2411 {
2412     return E_NOTIMPL;
2413 }
2414
2415 HRESULT STDMETHODCALLTYPE CShellBrowser::_OnFocusChange(UINT itb)
2416 {
2417     return E_NOTIMPL;
2418 }
2419
2420 HRESULT STDMETHODCALLTYPE CShellBrowser::v_ShowHideChildWindows(BOOL fChildOnly)
2421 {
2422     return E_NOTIMPL;
2423 }
2424
2425 UINT STDMETHODCALLTYPE CShellBrowser::_get_itbLastFocus()
2426 {
2427     return 0;
2428 }
2429
2430 HRESULT STDMETHODCALLTYPE CShellBrowser::_put_itbLastFocus(UINT itbLastFocus)
2431 {
2432     return E_NOTIMPL;
2433 }
2434
2435 HRESULT STDMETHODCALLTYPE CShellBrowser::_UIActivateView(UINT uState)
2436 {
2437     return E_NOTIMPL;
2438 }
2439
2440 HRESULT STDMETHODCALLTYPE CShellBrowser::_GetViewBorderRect(RECT *prc)
2441 {
2442     return E_NOTIMPL;
2443 }
2444
2445 HRESULT STDMETHODCALLTYPE CShellBrowser::_UpdateViewRectSize()
2446 {
2447     return E_NOTIMPL;
2448 }
2449
2450 HRESULT STDMETHODCALLTYPE CShellBrowser::_ResizeNextBorder(UINT itb)
2451 {
2452     return E_NOTIMPL;
2453 }
2454
2455 HRESULT STDMETHODCALLTYPE CShellBrowser::_ResizeView()
2456 {
2457     return E_NOTIMPL;
2458 }
2459
2460 HRESULT STDMETHODCALLTYPE CShellBrowser::_GetEffectiveClientArea(LPRECT lprectBorder, HMONITOR hmon)
2461 {
2462     return E_NOTIMPL;
2463 }
2464
2465 IStream *STDMETHODCALLTYPE CShellBrowser::v_GetViewStream(LPCITEMIDLIST pidl, DWORD grfMode, LPCWSTR pwszName)
2466 {
2467     return NULL;
2468 }
2469
2470 LRESULT STDMETHODCALLTYPE CShellBrowser::ForwardViewMsg(UINT uMsg, WPARAM wParam, LPARAM lParam)
2471 {
2472     return 0;
2473 }
2474
2475 HRESULT STDMETHODCALLTYPE CShellBrowser::SetAcceleratorMenu(HACCEL hacc)
2476 {
2477     return E_NOTIMPL;
2478 }
2479
2480 int STDMETHODCALLTYPE CShellBrowser::_GetToolbarCount()
2481 {
2482     return 0;
2483 }
2484
2485 LPTOOLBARITEM STDMETHODCALLTYPE CShellBrowser::_GetToolbarItem(int itb)
2486 {
2487     return NULL;
2488 }
2489
2490 HRESULT STDMETHODCALLTYPE CShellBrowser::_SaveToolbars(IStream *pstm)
2491 {
2492     return E_NOTIMPL;
2493 }
2494
2495 HRESULT STDMETHODCALLTYPE CShellBrowser::_LoadToolbars(IStream *pstm)
2496 {
2497     return E_NOTIMPL;
2498 }
2499
2500 HRESULT STDMETHODCALLTYPE CShellBrowser::_CloseAndReleaseToolbars(BOOL fClose)
2501 {
2502     return E_NOTIMPL;
2503 }
2504
2505 HRESULT STDMETHODCALLTYPE CShellBrowser::v_MayGetNextToolbarFocus(
2506     LPMSG lpMsg, UINT itbNext, int citb, LPTOOLBARITEM *pptbi, HWND *phwnd)
2507 {
2508     return E_NOTIMPL;
2509 }
2510
2511 HRESULT STDMETHODCALLTYPE CShellBrowser::_ResizeNextBorderHelper(UINT itb, BOOL bUseHmonitor)
2512 {
2513     return E_NOTIMPL;
2514 }
2515
2516 UINT STDMETHODCALLTYPE CShellBrowser::_FindTBar(IUnknown *punkSrc)
2517 {
2518     return 0;
2519 }
2520
2521 HRESULT STDMETHODCALLTYPE CShellBrowser::_SetFocus(LPTOOLBARITEM ptbi, HWND hwnd, LPMSG lpMsg)
2522 {
2523     return E_NOTIMPL;
2524 }
2525
2526 HRESULT STDMETHODCALLTYPE CShellBrowser::v_MayTranslateAccelerator(MSG *pmsg)
2527 {
2528     return E_NOTIMPL;
2529 }
2530
2531 HRESULT STDMETHODCALLTYPE CShellBrowser::_GetBorderDWHelper(IUnknown *punkSrc, LPRECT lprectBorder, BOOL bUseHmonitor)
2532 {
2533     return E_NOTIMPL;
2534 }
2535
2536 HRESULT STDMETHODCALLTYPE CShellBrowser::v_CheckZoneCrossing(LPCITEMIDLIST pidl)
2537 {
2538     return E_NOTIMPL;
2539 }
2540
2541 HRESULT STDMETHODCALLTYPE CShellBrowser::GoBack()
2542 {
2543     CComPtr<ITravelLog>                     travelLog;
2544     HRESULT                                 hResult;
2545
2546     hResult = GetTravelLog(&travelLog);
2547     if (FAILED(hResult))
2548         return hResult;
2549     return travelLog->Travel(static_cast<IDropTarget *>(this), TLOG_BACK);
2550 }
2551
2552 HRESULT STDMETHODCALLTYPE CShellBrowser::GoForward()
2553 {
2554     CComPtr<ITravelLog>                     travelLog;
2555     HRESULT                                 hResult;
2556
2557     hResult = GetTravelLog(&travelLog);
2558     if (FAILED(hResult))
2559         return hResult;
2560     return travelLog->Travel(static_cast<IDropTarget *>(this), TLOG_FORE);
2561 }
2562
2563 HRESULT STDMETHODCALLTYPE CShellBrowser::GoHome()
2564 {
2565     return E_NOTIMPL;
2566 }
2567
2568 HRESULT STDMETHODCALLTYPE CShellBrowser::GoSearch()
2569 {
2570     return E_NOTIMPL;
2571 }
2572
2573 HRESULT STDMETHODCALLTYPE CShellBrowser::Navigate(BSTR URL, VARIANT *Flags,
2574     VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
2575 {
2576     return E_NOTIMPL;
2577 }
2578
2579 HRESULT STDMETHODCALLTYPE CShellBrowser::Refresh()
2580 {
2581     VARIANT                                 level;
2582
2583     V_VT(&level) = VT_I4;
2584     V_I4(&level) = 4;
2585     return Refresh2(&level);
2586 }
2587
2588 HRESULT STDMETHODCALLTYPE CShellBrowser::Refresh2(VARIANT *Level)
2589 {
2590     CComPtr<IOleCommandTarget>              oleCommandTarget;
2591     HRESULT                                 hResult;
2592
2593     hResult = fCurrentShellView->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &oleCommandTarget));
2594     if (FAILED(hResult))
2595         return hResult;
2596     return oleCommandTarget->Exec(NULL, 22, 1, Level, NULL);
2597 }
2598
2599 HRESULT STDMETHODCALLTYPE CShellBrowser::Stop()
2600 {
2601     return E_NOTIMPL;
2602 }
2603
2604 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Application(IDispatch **ppDisp)
2605 {
2606     return E_NOTIMPL;
2607 }
2608
2609 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Parent(IDispatch **ppDisp)
2610 {
2611     return E_NOTIMPL;
2612 }
2613
2614 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Container(IDispatch **ppDisp)
2615 {
2616     return E_NOTIMPL;
2617 }
2618
2619 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Document(IDispatch **ppDisp)
2620 {
2621     return E_NOTIMPL;
2622 }
2623
2624 HRESULT STDMETHODCALLTYPE CShellBrowser::get_TopLevelContainer(VARIANT_BOOL *pBool)
2625 {
2626     return E_NOTIMPL;
2627 }
2628
2629 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Type(BSTR *Type)
2630 {
2631     return E_NOTIMPL;
2632 }
2633 #ifdef __exdisp_h__
2634 #define long LONG
2635 #endif
2636 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Left(long *pl)
2637 {
2638     return E_NOTIMPL;
2639 }
2640
2641 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Left(long Left)
2642 {
2643     return E_NOTIMPL;
2644 }
2645
2646 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Top(long *pl)
2647 {
2648     return E_NOTIMPL;
2649 }
2650
2651 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Top(long Top)
2652 {
2653     return E_NOTIMPL;
2654 }
2655
2656 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Width(long *pl)
2657 {
2658     return E_NOTIMPL;
2659 }
2660
2661 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Width(long Width)
2662 {
2663     return E_NOTIMPL;
2664 }
2665
2666 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Height(long *pl)
2667 {
2668     return E_NOTIMPL;
2669 }
2670
2671 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Height(long Height)
2672 {
2673     return E_NOTIMPL;
2674 }
2675 #ifdef __exdisp_h__
2676 #undef long
2677 #endif
2678 HRESULT STDMETHODCALLTYPE CShellBrowser::get_LocationName(BSTR *LocationName)
2679 {
2680     return E_NOTIMPL;
2681 }
2682
2683 HRESULT STDMETHODCALLTYPE CShellBrowser::get_LocationURL(BSTR *LocationURL)
2684 {
2685     return E_NOTIMPL;
2686 }
2687
2688 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Busy(VARIANT_BOOL *pBool)
2689 {
2690     return E_NOTIMPL;
2691 }
2692
2693 HRESULT STDMETHODCALLTYPE CShellBrowser::Quit()
2694 {
2695     return E_NOTIMPL;
2696 }
2697
2698 HRESULT STDMETHODCALLTYPE CShellBrowser::ClientToWindow(int *pcx, int *pcy)
2699 {
2700     return E_NOTIMPL;
2701 }
2702
2703 HRESULT STDMETHODCALLTYPE CShellBrowser::PutProperty(BSTR Property, VARIANT vtValue)
2704 {
2705     return E_NOTIMPL;
2706 }
2707
2708 HRESULT STDMETHODCALLTYPE CShellBrowser::GetProperty(BSTR Property, VARIANT *pvtValue)
2709 {
2710     return E_NOTIMPL;
2711 }
2712
2713 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Name(BSTR *Name)
2714 {
2715     return E_NOTIMPL;
2716 }
2717
2718 HRESULT STDMETHODCALLTYPE CShellBrowser::get_HWND(SHANDLE_PTR *pHWND)
2719 {
2720     return E_NOTIMPL;
2721 }
2722
2723 HRESULT STDMETHODCALLTYPE CShellBrowser::get_FullName(BSTR *FullName)
2724 {
2725     return E_NOTIMPL;
2726 }
2727
2728 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Path(BSTR *Path)
2729 {
2730     return E_NOTIMPL;
2731 }
2732
2733 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Visible(VARIANT_BOOL *pBool)
2734 {
2735     return E_NOTIMPL;
2736 }
2737
2738 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Visible(VARIANT_BOOL Value)
2739 {
2740     return E_NOTIMPL;
2741 }
2742
2743 HRESULT STDMETHODCALLTYPE CShellBrowser::get_StatusBar(VARIANT_BOOL *pBool)
2744 {
2745     return E_NOTIMPL;
2746 }
2747
2748 HRESULT STDMETHODCALLTYPE CShellBrowser::put_StatusBar(VARIANT_BOOL Value)
2749 {
2750     return E_NOTIMPL;
2751 }
2752
2753 HRESULT STDMETHODCALLTYPE CShellBrowser::get_StatusText(BSTR *StatusText)
2754 {
2755     return E_NOTIMPL;
2756 }
2757
2758 HRESULT STDMETHODCALLTYPE CShellBrowser::put_StatusText(BSTR StatusText)
2759 {
2760     return E_NOTIMPL;
2761 }
2762
2763 HRESULT STDMETHODCALLTYPE CShellBrowser::get_ToolBar(int *Value)
2764 {
2765     return E_NOTIMPL;
2766 }
2767
2768 HRESULT STDMETHODCALLTYPE CShellBrowser::put_ToolBar(int Value)
2769 {
2770     return E_NOTIMPL;
2771 }
2772
2773 HRESULT STDMETHODCALLTYPE CShellBrowser::get_MenuBar(VARIANT_BOOL *Value)
2774 {
2775     return E_NOTIMPL;
2776 }
2777
2778 HRESULT STDMETHODCALLTYPE CShellBrowser::put_MenuBar(VARIANT_BOOL Value)
2779 {
2780     return E_NOTIMPL;
2781 }
2782
2783 HRESULT STDMETHODCALLTYPE CShellBrowser::get_FullScreen(VARIANT_BOOL *pbFullScreen)
2784 {
2785     return E_NOTIMPL;
2786 }
2787
2788 HRESULT STDMETHODCALLTYPE CShellBrowser::put_FullScreen(VARIANT_BOOL bFullScreen)
2789 {
2790     return E_NOTIMPL;
2791 }
2792
2793 HRESULT STDMETHODCALLTYPE CShellBrowser::Navigate2(VARIANT *URL, VARIANT *Flags,
2794     VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
2795 {
2796     LPITEMIDLIST                            pidl;
2797     HRESULT                                 hResult;
2798
2799     // called from drive combo box to navigate to a directory
2800     if (V_VT(URL) != (VT_ARRAY | VT_UI1))
2801         return E_INVALIDARG;
2802     if (V_ARRAY(URL)->cDims != 1 || V_ARRAY(URL)->cbElements != 1)
2803         return E_INVALIDARG;
2804     pidl = (LPITEMIDLIST)V_ARRAY(URL)->pvData;
2805     hResult = BrowseToPIDL((LPITEMIDLIST)pidl, BTP_UPDATE_CUR_HISTORY | BTP_UPDATE_NEXT_HISTORY);
2806     if (FAILED(hResult))
2807         return hResult;
2808     return S_OK;
2809 }
2810
2811 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryStatusWB(OLECMDID cmdID, OLECMDF *pcmdf)
2812 {
2813     return E_NOTIMPL;
2814 }
2815
2816 HRESULT STDMETHODCALLTYPE CShellBrowser::ExecWB(OLECMDID cmdID, OLECMDEXECOPT cmdexecopt,
2817     VARIANT *pvaIn, VARIANT *pvaOut)
2818 {
2819     return E_NOTIMPL;
2820 }
2821
2822 HRESULT STDMETHODCALLTYPE CShellBrowser::ShowBrowserBar(VARIANT *pvaClsid, VARIANT *pvarShow, VARIANT *pvarSize)
2823 {
2824     CLSID                                   classID;
2825     bool                                    vertical;
2826
2827     // called to show search bar
2828     if (V_VT(pvaClsid) != VT_BSTR)
2829         return E_INVALIDARG;
2830     CLSIDFromString(V_BSTR(pvaClsid), &classID);
2831     // TODO: properly compute the value of vertical
2832     vertical = true;
2833     return ShowBand(classID, vertical);
2834 }
2835
2836 HRESULT STDMETHODCALLTYPE CShellBrowser::get_ReadyState(READYSTATE *plReadyState)
2837 {
2838     return E_NOTIMPL;
2839 }
2840
2841 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Offline(VARIANT_BOOL *pbOffline)
2842 {
2843     return E_NOTIMPL;
2844 }
2845
2846 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Offline(VARIANT_BOOL bOffline)
2847 {
2848     return E_NOTIMPL;
2849 }
2850
2851 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Silent(VARIANT_BOOL *pbSilent)
2852 {
2853     return E_NOTIMPL;
2854 }
2855
2856 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Silent(VARIANT_BOOL bSilent)
2857 {
2858     return E_NOTIMPL;
2859 }
2860
2861 HRESULT STDMETHODCALLTYPE CShellBrowser::get_RegisterAsBrowser(VARIANT_BOOL *pbRegister)
2862 {
2863     return E_NOTIMPL;
2864 }
2865
2866 HRESULT STDMETHODCALLTYPE CShellBrowser::put_RegisterAsBrowser(VARIANT_BOOL bRegister)
2867 {
2868     return E_NOTIMPL;
2869 }
2870
2871 HRESULT STDMETHODCALLTYPE CShellBrowser::get_RegisterAsDropTarget(VARIANT_BOOL *pbRegister)
2872 {
2873     return E_NOTIMPL;
2874 }
2875
2876 HRESULT STDMETHODCALLTYPE CShellBrowser::put_RegisterAsDropTarget(VARIANT_BOOL bRegister)
2877 {
2878     return E_NOTIMPL;
2879 }
2880
2881 HRESULT STDMETHODCALLTYPE CShellBrowser::get_TheaterMode(VARIANT_BOOL *pbRegister)
2882 {
2883     return E_NOTIMPL;
2884 }
2885
2886 HRESULT STDMETHODCALLTYPE CShellBrowser::put_TheaterMode(VARIANT_BOOL bRegister)
2887 {
2888     return E_NOTIMPL;
2889 }
2890
2891 HRESULT STDMETHODCALLTYPE CShellBrowser::get_AddressBar(VARIANT_BOOL *Value)
2892 {
2893     return E_NOTIMPL;
2894 }
2895
2896 HRESULT STDMETHODCALLTYPE CShellBrowser::put_AddressBar(VARIANT_BOOL Value)
2897 {
2898     return E_NOTIMPL;
2899 }
2900
2901 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Resizable(VARIANT_BOOL *Value)
2902 {
2903     return E_NOTIMPL;
2904 }
2905
2906 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Resizable(VARIANT_BOOL Value)
2907 {
2908     return E_NOTIMPL;
2909 }
2910
2911 HRESULT STDMETHODCALLTYPE CShellBrowser::FindWindowByIndex(DWORD dwID, IUnknown **ppunk)
2912 {
2913     return E_NOTIMPL;
2914 }
2915
2916 HRESULT STDMETHODCALLTYPE CShellBrowser::GetWindowData(IStream *pStream, LPWINDOWDATA pWinData)
2917 {
2918     if (pWinData == NULL)
2919         return E_POINTER;
2920
2921     pWinData->dwWindowID = -1;
2922     pWinData->uiCP = 0;
2923     pWinData->pidl = ILClone(fCurrentDirectoryPIDL);
2924     pWinData->lpszUrl = NULL;
2925     pWinData->lpszUrlLocation = NULL;
2926     pWinData->lpszTitle = NULL;
2927     return S_OK;
2928 }
2929
2930 HRESULT STDMETHODCALLTYPE CShellBrowser::LoadHistoryPosition(LPWSTR pszUrlLocation, DWORD dwPosition)
2931 {
2932     return E_NOTIMPL;
2933 }
2934
2935 HRESULT STDMETHODCALLTYPE CShellBrowser::GetClassID(CLSID *pClassID)
2936 {
2937     return E_NOTIMPL;
2938 }
2939
2940 HRESULT STDMETHODCALLTYPE CShellBrowser::LoadHistory(IStream *pStream, IBindCtx *pbc)
2941 {
2942     CComPtr<IPersistHistory>                viewPersistHistory;
2943     CComPtr<IOleObject>                     viewHistoryObject;
2944     persistState                            oldState;
2945     ULONG                                   numRead;
2946     LPITEMIDLIST                            pidl;
2947     HRESULT                                 hResult;
2948
2949     hResult = pStream->Read(&oldState, sizeof(oldState), &numRead);
2950     if (FAILED(hResult))
2951         return hResult;
2952     if (numRead != sizeof(oldState) || oldState.dwSize != sizeof(oldState))
2953         return E_FAIL;
2954     if (oldState.browseType != 2)
2955         return E_FAIL;
2956     pidl = static_cast<LPITEMIDLIST>(CoTaskMemAlloc(oldState.pidlSize));
2957     if (pidl == NULL)
2958         return E_OUTOFMEMORY;
2959     hResult = pStream->Read(pidl, oldState.pidlSize, &numRead);
2960     if (FAILED(hResult))
2961     {
2962         ILFree(pidl);
2963         return hResult;
2964     }
2965     if (numRead != oldState.pidlSize)
2966     {
2967         ILFree(pidl);
2968         return E_FAIL;
2969     }
2970     hResult = CoCreateInstance(oldState.persistClass, NULL, CLSCTX_LOCAL_SERVER | CLSCTX_INPROC_SERVER,
2971         IID_PPV_ARG(IOleObject, &viewHistoryObject));
2972     fHistoryObject = viewHistoryObject;
2973     fHistoryStream = pStream;
2974     fHistoryBindContext = pbc;
2975     hResult = BrowseToPIDL(pidl, BTP_UPDATE_CUR_HISTORY);
2976     fHistoryObject = NULL;
2977     fHistoryStream = NULL;
2978     fHistoryBindContext = NULL;
2979     ILFree(pidl);
2980     if (FAILED(hResult))
2981         return hResult;
2982     return S_OK;
2983 }
2984
2985 HRESULT STDMETHODCALLTYPE CShellBrowser::SaveHistory(IStream *pStream)
2986 {
2987     CComPtr<IPersistHistory>                viewPersistHistory;
2988     persistState                            newState;
2989     HRESULT                                 hResult;
2990
2991     hResult = fCurrentShellView->GetItemObject(
2992         SVGIO_BACKGROUND, IID_PPV_ARG(IPersistHistory, &viewPersistHistory));
2993     memset(&newState, 0, sizeof(newState));
2994     newState.dwSize = sizeof(newState);
2995     newState.browseType = 2;
2996     newState.browserIndex = GetBrowserIndex();
2997     if (viewPersistHistory.p != NULL)
2998     {
2999         hResult = viewPersistHistory->GetClassID(&newState.persistClass);
3000         if (FAILED(hResult))
3001             return hResult;
3002     }
3003     newState.pidlSize = ILGetSize(fCurrentDirectoryPIDL);
3004     hResult = pStream->Write(&newState, sizeof(newState), NULL);
3005     if (FAILED(hResult))
3006         return hResult;
3007     hResult = pStream->Write(fCurrentDirectoryPIDL, newState.pidlSize, NULL);
3008     if (FAILED(hResult))
3009         return hResult;
3010     if (viewPersistHistory.p != NULL)
3011     {
3012         hResult = viewPersistHistory->SaveHistory(pStream);
3013         if (FAILED(hResult))
3014             return hResult;
3015     }
3016     return S_OK;
3017 }
3018
3019 HRESULT STDMETHODCALLTYPE CShellBrowser::SetPositionCookie(DWORD dwPositioncookie)
3020 {
3021     return E_NOTIMPL;
3022 }
3023
3024 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPositionCookie(DWORD *pdwPositioncookie)
3025 {
3026     return E_NOTIMPL;
3027 }
3028
3029 LRESULT CShellBrowser::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3030 {
3031     // TODO: rip down everything
3032     PostQuitMessage(0);
3033     return 0;
3034 }
3035
3036 LRESULT CShellBrowser::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3037 {
3038     CComPtr<IDockingWindow>                 dockingWindow;
3039     RECT                                    availableBounds;
3040     static const INT                        excludeItems[] = {1, 1, 1, 0xa001, 0, 0};
3041     HRESULT                                 hResult;
3042
3043     if (wParam != SIZE_MINIMIZED)
3044     {
3045         GetEffectiveClientRect(m_hWnd, &availableBounds, excludeItems);
3046         for (INT x = 0; x < 3; x++)
3047         {
3048             if (fClientBars[x].clientBar != NULL)
3049             {
3050                 hResult = fClientBars[x].clientBar->QueryInterface(
3051                     IID_PPV_ARG(IDockingWindow, &dockingWindow));
3052                 if (SUCCEEDED(hResult) && dockingWindow != NULL)
3053                 {
3054                     hResult = dockingWindow->ResizeBorderDW(
3055                         &availableBounds, static_cast<IDropTarget *>(this), TRUE);
3056                     break;
3057                 }
3058             }
3059         }
3060         RepositionBars();
3061     }
3062     return 1;
3063 }
3064
3065 LRESULT CShellBrowser::OnInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3066 {
3067     HMENU                                   theMenu;
3068
3069     theMenu = reinterpret_cast<HMENU>(wParam);
3070     if (theMenu == SHGetMenuFromID(fCurrentMenuBar, FCIDM_MENU_VIEW))
3071         UpdateViewMenu(theMenu);
3072     return RelayMsgToShellView(uMsg, wParam, lParam, bHandled);
3073 }
3074
3075 LRESULT CShellBrowser::RelayMsgToShellView(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3076 {
3077     if (fCurrentShellViewWindow != NULL)
3078         return SendMessage(fCurrentShellViewWindow, uMsg, wParam, lParam);
3079     return 0;
3080 }
3081
3082 LRESULT CShellBrowser::OnClose(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3083 {
3084     return 0;
3085 }
3086
3087 LRESULT CShellBrowser::OnFolderOptions(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3088 {
3089     HRESULT                                 hResult;
3090
3091     hResult = DoFolderOptions();
3092     return 0;
3093 }
3094
3095 LRESULT CShellBrowser::OnMapNetworkDrive(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3096 {
3097 #ifndef __REACTOS__
3098     WNetConnectionDialog(m_hWnd, RESOURCETYPE_DISK);
3099 #endif /* __REACTOS__ */
3100     return 0;
3101 }
3102
3103 LRESULT CShellBrowser::OnDisconnectNetworkDrive(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3104 {
3105 #ifndef __REACTOS__
3106     WNetDisconnectDialog(m_hWnd, RESOURCETYPE_DISK);
3107 #endif /* __REACTOS__ */
3108     return 0;
3109 }
3110
3111 LRESULT CShellBrowser::OnAboutReactOS(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3112 {
3113     ShellAbout(m_hWnd, _T("ReactOS"), _T(""), NULL);
3114     return 0;
3115 }
3116
3117 LRESULT CShellBrowser::OnGoBack(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3118 {
3119     HRESULT                                 hResult;
3120
3121     hResult = GoBack();
3122     return 0;
3123 }
3124
3125 LRESULT CShellBrowser::OnGoForward(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3126 {
3127     HRESULT                                 hResult;
3128
3129     hResult = GoForward();
3130     return 0;
3131 }
3132
3133 LRESULT CShellBrowser::OnGoUpLevel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3134 {
3135     HRESULT                                 hResult;
3136
3137     hResult = NavigateToParent();
3138     return 0;
3139 }
3140
3141 LRESULT CShellBrowser::OnGoHome(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3142 {
3143     HRESULT                                 hResult;
3144
3145     hResult = GoHome();
3146     return 0;
3147 }
3148
3149 LRESULT CShellBrowser::OnIsThisLegal(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3150 {
3151     HRESULT                                 hResult;
3152
3153     typedef HRESULT (WINAPI *PSHOpenNewFrame)(LPITEMIDLIST pidl, IUnknown *b, long c, long d);
3154     PSHOpenNewFrame Func;
3155     HMODULE hShlwapi;
3156
3157     hShlwapi = LoadLibrary(TEXT("browseui.dll"));
3158     if (hShlwapi != NULL)
3159         Func = reinterpret_cast<PSHOpenNewFrame>(GetProcAddress(hShlwapi, (LPCSTR)103));
3160     else
3161         Func = NULL;
3162     if (Func != NULL)
3163     {
3164         LPITEMIDLIST                        desktopPIDL;
3165
3166         hResult = SHGetFolderLocation(NULL, CSIDL_DESKTOP, NULL, 0, &desktopPIDL);
3167         if (SUCCEEDED(hResult))
3168         {
3169             hResult = Func(desktopPIDL, NULL, -1, 1);
3170         }
3171     }
3172     return 0;
3173 }
3174
3175 LRESULT CShellBrowser::OnToggleStatusBarVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3176 {
3177     fStatusBarVisible = !fStatusBarVisible;
3178     // TODO: trigger a relayout of contained items
3179     return 0;
3180 }
3181
3182 LRESULT CShellBrowser::OnToggleToolbarLock(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3183 {
3184     CComPtr<IOleCommandTarget>              commandTarget;
3185     HRESULT                                 hResult;
3186
3187     hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3188         IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3189     if (FAILED(hResult))
3190         return 0;
3191     hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_TOOLBARLOCKED, 0, NULL, NULL);
3192     return 0;
3193 }
3194
3195 LRESULT CShellBrowser::OnToggleToolbarBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3196 {
3197     CComPtr<IOleCommandTarget>              commandTarget;
3198     HRESULT                                 hResult;
3199
3200     hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3201         IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3202     if (FAILED(hResult))
3203         return 0;
3204     hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_TOOLBARBANDSHOWN, 0, NULL, NULL);
3205     return 0;
3206 }
3207
3208 LRESULT CShellBrowser::OnToggleAddressBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3209 {
3210     CComPtr<IOleCommandTarget>              commandTarget;
3211     HRESULT                                 hResult;
3212
3213     hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3214         IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3215     if (FAILED(hResult))
3216         return 0;
3217     hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_ADDRESSBANDSHOWN, 0, NULL, NULL);
3218     return 0;
3219 }
3220
3221 LRESULT CShellBrowser::OnToggleLinksBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3222 {
3223     CComPtr<IOleCommandTarget>              commandTarget;
3224     HRESULT                                 hResult;
3225
3226     hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3227         IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3228     if (FAILED(hResult))
3229         return 0;
3230     hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_LINKSBANDSHOWN, 0, NULL, NULL);
3231     return 0;
3232 }
3233
3234 LRESULT CShellBrowser::OnToggleTextLabels(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3235 {
3236     CComPtr<IOleCommandTarget>              commandTarget;
3237     HRESULT                                 hResult;
3238
3239     hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3240         IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3241     if (FAILED(hResult))
3242         return 0;
3243     hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_TEXTLABELS, 0, NULL, NULL);
3244     return 0;
3245 }
3246
3247 LRESULT CShellBrowser::OnToolbarCustomize(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3248 {
3249     CComPtr<IOleCommandTarget>              commandTarget;
3250     HRESULT                                 hResult;
3251
3252     hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3253         IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3254     if (FAILED(hResult))
3255         return 0;
3256     hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_CUSTOMIZEENABLED, 0, NULL, NULL);
3257     return 0;
3258 }
3259
3260 LRESULT CShellBrowser::OnGoTravel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3261 {
3262     return 0;
3263 }
3264
3265 LRESULT CShellBrowser::RelayCommands(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3266 {
3267     if (HIWORD(wParam) == 0 && LOWORD(wParam) < FCIDM_SHVIEWLAST && fCurrentShellViewWindow != NULL)
3268         return SendMessage(fCurrentShellViewWindow, uMsg, wParam, lParam);
3269     return 0;
3270 }
3271
3272 //static LRESULT CALLBACK ExplorerWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
3273 //{
3274 //    return DefWindowProc(hwnd, uMsg, wParam, lParam);
3275 //}
3276
3277 static void ExplorerMessageLoop()
3278 {
3279     MSG Msg;
3280     BOOL Ret;
3281
3282     while (1)
3283     {
3284         Ret = (GetMessage(&Msg, NULL, 0, 0) != 0);
3285
3286         if (Ret != -1)
3287         {
3288             if (!Ret)
3289                 break;
3290
3291             TranslateMessage(&Msg);
3292             DispatchMessage(&Msg);
3293
3294             if (Msg.message == WM_QUIT)
3295                 break;
3296         }
3297     }
3298 }
3299
3300 DWORD WINAPI BrowserThreadProc(LPVOID lpThreadParameter)
3301 {
3302     CComPtr<IShellBrowser>                  shellBrowser;
3303     CComObject<CShellBrowser>               *theCabinet;
3304     IEThreadParamBlock                      *parameters;
3305     HRESULT                                 hResult;
3306
3307     parameters = (IEThreadParamBlock *)lpThreadParameter;
3308     OleInitialize(NULL);
3309     ATLTRY (theCabinet = new CComObject<CShellBrowser>);
3310     if (theCabinet == NULL)
3311         return E_OUTOFMEMORY;
3312     hResult = theCabinet->QueryInterface(IID_PPV_ARG(IShellBrowser, &shellBrowser));
3313     if (FAILED(hResult))
3314     {
3315         delete theCabinet;
3316         return hResult;
3317     }
3318     hResult = theCabinet->Initialize(parameters->directoryPIDL, 0, 0, 0);
3319     if (FAILED(hResult))
3320         return hResult;
3321     ExplorerMessageLoop();
3322     OleUninitialize();
3323     return 0;
3324 }