reactos/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         if (m_ContextMenu == NULL)
 289         {
 290             HRESULT hRet;
 291             CComPtr<IShellService> pSs;
 292
 293             /* Cache the context menu so we don't need to CoCreateInstance all the time... */
 294             hRet = CoCreateInstance(CLSID_BandSiteMenu, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IShellService, &pSs));
 295             TRACE("CoCreateInstance(CLSID_BandSiteMenu) for IShellService returned: 0x%x\n", hRet);
 296             if (!SUCCEEDED(hRet))
 297                 return hRet;
 298
 299             hRet = pSs->SetOwner((IBandSite*)this);
 300             if (!SUCCEEDED(hRet))
 301             {
 302                 return hRet;
 303             }
 304
 305             hRet = pSs->QueryInterface(IID_PPV_ARG(IContextMenu, &m_ContextMenu));
 306
 307             if (!SUCCEEDED(hRet))
 308                 return hRet;
 309         }
 310
 311         if (ppcm != NULL)
 312         {
 313             m_ContextMenu->AddRef();
 314             *ppcm = m_ContextMenu;
 315         }
 316
 317         /* Add the menu items */
 318         return m_ContextMenu->QueryContextMenu(hmenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
 319     }
 320
 321     virtual HRESULT STDMETHODCALLTYPE Lock(IN BOOL bLock)
 322     {
 323         BOOL bPrevLocked = Locked;
 324         BANDSITEINFO bsi;
 325         HRESULT hRet;
 326
 327         ASSERT(m_BandSite != NULL);
 328
 329         if (bPrevLocked != bLock)
 330         {
 331             Locked = bLock;
 332
 333             bsi.dwMask = BSIM_STYLE;
 334             bsi.dwStyle = (Locked ? BSIS_LOCKED | BSIS_NOGRIPPER : BSIS_AUTOGRIPPER);
 335
 336             hRet = m_BandSite->SetBandSiteInfo(&bsi);
 337
 338             /* HACK for CORE-9809 ! */
 339             if (hRet == E_NOTIMPL)
 340                 hRet = S_OK;
 341             else
 342                 ERR("HACK for CORE-9809 no longer needed!\n");
 343
 344             if (SUCCEEDED(hRet))
 345             {
 346                 hRet = Update();
 347             }
 348
 349             return hRet;
 350         }
 351
 352         return S_FALSE;
 353     }
 354
 355     /*******************************************************************/
 356
 357     virtual HRESULT STDMETHODCALLTYPE AddBand(IN IUnknown *punk)
 358     {
 359         /* Send the DBID_DELAYINIT command to initialize the band to be added */
 360         /* FIXME: Should be delayed */
 361         IUnknown_Exec(punk, IID_IDeskBand, DBID_DELAYINIT, 0, NULL, NULL);
 362
 363         return m_BandSite->AddBand(punk);
 364     }
 365
 366     virtual HRESULT STDMETHODCALLTYPE EnumBands(
 367         IN UINT uBand,
 368         OUT DWORD *pdwBandID)
 369     {
 370         return m_BandSite->EnumBands(uBand, pdwBandID);
 371     }
 372
 373     virtual HRESULT STDMETHODCALLTYPE QueryBand(
 374         IN DWORD dwBandID,
 375         OUT IDeskBand **ppstb,
 376         OUT DWORD *pdwState,
 377         OUT LPWSTR pszName,
 378         IN int cchName)
 379     {
 380         HRESULT hRet;
 381         IDeskBand *pstb = NULL;
 382
 383         hRet = m_BandSite->QueryBand(
 384             dwBandID,
 385             &pstb,
 386             pdwState,
 387             pszName,
 388             cchName);
 389
 390         if (SUCCEEDED(hRet))
 391         {
 392             hRet = IsSameObject(pstb, m_TaskBand);
 393             if (hRet == S_OK)
 394             {
 395                 /* Add the BSSF_UNDELETEABLE flag to pdwState because the task bar band shouldn't be deletable */
 396                 if (pdwState != NULL)
 397                     *pdwState |= BSSF_UNDELETEABLE;
 398             }
 399             else if (!SUCCEEDED(hRet))
 400             {
 401                 pstb->Release();
 402                 pstb = NULL;
 403             }
 404
 405             if (ppstb != NULL)
 406                 *ppstb = pstb;
 407         }
 408         else if (ppstb != NULL)
 409             *ppstb = NULL;
 410
 411         return hRet;
 412     }
 413
 414     virtual HRESULT STDMETHODCALLTYPE SetBandState(
 415         IN DWORD dwBandID,
 416         IN DWORD dwMask,
 417         IN DWORD dwState)
 418     {
 419         return m_BandSite->SetBandState(dwBandID, dwMask, dwState);
 420     }
 421
 422     virtual HRESULT STDMETHODCALLTYPE RemoveBand(
 423         IN DWORD dwBandID)
 424     {
 425         return m_BandSite->RemoveBand(dwBandID);
 426     }
 427
 428     virtual HRESULT STDMETHODCALLTYPE GetBandObject(
 429         IN DWORD dwBandID,
 430         IN REFIID riid,
 431         OUT VOID **ppv)
 432     {
 433         return m_BandSite->GetBandObject(dwBandID, riid, ppv);
 434     }
 435
 436     virtual HRESULT STDMETHODCALLTYPE SetBandSiteInfo(
 437         IN const BANDSITEINFO *pbsinfo)
 438     {
 439         return m_BandSite->SetBandSiteInfo(pbsinfo);
 440     }
 441
 442     virtual HRESULT STDMETHODCALLTYPE GetBandSiteInfo(
 443         IN OUT BANDSITEINFO *pbsinfo)
 444     {
 445         return m_BandSite->GetBandSiteInfo(pbsinfo);
 446     }
 447
 448     virtual BOOL HasTaskBand()
 449     {
 450         CComPtr<IPersist> pBand;
 451         CLSID BandCLSID;
 452         DWORD dwBandID;
 453         UINT uBand = 0;
 454
 455         /* Enumerate all bands */
 456         while (SUCCEEDED(m_BandSite->EnumBands(uBand, &dwBandID)))
 457         {
 458             if (SUCCEEDED(m_BandSite->GetBandObject(dwBandID, IID_PPV_ARG(IPersist, &pBand))))
 459             {
 460                 if (SUCCEEDED(pBand->GetClassID(&BandCLSID)))
 461                 {
 462                     if (IsEqualGUID(BandCLSID, CLSID_ITaskBand))
 463                     {
 464                         return TRUE;
 465                     }
 466                 }
 467             }
 468             uBand++;
 469         }
 470
 471         return FALSE;
 472     }
 473
 474     virtual HRESULT Update()
 475     {
 476         return IUnknown_Exec(m_Inner,
 477                 IID_IDeskBand,
 478                 DBID_BANDINFOCHANGED,
 479                 0,
 480                 NULL,
 481                 NULL);
 482     }
 483
 484     virtual VOID BroadcastOleCommandExec(REFGUID pguidCmdGroup,
 485         DWORD nCmdID,
 486         DWORD nCmdExecOpt,
 487         VARIANTARG *pvaIn,
 488         VARIANTARG *pvaOut)
 489     {
 490         IOleCommandTarget *pOct;
 491         DWORD dwBandID;
 492         UINT uBand = 0;
 493
 494         /* Enumerate all bands */
 495         while (SUCCEEDED(m_BandSite->EnumBands(uBand, &dwBandID)))
 496         {
 497             if (SUCCEEDED(m_BandSite->GetBandObject(dwBandID, IID_PPV_ARG(IOleCommandTarget, &pOct))))
 498             {
 499                 /* Execute the command */
 500                 pOct->Exec(
 501                     &pguidCmdGroup,
 502                     nCmdID,
 503                     nCmdExecOpt,
 504                     pvaIn,
 505                     pvaOut);
 506
 507                 pOct->Release();
 508             }
 509
 510             uBand++;
 511         }
 512     }
 513
 514     virtual HRESULT FinishInit()
 515     {
 516         /* Broadcast the DBID_FINISHINIT command */
 517         BroadcastOleCommandExec(IID_IDeskBand, DBID_FINISHINIT, 0, NULL, NULL);
 518
 519         return S_OK;
 520     }
 521
 522     virtual HRESULT Show(IN BOOL bShow)
 523     {
 524         CComPtr<IDeskBarClient> pDbc;
 525         HRESULT hRet;
 526
 527         hRet = m_BandSite->QueryInterface(IID_PPV_ARG(IDeskBarClient, &pDbc));
 528         if (SUCCEEDED(hRet))
 529         {
 530             hRet = pDbc->UIActivateDBC(bShow ? DBC_SHOW : DBC_HIDE);
 531         }
 532
 533         return hRet;
 534     }
 535
 536     virtual HRESULT LoadFromStream(IN OUT IStream *pStm)
 537     {
 538         CComPtr<IPersistStream> pPStm;
 539         HRESULT hRet;
 540
 541         ASSERT(m_BandSite != NULL);
 542
 543         /* We implement the undocumented COM interface IBandSiteStreamCallback
 544            that the shell will query so that we can intercept and custom-load
 545            the task band when it finds the task band's CLSID (which is internal).
 546            This way we can prevent the shell from attempting to CoCreateInstance
 547            the (internal) task band, resulting in a failure... */
 548         hRet = m_BandSite->QueryInterface(IID_PPV_ARG(IPersistStream, &pPStm));
 549         if (SUCCEEDED(hRet))
 550         {
 551             hRet = pPStm->Load(pStm);
 552             TRACE("->Load() returned 0x%x\n", hRet);
 553         }
 554
 555         return hRet;
 556     }
 557
 558     virtual IStream * GetUserBandsStream(IN DWORD grfMode)
 559     {
 560         HKEY hkStreams;
 561         IStream *Stream = NULL;
 562
 563         if (RegCreateKeyW(hkExplorer,
 564                           L"Streams",
 565                           &hkStreams) == ERROR_SUCCESS)
 566         {
 567             Stream = SHOpenRegStreamW(hkStreams,
 568                                       L"Desktop",
 569                                       L"TaskbarWinXP",
 570                                       grfMode);
 571
 572             RegCloseKey(hkStreams);
 573         }
 574
 575         return Stream;
 576     }
 577
 578     virtual IStream * GetDefaultBandsStream(IN DWORD grfMode)
 579     {
 580         HKEY hkStreams;
 581         IStream *Stream = NULL;
 582
 583         if (RegCreateKeyW(HKEY_LOCAL_MACHINE,
 584             L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Streams",
 585             &hkStreams) == ERROR_SUCCESS)
 586         {
 587             Stream = SHOpenRegStreamW(hkStreams,
 588                                       L"Desktop",
 589                                       L"Default Taskbar",
 590                                       grfMode);
 591
 592             RegCloseKey(hkStreams);
 593         }
 594
 595         return Stream;
 596     }
 597
 598     virtual HRESULT Load()
 599     {
 600         IStream *pStm;
 601         HRESULT hRet;
 602
 603         /* Try to load the user's settings */
 604         pStm = GetUserBandsStream(STGM_READ);
 605         if (pStm != NULL)
 606         {
 607             hRet = LoadFromStream(pStm);
 608
 609             TRACE("Loaded user bands settings: 0x%x\n", hRet);
 610             pStm->Release();
 611         }
 612         else
 613             hRet = E_FAIL;
 614
 615         /* If the user's settings couldn't be loaded, try with
 616            default settings (ie. when the user logs in for the
 617            first time! */
 618         if (!SUCCEEDED(hRet))
 619         {
 620             pStm = GetDefaultBandsStream(STGM_READ);
 621             if (pStm != NULL)
 622             {
 623                 hRet = LoadFromStream(pStm);
 624
 625                 TRACE("Loaded default user bands settings: 0x%x\n", hRet);
 626                 pStm->Release();
 627             }
 628             else
 629                 hRet = E_FAIL;
 630         }
 631
 632         return hRet;
 633     }
 634
 635     HRESULT _Init(IN ITrayWindow *tray, IN IDeskBand* pTaskBand)
 636     {
 637         CComPtr<IDeskBarClient> pDbc;
 638         CComPtr<IDeskBand> pDb;
 639         CComPtr<IOleWindow> pOw;
 640         HRESULT hRet;
 641
 642         m_Tray = tray;
 643         m_TaskBand = pTaskBand;
 644
 645         /* Create the RebarBandSite */
 646         hRet = CoCreateInstance(CLSID_RebarBandSite,
 647                                 static_cast<IBandSite*>(this),
 648                                 CLSCTX_INPROC_SERVER,
 649                                 IID_PPV_ARG(IUnknown, &m_Inner));
 650         if (FAILED_UNEXPECTEDLY(hRet))
 651             return hRet;
 652
 653         hRet = m_Inner->QueryInterface(IID_PPV_ARG(IBandSite, &m_BandSite));
 654         if (FAILED_UNEXPECTEDLY(hRet))
 655             return hRet;
 656
 657         hRet = m_Inner->QueryInterface(IID_PPV_ARG(IWinEventHandler, &m_WindowEventHandler));
 658         if (FAILED_UNEXPECTEDLY(hRet))
 659             return hRet;
 660
 661         hRet = m_Inner->QueryInterface(IID_PPV_ARG(IDeskBarClient, &pDbc));
 662         if (FAILED_UNEXPECTEDLY(hRet))
 663             return hRet;
 664
 665
 666
 667
 668         /* Crete the rebar in the tray */
 669         hRet = pDbc->SetDeskBarSite(tray);
 670         if (FAILED_UNEXPECTEDLY(hRet))
 671             return hRet;
 672
 673         hRet = pDbc->GetWindow(&m_Rebar);
 674         if (FAILED_UNEXPECTEDLY(hRet))
 675             return hRet;
 676
 677         SetWindowStyle(m_Rebar, RBS_BANDBORDERS, 0);
 678
 679         /* Set the Desk Bar mode to the current one */
 680         DWORD dwMode = 0;
 681         /* FIXME: We need to set the mode (and update) whenever the user docks
 682                   the tray window to another monitor edge! */
 683         if (!m_Tray->IsHorizontal())
 684             dwMode = DBIF_VIEWMODE_VERTICAL;
 685
 686         hRet = pDbc->SetModeDBC(dwMode);
 687
 688         /* Load the saved state of the task band site */
 689         /* FIXME: We should delay loading shell extensions, also see DBID_DELAYINIT */
 690         Load();
 691
 692         /* Add the task bar band if it hasn't been added while loading */
 693         if (!HasTaskBand())
 694         {
 695             hRet = m_BandSite->AddBand(m_TaskBand);
 696             if (FAILED_UNEXPECTEDLY(hRet))
 697                 return hRet;
 698         }
 699
 700         /* Should we send this after showing it? */
 701         Update();
 702
 703         /* FIXME: When should we send this? Does anyone care anyway? */
 704         FinishInit();
 705
 706         /* Activate the band site */
 707         Show(TRUE);
 708
 709         return S_OK;
 710     }
 711 };
 712 /*******************************************************************/
 713
 714 HRESULT CTrayBandSite_CreateInstance(IN ITrayWindow *tray, IN IDeskBand* pTaskBand, OUT ITrayBandSite** pBandSite)
 715 {
 716     HRESULT hr;
 717
 718     CTrayBandSite * tb = new CTrayBandSite();
 719     if (!tb)
 720         return E_FAIL;
 721
 722     tb->AddRef();
 723
 724     hr = tb->_Init(tray, pTaskBand);
 725     if (FAILED_UNEXPECTEDLY(hr))
 726     {
 727         tb->Release();
 728         return hr;
 729     }
 730
 731     *pBandSite = tb;
 732
 733     return S_OK;
 734 }