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