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