[EXPLORER] Remove SetBandSiteInfo hack. CORE-9809
[reactos.git] / base / shell / explorer / tbsite.cpp
1 /*
2 * ReactOS Explorer
3 *
4 * Copyright 2006 - 2007 Thomas Weidenmueller <w3seek@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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include "precomp.h"
22
23 #include <shdeprecated.h>
24
25 /*****************************************************************************
26 ** ITrayBandSite ************************************************************
27 *****************************************************************************/
28
29 // WARNING: Can't use ATL for this class due to our ATL not fully supporting the AGGREGATION functions needed for this class to be an "outer" class
30 // it works just fine this way.
31 class CTrayBandSite :
32 public ITrayBandSite,
33 public IBandSite,
34 public IBandSiteStreamCallback
35 /* TODO: IWinEventHandler */
36 {
37 volatile LONG m_RefCount;
38
39 CComPtr<ITrayWindow> m_Tray;
40
41 CComPtr<IUnknown> m_Inner;
42 CComPtr<IBandSite> m_BandSite;
43 CComPtr<IDeskBand> m_TaskBand;
44 CComPtr<IWinEventHandler> m_WindowEventHandler;
45 CComPtr<IContextMenu> m_ContextMenu;
46
47 HWND m_Rebar;
48
49 union
50 {
51 DWORD dwFlags;
52 struct
53 {
54 DWORD Locked : 1;
55 };
56 };
57
58 public:
59
60 virtual ULONG STDMETHODCALLTYPE AddRef()
61 {
62 return InterlockedIncrement(&m_RefCount);
63 }
64
65 virtual ULONG STDMETHODCALLTYPE Release()
66 {
67 ULONG Ret = InterlockedDecrement(&m_RefCount);
68
69 if (Ret == 0)
70 delete this;
71
72 return Ret;
73 }
74
75 virtual HRESULT STDMETHODCALLTYPE QueryInterface(IN REFIID riid, OUT LPVOID *ppvObj)
76 {
77 if (ppvObj == NULL)
78 return E_POINTER;
79
80 if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IBandSiteHelper))
81 {
82 // return IBandSiteStreamCallback's IUnknown
83 *ppvObj = static_cast<IBandSiteStreamCallback*>(this);
84 }
85 else if (IsEqualIID(riid, IID_IBandSite))
86 {
87 *ppvObj = static_cast<IBandSite*>(this);
88 }
89 else if (IsEqualIID(riid, IID_IWinEventHandler))
90 {
91 TRACE("ITaskBandSite: IWinEventHandler queried!\n");
92 *ppvObj = NULL;
93 return E_NOINTERFACE;
94 }
95 else if (m_Inner != NULL)
96 {
97 return m_Inner->QueryInterface(riid, ppvObj);
98 }
99 else
100 {
101 *ppvObj = NULL;
102 return E_NOINTERFACE;
103 }
104
105 AddRef();
106 return S_OK;
107 }
108
109 public:
110 CTrayBandSite() :
111 m_RefCount(0),
112 m_Rebar(NULL)
113 {
114 }
115
116 virtual ~CTrayBandSite() { }
117
118 virtual HRESULT STDMETHODCALLTYPE OnLoad(
119 IN OUT IStream *pStm,
120 IN REFIID riid,
121 OUT PVOID *pvObj)
122 {
123 LARGE_INTEGER liPosZero;
124 ULARGE_INTEGER liCurrent;
125 CLSID clsid;
126 ULONG ulRead;
127 HRESULT hRet;
128
129 /* NOTE: Callback routine called by the shell while loading the task band
130 stream. We use it to intercept the default behavior when the task
131 band is loaded from the stream.
132
133 NOTE: riid always points to IID_IUnknown! This is because the shell hasn't
134 read anything from the stream and therefore doesn't know what CLSID
135 it's dealing with. We'll have to find it out ourselves by reading
136 the GUID from the stream. */
137
138 /* Read the current position of the stream, we'll have to reset it everytime
139 we read a CLSID that's not the task band... */
140 ZeroMemory(&liPosZero, sizeof(liPosZero));
141 hRet = pStm->Seek(liPosZero, STREAM_SEEK_CUR, &liCurrent);
142
143 if (SUCCEEDED(hRet))
144 {
145 /* Now let's read the CLSID from the stream and see if it's our task band */
146 hRet = pStm->Read(&clsid, (ULONG)sizeof(clsid), &ulRead);
147
148 if (SUCCEEDED(hRet) && ulRead == sizeof(clsid))
149 {
150 if (IsEqualGUID(clsid, CLSID_ITaskBand))
151 {
152 ASSERT(m_TaskBand != NULL);
153 /* We're trying to load the task band! Let's create it... */
154
155 hRet = m_TaskBand->QueryInterface(
156 riid,
157 pvObj);
158 if (SUCCEEDED(hRet))
159 {
160 /* Load the stream */
161 TRACE("IBandSiteStreamCallback::OnLoad intercepted the task band CLSID!\n");
162 }
163
164 return hRet;
165 }
166 }
167 }
168
169 /* Reset the position and let the shell do all the work for us */
170 hRet = pStm->Seek(
171 *(LARGE_INTEGER*) &liCurrent,
172 STREAM_SEEK_SET,
173 NULL);
174 if (SUCCEEDED(hRet))
175 {
176 /* Let the shell handle everything else for us :) */
177 hRet = OleLoadFromStream(pStm,
178 riid,
179 pvObj);
180 }
181
182 if (!SUCCEEDED(hRet))
183 {
184 TRACE("IBandSiteStreamCallback::OnLoad(0x%p, 0x%p, 0x%p) returns 0x%x\n", pStm, riid, pvObj, hRet);
185 }
186
187 return hRet;
188 }
189
190 virtual HRESULT STDMETHODCALLTYPE OnSave(
191 IN OUT IUnknown *pUnk,
192 IN OUT IStream *pStm)
193 {
194 /* NOTE: Callback routine called by the shell while saving the task band
195 stream. We use it to intercept the default behavior when the task
196 band is saved to the stream */
197 /* FIXME: Implement */
198 TRACE("IBandSiteStreamCallback::OnSave(0x%p, 0x%p) returns E_NOTIMPL\n", pUnk, pStm);
199 return E_NOTIMPL;
200 }
201
202 virtual HRESULT STDMETHODCALLTYPE IsTaskBand(IN IUnknown *punk)
203 {
204 return IsSameObject(m_BandSite, punk);
205 }
206
207 virtual HRESULT STDMETHODCALLTYPE ProcessMessage(
208 IN HWND hWnd,
209 IN UINT uMsg,
210 IN WPARAM wParam,
211 IN LPARAM lParam,
212 OUT LRESULT *plResult)
213 {
214 HRESULT hRet;
215
216 ASSERT(m_Rebar != NULL);
217
218 /* Custom task band behavior */
219 switch (uMsg)
220 {
221 case WM_NOTIFY:
222 {
223 const NMHDR *nmh = (const NMHDR *) lParam;
224
225 if (nmh->hwndFrom == m_Rebar)
226 {
227 switch (nmh->code)
228 {
229 case NM_NCHITTEST:
230 {
231 LPNMMOUSE nmm = (LPNMMOUSE) lParam;
232
233 if (nmm->dwHitInfo == RBHT_CLIENT || nmm->dwHitInfo == RBHT_NOWHERE ||
234 nmm->dwItemSpec == (DWORD_PTR) -1)
235 {
236 /* Make the rebar control appear transparent so the user
237 can drag the tray window */
238 *plResult = HTTRANSPARENT;
239 }
240 return S_OK;
241 }
242
243 case RBN_MINMAX:
244 /* Deny if an Administrator disabled this "feature" */
245 *plResult = (SHRestricted(REST_NOMOVINGBAND) != 0);
246 return S_OK;
247 }
248 }
249
250 //TRACE("ITrayBandSite::ProcessMessage: WM_NOTIFY for 0x%p, From: 0x%p, Code: NM_FIRST-%u...\n", hWnd, nmh->hwndFrom, NM_FIRST - nmh->code);
251 break;
252 }
253 }
254
255 /* Forward to the shell's IWinEventHandler interface to get the default shell behavior! */
256 if (!m_WindowEventHandler)
257 return E_FAIL;
258
259 /*TRACE("Calling IWinEventHandler::ProcessMessage(0x%p, 0x%x, 0x%p, 0x%p, 0x%p) hWndRebar=0x%p\n", hWnd, uMsg, wParam, lParam, plResult, hWndRebar);*/
260 hRet = m_WindowEventHandler->OnWinEvent(hWnd, uMsg, wParam, lParam, plResult);
261
262 #if 0
263 if (FAILED(hRet))
264 {
265 if (uMsg == WM_NOTIFY)
266 {
267 const NMHDR *nmh = (const NMHDR *) lParam;
268 ERR("ITrayBandSite->IWinEventHandler::ProcessMessage: WM_NOTIFY for 0x%p, From: 0x%p, Code: NM_FIRST-%u returned 0x%x\n", hWnd, nmh->hwndFrom, NM_FIRST - nmh->code, hRet);
269 }
270 else
271 {
272 ERR("ITrayBandSite->IWinEventHandler::ProcessMessage(0x%p,0x%x,0x%p,0x%p,0x%p->0x%p) returned: 0x%x\n", hWnd, uMsg, wParam, lParam, plResult, *plResult, hRet);
273 }
274 }
275 #endif
276
277 return hRet;
278 }
279
280 virtual HRESULT STDMETHODCALLTYPE AddContextMenus(
281 IN HMENU hmenu,
282 IN UINT indexMenu,
283 IN UINT idCmdFirst,
284 IN UINT idCmdLast,
285 IN UINT uFlags,
286 OUT IContextMenu **ppcm)
287 {
288 HRESULT hRet;
289
290 if (m_ContextMenu == NULL)
291 {
292 /* Cache the context menu so we don't need to CoCreateInstance all the time... */
293 hRet = _CBandSiteMenu_CreateInstance(IID_PPV_ARG(IContextMenu, &m_ContextMenu));
294 if (FAILED_UNEXPECTEDLY(hRet))
295 return hRet;
296
297 hRet = IUnknown_SetOwner(m_ContextMenu, (IBandSite*)this);
298 if (FAILED_UNEXPECTEDLY(hRet))
299 return hRet;
300 }
301
302 if (ppcm != NULL)
303 {
304 m_ContextMenu->AddRef();
305 *ppcm = m_ContextMenu;
306 }
307
308 /* Add the menu items */
309 hRet = m_ContextMenu->QueryContextMenu(hmenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
310 if (FAILED_UNEXPECTEDLY(hRet))
311 return hRet;
312
313 return S_OK;
314 }
315
316 virtual HRESULT STDMETHODCALLTYPE Lock(IN BOOL bLock)
317 {
318 BOOL bPrevLocked = Locked;
319 BANDSITEINFO bsi;
320 HRESULT hRet;
321
322 ASSERT(m_BandSite != NULL);
323
324 if (bPrevLocked != bLock)
325 {
326 Locked = bLock;
327
328 bsi.dwMask = BSIM_STYLE;
329 bsi.dwStyle = (Locked ? BSIS_LOCKED | BSIS_NOGRIPPER : BSIS_AUTOGRIPPER);
330
331 hRet = m_BandSite->SetBandSiteInfo(&bsi);
332 if (SUCCEEDED(hRet))
333 {
334 hRet = Update();
335 }
336
337 return hRet;
338 }
339
340 return S_FALSE;
341 }
342
343 /*******************************************************************/
344
345 virtual HRESULT STDMETHODCALLTYPE AddBand(IN IUnknown *punk)
346 {
347 /* Send the DBID_DELAYINIT command to initialize the band to be added */
348 /* FIXME: Should be delayed */
349 IUnknown_Exec(punk, IID_IDeskBand, DBID_DELAYINIT, 0, NULL, NULL);
350
351 HRESULT hr = m_BandSite->AddBand(punk);
352 if (FAILED_UNEXPECTEDLY(hr))
353 return hr;
354
355 VARIANT vThemeName;
356 V_VT(&vThemeName) = VT_BSTR;
357 V_BSTR(&vThemeName) = SysAllocString(L"TaskBar");
358 IUnknown_Exec(punk,
359 IID_IDeskBand,
360 DBID_SETWINDOWTHEME,
361 0,
362 &vThemeName,
363 NULL);
364
365 SysFreeString(V_BSTR(&vThemeName));
366
367 return S_OK;
368 }
369
370 virtual HRESULT STDMETHODCALLTYPE EnumBands(
371 IN UINT uBand,
372 OUT DWORD *pdwBandID)
373 {
374 return m_BandSite->EnumBands(uBand, pdwBandID);
375 }
376
377 virtual HRESULT STDMETHODCALLTYPE QueryBand(
378 IN DWORD dwBandID,
379 OUT IDeskBand **ppstb,
380 OUT DWORD *pdwState,
381 OUT LPWSTR pszName,
382 IN int cchName)
383 {
384 HRESULT hRet;
385 IDeskBand *pstb = NULL;
386
387 hRet = m_BandSite->QueryBand(
388 dwBandID,
389 &pstb,
390 pdwState,
391 pszName,
392 cchName);
393
394 if (SUCCEEDED(hRet))
395 {
396 hRet = IsSameObject(pstb, m_TaskBand);
397 if (hRet == S_OK)
398 {
399 /* Add the BSSF_UNDELETEABLE flag to pdwState because the task bar band shouldn't be deletable */
400 if (pdwState != NULL)
401 *pdwState |= BSSF_UNDELETEABLE;
402 }
403 else if (!SUCCEEDED(hRet))
404 {
405 pstb->Release();
406 pstb = NULL;
407 }
408
409 if (ppstb != NULL)
410 *ppstb = pstb;
411 }
412 else if (ppstb != NULL)
413 *ppstb = NULL;
414
415 return hRet;
416 }
417
418 virtual HRESULT STDMETHODCALLTYPE SetBandState(
419 IN DWORD dwBandID,
420 IN DWORD dwMask,
421 IN DWORD dwState)
422 {
423 return m_BandSite->SetBandState(dwBandID, dwMask, dwState);
424 }
425
426 virtual HRESULT STDMETHODCALLTYPE RemoveBand(
427 IN DWORD dwBandID)
428 {
429 return m_BandSite->RemoveBand(dwBandID);
430 }
431
432 virtual HRESULT STDMETHODCALLTYPE GetBandObject(
433 IN DWORD dwBandID,
434 IN REFIID riid,
435 OUT VOID **ppv)
436 {
437 return m_BandSite->GetBandObject(dwBandID, riid, ppv);
438 }
439
440 virtual HRESULT STDMETHODCALLTYPE SetBandSiteInfo(
441 IN const BANDSITEINFO *pbsinfo)
442 {
443 return m_BandSite->SetBandSiteInfo(pbsinfo);
444 }
445
446 virtual HRESULT STDMETHODCALLTYPE GetBandSiteInfo(
447 IN OUT BANDSITEINFO *pbsinfo)
448 {
449 return m_BandSite->GetBandSiteInfo(pbsinfo);
450 }
451
452 virtual BOOL HasTaskBand()
453 {
454 CComPtr<IPersist> pBand;
455 CLSID BandCLSID;
456 DWORD dwBandID;
457 UINT uBand = 0;
458
459 /* Enumerate all bands */
460 while (SUCCEEDED(m_BandSite->EnumBands(uBand, &dwBandID)))
461 {
462 if (SUCCEEDED(m_BandSite->GetBandObject(dwBandID, IID_PPV_ARG(IPersist, &pBand))))
463 {
464 if (SUCCEEDED(pBand->GetClassID(&BandCLSID)))
465 {
466 if (IsEqualGUID(BandCLSID, CLSID_ITaskBand))
467 {
468 return TRUE;
469 }
470 }
471 }
472 uBand++;
473 }
474
475 return FALSE;
476 }
477
478 virtual HRESULT Update()
479 {
480 return IUnknown_Exec(m_Inner,
481 IID_IDeskBand,
482 DBID_BANDINFOCHANGED,
483 0,
484 NULL,
485 NULL);
486 }
487
488 virtual VOID BroadcastOleCommandExec(REFGUID pguidCmdGroup,
489 DWORD nCmdID,
490 DWORD nCmdExecOpt,
491 VARIANTARG *pvaIn,
492 VARIANTARG *pvaOut)
493 {
494 IOleCommandTarget *pOct;
495 DWORD dwBandID;
496 UINT uBand = 0;
497
498 /* Enumerate all bands */
499 while (SUCCEEDED(m_BandSite->EnumBands(uBand, &dwBandID)))
500 {
501 if (SUCCEEDED(m_BandSite->GetBandObject(dwBandID, IID_PPV_ARG(IOleCommandTarget, &pOct))))
502 {
503 /* Execute the command */
504 pOct->Exec(
505 &pguidCmdGroup,
506 nCmdID,
507 nCmdExecOpt,
508 pvaIn,
509 pvaOut);
510
511 pOct->Release();
512 }
513
514 uBand++;
515 }
516 }
517
518 virtual HRESULT FinishInit()
519 {
520 /* Broadcast the DBID_FINISHINIT command */
521 BroadcastOleCommandExec(IID_IDeskBand, DBID_FINISHINIT, 0, NULL, NULL);
522
523 return S_OK;
524 }
525
526 virtual HRESULT Show(IN BOOL bShow)
527 {
528 CComPtr<IDeskBarClient> pDbc;
529 HRESULT hRet;
530
531 hRet = m_BandSite->QueryInterface(IID_PPV_ARG(IDeskBarClient, &pDbc));
532 if (SUCCEEDED(hRet))
533 {
534 hRet = pDbc->UIActivateDBC(bShow ? DBC_SHOW : DBC_HIDE);
535 }
536
537 return hRet;
538 }
539
540 virtual HRESULT LoadFromStream(IN OUT IStream *pStm)
541 {
542 CComPtr<IPersistStream> pPStm;
543 HRESULT hRet;
544
545 ASSERT(m_BandSite != NULL);
546
547 /* We implement the undocumented COM interface IBandSiteStreamCallback
548 that the shell will query so that we can intercept and custom-load
549 the task band when it finds the task band's CLSID (which is internal).
550 This way we can prevent the shell from attempting to CoCreateInstance
551 the (internal) task band, resulting in a failure... */
552 hRet = m_BandSite->QueryInterface(IID_PPV_ARG(IPersistStream, &pPStm));
553 if (SUCCEEDED(hRet))
554 {
555 hRet = pPStm->Load(pStm);
556 TRACE("->Load() returned 0x%x\n", hRet);
557 }
558
559 return hRet;
560 }
561
562 virtual IStream * GetUserBandsStream(IN DWORD grfMode)
563 {
564 HKEY hkStreams;
565 IStream *Stream = NULL;
566
567 if (RegCreateKeyW(hkExplorer,
568 L"Streams",
569 &hkStreams) == ERROR_SUCCESS)
570 {
571 Stream = SHOpenRegStreamW(hkStreams,
572 L"Desktop",
573 L"TaskbarWinXP",
574 grfMode);
575
576 RegCloseKey(hkStreams);
577 }
578
579 return Stream;
580 }
581
582 virtual IStream * GetDefaultBandsStream(IN DWORD grfMode)
583 {
584 HKEY hkStreams;
585 IStream *Stream = NULL;
586
587 if (RegCreateKeyW(HKEY_LOCAL_MACHINE,
588 L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Streams",
589 &hkStreams) == ERROR_SUCCESS)
590 {
591 Stream = SHOpenRegStreamW(hkStreams,
592 L"Desktop",
593 L"Default Taskbar",
594 grfMode);
595
596 RegCloseKey(hkStreams);
597 }
598
599 return Stream;
600 }
601
602 virtual HRESULT Load()
603 {
604 IStream *pStm;
605 HRESULT hRet;
606
607 /* Try to load the user's settings */
608 pStm = GetUserBandsStream(STGM_READ);
609 if (pStm != NULL)
610 {
611 hRet = LoadFromStream(pStm);
612
613 TRACE("Loaded user bands settings: 0x%x\n", hRet);
614 pStm->Release();
615 }
616 else
617 hRet = E_FAIL;
618
619 /* If the user's settings couldn't be loaded, try with
620 default settings (ie. when the user logs in for the
621 first time! */
622 if (!SUCCEEDED(hRet))
623 {
624 pStm = GetDefaultBandsStream(STGM_READ);
625 if (pStm != NULL)
626 {
627 hRet = LoadFromStream(pStm);
628
629 TRACE("Loaded default user bands settings: 0x%x\n", hRet);
630 pStm->Release();
631 }
632 else
633 hRet = E_FAIL;
634 }
635
636 return hRet;
637 }
638
639 HRESULT _Init(IN ITrayWindow *tray, IN IDeskBand* pTaskBand)
640 {
641 CComPtr<IDeskBarClient> pDbc;
642 CComPtr<IDeskBand> pDb;
643 CComPtr<IOleWindow> pOw;
644 HRESULT hRet;
645
646 m_Tray = tray;
647 m_TaskBand = pTaskBand;
648
649 /* Create the RebarBandSite */
650 hRet = _CBandSite_CreateInstance(static_cast<IBandSite*>(this), IID_PPV_ARG(IUnknown, &m_Inner));
651 if (FAILED_UNEXPECTEDLY(hRet))
652 return hRet;
653
654 hRet = m_Inner->QueryInterface(IID_PPV_ARG(IBandSite, &m_BandSite));
655 if (FAILED_UNEXPECTEDLY(hRet))
656 return hRet;
657
658 hRet = m_Inner->QueryInterface(IID_PPV_ARG(IWinEventHandler, &m_WindowEventHandler));
659 if (FAILED_UNEXPECTEDLY(hRet))
660 return hRet;
661
662 hRet = m_Inner->QueryInterface(IID_PPV_ARG(IDeskBarClient, &pDbc));
663 if (FAILED_UNEXPECTEDLY(hRet))
664 return hRet;
665
666
667
668
669 /* Crete the rebar in the tray */
670 hRet = pDbc->SetDeskBarSite(tray);
671 if (FAILED_UNEXPECTEDLY(hRet))
672 return hRet;
673
674 hRet = pDbc->GetWindow(&m_Rebar);
675 if (FAILED_UNEXPECTEDLY(hRet))
676 return hRet;
677
678 SetWindowStyle(m_Rebar, RBS_BANDBORDERS, 0);
679
680 /* Set the Desk Bar mode to the current one */
681 DWORD dwMode = 0;
682 /* FIXME: We need to set the mode (and update) whenever the user docks
683 the tray window to another monitor edge! */
684 if (!m_Tray->IsHorizontal())
685 dwMode = DBIF_VIEWMODE_VERTICAL;
686
687 hRet = pDbc->SetModeDBC(dwMode);
688
689 /* Load the saved state of the task band site */
690 /* FIXME: We should delay loading shell extensions, also see DBID_DELAYINIT */
691 Load();
692
693 /* Add the task bar band if it hasn't been added while loading */
694 if (!HasTaskBand())
695 {
696 hRet = m_BandSite->AddBand(m_TaskBand);
697 if (FAILED_UNEXPECTEDLY(hRet))
698 return hRet;
699 }
700
701 /* Should we send this after showing it? */
702 Update();
703
704 /* FIXME: When should we send this? Does anyone care anyway? */
705 FinishInit();
706
707 /* Activate the band site */
708 Show(TRUE);
709
710 return S_OK;
711 }
712 };
713 /*******************************************************************/
714
715 HRESULT CTrayBandSite_CreateInstance(IN ITrayWindow *tray, IN IDeskBand* pTaskBand, OUT ITrayBandSite** pBandSite)
716 {
717 HRESULT hr;
718
719 CTrayBandSite * tb = new CTrayBandSite();
720 if (!tb)
721 return E_FAIL;
722
723 tb->AddRef();
724
725 hr = tb->_Init(tray, pTaskBand);
726 if (FAILED_UNEXPECTEDLY(hr))
727 {
728 tb->Release();
729 return hr;
730 }
731
732 *pBandSite = tb;
733
734 return S_OK;
735 }