reactos/dll/win32/browseui/bandsite.cpp

   1 /*
   2  *      Rebar band site
   3  *
   4  *      Copyright 2007  Hervé Poussineau
   5  *      Copyright 2009  Andrew Hill
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "precomp.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(browseui);
  25
  26 #ifndef ASSERT
  27 #define ASSERT(cond) \
  28     if (!(cond)) \
  29         ERR ("ASSERTION %s AT %s:%d FAILED!\n", #cond, __FILE__, __LINE__)
  30 #endif
  31
  32 CBandSiteBase::CBandSiteBase()
  33 {
  34     fBandsCount = 0;
  35     fBandsAllocated = 0;
  36     fBands = NULL;
  37     fRebarWindow = NULL;
  38 }
  39
  40 UINT CBandSiteBase::GetBandID(struct BandObject *Band)
  41 {
  42     return (UINT)(Band - fBands);
  43 }
  44
  45 struct CBandSiteBase::BandObject *CBandSiteBase::GetBandByID(DWORD dwBandID)
  46 {
  47     if ((LONG)dwBandID >= fBandsAllocated)
  48         return NULL;
  49
  50     if (fBands[dwBandID].DeskBand == NULL)
  51         return NULL;
  52
  53     return &fBands[dwBandID];
  54 }
  55
  56 void CBandSiteBase::FreeBand(struct BandObject *Band)
  57 {
  58     ATLASSERT(Band->DeskBand != NULL);
  59     ATLASSERT(Band->OleWindow != NULL);
  60     ATLASSERT(Band->WndEvtHandler != NULL);
  61     Band->DeskBand->Release();
  62     Band->OleWindow->Release();
  63     Band->WndEvtHandler->Release();
  64     memset(Band, 0, sizeof(*Band));
  65     fBandsCount--;
  66 }
  67
  68 DWORD CBandSiteBase::GetBandSiteViewMode()
  69 {
  70     DWORD                                                                       dwStyle;
  71
  72     /* FIXME: What about DBIF_VIEWMODE_FLOATING and DBIF_VIEWMODE_TRANSPARENT? */
  73     dwStyle = GetWindowLongPtr(fRebarWindow, GWL_STYLE);
  74
  75     if (dwStyle & CCS_VERT)
  76         return DBIF_VIEWMODE_VERTICAL;
  77     else
  78         return DBIF_VIEWMODE_NORMAL;
  79 }
  80
  81 VOID CBandSiteBase::BuildRebarBandInfo(struct BandObject *Band, REBARBANDINFOW *prbi)
  82 {
  83     memset(prbi, 0, sizeof(*prbi));
  84     prbi->cbSize = sizeof(*prbi);
  85
  86     prbi->fMask = RBBIM_ID;
  87     prbi->wID = GetBandID(Band);
  88
  89     if (Band->dbi.dwMask & DBIM_MINSIZE)
  90     {
  91         prbi->fMask |= RBBIM_CHILDSIZE;
  92         prbi->cxMinChild = Band->dbi.ptMinSize.x;
  93         prbi->cyMinChild = Band->dbi.ptMinSize.y;
  94     }
  95
  96     if (Band->dbi.dwMask & DBIM_MAXSIZE)
  97     {
  98         prbi->fMask |= RBBIM_CHILDSIZE;
  99         prbi->cyMaxChild = Band->dbi.ptMaxSize.y;
 100     }
 101
 102     if ((Band->dbi.dwMask & (DBIM_INTEGRAL | DBIM_MODEFLAGS)) == (DBIM_INTEGRAL | DBIM_MODEFLAGS) &&
 103         (Band->dbi.dwModeFlags & DBIMF_VARIABLEHEIGHT))
 104     {
 105         prbi->fMask |= RBBIM_CHILDSIZE;
 106         prbi->cyIntegral = Band->dbi.ptIntegral.y;
 107     }
 108
 109     if (Band->dbi.dwMask & DBIM_ACTUAL)
 110     {
 111         prbi->fMask |= RBBIM_IDEALSIZE | RBBIM_SIZE | RBBIM_CHILDSIZE;
 112         prbi->cxIdeal = Band->dbi.ptActual.x;
 113         prbi->cx = Band->dbi.ptActual.x;
 114         prbi->cyChild = Band->dbi.ptActual.y;
 115     }
 116
 117     if (Band->dbi.dwMask & DBIM_TITLE)
 118     {
 119         prbi->fMask |= RBBIM_TEXT;
 120         prbi->lpText = Band->dbi.wszTitle;
 121         prbi->cch = wcslen(Band->dbi.wszTitle);
 122     }
 123
 124     if (Band->dbi.dwMask & DBIM_MODEFLAGS)
 125     {
 126         prbi->fMask |= RBBIM_STYLE;
 127
 128         if (Band->dbi.dwModeFlags & DBIMF_FIXED)
 129             prbi->fStyle |= RBBS_FIXEDSIZE | RBBS_NOGRIPPER;
 130         if (Band->dbi.dwModeFlags & DBIMF_FIXEDBMP)
 131             prbi->fStyle |= RBBS_FIXEDBMP;
 132         if (Band->dbi.dwModeFlags & DBIMF_VARIABLEHEIGHT)
 133             prbi->fStyle |= RBBS_VARIABLEHEIGHT;
 134         if (Band->dbi.dwModeFlags & DBIMF_DEBOSSED)
 135             prbi->fStyle |= RBBS_CHILDEDGE;
 136         if (Band->dbi.dwModeFlags & DBIMF_USECHEVRON)
 137             prbi->fStyle |= RBBS_USECHEVRON;
 138         if (Band->dbi.dwModeFlags & DBIMF_BREAK)
 139             prbi->fStyle |= RBBS_BREAK;
 140         if (Band->dbi.dwModeFlags & DBIMF_TOPALIGN)
 141             prbi->fStyle |= RBBS_TOPALIGN;
 142         if (Band->dbi.dwModeFlags & DBIMF_NOGRIPPER)
 143             prbi->fStyle |= RBBS_NOGRIPPER;
 144         if (Band->dbi.dwModeFlags & DBIMF_ALWAYSGRIPPER)
 145             prbi->fStyle |= RBBS_GRIPPERALWAYS;
 146     }
 147
 148     if ((Band->dbi.dwMask & (DBIM_BKCOLOR | DBIM_MODEFLAGS)) == (DBIM_BKCOLOR | DBIM_MODEFLAGS) &&
 149         (Band->dbi.dwModeFlags & DBIMF_BKCOLOR))
 150     {
 151         prbi->fMask |= RBBIM_COLORS;
 152         prbi->clrFore = (COLORREF)(COLOR_WINDOWTEXT + 1);
 153         prbi->clrBack = Band->dbi.crBkgnd;
 154     }
 155 }
 156
 157 HRESULT CBandSiteBase::UpdateSingleBand(struct BandObject *Band)
 158 {
 159     REBARBANDINFOW                                                      rbi;
 160     DWORD                                                                       dwViewMode;
 161     UINT                                                                        uBand;
 162     HRESULT                                                                     hRet;
 163
 164     memset(&Band->dbi, 0, sizeof(Band->dbi));
 165     Band->dbi.dwMask = DBIM_MINSIZE | DBIM_MAXSIZE | DBIM_INTEGRAL |
 166         DBIM_ACTUAL | DBIM_TITLE | DBIM_MODEFLAGS | DBIM_BKCOLOR;
 167
 168     dwViewMode = GetBandSiteViewMode();
 169
 170     hRet = Band->DeskBand->GetBandInfo((DWORD)GetBandID(Band), dwViewMode, &Band->dbi);
 171     if (SUCCEEDED(hRet))
 172     {
 173         BuildRebarBandInfo(Band, &rbi);
 174         if (SUCCEEDED(Band->OleWindow->GetWindow(&rbi.hwndChild)) &&
 175             rbi.hwndChild != NULL)
 176         {
 177             rbi.fMask |= RBBIM_CHILD;
 178             WARN ("ReBar band uses child window 0x%p\n", rbi.hwndChild);
 179         }
 180
 181         uBand = (UINT)SendMessageW(fRebarWindow, RB_IDTOINDEX, (WPARAM)rbi.wID, 0);
 182         if (uBand != (UINT)-1)
 183         {
 184             if (!SendMessageW(fRebarWindow, RB_SETBANDINFOW, (WPARAM)uBand, (LPARAM)&rbi))
 185             {
 186                 WARN("Failed to update the rebar band!\n");
 187             }
 188         }
 189         else
 190             WARN("Failed to map rebar band id to index!\n");
 191
 192     }
 193
 194     return hRet;
 195 }
 196
 197 HRESULT CBandSiteBase::UpdateAllBands()
 198 {
 199     LONG                                                                        i;
 200     HRESULT                                                                     hRet;
 201
 202     for (i = 0; i < fBandsAllocated; i++)
 203     {
 204         if (fBands[i].DeskBand != NULL)
 205         {
 206             hRet = UpdateSingleBand(&fBands[i]);
 207             if (!SUCCEEDED(hRet))
 208                 return hRet;
 209         }
 210     }
 211
 212     return S_OK;
 213 }
 214
 215 HRESULT CBandSiteBase::UpdateBand(DWORD dwBandID)
 216 {
 217     struct BandObject                                           *Band;
 218
 219     Band = GetBandByID(dwBandID);
 220     if (Band == NULL)
 221         return E_FAIL;
 222
 223     return UpdateSingleBand(Band);
 224 }
 225
 226 struct CBandSiteBase::BandObject *CBandSiteBase::GetBandFromHwnd(HWND hwnd)
 227 {
 228     HRESULT                                                                     hRet;
 229     HWND                                                                        hWndBand;
 230     LONG                                                                        i;
 231
 232     for (i = 0; i < fBandsAllocated; i++)
 233     {
 234         if (fBands[i].DeskBand != NULL)
 235         {
 236             ASSERT(fBands[i].OleWindow);
 237
 238             hWndBand = NULL;
 239             hRet = fBands[i].OleWindow->GetWindow(&hWndBand);
 240             if (SUCCEEDED(hRet) && hWndBand == hwnd)
 241                 return &fBands[i];
 242         }
 243     }
 244
 245     return NULL;
 246 }
 247
 248 CBandSiteBase::~CBandSiteBase()
 249 {
 250
 251     TRACE("destroying %p\n", this);
 252
 253     if (fRebarWindow != NULL)
 254     {
 255         DestroyWindow(fRebarWindow);
 256         fRebarWindow = NULL;
 257     }
 258
 259     if (fBands != NULL)
 260     {
 261         int i;
 262         for (i = 0; i < fBandsAllocated; i++)
 263         {
 264             if (fBands[i].DeskBand != NULL)
 265                 FreeBand(&fBands[i]);
 266         }
 267         CoTaskMemFree(fBands);
 268         fBands = NULL;
 269     }
 270 }
 271
 272 HRESULT STDMETHODCALLTYPE CBandSiteBase::AddBand(IUnknown *punk)
 273 {
 274     INT                                                                         i;
 275     LONG                                                                        NewAllocated;
 276     struct BandObject                                           *NewBand = NULL;
 277     CComPtr<IDeskBand>                                          DeskBand;
 278     CComPtr<IObjectWithSite>                            ObjWithSite;
 279     CComPtr<IOleWindow>                                         OleWindow;
 280     CComPtr<IWinEventHandler>                           WndEvtHandler;
 281     REBARBANDINFOW                                                      rbi;
 282     HRESULT                                                                     hRet;
 283     UINT                                                                        uBand;
 284
 285     TRACE("(%p, %p)\n", this, punk);
 286
 287     if (punk == NULL || fRebarWindow == NULL)
 288         return E_FAIL;
 289
 290     hRet = punk->QueryInterface(IID_IDeskBand, (PVOID *)&DeskBand);
 291     if (!SUCCEEDED(hRet) || DeskBand == NULL)
 292         goto Cleanup;
 293     hRet = punk->QueryInterface(IID_IObjectWithSite, (PVOID *)&ObjWithSite);
 294     if (!SUCCEEDED(hRet) || ObjWithSite == NULL)
 295         goto Cleanup;
 296     hRet = punk->QueryInterface(IID_IOleWindow, (PVOID *)&OleWindow);
 297     if (!SUCCEEDED(hRet) || OleWindow == NULL)
 298         goto Cleanup;
 299     hRet = punk->QueryInterface(IID_IWinEventHandler, (PVOID *)&WndEvtHandler);
 300     if (!SUCCEEDED(hRet) || WndEvtHandler == NULL)
 301         goto Cleanup;
 302
 303     hRet = S_OK;
 304     if (fBandsAllocated > fBandsCount)
 305     {
 306         /* Search for a free band object */
 307         for (i = 0; i < fBandsAllocated; i++)
 308         {
 309             if (fBands[i].DeskBand == NULL)
 310             {
 311                 NewBand = &fBands[i];
 312                 break;
 313             }
 314         }
 315     }
 316     else if (fBandsAllocated > 0)
 317     {
 318         ASSERT (fBands != NULL);
 319
 320         /* Reallocate the band object array */
 321         NewAllocated = fBandsAllocated + 8;
 322         if (NewAllocated > 0xFFFF)
 323             NewAllocated = 0xFFFF;
 324         if (NewAllocated == fBandsAllocated)
 325         {
 326             hRet = E_OUTOFMEMORY;
 327             goto Cleanup;
 328         }
 329
 330
 331         NewBand = reinterpret_cast<struct BandObject *>(CoTaskMemAlloc(NewAllocated * sizeof(struct BandObject)));
 332         if (NewBand == NULL)
 333         {
 334             hRet = E_OUTOFMEMORY;
 335             goto Cleanup;
 336         }
 337
 338         /* Copy the old array */
 339         memcpy(NewBand, fBands, fBandsAllocated * sizeof(struct BandObject));
 340
 341         /* Initialize the added bands */
 342         memset(&NewBand[fBandsAllocated], 0, (NewAllocated - fBandsAllocated) * sizeof(struct BandObject));
 343
 344         NewBand = &fBands[fBandsAllocated];
 345         fBandsAllocated = NewAllocated;
 346         CoTaskMemFree(fBands);
 347         fBands = NewBand;
 348     }
 349     else
 350     {
 351         ASSERT(fBands == NULL);
 352         ASSERT(fBandsAllocated == 0);
 353         ASSERT(fBandsCount == 0);
 354
 355         /* Allocate new array */
 356         fBands = reinterpret_cast<struct BandObject *>(CoTaskMemAlloc(8 * sizeof(struct BandObject)));
 357         if (fBands == NULL)
 358         {
 359             hRet = E_OUTOFMEMORY;
 360             goto Cleanup;
 361         }
 362
 363         /* Initialize the added bands */
 364         memset(fBands, 0, 8 * sizeof(struct BandObject));
 365
 366         fBandsAllocated += 8;
 367         NewBand = &fBands[0];
 368     }
 369
 370     if (SUCCEEDED(hRet))
 371     {
 372         ASSERT(NewBand != NULL);
 373
 374         fBandsCount++;
 375         NewBand->DeskBand = DeskBand.Detach();
 376         NewBand->OleWindow = OleWindow.Detach();
 377         NewBand->WndEvtHandler = WndEvtHandler.Detach();
 378
 379         /* Create the ReBar band */
 380         hRet = ObjWithSite->SetSite((IOleWindow *)this);
 381         if (SUCCEEDED(hRet))
 382         {
 383             uBand = 0xffffffff;
 384             if (SUCCEEDED(UpdateSingleBand(NewBand)))
 385             {
 386                 if (NewBand->dbi.dwMask & DBIM_MODEFLAGS)
 387                 {
 388                     if (NewBand->dbi.dwModeFlags & DBIMF_ADDTOFRONT)
 389                         uBand = 0;
 390                 }
 391             }
 392
 393             BuildRebarBandInfo(NewBand, &rbi);
 394
 395             if (SUCCEEDED(NewBand->OleWindow->GetWindow(&rbi.hwndChild)) &&
 396                 rbi.hwndChild != NULL)
 397             {
 398                 rbi.fMask |= RBBIM_CHILD;
 399                 WARN ("ReBar band uses child window 0x%p\n", rbi.hwndChild);
 400             }
 401
 402             if (!SendMessageW(fRebarWindow, RB_INSERTBANDW, (WPARAM)uBand, (LPARAM)&rbi))
 403                 return E_FAIL;
 404
 405             hRet = (HRESULT)((USHORT)GetBandID(NewBand));
 406         }
 407         else
 408         {
 409             WARN("IBandSite::AddBand(): Call to IDeskBand::SetSite() failed: %x\n", hRet);
 410
 411             /* Remove the band from the ReBar control */
 412             BuildRebarBandInfo(NewBand, &rbi);
 413             uBand = (UINT)SendMessageW(fRebarWindow, RB_IDTOINDEX, (WPARAM)rbi.wID, 0);
 414             if (uBand != (UINT)-1)
 415             {
 416                 if (!SendMessageW(fRebarWindow, RB_DELETEBAND, (WPARAM)uBand, 0))
 417                 {
 418                     ERR("Failed to delete band!\n");
 419                 }
 420             }
 421             else
 422                 ERR("Failed to map band id to index!\n");
 423
 424             FreeBand(NewBand);
 425
 426             hRet = E_FAIL;
 427             /* goto Cleanup; */
 428         }
 429     }
 430 Cleanup:
 431     return hRet;
 432 }
 433
 434 HRESULT STDMETHODCALLTYPE CBandSiteBase::EnumBands(UINT uBand, DWORD *pdwBandID)
 435 {
 436     DWORD                                                                       i;
 437
 438     TRACE("(%p, %u, %p)\n", this, uBand, pdwBandID);
 439
 440     if (uBand == 0xffffffff)
 441         return (UINT)fBandsCount;
 442
 443     if (uBand >= (UINT)fBandsCount)
 444         return E_FAIL;
 445
 446     for (i = 0; i < (DWORD)fBandsAllocated; i++)
 447     {
 448         if (fBands[i].DeskBand != NULL)
 449         {
 450             if (uBand == 0)
 451             {
 452                 *pdwBandID = i;
 453                 return S_OK;
 454             }
 455
 456             uBand--;
 457         }
 458     }
 459
 460     return E_FAIL;
 461 }
 462
 463 HRESULT STDMETHODCALLTYPE CBandSiteBase::QueryBand(DWORD dwBandID, IDeskBand **ppstb, DWORD *pdwState, LPWSTR pszName, int cchName)
 464 {
 465     struct BandObject                                           *Band;
 466
 467     TRACE("(%p, %u, %p, %p, %p, %d)\n", this, dwBandID, ppstb, pdwState, pszName, cchName);
 468
 469     Band = GetBandByID(dwBandID);
 470     if (Band == NULL)
 471         return E_FAIL;
 472
 473     if (ppstb != NULL)
 474     {
 475         Band->DeskBand->AddRef();
 476         *ppstb = Band->DeskBand;
 477     }
 478
 479     if (pdwState != NULL)
 480     {
 481         FIXME("IBandSite::QueryBand() requests band state!\n");
 482         *pdwState = 0;
 483     }
 484
 485     if (pszName != NULL && cchName > 0)
 486     {
 487         FIXME("IBandSite::QueryBand() requests band name!\n");
 488         pszName[0] = 0;
 489     }
 490     return S_OK;
 491 }
 492
 493 HRESULT STDMETHODCALLTYPE CBandSiteBase::SetBandState(DWORD dwBandID, DWORD dwMask, DWORD dwState)
 494 {
 495     struct BandObject                                           *Band;
 496
 497     TRACE("(%p, %u, %x, %x)\n", this, dwBandID, dwMask, dwState);
 498
 499     Band = GetBandByID(dwBandID);
 500     if (Band == NULL)
 501         return E_FAIL;
 502
 503     FIXME("Stub\n");
 504     return E_NOTIMPL;
 505 }
 506
 507 HRESULT STDMETHODCALLTYPE CBandSiteBase::RemoveBand(DWORD dwBandID)
 508 {
 509     struct BandObject                                           *Band;
 510     UINT                                                                        uBand;
 511
 512     TRACE("(%p, %u)\n", this, dwBandID);
 513
 514     if (fRebarWindow == NULL)
 515         return E_FAIL;
 516
 517     Band = GetBandByID(dwBandID);
 518     if (Band == NULL)
 519         return E_FAIL;
 520
 521     uBand = (UINT)SendMessageW(fRebarWindow, RB_IDTOINDEX, (WPARAM)GetBandID(Band), 0);
 522     if (uBand != (UINT)-1)
 523     {
 524         if (!SendMessageW(fRebarWindow, RB_DELETEBAND, (WPARAM)uBand, 0))
 525         {
 526             ERR("Could not delete band!\n");
 527         }
 528     }
 529     else
 530         ERR("Could not map band id to index!\n");
 531
 532     FreeBand(Band);
 533     return S_OK;
 534 }
 535
 536 HRESULT STDMETHODCALLTYPE CBandSiteBase::GetBandObject(DWORD dwBandID, REFIID riid, VOID **ppv)
 537 {
 538     struct BandObject                                           *Band;
 539
 540     TRACE("(%p, %u, %s, %p)\n", this, dwBandID, debugstr_guid(&riid), ppv);
 541
 542     Band = GetBandByID(dwBandID);
 543     if (Band == NULL)
 544     {
 545         *ppv = NULL;
 546         return E_FAIL;
 547     }
 548
 549     return Band->DeskBand->QueryInterface(riid, ppv);
 550 }
 551
 552 HRESULT STDMETHODCALLTYPE CBandSiteBase::SetBandSiteInfo(const BANDSITEINFO *pbsinfo)
 553 {
 554     FIXME("(%p, %p)\n", this, pbsinfo);
 555     return E_NOTIMPL;
 556 }
 557
 558 HRESULT STDMETHODCALLTYPE CBandSiteBase::GetBandSiteInfo(BANDSITEINFO *pbsinfo)
 559 {
 560     FIXME("(%p, %p)\n", this, pbsinfo);
 561     return E_NOTIMPL;
 562 }
 563
 564 HRESULT STDMETHODCALLTYPE CBandSiteBase::OnWinEvent(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *plrResult)
 565 {
 566     struct BandObject                                           *Band;
 567
 568     TRACE("(%p, %p, %u, %p, %p, %p)\n", this, hWnd, uMsg, wParam, lParam, plrResult);
 569
 570     *plrResult = 0;
 571     if (fRebarWindow == NULL)
 572         return E_FAIL;
 573
 574     if (hWnd == fRebarWindow)
 575     {
 576         /* FIXME: Just send the message? */
 577         *plrResult = SendMessageW(hWnd, uMsg, wParam, lParam);
 578         return S_OK;
 579     }
 580
 581     Band = GetBandFromHwnd(hWnd);
 582     if (Band != NULL)
 583     {
 584         return Band->WndEvtHandler->OnWinEvent(hWnd, uMsg, wParam, lParam, plrResult);
 585     }
 586
 587     return E_FAIL;
 588 }
 589
 590 HRESULT STDMETHODCALLTYPE CBandSiteBase::IsWindowOwner(HWND hWnd)
 591 {
 592     struct BandObject                                           *Band;
 593
 594     TRACE("(%p, %p)\n", this, hWnd);
 595
 596     if (fRebarWindow == NULL)
 597         return E_FAIL;
 598
 599     Band = GetBandFromHwnd(hWnd);
 600     if (Band != NULL)
 601         return S_OK;
 602
 603     return S_FALSE;
 604 }
 605
 606 HRESULT STDMETHODCALLTYPE CBandSiteBase::GetWindow(HWND *phWnd)
 607 {
 608     TRACE("(%p, %p)\n", this, phWnd);
 609
 610     *phWnd = fRebarWindow;
 611     if (fRebarWindow != NULL)
 612         return S_OK;
 613
 614     return E_FAIL;
 615 }
 616
 617 HRESULT STDMETHODCALLTYPE CBandSiteBase::ContextSensitiveHelp(BOOL fEnterMode)
 618 {
 619     FIXME("(%p, %d)\n", this, fEnterMode);
 620     return E_NOTIMPL;
 621 }
 622
 623 HRESULT STDMETHODCALLTYPE CBandSiteBase::SetDeskBarSite(IUnknown *pUnk)
 624 {
 625     HWND                                                                        hWndParent;
 626     HRESULT                                                                     hRet;
 627
 628     TRACE("(%p, %p)\n", this, pUnk);
 629
 630     fOleWindow.Release();
 631
 632     hRet = pUnk->QueryInterface(IID_IOleWindow, (PVOID *)&fOleWindow);
 633     if (!SUCCEEDED(hRet))
 634         return E_FAIL;
 635
 636     hRet = fOleWindow->GetWindow(&hWndParent);
 637     if (!SUCCEEDED(hRet))
 638         return E_FAIL;
 639
 640     fRebarWindow = CreateWindowExW(WS_EX_TOOLWINDOW,
 641                                       REBARCLASSNAMEW,
 642                                       NULL,
 643                                       WS_CHILD | WS_CLIPSIBLINGS |
 644                                           WS_CLIPCHILDREN | RBS_VARHEIGHT |
 645                                           RBS_BANDBORDERS | CCS_NODIVIDER |
 646                                           CCS_NORESIZE | CCS_NOPARENTALIGN,
 647                                       0,
 648                                       0,
 649                                       0,
 650                                       0,
 651                                       hWndParent,
 652                                       NULL,
 653                                       _AtlBaseModule.GetModuleInstance(),
 654                                       NULL);
 655     if (fRebarWindow == NULL)
 656     {
 657         fOleWindow.Release();
 658         WARN("IDeskbarClient::SetDeskBarSite() failed to create ReBar control!\n");
 659         return E_FAIL;
 660     }
 661
 662     return S_OK;
 663 }
 664
 665 HRESULT STDMETHODCALLTYPE CBandSiteBase::SetModeDBC(DWORD dwMode)
 666 {
 667     LONG                                                                        dwStyle;
 668         LONG                                                                    dwPrevStyle;
 669
 670     TRACE("(%p, %x)\n", this, dwMode);
 671
 672     if (fRebarWindow == NULL)
 673         return E_FAIL;
 674
 675     dwStyle = dwPrevStyle = GetWindowLongPtr(fRebarWindow, GWL_STYLE);
 676     if (dwMode & DBIF_VIEWMODE_VERTICAL)
 677         dwStyle |= CCS_VERT;
 678
 679     if (dwMode & ~DBIF_VIEWMODE_VERTICAL)
 680         FIXME("IDeskBarClient::SetModeDBC() unhandled modes: %x\n", dwStyle & ~DBIF_VIEWMODE_VERTICAL);
 681
 682     if (dwStyle != dwPrevStyle)
 683     {
 684         SetWindowLongPtr(fRebarWindow, GWL_STYLE, dwPrevStyle);
 685     }
 686
 687     return S_OK;
 688 }
 689
 690 HRESULT STDMETHODCALLTYPE CBandSiteBase::UIActivateDBC(DWORD dwState)
 691 {
 692     TRACE("(%p, %x)\n", this, dwState);
 693
 694     if (fRebarWindow == NULL)
 695         return E_FAIL;
 696
 697     ShowWindow(fRebarWindow, (dwState & DBC_SHOW) ? SW_SHOW : SW_HIDE);
 698     FIXME("IDeskBarClient::UIActivateDBC() Properly notify bands?\n");
 699     return S_OK;
 700 }
 701
 702 HRESULT STDMETHODCALLTYPE CBandSiteBase::GetSize(DWORD unknown1, LPRECT unknown2)
 703 {
 704     FIXME("(%p, %x, %p)\n", this, unknown1, unknown2);
 705     return E_NOTIMPL;
 706 }
 707
 708 HRESULT STDMETHODCALLTYPE CBandSiteBase::QueryStatus(const GUID *pguidCmdGroup, DWORD cCmds, OLECMD *prgCmds, OLECMDTEXT *pCmdText)
 709 {
 710     FIXME("(%p, %p, %u, %p, %p)\n", this, pguidCmdGroup, cCmds, prgCmds, pCmdText);
 711     return E_NOTIMPL;
 712 }
 713
 714 HRESULT STDMETHODCALLTYPE CBandSiteBase::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdExecOpt, VARIANTARG *pvaIn, VARIANTARG *pvaOut)
 715 {
 716     HRESULT                                                                     hRet = S_OK;
 717
 718     TRACE("(%p, %p, %u, %u, %p, %p)\n", this, pguidCmdGroup, nCmdID, nCmdExecOpt, pvaIn, pvaOut);
 719
 720     if (fRebarWindow == NULL)
 721         return E_FAIL;
 722
 723     if (IsEqualIID(*pguidCmdGroup, IID_IDeskBand))
 724     {
 725         switch (nCmdID)
 726         {
 727             case DBID_BANDINFOCHANGED:
 728                 if (pvaIn == NULL)
 729                     hRet = UpdateAllBands();
 730                 else
 731                 {
 732                     /* Update a single band */
 733                     if (pvaIn->n1.n2.vt == VT_I4)
 734                         hRet = UpdateBand(pvaIn->n1.n2.n3.lVal);
 735                     else
 736                         hRet = E_FAIL;
 737                 }
 738                 break;
 739
 740             case DBID_SHOWONLY:
 741             case DBID_MAXIMIZEBAND:
 742             case DBID_PUSHCHEVRON:
 743                 FIXME("IOleCommandTarget::Exec(): Unsupported command ID %d\n", nCmdID);
 744                 return E_NOTIMPL;
 745             default:
 746                 return E_FAIL;
 747         }
 748         return S_OK;
 749     }
 750     else
 751         WARN("IOleCommandTarget::Exec(): Unsupported command group GUID\n");
 752
 753     return E_NOTIMPL;
 754 }
 755
 756 HRESULT STDMETHODCALLTYPE CBandSiteBase::UIActivateIO(BOOL fActivate, LPMSG lpMsg)
 757 {
 758         return E_NOTIMPL;
 759 }
 760
 761 HRESULT STDMETHODCALLTYPE CBandSiteBase::HasFocusIO()
 762 {
 763         return E_NOTIMPL;
 764 }
 765
 766 HRESULT STDMETHODCALLTYPE CBandSiteBase::TranslateAcceleratorIO(LPMSG lpMsg)
 767 {
 768         return E_NOTIMPL;
 769 }
 770
 771 HRESULT STDMETHODCALLTYPE CBandSiteBase::OnFocusChangeIS(struct IUnknown *paramC, int param10)
 772 {
 773         return E_NOTIMPL;
 774 }
 775
 776 HRESULT STDMETHODCALLTYPE CBandSiteBase::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
 777 {
 778         return E_NOTIMPL;
 779 }
 780
 781 HRESULT STDMETHODCALLTYPE CBandSiteBase::GetClassID(CLSID *pClassID)
 782 {
 783         return E_NOTIMPL;
 784 }
 785
 786 HRESULT STDMETHODCALLTYPE CBandSiteBase::IsDirty()
 787 {
 788         return E_NOTIMPL;
 789 }
 790
 791 HRESULT STDMETHODCALLTYPE CBandSiteBase::Load(IStream *pStm)
 792 {
 793         return E_NOTIMPL;
 794 }
 795
 796 HRESULT STDMETHODCALLTYPE CBandSiteBase::Save(IStream *pStm, BOOL fClearDirty)
 797 {
 798         return E_NOTIMPL;
 799 }
 800
 801 HRESULT STDMETHODCALLTYPE CBandSiteBase::GetSizeMax(ULARGE_INTEGER *pcbSize)
 802 {
 803         return E_NOTIMPL;
 804 }
 805
 806 HRESULT STDMETHODCALLTYPE CBandSiteBase::DragEnter(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
 807 {
 808         return E_NOTIMPL;
 809 }
 810
 811 HRESULT STDMETHODCALLTYPE CBandSiteBase::DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
 812 {
 813         return E_NOTIMPL;
 814 }
 815
 816 HRESULT STDMETHODCALLTYPE CBandSiteBase::DragLeave()
 817 {
 818         return E_NOTIMPL;
 819 }
 820
 821 HRESULT STDMETHODCALLTYPE CBandSiteBase::Drop(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
 822 {
 823         return E_NOTIMPL;
 824 }
 825
 826 HRESULT STDMETHODCALLTYPE CBandSiteBase::LoadFromStreamBS(IStream *, const GUID &, void **)
 827 {
 828         return E_NOTIMPL;
 829 }
 830
 831 HRESULT STDMETHODCALLTYPE CBandSiteBase::SaveToStreamBS(IUnknown *, IStream *)
 832 {
 833         return E_NOTIMPL;
 834 }