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