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

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