git.oblomov.eu Git - wine/blob - dlls/comctl32/rebar.c

   1 /*
   2  * Rebar control
   3  *
   4  * Copyright 1998, 1999 Eric Kohl
   5  *
   6  * NOTES
   7  *   An author is needed! Any volunteers?
   8  *   I will only improve this control once in a while.
   9  *     Eric <ekohl@abo.rhein-zeitung.de>
  10  *
  11  * TODO:
  12  *   - vertical placement
  13  *   - ComboBox and ComboBoxEx placement
  14  *   - center image
  15  *   - Layout code.
  16  *   - Display code.
  17  *   - Some messages.
  18  *   - All notifications.
  19  */
  20
  21 #include <string.h>
  22
  23 #include "winbase.h"
  24 #include "wingdi.h"
  25 #include "wine/unicode.h"
  26 #include "commctrl.h"
  27 #include "debugtools.h"
  28
  29 DEFAULT_DEBUG_CHANNEL(rebar);
  30
  31 typedef struct
  32 {
  33     UINT    fStyle;
  34     COLORREF  clrFore;
  35     COLORREF  clrBack;
  36     INT     iImage;
  37     HWND    hwndChild;
  38     UINT    cxMinChild;
  39     UINT    cyMinChild;
  40     UINT    cx;
  41     HBITMAP hbmBack;
  42     UINT    wID;
  43     UINT    cyChild;
  44     UINT    cyMaxChild;
  45     UINT    cyIntegral;
  46     UINT    cxIdeal;
  47     LPARAM    lParam;
  48     UINT    cxHeader;
  49
  50     UINT    uMinHeight;
  51     UINT    fDraw;          /* drawing flags */
  52     RECT    rcBand;         /* calculated band rectangle */
  53     RECT    rcGripper;      /* calculated gripper rectangle */
  54     RECT    rcCapImage;     /* calculated caption image rectangle */
  55     RECT    rcCapText;      /* calculated caption text rectangle */
  56     RECT    rcChild;        /* calculated child rectangle */
  57
  58     LPWSTR    lpText;
  59     HWND    hwndPrevParent;
  60 } REBAR_BAND;
  61
  62 typedef struct
  63 {
  64     COLORREF   clrBk;       /* background color */
  65     COLORREF   clrText;     /* text color */
  66     HIMAGELIST himl;        /* handle to imagelist */
  67     UINT     uNumBands;   /* number of bands in the rebar */
  68     HWND     hwndToolTip; /* handle to the tool tip control */
  69     HWND     hwndNotify;  /* notification window (parent) */
  70     HFONT    hFont;       /* handle to the rebar's font */
  71     SIZE     imageSize;   /* image size (image list) */
  72
  73     SIZE     calcSize;    /* calculated rebar size */
  74     BOOL     bAutoResize; /* auto resize deadlock flag */
  75     BOOL     bUnicode;    /* Unicode flag */
  76     HCURSOR  hcurArrow;   /* handle to the arrow cursor */
  77     HCURSOR  hcurHorz;    /* handle to the EW cursor */
  78     HCURSOR  hcurVert;    /* handle to the NS cursor */
  79     HCURSOR  hcurDrag;    /* handle to the drag cursor */
  80     INT      iVersion;    /* version number */
  81
  82     REBAR_BAND *bands;      /* pointer to the array of rebar bands */
  83 } REBAR_INFO;
  84
  85
  86 /* fDraw flags */
  87 #define DRAW_GRIPPER    1
  88 #define DRAW_IMAGE      2
  89 #define DRAW_TEXT       4
  90 #define DRAW_CHILD      8
  91
  92 #define GRIPPER_WIDTH   13
  93
  94
  95 #define REBAR_GetInfoPtr(wndPtr) ((REBAR_INFO *)GetWindowLongA (hwnd, 0))
  96
  97
  98 static VOID
  99 REBAR_DrawBand (HDC hdc, REBAR_INFO *infoPtr, REBAR_BAND *lpBand)
 100 {
 101
 102     DrawEdge (hdc, &lpBand->rcBand, BDR_RAISEDINNER, BF_MIDDLE);
 103
 104     /* draw background */
 105
 106     /* draw gripper */
 107     if (lpBand->fDraw & DRAW_GRIPPER)
 108         DrawEdge (hdc, &lpBand->rcGripper, BDR_RAISEDINNER, BF_RECT | BF_MIDDLE);
 109
 110     /* draw caption image */
 111     if (lpBand->fDraw & DRAW_IMAGE) {
 112         /* FIXME: center image */
 113         POINT pt;
 114
 115         pt.y = (lpBand->rcCapImage.bottom + lpBand->rcCapImage.top - infoPtr->imageSize.cy)/2;
 116         pt.x = (lpBand->rcCapImage.right + lpBand->rcCapImage.left - infoPtr->imageSize.cx)/2;
 117
 118         ImageList_Draw (infoPtr->himl, lpBand->iImage, hdc,
 119 /*                      lpBand->rcCapImage.left, lpBand->rcCapImage.top, */
 120                         pt.x, pt.y,
 121                         ILD_TRANSPARENT);
 122     }
 123
 124     /* draw caption text */
 125     if (lpBand->fDraw & DRAW_TEXT) {
 126         HFONT hOldFont = SelectObject (hdc, infoPtr->hFont);
 127         INT oldBkMode = SetBkMode (hdc, TRANSPARENT);
 128         DrawTextW (hdc, lpBand->lpText, -1, &lpBand->rcCapText,
 129                      DT_CENTER | DT_VCENTER | DT_SINGLELINE);
 130         if (oldBkMode != TRANSPARENT)
 131             SetBkMode (hdc, oldBkMode);
 132         SelectObject (hdc, hOldFont);
 133     }
 134 }
 135
 136
 137 static VOID
 138 REBAR_Refresh (HWND hwnd, HDC hdc)
 139 {
 140     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 141     REBAR_BAND *lpBand;
 142     UINT i;
 143
 144     for (i = 0; i < infoPtr->uNumBands; i++) {
 145         lpBand = &infoPtr->bands[i];
 146
 147         if ((lpBand->fStyle & RBBS_HIDDEN) ||
 148             ((GetWindowLongA (hwnd, GWL_STYLE) & CCS_VERT) &&
 149              (lpBand->fStyle & RBBS_NOVERT)))
 150             continue;
 151
 152         REBAR_DrawBand (hdc, infoPtr, lpBand);
 153
 154     }
 155 }
 156
 157
 158 static VOID
 159 REBAR_CalcHorzBand (REBAR_INFO *infoPtr, REBAR_BAND *lpBand)
 160 {
 161     lpBand->fDraw = 0;
 162
 163     /* set initial caption image rectangle */
 164     SetRect (&lpBand->rcCapImage, 0, 0, 0, 0);
 165
 166     /* image is visible */
 167     if ((lpBand->iImage > -1) && (infoPtr->himl)) {
 168         lpBand->fDraw |= DRAW_IMAGE;
 169
 170         lpBand->rcCapImage.right  = lpBand->rcCapImage.left + infoPtr->imageSize.cx;
 171         lpBand->rcCapImage.bottom = lpBand->rcCapImage.top + infoPtr->imageSize.cy;
 172
 173         /* update band height */
 174         if (lpBand->uMinHeight < infoPtr->imageSize.cy + 2) {
 175             lpBand->uMinHeight = infoPtr->imageSize.cy + 2;
 176             lpBand->rcBand.bottom = lpBand->rcBand.top + lpBand->uMinHeight;
 177         }
 178     }
 179
 180     /* set initial caption text rectangle */
 181     lpBand->rcCapText.left   = lpBand->rcCapImage.right;
 182     lpBand->rcCapText.top    = lpBand->rcBand.top + 1;
 183     lpBand->rcCapText.right  = lpBand->rcCapText.left;
 184     lpBand->rcCapText.bottom = lpBand->rcBand.bottom - 1;
 185
 186     /* text is visible */
 187     if (lpBand->lpText) {
 188         HDC hdc = GetDC (0);
 189         HFONT hOldFont = SelectObject (hdc, infoPtr->hFont);
 190         SIZE size;
 191
 192         lpBand->fDraw |= DRAW_TEXT;
 193         GetTextExtentPoint32W (hdc, lpBand->lpText,
 194                                lstrlenW (lpBand->lpText), &size);
 195         lpBand->rcCapText.right += size.cx;
 196
 197         SelectObject (hdc, hOldFont);
 198         ReleaseDC (0, hdc);
 199     }
 200
 201     /* set initial child window rectangle */
 202     if (lpBand->fStyle & RBBS_FIXEDSIZE) {
 203         lpBand->rcChild.left   = lpBand->rcCapText.right;
 204         lpBand->rcChild.top    = lpBand->rcBand.top;
 205         lpBand->rcChild.right  = lpBand->rcBand.right;
 206         lpBand->rcChild.bottom = lpBand->rcBand.bottom;
 207     }
 208     else {
 209         lpBand->rcChild.left   = lpBand->rcCapText.right + 4;
 210         lpBand->rcChild.top    = lpBand->rcBand.top + 2;
 211         lpBand->rcChild.right  = lpBand->rcBand.right - 4;
 212         lpBand->rcChild.bottom = lpBand->rcBand.bottom - 2;
 213     }
 214
 215     /* calculate gripper rectangle */
 216     if ((!(lpBand->fStyle & RBBS_NOGRIPPER)) &&
 217         (!(lpBand->fStyle & RBBS_FIXEDSIZE)) &&
 218         ((lpBand->fStyle & RBBS_GRIPPERALWAYS) ||
 219          (infoPtr->uNumBands > 1))) {
 220         lpBand->fDraw |= DRAW_GRIPPER;
 221         lpBand->rcGripper.left   = lpBand->rcBand.left + 3;
 222         lpBand->rcGripper.right  = lpBand->rcGripper.left + 3;
 223         lpBand->rcGripper.top    = lpBand->rcBand.top + 3;
 224         lpBand->rcGripper.bottom = lpBand->rcBand.bottom - 3;
 225
 226         /* move caption rectangles */
 227         OffsetRect (&lpBand->rcCapImage, GRIPPER_WIDTH, 0);
 228         OffsetRect (&lpBand->rcCapText, GRIPPER_WIDTH, 0);
 229
 230         /* adjust child rectangle */
 231         lpBand->rcChild.left += GRIPPER_WIDTH;
 232     }
 233
 234
 235 }
 236
 237
 238 static VOID
 239 REBAR_CalcVertBand (HWND hwnd, REBAR_INFO *infoPtr, REBAR_BAND *lpBand)
 240 {
 241     lpBand->fDraw = 0;
 242
 243     /* set initial caption image rectangle */
 244     SetRect (&lpBand->rcCapImage, 0, 0, 0, 0);
 245
 246     /* image is visible */
 247     if ((lpBand->iImage > -1) && (infoPtr->himl)) {
 248         lpBand->fDraw |= DRAW_IMAGE;
 249
 250         lpBand->rcCapImage.right  = lpBand->rcCapImage.left + infoPtr->imageSize.cx;
 251         lpBand->rcCapImage.bottom = lpBand->rcCapImage.top + infoPtr->imageSize.cy;
 252
 253         /* update band width */
 254         if (lpBand->uMinHeight < infoPtr->imageSize.cx + 2) {
 255             lpBand->uMinHeight = infoPtr->imageSize.cx + 2;
 256             lpBand->rcBand.right = lpBand->rcBand.left + lpBand->uMinHeight;
 257         }
 258     }
 259
 260     /* set initial caption text rectangle */
 261     lpBand->rcCapText.left   = lpBand->rcBand.left + 1;
 262     lpBand->rcCapText.top    = lpBand->rcCapImage.bottom;
 263     lpBand->rcCapText.right  = lpBand->rcBand.right - 1;
 264     lpBand->rcCapText.bottom = lpBand->rcCapText.top;
 265
 266     /* text is visible */
 267     if (lpBand->lpText) {
 268         HDC hdc = GetDC (0);
 269         HFONT hOldFont = SelectObject (hdc, infoPtr->hFont);
 270         SIZE size;
 271
 272         lpBand->fDraw |= DRAW_TEXT;
 273         GetTextExtentPoint32W (hdc, lpBand->lpText,
 274                                lstrlenW (lpBand->lpText), &size);
 275 /*      lpBand->rcCapText.right += size.cx; */
 276         lpBand->rcCapText.bottom += size.cy;
 277
 278         SelectObject (hdc, hOldFont);
 279         ReleaseDC (0, hdc);
 280     }
 281
 282     /* set initial child window rectangle */
 283     if (lpBand->fStyle & RBBS_FIXEDSIZE) {
 284         lpBand->rcChild.left   = lpBand->rcBand.left;
 285         lpBand->rcChild.top    = lpBand->rcCapText.bottom;
 286         lpBand->rcChild.right  = lpBand->rcBand.right;
 287         lpBand->rcChild.bottom = lpBand->rcBand.bottom;
 288     }
 289     else {
 290         lpBand->rcChild.left   = lpBand->rcBand.left + 2;
 291         lpBand->rcChild.top    = lpBand->rcCapText.bottom + 4;
 292         lpBand->rcChild.right  = lpBand->rcBand.right - 2;
 293         lpBand->rcChild.bottom = lpBand->rcBand.bottom - 4;
 294     }
 295
 296     /* calculate gripper rectangle */
 297     if ((!(lpBand->fStyle & RBBS_NOGRIPPER)) &&
 298         (!(lpBand->fStyle & RBBS_FIXEDSIZE)) &&
 299         ((lpBand->fStyle & RBBS_GRIPPERALWAYS) ||
 300          (infoPtr->uNumBands > 1))) {
 301         lpBand->fDraw |= DRAW_GRIPPER;
 302
 303         if (GetWindowLongA (hwnd, GWL_STYLE) & RBS_VERTICALGRIPPER) {
 304             /* adjust band width */
 305             lpBand->rcBand.right += GRIPPER_WIDTH;
 306             lpBand->uMinHeight += GRIPPER_WIDTH;
 307
 308             lpBand->rcGripper.left   = lpBand->rcBand.left + 3;
 309             lpBand->rcGripper.right  = lpBand->rcGripper.left + 3;
 310             lpBand->rcGripper.top    = lpBand->rcBand.top + 3;
 311             lpBand->rcGripper.bottom = lpBand->rcBand.bottom - 3;
 312
 313             /* move caption rectangles */
 314             OffsetRect (&lpBand->rcCapImage, GRIPPER_WIDTH, 0);
 315             OffsetRect (&lpBand->rcCapText, GRIPPER_WIDTH, 0);
 316
 317             /* adjust child rectangle */
 318             lpBand->rcChild.left += GRIPPER_WIDTH;
 319         }
 320         else {
 321             lpBand->rcGripper.left   = lpBand->rcBand.left + 3;
 322             lpBand->rcGripper.right  = lpBand->rcBand.right - 3;
 323             lpBand->rcGripper.top    = lpBand->rcBand.top + 3;
 324             lpBand->rcGripper.bottom = lpBand->rcGripper.top + 3;
 325
 326             /* move caption rectangles */
 327             OffsetRect (&lpBand->rcCapImage, 0, GRIPPER_WIDTH);
 328             OffsetRect (&lpBand->rcCapText, 0, GRIPPER_WIDTH);
 329
 330             /* adjust child rectangle */
 331             lpBand->rcChild.top += GRIPPER_WIDTH;
 332         }
 333     }
 334 }
 335
 336
 337 static VOID
 338 REBAR_Layout (HWND hwnd, LPRECT lpRect)
 339 {
 340     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 341     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
 342     REBAR_BAND *lpBand;
 343     RECT rcClient;
 344     INT x, y, cx, cy;
 345     UINT i;
 346
 347     if (lpRect)
 348         rcClient = *lpRect;
 349     else
 350         GetClientRect (hwnd, &rcClient);
 351
 352     x = 0;
 353     y = 0;
 354
 355     if (dwStyle & CCS_VERT) {
 356         cx = 20;    /* FIXME: fixed height */
 357         cy = rcClient.bottom - rcClient.top;
 358     }
 359     else {
 360         cx = rcClient.right - rcClient.left;
 361         cy = 20;    /* FIXME: fixed height */
 362     }
 363
 364     for (i = 0; i < infoPtr->uNumBands; i++) {
 365         lpBand = &infoPtr->bands[i];
 366
 367         if ((lpBand->fStyle & RBBS_HIDDEN) ||
 368             ((dwStyle & CCS_VERT) && (lpBand->fStyle & RBBS_NOVERT)))
 369             continue;
 370
 371
 372         if (dwStyle & CCS_VERT) {
 373             if (lpBand->fStyle & RBBS_VARIABLEHEIGHT)
 374                 cx = lpBand->cyMaxChild;
 375             else if (lpBand->fStyle & RBBIM_CHILDSIZE)
 376                 cx = lpBand->cyMinChild;
 377             else
 378                 cx = 20; /* FIXME */
 379
 380             lpBand->rcBand.left   = x;
 381             lpBand->rcBand.right  = x + cx;
 382             lpBand->rcBand.top    = y;
 383             lpBand->rcBand.bottom = y + cy;
 384             lpBand->uMinHeight = cx;
 385         }
 386         else {
 387             if (lpBand->fStyle & RBBS_VARIABLEHEIGHT)
 388                 cy = lpBand->cyMaxChild;
 389             else if (lpBand->fStyle & RBBIM_CHILDSIZE)
 390                 cy = lpBand->cyMinChild;
 391             else
 392                 cy = 20; /* FIXME */
 393
 394             lpBand->rcBand.left   = x;
 395             lpBand->rcBand.right  = x + cx;
 396             lpBand->rcBand.top    = y;
 397             lpBand->rcBand.bottom = y + cy;
 398             lpBand->uMinHeight = cy;
 399         }
 400
 401         if (dwStyle & CCS_VERT) {
 402             REBAR_CalcVertBand (hwnd, infoPtr, lpBand);
 403             x += lpBand->uMinHeight;
 404         }
 405         else {
 406             REBAR_CalcHorzBand (infoPtr, lpBand);
 407             y += lpBand->uMinHeight;
 408         }
 409     }
 410
 411     if (dwStyle & CCS_VERT) {
 412         infoPtr->calcSize.cx = x;
 413         infoPtr->calcSize.cy = rcClient.bottom - rcClient.top;
 414     }
 415     else {
 416         infoPtr->calcSize.cx = rcClient.right - rcClient.left;
 417         infoPtr->calcSize.cy = y;
 418     }
 419 }
 420
 421
 422 static VOID
 423 REBAR_ForceResize (HWND hwnd)
 424 {
 425     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 426     RECT rc;
 427
 428     TRACE(" to [%d x %d]!\n",
 429            infoPtr->calcSize.cx, infoPtr->calcSize.cy);
 430
 431     infoPtr->bAutoResize = TRUE;
 432
 433     rc.left = 0;
 434     rc.top = 0;
 435     rc.right  = infoPtr->calcSize.cx;
 436     rc.bottom = infoPtr->calcSize.cy;
 437
 438     if (GetWindowLongA (hwnd, GWL_STYLE) & WS_BORDER) {
 439         InflateRect (&rc, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
 440     }
 441
 442     SetWindowPos (hwnd, 0, 0, 0,
 443                     rc.right - rc.left, rc.bottom - rc.top,
 444                     SWP_NOMOVE | SWP_NOZORDER | SWP_SHOWWINDOW);
 445 }
 446
 447
 448 static VOID
 449 REBAR_MoveChildWindows (HWND hwnd)
 450 {
 451     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 452     REBAR_BAND *lpBand;
 453     CHAR szClassName[40];
 454     UINT i;
 455
 456     for (i = 0; i < infoPtr->uNumBands; i++) {
 457         lpBand = &infoPtr->bands[i];
 458
 459         if (lpBand->fStyle & RBBS_HIDDEN)
 460             continue;
 461         if (lpBand->hwndChild) {
 462             TRACE("hwndChild = %x\n", lpBand->hwndChild);
 463
 464             GetClassNameA (lpBand->hwndChild, szClassName, 40);
 465             if (!lstrcmpA (szClassName, "ComboBox")) {
 466                 INT nEditHeight, yPos;
 467                 RECT rc;
 468
 469                 /* special placement code for combo box */
 470
 471
 472                 /* get size of edit line */
 473                 GetWindowRect (lpBand->hwndChild, &rc);
 474                 nEditHeight = rc.bottom - rc.top;
 475                 yPos = (lpBand->rcChild.bottom + lpBand->rcChild.top - nEditHeight)/2;
 476
 477                 /* center combo box inside child area */
 478                 SetWindowPos (lpBand->hwndChild, HWND_TOP,
 479                             lpBand->rcChild.left, /*lpBand->rcChild.top*/ yPos,
 480                             lpBand->rcChild.right - lpBand->rcChild.left,
 481                             nEditHeight,
 482                             SWP_SHOWWINDOW);
 483             }
 484 #if 0
 485             else if (!lstrcmpA (szClassName, WC_COMBOBOXEXA)) {
 486                 INT nEditHeight, yPos;
 487                 RECT rc;
 488                 HWND hwndEdit;
 489
 490                 /* special placement code for extended combo box */
 491
 492                 /* get size of edit line */
 493                 hwndEdit = SendMessageA (lpBand->hwndChild, CBEM_GETEDITCONTROL, 0, 0);
 494                 GetWindowRect (hwndEdit, &rc);
 495                 nEditHeight = rc.bottom - rc.top;
 496                 yPos = (lpBand->rcChild.bottom + lpBand->rcChild.top - nEditHeight)/2;
 497
 498                 /* center combo box inside child area */
 499                 SetWindowPos (lpBand->hwndChild, HWND_TOP,
 500                             lpBand->rcChild.left, /*lpBand->rcChild.top*/ yPos,
 501                             lpBand->rcChild.right - lpBand->rcChild.left,
 502                             nEditHeight,
 503                             SWP_SHOWWINDOW);
 504
 505             }
 506 #endif
 507             else {
 508                 SetWindowPos (lpBand->hwndChild, HWND_TOP,
 509                             lpBand->rcChild.left, lpBand->rcChild.top,
 510                             lpBand->rcChild.right - lpBand->rcChild.left,
 511                             lpBand->rcChild.bottom - lpBand->rcChild.top,
 512                             SWP_SHOWWINDOW);
 513             }
 514         }
 515     }
 516 }
 517
 518
 519 static void
 520 REBAR_InternalHitTest (HWND hwnd, LPPOINT lpPt, UINT *pFlags, INT *pBand)
 521 {
 522     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 523     REBAR_BAND *lpBand;
 524     RECT rect;
 525     INT  iCount;
 526
 527     GetClientRect (hwnd, &rect);
 528
 529     *pFlags = RBHT_NOWHERE;
 530     if (PtInRect (&rect, *lpPt))
 531     {
 532         if (infoPtr->uNumBands == 0) {
 533             *pFlags = RBHT_NOWHERE;
 534             if (pBand)
 535                 *pBand = -1;
 536             TRACE("NOWHERE\n");
 537             return;
 538         }
 539         else {
 540             /* somewhere inside */
 541             for (iCount = 0; iCount < infoPtr->uNumBands; iCount++) {
 542                 lpBand = &infoPtr->bands[iCount];
 543                 if (PtInRect (&lpBand->rcBand, *lpPt)) {
 544                     if (pBand)
 545                         *pBand = iCount;
 546                     if (PtInRect (&lpBand->rcGripper, *lpPt)) {
 547                         *pFlags = RBHT_GRABBER;
 548                         TRACE("ON GRABBER %d\n", iCount);
 549                         return;
 550                     }
 551                     else if (PtInRect (&lpBand->rcCapImage, *lpPt)) {
 552                         *pFlags = RBHT_CAPTION;
 553                         TRACE("ON CAPTION %d\n", iCount);
 554                         return;
 555                     }
 556                     else if (PtInRect (&lpBand->rcCapText, *lpPt)) {
 557                         *pFlags = RBHT_CAPTION;
 558                         TRACE("ON CAPTION %d\n", iCount);
 559                         return;
 560                     }
 561                     else if (PtInRect (&lpBand->rcChild, *lpPt)) {
 562                         *pFlags = RBHT_CLIENT;
 563                         TRACE("ON CLIENT %d\n", iCount);
 564                         return;
 565                     }
 566                     else {
 567                         *pFlags = RBHT_NOWHERE;
 568                         TRACE("NOWHERE %d\n", iCount);
 569                         return;
 570                     }
 571                 }
 572             }
 573
 574             *pFlags = RBHT_NOWHERE;
 575             if (pBand)
 576                 *pBand = -1;
 577
 578             TRACE("NOWHERE\n");
 579             return;
 580         }
 581     }
 582     else {
 583         *pFlags = RBHT_NOWHERE;
 584         if (pBand)
 585             *pBand = -1;
 586         TRACE("NOWHERE\n");
 587         return;
 588     }
 589
 590     TRACE("flags=0x%X\n", *pFlags);
 591     return;
 592 }
 593
 594
 595
 596 /* << REBAR_BeginDrag >> */
 597
 598
 599 static LRESULT
 600 REBAR_DeleteBand (HWND hwnd, WPARAM wParam, LPARAM lParam)
 601 {
 602     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 603     UINT uBand = (UINT)wParam;
 604
 605     if (uBand >= infoPtr->uNumBands)
 606         return FALSE;
 607
 608     TRACE("deleting band %u!\n", uBand);
 609
 610     if (infoPtr->uNumBands == 1) {
 611         TRACE(" simple delete!\n");
 612         COMCTL32_Free (infoPtr->bands);
 613         infoPtr->bands = NULL;
 614         infoPtr->uNumBands = 0;
 615     }
 616     else {
 617         REBAR_BAND *oldBands = infoPtr->bands;
 618         TRACE("complex delete! [uBand=%u]\n", uBand);
 619
 620         infoPtr->uNumBands--;
 621         infoPtr->bands = COMCTL32_Alloc (sizeof (REBAR_BAND) * infoPtr->uNumBands);
 622         if (uBand > 0) {
 623             memcpy (&infoPtr->bands[0], &oldBands[0],
 624                     uBand * sizeof(REBAR_BAND));
 625         }
 626
 627         if (uBand < infoPtr->uNumBands) {
 628             memcpy (&infoPtr->bands[uBand], &oldBands[uBand+1],
 629                     (infoPtr->uNumBands - uBand) * sizeof(REBAR_BAND));
 630         }
 631
 632         COMCTL32_Free (oldBands);
 633     }
 634
 635     REBAR_Layout (hwnd, NULL);
 636     REBAR_ForceResize (hwnd);
 637     REBAR_MoveChildWindows (hwnd);
 638
 639     return TRUE;
 640 }
 641
 642
 643 /* << REBAR_DragMove >> */
 644 /* << REBAR_EndDrag >> */
 645
 646
 647 static LRESULT
 648 REBAR_GetBandBorders (HWND hwnd, WPARAM wParam, LPARAM lParam)
 649 {
 650     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 651     /* LPRECT32 lpRect = (LPRECT32)lParam; */
 652     REBAR_BAND *lpBand;
 653
 654     if (!lParam)
 655         return 0;
 656     if ((UINT)wParam >= infoPtr->uNumBands)
 657         return 0;
 658
 659     lpBand = &infoPtr->bands[(UINT)wParam];
 660     if (GetWindowLongA (hwnd, GWL_STYLE) & RBS_BANDBORDERS) {
 661
 662     }
 663     else {
 664
 665     }
 666
 667     return 0;
 668 }
 669
 670
 671 inline static LRESULT
 672 REBAR_GetBandCount (HWND hwnd)
 673 {
 674     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 675
 676     TRACE("band count %u!\n", infoPtr->uNumBands);
 677
 678     return infoPtr->uNumBands;
 679 }
 680
 681
 682 static LRESULT
 683 REBAR_GetBandInfoA (HWND hwnd, WPARAM wParam, LPARAM lParam)
 684 {
 685     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 686     LPREBARBANDINFOA lprbbi = (LPREBARBANDINFOA)lParam;
 687     REBAR_BAND *lpBand;
 688
 689     if (lprbbi == NULL)
 690         return FALSE;
 691     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEA)
 692         return FALSE;
 693     if ((UINT)wParam >= infoPtr->uNumBands)
 694         return FALSE;
 695
 696     TRACE("index %u\n", (UINT)wParam);
 697
 698     /* copy band information */
 699     lpBand = &infoPtr->bands[(UINT)wParam];
 700
 701     if (lprbbi->fMask & RBBIM_STYLE)
 702         lprbbi->fStyle = lpBand->fStyle;
 703
 704     if (lprbbi->fMask & RBBIM_COLORS) {
 705         lprbbi->clrFore = lpBand->clrFore;
 706         lprbbi->clrBack = lpBand->clrBack;
 707     }
 708
 709     if ((lprbbi->fMask & RBBIM_TEXT) &&
 710         (lprbbi->lpText) && (lpBand->lpText)) {
 711             lstrcpynWtoA (lprbbi->lpText, lpBand->lpText, lprbbi->cch);
 712     }
 713
 714     if (lprbbi->fMask & RBBIM_IMAGE)
 715         lprbbi->iImage = lpBand->iImage;
 716
 717     if (lprbbi->fMask & RBBIM_CHILD)
 718         lprbbi->hwndChild = lpBand->hwndChild;
 719
 720     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
 721         lprbbi->cxMinChild = lpBand->cxMinChild;
 722         lprbbi->cyMinChild = lpBand->cyMinChild;
 723         lprbbi->cyMaxChild = lpBand->cyMaxChild;
 724         lprbbi->cyChild    = lpBand->cyChild;
 725         lprbbi->cyIntegral = lpBand->cyIntegral;
 726     }
 727
 728     if (lprbbi->fMask & RBBIM_SIZE)
 729         lprbbi->cx = lpBand->cx;
 730
 731     if (lprbbi->fMask & RBBIM_BACKGROUND)
 732         lprbbi->hbmBack = lpBand->hbmBack;
 733
 734     if (lprbbi->fMask & RBBIM_ID)
 735         lprbbi->wID = lpBand->wID;
 736
 737     /* check for additional data */
 738     if (lprbbi->cbSize >= sizeof (REBARBANDINFOA)) {
 739         if (lprbbi->fMask & RBBIM_IDEALSIZE)
 740             lprbbi->cxIdeal = lpBand->cxIdeal;
 741
 742         if (lprbbi->fMask & RBBIM_LPARAM)
 743             lprbbi->lParam = lpBand->lParam;
 744
 745         if (lprbbi->fMask & RBBIM_HEADERSIZE)
 746             lprbbi->cxHeader = lpBand->cxHeader;
 747     }
 748
 749     return TRUE;
 750 }
 751
 752
 753 static LRESULT
 754 REBAR_GetBandInfoW (HWND hwnd, WPARAM wParam, LPARAM lParam)
 755 {
 756     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 757     LPREBARBANDINFOW lprbbi = (LPREBARBANDINFOW)lParam;
 758     REBAR_BAND *lpBand;
 759
 760     if (lprbbi == NULL)
 761         return FALSE;
 762     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEW)
 763         return FALSE;
 764     if ((UINT)wParam >= infoPtr->uNumBands)
 765         return FALSE;
 766
 767     TRACE("index %u\n", (UINT)wParam);
 768
 769     /* copy band information */
 770     lpBand = &infoPtr->bands[(UINT)wParam];
 771
 772     if (lprbbi->fMask & RBBIM_STYLE)
 773         lprbbi->fStyle = lpBand->fStyle;
 774
 775     if (lprbbi->fMask & RBBIM_COLORS) {
 776         lprbbi->clrFore = lpBand->clrFore;
 777         lprbbi->clrBack = lpBand->clrBack;
 778     }
 779
 780     if ((lprbbi->fMask & RBBIM_TEXT) &&
 781         (lprbbi->lpText) && (lpBand->lpText)) {
 782             lstrcpynW (lprbbi->lpText, lpBand->lpText, lprbbi->cch);
 783     }
 784
 785     if (lprbbi->fMask & RBBIM_IMAGE)
 786         lprbbi->iImage = lpBand->iImage;
 787
 788     if (lprbbi->fMask & RBBIM_CHILD)
 789         lprbbi->hwndChild = lpBand->hwndChild;
 790
 791     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
 792         lprbbi->cxMinChild = lpBand->cxMinChild;
 793         lprbbi->cyMinChild = lpBand->cyMinChild;
 794         lprbbi->cyMaxChild = lpBand->cyMaxChild;
 795         lprbbi->cyChild    = lpBand->cyChild;
 796         lprbbi->cyIntegral = lpBand->cyIntegral;
 797     }
 798
 799     if (lprbbi->fMask & RBBIM_SIZE)
 800         lprbbi->cx = lpBand->cx;
 801
 802     if (lprbbi->fMask & RBBIM_BACKGROUND)
 803         lprbbi->hbmBack = lpBand->hbmBack;
 804
 805     if (lprbbi->fMask & RBBIM_ID)
 806         lprbbi->wID = lpBand->wID;
 807
 808     /* check for additional data */
 809     if (lprbbi->cbSize >= sizeof (REBARBANDINFOA)) {
 810         if (lprbbi->fMask & RBBIM_IDEALSIZE)
 811             lprbbi->cxIdeal = lpBand->cxIdeal;
 812
 813         if (lprbbi->fMask & RBBIM_LPARAM)
 814             lprbbi->lParam = lpBand->lParam;
 815
 816         if (lprbbi->fMask & RBBIM_HEADERSIZE)
 817             lprbbi->cxHeader = lpBand->cxHeader;
 818     }
 819
 820     return TRUE;
 821 }
 822
 823
 824 static LRESULT
 825 REBAR_GetBarHeight (HWND hwnd, WPARAM wParam, LPARAM lParam)
 826 {
 827     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 828     INT nHeight;
 829
 830     REBAR_Layout (hwnd, NULL);
 831     nHeight = infoPtr->calcSize.cy;
 832
 833     if (GetWindowLongA (hwnd, GWL_STYLE) & WS_BORDER)
 834         nHeight += (2 * GetSystemMetrics(SM_CYEDGE));
 835
 836
 837     FIXME("height = %d\n", nHeight);
 838
 839     return nHeight;
 840 }
 841
 842
 843 static LRESULT
 844 REBAR_GetBarInfo (HWND hwnd, WPARAM wParam, LPARAM lParam)
 845 {
 846     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 847     LPREBARINFO lpInfo = (LPREBARINFO)lParam;
 848
 849     if (lpInfo == NULL)
 850         return FALSE;
 851
 852     if (lpInfo->cbSize < sizeof (REBARINFO))
 853         return FALSE;
 854
 855     TRACE("getting bar info!\n");
 856
 857     if (infoPtr->himl) {
 858         lpInfo->himl = infoPtr->himl;
 859         lpInfo->fMask |= RBIM_IMAGELIST;
 860     }
 861
 862     return TRUE;
 863 }
 864
 865
 866 inline static LRESULT
 867 REBAR_GetBkColor (HWND hwnd)
 868 {
 869     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 870
 871     TRACE("background color 0x%06lx!\n", infoPtr->clrBk);
 872
 873     return infoPtr->clrBk;
 874 }
 875
 876
 877 /* << REBAR_GetColorScheme >> */
 878 /* << REBAR_GetDropTarget >> */
 879
 880
 881 static LRESULT
 882 REBAR_GetPalette (HWND hwnd, WPARAM wParam, LPARAM lParam)
 883 {
 884     FIXME("empty stub!\n");
 885
 886     return 0;
 887 }
 888
 889
 890 static LRESULT
 891 REBAR_GetRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
 892 {
 893     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 894     INT iBand = (INT)wParam;
 895     LPRECT lprc = (LPRECT)lParam;
 896     REBAR_BAND *lpBand;
 897
 898     if ((iBand < 0) && ((UINT)iBand >= infoPtr->uNumBands))
 899         return FALSE;
 900     if (!lprc)
 901         return FALSE;
 902
 903     TRACE("band %d\n", iBand);
 904
 905     lpBand = &infoPtr->bands[iBand];
 906     CopyRect (lprc, &lpBand->rcBand);
 907 /*
 908     lprc->left   = lpBand->rcBand.left;
 909     lprc->top    = lpBand->rcBand.top;
 910     lprc->right  = lpBand->rcBand.right;
 911     lprc->bottom = lpBand->rcBand.bottom;
 912 */
 913
 914     return TRUE;
 915 }
 916
 917
 918 inline static LRESULT
 919 REBAR_GetRowCount (HWND hwnd)
 920 {
 921     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 922
 923     FIXME("%u : semi stub!\n", infoPtr->uNumBands);
 924
 925     return infoPtr->uNumBands;
 926 }
 927
 928
 929 static LRESULT
 930 REBAR_GetRowHeight (HWND hwnd, WPARAM wParam, LPARAM lParam)
 931 {
 932 /*    REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd); */
 933
 934     FIXME("-- height = 20: semi stub!\n");
 935
 936     return 20;
 937 }
 938
 939
 940 inline static LRESULT
 941 REBAR_GetTextColor (HWND hwnd)
 942 {
 943     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 944
 945     TRACE("text color 0x%06lx!\n", infoPtr->clrText);
 946
 947     return infoPtr->clrText;
 948 }
 949
 950
 951 inline static LRESULT
 952 REBAR_GetToolTips (HWND hwnd)
 953 {
 954     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 955     return infoPtr->hwndToolTip;
 956 }
 957
 958
 959 inline static LRESULT
 960 REBAR_GetUnicodeFormat (HWND hwnd)
 961 {
 962     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 963     return infoPtr->bUnicode;
 964 }
 965
 966
 967 inline static LRESULT
 968 REBAR_GetVersion (HWND hwnd)
 969 {
 970     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 971     return infoPtr->iVersion;
 972 }
 973
 974
 975 static LRESULT
 976 REBAR_HitTest (HWND hwnd, WPARAM wParam, LPARAM lParam)
 977 {
 978     /* REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd); */
 979     LPRBHITTESTINFO lprbht = (LPRBHITTESTINFO)lParam;
 980
 981     if (!lprbht)
 982         return -1;
 983
 984     REBAR_InternalHitTest (hwnd, &lprbht->pt, &lprbht->flags, &lprbht->iBand);
 985
 986     return lprbht->iBand;
 987 }
 988
 989
 990 static LRESULT
 991 REBAR_IdToIndex (HWND hwnd, WPARAM wParam, LPARAM lParam)
 992 {
 993     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
 994     UINT i;
 995
 996     if (infoPtr == NULL)
 997         return -1;
 998
 999     if (infoPtr->uNumBands < 1)
1000         return -1;
1001
1002     TRACE("id %u\n", (UINT)wParam);
1003
1004     for (i = 0; i < infoPtr->uNumBands; i++) {
1005         if (infoPtr->bands[i].wID == (UINT)wParam) {
1006             TRACE("band %u found!\n", i);
1007             return i;
1008         }
1009     }
1010
1011     TRACE("no band found!\n");
1012     return -1;
1013 }
1014
1015
1016 static LRESULT
1017 REBAR_InsertBandA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1018 {
1019     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1020     LPREBARBANDINFOA lprbbi = (LPREBARBANDINFOA)lParam;
1021     UINT uIndex = (UINT)wParam;
1022     REBAR_BAND *lpBand;
1023
1024     if (infoPtr == NULL)
1025         return FALSE;
1026     if (lprbbi == NULL)
1027         return FALSE;
1028     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEA)
1029         return FALSE;
1030
1031     TRACE("insert band at %u!\n", uIndex);
1032
1033     if (infoPtr->uNumBands == 0) {
1034         infoPtr->bands = (REBAR_BAND *)COMCTL32_Alloc (sizeof (REBAR_BAND));
1035         uIndex = 0;
1036     }
1037     else {
1038         REBAR_BAND *oldBands = infoPtr->bands;
1039         infoPtr->bands =
1040             (REBAR_BAND *)COMCTL32_Alloc ((infoPtr->uNumBands+1)*sizeof(REBAR_BAND));
1041         if (((INT)uIndex == -1) || (uIndex > infoPtr->uNumBands))
1042             uIndex = infoPtr->uNumBands;
1043
1044         /* pre insert copy */
1045         if (uIndex > 0) {
1046             memcpy (&infoPtr->bands[0], &oldBands[0],
1047                     uIndex * sizeof(REBAR_BAND));
1048         }
1049
1050         /* post copy */
1051         if (uIndex < infoPtr->uNumBands - 1) {
1052             memcpy (&infoPtr->bands[uIndex+1], &oldBands[uIndex],
1053                     (infoPtr->uNumBands - uIndex - 1) * sizeof(REBAR_BAND));
1054         }
1055
1056         COMCTL32_Free (oldBands);
1057     }
1058
1059     infoPtr->uNumBands++;
1060
1061     TRACE("index %u!\n", uIndex);
1062
1063     /* initialize band (infoPtr->bands[uIndex])*/
1064     lpBand = &infoPtr->bands[uIndex];
1065
1066     if (lprbbi->fMask & RBBIM_STYLE)
1067         lpBand->fStyle = lprbbi->fStyle;
1068
1069     if (lprbbi->fMask & RBBIM_COLORS) {
1070         lpBand->clrFore = lprbbi->clrFore;
1071         lpBand->clrBack = lprbbi->clrBack;
1072     }
1073     else {
1074         lpBand->clrFore = CLR_NONE;
1075         lpBand->clrBack = CLR_NONE;
1076     }
1077
1078     if ((lprbbi->fMask & RBBIM_TEXT) && (lprbbi->lpText)) {
1079         INT len = lstrlenA (lprbbi->lpText);
1080         if (len > 0) {
1081             lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
1082             lstrcpyAtoW (lpBand->lpText, lprbbi->lpText);
1083         }
1084     }
1085
1086     if (lprbbi->fMask & RBBIM_IMAGE)
1087         lpBand->iImage = lprbbi->iImage;
1088     else
1089         lpBand->iImage = -1;
1090
1091     if (lprbbi->fMask & RBBIM_CHILD) {
1092         TRACE("hwndChild = %x\n", lprbbi->hwndChild);
1093         lpBand->hwndChild = lprbbi->hwndChild;
1094         lpBand->hwndPrevParent =
1095             SetParent (lpBand->hwndChild, hwnd);
1096     }
1097
1098     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
1099         lpBand->cxMinChild = lprbbi->cxMinChild;
1100         lpBand->cyMinChild = lprbbi->cyMinChild;
1101         lpBand->cyMaxChild = lprbbi->cyMaxChild;
1102         lpBand->cyChild    = lprbbi->cyChild;
1103         lpBand->cyIntegral = lprbbi->cyIntegral;
1104     }
1105     else {
1106         lpBand->cxMinChild = -1;
1107         lpBand->cyMinChild = -1;
1108         lpBand->cyMaxChild = -1;
1109         lpBand->cyChild    = -1;
1110         lpBand->cyIntegral = -1;
1111     }
1112
1113     if (lprbbi->fMask & RBBIM_SIZE)
1114         lpBand->cx = lprbbi->cx;
1115     else
1116         lpBand->cx = -1;
1117
1118     if (lprbbi->fMask & RBBIM_BACKGROUND)
1119         lpBand->hbmBack = lprbbi->hbmBack;
1120
1121     if (lprbbi->fMask & RBBIM_ID)
1122         lpBand->wID = lprbbi->wID;
1123
1124     /* check for additional data */
1125     if (lprbbi->cbSize >= sizeof (REBARBANDINFOA)) {
1126         if (lprbbi->fMask & RBBIM_IDEALSIZE)
1127             lpBand->cxIdeal = lprbbi->cxIdeal;
1128
1129         if (lprbbi->fMask & RBBIM_LPARAM)
1130             lpBand->lParam = lprbbi->lParam;
1131
1132         if (lprbbi->fMask & RBBIM_HEADERSIZE)
1133             lpBand->cxHeader = lprbbi->cxHeader;
1134     }
1135
1136
1137     REBAR_Layout (hwnd, NULL);
1138     REBAR_ForceResize (hwnd);
1139     REBAR_MoveChildWindows (hwnd);
1140
1141     return TRUE;
1142 }
1143
1144
1145 static LRESULT
1146 REBAR_InsertBandW (HWND hwnd, WPARAM wParam, LPARAM lParam)
1147 {
1148     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1149     LPREBARBANDINFOW lprbbi = (LPREBARBANDINFOW)lParam;
1150     UINT uIndex = (UINT)wParam;
1151     REBAR_BAND *lpBand;
1152
1153     if (infoPtr == NULL)
1154         return FALSE;
1155     if (lprbbi == NULL)
1156         return FALSE;
1157     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEW)
1158         return FALSE;
1159
1160     TRACE("insert band at %u!\n", uIndex);
1161
1162     if (infoPtr->uNumBands == 0) {
1163         infoPtr->bands = (REBAR_BAND *)COMCTL32_Alloc (sizeof (REBAR_BAND));
1164         uIndex = 0;
1165     }
1166     else {
1167         REBAR_BAND *oldBands = infoPtr->bands;
1168         infoPtr->bands =
1169             (REBAR_BAND *)COMCTL32_Alloc ((infoPtr->uNumBands+1)*sizeof(REBAR_BAND));
1170         if (((INT)uIndex == -1) || (uIndex > infoPtr->uNumBands))
1171             uIndex = infoPtr->uNumBands;
1172
1173         /* pre insert copy */
1174         if (uIndex > 0) {
1175             memcpy (&infoPtr->bands[0], &oldBands[0],
1176                     uIndex * sizeof(REBAR_BAND));
1177         }
1178
1179         /* post copy */
1180         if (uIndex < infoPtr->uNumBands - 1) {
1181             memcpy (&infoPtr->bands[uIndex+1], &oldBands[uIndex],
1182                     (infoPtr->uNumBands - uIndex - 1) * sizeof(REBAR_BAND));
1183         }
1184
1185         COMCTL32_Free (oldBands);
1186     }
1187
1188     infoPtr->uNumBands++;
1189
1190     TRACE("index %u!\n", uIndex);
1191
1192     /* initialize band (infoPtr->bands[uIndex])*/
1193     lpBand = &infoPtr->bands[uIndex];
1194
1195     if (lprbbi->fMask & RBBIM_STYLE)
1196         lpBand->fStyle = lprbbi->fStyle;
1197
1198     if (lprbbi->fMask & RBBIM_COLORS) {
1199         lpBand->clrFore = lprbbi->clrFore;
1200         lpBand->clrBack = lprbbi->clrBack;
1201     }
1202     else {
1203         lpBand->clrFore = CLR_NONE;
1204         lpBand->clrBack = CLR_NONE;
1205     }
1206
1207     if ((lprbbi->fMask & RBBIM_TEXT) && (lprbbi->lpText)) {
1208         INT len = lstrlenW (lprbbi->lpText);
1209         if (len > 0) {
1210             lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
1211             strcpyW (lpBand->lpText, lprbbi->lpText);
1212         }
1213     }
1214
1215     if (lprbbi->fMask & RBBIM_IMAGE)
1216         lpBand->iImage = lprbbi->iImage;
1217     else
1218         lpBand->iImage = -1;
1219
1220     if (lprbbi->fMask & RBBIM_CHILD) {
1221         TRACE("hwndChild = %x\n", lprbbi->hwndChild);
1222         lpBand->hwndChild = lprbbi->hwndChild;
1223         lpBand->hwndPrevParent =
1224             SetParent (lpBand->hwndChild, hwnd);
1225     }
1226
1227     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
1228         lpBand->cxMinChild = lprbbi->cxMinChild;
1229         lpBand->cyMinChild = lprbbi->cyMinChild;
1230         lpBand->cyMaxChild = lprbbi->cyMaxChild;
1231         lpBand->cyChild    = lprbbi->cyChild;
1232         lpBand->cyIntegral = lprbbi->cyIntegral;
1233     }
1234     else {
1235         lpBand->cxMinChild = -1;
1236         lpBand->cyMinChild = -1;
1237         lpBand->cyMaxChild = -1;
1238         lpBand->cyChild    = -1;
1239         lpBand->cyIntegral = -1;
1240     }
1241
1242     if (lprbbi->fMask & RBBIM_SIZE)
1243         lpBand->cx = lprbbi->cx;
1244     else
1245         lpBand->cx = -1;
1246
1247     if (lprbbi->fMask & RBBIM_BACKGROUND)
1248         lpBand->hbmBack = lprbbi->hbmBack;
1249
1250     if (lprbbi->fMask & RBBIM_ID)
1251         lpBand->wID = lprbbi->wID;
1252
1253     /* check for additional data */
1254     if (lprbbi->cbSize >= sizeof (REBARBANDINFOW)) {
1255         if (lprbbi->fMask & RBBIM_IDEALSIZE)
1256             lpBand->cxIdeal = lprbbi->cxIdeal;
1257
1258         if (lprbbi->fMask & RBBIM_LPARAM)
1259             lpBand->lParam = lprbbi->lParam;
1260
1261         if (lprbbi->fMask & RBBIM_HEADERSIZE)
1262             lpBand->cxHeader = lprbbi->cxHeader;
1263     }
1264
1265
1266     REBAR_Layout (hwnd, NULL);
1267     REBAR_ForceResize (hwnd);
1268     REBAR_MoveChildWindows (hwnd);
1269
1270     return TRUE;
1271 }
1272
1273
1274 static LRESULT
1275 REBAR_MaximizeBand (HWND hwnd, WPARAM wParam, LPARAM lParam)
1276 {
1277 /*    REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd); */
1278
1279     FIXME("(uBand = %u fIdeal = %s)\n",
1280            (UINT)wParam, lParam ? "TRUE" : "FALSE");
1281
1282
1283     return 0;
1284 }
1285
1286
1287 static LRESULT
1288 REBAR_MinimizeBand (HWND hwnd, WPARAM wParam, LPARAM lParam)
1289 {
1290 /*    REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd); */
1291
1292     FIXME("(uBand = %u)\n", (UINT)wParam);
1293
1294
1295     return 0;
1296 }
1297
1298
1299 static LRESULT
1300 REBAR_MoveBand (HWND hwnd, WPARAM wParam, LPARAM lParam)
1301 {
1302 /*    REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd); */
1303
1304     FIXME("(iFrom = %u iTof = %u)\n",
1305            (UINT)wParam, (UINT)lParam);
1306
1307
1308     return FALSE;
1309 }
1310
1311
1312 static LRESULT
1313 REBAR_SetBandInfoA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1314 {
1315     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1316     LPREBARBANDINFOA lprbbi = (LPREBARBANDINFOA)lParam;
1317     REBAR_BAND *lpBand;
1318
1319     if (lprbbi == NULL)
1320         return FALSE;
1321     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEA)
1322         return FALSE;
1323     if ((UINT)wParam >= infoPtr->uNumBands)
1324         return FALSE;
1325
1326     TRACE("index %u\n", (UINT)wParam);
1327
1328     /* set band information */
1329     lpBand = &infoPtr->bands[(UINT)wParam];
1330
1331     if (lprbbi->fMask & RBBIM_STYLE)
1332         lpBand->fStyle = lprbbi->fStyle;
1333
1334     if (lprbbi->fMask & RBBIM_COLORS) {
1335         lpBand->clrFore = lprbbi->clrFore;
1336         lpBand->clrBack = lprbbi->clrBack;
1337     }
1338
1339     if (lprbbi->fMask & RBBIM_TEXT) {
1340         if (lpBand->lpText) {
1341             COMCTL32_Free (lpBand->lpText);
1342             lpBand->lpText = NULL;
1343         }
1344         if (lprbbi->lpText) {
1345             INT len = lstrlenA (lprbbi->lpText);
1346             lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
1347             lstrcpyAtoW (lpBand->lpText, lprbbi->lpText);
1348         }
1349     }
1350
1351     if (lprbbi->fMask & RBBIM_IMAGE)
1352         lpBand->iImage = lprbbi->iImage;
1353
1354     if (lprbbi->fMask & RBBIM_CHILD) {
1355         if (lprbbi->hwndChild) {
1356             lpBand->hwndChild = lprbbi->hwndChild;
1357             lpBand->hwndPrevParent =
1358                 SetParent (lpBand->hwndChild, hwnd);
1359         }
1360         else {
1361             TRACE("child: 0x%x  prev parent: 0x%x\n",
1362                    lpBand->hwndChild, lpBand->hwndPrevParent);
1363             lpBand->hwndChild = 0;
1364             lpBand->hwndPrevParent = 0;
1365         }
1366     }
1367
1368     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
1369         lpBand->cxMinChild = lprbbi->cxMinChild;
1370         lpBand->cyMinChild = lprbbi->cyMinChild;
1371         lpBand->cyMaxChild = lprbbi->cyMaxChild;
1372         lpBand->cyChild    = lprbbi->cyChild;
1373         lpBand->cyIntegral = lprbbi->cyIntegral;
1374     }
1375
1376     if (lprbbi->fMask & RBBIM_SIZE)
1377         lpBand->cx = lprbbi->cx;
1378
1379     if (lprbbi->fMask & RBBIM_BACKGROUND)
1380         lpBand->hbmBack = lprbbi->hbmBack;
1381
1382     if (lprbbi->fMask & RBBIM_ID)
1383         lpBand->wID = lprbbi->wID;
1384
1385     /* check for additional data */
1386     if (lprbbi->cbSize >= sizeof (REBARBANDINFOA)) {
1387         if (lprbbi->fMask & RBBIM_IDEALSIZE)
1388             lpBand->cxIdeal = lprbbi->cxIdeal;
1389
1390         if (lprbbi->fMask & RBBIM_LPARAM)
1391             lpBand->lParam = lprbbi->lParam;
1392
1393         if (lprbbi->fMask & RBBIM_HEADERSIZE)
1394             lpBand->cxHeader = lprbbi->cxHeader;
1395     }
1396
1397     REBAR_Layout (hwnd, NULL);
1398     REBAR_ForceResize (hwnd);
1399     REBAR_MoveChildWindows (hwnd);
1400
1401     return TRUE;
1402 }
1403
1404
1405 static LRESULT
1406 REBAR_SetBandInfoW (HWND hwnd, WPARAM wParam, LPARAM lParam)
1407 {
1408     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1409     LPREBARBANDINFOW lprbbi = (LPREBARBANDINFOW)lParam;
1410     REBAR_BAND *lpBand;
1411
1412     if (lprbbi == NULL)
1413         return FALSE;
1414     if (lprbbi->cbSize < REBARBANDINFO_V3_SIZEW)
1415         return FALSE;
1416     if ((UINT)wParam >= infoPtr->uNumBands)
1417         return FALSE;
1418
1419     TRACE("index %u\n", (UINT)wParam);
1420
1421     /* set band information */
1422     lpBand = &infoPtr->bands[(UINT)wParam];
1423
1424     if (lprbbi->fMask & RBBIM_STYLE)
1425         lpBand->fStyle = lprbbi->fStyle;
1426
1427     if (lprbbi->fMask & RBBIM_COLORS) {
1428         lpBand->clrFore = lprbbi->clrFore;
1429         lpBand->clrBack = lprbbi->clrBack;
1430     }
1431
1432     if (lprbbi->fMask & RBBIM_TEXT) {
1433         if (lpBand->lpText) {
1434             COMCTL32_Free (lpBand->lpText);
1435             lpBand->lpText = NULL;
1436         }
1437         if (lprbbi->lpText) {
1438             INT len = lstrlenW (lprbbi->lpText);
1439             lpBand->lpText = (LPWSTR)COMCTL32_Alloc ((len + 1)*sizeof(WCHAR));
1440             strcpyW (lpBand->lpText, lprbbi->lpText);
1441         }
1442     }
1443
1444     if (lprbbi->fMask & RBBIM_IMAGE)
1445         lpBand->iImage = lprbbi->iImage;
1446
1447     if (lprbbi->fMask & RBBIM_CHILD) {
1448         if (lprbbi->hwndChild) {
1449             lpBand->hwndChild = lprbbi->hwndChild;
1450             lpBand->hwndPrevParent =
1451                 SetParent (lpBand->hwndChild, hwnd);
1452         }
1453         else {
1454             TRACE("child: 0x%x  prev parent: 0x%x\n",
1455                    lpBand->hwndChild, lpBand->hwndPrevParent);
1456             lpBand->hwndChild = 0;
1457             lpBand->hwndPrevParent = 0;
1458         }
1459     }
1460
1461     if (lprbbi->fMask & RBBIM_CHILDSIZE) {
1462         lpBand->cxMinChild = lprbbi->cxMinChild;
1463         lpBand->cyMinChild = lprbbi->cyMinChild;
1464         lpBand->cyMaxChild = lprbbi->cyMaxChild;
1465         lpBand->cyChild    = lprbbi->cyChild;
1466         lpBand->cyIntegral = lprbbi->cyIntegral;
1467     }
1468
1469     if (lprbbi->fMask & RBBIM_SIZE)
1470         lpBand->cx = lprbbi->cx;
1471
1472     if (lprbbi->fMask & RBBIM_BACKGROUND)
1473         lpBand->hbmBack = lprbbi->hbmBack;
1474
1475     if (lprbbi->fMask & RBBIM_ID)
1476         lpBand->wID = lprbbi->wID;
1477
1478     /* check for additional data */
1479     if (lprbbi->cbSize >= sizeof (REBARBANDINFOW)) {
1480         if (lprbbi->fMask & RBBIM_IDEALSIZE)
1481             lpBand->cxIdeal = lprbbi->cxIdeal;
1482
1483         if (lprbbi->fMask & RBBIM_LPARAM)
1484             lpBand->lParam = lprbbi->lParam;
1485
1486         if (lprbbi->fMask & RBBIM_HEADERSIZE)
1487             lpBand->cxHeader = lprbbi->cxHeader;
1488     }
1489
1490     REBAR_Layout (hwnd, NULL);
1491     REBAR_ForceResize (hwnd);
1492     REBAR_MoveChildWindows (hwnd);
1493
1494     return TRUE;
1495 }
1496
1497
1498 static LRESULT
1499 REBAR_SetBarInfo (HWND hwnd, WPARAM wParam, LPARAM lParam)
1500 {
1501     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1502     LPREBARINFO lpInfo = (LPREBARINFO)lParam;
1503
1504     if (lpInfo == NULL)
1505         return FALSE;
1506
1507     if (lpInfo->cbSize < sizeof (REBARINFO))
1508         return FALSE;
1509
1510     TRACE("setting bar info!\n");
1511
1512     if (lpInfo->fMask & RBIM_IMAGELIST) {
1513         infoPtr->himl = lpInfo->himl;
1514         if (infoPtr->himl) {
1515             ImageList_GetIconSize (infoPtr->himl, &infoPtr->imageSize.cx,
1516                                    &infoPtr->imageSize.cy);
1517         }
1518         else {
1519             infoPtr->imageSize.cx = 0;
1520             infoPtr->imageSize.cy = 0;
1521         }
1522     }
1523
1524     return TRUE;
1525 }
1526
1527
1528 static LRESULT
1529 REBAR_SetBkColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
1530 {
1531     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1532     COLORREF clrTemp;
1533
1534     clrTemp = infoPtr->clrBk;
1535     infoPtr->clrBk = (COLORREF)lParam;
1536
1537     TRACE("background color 0x%06lx!\n", infoPtr->clrBk);
1538
1539     return clrTemp;
1540 }
1541
1542
1543 /* << REBAR_SetColorScheme >> */
1544 /* << REBAR_SetPalette >> */
1545
1546
1547 static LRESULT
1548 REBAR_SetParent (HWND hwnd, WPARAM wParam, LPARAM lParam)
1549 {
1550     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1551     HWND hwndTemp = infoPtr->hwndNotify;
1552
1553     infoPtr->hwndNotify = (HWND)wParam;
1554
1555     return (LRESULT)hwndTemp;
1556 }
1557
1558
1559 static LRESULT
1560 REBAR_SetTextColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
1561 {
1562     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1563     COLORREF clrTemp;
1564
1565     clrTemp = infoPtr->clrText;
1566     infoPtr->clrText = (COLORREF)lParam;
1567
1568     TRACE("text color 0x%06lx!\n", infoPtr->clrText);
1569
1570     return clrTemp;
1571 }
1572
1573
1574 /* << REBAR_SetTooltips >> */
1575
1576
1577 inline static LRESULT
1578 REBAR_SetUnicodeFormat (HWND hwnd, WPARAM wParam)
1579 {
1580     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1581     BOOL bTemp = infoPtr->bUnicode;
1582     infoPtr->bUnicode = (BOOL)wParam;
1583     return bTemp;
1584 }
1585
1586
1587 static LRESULT
1588 REBAR_SetVersion (HWND hwnd, INT iVersion)
1589 {
1590     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1591     INT iOldVersion = infoPtr->iVersion;
1592
1593     if (iVersion > COMCTL32_VERSION)
1594         return -1;
1595
1596     infoPtr->iVersion = iVersion;
1597
1598     return iOldVersion;
1599 }
1600
1601
1602 static LRESULT
1603 REBAR_ShowBand (HWND hwnd, WPARAM wParam, LPARAM lParam)
1604 {
1605     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1606     REBAR_BAND *lpBand;
1607
1608     if (((INT)wParam < 0) || ((INT)wParam > infoPtr->uNumBands))
1609         return FALSE;
1610
1611     lpBand = &infoPtr->bands[(INT)wParam];
1612
1613     if ((BOOL)lParam) {
1614         TRACE("show band %d\n", (INT)wParam);
1615         lpBand->fStyle = lpBand->fStyle & ~RBBS_HIDDEN;
1616         if (IsWindow (lpBand->hwndChild))
1617             ShowWindow (lpBand->hwndChild, SW_SHOW);
1618     }
1619     else {
1620         TRACE("hide band %d\n", (INT)wParam);
1621         lpBand->fStyle = lpBand->fStyle | RBBS_HIDDEN;
1622         if (IsWindow (lpBand->hwndChild))
1623             ShowWindow (lpBand->hwndChild, SW_SHOW);
1624     }
1625
1626     REBAR_Layout (hwnd, NULL);
1627     REBAR_ForceResize (hwnd);
1628     REBAR_MoveChildWindows (hwnd);
1629
1630     return TRUE;
1631 }
1632
1633
1634 static LRESULT
1635 REBAR_SizeToRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
1636 {
1637     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1638     LPRECT lpRect = (LPRECT)lParam;
1639
1640     if (lpRect == NULL)
1641         return FALSE;
1642
1643     FIXME("layout change not implemented!\n");
1644     FIXME("[%d %d %d %d]\n",
1645            lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
1646
1647 #if 0
1648     SetWindowPos (hwnd, 0, lpRect->left, lpRect->top,
1649                     lpRect->right - lpRect->left, lpRect->bottom - lpRect->top,
1650                     SWP_NOZORDER);
1651 #endif
1652
1653     infoPtr->calcSize.cx = lpRect->right - lpRect->left;
1654     infoPtr->calcSize.cy = lpRect->bottom - lpRect->top;
1655
1656     REBAR_ForceResize (hwnd);
1657     return TRUE;
1658 }
1659
1660
1661
1662 static LRESULT
1663 REBAR_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
1664 {
1665     REBAR_INFO *infoPtr;
1666
1667     /* allocate memory for info structure */
1668     infoPtr = (REBAR_INFO *)COMCTL32_Alloc (sizeof(REBAR_INFO));
1669     SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
1670
1671     /* initialize info structure */
1672     infoPtr->iVersion = 0;
1673     infoPtr->clrBk = CLR_NONE;
1674     infoPtr->clrText = RGB(0, 0, 0);
1675
1676     infoPtr->bAutoResize = FALSE;
1677     infoPtr->hcurArrow = LoadCursorA (0, IDC_ARROWA);
1678     infoPtr->hcurHorz  = LoadCursorA (0, IDC_SIZEWEA);
1679     infoPtr->hcurVert  = LoadCursorA (0, IDC_SIZENSA);
1680     infoPtr->hcurDrag  = LoadCursorA (0, IDC_SIZEA);
1681
1682     infoPtr->bUnicode = IsWindowUnicode (hwnd);
1683
1684     if (GetWindowLongA (hwnd, GWL_STYLE) & RBS_AUTOSIZE)
1685         FIXME("style RBS_AUTOSIZE set!\n");
1686
1687 #if 0
1688     SendMessageA (hwnd, WM_NOTIFYFORMAT, (WPARAM)hwnd, NF_QUERY);
1689 #endif
1690
1691     TRACE("created!\n");
1692     return 0;
1693 }
1694
1695
1696 static LRESULT
1697 REBAR_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
1698 {
1699     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1700     REBAR_BAND *lpBand;
1701     INT i;
1702
1703
1704     /* free rebar bands */
1705     if ((infoPtr->uNumBands > 0) && infoPtr->bands) {
1706         /* clean up each band */
1707         for (i = 0; i < infoPtr->uNumBands; i++) {
1708             lpBand = &infoPtr->bands[i];
1709
1710             /* delete text strings */
1711             if (lpBand->lpText) {
1712                 COMCTL32_Free (lpBand->lpText);
1713                 lpBand->lpText = NULL;
1714             }
1715             /* destroy child window */
1716             DestroyWindow (lpBand->hwndChild);
1717         }
1718
1719         /* free band array */
1720         COMCTL32_Free (infoPtr->bands);
1721         infoPtr->bands = NULL;
1722     }
1723
1724
1725
1726
1727     DeleteObject (infoPtr->hcurArrow);
1728     DeleteObject (infoPtr->hcurHorz);
1729     DeleteObject (infoPtr->hcurVert);
1730     DeleteObject (infoPtr->hcurDrag);
1731
1732
1733
1734
1735     /* free rebar info data */
1736     COMCTL32_Free (infoPtr);
1737     SetWindowLongA (hwnd, 0, 0);
1738     TRACE("destroyed!\n");
1739     return 0;
1740 }
1741
1742
1743 static LRESULT
1744 REBAR_GetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
1745 {
1746     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1747
1748     return (LRESULT)infoPtr->hFont;
1749 }
1750
1751
1752 #if 0
1753 static LRESULT
1754 REBAR_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
1755 {
1756     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1757
1758     return 0;
1759 }
1760 #endif
1761
1762
1763 inline static LRESULT
1764 REBAR_NCCalcSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
1765 {
1766     if (GetWindowLongA (hwnd, GWL_STYLE) & WS_BORDER) {
1767         ((LPRECT)lParam)->left   += GetSystemMetrics(SM_CXEDGE);
1768         ((LPRECT)lParam)->top    += GetSystemMetrics(SM_CYEDGE);
1769         ((LPRECT)lParam)->right  -= GetSystemMetrics(SM_CXEDGE);
1770         ((LPRECT)lParam)->bottom -= GetSystemMetrics(SM_CYEDGE);
1771     }
1772
1773     return 0;
1774 }
1775
1776
1777 static LRESULT
1778 REBAR_NCPaint (HWND hwnd, WPARAM wParam, LPARAM lParam)
1779 {
1780     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1781     RECT rcWindow;
1782     HDC hdc;
1783
1784     if (dwStyle & WS_MINIMIZE)
1785         return 0; /* Nothing to do */
1786
1787     DefWindowProcA (hwnd, WM_NCPAINT, wParam, lParam);
1788
1789     if (!(hdc = GetDCEx( hwnd, 0, DCX_USESTYLE | DCX_WINDOW )))
1790         return 0;
1791
1792     if (dwStyle & WS_BORDER) {
1793         GetWindowRect (hwnd, &rcWindow);
1794         OffsetRect (&rcWindow, -rcWindow.left, -rcWindow.top);
1795         DrawEdge (hdc, &rcWindow, EDGE_ETCHED, BF_RECT);
1796     }
1797
1798     ReleaseDC( hwnd, hdc );
1799
1800     return 0;
1801 }
1802
1803
1804 static LRESULT
1805 REBAR_Paint (HWND hwnd, WPARAM wParam)
1806 {
1807     HDC hdc;
1808     PAINTSTRUCT ps;
1809
1810     hdc = wParam==0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
1811     REBAR_Refresh (hwnd, hdc);
1812     if (!wParam)
1813         EndPaint (hwnd, &ps);
1814     return 0;
1815 }
1816
1817
1818 static LRESULT
1819 REBAR_SetCursor (HWND hwnd, WPARAM wParam, LPARAM lParam)
1820 {
1821     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1822     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1823     POINT pt;
1824     UINT  flags;
1825
1826     TRACE("code=0x%X  id=0x%X\n", LOWORD(lParam), HIWORD(lParam));
1827
1828     GetCursorPos (&pt);
1829     ScreenToClient (hwnd, &pt);
1830
1831     REBAR_InternalHitTest (hwnd, &pt, &flags, NULL);
1832
1833     if (flags == RBHT_GRABBER) {
1834         if ((dwStyle & CCS_VERT) &&
1835             !(dwStyle & RBS_VERTICALGRIPPER))
1836             SetCursor (infoPtr->hcurVert);
1837         else
1838             SetCursor (infoPtr->hcurHorz);
1839     }
1840     else if (flags != RBHT_CLIENT)
1841         SetCursor (infoPtr->hcurArrow);
1842
1843     return 0;
1844 }
1845
1846
1847 static LRESULT
1848 REBAR_SetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
1849 {
1850     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1851
1852     /* TEXTMETRIC32A tm; */
1853     HFONT hFont /*, hOldFont */;
1854     /* HDC32 hdc; */
1855
1856     infoPtr->hFont = (HFONT)wParam;
1857
1858     hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
1859 /*
1860     hdc = GetDC32 (0);
1861     hOldFont = SelectObject32 (hdc, hFont);
1862     GetTextMetrics32A (hdc, &tm);
1863     infoPtr->nHeight = tm.tmHeight + VERT_BORDER;
1864     SelectObject32 (hdc, hOldFont);
1865     ReleaseDC32 (0, hdc);
1866 */
1867     if (lParam) {
1868 /*
1869         REBAR_Layout (hwnd);
1870         hdc = GetDC32 (hwnd);
1871         REBAR_Refresh (hwnd, hdc);
1872         ReleaseDC32 (hwnd, hdc);
1873 */
1874     }
1875
1876     return 0;
1877 }
1878
1879 static LRESULT
1880 REBAR_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
1881 {
1882     REBAR_INFO *infoPtr = REBAR_GetInfoPtr (hwnd);
1883     /* DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE); */
1884     RECT rcParent;
1885     /* INT32 x, y, cx, cy; */
1886
1887     /* auto resize deadlock check */
1888     if (infoPtr->bAutoResize) {
1889         infoPtr->bAutoResize = FALSE;
1890         return 0;
1891     }
1892
1893     TRACE("sizing rebar!\n");
1894
1895     /* get parent rectangle */
1896     GetClientRect (GetParent (hwnd), &rcParent);
1897 /*
1898     REBAR_Layout (hwnd, &rcParent);
1899
1900     if (dwStyle & CCS_VERT) {
1901         if (dwStyle & CCS_LEFT == CCS_LEFT) {
1902             x = rcParent.left;
1903             y = rcParent.top;
1904             cx = infoPtr->calcSize.cx;
1905             cy = infoPtr->calcSize.cy;
1906         }
1907         else {
1908             x = rcParent.right - infoPtr->calcSize.cx;
1909             y = rcParent.top;
1910             cx = infoPtr->calcSize.cx;
1911             cy = infoPtr->calcSize.cy;
1912         }
1913     }
1914     else {
1915         if (dwStyle & CCS_TOP) {
1916             x = rcParent.left;
1917             y = rcParent.top;
1918             cx = infoPtr->calcSize.cx;
1919             cy = infoPtr->calcSize.cy;
1920         }
1921         else {
1922             x = rcParent.left;
1923             y = rcParent.bottom - infoPtr->calcSize.cy;
1924             cx = infoPtr->calcSize.cx;
1925             cy = infoPtr->calcSize.cy;
1926         }
1927     }
1928
1929     SetWindowPos32 (hwnd, 0, x, y, cx, cy,
1930                     SWP_NOZORDER | SWP_SHOWWINDOW);
1931 */
1932     REBAR_Layout (hwnd, NULL);
1933     REBAR_ForceResize (hwnd);
1934     REBAR_MoveChildWindows (hwnd);
1935
1936     return 0;
1937 }
1938
1939
1940 static LRESULT WINAPI
1941 REBAR_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1942 {
1943     TRACE("hwnd=%x msg=%x wparam=%x lparam=%lx\n", hwnd, uMsg, wParam, lParam);
1944     if (!REBAR_GetInfoPtr (hwnd) && (uMsg != WM_CREATE))
1945             return DefWindowProcA (hwnd, uMsg, wParam, lParam);
1946     switch (uMsg)
1947     {
1948 /*      case RB_BEGINDRAG: */
1949
1950         case RB_DELETEBAND:
1951             return REBAR_DeleteBand (hwnd, wParam, lParam);
1952
1953 /*      case RB_DRAGMOVE: */
1954 /*      case RB_ENDDRAG: */
1955
1956         case RB_GETBANDBORDERS:
1957             return REBAR_GetBandBorders (hwnd, wParam, lParam);
1958
1959         case RB_GETBANDCOUNT:
1960             return REBAR_GetBandCount (hwnd);
1961
1962 /*      case RB_GETBANDINFO32:  */ /* outdated, just for compatibility */
1963
1964         case RB_GETBANDINFOA:
1965             return REBAR_GetBandInfoA (hwnd, wParam, lParam);
1966
1967         case RB_GETBANDINFOW:
1968             return REBAR_GetBandInfoW (hwnd, wParam, lParam);
1969
1970         case RB_GETBARHEIGHT:
1971             return REBAR_GetBarHeight (hwnd, wParam, lParam);
1972
1973         case RB_GETBARINFO:
1974             return REBAR_GetBarInfo (hwnd, wParam, lParam);
1975
1976         case RB_GETBKCOLOR:
1977             return REBAR_GetBkColor (hwnd);
1978
1979 /*      case RB_GETCOLORSCHEME: */
1980 /*      case RB_GETDROPTARGET: */
1981
1982         case RB_GETPALETTE:
1983             return REBAR_GetPalette (hwnd, wParam, lParam);
1984
1985         case RB_GETRECT:
1986             return REBAR_GetRect (hwnd, wParam, lParam);
1987
1988         case RB_GETROWCOUNT:
1989             return REBAR_GetRowCount (hwnd);
1990
1991         case RB_GETROWHEIGHT:
1992             return REBAR_GetRowHeight (hwnd, wParam, lParam);
1993
1994         case RB_GETTEXTCOLOR:
1995             return REBAR_GetTextColor (hwnd);
1996
1997         case RB_GETTOOLTIPS:
1998             return REBAR_GetToolTips (hwnd);
1999
2000         case RB_GETUNICODEFORMAT:
2001             return REBAR_GetUnicodeFormat (hwnd);
2002
2003         case CCM_GETVERSION:
2004             return REBAR_GetVersion (hwnd);
2005
2006         case RB_HITTEST:
2007             return REBAR_HitTest (hwnd, wParam, lParam);
2008
2009         case RB_IDTOINDEX:
2010             return REBAR_IdToIndex (hwnd, wParam, lParam);
2011
2012         case RB_INSERTBANDA:
2013             return REBAR_InsertBandA (hwnd, wParam, lParam);
2014
2015         case RB_INSERTBANDW:
2016             return REBAR_InsertBandW (hwnd, wParam, lParam);
2017
2018         case RB_MAXIMIZEBAND:
2019             return REBAR_MaximizeBand (hwnd, wParam, lParam);
2020
2021         case RB_MINIMIZEBAND:
2022             return REBAR_MinimizeBand (hwnd, wParam, lParam);
2023
2024         case RB_MOVEBAND:
2025             return REBAR_MoveBand (hwnd, wParam, lParam);
2026
2027         case RB_SETBANDINFOA:
2028             return REBAR_SetBandInfoA (hwnd, wParam, lParam);
2029
2030         case RB_SETBANDINFOW:
2031             return REBAR_SetBandInfoW (hwnd, wParam, lParam);
2032
2033         case RB_SETBARINFO:
2034             return REBAR_SetBarInfo (hwnd, wParam, lParam);
2035
2036         case RB_SETBKCOLOR:
2037             return REBAR_SetBkColor (hwnd, wParam, lParam);
2038
2039 /*      case RB_SETCOLORSCHEME: */
2040 /*      case RB_SETPALETTE: */
2041 /*          return REBAR_GetPalette (hwnd, wParam, lParam); */
2042
2043         case RB_SETPARENT:
2044             return REBAR_SetParent (hwnd, wParam, lParam);
2045
2046         case RB_SETTEXTCOLOR:
2047             return REBAR_SetTextColor (hwnd, wParam, lParam);
2048
2049 /*      case RB_SETTOOLTIPS: */
2050
2051         case RB_SETUNICODEFORMAT:
2052             return REBAR_SetUnicodeFormat (hwnd, wParam);
2053
2054         case CCM_SETVERSION:
2055             return REBAR_SetVersion (hwnd, (INT)wParam);
2056
2057         case RB_SHOWBAND:
2058             return REBAR_ShowBand (hwnd, wParam, lParam);
2059
2060         case RB_SIZETORECT:
2061             return REBAR_SizeToRect (hwnd, wParam, lParam);
2062
2063
2064         case WM_COMMAND:
2065             return SendMessageA (GetParent (hwnd), uMsg, wParam, lParam);
2066
2067         case WM_CREATE:
2068             return REBAR_Create (hwnd, wParam, lParam);
2069
2070         case WM_DESTROY:
2071             return REBAR_Destroy (hwnd, wParam, lParam);
2072
2073         case WM_GETFONT:
2074             return REBAR_GetFont (hwnd, wParam, lParam);
2075
2076 /*      case WM_MOUSEMOVE: */
2077 /*          return REBAR_MouseMove (hwnd, wParam, lParam); */
2078
2079         case WM_NCCALCSIZE:
2080             return REBAR_NCCalcSize (hwnd, wParam, lParam);
2081
2082         case WM_NCPAINT:
2083             return REBAR_NCPaint (hwnd, wParam, lParam);
2084
2085         case WM_NOTIFY:
2086             return SendMessageA (GetParent (hwnd), uMsg, wParam, lParam);
2087
2088         case WM_PAINT:
2089             return REBAR_Paint (hwnd, wParam);
2090
2091         case WM_SETCURSOR:
2092             return REBAR_SetCursor (hwnd, wParam, lParam);
2093
2094         case WM_SETFONT:
2095             return REBAR_SetFont (hwnd, wParam, lParam);
2096
2097         case WM_SIZE:
2098             return REBAR_Size (hwnd, wParam, lParam);
2099
2100 /*      case WM_TIMER: */
2101
2102 /*      case WM_WININICHANGE: */
2103
2104         default:
2105             if (uMsg >= WM_USER)
2106                 ERR("unknown msg %04x wp=%08x lp=%08lx\n",
2107                      uMsg, wParam, lParam);
2108             return DefWindowProcA (hwnd, uMsg, wParam, lParam);
2109     }
2110     return 0;
2111 }
2112
2113
2114 VOID
2115 REBAR_Register (void)
2116 {
2117     WNDCLASSA wndClass;
2118
2119     ZeroMemory (&wndClass, sizeof(WNDCLASSA));
2120     wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS;
2121     wndClass.lpfnWndProc   = (WNDPROC)REBAR_WindowProc;
2122     wndClass.cbClsExtra    = 0;
2123     wndClass.cbWndExtra    = sizeof(REBAR_INFO *);
2124     wndClass.hCursor       = 0;
2125     wndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2126     wndClass.lpszClassName = REBARCLASSNAMEA;
2127
2128     RegisterClassA (&wndClass);
2129 }
2130
2131
2132 VOID
2133 REBAR_Unregister (void)
2134 {
2135     UnregisterClassA (REBARCLASSNAMEA, (HINSTANCE)NULL);
2136 }
2137