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