projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[BROWSEUI]
[reactos.git] / dll / win32 / browseui / shellbrowser.cpp
1 /*
2 * ReactOS Explorer
3 *
4 * Copyright 2009 Andrew Hill <ash77 at domain reactos.org>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "precomp.h"
22
23 #include <shellapi.h>
24 #include <htiframe.h>
25
26 #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_PPV_ARG(IShellFolder, 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_PPV_ARG(IExplorerToolbar, &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_PPV_ARG(IUnknown, &fClientBars[BIInternetToolbar].clientBar));
747 if (FAILED(hResult))
748 return hResult;
749 #else
750 hResult = CreateInternetToolbar(IID_PPV_ARG(IUnknown, &fClientBars[BIInternetToolbar].clientBar));
751 if (FAILED(hResult))
752 return hResult;
753 #endif
754
755 // create interfaces
756 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
757 IID_PPV_ARG(IDockingWindow, &dockingWindow));
758 if (FAILED(hResult))
759 return hResult;
760 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
761 IID_PPV_ARG(IPersistStreamInit, &persistStreamInit));
762 if (FAILED(hResult))
763 return hResult;
764 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
765 IID_PPV_ARG(IOleCommandTarget, &commandTarget));
766 if (FAILED(hResult))
767 return hResult;
768 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
769 IID_PPV_ARG(IObjectWithSite, &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_PPV_ARG(IShellFolder, &parentFolder), &childPIDL);
907 hResult = parentFolder->GetDisplayNameOf(childPIDL, uFlags, &L108);
908 StrRetToBufW(&L108, childPIDL, pszBuf, cchBuf);
909 if (rgfInOut)
910 hResult = parentFolder->GetAttributesOf(1, const_cast<LPCITEMIDLIST *>(&childPIDL), rgfInOut);
911 ILFree(childPIDL);
912 return S_OK;
913 }
914
915 long IEGetNameAndFlags(LPITEMIDLIST pidl, SHGDNF uFlags, LPWSTR pszBuf, UINT cchBuf, SFGAOF *rgfInOut)
916 {
917 return IEGetNameAndFlagsEx(pidl, uFlags, 0, pszBuf, cchBuf, rgfInOut);
918 }
919
920 HRESULT CShellBrowser::BrowseToPath(IShellFolder *newShellFolder,
921 LPCITEMIDLIST absolutePIDL, FOLDERSETTINGS *folderSettings, long flags)
922 {
923 CComPtr<IOleCommandTarget> oleCommandTarget;
924 CComPtr<IObjectWithSite> objectWithSite;
925 CComPtr<IShellFolder> saveCurrentShellFolder;
926 CComPtr<IShellView> saveCurrentShellView;
927 CComPtr<IShellView> newShellView;
928 CComPtr<ITravelLog> travelLog;
929 HWND newShellViewWindow;
930 BOOL windowUpdateIsLocked;
931 RECT shellViewWindowBounds;
932 HWND previousView;
933 HCURSOR saveCursor;
934 wchar_t newTitle[MAX_PATH];
935 SHGDNF nameFlags;
936 HRESULT hResult;
937
938 if (newShellFolder == NULL)
939 return E_INVALIDARG;
940
941 hResult = GetTravelLog(&travelLog);
942 if (FAILED(hResult))
943 return hResult;
944
945 // update history
946 if (flags & BTP_UPDATE_CUR_HISTORY)
947 {
948 if (travelLog->CountEntries(static_cast<IDropTarget *>(this)) > 0)
949 hResult = travelLog->UpdateEntry(static_cast<IDropTarget *>(this), FALSE);
950 // what to do with error? Do we want to halt browse because state save failed?
951 }
952
953 // create view object
954 hResult = newShellFolder->CreateViewObject(m_hWnd, IID_PPV_ARG(IShellView, &newShellView));
955 if (FAILED(hResult))
956 return hResult;
957 previousView = fCurrentShellViewWindow;
958
959 // enter updating section
960 saveCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
961 windowUpdateIsLocked = LockWindowUpdate(TRUE);
962 if (fCurrentShellView != NULL)
963 ::SendMessage(fCurrentShellViewWindow, WM_SETREDRAW, 0, 0);
964
965 // set site
966 hResult = newShellView->QueryInterface(IID_PPV_ARG(IObjectWithSite, &objectWithSite));
967 if (SUCCEEDED(hResult) && objectWithSite.p != NULL)
968 hResult = objectWithSite->SetSite(static_cast<IDropTarget *>(this));
969
970 // update folder and view
971 saveCurrentShellFolder = fCurrentShellFolder;
972 saveCurrentShellView = fCurrentShellView;
973 fCurrentShellFolder = newShellFolder;
974 fCurrentShellView = newShellView;
975
976 // get boundary
977 if (previousView != NULL)
978 ::GetWindowRect(previousView, &shellViewWindowBounds);
979 else
980 ZeroMemory(&shellViewWindowBounds, sizeof(shellViewWindowBounds));
981 ::MapWindowPoints(0, m_hWnd, reinterpret_cast<POINT *>(&shellViewWindowBounds), 2);
982
983 // create view window
984 hResult = newShellView->CreateViewWindow(saveCurrentShellView, folderSettings,
985 this, &shellViewWindowBounds, &newShellViewWindow);
986 if (FAILED(hResult) || newShellViewWindow == NULL)
987 {
988 fCurrentShellView = saveCurrentShellView;
989 fCurrentShellFolder = saveCurrentShellFolder;
990 ::SendMessage(fCurrentShellViewWindow, WM_SETREDRAW, 1, 0);
991 if (windowUpdateIsLocked)
992 LockWindowUpdate(FALSE);
993 SetCursor(saveCursor);
994 return hResult;
995 }
996
997 if (objectWithSite.p != NULL)
998 hResult = objectWithSite->SetSite(NULL);
999
1000 // update current pidl
1001 ILFree(fCurrentDirectoryPIDL);
1002 fCurrentDirectoryPIDL = ILClone(absolutePIDL);
1003
1004 // update view window
1005 if (saveCurrentShellView != NULL)
1006 saveCurrentShellView->DestroyViewWindow();
1007 fCurrentShellViewWindow = newShellViewWindow;
1008
1009 // get command target
1010 oleCommandTarget.Release();
1011 hResult = newShellView->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &oleCommandTarget));
1012
1013 // no use
1014 saveCurrentShellView.Release();
1015 saveCurrentShellFolder.Release();
1016
1017 hResult = newShellView->UIActivate(SVUIA_ACTIVATE_FOCUS);
1018
1019 // leave updating section
1020 if (windowUpdateIsLocked)
1021 LockWindowUpdate(FALSE);
1022 SetCursor(saveCursor);
1023
1024 // update history
1025 if (flags & BTP_UPDATE_NEXT_HISTORY)
1026 {
1027 hResult = travelLog->AddEntry(static_cast<IDropTarget *>(this), FALSE);
1028 hResult = travelLog->UpdateEntry(static_cast<IDropTarget *>(this), FALSE);
1029 }
1030
1031 // completed
1032 FireNavigateComplete(L"c:\\temp"); // TODO: use real path here
1033 if (fCabinetState.fFullPathTitle)
1034 nameFlags = SHGDN_FORADDRESSBAR | SHGDN_FORPARSING;
1035 else
1036 nameFlags = SHGDN_FORADDRESSBAR;
1037 hResult = IEGetNameAndFlags(fCurrentDirectoryPIDL, nameFlags, newTitle,
1038 sizeof(newTitle) / sizeof(wchar_t), NULL);
1039 if (SUCCEEDED(hResult))
1040 SetWindowText(newTitle);
1041
1042 // TODO: Update the window icon
1043
1044 FireCommandStateChangeAll();
1045 hResult = UpdateForwardBackState();
1046 return S_OK;
1047 }
1048
1049 HRESULT CShellBrowser::GetMenuBand(REFIID riid, void **shellMenu)
1050 {
1051 CComPtr<IServiceProvider> serviceProvider;
1052 CComPtr<IBandSite> bandSite;
1053 CComPtr<IDeskBand> deskBand;
1054 HRESULT hResult;
1055
1056 if (fClientBars[BIInternetToolbar].clientBar.p == NULL)
1057 return E_FAIL;
1058 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
1059 IID_PPV_ARG(IServiceProvider, &serviceProvider));
1060 if (FAILED(hResult))
1061 return hResult;
1062 hResult = serviceProvider->QueryService(SID_IBandSite, IID_PPV_ARG(IBandSite, &bandSite));
1063 if (FAILED(hResult))
1064 return hResult;
1065 hResult = bandSite->QueryBand(1, &deskBand, NULL, NULL, 0);
1066 if (FAILED(hResult))
1067 return hResult;
1068 return deskBand->QueryInterface(riid, shellMenu);
1069 }
1070
1071 HRESULT CShellBrowser::GetBaseBar(bool vertical, IUnknown **theBaseBar)
1072 {
1073 CComPtr<IUnknown> newBaseBar;
1074 CComPtr<IDeskBar> deskBar;
1075 CComPtr<IUnknown> newBaseBarSite;
1076 CComPtr<IObjectWithSite> objectWithSite;
1077 CComPtr<IDeskBarClient> deskBarClient;
1078 IUnknown **cache;
1079 HRESULT hResult;
1080
1081 if (vertical)
1082 cache = &fClientBars[BIVerticalBaseBar].clientBar.p;
1083 else
1084 cache = &fClientBars[BIHorizontalBaseBar].clientBar.p;
1085 if (*cache == NULL)
1086 {
1087 hResult = CreateBaseBar(IID_PPV_ARG(IUnknown, &newBaseBar));
1088 if (FAILED(hResult))
1089 return hResult;
1090 hResult = CreateBaseBarSite(IID_PPV_ARG(IUnknown, &newBaseBarSite));
1091 if (FAILED(hResult))
1092 return hResult;
1093
1094 // tell the new base bar about the shell browser
1095 hResult = newBaseBar->QueryInterface(IID_PPV_ARG(IObjectWithSite, &objectWithSite));
1096 if (FAILED(hResult))
1097 return hResult;
1098 hResult = objectWithSite->SetSite(static_cast<IDropTarget *>(this));
1099 if (FAILED(hResult))
1100 return hResult;
1101
1102 // tell the new base bar about the new base bar site
1103 hResult = newBaseBar->QueryInterface(IID_PPV_ARG(IDeskBar, &deskBar));
1104 if (FAILED(hResult))
1105 return hResult;
1106 hResult = deskBar->SetClient(newBaseBarSite);
1107 if (FAILED(hResult))
1108 return hResult;
1109
1110 // tell the new base bar site about the new base bar
1111 hResult = newBaseBarSite->QueryInterface(IID_PPV_ARG(IDeskBarClient, &deskBarClient));
1112 if (FAILED(hResult))
1113 return hResult;
1114 hResult = deskBarClient->SetDeskBarSite(newBaseBar);
1115 if (FAILED(hResult))
1116 return hResult;
1117
1118 *cache = newBaseBar.Detach();
1119 }
1120 return (*cache)->QueryInterface(IID_PPV_ARG(IUnknown, theBaseBar));
1121 }
1122
1123 HRESULT CShellBrowser::ShowBand(const CLSID &classID, bool vertical)
1124 {
1125 CComPtr<IDockingWindow> dockingWindow;
1126 CComPtr<IOleCommandTarget> oleCommandTarget;
1127 CComPtr<IUnknown> baseBarSite;
1128 CComPtr<IUnknown> newBand;
1129 CComPtr<IUnknown> theBaseBar;
1130 CComPtr<IDeskBar> deskBar;
1131 VARIANT vaIn;
1132 HRESULT hResult;
1133
1134 __debugbreak();
1135
1136 hResult = GetBaseBar(vertical, (IUnknown **)&theBaseBar);
1137 if (FAILED(hResult))
1138 return hResult;
1139 hResult = CoCreateInstance(classID, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IUnknown, &newBand));
1140 if (FAILED(hResult))
1141 return hResult;
1142 hResult = theBaseBar->QueryInterface(IID_PPV_ARG(IDeskBar, &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_PPV_ARG(IDockingWindow, &dockingWindow));
1149 if (FAILED(hResult))
1150 return hResult;
1151 hResult = baseBarSite->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &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_PPV_ARG(IShellPropSheetExt, &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_PPV_ARG(IObjectWithSite, &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_PPV_ARG(IGlobalFolderSettings, &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_PPV_ARG(IMenuBand, &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
1309 GetClientRect(&clientRect);
1310
1311 if (fStatusBarVisible && fStatusBar)
1312 {
1313 ::GetWindowRect(fStatusBar, &statusRect);
1314 ::SetWindowPos(fStatusBar, NULL, clientRect.left, clientRect.bottom - (statusRect.bottom - statusRect.top),
1315 clientRect.right - clientRect.left,
1316 statusRect.bottom - statusRect.top, SWP_NOOWNERZORDER | SWP_NOZORDER);
1317 clientRect.bottom -= statusRect.bottom - statusRect.top;
1318 }
1319
1320 for (x = 0; x < 3; x++)
1321 {
1322 if (fClientBars[x].hwnd == NULL && fClientBars[x].clientBar != NULL)
1323 {
1324 IUnknown_GetWindow(fClientBars[x].clientBar, &fClientBars[x].hwnd);
1325 }
1326 if (fClientBars[x].hwnd != NULL)
1327 {
1328 toolbarRect = clientRect;
1329 if (fClientBars[x].borderSpace.top != 0)
1330 toolbarRect.bottom = toolbarRect.top + fClientBars[x].borderSpace.top;
1331 else if (fClientBars[x].borderSpace.bottom != 0)
1332 toolbarRect.top = toolbarRect.bottom - fClientBars[x].borderSpace.bottom;
1333 if (fClientBars[x].borderSpace.left != 0)
1334 toolbarRect.right = toolbarRect.left + fClientBars[x].borderSpace.left;
1335 else if (fClientBars[x].borderSpace.right != 0)
1336 toolbarRect.left = toolbarRect.right - fClientBars[x].borderSpace.right;
1337 ::SetWindowPos(fClientBars[x].hwnd, NULL, toolbarRect.left, toolbarRect.top,
1338 toolbarRect.right - toolbarRect.left,
1339 toolbarRect.bottom - toolbarRect.top, SWP_NOOWNERZORDER | SWP_NOZORDER);
1340 clientRect.top += fClientBars[x].borderSpace.top;
1341 clientRect.left += fClientBars[x].borderSpace.left;
1342 clientRect.bottom += fClientBars[x].borderSpace.bottom;
1343 clientRect.right += fClientBars[x].borderSpace.right;
1344 }
1345 }
1346 ::SetWindowPos(fCurrentShellViewWindow, NULL, clientRect.left, clientRect.top,
1347 clientRect.right - clientRect.left,
1348 clientRect.bottom - clientRect.top, SWP_NOOWNERZORDER | SWP_NOZORDER);
1349 }
1350
1351 HRESULT CShellBrowser::FireEvent(DISPID dispIdMember, int argCount, VARIANT *arguments)
1352 {
1353 DISPPARAMS params;
1354 CComDynamicUnkArray &vec = IConnectionPointImpl<CShellBrowser, &DIID_DWebBrowserEvents2>::m_vec;
1355 CComDynamicUnkArray &vec2 = IConnectionPointImpl<CShellBrowser, &DIID_DWebBrowserEvents>::m_vec;
1356 HRESULT hResult;
1357
1358 params.rgvarg = arguments;
1359 params.rgdispidNamedArgs = NULL;
1360 params.cArgs = argCount;
1361 params.cNamedArgs = 0;
1362 IUnknown** pp = vec.begin();
1363 while (pp < vec.end())
1364 {
1365 if (*pp != NULL)
1366 {
1367 CComPtr<IDispatch> theDispatch;
1368
1369 hResult = (*pp)->QueryInterface(IID_PPV_ARG(IDispatch, &theDispatch));
1370 hResult = theDispatch->Invoke(dispIdMember, GUID_NULL, 0, DISPATCH_METHOD, &params, NULL, NULL, NULL);
1371 }
1372 pp++;
1373 }
1374 pp = vec2.begin();
1375 while (pp < vec2.end())
1376 {
1377 if (*pp != NULL)
1378 {
1379 CComPtr<IDispatch> theDispatch;
1380
1381 hResult = (*pp)->QueryInterface(IID_PPV_ARG(IDispatch, &theDispatch));
1382 hResult = theDispatch->Invoke(dispIdMember, GUID_NULL, 0, DISPATCH_METHOD, &params, NULL, NULL, NULL);
1383 }
1384 pp++;
1385 }
1386 return S_OK;
1387 }
1388
1389 HRESULT CShellBrowser::FireNavigateComplete(const wchar_t *newDirectory)
1390 {
1391 // these two variants intentionally to do use CComVariant because it would double free/release
1392 // or does not need to dispose at all
1393 VARIANT varArg[2];
1394 VARIANT varArgs;
1395 CComBSTR tempString(newDirectory);
1396
1397 V_VT(&varArgs) = VT_BSTR;
1398 V_BSTR(&varArgs) = tempString.m_str;
1399
1400 V_VT(&varArg[0]) = VT_VARIANT | VT_BYREF;
1401 V_VARIANTREF(&varArg[0]) = &varArgs;
1402 V_VT(&varArg[1]) = VT_DISPATCH;
1403 V_DISPATCH(&varArg[1]) = (IDispatch *)this;
1404
1405 return FireEvent(DISPID_NAVIGATECOMPLETE2, 2, varArg);
1406 }
1407
1408 HRESULT CShellBrowser::FireCommandStateChange(bool newState, int commandID)
1409 {
1410 VARIANT varArg[2];
1411
1412 V_VT(&varArg[0]) = VT_BOOL;
1413 V_BOOL(&varArg[0]) = newState ? VARIANT_TRUE : VARIANT_FALSE;
1414 V_VT(&varArg[1]) = VT_I4;
1415 V_I4(&varArg[1]) = commandID;
1416
1417 return FireEvent(DISPID_COMMANDSTATECHANGE, 2, varArg);
1418 }
1419
1420 HRESULT CShellBrowser::FireCommandStateChangeAll()
1421 {
1422 return FireCommandStateChange(false, -1);
1423 }
1424
1425 HRESULT CShellBrowser::UpdateForwardBackState()
1426 {
1427 CComPtr<ITravelLog> travelLog;
1428 CComPtr<ITravelEntry> unusedEntry;
1429 bool canGoBack;
1430 bool canGoForward;
1431 HRESULT hResult;
1432
1433 canGoBack = false;
1434 canGoForward = false;
1435 hResult = GetTravelLog(&travelLog);
1436 if (FAILED(hResult))
1437 return hResult;
1438 hResult = travelLog->GetTravelEntry(static_cast<IDropTarget *>(this), TLOG_BACK, &unusedEntry);
1439 if (SUCCEEDED(hResult))
1440 {
1441 canGoBack = true;
1442 unusedEntry.Release();
1443 }
1444 hResult = travelLog->GetTravelEntry(static_cast<IDropTarget *>(this), TLOG_FORE, &unusedEntry);
1445 if (SUCCEEDED(hResult))
1446 {
1447 canGoForward = true;
1448 unusedEntry.Release();
1449 }
1450 hResult = FireCommandStateChange(canGoBack, 2);
1451 hResult = FireCommandStateChange(canGoForward, 1);
1452 return S_OK;
1453 }
1454
1455 void CShellBrowser::UpdateGotoMenu(HMENU theMenu)
1456 {
1457 CComPtr<ITravelLog> travelLog;
1458 int position;
1459 MENUITEMINFO menuItemInfo;
1460 HRESULT hResult;
1461
1462 DeleteMenuItems(theMenu, IDM_GOTO_TRAVEL_FIRST, IDM_GOTO_TRAVEL_LAST);
1463
1464 position = GetMenuItemCount(theMenu);
1465 hResult = GetTravelLog(&travelLog);
1466 if (FAILED(hResult))
1467 return;
1468 hResult = travelLog->InsertMenuEntries(static_cast<IDropTarget *>(this), theMenu, position,
1469 IDM_GOTO_TRAVEL_FIRSTTARGET, IDM_GOTO_TRAVEL_LASTTARGET, TLMENUF_BACKANDFORTH | TLMENUF_CHECKCURRENT);
1470 if (SUCCEEDED(hResult))
1471 {
1472 menuItemInfo.cbSize = sizeof(menuItemInfo);
1473 menuItemInfo.fMask = MIIM_TYPE | MIIM_ID;
1474 menuItemInfo.fType = MF_SEPARATOR;
1475 menuItemInfo.wID = IDM_GOTO_TRAVEL_SEP;
1476 InsertMenuItem(theMenu, position, TRUE, &menuItemInfo);
1477 }
1478 }
1479
1480 void CShellBrowser::UpdateViewMenu(HMENU theMenu)
1481 {
1482 CComPtr<IOleCommandTarget> oleCommandTarget;
1483 CComPtr<ITravelLog> travelLog;
1484 HMENU gotoMenu;
1485 OLECMD commandList[5];
1486 HMENU toolbarMenuBar;
1487 HMENU toolbarMenu;
1488 MENUITEMINFO menuItemInfo;
1489 HRESULT hResult;
1490
1491 gotoMenu = SHGetMenuFromID(theMenu, FCIDM_MENU_EXPLORE);
1492 if (gotoMenu != NULL)
1493 UpdateGotoMenu(gotoMenu);
1494
1495 commandList[0].cmdID = ITID_TOOLBARBANDSHOWN;
1496 commandList[1].cmdID = ITID_ADDRESSBANDSHOWN;
1497 commandList[2].cmdID = ITID_LINKSBANDSHOWN;
1498 commandList[3].cmdID = ITID_TOOLBARLOCKED;
1499 commandList[4].cmdID = ITID_CUSTOMIZEENABLED;
1500
1501 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
1502 IID_PPV_ARG(IOleCommandTarget, &oleCommandTarget));
1503 if (SUCCEEDED(hResult))
1504 hResult = oleCommandTarget->QueryStatus(&CGID_PrivCITCommands, 5, commandList, NULL);
1505 if (FAILED(hResult))
1506 DeleteMenu(theMenu, IDM_VIEW_TOOLBARS, MF_BYCOMMAND);
1507 else
1508 {
1509 toolbarMenuBar = LoadMenu(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(IDM_CABINET_CONTEXTMENU));
1510 toolbarMenu = GetSubMenu(toolbarMenuBar, 0);
1511
1512 SHCheckMenuItem(toolbarMenu, IDM_TOOLBARS_STANDARDBUTTONS, commandList[0].cmdf);
1513 SHCheckMenuItem(toolbarMenu, IDM_TOOLBARS_ADDRESSBAR, commandList[1].cmdf & OLECMDF_ENABLED);
1514 SHCheckMenuItem(toolbarMenu, IDM_TOOLBARS_LINKSBAR, commandList[2].cmdf & OLECMDF_ENABLED);
1515 SHCheckMenuItem(toolbarMenu, IDM_TOOLBARS_LOCKTOOLBARS, commandList[3].cmdf & OLECMDF_ENABLED);
1516 if ((commandList[4].cmdf & OLECMDF_ENABLED) == 0)
1517 DeleteMenu(toolbarMenu, IDM_TOOLBARS_CUSTOMIZE, MF_BYCOMMAND);
1518 DeleteMenu(toolbarMenu, IDM_TOOLBARS_TEXTLABELS, MF_BYCOMMAND);
1519 DeleteMenu(toolbarMenu, IDM_TOOLBARS_GOBUTTON, MF_BYCOMMAND);
1520
1521 menuItemInfo.cbSize = sizeof(menuItemInfo);
1522 menuItemInfo.fMask = MIIM_SUBMENU;
1523 menuItemInfo.hSubMenu = toolbarMenu;
1524 SetMenuItemInfo(theMenu, IDM_VIEW_TOOLBARS, FALSE, &menuItemInfo);
1525 }
1526 SHCheckMenuItem(theMenu, IDM_VIEW_STATUSBAR, fStatusBarVisible ? TRUE : FALSE);
1527 }
1528
1529 bool IUnknownIsEqual(IUnknown *int1, IUnknown *int2)
1530 {
1531 CComPtr<IUnknown> int1Retry;
1532 CComPtr<IUnknown> int2Retry;
1533 HRESULT hResult;
1534
1535 if (int1 == int2)
1536 return true;
1537 if (int1 == NULL || int2 == NULL)
1538 return false;
1539 hResult = int1->QueryInterface(IID_PPV_ARG(IUnknown, &int1Retry));
1540 if (FAILED(hResult))
1541 return false;
1542 hResult = int2->QueryInterface(IID_PPV_ARG(IUnknown, &int2Retry));
1543 if (FAILED(hResult))
1544 return false;
1545 if (int1Retry == int2Retry)
1546 return true;
1547 return false;
1548 }
1549
1550 HRESULT STDMETHODCALLTYPE CShellBrowser::GetBorderDW(IUnknown *punkObj, LPRECT prcBorder)
1551 {
1552 RECT availableBounds;
1553 static const INT excludeItems[] = {1, 1, 1, 0xa001, 0, 0};
1554
1555 GetEffectiveClientRect(m_hWnd, &availableBounds, excludeItems);
1556 for (INT x = 0; x < 3; x++)
1557 {
1558 if (fClientBars[x].clientBar.p != NULL && !IUnknownIsEqual(fClientBars[x].clientBar, punkObj))
1559 {
1560 availableBounds.top += fClientBars[x].borderSpace.top;
1561 availableBounds.left += fClientBars[x].borderSpace.left;
1562 availableBounds.bottom -= fClientBars[x].borderSpace.bottom;
1563 availableBounds.right -= fClientBars[x].borderSpace.right;
1564 }
1565 }
1566 *prcBorder = availableBounds;
1567 return S_OK;
1568 }
1569
1570 HRESULT STDMETHODCALLTYPE CShellBrowser::RequestBorderSpaceDW(IUnknown* punkObj, LPCBORDERWIDTHS pbw)
1571 {
1572 return S_OK;
1573 }
1574
1575 HRESULT STDMETHODCALLTYPE CShellBrowser::SetBorderSpaceDW(IUnknown* punkObj, LPCBORDERWIDTHS pbw)
1576 {
1577 for (INT x = 0; x < 3; x++)
1578 {
1579 if (IUnknownIsEqual(fClientBars[x].clientBar, punkObj))
1580 {
1581 fClientBars[x].borderSpace = *pbw;
1582 // if this bar changed size, it cascades and forces all subsequent bars to resize
1583 RepositionBars();
1584 return S_OK;
1585 }
1586 }
1587 return E_INVALIDARG;
1588 }
1589
1590 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryStatus(const GUID *pguidCmdGroup,
1591 ULONG cCmds, OLECMD prgCmds[ ], OLECMDTEXT *pCmdText)
1592 {
1593 CComPtr<IOleCommandTarget> commandTarget;
1594 HRESULT hResult;
1595
1596 if (prgCmds == NULL)
1597 return E_INVALIDARG;
1598 if (pguidCmdGroup == NULL)
1599 {
1600 if (fCurrentShellView.p != NULL)
1601 {
1602 hResult = fCurrentShellView->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &commandTarget));
1603 if (SUCCEEDED(hResult) && commandTarget.p != NULL)
1604 return commandTarget->QueryStatus(NULL, 1, prgCmds, pCmdText);
1605 }
1606 while (cCmds != 0)
1607 {
1608 prgCmds->cmdf = 0;
1609 prgCmds++;
1610 cCmds--;
1611 }
1612 }
1613 else if (IsEqualIID(*pguidCmdGroup, CGID_Explorer))
1614 {
1615 while (cCmds != 0)
1616 {
1617 switch (prgCmds->cmdID)
1618 {
1619 case 0x1c: // search
1620 prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1621 break;
1622 case 0x1d: // history
1623 prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1624 break;
1625 case 0x1e: // favorites
1626 prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
1627 break;
1628 case 0x23: // folders
1629 prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED | OLECMDF_LATCHED;
1630 break;
1631 default:
1632 prgCmds->cmdf = 0;
1633 break;
1634 }
1635 prgCmds++;
1636 cCmds--;
1637 }
1638 }
1639 else if (IsEqualIID(*pguidCmdGroup, CGID_ShellBrowser))
1640 {
1641 while (cCmds != 0)
1642 {
1643 switch (prgCmds->cmdID)
1644 {
1645 case 0xa022: // up level
1646 prgCmds->cmdf = OLECMDF_SUPPORTED;
1647 if (fCurrentDirectoryPIDL->mkid.cb != 0)
1648 prgCmds->cmdf |= OLECMDF_ENABLED;
1649 break;
1650 }
1651 prgCmds++;
1652 cCmds--;
1653 }
1654 }
1655 return S_OK;
1656 }
1657
1658 HRESULT STDMETHODCALLTYPE CShellBrowser::Exec(const GUID *pguidCmdGroup, DWORD nCmdID,
1659 DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
1660 {
1661 HRESULT hResult;
1662
1663 if (IsEqualIID(*pguidCmdGroup, CGID_Explorer))
1664 {
1665 switch (nCmdID)
1666 {
1667 case 0x23:
1668 hResult = ShowBand(CLSID_ExplorerBand, true);
1669 return S_OK;
1670 case 0x27:
1671 if (nCmdexecopt == 1)
1672 {
1673 // pvaIn is a VT_UNKNOWN with a band that is being hidden
1674 }
1675 else
1676 {
1677 // update zones part of the status bar
1678 }
1679 return S_OK;
1680 case 0x35: // don't do this, and the internet toolbar doesn't create a menu band
1681 V_VT(pvaOut) = VT_INT_PTR;
1682 V_INTREF(pvaOut) = reinterpret_cast<INT *>(
1683 LoadMenu(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(IDM_CABINET_MAINMENU)));
1684 return S_OK;
1685 case 0x38:
1686 // indicate if this cabinet was opened as a browser
1687 return S_FALSE;
1688 default:
1689 return E_NOTIMPL;
1690 }
1691 }
1692 else if (IsEqualIID(*pguidCmdGroup, CGID_InternetButtons))
1693 {
1694 switch (nCmdID)
1695 {
1696 case 0x23:
1697 // placeholder
1698 return S_OK;
1699 }
1700 }
1701 else if (IsEqualIID(*pguidCmdGroup, CGID_Theater))
1702 {
1703 switch (nCmdID)
1704 {
1705 case 6:
1706 // what is theater mode and why do we receive this?
1707 return E_NOTIMPL;
1708 }
1709 }
1710 else if (IsEqualIID(*pguidCmdGroup, CGID_MenuBand))
1711 {
1712 switch (nCmdID)
1713 {
1714 case 14:
1715 // initialize favorites menu
1716 return S_OK;
1717 }
1718 }
1719 else if (IsEqualIID(*pguidCmdGroup, CGID_ShellDocView))
1720 {
1721 switch (nCmdID)
1722 {
1723 case 0x12:
1724 // refresh on toolbar clicked
1725 return S_OK;
1726 case 0x4d:
1727 // tell the view if it should hide the task pane or not
1728 return (fClientBars[BIVerticalBaseBar].clientBar.p == NULL) ? S_FALSE : S_OK;
1729 }
1730 }
1731 else if (IsEqualIID(*pguidCmdGroup, CGID_ShellBrowser))
1732 {
1733 switch (nCmdID)
1734 {
1735 case 40994:
1736 return NavigateToParent();
1737 }
1738 }
1739 else if (IsEqualIID(*pguidCmdGroup, CGID_IExplorerToolbar))
1740 {
1741 switch (nCmdID)
1742 {
1743 case 0x7063:
1744 return DoFolderOptions();
1745 }
1746 }
1747 else if (IsEqualIID(*pguidCmdGroup, CGID_DefView))
1748 {
1749 switch (nCmdID)
1750 {
1751 case 1:
1752 // Reset All Folders option in Folder Options
1753 break;
1754 }
1755 }
1756 else
1757 {
1758 return E_NOTIMPL;
1759 }
1760 return E_NOTIMPL;
1761 }
1762
1763 HRESULT STDMETHODCALLTYPE CShellBrowser::GetWindow(HWND *lphwnd)
1764 {
1765 if (lphwnd == NULL)
1766 return E_POINTER;
1767 *lphwnd = m_hWnd;
1768 return S_OK;
1769 }
1770
1771 HRESULT STDMETHODCALLTYPE CShellBrowser::ContextSensitiveHelp(BOOL fEnterMode)
1772 {
1773 return E_NOTIMPL;
1774 }
1775
1776 HRESULT STDMETHODCALLTYPE CShellBrowser::InsertMenusSB(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths)
1777 {
1778 HMENU mainMenu = LoadMenu(_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(IDM_CABINET_MAINMENU));
1779 Shell_MergeMenus(hmenuShared, mainMenu, 0, 0, FCIDM_BROWSERLAST, MM_SUBMENUSHAVEIDS);
1780
1781 int GCCU(itemCount3) = GetMenuItemCount(hmenuShared);
1782 Unused(itemCount3);
1783
1784 lpMenuWidths->width[0] = 2;
1785 lpMenuWidths->width[2] = 3;
1786 lpMenuWidths->width[4] = 1;
1787 return S_OK;
1788 }
1789
1790 HRESULT STDMETHODCALLTYPE CShellBrowser::SetMenuSB(HMENU hmenuShared, HOLEMENU holemenuRes, HWND hwndActiveObject)
1791 {
1792 CComPtr<IShellMenu> shellMenu;
1793 HRESULT hResult;
1794
1795 if (IsMenu(hmenuShared) == FALSE)
1796 return E_FAIL;
1797 hResult = GetMenuBand(IID_PPV_ARG(IShellMenu, &shellMenu));
1798 if (FAILED(hResult))
1799 return hResult;
1800 hResult = shellMenu->SetMenu(hmenuShared, NULL, SMSET_DONTOWN);
1801 if (FAILED(hResult))
1802 return hResult;
1803 fCurrentMenuBar = hmenuShared;
1804 return S_OK;
1805 }
1806
1807 HRESULT STDMETHODCALLTYPE CShellBrowser::RemoveMenusSB(HMENU hmenuShared)
1808 {
1809 if (hmenuShared == fCurrentMenuBar)
1810 fCurrentMenuBar = NULL;
1811 return S_OK;
1812 }
1813
1814 HRESULT STDMETHODCALLTYPE CShellBrowser::SetStatusTextSB(LPCOLESTR pszStatusText)
1815 {
1816 return E_NOTIMPL;
1817 }
1818
1819 HRESULT STDMETHODCALLTYPE CShellBrowser::EnableModelessSB(BOOL fEnable)
1820 {
1821 return E_NOTIMPL;
1822 }
1823
1824 HRESULT STDMETHODCALLTYPE CShellBrowser::TranslateAcceleratorSB(MSG *pmsg, WORD wID)
1825 {
1826 return E_NOTIMPL;
1827 }
1828
1829 HRESULT STDMETHODCALLTYPE CShellBrowser::BrowseObject(LPCITEMIDLIST pidl, UINT wFlags)
1830 {
1831 return BrowseToPIDL(pidl, BTP_UPDATE_CUR_HISTORY | BTP_UPDATE_NEXT_HISTORY);
1832 }
1833
1834 HRESULT STDMETHODCALLTYPE CShellBrowser::GetViewStateStream(DWORD grfMode, IStream **ppStrm)
1835 {
1836 return E_NOTIMPL;
1837 }
1838
1839 HRESULT STDMETHODCALLTYPE CShellBrowser::GetControlWindow(UINT id, HWND *lphwnd)
1840 {
1841 if (lphwnd == NULL)
1842 return E_POINTER;
1843 *lphwnd = NULL;
1844 switch(id)
1845 {
1846 case FCW_TOOLBAR:
1847 *lphwnd = fToolbarProxy.m_hWnd;
1848 return S_OK;
1849 case FCW_STATUS:
1850 *lphwnd = fStatusBar;
1851 return S_OK;
1852 case FCW_TREE:
1853 // find the directory browser and return it
1854 // this should be used only to determine if a tree is present
1855 return S_OK;
1856 case FCW_PROGRESS:
1857 // is this a progress dialog?
1858 return S_OK;
1859 }
1860 return S_OK;
1861 }
1862
1863 HRESULT STDMETHODCALLTYPE CShellBrowser::SendControlMsg(
1864 UINT id, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *pret)
1865 {
1866 LPARAM result;
1867
1868 if (pret != NULL)
1869 *pret = 0;
1870 switch(id)
1871 {
1872 case FCW_TOOLBAR:
1873 result = fToolbarProxy.SendMessage(uMsg, wParam, lParam);
1874 if (pret != NULL)
1875 *pret = result;
1876 break;
1877 case FCW_STATUS:
1878 result = SendMessage(fStatusBar, uMsg, wParam, lParam);
1879 if (pret != NULL)
1880 *pret = result;
1881 break;
1882 }
1883 return S_OK;
1884 }
1885
1886 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryActiveShellView(IShellView **ppshv)
1887 {
1888 if (ppshv == NULL)
1889 return E_POINTER;
1890 *ppshv = fCurrentShellView;
1891 if (fCurrentShellView.p != NULL)
1892 fCurrentShellView.p->AddRef();
1893 return S_OK;
1894 }
1895
1896 HRESULT STDMETHODCALLTYPE CShellBrowser::OnViewWindowActive(IShellView *ppshv)
1897 {
1898 return E_NOTIMPL;
1899 }
1900
1901 HRESULT STDMETHODCALLTYPE CShellBrowser::SetToolbarItems(LPTBBUTTON lpButtons, UINT nButtons, UINT uFlags)
1902 {
1903 return E_NOTIMPL;
1904 }
1905
1906 HRESULT STDMETHODCALLTYPE CShellBrowser::DragEnter(
1907 IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
1908 {
1909 return E_NOTIMPL;
1910 }
1911
1912 HRESULT STDMETHODCALLTYPE CShellBrowser::DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
1913 {
1914 return E_NOTIMPL;
1915 }
1916
1917 HRESULT STDMETHODCALLTYPE CShellBrowser::DragLeave()
1918 {
1919 return E_NOTIMPL;
1920 }
1921
1922 HRESULT STDMETHODCALLTYPE CShellBrowser::Drop(
1923 IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
1924 {
1925 return E_NOTIMPL;
1926 }
1927
1928 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
1929 {
1930 // view does a query for SID_STopLevelBrowser, IID_IShellBrowserService
1931 // the returned interface has a method GetPropertyBag on it
1932 if (IsEqualIID(guidService, SID_STopLevelBrowser))
1933 return this->QueryInterface(riid, ppvObject);
1934 if (IsEqualIID(guidService, SID_SShellBrowser))
1935 return this->QueryInterface(riid, ppvObject);
1936 if (IsEqualIID(guidService, SID_ITargetFrame2))
1937 return this->QueryInterface(riid, ppvObject);
1938 if (IsEqualIID(guidService, SID_IWebBrowserApp)) // without this, the internet toolbar won't reflect notifications
1939 return this->QueryInterface(riid, ppvObject);
1940 if (IsEqualIID(guidService, SID_SProxyBrowser))
1941 return this->QueryInterface(riid, ppvObject);
1942 if (IsEqualIID(guidService, SID_IExplorerToolbar))
1943 return fClientBars[BIInternetToolbar].clientBar->QueryInterface(riid, ppvObject);
1944 if (IsEqualIID(riid, IID_IShellBrowser))
1945 return this->QueryInterface(riid, ppvObject);
1946 return E_NOINTERFACE;
1947 }
1948
1949 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPropertyBag(long flags, REFIID riid, void **ppvObject)
1950 {
1951 if (ppvObject == NULL)
1952 return E_POINTER;
1953 *ppvObject = NULL;
1954 return E_NOTIMPL;
1955 }
1956
1957 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTypeInfoCount(UINT *pctinfo)
1958 {
1959 return E_NOTIMPL;
1960 }
1961
1962 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1963 {
1964 return E_NOTIMPL;
1965 }
1966
1967 HRESULT STDMETHODCALLTYPE CShellBrowser::GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames,
1968 UINT cNames, LCID lcid, DISPID *rgDispId)
1969 {
1970 return E_NOTIMPL;
1971 }
1972
1973 HRESULT STDMETHODCALLTYPE CShellBrowser::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
1974 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1975 {
1976 return E_NOTIMPL;
1977 }
1978
1979 HRESULT STDMETHODCALLTYPE CShellBrowser::GetParentSite(IOleInPlaceSite **ppipsite)
1980 {
1981 return E_NOTIMPL;
1982 }
1983
1984 HRESULT STDMETHODCALLTYPE CShellBrowser::SetTitle(IShellView *psv, LPCWSTR pszName)
1985 {
1986 return E_NOTIMPL;
1987 }
1988
1989 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTitle(IShellView *psv, LPWSTR pszName, DWORD cchName)
1990 {
1991 return E_NOTIMPL;
1992 }
1993
1994 HRESULT STDMETHODCALLTYPE CShellBrowser::GetOleObject(IOleObject **ppobjv)
1995 {
1996 return E_NOTIMPL;
1997 }
1998
1999 HRESULT STDMETHODCALLTYPE CShellBrowser::GetTravelLog(ITravelLog **pptl)
2000 {
2001 HRESULT hResult;
2002
2003 // called by toolbar when displaying tooltips
2004 if (pptl != NULL)
2005 *pptl = NULL;
2006 if (fTravelLog.p == NULL)
2007 {
2008 hResult = CreateTravelLog(IID_PPV_ARG(ITravelLog, &fTravelLog));
2009 if (FAILED(hResult))
2010 return hResult;
2011 }
2012 *pptl = fTravelLog.p;
2013 fTravelLog.p->AddRef();
2014 return S_OK;
2015 }
2016
2017 HRESULT STDMETHODCALLTYPE CShellBrowser::ShowControlWindow(UINT id, BOOL fShow)
2018 {
2019 return E_NOTIMPL;
2020 }
2021
2022 HRESULT STDMETHODCALLTYPE CShellBrowser::IsControlWindowShown(UINT id, BOOL *pfShown)
2023 {
2024 return E_NOTIMPL;
2025 }
2026
2027 HRESULT STDMETHODCALLTYPE CShellBrowser::IEGetDisplayName(LPCITEMIDLIST pidl, LPWSTR pwszName, UINT uFlags)
2028 {
2029 return E_NOTIMPL;
2030 }
2031
2032 HRESULT STDMETHODCALLTYPE CShellBrowser::IEParseDisplayName(UINT uiCP, LPCWSTR pwszPath, LPITEMIDLIST *ppidlOut)
2033 {
2034 return E_NOTIMPL;
2035 }
2036
2037 HRESULT STDMETHODCALLTYPE CShellBrowser::DisplayParseError(HRESULT hres, LPCWSTR pwszPath)
2038 {
2039 return E_NOTIMPL;
2040 }
2041
2042 HRESULT STDMETHODCALLTYPE CShellBrowser::NavigateToPidl(LPCITEMIDLIST pidl, DWORD grfHLNF)
2043 {
2044 return E_NOTIMPL;
2045 }
2046
2047 HRESULT STDMETHODCALLTYPE CShellBrowser::SetNavigateState(BNSTATE bnstate)
2048 {
2049 return E_NOTIMPL;
2050 }
2051
2052 HRESULT STDMETHODCALLTYPE CShellBrowser::GetNavigateState(BNSTATE *pbnstate)
2053 {
2054 return E_NOTIMPL;
2055 }
2056
2057 HRESULT STDMETHODCALLTYPE CShellBrowser::NotifyRedirect(IShellView *psv, LPCITEMIDLIST pidl, BOOL *pfDidBrowse)
2058 {
2059 return E_NOTIMPL;
2060 }
2061
2062 HRESULT STDMETHODCALLTYPE CShellBrowser::UpdateWindowList()
2063 {
2064 return E_NOTIMPL;
2065 }
2066
2067 HRESULT STDMETHODCALLTYPE CShellBrowser::UpdateBackForwardState()
2068 {
2069 return E_NOTIMPL;
2070 }
2071
2072 HRESULT STDMETHODCALLTYPE CShellBrowser::SetFlags(DWORD dwFlags, DWORD dwFlagMask)
2073 {
2074 return E_NOTIMPL;
2075 }
2076
2077 HRESULT STDMETHODCALLTYPE CShellBrowser::GetFlags(DWORD *pdwFlags)
2078 {
2079 return E_NOTIMPL;
2080 }
2081
2082 HRESULT STDMETHODCALLTYPE CShellBrowser::CanNavigateNow()
2083 {
2084 return E_NOTIMPL;
2085 }
2086
2087 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPidl(LPITEMIDLIST *ppidl)
2088 {
2089 // called by explorer bar to get current pidl
2090 if (ppidl == NULL)
2091 return E_POINTER;
2092 *ppidl = ILClone(fCurrentDirectoryPIDL);
2093 return S_OK;
2094 }
2095
2096 HRESULT STDMETHODCALLTYPE CShellBrowser::SetReferrer(LPCITEMIDLIST pidl)
2097 {
2098 return E_NOTIMPL;
2099 }
2100
2101 DWORD STDMETHODCALLTYPE CShellBrowser::GetBrowserIndex()
2102 {
2103 return -1;
2104 }
2105
2106 HRESULT STDMETHODCALLTYPE CShellBrowser::GetBrowserByIndex(DWORD dwID, IUnknown **ppunk)
2107 {
2108 return E_NOTIMPL;
2109 }
2110
2111 HRESULT STDMETHODCALLTYPE CShellBrowser::GetHistoryObject(IOleObject **ppole, IStream **pstm, IBindCtx **ppbc)
2112 {
2113 if (ppole == NULL || pstm == NULL || ppbc == NULL)
2114 return E_INVALIDARG;
2115 *ppole = fHistoryObject;
2116 if (fHistoryObject != NULL)
2117 fHistoryObject->AddRef();
2118 *pstm = fHistoryStream;
2119 if (fHistoryStream != NULL)
2120 fHistoryStream->AddRef();
2121 *ppbc = fHistoryBindContext;
2122 if (fHistoryBindContext != NULL)
2123 fHistoryBindContext->AddRef();
2124 fHistoryObject = NULL;
2125 fHistoryStream = NULL;
2126 fHistoryBindContext = NULL;
2127 if (*ppole == NULL)
2128 return E_FAIL;
2129 return S_OK;
2130 }
2131
2132 HRESULT STDMETHODCALLTYPE CShellBrowser::SetHistoryObject(IOleObject *pole, BOOL fIsLocalAnchor)
2133 {
2134 return E_NOTIMPL;
2135 }
2136
2137 HRESULT STDMETHODCALLTYPE CShellBrowser::CacheOLEServer(IOleObject *pole)
2138 {
2139 return E_NOTIMPL;
2140 }
2141
2142 HRESULT STDMETHODCALLTYPE CShellBrowser::GetSetCodePage(VARIANT *pvarIn, VARIANT *pvarOut)
2143 {
2144 return E_NOTIMPL;
2145 }
2146
2147 HRESULT STDMETHODCALLTYPE CShellBrowser::OnHttpEquiv(
2148 IShellView *psv, BOOL fDone, VARIANT *pvarargIn, VARIANT *pvarargOut)
2149 {
2150 return E_NOTIMPL;
2151 }
2152
2153 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPalette(HPALETTE *hpal)
2154 {
2155 return E_NOTIMPL;
2156 }
2157
2158 HRESULT STDMETHODCALLTYPE CShellBrowser::RegisterWindow(BOOL fForceRegister, int swc)
2159 {
2160 return E_NOTIMPL;
2161 }
2162
2163 LRESULT STDMETHODCALLTYPE CShellBrowser::WndProcBS(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
2164 {
2165 return E_NOTIMPL;
2166 }
2167
2168 HRESULT STDMETHODCALLTYPE CShellBrowser::SetAsDefFolderSettings()
2169 {
2170 return E_NOTIMPL;
2171 }
2172
2173 HRESULT STDMETHODCALLTYPE CShellBrowser::GetViewRect(RECT *prc)
2174 {
2175 return E_NOTIMPL;
2176 }
2177
2178 HRESULT STDMETHODCALLTYPE CShellBrowser::OnSize(WPARAM wParam)
2179 {
2180 return E_NOTIMPL;
2181 }
2182
2183 HRESULT STDMETHODCALLTYPE CShellBrowser::OnCreate(struct tagCREATESTRUCTW *pcs)
2184 {
2185 return E_NOTIMPL;
2186 }
2187
2188 LRESULT STDMETHODCALLTYPE CShellBrowser::OnCommand(WPARAM wParam, LPARAM lParam)
2189 {
2190 return 0;
2191 }
2192
2193 HRESULT STDMETHODCALLTYPE CShellBrowser::OnDestroy()
2194 {
2195 return E_NOTIMPL;
2196 }
2197
2198 LRESULT STDMETHODCALLTYPE CShellBrowser::OnNotify(struct tagNMHDR *pnm)
2199 {
2200 return 0;
2201 }
2202
2203 HRESULT STDMETHODCALLTYPE CShellBrowser::OnSetFocus()
2204 {
2205 return E_NOTIMPL;
2206 }
2207
2208 HRESULT STDMETHODCALLTYPE CShellBrowser::OnFrameWindowActivateBS(BOOL fActive)
2209 {
2210 return E_NOTIMPL;
2211 }
2212
2213 HRESULT STDMETHODCALLTYPE CShellBrowser::ReleaseShellView()
2214 {
2215 return E_NOTIMPL;
2216 }
2217
2218 HRESULT STDMETHODCALLTYPE CShellBrowser::ActivatePendingView()
2219 {
2220 return E_NOTIMPL;
2221 }
2222
2223 HRESULT STDMETHODCALLTYPE CShellBrowser::CreateViewWindow(
2224 IShellView *psvNew, IShellView *psvOld, LPRECT prcView, HWND *phwnd)
2225 {
2226 return E_NOTIMPL;
2227 }
2228
2229 HRESULT STDMETHODCALLTYPE CShellBrowser::CreateBrowserPropSheetExt(REFIID riid, void **ppv)
2230 {
2231 return E_NOTIMPL;
2232 }
2233
2234 HRESULT STDMETHODCALLTYPE CShellBrowser::GetViewWindow(HWND *phwndView)
2235 {
2236 return E_NOTIMPL;
2237 }
2238
2239 HRESULT STDMETHODCALLTYPE CShellBrowser::GetBaseBrowserData(LPCBASEBROWSERDATA *pbbd)
2240 {
2241 return E_NOTIMPL;
2242 }
2243
2244 LPBASEBROWSERDATA STDMETHODCALLTYPE CShellBrowser::PutBaseBrowserData()
2245 {
2246 return NULL;
2247 }
2248
2249 HRESULT STDMETHODCALLTYPE CShellBrowser::InitializeTravelLog(ITravelLog *ptl, DWORD dw)
2250 {
2251 return E_NOTIMPL;
2252 }
2253
2254 HRESULT STDMETHODCALLTYPE CShellBrowser::SetTopBrowser()
2255 {
2256 return E_NOTIMPL;
2257 }
2258
2259 HRESULT STDMETHODCALLTYPE CShellBrowser::Offline(int iCmd)
2260 {
2261 return E_NOTIMPL;
2262 }
2263
2264 HRESULT STDMETHODCALLTYPE CShellBrowser::AllowViewResize(BOOL f)
2265 {
2266 return E_NOTIMPL;
2267 }
2268
2269 HRESULT STDMETHODCALLTYPE CShellBrowser::SetActivateState(UINT u)
2270 {
2271 return E_NOTIMPL;
2272 }
2273
2274 HRESULT STDMETHODCALLTYPE CShellBrowser::UpdateSecureLockIcon(int eSecureLock)
2275 {
2276 return E_NOTIMPL;
2277 }
2278
2279 HRESULT STDMETHODCALLTYPE CShellBrowser::InitializeDownloadManager()
2280 {
2281 return E_NOTIMPL;
2282 }
2283
2284 HRESULT STDMETHODCALLTYPE CShellBrowser::InitializeTransitionSite()
2285 {
2286 return E_NOTIMPL;
2287 }
2288
2289 HRESULT STDMETHODCALLTYPE CShellBrowser::_Initialize(HWND hwnd, IUnknown *pauto)
2290 {
2291 return E_NOTIMPL;
2292 }
2293
2294 HRESULT STDMETHODCALLTYPE CShellBrowser::_CancelPendingNavigationAsync()
2295 {
2296 return E_NOTIMPL;
2297 }
2298
2299 HRESULT STDMETHODCALLTYPE CShellBrowser::_CancelPendingView()
2300 {
2301 return E_NOTIMPL;
2302 }
2303
2304 HRESULT STDMETHODCALLTYPE CShellBrowser::_MaySaveChanges()
2305 {
2306 return E_NOTIMPL;
2307 }
2308
2309 HRESULT STDMETHODCALLTYPE CShellBrowser::_PauseOrResumeView(BOOL fPaused)
2310 {
2311 return E_NOTIMPL;
2312 }
2313
2314 HRESULT STDMETHODCALLTYPE CShellBrowser::_DisableModeless()
2315 {
2316 return E_NOTIMPL;
2317 }
2318
2319 HRESULT STDMETHODCALLTYPE CShellBrowser::_NavigateToPidl(LPCITEMIDLIST pidl, DWORD grfHLNF, DWORD dwFlags)
2320 {
2321 return E_NOTIMPL;
2322 }
2323
2324 HRESULT STDMETHODCALLTYPE CShellBrowser::_TryShell2Rename(IShellView *psv, LPCITEMIDLIST pidlNew)
2325 {
2326 return E_NOTIMPL;
2327 }
2328
2329 HRESULT STDMETHODCALLTYPE CShellBrowser::_SwitchActivationNow()
2330 {
2331 return E_NOTIMPL;
2332 }
2333
2334 HRESULT STDMETHODCALLTYPE CShellBrowser::_ExecChildren(IUnknown *punkBar, BOOL fBroadcast,
2335 const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
2336 {
2337 return E_NOTIMPL;
2338 }
2339
2340 HRESULT STDMETHODCALLTYPE CShellBrowser::_SendChildren(
2341 HWND hwndBar, BOOL fBroadcast, UINT uMsg, WPARAM wParam, LPARAM lParam)
2342 {
2343 return E_NOTIMPL;
2344 }
2345
2346 HRESULT STDMETHODCALLTYPE CShellBrowser::GetFolderSetData(struct tagFolderSetData *pfsd)
2347 {
2348 return E_NOTIMPL;
2349 }
2350
2351 HRESULT STDMETHODCALLTYPE CShellBrowser::_OnFocusChange(UINT itb)
2352 {
2353 return E_NOTIMPL;
2354 }
2355
2356 HRESULT STDMETHODCALLTYPE CShellBrowser::v_ShowHideChildWindows(BOOL fChildOnly)
2357 {
2358 return E_NOTIMPL;
2359 }
2360
2361 UINT STDMETHODCALLTYPE CShellBrowser::_get_itbLastFocus()
2362 {
2363 return 0;
2364 }
2365
2366 HRESULT STDMETHODCALLTYPE CShellBrowser::_put_itbLastFocus(UINT itbLastFocus)
2367 {
2368 return E_NOTIMPL;
2369 }
2370
2371 HRESULT STDMETHODCALLTYPE CShellBrowser::_UIActivateView(UINT uState)
2372 {
2373 return E_NOTIMPL;
2374 }
2375
2376 HRESULT STDMETHODCALLTYPE CShellBrowser::_GetViewBorderRect(RECT *prc)
2377 {
2378 return E_NOTIMPL;
2379 }
2380
2381 HRESULT STDMETHODCALLTYPE CShellBrowser::_UpdateViewRectSize()
2382 {
2383 return E_NOTIMPL;
2384 }
2385
2386 HRESULT STDMETHODCALLTYPE CShellBrowser::_ResizeNextBorder(UINT itb)
2387 {
2388 return E_NOTIMPL;
2389 }
2390
2391 HRESULT STDMETHODCALLTYPE CShellBrowser::_ResizeView()
2392 {
2393 return E_NOTIMPL;
2394 }
2395
2396 HRESULT STDMETHODCALLTYPE CShellBrowser::_GetEffectiveClientArea(LPRECT lprectBorder, HMONITOR hmon)
2397 {
2398 return E_NOTIMPL;
2399 }
2400
2401 IStream *STDMETHODCALLTYPE CShellBrowser::v_GetViewStream(LPCITEMIDLIST pidl, DWORD grfMode, LPCWSTR pwszName)
2402 {
2403 return NULL;
2404 }
2405
2406 LRESULT STDMETHODCALLTYPE CShellBrowser::ForwardViewMsg(UINT uMsg, WPARAM wParam, LPARAM lParam)
2407 {
2408 return 0;
2409 }
2410
2411 HRESULT STDMETHODCALLTYPE CShellBrowser::SetAcceleratorMenu(HACCEL hacc)
2412 {
2413 return E_NOTIMPL;
2414 }
2415
2416 int STDMETHODCALLTYPE CShellBrowser::_GetToolbarCount()
2417 {
2418 return 0;
2419 }
2420
2421 LPTOOLBARITEM STDMETHODCALLTYPE CShellBrowser::_GetToolbarItem(int itb)
2422 {
2423 return NULL;
2424 }
2425
2426 HRESULT STDMETHODCALLTYPE CShellBrowser::_SaveToolbars(IStream *pstm)
2427 {
2428 return E_NOTIMPL;
2429 }
2430
2431 HRESULT STDMETHODCALLTYPE CShellBrowser::_LoadToolbars(IStream *pstm)
2432 {
2433 return E_NOTIMPL;
2434 }
2435
2436 HRESULT STDMETHODCALLTYPE CShellBrowser::_CloseAndReleaseToolbars(BOOL fClose)
2437 {
2438 return E_NOTIMPL;
2439 }
2440
2441 HRESULT STDMETHODCALLTYPE CShellBrowser::v_MayGetNextToolbarFocus(
2442 LPMSG lpMsg, UINT itbNext, int citb, LPTOOLBARITEM *pptbi, HWND *phwnd)
2443 {
2444 return E_NOTIMPL;
2445 }
2446
2447 HRESULT STDMETHODCALLTYPE CShellBrowser::_ResizeNextBorderHelper(UINT itb, BOOL bUseHmonitor)
2448 {
2449 return E_NOTIMPL;
2450 }
2451
2452 UINT STDMETHODCALLTYPE CShellBrowser::_FindTBar(IUnknown *punkSrc)
2453 {
2454 return 0;
2455 }
2456
2457 HRESULT STDMETHODCALLTYPE CShellBrowser::_SetFocus(LPTOOLBARITEM ptbi, HWND hwnd, LPMSG lpMsg)
2458 {
2459 return E_NOTIMPL;
2460 }
2461
2462 HRESULT STDMETHODCALLTYPE CShellBrowser::v_MayTranslateAccelerator(MSG *pmsg)
2463 {
2464 return E_NOTIMPL;
2465 }
2466
2467 HRESULT STDMETHODCALLTYPE CShellBrowser::_GetBorderDWHelper(IUnknown *punkSrc, LPRECT lprectBorder, BOOL bUseHmonitor)
2468 {
2469 return E_NOTIMPL;
2470 }
2471
2472 HRESULT STDMETHODCALLTYPE CShellBrowser::v_CheckZoneCrossing(LPCITEMIDLIST pidl)
2473 {
2474 return E_NOTIMPL;
2475 }
2476
2477 HRESULT STDMETHODCALLTYPE CShellBrowser::GoBack()
2478 {
2479 CComPtr<ITravelLog> travelLog;
2480 HRESULT hResult;
2481
2482 hResult = GetTravelLog(&travelLog);
2483 if (FAILED(hResult))
2484 return hResult;
2485 return travelLog->Travel(static_cast<IDropTarget *>(this), TLOG_BACK);
2486 }
2487
2488 HRESULT STDMETHODCALLTYPE CShellBrowser::GoForward()
2489 {
2490 CComPtr<ITravelLog> travelLog;
2491 HRESULT hResult;
2492
2493 hResult = GetTravelLog(&travelLog);
2494 if (FAILED(hResult))
2495 return hResult;
2496 return travelLog->Travel(static_cast<IDropTarget *>(this), TLOG_FORE);
2497 }
2498
2499 HRESULT STDMETHODCALLTYPE CShellBrowser::GoHome()
2500 {
2501 return E_NOTIMPL;
2502 }
2503
2504 HRESULT STDMETHODCALLTYPE CShellBrowser::GoSearch()
2505 {
2506 return E_NOTIMPL;
2507 }
2508
2509 HRESULT STDMETHODCALLTYPE CShellBrowser::Navigate(BSTR URL, VARIANT *Flags,
2510 VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
2511 {
2512 return E_NOTIMPL;
2513 }
2514
2515 HRESULT STDMETHODCALLTYPE CShellBrowser::Refresh()
2516 {
2517 VARIANT level;
2518
2519 V_VT(&level) = VT_I4;
2520 V_I4(&level) = 4;
2521 return Refresh2(&level);
2522 }
2523
2524 HRESULT STDMETHODCALLTYPE CShellBrowser::Refresh2(VARIANT *Level)
2525 {
2526 CComPtr<IOleCommandTarget> oleCommandTarget;
2527 HRESULT hResult;
2528
2529 hResult = fCurrentShellView->QueryInterface(IID_PPV_ARG(IOleCommandTarget, &oleCommandTarget));
2530 if (FAILED(hResult))
2531 return hResult;
2532 return oleCommandTarget->Exec(NULL, 22, 1, Level, NULL);
2533 }
2534
2535 HRESULT STDMETHODCALLTYPE CShellBrowser::Stop()
2536 {
2537 return E_NOTIMPL;
2538 }
2539
2540 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Application(IDispatch **ppDisp)
2541 {
2542 return E_NOTIMPL;
2543 }
2544
2545 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Parent(IDispatch **ppDisp)
2546 {
2547 return E_NOTIMPL;
2548 }
2549
2550 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Container(IDispatch **ppDisp)
2551 {
2552 return E_NOTIMPL;
2553 }
2554
2555 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Document(IDispatch **ppDisp)
2556 {
2557 return E_NOTIMPL;
2558 }
2559
2560 HRESULT STDMETHODCALLTYPE CShellBrowser::get_TopLevelContainer(VARIANT_BOOL *pBool)
2561 {
2562 return E_NOTIMPL;
2563 }
2564
2565 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Type(BSTR *Type)
2566 {
2567 return E_NOTIMPL;
2568 }
2569 #ifdef __exdisp_h__
2570 #define long LONG
2571 #endif
2572 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Left(long *pl)
2573 {
2574 return E_NOTIMPL;
2575 }
2576
2577 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Left(long Left)
2578 {
2579 return E_NOTIMPL;
2580 }
2581
2582 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Top(long *pl)
2583 {
2584 return E_NOTIMPL;
2585 }
2586
2587 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Top(long Top)
2588 {
2589 return E_NOTIMPL;
2590 }
2591
2592 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Width(long *pl)
2593 {
2594 return E_NOTIMPL;
2595 }
2596
2597 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Width(long Width)
2598 {
2599 return E_NOTIMPL;
2600 }
2601
2602 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Height(long *pl)
2603 {
2604 return E_NOTIMPL;
2605 }
2606
2607 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Height(long Height)
2608 {
2609 return E_NOTIMPL;
2610 }
2611 #ifdef __exdisp_h__
2612 #undef long
2613 #endif
2614 HRESULT STDMETHODCALLTYPE CShellBrowser::get_LocationName(BSTR *LocationName)
2615 {
2616 return E_NOTIMPL;
2617 }
2618
2619 HRESULT STDMETHODCALLTYPE CShellBrowser::get_LocationURL(BSTR *LocationURL)
2620 {
2621 return E_NOTIMPL;
2622 }
2623
2624 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Busy(VARIANT_BOOL *pBool)
2625 {
2626 return E_NOTIMPL;
2627 }
2628
2629 HRESULT STDMETHODCALLTYPE CShellBrowser::Quit()
2630 {
2631 return E_NOTIMPL;
2632 }
2633
2634 HRESULT STDMETHODCALLTYPE CShellBrowser::ClientToWindow(int *pcx, int *pcy)
2635 {
2636 return E_NOTIMPL;
2637 }
2638
2639 HRESULT STDMETHODCALLTYPE CShellBrowser::PutProperty(BSTR Property, VARIANT vtValue)
2640 {
2641 return E_NOTIMPL;
2642 }
2643
2644 HRESULT STDMETHODCALLTYPE CShellBrowser::GetProperty(BSTR Property, VARIANT *pvtValue)
2645 {
2646 return E_NOTIMPL;
2647 }
2648
2649 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Name(BSTR *Name)
2650 {
2651 return E_NOTIMPL;
2652 }
2653
2654 HRESULT STDMETHODCALLTYPE CShellBrowser::get_HWND(SHANDLE_PTR *pHWND)
2655 {
2656 return E_NOTIMPL;
2657 }
2658
2659 HRESULT STDMETHODCALLTYPE CShellBrowser::get_FullName(BSTR *FullName)
2660 {
2661 return E_NOTIMPL;
2662 }
2663
2664 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Path(BSTR *Path)
2665 {
2666 return E_NOTIMPL;
2667 }
2668
2669 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Visible(VARIANT_BOOL *pBool)
2670 {
2671 return E_NOTIMPL;
2672 }
2673
2674 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Visible(VARIANT_BOOL Value)
2675 {
2676 return E_NOTIMPL;
2677 }
2678
2679 HRESULT STDMETHODCALLTYPE CShellBrowser::get_StatusBar(VARIANT_BOOL *pBool)
2680 {
2681 return E_NOTIMPL;
2682 }
2683
2684 HRESULT STDMETHODCALLTYPE CShellBrowser::put_StatusBar(VARIANT_BOOL Value)
2685 {
2686 return E_NOTIMPL;
2687 }
2688
2689 HRESULT STDMETHODCALLTYPE CShellBrowser::get_StatusText(BSTR *StatusText)
2690 {
2691 return E_NOTIMPL;
2692 }
2693
2694 HRESULT STDMETHODCALLTYPE CShellBrowser::put_StatusText(BSTR StatusText)
2695 {
2696 return E_NOTIMPL;
2697 }
2698
2699 HRESULT STDMETHODCALLTYPE CShellBrowser::get_ToolBar(int *Value)
2700 {
2701 return E_NOTIMPL;
2702 }
2703
2704 HRESULT STDMETHODCALLTYPE CShellBrowser::put_ToolBar(int Value)
2705 {
2706 return E_NOTIMPL;
2707 }
2708
2709 HRESULT STDMETHODCALLTYPE CShellBrowser::get_MenuBar(VARIANT_BOOL *Value)
2710 {
2711 return E_NOTIMPL;
2712 }
2713
2714 HRESULT STDMETHODCALLTYPE CShellBrowser::put_MenuBar(VARIANT_BOOL Value)
2715 {
2716 return E_NOTIMPL;
2717 }
2718
2719 HRESULT STDMETHODCALLTYPE CShellBrowser::get_FullScreen(VARIANT_BOOL *pbFullScreen)
2720 {
2721 return E_NOTIMPL;
2722 }
2723
2724 HRESULT STDMETHODCALLTYPE CShellBrowser::put_FullScreen(VARIANT_BOOL bFullScreen)
2725 {
2726 return E_NOTIMPL;
2727 }
2728
2729 HRESULT STDMETHODCALLTYPE CShellBrowser::Navigate2(VARIANT *URL, VARIANT *Flags,
2730 VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
2731 {
2732 LPITEMIDLIST pidl;
2733 HRESULT hResult;
2734
2735 // called from drive combo box to navigate to a directory
2736 if (V_VT(URL) != (VT_ARRAY | VT_UI1))
2737 return E_INVALIDARG;
2738 if (V_ARRAY(URL)->cDims != 1 || V_ARRAY(URL)->cbElements != 1)
2739 return E_INVALIDARG;
2740 pidl = (LPITEMIDLIST)V_ARRAY(URL)->pvData;
2741 hResult = BrowseToPIDL((LPITEMIDLIST)pidl, BTP_UPDATE_CUR_HISTORY | BTP_UPDATE_NEXT_HISTORY);
2742 if (FAILED(hResult))
2743 return hResult;
2744 return S_OK;
2745 }
2746
2747 HRESULT STDMETHODCALLTYPE CShellBrowser::QueryStatusWB(OLECMDID cmdID, OLECMDF *pcmdf)
2748 {
2749 return E_NOTIMPL;
2750 }
2751
2752 HRESULT STDMETHODCALLTYPE CShellBrowser::ExecWB(OLECMDID cmdID, OLECMDEXECOPT cmdexecopt,
2753 VARIANT *pvaIn, VARIANT *pvaOut)
2754 {
2755 return E_NOTIMPL;
2756 }
2757
2758 HRESULT STDMETHODCALLTYPE CShellBrowser::ShowBrowserBar(VARIANT *pvaClsid, VARIANT *pvarShow, VARIANT *pvarSize)
2759 {
2760 CLSID classID;
2761 bool vertical;
2762
2763 // called to show search bar
2764 if (V_VT(pvaClsid) != VT_BSTR)
2765 return E_INVALIDARG;
2766 CLSIDFromString(V_BSTR(pvaClsid), &classID);
2767 // TODO: properly compute the value of vertical
2768 vertical = true;
2769 return ShowBand(classID, vertical);
2770 }
2771
2772 HRESULT STDMETHODCALLTYPE CShellBrowser::get_ReadyState(READYSTATE *plReadyState)
2773 {
2774 return E_NOTIMPL;
2775 }
2776
2777 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Offline(VARIANT_BOOL *pbOffline)
2778 {
2779 return E_NOTIMPL;
2780 }
2781
2782 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Offline(VARIANT_BOOL bOffline)
2783 {
2784 return E_NOTIMPL;
2785 }
2786
2787 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Silent(VARIANT_BOOL *pbSilent)
2788 {
2789 return E_NOTIMPL;
2790 }
2791
2792 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Silent(VARIANT_BOOL bSilent)
2793 {
2794 return E_NOTIMPL;
2795 }
2796
2797 HRESULT STDMETHODCALLTYPE CShellBrowser::get_RegisterAsBrowser(VARIANT_BOOL *pbRegister)
2798 {
2799 return E_NOTIMPL;
2800 }
2801
2802 HRESULT STDMETHODCALLTYPE CShellBrowser::put_RegisterAsBrowser(VARIANT_BOOL bRegister)
2803 {
2804 return E_NOTIMPL;
2805 }
2806
2807 HRESULT STDMETHODCALLTYPE CShellBrowser::get_RegisterAsDropTarget(VARIANT_BOOL *pbRegister)
2808 {
2809 return E_NOTIMPL;
2810 }
2811
2812 HRESULT STDMETHODCALLTYPE CShellBrowser::put_RegisterAsDropTarget(VARIANT_BOOL bRegister)
2813 {
2814 return E_NOTIMPL;
2815 }
2816
2817 HRESULT STDMETHODCALLTYPE CShellBrowser::get_TheaterMode(VARIANT_BOOL *pbRegister)
2818 {
2819 return E_NOTIMPL;
2820 }
2821
2822 HRESULT STDMETHODCALLTYPE CShellBrowser::put_TheaterMode(VARIANT_BOOL bRegister)
2823 {
2824 return E_NOTIMPL;
2825 }
2826
2827 HRESULT STDMETHODCALLTYPE CShellBrowser::get_AddressBar(VARIANT_BOOL *Value)
2828 {
2829 return E_NOTIMPL;
2830 }
2831
2832 HRESULT STDMETHODCALLTYPE CShellBrowser::put_AddressBar(VARIANT_BOOL Value)
2833 {
2834 return E_NOTIMPL;
2835 }
2836
2837 HRESULT STDMETHODCALLTYPE CShellBrowser::get_Resizable(VARIANT_BOOL *Value)
2838 {
2839 return E_NOTIMPL;
2840 }
2841
2842 HRESULT STDMETHODCALLTYPE CShellBrowser::put_Resizable(VARIANT_BOOL Value)
2843 {
2844 return E_NOTIMPL;
2845 }
2846
2847 HRESULT STDMETHODCALLTYPE CShellBrowser::FindWindowByIndex(DWORD dwID, IUnknown **ppunk)
2848 {
2849 return E_NOTIMPL;
2850 }
2851
2852 HRESULT STDMETHODCALLTYPE CShellBrowser::GetWindowData(IStream *pStream, LPWINDOWDATA pWinData)
2853 {
2854 if (pWinData == NULL)
2855 return E_POINTER;
2856
2857 pWinData->dwWindowID = -1;
2858 pWinData->uiCP = 0;
2859 pWinData->pidl = ILClone(fCurrentDirectoryPIDL);
2860 pWinData->lpszUrl = NULL;
2861 pWinData->lpszUrlLocation = NULL;
2862 pWinData->lpszTitle = NULL;
2863 return S_OK;
2864 }
2865
2866 HRESULT STDMETHODCALLTYPE CShellBrowser::LoadHistoryPosition(LPWSTR pszUrlLocation, DWORD dwPosition)
2867 {
2868 return E_NOTIMPL;
2869 }
2870
2871 HRESULT STDMETHODCALLTYPE CShellBrowser::GetClassID(CLSID *pClassID)
2872 {
2873 return E_NOTIMPL;
2874 }
2875
2876 HRESULT STDMETHODCALLTYPE CShellBrowser::LoadHistory(IStream *pStream, IBindCtx *pbc)
2877 {
2878 CComPtr<IPersistHistory> viewPersistHistory;
2879 CComPtr<IOleObject> viewHistoryObject;
2880 persistState oldState;
2881 ULONG numRead;
2882 LPITEMIDLIST pidl;
2883 HRESULT hResult;
2884
2885 hResult = pStream->Read(&oldState, sizeof(oldState), &numRead);
2886 if (FAILED(hResult))
2887 return hResult;
2888 if (numRead != sizeof(oldState) || oldState.dwSize != sizeof(oldState))
2889 return E_FAIL;
2890 if (oldState.browseType != 2)
2891 return E_FAIL;
2892 pidl = static_cast<LPITEMIDLIST>(CoTaskMemAlloc(oldState.pidlSize));
2893 if (pidl == NULL)
2894 return E_OUTOFMEMORY;
2895 hResult = pStream->Read(pidl, oldState.pidlSize, &numRead);
2896 if (FAILED(hResult))
2897 {
2898 ILFree(pidl);
2899 return hResult;
2900 }
2901 if (numRead != oldState.pidlSize)
2902 {
2903 ILFree(pidl);
2904 return E_FAIL;
2905 }
2906 hResult = CoCreateInstance(oldState.persistClass, NULL, CLSCTX_LOCAL_SERVER | CLSCTX_INPROC_SERVER,
2907 IID_PPV_ARG(IOleObject, &viewHistoryObject));
2908 fHistoryObject = viewHistoryObject;
2909 fHistoryStream = pStream;
2910 fHistoryBindContext = pbc;
2911 hResult = BrowseToPIDL(pidl, BTP_UPDATE_CUR_HISTORY);
2912 fHistoryObject = NULL;
2913 fHistoryStream = NULL;
2914 fHistoryBindContext = NULL;
2915 ILFree(pidl);
2916 if (FAILED(hResult))
2917 return hResult;
2918 return S_OK;
2919 }
2920
2921 HRESULT STDMETHODCALLTYPE CShellBrowser::SaveHistory(IStream *pStream)
2922 {
2923 CComPtr<IPersistHistory> viewPersistHistory;
2924 persistState newState;
2925 HRESULT hResult;
2926
2927 hResult = fCurrentShellView->GetItemObject(
2928 SVGIO_BACKGROUND, IID_PPV_ARG(IPersistHistory, &viewPersistHistory));
2929 memset(&newState, 0, sizeof(newState));
2930 newState.dwSize = sizeof(newState);
2931 newState.browseType = 2;
2932 newState.browserIndex = GetBrowserIndex();
2933 if (viewPersistHistory.p != NULL)
2934 {
2935 hResult = viewPersistHistory->GetClassID(&newState.persistClass);
2936 if (FAILED(hResult))
2937 return hResult;
2938 }
2939 newState.pidlSize = ILGetSize(fCurrentDirectoryPIDL);
2940 hResult = pStream->Write(&newState, sizeof(newState), NULL);
2941 if (FAILED(hResult))
2942 return hResult;
2943 hResult = pStream->Write(fCurrentDirectoryPIDL, newState.pidlSize, NULL);
2944 if (FAILED(hResult))
2945 return hResult;
2946 if (viewPersistHistory.p != NULL)
2947 {
2948 hResult = viewPersistHistory->SaveHistory(pStream);
2949 if (FAILED(hResult))
2950 return hResult;
2951 }
2952 return S_OK;
2953 }
2954
2955 HRESULT STDMETHODCALLTYPE CShellBrowser::SetPositionCookie(DWORD dwPositioncookie)
2956 {
2957 return E_NOTIMPL;
2958 }
2959
2960 HRESULT STDMETHODCALLTYPE CShellBrowser::GetPositionCookie(DWORD *pdwPositioncookie)
2961 {
2962 return E_NOTIMPL;
2963 }
2964
2965 LRESULT CShellBrowser::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
2966 {
2967 // TODO: rip down everything
2968 PostQuitMessage(0);
2969 return 0;
2970 }
2971
2972 LRESULT CShellBrowser::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
2973 {
2974 CComPtr<IDockingWindow> dockingWindow;
2975 RECT availableBounds;
2976 static const INT excludeItems[] = {1, 1, 1, 0xa001, 0, 0};
2977 HRESULT hResult;
2978
2979 if (wParam != SIZE_MINIMIZED)
2980 {
2981 GetEffectiveClientRect(m_hWnd, &availableBounds, excludeItems);
2982 for (INT x = 0; x < 3; x++)
2983 {
2984 if (fClientBars[x].clientBar != NULL)
2985 {
2986 hResult = fClientBars[x].clientBar->QueryInterface(
2987 IID_PPV_ARG(IDockingWindow, &dockingWindow));
2988 if (SUCCEEDED(hResult) && dockingWindow != NULL)
2989 {
2990 hResult = dockingWindow->ResizeBorderDW(
2991 &availableBounds, static_cast<IDropTarget *>(this), TRUE);
2992 break;
2993 }
2994 }
2995 }
2996 RepositionBars();
2997 }
2998 return 1;
2999 }
3000
3001 LRESULT CShellBrowser::OnInitMenuPopup(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3002 {
3003 HMENU theMenu;
3004
3005 theMenu = reinterpret_cast<HMENU>(wParam);
3006 if (theMenu == SHGetMenuFromID(fCurrentMenuBar, FCIDM_MENU_VIEW))
3007 UpdateViewMenu(theMenu);
3008 return RelayMsgToShellView(uMsg, wParam, lParam, bHandled);
3009 }
3010
3011 LRESULT CShellBrowser::RelayMsgToShellView(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3012 {
3013 if (fCurrentShellViewWindow != NULL)
3014 return SendMessage(fCurrentShellViewWindow, uMsg, wParam, lParam);
3015 return 0;
3016 }
3017
3018 LRESULT CShellBrowser::OnClose(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3019 {
3020 return 0;
3021 }
3022
3023 LRESULT CShellBrowser::OnFolderOptions(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3024 {
3025 HRESULT hResult;
3026
3027 hResult = DoFolderOptions();
3028 return 0;
3029 }
3030
3031 LRESULT CShellBrowser::OnMapNetworkDrive(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3032 {
3033 #ifndef __REACTOS__
3034 WNetConnectionDialog(m_hWnd, RESOURCETYPE_DISK);
3035 #endif /* __REACTOS__ */
3036 return 0;
3037 }
3038
3039 LRESULT CShellBrowser::OnDisconnectNetworkDrive(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3040 {
3041 #ifndef __REACTOS__
3042 WNetDisconnectDialog(m_hWnd, RESOURCETYPE_DISK);
3043 #endif /* __REACTOS__ */
3044 return 0;
3045 }
3046
3047 LRESULT CShellBrowser::OnAboutReactOS(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3048 {
3049 ShellAbout(m_hWnd, _T("ReactOS"), _T(""), NULL);
3050 return 0;
3051 }
3052
3053 LRESULT CShellBrowser::OnGoBack(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3054 {
3055 HRESULT hResult;
3056
3057 hResult = GoBack();
3058 return 0;
3059 }
3060
3061 LRESULT CShellBrowser::OnGoForward(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3062 {
3063 HRESULT hResult;
3064
3065 hResult = GoForward();
3066 return 0;
3067 }
3068
3069 LRESULT CShellBrowser::OnGoUpLevel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3070 {
3071 HRESULT hResult;
3072
3073 hResult = NavigateToParent();
3074 return 0;
3075 }
3076
3077 LRESULT CShellBrowser::OnGoHome(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3078 {
3079 HRESULT hResult;
3080
3081 hResult = GoHome();
3082 return 0;
3083 }
3084
3085 LRESULT CShellBrowser::OnIsThisLegal(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3086 {
3087 HRESULT hResult;
3088
3089 typedef HRESULT (WINAPI *PSHOpenNewFrame)(LPITEMIDLIST pidl, IUnknown *b, long c, long d);
3090 PSHOpenNewFrame Func;
3091 HMODULE hShlwapi;
3092
3093 hShlwapi = LoadLibrary(TEXT("browseui.dll"));
3094 if (hShlwapi != NULL)
3095 Func = reinterpret_cast<PSHOpenNewFrame>(GetProcAddress(hShlwapi, (LPCSTR)103));
3096 else
3097 Func = NULL;
3098 if (Func != NULL)
3099 {
3100 LPITEMIDLIST desktopPIDL;
3101
3102 hResult = SHGetFolderLocation(NULL, CSIDL_DESKTOP, NULL, 0, &desktopPIDL);
3103 if (SUCCEEDED(hResult))
3104 {
3105 hResult = Func(desktopPIDL, NULL, -1, 1);
3106 }
3107 }
3108 return 0;
3109 }
3110
3111 LRESULT CShellBrowser::OnToggleStatusBarVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3112 {
3113 fStatusBarVisible = !fStatusBarVisible;
3114 // TODO: trigger a relayout of contained items
3115 return 0;
3116 }
3117
3118 LRESULT CShellBrowser::OnToggleToolbarLock(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3119 {
3120 CComPtr<IOleCommandTarget> commandTarget;
3121 HRESULT hResult;
3122
3123 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3124 IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3125 if (FAILED(hResult))
3126 return 0;
3127 hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_TOOLBARLOCKED, 0, NULL, NULL);
3128 return 0;
3129 }
3130
3131 LRESULT CShellBrowser::OnToggleToolbarBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3132 {
3133 CComPtr<IOleCommandTarget> commandTarget;
3134 HRESULT hResult;
3135
3136 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3137 IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3138 if (FAILED(hResult))
3139 return 0;
3140 hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_TOOLBARBANDSHOWN, 0, NULL, NULL);
3141 return 0;
3142 }
3143
3144 LRESULT CShellBrowser::OnToggleAddressBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3145 {
3146 CComPtr<IOleCommandTarget> commandTarget;
3147 HRESULT hResult;
3148
3149 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3150 IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3151 if (FAILED(hResult))
3152 return 0;
3153 hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_ADDRESSBANDSHOWN, 0, NULL, NULL);
3154 return 0;
3155 }
3156
3157 LRESULT CShellBrowser::OnToggleLinksBandVisible(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3158 {
3159 CComPtr<IOleCommandTarget> commandTarget;
3160 HRESULT hResult;
3161
3162 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3163 IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3164 if (FAILED(hResult))
3165 return 0;
3166 hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_LINKSBANDSHOWN, 0, NULL, NULL);
3167 return 0;
3168 }
3169
3170 LRESULT CShellBrowser::OnToggleTextLabels(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3171 {
3172 CComPtr<IOleCommandTarget> commandTarget;
3173 HRESULT hResult;
3174
3175 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3176 IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3177 if (FAILED(hResult))
3178 return 0;
3179 hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_TEXTLABELS, 0, NULL, NULL);
3180 return 0;
3181 }
3182
3183 LRESULT CShellBrowser::OnToolbarCustomize(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3184 {
3185 CComPtr<IOleCommandTarget> commandTarget;
3186 HRESULT hResult;
3187
3188 hResult = fClientBars[BIInternetToolbar].clientBar->QueryInterface(
3189 IID_PPV_ARG(IOleCommandTarget, &commandTarget));
3190 if (FAILED(hResult))
3191 return 0;
3192 hResult = commandTarget->Exec(&CGID_PrivCITCommands, ITID_CUSTOMIZEENABLED, 0, NULL, NULL);
3193 return 0;
3194 }
3195
3196 LRESULT CShellBrowser::OnGoTravel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL &bHandled)
3197 {
3198 return 0;
3199 }
3200
3201 LRESULT CShellBrowser::RelayCommands(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
3202 {
3203 if (HIWORD(wParam) == 0 && LOWORD(wParam) < FCIDM_SHVIEWLAST && fCurrentShellViewWindow != NULL)
3204 return SendMessage(fCurrentShellViewWindow, uMsg, wParam, lParam);
3205 return 0;
3206 }
3207
3208 //static LRESULT CALLBACK ExplorerWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
3209 //{
3210 // return DefWindowProc(hwnd, uMsg, wParam, lParam);
3211 //}
3212
3213 static void ExplorerMessageLoop()
3214 {
3215 MSG Msg;
3216 BOOL Ret;
3217
3218 while (1)
3219 {
3220 Ret = (GetMessage(&Msg, NULL, 0, 0) != 0);
3221
3222 if (Ret != -1)
3223 {
3224 if (!Ret)
3225 break;
3226
3227 TranslateMessage(&Msg);
3228 DispatchMessage(&Msg);
3229
3230 if (Msg.message == WM_QUIT)
3231 break;
3232 }
3233 }
3234 }
3235
3236 DWORD WINAPI BrowserThreadProc(LPVOID lpThreadParameter)
3237 {
3238 CComPtr<IShellBrowser> shellBrowser;
3239 CComObject<CShellBrowser> *theCabinet;
3240 IEThreadParamBlock *parameters;
3241 HRESULT hResult;
3242
3243 parameters = (IEThreadParamBlock *)lpThreadParameter;
3244 OleInitialize(NULL);
3245 ATLTRY (theCabinet = new CComObject<CShellBrowser>);
3246 if (theCabinet == NULL)
3247 return E_OUTOFMEMORY;
3248 hResult = theCabinet->QueryInterface(IID_PPV_ARG(IShellBrowser, &shellBrowser));
3249 if (FAILED(hResult))
3250 {
3251 delete theCabinet;
3252 return hResult;
3253 }
3254 hResult = theCabinet->Initialize(parameters->directoryPIDL, 0, 0, 0);
3255 if (FAILED(hResult))
3256 return hResult;
3257 ExplorerMessageLoop();
3258 OleUninitialize();
3259 return 0;
3260 }
A free Windows-compatible Operating System