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