controls/toolbar.c

   1 /*
   2  * Toolbar control
   3  *
   4  * Copyright 1998 Eric Kohl
   5  *
   6  * TODO:
   7  *   - Bitmap drawing.
   8  *   - Button wrapping.
   9  *   - Messages.
  10  *   - Notifications.
  11  *   - Fix TB_GETBITMAPFLAGS.
  12  *   - Fix TB_GETROWS and TB_SETROWS.
  13  *   - Tooltip support (partially).
  14  *   - Unicode suppport.
  15  *   - Internal COMMCTL32 bitmaps.
  16  *   - Fix TOOLBAR_Customize. (Customize dialog.)
  17  *
  18  * Testing:
  19  *   - Run tests using Waite Group Windows95 API Bible Volume 2.
  20  *     The second cdrom contains executables addstr.exe, btncount.exe,
  21  *     btnstate.exe, butstrsz.exe, chkbtn.exe, chngbmp.exe, customiz.exe,
  22  *     enablebtn.exe, getbmp.exe, getbtn.exe, getflags.exe, hidebtn.exe,
  23  *     indetbtn.exe, insbtn.exe, pressbtn.exe, setbtnsz.exe, setcmdid.exe,
  24  *     setparnt.exe, setrows.exe, toolwnd.exe.
  25  *   - additional features.
  26  */
  27
  28 #include "windows.h"
  29 #include "commctrl.h"
  30 #include "cache.h"
  31 #include "toolbar.h"
  32 #include "heap.h"
  33 #include "win.h"
  34 #include "debug.h"
  35
  36
  37 #define SEPARATOR_WIDTH    8
  38 #define SEPARATOR_HEIGHT   5
  39 #define TOP_BORDER         2
  40 #define BOTTOM_BORDER      2
  41
  42
  43
  44 #define TOOLBAR_GetInfoPtr(wndPtr) ((TOOLBAR_INFO *)wndPtr->wExtra[0])
  45
  46
  47 static void
  48 TOOLBAR_DrawFlatSeparator (LPRECT32 lpRect, HDC32 hdc)
  49 {
  50     INT32 x = (lpRect->left + lpRect->right) / 2 - 1;
  51     INT32 yBottom = lpRect->bottom - 3;
  52     INT32 yTop = lpRect->top + 1;
  53
  54     SelectObject32 ( hdc, GetSysColorPen32 (COLOR_3DSHADOW));
  55     MoveToEx32 (hdc, x, yBottom, NULL);
  56     LineTo32 (hdc, x, yTop);
  57     x++;
  58     SelectObject32 ( hdc, GetSysColorPen32 (COLOR_3DHILIGHT));
  59     MoveToEx32 (hdc, x, yBottom, NULL);
  60     LineTo32 (hdc, x, yTop);
  61 }
  62
  63
  64 static void
  65 TOOLBAR_DrawString (TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr,
  66                     HDC32 hdc, INT32 nState)
  67 {
  68     RECT32 rcText = btnPtr->rect;
  69     HFONT32 hOldFont;
  70     INT32   nOldBkMode;
  71
  72     /* draw text */
  73     if ((btnPtr->iString > -1) && (btnPtr->iString < infoPtr->nNumStrings)) {
  74
  75         InflateRect32 (&rcText, -3, -3);
  76         rcText.top += infoPtr->nBitmapHeight;
  77         if (nState & (TBSTATE_PRESSED | TBSTATE_CHECKED))
  78             OffsetRect32 (&rcText, 1, 1);
  79
  80         hOldFont = SelectObject32 (hdc, infoPtr->hFont);
  81         nOldBkMode = SetBkMode32 (hdc, TRANSPARENT);
  82         if (!(nState & TBSTATE_ENABLED)) {
  83             COLORREF clrOld =
  84                 SetTextColor32 (hdc, GetSysColor32 (COLOR_3DHILIGHT));
  85             OffsetRect32 (&rcText, 1, 1);
  86             DrawText32A (hdc, infoPtr->strings[btnPtr->iString], -1, &rcText,
  87                          DT_CENTER);
  88             SetTextColor32 (hdc, GetSysColor32 (COLOR_3DSHADOW));
  89             OffsetRect32 (&rcText, -1, -1);
  90             DrawText32A (hdc, infoPtr->strings[btnPtr->iString], -1, &rcText,
  91                          DT_CENTER);
  92             SetTextColor32 (hdc, clrOld);
  93         }
  94         else if (nState & TBSTATE_INDETERMINATE) {
  95             COLORREF clrOld =
  96                 SetTextColor32 (hdc, GetSysColor32 (COLOR_3DSHADOW));
  97             DrawText32A (hdc, infoPtr->strings[btnPtr->iString], -1, &rcText,
  98                          DT_CENTER);
  99             SetTextColor32 (hdc, clrOld);
 100         }
 101         else
 102             DrawText32A (hdc, infoPtr->strings[btnPtr->iString], -1, &rcText,
 103                          DT_CENTER);
 104
 105         SelectObject32 (hdc, hOldFont);
 106         if (nOldBkMode != TRANSPARENT)
 107             SetBkMode32 (hdc, nOldBkMode);
 108     }
 109 }
 110
 111
 112 static void
 113 TOOLBAR_DrawButton (WND *wndPtr, TBUTTON_INFO *btnPtr, HDC32 hdc)
 114 {
 115     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 116     BOOL32 bFlat = (wndPtr->dwStyle & TBSTYLE_FLAT);
 117     RECT32 rc;
 118
 119     if (btnPtr->fsState & TBSTATE_HIDDEN) return;
 120
 121     rc = btnPtr->rect;
 122     if (btnPtr->fsStyle & TBSTYLE_SEP) {
 123         if ((bFlat) && (btnPtr->idCommand == 0))
 124             TOOLBAR_DrawFlatSeparator (&btnPtr->rect, hdc);
 125         return;
 126     }
 127
 128     /* disabled */
 129     if (!(btnPtr->fsState & TBSTATE_ENABLED)) {
 130         HICON32 hIcon;
 131         DrawEdge32 (hdc, &rc, EDGE_RAISED,
 132                     BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
 133
 134 //      ImageList_Draw (infoPtr->himlDis, btnPtr->iBitmap, hdc,
 135 //                      rc.left+1, rc.top+1, ILD_NORMAL);
 136         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
 137         return;
 138     }
 139
 140     /* pressed TBSTYLE_BUTTON */
 141     if (btnPtr->fsState & TBSTATE_PRESSED) {
 142         DrawEdge32 (hdc, &rc, EDGE_SUNKEN,
 143                     BF_RECT | BF_MIDDLE | BF_ADJUST);
 144         ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
 145                         rc.left+2, rc.top+2, ILD_NORMAL);
 146         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
 147         return;
 148     }
 149
 150     /* checked TBSTYLE_CHECK*/
 151     if ((btnPtr->fsStyle & TBSTYLE_CHECK) &&
 152         (btnPtr->fsState & TBSTATE_CHECKED)) {
 153         HBRUSH32 hbr;
 154         DrawEdge32 (hdc, &rc, EDGE_SUNKEN,
 155                     BF_RECT | BF_MIDDLE | BF_ADJUST);
 156
 157         hbr = SelectObject32 (hdc, CACHE_GetPattern55AABrush ());
 158         PatBlt32 (hdc, rc.left, rc.top, rc.right - rc.left,
 159                   rc.bottom - rc.top, 0x00FA0089);
 160         SelectObject32 (hdc, hbr);
 161         ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
 162                         rc.left+2, rc.top+2, ILD_NORMAL);
 163         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
 164         return;
 165     }
 166
 167     /* indeterminate */
 168     if (btnPtr->fsState & TBSTATE_INDETERMINATE) {
 169         HBRUSH32 hbr;
 170         DrawEdge32 (hdc, &rc, EDGE_RAISED,
 171                     BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
 172
 173         hbr = SelectObject32 (hdc, CACHE_GetPattern55AABrush ());
 174         PatBlt32 (hdc, rc.left, rc.top, rc.right - rc.left,
 175                   rc.bottom - rc.top, 0x00FA0089);
 176         SelectObject32 (hdc, hbr);
 177 //      ImageList_Draw (infoPtr->himlDis, btnPtr->iBitmap, hdc,
 178 //                      rc.left+1, rc.top+1, ILD_NORMAL);
 179         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
 180         return;
 181     }
 182
 183     /* normal state */
 184     DrawEdge32 (hdc, &rc, EDGE_RAISED,
 185                 BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
 186     ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
 187                     rc.left+1, rc.top+1, ILD_NORMAL);
 188     TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
 189 }
 190
 191
 192 static void
 193 TOOLBAR_Refresh (WND *wndPtr, HDC32 hdc)
 194 {
 195     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 196     TBUTTON_INFO *btnPtr;
 197     INT32 i;
 198
 199     /* draw buttons */
 200     btnPtr = infoPtr->buttons;
 201     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++)
 202         TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
 203 }
 204
 205
 206 static void
 207 TOOLBAR_CalcStrings (WND *wndPtr, LPSIZE32 lpSize)
 208 {
 209     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 210     TBUTTON_INFO *btnPtr;
 211     INT32 i;
 212     HDC32 hdc;
 213     HFONT32 hOldFont;
 214     SIZE32 sz;
 215
 216     lpSize->cx = 0;
 217     lpSize->cy = 0;
 218     hdc = GetDC32 (0);
 219     hOldFont = SelectObject32 (hdc, infoPtr->hFont);
 220
 221     btnPtr = infoPtr->buttons;
 222     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
 223         if (!(btnPtr->fsState & TBSTATE_HIDDEN) &&
 224             (btnPtr->iString > -1) &&
 225             (btnPtr->iString < infoPtr->nNumStrings)) {
 226             LPSTR lpText = infoPtr->strings[btnPtr->iString];
 227             GetTextExtentPoint32A (hdc, lpText, lstrlen32A(lpText), &sz);
 228             if (sz.cx > lpSize->cx)
 229                 lpSize->cx = sz.cx;
 230             if (sz.cy > lpSize->cy)
 231                 lpSize->cy = sz.cy;
 232         }
 233     }
 234
 235     SelectObject32 (hdc, hOldFont);
 236     ReleaseDC32 (0, hdc);
 237
 238     TRACE (toolbar, "string size %d x %d!\n", lpSize->cx, lpSize->cy);
 239 }
 240
 241
 242 static void
 243 TOOLBAR_CalcToolbar (WND *wndPtr)
 244 {
 245     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 246     TBUTTON_INFO *btnPtr;
 247     INT32 i, j, nRows;
 248     INT32 x, y, cx, cy;
 249     BOOL32 bVertical;
 250     SIZE32  sizeString;
 251
 252
 253     /* test */
 254     TOOLBAR_CalcStrings (wndPtr, &sizeString);
 255
 256     if (sizeString.cy > 0)
 257         infoPtr->nButtonHeight = sizeString.cy + infoPtr->nBitmapHeight + 6;
 258
 259     if (sizeString.cx > infoPtr->nBitmapWidth)
 260         infoPtr->nButtonWidth = sizeString.cx + 6;
 261
 262     x  = infoPtr->nIndent;
 263     y  = TOP_BORDER;
 264     cx = infoPtr->nButtonWidth;
 265     cy = infoPtr->nButtonHeight;
 266     nRows = 1;
 267
 268     btnPtr = infoPtr->buttons;
 269     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
 270         bVertical = FALSE;
 271
 272         if (btnPtr->fsState & TBSTATE_HIDDEN)
 273             continue;
 274
 275         if (btnPtr->fsStyle & TBSTYLE_SEP) {
 276             /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
 277             /* it is the actual width of the separator. This is used for */
 278             /* custom controls in toolbars.                              */
 279             if ((wndPtr->dwStyle & TBSTYLE_WRAPABLE) &&
 280                 (btnPtr->fsState & TBSTATE_WRAP)) {
 281                 x = 0;
 282                 y += cy;
 283                 cx = infoPtr->nWidth;
 284                 cy = ((btnPtr->iBitmap == 0) ?
 285                     SEPARATOR_WIDTH : btnPtr->iBitmap) * 2 / 3;
 286                 nRows++;
 287                 bVertical = TRUE;
 288             }
 289             else
 290                 cx = (btnPtr->iBitmap == 0) ?
 291                     SEPARATOR_WIDTH : btnPtr->iBitmap;
 292         }
 293         else {
 294             /* this must be a button */
 295             cx = infoPtr->nButtonWidth;
 296
 297         }
 298
 299         btnPtr->rect.left   = x;
 300         btnPtr->rect.top    = y;
 301         btnPtr->rect.right  = x + cx;
 302         btnPtr->rect.bottom = y + cy;
 303
 304         if (bVertical) {
 305             x = 0;
 306             y += cy;
 307             if (i < infoPtr->nNumButtons)
 308                 nRows++;
 309         }
 310         else
 311             x += cx;
 312     }
 313
 314     infoPtr->nHeight = y + cy + BOTTOM_BORDER;
 315     TRACE (toolbar, "toolbar height %d\n", infoPtr->nHeight);
 316 }
 317
 318
 319 static INT32
 320 TOOLBAR_InternalHitTest (WND *wndPtr, LPPOINT32 lpPt)
 321 {
 322     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 323     TBUTTON_INFO *btnPtr;
 324     INT32 i;
 325
 326     btnPtr = infoPtr->buttons;
 327     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
 328         if (btnPtr->fsState & TBSTATE_HIDDEN)
 329             continue;
 330
 331         if (btnPtr->fsStyle & TBSTYLE_SEP) {
 332             if (PtInRect32 (&btnPtr->rect, *lpPt)) {
 333                 TRACE (toolbar, " ON SEPARATOR %d!\n", i);
 334                 return -i;
 335             }
 336         }
 337         else {
 338             if (PtInRect32 (&btnPtr->rect, *lpPt)) {
 339                 TRACE (toolbar, " ON BUTTON %d!\n", i);
 340                 return i;
 341             }
 342         }
 343     }
 344
 345     TRACE (toolbar, " NOWHERE!\n");
 346     return -1;
 347 }
 348
 349
 350 static INT32
 351 TOOLBAR_GetButtonIndex (TOOLBAR_INFO *infoPtr, INT32 idCommand)
 352 {
 353     TBUTTON_INFO *btnPtr;
 354     INT32 i;
 355
 356     btnPtr = infoPtr->buttons;
 357     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
 358         if (btnPtr->idCommand == idCommand) {
 359             TRACE (toolbar, "command=%d index=%d\n", idCommand, i);
 360             return i;
 361         }
 362     }
 363     TRACE (toolbar, "no index found for command=%d\n", idCommand);
 364     return -1;
 365 }
 366
 367
 368 static INT32
 369 TOOLBAR_GetCheckedGroupButtonIndex (TOOLBAR_INFO *infoPtr, INT32 nIndex)
 370 {
 371     TBUTTON_INFO *btnPtr;
 372     INT32 nRunIndex;
 373
 374     if ((nIndex < 0) || (nIndex > infoPtr->nNumButtons))
 375         return -1;
 376
 377     /* check index button */
 378     btnPtr = &infoPtr->buttons[nIndex];
 379     if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
 380         if (btnPtr->fsState & TBSTATE_CHECKED)
 381             return nIndex;
 382     }
 383
 384     /* check previous buttons */
 385     nRunIndex = nIndex - 1;
 386     while (nRunIndex >= 0) {
 387         btnPtr = &infoPtr->buttons[nRunIndex];
 388         if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
 389             if (btnPtr->fsState & TBSTATE_CHECKED)
 390                 return nRunIndex;
 391         }
 392         else
 393             break;
 394         nRunIndex--;
 395     }
 396
 397     /* check next buttons */
 398     nRunIndex = nIndex + 1;
 399     while (nRunIndex < infoPtr->nNumButtons) {
 400         btnPtr = &infoPtr->buttons[nRunIndex];
 401         if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
 402             if (btnPtr->fsState & TBSTATE_CHECKED)
 403                 return nRunIndex;
 404         }
 405         else
 406             break;
 407         nRunIndex++;
 408     }
 409
 410     return -1;
 411 }
 412
 413
 414 static LRESULT
 415 TOOLBAR_AddBitmap (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 416 {
 417     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 418     LPTBADDBITMAP lpAddBmp = (LPTBADDBITMAP)lParam;
 419     INT32 nIndex = 0;
 420
 421     if ((!lpAddBmp) || ((INT32)wParam <= 0))
 422         return -1;
 423
 424     TRACE (toolbar, "adding %d bitmaps!\n", wParam);
 425
 426     if (!(infoPtr->himlDef)) {
 427         /* create new default image list */
 428         TRACE (toolbar, "creating default image list!\n");
 429         infoPtr->himlDef =
 430             ImageList_Create (infoPtr->nBitmapWidth, infoPtr->nBitmapHeight,
 431                               ILC_COLOR | ILC_MASK, (INT32)wParam, 2);
 432     }
 433
 434 #if 0
 435     if (!(infoPtr->himlDis)) {
 436         /* create new disabled image list */
 437         TRACE (toolbar, "creating disabled image list!\n");
 438         infoPtr->himlDis =
 439             ImageList_Create (infoPtr->nBitmapWidth,
 440                               infoPtr->nBitmapHeight, ILC_COLOR | ILC_MASK,
 441                               (INT32)wParam, 2);
 442     }
 443 #endif
 444
 445     /* Add bitmaps to the default image list */
 446     if (lpAddBmp->hInst == (HINSTANCE32)0) {
 447         nIndex =
 448             ImageList_AddMasked (infoPtr->himlDef, (HBITMAP32)lpAddBmp->nID,
 449                                  GetSysColor32 (COLOR_3DFACE));
 450     }
 451     else if (lpAddBmp->hInst == HINST_COMMCTRL) {
 452         /* add internal bitmaps */
 453         FIXME (toolbar, "internal bitmaps not supported!\n");
 454
 455         /* Hack to "add" some reserved images within the image list
 456            to get the right image indices */
 457         nIndex = ImageList_GetImageCount (infoPtr->himlDef);
 458         ImageList_SetImageCount (infoPtr->himlDef, nIndex + (INT32)wParam);
 459     }
 460     else {
 461         HBITMAP32 hBmp =
 462             LoadBitmap32A (lpAddBmp->hInst, (LPSTR)lpAddBmp->nID);
 463
 464         nIndex = ImageList_Add (infoPtr->himlDef, hBmp, (HBITMAP32)0);
 465
 466         DeleteObject32 (hBmp);
 467     }
 468
 469
 470     infoPtr->nNumBitmaps += (INT32)wParam;
 471
 472     return nIndex;
 473 }
 474
 475
 476 static LRESULT
 477 TOOLBAR_AddButtons32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 478 {
 479     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 480     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
 481     INT32 nOldButtons, nNewButtons, nAddButtons, nCount;
 482     HDC32 hdc;
 483
 484     TRACE (toolbar, "adding %d buttons!\n", wParam);
 485
 486     nAddButtons = (UINT32)wParam;
 487     nOldButtons = infoPtr->nNumButtons;
 488     nNewButtons = nOldButtons + nAddButtons;
 489
 490     if (infoPtr->nNumButtons == 0) {
 491         infoPtr->buttons =
 492             HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
 493                        sizeof (TBUTTON_INFO) * nNewButtons);
 494     }
 495     else {
 496         TBUTTON_INFO *oldButtons = infoPtr->buttons;
 497         infoPtr->buttons =
 498             HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
 499                        sizeof (TBUTTON_INFO) * nNewButtons);
 500         memcpy (&infoPtr->buttons[0], &oldButtons[0],
 501                 nOldButtons * sizeof(TBUTTON_INFO));
 502         HeapFree (GetProcessHeap (), 0, oldButtons);
 503     }
 504
 505     infoPtr->nNumButtons = nNewButtons;
 506
 507     /* insert new button data (bad implementation)*/
 508     for (nCount = 0; nCount < nAddButtons; nCount++) {
 509         infoPtr->buttons[nOldButtons+nCount].iBitmap   = lpTbb[nCount].iBitmap;
 510         infoPtr->buttons[nOldButtons+nCount].idCommand = lpTbb[nCount].idCommand;
 511         infoPtr->buttons[nOldButtons+nCount].fsState   = lpTbb[nCount].fsState;
 512         infoPtr->buttons[nOldButtons+nCount].fsStyle   = lpTbb[nCount].fsStyle;
 513         infoPtr->buttons[nOldButtons+nCount].dwData    = lpTbb[nCount].dwData;
 514         infoPtr->buttons[nOldButtons+nCount].iString   = lpTbb[nCount].iString;
 515     }
 516
 517     TOOLBAR_CalcToolbar (wndPtr);
 518
 519     hdc = GetDC32 (wndPtr->hwndSelf);
 520     TOOLBAR_Refresh (wndPtr, hdc);
 521     ReleaseDC32 (wndPtr->hwndSelf, hdc);
 522
 523     return TRUE;
 524 }
 525
 526
 527 // << TOOLBAR_AddButtons32W >>
 528
 529
 530 static LRESULT
 531 TOOLBAR_AddString32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 532 {
 533     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 534     INT32 nIndex;
 535
 536     if (wParam) {
 537         char szString[256];
 538         INT32 len;
 539         TRACE (toolbar, "adding string from resource!\n");
 540
 541         len = LoadString32A ((HINSTANCE32)wParam, (UINT32)lParam,
 542                              szString, 256);
 543
 544         TRACE (toolbar, "len=%d \"%s\"\n", len, szString);
 545         nIndex = infoPtr->nNumStrings;
 546         if (infoPtr->nNumStrings == 0) {
 547             infoPtr->strings =
 548                 HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(char *));
 549         }
 550         else {
 551             char **oldStrings = infoPtr->strings;
 552             infoPtr->strings =
 553                 HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
 554                            sizeof(char *) * (infoPtr->nNumStrings + 1));
 555             memcpy (&infoPtr->strings[0], &oldStrings[0],
 556                     sizeof(char *) * infoPtr->nNumStrings);
 557             HeapFree (GetProcessHeap (), 0, oldStrings);
 558         }
 559
 560         infoPtr->strings[infoPtr->nNumStrings] =
 561             HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(char)*(len+1));
 562         lstrcpy32A (infoPtr->strings[infoPtr->nNumStrings], szString);
 563         infoPtr->nNumStrings++;
 564     }
 565     else {
 566         char *p = (char*)lParam;
 567         INT32 len;
 568
 569         if (p == NULL) return -1;
 570         TRACE (toolbar, "adding string(s) from array!\n");
 571         nIndex = infoPtr->nNumStrings;
 572         while (*p) {
 573             len = lstrlen32A (p);
 574             TRACE (toolbar, "len=%d \"%s\"\n", len, p);
 575
 576             if (infoPtr->nNumStrings == 0) {
 577                 infoPtr->strings =
 578                     HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(char *));
 579             }
 580             else {
 581                 char **oldStrings = infoPtr->strings;
 582                 infoPtr->strings =
 583                     HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
 584                                sizeof(char *) * (infoPtr->nNumStrings + 1));
 585                 memcpy (&infoPtr->strings[0], &oldStrings[0],
 586                         sizeof(char *) * infoPtr->nNumStrings);
 587                 HeapFree (GetProcessHeap (), 0, oldStrings);
 588             }
 589
 590             infoPtr->strings[infoPtr->nNumStrings] =
 591                 HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(char)*(len+1));
 592             lstrcpy32A (infoPtr->strings[infoPtr->nNumStrings], p);
 593             infoPtr->nNumStrings++;
 594
 595             p += (len+1);
 596         }
 597     }
 598
 599     return nIndex;
 600 }
 601
 602
 603 // << TOOLBAR_AddString32W >>
 604
 605
 606 static LRESULT
 607 TOOLBAR_AutoSize (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 608 {
 609     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 610     RECT32 parent_rect;
 611     HWND32 parent;
 612     INT32  x, y, cx, cy;
 613     UINT32 uPosFlags = 0;
 614
 615     FIXME (toolbar, "auto size!\n");
 616
 617     parent = GetParent32 (wndPtr->hwndSelf);
 618     GetClientRect32(parent, &parent_rect);
 619
 620     if (wndPtr->dwStyle & CCS_NORESIZE) {
 621         uPosFlags |= SWP_NOSIZE;
 622         cx = 0;
 623         cy = 0;
 624     }
 625     else {
 626         infoPtr->nWidth = parent_rect.right - parent_rect.left;
 627         TOOLBAR_CalcToolbar (wndPtr);
 628         cy = infoPtr->nHeight;
 629         cx = infoPtr->nWidth;
 630     }
 631
 632     if (wndPtr->dwStyle & CCS_NOPARENTALIGN)
 633         uPosFlags |= SWP_NOMOVE;
 634
 635     if (!(wndPtr->dwStyle & CCS_NODIVIDER))
 636         cy += 2;
 637
 638     infoPtr->bAutoSize = TRUE;
 639     SetWindowPos32 (wndPtr->hwndSelf, 0, parent_rect.left, parent_rect.top,
 640                     cx, cy, uPosFlags | SWP_NOZORDER);
 641
 642     return 0;
 643 }
 644
 645
 646 static LRESULT
 647 TOOLBAR_ButtonCount (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 648 {
 649     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 650
 651     return infoPtr->nNumButtons;
 652 }
 653
 654
 655 static LRESULT
 656 TOOLBAR_ButtonStructSize (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 657 {
 658     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 659
 660     if (infoPtr == NULL) {
 661         ERR (toolbar, "(0x%08lx, 0x%08x, 0x%08lx)\n", (DWORD)wndPtr, wParam, lParam);
 662         ERR (toolbar, "infoPtr == NULL!\n");
 663         return 0;
 664     }
 665
 666     infoPtr->dwStructSize = (DWORD)wParam;
 667
 668     return 0;
 669 }
 670
 671
 672 static LRESULT
 673 TOOLBAR_ChangeBitmap (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 674 {
 675     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 676     TBUTTON_INFO *btnPtr;
 677     HDC32 hdc;
 678     INT32 nIndex;
 679
 680     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
 681     if (nIndex == -1)
 682         return FALSE;
 683
 684     btnPtr = &infoPtr->buttons[nIndex];
 685     btnPtr->iBitmap = LOWORD(lParam);
 686
 687     hdc = GetDC32 (wndPtr->hwndSelf);
 688     TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
 689     ReleaseDC32 (wndPtr->hwndSelf, hdc);
 690
 691     return TRUE;
 692 }
 693
 694
 695 static LRESULT
 696 TOOLBAR_CheckButton (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 697 {
 698     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 699     TBUTTON_INFO *btnPtr;
 700     HDC32 hdc;
 701     INT32 nIndex;
 702     INT32 nOldIndex = -1;
 703
 704     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
 705     if (nIndex == -1)
 706         return FALSE;
 707
 708     btnPtr = &infoPtr->buttons[nIndex];
 709
 710     if (!(btnPtr->fsStyle & TBSTYLE_CHECK))
 711         return FALSE;
 712
 713     if (LOWORD(lParam) == FALSE)
 714         btnPtr->fsState &= ~TBSTATE_CHECKED;
 715     else {
 716         if (btnPtr->fsStyle & TBSTYLE_GROUP) {
 717             nOldIndex =
 718                 TOOLBAR_GetCheckedGroupButtonIndex (infoPtr, nIndex);
 719             if (nOldIndex == nIndex)
 720                 return 0;
 721             if (nOldIndex != -1)
 722                 infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
 723         }
 724         btnPtr->fsState |= TBSTATE_CHECKED;
 725     }
 726
 727     hdc = GetDC32 (wndPtr->hwndSelf);
 728     if (nOldIndex != -1)
 729         TOOLBAR_DrawButton (wndPtr, &infoPtr->buttons[nOldIndex], hdc);
 730     TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
 731     ReleaseDC32 (wndPtr->hwndSelf, hdc);
 732
 733     /* FIXME: Send a WM_NOTIFY?? */
 734
 735     return TRUE;
 736 }
 737
 738
 739 static LRESULT
 740 TOOLBAR_CommandToIndex (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 741 {
 742     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 743
 744     return TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
 745 }
 746
 747
 748 static LRESULT
 749 TOOLBAR_Customize (WND *wndPtr)
 750 {
 751     FIXME (toolbar, "customization not implemented!\n");
 752
 753     return 0;
 754 }
 755
 756
 757 static LRESULT
 758 TOOLBAR_DeleteButton (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 759 {
 760     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 761     INT32 nIndex = (INT32)wParam;
 762
 763     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
 764         return FALSE;
 765
 766     if (infoPtr->nNumButtons == 1) {
 767         TRACE (toolbar, " simple delete!\n");
 768         HeapFree (GetProcessHeap (), 0, infoPtr->buttons);
 769         infoPtr->buttons = NULL;
 770         infoPtr->nNumButtons = 0;
 771     }
 772     else {
 773         TBUTTON_INFO *oldButtons = infoPtr->buttons;
 774         TRACE(toolbar, "complex delete! [nIndex=%d]\n", nIndex);
 775
 776         infoPtr->nNumButtons--;
 777         infoPtr->buttons = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
 778                                       sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
 779         if (nIndex > 0) {
 780             memcpy (&infoPtr->buttons[0], &oldButtons[0],
 781                     nIndex * sizeof(TBUTTON_INFO));
 782         }
 783
 784         if (nIndex < infoPtr->nNumButtons) {
 785             memcpy (&infoPtr->buttons[nIndex], &oldButtons[nIndex+1],
 786                     (infoPtr->nNumButtons - nIndex) * sizeof(TBUTTON_INFO));
 787         }
 788
 789         HeapFree (GetProcessHeap (), 0, oldButtons);
 790     }
 791
 792     TOOLBAR_CalcToolbar (wndPtr);
 793
 794     InvalidateRect32 (wndPtr->hwndSelf, NULL, TRUE);
 795     UpdateWindow32 (wndPtr->hwndSelf);
 796
 797     return TRUE;
 798 }
 799
 800
 801 static LRESULT
 802 TOOLBAR_EnableButton (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 803 {
 804     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 805     TBUTTON_INFO *btnPtr;
 806     HDC32 hdc;
 807     INT32 nIndex;
 808
 809     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
 810     if (nIndex == -1)
 811         return FALSE;
 812
 813     btnPtr = &infoPtr->buttons[nIndex];
 814     if (LOWORD(lParam) == FALSE)
 815         btnPtr->fsState &= ~(TBSTATE_ENABLED | TBSTATE_PRESSED);
 816     else
 817         btnPtr->fsState |= TBSTATE_ENABLED;
 818
 819     hdc = GetDC32 (wndPtr->hwndSelf);
 820     TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
 821     ReleaseDC32 (wndPtr->hwndSelf, hdc);
 822
 823     return TRUE;
 824 }
 825
 826
 827 // << TOOLBAR_GetAnchorHighlight >>
 828
 829
 830 static LRESULT
 831 TOOLBAR_GetBitmap (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 832 {
 833     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 834     INT32 nIndex;
 835
 836     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
 837     if (nIndex == -1)
 838         return 0;
 839
 840     return infoPtr->buttons[nIndex].iBitmap;
 841 }
 842
 843
 844 static LRESULT
 845 TOOLBAR_GetBitmapFlags (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 846 {
 847     FIXME (toolbar, "stub!\n");
 848     return 0;
 849 }
 850
 851
 852 static LRESULT
 853 TOOLBAR_GetButton (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 854 {
 855     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 856     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
 857     INT32 nIndex = (INT32)wParam;
 858     TBUTTON_INFO *btnPtr;
 859
 860     if (infoPtr == NULL) return FALSE;
 861     if (lpTbb == NULL) return FALSE;
 862
 863     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
 864         return FALSE;
 865
 866     btnPtr = &infoPtr->buttons[nIndex];
 867     lpTbb->iBitmap   = btnPtr->iBitmap;
 868     lpTbb->idCommand = btnPtr->idCommand;
 869     lpTbb->fsState   = btnPtr->fsState;
 870     lpTbb->fsStyle   = btnPtr->fsStyle;
 871     lpTbb->dwData    = btnPtr->dwData;
 872     lpTbb->iString   = btnPtr->iString;
 873
 874     return TRUE;
 875 }
 876
 877
 878 // << TOOLBAR_GetButtonInfo >>
 879
 880
 881 static LRESULT
 882 TOOLBAR_GetButtonSize (WND *wndPtr)
 883 {
 884     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 885
 886     return MAKELONG((WORD)infoPtr->nButtonWidth,
 887                     (WORD)infoPtr->nButtonHeight);
 888 }
 889
 890
 891 static LRESULT
 892 TOOLBAR_GetButtonText32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 893 {
 894     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 895     INT32 nIndex, nStringIndex;
 896
 897     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
 898     if (nIndex == -1)
 899         return -1;
 900
 901     nStringIndex = infoPtr->buttons[nIndex].iString;
 902
 903     TRACE (toolbar, "index=%d stringIndex=%d\n", nIndex, nStringIndex);
 904
 905     if ((nStringIndex < 0) || (nStringIndex >= infoPtr->nNumStrings))
 906         return -1;
 907
 908     if (lParam == 0) return -1;
 909
 910     lstrcpy32A ((LPSTR)lParam, (LPSTR)infoPtr->strings[nStringIndex]);
 911
 912     return lstrlen32A ((LPSTR)infoPtr->strings[nStringIndex]);
 913 }
 914
 915
 916 // << TOOLBAR_GetButtonText32W >>
 917 // << TOOLBAR_GetColorScheme >>
 918
 919
 920 static LRESULT
 921 TOOLBAR_GetDisabledImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 922 {
 923     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 924
 925     if (wndPtr->dwStyle & TBSTYLE_FLAT)
 926         return (LRESULT)infoPtr->himlDis;
 927     else
 928         return 0;
 929 }
 930
 931
 932 // << TOOLBAR_GetExtendedStyle >>
 933
 934
 935 static LRESULT
 936 TOOLBAR_GetHotImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 937 {
 938     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 939
 940     if (wndPtr->dwStyle & TBSTYLE_FLAT)
 941         return (LRESULT)infoPtr->himlHot;
 942     else
 943         return 0;
 944 }
 945
 946
 947 // << TOOLBAR_GetHotItem >>
 948
 949
 950 static LRESULT
 951 TOOLBAR_GetImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 952 {
 953     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 954
 955     if (wndPtr->dwStyle & TBSTYLE_FLAT)
 956         return (LRESULT)infoPtr->himlDef;
 957     else
 958         return 0;
 959 }
 960
 961
 962 // << TOOLBAR_GetInsertMark >>
 963 // << TOOLBAR_GetInsertMarkColor >>
 964
 965
 966 static LRESULT
 967 TOOLBAR_GetItemRect (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 968 {
 969     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 970     TBUTTON_INFO *btnPtr;
 971     LPRECT32     lpRect;
 972     INT32        nIndex;
 973
 974     if (infoPtr == NULL) return FALSE;
 975     nIndex = (INT32)wParam;
 976     btnPtr = &infoPtr->buttons[nIndex];
 977     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
 978         return FALSE;
 979     lpRect = (LPRECT32)lParam;
 980     if (lpRect == NULL) return FALSE;
 981     if (btnPtr->fsState & TBSTATE_HIDDEN) return FALSE;
 982
 983     lpRect->left   = btnPtr->rect.left;
 984     lpRect->right  = btnPtr->rect.right;
 985     lpRect->bottom = btnPtr->rect.bottom;
 986     lpRect->top    = btnPtr->rect.top;
 987
 988     return TRUE;
 989 }
 990
 991
 992 static LRESULT
 993 TOOLBAR_GetMaxSize (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 994 {
 995     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
 996     LPSIZE32 lpSize = (LPSIZE32)lParam;
 997
 998
 999
1000     return TRUE;
1001 }
1002
1003
1004 // << TOOLBAR_GetObject >>
1005 // << TOOLBAR_GetPadding >>
1006 // << TOOLBAR_GetRect >>
1007
1008
1009 static LRESULT
1010 TOOLBAR_GetRows (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1011 {
1012     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1013
1014     if (wndPtr->dwStyle & TBSTYLE_WRAPABLE)
1015         return infoPtr->nMaxRows;
1016     else
1017         return 1;
1018 }
1019
1020
1021 static LRESULT
1022 TOOLBAR_GetState (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1023 {
1024     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1025     INT32 nIndex;
1026
1027     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
1028     if (nIndex == -1) return -1;
1029
1030     return infoPtr->buttons[nIndex].fsState;
1031 }
1032
1033
1034 static LRESULT
1035 TOOLBAR_GetStyle (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1036 {
1037     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1038     INT32 nIndex;
1039
1040     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
1041     if (nIndex == -1) return -1;
1042
1043     return infoPtr->buttons[nIndex].fsStyle;
1044 }
1045
1046
1047 // << TOOLBAR_GetTextRows >>
1048
1049
1050 static LRESULT
1051 TOOLBAR_GetToolTips (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1052 {
1053     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1054
1055     if (infoPtr == NULL) return 0;
1056     return infoPtr->hwndToolTip;
1057 }
1058
1059
1060 // << TOOLBAR_GetUnicodeFormat >>
1061
1062
1063 static LRESULT
1064 TOOLBAR_HideButton (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1065 {
1066     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1067     TBUTTON_INFO *btnPtr;
1068     INT32 nIndex;
1069
1070     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
1071     if (nIndex == -1)
1072         return FALSE;
1073
1074     btnPtr = &infoPtr->buttons[nIndex];
1075     if (LOWORD(lParam) == FALSE)
1076         btnPtr->fsState &= ~TBSTATE_HIDDEN;
1077     else
1078         btnPtr->fsState |= TBSTATE_HIDDEN;
1079
1080     TOOLBAR_CalcToolbar (wndPtr);
1081
1082     InvalidateRect32 (wndPtr->hwndSelf, NULL, TRUE);
1083     UpdateWindow32 (wndPtr->hwndSelf);
1084
1085     return TRUE;
1086 }
1087
1088
1089 static LRESULT
1090 TOOLBAR_HitTest (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1091 {
1092     return TOOLBAR_InternalHitTest (wndPtr, (LPPOINT32)lParam);
1093 }
1094
1095
1096 static LRESULT
1097 TOOLBAR_Indeterminate (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1098 {
1099     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1100     TBUTTON_INFO *btnPtr;
1101     HDC32 hdc;
1102     INT32 nIndex;
1103
1104     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
1105     if (nIndex == -1)
1106         return FALSE;
1107
1108     btnPtr = &infoPtr->buttons[nIndex];
1109     if (LOWORD(lParam) == FALSE)
1110         btnPtr->fsState &= ~TBSTATE_INDETERMINATE;
1111     else
1112         btnPtr->fsState |= TBSTATE_INDETERMINATE;
1113
1114     hdc = GetDC32 (wndPtr->hwndSelf);
1115     TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
1116     ReleaseDC32 (wndPtr->hwndSelf, hdc);
1117
1118     return TRUE;
1119 }
1120
1121
1122 static LRESULT
1123 TOOLBAR_InsertButton32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1124 {
1125     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1126     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
1127     INT32 nIndex = (INT32)wParam;
1128     TBUTTON_INFO *oldButtons;
1129     HDC32 hdc;
1130
1131     if (lpTbb == NULL) return FALSE;
1132     if (nIndex < 0) return FALSE;
1133
1134     TRACE (toolbar, "inserting button index=%d\n", nIndex);
1135     if (nIndex > infoPtr->nNumButtons) {
1136         nIndex = infoPtr->nNumButtons;
1137         TRACE (toolbar, "adjust index=%d\n", nIndex);
1138     }
1139
1140     oldButtons = infoPtr->buttons;
1141     infoPtr->nNumButtons++;
1142     infoPtr->buttons = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
1143                                   sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
1144     /* pre insert copy */
1145     if (nIndex > 0) {
1146         memcpy (&infoPtr->buttons[0], &oldButtons[0],
1147                 nIndex * sizeof(TBUTTON_INFO));
1148     }
1149
1150     /* insert new button */
1151     infoPtr->buttons[nIndex].iBitmap   = lpTbb->iBitmap;
1152     infoPtr->buttons[nIndex].idCommand = lpTbb->idCommand;
1153     infoPtr->buttons[nIndex].fsState   = lpTbb->fsState;
1154     infoPtr->buttons[nIndex].fsStyle   = lpTbb->fsStyle;
1155     infoPtr->buttons[nIndex].dwData    = lpTbb->dwData;
1156     infoPtr->buttons[nIndex].iString   = lpTbb->iString;
1157
1158     /* post insert copy */
1159     if (nIndex < infoPtr->nNumButtons - 1) {
1160         memcpy (&infoPtr->buttons[nIndex+1], &oldButtons[nIndex],
1161                 (infoPtr->nNumButtons - nIndex - 1) * sizeof(TBUTTON_INFO));
1162     }
1163
1164     HeapFree (GetProcessHeap (), 0, oldButtons);
1165
1166     TOOLBAR_CalcToolbar (wndPtr);
1167
1168     hdc = GetDC32 (wndPtr->hwndSelf);
1169     TOOLBAR_Refresh (wndPtr, hdc);
1170     ReleaseDC32 (wndPtr->hwndSelf, hdc);
1171
1172     return TRUE;
1173 }
1174
1175
1176 // << TOOLBAR_InsertButton32W >>
1177 // << TOOLBAR_InsertMarkHitTest >>
1178
1179
1180 static LRESULT
1181 TOOLBAR_IsButtonChecked (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1182 {
1183     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1184     INT32 nIndex;
1185
1186     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
1187     if (nIndex == -1)
1188         return FALSE;
1189
1190     return (infoPtr->buttons[nIndex].fsState & TBSTATE_CHECKED);
1191 }
1192
1193
1194 static LRESULT
1195 TOOLBAR_IsButtonEnabled (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1196 {
1197     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1198     INT32 nIndex;
1199
1200     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
1201     if (nIndex == -1)
1202         return FALSE;
1203
1204     return (infoPtr->buttons[nIndex].fsState & TBSTATE_ENABLED);
1205 }
1206
1207
1208 static LRESULT
1209 TOOLBAR_IsButtonHidden (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1210 {
1211     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1212     INT32 nIndex;
1213
1214     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
1215     if (nIndex == -1)
1216         return FALSE;
1217
1218     return (infoPtr->buttons[nIndex].fsState & TBSTATE_HIDDEN);
1219 }
1220
1221
1222 static LRESULT
1223 TOOLBAR_IsButtonHighlighted (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1224 {
1225     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1226     INT32 nIndex;
1227
1228     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
1229     if (nIndex == -1)
1230         return FALSE;
1231
1232     return (infoPtr->buttons[nIndex].fsState & TBSTATE_MARKED);
1233 }
1234
1235
1236 static LRESULT
1237 TOOLBAR_IsButtonIndeterminate (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1238 {
1239     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1240     INT32 nIndex;
1241
1242     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
1243     if (nIndex == -1)
1244         return FALSE;
1245
1246     return (infoPtr->buttons[nIndex].fsState & TBSTATE_INDETERMINATE);
1247 }
1248
1249
1250 static LRESULT
1251 TOOLBAR_IsButtonPressed (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1252 {
1253     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1254     INT32 nIndex;
1255
1256     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
1257     if (nIndex == -1)
1258         return FALSE;
1259
1260     return (infoPtr->buttons[nIndex].fsState & TBSTATE_PRESSED);
1261 }
1262
1263
1264 // << TOOLBAR_LoadImages >>
1265 // << TOOLBAR_MapAccelerator >>
1266 // << TOOLBAR_MarkButton >>
1267 // << TOOLBAR_MoveButton >>
1268
1269
1270 static LRESULT
1271 TOOLBAR_PressButton (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1272 {
1273     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1274     TBUTTON_INFO *btnPtr;
1275     HDC32 hdc;
1276     INT32 nIndex;
1277
1278     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
1279     if (nIndex == -1)
1280         return FALSE;
1281
1282     btnPtr = &infoPtr->buttons[nIndex];
1283     if (LOWORD(lParam) == FALSE)
1284         btnPtr->fsState &= ~TBSTATE_PRESSED;
1285     else
1286         btnPtr->fsState |= TBSTATE_PRESSED;
1287
1288     hdc = GetDC32 (wndPtr->hwndSelf);
1289     TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
1290     ReleaseDC32 (wndPtr->hwndSelf, hdc);
1291
1292     return TRUE;
1293 }
1294
1295
1296 // << TOOLBAR_ReplaceBitmap >>
1297
1298
1299 static LRESULT
1300 TOOLBAR_SaveRestore32A (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1301 {
1302     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1303     LPTBSAVEPARAMS32A lpSave = (LPTBSAVEPARAMS32A)lParam;
1304
1305     if (lpSave == NULL) return 0;
1306
1307     if ((BOOL32)wParam) {
1308         /* save toolbar information */
1309         FIXME (toolbar, "save to \"%s\" \"%s\"\n",
1310                lpSave->pszSubKey, lpSave->pszValueName);
1311
1312
1313     }
1314     else {
1315         /* restore toolbar information */
1316
1317         FIXME (toolbar, "restore from \"%s\" \"%s\"\n",
1318                lpSave->pszSubKey, lpSave->pszValueName);
1319
1320
1321     }
1322
1323     return 0;
1324 }
1325
1326
1327 // << TOOLBAR_SaveRestore32W >>
1328 // << TOOLBAR_SetAnchorHighlight >>
1329
1330
1331 static LRESULT
1332 TOOLBAR_SetBitmapSize (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1333 {
1334     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1335
1336     if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0))
1337         return FALSE;
1338
1339     infoPtr->nBitmapWidth = (INT32)LOWORD(lParam);
1340     infoPtr->nBitmapHeight = (INT32)HIWORD(lParam);
1341
1342     return TRUE;
1343 }
1344
1345
1346 // << TOOLBAR_SetButtonInfo >>
1347
1348
1349 static LRESULT
1350 TOOLBAR_SetButtonSize (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1351 {
1352     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1353
1354     if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0))
1355         return FALSE;
1356
1357     infoPtr->nButtonWidth = (INT32)LOWORD(lParam);
1358     infoPtr->nButtonHeight = (INT32)HIWORD(lParam);
1359
1360     return TRUE;
1361 }
1362
1363
1364 // << TOOLBAR_SetButtonWidth >>
1365
1366
1367 static LRESULT
1368 TOOLBAR_SetCmdId (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1369 {
1370     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1371     INT32 nIndex = (INT32)wParam;
1372
1373     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
1374         return FALSE;
1375
1376     infoPtr->buttons[nIndex].idCommand = (INT32)lParam;
1377
1378     return TRUE;
1379 }
1380
1381
1382 // << TOOLBAR_SetColorScheme >>
1383
1384
1385 static LRESULT
1386 TOOLBAR_SetDisabledImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1387 {
1388     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1389     HIMAGELIST himlTemp;
1390
1391     if (!(wndPtr->dwStyle & TBSTYLE_FLAT))
1392         return 0;
1393
1394     himlTemp = infoPtr->himlDis;
1395     infoPtr->himlDis = (HIMAGELIST)lParam;
1396
1397     /* FIXME: redraw ? */
1398
1399     return (LRESULT)himlTemp;
1400 }
1401
1402
1403 // << TOOLBAR_SetDrawTextFlags >>
1404
1405
1406 static LRESULT
1407 TOOLBAR_SetExtendedStyle (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1408 {
1409     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1410     DWORD dwTemp;
1411
1412     dwTemp = infoPtr->dwExStyle;
1413     infoPtr->dwExStyle = (DWORD)lParam;
1414
1415     return (LRESULT)dwTemp;
1416 }
1417
1418
1419 static LRESULT
1420 TOOLBAR_SetHotImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1421 {
1422     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1423     HIMAGELIST himlTemp;
1424
1425     if (!(wndPtr->dwStyle & TBSTYLE_FLAT))
1426         return 0;
1427
1428     himlTemp = infoPtr->himlHot;
1429     infoPtr->himlHot = (HIMAGELIST)lParam;
1430
1431     /* FIXME: redraw ? */
1432
1433     return (LRESULT)himlTemp;
1434 }
1435
1436
1437 // << TOOLBAR_SetHotItem >>
1438
1439
1440 static LRESULT
1441 TOOLBAR_SetImageList (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1442 {
1443     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1444     HIMAGELIST himlTemp;
1445
1446     if (!(wndPtr->dwStyle & TBSTYLE_FLAT))
1447         return 0;
1448
1449     himlTemp = infoPtr->himlDef;
1450     infoPtr->himlDef = (HIMAGELIST)lParam;
1451
1452     /* FIXME: redraw ? */
1453
1454     return (LRESULT)himlTemp;
1455 }
1456
1457
1458 static LRESULT
1459 TOOLBAR_SetIndent (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1460 {
1461     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1462     HDC32 hdc;
1463
1464     infoPtr->nIndent = (INT32)wParam;
1465     TOOLBAR_CalcToolbar (wndPtr);
1466     hdc = GetDC32 (wndPtr->hwndSelf);
1467     TOOLBAR_Refresh (wndPtr, hdc);
1468     ReleaseDC32 (wndPtr->hwndSelf, hdc);
1469
1470     return TRUE;
1471 }
1472
1473
1474 // << TOOLBAR_SetInsertMark >>
1475
1476
1477 static LRESULT
1478 TOOLBAR_SetInsertMarkColor (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1479 {
1480     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1481
1482     infoPtr->clrInsertMark = (COLORREF)lParam;
1483
1484     /* FIXME : redraw ??*/
1485
1486     return 0;
1487 }
1488
1489
1490 // << TOOLBAR_SetMaxTextRows >>
1491 // << TOOLBAR_SetPadding >>
1492
1493
1494 static LRESULT
1495 TOOLBAR_SetParent (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1496 {
1497     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1498     HWND32 hwndOldNotify;
1499
1500     if (infoPtr == NULL) return 0;
1501     hwndOldNotify = infoPtr->hwndNotify;
1502     infoPtr->hwndNotify = (HWND32)wParam;
1503
1504     return hwndOldNotify;
1505 }
1506
1507
1508 static LRESULT
1509 TOOLBAR_SetRows (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1510 {
1511     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1512
1513     FIXME (toolbar, "support multiple rows!\n");
1514
1515     return 0;
1516 }
1517
1518
1519 static LRESULT
1520 TOOLBAR_SetState (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1521 {
1522     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1523     TBUTTON_INFO *btnPtr;
1524     HDC32 hdc;
1525     INT32 nIndex;
1526
1527     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
1528     if (nIndex == -1)
1529         return FALSE;
1530
1531     btnPtr = &infoPtr->buttons[nIndex];
1532     btnPtr->fsState = LOWORD(lParam);
1533
1534     hdc = GetDC32 (wndPtr->hwndSelf);
1535     TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
1536     ReleaseDC32 (wndPtr->hwndSelf, hdc);
1537
1538     return TRUE;
1539 }
1540
1541
1542 static LRESULT
1543 TOOLBAR_SetStyle (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1544 {
1545     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1546     TBUTTON_INFO *btnPtr;
1547     HDC32 hdc;
1548     INT32 nIndex;
1549
1550     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT32)wParam);
1551     if (nIndex == -1)
1552         return FALSE;
1553
1554     btnPtr = &infoPtr->buttons[nIndex];
1555     btnPtr->fsStyle = LOWORD(lParam);
1556
1557     hdc = GetDC32 (wndPtr->hwndSelf);
1558     TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
1559     ReleaseDC32 (wndPtr->hwndSelf, hdc);
1560
1561     return TRUE;
1562 }
1563
1564
1565 static LRESULT
1566 TOOLBAR_SetToolTips (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1567 {
1568     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1569
1570     if (infoPtr == NULL) return 0;
1571     infoPtr->hwndToolTip = (HWND32)wParam;
1572     return 0;
1573 }
1574
1575
1576 static LRESULT
1577 TOOLBAR_SetUnicodeFormat (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1578 {
1579     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1580
1581     FIXME (toolbar, "hwnd=0x%04x stub!\n", wndPtr->hwndSelf);
1582
1583     return 0;
1584 }
1585
1586
1587 static LRESULT
1588 TOOLBAR_Create (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1589 {
1590     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1591     LOGFONT32A logFont;
1592
1593     /* initialize info structure */
1594     infoPtr->nButtonHeight = 22;
1595     infoPtr->nButtonWidth = 23;
1596     infoPtr->nBitmapHeight = 15;
1597     infoPtr->nBitmapWidth = 16;
1598
1599     infoPtr->nHeight = infoPtr->nButtonHeight + TOP_BORDER + BOTTOM_BORDER;
1600     infoPtr->nMaxRows = 1;
1601
1602     infoPtr->bCaptured = 0;
1603     infoPtr->nButtonDown = -1;
1604     infoPtr->nOldHit = -1;
1605
1606     infoPtr->hwndNotify = GetParent32 (wndPtr->hwndSelf);
1607     infoPtr->bTransparent = (wndPtr->dwStyle & TBSTYLE_FLAT);
1608     infoPtr->nHotItem = -1;
1609
1610     SystemParametersInfo32A (SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
1611     infoPtr->hFont = CreateFontIndirect32A (&logFont);
1612
1613     if (wndPtr->dwStyle & TBSTYLE_TOOLTIPS) {
1614         /* Create tooltip control */
1615 //      infoPtr->hwndToolTip = CreateWindowEx32A (....);
1616
1617         /* Send NM_TOOLTIPSCREATED notification */
1618
1619     }
1620
1621     return 0;
1622 }
1623
1624
1625 static LRESULT
1626 TOOLBAR_Destroy (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1627 {
1628     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1629
1630     /* delete tooltip control */
1631     if (infoPtr->hwndToolTip)
1632         DestroyWindow32 (infoPtr->hwndToolTip);
1633
1634     /* delete button data */
1635     if (infoPtr->buttons)
1636         HeapFree (GetProcessHeap (), 0, infoPtr->buttons);
1637
1638     /* delete strings */
1639     if (infoPtr->strings) {
1640         INT32 i;
1641         for (i = 0; i < infoPtr->nNumStrings; i++)
1642             if (infoPtr->strings[i])
1643                 HeapFree (GetProcessHeap (), 0, infoPtr->strings[i]);
1644
1645         HeapFree (GetProcessHeap (), 0, infoPtr->strings);
1646     }
1647
1648     /* destroy default image list */
1649     if (infoPtr->himlDef)
1650         ImageList_Destroy (infoPtr->himlDef);
1651
1652     /* destroy disabled image list */
1653     if (infoPtr->himlDis)
1654         ImageList_Destroy (infoPtr->himlDis);
1655
1656     /* destroy hot image list */
1657     if (infoPtr->himlHot)
1658         ImageList_Destroy (infoPtr->himlHot);
1659
1660     /* delete default font */
1661     if (infoPtr->hFont)
1662         DeleteObject32 (infoPtr->hFont);
1663
1664     /* free toolbar info data */
1665     HeapFree (GetProcessHeap (), 0, infoPtr);
1666
1667     return 0;
1668 }
1669
1670
1671 static LRESULT
1672 TOOLBAR_EraseBackground (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1673 {
1674     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1675
1676     if (infoPtr->bTransparent)
1677         return SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_ERASEBKGND,
1678                                wParam, lParam);
1679
1680     return DefWindowProc32A (wndPtr->hwndSelf, WM_ERASEBKGND, wParam, lParam);
1681 }
1682
1683
1684 static LRESULT
1685 TOOLBAR_LButtonDblClk (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1686 {
1687     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1688     TBUTTON_INFO *btnPtr;
1689     POINT32 pt;
1690     INT32   nHit;
1691     HDC32   hdc;
1692
1693     pt.x = (INT32)LOWORD(lParam);
1694     pt.y = (INT32)HIWORD(lParam);
1695     nHit = TOOLBAR_InternalHitTest (wndPtr, &pt);
1696
1697     if (nHit >= 0) {
1698         btnPtr = &infoPtr->buttons[nHit];
1699         if (!(btnPtr->fsState & TBSTATE_ENABLED))
1700             return 0;
1701         SetCapture32 (wndPtr->hwndSelf);
1702         infoPtr->bCaptured = TRUE;
1703         infoPtr->nButtonDown = nHit;
1704
1705         btnPtr->fsState |= TBSTATE_PRESSED;
1706
1707         hdc = GetDC32 (wndPtr->hwndSelf);
1708         TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
1709         ReleaseDC32 (wndPtr->hwndSelf, hdc);
1710     }
1711     else if (wndPtr->dwStyle & CCS_ADJUSTABLE)
1712         TOOLBAR_Customize (wndPtr);
1713
1714     return 0;
1715 }
1716
1717
1718 static LRESULT
1719 TOOLBAR_LButtonDown (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1720 {
1721     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1722     TBUTTON_INFO *btnPtr;
1723     POINT32 pt;
1724     INT32   nHit;
1725     HDC32   hdc;
1726
1727     pt.x = (INT32)LOWORD(lParam);
1728     pt.y = (INT32)HIWORD(lParam);
1729     nHit = TOOLBAR_InternalHitTest (wndPtr, &pt);
1730
1731     if (nHit >= 0) {
1732         btnPtr = &infoPtr->buttons[nHit];
1733         if (!(btnPtr->fsState & TBSTATE_ENABLED))
1734             return 0;
1735
1736         SetCapture32 (wndPtr->hwndSelf);
1737         infoPtr->bCaptured = TRUE;
1738         infoPtr->nButtonDown = nHit;
1739         infoPtr->nOldHit = nHit;
1740
1741         btnPtr->fsState |= TBSTATE_PRESSED;
1742
1743         hdc = GetDC32 (wndPtr->hwndSelf);
1744         TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
1745         ReleaseDC32 (wndPtr->hwndSelf, hdc);
1746     }
1747
1748
1749     return 0;
1750 }
1751
1752
1753 static LRESULT
1754 TOOLBAR_LButtonUp (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1755 {
1756     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1757     TBUTTON_INFO *btnPtr;
1758     POINT32 pt;
1759     INT32   nHit;
1760     INT32   nOldIndex = -1;
1761     HDC32   hdc;
1762     BOOL32  bSendMessage = TRUE;
1763
1764     pt.x = (INT32)LOWORD(lParam);
1765     pt.y = (INT32)HIWORD(lParam);
1766     nHit = TOOLBAR_InternalHitTest (wndPtr, &pt);
1767
1768     if ((infoPtr->bCaptured) && (infoPtr->nButtonDown >= 0)) {
1769         infoPtr->bCaptured = FALSE;
1770         ReleaseCapture ();
1771         btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
1772         btnPtr->fsState &= ~TBSTATE_PRESSED;
1773
1774         if (nHit == infoPtr->nButtonDown) {
1775             if (btnPtr->fsStyle & TBSTYLE_CHECK) {
1776                 if (btnPtr->fsStyle & TBSTYLE_GROUP) {
1777                     nOldIndex = TOOLBAR_GetCheckedGroupButtonIndex (infoPtr,
1778                         infoPtr->nButtonDown);
1779                     if (nOldIndex == infoPtr->nButtonDown)
1780                         bSendMessage = FALSE;
1781                     if ((nOldIndex != infoPtr->nButtonDown) &&
1782                         (nOldIndex != -1))
1783                         infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
1784                     btnPtr->fsState |= TBSTATE_CHECKED;
1785                 }
1786                 else {
1787                     if (btnPtr->fsState & TBSTATE_CHECKED)
1788                         btnPtr->fsState &= ~TBSTATE_CHECKED;
1789                     else
1790                         btnPtr->fsState |= TBSTATE_CHECKED;
1791                 }
1792             }
1793         }
1794         else
1795             bSendMessage = FALSE;
1796
1797         hdc = GetDC32 (wndPtr->hwndSelf);
1798         if (nOldIndex != -1)
1799             TOOLBAR_DrawButton (wndPtr, &infoPtr->buttons[nOldIndex], hdc);
1800         TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
1801         ReleaseDC32 (wndPtr->hwndSelf, hdc);
1802
1803         if (bSendMessage)
1804             SendMessage32A (infoPtr->hwndNotify, WM_COMMAND,
1805                             MAKEWPARAM(btnPtr->idCommand, 0),
1806                             (LPARAM)wndPtr->hwndSelf);
1807
1808         infoPtr->nButtonDown = -1;
1809         infoPtr->nOldHit = -1;
1810     }
1811
1812     return 0;
1813 }
1814
1815
1816 static LRESULT
1817 TOOLBAR_MouseMove (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1818 {
1819     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1820     TBUTTON_INFO *btnPtr;
1821     POINT32 pt;
1822     INT32   nHit;
1823     HDC32   hdc;
1824
1825     pt.x = (INT32)LOWORD(lParam);
1826     pt.y = (INT32)HIWORD(lParam);
1827     nHit = TOOLBAR_InternalHitTest (wndPtr, &pt);
1828
1829     if (infoPtr->bCaptured) {
1830         if (infoPtr->nOldHit != nHit) {
1831             btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
1832             if (infoPtr->nOldHit == infoPtr->nButtonDown) {
1833                 btnPtr->fsState &= ~TBSTATE_PRESSED;
1834                 hdc = GetDC32 (wndPtr->hwndSelf);
1835                 TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
1836                 ReleaseDC32 (wndPtr->hwndSelf, hdc);
1837             }
1838             else if (nHit == infoPtr->nButtonDown) {
1839                 btnPtr->fsState |= TBSTATE_PRESSED;
1840                 hdc = GetDC32 (wndPtr->hwndSelf);
1841                 TOOLBAR_DrawButton (wndPtr, btnPtr, hdc);
1842                 ReleaseDC32 (wndPtr->hwndSelf, hdc);
1843             }
1844         }
1845         infoPtr->nOldHit = nHit;
1846     }
1847
1848     return 0;
1849 }
1850
1851
1852
1853
1854
1855 static LRESULT
1856 TOOLBAR_NCCalcSize (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1857 {
1858     if (!(wndPtr->dwStyle & CCS_NODIVIDER)) {
1859         LPRECT32 winRect  = (LPRECT32)lParam;
1860         winRect->top    += 2;
1861         winRect->bottom += 2;
1862     }
1863
1864     return DefWindowProc32A (wndPtr->hwndSelf, WM_NCCALCSIZE, wParam, lParam);
1865 }
1866
1867
1868 static LRESULT
1869 TOOLBAR_NCCreate (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1870 {
1871     TOOLBAR_INFO *infoPtr;
1872
1873     /* allocate memory for info structure */
1874     infoPtr = (TOOLBAR_INFO *)HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
1875                                    sizeof(TOOLBAR_INFO));
1876     wndPtr->wExtra[0] = (DWORD)infoPtr;
1877
1878     if (infoPtr == NULL) {
1879         ERR (toolbar, "could not allocate info memory!\n");
1880         return 0;
1881     }
1882
1883     if ((TOOLBAR_INFO*)wndPtr->wExtra[0] != infoPtr) {
1884         ERR (toolbar, "pointer assignment error!\n");
1885         return 0;
1886     }
1887
1888     /* this is just for security (reliable??)*/
1889     infoPtr->dwStructSize = sizeof(TBBUTTON);
1890
1891     return DefWindowProc32A (wndPtr->hwndSelf, WM_NCCREATE, wParam, lParam);
1892 }
1893
1894
1895 static LRESULT
1896 TOOLBAR_NCPaint (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1897 {
1898     HDC32 hdc;
1899     RECT32 rect;
1900     HWND32 hwnd = wndPtr->hwndSelf;
1901
1902     if ( wndPtr->dwStyle & WS_MINIMIZE ||
1903         !WIN_IsWindowDrawable( wndPtr, 0 )) return 0; /* Nothing to do */
1904
1905     DefWindowProc32A (hwnd, WM_NCPAINT, wParam, lParam);
1906
1907     if (!(hdc = GetDCEx32( hwnd, 0, DCX_USESTYLE | DCX_WINDOW ))) return 0;
1908
1909     if (ExcludeVisRect( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
1910                         wndPtr->rectClient.top-wndPtr->rectWindow.top,
1911                         wndPtr->rectClient.right-wndPtr->rectWindow.left,
1912                         wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
1913         == NULLREGION)
1914     {
1915         ReleaseDC32( hwnd, hdc );
1916         return 0;
1917     }
1918
1919     if (!(wndPtr->flags & WIN_MANAGED)) {
1920         if (!(wndPtr->dwStyle & CCS_NODIVIDER)) {
1921             rect.left = wndPtr->rectClient.left;
1922             rect.top = wndPtr->rectClient.top - 2;
1923             rect.right = wndPtr->rectClient.right;
1924
1925             SelectObject32 ( hdc, GetSysColorPen32 (COLOR_3DSHADOW));
1926             MoveToEx32 (hdc, rect.left, rect.top, NULL);
1927             LineTo32 (hdc, rect.right, rect.top);
1928             rect.top++;
1929             SelectObject32 ( hdc, GetSysColorPen32 (COLOR_3DHILIGHT));
1930             MoveToEx32 (hdc, rect.left, rect.top, NULL);
1931             LineTo32 (hdc, rect.right, rect.top);
1932         }
1933
1934     }
1935
1936     ReleaseDC32( hwnd, hdc );
1937
1938     return 0;
1939 }
1940
1941
1942 static LRESULT
1943 TOOLBAR_Paint (WND *wndPtr, WPARAM32 wParam)
1944 {
1945     HDC32 hdc;
1946     PAINTSTRUCT32 ps;
1947
1948     hdc = wParam==0 ? BeginPaint32 (wndPtr->hwndSelf, &ps) : (HDC32)wParam;
1949     TOOLBAR_Refresh (wndPtr, hdc);
1950     if (!wParam)
1951         EndPaint32 (wndPtr->hwndSelf, &ps);
1952     return 0;
1953 }
1954
1955
1956 static LRESULT
1957 TOOLBAR_Size (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
1958 {
1959     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(wndPtr);
1960     RECT32 parent_rect;
1961     HWND32 parent;
1962     INT32  x, y, cx, cy;
1963     INT32  flags;
1964     UINT32 uPosFlags = 0;
1965
1966     /* Resize deadlock check */
1967     if (infoPtr->bAutoSize) {
1968         infoPtr->bAutoSize = FALSE;
1969         return 0;
1970     }
1971
1972     flags = (INT32) wParam;
1973
1974     /* FIXME for flags =
1975      * SIZE_MAXIMIZED, SIZE_MAXSHOW, SIZE_MINIMIZED
1976      */
1977
1978     TRACE (toolbar, "sizing toolbar!\n");
1979
1980     if (flags == SIZE_RESTORED) {
1981         /* width and height don't apply */
1982         parent = GetParent32 (wndPtr->hwndSelf);
1983         GetClientRect32(parent, &parent_rect);
1984
1985         if (wndPtr->dwStyle & CCS_NORESIZE) {
1986             uPosFlags |= SWP_NOSIZE;
1987
1988             /* FIXME */
1989 //          infoPtr->nWidth = parent_rect.right - parent_rect.left;
1990             cy = infoPtr->nHeight;
1991             cx = infoPtr->nWidth;
1992             TOOLBAR_CalcToolbar (wndPtr);
1993             infoPtr->nWidth = cx;
1994             infoPtr->nHeight = cy;
1995         }
1996         else {
1997             infoPtr->nWidth = parent_rect.right - parent_rect.left;
1998             TOOLBAR_CalcToolbar (wndPtr);
1999             cy = infoPtr->nHeight;
2000             cx = infoPtr->nWidth;
2001         }
2002
2003         if (wndPtr->dwStyle & CCS_NOPARENTALIGN) {
2004             uPosFlags |= SWP_NOMOVE;
2005             cy = infoPtr->nHeight;
2006             cx = infoPtr->nWidth;
2007         }
2008
2009         if (!(wndPtr->dwStyle & CCS_NODIVIDER))
2010             cy += 2;
2011
2012         SetWindowPos32 (wndPtr->hwndSelf, 0, parent_rect.left, parent_rect.top,
2013                         cx, cy, uPosFlags | SWP_NOZORDER);
2014     }
2015     return 0;
2016 }
2017
2018
2019
2020
2021
2022
2023
2024 LRESULT WINAPI
2025 ToolbarWindowProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam)
2026 {
2027     WND *wndPtr = WIN_FindWndPtr(hwnd);
2028
2029     switch (uMsg)
2030     {
2031         case TB_ADDBITMAP:
2032             return TOOLBAR_AddBitmap (wndPtr, wParam, lParam);
2033
2034         case TB_ADDBUTTONS32A:
2035             return TOOLBAR_AddButtons32A (wndPtr, wParam, lParam);
2036
2037 //      case TB_ADDBUTTONS32W:
2038
2039         case TB_ADDSTRING32A:
2040             return TOOLBAR_AddString32A (wndPtr, wParam, lParam);
2041
2042 //      case TB_ADDSTRING32W:
2043
2044         case TB_AUTOSIZE:
2045             return TOOLBAR_AutoSize (wndPtr, wParam, lParam);
2046
2047         case TB_BUTTONCOUNT:
2048             return TOOLBAR_ButtonCount (wndPtr, wParam, lParam);
2049
2050         case TB_BUTTONSTRUCTSIZE:
2051             return TOOLBAR_ButtonStructSize (wndPtr, wParam, lParam);
2052
2053         case TB_CHANGEBITMAP:
2054             return TOOLBAR_ChangeBitmap (wndPtr, wParam, lParam);
2055
2056         case TB_CHECKBUTTON:
2057             return TOOLBAR_CheckButton (wndPtr, wParam, lParam);
2058
2059         case TB_COMMANDTOINDEX:
2060             return TOOLBAR_CommandToIndex (wndPtr, wParam, lParam);
2061
2062         case TB_CUSTOMIZE:
2063             return TOOLBAR_Customize (wndPtr);
2064
2065         case TB_DELETEBUTTON:
2066             return TOOLBAR_DeleteButton (wndPtr, wParam, lParam);
2067
2068         case TB_ENABLEBUTTON:
2069             return TOOLBAR_EnableButton (wndPtr, wParam, lParam);
2070
2071 //      case TB_GETANCHORHIGHLIGHT:             /* 4.71 */
2072
2073         case TB_GETBITMAP:
2074             return TOOLBAR_GetBitmap (wndPtr, wParam, lParam);
2075
2076         case TB_GETBITMAPFLAGS:
2077             return TOOLBAR_GetBitmapFlags (wndPtr, wParam, lParam);
2078
2079         case TB_GETBUTTON:
2080             return TOOLBAR_GetButton (wndPtr, wParam, lParam);
2081
2082 //      case TB_GETBUTTONINFO:                  /* 4.71 */
2083
2084         case TB_GETBUTTONSIZE:
2085             return TOOLBAR_GetButtonSize (wndPtr);
2086
2087         case TB_GETBUTTONTEXT32A:
2088             return TOOLBAR_GetButtonText32A (wndPtr, wParam, lParam);
2089
2090 //      case TB_GETBUTTONTEXT32W:
2091 //      case TB_GETCOLORSCHEME:                 /* 4.71 */
2092
2093         case TB_GETDISABLEDIMAGELIST:
2094             return TOOLBAR_GetDisabledImageList (wndPtr, wParam, lParam);
2095
2096 //      case TB_GETEXTENDEDSTYLE:               /* 4.71 */
2097
2098         case TB_GETHOTIMAGELIST:
2099             return TOOLBAR_GetHotImageList (wndPtr, wParam, lParam);
2100
2101 //      case TB_GETHOTITEM:                     /* 4.71 */
2102
2103         case TB_GETIMAGELIST:
2104             return TOOLBAR_GetImageList (wndPtr, wParam, lParam);
2105
2106 //      case TB_GETINSERTMARK:                  /* 4.71 */
2107 //      case TB_GETINSERTMARKCOLOR:             /* 4.71 */
2108
2109         case TB_GETITEMRECT:
2110             return TOOLBAR_GetItemRect (wndPtr, wParam, lParam);
2111
2112         case TB_GETMAXSIZE:
2113             return TOOLBAR_GetMaxSize (wndPtr, wParam, lParam);
2114
2115 //      case TB_GETOBJECT:                      /* 4.71 */
2116 //      case TB_GETPADDING:                     /* 4.71 */
2117 //      case TB_GETRECT:                        /* 4.70 */
2118
2119         case TB_GETROWS:
2120             return TOOLBAR_GetRows (wndPtr, wParam, lParam);
2121
2122         case TB_GETSTATE:
2123             return TOOLBAR_GetState (wndPtr, wParam, lParam);
2124
2125         case TB_GETSTYLE:
2126             return TOOLBAR_GetStyle (wndPtr, wParam, lParam);
2127
2128 //      case TB_GETTEXTROWS:                    /* 4.70 */
2129
2130         case TB_GETTOOLTIPS:
2131             return TOOLBAR_GetToolTips (wndPtr, wParam, lParam);
2132
2133 //      case TB_GETUNICODEFORMAT:
2134
2135         case TB_HIDEBUTTON:
2136             return TOOLBAR_HideButton (wndPtr, wParam, lParam);
2137
2138         case TB_HITTEST:
2139             return TOOLBAR_HitTest (wndPtr, wParam, lParam);
2140
2141         case TB_INDETERMINATE:
2142             return TOOLBAR_Indeterminate (wndPtr, wParam, lParam);
2143
2144         case TB_INSERTBUTTON32A:
2145             return TOOLBAR_InsertButton32A (wndPtr, wParam, lParam);
2146
2147 //      case TB_INSERTBUTTON32W:
2148 //      case TB_INSERTMARKHITTEST:              /* 4.71 */
2149
2150         case TB_ISBUTTONCHECKED:
2151             return TOOLBAR_IsButtonChecked (wndPtr, wParam, lParam);
2152
2153         case TB_ISBUTTONENABLED:
2154             return TOOLBAR_IsButtonEnabled (wndPtr, wParam, lParam);
2155
2156         case TB_ISBUTTONHIDDEN:
2157             return TOOLBAR_IsButtonHidden (wndPtr, wParam, lParam);
2158
2159         case TB_ISBUTTONHIGHLIGHTED:
2160             return TOOLBAR_IsButtonHighlighted (wndPtr, wParam, lParam);
2161
2162         case TB_ISBUTTONINDETERMINATE:
2163             return TOOLBAR_IsButtonIndeterminate (wndPtr, wParam, lParam);
2164
2165         case TB_ISBUTTONPRESSED:
2166             return TOOLBAR_IsButtonPressed (wndPtr, wParam, lParam);
2167
2168 //      case TB_LOADIMAGES:                     /* 4.70 */
2169 //      case TB_MAPACCELERATOR32A:              /* 4.71 */
2170 //      case TB_MAPACCELERATOR32W:              /* 4.71 */
2171 //      case TB_MARKBUTTON:                     /* 4.71 */
2172 //      case TB_MOVEBUTTON:                     /* 4.71 */
2173
2174         case TB_PRESSBUTTON:
2175             return TOOLBAR_PressButton (wndPtr, wParam, lParam);
2176
2177 //      case TB_REPLACEBITMAP:
2178
2179         case TB_SAVERESTORE32A:
2180             return TOOLBAR_SaveRestore32A (wndPtr, wParam, lParam);
2181
2182 //      case TB_SAVERESTORE32W:
2183 //      case TB_SETANCHORHIGHLIGHT:             /* 4.71 */
2184
2185         case TB_SETBITMAPSIZE:
2186             return TOOLBAR_SetBitmapSize (wndPtr, wParam, lParam);
2187
2188 //      case TB_SETBUTTONINFO:                  /* 4.71 */
2189
2190         case TB_SETBUTTONSIZE:
2191             return TOOLBAR_SetButtonSize (wndPtr, wParam, lParam);
2192
2193 //      case TB_SETBUTTONWIDTH:                 /* 4.70 */
2194
2195         case TB_SETCMDID:
2196             return TOOLBAR_SetCmdId (wndPtr, wParam, lParam);
2197
2198 //      case TB_SETCOLORSCHEME:                 /* 4.71 */
2199
2200         case TB_SETDISABLEDIMAGELIST:
2201             return TOOLBAR_SetDisabledImageList (wndPtr, wParam, lParam);
2202
2203 //      case TB_SETDRAWTEXTFLAGS:               /* 4.71 */
2204
2205         case TB_SETEXTENDEDSTYLE:
2206             return TOOLBAR_SetExtendedStyle (wndPtr, wParam, lParam);
2207
2208         case TB_SETHOTIMAGELIST:
2209             return TOOLBAR_SetHotImageList (wndPtr, wParam, lParam);
2210
2211 //      case TB_SETHOTITEM:                     /* 4.71 */
2212
2213         case TB_SETIMAGELIST:
2214             return TOOLBAR_SetImageList (wndPtr, wParam, lParam);
2215
2216         case TB_SETINDENT:
2217             return TOOLBAR_SetIndent (wndPtr, wParam, lParam);
2218
2219 //      case TB_SETINSERTMARK:                  /* 4.71 */
2220
2221         case TB_SETINSERTMARKCOLOR:
2222             return TOOLBAR_SetInsertMarkColor (wndPtr, wParam, lParam);
2223
2224 //      case TB_SETMAXTEXTROWS:                 /* 4.70 */
2225 //      case TB_SETPADDING:                     /* 4.71 */
2226
2227         case TB_SETPARENT:
2228             return TOOLBAR_SetParent (wndPtr, wParam, lParam);
2229
2230         case TB_SETROWS:
2231             return TOOLBAR_SetRows (wndPtr, wParam, lParam);
2232
2233         case TB_SETSTATE:
2234             return TOOLBAR_SetState (wndPtr, wParam, lParam);
2235
2236         case TB_SETSTYLE:
2237             return TOOLBAR_SetStyle (wndPtr, wParam, lParam);
2238
2239         case TB_SETTOOLTIPS:
2240             return TOOLBAR_SetToolTips (wndPtr, wParam, lParam);
2241
2242         case TB_SETUNICODEFORMAT:
2243             return TOOLBAR_SetUnicodeFormat (wndPtr, wParam, lParam);
2244
2245
2246         case WM_CREATE:
2247             return TOOLBAR_Create (wndPtr, wParam, lParam);
2248
2249         case WM_DESTROY:
2250             return TOOLBAR_Destroy (wndPtr, wParam, lParam);
2251
2252         case WM_ERASEBKGND:
2253             return TOOLBAR_EraseBackground (wndPtr, wParam, lParam);
2254
2255         case WM_LBUTTONDBLCLK:
2256             return TOOLBAR_LButtonDblClk (wndPtr, wParam, lParam);
2257
2258         case WM_LBUTTONDOWN:
2259             return TOOLBAR_LButtonDown (wndPtr, wParam, lParam);
2260
2261         case WM_LBUTTONUP:
2262             return TOOLBAR_LButtonUp (wndPtr, wParam, lParam);
2263
2264         case WM_MOUSEMOVE:
2265             return TOOLBAR_MouseMove (wndPtr, wParam, lParam);
2266
2267 //      case WM_NCACTIVATE:
2268 //          return TOOLBAR_NCActivate (wndPtr, wParam, lParam);
2269
2270         case WM_NCCALCSIZE:
2271             return TOOLBAR_NCCalcSize (wndPtr, wParam, lParam);
2272
2273         case WM_NCCREATE:
2274             return TOOLBAR_NCCreate (wndPtr, wParam, lParam);
2275
2276         case WM_NCPAINT:
2277             return TOOLBAR_NCPaint (wndPtr, wParam, lParam);
2278
2279 //      case WM_NOTIFY:
2280 //          SendMessage32A (GetParent32 (hwnd), uMsg, wParam, lParam);
2281
2282         case WM_PAINT:
2283             return TOOLBAR_Paint (wndPtr, wParam);
2284
2285         case WM_SIZE:
2286             return TOOLBAR_Size (wndPtr, wParam, lParam);
2287
2288 //      case WM_SYSCOLORCHANGE:
2289
2290 //      case WM_WININICHANGE:
2291
2292         case WM_CHARTOITEM:
2293         case WM_COMMAND:
2294         case WM_DRAWITEM:
2295         case WM_MEASUREITEM:
2296         case WM_VKEYTOITEM:
2297             return SendMessage32A (GetParent32 (hwnd), uMsg, wParam, lParam);
2298
2299         default:
2300             if (uMsg >= WM_USER)
2301                 ERR (toolbar, "unknown msg %04x wp=%08x lp=%08lx\n",
2302                      uMsg, wParam, lParam);
2303             return DefWindowProc32A (hwnd, uMsg, wParam, lParam);
2304     }
2305     return 0;
2306 }
2307
2308
2309 void
2310 TOOLBAR_Register (void)
2311 {
2312     WNDCLASS32A wndClass;
2313
2314     if (GlobalFindAtom32A (TOOLBARCLASSNAME32A)) return;
2315
2316     ZeroMemory (&wndClass, sizeof(WNDCLASS32A));
2317     wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS;
2318     wndClass.lpfnWndProc   = (WNDPROC32)ToolbarWindowProc;
2319     wndClass.cbClsExtra    = 0;
2320     wndClass.cbWndExtra    = sizeof(TOOLBAR_INFO *);
2321     wndClass.hCursor       = LoadCursor32A (0, IDC_ARROW32A);
2322     wndClass.hbrBackground = (HBRUSH32)(COLOR_3DFACE + 1);
2323     wndClass.lpszClassName = TOOLBARCLASSNAME32A;
2324
2325     RegisterClass32A (&wndClass);
2326 }
2327