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