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