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