projects / reactos.git / blob
? search:


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