projects / reactos.git / blob
? search:


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