projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[EXPLORER-NEW]
[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 SendMessage(WM_SETICON, ICON_SMALL, reinterpret_cast<LPARAM>(icSmall));
1082 SendMessage(WM_SETICON, ICON_BIG, reinterpret_cast<LPARAM>(icLarge));
1083 }
1084
1085 // TODO: Update the window icon
1086
1087 FireCommandStateChangeAll();
1088 hResult = UpdateForwardBackState();
1089 return S_OK;
1090 }
1091
1092 HRESULT CShellBrowser::GetMenuBand(REFIID riid, void **shellMenu)
1093 {
1094 CComPtr<IServiceProvider> serviceProvider;
1095 CComPtr<IBandSite> bandSite;
1096 CComPtr<IDeskBand> deskBand;
1097 HRESULT hResult;
1098
1099 if (!fClientBars[BIInternetToolbar].clientBar)
1100 return E_FAIL;
1101
1102 hResult = IUnknown_QueryService(fClientBars[BIInternetToolbar].clientBar, SID_IBandSite, IID_PPV_ARG(IBandSite, &bandSite));
1103 if (FAILED_UNEXPECTEDLY(hResult))
1104 return hResult;
1105
1106 hResult = bandSite->QueryBand(1, &deskBand, NULL, NULL, 0);
1107 if (FAILED_UNEXPECTEDLY(hResult))
1108 return hResult;
1109
1110 return deskBand->QueryInterface(riid, shellMenu);
1111 }
1112
1113 HRESULT CShellBrowser::GetBaseBar(bool vertical, IUnknown **theBaseBar)
1114 {
1115 CComPtr<IUnknown> newBaseBar;
1116 CComPtr<IDeskBar> deskBar;
1117 CComPtr<IUnknown> newBaseBarSite;
1118 CComPtr<IObjectWithSite> objectWithSite;
1119 CComPtr<IDeskBarClient> deskBarClient;
1120 IUnknown **cache;
1121 HRESULT hResult;
1122
1123 if (vertical)
1124 cache = &fClientBars[BIVerticalBaseBar].clientBar.p;
1125 else
1126 cache = &fClientBars[BIHorizontalBaseBar].clientBar.p;
1127 if (*cache == NULL)
1128 {
1129 hResult = CreateBaseBar(IID_PPV_ARG(IUnknown, &newBaseBar));
1130 if (FAILED_UNEXPECTEDLY(hResult))
1131 return hResult;
1132 hResult = CreateBaseBarSite(IID_PPV_ARG(IUnknown, &newBaseBarSite));
1133 if (FAILED_UNEXPECTEDLY(hResult))
1134 return hResult;
1135
1136 // tell the new base bar about the shell browser
1137 hResult = newBaseBar->QueryInterface(IID_PPV_ARG(IObjectWithSite, &objectWithSite));
1138 if (FAILED_UNEXPECTEDLY(hResult))
1139 return hResult;
1140 hResult = objectWithSite->SetSite(static_cast<IDropTarget *>(this));
1141 if (FAILED_UNEXPECTEDLY(hResult))
1142 return hResult;
1143
1144 // tell the new base bar about the new base bar site
1145 hResult = newBaseBar->QueryInterface(IID_PPV_ARG(IDeskBar, &deskBar));
1146 if (FAILED_UNEXPECTEDLY(hResult))
1147 return hResult;
1148 hResult = deskBar->SetClient(newBaseBarSite);
1149 if (FAILED_UNEXPECTEDLY(hResult))
1150 return hResult;
1151
1152 // tell the new base bar site about the new base bar
1153 hResult = newBaseBarSite->QueryInterface(IID_PPV_ARG(IDeskBarClient, &deskBarClient));
1154 if (FAILED_UNEXPECTEDLY(hResult))
1155 return hResult;
1156 hResult = deskBarClient->SetDeskBarSite(newBaseBar);
1157 if (FAILED_UNEXPECTEDLY(hResult))
1158 return hResult;
1159
1160 *cache = newBaseBar.Detach();
1161 }
1162 return (*cache)->QueryInterface(IID_PPV_ARG(IUnknown, theBaseBar));
1163 }
1164
1165 HRESULT CShellBrowser::ShowBand(const CLSID &classID, bool vertical)
1166 {
1167 CComPtr<IDockingWindow> dockingWindow;
1168 CComPtr<IOleCommandTarget> oleCommandTarget;
1169 CComPtr<IUnknown> baseBarSite;
1170 CComPtr<IUnknown> newBand;
1171 CComPtr<IUnknown> theBaseBar;
1172 CComPtr<IDeskBar> deskBar;
1173 VARIANT vaIn;
1174 HRESULT hResult;
1175
1176 __debugbreak();
1177
1178 hResult = GetBaseBar(vertical, (IUnknown **)&theBaseBar);
1179 if (FAILED_UNEXPECTEDLY(hResult))
1180 return hResult;
1181 hResult = CoCreateInstance(classID, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IUnknown, &newBand));
1182 if (FAILED_UNEXPECTEDLY(hResult))
1183 return hResult;
1184 hResult = theBaseBar->QueryInterface(IID_PPV_ARG(IDeskBar, &deskBar));
1185 if (FAILED_UNEXPECTEDLY(hResult))
1186 return hResult;
1187 hResult = deskBar->GetClient(&baseBarSite);
1188 if (FAILED_UNEXPECTEDLY(hResult))
1189 return hResult;
1190 hResult = theBaseBar->QueryInterface(IID_PPV_ARG(IDockingWindow, &dockingWindow));
1191 if (FAILED_UNEXPECTEDLY(hResult))
1192 return hResult;
1193 hResult = baseBarSite->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &oleCommandTarget));
1194 if (FAILED_UNEXPECTEDLY(hResult))
1195 return hResult;
1196 V_VT(&vaIn) = VT_UNKNOWN;
1197 V_UNKNOWN(&vaIn) = newBand.p;
1198 hResult = oleCommandTarget->Exec(&CGID_IDeskBand, 1, 1, &vaIn, NULL);
1199 if (FAILED_UNEXPECTEDLY(hResult))
1200 return hResult;
1201 hResult = dockingWindow->ShowDW(TRUE);
1202 if (FAILED_UNEXPECTEDLY(hResult))
1203 return hResult;
1204 return S_OK;
1205 }
1206
1207 HRESULT CShellBrowser::NavigateToParent()
1208 {
1209 LPITEMIDLIST newDirectory;
1210 HRESULT hResult;
1211
1212 newDirectory = ILClone(fCurrentDirectoryPIDL);
1213 if (newDirectory == NULL)
1214 return E_OUTOFMEMORY;
1215 ILRemoveLastID(newDirectory);
1216 hResult = BrowseToPIDL(newDirectory, BTP_UPDATE_CUR_HISTORY | BTP_UPDATE_NEXT_HISTORY);
1217 ILFree(newDirectory);
1218 if (FAILED_UNEXPECTEDLY(hResult))
1219 return hResult;
1220 return S_OK;
1221 }
1222
1223 BOOL CALLBACK AddFolderOptionsPage(HPROPSHEETPAGE thePage, LPARAM lParam)
1224 {
1225 PROPSHEETHEADER *sheetInfo;
1226
1227 sheetInfo = (PROPSHEETHEADER *)lParam;
1228 if (sheetInfo->nPages >= folderOptionsPageCountMax)
1229 return FALSE;
1230 sheetInfo->phpage[sheetInfo->nPages] = thePage;
1231 sheetInfo->nPages++;
1232 return TRUE;
1233 }
1234
1235 HRESULT CShellBrowser::DoFolderOptions()
1236 {
1237 CComPtr<IShellPropSheetExt> folderOptionsSheet;
1238 CComPtr<IObjectWithSite> objectWithSite;
1239 PROPSHEETHEADER m_PropSheet;
1240 HPROPSHEETPAGE m_psp[folderOptionsPageCountMax];
1241 // CComPtr<IGlobalFolderSettings> globalSettings;
1242 // SHELLSTATE2 shellState;
1243 HRESULT hResult;
1244
1245 memset(m_psp, 0, sizeof(m_psp));
1246 memset(&m_PropSheet, 0, sizeof(m_PropSheet));
1247
1248 // create sheet object
1249 hResult = CoCreateInstance(CLSID_ShellFldSetExt, NULL, CLSCTX_INPROC_SERVER,
1250 IID_PPV_ARG(IShellPropSheetExt, &folderOptionsSheet));
1251 if (FAILED_UNEXPECTEDLY(hResult))
1252 return E_FAIL;
1253
1254 // must set site in order for Apply to all Folders on Advanced page to be enabled
1255 hResult = folderOptionsSheet->QueryInterface(IID_PPV_ARG(IObjectWithSite, &objectWithSite));
1256 if (SUCCEEDED(hResult) && objectWithSite.p != NULL)
1257 hResult = objectWithSite->SetSite(static_cast<IDispatch *>(this));
1258 m_PropSheet.phpage = m_psp;
1259
1260 #if 0
1261 hResult = CoCreateInstance(CLSID_GlobalFolderSettings, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IGlobalFolderSettings, &globalSettings));
1262 if (FAILED_UNEXPECTEDLY(hResult))
1263 return E_FAIL;
1264 hResult = globalSettings->Get(&shellState, sizeof(shellState));
1265 if (FAILED_UNEXPECTEDLY(hResult))
1266 return E_FAIL;
1267 #endif
1268
1269 // add pages
1270 hResult = folderOptionsSheet->AddPages(AddFolderOptionsPage, reinterpret_cast<LPARAM>(&m_PropSheet));
1271 if (FAILED_UNEXPECTEDLY(hResult))
1272 return E_FAIL;
1273
1274 if (fCurrentShellView != NULL)
1275 {
1276 hResult = fCurrentShellView->AddPropertySheetPages(
1277 0, AddFolderOptionsPage, reinterpret_cast<LPARAM>(&m_PropSheet));
1278 if (FAILED_UNEXPECTEDLY(hResult))
1279 return E_FAIL;
1280 }
1281
1282 // show sheet
1283 m_PropSheet.dwSize = sizeof(PROPSHEETHEADER);
1284 m_PropSheet.dwFlags = 0;
1285 m_PropSheet.hwndParent = m_hWnd;
1286 m_PropSheet.hInstance = _AtlBaseModule.GetResourceInstance();
1287 m_PropSheet.pszCaption = _T("Folder Options");
1288 m_PropSheet.nStartPage = 0;
1289 PropertySheet(&m_PropSheet);
1290 return S_OK;
1291 }
1292
1293 LRESULT CALLBACK CShellBrowser::WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1294 {
1295 CShellBrowser *pThis = reinterpret_cast<CShellBrowser *>(hWnd);
1296 _ATL_MSG msg(pThis->m_hWnd, uMsg, wParam, lParam);
1297 LRESULT lResult;
1298 const _ATL_MSG *previousMessage;
1299 BOOL handled;
1300 WNDPROC saveWindowProc;
1301 HRESULT hResult;
1302
1303 hWnd = pThis->m_hWnd;
1304 previousMessage = pThis->m_pCurrentMsg;
1305 pThis->m_pCurrentMsg = &msg;
1306
1307 CComPtr<IMenuBand> menuBand;
1308 hResult = pThis->GetMenuBand(IID_PPV_ARG(IMenuBand, &menuBand));
1309 if (SUCCEEDED(hResult) && menuBand.p != NULL)
1310 {
1311 hResult = menuBand->TranslateMenuMessage(&msg, &lResult);
1312 if (hResult == S_OK)
1313 return lResult;
1314 uMsg = msg.message;
1315 wParam = msg.wParam;
1316 lParam = msg.lParam;
1317 }
1318 menuBand.Release();
1319
1320 handled = pThis->ProcessWindowMessage(hWnd, uMsg, wParam, lParam, lResult, 0);
1321 ATLASSERT(pThis->m_pCurrentMsg == &msg);
1322 if (handled == FALSE)
1323 {
1324 if (uMsg == WM_NCDESTROY)
1325 {
1326 saveWindowProc = reinterpret_cast<WNDPROC>(GetWindowLongPtr(hWnd, GWL_WNDPROC));
1327 lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
1328 if (saveWindowProc == reinterpret_cast<WNDPROC>(GetWindowLongPtr(hWnd, GWL_WNDPROC)))
1329 SetWindowLongPtr(hWnd, GWL_WNDPROC, (LONG_PTR)pThis->m_pfnSuperWindowProc);
1330 pThis->m_dwState |= WINSTATE_DESTROYED;
1331 }
1332 else
1333 lResult = pThis->DefWindowProc(uMsg, wParam, lParam);
1334 }
1335 pThis->m_pCurrentMsg = previousMessage;
1336 if (previousMessage == NULL && (pThis->m_dwState & WINSTATE_DESTROYED) != 0)
1337 {
1338 pThis->m_dwState &= ~WINSTATE_DESTROYED;
1339 pThis->m_hWnd = NULL;
1340 pThis->OnFinalMessage(hWnd);
1341 }
1342 return lResult;
1343 }
1344
1345 void CShellBrowser::RepositionBars()
1346 {
1347 RECT clientRect;
1348 RECT statusRect;
1349 int x;
1350
1351 GetClientRect(&clientRect);
1352
1353 if (fStatusBarVisible && fStatusBar)
1354 {
1355 ::GetWindowRect(fStatusBar, &statusRect);
1356 ::SetWindowPos(fStatusBar, NULL, clientRect.left, clientRect.bottom - (statusRect.bottom - statusRect.top),
1357 clientRect.right - clientRect.left,
1358 statusRect.bottom - statusRect.top, SWP_NOOWNERZORDER | SWP_NOZORDER);
1359 clientRect.bottom -= statusRect.bottom - statusRect.top;
1360 }
1361
1362 for (x = 0; x < 3; x++)
1363 {
1364 HWND hwnd = fClientBars[x].hwnd;
1365 RECT borderSpace = fClientBars[x].borderSpace;
1366 if (hwnd == NULL && fClientBars[x].clientBar != NULL)
1367 {
1368 IUnknown_GetWindow(fClientBars[x].clientBar, &hwnd);
1369 fClientBars[x].hwnd = hwnd;
1370 }
1371 if (hwnd != NULL)
1372 {
1373 RECT toolbarRect = clientRect;
1374 if (borderSpace.top != 0)
1375 {
1376 toolbarRect.bottom = toolbarRect.top + borderSpace.top;
1377 }
1378 else if (borderSpace.bottom != 0)
1379 {
1380 toolbarRect.top = toolbarRect.bottom - borderSpace.bottom;
1381 }
1382 else if (borderSpace.left != 0)
1383 {
1384 toolbarRect.right = toolbarRect.left + borderSpace.left;
1385 }
1386 else if (borderSpace.right != 0)
1387 {
1388 toolbarRect.left = toolbarRect.right - borderSpace.right;
1389 }
1390
1391 ::SetWindowPos(hwnd, NULL,
1392 toolbarRect.left,
1393 toolbarRect.top,
1394 toolbarRect.right - toolbarRect.left,
1395 toolbarRect.bottom - toolbarRect.top,
1396 SWP_NOOWNERZORDER | SWP_NOZORDER);
1397
1398 if (borderSpace.top != 0)
1399 {
1400 clientRect.top = toolbarRect.bottom;
1401 }
1402 else if (borderSpace.bottom != 0)
1403 {
1404 clientRect.bottom = toolbarRect.top;
1405 }
1406 else if (borderSpace.left != 0)
1407 {
1408 clientRect.left = toolbarRect.right;
1409 }
1410 else if (borderSpace.right != 0)
1411 {
1412 clientRect.right = toolbarRect.left;
1413 }
1414 }
1415 }
1416 ::SetWindowPos(fCurrentShellViewWindow, NULL, clientRect.left, clientRect.top,
1417 clientRect.right - clientRect.left,
1418 clientRect.bottom - clientRect.top, SWP_NOOWNERZORDER | SWP_NOZORDER);
1419 }
1420
1421 HRESULT CShellBrowser::FireEvent(DISPID dispIdMember, int argCount, VARIANT *arguments)
1422 {
1423 DISPPARAMS params;
1424 CComDynamicUnkArray &vec = IConnectionPointImpl<CShellBrowser, &DIID_DWebBrowserEvents2>::m_vec;
1425 CComDynamicUnkArray &vec2 = IConnectionPointImpl<CShellBrowser, &DIID_DWebBrowserEvents>::m_vec;
1426 HRESULT hResult;
1427
1428 params.rgvarg = arguments;
1429 params.rgdispidNamedArgs = NULL;
1430 params.cArgs = argCount;
1431 params.cNamedArgs = 0;
1432 IUnknown** pp = vec.begin();
1433 while (pp < vec.end())
1434 {
1435 if (*pp != NULL)
1436 {
1437 CComPtr<IDispatch> theDispatch;
1438
1439 hResult = (*pp)->QueryInterface(IID_PPV_ARG(IDispatch, &theDispatch));
1440 hResult = theDispatch->Invoke(dispIdMember, GUID_NULL, 0, DISPATCH_METHOD, &params, NULL, NULL, NULL);
1441 }
1442 pp++;
1443 }
1444 pp = vec2.begin();
1445 while (pp < vec2.end())
1446 {
1447 if (*pp != NULL)
1448 {
1449 CComPtr<IDispatch> theDispatch;
1450
1451 hResult = (*pp)->QueryInterface(IID_PPV_ARG(IDispatch, &theDispatch));
1452 hResult = theDispatch->Invoke(dispIdMember, GUID_NULL, 0, DISPATCH_METHOD, &params, NULL, NULL, NULL);
1453 }
1454 pp++;
1455 }
1456 return S_OK;
1457 }
1458
1459 HRESULT CShellBrowser::FireNavigateComplete(const wchar_t *newDirectory)
1460 {
1461 // these two variants intentionally to do use CComVariant because it would double free/release
1462 // or does not need to dispose at all
1463 VARIANT varArg[2];
1464 VARIANT varArgs;
1465 CComBSTR tempString(newDirectory);
1466
1467 V_VT(&varArgs) = VT_BSTR;
1468 V_BSTR(&varArgs) = tempString.m_str;
1469
1470 V_VT(&varArg[0]) = VT_VARIANT | VT_BYREF;
1471 V_VARIANTREF(&varArg[0]) = &varArgs;
1472 V_VT(&varArg[1]) = VT_DISPATCH;
1473 V_DISPATCH(&varArg[1]) = (IDispatch *)this;
1474
1475 return FireEvent(DISPID_NAVIGATECOMPLETE2, 2, varArg);
1476 }
1477
1478 HRESULT CShellBrowser::FireCommandStateChange(bool newState, int commandID)
1479 {
1480 VARIANT varArg[2];
1481
1482 V_VT(&varArg[0]) = VT_BOOL;
1483 V_BOOL(&varArg[0]) = newState ? VARIANT_TRUE : VARIANT_FALSE;
1484 V_VT(&varArg[1]) = VT_I4;
1485 V_I4(&varArg[1]) = commandID;
1486
1487 return FireEvent(DISPID_COMMANDSTATECHANGE, 2, varArg);
1488 }
1489
1490 HRESULT CShellBrowser::FireCommandStateChangeAll()
1491 {
1492 return FireCommandStateChange(false, -1);
1493 }
1494
1495 HRESULT CShellBrowser::UpdateForwardBackState()
1496 {
1497 CComPtr<ITravelLog> travelLog;
1498 CComPtr<ITravelEntry> unusedEntry;
1499 bool canGoBack;
1500 bool canGoForward;
1501 HRESULT hResult;
1502
1503 canGoBack = false;
1504 canGoForward = false;
1505 hResult = GetTravelLog(&travelLog);
1506 if (FAILED_UNEXPECTEDLY(hResult))
1507 return hResult;
1508 hResult = travelLog->GetTravelEntry(static_cast<IDropTarget *>(this), TLOG_BACK, &unusedEntry);
1509 if (SUCCEEDED(hResult))
1510 {
1511 canGoBack = true;
1512 unusedEntry.Release();
1513 }
1514 hResult = travelLog->GetTravelEntry(static_cast<IDropTarget *>(this), TLOG_FORE, &unusedEntry);
1515 if (SUCCEEDED(hResult))
1516 {
1517 canGoForward = true;
1518 unusedEntry.Release();
1519 }
1520 hResult = FireCommandStateChange(canGoBack, 2);
1521 hResult = FireCommandStateChange(canGoForward, 1);
1522 return S_OK;
1523 }
1524
1525 void CShellBrowser::UpdateGotoMenu(HMENU theMenu)
1526 {
1527 CComPtr<ITravelLog> travelLog;
1528 int position;
1529 MENUITEMINFO menuItemInfo;
1530 HRESULT hResult;
1531
1532 DeleteMenuItems(theMenu, IDM_GOTO_TRAVEL_FIRST, IDM_GOTO_TRAVEL_LAST);
1533
1534 position = GetMenuItemCount(theMenu);
1535 hResult = GetTravelLog(&travelLog);
1536 if (FAILED_UNEXPECTEDLY(hResult))
1537 return;
1538 hResult = travelLog->InsertMenuEntries(static_cast<IDropTarget *>(this), theMenu, position,
1539 IDM_GOTO_TRAVEL_FIRSTTARGET, IDM_GOTO_TRAVEL_LASTTARGET, TLMENUF_BACKANDFORTH | TLMENUF_CHECKCURRENT);
1540 if (SUCCEEDED(hResult))
1541 {
1542 menuItemInfo.cbSize = sizeof(menuItemInfo);
1543 menuItemInfo.fMask = MIIM_TYPE | MIIM_ID;
1544 menuItemInfo.fType = MF_SEPARATOR;
1545 menuItemInfo.wID = IDM_GOTO_TRAVEL_SEP;
1546 InsertMenuItem(theMenu, position, TRUE, &menuItemInfo);
1547 }
1548 }
1549
1550 void CShellBrowser::UpdateViewMenu(HMENU theMenu)
1551 {
1552 CComPtr<IOleCommandTarget> oleCommandTarget;
1553 CComPtr<ITravelLog> travelLog;
1554 HMENU gotoMenu;
1555 OLECMD commandList[5];
1556 HMENU toolbarMenuBar;
1557 HMENU toolbarMenu;
1558 MENUITEMINFO menuItemInfo;
1559 HRESULT hResult;
1560
1561 gotoMenu = SHGetMenuFromID(theMenu, FCIDM_MENU_EXPLORE);
1562 if (gotoMenu != NULL)
1563 UpdateGotoMenu(gotoMenu);
1564
1565 commandList[0].cmdID = ITID_TOOLBARBANDSHOWN;
1566 commandList[1].cmdID = ITID_ADDRESSBANDSHOWN;
1567 commandList[2].cmdID = ITID_LINKSBANDSHOWN;
1568 commandList[3].cmdID = ITID_TOOLBARLOCKED;
1569 commandList[4].cmdID = ITID_CUSTOMIZEENABLED;
1570
1571 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
1572 IID_PPV_ARG(IOleCommandTarget, &oleCommandTarget));
1573 if (SUCCEEDED(hResult))
1574 hResult = oleCommandTarget->QueryStatus(&CGID_PrivCITCommands, 5, commandList, NULL);
1575 if (FAILED_UNEXPECTEDLY(hResult))
1576 DeleteMenu(theMenu, IDM_VIEW_TOOLBARS, MF_BYCOMMAND);
1577 else
1578 {
1579 menuItemInfo.cbSize = sizeof(menuItemInfo);
1580 menuItemInfo.fMask = MIIM_SUBMENU;
1581 GetMenuItemInfo(theMenu, IDM_VIEW_TOOLBARS, FALSE, &menuItemInfo);
1582 DestroyMenu(menuItemInfo.hSubMenu);
1583
1584 toolbarMenuBar = LoadMenu(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(IDM_CABINET_CONTEXTMENU));
1585 toolbarMenu = GetSubMenu(toolbarMenuBar, 0);
1586 RemoveMenu(toolbarMenuBar, 0, MF_BYPOSITION);
1587 DestroyMenu(toolbarMenuBar);
1588
1589 SHCheckMenuItem(toolbarMenu, IDM_TOOLBARS_STANDARDBUTTONS, commandList[0].cmdf);
1590 SHCheckMenuItem(toolbarMenu, IDM_TOOLBARS_ADDRESSBAR, commandList[1].cmdf & OLECMDF_ENABLED);
1591 SHCheckMenuItem(toolbarMenu, IDM_TOOLBARS_LINKSBAR, commandList[2].cmdf & OLECMDF_ENABLED);
1592 SHCheckMenuItem(toolbarMenu, IDM_TOOLBARS_LOCKTOOLBARS, commandList[3].cmdf & OLECMDF_ENABLED);
1593 if ((commandList[4].cmdf & OLECMDF_ENABLED) == 0)
1594 DeleteMenu(toolbarMenu, IDM_TOOLBARS_CUSTOMIZE, MF_BYCOMMAND);
1595 DeleteMenu(toolbarMenu, IDM_TOOLBARS_TEXTLABELS, MF_BYCOMMAND);
1596 DeleteMenu(toolbarMenu, IDM_TOOLBARS_GOBUTTON, MF_BYCOMMAND);
1597
1598 menuItemInfo.cbSize = sizeof(menuItemInfo);
1599 menuItemInfo.fMask = MIIM_SUBMENU;
1600 menuItemInfo.hSubMenu = toolbarMenu;
1601 SetMenuItemInfo(theMenu, IDM_VIEW_TOOLBARS, FALSE, &menuItemInfo);
1602 }
1603 SHCheckMenuItem(theMenu, IDM_VIEW_STATUSBAR, fStatusBarVisible ? TRUE : FALSE);
1604 }
1605
1606 bool IUnknownIsEqual(IUnknown *int1, IUnknown *int2)
1607 {
1608 CComPtr<IUnknown> int1Retry;
1609 CComPtr<IUnknown> int2Retry;
1610 HRESULT hResult;
1611
1612 if (int1 == int2)
1613 return true;
1614 if (int1 == NULL || int2 == NULL)
1615 return false;
1616 hResult = int1->QueryInterface(IID_PPV_ARG(IUnknown, &int1Retry));
1617 if (FAILED_UNEXPECTEDLY(hResult))
1618 return false;
1619 hResult = int2->QueryInterface(IID_PPV_ARG(IUnknown, &int2Retry));
1620 if (FAILED_UNEXPECTEDLY(hResult))
1621 return false;
1622 if (int1Retry == int2Retry)
1623 return true;
1624 return false;
1625 }
1626
1627 HRESULT STDMETHODCALLTYPE CShellBrowser::GetBorderDW(IUnknown *punkObj, LPRECT prcBorder)
1628 {
1629 static const INT excludeItems[] = { 1, 1, 1, 0xa001, 0, 0 };
1630
1631 RECT availableBounds;
1632
1633 GetEffectiveClientRect(m_hWnd, &availableBounds, excludeItems);
1634 for (INT x = 0; x < 3; x++)
1635 {
1636 if (fClientBars[x].clientBar.p != NULL && !IUnknownIsEqual(fClientBars[x].clientBar, punkObj))
1637 {
1638 availableBounds.top += fClientBars[x].borderSpace.top;
1639 availableBounds.left += fClientBars[x].borderSpace.left;
1640 availableBounds.bottom -= fClientBars[x].borderSpace.bottom;
1641 availableBounds.right -= fClientBars[x].borderSpace.right;
1642 }
1643 }
1644 *prcBorder = availableBounds;
1645 return S_OK;
1646 }
1647
1648 HRESULT STDMETHODCALLTYPE CShellBrowser::RequestBorderSpaceDW(IUnknown* punkObj, LPCBORDERWIDTHS pbw)
1649 {
1650 return S_OK;
1651 }
1652
1653 HRESULT STDMETHODCALLTYPE CShellBrowser::SetBorderSpaceDW(IUnknown* punkObj, LPCBORDERWIDTHS pbw)
1654 {
1655 for (INT x = 0; x < 3; x++)
1656 {
1657 if (IUnknownIsEqual(fClientBars[x].clientBar, punkObj))
1658 {
1659 fClientBars[x].borderSpace = *pbw;
1660 // if this bar changed size, it cascades and forces all subsequent bars to resize
1661 RepositionBars();
1662 return S_OK;
1663 }
1664 }
1665 return E_INVALIDARG;
1666 }
1667
1668 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryStatus(const GUID *pguidCmdGroup,
1669 ULONG cCmds, OLECMD prgCmds[ ], OLECMDTEXT *pCmdText)
1670 {
1671 CComPtr<IOleCommandTarget> commandTarget;
1672 HRESULT hResult;
1673
1674 if (prgCmds == NULL)
1675 return E_INVALIDARG;
1676 if (pguidCmdGroup == NULL)
1677 {
1678 if (fCurrentShellView.p != NULL)
1679 {
1680 hResult = fCurrentShellView->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &commandTarget));
1681 if (SUCCEEDED(hResult) && commandTarget.p != NULL)
1682 return commandTarget->QueryStatus(NULL, 1, prgCmds, pCmdText);
1683 }
1684 while (cCmds != 0)
1685 {
1686 prgCmds->cmdf = 0;
1687 prgCmds++;
1688 cCmds--;
1689 }
1690 }
1691 else if (IsEqualIID(*pguidCmdGroup, CGID_Explorer))
1692 {
1693 while (cCmds != 0)
1694 {
1695 switch (prgCmds->cmdID)
1696 {
1697 case 0x1c: // search
1698 prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1699 break;
1700 case 0x1d: // history
1701 prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1702 break;
1703 case 0x1e: // favorites
1704 prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1705 break;
1706 case 0x23: // folders
1707 prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED | OLECMDF_LATCHED;
1708 break;
1709 default:
1710 prgCmds->cmdf = 0;
1711 break;
1712 }
1713 prgCmds++;
1714 cCmds--;
1715 }
1716 }
1717 else if (IsEqualIID(*pguidCmdGroup, CGID_ShellBrowser))
1718 {
1719 while (cCmds != 0)
1720 {
1721 switch (prgCmds->cmdID)
1722 {
1723 case 0xa022: // up level
1724 prgCmds->cmdf = OLECMDF_SUPPORTED;
1725 if (fCurrentDirectoryPIDL->mkid.cb != 0)
1726 prgCmds->cmdf |= OLECMDF_ENABLED;
1727 break;
1728 }
1729 prgCmds++;
1730 cCmds--;
1731 }
1732 }
1733 return S_OK;
1734 }
1735
1736 HRESULT STDMETHODCALLTYPE CShellBrowser::Exec(const GUID *pguidCmdGroup, DWORD nCmdID,
1737 DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
1738 {
1739 HRESULT hResult;
1740
1741 if (IsEqualIID(*pguidCmdGroup, CGID_Explorer))
1742 {
1743 switch (nCmdID)
1744 {
1745 case 0x23:
1746 hResult = ShowBand(CLSID_ExplorerBand, true);
1747 return S_OK;
1748 case 0x27:
1749 if (nCmdexecopt == 1)
1750 {
1751 // pvaIn is a VT_UNKNOWN with a band that is being hidden
1752 }
1753 else
1754 {
1755 // update zones part of the status bar
1756 }
1757 return S_OK;
1758 case 0x35: // don't do this, and the internet toolbar doesn't create a menu band
1759 V_VT(pvaOut) = VT_INT_PTR;
1760 V_INTREF(pvaOut) = reinterpret_cast<INT *>(
1761 LoadMenu(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(IDM_CABINET_MAINMENU)));
1762 return S_OK;
1763 case 0x38:
1764 // indicate if this cabinet was opened as a browser
1765 return S_FALSE;
1766 default:
1767 return E_NOTIMPL;
1768 }
1769 }
1770 else if (IsEqualIID(*pguidCmdGroup, CGID_InternetButtons))
1771 {
1772 switch (nCmdID)
1773 {
1774 case 0x23:
1775 // placeholder
1776 return S_OK;
1777 }
1778 }
1779 else if (IsEqualIID(*pguidCmdGroup, CGID_Theater))
1780 {
1781 switch (nCmdID)
1782 {
1783 case 6:
1784 // what is theater mode and why do we receive this?
1785 return E_NOTIMPL;
1786 }
1787 }
1788 else if (IsEqualIID(*pguidCmdGroup, CGID_MenuBand))
1789 {
1790 switch (nCmdID)
1791 {
1792 case 14:
1793 // initialize favorites menu
1794 return S_OK;
1795 }
1796 }
1797 else if (IsEqualIID(*pguidCmdGroup, CGID_ShellDocView))
1798 {
1799 switch (nCmdID)
1800 {
1801 case 0x12:
1802 // refresh on toolbar clicked
1803 return S_OK;
1804 case 0x4d:
1805 // tell the view if it should hide the task pane or not
1806 return (fClientBars[BIVerticalBaseBar].clientBar.p == NULL) ? S_FALSE : S_OK;
1807 }
1808 }
1809 else if (IsEqualIID(*pguidCmdGroup, CGID_ShellBrowser))
1810 {
1811 switch (nCmdID)
1812 {
1813 case 40994:
1814 return NavigateToParent();
1815 }
1816 }
1817 else if (IsEqualIID(*pguidCmdGroup, CGID_IExplorerToolbar))
1818 {
1819 switch (nCmdID)
1820 {
1821 case 0x7063:
1822 return DoFolderOptions();
1823 }
1824 }
1825 else if (IsEqualIID(*pguidCmdGroup, CGID_DefView))
1826 {
1827 switch (nCmdID)
1828 {
1829 case 1:
1830 // Reset All Folders option in Folder Options
1831 break;
1832 }
1833 }
1834 else
1835 {
1836 return E_NOTIMPL;
1837 }
1838 return E_NOTIMPL;
1839 }
1840
1841 HRESULT STDMETHODCALLTYPE CShellBrowser::GetWindow(HWND *lphwnd)
1842 {
1843 if (lphwnd == NULL)
1844 return E_POINTER;
1845 *lphwnd = m_hWnd;
1846 return S_OK;
1847 }
1848
1849 HRESULT STDMETHODCALLTYPE CShellBrowser::ContextSensitiveHelp(BOOL fEnterMode)
1850 {
1851 return E_NOTIMPL;
1852 }
1853
1854 HRESULT STDMETHODCALLTYPE CShellBrowser::InsertMenusSB(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths)
1855 {
1856 HMENU mainMenu = LoadMenu(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(IDM_CABINET_MAINMENU));
1857
1858 Shell_MergeMenus(hmenuShared, mainMenu, 0, 0, FCIDM_BROWSERLAST, MM_SUBMENUSHAVEIDS);
1859
1860 int GCCU(itemCount3) = GetMenuItemCount(hmenuShared);
1861 Unused(itemCount3);
1862
1863 DestroyMenu(mainMenu);
1864
1865 lpMenuWidths->width[0] = 2;
1866 lpMenuWidths->width[2] = 3;
1867 lpMenuWidths->width[4] = 1;
1868 return S_OK;
1869 }
1870
1871 HRESULT STDMETHODCALLTYPE CShellBrowser::SetMenuSB(HMENU hmenuShared, HOLEMENU holemenuRes, HWND hwndActiveObject)
1872 {
1873 CComPtr<IShellMenu> shellMenu;
1874 HRESULT hResult;
1875
1876 if (hmenuShared && IsMenu(hmenuShared) == FALSE)
1877 return E_FAIL;
1878 hResult = GetMenuBand(IID_PPV_ARG(IShellMenu, &shellMenu));
1879 if (FAILED_UNEXPECTEDLY(hResult))
1880 return hResult;
1881 hResult = shellMenu->SetMenu(hmenuShared, NULL, SMSET_DONTOWN);
1882 if (FAILED_UNEXPECTEDLY(hResult))
1883 return hResult;
1884 fCurrentMenuBar = hmenuShared;
1885 return S_OK;
1886 }
1887
1888 HRESULT STDMETHODCALLTYPE CShellBrowser::RemoveMenusSB(HMENU hmenuShared)
1889 {
1890 if (hmenuShared == fCurrentMenuBar)
1891 {
1892 //DestroyMenu(fCurrentMenuBar);
1893 SetMenuSB(NULL, NULL, NULL);
1894 }
1895 return S_OK;
1896 }
1897
1898 HRESULT STDMETHODCALLTYPE CShellBrowser::SetStatusTextSB(LPCOLESTR pszStatusText)
1899 {
1900 //
1901 if (pszStatusText)
1902 {
1903 ::SetWindowText(fStatusBar, pszStatusText);
1904 }
1905 else
1906 {
1907
1908 }
1909 return E_NOTIMPL;
1910 }
1911
1912 HRESULT STDMETHODCALLTYPE CShellBrowser::EnableModelessSB(BOOL fEnable)
1913 {
1914 return E_NOTIMPL;
1915 }
1916
1917 HRESULT STDMETHODCALLTYPE CShellBrowser::TranslateAcceleratorSB(MSG *pmsg, WORD wID)
1918 {
1919 if (!::TranslateAcceleratorW(m_hWnd, m_hAccel, pmsg))
1920 return S_FALSE;
1921 return S_OK;
1922 }
1923
1924 HRESULT STDMETHODCALLTYPE CShellBrowser::BrowseObject(LPCITEMIDLIST pidl, UINT wFlags)
1925 {
1926 return BrowseToPIDL(pidl, BTP_UPDATE_CUR_HISTORY | BTP_UPDATE_NEXT_HISTORY);
1927 }
1928
1929 HRESULT STDMETHODCALLTYPE CShellBrowser::GetViewStateStream(DWORD grfMode, IStream **ppStrm)
1930 {
1931 return E_NOTIMPL;
1932 }
1933
1934 HRESULT STDMETHODCALLTYPE CShellBrowser::GetControlWindow(UINT id, HWND *lphwnd)
1935 {
1936 if (lphwnd == NULL)
1937 return E_POINTER;
1938 *lphwnd = NULL;
1939 switch(id)
1940 {
1941 case FCW_TOOLBAR:
1942 *lphwnd = fToolbarProxy.m_hWnd;
1943 return S_OK;
1944 case FCW_STATUS:
1945 *lphwnd = fStatusBar;
1946 return S_OK;
1947 case FCW_TREE:
1948 // find the directory browser and return it
1949 // this should be used only to determine if a tree is present
1950 return S_OK;
1951 case FCW_PROGRESS:
1952 // is this a progress dialog?
1953 return S_OK;
1954 }
1955 return S_OK;
1956 }
1957
1958 HRESULT STDMETHODCALLTYPE CShellBrowser::SendControlMsg(
1959 UINT id, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *pret)
1960 {
1961 LPARAM result;
1962
1963 if (pret != NULL)
1964 *pret = 0;
1965 switch(id)
1966 {
1967 case FCW_TOOLBAR:
1968 result = fToolbarProxy.SendMessage(uMsg, wParam, lParam);
1969 if (pret != NULL)
1970 *pret = result;
1971 break;
1972 case FCW_STATUS:
1973 result = SendMessage(fStatusBar, uMsg, wParam, lParam);
1974 if (pret != NULL)
1975 *pret = result;
1976 break;
1977 }
1978 return S_OK;
1979 }
1980
1981 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryActiveShellView(IShellView **ppshv)
1982 {
1983 if (ppshv == NULL)
1984 return E_POINTER;
1985 *ppshv = fCurrentShellView;
1986 if (fCurrentShellView.p != NULL)
1987 fCurrentShellView.p->AddRef();
1988 return S_OK;
1989 }
1990
1991 HRESULT STDMETHODCALLTYPE CShellBrowser::OnViewWindowActive(IShellView *ppshv)
1992 {
1993 return E_NOTIMPL;
1994 }
1995
1996 HRESULT STDMETHODCALLTYPE CShellBrowser::SetToolbarItems(LPTBBUTTON lpButtons, UINT nButtons, UINT uFlags)
1997 {
1998 return E_NOTIMPL;
1999 }
2000
2001 HRESULT STDMETHODCALLTYPE CShellBrowser::DragEnter(
2002 IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
2003 {
2004 return E_NOTIMPL;
2005 }
2006
2007 HRESULT STDMETHODCALLTYPE CShellBrowser::DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
2008 {
2009 return E_NOTIMPL;
2010 }
2011
2012 HRESULT STDMETHODCALLTYPE CShellBrowser::DragLeave()
2013 {
2014 return E_NOTIMPL;
2015 }
2016
2017 HRESULT STDMETHODCALLTYPE CShellBrowser::Drop(
2018 IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
2019 {
2020 return E_NOTIMPL;
2021 }
2022
2023 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
2024 {
2025 // view does a query for SID_STopLevelBrowser, IID_IShellBrowserService
2026 // the returned interface has a method GetPropertyBag on it
2027 if (IsEqualIID(guidService, SID_STopLevelBrowser))
2028 return this->QueryInterface(riid, ppvObject);
2029 if (IsEqualIID(guidService, SID_SShellBrowser))
2030 return this->QueryInterface(riid, ppvObject);
2031 if (IsEqualIID(guidService, SID_ITargetFrame2))
2032 return this->QueryInterface(riid, ppvObject);
2033 if (IsEqualIID(guidService, SID_IWebBrowserApp)) // without this, the internet toolbar won't reflect notifications
2034 return this->QueryInterface(riid, ppvObject);
2035 if (IsEqualIID(guidService, SID_SProxyBrowser))
2036 return this->QueryInterface(riid, ppvObject);
2037 if (IsEqualIID(guidService, SID_IExplorerToolbar))
2038 return fClientBars[BIInternetToolbar].clientBar->QueryInterface(riid, ppvObject);
2039 if (IsEqualIID(riid, IID_IShellBrowser))
2040 return this->QueryInterface(riid, ppvObject);
2041 return E_NOINTERFACE;
2042 }
2043
2044 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPropertyBag(long flags, REFIID riid, void **ppvObject)
2045 {
2046 if (ppvObject == NULL)
2047 return E_POINTER;
2048 *ppvObject = NULL;
2049 return E_NOTIMPL;
2050 }
2051
2052 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTypeInfoCount(UINT *pctinfo)
2053 {
2054 return E_NOTIMPL;
2055 }
2056
2057 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
2058 {
2059 return E_NOTIMPL;
2060 }
2061
2062 HRESULT STDMETHODCALLTYPE CShellBrowser::GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames,
2063 UINT cNames, LCID lcid, DISPID *rgDispId)
2064 {
2065 return E_NOTIMPL;
2066 }
2067
2068 HRESULT STDMETHODCALLTYPE CShellBrowser::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
2069 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2070 {
2071 return E_NOTIMPL;
2072 }
2073
2074 HRESULT STDMETHODCALLTYPE CShellBrowser::GetParentSite(IOleInPlaceSite **ppipsite)
2075 {
2076 return E_NOTIMPL;
2077 }
2078
2079 HRESULT STDMETHODCALLTYPE CShellBrowser::SetTitle(IShellView *psv, LPCWSTR pszName)
2080 {
2081 return E_NOTIMPL;
2082 }
2083
2084 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTitle(IShellView *psv, LPWSTR pszName, DWORD cchName)
2085 {
2086 return E_NOTIMPL;
2087 }
2088
2089 HRESULT STDMETHODCALLTYPE CShellBrowser::GetOleObject(IOleObject **ppobjv)
2090 {
2091 return E_NOTIMPL;
2092 }
2093
2094 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTravelLog(ITravelLog **pptl)
2095 {
2096 HRESULT hResult;
2097
2098 // called by toolbar when displaying tooltips
2099 if (pptl == NULL)
2100 return E_FAIL;
2101
2102 *pptl = NULL;
2103 if (fTravelLog.p == NULL)
2104 {
2105 hResult = CreateTravelLog(IID_PPV_ARG(ITravelLog, &fTravelLog));
2106 if (FAILED_UNEXPECTEDLY(hResult))
2107 return hResult;
2108 }
2109 *pptl = fTravelLog.p;
2110 fTravelLog.p->AddRef();
2111 return S_OK;
2112 }
2113
2114 HRESULT STDMETHODCALLTYPE CShellBrowser::ShowControlWindow(UINT id, BOOL fShow)
2115 {
2116 return E_NOTIMPL;
2117 }
2118
2119 HRESULT STDMETHODCALLTYPE CShellBrowser::IsControlWindowShown(UINT id, BOOL *pfShown)
2120 {
2121 return E_NOTIMPL;
2122 }
2123
2124 HRESULT STDMETHODCALLTYPE CShellBrowser::IEGetDisplayName(LPCITEMIDLIST pidl, LPWSTR pwszName, UINT uFlags)
2125 {
2126 return E_NOTIMPL;
2127 }
2128
2129 HRESULT STDMETHODCALLTYPE CShellBrowser::IEParseDisplayName(UINT uiCP, LPCWSTR pwszPath, LPITEMIDLIST *ppidlOut)
2130 {
2131 return E_NOTIMPL;
2132 }
2133
2134 HRESULT STDMETHODCALLTYPE CShellBrowser::DisplayParseError(HRESULT hres, LPCWSTR pwszPath)
2135 {
2136 return E_NOTIMPL;
2137 }
2138
2139 HRESULT STDMETHODCALLTYPE CShellBrowser::NavigateToPidl(LPCITEMIDLIST pidl, DWORD grfHLNF)
2140 {
2141 return E_NOTIMPL;
2142 }
2143
2144 HRESULT STDMETHODCALLTYPE CShellBrowser::SetNavigateState(BNSTATE bnstate)
2145 {
2146 return E_NOTIMPL;
2147 }
2148
2149 HRESULT STDMETHODCALLTYPE CShellBrowser::GetNavigateState(BNSTATE *pbnstate)
2150 {
2151 return E_NOTIMPL;
2152 }
2153
2154 HRESULT STDMETHODCALLTYPE CShellBrowser::NotifyRedirect(IShellView *psv, LPCITEMIDLIST pidl, BOOL *pfDidBrowse)
2155 {
2156 return E_NOTIMPL;
2157 }
2158
2159 HRESULT STDMETHODCALLTYPE CShellBrowser::UpdateWindowList()
2160 {
2161 return E_NOTIMPL;
2162 }
2163
2164 HRESULT STDMETHODCALLTYPE CShellBrowser::UpdateBackForwardState()
2165 {
2166 return E_NOTIMPL;
2167 }
2168
2169 HRESULT STDMETHODCALLTYPE CShellBrowser::SetFlags(DWORD dwFlags, DWORD dwFlagMask)
2170 {
2171 return E_NOTIMPL;
2172 }
2173
2174 HRESULT STDMETHODCALLTYPE CShellBrowser::GetFlags(DWORD *pdwFlags)
2175 {
2176 return E_NOTIMPL;
2177 }
2178
2179 HRESULT STDMETHODCALLTYPE CShellBrowser::CanNavigateNow()
2180 {
2181 return E_NOTIMPL;
2182 }
2183
2184 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPidl(LPITEMIDLIST *ppidl)
2185 {
2186 // called by explorer bar to get current pidl
2187 if (ppidl == NULL)
2188 return E_POINTER;
2189 *ppidl = ILClone(fCurrentDirectoryPIDL);
2190 return S_OK;
2191 }
2192
2193 HRESULT STDMETHODCALLTYPE CShellBrowser::SetReferrer(LPCITEMIDLIST pidl)
2194 {
2195 return E_NOTIMPL;
2196 }
2197
2198 DWORD STDMETHODCALLTYPE CShellBrowser::GetBrowserIndex()
2199 {
2200 return -1;
2201 }
2202
2203 HRESULT STDMETHODCALLTYPE CShellBrowser::GetBrowserByIndex(DWORD dwID, IUnknown **ppunk)
2204 {
2205 return E_NOTIMPL;
2206 }
2207
2208 HRESULT STDMETHODCALLTYPE CShellBrowser::GetHistoryObject(IOleObject **ppole, IStream **pstm, IBindCtx **ppbc)
2209 {
2210 if (ppole == NULL || pstm == NULL || ppbc == NULL)
2211 return E_INVALIDARG;
2212 *ppole = fHistoryObject;
2213 if (fHistoryObject != NULL)
2214 fHistoryObject->AddRef();
2215 *pstm = fHistoryStream;
2216 if (fHistoryStream != NULL)
2217 fHistoryStream->AddRef();
2218 *ppbc = fHistoryBindContext;
2219 if (fHistoryBindContext != NULL)
2220 fHistoryBindContext->AddRef();
2221 fHistoryObject = NULL;
2222 fHistoryStream = NULL;
2223 fHistoryBindContext = NULL;
2224 if (*ppole == NULL)
2225 return E_FAIL;
2226 return S_OK;
2227 }
2228
2229 HRESULT STDMETHODCALLTYPE CShellBrowser::SetHistoryObject(IOleObject *pole, BOOL fIsLocalAnchor)
2230 {
2231 return E_NOTIMPL;
2232 }
2233
2234 HRESULT STDMETHODCALLTYPE CShellBrowser::CacheOLEServer(IOleObject *pole)
2235 {
2236 return E_NOTIMPL;
2237 }
2238
2239 HRESULT STDMETHODCALLTYPE CShellBrowser::GetSetCodePage(VARIANT *pvarIn, VARIANT *pvarOut)
2240 {
2241 return E_NOTIMPL;
2242 }
2243
2244 HRESULT STDMETHODCALLTYPE CShellBrowser::OnHttpEquiv(
2245 IShellView *psv, BOOL fDone, VARIANT *pvarargIn, VARIANT *pvarargOut)
2246 {
2247 return E_NOTIMPL;
2248 }
2249
2250 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPalette(HPALETTE *hpal)
2251 {
2252 return E_NOTIMPL;
2253 }
2254
2255 HRESULT STDMETHODCALLTYPE CShellBrowser::RegisterWindow(BOOL fForceRegister, int swc)
2256 {
2257 return E_NOTIMPL;
2258 }
2259
2260 LRESULT STDMETHODCALLTYPE CShellBrowser::WndProcBS(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
2261 {
2262 return E_NOTIMPL;
2263 }
2264
2265 HRESULT STDMETHODCALLTYPE CShellBrowser::SetAsDefFolderSettings()
2266 {
2267 return E_NOTIMPL;
2268 }
2269
2270 HRESULT STDMETHODCALLTYPE CShellBrowser::GetViewRect(RECT *prc)
2271 {
2272 return E_NOTIMPL;
2273 }
2274
2275 HRESULT STDMETHODCALLTYPE CShellBrowser::OnSize(WPARAM wParam)
2276 {
2277 return E_NOTIMPL;
2278 }
2279
2280 HRESULT STDMETHODCALLTYPE CShellBrowser::OnCreate(struct tagCREATESTRUCTW *pcs)
2281 {
2282 m_hAccel = LoadAcceleratorsW(GetModuleHandle(L"browseui.dll"), MAKEINTRESOURCEW(256));
2283 return S_OK;
2284 }
2285
2286 LRESULT STDMETHODCALLTYPE CShellBrowser::OnCommand(WPARAM wParam, LPARAM lParam)
2287 {
2288 return 0;
2289 }
2290
2291 HRESULT STDMETHODCALLTYPE CShellBrowser::OnDestroy()
2292 {
2293 return E_NOTIMPL;
2294 }
2295
2296 LRESULT STDMETHODCALLTYPE CShellBrowser::OnNotify(struct tagNMHDR *pnm)
2297 {
2298 return 0;
2299 }
2300
2301 HRESULT STDMETHODCALLTYPE CShellBrowser::OnSetFocus()
2302 {
2303 return E_NOTIMPL;
2304 }
2305
2306 HRESULT STDMETHODCALLTYPE CShellBrowser::OnFrameWindowActivateBS(BOOL fActive)
2307 {
2308 return E_NOTIMPL;
2309 }
2310
2311 HRESULT STDMETHODCALLTYPE CShellBrowser::ReleaseShellView()
2312 {
2313 return E_NOTIMPL;
2314 }
2315
2316 HRESULT STDMETHODCALLTYPE CShellBrowser::ActivatePendingView()
2317 {
2318 return E_NOTIMPL;
2319 }
2320
2321 HRESULT STDMETHODCALLTYPE CShellBrowser::CreateViewWindow(
2322 IShellView *psvNew, IShellView *psvOld, LPRECT prcView, HWND *phwnd)
2323 {
2324 return E_NOTIMPL;
2325 }
2326
2327 HRESULT STDMETHODCALLTYPE CShellBrowser::CreateBrowserPropSheetExt(REFIID riid, void **ppv)
2328 {
2329 return E_NOTIMPL;
2330 }
2331
2332 HRESULT STDMETHODCALLTYPE CShellBrowser::GetViewWindow(HWND *phwndView)
2333 {
2334 return E_NOTIMPL;
2335 }
2336
2337 HRESULT STDMETHODCALLTYPE CShellBrowser::GetBaseBrowserData(LPCBASEBROWSERDATA *pbbd)
2338 {
2339 return E_NOTIMPL;
2340 }
2341
2342 LPBASEBROWSERDATA STDMETHODCALLTYPE CShellBrowser::PutBaseBrowserData()
2343 {
2344 return NULL;
2345 }
2346
2347 HRESULT STDMETHODCALLTYPE CShellBrowser::InitializeTravelLog(ITravelLog *ptl, DWORD dw)
2348 {
2349 return E_NOTIMPL;
2350 }
2351
2352 HRESULT STDMETHODCALLTYPE CShellBrowser::SetTopBrowser()
2353 {
2354 return E_NOTIMPL;
2355 }
2356
2357 HRESULT STDMETHODCALLTYPE CShellBrowser::Offline(int iCmd)
2358 {
2359 return E_NOTIMPL;
2360 }
2361
2362 HRESULT STDMETHODCALLTYPE CShellBrowser::AllowViewResize(BOOL f)
2363 {
2364 return E_NOTIMPL;
2365 }
2366
2367 HRESULT STDMETHODCALLTYPE CShellBrowser::SetActivateState(UINT u)
2368 {
2369 return E_NOTIMPL;
2370 }
2371
2372 HRESULT STDMETHODCALLTYPE CShellBrowser::UpdateSecureLockIcon(int eSecureLock)
2373 {
2374 return E_NOTIMPL;
2375 }
2376
2377 HRESULT STDMETHODCALLTYPE CShellBrowser::InitializeDownloadManager()
2378 {
2379 return E_NOTIMPL;
2380 }
2381
2382 HRESULT STDMETHODCALLTYPE CShellBrowser::InitializeTransitionSite()
2383 {
2384 return E_NOTIMPL;
2385 }
2386
2387 HRESULT STDMETHODCALLTYPE CShellBrowser::_Initialize(HWND hwnd, IUnknown *pauto)
2388 {
2389 return E_NOTIMPL;
2390 }
2391
2392 HRESULT STDMETHODCALLTYPE CShellBrowser::_CancelPendingNavigationAsync()
2393 {
2394 return E_NOTIMPL;
2395 }
2396
2397 HRESULT STDMETHODCALLTYPE CShellBrowser::_CancelPendingView()
2398 {
2399 return E_NOTIMPL;
2400 }
2401
2402 HRESULT STDMETHODCALLTYPE CShellBrowser::_MaySaveChanges()
2403 {
2404 return E_NOTIMPL;
2405 }
2406
2407 HRESULT STDMETHODCALLTYPE CShellBrowser::_PauseOrResumeView(BOOL fPaused)
2408 {
2409 return E_NOTIMPL;
2410 }
2411
2412 HRESULT STDMETHODCALLTYPE CShellBrowser::_DisableModeless()
2413 {
2414 return E_NOTIMPL;
2415 }
2416
2417 HRESULT STDMETHODCALLTYPE CShellBrowser::_NavigateToPidl(LPCITEMIDLIST pidl, DWORD grfHLNF, DWORD dwFlags)
2418 {
2419 return E_NOTIMPL;
2420 }
2421
2422 HRESULT STDMETHODCALLTYPE CShellBrowser::_TryShell2Rename(IShellView *psv, LPCITEMIDLIST pidlNew)
2423 {
2424 return E_NOTIMPL;
2425 }
2426
2427 HRESULT STDMETHODCALLTYPE CShellBrowser::_SwitchActivationNow()
2428 {
2429 return E_NOTIMPL;
2430 }
2431
2432 HRESULT STDMETHODCALLTYPE CShellBrowser::_ExecChildren(IUnknown *punkBar, BOOL fBroadcast,
2433 const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
2434 {
2435 return E_NOTIMPL;
2436 }
2437
2438 HRESULT STDMETHODCALLTYPE CShellBrowser::_SendChildren(
2439 HWND hwndBar, BOOL fBroadcast, UINT uMsg, WPARAM wParam, LPARAM lParam)
2440 {
2441 return E_NOTIMPL;
2442 }
2443
2444 HRESULT STDMETHODCALLTYPE CShellBrowser::GetFolderSetData(struct tagFolderSetData *pfsd)
2445 {
2446 return E_NOTIMPL;
2447 }
2448
2449 HRESULT STDMETHODCALLTYPE CShellBrowser::_OnFocusChange(UINT itb)
2450 {
2451 return E_NOTIMPL;
2452 }
2453
2454 HRESULT STDMETHODCALLTYPE CShellBrowser::v_ShowHideChildWindows(BOOL fChildOnly)
2455 {
2456 return E_NOTIMPL;
2457 }
2458
2459 UINT STDMETHODCALLTYPE CShellBrowser::_get_itbLastFocus()
2460 {
2461 return 0;
2462 }
2463
2464 HRESULT STDMETHODCALLTYPE CShellBrowser::_put_itbLastFocus(UINT itbLastFocus)
2465 {
2466 return E_NOTIMPL;
2467 }
2468
2469 HRESULT STDMETHODCALLTYPE CShellBrowser::_UIActivateView(UINT uState)
2470 {
2471 return E_NOTIMPL;
2472 }
2473
2474 HRESULT STDMETHODCALLTYPE CShellBrowser::_GetViewBorderRect(RECT *prc)
2475 {
2476 return E_NOTIMPL;
2477 }
2478
2479 HRESULT STDMETHODCALLTYPE CShellBrowser::_UpdateViewRectSize()
2480 {
2481 return E_NOTIMPL;
2482 }
2483
2484 HRESULT STDMETHODCALLTYPE CShellBrowser::_ResizeNextBorder(UINT itb)
2485 {
2486 return E_NOTIMPL;
2487 }
2488
2489 HRESULT STDMETHODCALLTYPE CShellBrowser::_ResizeView()
2490 {
2491 return E_NOTIMPL;
2492 }
2493
2494 HRESULT STDMETHODCALLTYPE CShellBrowser::_GetEffectiveClientArea(LPRECT lprectBorder, HMONITOR hmon)
2495 {
2496 return E_NOTIMPL;
2497 }
2498
2499 IStream *STDMETHODCALLTYPE CShellBrowser::v_GetViewStream(LPCITEMIDLIST pidl, DWORD grfMode, LPCWSTR pwszName)
2500 {
2501 return NULL;
2502 }
2503
2504 LRESULT STDMETHODCALLTYPE CShellBrowser::ForwardViewMsg(UINT uMsg, WPARAM wParam, LPARAM lParam)
2505 {
2506 return 0;
2507 }
2508
2509 HRESULT STDMETHODCALLTYPE CShellBrowser::SetAcceleratorMenu(HACCEL hacc)
2510 {
2511 return E_NOTIMPL;
2512 }
2513
2514 int STDMETHODCALLTYPE CShellBrowser::_GetToolbarCount()
2515 {
2516 return 0;
2517 }
2518
2519 LPTOOLBARITEM STDMETHODCALLTYPE CShellBrowser::_GetToolbarItem(int itb)
2520 {
2521 return NULL;
2522 }
2523
2524 HRESULT STDMETHODCALLTYPE CShellBrowser::_SaveToolbars(IStream *pstm)
2525 {
2526 return E_NOTIMPL;
2527 }
2528
2529 HRESULT STDMETHODCALLTYPE CShellBrowser::_LoadToolbars(IStream *pstm)
2530 {
2531 return E_NOTIMPL;
2532 }
2533
2534 HRESULT STDMETHODCALLTYPE CShellBrowser::_CloseAndReleaseToolbars(BOOL fClose)
2535 {
2536 return E_NOTIMPL;
2537 }
2538
2539 HRESULT STDMETHODCALLTYPE CShellBrowser::v_MayGetNextToolbarFocus(
2540 LPMSG lpMsg, UINT itbNext, int citb, LPTOOLBARITEM *pptbi, HWND *phwnd)
2541 {
2542 return E_NOTIMPL;
2543 }
2544
2545 HRESULT STDMETHODCALLTYPE CShellBrowser::_ResizeNextBorderHelper(UINT itb, BOOL bUseHmonitor)
2546 {
2547 return E_NOTIMPL;
2548 }
2549
2550 UINT STDMETHODCALLTYPE CShellBrowser::_FindTBar(IUnknown *punkSrc)
2551 {
2552 return 0;
2553 }
2554
2555 HRESULT STDMETHODCALLTYPE CShellBrowser::_SetFocus(LPTOOLBARITEM ptbi, HWND hwnd, LPMSG lpMsg)
2556 {
2557 return E_NOTIMPL;
2558 }
2559
2560 extern HRESULT IUnknown_HasFocusIO(IUnknown * punk);
2561 extern HRESULT IUnknown_TranslateAcceleratorIO(IUnknown * punk, MSG * pmsg);
2562 HRESULT STDMETHODCALLTYPE CShellBrowser::v_MayTranslateAccelerator(MSG *pmsg)
2563 {
2564 for (int i = 0; i < 3; i++)
2565 {
2566 if (IUnknown_TranslateAcceleratorIO(fClientBars[i].clientBar, pmsg) == S_OK)
2567 return S_OK;
2568 }
2569
2570 if (!fCurrentShellView)
2571 return S_FALSE;
2572
2573 return fCurrentShellView->TranslateAcceleratorW(pmsg);
2574 }
2575
2576 HRESULT STDMETHODCALLTYPE CShellBrowser::_GetBorderDWHelper(IUnknown *punkSrc, LPRECT lprectBorder, BOOL bUseHmonitor)
2577 {
2578 return E_NOTIMPL;
2579 }
2580
2581 HRESULT STDMETHODCALLTYPE CShellBrowser::v_CheckZoneCrossing(LPCITEMIDLIST pidl)
2582 {
2583 return E_NOTIMPL;
2584 }
2585
2586 HRESULT STDMETHODCALLTYPE CShellBrowser::GoBack()
2587 {
2588 CComPtr<ITravelLog> travelLog;
2589 HRESULT hResult;
2590
2591 hResult = GetTravelLog(&travelLog);
2592 if (FAILED_UNEXPECTEDLY(hResult))
2593 return hResult;
2594 return travelLog->Travel(static_cast<IDropTarget *>(this), TLOG_BACK);
2595 }
2596
2597 HRESULT STDMETHODCALLTYPE CShellBrowser::GoForward()
2598 {
2599 CComPtr<ITravelLog> travelLog;
2600 HRESULT hResult;
2601
2602 hResult = GetTravelLog(&travelLog);
2603 if (FAILED_UNEXPECTEDLY(hResult))
2604 return hResult;
2605 return travelLog->Travel(static_cast<IDropTarget *>(this), TLOG_FORE);
2606 }
2607
2608 HRESULT STDMETHODCALLTYPE CShellBrowser::GoHome()
2609 {
2610 return E_NOTIMPL;
2611 }
2612
2613 HRESULT STDMETHODCALLTYPE CShellBrowser::GoSearch()
2614 {
2615 return E_NOTIMPL;
2616 }
2617
2618 HRESULT STDMETHODCALLTYPE CShellBrowser::Navigate(BSTR URL, VARIANT *Flags,
2619 VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
2620 {
2621 return E_NOTIMPL;
2622 }
2623
2624 HRESULT STDMETHODCALLTYPE CShellBrowser::Refresh()
2625 {
2626 VARIANT level;
2627
2628 V_VT(&level) = VT_I4;
2629 V_I4(&level) = 4;
2630 return Refresh2(&level);
2631 }
2632
2633 HRESULT STDMETHODCALLTYPE CShellBrowser::Refresh2(VARIANT *Level)
2634 {
2635 CComPtr<IOleCommandTarget> oleCommandTarget;
2636 HRESULT hResult;
2637
2638 hResult = fCurrentShellView->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &oleCommandTarget));
2639 if (FAILED_UNEXPECTEDLY(hResult))
2640 return hResult;
2641 return oleCommandTarget->Exec(NULL, 22, 1, Level, NULL);
2642 }
2643
2644 HRESULT STDMETHODCALLTYPE CShellBrowser::Stop()
2645 {
2646 return E_NOTIMPL;
2647 }
2648
2649 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Application(IDispatch **ppDisp)
2650 {
2651 return E_NOTIMPL;
2652 }
2653
2654 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Parent(IDispatch **ppDisp)
2655 {
2656 return E_NOTIMPL;
2657 }
2658
2659 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Container(IDispatch **ppDisp)
2660 {
2661 return E_NOTIMPL;
2662 }
2663
2664 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Document(IDispatch **ppDisp)
2665 {
2666 return E_NOTIMPL;
2667 }
2668
2669 HRESULT STDMETHODCALLTYPE CShellBrowser::get_TopLevelContainer(VARIANT_BOOL *pBool)
2670 {
2671 return E_NOTIMPL;
2672 }
2673
2674 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Type(BSTR *Type)
2675 {
2676 return E_NOTIMPL;
2677 }
2678 #ifdef __exdisp_h__
2679 #define long LONG
2680 #endif
2681 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Left(long *pl)
2682 {
2683 return E_NOTIMPL;
2684 }
2685
2686 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Left(long Left)
2687 {
2688 return E_NOTIMPL;
2689 }
2690
2691 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Top(long *pl)
2692 {
2693 return E_NOTIMPL;
2694 }
2695
2696 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Top(long Top)
2697 {
2698 return E_NOTIMPL;
2699 }
2700
2701 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Width(long *pl)
2702 {
2703 return E_NOTIMPL;
2704 }
2705
2706 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Width(long Width)
2707 {
2708 return E_NOTIMPL;
2709 }
2710
2711 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Height(long *pl)
2712 {
2713 return E_NOTIMPL;
2714 }
2715
2716 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Height(long Height)
2717 {
2718 return E_NOTIMPL;
2719 }
2720 #ifdef __exdisp_h__
2721 #undef long
2722 #endif
2723 HRESULT STDMETHODCALLTYPE CShellBrowser::get_LocationName(BSTR *LocationName)
2724 {
2725 return E_NOTIMPL;
2726 }
2727
2728 HRESULT STDMETHODCALLTYPE CShellBrowser::get_LocationURL(BSTR *LocationURL)
2729 {
2730 return E_NOTIMPL;
2731 }
2732
2733 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Busy(VARIANT_BOOL *pBool)
2734 {
2735 return E_NOTIMPL;
2736 }
2737
2738 HRESULT STDMETHODCALLTYPE CShellBrowser::Quit()
2739 {
2740 return E_NOTIMPL;
2741 }
2742
2743 HRESULT STDMETHODCALLTYPE CShellBrowser::ClientToWindow(int *pcx, int *pcy)
2744 {
2745 return E_NOTIMPL;
2746 }
2747
2748 HRESULT STDMETHODCALLTYPE CShellBrowser::PutProperty(BSTR Property, VARIANT vtValue)
2749 {
2750 return E_NOTIMPL;
2751 }
2752
2753 HRESULT STDMETHODCALLTYPE CShellBrowser::GetProperty(BSTR Property, VARIANT *pvtValue)
2754 {
2755 return E_NOTIMPL;
2756 }
2757
2758 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Name(BSTR *Name)
2759 {
2760 return E_NOTIMPL;
2761 }
2762
2763 HRESULT STDMETHODCALLTYPE CShellBrowser::get_HWND(SHANDLE_PTR *pHWND)
2764 {
2765 return E_NOTIMPL;
2766 }
2767
2768 HRESULT STDMETHODCALLTYPE CShellBrowser::get_FullName(BSTR *FullName)
2769 {
2770 return E_NOTIMPL;
2771 }
2772
2773 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Path(BSTR *Path)
2774 {
2775 return E_NOTIMPL;
2776 }
2777
2778 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Visible(VARIANT_BOOL *pBool)
2779 {
2780 return E_NOTIMPL;
2781 }
2782
2783 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Visible(VARIANT_BOOL Value)
2784 {
2785 return E_NOTIMPL;
2786 }
2787
2788 HRESULT STDMETHODCALLTYPE CShellBrowser::get_StatusBar(VARIANT_BOOL *pBool)
2789 {
2790 return E_NOTIMPL;
2791 }
2792
2793 HRESULT STDMETHODCALLTYPE CShellBrowser::put_StatusBar(VARIANT_BOOL Value)
2794 {
2795 return E_NOTIMPL;
2796 }
2797
2798 HRESULT STDMETHODCALLTYPE CShellBrowser::get_StatusText(BSTR *StatusText)
2799 {
2800 return E_NOTIMPL;
2801 }
2802
2803 HRESULT STDMETHODCALLTYPE CShellBrowser::put_StatusText(BSTR StatusText)
2804 {
2805 return E_NOTIMPL;
2806 }
2807
2808 HRESULT STDMETHODCALLTYPE CShellBrowser::get_ToolBar(int *Value)
2809 {
2810 return E_NOTIMPL;
2811 }
2812
2813 HRESULT STDMETHODCALLTYPE CShellBrowser::put_ToolBar(int Value)
2814 {
2815 return E_NOTIMPL;
2816 }
2817
2818 HRESULT STDMETHODCALLTYPE CShellBrowser::get_MenuBar(VARIANT_BOOL *Value)
2819 {
2820 return E_NOTIMPL;
2821 }
2822
2823 HRESULT STDMETHODCALLTYPE CShellBrowser::put_MenuBar(VARIANT_BOOL Value)
2824 {
2825 return E_NOTIMPL;
2826 }
2827
2828 HRESULT STDMETHODCALLTYPE CShellBrowser::get_FullScreen(VARIANT_BOOL *pbFullScreen)
2829 {
2830 return E_NOTIMPL;
2831 }
2832
2833 HRESULT STDMETHODCALLTYPE CShellBrowser::put_FullScreen(VARIANT_BOOL bFullScreen)
2834 {
2835 return E_NOTIMPL;
2836 }
2837
2838 HRESULT STDMETHODCALLTYPE CShellBrowser::Navigate2(VARIANT *URL, VARIANT *Flags,
2839 VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
2840 {
2841 LPITEMIDLIST pidl;
2842 HRESULT hResult;
2843
2844 // called from drive combo box to navigate to a directory
2845 if (V_VT(URL) != (VT_ARRAY | VT_UI1))
2846 return E_INVALIDARG;
2847 if (V_ARRAY(URL)->cDims != 1 || V_ARRAY(URL)->cbElements != 1)
2848 return E_INVALIDARG;
2849 pidl = (LPITEMIDLIST)V_ARRAY(URL)->pvData;
2850 hResult = BrowseToPIDL((LPITEMIDLIST)pidl, BTP_UPDATE_CUR_HISTORY | BTP_UPDATE_NEXT_HISTORY);
2851 if (FAILED_UNEXPECTEDLY(hResult))
2852 return hResult;
2853 return S_OK;
2854 }
2855
2856 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryStatusWB(OLECMDID cmdID, OLECMDF *pcmdf)
2857 {
2858 return E_NOTIMPL;
2859 }
2860
2861 HRESULT STDMETHODCALLTYPE CShellBrowser::ExecWB(OLECMDID cmdID, OLECMDEXECOPT cmdexecopt,
2862 VARIANT *pvaIn, VARIANT *pvaOut)
2863 {
2864 return E_NOTIMPL;
2865 }
2866
2867 HRESULT STDMETHODCALLTYPE CShellBrowser::ShowBrowserBar(VARIANT *pvaClsid, VARIANT *pvarShow, VARIANT *pvarSize)
2868 {
2869 CLSID classID;
2870 bool vertical;
2871
2872 // called to show search bar
2873 if (V_VT(pvaClsid) != VT_BSTR)
2874 return E_INVALIDARG;
2875 CLSIDFromString(V_BSTR(pvaClsid), &classID);
2876 // TODO: properly compute the value of vertical
2877 vertical = true;
2878 return ShowBand(classID, vertical);
2879 }
2880
2881 HRESULT STDMETHODCALLTYPE CShellBrowser::get_ReadyState(READYSTATE *plReadyState)
2882 {
2883 return E_NOTIMPL;
2884 }
2885
2886 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Offline(VARIANT_BOOL *pbOffline)
2887 {
2888 return E_NOTIMPL;
2889 }
2890
2891 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Offline(VARIANT_BOOL bOffline)
2892 {
2893 return E_NOTIMPL;
2894 }
2895
2896 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Silent(VARIANT_BOOL *pbSilent)
2897 {
2898 return E_NOTIMPL;
2899 }
2900
2901 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Silent(VARIANT_BOOL bSilent)
2902 {
2903 return E_NOTIMPL;
2904 }
2905
2906 HRESULT STDMETHODCALLTYPE CShellBrowser::get_RegisterAsBrowser(VARIANT_BOOL *pbRegister)
2907 {
2908 return E_NOTIMPL;
2909 }
2910
2911 HRESULT STDMETHODCALLTYPE CShellBrowser::put_RegisterAsBrowser(VARIANT_BOOL bRegister)
2912 {
2913 return E_NOTIMPL;
2914 }
2915
2916 HRESULT STDMETHODCALLTYPE CShellBrowser::get_RegisterAsDropTarget(VARIANT_BOOL *pbRegister)
2917 {
2918 return E_NOTIMPL;
2919 }
2920
2921 HRESULT STDMETHODCALLTYPE CShellBrowser::put_RegisterAsDropTarget(VARIANT_BOOL bRegister)
2922 {
2923 return E_NOTIMPL;
2924 }
2925
2926 HRESULT STDMETHODCALLTYPE CShellBrowser::get_TheaterMode(VARIANT_BOOL *pbRegister)
2927 {
2928 return E_NOTIMPL;
2929 }
2930
2931 HRESULT STDMETHODCALLTYPE CShellBrowser::put_TheaterMode(VARIANT_BOOL bRegister)
2932 {
2933 return E_NOTIMPL;
2934 }
2935
2936 HRESULT STDMETHODCALLTYPE CShellBrowser::get_AddressBar(VARIANT_BOOL *Value)
2937 {
2938 return E_NOTIMPL;
2939 }
2940
2941 HRESULT STDMETHODCALLTYPE CShellBrowser::put_AddressBar(VARIANT_BOOL Value)
2942 {
2943 return E_NOTIMPL;
2944 }
2945
2946 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Resizable(VARIANT_BOOL *Value)
2947 {
2948 return E_NOTIMPL;
2949 }
2950
2951 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Resizable(VARIANT_BOOL Value)
2952 {
2953 return E_NOTIMPL;
2954 }
2955
2956 HRESULT STDMETHODCALLTYPE CShellBrowser::FindWindowByIndex(DWORD dwID, IUnknown **ppunk)
2957 {
2958 return E_NOTIMPL;
2959 }
2960
2961 HRESULT STDMETHODCALLTYPE CShellBrowser::GetWindowData(IStream *pStream, LPWINDOWDATA pWinData)
2962 {
2963 if (pWinData == NULL)
2964 return E_POINTER;
2965
2966 pWinData->dwWindowID = -1;
2967 pWinData->uiCP = 0;
2968 pWinData->pidl = ILClone(fCurrentDirectoryPIDL);
2969 pWinData->lpszUrl = NULL;
2970 pWinData->lpszUrlLocation = NULL;
2971 pWinData->lpszTitle = NULL;
2972 return S_OK;
2973 }
2974
2975 HRESULT STDMETHODCALLTYPE CShellBrowser::LoadHistoryPosition(LPWSTR pszUrlLocation, DWORD dwPosition)
2976 {
2977 return E_NOTIMPL;
2978 }
2979
2980 HRESULT STDMETHODCALLTYPE CShellBrowser::GetClassID(CLSID *pClassID)
2981 {
2982 return E_NOTIMPL;
2983 }
2984
2985 HRESULT STDMETHODCALLTYPE CShellBrowser::LoadHistory(IStream *pStream, IBindCtx *pbc)
2986 {
2987 CComPtr<IPersistHistory> viewPersistHistory;
2988 CComPtr<IOleObject> viewHistoryObject;
2989 persistState oldState;
2990 ULONG numRead;
2991 LPITEMIDLIST pidl;
2992 HRESULT hResult;
2993
2994 hResult = pStream->Read(&oldState, sizeof(oldState), &numRead);
2995 if (FAILED_UNEXPECTEDLY(hResult))
2996 return hResult;
2997 if (numRead != sizeof(oldState) || oldState.dwSize != sizeof(oldState))
2998 return E_FAIL;
2999 if (oldState.browseType != 2)
3000 return E_FAIL;
3001 pidl = static_cast<LPITEMIDLIST>(CoTaskMemAlloc(oldState.pidlSize));
3002 if (pidl == NULL)
3003 return E_OUTOFMEMORY;
3004 hResult = pStream->Read(pidl, oldState.pidlSize, &numRead);
3005 if (FAILED_UNEXPECTEDLY(hResult))
3006 {
3007 ILFree(pidl);
3008 return hResult;
3009 }
3010 if (numRead != oldState.pidlSize)
3011 {
3012 ILFree(pidl);
3013 return E_FAIL;
3014 }
3015 hResult = CoCreateInstance(oldState.persistClass, NULL, CLSCTX_LOCAL_SERVER | CLSCTX_INPROC_SERVER,
3016 IID_PPV_ARG(IOleObject, &viewHistoryObject));
3017 fHistoryObject = viewHistoryObject;
3018 fHistoryStream = pStream;
3019 fHistoryBindContext = pbc;
3020 hResult = BrowseToPIDL(pidl, BTP_UPDATE_CUR_HISTORY);
3021 fHistoryObject = NULL;
3022 fHistoryStream = NULL;
3023 fHistoryBindContext = NULL;
3024 ILFree(pidl);
3025 if (FAILED_UNEXPECTEDLY(hResult))
3026 return hResult;
3027 return S_OK;
3028 }
3029
3030 HRESULT STDMETHODCALLTYPE CShellBrowser::SaveHistory(IStream *pStream)
3031 {
3032 CComPtr<IPersistHistory> viewPersistHistory;
3033 persistState newState;
3034 HRESULT hResult;
3035
3036 hResult = fCurrentShellView->GetItemObject(
3037 SVGIO_BACKGROUND, IID_PPV_ARG(IPersistHistory, &viewPersistHistory));
3038 memset(&newState, 0, sizeof(newState));
3039 newState.dwSize = sizeof(newState);
3040 newState.browseType = 2;
3041 newState.browserIndex = GetBrowserIndex();
3042 if (viewPersistHistory.p != NULL)
3043 {
3044 hResult = viewPersistHistory->GetClassID(&newState.persistClass);
3045 if (FAILED_UNEXPECTEDLY(hResult))
3046 return hResult;
3047 }
3048 newState.pidlSize = ILGetSize(fCurrentDirectoryPIDL);
3049 hResult = pStream->Write(&newState, sizeof(newState), NULL);
3050 if (FAILED_UNEXPECTEDLY(hResult))
3051 return hResult;
3052 hResult = pStream->Write(fCurrentDirectoryPIDL, newState.pidlSize, NULL);
3053 if (FAILED_UNEXPECTEDLY(hResult))
3054 return hResult;
3055 if (viewPersistHistory.p != NULL)
3056 {
3057 hResult = viewPersistHistory->SaveHistory(pStream);
3058 if (FAILED_UNEXPECTEDLY(hResult))
3059 return hResult;
3060 }
3061 return S_OK;
3062 }
3063
3064 HRESULT STDMETHODCALLTYPE CShellBrowser::SetPositionCookie(DWORD dwPositioncookie)
3065 {
3066 return E_NOTIMPL;
3067 }
3068
3069 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPositionCookie(DWORD *pdwPositioncookie)
3070 {
3071 return E_NOTIMPL;
3072 }
3073
3074 LRESULT CShellBrowser::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3075 {
3076 OnCreate(reinterpret_cast<LPCREATESTRUCT> (lParam));
3077 return 0;
3078 }
3079
3080 LRESULT CShellBrowser::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3081 {
3082 HRESULT hr;
3083 // TODO: rip down everything
3084 {
3085 fCurrentShellView->DestroyViewWindow();
3086 fCurrentShellView->UIActivate(SVUIA_DEACTIVATE);
3087 ReleaseCComPtrExpectZero(fCurrentShellView);
3088
3089 for (int i = 0; i < 3; i++)
3090 {
3091 if (fClientBars[i].clientBar == NULL)
3092 continue;
3093 IDockingWindow * pdw;
3094 hr = fClientBars[i].clientBar->QueryInterface(IID_PPV_ARG(IDockingWindow, &pdw));
3095 if (FAILED_UNEXPECTEDLY(hr))
3096 continue;
3097 pdw->ShowDW(FALSE);
3098 pdw->CloseDW(0);
3099 pdw->Release();
3100 ReleaseCComPtrExpectZero(fClientBars[i].clientBar);
3101 }
3102 ReleaseCComPtrExpectZero(fTravelLog);
3103
3104 fCurrentShellFolder.Release();
3105 ILFree(fCurrentDirectoryPIDL);
3106 ::DestroyWindow(fStatusBar);
3107 DestroyMenu(fCurrentMenuBar);
3108 }
3109 PostQuitMessage(0);
3110 return 0;
3111 }
3112
3113 LRESULT CShellBrowser::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3114 {
3115 CComPtr<IDockingWindow> dockingWindow;
3116 RECT availableBounds;
3117 static const INT excludeItems[] = {1, 1, 1, 0xa001, 0, 0};
3118 HRESULT hResult;
3119
3120 if (wParam != SIZE_MINIMIZED)
3121 {
3122 GetEffectiveClientRect(m_hWnd, &availableBounds, excludeItems);
3123 for (INT x = 0; x < 3; x++)
3124 {
3125 if (fClientBars[x].clientBar != NULL)
3126 {
3127 hResult = fClientBars[x].clientBar->QueryInterface(
3128 IID_PPV_ARG(IDockingWindow, &dockingWindow));
3129 if (SUCCEEDED(hResult) && dockingWindow != NULL)
3130 {
3131 hResult = dockingWindow->ResizeBorderDW(
3132 &availableBounds, static_cast<IDropTarget *>(this), TRUE);
3133 break;
3134 }
3135 }
3136 }
3137 RepositionBars();
3138 }
3139 return 1;
3140 }
3141
3142 LRESULT CShellBrowser::OnInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3143 {
3144 HMENU theMenu;
3145 LPARAM menuIndex = lParam;
3146
3147 theMenu = reinterpret_cast<HMENU>(wParam);
3148
3149 if (theMenu == SHGetMenuFromID(fCurrentMenuBar, FCIDM_MENU_FILE))
3150 {
3151 menuIndex = 0;
3152 }
3153 else if (theMenu == SHGetMenuFromID(fCurrentMenuBar, FCIDM_MENU_EDIT))
3154 {
3155 menuIndex = 1;
3156 }
3157 else if (theMenu == SHGetMenuFromID(fCurrentMenuBar, FCIDM_MENU_VIEW))
3158 {
3159 UpdateViewMenu(theMenu);
3160 menuIndex = 2;
3161 }
3162 else if (theMenu == SHGetMenuFromID(fCurrentMenuBar, FCIDM_MENU_FAVORITES))
3163 {
3164 menuIndex = 3;
3165 }
3166 else if (theMenu == SHGetMenuFromID(fCurrentMenuBar, FCIDM_MENU_TOOLS))
3167 {
3168 menuIndex = 4;
3169 }
3170 else if (theMenu == SHGetMenuFromID(fCurrentMenuBar, FCIDM_MENU_HELP))
3171 {
3172 menuIndex = 5;
3173 }
3174
3175 LRESULT ret = RelayMsgToShellView(uMsg, wParam, menuIndex, bHandled);
3176
3177 return ret;
3178 }
3179
3180 LRESULT CShellBrowser::RelayMsgToShellView(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3181 {
3182 if (fCurrentShellViewWindow != NULL)
3183 return SendMessage(fCurrentShellViewWindow, uMsg, wParam, lParam);
3184 return 0;
3185 }
3186
3187 LRESULT CShellBrowser::OnClose(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3188 {
3189 return 0;
3190 }
3191
3192 LRESULT CShellBrowser::OnFolderOptions(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3193 {
3194 HRESULT hResult;
3195
3196 hResult = DoFolderOptions();
3197 return 0;
3198 }
3199
3200 LRESULT CShellBrowser::OnMapNetworkDrive(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3201 {
3202 #ifndef __REACTOS__
3203 WNetConnectionDialog(m_hWnd, RESOURCETYPE_DISK);
3204 #endif /* __REACTOS__ */
3205 return 0;
3206 }
3207
3208 LRESULT CShellBrowser::OnDisconnectNetworkDrive(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3209 {
3210 #ifndef __REACTOS__
3211 WNetDisconnectDialog(m_hWnd, RESOURCETYPE_DISK);
3212 #endif /* __REACTOS__ */
3213 return 0;
3214 }
3215
3216 LRESULT CShellBrowser::OnAboutReactOS(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3217 {
3218 ShellAbout(m_hWnd, _T("ReactOS"), _T(""), NULL);
3219 return 0;
3220 }
3221
3222 LRESULT CShellBrowser::OnGoBack(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3223 {
3224 HRESULT hResult;
3225
3226 hResult = GoBack();
3227 return 0;
3228 }
3229
3230 LRESULT CShellBrowser::OnGoForward(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3231 {
3232 HRESULT hResult;
3233
3234 hResult = GoForward();
3235 return 0;
3236 }
3237
3238 LRESULT CShellBrowser::OnGoUpLevel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3239 {
3240 HRESULT hResult;
3241
3242 hResult = NavigateToParent();
3243 return 0;
3244 }
3245
3246 LRESULT CShellBrowser::OnGoHome(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3247 {
3248 HRESULT hResult;
3249
3250 hResult = GoHome();
3251 return 0;
3252 }
3253
3254 LRESULT CShellBrowser::OnBackspace(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3255 {
3256 HRESULT hResult;
3257
3258 // FIXME: This does not appear to be what windows does.
3259 hResult = NavigateToParent();
3260 return 0;
3261 }
3262
3263 LRESULT CShellBrowser::OnIsThisLegal(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3264 {
3265 HRESULT hResult;
3266
3267 typedef HRESULT (WINAPI *PSHOpenNewFrame)(LPITEMIDLIST pidl, IUnknown *b, long c, long d);
3268 PSHOpenNewFrame Func = NULL;
3269 HMODULE Module = GetModuleHandle(TEXT("browseui.dll"));
3270 if (Module != NULL)
3271 Func = reinterpret_cast<PSHOpenNewFrame>(GetProcAddress(Module, (LPCSTR) 103));
3272 if (Func != NULL)
3273 {
3274 LPITEMIDLIST desktopPIDL;
3275
3276 hResult = SHGetFolderLocation(NULL, CSIDL_DESKTOP, NULL, 0, &desktopPIDL);
3277 if (SUCCEEDED(hResult))
3278 {
3279 hResult = Func(desktopPIDL, NULL, -1, 1);
3280 }
3281 }
3282 return 0;
3283 }
3284
3285 LRESULT CShellBrowser::OnToggleStatusBarVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3286 {
3287 fStatusBarVisible = !fStatusBarVisible;
3288 // TODO: trigger a relayout of contained items
3289 return 0;
3290 }
3291
3292 LRESULT CShellBrowser::OnToggleToolbarLock(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3293 {
3294 CComPtr<IOleCommandTarget> commandTarget;
3295 HRESULT hResult;
3296
3297 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3298 IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3299 if (FAILED_UNEXPECTEDLY(hResult))
3300 return 0;
3301 hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_TOOLBARLOCKED, 0, NULL, NULL);
3302 return 0;
3303 }
3304
3305 LRESULT CShellBrowser::OnToggleToolbarBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3306 {
3307 CComPtr<IOleCommandTarget> commandTarget;
3308 HRESULT hResult;
3309
3310 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3311 IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3312 if (FAILED_UNEXPECTEDLY(hResult))
3313 return 0;
3314 hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_TOOLBARBANDSHOWN, 0, NULL, NULL);
3315 return 0;
3316 }
3317
3318 LRESULT CShellBrowser::OnToggleAddressBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3319 {
3320 CComPtr<IOleCommandTarget> commandTarget;
3321 HRESULT hResult;
3322
3323 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3324 IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3325 if (FAILED_UNEXPECTEDLY(hResult))
3326 return 0;
3327 hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_ADDRESSBANDSHOWN, 0, NULL, NULL);
3328 return 0;
3329 }
3330
3331 LRESULT CShellBrowser::OnToggleLinksBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3332 {
3333 CComPtr<IOleCommandTarget> commandTarget;
3334 HRESULT hResult;
3335
3336 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3337 IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3338 if (FAILED_UNEXPECTEDLY(hResult))
3339 return 0;
3340 hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_LINKSBANDSHOWN, 0, NULL, NULL);
3341 return 0;
3342 }
3343
3344 LRESULT CShellBrowser::OnToggleTextLabels(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3345 {
3346 CComPtr<IOleCommandTarget> commandTarget;
3347 HRESULT hResult;
3348
3349 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3350 IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3351 if (FAILED_UNEXPECTEDLY(hResult))
3352 return 0;
3353 hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_TEXTLABELS, 0, NULL, NULL);
3354 return 0;
3355 }
3356
3357 LRESULT CShellBrowser::OnToolbarCustomize(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3358 {
3359 CComPtr<IOleCommandTarget> commandTarget;
3360 HRESULT hResult;
3361
3362 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3363 IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3364 if (FAILED_UNEXPECTEDLY(hResult))
3365 return 0;
3366 hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_CUSTOMIZEENABLED, 0, NULL, NULL);
3367 return 0;
3368 }
3369
3370 LRESULT CShellBrowser::OnGoTravel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3371 {
3372 return 0;
3373 }
3374
3375 LRESULT CShellBrowser::RelayCommands(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3376 {
3377 if (HIWORD(wParam) == 0 && LOWORD(wParam) < FCIDM_SHVIEWLAST && fCurrentShellViewWindow != NULL)
3378 return SendMessage(fCurrentShellViewWindow, uMsg, wParam, lParam);
3379 return 0;
3380 }
3381
3382 static HRESULT ExplorerMessageLoop(IEThreadParamBlock * parameters)
3383 {
3384 CComPtr<CShellBrowser> theCabinet;
3385 HRESULT hResult;
3386 MSG Msg;
3387 BOOL Ret;
3388
3389 // Tell the thread ref we are using it.
3390 if (parameters && parameters->offsetF8)
3391 parameters->offsetF8->AddRef();
3392
3393 ATLTRY(theCabinet = new CComObject<CShellBrowser>);
3394 if (theCabinet == NULL)
3395 {
3396 return E_OUTOFMEMORY;
3397 }
3398
3399 hResult = theCabinet->Initialize(parameters->directoryPIDL, 0, 0, 0);
3400 if (FAILED_UNEXPECTEDLY(hResult))
3401 return E_OUTOFMEMORY;
3402
3403 while ((Ret = GetMessage(&Msg, NULL, 0, 0)) != 0)
3404 {
3405 if (Ret == -1)
3406 {
3407 // Error: continue or exit?
3408 break;
3409 }
3410
3411 if (Msg.message == WM_QUIT)
3412 break;
3413
3414 if (theCabinet->v_MayTranslateAccelerator(&Msg) != S_OK)
3415 {
3416 TranslateMessage(&Msg);
3417 DispatchMessage(&Msg);
3418 }
3419 }
3420
3421 int nrc = theCabinet->Release();
3422 if (nrc > 0)
3423 {
3424 DbgPrint("WARNING: There are %d references to the CShellBrowser active or leaked.\n", nrc);
3425 }
3426
3427 theCabinet.Detach();
3428
3429 // Tell the thread ref we are not using it anymore.
3430 if (parameters && parameters->offsetF8)
3431 parameters->offsetF8->Release();
3432
3433 return hResult;
3434 }
3435
3436 DWORD WINAPI BrowserThreadProc(LPVOID lpThreadParameter)
3437 {
3438 HRESULT hr;
3439 IEThreadParamBlock * parameters = (IEThreadParamBlock *) lpThreadParameter;
3440
3441 OleInitialize(NULL);
3442
3443 ATLTRY(hr = ExplorerMessageLoop(parameters));
3444
3445 OleUninitialize();
3446
3447 SHDestroyIETHREADPARAM(parameters);
3448
3449 return hr;
3450 }
A free Windows-compatible Operating System