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