projects / reactos.git / blob
? search:


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