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