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

   1 /*
   2  * Toolbar control
   3  *
   4  * Copyright 1998,1999 Eric Kohl
   5  *
   6  * TODO:
   7  *   - A little bug in TOOLBAR_DrawMasked()
   8  *   - Button wrapping (under construction).
   9  *   - Messages.
  10  *   - Notifications (under construction).
  11  *   - Fix TB_SETROWS.
  12  *   - Tooltip support (almost complete).
  13  *   - Unicode suppport (under construction).
  14  *   - Fix TOOLBAR_SetButtonInfo32A/W.
  15  *   - Customize dialog (under construction).
  16  *
  17  * Testing:
  18  *   - Run tests using Waite Group Windows95 API Bible Volume 2.
  19  *     The second cdrom contains executables addstr.exe, btncount.exe,
  20  *     btnstate.exe, butstrsz.exe, chkbtn.exe, chngbmp.exe, customiz.exe,
  21  *     enablebtn.exe, getbmp.exe, getbtn.exe, getflags.exe, hidebtn.exe,
  22  *     indetbtn.exe, insbtn.exe, pressbtn.exe, setbtnsz.exe, setcmdid.exe,
  23  *     setparnt.exe, setrows.exe, toolwnd.exe.
  24  *   - Microsofts controlspy examples.
  25  */
  26
  27 #include <string.h>
  28
  29 #include "winbase.h"
  30 #include "windef.h"
  31 #include "wingdi.h"
  32 #include "winuser.h"
  33 #include "commctrl.h"
  34 #include "cache.h"
  35 #include "comctl32.h"
  36 #include "toolbar.h"
  37 #include "debugtools.h"
  38
  39 DEFAULT_DEBUG_CHANNEL(toolbar)
  40
  41 #define SEPARATOR_WIDTH    8
  42 #define TOP_BORDER         2
  43 #define BOTTOM_BORDER      2
  44
  45 #define TOOLBAR_GetInfoPtr(hwnd) ((TOOLBAR_INFO *)GetWindowLongA(hwnd,0))
  46
  47
  48 static void
  49 TOOLBAR_DrawFlatSeparator (LPRECT lpRect, HDC hdc)
  50 {
  51     INT x = (lpRect->left + lpRect->right) / 2 - 1;
  52     INT yBottom = lpRect->bottom - 3;
  53     INT yTop = lpRect->top + 1;
  54
  55     SelectObject ( hdc, GetSysColorPen (COLOR_3DSHADOW));
  56     MoveToEx (hdc, x, yBottom, NULL);
  57     LineTo (hdc, x, yTop);
  58     x++;
  59     SelectObject ( hdc, GetSysColorPen (COLOR_3DHILIGHT));
  60     MoveToEx (hdc, x, yBottom, NULL);
  61     LineTo (hdc, x, yTop);
  62 }
  63
  64 /*
  65  * Draw the text string for this button.
  66  * note: himl is not used, except to determine whether this button has
  67  *       an associated bitmap. If so, the text is drawn below it, otherwise
  68  *       the text is drawn within the rectangle of the button itself.
  69  */
  70 static void
  71 TOOLBAR_DrawString (TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr,
  72                     HDC hdc, INT nState, DWORD dwStyle, HIMAGELIST himl)
  73 {
  74     RECT   rcText = btnPtr->rect;
  75     HFONT  hOldFont;
  76     INT    nOldBkMode;
  77     COLORREF clrOld;
  78
  79     /* draw text */
  80     if ((btnPtr->iString > -1) && (btnPtr->iString < infoPtr->nNumStrings)) {
  81
  82         InflateRect (&rcText, -3, -3);
  83         if (himl && btnPtr->iBitmap>0) {
  84                 if (dwStyle & TBSTYLE_LIST) {
  85                     rcText.left += infoPtr->nBitmapWidth;
  86                 }
  87                 else {
  88                     rcText.top += infoPtr->nBitmapHeight;
  89                 }
  90         }
  91
  92         if (nState & (TBSTATE_PRESSED | TBSTATE_CHECKED))
  93             OffsetRect (&rcText, 1, 1);
  94
  95         hOldFont = SelectObject (hdc, infoPtr->hFont);
  96         nOldBkMode = SetBkMode (hdc, TRANSPARENT);
  97         if (!(nState & TBSTATE_ENABLED)) {
  98             clrOld = SetTextColor (hdc, GetSysColor (COLOR_3DHILIGHT));
  99             OffsetRect (&rcText, 1, 1);
 100             DrawTextW (hdc, infoPtr->strings[btnPtr->iString], -1,
 101                          &rcText, infoPtr->dwDTFlags);
 102             SetTextColor (hdc, GetSysColor (COLOR_3DSHADOW));
 103             OffsetRect (&rcText, -1, -1);
 104             DrawTextW (hdc, infoPtr->strings[btnPtr->iString], -1,
 105                          &rcText, infoPtr->dwDTFlags);
 106         }
 107         else if (nState & TBSTATE_INDETERMINATE) {
 108             clrOld = SetTextColor (hdc, GetSysColor (COLOR_3DSHADOW));
 109             DrawTextW (hdc, infoPtr->strings[btnPtr->iString], -1,
 110                          &rcText, infoPtr->dwDTFlags);
 111         }
 112         else {
 113             clrOld = SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
 114             DrawTextW (hdc, infoPtr->strings[btnPtr->iString], -1,
 115                          &rcText, infoPtr->dwDTFlags);
 116         }
 117
 118         SetTextColor (hdc, clrOld);
 119         SelectObject (hdc, hOldFont);
 120         if (nOldBkMode != TRANSPARENT)
 121             SetBkMode (hdc, nOldBkMode);
 122     }
 123 }
 124
 125
 126 static void
 127 TOOLBAR_DrawPattern (HDC hdc, LPRECT lpRect)
 128 {
 129     HBRUSH hbr = SelectObject (hdc, CACHE_GetPattern55AABrush ());
 130     INT cx = lpRect->right - lpRect->left;
 131     INT cy = lpRect->bottom - lpRect->top;
 132     PatBlt (hdc, lpRect->left, lpRect->top, cx, cy, 0x00FA0089);
 133     SelectObject (hdc, hbr);
 134 }
 135
 136
 137 static void
 138 TOOLBAR_DrawMasked (TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr,
 139                     HDC hdc, INT x, INT y)
 140 {
 141     /* FIXME: this function is a hack since it uses image list
 142               internals directly */
 143
 144     HIMAGELIST himl = infoPtr->himlDef;
 145     HBITMAP hbmMask;
 146     HDC hdcImageList;
 147     HDC hdcMask;
 148
 149     if (!himl)
 150         return;
 151
 152     /* create new dc's */
 153     hdcImageList = CreateCompatibleDC (0);
 154     hdcMask = CreateCompatibleDC (0);
 155
 156     /* create new bitmap */
 157     hbmMask = CreateBitmap (himl->cx, himl->cy, 1, 1, NULL);
 158     SelectObject (hdcMask, hbmMask);
 159
 160     /* copy the mask bitmap */
 161     SelectObject (hdcImageList, himl->hbmMask);
 162     SetBkColor (hdcImageList, RGB(255, 255, 255));
 163     SetTextColor (hdcImageList, RGB(0, 0, 0));
 164     BitBlt (hdcMask, 0, 0, himl->cx, himl->cy,
 165               hdcImageList, himl->cx * btnPtr->iBitmap, 0, SRCCOPY);
 166
 167 #if 0
 168     /* add white mask from image */
 169     SelectObject (hdcImageList, himl->hbmImage);
 170     SetBkColor (hdcImageList, RGB(0, 0, 0));
 171     BitBlt (hdcMask, 0, 0, himl->cx, himl->cy,
 172               hdcImageList, himl->cx * btnPtr->iBitmap, 0, MERGEPAINT);
 173 #endif
 174
 175     /* draw the new mask */
 176     SelectObject (hdc, GetSysColorBrush (COLOR_3DHILIGHT));
 177     BitBlt (hdc, x+1, y+1, himl->cx, himl->cy,
 178               hdcMask, 0, 0, 0xB8074A);
 179
 180     SelectObject (hdc, GetSysColorBrush (COLOR_3DSHADOW));
 181     BitBlt (hdc, x, y, himl->cx, himl->cy,
 182               hdcMask, 0, 0, 0xB8074A);
 183
 184     DeleteObject (hbmMask);
 185     DeleteDC (hdcMask);
 186     DeleteDC (hdcImageList);
 187 }
 188
 189
 190 static void
 191 TOOLBAR_DrawButton (HWND hwnd, TBUTTON_INFO *btnPtr, HDC hdc)
 192 {
 193     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
 194     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
 195     RECT rc;
 196
 197     if (btnPtr->fsState & TBSTATE_HIDDEN)
 198         return;
 199
 200     rc = btnPtr->rect;
 201
 202     /* separator */
 203     if (btnPtr->fsStyle & TBSTYLE_SEP) {
 204         if ((dwStyle & TBSTYLE_FLAT) && (btnPtr->iBitmap == 0))
 205             TOOLBAR_DrawFlatSeparator (&rc, hdc);
 206         return;
 207     }
 208
 209     /* disabled */
 210     if (!(btnPtr->fsState & TBSTATE_ENABLED)) {
 211         if (!(dwStyle & TBSTYLE_FLAT))
 212             DrawEdge (hdc, &rc, EDGE_RAISED,
 213                       BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
 214
 215         if (infoPtr->himlDis && btnPtr->iBitmap>=0)
 216             ImageList_Draw (infoPtr->himlDis, btnPtr->iBitmap, hdc,
 217                                 rc.left+1, rc.top+1, ILD_NORMAL);
 218         else
 219             TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1);
 220
 221         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle,
 222                 infoPtr->himlDis);
 223         return;
 224     }
 225
 226     /* pressed TBSTYLE_BUTTON */
 227     if (btnPtr->fsState & TBSTATE_PRESSED) {
 228         if (dwStyle & TBSTYLE_FLAT)
 229             DrawEdge (hdc, &rc, BDR_SUNKENOUTER, BF_RECT | BF_MIDDLE | BF_ADJUST);
 230         else
 231             DrawEdge (hdc, &rc, EDGE_SUNKEN, BF_RECT | BF_MIDDLE | BF_ADJUST);
 232         if (btnPtr->iBitmap>0)
 233             ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
 234                         rc.left+2, rc.top+2, ILD_NORMAL);
 235         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle,
 236             infoPtr->himlDef);
 237         return;
 238     }
 239
 240     /* checked TBSTYLE_CHECK */
 241     if ((btnPtr->fsStyle & TBSTYLE_CHECK) &&
 242         (btnPtr->fsState & TBSTATE_CHECKED)) {
 243         if (dwStyle & TBSTYLE_FLAT)
 244             DrawEdge (hdc, &rc, BDR_SUNKENOUTER,
 245                         BF_RECT | BF_MIDDLE | BF_ADJUST);
 246         else
 247             DrawEdge (hdc, &rc, EDGE_SUNKEN,
 248                         BF_RECT | BF_MIDDLE | BF_ADJUST);
 249
 250         TOOLBAR_DrawPattern (hdc, &rc);
 251
 252         if (btnPtr->iBitmap>0)
 253             ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
 254                         rc.left+2, rc.top+2, ILD_NORMAL);
 255
 256         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle,
 257                 infoPtr->himlDef);
 258         return;
 259     }
 260
 261     /* indeterminate */
 262     if (btnPtr->fsState & TBSTATE_INDETERMINATE) {
 263         DrawEdge (hdc, &rc, EDGE_RAISED,
 264                     BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
 265
 266         TOOLBAR_DrawPattern (hdc, &rc);
 267         TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1);
 268         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle,
 269                 infoPtr->himlDef);
 270         return;
 271     }
 272
 273     /* normal state */
 274     if (dwStyle & TBSTYLE_FLAT)
 275     {
 276         if (btnPtr->bHot)
 277             DrawEdge (hdc, &rc, BDR_RAISEDINNER, BF_RECT | BF_MIDDLE);
 278         if (btnPtr->bHot && infoPtr->himlHot && btnPtr->iBitmap>0)
 279             ImageList_Draw (infoPtr->himlHot, btnPtr->iBitmap, hdc,
 280                             rc.left +2, rc.top +2, ILD_NORMAL);
 281         else if (btnPtr->iBitmap>0)
 282             ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
 283                             rc.left +2, rc.top +2, ILD_NORMAL);
 284     }
 285     else
 286     {
 287         DrawEdge (hdc, &rc, EDGE_RAISED,
 288                 BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
 289
 290         if (btnPtr->iBitmap>0)
 291             ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
 292                         rc.left+1, rc.top+1, ILD_NORMAL);
 293     }
 294
 295     TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle,
 296                 infoPtr->himlDef);
 297 }
 298
 299
 300 static void
 301 TOOLBAR_Refresh (HWND hwnd, HDC hdc)
 302 {
 303     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
 304     TBUTTON_INFO *btnPtr;
 305     INT i;
 306
 307     /* draw buttons */
 308     btnPtr = infoPtr->buttons;
 309     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++)
 310         TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
 311 }
 312
 313
 314 static void
 315 TOOLBAR_CalcStrings (HWND hwnd, LPSIZE lpSize)
 316 {
 317     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
 318     TBUTTON_INFO *btnPtr;
 319     INT i;
 320     HDC hdc;
 321     HFONT hOldFont;
 322     SIZE sz;
 323
 324
 325     lpSize->cx = 0;
 326     lpSize->cy = 0;
 327     hdc = GetDC (0);
 328     hOldFont = SelectObject (hdc, infoPtr->hFont);
 329
 330     btnPtr = infoPtr->buttons;
 331     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
 332         if (!(btnPtr->fsState & TBSTATE_HIDDEN) &&
 333             (btnPtr->iString > -1) &&
 334             (btnPtr->iString < infoPtr->nNumStrings)) {
 335             LPWSTR lpText = infoPtr->strings[btnPtr->iString];
 336             GetTextExtentPoint32W (hdc, lpText, lstrlenW (lpText), &sz);
 337             if (sz.cx > lpSize->cx)
 338                 lpSize->cx = sz.cx;
 339             if (sz.cy > lpSize->cy)
 340                 lpSize->cy = sz.cy;
 341         }
 342     }
 343
 344     SelectObject (hdc, hOldFont);
 345     ReleaseDC (0, hdc);
 346
 347     TRACE("string size %d x %d!\n", lpSize->cx, lpSize->cy);
 348 }
 349
 350 /***********************************************************************
 351 *               TOOLBAR_WrapToolbar
 352 *
 353 * This function walks through the buttons and seperators in the
 354 * toolbar, and sets the TBSTATE_WRAP flag only on those items where
 355 * wrapping should occur based on the width of the toolbar window.
 356 * It does *not* calculate button placement itself.  That task
 357 * takes place in TOOLBAR_CalcToolbar. If the program wants to manage
 358 * the toolbar wrapping on it's own, it can use the TBSTYLE_WRAPPABLE
 359 * flag, and set the TBSTATE_WRAP flags manually on the appropriate items.
 360 */
 361
 362 static void
 363 TOOLBAR_WrapToolbar( HWND hwnd, DWORD dwStyle )
 364 {
 365     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
 366     TBUTTON_INFO *btnPtr;
 367     INT x, cx, i, j;
 368     RECT rc;
 369     BOOL bWrap, bButtonWrap;
 370
 371     /*  When the toolbar window style is not TBSTYLE_WRAPABLE,  */
 372     /*  no layout is necessary. Applications may use this style */
 373     /*  to perform their own layout on the toolbar.             */
 374     if( !(dwStyle & TBSTYLE_WRAPABLE) )
 375         return;
 376
 377     btnPtr = infoPtr->buttons;
 378     x  = infoPtr->nIndent;
 379
 380     /* this can get the parents width, to know how far we can extend
 381      * this toolbar.  We cannot use its height, as there may be multiple
 382      * toolbars in a rebar control
 383      */
 384     GetClientRect( GetParent(hwnd), &rc );
 385     infoPtr->nWidth = rc.right - rc.left;
 386     bButtonWrap = FALSE;
 387
 388     for (i = 0; i < infoPtr->nNumButtons; i++ )
 389     {
 390         bWrap = FALSE;
 391         btnPtr[i].fsState &= ~TBSTATE_WRAP;
 392
 393         if (btnPtr[i].fsState & TBSTATE_HIDDEN)
 394             continue;
 395
 396         /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
 397         /* it is the actual width of the separator. This is used for */
 398         /* custom controls in toolbars.                              */
 399         if (btnPtr[i].fsStyle & TBSTYLE_SEP)
 400             cx = (btnPtr[i].iBitmap > 0) ?
 401                         btnPtr[i].iBitmap : SEPARATOR_WIDTH;
 402         else
 403             cx = infoPtr->nButtonWidth;
 404
 405         /* Two or more adjacent separators form a separator group.   */
 406         /* The first separator in a group should be wrapped to the   */
 407         /* next row if the previous wrapping is on a button.         */
 408         if( bButtonWrap &&
 409                 (btnPtr[i].fsStyle & TBSTYLE_SEP) &&
 410                 (i + 1 < infoPtr->nNumButtons ) &&
 411                 (btnPtr[i + 1].fsStyle & TBSTYLE_SEP) )
 412         {
 413             btnPtr[i].fsState |= TBSTATE_WRAP;
 414             x = infoPtr->nIndent;
 415             i++;
 416             bButtonWrap = FALSE;
 417             continue;
 418         }
 419
 420         /* The layout makes sure the bitmap is visible, but not the button. */
 421         if ( x + cx - (infoPtr->nButtonWidth - infoPtr->nBitmapWidth) / 2
 422                  > infoPtr->nWidth )
 423         {
 424             BOOL bFound = FALSE;
 425
 426             /*  If the current button is a separator and not hidden,  */
 427             /*  go to the next until it reaches a non separator.      */
 428             /*  Wrap the last separator if it is before a button.     */
 429             while( ( (btnPtr[i].fsStyle & TBSTYLE_SEP) ||
 430                         (btnPtr[i].fsState & TBSTATE_HIDDEN) ) &&
 431                         i < infoPtr->nNumButtons )
 432             {
 433                 i++;
 434                 bFound = TRUE;
 435             }
 436
 437             if( bFound && i < infoPtr->nNumButtons )
 438             {
 439                 i--;
 440                 btnPtr[i].fsState |= TBSTATE_WRAP;
 441                 x = infoPtr->nIndent;
 442                 bButtonWrap = FALSE;
 443                 continue;
 444             }
 445             else if ( i >= infoPtr->nNumButtons)
 446                 break;
 447
 448             /*  If the current button is not a separator, find the last  */
 449             /*  separator and wrap it.                                   */
 450             for ( j = i - 1; j >= 0  &&  !(btnPtr[j].fsState & TBSTATE_WRAP); j--)
 451             {
 452                 if ((btnPtr[j].fsStyle & TBSTYLE_SEP) &&
 453                         !(btnPtr[j].fsState & TBSTATE_HIDDEN))
 454                 {
 455                     bFound = TRUE;
 456                     i = j;
 457                     x = infoPtr->nIndent;
 458                     btnPtr[j].fsState |= TBSTATE_WRAP;
 459                     bButtonWrap = FALSE;
 460                     break;
 461                 }
 462             }
 463
 464             /*  If no separator available for wrapping, wrap one of     */
 465             /*  non-hidden previous button.                             */
 466             if (!bFound)
 467             {
 468                 for ( j = i - 1;
 469                         j >= 0 && !(btnPtr[j].fsState & TBSTATE_WRAP); j--)
 470                 {
 471                     if (btnPtr[j].fsState & TBSTATE_HIDDEN)
 472                         continue;
 473
 474                     bFound = TRUE;
 475                     i = j;
 476                     x = infoPtr->nIndent;
 477                     btnPtr[j].fsState |= TBSTATE_WRAP;
 478                     bButtonWrap = TRUE;
 479                     break;
 480                 }
 481             }
 482
 483             /* If all above failed, wrap the current button. */
 484             if (!bFound)
 485             {
 486                 btnPtr[i].fsState |= TBSTATE_WRAP;
 487                 bFound = TRUE;
 488                 x = infoPtr->nIndent;
 489                 if (btnPtr[i].fsState & TBSTYLE_SEP )
 490                     bButtonWrap = FALSE;
 491                 else
 492                     bButtonWrap = TRUE;
 493             }
 494         }
 495         else
 496             x += cx;
 497     }
 498 }
 499
 500 /***********************************************************************
 501 *               TOOLBAR_CalcToolbar
 502 *
 503 * This function calculates button and separator placement. It first
 504 * calculates the button sizes, gets the toolbar window width and then
 505 * calls TOOLBAR_WrapToolbar to determine which buttons we need to wrap
 506 * on. It assigns a new location to each item and sends this location to
 507 * the tooltip window if appropriate. Finally, it updates the rcBound
 508 * rect and calculates the new required toolbar window height.
 509 */
 510
 511 static void
 512 TOOLBAR_CalcToolbar (HWND hwnd)
 513 {
 514     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
 515     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
 516     TBUTTON_INFO *btnPtr;
 517     INT i, nRows, nSepRows;
 518     INT x, y, cx, cy;
 519     SIZE  sizeString;
 520     RECT rc;
 521     BOOL bWrap;
 522
 523     TOOLBAR_CalcStrings (hwnd, &sizeString);
 524
 525     if (dwStyle & TBSTYLE_LIST) {
 526         infoPtr->nButtonHeight = max(infoPtr->nBitmapHeight, sizeString.cy) + 6;
 527         infoPtr->nButtonWidth = infoPtr->nBitmapWidth + sizeString.cx + 6;
 528     }
 529     else {
 530     if (sizeString.cy > 0)
 531         infoPtr->nButtonHeight = sizeString.cy + infoPtr->nBitmapHeight + 6;
 532     else if (infoPtr->nButtonHeight < infoPtr->nBitmapHeight + 6)
 533         infoPtr->nButtonHeight = infoPtr->nBitmapHeight + 6;
 534
 535     if (sizeString.cx > infoPtr->nBitmapWidth)
 536         infoPtr->nButtonWidth = sizeString.cx + 6;
 537     else if (infoPtr->nButtonWidth < infoPtr->nBitmapWidth + 6)
 538         infoPtr->nButtonWidth = infoPtr->nBitmapWidth + 6;
 539     }
 540
 541     if ( infoPtr->cxMin >= 0 && infoPtr->nButtonWidth < infoPtr->cxMin )
 542         infoPtr->nButtonWidth = infoPtr->cxMin;
 543     if ( infoPtr->cxMax >= 0 && infoPtr->nButtonWidth > infoPtr->cxMax )
 544         infoPtr->nButtonWidth = infoPtr->cxMax;
 545
 546     TOOLBAR_WrapToolbar( hwnd, dwStyle );
 547
 548     x  = infoPtr->nIndent;
 549     y  = (dwStyle & TBSTYLE_FLAT) ? 0 : TOP_BORDER;
 550
 551     GetClientRect( hwnd, &rc );
 552     /* get initial values for toolbar */
 553     infoPtr->nWidth  = rc.right - rc.left;
 554     infoPtr->nHeight = rc.bottom - rc.top;
 555
 556     /* from above, minimum is a button, and possible text */
 557     cx = infoPtr->nButtonWidth;
 558     /* cannot use just ButtonHeight, we may have no buttons! */
 559     cy = infoPtr->nHeight;
 560
 561     nRows = nSepRows = 0;
 562
 563     infoPtr->rcBound.top = y;
 564     infoPtr->rcBound.left = x;
 565     infoPtr->rcBound.bottom = y + cy;
 566     infoPtr->rcBound.right = x;
 567
 568     btnPtr = infoPtr->buttons;
 569
 570     /* do not base height/width on parent, if the parent is a */
 571     /* rebar control it could have multiple rows of toolbars  */
 572 /*    GetClientRect( GetParent(hwnd), &rc ); */
 573 /*    cx = rc.right - rc.left; */
 574 /*    cy = rc.bottom - rc.top; */
 575
 576     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++ )
 577     {
 578         bWrap = FALSE;
 579         if (btnPtr->fsState & TBSTATE_HIDDEN)
 580         {
 581             SetRectEmpty (&btnPtr->rect);
 582             continue;
 583         }
 584
 585             /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
 586             /* it is the actual width of the separator. This is used for */
 587             /* custom controls in toolbars.                              */
 588         if (btnPtr->fsStyle & TBSTYLE_SEP)
 589                 cx = (btnPtr->iBitmap > 0) ?
 590                      btnPtr->iBitmap : SEPARATOR_WIDTH;
 591         else {
 592             cx = infoPtr->nButtonWidth;
 593         }
 594         cy = infoPtr->nHeight;
 595
 596         if (btnPtr->fsState & TBSTATE_WRAP )
 597                     bWrap = TRUE;
 598
 599         SetRect (&btnPtr->rect, x, y, x + cx, y + cy);
 600
 601         if (infoPtr->rcBound.left > x)
 602             infoPtr->rcBound.left = x;
 603         if (infoPtr->rcBound.right < x + cx)
 604             infoPtr->rcBound.right = x + cx;
 605         if (infoPtr->rcBound.bottom < y + cy)
 606             infoPtr->rcBound.bottom = y + cy;
 607
 608         /* Set the toolTip only for non-hidden, non-separator button */
 609         if (infoPtr->hwndToolTip && !(btnPtr->fsStyle & TBSTYLE_SEP ))
 610         {
 611             TTTOOLINFOA ti;
 612
 613             ZeroMemory (&ti, sizeof(TTTOOLINFOA));
 614             ti.cbSize = sizeof(TTTOOLINFOA);
 615             ti.hwnd = hwnd;
 616             ti.uId = btnPtr->idCommand;
 617             ti.rect = btnPtr->rect;
 618             SendMessageA (infoPtr->hwndToolTip, TTM_NEWTOOLRECTA,
 619                             0, (LPARAM)&ti);
 620         }
 621
 622         /* btnPtr->nRow is zero based. The space between the rows is    */
 623         /* also considered as a row.                                    */
 624         btnPtr->nRow = nRows + nSepRows;
 625         if( bWrap )
 626         {
 627             if ( !(btnPtr->fsStyle & TBSTYLE_SEP) )
 628             y += cy;
 629             else
 630             {
 631                 /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
 632                 /* it is the actual width of the separator. This is used for */
 633                 /* custom controls in toolbars.                              */
 634                 y += cy + ( (btnPtr->iBitmap > 0 ) ?
 635                         btnPtr->iBitmap : SEPARATOR_WIDTH) * 2 /3;
 636
 637                 /* nSepRows is used to calculate the extra height follwoing  */
 638                 /* the last row.                                             */
 639                 nSepRows++;
 640             }
 641             x = infoPtr->nIndent;
 642                 nRows++;
 643         }
 644         else
 645             x += cx;
 646     }
 647
 648     /* infoPtr->nRows is the number of rows on the toolbar */
 649     infoPtr->nRows = nRows + nSepRows + 1;
 650
 651     /* nSepRows * (infoPtr->nBitmapHeight + 1) is the space following   */
 652     /* the last row.                                                    */
 653     infoPtr->nHeight = TOP_BORDER + (nRows + 1) * infoPtr->nButtonHeight +
 654                         nSepRows * (SEPARATOR_WIDTH * 2 / 3) +
 655                         nSepRows * (infoPtr->nBitmapHeight + 1) +
 656                         BOTTOM_BORDER;
 657     TRACE("toolbar height %d\n", infoPtr->nHeight);
 658 }
 659
 660
 661 static INT
 662 TOOLBAR_InternalHitTest (HWND hwnd, LPPOINT lpPt)
 663 {
 664     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
 665     TBUTTON_INFO *btnPtr;
 666     INT i;
 667
 668     btnPtr = infoPtr->buttons;
 669     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
 670         if (btnPtr->fsState & TBSTATE_HIDDEN)
 671             continue;
 672
 673         if (btnPtr->fsStyle & TBSTYLE_SEP) {
 674             if (PtInRect (&btnPtr->rect, *lpPt)) {
 675                 TRACE(" ON SEPARATOR %d!\n", i);
 676                 return -i;
 677             }
 678         }
 679         else {
 680             if (PtInRect (&btnPtr->rect, *lpPt)) {
 681                 TRACE(" ON BUTTON %d!\n", i);
 682                 return i;
 683             }
 684         }
 685     }
 686
 687     TRACE(" NOWHERE!\n");
 688     return -1;
 689 }
 690
 691
 692 static INT
 693 TOOLBAR_GetButtonIndex (TOOLBAR_INFO *infoPtr, INT idCommand)
 694 {
 695     TBUTTON_INFO *btnPtr;
 696     INT i;
 697
 698     btnPtr = infoPtr->buttons;
 699     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
 700         if (btnPtr->idCommand == idCommand) {
 701             TRACE("command=%d index=%d\n", idCommand, i);
 702             return i;
 703         }
 704     }
 705     TRACE("no index found for command=%d\n", idCommand);
 706     return -1;
 707 }
 708
 709
 710 static INT
 711 TOOLBAR_GetCheckedGroupButtonIndex (TOOLBAR_INFO *infoPtr, INT nIndex)
 712 {
 713     TBUTTON_INFO *btnPtr;
 714     INT nRunIndex;
 715
 716     if ((nIndex < 0) || (nIndex > infoPtr->nNumButtons))
 717         return -1;
 718
 719     /* check index button */
 720     btnPtr = &infoPtr->buttons[nIndex];
 721     if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
 722         if (btnPtr->fsState & TBSTATE_CHECKED)
 723             return nIndex;
 724     }
 725
 726     /* check previous buttons */
 727     nRunIndex = nIndex - 1;
 728     while (nRunIndex >= 0) {
 729         btnPtr = &infoPtr->buttons[nRunIndex];
 730         if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
 731             if (btnPtr->fsState & TBSTATE_CHECKED)
 732                 return nRunIndex;
 733         }
 734         else
 735             break;
 736         nRunIndex--;
 737     }
 738
 739     /* check next buttons */
 740     nRunIndex = nIndex + 1;
 741     while (nRunIndex < infoPtr->nNumButtons) {
 742         btnPtr = &infoPtr->buttons[nRunIndex];
 743         if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
 744             if (btnPtr->fsState & TBSTATE_CHECKED)
 745                 return nRunIndex;
 746         }
 747         else
 748             break;
 749         nRunIndex++;
 750     }
 751
 752     return -1;
 753 }
 754
 755
 756 static VOID
 757 TOOLBAR_RelayEvent (HWND hwndTip, HWND hwndMsg, UINT uMsg,
 758                     WPARAM wParam, LPARAM lParam)
 759 {
 760     MSG msg;
 761
 762     msg.hwnd = hwndMsg;
 763     msg.message = uMsg;
 764     msg.wParam = wParam;
 765     msg.lParam = lParam;
 766     msg.time = GetMessageTime ();
 767     msg.pt.x = LOWORD(GetMessagePos ());
 768     msg.pt.y = HIWORD(GetMessagePos ());
 769
 770     SendMessageA (hwndTip, TTM_RELAYEVENT, 0, (LPARAM)&msg);
 771 }
 772
 773
 774 /***********************************************************************
 775  * TOOLBAR_CustomizeDialogProc
 776  * This function implements the toolbar customization dialog.
 777  */
 778 static BOOL WINAPI
 779 TOOLBAR_CustomizeDialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 780 {
 781     TOOLBAR_INFO *infoPtr = (TOOLBAR_INFO *)GetWindowLongA (hwnd, DWL_USER);
 782     static HDSA hDsa = NULL;
 783
 784     switch (uMsg)
 785     {
 786         case WM_INITDIALOG:
 787             infoPtr = (TOOLBAR_INFO *)lParam;
 788             SetWindowLongA (hwnd, DWL_USER, (DWORD)infoPtr);
 789
 790             hDsa = DSA_Create (sizeof(TBUTTON_INFO), 5);
 791
 792             if (infoPtr)
 793             {
 794                 TBUTTON_INFO *btnPtr;
 795                 INT i;
 796
 797                 /* insert 'virtual' separator button into 'available buttons' list */
 798                 SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)"");
 799
 800                 /* copy all buttons and append them to the right listbox */
 801                 btnPtr = infoPtr->buttons;
 802                 for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++)
 803                 {
 804                     DSA_InsertItem (hDsa, i, btnPtr);
 805
 806                     /* FIXME: hidden buttons appear in the 'toolbar buttons' list too */
 807                     if (btnPtr->fsState & TBSTATE_HIDDEN)
 808                     {
 809                         SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)"");
 810                     }
 811                     else
 812                     {
 813                         SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)"");
 814                     }
 815                 }
 816
 817                 /* append 'virtual' separator button to the 'toolbar buttons' list */
 818                 /* TODO */
 819             }
 820             return TRUE;
 821
 822         case WM_CLOSE:
 823             EndDialog(hwnd, FALSE);
 824             return TRUE;
 825
 826         case WM_COMMAND:
 827             switch (LOWORD(wParam))
 828             {
 829                 case IDCANCEL:
 830                     EndDialog(hwnd, FALSE);
 831                     break;
 832             }
 833             return TRUE;
 834
 835         case WM_DESTROY:
 836             if (hDsa)
 837                 DSA_Destroy (hDsa);
 838             return TRUE;
 839
 840         case WM_DRAWITEM:
 841             if (wParam == IDC_AVAILBTN_LBOX || wParam == IDC_TOOLBARBTN_LBOX)
 842             {
 843                 LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT)lParam;
 844                 TBUTTON_INFO btnPtr;
 845                 RECT rcButton;
 846                 RECT rcText;
 847                 HPEN hOldPen;
 848                 HBRUSH hOldBrush;
 849                 COLORREF oldText = 0;
 850                 COLORREF oldBk = 0;
 851
 852                 FIXME("action: %x itemState: %x\n",
 853                       lpdis->itemAction, lpdis->itemState);
 854
 855                 DSA_GetItem (hDsa, 0 /*lpdis->itemID*/, &btnPtr);
 856
 857                 if (lpdis->itemState & ODS_FOCUS)
 858                 {
 859                     oldBk = SetBkColor (lpdis->hDC, GetSysColor(COLOR_HIGHLIGHT));
 860                     oldText = SetTextColor (lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
 861                 }
 862
 863                 hOldPen = SelectObject (lpdis->hDC, GetSysColorPen ((lpdis->itemState & ODS_SELECTED)?COLOR_HIGHLIGHT:COLOR_WINDOW));
 864                 hOldBrush = SelectObject (lpdis->hDC, GetSysColorBrush ((lpdis->itemState & ODS_FOCUS)?COLOR_HIGHLIGHT:COLOR_WINDOW));
 865
 866                 /* fill background rectangle */
 867                 Rectangle (lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
 868                            lpdis->rcItem.right, lpdis->rcItem.bottom);
 869
 870                 /* calculate button and text rectangles */
 871                 CopyRect (&rcButton, &lpdis->rcItem);
 872                 InflateRect (&rcButton, -1, -1);
 873                 CopyRect (&rcText, &rcButton);
 874                 rcButton.right = rcButton.left + infoPtr->nBitmapWidth + 6;
 875                 rcText.left = rcButton.right + 2;
 876
 877                 /* draw focus rectangle */
 878                 if (lpdis->itemState & ODS_FOCUS)
 879                     DrawFocusRect (lpdis->hDC, &lpdis->rcItem);
 880
 881                 /* draw button */
 882                 DrawEdge (lpdis->hDC, &rcButton, EDGE_RAISED, BF_RECT|BF_MIDDLE|BF_SOFT);
 883
 884                 /* draw image and text */
 885                 if (wParam == IDC_AVAILBTN_LBOX && lpdis->itemID == 0)
 886                 {
 887                     /* virtual separator in the 'available' list */
 888                     DrawTextA (lpdis->hDC, "Separator", -1, &rcText,
 889                                DT_LEFT | DT_VCENTER | DT_SINGLELINE);
 890                 }
 891                 else
 892                 {
 893                     /* real button */
 894
 895                     ImageList_Draw (infoPtr->himlDef, btnPtr.iBitmap, lpdis->hDC,
 896                                     rcButton.left+1, rcButton.top+1, ILD_NORMAL);
 897
 898                     DrawTextW (lpdis->hDC,  infoPtr->strings[btnPtr.iString], -1, &rcText,
 899                                DT_LEFT | DT_VCENTER | DT_SINGLELINE);
 900
 901                 }
 902
 903                 if (lpdis->itemState & ODS_FOCUS)
 904                 {
 905                     SetBkColor (lpdis->hDC, oldBk);
 906                     SetTextColor (lpdis->hDC, oldText);
 907                 }
 908
 909                 SelectObject (lpdis->hDC, hOldBrush);
 910                 SelectObject (lpdis->hDC, hOldPen);
 911
 912                 return TRUE;
 913             }
 914             return FALSE;
 915
 916         case WM_MEASUREITEM:
 917             if (wParam == IDC_AVAILBTN_LBOX || wParam == IDC_TOOLBARBTN_LBOX)
 918             {
 919                 MEASUREITEMSTRUCT *lpmis = (MEASUREITEMSTRUCT*)lParam;
 920
 921                 if (infoPtr)
 922                     lpmis->itemHeight = infoPtr->nBitmapHeight + 8;
 923                 else
 924                     lpmis->itemHeight = 15 + 8; /* default height */
 925
 926                 return TRUE;
 927             }
 928             return FALSE;
 929
 930         default:
 931             return FALSE;
 932     }
 933 }
 934
 935
 936 /***********************************************************************
 937  * TOOLBAR_AddBitmap:  Add the bitmaps to the default image list.
 938  *
 939  */
 940 static LRESULT
 941 TOOLBAR_AddBitmap (HWND hwnd, WPARAM wParam, LPARAM lParam)
 942 {
 943     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
 944     LPTBADDBITMAP lpAddBmp = (LPTBADDBITMAP)lParam;
 945     INT nIndex = 0, nButtons;
 946     HBITMAP hbmLoad;
 947
 948     if (!lpAddBmp)
 949         return -1;
 950
 951     if (lpAddBmp->hInst == HINST_COMMCTRL)
 952     {
 953         if ((lpAddBmp->nID & ~1) == IDB_STD_SMALL_COLOR)
 954             nButtons = 15;
 955         else if ((lpAddBmp->nID & ~1) == IDB_VIEW_SMALL_COLOR)
 956             nButtons = 13;
 957         else if ((lpAddBmp->nID & ~1) == IDB_HIST_SMALL_COLOR)
 958             nButtons = 5;
 959         else
 960             return -1;
 961
 962         TRACE ("adding %d internal bitmaps!\n", nButtons);
 963
 964         /* Windows resize all the buttons to the size of a newly added standard image */
 965         if (lpAddBmp->nID & 1)
 966         {
 967             /* large icons */
 968             SendMessageA (hwnd, TB_SETBITMAPSIZE, 0,
 969                           MAKELPARAM((WORD)26, (WORD)26));
 970             SendMessageA (hwnd, TB_SETBUTTONSIZE, 0,
 971                           MAKELPARAM((WORD)33, (WORD)33));
 972         }
 973         else
 974         {
 975             /* small icons */
 976             SendMessageA (hwnd, TB_SETBITMAPSIZE, 0,
 977                           MAKELPARAM((WORD)16, (WORD)16));
 978             SendMessageA (hwnd, TB_SETBUTTONSIZE, 0,
 979                           MAKELPARAM((WORD)22, (WORD)22));
 980         }
 981
 982         TOOLBAR_CalcToolbar (hwnd);
 983     }
 984     else
 985     {
 986         nButtons = (INT)wParam;
 987         if (nButtons <= 0)
 988             return -1;
 989
 990         TRACE ("adding %d bitmaps!\n", nButtons);
 991     }
 992
 993     if (!(infoPtr->himlDef)) {
 994         /* create new default image list */
 995         TRACE ("creating default image list!\n");
 996
 997         infoPtr->himlDef =
 998             ImageList_Create (infoPtr->nBitmapWidth, infoPtr->nBitmapHeight + 1,
 999                               ILC_COLOR | ILC_MASK, nButtons, 2);
1000         infoPtr->himlInt = infoPtr->himlDef;
1001     }
1002
1003     /* Add bitmaps to the default image list */
1004     if (lpAddBmp->hInst == (HINSTANCE)0)
1005     {
1006         nIndex =
1007             ImageList_AddMasked (infoPtr->himlDef, (HBITMAP)lpAddBmp->nID,
1008                                  CLR_DEFAULT);
1009     }
1010     else if (lpAddBmp->hInst == HINST_COMMCTRL)
1011     {
1012         /* Add system bitmaps */
1013         switch (lpAddBmp->nID)
1014     {
1015             case IDB_STD_SMALL_COLOR:
1016                 hbmLoad = LoadBitmapA (COMCTL32_hModule,
1017                                        MAKEINTRESOURCEA(IDB_STD_SMALL));
1018                 nIndex = ImageList_AddMasked (infoPtr->himlDef,
1019                                               hbmLoad, CLR_DEFAULT);
1020                 DeleteObject (hbmLoad);
1021                 break;
1022
1023             case IDB_STD_LARGE_COLOR:
1024                 hbmLoad = LoadBitmapA (COMCTL32_hModule,
1025                                        MAKEINTRESOURCEA(IDB_STD_LARGE));
1026                 nIndex = ImageList_AddMasked (infoPtr->himlDef,
1027                                               hbmLoad, CLR_DEFAULT);
1028                 DeleteObject (hbmLoad);
1029                 break;
1030
1031             case IDB_VIEW_SMALL_COLOR:
1032                 hbmLoad = LoadBitmapA (COMCTL32_hModule,
1033                                        MAKEINTRESOURCEA(IDB_VIEW_SMALL));
1034                 nIndex = ImageList_AddMasked (infoPtr->himlDef,
1035                                               hbmLoad, CLR_DEFAULT);
1036                 DeleteObject (hbmLoad);
1037                 break;
1038
1039             case IDB_VIEW_LARGE_COLOR:
1040                 hbmLoad = LoadBitmapA (COMCTL32_hModule,
1041                                        MAKEINTRESOURCEA(IDB_VIEW_LARGE));
1042                 nIndex = ImageList_AddMasked (infoPtr->himlDef,
1043                                               hbmLoad, CLR_DEFAULT);
1044                 DeleteObject (hbmLoad);
1045                 break;
1046
1047             case IDB_HIST_SMALL_COLOR:
1048                 hbmLoad = LoadBitmapA (COMCTL32_hModule,
1049                                        MAKEINTRESOURCEA(IDB_HIST_SMALL));
1050                 nIndex = ImageList_AddMasked (infoPtr->himlDef,
1051                                               hbmLoad, CLR_DEFAULT);
1052                 DeleteObject (hbmLoad);
1053                 break;
1054
1055             case IDB_HIST_LARGE_COLOR:
1056                 hbmLoad = LoadBitmapA (COMCTL32_hModule,
1057                                        MAKEINTRESOURCEA(IDB_HIST_LARGE));
1058                 nIndex = ImageList_AddMasked (infoPtr->himlDef,
1059                                               hbmLoad, CLR_DEFAULT);
1060                 DeleteObject (hbmLoad);
1061                 break;
1062
1063             default:
1064         nIndex = ImageList_GetImageCount (infoPtr->himlDef);
1065                 ERR ("invalid imagelist!\n");
1066                 break;
1067         }
1068     }
1069     else
1070     {
1071         hbmLoad = LoadBitmapA (lpAddBmp->hInst, (LPSTR)lpAddBmp->nID);
1072         nIndex = ImageList_AddMasked (infoPtr->himlDef, hbmLoad, CLR_DEFAULT);
1073         DeleteObject (hbmLoad);
1074     }
1075
1076     infoPtr->nNumBitmaps += nButtons;
1077
1078     return nIndex;
1079 }
1080
1081
1082 static LRESULT
1083 TOOLBAR_AddButtonsA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1084 {
1085     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1086     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
1087     INT nOldButtons, nNewButtons, nAddButtons, nCount;
1088
1089     TRACE("adding %d buttons!\n", wParam);
1090
1091     nAddButtons = (UINT)wParam;
1092     nOldButtons = infoPtr->nNumButtons;
1093     nNewButtons = nOldButtons + nAddButtons;
1094
1095     if (infoPtr->nNumButtons == 0) {
1096         infoPtr->buttons =
1097             COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
1098     }
1099     else {
1100         TBUTTON_INFO *oldButtons = infoPtr->buttons;
1101         infoPtr->buttons =
1102             COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
1103         memcpy (&infoPtr->buttons[0], &oldButtons[0],
1104                 nOldButtons * sizeof(TBUTTON_INFO));
1105         COMCTL32_Free (oldButtons);
1106     }
1107
1108     infoPtr->nNumButtons = nNewButtons;
1109
1110     /* insert new button data */
1111     for (nCount = 0; nCount < nAddButtons; nCount++) {
1112         TBUTTON_INFO *btnPtr = &infoPtr->buttons[nOldButtons+nCount];
1113         btnPtr->iBitmap   = lpTbb[nCount].iBitmap;
1114         btnPtr->idCommand = lpTbb[nCount].idCommand;
1115         btnPtr->fsState   = lpTbb[nCount].fsState;
1116         btnPtr->fsStyle   = lpTbb[nCount].fsStyle;
1117         btnPtr->dwData    = lpTbb[nCount].dwData;
1118         btnPtr->iString   = lpTbb[nCount].iString;
1119         btnPtr->bHot      = FALSE;
1120
1121         if ((infoPtr->hwndToolTip) && !(btnPtr->fsStyle & TBSTYLE_SEP)) {
1122             TTTOOLINFOA ti;
1123
1124             ZeroMemory (&ti, sizeof(TTTOOLINFOA));
1125             ti.cbSize   = sizeof (TTTOOLINFOA);
1126             ti.hwnd     = hwnd;
1127             ti.uId      = btnPtr->idCommand;
1128             ti.hinst    = 0;
1129             ti.lpszText = LPSTR_TEXTCALLBACKA;
1130
1131             SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
1132                             0, (LPARAM)&ti);
1133         }
1134     }
1135
1136     TOOLBAR_CalcToolbar (hwnd);
1137
1138     InvalidateRect(hwnd, NULL, FALSE);
1139
1140     return TRUE;
1141 }
1142
1143
1144 static LRESULT
1145 TOOLBAR_AddButtonsW (HWND hwnd, WPARAM wParam, LPARAM lParam)
1146 {
1147     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1148     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
1149     INT nOldButtons, nNewButtons, nAddButtons, nCount;
1150
1151     TRACE("adding %d buttons!\n", wParam);
1152
1153     nAddButtons = (UINT)wParam;
1154     nOldButtons = infoPtr->nNumButtons;
1155     nNewButtons = nOldButtons + nAddButtons;
1156
1157     if (infoPtr->nNumButtons == 0) {
1158         infoPtr->buttons =
1159             COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
1160     }
1161     else {
1162         TBUTTON_INFO *oldButtons = infoPtr->buttons;
1163         infoPtr->buttons =
1164             COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
1165         memcpy (&infoPtr->buttons[0], &oldButtons[0],
1166                 nOldButtons * sizeof(TBUTTON_INFO));
1167         COMCTL32_Free (oldButtons);
1168     }
1169
1170     infoPtr->nNumButtons = nNewButtons;
1171
1172     /* insert new button data */
1173     for (nCount = 0; nCount < nAddButtons; nCount++) {
1174         TBUTTON_INFO *btnPtr = &infoPtr->buttons[nOldButtons+nCount];
1175         btnPtr->iBitmap   = lpTbb[nCount].iBitmap;
1176         btnPtr->idCommand = lpTbb[nCount].idCommand;
1177         btnPtr->fsState   = lpTbb[nCount].fsState;
1178         btnPtr->fsStyle   = lpTbb[nCount].fsStyle;
1179         btnPtr->dwData    = lpTbb[nCount].dwData;
1180         btnPtr->iString   = lpTbb[nCount].iString;
1181         btnPtr->bHot      = FALSE;
1182
1183         if ((infoPtr->hwndToolTip) && !(btnPtr->fsStyle & TBSTYLE_SEP)) {
1184             TTTOOLINFOW ti;
1185
1186             ZeroMemory (&ti, sizeof(TTTOOLINFOW));
1187             ti.cbSize   = sizeof (TTTOOLINFOW);
1188             ti.hwnd     = hwnd;
1189             ti.uId      = btnPtr->idCommand;
1190             ti.hinst    = 0;
1191             ti.lpszText = LPSTR_TEXTCALLBACKW;
1192
1193             SendMessageW (infoPtr->hwndToolTip, TTM_ADDTOOLW,
1194                             0, (LPARAM)&ti);
1195         }
1196     }
1197
1198     TOOLBAR_CalcToolbar (hwnd);
1199
1200     InvalidateRect(hwnd, NULL, FALSE);
1201
1202     return TRUE;
1203 }
1204
1205
1206 static LRESULT
1207 TOOLBAR_AddStringA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1208 {
1209     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1210     INT nIndex;
1211
1212     if ((wParam) && (HIWORD(lParam) == 0)) {
1213         char szString[256];
1214         INT len;
1215         TRACE("adding string from resource!\n");
1216
1217         len = LoadStringA ((HINSTANCE)wParam, (UINT)lParam,
1218                              szString, 256);
1219
1220         TRACE("len=%d \"%s\"\n", len, szString);
1221         nIndex = infoPtr->nNumStrings;
1222         if (infoPtr->nNumStrings == 0) {
1223             infoPtr->strings =
1224                 COMCTL32_Alloc (sizeof(LPWSTR));
1225         }
1226         else {
1227             LPWSTR *oldStrings = infoPtr->strings;
1228             infoPtr->strings =
1229                 COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
1230             memcpy (&infoPtr->strings[0], &oldStrings[0],
1231                     sizeof(LPWSTR) * infoPtr->nNumStrings);
1232             COMCTL32_Free (oldStrings);
1233         }
1234
1235         infoPtr->strings[infoPtr->nNumStrings] =
1236             COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
1237         lstrcpyAtoW (infoPtr->strings[infoPtr->nNumStrings], szString);
1238         infoPtr->nNumStrings++;
1239     }
1240     else {
1241         LPSTR p = (LPSTR)lParam;
1242         INT len;
1243
1244         if (p == NULL)
1245             return -1;
1246         TRACE("adding string(s) from array!\n");
1247         nIndex = infoPtr->nNumStrings;
1248         while (*p) {
1249             len = lstrlenA (p);
1250             TRACE("len=%d \"%s\"\n", len, p);
1251
1252             if (infoPtr->nNumStrings == 0) {
1253                 infoPtr->strings =
1254                     COMCTL32_Alloc (sizeof(LPWSTR));
1255             }
1256             else {
1257                 LPWSTR *oldStrings = infoPtr->strings;
1258                 infoPtr->strings =
1259                     COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
1260                 memcpy (&infoPtr->strings[0], &oldStrings[0],
1261                         sizeof(LPWSTR) * infoPtr->nNumStrings);
1262                 COMCTL32_Free (oldStrings);
1263             }
1264
1265             infoPtr->strings[infoPtr->nNumStrings] =
1266                 COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
1267             lstrcpyAtoW (infoPtr->strings[infoPtr->nNumStrings], p);
1268             infoPtr->nNumStrings++;
1269
1270             p += (len+1);
1271         }
1272     }
1273
1274     return nIndex;
1275 }
1276
1277
1278 static LRESULT
1279 TOOLBAR_AddStringW (HWND hwnd, WPARAM wParam, LPARAM lParam)
1280 {
1281     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1282     INT nIndex;
1283
1284     if ((wParam) && (HIWORD(lParam) == 0)) {
1285         WCHAR szString[256];
1286         INT len;
1287         TRACE("adding string from resource!\n");
1288
1289         len = LoadStringW ((HINSTANCE)wParam, (UINT)lParam,
1290                              szString, 256);
1291
1292         TRACE("len=%d \"%s\"\n", len, debugstr_w(szString));
1293         nIndex = infoPtr->nNumStrings;
1294         if (infoPtr->nNumStrings == 0) {
1295             infoPtr->strings =
1296                 COMCTL32_Alloc (sizeof(LPWSTR));
1297         }
1298         else {
1299             LPWSTR *oldStrings = infoPtr->strings;
1300             infoPtr->strings =
1301                 COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
1302             memcpy (&infoPtr->strings[0], &oldStrings[0],
1303                     sizeof(LPWSTR) * infoPtr->nNumStrings);
1304             COMCTL32_Free (oldStrings);
1305         }
1306
1307         infoPtr->strings[infoPtr->nNumStrings] =
1308             COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
1309         lstrcpyW (infoPtr->strings[infoPtr->nNumStrings], szString);
1310         infoPtr->nNumStrings++;
1311     }
1312     else {
1313         LPWSTR p = (LPWSTR)lParam;
1314         INT len;
1315
1316         if (p == NULL)
1317             return -1;
1318         TRACE("adding string(s) from array!\n");
1319         nIndex = infoPtr->nNumStrings;
1320         while (*p) {
1321             len = lstrlenW (p);
1322             TRACE("len=%d \"%s\"\n", len, debugstr_w(p));
1323
1324             if (infoPtr->nNumStrings == 0) {
1325                 infoPtr->strings =
1326                     COMCTL32_Alloc (sizeof(LPWSTR));
1327             }
1328             else {
1329                 LPWSTR *oldStrings = infoPtr->strings;
1330                 infoPtr->strings =
1331                     COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
1332                 memcpy (&infoPtr->strings[0], &oldStrings[0],
1333                         sizeof(LPWSTR) * infoPtr->nNumStrings);
1334                 COMCTL32_Free (oldStrings);
1335             }
1336
1337             infoPtr->strings[infoPtr->nNumStrings] =
1338                 COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
1339             lstrcpyW (infoPtr->strings[infoPtr->nNumStrings], p);
1340             infoPtr->nNumStrings++;
1341
1342             p += (len+1);
1343         }
1344     }
1345
1346     return nIndex;
1347 }
1348
1349
1350 static LRESULT
1351 TOOLBAR_AutoSize (HWND hwnd)
1352 {
1353     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1354     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1355     RECT parent_rect;
1356     RECT window_rect;
1357     HWND parent;
1358     INT  x, y;
1359     INT  cx, cy;
1360     UINT uPosFlags = 0;
1361
1362     TRACE("resize forced!\n");
1363
1364     parent = GetParent (hwnd);
1365     GetClientRect(parent, &parent_rect);
1366
1367     x = parent_rect.left;
1368     y = parent_rect.top;
1369
1370     if (dwStyle & CCS_NORESIZE) {
1371         uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
1372         cx = 0;
1373         cy = 0;
1374     }
1375     else {
1376         infoPtr->nWidth = parent_rect.right - parent_rect.left;
1377         TOOLBAR_CalcToolbar (hwnd);
1378         InvalidateRect( hwnd, NULL, TRUE );
1379         cy = infoPtr->nHeight;
1380         cx = infoPtr->nWidth;
1381
1382         if (dwStyle & CCS_NOMOVEY) {
1383                 GetWindowRect(hwnd, &window_rect);
1384                 ScreenToClient(parent, (LPPOINT)&window_rect.left);
1385                 y = window_rect.top;
1386         }
1387     }
1388
1389     if (dwStyle & CCS_NOPARENTALIGN)
1390         uPosFlags |= SWP_NOMOVE;
1391
1392     if (!(dwStyle & CCS_NODIVIDER))
1393         cy += GetSystemMetrics(SM_CYEDGE);
1394
1395     if (dwStyle & WS_BORDER)
1396     {
1397         x = y = 1;
1398         cy += GetSystemMetrics(SM_CYEDGE);
1399         cx += GetSystemMetrics(SM_CYEDGE);
1400     }
1401
1402     infoPtr->bAutoSize = TRUE;
1403     SetWindowPos (hwnd, HWND_TOP, parent_rect.left - x, parent_rect.top - y,
1404                         cx, cy, uPosFlags);
1405     /* The following line makes sure that the infoPtr->bAutoSize is turned off after
1406      * the setwindowpos calls */
1407     infoPtr->bAutoSize = FALSE;
1408
1409     return 0;
1410 }
1411
1412
1413 static LRESULT
1414 TOOLBAR_ButtonCount (HWND hwnd, WPARAM wParam, LPARAM lParam)
1415 {
1416     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1417
1418     return infoPtr->nNumButtons;
1419 }
1420
1421
1422 static LRESULT
1423 TOOLBAR_ButtonStructSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
1424 {
1425     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1426
1427     if (infoPtr == NULL) {
1428         ERR("(0x%x, 0x%x, 0x%lx)\n", hwnd, wParam, lParam);
1429         ERR("infoPtr == NULL!\n");
1430         return 0;
1431     }
1432
1433     infoPtr->dwStructSize = (DWORD)wParam;
1434
1435     return 0;
1436 }
1437
1438
1439 static LRESULT
1440 TOOLBAR_ChangeBitmap (HWND hwnd, WPARAM wParam, LPARAM lParam)
1441 {
1442     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1443     TBUTTON_INFO *btnPtr;
1444     INT nIndex;
1445
1446     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1447     if (nIndex == -1)
1448         return FALSE;
1449
1450     btnPtr = &infoPtr->buttons[nIndex];
1451     btnPtr->iBitmap = LOWORD(lParam);
1452
1453     RedrawWindow(hwnd,&btnPtr->rect,NULL,RDW_ERASE|RDW_INVALIDATE);
1454
1455     return TRUE;
1456 }
1457
1458
1459 static LRESULT
1460 TOOLBAR_CheckButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
1461 {
1462     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1463     TBUTTON_INFO *btnPtr;
1464     INT nIndex;
1465     INT nOldIndex = -1;
1466     BOOL bChecked = FALSE;
1467
1468     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1469     if (nIndex == -1)
1470         return FALSE;
1471
1472     btnPtr = &infoPtr->buttons[nIndex];
1473
1474     if (!(btnPtr->fsStyle & TBSTYLE_CHECK))
1475         return FALSE;
1476
1477     bChecked = (btnPtr->fsState & TBSTATE_CHECKED) ? TRUE : FALSE;
1478
1479     if (LOWORD(lParam) == FALSE)
1480         btnPtr->fsState &= ~TBSTATE_CHECKED;
1481     else {
1482         if (btnPtr->fsStyle & TBSTYLE_GROUP) {
1483             nOldIndex =
1484                 TOOLBAR_GetCheckedGroupButtonIndex (infoPtr, nIndex);
1485             if (nOldIndex == nIndex)
1486                 return 0;
1487             if (nOldIndex != -1)
1488                 infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
1489         }
1490         btnPtr->fsState |= TBSTATE_CHECKED;
1491     }
1492
1493     if( bChecked != LOWORD(lParam) )
1494     {
1495         if (nOldIndex != -1)
1496             RedrawWindow(hwnd,&infoPtr->buttons[nOldIndex].rect,NULL,
1497             RDW_ERASE|RDW_INVALIDATE);
1498         RedrawWindow(hwnd,&btnPtr->rect,NULL,RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
1499     }
1500
1501     /* FIXME: Send a WM_NOTIFY?? */
1502
1503     return TRUE;
1504 }
1505
1506
1507 static LRESULT
1508 TOOLBAR_CommandToIndex (HWND hwnd, WPARAM wParam, LPARAM lParam)
1509 {
1510     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1511
1512     return TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1513 }
1514
1515
1516 static LRESULT
1517 TOOLBAR_Customize (HWND hwnd)
1518 {
1519     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1520     LRESULT ret;
1521     LPCVOID template;
1522     HRSRC hRes;
1523     NMHDR nmhdr;
1524
1525     /* send TBN_BEGINADJUST notification */
1526     nmhdr.hwndFrom = hwnd;
1527     nmhdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
1528     nmhdr.code     = TBN_BEGINADJUST;
1529
1530     SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
1531                   (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
1532
1533     if (!(hRes = FindResourceA (COMCTL32_hModule,
1534                                 MAKEINTRESOURCEA(IDD_TBCUSTOMIZE),
1535                                 RT_DIALOGA)))
1536         return FALSE;
1537
1538     if(!(template = (LPVOID)LoadResource (COMCTL32_hModule, hRes)))
1539         return FALSE;
1540
1541     ret = DialogBoxIndirectParamA (GetWindowLongA (hwnd, GWL_HINSTANCE),
1542                                    (LPDLGTEMPLATEA)template,
1543                                    hwnd,
1544                                    (DLGPROC)TOOLBAR_CustomizeDialogProc,
1545                                    (LPARAM)infoPtr);
1546
1547     /* send TBN_ENDADJUST notification */
1548     nmhdr.code = TBN_ENDADJUST;
1549
1550     SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
1551                   (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
1552
1553     return ret;
1554 }
1555
1556
1557 static LRESULT
1558 TOOLBAR_DeleteButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
1559 {
1560     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1561     INT nIndex = (INT)wParam;
1562
1563     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
1564         return FALSE;
1565
1566     if ((infoPtr->hwndToolTip) &&
1567         !(infoPtr->buttons[nIndex].fsStyle & TBSTYLE_SEP)) {
1568         TTTOOLINFOA ti;
1569
1570         ZeroMemory (&ti, sizeof(TTTOOLINFOA));
1571         ti.cbSize   = sizeof (TTTOOLINFOA);
1572         ti.hwnd     = hwnd;
1573         ti.uId      = infoPtr->buttons[nIndex].idCommand;
1574
1575         SendMessageA (infoPtr->hwndToolTip, TTM_DELTOOLA, 0, (LPARAM)&ti);
1576     }
1577
1578     if (infoPtr->nNumButtons == 1) {
1579         TRACE(" simple delete!\n");
1580         COMCTL32_Free (infoPtr->buttons);
1581         infoPtr->buttons = NULL;
1582         infoPtr->nNumButtons = 0;
1583     }
1584     else {
1585         TBUTTON_INFO *oldButtons = infoPtr->buttons;
1586         TRACE("complex delete! [nIndex=%d]\n", nIndex);
1587
1588         infoPtr->nNumButtons--;
1589         infoPtr->buttons = COMCTL32_Alloc (sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
1590         if (nIndex > 0) {
1591             memcpy (&infoPtr->buttons[0], &oldButtons[0],
1592                     nIndex * sizeof(TBUTTON_INFO));
1593         }
1594
1595         if (nIndex < infoPtr->nNumButtons) {
1596             memcpy (&infoPtr->buttons[nIndex], &oldButtons[nIndex+1],
1597                     (infoPtr->nNumButtons - nIndex) * sizeof(TBUTTON_INFO));
1598         }
1599
1600         COMCTL32_Free (oldButtons);
1601     }
1602
1603     TOOLBAR_CalcToolbar (hwnd);
1604
1605     InvalidateRect (hwnd, NULL, TRUE);
1606
1607     return TRUE;
1608 }
1609
1610
1611 static LRESULT
1612 TOOLBAR_EnableButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
1613 {
1614     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1615     TBUTTON_INFO *btnPtr;
1616     INT nIndex;
1617     DWORD bState;
1618
1619     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1620     if (nIndex == -1)
1621         return FALSE;
1622
1623     btnPtr = &infoPtr->buttons[nIndex];
1624
1625     bState = btnPtr->fsState & TBSTATE_ENABLED;
1626
1627     /* update the toolbar button state */
1628     if(LOWORD(lParam) == FALSE) {
1629         btnPtr->fsState &= ~(TBSTATE_ENABLED | TBSTATE_PRESSED);
1630     } else {
1631         btnPtr->fsState |= TBSTATE_ENABLED;
1632     }
1633
1634     /* redraw the button only if the state of the button changed */
1635     if(bState != (btnPtr->fsState & TBSTATE_ENABLED)) {
1636             RedrawWindow(hwnd,&btnPtr->rect,NULL,RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
1637     }
1638
1639     return TRUE;
1640 }
1641
1642
1643 static inline LRESULT
1644 TOOLBAR_GetAnchorHighlight (HWND hwnd)
1645 {
1646     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1647
1648     return infoPtr->bAnchor;
1649 }
1650
1651
1652 static LRESULT
1653 TOOLBAR_GetBitmap (HWND hwnd, WPARAM wParam, LPARAM lParam)
1654 {
1655     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1656     INT nIndex;
1657
1658     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1659     if (nIndex == -1)
1660         return -1;
1661
1662     return infoPtr->buttons[nIndex].iBitmap;
1663 }
1664
1665
1666 static inline LRESULT
1667 TOOLBAR_GetBitmapFlags (HWND hwnd, WPARAM wParam, LPARAM lParam)
1668 {
1669     return (GetDeviceCaps (0, LOGPIXELSX) >= 120) ? TBBF_LARGE : 0;
1670 }
1671
1672
1673 static LRESULT
1674 TOOLBAR_GetButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
1675 {
1676     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1677     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
1678     INT nIndex = (INT)wParam;
1679     TBUTTON_INFO *btnPtr;
1680
1681     if (infoPtr == NULL)
1682         return FALSE;
1683
1684     if (lpTbb == NULL)
1685         return FALSE;
1686
1687     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
1688         return FALSE;
1689
1690     btnPtr = &infoPtr->buttons[nIndex];
1691     lpTbb->iBitmap   = btnPtr->iBitmap;
1692     lpTbb->idCommand = btnPtr->idCommand;
1693     lpTbb->fsState   = btnPtr->fsState;
1694     lpTbb->fsStyle   = btnPtr->fsStyle;
1695     lpTbb->dwData    = btnPtr->dwData;
1696     lpTbb->iString   = btnPtr->iString;
1697
1698     return TRUE;
1699 }
1700
1701
1702 static LRESULT
1703 TOOLBAR_GetButtonInfoA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1704 {
1705     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1706     LPTBBUTTONINFOA lpTbInfo = (LPTBBUTTONINFOA)lParam;
1707     TBUTTON_INFO *btnPtr;
1708     INT nIndex;
1709
1710     if (infoPtr == NULL)
1711         return -1;
1712     if (lpTbInfo == NULL)
1713         return -1;
1714     if (lpTbInfo->cbSize < sizeof(TBBUTTONINFOA))
1715         return -1;
1716
1717     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1718     if (nIndex == -1)
1719         return -1;
1720
1721     btnPtr = &infoPtr->buttons[nIndex];
1722
1723     if (lpTbInfo->dwMask & TBIF_COMMAND)
1724         lpTbInfo->idCommand = btnPtr->idCommand;
1725     if (lpTbInfo->dwMask & TBIF_IMAGE)
1726         lpTbInfo->iImage = btnPtr->iBitmap;
1727     if (lpTbInfo->dwMask & TBIF_LPARAM)
1728         lpTbInfo->lParam = btnPtr->dwData;
1729     if (lpTbInfo->dwMask & TBIF_SIZE)
1730         lpTbInfo->cx = (WORD)(btnPtr->rect.right - btnPtr->rect.left);
1731     if (lpTbInfo->dwMask & TBIF_STATE)
1732         lpTbInfo->fsState = btnPtr->fsState;
1733     if (lpTbInfo->dwMask & TBIF_STYLE)
1734         lpTbInfo->fsStyle = btnPtr->fsStyle;
1735     if (lpTbInfo->dwMask & TBIF_TEXT) {
1736         if ((btnPtr->iString >= 0) || (btnPtr->iString < infoPtr->nNumStrings))
1737             lstrcpynWtoA (lpTbInfo->pszText,
1738                           (LPWSTR)infoPtr->strings[btnPtr->iString],
1739                          lpTbInfo->cchText);
1740     }
1741
1742     return nIndex;
1743 }
1744
1745
1746 static LRESULT
1747 TOOLBAR_GetButtonInfoW (HWND hwnd, WPARAM wParam, LPARAM lParam)
1748 {
1749     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1750     LPTBBUTTONINFOW lpTbInfo = (LPTBBUTTONINFOW)lParam;
1751     TBUTTON_INFO *btnPtr;
1752     INT nIndex;
1753
1754     if (infoPtr == NULL)
1755         return -1;
1756     if (lpTbInfo == NULL)
1757         return -1;
1758     if (lpTbInfo->cbSize < sizeof(TBBUTTONINFOW))
1759         return -1;
1760
1761     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1762     if (nIndex == -1)
1763         return -1;
1764
1765     btnPtr = &infoPtr->buttons[nIndex];
1766
1767     if (lpTbInfo->dwMask & TBIF_COMMAND)
1768         lpTbInfo->idCommand = btnPtr->idCommand;
1769     if (lpTbInfo->dwMask & TBIF_IMAGE)
1770         lpTbInfo->iImage = btnPtr->iBitmap;
1771     if (lpTbInfo->dwMask & TBIF_LPARAM)
1772         lpTbInfo->lParam = btnPtr->dwData;
1773     if (lpTbInfo->dwMask & TBIF_SIZE)
1774         lpTbInfo->cx = (WORD)(btnPtr->rect.right - btnPtr->rect.left);
1775     if (lpTbInfo->dwMask & TBIF_STATE)
1776         lpTbInfo->fsState = btnPtr->fsState;
1777     if (lpTbInfo->dwMask & TBIF_STYLE)
1778         lpTbInfo->fsStyle = btnPtr->fsStyle;
1779     if (lpTbInfo->dwMask & TBIF_TEXT) {
1780         if ((btnPtr->iString >= 0) || (btnPtr->iString < infoPtr->nNumStrings))
1781             lstrcpynW (lpTbInfo->pszText,
1782                        (LPWSTR)infoPtr->strings[btnPtr->iString],
1783                        lpTbInfo->cchText);
1784     }
1785
1786     return nIndex;
1787 }
1788
1789
1790 static LRESULT
1791 TOOLBAR_GetButtonSize (HWND hwnd)
1792 {
1793     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1794
1795     return MAKELONG((WORD)infoPtr->nButtonWidth,
1796                     (WORD)infoPtr->nButtonHeight);
1797 }
1798
1799
1800 static LRESULT
1801 TOOLBAR_GetButtonTextA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1802 {
1803     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1804     INT nIndex, nStringIndex;
1805
1806     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1807     if (nIndex == -1)
1808         return -1;
1809
1810     nStringIndex = infoPtr->buttons[nIndex].iString;
1811
1812     TRACE("index=%d stringIndex=%d\n", nIndex, nStringIndex);
1813
1814     if ((nStringIndex < 0) || (nStringIndex >= infoPtr->nNumStrings))
1815         return -1;
1816
1817     if (lParam == 0)
1818         return -1;
1819
1820     lstrcpyWtoA ((LPSTR)lParam, (LPWSTR)infoPtr->strings[nStringIndex]);
1821
1822     return lstrlenW ((LPWSTR)infoPtr->strings[nStringIndex]);
1823 }
1824
1825
1826 static LRESULT
1827 TOOLBAR_GetButtonTextW (HWND hwnd, WPARAM wParam, LPARAM lParam)
1828 {
1829     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1830     INT nIndex, nStringIndex;
1831
1832     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1833     if (nIndex == -1)
1834         return -1;
1835
1836     nStringIndex = infoPtr->buttons[nIndex].iString;
1837
1838     TRACE("index=%d stringIndex=%d\n", nIndex, nStringIndex);
1839
1840     if ((nStringIndex < 0) || (nStringIndex >= infoPtr->nNumStrings))
1841         return -1;
1842
1843     if (lParam == 0)
1844         return -1;
1845
1846     lstrcpyW ((LPWSTR)lParam, (LPWSTR)infoPtr->strings[nStringIndex]);
1847
1848     return lstrlenW ((LPWSTR)infoPtr->strings[nStringIndex]);
1849 }
1850
1851
1852 /* << TOOLBAR_GetColorScheme >> */
1853
1854
1855 static LRESULT
1856 TOOLBAR_GetDisabledImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
1857 {
1858     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1859
1860     return (LRESULT)infoPtr->himlDis;
1861 }
1862
1863
1864 inline static LRESULT
1865 TOOLBAR_GetExtendedStyle (HWND hwnd)
1866 {
1867     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1868
1869     return infoPtr->dwExStyle;
1870 }
1871
1872
1873 static LRESULT
1874 TOOLBAR_GetHotImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
1875 {
1876     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1877
1878     return (LRESULT)infoPtr->himlHot;
1879 }
1880
1881
1882 static LRESULT
1883 TOOLBAR_GetHotItem (HWND hwnd)
1884 {
1885     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1886
1887     if (!(GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT))
1888         return -1;
1889
1890     if (infoPtr->nHotItem < 0)
1891         return -1;
1892
1893     return (LRESULT)infoPtr->nHotItem;
1894 }
1895
1896
1897 static LRESULT
1898 TOOLBAR_GetImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
1899 {
1900     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1901
1902     return (LRESULT)infoPtr->himlDef;
1903 }
1904
1905
1906 /* << TOOLBAR_GetInsertMark >> */
1907 /* << TOOLBAR_GetInsertMarkColor >> */
1908
1909
1910 static LRESULT
1911 TOOLBAR_GetItemRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
1912 {
1913     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1914     TBUTTON_INFO *btnPtr;
1915     LPRECT     lpRect;
1916     INT        nIndex;
1917
1918     if (infoPtr == NULL)
1919         return FALSE;
1920     nIndex = (INT)wParam;
1921     btnPtr = &infoPtr->buttons[nIndex];
1922     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
1923         return FALSE;
1924     lpRect = (LPRECT)lParam;
1925     if (lpRect == NULL)
1926         return FALSE;
1927     if (btnPtr->fsState & TBSTATE_HIDDEN)
1928         return FALSE;
1929
1930     TOOLBAR_CalcToolbar( hwnd );
1931
1932     lpRect->left   = btnPtr->rect.left;
1933     lpRect->right  = btnPtr->rect.right;
1934     lpRect->bottom = btnPtr->rect.bottom;
1935     lpRect->top    = btnPtr->rect.top;
1936
1937     return TRUE;
1938 }
1939
1940
1941 static LRESULT
1942 TOOLBAR_GetMaxSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
1943 {
1944     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1945     LPSIZE lpSize = (LPSIZE)lParam;
1946
1947     if (lpSize == NULL)
1948         return FALSE;
1949
1950     lpSize->cx = infoPtr->rcBound.right - infoPtr->rcBound.left;
1951     lpSize->cy = infoPtr->rcBound.bottom - infoPtr->rcBound.top;
1952
1953     TRACE("maximum size %d x %d\n",
1954            infoPtr->rcBound.right - infoPtr->rcBound.left,
1955            infoPtr->rcBound.bottom - infoPtr->rcBound.top);
1956
1957     return TRUE;
1958 }
1959
1960
1961 /* << TOOLBAR_GetObject >> */
1962 /* << TOOLBAR_GetPadding >> */
1963
1964
1965 static LRESULT
1966 TOOLBAR_GetRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
1967 {
1968     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1969     TBUTTON_INFO *btnPtr;
1970     LPRECT     lpRect;
1971     INT        nIndex;
1972
1973     if (infoPtr == NULL)
1974         return FALSE;
1975     nIndex = (INT)wParam;
1976     btnPtr = &infoPtr->buttons[nIndex];
1977     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
1978         return FALSE;
1979     lpRect = (LPRECT)lParam;
1980     if (lpRect == NULL)
1981         return FALSE;
1982
1983     lpRect->left   = btnPtr->rect.left;
1984     lpRect->right  = btnPtr->rect.right;
1985     lpRect->bottom = btnPtr->rect.bottom;
1986     lpRect->top    = btnPtr->rect.top;
1987
1988     return TRUE;
1989 }
1990
1991
1992 static LRESULT
1993 TOOLBAR_GetRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
1994 {
1995     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1996
1997     if (GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_WRAPABLE)
1998         return infoPtr->nRows;
1999     else
2000         return 1;
2001 }
2002
2003
2004 static LRESULT
2005 TOOLBAR_GetState (HWND hwnd, WPARAM wParam, LPARAM lParam)
2006 {
2007     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2008     INT nIndex;
2009
2010     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2011     if (nIndex == -1)
2012         return -1;
2013
2014     return infoPtr->buttons[nIndex].fsState;
2015 }
2016
2017
2018 static LRESULT
2019 TOOLBAR_GetStyle (HWND hwnd, WPARAM wParam, LPARAM lParam)
2020 {
2021     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2022     INT nIndex;
2023
2024     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2025     if (nIndex == -1)
2026         return -1;
2027
2028     return infoPtr->buttons[nIndex].fsStyle;
2029 }
2030
2031
2032 static LRESULT
2033 TOOLBAR_GetTextRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
2034 {
2035     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2036
2037     if (infoPtr == NULL)
2038         return 0;
2039
2040     return infoPtr->nMaxTextRows;
2041 }
2042
2043
2044 static LRESULT
2045 TOOLBAR_GetToolTips (HWND hwnd, WPARAM wParam, LPARAM lParam)
2046 {
2047     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2048
2049     if (infoPtr == NULL)
2050         return 0;
2051     return infoPtr->hwndToolTip;
2052 }
2053
2054
2055 static LRESULT
2056 TOOLBAR_GetUnicodeFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
2057 {
2058     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2059
2060     TRACE("%s hwnd=0x%x stub!\n",
2061            infoPtr->bUnicode ? "TRUE" : "FALSE", hwnd);
2062
2063     return infoPtr->bUnicode;
2064 }
2065
2066
2067 inline static LRESULT
2068 TOOLBAR_GetVersion (HWND hwnd)
2069 {
2070     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2071     return infoPtr->iVersion;
2072 }
2073
2074
2075 static LRESULT
2076 TOOLBAR_HideButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
2077 {
2078     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2079     TBUTTON_INFO *btnPtr;
2080     INT nIndex;
2081
2082     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2083     if (nIndex == -1)
2084         return FALSE;
2085
2086     btnPtr = &infoPtr->buttons[nIndex];
2087     if (LOWORD(lParam) == FALSE)
2088         btnPtr->fsState &= ~TBSTATE_HIDDEN;
2089     else
2090         btnPtr->fsState |= TBSTATE_HIDDEN;
2091
2092     TOOLBAR_CalcToolbar (hwnd);
2093
2094     InvalidateRect (hwnd, NULL, TRUE);
2095
2096     return TRUE;
2097 }
2098
2099
2100 inline static LRESULT
2101 TOOLBAR_HitTest (HWND hwnd, WPARAM wParam, LPARAM lParam)
2102 {
2103     return TOOLBAR_InternalHitTest (hwnd, (LPPOINT)lParam);
2104 }
2105
2106
2107 static LRESULT
2108 TOOLBAR_Indeterminate (HWND hwnd, WPARAM wParam, LPARAM lParam)
2109 {
2110     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2111     TBUTTON_INFO *btnPtr;
2112     INT nIndex;
2113
2114     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2115     if (nIndex == -1)
2116         return FALSE;
2117
2118     btnPtr = &infoPtr->buttons[nIndex];
2119     if (LOWORD(lParam) == FALSE)
2120         btnPtr->fsState &= ~TBSTATE_INDETERMINATE;
2121     else
2122         btnPtr->fsState |= TBSTATE_INDETERMINATE;
2123
2124     RedrawWindow(hwnd,&btnPtr->rect,NULL,
2125                  RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
2126
2127     return TRUE;
2128 }
2129
2130
2131 static LRESULT
2132 TOOLBAR_InsertButtonA (HWND hwnd, WPARAM wParam, LPARAM lParam)
2133 {
2134     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2135     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
2136     INT nIndex = (INT)wParam;
2137     TBUTTON_INFO *oldButtons;
2138
2139     if (lpTbb == NULL)
2140         return FALSE;
2141
2142     if (nIndex == -1) {
2143        /* EPP: this seems to be an undocumented call (from my IE4)
2144         * I assume in that case that:
2145         * - lpTbb->iString is a string pointer (not a string index in strings[] table
2146         * - index of insertion is at the end of existing buttons
2147         * I only see this happen with nIndex == -1, but it could have a special
2148         * meaning (like -nIndex (or ~nIndex) to get the real position of insertion).
2149         */
2150        int      len = lstrlenA((char*)lpTbb->iString) + 2;
2151        LPSTR    ptr = COMCTL32_Alloc(len);
2152
2153        nIndex = infoPtr->nNumButtons;
2154        strcpy(ptr, (char*)lpTbb->iString);
2155        ptr[len - 1] = 0; /* ended by two '\0' */
2156        lpTbb->iString = TOOLBAR_AddStringA(hwnd, 0, (LPARAM)ptr);
2157        COMCTL32_Free(ptr);
2158
2159     } else if (nIndex < 0)
2160        return FALSE;
2161
2162     TRACE("inserting button index=%d\n", nIndex);
2163     if (nIndex > infoPtr->nNumButtons) {
2164         nIndex = infoPtr->nNumButtons;
2165         TRACE("adjust index=%d\n", nIndex);
2166     }
2167
2168     oldButtons = infoPtr->buttons;
2169     infoPtr->nNumButtons++;
2170     infoPtr->buttons = COMCTL32_Alloc (sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
2171     /* pre insert copy */
2172     if (nIndex > 0) {
2173         memcpy (&infoPtr->buttons[0], &oldButtons[0],
2174                 nIndex * sizeof(TBUTTON_INFO));
2175     }
2176
2177     /* insert new button */
2178     infoPtr->buttons[nIndex].iBitmap   = lpTbb->iBitmap;
2179     infoPtr->buttons[nIndex].idCommand = lpTbb->idCommand;
2180     infoPtr->buttons[nIndex].fsState   = lpTbb->fsState;
2181     infoPtr->buttons[nIndex].fsStyle   = lpTbb->fsStyle;
2182     infoPtr->buttons[nIndex].dwData    = lpTbb->dwData;
2183     infoPtr->buttons[nIndex].iString   = lpTbb->iString;
2184
2185     if ((infoPtr->hwndToolTip) && !(lpTbb->fsStyle & TBSTYLE_SEP)) {
2186         TTTOOLINFOA ti;
2187
2188         ZeroMemory (&ti, sizeof(TTTOOLINFOA));
2189         ti.cbSize   = sizeof (TTTOOLINFOA);
2190         ti.hwnd     = hwnd;
2191         ti.uId      = lpTbb->idCommand;
2192         ti.hinst    = 0;
2193         ti.lpszText = LPSTR_TEXTCALLBACKA;
2194
2195         SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
2196                         0, (LPARAM)&ti);
2197     }
2198
2199     /* post insert copy */
2200     if (nIndex < infoPtr->nNumButtons - 1) {
2201         memcpy (&infoPtr->buttons[nIndex+1], &oldButtons[nIndex],
2202                 (infoPtr->nNumButtons - nIndex - 1) * sizeof(TBUTTON_INFO));
2203     }
2204
2205     COMCTL32_Free (oldButtons);
2206
2207     TOOLBAR_CalcToolbar (hwnd);
2208
2209     InvalidateRect (hwnd, NULL, FALSE);
2210
2211     return TRUE;
2212 }
2213
2214
2215 static LRESULT
2216 TOOLBAR_InsertButtonW (HWND hwnd, WPARAM wParam, LPARAM lParam)
2217 {
2218     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2219     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
2220     INT nIndex = (INT)wParam;
2221     TBUTTON_INFO *oldButtons;
2222
2223     if (lpTbb == NULL)
2224         return FALSE;
2225     if (nIndex < 0)
2226         return FALSE;
2227
2228     TRACE("inserting button index=%d\n", nIndex);
2229     if (nIndex > infoPtr->nNumButtons) {
2230         nIndex = infoPtr->nNumButtons;
2231         TRACE("adjust index=%d\n", nIndex);
2232     }
2233
2234     oldButtons = infoPtr->buttons;
2235     infoPtr->nNumButtons++;
2236     infoPtr->buttons = COMCTL32_Alloc (sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
2237     /* pre insert copy */
2238     if (nIndex > 0) {
2239         memcpy (&infoPtr->buttons[0], &oldButtons[0],
2240                 nIndex * sizeof(TBUTTON_INFO));
2241     }
2242
2243     /* insert new button */
2244     infoPtr->buttons[nIndex].iBitmap   = lpTbb->iBitmap;
2245     infoPtr->buttons[nIndex].idCommand = lpTbb->idCommand;
2246     infoPtr->buttons[nIndex].fsState   = lpTbb->fsState;
2247     infoPtr->buttons[nIndex].fsStyle   = lpTbb->fsStyle;
2248     infoPtr->buttons[nIndex].dwData    = lpTbb->dwData;
2249     infoPtr->buttons[nIndex].iString   = lpTbb->iString;
2250
2251     if ((infoPtr->hwndToolTip) && !(lpTbb->fsStyle & TBSTYLE_SEP)) {
2252         TTTOOLINFOW ti;
2253
2254         ZeroMemory (&ti, sizeof(TTTOOLINFOW));
2255         ti.cbSize   = sizeof (TTTOOLINFOW);
2256         ti.hwnd     = hwnd;
2257         ti.uId      = lpTbb->idCommand;
2258         ti.hinst    = 0;
2259         ti.lpszText = LPSTR_TEXTCALLBACKW;
2260
2261         SendMessageW (infoPtr->hwndToolTip, TTM_ADDTOOLW,
2262                         0, (LPARAM)&ti);
2263     }
2264
2265     /* post insert copy */
2266     if (nIndex < infoPtr->nNumButtons - 1) {
2267         memcpy (&infoPtr->buttons[nIndex+1], &oldButtons[nIndex],
2268                 (infoPtr->nNumButtons - nIndex - 1) * sizeof(TBUTTON_INFO));
2269     }
2270
2271     COMCTL32_Free (oldButtons);
2272
2273     TOOLBAR_CalcToolbar (hwnd);
2274
2275     InvalidateRect (hwnd, NULL, FALSE);
2276
2277     return TRUE;
2278 }
2279
2280
2281 /* << TOOLBAR_InsertMarkHitTest >> */
2282
2283
2284 static LRESULT
2285 TOOLBAR_IsButtonChecked (HWND hwnd, WPARAM wParam, LPARAM lParam)
2286 {
2287     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2288     INT nIndex;
2289
2290     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2291     if (nIndex == -1)
2292         return FALSE;
2293
2294     return (infoPtr->buttons[nIndex].fsState & TBSTATE_CHECKED);
2295 }
2296
2297
2298 static LRESULT
2299 TOOLBAR_IsButtonEnabled (HWND hwnd, WPARAM wParam, LPARAM lParam)
2300 {
2301     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2302     INT nIndex;
2303
2304     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2305     if (nIndex == -1)
2306         return FALSE;
2307
2308     return (infoPtr->buttons[nIndex].fsState & TBSTATE_ENABLED);
2309 }
2310
2311
2312 static LRESULT
2313 TOOLBAR_IsButtonHidden (HWND hwnd, WPARAM wParam, LPARAM lParam)
2314 {
2315     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2316     INT nIndex;
2317
2318     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2319     if (nIndex == -1)
2320         return FALSE;
2321
2322     return (infoPtr->buttons[nIndex].fsState & TBSTATE_HIDDEN);
2323 }
2324
2325
2326 static LRESULT
2327 TOOLBAR_IsButtonHighlighted (HWND hwnd, WPARAM wParam, LPARAM lParam)
2328 {
2329     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2330     INT nIndex;
2331
2332     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2333     if (nIndex == -1)
2334         return FALSE;
2335
2336     return (infoPtr->buttons[nIndex].fsState & TBSTATE_MARKED);
2337 }
2338
2339
2340 static LRESULT
2341 TOOLBAR_IsButtonIndeterminate (HWND hwnd, WPARAM wParam, LPARAM lParam)
2342 {
2343     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2344     INT nIndex;
2345
2346     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2347     if (nIndex == -1)
2348         return FALSE;
2349
2350     return (infoPtr->buttons[nIndex].fsState & TBSTATE_INDETERMINATE);
2351 }
2352
2353
2354 static LRESULT
2355 TOOLBAR_IsButtonPressed (HWND hwnd, WPARAM wParam, LPARAM lParam)
2356 {
2357     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2358     INT nIndex;
2359
2360     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2361     if (nIndex == -1)
2362         return FALSE;
2363
2364     return (infoPtr->buttons[nIndex].fsState & TBSTATE_PRESSED);
2365 }
2366
2367
2368 /* << TOOLBAR_LoadImages >> */
2369 /* << TOOLBAR_MapAccelerator >> */
2370 /* << TOOLBAR_MarkButton >> */
2371 /* << TOOLBAR_MoveButton >> */
2372
2373
2374 static LRESULT
2375 TOOLBAR_PressButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
2376 {
2377     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2378     TBUTTON_INFO *btnPtr;
2379     INT nIndex;
2380
2381     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2382     if (nIndex == -1)
2383         return FALSE;
2384
2385     btnPtr = &infoPtr->buttons[nIndex];
2386     if (LOWORD(lParam) == FALSE)
2387         btnPtr->fsState &= ~TBSTATE_PRESSED;
2388     else
2389         btnPtr->fsState |= TBSTATE_PRESSED;
2390
2391     RedrawWindow(hwnd,&btnPtr->rect,NULL,
2392                  RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
2393
2394     return TRUE;
2395 }
2396
2397
2398 /* << TOOLBAR_ReplaceBitmap >> */
2399
2400
2401 static LRESULT
2402 TOOLBAR_SaveRestoreA (HWND hwnd, WPARAM wParam, LPARAM lParam)
2403 {
2404 #if 0
2405     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2406     LPTBSAVEPARAMSA lpSave = (LPTBSAVEPARAMSA)lParam;
2407
2408     if (lpSave == NULL) return 0;
2409
2410     if ((BOOL)wParam) {
2411         /* save toolbar information */
2412         FIXME("save to \"%s\" \"%s\"\n",
2413                lpSave->pszSubKey, lpSave->pszValueName);
2414
2415
2416     }
2417     else {
2418         /* restore toolbar information */
2419
2420         FIXME("restore from \"%s\" \"%s\"\n",
2421                lpSave->pszSubKey, lpSave->pszValueName);
2422
2423
2424     }
2425 #endif
2426
2427     return 0;
2428 }
2429
2430
2431 static LRESULT
2432 TOOLBAR_SaveRestoreW (HWND hwnd, WPARAM wParam, LPARAM lParam)
2433 {
2434 #if 0
2435     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2436     LPTBSAVEPARAMSW lpSave = (LPTBSAVEPARAMSW)lParam;
2437
2438     if (lpSave == NULL)
2439         return 0;
2440
2441     if ((BOOL)wParam) {
2442         /* save toolbar information */
2443         FIXME("save to \"%s\" \"%s\"\n",
2444                lpSave->pszSubKey, lpSave->pszValueName);
2445
2446
2447     }
2448     else {
2449         /* restore toolbar information */
2450
2451         FIXME("restore from \"%s\" \"%s\"\n",
2452                lpSave->pszSubKey, lpSave->pszValueName);
2453
2454
2455     }
2456 #endif
2457
2458     return 0;
2459 }
2460
2461
2462 static LRESULT
2463 TOOLBAR_SetAnchorHighlight (HWND hwnd, WPARAM wParam)
2464 {
2465     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2466     BOOL bOldAnchor = infoPtr->bAnchor;
2467
2468     infoPtr->bAnchor = (BOOL)wParam;
2469
2470     return (LRESULT)bOldAnchor;
2471 }
2472
2473
2474 static LRESULT
2475 TOOLBAR_SetBitmapSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
2476 {
2477     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2478
2479     if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0))
2480         return FALSE;
2481
2482     /* Bitmap size can only be set before adding any button to the toolbar
2483        according to the documentation.  */
2484     if( infoPtr->nNumButtons != 0 )
2485         return FALSE;
2486
2487     infoPtr->nBitmapWidth = (INT)LOWORD(lParam);
2488     infoPtr->nBitmapHeight = (INT)HIWORD(lParam);
2489
2490     return TRUE;
2491 }
2492
2493
2494 static LRESULT
2495 TOOLBAR_SetButtonInfoA (HWND hwnd, WPARAM wParam, LPARAM lParam)
2496 {
2497     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2498     LPTBBUTTONINFOA lptbbi = (LPTBBUTTONINFOA)lParam;
2499     TBUTTON_INFO *btnPtr;
2500     INT nIndex;
2501
2502     if (lptbbi == NULL)
2503         return FALSE;
2504     if (lptbbi->cbSize < sizeof(TBBUTTONINFOA))
2505         return FALSE;
2506
2507     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2508     if (nIndex == -1)
2509         return FALSE;
2510
2511     btnPtr = &infoPtr->buttons[nIndex];
2512     if (lptbbi->dwMask & TBIF_COMMAND)
2513         btnPtr->idCommand = lptbbi->idCommand;
2514     if (lptbbi->dwMask & TBIF_IMAGE)
2515         btnPtr->iBitmap = lptbbi->iImage;
2516     if (lptbbi->dwMask & TBIF_LPARAM)
2517         btnPtr->dwData = lptbbi->lParam;
2518 /*    if (lptbbi->dwMask & TBIF_SIZE) */
2519 /*      btnPtr->cx = lptbbi->cx; */
2520     if (lptbbi->dwMask & TBIF_STATE)
2521         btnPtr->fsState = lptbbi->fsState;
2522     if (lptbbi->dwMask & TBIF_STYLE)
2523         btnPtr->fsStyle = lptbbi->fsStyle;
2524
2525     if (lptbbi->dwMask & TBIF_TEXT) {
2526         if ((btnPtr->iString >= 0) ||
2527             (btnPtr->iString < infoPtr->nNumStrings)) {
2528            TRACE("Ooooooch\n");
2529 #if 0
2530             WCHAR **lpString = &infoPtr->strings[btnPtr->iString];
2531             INT len = lstrlenA (lptbbi->pszText);
2532             *lpString = COMCTL32_ReAlloc (lpString, sizeof(WCHAR)*(len+1));
2533 #endif
2534
2535             /* this is the ultimate sollution */
2536 /*          Str_SetPtrA (&infoPtr->strings[btnPtr->iString], lptbbi->pszText); */
2537         }
2538     }
2539
2540     return TRUE;
2541 }
2542
2543
2544 static LRESULT
2545 TOOLBAR_SetButtonInfoW (HWND hwnd, WPARAM wParam, LPARAM lParam)
2546 {
2547     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2548     LPTBBUTTONINFOW lptbbi = (LPTBBUTTONINFOW)lParam;
2549     TBUTTON_INFO *btnPtr;
2550     INT nIndex;
2551
2552     if (lptbbi == NULL)
2553         return FALSE;
2554     if (lptbbi->cbSize < sizeof(TBBUTTONINFOW))
2555         return FALSE;
2556
2557     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2558     if (nIndex == -1)
2559         return FALSE;
2560
2561     btnPtr = &infoPtr->buttons[nIndex];
2562     if (lptbbi->dwMask & TBIF_COMMAND)
2563         btnPtr->idCommand = lptbbi->idCommand;
2564     if (lptbbi->dwMask & TBIF_IMAGE)
2565         btnPtr->iBitmap = lptbbi->iImage;
2566     if (lptbbi->dwMask & TBIF_LPARAM)
2567         btnPtr->dwData = lptbbi->lParam;
2568 /*    if (lptbbi->dwMask & TBIF_SIZE) */
2569 /*      btnPtr->cx = lptbbi->cx; */
2570     if (lptbbi->dwMask & TBIF_STATE)
2571         btnPtr->fsState = lptbbi->fsState;
2572     if (lptbbi->dwMask & TBIF_STYLE)
2573         btnPtr->fsStyle = lptbbi->fsStyle;
2574
2575     if (lptbbi->dwMask & TBIF_TEXT) {
2576         if ((btnPtr->iString >= 0) ||
2577             (btnPtr->iString < infoPtr->nNumStrings)) {
2578 #if 0
2579             WCHAR **lpString = &infoPtr->strings[btnPtr->iString];
2580             INT len = lstrlenW (lptbbi->pszText);
2581             *lpString = COMCTL32_ReAlloc (lpString, sizeof(WCHAR)*(len+1));
2582 #endif
2583
2584             /* this is the ultimate sollution */
2585 /*          Str_SetPtrA (&infoPtr->strings[btnPtr->iString], lptbbi->pszText); */
2586         }
2587     }
2588
2589     return TRUE;
2590 }
2591
2592
2593 static LRESULT
2594 TOOLBAR_SetButtonSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
2595 {
2596     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2597
2598     if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0))
2599         return FALSE;
2600
2601     /* Button size can only be set before adding any button to the toolbar
2602        according to the documentation.  */
2603     if( infoPtr->nNumButtons != 0 )
2604         return FALSE;
2605
2606     infoPtr->nButtonWidth = (INT)LOWORD(lParam);
2607     infoPtr->nButtonHeight = (INT)HIWORD(lParam);
2608     return TRUE;
2609 }
2610
2611
2612 static LRESULT
2613 TOOLBAR_SetButtonWidth (HWND hwnd, WPARAM wParam, LPARAM lParam)
2614 {
2615     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2616
2617     if (infoPtr == NULL)
2618         return FALSE;
2619
2620     infoPtr->cxMin = (INT)LOWORD(lParam);
2621     infoPtr->cxMax = (INT)HIWORD(lParam);
2622
2623     return TRUE;
2624 }
2625
2626
2627 static LRESULT
2628 TOOLBAR_SetCmdId (HWND hwnd, WPARAM wParam, LPARAM lParam)
2629 {
2630     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2631     INT nIndex = (INT)wParam;
2632
2633     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
2634         return FALSE;
2635
2636     infoPtr->buttons[nIndex].idCommand = (INT)lParam;
2637
2638     if (infoPtr->hwndToolTip) {
2639
2640         FIXME("change tool tip!\n");
2641
2642     }
2643
2644     return TRUE;
2645 }
2646
2647
2648 /* << TOOLBAR_SetColorScheme >> */
2649
2650
2651 static LRESULT
2652 TOOLBAR_SetDisabledImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
2653 {
2654     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2655     HIMAGELIST himlTemp;
2656
2657
2658     himlTemp = infoPtr->himlDis;
2659     infoPtr->himlDis = (HIMAGELIST)lParam;
2660
2661     /* FIXME: redraw ? */
2662
2663     return (LRESULT)himlTemp;
2664 }
2665
2666
2667 static LRESULT
2668 TOOLBAR_SetDrawTextFlags (HWND hwnd, WPARAM wParam, LPARAM lParam)
2669 {
2670     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2671     DWORD dwTemp;
2672
2673     dwTemp = infoPtr->dwDTFlags;
2674     infoPtr->dwDTFlags =
2675         (infoPtr->dwDTFlags & (DWORD)wParam) | (DWORD)lParam;
2676
2677     return (LRESULT)dwTemp;
2678 }
2679
2680
2681 static LRESULT
2682 TOOLBAR_SetExtendedStyle (HWND hwnd, WPARAM wParam, LPARAM lParam)
2683 {
2684     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2685     DWORD dwTemp;
2686
2687     dwTemp = infoPtr->dwExStyle;
2688     infoPtr->dwExStyle = (DWORD)lParam;
2689
2690     return (LRESULT)dwTemp;
2691 }
2692
2693
2694 static LRESULT
2695 TOOLBAR_SetHotImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
2696 {
2697     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
2698     HIMAGELIST himlTemp;
2699
2700     himlTemp = infoPtr->himlHot;
2701     infoPtr->himlHot = (HIMAGELIST)lParam;
2702
2703     /* FIXME: redraw ? */
2704
2705     return (LRESULT)himlTemp;
2706 }
2707
2708
2709 static LRESULT
2710 TOOLBAR_SetHotItem (HWND hwnd, WPARAM wParam)
2711 {
2712     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
2713     INT nOldHotItem = infoPtr->nHotItem;
2714
2715     if (GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT)
2716     {
2717         infoPtr->nHotItem = (INT)wParam;
2718
2719         /* FIXME: What else must be done ??? */
2720
2721     }
2722
2723     if (nOldHotItem < 0)
2724         return -1;
2725
2726     return (LRESULT)nOldHotItem;
2727 }
2728
2729
2730 static LRESULT
2731 TOOLBAR_SetImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
2732 {
2733     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2734     HIMAGELIST himlTemp;
2735
2736     himlTemp = infoPtr->himlDef;
2737     infoPtr->himlDef = (HIMAGELIST)lParam;
2738
2739     /* FIXME: redraw ? */
2740
2741     return (LRESULT)himlTemp;
2742 }
2743
2744
2745 static LRESULT
2746 TOOLBAR_SetIndent (HWND hwnd, WPARAM wParam, LPARAM lParam)
2747 {
2748     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2749
2750     infoPtr->nIndent = (INT)wParam;
2751
2752     TOOLBAR_CalcToolbar (hwnd);
2753
2754     InvalidateRect(hwnd, NULL, FALSE);
2755
2756     return TRUE;
2757 }
2758
2759
2760 /* << TOOLBAR_SetInsertMark >> */
2761
2762
2763 static LRESULT
2764 TOOLBAR_SetInsertMarkColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
2765 {
2766     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2767
2768     infoPtr->clrInsertMark = (COLORREF)lParam;
2769
2770     /* FIXME : redraw ??*/
2771
2772     return 0;
2773 }
2774
2775
2776 static LRESULT
2777 TOOLBAR_SetMaxTextRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
2778 {
2779     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2780
2781     if (infoPtr == NULL)
2782         return FALSE;
2783
2784     infoPtr->nMaxTextRows = (INT)wParam;
2785
2786     return TRUE;
2787 }
2788
2789
2790 /* << TOOLBAR_SetPadding >> */
2791
2792
2793 static LRESULT
2794 TOOLBAR_SetParent (HWND hwnd, WPARAM wParam, LPARAM lParam)
2795 {
2796     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2797     HWND hwndOldNotify;
2798
2799     if (infoPtr == NULL)
2800         return 0;
2801     hwndOldNotify = infoPtr->hwndNotify;
2802     infoPtr->hwndNotify = (HWND)wParam;
2803
2804     return hwndOldNotify;
2805 }
2806
2807
2808 static LRESULT
2809 TOOLBAR_SetRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
2810 {
2811     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2812     LPRECT lprc = (LPRECT)lParam;
2813
2814     if (LOWORD(wParam) > 1) {
2815
2816         FIXME("multiple rows not supported!\n");
2817
2818     }
2819
2820     /* recalculate toolbar */
2821     TOOLBAR_CalcToolbar (hwnd);
2822
2823     /* return bounding rectangle */
2824     if (lprc) {
2825         lprc->left   = infoPtr->rcBound.left;
2826         lprc->right  = infoPtr->rcBound.right;
2827         lprc->top    = infoPtr->rcBound.top;
2828         lprc->bottom = infoPtr->rcBound.bottom;
2829     }
2830
2831     /* repaint toolbar */
2832     InvalidateRect(hwnd, NULL, FALSE);
2833
2834     return 0;
2835 }
2836
2837
2838 static LRESULT
2839 TOOLBAR_SetState (HWND hwnd, WPARAM wParam, LPARAM lParam)
2840 {
2841     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2842     TBUTTON_INFO *btnPtr;
2843     INT nIndex;
2844
2845     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2846     if (nIndex == -1)
2847         return FALSE;
2848
2849     btnPtr = &infoPtr->buttons[nIndex];
2850     btnPtr->fsState = LOWORD(lParam);
2851
2852     RedrawWindow(hwnd,&btnPtr->rect,NULL,
2853                  RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
2854
2855     return TRUE;
2856 }
2857
2858
2859 static LRESULT
2860 TOOLBAR_SetStyle (HWND hwnd, WPARAM wParam, LPARAM lParam)
2861 {
2862     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2863     TBUTTON_INFO *btnPtr;
2864     INT nIndex;
2865
2866     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2867     if (nIndex == -1)
2868         return FALSE;
2869
2870     btnPtr = &infoPtr->buttons[nIndex];
2871     btnPtr->fsStyle = LOWORD(lParam);
2872
2873     RedrawWindow(hwnd,&btnPtr->rect,NULL,
2874                  RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
2875
2876     if (infoPtr->hwndToolTip) {
2877
2878         FIXME("change tool tip!\n");
2879
2880     }
2881
2882     return TRUE;
2883 }
2884
2885
2886 inline static LRESULT
2887 TOOLBAR_SetToolTips (HWND hwnd, WPARAM wParam, LPARAM lParam)
2888 {
2889     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2890
2891     if (infoPtr == NULL)
2892         return 0;
2893     infoPtr->hwndToolTip = (HWND)wParam;
2894     return 0;
2895 }
2896
2897
2898 static LRESULT
2899 TOOLBAR_SetUnicodeFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
2900 {
2901     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2902     BOOL bTemp;
2903
2904     TRACE("%s hwnd=0x%04x stub!\n",
2905            ((BOOL)wParam) ? "TRUE" : "FALSE", hwnd);
2906
2907     bTemp = infoPtr->bUnicode;
2908     infoPtr->bUnicode = (BOOL)wParam;
2909
2910     return bTemp;
2911 }
2912
2913
2914 static LRESULT
2915 TOOLBAR_SetVersion (HWND hwnd, INT iVersion)
2916 {
2917     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2918     INT iOldVersion = infoPtr->iVersion;
2919
2920     infoPtr->iVersion = iVersion;
2921
2922     return iOldVersion;
2923 }
2924
2925
2926 static LRESULT
2927 TOOLBAR_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
2928 {
2929     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2930     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
2931     LOGFONTA logFont;
2932
2933     /* initialize info structure */
2934     infoPtr->nButtonHeight = 22;
2935     infoPtr->nButtonWidth = 24;
2936     infoPtr->nBitmapHeight = 15;
2937     infoPtr->nBitmapWidth = 16;
2938
2939     infoPtr->nHeight = infoPtr->nButtonHeight + TOP_BORDER + BOTTOM_BORDER;
2940     infoPtr->nRows = 1;
2941     infoPtr->nMaxTextRows = 1;
2942     infoPtr->cxMin = -1;
2943     infoPtr->cxMax = -1;
2944
2945     infoPtr->bCaptured = FALSE;
2946     infoPtr->bUnicode = IsWindowUnicode (hwnd);
2947     infoPtr->nButtonDown = -1;
2948     infoPtr->nOldHit = -1;
2949     infoPtr->nHotItem = -2; /* It has to be initially different from nOldHit */
2950     infoPtr->hwndNotify = GetParent (hwnd);
2951     infoPtr->bTransparent = (dwStyle & TBSTYLE_FLAT);
2952     infoPtr->dwDTFlags = (dwStyle & TBSTYLE_LIST) ? DT_LEFT | DT_VCENTER | DT_SINGLELINE : DT_CENTER;
2953     infoPtr->bAnchor = FALSE; /* no anchor highlighting */
2954     infoPtr->iVersion = 0;
2955
2956     SystemParametersInfoA (SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
2957     infoPtr->hFont = CreateFontIndirectA (&logFont);
2958
2959     if (dwStyle & TBSTYLE_TOOLTIPS) {
2960         /* Create tooltip control */
2961         infoPtr->hwndToolTip =
2962             CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
2963                                CW_USEDEFAULT, CW_USEDEFAULT,
2964                                CW_USEDEFAULT, CW_USEDEFAULT,
2965                                hwnd, 0, 0, 0);
2966
2967         /* Send NM_TOOLTIPSCREATED notification */
2968         if (infoPtr->hwndToolTip) {
2969             NMTOOLTIPSCREATED nmttc;
2970
2971             nmttc.hdr.hwndFrom = hwnd;
2972             nmttc.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
2973             nmttc.hdr.code = NM_TOOLTIPSCREATED;
2974             nmttc.hwndToolTips = infoPtr->hwndToolTip;
2975
2976             SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
2977                           (WPARAM)nmttc.hdr.idFrom, (LPARAM)&nmttc);
2978         }
2979     }
2980
2981     return 0;
2982 }
2983
2984
2985 static LRESULT
2986 TOOLBAR_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
2987 {
2988     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2989
2990     /* delete tooltip control */
2991     if (infoPtr->hwndToolTip)
2992         DestroyWindow (infoPtr->hwndToolTip);
2993
2994     /* delete button data */
2995     if (infoPtr->buttons)
2996         COMCTL32_Free (infoPtr->buttons);
2997
2998     /* delete strings */
2999     if (infoPtr->strings) {
3000         INT i;
3001         for (i = 0; i < infoPtr->nNumStrings; i++)
3002             if (infoPtr->strings[i])
3003                 COMCTL32_Free (infoPtr->strings[i]);
3004
3005         COMCTL32_Free (infoPtr->strings);
3006     }
3007
3008     /* destroy internal image list */
3009     if (infoPtr->himlInt)
3010         ImageList_Destroy (infoPtr->himlInt);
3011
3012     /* delete default font */
3013     if (infoPtr->hFont)
3014         DeleteObject (infoPtr->hFont);
3015
3016     /* free toolbar info data */
3017     COMCTL32_Free (infoPtr);
3018     SetWindowLongA (hwnd, 0, 0);
3019
3020     return 0;
3021 }
3022
3023
3024 static LRESULT
3025 TOOLBAR_EraseBackground (HWND hwnd, WPARAM wParam, LPARAM lParam)
3026 {
3027     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3028
3029     if (infoPtr->bTransparent)
3030         return SendMessageA (GetParent (hwnd), WM_ERASEBKGND, wParam, lParam);
3031
3032     return DefWindowProcA (hwnd, WM_ERASEBKGND, wParam, lParam);
3033 }
3034
3035
3036 static LRESULT
3037 TOOLBAR_GetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
3038 {
3039     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3040
3041     return infoPtr->hFont;
3042 }
3043
3044
3045 static LRESULT
3046 TOOLBAR_LButtonDblClk (HWND hwnd, WPARAM wParam, LPARAM lParam)
3047 {
3048     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3049     TBUTTON_INFO *btnPtr;
3050     POINT pt;
3051     INT   nHit;
3052
3053     pt.x = (INT)LOWORD(lParam);
3054     pt.y = (INT)HIWORD(lParam);
3055     nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
3056
3057     if (nHit >= 0) {
3058         btnPtr = &infoPtr->buttons[nHit];
3059         if (!(btnPtr->fsState & TBSTATE_ENABLED))
3060             return 0;
3061         SetCapture (hwnd);
3062         infoPtr->bCaptured = TRUE;
3063         infoPtr->nButtonDown = nHit;
3064
3065         btnPtr->fsState |= TBSTATE_PRESSED;
3066
3067         RedrawWindow(hwnd,&btnPtr->rect,NULL,
3068                      RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
3069     }
3070     else if (GetWindowLongA (hwnd, GWL_STYLE) & CCS_ADJUSTABLE)
3071         TOOLBAR_Customize (hwnd);
3072
3073     return 0;
3074 }
3075
3076
3077 static LRESULT
3078 TOOLBAR_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
3079 {
3080     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3081     TBUTTON_INFO *btnPtr;
3082     POINT pt;
3083     INT   nHit;
3084
3085     if (infoPtr->hwndToolTip)
3086         TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
3087                             WM_LBUTTONDOWN, wParam, lParam);
3088
3089     pt.x = (INT)LOWORD(lParam);
3090     pt.y = (INT)HIWORD(lParam);
3091     nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
3092
3093     if (nHit >= 0) {
3094         btnPtr = &infoPtr->buttons[nHit];
3095         if (!(btnPtr->fsState & TBSTATE_ENABLED))
3096             return 0;
3097
3098         if (btnPtr->fsStyle &  TBSTYLE_DROPDOWN)
3099         {
3100             NMTOOLBARA nmtb;
3101
3102             nmtb.hdr.hwndFrom = hwnd;
3103             nmtb.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
3104             nmtb.hdr.code = TBN_DROPDOWN;
3105             nmtb.iItem = btnPtr->idCommand;
3106
3107             SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
3108                           (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb);
3109         }
3110
3111         SetCapture (hwnd);
3112         infoPtr->bCaptured = TRUE;
3113         infoPtr->nButtonDown = nHit;
3114         infoPtr->nOldHit = nHit;
3115
3116         btnPtr->fsState |= TBSTATE_PRESSED;
3117         btnPtr->bHot = FALSE;
3118
3119         RedrawWindow(hwnd,&btnPtr->rect,NULL,
3120                      RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
3121     }
3122
3123     return 0;
3124 }
3125
3126 static LRESULT
3127 TOOLBAR_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
3128 {
3129     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3130     TBUTTON_INFO *btnPtr;
3131     POINT pt;
3132     INT   nHit;
3133     INT   nOldIndex = -1;
3134     BOOL  bSendMessage = TRUE;
3135
3136     if (infoPtr->hwndToolTip)
3137         TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
3138                             WM_LBUTTONUP, wParam, lParam);
3139
3140     pt.x = (INT)LOWORD(lParam);
3141     pt.y = (INT)HIWORD(lParam);
3142     nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
3143
3144     if ((infoPtr->bCaptured) && (infoPtr->nButtonDown >= 0)) {
3145         infoPtr->bCaptured = FALSE;
3146         ReleaseCapture ();
3147         btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
3148         btnPtr->fsState &= ~TBSTATE_PRESSED;
3149
3150         if (nHit == infoPtr->nButtonDown) {
3151             if (btnPtr->fsStyle & TBSTYLE_CHECK) {
3152                 if (btnPtr->fsStyle & TBSTYLE_GROUP) {
3153                     nOldIndex = TOOLBAR_GetCheckedGroupButtonIndex (infoPtr,
3154                         infoPtr->nButtonDown);
3155                     if (nOldIndex == infoPtr->nButtonDown)
3156                         bSendMessage = FALSE;
3157                     if ((nOldIndex != infoPtr->nButtonDown) &&
3158                         (nOldIndex != -1))
3159                         infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
3160                     btnPtr->fsState |= TBSTATE_CHECKED;
3161                 }
3162                 else {
3163                     if (btnPtr->fsState & TBSTATE_CHECKED)
3164                         btnPtr->fsState &= ~TBSTATE_CHECKED;
3165                     else
3166                         btnPtr->fsState |= TBSTATE_CHECKED;
3167                 }
3168             }
3169         }
3170         else
3171             bSendMessage = FALSE;
3172
3173         if (nOldIndex != -1)
3174             RedrawWindow(hwnd,&infoPtr->buttons[nOldIndex].rect,NULL,
3175                          RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
3176         RedrawWindow(hwnd,&btnPtr->rect,NULL,
3177                      RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
3178
3179         if (bSendMessage) {
3180             SendMessageA (GetParent(hwnd), WM_COMMAND,
3181                           MAKEWPARAM(btnPtr->idCommand, 0), (LPARAM)hwnd);
3182
3183 //          if ((GetWindowLongA(hwnd, GWL_STYLE) & TBSTYLE_DROPDOWN) ||
3184 //              (btnPtr->fsStyle & 0x08/* BTNS_DROPDOWN */)) {
3185        /*
3186         * This appears to be an error. Instead of checking the style of the
3187         * button in question wine was checking the style of the toolbar
3188         * itself. This caused a number of strange behaviors. In my
3189         * invistigation i think the whole dropdown thing is still fairly
3190         * broken. but this helps fix some of the problems.
3191         */
3192
3193         if (btnPtr->fsStyle &  TBSTYLE_DROPDOWN) {
3194                NMTOOLBARW       nmtb;
3195
3196                nmtb.hdr.hwndFrom = hwnd;
3197                nmtb.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
3198                nmtb.hdr.code     = TBN_DROPDOWN;
3199                nmtb.iItem        = nHit;
3200                /* nmtb.tbButton not used with TBN_DROPDOWN */
3201                if ((btnPtr->iString >= 0) && (btnPtr->iString < infoPtr->nNumStrings)) {
3202                   nmtb.pszText      = infoPtr->strings[btnPtr->iString];
3203                   nmtb.cchText      = lstrlenW(nmtb.pszText);
3204                } else {
3205                   nmtb.pszText      = NULL;
3206                   nmtb.cchText      = 0;
3207                }
3208                nmtb.rcButton     = btnPtr->rect;
3209
3210                SendMessageW(infoPtr->hwndNotify, WM_NOTIFY,
3211                             (WPARAM)nmtb.hdr.idFrom, (LPARAM)&nmtb);
3212             }
3213         }
3214         infoPtr->nButtonDown = -1;
3215         infoPtr->nOldHit = -1;
3216     }
3217
3218     return 0;
3219 }
3220
3221 static LRESULT
3222 TOOLBAR_MouseLeave (HWND hwnd, WPARAM wParam, LPARAM lParam)
3223 {
3224     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3225     TBUTTON_INFO *hotBtnPtr;
3226
3227     hotBtnPtr = &infoPtr->buttons[infoPtr->nOldHit];
3228
3229     /* Redraw the button if the last button we were over is the hot button and it
3230        is enabled */
3231     if((infoPtr->nOldHit == infoPtr->nHotItem) && (hotBtnPtr->fsState & TBSTATE_ENABLED))
3232     {
3233         hotBtnPtr->bHot = FALSE;
3234
3235         InvalidateRect (hwnd, &hotBtnPtr->rect, TRUE);
3236     }
3237
3238     infoPtr->nOldHit = -1; /* reset the old hit index as we've left the toolbar */
3239     infoPtr->nHotItem = -2; /* It has to be initially different from nOldHit */
3240
3241     return TRUE;
3242 }
3243
3244 static LRESULT
3245 TOOLBAR_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
3246 {
3247     TBUTTON_INFO *btnPtr, *oldBtnPtr;
3248     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3249     POINT pt;
3250     INT   nHit;
3251     TRACKMOUSEEVENT trackinfo;
3252
3253     /* fill in the TRACKMOUSEEVENT struct */
3254     trackinfo.cbSize = sizeof(TRACKMOUSEEVENT);
3255     trackinfo.dwFlags = TME_QUERY;
3256     trackinfo.hwndTrack = hwnd;
3257     trackinfo.dwHoverTime = HOVER_DEFAULT;
3258
3259     /* call _TrackMouseEvent to see if we are currently tracking for this hwnd */
3260     _TrackMouseEvent(&trackinfo);
3261
3262     /* Make sure tracking is enabled so we recieve a WM_MOUSELEAVE message */
3263     if(!(trackinfo.dwFlags & TME_LEAVE)) {
3264         trackinfo.dwFlags = TME_LEAVE; /* notify upon leaving */
3265
3266         /* call TRACKMOUSEEVENT so we recieve a WM_MOUSELEAVE message */
3267         /* and can properly deactivate the hot toolbar button */
3268         _TrackMouseEvent(&trackinfo);
3269    }
3270
3271     if (infoPtr->hwndToolTip)
3272         TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
3273                             WM_MOUSEMOVE, wParam, lParam);
3274
3275     pt.x = (INT)LOWORD(lParam);
3276     pt.y = (INT)HIWORD(lParam);
3277
3278     nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
3279
3280     if (infoPtr->nOldHit != nHit)
3281     {
3282         /* Remove the effect of an old hot button if the button was enabled and was
3283            drawn with the hot button effect */
3284         if(infoPtr->nOldHit == infoPtr->nHotItem &&
3285                 (infoPtr->buttons[infoPtr->nOldHit].fsState & TBSTATE_ENABLED))
3286         {
3287             oldBtnPtr = &infoPtr->buttons[infoPtr->nOldHit];
3288             oldBtnPtr->bHot = FALSE;
3289
3290             InvalidateRect (hwnd, &oldBtnPtr->rect, TRUE);
3291         }
3292
3293         /* It's not a separator or in nowhere. It's a hot button. */
3294         if (nHit >= 0)
3295         {
3296             btnPtr = &infoPtr->buttons[nHit];
3297             btnPtr->bHot = TRUE;
3298
3299             RedrawWindow(hwnd,&btnPtr->rect,NULL,
3300                          RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
3301
3302             infoPtr->nHotItem = nHit;
3303         }
3304
3305     if (infoPtr->bCaptured) {
3306             btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
3307             if (infoPtr->nOldHit == infoPtr->nButtonDown) {
3308                 btnPtr->fsState &= ~TBSTATE_PRESSED;
3309                 RedrawWindow(hwnd,&btnPtr->rect,NULL,
3310                              RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
3311             }
3312             else if (nHit == infoPtr->nButtonDown) {
3313                 btnPtr->fsState |= TBSTATE_PRESSED;
3314                 RedrawWindow(hwnd,&btnPtr->rect,NULL,
3315                              RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
3316             }
3317         }
3318         infoPtr->nOldHit = nHit;
3319     }
3320     return 0;
3321 }
3322
3323
3324 inline static LRESULT
3325 TOOLBAR_NCActivate (HWND hwnd, WPARAM wParam, LPARAM lParam)
3326 {
3327 /*    if (wndPtr->dwStyle & CCS_NODIVIDER) */
3328         return DefWindowProcA (hwnd, WM_NCACTIVATE, wParam, lParam);
3329 /*    else */
3330 /*      return TOOLBAR_NCPaint (wndPtr, wParam, lParam); */
3331 }
3332
3333
3334 inline static LRESULT
3335 TOOLBAR_NCCalcSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
3336 {
3337     if (!(GetWindowLongA (hwnd, GWL_STYLE) & CCS_NODIVIDER))
3338         ((LPRECT)lParam)->top += GetSystemMetrics(SM_CYEDGE);
3339
3340     return DefWindowProcA (hwnd, WM_NCCALCSIZE, wParam, lParam);
3341 }
3342
3343
3344 static LRESULT
3345 TOOLBAR_NCCreate (HWND hwnd, WPARAM wParam, LPARAM lParam)
3346 {
3347     TOOLBAR_INFO *infoPtr;
3348
3349     /* allocate memory for info structure */
3350     infoPtr = (TOOLBAR_INFO *)COMCTL32_Alloc (sizeof(TOOLBAR_INFO));
3351     SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
3352
3353     /* paranoid!! */
3354     infoPtr->dwStructSize = sizeof(TBBUTTON);
3355
3356     /* fix instance handle, if the toolbar was created by CreateToolbarEx() */
3357     if (!GetWindowLongA (hwnd, GWL_HINSTANCE)) {
3358         HINSTANCE hInst = (HINSTANCE)GetWindowLongA (GetParent (hwnd), GWL_HINSTANCE);
3359         SetWindowLongA (hwnd, GWL_HINSTANCE, (DWORD)hInst);
3360     }
3361
3362     return DefWindowProcA (hwnd, WM_NCCREATE, wParam, lParam);
3363 }
3364
3365
3366 static LRESULT
3367 TOOLBAR_NCPaint (HWND hwnd, WPARAM wParam, LPARAM lParam)
3368 {
3369     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
3370     RECT rcWindow;
3371     HDC hdc;
3372
3373     if (dwStyle & WS_MINIMIZE)
3374         return 0; /* Nothing to do */
3375
3376     DefWindowProcA (hwnd, WM_NCPAINT, wParam, lParam);
3377
3378     if (!(hdc = GetDCEx (hwnd, 0, DCX_USESTYLE | DCX_WINDOW)))
3379         return 0;
3380
3381     if (!(dwStyle & CCS_NODIVIDER))
3382     {
3383         GetWindowRect (hwnd, &rcWindow);
3384         OffsetRect (&rcWindow, -rcWindow.left, -rcWindow.top);
3385         if( dwStyle & WS_BORDER )
3386             OffsetRect (&rcWindow, 1, 1);
3387         DrawEdge (hdc, &rcWindow, EDGE_ETCHED, BF_TOP);
3388     }
3389
3390     ReleaseDC( hwnd, hdc );
3391
3392     return 0;
3393 }
3394
3395
3396 inline static LRESULT
3397 TOOLBAR_Notify (HWND hwnd, WPARAM wParam, LPARAM lParam)
3398 {
3399     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3400     LPNMHDR lpnmh = (LPNMHDR)lParam;
3401
3402     TRACE("passing WM_NOTIFY!\n");
3403
3404     if ((infoPtr->hwndToolTip) && (lpnmh->hwndFrom == infoPtr->hwndToolTip)) {
3405         SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,   wParam, lParam);
3406
3407 #if 0
3408         if (lpnmh->code == TTN_GETDISPINFOA) {
3409             LPNMTTDISPINFOA lpdi = (LPNMTTDISPINFOA)lParam;
3410
3411             FIXME("retrieving ASCII string\n");
3412
3413         }
3414         else if (lpnmh->code == TTN_GETDISPINFOW) {
3415             LPNMTTDISPINFOW lpdi = (LPNMTTDISPINFOW)lParam;
3416
3417             FIXME("retrieving UNICODE string\n");
3418
3419         }
3420 #endif
3421     }
3422
3423     return 0;
3424 }
3425
3426
3427 static LRESULT
3428 TOOLBAR_Paint (HWND hwnd, WPARAM wParam)
3429 {
3430     HDC hdc;
3431     PAINTSTRUCT ps;
3432
3433     TOOLBAR_CalcToolbar( hwnd );
3434     hdc = wParam==0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
3435     TOOLBAR_Refresh (hwnd, hdc);
3436     if (!wParam)
3437         EndPaint (hwnd, &ps);
3438     return 0;
3439 }
3440
3441
3442 static LRESULT
3443 TOOLBAR_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
3444 {
3445     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3446     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
3447     RECT parent_rect;
3448     RECT window_rect;
3449     HWND parent;
3450     INT  x, y;
3451     INT  cx, cy;
3452     INT  flags;
3453     UINT uPosFlags = 0;
3454
3455     /* Resize deadlock check */
3456     if (infoPtr->bAutoSize) {
3457         infoPtr->bAutoSize = FALSE;
3458         return 0;
3459     }
3460
3461     flags = (INT) wParam;
3462
3463     /* FIXME for flags =
3464      * SIZE_MAXIMIZED, SIZE_MAXSHOW, SIZE_MINIMIZED
3465      */
3466
3467     TRACE("sizing toolbar!\n");
3468
3469     if (flags == SIZE_RESTORED) {
3470         /* width and height don't apply */
3471         parent = GetParent (hwnd);
3472         GetClientRect(parent, &parent_rect);
3473         x = parent_rect.left;
3474         y = parent_rect.top;
3475
3476         if (dwStyle & CCS_NORESIZE) {
3477             uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
3478
3479             /* FIXME */
3480 /*          infoPtr->nWidth = parent_rect.right - parent_rect.left; */
3481             cy = infoPtr->nHeight;
3482             cx = infoPtr->nWidth;
3483             TOOLBAR_CalcToolbar (hwnd);
3484             infoPtr->nWidth = cx;
3485             infoPtr->nHeight = cy;
3486         }
3487         else {
3488             infoPtr->nWidth = parent_rect.right - parent_rect.left;
3489             TOOLBAR_CalcToolbar (hwnd);
3490             cy = infoPtr->nHeight;
3491             cx = infoPtr->nWidth;
3492
3493             if (dwStyle & CCS_NOMOVEY) {
3494                 GetWindowRect(hwnd, &window_rect);
3495                 ScreenToClient(parent, (LPPOINT)&window_rect.left);
3496                 y = window_rect.top;
3497             }
3498         }
3499
3500         if (dwStyle & CCS_NOPARENTALIGN) {
3501             uPosFlags |= SWP_NOMOVE;
3502             cy = infoPtr->nHeight;
3503             cx = infoPtr->nWidth;
3504         }
3505
3506         if (!(dwStyle & CCS_NODIVIDER))
3507             cy += GetSystemMetrics(SM_CYEDGE);
3508
3509         if (dwStyle & WS_BORDER)
3510         {
3511             x = y = 1;
3512             cy += GetSystemMetrics(SM_CYEDGE);
3513             cx += GetSystemMetrics(SM_CYEDGE);
3514         }
3515
3516         SetWindowPos (hwnd, 0, parent_rect.left - x, parent_rect.top - y,
3517                         cx, cy, uPosFlags | SWP_NOZORDER);
3518     }
3519     return 0;
3520 }
3521
3522
3523 static LRESULT
3524 TOOLBAR_StyleChanged (HWND hwnd, INT nType, LPSTYLESTRUCT lpStyle)
3525 {
3526     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3527
3528     if (nType == GWL_STYLE) {
3529         if (lpStyle->styleNew & TBSTYLE_LIST) {
3530             infoPtr->dwDTFlags = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
3531         }
3532         else {
3533             infoPtr->dwDTFlags = DT_CENTER;
3534         }
3535     }
3536
3537     TOOLBAR_AutoSize (hwnd);
3538
3539     InvalidateRect(hwnd, NULL, FALSE);
3540
3541     return 0;
3542 }
3543
3544
3545
3546 static LRESULT WINAPI
3547 ToolbarWindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
3548 {
3549
3550     switch (uMsg)
3551     {
3552        case WM_DESTROY:
3553            return TOOLBAR_Destroy (hwnd, wParam, lParam);
3554
3555        case WM_NCCREATE:
3556            return TOOLBAR_NCCreate (hwnd, wParam, lParam);
3557     }
3558
3559     if (!TOOLBAR_GetInfoPtr (hwnd))
3560     {
3561        return DefWindowProcA (hwnd, uMsg, wParam, lParam);
3562     }
3563
3564     switch (uMsg)
3565     {
3566         case TB_ADDBITMAP:
3567             return TOOLBAR_AddBitmap (hwnd, wParam, lParam);
3568
3569         case TB_ADDBUTTONSA:
3570             return TOOLBAR_AddButtonsA (hwnd, wParam, lParam);
3571
3572         case TB_ADDBUTTONSW:
3573             return TOOLBAR_AddButtonsW (hwnd, wParam, lParam);
3574
3575         case TB_ADDSTRINGA:
3576             return TOOLBAR_AddStringA (hwnd, wParam, lParam);
3577
3578         case TB_ADDSTRINGW:
3579             return TOOLBAR_AddStringW (hwnd, wParam, lParam);
3580
3581         case TB_AUTOSIZE:
3582             return TOOLBAR_AutoSize (hwnd);
3583
3584         case TB_BUTTONCOUNT:
3585             return TOOLBAR_ButtonCount (hwnd, wParam, lParam);
3586
3587         case TB_BUTTONSTRUCTSIZE:
3588             return TOOLBAR_ButtonStructSize (hwnd, wParam, lParam);
3589
3590         case TB_CHANGEBITMAP:
3591             return TOOLBAR_ChangeBitmap (hwnd, wParam, lParam);
3592
3593         case TB_CHECKBUTTON:
3594             return TOOLBAR_CheckButton (hwnd, wParam, lParam);
3595
3596         case TB_COMMANDTOINDEX:
3597             return TOOLBAR_CommandToIndex (hwnd, wParam, lParam);
3598
3599         case TB_CUSTOMIZE:
3600             return TOOLBAR_Customize (hwnd);
3601
3602         case TB_DELETEBUTTON:
3603             return TOOLBAR_DeleteButton (hwnd, wParam, lParam);
3604
3605         case TB_ENABLEBUTTON:
3606             return TOOLBAR_EnableButton (hwnd, wParam, lParam);
3607
3608         case TB_GETANCHORHIGHLIGHT:
3609             return TOOLBAR_GetAnchorHighlight (hwnd);
3610
3611         case TB_GETBITMAP:
3612             return TOOLBAR_GetBitmap (hwnd, wParam, lParam);
3613
3614         case TB_GETBITMAPFLAGS:
3615             return TOOLBAR_GetBitmapFlags (hwnd, wParam, lParam);
3616
3617         case TB_GETBUTTON:
3618             return TOOLBAR_GetButton (hwnd, wParam, lParam);
3619
3620         case TB_GETBUTTONINFOA:
3621             return TOOLBAR_GetButtonInfoA (hwnd, wParam, lParam);
3622
3623         case TB_GETBUTTONINFOW:
3624             return TOOLBAR_GetButtonInfoW (hwnd, wParam, lParam);
3625
3626         case TB_GETBUTTONSIZE:
3627             return TOOLBAR_GetButtonSize (hwnd);
3628
3629         case TB_GETBUTTONTEXTA:
3630             return TOOLBAR_GetButtonTextA (hwnd, wParam, lParam);
3631
3632         case TB_GETBUTTONTEXTW:
3633             return TOOLBAR_GetButtonTextW (hwnd, wParam, lParam);
3634
3635 /*      case TB_GETCOLORSCHEME:                 */ /* 4.71 */
3636
3637         case TB_GETDISABLEDIMAGELIST:
3638             return TOOLBAR_GetDisabledImageList (hwnd, wParam, lParam);
3639
3640         case TB_GETEXTENDEDSTYLE:
3641             return TOOLBAR_GetExtendedStyle (hwnd);
3642
3643         case TB_GETHOTIMAGELIST:
3644             return TOOLBAR_GetHotImageList (hwnd, wParam, lParam);
3645
3646         case TB_GETHOTITEM:
3647             return TOOLBAR_GetHotItem (hwnd);
3648
3649         case TB_GETIMAGELIST:
3650             return TOOLBAR_GetImageList (hwnd, wParam, lParam);
3651
3652 /*      case TB_GETINSERTMARK:                  */ /* 4.71 */
3653 /*      case TB_GETINSERTMARKCOLOR:             */ /* 4.71 */
3654
3655         case TB_GETITEMRECT:
3656             return TOOLBAR_GetItemRect (hwnd, wParam, lParam);
3657
3658         case TB_GETMAXSIZE:
3659             return TOOLBAR_GetMaxSize (hwnd, wParam, lParam);
3660
3661 /*      case TB_GETOBJECT:                      */ /* 4.71 */
3662 /*      case TB_GETPADDING:                     */ /* 4.71 */
3663
3664         case TB_GETRECT:
3665             return TOOLBAR_GetRect (hwnd, wParam, lParam);
3666
3667         case TB_GETROWS:
3668             return TOOLBAR_GetRows (hwnd, wParam, lParam);
3669
3670         case TB_GETSTATE:
3671             return TOOLBAR_GetState (hwnd, wParam, lParam);
3672
3673         case TB_GETSTYLE:
3674             return TOOLBAR_GetStyle (hwnd, wParam, lParam);
3675
3676         case TB_GETTEXTROWS:
3677             return TOOLBAR_GetTextRows (hwnd, wParam, lParam);
3678
3679         case TB_GETTOOLTIPS:
3680             return TOOLBAR_GetToolTips (hwnd, wParam, lParam);
3681
3682         case TB_GETUNICODEFORMAT:
3683             return TOOLBAR_GetUnicodeFormat (hwnd, wParam, lParam);
3684
3685         case CCM_GETVERSION:
3686             return TOOLBAR_GetVersion (hwnd);
3687
3688         case TB_HIDEBUTTON:
3689             return TOOLBAR_HideButton (hwnd, wParam, lParam);
3690
3691         case TB_HITTEST:
3692             return TOOLBAR_HitTest (hwnd, wParam, lParam);
3693
3694         case TB_INDETERMINATE:
3695             return TOOLBAR_Indeterminate (hwnd, wParam, lParam);
3696
3697         case TB_INSERTBUTTONA:
3698             return TOOLBAR_InsertButtonA (hwnd, wParam, lParam);
3699
3700         case TB_INSERTBUTTONW:
3701             return TOOLBAR_InsertButtonW (hwnd, wParam, lParam);
3702
3703 /*      case TB_INSERTMARKHITTEST:              */ /* 4.71 */
3704
3705         case TB_ISBUTTONCHECKED:
3706             return TOOLBAR_IsButtonChecked (hwnd, wParam, lParam);
3707
3708         case TB_ISBUTTONENABLED:
3709             return TOOLBAR_IsButtonEnabled (hwnd, wParam, lParam);
3710
3711         case TB_ISBUTTONHIDDEN:
3712             return TOOLBAR_IsButtonHidden (hwnd, wParam, lParam);
3713
3714         case TB_ISBUTTONHIGHLIGHTED:
3715             return TOOLBAR_IsButtonHighlighted (hwnd, wParam, lParam);
3716
3717         case TB_ISBUTTONINDETERMINATE:
3718             return TOOLBAR_IsButtonIndeterminate (hwnd, wParam, lParam);
3719
3720         case TB_ISBUTTONPRESSED:
3721             return TOOLBAR_IsButtonPressed (hwnd, wParam, lParam);
3722
3723         case TB_LOADIMAGES:                        /* 4.70 */
3724             FIXME("missing standard imagelists\n");
3725             return 0;
3726
3727 /*      case TB_MAPACCELERATORA:                */ /* 4.71 */
3728 /*      case TB_MAPACCELERATORW:                */ /* 4.71 */
3729 /*      case TB_MARKBUTTON:                     */ /* 4.71 */
3730 /*      case TB_MOVEBUTTON:                     */ /* 4.71 */
3731
3732         case TB_PRESSBUTTON:
3733             return TOOLBAR_PressButton (hwnd, wParam, lParam);
3734
3735 /*      case TB_REPLACEBITMAP: */
3736
3737         case TB_SAVERESTOREA:
3738             return TOOLBAR_SaveRestoreA (hwnd, wParam, lParam);
3739
3740         case TB_SAVERESTOREW:
3741             return TOOLBAR_SaveRestoreW (hwnd, wParam, lParam);
3742
3743         case TB_SETANCHORHIGHLIGHT:
3744             return TOOLBAR_SetAnchorHighlight (hwnd, wParam);
3745
3746         case TB_SETBITMAPSIZE:
3747             return TOOLBAR_SetBitmapSize (hwnd, wParam, lParam);
3748
3749         case TB_SETBUTTONINFOA:
3750             return TOOLBAR_SetButtonInfoA (hwnd, wParam, lParam);
3751
3752         case TB_SETBUTTONINFOW:
3753             return TOOLBAR_SetButtonInfoW (hwnd, wParam, lParam);
3754
3755         case TB_SETBUTTONSIZE:
3756             return TOOLBAR_SetButtonSize (hwnd, wParam, lParam);
3757
3758         case TB_SETBUTTONWIDTH:
3759             return TOOLBAR_SetButtonWidth (hwnd, wParam, lParam);
3760
3761         case TB_SETCMDID:
3762             return TOOLBAR_SetCmdId (hwnd, wParam, lParam);
3763
3764 /*      case TB_SETCOLORSCHEME:                 */ /* 4.71 */
3765
3766         case TB_SETDISABLEDIMAGELIST:
3767             return TOOLBAR_SetDisabledImageList (hwnd, wParam, lParam);
3768
3769         case TB_SETDRAWTEXTFLAGS:
3770             return TOOLBAR_SetDrawTextFlags (hwnd, wParam, lParam);
3771
3772         case TB_SETEXTENDEDSTYLE:
3773             return TOOLBAR_SetExtendedStyle (hwnd, wParam, lParam);
3774
3775         case TB_SETHOTIMAGELIST:
3776             return TOOLBAR_SetHotImageList (hwnd, wParam, lParam);
3777
3778         case TB_SETHOTITEM:
3779             return TOOLBAR_SetHotItem (hwnd, wParam);
3780
3781         case TB_SETIMAGELIST:
3782             return TOOLBAR_SetImageList (hwnd, wParam, lParam);
3783
3784         case TB_SETINDENT:
3785             return TOOLBAR_SetIndent (hwnd, wParam, lParam);
3786
3787 /*      case TB_SETINSERTMARK:                  */ /* 4.71 */
3788
3789         case TB_SETINSERTMARKCOLOR:
3790             return TOOLBAR_SetInsertMarkColor (hwnd, wParam, lParam);
3791
3792         case TB_SETMAXTEXTROWS:
3793             return TOOLBAR_SetMaxTextRows (hwnd, wParam, lParam);
3794
3795 /*      case TB_SETPADDING:                     */ /* 4.71 */
3796
3797         case TB_SETPARENT:
3798             return TOOLBAR_SetParent (hwnd, wParam, lParam);
3799
3800         case TB_SETROWS:
3801             return TOOLBAR_SetRows (hwnd, wParam, lParam);
3802
3803         case TB_SETSTATE:
3804             return TOOLBAR_SetState (hwnd, wParam, lParam);
3805
3806         case TB_SETSTYLE:
3807             return TOOLBAR_SetStyle (hwnd, wParam, lParam);
3808
3809         case TB_SETTOOLTIPS:
3810             return TOOLBAR_SetToolTips (hwnd, wParam, lParam);
3811
3812         case TB_SETUNICODEFORMAT:
3813             return TOOLBAR_SetUnicodeFormat (hwnd, wParam, lParam);
3814
3815         case CCM_SETVERSION:
3816             return TOOLBAR_SetVersion (hwnd, (INT)wParam);
3817
3818
3819 /*      case WM_CHAR: */
3820
3821         case WM_CREATE:
3822             return TOOLBAR_Create (hwnd, wParam, lParam);
3823
3824         case WM_ERASEBKGND:
3825             return TOOLBAR_EraseBackground (hwnd, wParam, lParam);
3826
3827         case WM_GETFONT:
3828                 return TOOLBAR_GetFont (hwnd, wParam, lParam);
3829
3830 /*      case WM_KEYDOWN: */
3831 /*      case WM_KILLFOCUS: */
3832
3833         case WM_LBUTTONDBLCLK:
3834             return TOOLBAR_LButtonDblClk (hwnd, wParam, lParam);
3835
3836         case WM_LBUTTONDOWN:
3837             return TOOLBAR_LButtonDown (hwnd, wParam, lParam);
3838
3839         case WM_LBUTTONUP:
3840             return TOOLBAR_LButtonUp (hwnd, wParam, lParam);
3841
3842         case WM_MOUSEMOVE:
3843             return TOOLBAR_MouseMove (hwnd, wParam, lParam);
3844
3845         case WM_MOUSELEAVE:
3846             return TOOLBAR_MouseLeave (hwnd, wParam, lParam);
3847
3848         case WM_NCACTIVATE:
3849             return TOOLBAR_NCActivate (hwnd, wParam, lParam);
3850
3851         case WM_NCCALCSIZE:
3852             return TOOLBAR_NCCalcSize (hwnd, wParam, lParam);
3853
3854         case WM_NCPAINT:
3855             return TOOLBAR_NCPaint (hwnd, wParam, lParam);
3856
3857         case WM_NOTIFY:
3858             return TOOLBAR_Notify (hwnd, wParam, lParam);
3859
3860 /*      case WM_NOTIFYFORMAT: */
3861
3862         case WM_PAINT:
3863             return TOOLBAR_Paint (hwnd, wParam);
3864
3865         case WM_SIZE:
3866             return TOOLBAR_Size (hwnd, wParam, lParam);
3867
3868         case WM_STYLECHANGED:
3869             return TOOLBAR_StyleChanged (hwnd, (INT)wParam, (LPSTYLESTRUCT)lParam);
3870
3871 /*      case WM_SYSCOLORCHANGE: */
3872
3873 /*      case WM_WININICHANGE: */
3874
3875         case WM_CHARTOITEM:
3876         case WM_COMMAND:
3877         case WM_DRAWITEM:
3878         case WM_MEASUREITEM:
3879         case WM_VKEYTOITEM:
3880             return SendMessageA (GetParent (hwnd), uMsg, wParam, lParam);
3881
3882         default:
3883             if (uMsg >= WM_USER)
3884                 ERR("unknown msg %04x wp=%08x lp=%08lx\n",
3885                      uMsg, wParam, lParam);
3886             return DefWindowProcA (hwnd, uMsg, wParam, lParam);
3887     }
3888     return 0;
3889 }
3890
3891
3892 VOID
3893 TOOLBAR_Register (void)
3894 {
3895     WNDCLASSA wndClass;
3896
3897     ZeroMemory (&wndClass, sizeof(WNDCLASSA));
3898     wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS;
3899     wndClass.lpfnWndProc   = (WNDPROC)ToolbarWindowProc;
3900     wndClass.cbClsExtra    = 0;
3901     wndClass.cbWndExtra    = sizeof(TOOLBAR_INFO *);
3902     wndClass.hCursor       = LoadCursorA (0, IDC_ARROWA);
3903     wndClass.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
3904     wndClass.lpszClassName = TOOLBARCLASSNAMEA;
3905
3906     RegisterClassA (&wndClass);
3907 }
3908
3909
3910 VOID
3911 TOOLBAR_Unregister (void)
3912 {
3913     UnregisterClassA (TOOLBARCLASSNAMEA, (HINSTANCE)NULL);
3914 }
3915