projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[BROWSEUI]
[reactos.git] / dll / win32 / browseui / shellbrowser.cpp
1 /*
2 * ReactOS Explorer
3 *
4 * Copyright 2009 Andrew Hill <ash77 at domain reactos.org>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "precomp.h"
22
23 #include <shellapi.h>
24 #include <htiframe.h>
25 #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 hResult = shellMenu->SetMenu(hmenuShared, m_hWnd, SMSET_DONTOWN);
1878 if (FAILED_UNEXPECTEDLY(hResult))
1879 return hResult;
1880 fCurrentMenuBar = hmenuShared;
1881 return S_OK;
1882 }
1883
1884 HRESULT STDMETHODCALLTYPE CShellBrowser::RemoveMenusSB(HMENU hmenuShared)
1885 {
1886 if (hmenuShared == fCurrentMenuBar)
1887 {
1888 //DestroyMenu(fCurrentMenuBar);
1889 SetMenuSB(NULL, NULL, NULL);
1890 }
1891 return S_OK;
1892 }
1893
1894 HRESULT STDMETHODCALLTYPE CShellBrowser::SetStatusTextSB(LPCOLESTR pszStatusText)
1895 {
1896 //
1897 if (pszStatusText)
1898 {
1899 ::SetWindowText(fStatusBar, pszStatusText);
1900 }
1901 else
1902 {
1903
1904 }
1905 return E_NOTIMPL;
1906 }
1907
1908 HRESULT STDMETHODCALLTYPE CShellBrowser::EnableModelessSB(BOOL fEnable)
1909 {
1910 return E_NOTIMPL;
1911 }
1912
1913 HRESULT STDMETHODCALLTYPE CShellBrowser::TranslateAcceleratorSB(MSG *pmsg, WORD wID)
1914 {
1915 if (!::TranslateAcceleratorW(m_hWnd, m_hAccel, pmsg))
1916 return S_FALSE;
1917 return S_OK;
1918 }
1919
1920 HRESULT STDMETHODCALLTYPE CShellBrowser::BrowseObject(LPCITEMIDLIST pidl, UINT wFlags)
1921 {
1922 return BrowseToPIDL(pidl, BTP_UPDATE_CUR_HISTORY | BTP_UPDATE_NEXT_HISTORY);
1923 }
1924
1925 HRESULT STDMETHODCALLTYPE CShellBrowser::GetViewStateStream(DWORD grfMode, IStream **ppStrm)
1926 {
1927 return E_NOTIMPL;
1928 }
1929
1930 HRESULT STDMETHODCALLTYPE CShellBrowser::GetControlWindow(UINT id, HWND *lphwnd)
1931 {
1932 if (lphwnd == NULL)
1933 return E_POINTER;
1934 *lphwnd = NULL;
1935 switch(id)
1936 {
1937 case FCW_TOOLBAR:
1938 *lphwnd = fToolbarProxy.m_hWnd;
1939 return S_OK;
1940 case FCW_STATUS:
1941 *lphwnd = fStatusBar;
1942 return S_OK;
1943 case FCW_TREE:
1944 // find the directory browser and return it
1945 // this should be used only to determine if a tree is present
1946 return S_OK;
1947 case FCW_PROGRESS:
1948 // is this a progress dialog?
1949 return S_OK;
1950 }
1951 return S_OK;
1952 }
1953
1954 HRESULT STDMETHODCALLTYPE CShellBrowser::SendControlMsg(
1955 UINT id, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *pret)
1956 {
1957 LPARAM result;
1958
1959 if (pret != NULL)
1960 *pret = 0;
1961 switch(id)
1962 {
1963 case FCW_TOOLBAR:
1964 result = fToolbarProxy.SendMessage(uMsg, wParam, lParam);
1965 if (pret != NULL)
1966 *pret = result;
1967 break;
1968 case FCW_STATUS:
1969 result = SendMessage(fStatusBar, uMsg, wParam, lParam);
1970 if (pret != NULL)
1971 *pret = result;
1972 break;
1973 }
1974 return S_OK;
1975 }
1976
1977 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryActiveShellView(IShellView **ppshv)
1978 {
1979 if (ppshv == NULL)
1980 return E_POINTER;
1981 *ppshv = fCurrentShellView;
1982 if (fCurrentShellView.p != NULL)
1983 fCurrentShellView.p->AddRef();
1984 return S_OK;
1985 }
1986
1987 HRESULT STDMETHODCALLTYPE CShellBrowser::OnViewWindowActive(IShellView *ppshv)
1988 {
1989 return E_NOTIMPL;
1990 }
1991
1992 HRESULT STDMETHODCALLTYPE CShellBrowser::SetToolbarItems(LPTBBUTTON lpButtons, UINT nButtons, UINT uFlags)
1993 {
1994 return E_NOTIMPL;
1995 }
1996
1997 HRESULT STDMETHODCALLTYPE CShellBrowser::DragEnter(
1998 IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
1999 {
2000 return E_NOTIMPL;
2001 }
2002
2003 HRESULT STDMETHODCALLTYPE CShellBrowser::DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
2004 {
2005 return E_NOTIMPL;
2006 }
2007
2008 HRESULT STDMETHODCALLTYPE CShellBrowser::DragLeave()
2009 {
2010 return E_NOTIMPL;
2011 }
2012
2013 HRESULT STDMETHODCALLTYPE CShellBrowser::Drop(
2014 IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
2015 {
2016 return E_NOTIMPL;
2017 }
2018
2019 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
2020 {
2021 // view does a query for SID_STopLevelBrowser, IID_IShellBrowserService
2022 // the returned interface has a method GetPropertyBag on it
2023 if (IsEqualIID(guidService, SID_STopLevelBrowser))
2024 return this->QueryInterface(riid, ppvObject);
2025 if (IsEqualIID(guidService, SID_SShellBrowser))
2026 return this->QueryInterface(riid, ppvObject);
2027 if (IsEqualIID(guidService, SID_ITargetFrame2))
2028 return this->QueryInterface(riid, ppvObject);
2029 if (IsEqualIID(guidService, SID_IWebBrowserApp)) // without this, the internet toolbar won't reflect notifications
2030 return this->QueryInterface(riid, ppvObject);
2031 if (IsEqualIID(guidService, SID_SProxyBrowser))
2032 return this->QueryInterface(riid, ppvObject);
2033 if (IsEqualIID(guidService, SID_IExplorerToolbar))
2034 return fClientBars[BIInternetToolbar].clientBar->QueryInterface(riid, ppvObject);
2035 if (IsEqualIID(riid, IID_IShellBrowser))
2036 return this->QueryInterface(riid, ppvObject);
2037 return E_NOINTERFACE;
2038 }
2039
2040 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPropertyBag(long flags, REFIID riid, void **ppvObject)
2041 {
2042 if (ppvObject == NULL)
2043 return E_POINTER;
2044 *ppvObject = NULL;
2045 return E_NOTIMPL;
2046 }
2047
2048 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTypeInfoCount(UINT *pctinfo)
2049 {
2050 return E_NOTIMPL;
2051 }
2052
2053 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
2054 {
2055 return E_NOTIMPL;
2056 }
2057
2058 HRESULT STDMETHODCALLTYPE CShellBrowser::GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames,
2059 UINT cNames, LCID lcid, DISPID *rgDispId)
2060 {
2061 return E_NOTIMPL;
2062 }
2063
2064 HRESULT STDMETHODCALLTYPE CShellBrowser::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
2065 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2066 {
2067 return E_NOTIMPL;
2068 }
2069
2070 HRESULT STDMETHODCALLTYPE CShellBrowser::GetParentSite(IOleInPlaceSite **ppipsite)
2071 {
2072 return E_NOTIMPL;
2073 }
2074
2075 HRESULT STDMETHODCALLTYPE CShellBrowser::SetTitle(IShellView *psv, LPCWSTR pszName)
2076 {
2077 return E_NOTIMPL;
2078 }
2079
2080 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTitle(IShellView *psv, LPWSTR pszName, DWORD cchName)
2081 {
2082 return E_NOTIMPL;
2083 }
2084
2085 HRESULT STDMETHODCALLTYPE CShellBrowser::GetOleObject(IOleObject **ppobjv)
2086 {
2087 return E_NOTIMPL;
2088 }
2089
2090 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTravelLog(ITravelLog **pptl)
2091 {
2092 HRESULT hResult;
2093
2094 // called by toolbar when displaying tooltips
2095 if (pptl == NULL)
2096 return E_FAIL;
2097
2098 *pptl = NULL;
2099 if (fTravelLog.p == NULL)
2100 {
2101 hResult = CreateTravelLog(IID_PPV_ARG(ITravelLog, &fTravelLog));
2102 if (FAILED_UNEXPECTEDLY(hResult))
2103 return hResult;
2104 }
2105 *pptl = fTravelLog.p;
2106 fTravelLog.p->AddRef();
2107 return S_OK;
2108 }
2109
2110 HRESULT STDMETHODCALLTYPE CShellBrowser::ShowControlWindow(UINT id, BOOL fShow)
2111 {
2112 return E_NOTIMPL;
2113 }
2114
2115 HRESULT STDMETHODCALLTYPE CShellBrowser::IsControlWindowShown(UINT id, BOOL *pfShown)
2116 {
2117 return E_NOTIMPL;
2118 }
2119
2120 HRESULT STDMETHODCALLTYPE CShellBrowser::IEGetDisplayName(LPCITEMIDLIST pidl, LPWSTR pwszName, UINT uFlags)
2121 {
2122 return E_NOTIMPL;
2123 }
2124
2125 HRESULT STDMETHODCALLTYPE CShellBrowser::IEParseDisplayName(UINT uiCP, LPCWSTR pwszPath, LPITEMIDLIST *ppidlOut)
2126 {
2127 return E_NOTIMPL;
2128 }
2129
2130 HRESULT STDMETHODCALLTYPE CShellBrowser::DisplayParseError(HRESULT hres, LPCWSTR pwszPath)
2131 {
2132 return E_NOTIMPL;
2133 }
2134
2135 HRESULT STDMETHODCALLTYPE CShellBrowser::NavigateToPidl(LPCITEMIDLIST pidl, DWORD grfHLNF)
2136 {
2137 return E_NOTIMPL;
2138 }
2139
2140 HRESULT STDMETHODCALLTYPE CShellBrowser::SetNavigateState(BNSTATE bnstate)
2141 {
2142 return E_NOTIMPL;
2143 }
2144
2145 HRESULT STDMETHODCALLTYPE CShellBrowser::GetNavigateState(BNSTATE *pbnstate)
2146 {
2147 return E_NOTIMPL;
2148 }
2149
2150 HRESULT STDMETHODCALLTYPE CShellBrowser::NotifyRedirect(IShellView *psv, LPCITEMIDLIST pidl, BOOL *pfDidBrowse)
2151 {
2152 return E_NOTIMPL;
2153 }
2154
2155 HRESULT STDMETHODCALLTYPE CShellBrowser::UpdateWindowList()
2156 {
2157 return E_NOTIMPL;
2158 }
2159
2160 HRESULT STDMETHODCALLTYPE CShellBrowser::UpdateBackForwardState()
2161 {
2162 return E_NOTIMPL;
2163 }
2164
2165 HRESULT STDMETHODCALLTYPE CShellBrowser::SetFlags(DWORD dwFlags, DWORD dwFlagMask)
2166 {
2167 return E_NOTIMPL;
2168 }
2169
2170 HRESULT STDMETHODCALLTYPE CShellBrowser::GetFlags(DWORD *pdwFlags)
2171 {
2172 return E_NOTIMPL;
2173 }
2174
2175 HRESULT STDMETHODCALLTYPE CShellBrowser::CanNavigateNow()
2176 {
2177 return E_NOTIMPL;
2178 }
2179
2180 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPidl(LPITEMIDLIST *ppidl)
2181 {
2182 // called by explorer bar to get current pidl
2183 if (ppidl == NULL)
2184 return E_POINTER;
2185 *ppidl = ILClone(fCurrentDirectoryPIDL);
2186 return S_OK;
2187 }
2188
2189 HRESULT STDMETHODCALLTYPE CShellBrowser::SetReferrer(LPCITEMIDLIST pidl)
2190 {
2191 return E_NOTIMPL;
2192 }
2193
2194 DWORD STDMETHODCALLTYPE CShellBrowser::GetBrowserIndex()
2195 {
2196 return -1;
2197 }
2198
2199 HRESULT STDMETHODCALLTYPE CShellBrowser::GetBrowserByIndex(DWORD dwID, IUnknown **ppunk)
2200 {
2201 return E_NOTIMPL;
2202 }
2203
2204 HRESULT STDMETHODCALLTYPE CShellBrowser::GetHistoryObject(IOleObject **ppole, IStream **pstm, IBindCtx **ppbc)
2205 {
2206 if (ppole == NULL || pstm == NULL || ppbc == NULL)
2207 return E_INVALIDARG;
2208 *ppole = fHistoryObject;
2209 if (fHistoryObject != NULL)
2210 fHistoryObject->AddRef();
2211 *pstm = fHistoryStream;
2212 if (fHistoryStream != NULL)
2213 fHistoryStream->AddRef();
2214 *ppbc = fHistoryBindContext;
2215 if (fHistoryBindContext != NULL)
2216 fHistoryBindContext->AddRef();
2217 fHistoryObject = NULL;
2218 fHistoryStream = NULL;
2219 fHistoryBindContext = NULL;
2220 if (*ppole == NULL)
2221 return E_FAIL;
2222 return S_OK;
2223 }
2224
2225 HRESULT STDMETHODCALLTYPE CShellBrowser::SetHistoryObject(IOleObject *pole, BOOL fIsLocalAnchor)
2226 {
2227 return E_NOTIMPL;
2228 }
2229
2230 HRESULT STDMETHODCALLTYPE CShellBrowser::CacheOLEServer(IOleObject *pole)
2231 {
2232 return E_NOTIMPL;
2233 }
2234
2235 HRESULT STDMETHODCALLTYPE CShellBrowser::GetSetCodePage(VARIANT *pvarIn, VARIANT *pvarOut)
2236 {
2237 return E_NOTIMPL;
2238 }
2239
2240 HRESULT STDMETHODCALLTYPE CShellBrowser::OnHttpEquiv(
2241 IShellView *psv, BOOL fDone, VARIANT *pvarargIn, VARIANT *pvarargOut)
2242 {
2243 return E_NOTIMPL;
2244 }
2245
2246 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPalette(HPALETTE *hpal)
2247 {
2248 return E_NOTIMPL;
2249 }
2250
2251 HRESULT STDMETHODCALLTYPE CShellBrowser::RegisterWindow(BOOL fForceRegister, int swc)
2252 {
2253 return E_NOTIMPL;
2254 }
2255
2256 LRESULT STDMETHODCALLTYPE CShellBrowser::WndProcBS(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
2257 {
2258 return E_NOTIMPL;
2259 }
2260
2261 HRESULT STDMETHODCALLTYPE CShellBrowser::SetAsDefFolderSettings()
2262 {
2263 return E_NOTIMPL;
2264 }
2265
2266 HRESULT STDMETHODCALLTYPE CShellBrowser::GetViewRect(RECT *prc)
2267 {
2268 return E_NOTIMPL;
2269 }
2270
2271 HRESULT STDMETHODCALLTYPE CShellBrowser::OnSize(WPARAM wParam)
2272 {
2273 return E_NOTIMPL;
2274 }
2275
2276 HRESULT STDMETHODCALLTYPE CShellBrowser::OnCreate(struct tagCREATESTRUCTW *pcs)
2277 {
2278 m_hAccel = LoadAcceleratorsW(GetModuleHandle(L"browseui.dll"), MAKEINTRESOURCEW(256));
2279 return S_OK;
2280 }
2281
2282 LRESULT STDMETHODCALLTYPE CShellBrowser::OnCommand(WPARAM wParam, LPARAM lParam)
2283 {
2284 return 0;
2285 }
2286
2287 HRESULT STDMETHODCALLTYPE CShellBrowser::OnDestroy()
2288 {
2289 return E_NOTIMPL;
2290 }
2291
2292 LRESULT STDMETHODCALLTYPE CShellBrowser::OnNotify(struct tagNMHDR *pnm)
2293 {
2294 return 0;
2295 }
2296
2297 HRESULT STDMETHODCALLTYPE CShellBrowser::OnSetFocus()
2298 {
2299 return E_NOTIMPL;
2300 }
2301
2302 HRESULT STDMETHODCALLTYPE CShellBrowser::OnFrameWindowActivateBS(BOOL fActive)
2303 {
2304 return E_NOTIMPL;
2305 }
2306
2307 HRESULT STDMETHODCALLTYPE CShellBrowser::ReleaseShellView()
2308 {
2309 return E_NOTIMPL;
2310 }
2311
2312 HRESULT STDMETHODCALLTYPE CShellBrowser::ActivatePendingView()
2313 {
2314 return E_NOTIMPL;
2315 }
2316
2317 HRESULT STDMETHODCALLTYPE CShellBrowser::CreateViewWindow(
2318 IShellView *psvNew, IShellView *psvOld, LPRECT prcView, HWND *phwnd)
2319 {
2320 return E_NOTIMPL;
2321 }
2322
2323 HRESULT STDMETHODCALLTYPE CShellBrowser::CreateBrowserPropSheetExt(REFIID riid, void **ppv)
2324 {
2325 return E_NOTIMPL;
2326 }
2327
2328 HRESULT STDMETHODCALLTYPE CShellBrowser::GetViewWindow(HWND *phwndView)
2329 {
2330 return E_NOTIMPL;
2331 }
2332
2333 HRESULT STDMETHODCALLTYPE CShellBrowser::GetBaseBrowserData(LPCBASEBROWSERDATA *pbbd)
2334 {
2335 return E_NOTIMPL;
2336 }
2337
2338 LPBASEBROWSERDATA STDMETHODCALLTYPE CShellBrowser::PutBaseBrowserData()
2339 {
2340 return NULL;
2341 }
2342
2343 HRESULT STDMETHODCALLTYPE CShellBrowser::InitializeTravelLog(ITravelLog *ptl, DWORD dw)
2344 {
2345 return E_NOTIMPL;
2346 }
2347
2348 HRESULT STDMETHODCALLTYPE CShellBrowser::SetTopBrowser()
2349 {
2350 return E_NOTIMPL;
2351 }
2352
2353 HRESULT STDMETHODCALLTYPE CShellBrowser::Offline(int iCmd)
2354 {
2355 return E_NOTIMPL;
2356 }
2357
2358 HRESULT STDMETHODCALLTYPE CShellBrowser::AllowViewResize(BOOL f)
2359 {
2360 return E_NOTIMPL;
2361 }
2362
2363 HRESULT STDMETHODCALLTYPE CShellBrowser::SetActivateState(UINT u)
2364 {
2365 return E_NOTIMPL;
2366 }
2367
2368 HRESULT STDMETHODCALLTYPE CShellBrowser::UpdateSecureLockIcon(int eSecureLock)
2369 {
2370 return E_NOTIMPL;
2371 }
2372
2373 HRESULT STDMETHODCALLTYPE CShellBrowser::InitializeDownloadManager()
2374 {
2375 return E_NOTIMPL;
2376 }
2377
2378 HRESULT STDMETHODCALLTYPE CShellBrowser::InitializeTransitionSite()
2379 {
2380 return E_NOTIMPL;
2381 }
2382
2383 HRESULT STDMETHODCALLTYPE CShellBrowser::_Initialize(HWND hwnd, IUnknown *pauto)
2384 {
2385 return E_NOTIMPL;
2386 }
2387
2388 HRESULT STDMETHODCALLTYPE CShellBrowser::_CancelPendingNavigationAsync()
2389 {
2390 return E_NOTIMPL;
2391 }
2392
2393 HRESULT STDMETHODCALLTYPE CShellBrowser::_CancelPendingView()
2394 {
2395 return E_NOTIMPL;
2396 }
2397
2398 HRESULT STDMETHODCALLTYPE CShellBrowser::_MaySaveChanges()
2399 {
2400 return E_NOTIMPL;
2401 }
2402
2403 HRESULT STDMETHODCALLTYPE CShellBrowser::_PauseOrResumeView(BOOL fPaused)
2404 {
2405 return E_NOTIMPL;
2406 }
2407
2408 HRESULT STDMETHODCALLTYPE CShellBrowser::_DisableModeless()
2409 {
2410 return E_NOTIMPL;
2411 }
2412
2413 HRESULT STDMETHODCALLTYPE CShellBrowser::_NavigateToPidl(LPCITEMIDLIST pidl, DWORD grfHLNF, DWORD dwFlags)
2414 {
2415 return E_NOTIMPL;
2416 }
2417
2418 HRESULT STDMETHODCALLTYPE CShellBrowser::_TryShell2Rename(IShellView *psv, LPCITEMIDLIST pidlNew)
2419 {
2420 return E_NOTIMPL;
2421 }
2422
2423 HRESULT STDMETHODCALLTYPE CShellBrowser::_SwitchActivationNow()
2424 {
2425 return E_NOTIMPL;
2426 }
2427
2428 HRESULT STDMETHODCALLTYPE CShellBrowser::_ExecChildren(IUnknown *punkBar, BOOL fBroadcast,
2429 const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
2430 {
2431 return E_NOTIMPL;
2432 }
2433
2434 HRESULT STDMETHODCALLTYPE CShellBrowser::_SendChildren(
2435 HWND hwndBar, BOOL fBroadcast, UINT uMsg, WPARAM wParam, LPARAM lParam)
2436 {
2437 return E_NOTIMPL;
2438 }
2439
2440 HRESULT STDMETHODCALLTYPE CShellBrowser::GetFolderSetData(struct tagFolderSetData *pfsd)
2441 {
2442 return E_NOTIMPL;
2443 }
2444
2445 HRESULT STDMETHODCALLTYPE CShellBrowser::_OnFocusChange(UINT itb)
2446 {
2447 return E_NOTIMPL;
2448 }
2449
2450 HRESULT STDMETHODCALLTYPE CShellBrowser::v_ShowHideChildWindows(BOOL fChildOnly)
2451 {
2452 return E_NOTIMPL;
2453 }
2454
2455 UINT STDMETHODCALLTYPE CShellBrowser::_get_itbLastFocus()
2456 {
2457 return 0;
2458 }
2459
2460 HRESULT STDMETHODCALLTYPE CShellBrowser::_put_itbLastFocus(UINT itbLastFocus)
2461 {
2462 return E_NOTIMPL;
2463 }
2464
2465 HRESULT STDMETHODCALLTYPE CShellBrowser::_UIActivateView(UINT uState)
2466 {
2467 return E_NOTIMPL;
2468 }
2469
2470 HRESULT STDMETHODCALLTYPE CShellBrowser::_GetViewBorderRect(RECT *prc)
2471 {
2472 return E_NOTIMPL;
2473 }
2474
2475 HRESULT STDMETHODCALLTYPE CShellBrowser::_UpdateViewRectSize()
2476 {
2477 return E_NOTIMPL;
2478 }
2479
2480 HRESULT STDMETHODCALLTYPE CShellBrowser::_ResizeNextBorder(UINT itb)
2481 {
2482 return E_NOTIMPL;
2483 }
2484
2485 HRESULT STDMETHODCALLTYPE CShellBrowser::_ResizeView()
2486 {
2487 return E_NOTIMPL;
2488 }
2489
2490 HRESULT STDMETHODCALLTYPE CShellBrowser::_GetEffectiveClientArea(LPRECT lprectBorder, HMONITOR hmon)
2491 {
2492 return E_NOTIMPL;
2493 }
2494
2495 IStream *STDMETHODCALLTYPE CShellBrowser::v_GetViewStream(LPCITEMIDLIST pidl, DWORD grfMode, LPCWSTR pwszName)
2496 {
2497 return NULL;
2498 }
2499
2500 LRESULT STDMETHODCALLTYPE CShellBrowser::ForwardViewMsg(UINT uMsg, WPARAM wParam, LPARAM lParam)
2501 {
2502 return 0;
2503 }
2504
2505 HRESULT STDMETHODCALLTYPE CShellBrowser::SetAcceleratorMenu(HACCEL hacc)
2506 {
2507 return E_NOTIMPL;
2508 }
2509
2510 int STDMETHODCALLTYPE CShellBrowser::_GetToolbarCount()
2511 {
2512 return 0;
2513 }
2514
2515 LPTOOLBARITEM STDMETHODCALLTYPE CShellBrowser::_GetToolbarItem(int itb)
2516 {
2517 return NULL;
2518 }
2519
2520 HRESULT STDMETHODCALLTYPE CShellBrowser::_SaveToolbars(IStream *pstm)
2521 {
2522 return E_NOTIMPL;
2523 }
2524
2525 HRESULT STDMETHODCALLTYPE CShellBrowser::_LoadToolbars(IStream *pstm)
2526 {
2527 return E_NOTIMPL;
2528 }
2529
2530 HRESULT STDMETHODCALLTYPE CShellBrowser::_CloseAndReleaseToolbars(BOOL fClose)
2531 {
2532 return E_NOTIMPL;
2533 }
2534
2535 HRESULT STDMETHODCALLTYPE CShellBrowser::v_MayGetNextToolbarFocus(
2536 LPMSG lpMsg, UINT itbNext, int citb, LPTOOLBARITEM *pptbi, HWND *phwnd)
2537 {
2538 return E_NOTIMPL;
2539 }
2540
2541 HRESULT STDMETHODCALLTYPE CShellBrowser::_ResizeNextBorderHelper(UINT itb, BOOL bUseHmonitor)
2542 {
2543 return E_NOTIMPL;
2544 }
2545
2546 UINT STDMETHODCALLTYPE CShellBrowser::_FindTBar(IUnknown *punkSrc)
2547 {
2548 return 0;
2549 }
2550
2551 HRESULT STDMETHODCALLTYPE CShellBrowser::_SetFocus(LPTOOLBARITEM ptbi, HWND hwnd, LPMSG lpMsg)
2552 {
2553 return E_NOTIMPL;
2554 }
2555
2556 extern HRESULT IUnknown_HasFocusIO(IUnknown * punk);
2557 extern HRESULT IUnknown_TranslateAcceleratorIO(IUnknown * punk, MSG * pmsg);
2558 HRESULT STDMETHODCALLTYPE CShellBrowser::v_MayTranslateAccelerator(MSG *pmsg)
2559 {
2560 for (int i = 0; i < 3; i++)
2561 {
2562 if (IUnknown_TranslateAcceleratorIO(fClientBars[i].clientBar, pmsg) == S_OK)
2563 return S_OK;
2564 }
2565
2566 if (!fCurrentShellView)
2567 return S_FALSE;
2568
2569 return fCurrentShellView->TranslateAcceleratorW(pmsg);
2570 }
2571
2572 HRESULT STDMETHODCALLTYPE CShellBrowser::_GetBorderDWHelper(IUnknown *punkSrc, LPRECT lprectBorder, BOOL bUseHmonitor)
2573 {
2574 return E_NOTIMPL;
2575 }
2576
2577 HRESULT STDMETHODCALLTYPE CShellBrowser::v_CheckZoneCrossing(LPCITEMIDLIST pidl)
2578 {
2579 return E_NOTIMPL;
2580 }
2581
2582 HRESULT STDMETHODCALLTYPE CShellBrowser::GoBack()
2583 {
2584 CComPtr<ITravelLog> travelLog;
2585 HRESULT hResult = GetTravelLog(&travelLog);
2586 if (FAILED_UNEXPECTEDLY(hResult))
2587 return hResult;
2588 return travelLog->Travel(static_cast<IDropTarget *>(this), TLOG_BACK);
2589 }
2590
2591 HRESULT STDMETHODCALLTYPE CShellBrowser::GoForward()
2592 {
2593 CComPtr<ITravelLog> travelLog;
2594 HRESULT hResult = GetTravelLog(&travelLog);
2595 if (FAILED_UNEXPECTEDLY(hResult))
2596 return hResult;
2597 return travelLog->Travel(static_cast<IDropTarget *>(this), TLOG_FORE);
2598 }
2599
2600 HRESULT STDMETHODCALLTYPE CShellBrowser::GoHome()
2601 {
2602 return E_NOTIMPL;
2603 }
2604
2605 HRESULT STDMETHODCALLTYPE CShellBrowser::GoSearch()
2606 {
2607 return E_NOTIMPL;
2608 }
2609
2610 HRESULT STDMETHODCALLTYPE CShellBrowser::Navigate(BSTR URL, VARIANT *Flags,
2611 VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
2612 {
2613 return E_NOTIMPL;
2614 }
2615
2616 HRESULT STDMETHODCALLTYPE CShellBrowser::Refresh()
2617 {
2618 VARIANT level;
2619
2620 V_VT(&level) = VT_I4;
2621 V_I4(&level) = 4;
2622 return Refresh2(&level);
2623 }
2624
2625 HRESULT STDMETHODCALLTYPE CShellBrowser::Refresh2(VARIANT *Level)
2626 {
2627 CComPtr<IOleCommandTarget> oleCommandTarget;
2628 HRESULT hResult;
2629
2630 hResult = fCurrentShellView->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &oleCommandTarget));
2631 if (FAILED_UNEXPECTEDLY(hResult))
2632 return hResult;
2633 return oleCommandTarget->Exec(NULL, 22, 1, Level, NULL);
2634 }
2635
2636 HRESULT STDMETHODCALLTYPE CShellBrowser::Stop()
2637 {
2638 return E_NOTIMPL;
2639 }
2640
2641 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Application(IDispatch **ppDisp)
2642 {
2643 return E_NOTIMPL;
2644 }
2645
2646 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Parent(IDispatch **ppDisp)
2647 {
2648 return E_NOTIMPL;
2649 }
2650
2651 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Container(IDispatch **ppDisp)
2652 {
2653 return E_NOTIMPL;
2654 }
2655
2656 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Document(IDispatch **ppDisp)
2657 {
2658 return E_NOTIMPL;
2659 }
2660
2661 HRESULT STDMETHODCALLTYPE CShellBrowser::get_TopLevelContainer(VARIANT_BOOL *pBool)
2662 {
2663 return E_NOTIMPL;
2664 }
2665
2666 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Type(BSTR *Type)
2667 {
2668 return E_NOTIMPL;
2669 }
2670 #ifdef __exdisp_h__
2671 #define long LONG
2672 #endif
2673 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Left(long *pl)
2674 {
2675 return E_NOTIMPL;
2676 }
2677
2678 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Left(long Left)
2679 {
2680 return E_NOTIMPL;
2681 }
2682
2683 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Top(long *pl)
2684 {
2685 return E_NOTIMPL;
2686 }
2687
2688 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Top(long Top)
2689 {
2690 return E_NOTIMPL;
2691 }
2692
2693 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Width(long *pl)
2694 {
2695 return E_NOTIMPL;
2696 }
2697
2698 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Width(long Width)
2699 {
2700 return E_NOTIMPL;
2701 }
2702
2703 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Height(long *pl)
2704 {
2705 return E_NOTIMPL;
2706 }
2707
2708 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Height(long Height)
2709 {
2710 return E_NOTIMPL;
2711 }
2712 #ifdef __exdisp_h__
2713 #undef long
2714 #endif
2715 HRESULT STDMETHODCALLTYPE CShellBrowser::get_LocationName(BSTR *LocationName)
2716 {
2717 return E_NOTIMPL;
2718 }
2719
2720 HRESULT STDMETHODCALLTYPE CShellBrowser::get_LocationURL(BSTR *LocationURL)
2721 {
2722 return E_NOTIMPL;
2723 }
2724
2725 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Busy(VARIANT_BOOL *pBool)
2726 {
2727 return E_NOTIMPL;
2728 }
2729
2730 HRESULT STDMETHODCALLTYPE CShellBrowser::Quit()
2731 {
2732 return E_NOTIMPL;
2733 }
2734
2735 HRESULT STDMETHODCALLTYPE CShellBrowser::ClientToWindow(int *pcx, int *pcy)
2736 {
2737 return E_NOTIMPL;
2738 }
2739
2740 HRESULT STDMETHODCALLTYPE CShellBrowser::PutProperty(BSTR Property, VARIANT vtValue)
2741 {
2742 return E_NOTIMPL;
2743 }
2744
2745 HRESULT STDMETHODCALLTYPE CShellBrowser::GetProperty(BSTR Property, VARIANT *pvtValue)
2746 {
2747 return E_NOTIMPL;
2748 }
2749
2750 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Name(BSTR *Name)
2751 {
2752 return E_NOTIMPL;
2753 }
2754
2755 HRESULT STDMETHODCALLTYPE CShellBrowser::get_HWND(SHANDLE_PTR *pHWND)
2756 {
2757 return E_NOTIMPL;
2758 }
2759
2760 HRESULT STDMETHODCALLTYPE CShellBrowser::get_FullName(BSTR *FullName)
2761 {
2762 return E_NOTIMPL;
2763 }
2764
2765 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Path(BSTR *Path)
2766 {
2767 return E_NOTIMPL;
2768 }
2769
2770 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Visible(VARIANT_BOOL *pBool)
2771 {
2772 return E_NOTIMPL;
2773 }
2774
2775 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Visible(VARIANT_BOOL Value)
2776 {
2777 return E_NOTIMPL;
2778 }
2779
2780 HRESULT STDMETHODCALLTYPE CShellBrowser::get_StatusBar(VARIANT_BOOL *pBool)
2781 {
2782 return E_NOTIMPL;
2783 }
2784
2785 HRESULT STDMETHODCALLTYPE CShellBrowser::put_StatusBar(VARIANT_BOOL Value)
2786 {
2787 return E_NOTIMPL;
2788 }
2789
2790 HRESULT STDMETHODCALLTYPE CShellBrowser::get_StatusText(BSTR *StatusText)
2791 {
2792 return E_NOTIMPL;
2793 }
2794
2795 HRESULT STDMETHODCALLTYPE CShellBrowser::put_StatusText(BSTR StatusText)
2796 {
2797 return E_NOTIMPL;
2798 }
2799
2800 HRESULT STDMETHODCALLTYPE CShellBrowser::get_ToolBar(int *Value)
2801 {
2802 return E_NOTIMPL;
2803 }
2804
2805 HRESULT STDMETHODCALLTYPE CShellBrowser::put_ToolBar(int Value)
2806 {
2807 return E_NOTIMPL;
2808 }
2809
2810 HRESULT STDMETHODCALLTYPE CShellBrowser::get_MenuBar(VARIANT_BOOL *Value)
2811 {
2812 return E_NOTIMPL;
2813 }
2814
2815 HRESULT STDMETHODCALLTYPE CShellBrowser::put_MenuBar(VARIANT_BOOL Value)
2816 {
2817 return E_NOTIMPL;
2818 }
2819
2820 HRESULT STDMETHODCALLTYPE CShellBrowser::get_FullScreen(VARIANT_BOOL *pbFullScreen)
2821 {
2822 return E_NOTIMPL;
2823 }
2824
2825 HRESULT STDMETHODCALLTYPE CShellBrowser::put_FullScreen(VARIANT_BOOL bFullScreen)
2826 {
2827 return E_NOTIMPL;
2828 }
2829
2830 HRESULT STDMETHODCALLTYPE CShellBrowser::Navigate2(VARIANT *URL, VARIANT *Flags,
2831 VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
2832 {
2833 // called from drive combo box to navigate to a directory
2834 if (V_VT(URL) != (VT_ARRAY | VT_UI1))
2835 return E_INVALIDARG;
2836 if (V_ARRAY(URL)->cDims != 1 || V_ARRAY(URL)->cbElements != 1)
2837 return E_INVALIDARG;
2838
2839 LPITEMIDLIST pidl = static_cast<LPITEMIDLIST>(V_ARRAY(URL)->pvData);
2840 HRESULT hResult = BrowseToPIDL(pidl, BTP_UPDATE_CUR_HISTORY | BTP_UPDATE_NEXT_HISTORY);
2841 if (FAILED_UNEXPECTEDLY(hResult))
2842 return hResult;
2843 return S_OK;
2844 }
2845
2846 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryStatusWB(OLECMDID cmdID, OLECMDF *pcmdf)
2847 {
2848 return E_NOTIMPL;
2849 }
2850
2851 HRESULT STDMETHODCALLTYPE CShellBrowser::ExecWB(OLECMDID cmdID, OLECMDEXECOPT cmdexecopt,
2852 VARIANT *pvaIn, VARIANT *pvaOut)
2853 {
2854 return E_NOTIMPL;
2855 }
2856
2857 HRESULT STDMETHODCALLTYPE CShellBrowser::ShowBrowserBar(VARIANT *pvaClsid, VARIANT *pvarShow, VARIANT *pvarSize)
2858 {
2859 CLSID classID;
2860 bool vertical;
2861
2862 // called to show search bar
2863 if (V_VT(pvaClsid) != VT_BSTR)
2864 return E_INVALIDARG;
2865 CLSIDFromString(V_BSTR(pvaClsid), &classID);
2866 // TODO: properly compute the value of vertical
2867 vertical = true;
2868 return ShowBand(classID, vertical);
2869 }
2870
2871 HRESULT STDMETHODCALLTYPE CShellBrowser::get_ReadyState(READYSTATE *plReadyState)
2872 {
2873 return E_NOTIMPL;
2874 }
2875
2876 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Offline(VARIANT_BOOL *pbOffline)
2877 {
2878 return E_NOTIMPL;
2879 }
2880
2881 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Offline(VARIANT_BOOL bOffline)
2882 {
2883 return E_NOTIMPL;
2884 }
2885
2886 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Silent(VARIANT_BOOL *pbSilent)
2887 {
2888 return E_NOTIMPL;
2889 }
2890
2891 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Silent(VARIANT_BOOL bSilent)
2892 {
2893 return E_NOTIMPL;
2894 }
2895
2896 HRESULT STDMETHODCALLTYPE CShellBrowser::get_RegisterAsBrowser(VARIANT_BOOL *pbRegister)
2897 {
2898 return E_NOTIMPL;
2899 }
2900
2901 HRESULT STDMETHODCALLTYPE CShellBrowser::put_RegisterAsBrowser(VARIANT_BOOL bRegister)
2902 {
2903 return E_NOTIMPL;
2904 }
2905
2906 HRESULT STDMETHODCALLTYPE CShellBrowser::get_RegisterAsDropTarget(VARIANT_BOOL *pbRegister)
2907 {
2908 return E_NOTIMPL;
2909 }
2910
2911 HRESULT STDMETHODCALLTYPE CShellBrowser::put_RegisterAsDropTarget(VARIANT_BOOL bRegister)
2912 {
2913 return E_NOTIMPL;
2914 }
2915
2916 HRESULT STDMETHODCALLTYPE CShellBrowser::get_TheaterMode(VARIANT_BOOL *pbRegister)
2917 {
2918 return E_NOTIMPL;
2919 }
2920
2921 HRESULT STDMETHODCALLTYPE CShellBrowser::put_TheaterMode(VARIANT_BOOL bRegister)
2922 {
2923 return E_NOTIMPL;
2924 }
2925
2926 HRESULT STDMETHODCALLTYPE CShellBrowser::get_AddressBar(VARIANT_BOOL *Value)
2927 {
2928 return E_NOTIMPL;
2929 }
2930
2931 HRESULT STDMETHODCALLTYPE CShellBrowser::put_AddressBar(VARIANT_BOOL Value)
2932 {
2933 return E_NOTIMPL;
2934 }
2935
2936 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Resizable(VARIANT_BOOL *Value)
2937 {
2938 return E_NOTIMPL;
2939 }
2940
2941 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Resizable(VARIANT_BOOL Value)
2942 {
2943 return E_NOTIMPL;
2944 }
2945
2946 HRESULT STDMETHODCALLTYPE CShellBrowser::FindWindowByIndex(DWORD dwID, IUnknown **ppunk)
2947 {
2948 return E_NOTIMPL;
2949 }
2950
2951 HRESULT STDMETHODCALLTYPE CShellBrowser::GetWindowData(IStream *pStream, LPWINDOWDATA pWinData)
2952 {
2953 if (pWinData == NULL)
2954 return E_POINTER;
2955
2956 pWinData->dwWindowID = -1;
2957 pWinData->uiCP = 0;
2958 pWinData->pidl = ILClone(fCurrentDirectoryPIDL);
2959 pWinData->lpszUrl = NULL;
2960 pWinData->lpszUrlLocation = NULL;
2961 pWinData->lpszTitle = NULL;
2962 return S_OK;
2963 }
2964
2965 HRESULT STDMETHODCALLTYPE CShellBrowser::LoadHistoryPosition(LPWSTR pszUrlLocation, DWORD dwPosition)
2966 {
2967 return E_NOTIMPL;
2968 }
2969
2970 HRESULT STDMETHODCALLTYPE CShellBrowser::GetClassID(CLSID *pClassID)
2971 {
2972 return E_NOTIMPL;
2973 }
2974
2975 HRESULT STDMETHODCALLTYPE CShellBrowser::LoadHistory(IStream *pStream, IBindCtx *pbc)
2976 {
2977 CComPtr<IPersistHistory> viewPersistHistory;
2978 CComPtr<IOleObject> viewHistoryObject;
2979 persistState oldState;
2980 ULONG numRead;
2981 LPITEMIDLIST pidl;
2982 HRESULT hResult;
2983
2984 hResult = pStream->Read(&oldState, sizeof(oldState), &numRead);
2985 if (FAILED_UNEXPECTEDLY(hResult))
2986 return hResult;
2987 if (numRead != sizeof(oldState) || oldState.dwSize != sizeof(oldState))
2988 return E_FAIL;
2989 if (oldState.browseType != 2)
2990 return E_FAIL;
2991 pidl = static_cast<LPITEMIDLIST>(CoTaskMemAlloc(oldState.pidlSize));
2992 if (pidl == NULL)
2993 return E_OUTOFMEMORY;
2994 hResult = pStream->Read(pidl, oldState.pidlSize, &numRead);
2995 if (FAILED_UNEXPECTEDLY(hResult))
2996 {
2997 ILFree(pidl);
2998 return hResult;
2999 }
3000 if (numRead != oldState.pidlSize)
3001 {
3002 ILFree(pidl);
3003 return E_FAIL;
3004 }
3005 hResult = CoCreateInstance(oldState.persistClass, NULL, CLSCTX_LOCAL_SERVER | CLSCTX_INPROC_SERVER,
3006 IID_PPV_ARG(IOleObject, &viewHistoryObject));
3007 fHistoryObject = viewHistoryObject;
3008 fHistoryStream = pStream;
3009 fHistoryBindContext = pbc;
3010 hResult = BrowseToPIDL(pidl, BTP_UPDATE_CUR_HISTORY);
3011 fHistoryObject = NULL;
3012 fHistoryStream = NULL;
3013 fHistoryBindContext = NULL;
3014 ILFree(pidl);
3015 if (FAILED_UNEXPECTEDLY(hResult))
3016 return hResult;
3017 return S_OK;
3018 }
3019
3020 HRESULT STDMETHODCALLTYPE CShellBrowser::SaveHistory(IStream *pStream)
3021 {
3022 CComPtr<IPersistHistory> viewPersistHistory;
3023 persistState newState;
3024 HRESULT hResult;
3025
3026 hResult = fCurrentShellView->GetItemObject(
3027 SVGIO_BACKGROUND, IID_PPV_ARG(IPersistHistory, &viewPersistHistory));
3028 memset(&newState, 0, sizeof(newState));
3029 newState.dwSize = sizeof(newState);
3030 newState.browseType = 2;
3031 newState.browserIndex = GetBrowserIndex();
3032 if (viewPersistHistory.p != NULL)
3033 {
3034 hResult = viewPersistHistory->GetClassID(&newState.persistClass);
3035 if (FAILED_UNEXPECTEDLY(hResult))
3036 return hResult;
3037 }
3038 newState.pidlSize = ILGetSize(fCurrentDirectoryPIDL);
3039 hResult = pStream->Write(&newState, sizeof(newState), NULL);
3040 if (FAILED_UNEXPECTEDLY(hResult))
3041 return hResult;
3042 hResult = pStream->Write(fCurrentDirectoryPIDL, newState.pidlSize, NULL);
3043 if (FAILED_UNEXPECTEDLY(hResult))
3044 return hResult;
3045 if (viewPersistHistory.p != NULL)
3046 {
3047 hResult = viewPersistHistory->SaveHistory(pStream);
3048 if (FAILED_UNEXPECTEDLY(hResult))
3049 return hResult;
3050 }
3051 return S_OK;
3052 }
3053
3054 HRESULT STDMETHODCALLTYPE CShellBrowser::SetPositionCookie(DWORD dwPositioncookie)
3055 {
3056 return E_NOTIMPL;
3057 }
3058
3059 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPositionCookie(DWORD *pdwPositioncookie)
3060 {
3061 return E_NOTIMPL;
3062 }
3063
3064 LRESULT CShellBrowser::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3065 {
3066 OnCreate(reinterpret_cast<LPCREATESTRUCT> (lParam));
3067 return 0;
3068 }
3069
3070 LRESULT CShellBrowser::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3071 {
3072 HRESULT hr;
3073 // TODO: rip down everything
3074 {
3075 fCurrentShellView->DestroyViewWindow();
3076 fCurrentShellView->UIActivate(SVUIA_DEACTIVATE);
3077 ReleaseCComPtrExpectZero(fCurrentShellView);
3078
3079 for (int i = 0; i < 3; i++)
3080 {
3081 if (fClientBars[i].clientBar == NULL)
3082 continue;
3083 IDockingWindow * pdw;
3084 hr = fClientBars[i].clientBar->QueryInterface(IID_PPV_ARG(IDockingWindow, &pdw));
3085 if (FAILED_UNEXPECTEDLY(hr))
3086 continue;
3087 pdw->ShowDW(FALSE);
3088 pdw->CloseDW(0);
3089 pdw->Release();
3090 ReleaseCComPtrExpectZero(fClientBars[i].clientBar);
3091 }
3092 ReleaseCComPtrExpectZero(fTravelLog);
3093
3094 fCurrentShellFolder.Release();
3095 ILFree(fCurrentDirectoryPIDL);
3096 ::DestroyWindow(fStatusBar);
3097 DestroyMenu(fCurrentMenuBar);
3098 }
3099 PostQuitMessage(0);
3100 return 0;
3101 }
3102
3103 LRESULT CShellBrowser::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3104 {
3105 CComPtr<IDockingWindow> dockingWindow;
3106 RECT availableBounds;
3107 static const INT excludeItems[] = {1, 1, 1, 0xa001, 0, 0};
3108 HRESULT hResult;
3109
3110 if (wParam != SIZE_MINIMIZED)
3111 {
3112 GetEffectiveClientRect(m_hWnd, &availableBounds, excludeItems);
3113 for (INT x = 0; x < 3; x++)
3114 {
3115 if (fClientBars[x].clientBar != NULL)
3116 {
3117 hResult = fClientBars[x].clientBar->QueryInterface(
3118 IID_PPV_ARG(IDockingWindow, &dockingWindow));
3119 if (SUCCEEDED(hResult) && dockingWindow != NULL)
3120 {
3121 hResult = dockingWindow->ResizeBorderDW(
3122 &availableBounds, static_cast<IDropTarget *>(this), TRUE);
3123 break;
3124 }
3125 }
3126 }
3127 RepositionBars();
3128 }
3129 return 1;
3130 }
3131
3132 LRESULT CShellBrowser::OnInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3133 {
3134 HMENU theMenu;
3135 LPARAM menuIndex = lParam;
3136
3137 theMenu = reinterpret_cast<HMENU>(wParam);
3138
3139 if (theMenu == SHGetMenuFromID(fCurrentMenuBar, FCIDM_MENU_FILE))
3140 {
3141 menuIndex = 0;
3142 }
3143 else if (theMenu == SHGetMenuFromID(fCurrentMenuBar, FCIDM_MENU_EDIT))
3144 {
3145 menuIndex = 1;
3146 }
3147 else if (theMenu == SHGetMenuFromID(fCurrentMenuBar, FCIDM_MENU_VIEW))
3148 {
3149 UpdateViewMenu(theMenu);
3150 menuIndex = 2;
3151 }
3152 else if (theMenu == SHGetMenuFromID(fCurrentMenuBar, FCIDM_MENU_FAVORITES))
3153 {
3154 menuIndex = 3;
3155 }
3156 else if (theMenu == SHGetMenuFromID(fCurrentMenuBar, FCIDM_MENU_TOOLS))
3157 {
3158 // FIXME: Remove once implemented
3159 SHEnableMenuItem(theMenu, IDM_TOOLS_MAPNETWORKDRIVE, FALSE);
3160 SHEnableMenuItem(theMenu, IDM_TOOLS_DISCONNECTNETWORKDRIVE, FALSE);
3161 SHEnableMenuItem(theMenu, IDM_TOOLS_SYNCHRONIZE, FALSE);
3162 SHEnableMenuItem(theMenu, IDM_TOOLS_FOLDEROPTIONS, FALSE);
3163 menuIndex = 4;
3164 }
3165 else if (theMenu == SHGetMenuFromID(fCurrentMenuBar, FCIDM_MENU_HELP))
3166 {
3167 menuIndex = 5;
3168 }
3169
3170 LRESULT ret = RelayMsgToShellView(uMsg, wParam, menuIndex, bHandled);
3171
3172 return ret;
3173 }
3174
3175 LRESULT CShellBrowser::RelayMsgToShellView(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3176 {
3177 if (fCurrentShellViewWindow != NULL)
3178 return SendMessage(fCurrentShellViewWindow, uMsg, wParam, lParam);
3179 return 0;
3180 }
3181
3182 LRESULT CShellBrowser::OnClose(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3183 {
3184 return SendMessage(WM_CLOSE);
3185 }
3186
3187 LRESULT CShellBrowser::OnFolderOptions(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3188 {
3189 HRESULT hResult = DoFolderOptions();
3190 if (FAILED(hResult))
3191 TRACE("DoFolderOptions failed with hResult=%08lx\n", hResult);
3192 return 0;
3193 }
3194
3195 LRESULT CShellBrowser::OnMapNetworkDrive(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3196 {
3197 #ifndef __REACTOS__
3198 WNetConnectionDialog(m_hWnd, RESOURCETYPE_DISK);
3199 #endif /* __REACTOS__ */
3200 return 0;
3201 }
3202
3203 LRESULT CShellBrowser::OnDisconnectNetworkDrive(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3204 {
3205 #ifndef __REACTOS__
3206 WNetDisconnectDialog(m_hWnd, RESOURCETYPE_DISK);
3207 #endif /* __REACTOS__ */
3208 return 0;
3209 }
3210
3211 LRESULT CShellBrowser::OnAboutReactOS(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3212 {
3213 ShellAbout(m_hWnd, _T("ReactOS"), _T(""), NULL);
3214 return 0;
3215 }
3216
3217 LRESULT CShellBrowser::OnGoBack(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3218 {
3219 HRESULT hResult = GoBack();
3220 if (FAILED(hResult))
3221 TRACE("GoBack failed with hResult=%08lx\n", hResult);
3222 return 0;
3223 }
3224
3225 LRESULT CShellBrowser::OnGoForward(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3226 {
3227 HRESULT hResult = GoForward();
3228 if (FAILED(hResult))
3229 TRACE("GoForward failed with hResult=%08lx\n", hResult);
3230 return 0;
3231 }
3232
3233 LRESULT CShellBrowser::OnGoUpLevel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3234 {
3235 HRESULT hResult = NavigateToParent();
3236 if (FAILED(hResult))
3237 TRACE("NavigateToParent failed with hResult=%08lx\n", hResult);
3238 return 0;
3239 }
3240
3241 LRESULT CShellBrowser::OnGoHome(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3242 {
3243 HRESULT hResult = GoHome();
3244 if (FAILED(hResult))
3245 TRACE("GoHome failed with hResult=%08lx\n", hResult);
3246 return 0;
3247 }
3248
3249 LRESULT CShellBrowser::OnBackspace(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3250 {
3251 // FIXME: This does not appear to be what windows does.
3252 HRESULT hResult = NavigateToParent();
3253 if (FAILED(hResult))
3254 TRACE("NavigateToParent failed with hResult=%08lx\n", hResult);
3255 return 0;
3256 }
3257
3258 LRESULT CShellBrowser::OnOrganizeFavorites(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3259 {
3260 CComPtr<IShellFolder> psfDesktop;
3261 LPITEMIDLIST pidlFavs;
3262 HRESULT hr;
3263 hr = SHGetSpecialFolderLocation(m_hWnd, CSIDL_FAVORITES, &pidlFavs);
3264 if (FAILED(hr))
3265 {
3266 hr = SHGetSpecialFolderLocation(m_hWnd, CSIDL_COMMON_FAVORITES, &pidlFavs);
3267 if (FAILED(hr))
3268 return 0;
3269 }
3270
3271 hr = SHGetDesktopFolder(&psfDesktop);
3272 if (FAILED_UNEXPECTEDLY(hr))
3273 return 0;
3274
3275 hr = SHInvokeDefaultCommand(m_hWnd, psfDesktop, pidlFavs);
3276 if (FAILED_UNEXPECTEDLY(hr))
3277 return 0;
3278
3279 return 0;
3280 }
3281
3282 LRESULT CShellBrowser::OnIsThisLegal(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3283 {
3284 /* TODO: Implement properly */
3285
3286 LPCWSTR strSite = L"https://www.reactos.org/user-faq";
3287
3288 /* TODO: Make localizable */
3289 LPCWSTR strCaption = L"Sorry";
3290 LPCWSTR strMessage = L"ReactOS could not browse to '%s' (error %d). Please make sure there is a web browser installed.";
3291 WCHAR tmpMessage[512];
3292
3293 /* TODO: Read from the registry */
3294 LPCWSTR strVerb = NULL; /* default */
3295 LPCWSTR strPath = strSite;
3296 LPCWSTR strParams = NULL;
3297
3298 /* The return value is defined as HINSTANCE for backwards compatibility only, the cast is needed */
3299 int result = (int) ShellExecuteW(m_hWnd, strVerb, strPath, strParams, NULL, SW_SHOWNORMAL);
3300 if (result <= 32)
3301 {
3302 StringCchPrintfW(tmpMessage, 512, strMessage, strSite, result);
3303 MessageBoxExW(m_hWnd, tmpMessage, strCaption, MB_OK, 0);
3304 }
3305
3306 return 0;
3307 }
3308
3309 LRESULT CShellBrowser::OnToggleStatusBarVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3310 {
3311 fStatusBarVisible = !fStatusBarVisible;
3312 if (fStatusBar)
3313 {
3314 ::ShowWindow(fStatusBar, fStatusBarVisible ? SW_SHOW : SW_HIDE);
3315 RepositionBars();
3316 }
3317 return 0;
3318 }
3319
3320 LRESULT CShellBrowser::OnToggleToolbarLock(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3321 {
3322 HRESULT hResult;
3323 hResult = IUnknown_Exec(fClientBars[BIInternetToolbar].clientBar,
3324 CGID_PrivCITCommands, ITID_TOOLBARLOCKED, 0, NULL, NULL);
3325 return 0;
3326 }
3327
3328 LRESULT CShellBrowser::OnToggleToolbarBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3329 {
3330 HRESULT hResult;
3331 hResult = IUnknown_Exec(fClientBars[BIInternetToolbar].clientBar,
3332 CGID_PrivCITCommands, ITID_TOOLBARBANDSHOWN, 0, NULL, NULL);
3333 return 0;
3334 }
3335
3336 LRESULT CShellBrowser::OnToggleAddressBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3337 {
3338 HRESULT hResult;
3339 hResult = IUnknown_Exec(fClientBars[BIInternetToolbar].clientBar,
3340 CGID_PrivCITCommands, ITID_ADDRESSBANDSHOWN, 0, NULL, NULL);
3341 return 0;
3342 }
3343
3344 LRESULT CShellBrowser::OnToggleLinksBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3345 {
3346 HRESULT hResult;
3347 hResult = IUnknown_Exec(fClientBars[BIInternetToolbar].clientBar,
3348 CGID_PrivCITCommands, ITID_LINKSBANDSHOWN, 0, NULL, NULL);
3349 return 0;
3350 }
3351
3352 LRESULT CShellBrowser::OnToggleTextLabels(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3353 {
3354 HRESULT hResult;
3355 hResult = IUnknown_Exec(fClientBars[BIInternetToolbar].clientBar,
3356 CGID_PrivCITCommands, ITID_TEXTLABELS, 0, NULL, NULL);
3357 return 0;
3358 }
3359
3360 LRESULT CShellBrowser::OnToolbarCustomize(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3361 {
3362 HRESULT hResult;
3363 hResult = IUnknown_Exec(fClientBars[BIInternetToolbar].clientBar,
3364 CGID_PrivCITCommands, ITID_CUSTOMIZEENABLED, 0, NULL, NULL);
3365 return 0;
3366 }
3367
3368 LRESULT CShellBrowser::OnGoTravel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3369 {
3370 return 0;
3371 }
3372
3373 LRESULT CShellBrowser::RelayCommands(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3374 {
3375 if (HIWORD(wParam) == 0 && LOWORD(wParam) < FCIDM_SHVIEWLAST && fCurrentShellViewWindow != NULL)
3376 return SendMessage(fCurrentShellViewWindow, uMsg, wParam, lParam);
3377 return 0;
3378 }
3379
3380 static HRESULT ExplorerMessageLoop(IEThreadParamBlock * parameters)
3381 {
3382 CComPtr<CShellBrowser> theCabinet;
3383 HRESULT hResult;
3384 MSG Msg;
3385 BOOL Ret;
3386
3387 // Tell the thread ref we are using it.
3388 if (parameters && parameters->offsetF8)
3389 parameters->offsetF8->AddRef();
3390
3391 ATLTRY(theCabinet = new CComObject<CShellBrowser>);
3392 if (theCabinet == NULL)
3393 {
3394 return E_OUTOFMEMORY;
3395 }
3396
3397 hResult = theCabinet->Initialize(parameters->directoryPIDL, 0, 0, 0);
3398 if (FAILED_UNEXPECTEDLY(hResult))
3399 return E_OUTOFMEMORY;
3400
3401 while ((Ret = GetMessage(&Msg, NULL, 0, 0)) != 0)
3402 {
3403 if (Ret == -1)
3404 {
3405 // Error: continue or exit?
3406 break;
3407 }
3408
3409 if (Msg.message == WM_QUIT)
3410 break;
3411
3412 if (theCabinet->v_MayTranslateAccelerator(&Msg) != S_OK)
3413 {
3414 TranslateMessage(&Msg);
3415 DispatchMessage(&Msg);
3416 }
3417 }
3418
3419 int nrc = theCabinet->Release();
3420 if (nrc > 0)
3421 {
3422 DbgPrint("WARNING: There are %d references to the CShellBrowser active or leaked.\n", nrc);
3423 }
3424
3425 theCabinet.Detach();
3426
3427 // Tell the thread ref we are not using it anymore.
3428 if (parameters && parameters->offsetF8)
3429 parameters->offsetF8->Release();
3430
3431 return hResult;
3432 }
3433
3434 DWORD WINAPI BrowserThreadProc(LPVOID lpThreadParameter)
3435 {
3436 HRESULT hr;
3437 IEThreadParamBlock * parameters = (IEThreadParamBlock *) lpThreadParameter;
3438
3439 OleInitialize(NULL);
3440
3441 ATLTRY(hr = ExplorerMessageLoop(parameters));
3442
3443 OleUninitialize();
3444
3445 SHDestroyIETHREADPARAM(parameters);
3446
3447 return hr;
3448 }
A free Windows-compatible Operating System