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

   1 /*
   2  * Toolbar control
   3  *
   4  * Copyright 1998,1999 Eric Kohl
   5  * Copyright 2000 Eric Kohl for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  *  Differences between MSDN and actual native control operation:
  22  *   1. MSDN says: "TBSTYLE_LIST: Creates a flat toolbar with button text
  23  *                  to the right of the bitmap. Otherwise, this style is
  24  *                  identical to TBSTYLE_FLAT."
  25  *      As implemented by both v4.71 and v5.80 of the native COMCTL32.DLL
  26  *      you can create a TBSTYLE_LIST without TBSTYLE_FLAT and the result
  27  *      is non-flat non-transparent buttons. Therefore TBSTYLE_LIST does
  28  *      *not* imply TBSTYLE_FLAT as documented.  (GA 8/2001)
  29  *
  30  *
  31  * TODO:
  32  *   - A little bug in TOOLBAR_DrawMasked()
  33  *   - Button wrapping (under construction).
  34  *   - Messages.
  35  *   - Notifications (under construction).
  36  *   - Fix TB_SETROWS.
  37  *   - Tooltip support (almost complete).
  38  *   - Unicode suppport (under construction).
  39  *   - Fix TOOLBAR_SetButtonInfo32A/W.
  40  *   - TBSTYLE_AUTOSIZE for toolbar and buttons.
  41  *   - I_IMAGECALLBACK support.
  42  *   - iString of -1 is undocumented
  43  *   - Customization dialog:
  44  *      - Add flat look.
  45  *      - Minor buglet in 'available buttons' list:
  46  *        Buttons are not listed in M$-like order. M$ seems to use a single
  47  *        internal list to store the button information of both listboxes.
  48  *      - Drag list support.
  49  *      - Help and Reset button support.
  50  *
  51  * Testing:
  52  *   - Run tests using Waite Group Windows95 API Bible Volume 2.
  53  *     The second cdrom contains executables addstr.exe, btncount.exe,
  54  *     btnstate.exe, butstrsz.exe, chkbtn.exe, chngbmp.exe, customiz.exe,
  55  *     enablebtn.exe, getbmp.exe, getbtn.exe, getflags.exe, hidebtn.exe,
  56  *     indetbtn.exe, insbtn.exe, pressbtn.exe, setbtnsz.exe, setcmdid.exe,
  57  *     setparnt.exe, setrows.exe, toolwnd.exe.
  58  *   - Microsofts controlspy examples.
  59  *   - Charles Petzold's 'Programming Windows': gadgets.exe
  60  */
  61
  62 #include <string.h>
  63
  64 #include "winbase.h"
  65 #include "windef.h"
  66 #include "wingdi.h"
  67 #include "winuser.h"
  68 #include "wine/unicode.h"
  69 #include "commctrl.h"
  70 #include "imagelist.h"
  71 #include "comctl32.h"
  72 #include "wine/debug.h"
  73
  74 WINE_DEFAULT_DEBUG_CHANNEL(toolbar);
  75
  76 typedef struct
  77 {
  78     INT iBitmap;
  79     INT idCommand;
  80     BYTE  fsState;
  81     BYTE  fsStyle;
  82     DWORD dwData;
  83     INT iString;
  84
  85     BOOL bHot;
  86     INT nRow;
  87     RECT rect;
  88 } TBUTTON_INFO;
  89
  90 typedef struct
  91 {
  92     DWORD      dwStructSize;   /* size of TBBUTTON struct */
  93     INT      nHeight;        /* height of the toolbar */
  94     INT      nWidth;         /* width of the toolbar */
  95     INT      nButtonHeight;
  96     INT      nButtonWidth;
  97     INT      nBitmapHeight;
  98     INT      nBitmapWidth;
  99     INT      nIndent;
 100     INT      nRows;           /* number of button rows */
 101     INT      nMaxTextRows;    /* maximum number of text rows */
 102     INT      cxMin;           /* minimum button width */
 103     INT      cxMax;           /* maximum button width */
 104     INT      nNumButtons;     /* number of buttons */
 105     INT      nNumBitmaps;     /* number of bitmaps */
 106     INT      nNumStrings;     /* number of strings */
 107     BOOL     bUnicode;        /* ASCII (FALSE) or Unicode (TRUE)? */
 108     BOOL     bCaptured;       /* mouse captured? */
 109     INT      nButtonDown;
 110     INT      nOldHit;
 111     INT      nHotItem;        /* index of the "hot" item */
 112     DWORD    dwBaseCustDraw;  /* CDRF_ response (w/o TBCDRF_) from PREPAINT */
 113     DWORD    dwItemCustDraw;  /* CDRF_ response (w/o TBCDRF_) from ITEMPREP */
 114     DWORD    dwItemCDFlag;    /* TBCDRF_ flags from last ITEMPREPAINT    */
 115     SIZE     szPadding;       /* padding values around button */
 116     HFONT    hDefaultFont;
 117     HFONT    hFont;           /* text font */
 118     HIMAGELIST himlInt;         /* image list created internally */
 119     HIMAGELIST himlDef;         /* default image list */
 120     HIMAGELIST himlHot;         /* hot image list */
 121     HIMAGELIST himlDis;         /* disabled image list */
 122     HWND     hwndToolTip;     /* handle to tool tip control */
 123     HWND     hwndNotify;      /* handle to the window that gets notifications */
 124     HWND     hwndSelf;        /* my own handle */
 125     BOOL     bTransparent;    /* background transparency flag */
 126     BOOL     bBtnTranspnt;    /* button transparency flag */
 127     BOOL     bAutoSize;       /* auto size deadlock indicator */
 128     BOOL     bAnchor;         /* anchor highlight enabled */
 129     BOOL     bNtfUnicode;     /* TRUE if NOTIFYs use {W} */
 130     BOOL     bDoRedraw;       /* Redraw status */
 131     DWORD      dwExStyle;       /* extended toolbar style */
 132     DWORD      dwDTFlags;       /* DrawText flags */
 133
 134     COLORREF   clrInsertMark;   /* insert mark color */
 135     COLORREF   clrBtnHighlight; /* color for Flat Separator */
 136     COLORREF   clrBtnShadow;    /* color for Flag Separator */
 137     RECT     rcBound;         /* bounding rectangle */
 138     INT      iVersion;
 139
 140     TBUTTON_INFO *buttons;      /* pointer to button array */
 141     LPWSTR       *strings;      /* pointer to string array */
 142 } TOOLBAR_INFO, *PTOOLBAR_INFO;
 143
 144
 145 /* used by customization dialog */
 146 typedef struct
 147 {
 148     PTOOLBAR_INFO tbInfo;
 149     HWND          tbHwnd;
 150 } CUSTDLG_INFO, *PCUSTDLG_INFO;
 151
 152 typedef struct
 153 {
 154     TBBUTTON btn;
 155     BOOL     bVirtual;
 156     BOOL     bRemovable;
 157     CHAR     text[64];
 158 } CUSTOMBUTTON, *PCUSTOMBUTTON;
 159
 160
 161 #define SEPARATOR_WIDTH    8
 162 #define TOP_BORDER         2
 163 #define BOTTOM_BORDER      2
 164 #define DDARROW_WIDTH      11
 165
 166 #define TOOLBAR_GetInfoPtr(hwnd) ((TOOLBAR_INFO *)GetWindowLongA(hwnd,0))
 167 #define TOOLBAR_HasText(x, y) (TOOLBAR_GetText(x, y) ? TRUE : FALSE)
 168 #define TOOLBAR_HasDropDownArrows(exStyle) ((exStyle & TBSTYLE_EX_DRAWDDARROWS) ? TRUE : FALSE)
 169
 170 /* Used to find undocumented extended styles */
 171 #define TBSTYLE_EX_ALL (TBSTYLE_EX_DRAWDDARROWS | \
 172                         TBSTYLE_EX_UNDOC1 | \
 173                         TBSTYLE_EX_MIXEDBUTTONS | \
 174                         TBSTYLE_EX_HIDECLIPPEDBUTTONS)
 175
 176 static LRESULT
 177 TOOLBAR_NotifyFormat(TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam);
 178
 179
 180 static LPWSTR
 181 TOOLBAR_GetText(TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr)
 182 {
 183     LPWSTR lpText = NULL;
 184
 185     /* FIXME: iString == -1 is undocumented */
 186     if ((HIWORD(btnPtr->iString) != 0) && (btnPtr->iString != -1))
 187         lpText = (LPWSTR)btnPtr->iString;
 188     else if ((btnPtr->iString >= 0) && (btnPtr->iString < infoPtr->nNumStrings))
 189         lpText = infoPtr->strings[btnPtr->iString];
 190
 191     return lpText;
 192 }
 193
 194 static void
 195 TOOLBAR_DumpButton(TOOLBAR_INFO *infoPtr, TBUTTON_INFO *bP, INT btn_num, BOOL internal)
 196 {
 197     if (TRACE_ON(toolbar)){
 198         TRACE("button %d id %d, bitmap=%d, state=%02x, style=%02x, data=%08lx, stringid=0x%08x\n",
 199               btn_num, bP->idCommand,
 200               bP->iBitmap, bP->fsState, bP->fsStyle, bP->dwData, bP->iString);
 201         TRACE("string %s\n", debugstr_w(TOOLBAR_GetText(infoPtr,bP)));
 202         if (internal)
 203             TRACE("button %d id %d, hot=%s, row=%d, rect=(%d,%d)-(%d,%d)\n",
 204                   btn_num, bP->idCommand,
 205                   (bP->bHot) ? "TRUE":"FALSE", bP->nRow,
 206                   bP->rect.left, bP->rect.top,
 207                   bP->rect.right, bP->rect.bottom);
 208     }
 209 }
 210
 211
 212 static void
 213 TOOLBAR_DumpToolbar(TOOLBAR_INFO *iP, INT line)
 214 {
 215     if (TRACE_ON(toolbar)) {
 216         INT i;
 217         DWORD dwStyle;
 218
 219         dwStyle = GetWindowLongA (iP->hwndSelf, GWL_STYLE);
 220         TRACE("toolbar %08x at line %d, exStyle=%08lx, buttons=%d, bitmaps=%d, strings=%d, style=%08lx\n",
 221               iP->hwndSelf, line,
 222               iP->dwExStyle, iP->nNumButtons, iP->nNumBitmaps,
 223               iP->nNumStrings, dwStyle);
 224         TRACE("toolbar %08x at line %d, himlInt=%p, himlDef=%p, himlHot=%p, himlDis=%p, redrawable=%s\n",
 225               iP->hwndSelf, line,
 226               iP->himlInt, iP->himlDef, iP->himlHot, iP->himlDis,
 227               (iP->bDoRedraw) ? "TRUE" : "FALSE");
 228         for(i=0; i<iP->nNumButtons; i++) {
 229             TOOLBAR_DumpButton(iP, &iP->buttons[i], i, TRUE);
 230         }
 231     }
 232 }
 233
 234
 235 /***********************************************************************
 236 *               TOOLBAR_CheckStyle
 237 *
 238 * This function validates that the styles set are implemented and
 239 * issues FIXME's warning of possible problems. In a perfect world this
 240 * function should be null.
 241 */
 242 static void
 243 TOOLBAR_CheckStyle (HWND hwnd, DWORD dwStyle)
 244 {
 245     if (dwStyle & TBSTYLE_ALTDRAG)
 246         FIXME("[%04x] TBSTYLE_ALTDRAG not implemented\n", hwnd);
 247     if (dwStyle & TBSTYLE_REGISTERDROP)
 248         FIXME("[%04x] TBSTYLE_REGISTERDROP not implemented\n", hwnd);
 249 }
 250
 251
 252 static INT
 253 TOOLBAR_SendNotify (NMHDR *nmhdr, TOOLBAR_INFO *infoPtr, UINT code)
 254 {
 255         if(!IsWindow(infoPtr->hwndSelf))
 256             return 0;   /* we have just been destroyed */
 257
 258     nmhdr->idFrom = GetDlgCtrlID (infoPtr->hwndSelf);
 259     nmhdr->hwndFrom = infoPtr->hwndSelf;
 260     nmhdr->code = code;
 261
 262     TRACE("to window %04x, code=%08x, %s\n", infoPtr->hwndNotify, code,
 263           (infoPtr->bNtfUnicode) ? "via Unicode" : "via ANSI");
 264
 265     if (infoPtr->bNtfUnicode)
 266         return SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
 267                              (WPARAM) nmhdr->idFrom, (LPARAM)nmhdr);
 268     else
 269         return SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
 270                              (WPARAM) nmhdr->idFrom, (LPARAM)nmhdr);
 271 }
 272
 273 /***********************************************************************
 274 *               TOOLBAR_GetBitmapIndex
 275 *
 276 * This function returns the bitmap index associated with a button.
 277 * If the button specifies I_IMAGECALLBACK, then the TBN_GETDISPINFO
 278 * is issued to retrieve the index.
 279 */
 280 static INT
 281 TOOLBAR_GetBitmapIndex(TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr)
 282 {
 283     INT ret = btnPtr->iBitmap;
 284
 285     if (ret == I_IMAGECALLBACK) {
 286         /* issue TBN_GETDISPINFO */
 287         NMTBDISPINFOA nmgd;
 288
 289         nmgd.idCommand = btnPtr->idCommand;
 290         nmgd.lParam = btnPtr->dwData;
 291         nmgd.dwMask = TBNF_IMAGE;
 292         TOOLBAR_SendNotify ((NMHDR *) &nmgd, infoPtr,
 293                         (infoPtr->bNtfUnicode) ? TBN_GETDISPINFOW :
 294                         TBN_GETDISPINFOA);
 295         if (nmgd.dwMask & TBNF_DI_SETITEM) {
 296             btnPtr->iBitmap = nmgd.iImage;
 297         }
 298         ret = nmgd.iImage;
 299         TRACE("TBN_GETDISPINFOA returned bitmap id %d, mask=%08lx, nNumBitmaps=%d\n",
 300               ret, nmgd.dwMask, infoPtr->nNumBitmaps);
 301     }
 302     return ret;
 303 }
 304
 305
 306 static BOOL
 307 TOOLBAR_IsValidBitmapIndex(TOOLBAR_INFO *infoPtr, INT index)
 308 {
 309     if (((index>=0) && (index <= infoPtr->nNumBitmaps)) ||
 310         (index == I_IMAGECALLBACK))
 311       return TRUE;
 312     else
 313       return FALSE;
 314 }
 315
 316
 317 /***********************************************************************
 318 *               TOOLBAR_DrawImageList
 319 *
 320 * This function validates the bitmap index (including I_IMAGECALLBACK
 321 * functionality). It then draws the image via the ImageList_Draw
 322 * function. It returns TRUE if the image was drawn, FALSE otherwise.
 323 */
 324 static BOOL
 325 TOOLBAR_DrawImageList (TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr, HIMAGELIST himl,
 326                         HDC hdc, UINT left, UINT top, UINT draw_flags)
 327 {
 328     INT index;
 329
 330     if (!himl) return FALSE;
 331
 332     if (!TOOLBAR_IsValidBitmapIndex(infoPtr,btnPtr->iBitmap)) {
 333         if (btnPtr->iBitmap == I_IMAGENONE) return FALSE;
 334         ERR("index %d is not valid, max %d\n",
 335             btnPtr->iBitmap, infoPtr->nNumBitmaps);
 336         return FALSE;
 337     }
 338
 339     if ((index = TOOLBAR_GetBitmapIndex(infoPtr, btnPtr)) < 0) {
 340         if ((index == I_IMAGECALLBACK) ||
 341             (index == I_IMAGENONE)) return FALSE;
 342         ERR("TBN_GETDISPINFO returned invalid index %d\n",
 343             index);
 344         return FALSE;
 345     }
 346     TRACE("drawing index=%d, himl=%p, left=%d, top=%d, flags=%08x\n",
 347           index, himl, left, top, draw_flags);
 348
 349     ImageList_Draw (himl, index, hdc, left, top, draw_flags);
 350     return TRUE;
 351 }
 352
 353
 354 /***********************************************************************
 355 *               TOOLBAR_TestImageExist
 356 *
 357 * This function is similar to TOOLBAR_DrawImageList, except it does not
 358 * draw the image. The I_IMAGECALLBACK functionality is implemented.
 359 */
 360 static BOOL
 361 TOOLBAR_TestImageExist (TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr, HIMAGELIST himl)
 362 {
 363     INT index;
 364
 365     if (!himl) return FALSE;
 366
 367     if (!TOOLBAR_IsValidBitmapIndex(infoPtr,btnPtr->iBitmap)) {
 368         if (btnPtr->iBitmap == I_IMAGENONE) return FALSE;
 369         ERR("index %d is not valid, max %d\n",
 370             btnPtr->iBitmap, infoPtr->nNumBitmaps);
 371         return FALSE;
 372     }
 373
 374     if ((index = TOOLBAR_GetBitmapIndex(infoPtr, btnPtr)) < 0) {
 375         if ((index == I_IMAGECALLBACK) ||
 376             (index == I_IMAGENONE)) return FALSE;
 377         ERR("TBN_GETDISPINFO returned invalid index %d\n",
 378             index);
 379         return FALSE;
 380     }
 381     return TRUE;
 382 }
 383
 384
 385 static void
 386 TOOLBAR_DrawFlatSeparator (LPRECT lpRect, HDC hdc, TOOLBAR_INFO *infoPtr)
 387 {
 388     RECT myrect;
 389     COLORREF oldcolor, newcolor;
 390
 391     myrect.left = (lpRect->left + lpRect->right) / 2 - 1;
 392     myrect.right = myrect.left + 1;
 393     myrect.top = lpRect->top + 2;
 394     myrect.bottom = lpRect->bottom - 2;
 395
 396     newcolor = (infoPtr->clrBtnShadow == CLR_DEFAULT) ?
 397                 comctl32_color.clrBtnShadow : infoPtr->clrBtnShadow;
 398     oldcolor = SetBkColor (hdc, newcolor);
 399     ExtTextOutA (hdc, 0, 0, ETO_OPAQUE, &myrect, 0, 0, 0);
 400
 401     myrect.left = myrect.right;
 402     myrect.right = myrect.left + 1;
 403
 404     newcolor = (infoPtr->clrBtnHighlight == CLR_DEFAULT) ?
 405                 comctl32_color.clrBtnHighlight : infoPtr->clrBtnHighlight;
 406     SetBkColor (hdc, newcolor);
 407     ExtTextOutA (hdc, 0, 0, ETO_OPAQUE, &myrect, 0, 0, 0);
 408
 409     SetBkColor (hdc, oldcolor);
 410 }
 411
 412
 413 /***********************************************************************
 414 *               TOOLBAR_DrawDDFlatSeparator
 415 *
 416 * This function draws the separator that was flaged as TBSTYLE_DROPDOWN.
 417 * In this case, the separator is a pixel high line of COLOR_BTNSHADOW,
 418 * followed by a pixel high line of COLOR_BTNHIGHLIGHT. These separators
 419 * are horizontal as opposed to the vertical separators for not dropdown
 420 * type.
 421 *
 422 * FIXME: It is possible that the height of each line is really SM_CYBORDER.
 423 */
 424 static void
 425 TOOLBAR_DrawDDFlatSeparator (LPRECT lpRect, HDC hdc, TBUTTON_INFO *btnPtr, TOOLBAR_INFO *infoPtr)
 426 {
 427     RECT myrect;
 428     COLORREF oldcolor, newcolor;
 429
 430     myrect.left = lpRect->left;
 431     myrect.right = lpRect->right;
 432     myrect.top = lpRect->top + (lpRect->bottom - lpRect->top - 2)/2;
 433     myrect.bottom = myrect.top + 1;
 434
 435     InflateRect (&myrect, -2, 0);
 436
 437     TRACE("rect=(%d,%d)-(%d,%d)\n",
 438           myrect.left, myrect.top, myrect.right, myrect.bottom);
 439
 440     newcolor = (infoPtr->clrBtnShadow == CLR_DEFAULT) ?
 441                 comctl32_color.clrBtnShadow : infoPtr->clrBtnShadow;
 442     oldcolor = SetBkColor (hdc, newcolor);
 443     ExtTextOutA (hdc, 0, 0, ETO_OPAQUE, &myrect, 0, 0, 0);
 444
 445     myrect.top = myrect.bottom;
 446     myrect.bottom = myrect.top + 1;
 447
 448     newcolor = (infoPtr->clrBtnHighlight == CLR_DEFAULT) ?
 449                 comctl32_color.clrBtnHighlight : infoPtr->clrBtnHighlight;
 450     SetBkColor (hdc, newcolor);
 451     ExtTextOutA (hdc, 0, 0, ETO_OPAQUE, &myrect, 0, 0, 0);
 452
 453     SetBkColor (hdc, oldcolor);
 454 }
 455
 456
 457 static void
 458 TOOLBAR_DrawArrow (HDC hdc, INT left, INT top, INT colorRef)
 459 {
 460     INT x, y;
 461     SelectObject ( hdc, GetSysColorPen (colorRef));
 462     x = left + 2;
 463     y = top + 8;
 464     MoveToEx (hdc, x, y, NULL);
 465     LineTo (hdc, x+5, y++); x++;
 466     MoveToEx (hdc, x, y, NULL);
 467     LineTo (hdc, x+3, y++); x++;
 468     MoveToEx (hdc, x, y, NULL);
 469     LineTo (hdc, x+1, y++);
 470 }
 471
 472 /*
 473  * Draw the text string for this button.
 474  * note: infoPtr->himlDis *SHOULD* be non-zero when infoPtr->himlDef
 475  *      is non-zero, so we can simply check himlDef to see if we have
 476  *      an image list
 477  */
 478 static void
 479 TOOLBAR_DrawString (TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr,
 480                     HDC hdc, INT nState, DWORD dwStyle,
 481                     RECT *rcText, LPWSTR lpText, NMTBCUSTOMDRAW *tbcd)
 482 {
 483     HFONT  hOldFont = 0;
 484     COLORREF clrOld = 0;
 485
 486     /* draw text */
 487     if (lpText) {
 488         TRACE("string rect=(%d,%d)-(%d,%d)\n",
 489               rcText->left, rcText->top, rcText->right, rcText->bottom);
 490
 491         hOldFont = SelectObject (hdc, infoPtr->hFont);
 492         if (!(nState & TBSTATE_ENABLED)) {
 493             clrOld = SetTextColor (hdc, tbcd->clrBtnHighlight);
 494             OffsetRect (rcText, 1, 1);
 495             DrawTextW (hdc, lpText, -1, rcText, infoPtr->dwDTFlags);
 496             SetTextColor (hdc, comctl32_color.clr3dShadow);
 497             OffsetRect (rcText, -1, -1);
 498         }
 499         else if (nState & TBSTATE_INDETERMINATE) {
 500             clrOld = SetTextColor (hdc, comctl32_color.clr3dShadow);
 501         }
 502         else if (btnPtr->bHot && (infoPtr->dwItemCDFlag & TBCDRF_HILITEHOTTRACK )) {
 503             clrOld = SetTextColor (hdc, tbcd->clrTextHighlight);
 504         }
 505         else {
 506             clrOld = SetTextColor (hdc, tbcd->clrText);
 507         }
 508
 509         DrawTextW (hdc, lpText, -1, rcText, infoPtr->dwDTFlags);
 510         SetTextColor (hdc, clrOld);
 511         SelectObject (hdc, hOldFont);
 512     }
 513 }
 514
 515
 516 static void
 517 TOOLBAR_DrawPattern (HDC hdc, LPRECT lpRect)
 518 {
 519     HBRUSH hbr = SelectObject (hdc, COMCTL32_hPattern55AABrush);
 520     INT cx = lpRect->right - lpRect->left;
 521     INT cy = lpRect->bottom - lpRect->top;
 522     PatBlt (hdc, lpRect->left, lpRect->top, cx, cy, 0x00FA0089);
 523     SelectObject (hdc, hbr);
 524 }
 525
 526
 527 static void
 528 TOOLBAR_DrawMasked (TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr,
 529                     HDC hdc, INT x, INT y)
 530 {
 531     /* FIXME: this function is a hack since it uses image list
 532               internals directly */
 533
 534     HIMAGELIST himl = infoPtr->himlDef;
 535     HBITMAP hbmMask;
 536     HDC hdcImageList;
 537     HDC hdcMask;
 538
 539     if (!himl)
 540         return;
 541
 542     /* create new dc's */
 543     hdcImageList = CreateCompatibleDC (0);
 544     hdcMask = CreateCompatibleDC (0);
 545
 546     /* create new bitmap */
 547     hbmMask = CreateBitmap (himl->cx, himl->cy, 1, 1, NULL);
 548     SelectObject (hdcMask, hbmMask);
 549
 550     /* copy the mask bitmap */
 551     SelectObject (hdcImageList, himl->hbmMask);
 552     SetBkColor (hdcImageList, RGB(255, 255, 255));
 553     SetTextColor (hdcImageList, RGB(0, 0, 0));
 554     BitBlt (hdcMask, 0, 0, himl->cx, himl->cy,
 555               hdcImageList, himl->cx * btnPtr->iBitmap, 0, SRCCOPY);
 556
 557     /* draw the new mask */
 558     SelectObject (hdc, GetSysColorBrush (COLOR_3DHILIGHT));
 559     BitBlt (hdc, x+1, y+1, himl->cx, himl->cy,
 560               hdcMask, 0, 0, 0xB8074A);
 561
 562     SelectObject (hdc, GetSysColorBrush (COLOR_3DSHADOW));
 563     BitBlt (hdc, x, y, himl->cx, himl->cy,
 564               hdcMask, 0, 0, 0xB8074A);
 565
 566     DeleteObject (hbmMask);
 567     DeleteDC (hdcMask);
 568     DeleteDC (hdcImageList);
 569 }
 570
 571
 572 static UINT
 573 TOOLBAR_TranslateState(TBUTTON_INFO *btnPtr)
 574 {
 575     UINT retstate = 0;
 576
 577     retstate |= (btnPtr->fsState & TBSTATE_CHECKED) ? CDIS_CHECKED  : 0;
 578     retstate |= (btnPtr->fsState & TBSTATE_PRESSED) ? CDIS_SELECTED : 0;
 579     retstate |= (btnPtr->fsState & TBSTATE_ENABLED) ? 0 : CDIS_DISABLED;
 580     retstate |= (btnPtr->fsState & TBSTATE_MARKED ) ? CDIS_MARKED   : 0;
 581     retstate |= (btnPtr->bHot                     ) ? CDIS_HOT      : 0;
 582     retstate |= (btnPtr->fsState & TBSTATE_INDETERMINATE) ? CDIS_INDETERMINATE : 0;
 583     /* FIXME: don't set CDIS_GRAYED, CDIS_FOCUS, CDIS_DEFAULT       */
 584     /*        don't test TBSTATE_HIDDEN                             */
 585     return retstate;
 586 }
 587
 588
 589 static void
 590 TOOLBAR_DrawButton (HWND hwnd, TBUTTON_INFO *btnPtr, HDC hdc)
 591 {
 592     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
 593     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
 594     BOOL hasDropDownArrow = TOOLBAR_HasDropDownArrows(infoPtr->dwExStyle) &&
 595                             (btnPtr->fsStyle & TBSTYLE_DROPDOWN);
 596     RECT rc, rcArrow, rcBitmap, rcText, rcFill;
 597     LPWSTR lpText = NULL;
 598     NMTBCUSTOMDRAW tbcd;
 599     DWORD ntfret;
 600     INT offset;
 601
 602     if (btnPtr->fsState & TBSTATE_HIDDEN)
 603         return;
 604
 605     rc = btnPtr->rect;
 606     CopyRect (&rcFill, &rc);
 607     CopyRect (&rcArrow, &rc);
 608     CopyRect(&rcBitmap, &rc);
 609     CopyRect(&rcText, &rc);
 610
 611     /* get a pointer to the text */
 612     lpText = TOOLBAR_GetText(infoPtr, btnPtr);
 613
 614     if (hasDropDownArrow)
 615     {
 616         if (dwStyle & TBSTYLE_FLAT)
 617             rc.right = max(rc.left, rc.right - DDARROW_WIDTH);
 618         else
 619             rc.right = max(rc.left, rc.right - DDARROW_WIDTH - 2);
 620         rcArrow.left = rc.right;
 621     }
 622
 623     /* Center the bitmap horizontally and vertically */
 624     if (dwStyle & TBSTYLE_LIST)
 625         rcBitmap.left += 3;
 626     else
 627         rcBitmap.left+=(infoPtr->nButtonWidth - infoPtr->nBitmapWidth) / 2;
 628
 629     if(lpText)
 630         rcBitmap.top+=2; /* this looks to be the correct value from vmware comparison - cmm */
 631     else
 632         rcBitmap.top+=(infoPtr->nButtonHeight - infoPtr->nBitmapHeight) / 2;
 633
 634     TRACE("iBitmap: %d, start=(%d,%d) w=%d, h=%d\n",
 635           btnPtr->iBitmap, rcBitmap.left, rcBitmap.top,
 636           infoPtr->nBitmapWidth, infoPtr->nBitmapHeight);
 637     TRACE ("iString: %x\n", btnPtr->iString);
 638     TRACE ("Stringtext: %s\n", debugstr_w(lpText));
 639
 640     /* draw text */
 641     if (lpText) {
 642
 643         InflateRect (&rcText, -3, -3);
 644
 645         if (infoPtr->himlDef &&
 646             TOOLBAR_IsValidBitmapIndex(infoPtr,btnPtr->iBitmap)) {
 647                 /* The following test looked like this before
 648                  * I changed it. IE4 "Links" toolbar would not
 649                  * draw correctly with the original code.  - GA 8/01
 650                  *   ((dwStyle & TBSTYLE_LIST) &&
 651                  *    ((btnPtr->fsStyle & TBSTYLE_AUTOSIZE) == 0) &&
 652                  *       (btnPtr->iBitmap != I_IMAGENONE))
 653                  */
 654                 if (dwStyle & TBSTYLE_LIST) {
 655                     /* LIST style w/ ICON offset is by matching native. */
 656                     /* Matches IE4 "Links" bar.   - GA 8/01             */
 657                     rcText.left += (infoPtr->nBitmapWidth + 2);
 658                 }
 659                 else {
 660                     rcText.top += infoPtr->nBitmapHeight + 1;
 661                 }
 662         }
 663         else {
 664                 if (dwStyle & TBSTYLE_LIST) {
 665                     /* LIST style w/o ICON offset is by matching native. */
 666                     /* Matches IE4 "menu" bar.   - GA  8/01              */
 667                     rcText.left += 4;
 668                 }
 669         }
 670
 671         if (btnPtr->fsState & (TBSTATE_PRESSED | TBSTATE_CHECKED))
 672             OffsetRect (&rcText, 1, 1);
 673     }
 674
 675     /* Initialize fields in all cases, because we use these later */
 676     ZeroMemory (&tbcd, sizeof(NMTBCUSTOMDRAW));
 677     tbcd.clrText = comctl32_color.clrBtnText;
 678     tbcd.clrTextHighlight = comctl32_color.clrHighlightText;
 679     tbcd.clrBtnFace = comctl32_color.clrBtnFace;
 680     tbcd.clrBtnHighlight = comctl32_color.clrBtnHighlight;
 681     tbcd.clrMark = comctl32_color.clrHighlight;
 682     tbcd.clrHighlightHotTrack = 0;
 683     tbcd.nStringBkMode = (infoPtr->bBtnTranspnt) ? TRANSPARENT : OPAQUE;
 684     tbcd.nHLStringBkMode = (infoPtr->bBtnTranspnt) ? TRANSPARENT : OPAQUE;
 685     /* MSDN says that this is the text rectangle.              */
 686     /* But (why always a but) tracing of v5.7 of native shows  */
 687     /* that this is really a *relative* rectangle based on the */
 688     /* the nmcd.rc. Also the left and top are always 0 ignoring*/
 689     /* any bitmap that might be present.                       */
 690     tbcd.rcText.left = 0;
 691     tbcd.rcText.top = 0;
 692     tbcd.rcText.right = rcText.right - rc.left;
 693     tbcd.rcText.bottom = rcText.bottom - rc.top;
 694
 695     /* FIXME: what should these be set to ????? */
 696     tbcd.hbrMonoDither = 0;
 697     tbcd.hbrLines = 0;
 698     tbcd.hpenLines = 0;
 699
 700     /* Issue Item Prepaint notify */
 701     infoPtr->dwItemCustDraw = 0;
 702     infoPtr->dwItemCDFlag = 0;
 703     if (infoPtr->dwBaseCustDraw & CDRF_NOTIFYITEMDRAW)
 704     {
 705         tbcd.nmcd.dwDrawStage = CDDS_ITEMPREPAINT;
 706         tbcd.nmcd.hdc = hdc;
 707         tbcd.nmcd.rc = rc;
 708         tbcd.nmcd.dwItemSpec = btnPtr->idCommand;
 709         tbcd.nmcd.uItemState = TOOLBAR_TranslateState(btnPtr);
 710         tbcd.nmcd.lItemlParam = btnPtr->dwData;
 711         ntfret = TOOLBAR_SendNotify ((NMHDR *)&tbcd, infoPtr, NM_CUSTOMDRAW);
 712         infoPtr->dwItemCustDraw = ntfret & 0xffff;
 713         infoPtr->dwItemCDFlag = ntfret & 0xffff0000;
 714         if (infoPtr->dwItemCustDraw & CDRF_SKIPDEFAULT)
 715             return;
 716         /* save the only part of the rect that the user can change */
 717         rcText.right = tbcd.rcText.right + rc.left;
 718         rcText.bottom = tbcd.rcText.bottom + rc.top;
 719     }
 720
 721     if (!infoPtr->bBtnTranspnt)
 722         FillRect( hdc, &rcFill, GetSysColorBrush(COLOR_BTNFACE));
 723
 724     /* separator */
 725     if (btnPtr->fsStyle & TBSTYLE_SEP) {
 726         /* with the FLAT style, iBitmap is the width and has already */
 727         /* been taken into consideration in calculating the width    */
 728         /* so now we need to draw the vertical separator             */
 729         /* empirical tests show that iBitmap can/will be non-zero    */
 730         /* when drawing the vertical bar...      */
 731         if ((dwStyle & TBSTYLE_FLAT) /* && (btnPtr->iBitmap == 0) */) {
 732             if (btnPtr->fsStyle & TBSTYLE_DROPDOWN)
 733                 TOOLBAR_DrawDDFlatSeparator (&rc, hdc, btnPtr, infoPtr);
 734             else
 735                 TOOLBAR_DrawFlatSeparator (&rc, hdc, infoPtr);
 736         }
 737         else if (btnPtr->fsStyle != TBSTYLE_SEP) {
 738             FIXME("Draw some kind of separator: fsStyle=%x\n",
 739                   btnPtr->fsStyle);
 740         }
 741         goto FINALNOTIFY;
 742     }
 743
 744     /* disabled */
 745     if (!(btnPtr->fsState & TBSTATE_ENABLED)) {
 746         if (!(dwStyle & TBSTYLE_FLAT) && !(infoPtr->dwItemCDFlag & TBCDRF_NOEDGES))
 747         {
 748             DrawEdge (hdc, &rc, EDGE_RAISED,
 749                       BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
 750             if (hasDropDownArrow)
 751             DrawEdge (hdc, &rcArrow, EDGE_RAISED,
 752                       BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
 753         }
 754
 755         if (hasDropDownArrow)
 756         {
 757             TOOLBAR_DrawArrow(hdc, rcArrow.left+1, rcArrow.top+1, COLOR_3DHIGHLIGHT);
 758             TOOLBAR_DrawArrow(hdc, rcArrow.left, rcArrow.top, COLOR_3DSHADOW);
 759         }
 760
 761         if (!TOOLBAR_DrawImageList (infoPtr, btnPtr, infoPtr->himlDis,
 762                                    hdc, rcBitmap.left, rcBitmap.top,
 763                                    ILD_NORMAL))
 764             TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rcBitmap.left, rcBitmap.top);
 765
 766         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle, &rcText, lpText, &tbcd);
 767         goto FINALNOTIFY;
 768     }
 769
 770     /* pressed TBSTYLE_BUTTON */
 771     if (btnPtr->fsState & TBSTATE_PRESSED) {
 772         offset = (infoPtr->dwItemCDFlag & TBCDRF_NOOFFSET) ? 0 : 1;
 773         if (!(infoPtr->dwItemCDFlag & TBCDRF_NOEDGES))
 774         {
 775             if (dwStyle & TBSTYLE_FLAT)
 776             {
 777                 DrawEdge (hdc, &rc, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
 778                 if (hasDropDownArrow)
 779                     DrawEdge (hdc, &rcArrow, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
 780             }
 781             else
 782             {
 783                 DrawEdge (hdc, &rc, EDGE_SUNKEN, BF_RECT | BF_MIDDLE | BF_ADJUST);
 784                 if (hasDropDownArrow)
 785                     DrawEdge (hdc, &rcArrow, EDGE_SUNKEN, BF_RECT | BF_MIDDLE | BF_ADJUST);
 786             }
 787         }
 788
 789         if (hasDropDownArrow)
 790             TOOLBAR_DrawArrow(hdc, rcArrow.left, rcArrow.top, COLOR_WINDOWFRAME);
 791
 792         TOOLBAR_DrawImageList (infoPtr, btnPtr, infoPtr->himlDef,
 793                                hdc, rcBitmap.left+offset, rcBitmap.top+offset,
 794                                ILD_NORMAL);
 795
 796         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle, &rcText, lpText, &tbcd);
 797         goto FINALNOTIFY;
 798     }
 799
 800     /* checked TBSTYLE_CHECK */
 801     if ((btnPtr->fsStyle & TBSTYLE_CHECK) &&
 802         (btnPtr->fsState & TBSTATE_CHECKED)) {
 803         if (!(infoPtr->dwItemCDFlag & TBCDRF_NOEDGES))
 804         {
 805             if (dwStyle & TBSTYLE_FLAT)
 806                 DrawEdge (hdc, &rc, BDR_SUNKENOUTER,
 807                           BF_RECT | BF_ADJUST);
 808             else
 809                 DrawEdge (hdc, &rc, EDGE_SUNKEN,
 810                           BF_RECT | BF_MIDDLE | BF_ADJUST);
 811         }
 812
 813         TOOLBAR_DrawPattern (hdc, &rc);
 814
 815         TOOLBAR_DrawImageList (infoPtr, btnPtr, infoPtr->himlDef,
 816                                hdc, rcBitmap.left+1, rcBitmap.top+1,
 817                                ILD_NORMAL);
 818
 819         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle, &rcText, lpText, &tbcd);
 820         goto FINALNOTIFY;
 821     }
 822
 823     /* indeterminate */
 824     if (btnPtr->fsState & TBSTATE_INDETERMINATE) {
 825         if (!(infoPtr->dwItemCDFlag & TBCDRF_NOEDGES))
 826             DrawEdge (hdc, &rc, EDGE_RAISED,
 827                       BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
 828
 829         TOOLBAR_DrawPattern (hdc, &rc);
 830         TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rcBitmap.left, rcBitmap.top);
 831         TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle, &rcText, lpText, &tbcd);
 832         goto FINALNOTIFY;
 833     }
 834
 835     /* normal state */
 836     if (dwStyle & TBSTYLE_FLAT)
 837     {
 838         if (btnPtr->bHot)
 839         {
 840             if ( infoPtr->dwItemCDFlag & TBCDRF_HILITEHOTTRACK )
 841             {
 842                 COLORREF oldclr;
 843
 844                 oldclr = SetBkColor(hdc, tbcd.clrHighlightHotTrack);
 845                 ExtTextOutA(hdc, 0, 0, ETO_OPAQUE, &rc, NULL, 0, 0);
 846                 if (hasDropDownArrow)
 847                     ExtTextOutA(hdc, 0, 0, ETO_OPAQUE, &rcArrow, NULL, 0, 0);
 848                 SetBkColor(hdc, oldclr);
 849             }
 850             else
 851             {
 852                 if (!(infoPtr->dwItemCDFlag & TBCDRF_NOEDGES))
 853                 {
 854                     DrawEdge (hdc, &rc, BDR_RAISEDINNER, BF_RECT);
 855                     if (hasDropDownArrow)
 856                         DrawEdge (hdc, &rcArrow, BDR_RAISEDINNER, BF_RECT);
 857                 }
 858             }
 859         }
 860 #if 1
 861         else /* The following code needs to be removed after
 862               * "hot item" support has been implemented for the
 863               * case where it is being de-selected.
 864               */
 865         {
 866             FrameRect(hdc, &rc, GetSysColorBrush(COLOR_BTNFACE));
 867             if (hasDropDownArrow)
 868             FrameRect(hdc, &rcArrow, GetSysColorBrush(COLOR_BTNFACE));
 869         }
 870 #endif
 871
 872         if (hasDropDownArrow)
 873             TOOLBAR_DrawArrow(hdc, rcArrow.left+1, rcArrow.top, COLOR_WINDOWFRAME);
 874
 875         if (btnPtr->bHot) {
 876             /* if hot, attempt to draw with himlHot, if fails, use himlDef */
 877             if (!TOOLBAR_DrawImageList (infoPtr, btnPtr,
 878                                         infoPtr->himlHot,
 879                                         hdc, rcBitmap.left,
 880                                         rcBitmap.top, ILD_NORMAL))
 881                 TOOLBAR_DrawImageList (infoPtr, btnPtr, infoPtr->himlDef,
 882                                        hdc, rcBitmap.left, rcBitmap.top,
 883                                        ILD_NORMAL);
 884         }
 885         else
 886             TOOLBAR_DrawImageList (infoPtr, btnPtr, infoPtr->himlDef,
 887                                    hdc, rcBitmap.left, rcBitmap.top,
 888                                    ILD_NORMAL);
 889     }
 890     else
 891     {
 892         if (!(infoPtr->dwItemCDFlag & TBCDRF_NOEDGES))
 893             DrawEdge (hdc, &rc, EDGE_RAISED,
 894                       BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
 895
 896         if (hasDropDownArrow)
 897         {
 898             if (!(infoPtr->dwItemCDFlag & TBCDRF_NOEDGES))
 899                 DrawEdge (hdc, &rcArrow, EDGE_RAISED,
 900                           BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
 901             TOOLBAR_DrawArrow(hdc, rcArrow.left, rcArrow.top, COLOR_WINDOWFRAME);
 902         }
 903
 904         TOOLBAR_DrawImageList (infoPtr, btnPtr, infoPtr->himlDef,
 905                                hdc, rcBitmap.left, rcBitmap.top,
 906                                ILD_NORMAL);}
 907
 908
 909     TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState, dwStyle, &rcText, lpText, &tbcd);
 910
 911  FINALNOTIFY:
 912     if (infoPtr->dwItemCustDraw & CDRF_NOTIFYPOSTPAINT)
 913     {
 914         tbcd.nmcd.dwDrawStage = CDDS_ITEMPOSTPAINT;
 915         tbcd.nmcd.hdc = hdc;
 916         tbcd.nmcd.rc = rc;
 917         tbcd.nmcd.dwItemSpec = btnPtr->idCommand;
 918         tbcd.nmcd.uItemState = TOOLBAR_TranslateState(btnPtr);
 919         tbcd.nmcd.lItemlParam = btnPtr->dwData;
 920         tbcd.rcText = rcText;
 921         tbcd.nStringBkMode = (infoPtr->bBtnTranspnt) ? TRANSPARENT : OPAQUE;
 922         tbcd.nHLStringBkMode = (infoPtr->bBtnTranspnt) ? TRANSPARENT : OPAQUE;
 923         ntfret = TOOLBAR_SendNotify ((NMHDR *)&tbcd, infoPtr, NM_CUSTOMDRAW);
 924     }
 925
 926 }
 927
 928
 929 static void
 930 TOOLBAR_Refresh (HWND hwnd, HDC hdc, PAINTSTRUCT* ps)
 931 {
 932     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
 933     TBUTTON_INFO *btnPtr;
 934     INT i, oldBKmode = 0;
 935     RECT rcTemp;
 936     NMTBCUSTOMDRAW tbcd;
 937     DWORD ntfret;
 938
 939     /* if imagelist belongs to the app, it can be changed
 940        by the app after setting it */
 941     if (infoPtr->himlDef != infoPtr->himlInt)
 942         infoPtr->nNumBitmaps = ImageList_GetImageCount(infoPtr->himlDef);
 943
 944     TOOLBAR_DumpToolbar (infoPtr, __LINE__);
 945
 946     /* Send initial notify */
 947     ZeroMemory (&tbcd, sizeof(NMTBCUSTOMDRAW));
 948     tbcd.nmcd.dwDrawStage = CDDS_PREPAINT;
 949     tbcd.nmcd.hdc = hdc;
 950     tbcd.nmcd.rc = ps->rcPaint;
 951     ntfret = TOOLBAR_SendNotify ((NMHDR *)&tbcd, infoPtr, NM_CUSTOMDRAW);
 952     infoPtr->dwBaseCustDraw = ntfret & 0xffff;
 953
 954     if (infoPtr->bBtnTranspnt)
 955         oldBKmode = SetBkMode (hdc, TRANSPARENT);
 956
 957     /* redraw necessary buttons */
 958     btnPtr = infoPtr->buttons;
 959     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++)
 960     {
 961         if(IntersectRect(&rcTemp, &(ps->rcPaint), &(btnPtr->rect)))
 962             TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
 963     }
 964
 965     if (infoPtr->bBtnTranspnt && (oldBKmode != TRANSPARENT))
 966         SetBkMode (hdc, oldBKmode);
 967
 968     if (infoPtr->dwBaseCustDraw & CDRF_NOTIFYPOSTPAINT)
 969     {
 970         ZeroMemory (&tbcd, sizeof(NMTBCUSTOMDRAW));
 971         tbcd.nmcd.dwDrawStage = CDDS_POSTPAINT;
 972         tbcd.nmcd.hdc = hdc;
 973         tbcd.nmcd.rc = ps->rcPaint;
 974         ntfret = TOOLBAR_SendNotify ((NMHDR *)&tbcd, infoPtr, NM_CUSTOMDRAW);
 975     }
 976 }
 977
 978 /***********************************************************************
 979 *               TOOLBAR_MeasureString
 980 *
 981 * This function gets the width and height of a string in pixels. This
 982 * is done first by using GetTextExtentPoint to get the basic width
 983 * and height. The DrawText is called with DT_CALCRECT to get the exact
 984 * width. The reason is because the text may have more than one "&" (or
 985 * prefix characters as M$ likes to call them). The prefix character
 986 * indicates where the underline goes, except for the string "&&" which
 987 * is reduced to a single "&". GetTextExtentPoint does not process these
 988 * only DrawText does. Note that the TBSTYLE_NOPREFIX is handled here.
 989 */
 990 static void
 991 TOOLBAR_MeasureString(TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr,
 992                       HDC hdc, LPSIZE lpSize)
 993 {
 994     RECT myrect;
 995
 996     lpSize->cx = 0;
 997     lpSize->cy = 0;
 998
 999     if (!(btnPtr->fsState & TBSTATE_HIDDEN) )
1000     {
1001         LPWSTR lpText = TOOLBAR_GetText(infoPtr, btnPtr);
1002
1003         if(lpText != NULL) {
1004             /* first get size of all the text */
1005             GetTextExtentPoint32W (hdc, lpText, strlenW (lpText), lpSize);
1006
1007             /* feed above size into the rectangle for DrawText */
1008             myrect.left = myrect.top = 0;
1009             myrect.right = lpSize->cx;
1010             myrect.bottom = lpSize->cy;
1011
1012             /* Use DrawText to get true size as drawn (less pesky "&") */
1013             DrawTextW (hdc, lpText, -1, &myrect, DT_VCENTER | DT_SINGLELINE |
1014                    DT_CALCRECT | ((btnPtr->fsStyle & TBSTYLE_NOPREFIX) ?
1015                                   DT_NOPREFIX : 0));
1016
1017             /* feed back to caller  */
1018             lpSize->cx = myrect.right;
1019             lpSize->cy = myrect.bottom;
1020         }
1021     }
1022
1023     TRACE("string size %ld x %ld!\n", lpSize->cx, lpSize->cy);
1024 }
1025
1026 /***********************************************************************
1027 *               TOOLBAR_CalcStrings
1028 *
1029 * This function walks through each string and measures it and returns
1030 * the largest height and width to caller.
1031 */
1032 static void
1033 TOOLBAR_CalcStrings (HWND hwnd, LPSIZE lpSize)
1034 {
1035     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1036     TBUTTON_INFO *btnPtr;
1037     INT i;
1038     SIZE sz;
1039     HDC hdc;
1040     HFONT hOldFont;
1041
1042     lpSize->cx = 0;
1043     lpSize->cy = 0;
1044
1045     hdc = GetDC (hwnd);
1046     hOldFont = SelectObject (hdc, infoPtr->hFont);
1047
1048     btnPtr = infoPtr->buttons;
1049     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
1050         if(TOOLBAR_HasText(infoPtr, btnPtr))
1051         {
1052             TOOLBAR_MeasureString(infoPtr, btnPtr, hdc, &sz);
1053             if (sz.cx > lpSize->cx)
1054                 lpSize->cx = sz.cx;
1055             if (sz.cy > lpSize->cy)
1056                 lpSize->cy = sz.cy;
1057         }
1058     }
1059
1060     SelectObject (hdc, hOldFont);
1061     ReleaseDC (hwnd, hdc);
1062
1063     TRACE("max string size %ld x %ld!\n", lpSize->cx, lpSize->cy);
1064 }
1065
1066 /***********************************************************************
1067 *               TOOLBAR_WrapToolbar
1068 *
1069 * This function walks through the buttons and seperators in the
1070 * toolbar, and sets the TBSTATE_WRAP flag only on those items where
1071 * wrapping should occur based on the width of the toolbar window.
1072 * It does *not* calculate button placement itself.  That task
1073 * takes place in TOOLBAR_CalcToolbar. If the program wants to manage
1074 * the toolbar wrapping on its own, it can use the TBSTYLE_WRAPABLE
1075 * flag, and set the TBSTATE_WRAP flags manually on the appropriate items.
1076 *
1077 * Note: TBSTYLE_WRAPABLE or TBSTYLE_EX_UNDOC1 can be used also to allow
1078 * vertical toolbar lists.
1079 */
1080
1081 static void
1082 TOOLBAR_WrapToolbar( HWND hwnd, DWORD dwStyle )
1083 {
1084     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1085     TBUTTON_INFO *btnPtr;
1086     INT x, cx, i, j;
1087     RECT rc;
1088     BOOL bWrap, bButtonWrap;
1089
1090     /*  When the toolbar window style is not TBSTYLE_WRAPABLE,  */
1091     /*  no layout is necessary. Applications may use this style */
1092     /*  to perform their own layout on the toolbar.             */
1093     if( !(dwStyle & TBSTYLE_WRAPABLE) &&
1094         !(infoPtr->dwExStyle & TBSTYLE_EX_UNDOC1) )  return;
1095
1096     btnPtr = infoPtr->buttons;
1097     x  = infoPtr->nIndent;
1098
1099     /* this can get the parents width, to know how far we can extend
1100      * this toolbar.  We cannot use its height, as there may be multiple
1101      * toolbars in a rebar control
1102      */
1103     GetClientRect( GetParent(hwnd), &rc );
1104     infoPtr->nWidth = rc.right - rc.left;
1105     bButtonWrap = FALSE;
1106
1107     TRACE("start ButtonWidth=%d, BitmapWidth=%d, nWidth=%d, nIndent=%d\n",
1108           infoPtr->nButtonWidth, infoPtr->nBitmapWidth, infoPtr->nWidth,
1109           infoPtr->nIndent);
1110
1111     for (i = 0; i < infoPtr->nNumButtons; i++ )
1112     {
1113         bWrap = FALSE;
1114         btnPtr[i].fsState &= ~TBSTATE_WRAP;
1115
1116         if (btnPtr[i].fsState & TBSTATE_HIDDEN)
1117             continue;
1118
1119         /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
1120         /* it is the actual width of the separator. This is used for */
1121         /* custom controls in toolbars.                              */
1122         /*                                                           */
1123         /* TBSTYLE_DROPDOWN separators are treated as buttons for    */
1124         /* width.  - GA 8/01                                         */
1125         if ((btnPtr[i].fsStyle & TBSTYLE_SEP) &&
1126             !(btnPtr[i].fsStyle & TBSTYLE_DROPDOWN))
1127             cx = (btnPtr[i].iBitmap > 0) ?
1128                         btnPtr[i].iBitmap : SEPARATOR_WIDTH;
1129         else
1130             cx = infoPtr->nButtonWidth;
1131
1132         /* Two or more adjacent separators form a separator group.   */
1133         /* The first separator in a group should be wrapped to the   */
1134         /* next row if the previous wrapping is on a button.         */
1135         if( bButtonWrap &&
1136                 (btnPtr[i].fsStyle & TBSTYLE_SEP) &&
1137                 (i + 1 < infoPtr->nNumButtons ) &&
1138                 (btnPtr[i + 1].fsStyle & TBSTYLE_SEP) )
1139         {
1140             TRACE("wrap point 1 btn %d style %02x\n", i, btnPtr[i].fsStyle);
1141             btnPtr[i].fsState |= TBSTATE_WRAP;
1142             x = infoPtr->nIndent;
1143             i++;
1144             bButtonWrap = FALSE;
1145             continue;
1146         }
1147
1148         /* The layout makes sure the bitmap is visible, but not the button. */
1149         /* Test added to also wrap after a button that starts a row but     */
1150         /* is bigger than the area.  - GA  8/01                             */
1151         if (( x + cx - (infoPtr->nButtonWidth - infoPtr->nBitmapWidth) / 2
1152            > infoPtr->nWidth ) ||
1153             ((x == infoPtr->nIndent) && (cx > infoPtr->nWidth)))
1154         {
1155             BOOL bFound = FALSE;
1156
1157             /*  If the current button is a separator and not hidden,  */
1158             /*  go to the next until it reaches a non separator.      */
1159             /*  Wrap the last separator if it is before a button.     */
1160             while( ( ((btnPtr[i].fsStyle & TBSTYLE_SEP) &&
1161                       !(btnPtr[i].fsStyle & TBSTYLE_DROPDOWN)) ||
1162                      (btnPtr[i].fsState & TBSTATE_HIDDEN) ) &&
1163                         i < infoPtr->nNumButtons )
1164             {
1165                 i++;
1166                 bFound = TRUE;
1167             }
1168
1169             if( bFound && i < infoPtr->nNumButtons )
1170             {
1171                 i--;
1172                 TRACE("wrap point 2 btn %d style %02x, x=%d, cx=%d\n",
1173                       i, btnPtr[i].fsStyle, x, cx);
1174                 btnPtr[i].fsState |= TBSTATE_WRAP;
1175                 x = infoPtr->nIndent;
1176                 bButtonWrap = FALSE;
1177                 continue;
1178             }
1179             else if ( i >= infoPtr->nNumButtons)
1180                 break;
1181
1182             /*  If the current button is not a separator, find the last  */
1183             /*  separator and wrap it.                                   */
1184             for ( j = i - 1; j >= 0  &&  !(btnPtr[j].fsState & TBSTATE_WRAP); j--)
1185             {
1186                 if ((btnPtr[j].fsStyle & TBSTYLE_SEP) &&
1187                         !(btnPtr[j].fsState & TBSTATE_HIDDEN))
1188                 {
1189                     bFound = TRUE;
1190                     i = j;
1191                     TRACE("wrap point 3 btn %d style %02x, x=%d, cx=%d\n",
1192                           i, btnPtr[i].fsStyle, x, cx);
1193                     x = infoPtr->nIndent;
1194                     btnPtr[j].fsState |= TBSTATE_WRAP;
1195                     bButtonWrap = FALSE;
1196                     break;
1197                 }
1198             }
1199
1200             /*  If no separator available for wrapping, wrap one of     */
1201             /*  non-hidden previous button.                             */
1202             if (!bFound)
1203             {
1204                 for ( j = i - 1;
1205                         j >= 0 && !(btnPtr[j].fsState & TBSTATE_WRAP); j--)
1206                 {
1207                     if (btnPtr[j].fsState & TBSTATE_HIDDEN)
1208                         continue;
1209
1210                     bFound = TRUE;
1211                     i = j;
1212                     TRACE("wrap point 4 btn %d style %02x, x=%d, cx=%d\n",
1213                           i, btnPtr[i].fsStyle, x, cx);
1214                     x = infoPtr->nIndent;
1215                     btnPtr[j].fsState |= TBSTATE_WRAP;
1216                     bButtonWrap = TRUE;
1217                     break;
1218                 }
1219             }
1220
1221             /* If all above failed, wrap the current button. */
1222             if (!bFound)
1223             {
1224                 TRACE("wrap point 5 btn %d style %02x, x=%d, cx=%d\n",
1225                       i, btnPtr[i].fsStyle, x, cx);
1226                 btnPtr[i].fsState |= TBSTATE_WRAP;
1227                 bFound = TRUE;
1228                 x = infoPtr->nIndent;
1229                 if (btnPtr[i].fsStyle & TBSTYLE_SEP )
1230                     bButtonWrap = FALSE;
1231                 else
1232                     bButtonWrap = TRUE;
1233             }
1234         }
1235         else {
1236             TRACE("wrap point 6 btn %d style %02x, x=%d, cx=%d\n",
1237                   i, btnPtr[i].fsStyle, x, cx);
1238             x += cx;
1239         }
1240     }
1241 }
1242
1243
1244 /***********************************************************************
1245 *               TOOLBAR_CalcToolbar
1246 *
1247 * This function calculates button and separator placement. It first
1248 * calculates the button sizes, gets the toolbar window width and then
1249 * calls TOOLBAR_WrapToolbar to determine which buttons we need to wrap
1250 * on. It assigns a new location to each item and sends this location to
1251 * the tooltip window if appropriate. Finally, it updates the rcBound
1252 * rect and calculates the new required toolbar window height.
1253 */
1254
1255 static void
1256 TOOLBAR_CalcToolbar (HWND hwnd)
1257 {
1258     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
1259     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1260     TBUTTON_INFO *btnPtr;
1261     INT i, nRows, nSepRows;
1262     INT x, y, cx, cy;
1263     SIZE  sizeString;
1264     BOOL bWrap;
1265     BOOL usesBitmaps = FALSE;
1266     BOOL hasDropDownArrows = TOOLBAR_HasDropDownArrows(infoPtr->dwExStyle);
1267
1268     TOOLBAR_CalcStrings (hwnd, &sizeString);
1269
1270     for (i = 0; i < infoPtr->nNumButtons && !usesBitmaps; i++)
1271     {
1272         if (TOOLBAR_IsValidBitmapIndex(infoPtr,infoPtr->buttons[i].iBitmap))
1273             usesBitmaps = TRUE;
1274     }
1275     if (dwStyle & TBSTYLE_LIST)
1276     {
1277         infoPtr->nButtonHeight = max((usesBitmaps) ? infoPtr->nBitmapHeight :
1278                                      0, sizeString.cy) + infoPtr->szPadding.cy;
1279         infoPtr->nButtonWidth = ((usesBitmaps) ? infoPtr->nBitmapWidth :
1280                                  0) + sizeString.cx + 6;
1281         TRACE("LIST style, But w=%d h=%d, useBitmaps=%d, Bit w=%d h=%d\n",
1282               infoPtr->nButtonWidth, infoPtr->nButtonHeight, usesBitmaps,
1283               infoPtr->nBitmapWidth, infoPtr->nBitmapHeight);
1284         TOOLBAR_DumpToolbar (infoPtr, __LINE__);
1285     }
1286     else {
1287         if (sizeString.cy > 0)
1288         {
1289             if (usesBitmaps)
1290                 infoPtr->nButtonHeight = sizeString.cy +
1291                     2 + /* this is the space to separate text from bitmap */
1292                   infoPtr->nBitmapHeight + 6;
1293             else
1294                 infoPtr->nButtonHeight = sizeString.cy + 6;
1295         }
1296         else if (infoPtr->nButtonHeight < infoPtr->nBitmapHeight + 6)
1297             infoPtr->nButtonHeight = infoPtr->nBitmapHeight + 6;
1298
1299         if (sizeString.cx > infoPtr->nBitmapWidth)
1300             infoPtr->nButtonWidth = sizeString.cx + 6;
1301         else if (infoPtr->nButtonWidth < infoPtr->nBitmapWidth + 6)
1302             infoPtr->nButtonWidth = infoPtr->nBitmapWidth + 6;
1303     }
1304
1305     if ( infoPtr->cxMin >= 0 && infoPtr->nButtonWidth < infoPtr->cxMin )
1306         infoPtr->nButtonWidth = infoPtr->cxMin;
1307     if ( infoPtr->cxMax > 0 && infoPtr->nButtonWidth > infoPtr->cxMax )
1308         infoPtr->nButtonWidth = infoPtr->cxMax;
1309
1310     TOOLBAR_WrapToolbar( hwnd, dwStyle );
1311
1312     x  = infoPtr->nIndent;
1313     y  = 0;
1314
1315    /*
1316     * We will set the height below, and we set the width on entry
1317     * so we do not reset them here..
1318     */
1319 #if 0
1320     GetClientRect( hwnd, &rc );
1321     /* get initial values for toolbar */
1322     infoPtr->nWidth  = rc.right - rc.left;
1323     infoPtr->nHeight = rc.bottom - rc.top;
1324 #endif
1325
1326     /* from above, minimum is a button, and possible text */
1327     cx = infoPtr->nButtonWidth;
1328
1329     /* cannot use just ButtonHeight, we may have no buttons! */
1330     if (infoPtr->nNumButtons > 0)
1331         infoPtr->nHeight = infoPtr->nButtonHeight;
1332
1333     cy = infoPtr->nHeight;
1334
1335     nRows = nSepRows = 0;
1336
1337     infoPtr->rcBound.top = y;
1338     infoPtr->rcBound.left = x;
1339     infoPtr->rcBound.bottom = y + cy;
1340     infoPtr->rcBound.right = x;
1341
1342     btnPtr = infoPtr->buttons;
1343
1344     /* do not base height/width on parent, if the parent is a */
1345     /* rebar control it could have multiple rows of toolbars  */
1346 /*    GetClientRect( GetParent(hwnd), &rc ); */
1347 /*    cx = rc.right - rc.left; */
1348 /*    cy = rc.bottom - rc.top; */
1349
1350     TRACE("cy=%d\n", cy);
1351
1352     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++ )
1353     {
1354         bWrap = FALSE;
1355         if (btnPtr->fsState & TBSTATE_HIDDEN)
1356         {
1357             SetRectEmpty (&btnPtr->rect);
1358             continue;
1359         }
1360
1361         cy = infoPtr->nHeight;
1362
1363         /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
1364         /* it is the actual width of the separator. This is used for */
1365         /* custom controls in toolbars.                              */
1366         if (btnPtr->fsStyle & TBSTYLE_SEP) {
1367             if (btnPtr->fsStyle & TBSTYLE_DROPDOWN) {
1368                 cy = (btnPtr->iBitmap > 0) ?
1369                      btnPtr->iBitmap : SEPARATOR_WIDTH;
1370                 cx = infoPtr->nButtonWidth;
1371             }
1372             else
1373                 cx = (btnPtr->iBitmap > 0) ?
1374                      btnPtr->iBitmap : SEPARATOR_WIDTH;
1375         }
1376         else
1377         {
1378             if (btnPtr->fsStyle & TBSTYLE_AUTOSIZE)
1379             {
1380               SIZE sz;
1381               HDC hdc;
1382               HFONT hOldFont;
1383
1384               hdc = GetDC (hwnd);
1385               hOldFont = SelectObject (hdc, infoPtr->hFont);
1386
1387               TOOLBAR_MeasureString(infoPtr, btnPtr, hdc, &sz);
1388
1389               SelectObject (hdc, hOldFont);
1390               ReleaseDC (hwnd, hdc);
1391
1392               /* Fudge amount measured against IE4 "menu" and "Links" */
1393               /* toolbars with native control (v4.71).  -  GA 8/01    */
1394               cx = sz.cx + 6 + 5 + 5;
1395               if ((dwStyle & TBSTYLE_LIST) &&
1396                   (TOOLBAR_TestImageExist (infoPtr, btnPtr, infoPtr->himlDef)))
1397                   cx += infoPtr->nBitmapWidth;
1398             }
1399             else
1400               cx = infoPtr->nButtonWidth;
1401
1402             if (hasDropDownArrows && (btnPtr->fsStyle & TBSTYLE_DROPDOWN))
1403               cx += DDARROW_WIDTH;
1404         }
1405         if (btnPtr->fsState & TBSTATE_WRAP )
1406                     bWrap = TRUE;
1407
1408         SetRect (&btnPtr->rect, x, y, x + cx, y + cy);
1409
1410         if (infoPtr->rcBound.left > x)
1411             infoPtr->rcBound.left = x;
1412         if (infoPtr->rcBound.right < x + cx)
1413             infoPtr->rcBound.right = x + cx;
1414         if (infoPtr->rcBound.bottom < y + cy)
1415             infoPtr->rcBound.bottom = y + cy;
1416
1417         /* Set the toolTip only for non-hidden, non-separator button */
1418         if (infoPtr->hwndToolTip && !(btnPtr->fsStyle & TBSTYLE_SEP ))
1419         {
1420             TTTOOLINFOA ti;
1421
1422             ZeroMemory (&ti, sizeof(TTTOOLINFOA));
1423             ti.cbSize = sizeof(TTTOOLINFOA);
1424             ti.hwnd = hwnd;
1425             ti.uId = btnPtr->idCommand;
1426             ti.rect = btnPtr->rect;
1427             SendMessageA (infoPtr->hwndToolTip, TTM_NEWTOOLRECTA,
1428                             0, (LPARAM)&ti);
1429         }
1430
1431         /* btnPtr->nRow is zero based. The space between the rows is    */
1432         /* also considered as a row.                                    */
1433         btnPtr->nRow = nRows + nSepRows;
1434
1435         TRACE("button %d style=%x, bWrap=%d, nRows=%d, nSepRows=%d, btnrow=%d, (%d,%d)-(%d,%d)\n",
1436               i, btnPtr->fsStyle, bWrap, nRows, nSepRows, btnPtr->nRow,
1437               x, y, x+cx, y+cy);
1438
1439         if( bWrap )
1440         {
1441             if ( !(btnPtr->fsStyle & TBSTYLE_SEP) )
1442                 y += cy;
1443             else
1444             {
1445                 /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
1446                 /* it is the actual width of the separator. This is used for */
1447                 /* custom controls in toolbars.                              */
1448                 if ( !(btnPtr->fsStyle & TBSTYLE_DROPDOWN))
1449                     y += cy + ( (btnPtr->iBitmap > 0 ) ?
1450                                 btnPtr->iBitmap : SEPARATOR_WIDTH) * 2 /3;
1451                 else
1452                     y += cy;
1453
1454                 /* nSepRows is used to calculate the extra height follwoing  */
1455                 /* the last row.                                             */
1456                 nSepRows++;
1457             }
1458             x = infoPtr->nIndent;
1459
1460             /* Increment row number unless this is the last button    */
1461             /* and it has Wrap set.                                   */
1462             if (i != infoPtr->nNumButtons-1)
1463                 nRows++;
1464         }
1465         else
1466             x += cx;
1467     }
1468
1469     /* infoPtr->nRows is the number of rows on the toolbar */
1470     infoPtr->nRows = nRows + nSepRows + 1;
1471
1472 #if 0
1473     /********************************************************************
1474      * The following while interesting, does not match the values       *
1475      * created above for the button rectangles, nor the rcBound rect.   *
1476      * We will comment it out and remove it later.                      *
1477      *                                                                  *
1478      * The problem showed up as heights in the pager control that was   *
1479      * wrong.                                                           *
1480      ********************************************************************/
1481
1482     /* nSepRows * (infoPtr->nBitmapHeight + 1) is the space following   */
1483     /* the last row.                                                    */
1484     infoPtr->nHeight = TOP_BORDER + (nRows + 1) * infoPtr->nButtonHeight +
1485                         nSepRows * (SEPARATOR_WIDTH * 2 / 3) +
1486                         nSepRows * (infoPtr->nBitmapHeight + 1) +
1487                         BOTTOM_BORDER;
1488 #endif
1489
1490     infoPtr->nHeight = infoPtr->rcBound.bottom - infoPtr->rcBound.top;
1491
1492     TRACE("toolbar height %d, button width %d\n", infoPtr->nHeight, infoPtr->nButtonWidth);
1493 }
1494
1495
1496 static INT
1497 TOOLBAR_InternalHitTest (HWND hwnd, LPPOINT lpPt)
1498 {
1499     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1500     TBUTTON_INFO *btnPtr;
1501     INT i;
1502
1503     btnPtr = infoPtr->buttons;
1504     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
1505         if (btnPtr->fsState & TBSTATE_HIDDEN)
1506             continue;
1507
1508         if (btnPtr->fsStyle & TBSTYLE_SEP) {
1509             if (PtInRect (&btnPtr->rect, *lpPt)) {
1510                 TRACE(" ON SEPARATOR %d!\n", i);
1511                 return -i;
1512             }
1513         }
1514         else {
1515             if (PtInRect (&btnPtr->rect, *lpPt)) {
1516                 TRACE(" ON BUTTON %d!\n", i);
1517                 return i;
1518             }
1519         }
1520     }
1521
1522     TRACE(" NOWHERE!\n");
1523     return -1;
1524 }
1525
1526
1527 static INT
1528 TOOLBAR_GetButtonIndex (TOOLBAR_INFO *infoPtr, INT idCommand, BOOL CommandIsIndex)
1529 {
1530     TBUTTON_INFO *btnPtr;
1531     INT i;
1532
1533     if (CommandIsIndex) {
1534         TRACE("command is really index command=%d\n", idCommand);
1535         if (idCommand >= infoPtr->nNumButtons) return -1;
1536         return idCommand;
1537     }
1538     btnPtr = infoPtr->buttons;
1539     for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
1540         if (btnPtr->idCommand == idCommand) {
1541             TRACE("command=%d index=%d\n", idCommand, i);
1542             return i;
1543         }
1544     }
1545     TRACE("no index found for command=%d\n", idCommand);
1546     return -1;
1547 }
1548
1549
1550 static INT
1551 TOOLBAR_GetCheckedGroupButtonIndex (TOOLBAR_INFO *infoPtr, INT nIndex)
1552 {
1553     TBUTTON_INFO *btnPtr;
1554     INT nRunIndex;
1555
1556     if ((nIndex < 0) || (nIndex > infoPtr->nNumButtons))
1557         return -1;
1558
1559     /* check index button */
1560     btnPtr = &infoPtr->buttons[nIndex];
1561     if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
1562         if (btnPtr->fsState & TBSTATE_CHECKED)
1563             return nIndex;
1564     }
1565
1566     /* check previous buttons */
1567     nRunIndex = nIndex - 1;
1568     while (nRunIndex >= 0) {
1569         btnPtr = &infoPtr->buttons[nRunIndex];
1570         if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
1571             if (btnPtr->fsState & TBSTATE_CHECKED)
1572                 return nRunIndex;
1573         }
1574         else
1575             break;
1576         nRunIndex--;
1577     }
1578
1579     /* check next buttons */
1580     nRunIndex = nIndex + 1;
1581     while (nRunIndex < infoPtr->nNumButtons) {
1582         btnPtr = &infoPtr->buttons[nRunIndex];
1583         if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
1584             if (btnPtr->fsState & TBSTATE_CHECKED)
1585                 return nRunIndex;
1586         }
1587         else
1588             break;
1589         nRunIndex++;
1590     }
1591
1592     return -1;
1593 }
1594
1595
1596 static VOID
1597 TOOLBAR_RelayEvent (HWND hwndTip, HWND hwndMsg, UINT uMsg,
1598                     WPARAM wParam, LPARAM lParam)
1599 {
1600     MSG msg;
1601
1602     msg.hwnd = hwndMsg;
1603     msg.message = uMsg;
1604     msg.wParam = wParam;
1605     msg.lParam = lParam;
1606     msg.time = GetMessageTime ();
1607     msg.pt.x = LOWORD(GetMessagePos ());
1608     msg.pt.y = HIWORD(GetMessagePos ());
1609
1610     SendMessageA (hwndTip, TTM_RELAYEVENT, 0, (LPARAM)&msg);
1611 }
1612
1613
1614 /***********************************************************************
1615  * TOOLBAR_CustomizeDialogProc
1616  * This function implements the toolbar customization dialog.
1617  */
1618 static BOOL WINAPI
1619 TOOLBAR_CustomizeDialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1620 {
1621     PCUSTDLG_INFO custInfo = (PCUSTDLG_INFO)GetWindowLongA (hwnd, DWL_USER);
1622     PCUSTOMBUTTON btnInfo;
1623     NMTOOLBARA nmtb;
1624     TOOLBAR_INFO *infoPtr = custInfo ? custInfo->tbInfo : NULL;
1625
1626     switch (uMsg)
1627     {
1628         case WM_INITDIALOG:
1629             custInfo = (PCUSTDLG_INFO)lParam;
1630             SetWindowLongA (hwnd, DWL_USER, (DWORD)custInfo);
1631
1632             if (custInfo)
1633             {
1634                 char Buffer[256];
1635                 int i = 0;
1636                 int index;
1637
1638                 infoPtr = custInfo->tbInfo;
1639
1640                 /* send TBN_QUERYINSERT notification */
1641                 nmtb.iItem = custInfo->tbInfo->nNumButtons;
1642
1643                 if (!TOOLBAR_SendNotify ((NMHDR *) &nmtb, infoPtr, TBN_QUERYINSERT))
1644                     return FALSE;
1645
1646                 /* add items to 'toolbar buttons' list and check if removable */
1647                 for (i = 0; i < custInfo->tbInfo->nNumButtons; i++)
1648                 {
1649                     btnInfo = (PCUSTOMBUTTON)COMCTL32_Alloc(sizeof(CUSTOMBUTTON));
1650                     memset (&btnInfo->btn, 0, sizeof(TBBUTTON));
1651                     btnInfo->btn.fsStyle = TBSTYLE_SEP;
1652                     btnInfo->bVirtual = FALSE;
1653                     LoadStringA (COMCTL32_hModule, IDS_SEPARATOR, btnInfo->text, 64);
1654
1655                     /* send TBN_QUERYDELETE notification */
1656                     nmtb.iItem = i;
1657                     btnInfo->bRemovable = TOOLBAR_SendNotify ((NMHDR *) &nmtb,
1658                                                       infoPtr,
1659                                                       TBN_QUERYDELETE);
1660
1661                     index = (int)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_ADDSTRING, 0, 0);
1662                     SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
1663                 }
1664
1665                 /* insert separator button into 'available buttons' list */
1666                 btnInfo = (PCUSTOMBUTTON)COMCTL32_Alloc(sizeof(CUSTOMBUTTON));
1667                 memset (&btnInfo->btn, 0, sizeof(TBBUTTON));
1668                 btnInfo->btn.fsStyle = TBSTYLE_SEP;
1669                 btnInfo->bVirtual = FALSE;
1670                 btnInfo->bRemovable = TRUE;
1671                 LoadStringA (COMCTL32_hModule, IDS_SEPARATOR, btnInfo->text, 64);
1672                 index = (int)SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)btnInfo);
1673                 SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
1674
1675                 /* insert all buttons into dsa */
1676                 for (i = 0;; i++)
1677                 {
1678                     /* send TBN_GETBUTTONINFO notification */
1679                     nmtb.iItem = i;
1680                     nmtb.pszText = Buffer;
1681                     nmtb.cchText = 256;
1682
1683                     if (!TOOLBAR_SendNotify ((NMHDR *) &nmtb, infoPtr, TBN_GETBUTTONINFOA))
1684                         break;
1685
1686                     TRACE("style: %x\n", nmtb.tbButton.fsStyle);
1687
1688                     /* insert button into the apropriate list */
1689                     index = TOOLBAR_GetButtonIndex (custInfo->tbInfo, nmtb.tbButton.idCommand, FALSE);
1690                     if (index == -1)
1691                     {
1692                         btnInfo = (PCUSTOMBUTTON)COMCTL32_Alloc(sizeof(CUSTOMBUTTON));
1693                         memcpy (&btnInfo->btn, &nmtb.tbButton, sizeof(TBBUTTON));
1694                         btnInfo->bVirtual = FALSE;
1695                         btnInfo->bRemovable = TRUE;
1696                         if (!(nmtb.tbButton.fsStyle & TBSTYLE_SEP))
1697                             strcpy (btnInfo->text, nmtb.pszText);
1698
1699                         index = SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, 0);
1700                         SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
1701                     }
1702                     else
1703                     {
1704                         btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
1705                         memcpy (&btnInfo->btn, &nmtb.tbButton, sizeof(TBBUTTON));
1706                         if (!(nmtb.tbButton.fsStyle & TBSTYLE_SEP))
1707                             strcpy (btnInfo->text, nmtb.pszText);
1708
1709                         SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
1710                     }
1711                 }
1712
1713                 /* select first item in the 'available' list */
1714                 SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETCURSEL, 0, 0);
1715
1716                 /* append 'virtual' separator button to the 'toolbar buttons' list */
1717                 btnInfo = (PCUSTOMBUTTON)COMCTL32_Alloc(sizeof(CUSTOMBUTTON));
1718                 memset (&btnInfo->btn, 0, sizeof(TBBUTTON));
1719                 btnInfo->btn.fsStyle = TBSTYLE_SEP;
1720                 btnInfo->bVirtual = TRUE;
1721                 btnInfo->bRemovable = FALSE;
1722                 LoadStringA (COMCTL32_hModule, IDS_SEPARATOR, btnInfo->text, 64);
1723                 index = (int)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_ADDSTRING, 0, (LPARAM)btnInfo);
1724                 SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
1725
1726                 /* select last item in the 'toolbar' list */
1727                 SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETCURSEL, index, 0);
1728                 SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETTOPINDEX, index, 0);
1729
1730                 /* set focus and disable buttons */
1731                 PostMessageA (hwnd, WM_USER, 0, 0);
1732             }
1733             return TRUE;
1734
1735         case WM_USER:
1736             EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), FALSE);
1737             EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), FALSE);
1738             EnableWindow (GetDlgItem (hwnd,IDC_REMOVE_BTN), FALSE);
1739             SetFocus (GetDlgItem (hwnd, IDC_TOOLBARBTN_LBOX));
1740             return TRUE;
1741
1742         case WM_CLOSE:
1743             EndDialog(hwnd, FALSE);
1744             return TRUE;
1745
1746         case WM_COMMAND:
1747             switch (LOWORD(wParam))
1748             {
1749                 case IDC_TOOLBARBTN_LBOX:
1750                     if (HIWORD(wParam) == LBN_SELCHANGE)
1751                     {
1752                         PCUSTOMBUTTON btnInfo;
1753                         NMTOOLBARA nmtb;
1754                         int count;
1755                         int index;
1756
1757                         count = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCOUNT, 0, 0);
1758                         index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
1759
1760                         /* send TBN_QUERYINSERT notification */
1761                         nmtb.iItem = index;
1762                         TOOLBAR_SendNotify ((NMHDR *) &nmtb, infoPtr,
1763                                         TBN_QUERYINSERT);
1764
1765                         /* get list box item */
1766                         btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
1767
1768                         if (index == (count - 1))
1769                         {
1770                             /* last item (virtual separator) */
1771                             EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), FALSE);
1772                             EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), FALSE);
1773                         }
1774                         else if (index == (count - 2))
1775                         {
1776                             /* second last item (last non-virtual item) */
1777                             EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), TRUE);
1778                             EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), FALSE);
1779                         }
1780                         else if (index == 0)
1781                         {
1782                             /* first item */
1783                             EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), FALSE);
1784                             EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), TRUE);
1785                         }
1786                         else
1787                         {
1788                             EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), TRUE);
1789                             EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), TRUE);
1790                         }
1791
1792                         EnableWindow (GetDlgItem (hwnd,IDC_REMOVE_BTN), btnInfo->bRemovable);
1793                     }
1794                     break;
1795
1796                 case IDC_MOVEUP_BTN:
1797                     {
1798                         PCUSTOMBUTTON btnInfo;
1799                         int index;
1800                         int count;
1801
1802                         count = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCOUNT, 0, 0);
1803                         index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
1804                         TRACE("Move up: index %d\n", index);
1805
1806                         /* send TBN_QUERYINSERT notification */
1807                         nmtb.iItem = index;
1808
1809                         if (TOOLBAR_SendNotify ((NMHDR *) &nmtb, infoPtr,
1810                                             TBN_QUERYINSERT))
1811                         {
1812                             btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
1813
1814                             SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_DELETESTRING, index, 0);
1815                             SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_INSERTSTRING, index-1, 0);
1816                             SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index-1, (LPARAM)btnInfo);
1817                             SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETCURSEL, index-1 , 0);
1818
1819                             if (index <= 1)
1820                                 EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), FALSE);
1821                             else if (index >= (count - 3))
1822                                 EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), TRUE);
1823
1824                             SendMessageA (custInfo->tbHwnd, TB_DELETEBUTTON, index, 0);
1825                             SendMessageA (custInfo->tbHwnd, TB_INSERTBUTTONA, index-1, (LPARAM)&(btnInfo->btn));
1826                         }
1827                     }
1828                     break;
1829
1830                 case IDC_MOVEDN_BTN: /* move down */
1831                     {
1832                         PCUSTOMBUTTON btnInfo;
1833                         int index;
1834                         int count;
1835
1836                         count = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCOUNT, 0, 0);
1837                         index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
1838                         TRACE("Move up: index %d\n", index);
1839
1840                         /* send TBN_QUERYINSERT notification */
1841                         nmtb.iItem = index;
1842                         if (TOOLBAR_SendNotify ((NMHDR *) &nmtb, infoPtr,
1843                                             TBN_QUERYINSERT))
1844                         {
1845                             btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
1846
1847                             /* move button down */
1848                             SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_DELETESTRING, index, 0);
1849                             SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_INSERTSTRING, index+1, 0);
1850                             SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index+1, (LPARAM)btnInfo);
1851                             SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETCURSEL, index+1 , 0);
1852
1853                             if (index == 0)
1854                                 EnableWindow (GetDlgItem (hwnd,IDC_MOVEUP_BTN), TRUE);
1855                             else if (index >= (count - 3))
1856                                 EnableWindow (GetDlgItem (hwnd,IDC_MOVEDN_BTN), FALSE);
1857
1858                             SendMessageA (custInfo->tbHwnd, TB_DELETEBUTTON, index, 0);
1859                             SendMessageA (custInfo->tbHwnd, TB_INSERTBUTTONA, index+1, (LPARAM)&(btnInfo->btn));
1860                         }
1861                     }
1862                     break;
1863
1864                 case IDC_REMOVE_BTN: /* remove button */
1865                     {
1866                         PCUSTOMBUTTON btnInfo;
1867                         int index;
1868
1869                         index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
1870                         TRACE("Remove: index %d\n", index);
1871
1872                         /* send TBN_QUERYDELETE notification */
1873                         nmtb.iItem = index;
1874                         if (TOOLBAR_SendNotify ((NMHDR *) &nmtb, infoPtr,
1875                                             TBN_QUERYDELETE))
1876                         {
1877                             btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, index, 0);
1878                             SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_DELETESTRING, index, 0);
1879                             SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETCURSEL, index , 0);
1880
1881                             SendMessageA (custInfo->tbHwnd, TB_DELETEBUTTON, index, 0);
1882
1883                             /* insert into 'available button' list */
1884                             if (!(btnInfo->btn.fsStyle & TBSTYLE_SEP))
1885                             {
1886                                 index = (int)SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_ADDSTRING, 0, 0);
1887                                 SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
1888                             }
1889                             else
1890                                 COMCTL32_Free (btnInfo);
1891                         }
1892                     }
1893                     break;
1894
1895                 case IDOK: /* Add button */
1896                     {
1897                         int index;
1898                         int count;
1899
1900                         count = SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETCOUNT, 0, 0);
1901                         index = SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETCURSEL, 0, 0);
1902                         TRACE("Add: index %d\n", index);
1903
1904                         /* send TBN_QUERYINSERT notification */
1905                         nmtb.iItem = index;
1906                         if (TOOLBAR_SendNotify ((NMHDR *) &nmtb, infoPtr,
1907                                             TBN_QUERYINSERT))
1908                         {
1909                             btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETITEMDATA, index, 0);
1910
1911                             if (index != 0)
1912                             {
1913                                 /* remove from 'available buttons' list */
1914                                 SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_DELETESTRING, index, 0);
1915                                 if (index == count-1)
1916                                     SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETCURSEL, index-1 , 0);
1917                                 else
1918                                     SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETCURSEL, index , 0);
1919                             }
1920                             else
1921                             {
1922                                 PCUSTOMBUTTON btnNew;
1923
1924                                 /* duplicate 'separator' button */
1925                                 btnNew = (PCUSTOMBUTTON)COMCTL32_Alloc (sizeof(CUSTOMBUTTON));
1926                                 memcpy (btnNew, btnInfo, sizeof(CUSTOMBUTTON));
1927                                 btnInfo = btnNew;
1928                             }
1929
1930                             /* insert into 'toolbar button' list */
1931                             index = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCURSEL, 0, 0);
1932                             SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_INSERTSTRING, index, 0);
1933                             SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, index, (LPARAM)btnInfo);
1934
1935                             SendMessageA (custInfo->tbHwnd, TB_INSERTBUTTONA, index, (LPARAM)&(btnInfo->btn));
1936                         }
1937                     }
1938                     break;
1939
1940                 case IDCANCEL:
1941                     EndDialog(hwnd, FALSE);
1942                     break;
1943             }
1944             return TRUE;
1945
1946         case WM_DESTROY:
1947             {
1948                 int count;
1949                 int i;
1950
1951                 /* delete items from 'toolbar buttons' listbox*/
1952                 count = SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETCOUNT, 0, 0);
1953                 for (i = 0; i < count; i++)
1954                 {
1955                     btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_GETITEMDATA, i, 0);
1956                     COMCTL32_Free(btnInfo);
1957                     SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_SETITEMDATA, 0, 0);
1958                 }
1959                 SendDlgItemMessageA (hwnd, IDC_TOOLBARBTN_LBOX, LB_RESETCONTENT, 0, 0);
1960
1961
1962                 /* delete items from 'available buttons' listbox*/
1963                 count = SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETCOUNT, 0, 0);
1964                 for (i = 0; i < count; i++)
1965                 {
1966                     btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_GETITEMDATA, i, 0);
1967                     COMCTL32_Free(btnInfo);
1968                     SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_SETITEMDATA, i, 0);
1969                 }
1970                 SendDlgItemMessageA (hwnd, IDC_AVAILBTN_LBOX, LB_RESETCONTENT, 0, 0);
1971             }
1972             return TRUE;
1973
1974         case WM_DRAWITEM:
1975             if (wParam == IDC_AVAILBTN_LBOX || wParam == IDC_TOOLBARBTN_LBOX)
1976             {
1977                 LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT)lParam;
1978                 RECT rcButton;
1979                 RECT rcText;
1980                 HPEN hOldPen;
1981                 HBRUSH hOldBrush;
1982                 COLORREF oldText = 0;
1983                 COLORREF oldBk = 0;
1984
1985                 /* get item data */
1986                 btnInfo = (PCUSTOMBUTTON)SendDlgItemMessageA (hwnd, wParam, LB_GETITEMDATA, (WPARAM)lpdis->itemID, 0);
1987                 if (btnInfo == NULL)
1988                 {
1989                     FIXME("btnInfo invalid!\n");
1990                     return TRUE;
1991                 }
1992
1993                 /* set colors and select objects */
1994                 oldBk = SetBkColor (lpdis->hDC, (lpdis->itemState & ODS_FOCUS)?comctl32_color.clrHighlight:comctl32_color.clrWindow);
1995                 if (btnInfo->bVirtual)
1996                    oldText = SetTextColor (lpdis->hDC, comctl32_color.clrGrayText);
1997                 else
1998                    oldText = SetTextColor (lpdis->hDC, (lpdis->itemState & ODS_FOCUS)?comctl32_color.clrHighlightText:comctl32_color.clrWindowText);
1999                 hOldPen = SelectObject (lpdis->hDC, GetSysColorPen ((lpdis->itemState & ODS_SELECTED)?COLOR_HIGHLIGHT:COLOR_WINDOW));
2000                 hOldBrush = SelectObject (lpdis->hDC, GetSysColorBrush ((lpdis->itemState & ODS_FOCUS)?COLOR_HIGHLIGHT:COLOR_WINDOW));
2001
2002                 /* fill background rectangle */
2003                 Rectangle (lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
2004                            lpdis->rcItem.right, lpdis->rcItem.bottom);
2005
2006                 /* calculate button and text rectangles */
2007                 CopyRect (&rcButton, &lpdis->rcItem);
2008                 InflateRect (&rcButton, -1, -1);
2009                 CopyRect (&rcText, &rcButton);
2010                 rcButton.right = rcButton.left + custInfo->tbInfo->nBitmapWidth + 6;
2011                 rcText.left = rcButton.right + 2;
2012
2013                 /* draw focus rectangle */
2014                 if (lpdis->itemState & ODS_FOCUS)
2015                     DrawFocusRect (lpdis->hDC, &lpdis->rcItem);
2016
2017                 /* draw button */
2018                 DrawEdge (lpdis->hDC, &rcButton, EDGE_RAISED, BF_RECT|BF_MIDDLE|BF_SOFT);
2019
2020                 /* draw image and text */
2021                 if ((btnInfo->btn.fsStyle & TBSTYLE_SEP) == 0)
2022                     ImageList_Draw (custInfo->tbInfo->himlDef, btnInfo->btn.iBitmap, lpdis->hDC,
2023                                     rcButton.left+3, rcButton.top+3, ILD_NORMAL);
2024                 DrawTextA (lpdis->hDC,  btnInfo->text, -1, &rcText,
2025                                DT_LEFT | DT_VCENTER | DT_SINGLELINE);
2026
2027                 /* delete objects and reset colors */
2028                 SelectObject (lpdis->hDC, hOldBrush);
2029                 SelectObject (lpdis->hDC, hOldPen);
2030                 SetBkColor (lpdis->hDC, oldBk);
2031                 SetTextColor (lpdis->hDC, oldText);
2032
2033                 return TRUE;
2034             }
2035             return FALSE;
2036
2037         case WM_MEASUREITEM:
2038             if (wParam == IDC_AVAILBTN_LBOX || wParam == IDC_TOOLBARBTN_LBOX)
2039             {
2040                 MEASUREITEMSTRUCT *lpmis = (MEASUREITEMSTRUCT*)lParam;
2041
2042                 if (custInfo && custInfo->tbInfo)
2043                     lpmis->itemHeight = custInfo->tbInfo->nBitmapHeight + 8;
2044                 else
2045                     lpmis->itemHeight = 15 + 8; /* default height */
2046
2047                 return TRUE;
2048             }
2049             return FALSE;
2050
2051         default:
2052             return FALSE;
2053     }
2054 }
2055
2056
2057 /***********************************************************************
2058  * TOOLBAR_AddBitmap:  Add the bitmaps to the default image list.
2059  *
2060  */
2061 static LRESULT
2062 TOOLBAR_AddBitmap (HWND hwnd, WPARAM wParam, LPARAM lParam)
2063 {
2064     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2065     LPTBADDBITMAP lpAddBmp = (LPTBADDBITMAP)lParam;
2066     INT nIndex = 0, nButtons, nCount;
2067     HBITMAP hbmLoad;
2068
2069     TRACE("hwnd=%x wParam=%x lParam=%lx\n", hwnd, wParam, lParam);
2070     if (!lpAddBmp)
2071         return -1;
2072
2073     if (lpAddBmp->hInst == HINST_COMMCTRL)
2074     {
2075         if ((lpAddBmp->nID & ~1) == IDB_STD_SMALL_COLOR)
2076             nButtons = 15;
2077         else if ((lpAddBmp->nID & ~1) == IDB_VIEW_SMALL_COLOR)
2078             nButtons = 13;
2079         else if ((lpAddBmp->nID & ~1) == IDB_HIST_SMALL_COLOR)
2080             nButtons = 5;
2081         else
2082             return -1;
2083
2084         TRACE ("adding %d internal bitmaps!\n", nButtons);
2085
2086         /* Windows resize all the buttons to the size of a newly added standard image */
2087         if (lpAddBmp->nID & 1)
2088         {
2089             /* large icons */
2090             /* FIXME: on windows the size of the images is 25x24 but the size of the bitmap
2091              * in rsrc is only 24x24. Fix the bitmap (how?) and then fix this
2092              */
2093             SendMessageA (hwnd, TB_SETBITMAPSIZE, 0,
2094                           MAKELPARAM((WORD)24, (WORD)24));
2095             SendMessageA (hwnd, TB_SETBUTTONSIZE, 0,
2096                           MAKELPARAM((WORD)31, (WORD)30));
2097         }
2098         else
2099         {
2100             /* small icons */
2101             SendMessageA (hwnd, TB_SETBITMAPSIZE, 0,
2102                           MAKELPARAM((WORD)16, (WORD)16));
2103             SendMessageA (hwnd, TB_SETBUTTONSIZE, 0,
2104                           MAKELPARAM((WORD)22, (WORD)22));
2105         }
2106
2107         TOOLBAR_CalcToolbar (hwnd);
2108     }
2109     else
2110     {
2111         nButtons = (INT)wParam;
2112         if (nButtons <= 0)
2113             return -1;
2114
2115         TRACE ("adding %d bitmaps!\n", nButtons);
2116     }
2117
2118     if (!(infoPtr->himlDef)) {
2119         /* create new default image list */
2120         TRACE ("creating default image list!\n");
2121
2122         infoPtr->himlDef =
2123             ImageList_Create (infoPtr->nBitmapWidth, infoPtr->nBitmapHeight,
2124                               ILC_COLOR | ILC_MASK, nButtons, 2);
2125         infoPtr->himlInt = infoPtr->himlDef;
2126     }
2127
2128     nCount = ImageList_GetImageCount(infoPtr->himlDef);
2129
2130     /* Add bitmaps to the default image list */
2131     if (lpAddBmp->hInst == (HINSTANCE)0)
2132     {
2133         nIndex =
2134             ImageList_AddMasked (infoPtr->himlDef, (HBITMAP)lpAddBmp->nID,
2135                                  CLR_DEFAULT);
2136     }
2137     else if (lpAddBmp->hInst == HINST_COMMCTRL)
2138     {
2139         /* Add system bitmaps */
2140         switch (lpAddBmp->nID)
2141     {
2142             case IDB_STD_SMALL_COLOR:
2143                 hbmLoad = LoadBitmapA (COMCTL32_hModule,
2144                                        MAKEINTRESOURCEA(IDB_STD_SMALL));
2145                 nIndex = ImageList_AddMasked (infoPtr->himlDef,
2146                                               hbmLoad, CLR_DEFAULT);
2147                 DeleteObject (hbmLoad);
2148                 break;
2149
2150             case IDB_STD_LARGE_COLOR:
2151                 hbmLoad = LoadBitmapA (COMCTL32_hModule,
2152                                        MAKEINTRESOURCEA(IDB_STD_LARGE));
2153                 nIndex = ImageList_AddMasked (infoPtr->himlDef,
2154                                               hbmLoad, CLR_DEFAULT);
2155                 DeleteObject (hbmLoad);
2156                 break;
2157
2158             case IDB_VIEW_SMALL_COLOR:
2159                 hbmLoad = LoadBitmapA (COMCTL32_hModule,
2160                                        MAKEINTRESOURCEA(IDB_VIEW_SMALL));
2161                 nIndex = ImageList_AddMasked (infoPtr->himlDef,
2162                                               hbmLoad, CLR_DEFAULT);
2163                 DeleteObject (hbmLoad);
2164                 break;
2165
2166             case IDB_VIEW_LARGE_COLOR:
2167                 hbmLoad = LoadBitmapA (COMCTL32_hModule,
2168                                        MAKEINTRESOURCEA(IDB_VIEW_LARGE));
2169                 nIndex = ImageList_AddMasked (infoPtr->himlDef,
2170                                               hbmLoad, CLR_DEFAULT);
2171                 DeleteObject (hbmLoad);
2172                 break;
2173
2174             case IDB_HIST_SMALL_COLOR:
2175                 hbmLoad = LoadBitmapA (COMCTL32_hModule,
2176                                        MAKEINTRESOURCEA(IDB_HIST_SMALL));
2177                 nIndex = ImageList_AddMasked (infoPtr->himlDef,
2178                                               hbmLoad, CLR_DEFAULT);
2179                 DeleteObject (hbmLoad);
2180                 break;
2181
2182             case IDB_HIST_LARGE_COLOR:
2183                 hbmLoad = LoadBitmapA (COMCTL32_hModule,
2184                                        MAKEINTRESOURCEA(IDB_HIST_LARGE));
2185                 nIndex = ImageList_AddMasked (infoPtr->himlDef,
2186                                               hbmLoad, CLR_DEFAULT);
2187                 DeleteObject (hbmLoad);
2188                 break;
2189
2190             default:
2191         nIndex = ImageList_GetImageCount (infoPtr->himlDef);
2192                 ERR ("invalid imagelist!\n");
2193                 break;
2194         }
2195     }
2196     else
2197     {
2198         hbmLoad = LoadBitmapA (lpAddBmp->hInst, (LPSTR)lpAddBmp->nID);
2199         nIndex = ImageList_AddMasked (infoPtr->himlDef, hbmLoad, CLR_DEFAULT);
2200         DeleteObject (hbmLoad);
2201     }
2202
2203     if (nIndex != -1)
2204     {
2205        INT imagecount = ImageList_GetImageCount(infoPtr->himlDef);
2206
2207        if (infoPtr->nNumBitmaps + nButtons != imagecount)
2208        {
2209          WARN("Desired images do not match received images : Previous image number %i Previous images in list %i added %i expecting total %i, Images in list %i\n",
2210               infoPtr->nNumBitmaps, nCount, imagecount - nCount,
2211               infoPtr->nNumBitmaps+nButtons,imagecount);
2212
2213          infoPtr->nNumBitmaps = imagecount;
2214        }
2215        else
2216          infoPtr->nNumBitmaps += nButtons;
2217     }
2218
2219     InvalidateRect(hwnd, NULL, FALSE);
2220
2221     return nIndex;
2222 }
2223
2224
2225 static LRESULT
2226 TOOLBAR_AddButtonsA (HWND hwnd, WPARAM wParam, LPARAM lParam)
2227 {
2228     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2229     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
2230     INT nOldButtons, nNewButtons, nAddButtons, nCount;
2231
2232     TRACE("adding %d buttons!\n", wParam);
2233
2234     nAddButtons = (UINT)wParam;
2235     nOldButtons = infoPtr->nNumButtons;
2236     nNewButtons = nOldButtons + nAddButtons;
2237
2238     if (infoPtr->nNumButtons == 0) {
2239         infoPtr->buttons =
2240             COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
2241     }
2242     else {
2243         TBUTTON_INFO *oldButtons = infoPtr->buttons;
2244         infoPtr->buttons =
2245             COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
2246         memcpy (&infoPtr->buttons[0], &oldButtons[0],
2247                 nOldButtons * sizeof(TBUTTON_INFO));
2248         COMCTL32_Free (oldButtons);
2249     }
2250
2251     infoPtr->nNumButtons = nNewButtons;
2252
2253     /* insert new button data */
2254     for (nCount = 0; nCount < nAddButtons; nCount++) {
2255         TBUTTON_INFO *btnPtr = &infoPtr->buttons[nOldButtons+nCount];
2256         btnPtr->iBitmap   = lpTbb[nCount].iBitmap;
2257         btnPtr->idCommand = lpTbb[nCount].idCommand;
2258         btnPtr->fsState   = lpTbb[nCount].fsState;
2259         btnPtr->fsStyle   = lpTbb[nCount].fsStyle;
2260         btnPtr->dwData    = lpTbb[nCount].dwData;
2261         btnPtr->iString   = lpTbb[nCount].iString;
2262         btnPtr->bHot      = FALSE;
2263
2264         if ((infoPtr->hwndToolTip) && !(btnPtr->fsStyle & TBSTYLE_SEP)) {
2265             TTTOOLINFOA ti;
2266
2267             ZeroMemory (&ti, sizeof(TTTOOLINFOA));
2268             ti.cbSize   = sizeof (TTTOOLINFOA);
2269             ti.hwnd     = hwnd;
2270             ti.uId      = btnPtr->idCommand;
2271             ti.hinst    = 0;
2272             ti.lpszText = LPSTR_TEXTCALLBACKA;
2273
2274             SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
2275                             0, (LPARAM)&ti);
2276         }
2277     }
2278
2279     TOOLBAR_CalcToolbar (hwnd);
2280
2281     TOOLBAR_DumpToolbar (infoPtr, __LINE__);
2282
2283     InvalidateRect(hwnd, NULL, FALSE);
2284
2285     return TRUE;
2286 }
2287
2288
2289 static LRESULT
2290 TOOLBAR_AddButtonsW (HWND hwnd, WPARAM wParam, LPARAM lParam)
2291 {
2292     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2293     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
2294     INT nOldButtons, nNewButtons, nAddButtons, nCount;
2295
2296     TRACE("adding %d buttons!\n", wParam);
2297
2298     nAddButtons = (UINT)wParam;
2299     nOldButtons = infoPtr->nNumButtons;
2300     nNewButtons = nOldButtons + nAddButtons;
2301
2302     if (infoPtr->nNumButtons == 0) {
2303         infoPtr->buttons =
2304             COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
2305     }
2306     else {
2307         TBUTTON_INFO *oldButtons = infoPtr->buttons;
2308         infoPtr->buttons =
2309             COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
2310         memcpy (&infoPtr->buttons[0], &oldButtons[0],
2311                 nOldButtons * sizeof(TBUTTON_INFO));
2312         COMCTL32_Free (oldButtons);
2313     }
2314
2315     infoPtr->nNumButtons = nNewButtons;
2316
2317     /* insert new button data */
2318     for (nCount = 0; nCount < nAddButtons; nCount++) {
2319         TBUTTON_INFO *btnPtr = &infoPtr->buttons[nOldButtons+nCount];
2320         btnPtr->iBitmap   = lpTbb[nCount].iBitmap;
2321         btnPtr->idCommand = lpTbb[nCount].idCommand;
2322         btnPtr->fsState   = lpTbb[nCount].fsState;
2323         btnPtr->fsStyle   = lpTbb[nCount].fsStyle;
2324         btnPtr->dwData    = lpTbb[nCount].dwData;
2325         btnPtr->iString   = lpTbb[nCount].iString;
2326         btnPtr->bHot      = FALSE;
2327
2328         if ((infoPtr->hwndToolTip) && !(btnPtr->fsStyle & TBSTYLE_SEP)) {
2329             TTTOOLINFOW ti;
2330
2331             ZeroMemory (&ti, sizeof(TTTOOLINFOW));
2332             ti.cbSize   = sizeof (TTTOOLINFOW);
2333             ti.hwnd     = hwnd;
2334             ti.uId      = btnPtr->idCommand;
2335             ti.hinst    = 0;
2336             ti.lpszText = LPSTR_TEXTCALLBACKW;
2337
2338             SendMessageW (infoPtr->hwndToolTip, TTM_ADDTOOLW,
2339                             0, (LPARAM)&ti);
2340         }
2341     }
2342
2343     TOOLBAR_CalcToolbar (hwnd);
2344
2345     TOOLBAR_DumpToolbar (infoPtr, __LINE__);
2346
2347     InvalidateRect(hwnd, NULL, FALSE);
2348
2349     return TRUE;
2350 }
2351
2352
2353 static LRESULT
2354 TOOLBAR_AddStringA (HWND hwnd, WPARAM wParam, LPARAM lParam)
2355 {
2356     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2357     INT nIndex;
2358
2359     if ((wParam) && (HIWORD(lParam) == 0)) {
2360         char szString[256];
2361         INT len;
2362         TRACE("adding string from resource!\n");
2363
2364         len = LoadStringA ((HINSTANCE)wParam, (UINT)lParam,
2365                              szString, 256);
2366
2367         TRACE("len=%d \"%s\"\n", len, szString);
2368         nIndex = infoPtr->nNumStrings;
2369         if (infoPtr->nNumStrings == 0) {
2370             infoPtr->strings =
2371                 COMCTL32_Alloc (sizeof(LPWSTR));
2372         }
2373         else {
2374             LPWSTR *oldStrings = infoPtr->strings;
2375             infoPtr->strings =
2376                 COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
2377             memcpy (&infoPtr->strings[0], &oldStrings[0],
2378                     sizeof(LPWSTR) * infoPtr->nNumStrings);
2379             COMCTL32_Free (oldStrings);
2380         }
2381
2382         /*COMCTL32_Alloc zeros out the allocated memory*/
2383         Str_SetPtrAtoW (&infoPtr->strings[infoPtr->nNumStrings], szString );
2384         infoPtr->nNumStrings++;
2385     }
2386     else {
2387         LPSTR p = (LPSTR)lParam;
2388         INT len;
2389
2390         if (p == NULL)
2391             return -1;
2392         TRACE("adding string(s) from array!\n");
2393
2394         nIndex = infoPtr->nNumStrings;
2395         while (*p) {
2396             len = strlen (p);
2397             TRACE("len=%d \"%s\"\n", len, p);
2398
2399             if (infoPtr->nNumStrings == 0) {
2400                 infoPtr->strings =
2401                     COMCTL32_Alloc (sizeof(LPWSTR));
2402             }
2403             else {
2404                 LPWSTR *oldStrings = infoPtr->strings;
2405                 infoPtr->strings =
2406                     COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
2407                 memcpy (&infoPtr->strings[0], &oldStrings[0],
2408                         sizeof(LPWSTR) * infoPtr->nNumStrings);
2409                 COMCTL32_Free (oldStrings);
2410             }
2411
2412             Str_SetPtrAtoW (&infoPtr->strings[infoPtr->nNumStrings], p );
2413             infoPtr->nNumStrings++;
2414
2415             p += (len+1);
2416         }
2417     }
2418
2419     return nIndex;
2420 }
2421
2422
2423 static LRESULT
2424 TOOLBAR_AddStringW (HWND hwnd, WPARAM wParam, LPARAM lParam)
2425 {
2426 #define MAX_RESOURCE_STRING_LENGTH 512
2427     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2428     INT nIndex;
2429
2430     if ((wParam) && (HIWORD(lParam) == 0)) {
2431         WCHAR szString[MAX_RESOURCE_STRING_LENGTH];
2432         INT len;
2433         TRACE("adding string from resource!\n");
2434
2435         len = LoadStringW ((HINSTANCE)wParam, (UINT)lParam,
2436                              szString, MAX_RESOURCE_STRING_LENGTH);
2437
2438         TRACE("len=%d %s\n", len, debugstr_w(szString));
2439         TRACE("First char: 0x%x\n", *szString);
2440         if (szString[0] == L'|')
2441         {
2442             PWSTR p = szString + 1;
2443
2444             nIndex = infoPtr->nNumStrings;
2445             while (*p != L'|') {
2446
2447             if (infoPtr->nNumStrings == 0) {
2448                 infoPtr->strings =
2449                     COMCTL32_Alloc (sizeof(LPWSTR));
2450             }
2451             else {
2452                 LPWSTR *oldStrings = infoPtr->strings;
2453                 infoPtr->strings =
2454                     COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
2455                 memcpy (&infoPtr->strings[0], &oldStrings[0],
2456                         sizeof(LPWSTR) * infoPtr->nNumStrings);
2457                 COMCTL32_Free (oldStrings);
2458             }
2459
2460             len = COMCTL32_StrChrW (p, L'|') - p;
2461             TRACE("len=%d %s\n", len, debugstr_w(p));
2462             infoPtr->strings[infoPtr->nNumStrings] =
2463                 COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
2464             lstrcpynW (infoPtr->strings[infoPtr->nNumStrings], p, len+1);
2465             infoPtr->nNumStrings++;
2466
2467                 p += (len+1);
2468             }
2469         }
2470         else
2471         {
2472             nIndex = infoPtr->nNumStrings;
2473             if (infoPtr->nNumStrings == 0) {
2474                 infoPtr->strings =
2475                     COMCTL32_Alloc (sizeof(LPWSTR));
2476             }
2477             else {
2478                 LPWSTR *oldStrings = infoPtr->strings;
2479                 infoPtr->strings =
2480                     COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
2481                 memcpy (&infoPtr->strings[0], &oldStrings[0],
2482                         sizeof(LPWSTR) * infoPtr->nNumStrings);
2483                 COMCTL32_Free (oldStrings);
2484             }
2485
2486             Str_SetPtrW (&infoPtr->strings[infoPtr->nNumStrings], szString);
2487             infoPtr->nNumStrings++;
2488         }
2489     }
2490     else {
2491         LPWSTR p = (LPWSTR)lParam;
2492         INT len;
2493
2494         if (p == NULL)
2495             return -1;
2496         TRACE("adding string(s) from array!\n");
2497         nIndex = infoPtr->nNumStrings;
2498         while (*p) {
2499             len = strlenW (p);
2500
2501             TRACE("len=%d %s\n", len, debugstr_w(p));
2502             if (infoPtr->nNumStrings == 0) {
2503                 infoPtr->strings =
2504                     COMCTL32_Alloc (sizeof(LPWSTR));
2505             }
2506             else {
2507                 LPWSTR *oldStrings = infoPtr->strings;
2508                 infoPtr->strings =
2509                     COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
2510                 memcpy (&infoPtr->strings[0], &oldStrings[0],
2511                         sizeof(LPWSTR) * infoPtr->nNumStrings);
2512                 COMCTL32_Free (oldStrings);
2513             }
2514
2515             Str_SetPtrW (&infoPtr->strings[infoPtr->nNumStrings], p);
2516             infoPtr->nNumStrings++;
2517
2518             p += (len+1);
2519         }
2520     }
2521
2522     return nIndex;
2523 }
2524
2525
2526 static LRESULT
2527 TOOLBAR_AutoSize (HWND hwnd)
2528 {
2529     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2530     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
2531     RECT parent_rect;
2532     RECT window_rect;
2533     HWND parent;
2534     INT  x, y;
2535     INT  cx, cy;
2536     UINT uPosFlags = SWP_NOZORDER;
2537
2538     TRACE("resize forced, style=%lx!\n", dwStyle);
2539
2540     parent = GetParent (hwnd);
2541     GetClientRect(parent, &parent_rect);
2542
2543     x = parent_rect.left;
2544     y = parent_rect.top;
2545
2546     /* FIXME: we should be able to early out if nothing */
2547     /* has changed with nWidth != parent_rect width */
2548
2549     if (dwStyle & CCS_NORESIZE) {
2550         uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
2551         cx = 0;
2552         cy = 0;
2553         TOOLBAR_CalcToolbar (hwnd);
2554     }
2555     else {
2556         infoPtr->nWidth = parent_rect.right - parent_rect.left;
2557         TOOLBAR_CalcToolbar (hwnd);
2558         InvalidateRect( hwnd, NULL, TRUE );
2559         cy = infoPtr->nHeight;
2560         cx = infoPtr->nWidth;
2561
2562         if (dwStyle & CCS_NOMOVEY) {
2563                 GetWindowRect(hwnd, &window_rect);
2564                 ScreenToClient(parent, (LPPOINT)&window_rect.left);
2565                 y = window_rect.top;
2566         }
2567     }
2568
2569     if (dwStyle & CCS_NOPARENTALIGN)
2570         uPosFlags |= SWP_NOMOVE;
2571
2572     if (!(dwStyle & CCS_NODIVIDER))
2573         cy += GetSystemMetrics(SM_CYEDGE);
2574
2575     if (dwStyle & WS_BORDER)
2576     {
2577         x = y = 1;
2578         cy += GetSystemMetrics(SM_CYEDGE);
2579         cx += GetSystemMetrics(SM_CYEDGE);
2580     }
2581
2582     infoPtr->bAutoSize = TRUE;
2583     SetWindowPos (hwnd, HWND_TOP, parent_rect.left - x, parent_rect.top - y,
2584                         cx, cy, uPosFlags);
2585     /* The following line makes sure that the infoPtr->bAutoSize is turned off after
2586      * the setwindowpos calls */
2587     infoPtr->bAutoSize = FALSE;
2588
2589     return 0;
2590 }
2591
2592
2593 static LRESULT
2594 TOOLBAR_ButtonCount (HWND hwnd, WPARAM wParam, LPARAM lParam)
2595 {
2596     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2597
2598     return infoPtr->nNumButtons;
2599 }
2600
2601
2602 static LRESULT
2603 TOOLBAR_ButtonStructSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
2604 {
2605     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2606
2607     if (infoPtr == NULL) {
2608         ERR("(0x%x, 0x%x, 0x%lx)\n", hwnd, wParam, lParam);
2609         ERR("infoPtr == NULL!\n");
2610         return 0;
2611     }
2612
2613     infoPtr->dwStructSize = (DWORD)wParam;
2614
2615     return 0;
2616 }
2617
2618
2619 static LRESULT
2620 TOOLBAR_ChangeBitmap (HWND hwnd, WPARAM wParam, LPARAM lParam)
2621 {
2622     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2623     TBUTTON_INFO *btnPtr;
2624     INT nIndex;
2625
2626     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
2627     if (nIndex == -1)
2628         return FALSE;
2629
2630     btnPtr = &infoPtr->buttons[nIndex];
2631     btnPtr->iBitmap = LOWORD(lParam);
2632
2633     /* we HAVE to erase the background, the new bitmap could be */
2634     /* transparent */
2635     InvalidateRect(hwnd, &btnPtr->rect, TRUE);
2636
2637     return TRUE;
2638 }
2639
2640
2641 static LRESULT
2642 TOOLBAR_CheckButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
2643 {
2644     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2645     TBUTTON_INFO *btnPtr;
2646     INT nIndex;
2647     INT nOldIndex = -1;
2648     BOOL bChecked = FALSE;
2649
2650     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
2651     if (nIndex == -1)
2652         return FALSE;
2653
2654     btnPtr = &infoPtr->buttons[nIndex];
2655
2656     if (!(btnPtr->fsStyle & TBSTYLE_CHECK))
2657         return FALSE;
2658
2659     bChecked = (btnPtr->fsState & TBSTATE_CHECKED) ? TRUE : FALSE;
2660
2661     if (LOWORD(lParam) == FALSE)
2662         btnPtr->fsState &= ~TBSTATE_CHECKED;
2663     else {
2664         if (btnPtr->fsStyle & TBSTYLE_GROUP) {
2665             nOldIndex =
2666                 TOOLBAR_GetCheckedGroupButtonIndex (infoPtr, nIndex);
2667             if (nOldIndex == nIndex)
2668                 return 0;
2669             if (nOldIndex != -1)
2670                 infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
2671         }
2672         btnPtr->fsState |= TBSTATE_CHECKED;
2673     }
2674
2675     if( bChecked != LOWORD(lParam) )
2676     {
2677         if (nOldIndex != -1)
2678         {
2679             InvalidateRect(hwnd, &infoPtr->buttons[nOldIndex].rect,
2680                 TOOLBAR_HasText(infoPtr, &infoPtr->buttons[nOldIndex]));
2681         }
2682         InvalidateRect(hwnd, &btnPtr->rect, TRUE);
2683     }
2684
2685     /* FIXME: Send a WM_NOTIFY?? */
2686
2687     return TRUE;
2688 }
2689
2690
2691 static LRESULT
2692 TOOLBAR_CommandToIndex (HWND hwnd, WPARAM wParam, LPARAM lParam)
2693 {
2694     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2695
2696     return TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
2697 }
2698
2699
2700 static LRESULT
2701 TOOLBAR_Customize (HWND hwnd)
2702 {
2703     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2704     CUSTDLG_INFO custInfo;
2705     LRESULT ret;
2706     LPCVOID template;
2707     HRSRC hRes;
2708     NMHDR nmhdr;
2709
2710     custInfo.tbInfo = infoPtr;
2711     custInfo.tbHwnd = hwnd;
2712
2713     /* send TBN_BEGINADJUST notification */
2714     TOOLBAR_SendNotify ((NMHDR *) &nmhdr, infoPtr,
2715                     TBN_BEGINADJUST);
2716
2717     if (!(hRes = FindResourceA (COMCTL32_hModule,
2718                                 MAKEINTRESOURCEA(IDD_TBCUSTOMIZE),
2719                                 RT_DIALOGA)))
2720         return FALSE;
2721
2722     if(!(template = (LPVOID)LoadResource (COMCTL32_hModule, hRes)))
2723         return FALSE;
2724
2725     ret = DialogBoxIndirectParamA (GetWindowLongA (hwnd, GWL_HINSTANCE),
2726                                    (LPDLGTEMPLATEA)template,
2727                                    hwnd,
2728                                    (DLGPROC)TOOLBAR_CustomizeDialogProc,
2729                                    (LPARAM)&custInfo);
2730
2731     /* send TBN_ENDADJUST notification */
2732     TOOLBAR_SendNotify ((NMHDR *) &nmhdr, infoPtr,
2733                     TBN_ENDADJUST);
2734
2735     return ret;
2736 }
2737
2738
2739 static LRESULT
2740 TOOLBAR_DeleteButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
2741 {
2742     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2743     INT nIndex = (INT)wParam;
2744
2745     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
2746         return FALSE;
2747
2748     if ((infoPtr->hwndToolTip) &&
2749         !(infoPtr->buttons[nIndex].fsStyle & TBSTYLE_SEP)) {
2750         TTTOOLINFOA ti;
2751
2752         ZeroMemory (&ti, sizeof(TTTOOLINFOA));
2753         ti.cbSize   = sizeof (TTTOOLINFOA);
2754         ti.hwnd     = hwnd;
2755         ti.uId      = infoPtr->buttons[nIndex].idCommand;
2756
2757         SendMessageA (infoPtr->hwndToolTip, TTM_DELTOOLA, 0, (LPARAM)&ti);
2758     }
2759
2760     if (infoPtr->nNumButtons == 1) {
2761         TRACE(" simple delete!\n");
2762         COMCTL32_Free (infoPtr->buttons);
2763         infoPtr->buttons = NULL;
2764         infoPtr->nNumButtons = 0;
2765     }
2766     else {
2767         TBUTTON_INFO *oldButtons = infoPtr->buttons;
2768         TRACE("complex delete! [nIndex=%d]\n", nIndex);
2769
2770         infoPtr->nNumButtons--;
2771         infoPtr->buttons = COMCTL32_Alloc (sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
2772         if (nIndex > 0) {
2773             memcpy (&infoPtr->buttons[0], &oldButtons[0],
2774                     nIndex * sizeof(TBUTTON_INFO));
2775         }
2776
2777         if (nIndex < infoPtr->nNumButtons) {
2778             memcpy (&infoPtr->buttons[nIndex], &oldButtons[nIndex+1],
2779                     (infoPtr->nNumButtons - nIndex) * sizeof(TBUTTON_INFO));
2780         }
2781
2782         COMCTL32_Free (oldButtons);
2783     }
2784
2785     TOOLBAR_CalcToolbar (hwnd);
2786
2787     InvalidateRect (hwnd, NULL, TRUE);
2788
2789     return TRUE;
2790 }
2791
2792
2793 static LRESULT
2794 TOOLBAR_EnableButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
2795 {
2796     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2797     TBUTTON_INFO *btnPtr;
2798     INT nIndex;
2799     DWORD bState;
2800
2801     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
2802     if (nIndex == -1)
2803         return FALSE;
2804
2805     btnPtr = &infoPtr->buttons[nIndex];
2806
2807     bState = btnPtr->fsState & TBSTATE_ENABLED;
2808
2809     /* update the toolbar button state */
2810     if(LOWORD(lParam) == FALSE) {
2811         btnPtr->fsState &= ~(TBSTATE_ENABLED | TBSTATE_PRESSED);
2812     } else {
2813         btnPtr->fsState |= TBSTATE_ENABLED;
2814     }
2815
2816     /* redraw the button only if the state of the button changed */
2817     if(bState != (btnPtr->fsState & TBSTATE_ENABLED))
2818     {
2819         InvalidateRect(hwnd, &btnPtr->rect,
2820             TOOLBAR_HasText(infoPtr, btnPtr));
2821     }
2822
2823     return TRUE;
2824 }
2825
2826
2827 static inline LRESULT
2828 TOOLBAR_GetAnchorHighlight (HWND hwnd)
2829 {
2830     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2831
2832     return infoPtr->bAnchor;
2833 }
2834
2835
2836 static LRESULT
2837 TOOLBAR_GetBitmap (HWND hwnd, WPARAM wParam, LPARAM lParam)
2838 {
2839     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2840     INT nIndex;
2841
2842     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
2843     if (nIndex == -1)
2844         return -1;
2845
2846     return infoPtr->buttons[nIndex].iBitmap;
2847 }
2848
2849
2850 static inline LRESULT
2851 TOOLBAR_GetBitmapFlags (HWND hwnd, WPARAM wParam, LPARAM lParam)
2852 {
2853     return (GetDeviceCaps (0, LOGPIXELSX) >= 120) ? TBBF_LARGE : 0;
2854 }
2855
2856
2857 static LRESULT
2858 TOOLBAR_GetButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
2859 {
2860     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2861     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
2862     INT nIndex = (INT)wParam;
2863     TBUTTON_INFO *btnPtr;
2864
2865     if (infoPtr == NULL)
2866         return FALSE;
2867
2868     if (lpTbb == NULL)
2869         return FALSE;
2870
2871     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
2872         return FALSE;
2873
2874     btnPtr = &infoPtr->buttons[nIndex];
2875     lpTbb->iBitmap   = btnPtr->iBitmap;
2876     lpTbb->idCommand = btnPtr->idCommand;
2877     lpTbb->fsState   = btnPtr->fsState;
2878     lpTbb->fsStyle   = btnPtr->fsStyle;
2879     lpTbb->dwData    = btnPtr->dwData;
2880     lpTbb->iString   = btnPtr->iString;
2881
2882     return TRUE;
2883 }
2884
2885
2886 static LRESULT
2887 TOOLBAR_GetButtonInfoA (HWND hwnd, WPARAM wParam, LPARAM lParam)
2888 {
2889     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2890     LPTBBUTTONINFOA lpTbInfo = (LPTBBUTTONINFOA)lParam;
2891     TBUTTON_INFO *btnPtr;
2892     INT nIndex;
2893
2894     if (infoPtr == NULL)
2895         return -1;
2896     if (lpTbInfo == NULL)
2897         return -1;
2898     if (lpTbInfo->cbSize < sizeof(TBBUTTONINFOA))
2899         return -1;
2900
2901     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam,
2902                                      lpTbInfo->dwMask & 0x80000000);
2903     if (nIndex == -1)
2904         return -1;
2905
2906     if (!(btnPtr = &infoPtr->buttons[nIndex])) return -1;
2907
2908     if (lpTbInfo->dwMask & TBIF_COMMAND)
2909         lpTbInfo->idCommand = btnPtr->idCommand;
2910     if (lpTbInfo->dwMask & TBIF_IMAGE)
2911         lpTbInfo->iImage = btnPtr->iBitmap;
2912     if (lpTbInfo->dwMask & TBIF_LPARAM)
2913         lpTbInfo->lParam = btnPtr->dwData;
2914     if (lpTbInfo->dwMask & TBIF_SIZE)
2915         lpTbInfo->cx = (WORD)(btnPtr->rect.right - btnPtr->rect.left);
2916     if (lpTbInfo->dwMask & TBIF_STATE)
2917         lpTbInfo->fsState = btnPtr->fsState;
2918     if (lpTbInfo->dwMask & TBIF_STYLE)
2919         lpTbInfo->fsStyle = btnPtr->fsStyle;
2920      if (lpTbInfo->dwMask & TBIF_TEXT) {
2921          LPWSTR lpText = TOOLBAR_GetText(infoPtr,btnPtr);
2922          Str_GetPtrWtoA (lpText, lpTbInfo->pszText,lpTbInfo->cchText);
2923          }
2924     return nIndex;
2925 }
2926
2927
2928 static LRESULT
2929 TOOLBAR_GetButtonInfoW (HWND hwnd, WPARAM wParam, LPARAM lParam)
2930 {
2931     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2932     LPTBBUTTONINFOW lpTbInfo = (LPTBBUTTONINFOW)lParam;
2933     TBUTTON_INFO *btnPtr;
2934     INT nIndex;
2935
2936     if (infoPtr == NULL)
2937         return -1;
2938     if (lpTbInfo == NULL)
2939         return -1;
2940     if (lpTbInfo->cbSize < sizeof(TBBUTTONINFOW))
2941         return -1;
2942
2943     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam,
2944                                      lpTbInfo->dwMask & 0x80000000);
2945     if (nIndex == -1)
2946         return -1;
2947
2948     btnPtr = &infoPtr->buttons[nIndex];
2949
2950     if (lpTbInfo->dwMask & TBIF_COMMAND)
2951         lpTbInfo->idCommand = btnPtr->idCommand;
2952     if (lpTbInfo->dwMask & TBIF_IMAGE)
2953         lpTbInfo->iImage = btnPtr->iBitmap;
2954     if (lpTbInfo->dwMask & TBIF_LPARAM)
2955         lpTbInfo->lParam = btnPtr->dwData;
2956     if (lpTbInfo->dwMask & TBIF_SIZE)
2957         lpTbInfo->cx = (WORD)(btnPtr->rect.right - btnPtr->rect.left);
2958     if (lpTbInfo->dwMask & TBIF_STATE)
2959         lpTbInfo->fsState = btnPtr->fsState;
2960     if (lpTbInfo->dwMask & TBIF_STYLE)
2961         lpTbInfo->fsStyle = btnPtr->fsStyle;
2962     if (lpTbInfo->dwMask & TBIF_TEXT) {
2963         LPWSTR lpText = TOOLBAR_GetText(infoPtr,btnPtr);
2964         Str_GetPtrW (lpText,lpTbInfo->pszText,lpTbInfo->cchText);
2965     }
2966
2967     return nIndex;
2968 }
2969
2970
2971 static LRESULT
2972 TOOLBAR_GetButtonSize (HWND hwnd)
2973 {
2974     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2975
2976     if (infoPtr->nNumButtons > 0)
2977         return MAKELONG((WORD)infoPtr->nButtonWidth,
2978                         (WORD)infoPtr->nButtonHeight);
2979     else
2980         return MAKELONG(8,7);
2981 }
2982
2983
2984 static LRESULT
2985 TOOLBAR_GetButtonTextA (HWND hwnd, WPARAM wParam, LPARAM lParam)
2986 {
2987     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2988     INT nIndex;
2989     LPWSTR lpText;
2990
2991     if (lParam == 0)
2992         return -1;
2993
2994     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
2995     if (nIndex == -1)
2996         return -1;
2997
2998     lpText = TOOLBAR_GetText(infoPtr,&infoPtr->buttons[nIndex]);
2999
3000     return WideCharToMultiByte( CP_ACP, 0, lpText, -1,
3001                                 (LPSTR)lParam, 0x7fffffff, NULL, NULL ) - 1;
3002 }
3003
3004
3005 static LRESULT
3006 TOOLBAR_GetButtonTextW (HWND hwnd, WPARAM wParam, LPARAM lParam)
3007 {
3008     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3009     INT nIndex;
3010     LPWSTR lpText;
3011
3012     if (lParam == 0)
3013         return -1;
3014
3015     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
3016     if (nIndex == -1)
3017         return -1;
3018
3019     lpText = TOOLBAR_GetText(infoPtr,&infoPtr->buttons[nIndex]);
3020
3021     strcpyW ((LPWSTR)lParam, lpText);
3022
3023     return strlenW (lpText);
3024 }
3025
3026
3027 static LRESULT
3028 TOOLBAR_GetDisabledImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
3029 {
3030     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3031
3032     return (LRESULT)infoPtr->himlDis;
3033 }
3034
3035
3036 inline static LRESULT
3037 TOOLBAR_GetExtendedStyle (HWND hwnd)
3038 {
3039     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3040
3041     return infoPtr->dwExStyle;
3042 }
3043
3044
3045 static LRESULT
3046 TOOLBAR_GetHotImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
3047 {
3048     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3049
3050     return (LRESULT)infoPtr->himlHot;
3051 }
3052
3053
3054 static LRESULT
3055 TOOLBAR_GetHotItem (HWND hwnd)
3056 {
3057     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3058
3059     if (!(GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT))
3060         return -1;
3061
3062     if (infoPtr->nHotItem < 0)
3063         return -1;
3064
3065     return (LRESULT)infoPtr->nHotItem;
3066 }
3067
3068
3069 static LRESULT
3070 TOOLBAR_GetImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
3071 {
3072     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3073
3074     return (LRESULT)infoPtr->himlDef;
3075 }
3076
3077
3078 /* << TOOLBAR_GetInsertMark >> */
3079 /* << TOOLBAR_GetInsertMarkColor >> */
3080
3081
3082 static LRESULT
3083 TOOLBAR_GetItemRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
3084 {
3085     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3086     TBUTTON_INFO *btnPtr;
3087     LPRECT     lpRect;
3088     INT        nIndex;
3089
3090     if (infoPtr == NULL)
3091         return FALSE;
3092     nIndex = (INT)wParam;
3093     btnPtr = &infoPtr->buttons[nIndex];
3094     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
3095         return FALSE;
3096     lpRect = (LPRECT)lParam;
3097     if (lpRect == NULL)
3098         return FALSE;
3099     if (btnPtr->fsState & TBSTATE_HIDDEN)
3100         return FALSE;
3101
3102     lpRect->left   = btnPtr->rect.left;
3103     lpRect->right  = btnPtr->rect.right;
3104     lpRect->bottom = btnPtr->rect.bottom;
3105     lpRect->top    = btnPtr->rect.top;
3106
3107     return TRUE;
3108 }
3109
3110
3111 static LRESULT
3112 TOOLBAR_GetMaxSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
3113 {
3114     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3115     LPSIZE lpSize = (LPSIZE)lParam;
3116
3117     if (lpSize == NULL)
3118         return FALSE;
3119
3120     lpSize->cx = infoPtr->rcBound.right - infoPtr->rcBound.left;
3121     lpSize->cy = infoPtr->rcBound.bottom - infoPtr->rcBound.top;
3122
3123     TRACE("maximum size %d x %d\n",
3124            infoPtr->rcBound.right - infoPtr->rcBound.left,
3125            infoPtr->rcBound.bottom - infoPtr->rcBound.top);
3126
3127     return TRUE;
3128 }
3129
3130
3131 /* << TOOLBAR_GetObject >> */
3132
3133
3134 static LRESULT
3135 TOOLBAR_GetPadding (HWND hwnd)
3136 {
3137     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3138     DWORD oldPad;
3139
3140     oldPad = MAKELONG(infoPtr->szPadding.cx, infoPtr->szPadding.cy);
3141     return (LRESULT) oldPad;
3142 }
3143
3144
3145 static LRESULT
3146 TOOLBAR_GetRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
3147 {
3148     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3149     TBUTTON_INFO *btnPtr;
3150     LPRECT     lpRect;
3151     INT        nIndex;
3152
3153     if (infoPtr == NULL)
3154         return FALSE;
3155     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
3156     btnPtr = &infoPtr->buttons[nIndex];
3157     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
3158         return FALSE;
3159     lpRect = (LPRECT)lParam;
3160     if (lpRect == NULL)
3161         return FALSE;
3162
3163     lpRect->left   = btnPtr->rect.left;
3164     lpRect->right  = btnPtr->rect.right;
3165     lpRect->bottom = btnPtr->rect.bottom;
3166     lpRect->top    = btnPtr->rect.top;
3167
3168     return TRUE;
3169 }
3170
3171
3172 static LRESULT
3173 TOOLBAR_GetRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
3174 {
3175     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3176
3177     if (GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_WRAPABLE)
3178         return infoPtr->nRows;
3179     else
3180         return 1;
3181 }
3182
3183
3184 static LRESULT
3185 TOOLBAR_GetState (HWND hwnd, WPARAM wParam, LPARAM lParam)
3186 {
3187     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3188     INT nIndex;
3189
3190     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
3191     if (nIndex == -1)
3192         return -1;
3193
3194     return infoPtr->buttons[nIndex].fsState;
3195 }
3196
3197
3198 static LRESULT
3199 TOOLBAR_GetStyle (HWND hwnd, WPARAM wParam, LPARAM lParam)
3200 {
3201     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3202     INT nIndex;
3203
3204     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
3205     if (nIndex == -1)
3206         return -1;
3207
3208     return infoPtr->buttons[nIndex].fsStyle;
3209 }
3210
3211
3212 static LRESULT
3213 TOOLBAR_GetTextRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
3214 {
3215     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3216
3217     if (infoPtr == NULL)
3218         return 0;
3219
3220     return infoPtr->nMaxTextRows;
3221 }
3222
3223
3224 static LRESULT
3225 TOOLBAR_GetToolTips (HWND hwnd, WPARAM wParam, LPARAM lParam)
3226 {
3227     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3228
3229     if (infoPtr == NULL)
3230         return 0;
3231     return infoPtr->hwndToolTip;
3232 }
3233
3234
3235 static LRESULT
3236 TOOLBAR_GetUnicodeFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
3237 {
3238     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3239
3240     TRACE("%s hwnd=0x%x stub!\n",
3241            infoPtr->bUnicode ? "TRUE" : "FALSE", hwnd);
3242
3243     return infoPtr->bUnicode;
3244 }
3245
3246
3247 inline static LRESULT
3248 TOOLBAR_GetVersion (HWND hwnd)
3249 {
3250     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3251     return infoPtr->iVersion;
3252 }
3253
3254
3255 static LRESULT
3256 TOOLBAR_HideButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
3257 {
3258     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3259     TBUTTON_INFO *btnPtr;
3260     INT nIndex;
3261
3262     TRACE("\n");
3263
3264     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
3265     if (nIndex == -1)
3266         return FALSE;
3267
3268     btnPtr = &infoPtr->buttons[nIndex];
3269     if (LOWORD(lParam) == FALSE)
3270         btnPtr->fsState &= ~TBSTATE_HIDDEN;
3271     else
3272         btnPtr->fsState |= TBSTATE_HIDDEN;
3273
3274     TOOLBAR_CalcToolbar (hwnd);
3275
3276     InvalidateRect (hwnd, NULL, TRUE);
3277
3278     return TRUE;
3279 }
3280
3281
3282 inline static LRESULT
3283 TOOLBAR_HitTest (HWND hwnd, WPARAM wParam, LPARAM lParam)
3284 {
3285     return TOOLBAR_InternalHitTest (hwnd, (LPPOINT)lParam);
3286 }
3287
3288
3289 static LRESULT
3290 TOOLBAR_Indeterminate (HWND hwnd, WPARAM wParam, LPARAM lParam)
3291 {
3292     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3293     TBUTTON_INFO *btnPtr;
3294     INT nIndex;
3295
3296     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
3297     if (nIndex == -1)
3298         return FALSE;
3299
3300     btnPtr = &infoPtr->buttons[nIndex];
3301     if (LOWORD(lParam) == FALSE)
3302         btnPtr->fsState &= ~TBSTATE_INDETERMINATE;
3303     else
3304         btnPtr->fsState |= TBSTATE_INDETERMINATE;
3305
3306     InvalidateRect(hwnd, &btnPtr->rect, TOOLBAR_HasText(infoPtr, btnPtr));
3307
3308     return TRUE;
3309 }
3310
3311
3312 static LRESULT
3313 TOOLBAR_InsertButtonA (HWND hwnd, WPARAM wParam, LPARAM lParam)
3314 {
3315     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3316     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
3317     INT nIndex = (INT)wParam;
3318     TBUTTON_INFO *oldButtons;
3319
3320     if (lpTbb == NULL)
3321         return FALSE;
3322
3323     TOOLBAR_DumpButton(infoPtr, (TBUTTON_INFO *)lpTbb, nIndex, FALSE);
3324
3325     if (nIndex == -1) {
3326        /* EPP: this seems to be an undocumented call (from my IE4)
3327         * I assume in that case that:
3328         * - lpTbb->iString is a string pointer (not a string index in strings[] table
3329         * - index of insertion is at the end of existing buttons
3330         * I only see this happen with nIndex == -1, but it could have a special
3331         * meaning (like -nIndex (or ~nIndex) to get the real position of insertion).
3332         */
3333         nIndex = infoPtr->nNumButtons;
3334
3335     } else if (nIndex < 0)
3336        return FALSE;
3337
3338     /* If the string passed is not an index, assume address of string
3339        and do our own AddString */
3340     if ((HIWORD(lpTbb->iString) != 0) && (lpTbb->iString != -1)) {
3341         LPSTR ptr;
3342         INT len;
3343
3344         TRACE("string %s passed instead of index, adding string\n",
3345               debugstr_a((LPSTR)lpTbb->iString));
3346         len = strlen((LPSTR)lpTbb->iString) + 2;
3347         ptr = COMCTL32_Alloc(len);
3348         strcpy(ptr, (LPSTR)lpTbb->iString);
3349         ptr[len - 1] = 0; /* ended by two '\0' */
3350         lpTbb->iString = TOOLBAR_AddStringA(hwnd, 0, (LPARAM)ptr);
3351         COMCTL32_Free(ptr);
3352     }
3353
3354     TRACE("inserting button index=%d\n", nIndex);
3355     if (nIndex > infoPtr->nNumButtons) {
3356         nIndex = infoPtr->nNumButtons;
3357         TRACE("adjust index=%d\n", nIndex);
3358     }
3359
3360     oldButtons = infoPtr->buttons;
3361     infoPtr->nNumButtons++;
3362     infoPtr->buttons = COMCTL32_Alloc (sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
3363     /* pre insert copy */
3364     if (nIndex > 0) {
3365         memcpy (&infoPtr->buttons[0], &oldButtons[0],
3366                 nIndex * sizeof(TBUTTON_INFO));
3367     }
3368
3369     /* insert new button */
3370     infoPtr->buttons[nIndex].iBitmap   = lpTbb->iBitmap;
3371     infoPtr->buttons[nIndex].idCommand = lpTbb->idCommand;
3372     infoPtr->buttons[nIndex].fsState   = lpTbb->fsState;
3373     infoPtr->buttons[nIndex].fsStyle   = lpTbb->fsStyle;
3374     infoPtr->buttons[nIndex].dwData    = lpTbb->dwData;
3375     /* if passed string and not index, then add string */
3376     if(HIWORD(lpTbb->iString) && lpTbb->iString!=-1) {
3377         Str_SetPtrAtoW ((LPWSTR *)&infoPtr->buttons[nIndex].iString, (LPCSTR )lpTbb->iString);
3378     }
3379     else
3380         infoPtr->buttons[nIndex].iString   = lpTbb->iString;
3381
3382     if ((infoPtr->hwndToolTip) && !(lpTbb->fsStyle & TBSTYLE_SEP)) {
3383         TTTOOLINFOA ti;
3384
3385         ZeroMemory (&ti, sizeof(TTTOOLINFOA));
3386         ti.cbSize   = sizeof (TTTOOLINFOA);
3387         ti.hwnd     = hwnd;
3388         ti.uId      = lpTbb->idCommand;
3389         ti.hinst    = 0;
3390         ti.lpszText = LPSTR_TEXTCALLBACKA;
3391
3392         SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
3393                         0, (LPARAM)&ti);
3394     }
3395
3396     /* post insert copy */
3397     if (nIndex < infoPtr->nNumButtons - 1) {
3398         memcpy (&infoPtr->buttons[nIndex+1], &oldButtons[nIndex],
3399                 (infoPtr->nNumButtons - nIndex - 1) * sizeof(TBUTTON_INFO));
3400     }
3401
3402     COMCTL32_Free (oldButtons);
3403
3404     TOOLBAR_CalcToolbar (hwnd);
3405
3406     InvalidateRect (hwnd, NULL, TRUE);
3407
3408     return TRUE;
3409 }
3410
3411
3412 static LRESULT
3413 TOOLBAR_InsertButtonW (HWND hwnd, WPARAM wParam, LPARAM lParam)
3414 {
3415     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3416     LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
3417     INT nIndex = (INT)wParam;
3418     TBUTTON_INFO *oldButtons;
3419
3420     if (lpTbb == NULL)
3421         return FALSE;
3422
3423     TOOLBAR_DumpButton(infoPtr, (TBUTTON_INFO *)lpTbb, nIndex, FALSE);
3424
3425     if (nIndex == -1) {
3426        /* EPP: this seems to be an undocumented call (from my IE4)
3427         * I assume in that case that:
3428         * - lpTbb->iString is a string pointer (not a string index in strings[] table
3429         * - index of insertion is at the end of existing buttons
3430         * I only see this happen with nIndex == -1, but it could have a special
3431         * meaning (like -nIndex (or ~nIndex) to get the real position of insertion).
3432         */
3433         nIndex = infoPtr->nNumButtons;
3434
3435     } else if (nIndex < 0)
3436        return FALSE;
3437
3438     /* If the string passed is not an index, assume address of string
3439        and do our own AddString */
3440     if ((HIWORD(lpTbb->iString) != 0) && (lpTbb->iString != -1)) {
3441         LPWSTR ptr;
3442         INT len;
3443
3444         TRACE("string %s passed instead of index, adding string\n",
3445               debugstr_w((LPWSTR)lpTbb->iString));
3446         len = strlenW((LPWSTR)lpTbb->iString) + 2;
3447         ptr = COMCTL32_Alloc(len*sizeof(WCHAR));
3448         strcpyW(ptr, (LPWSTR)lpTbb->iString);
3449         ptr[len - 1] = 0; /* ended by two '\0' */
3450         lpTbb->iString = TOOLBAR_AddStringW(hwnd, 0, (LPARAM)ptr);
3451         COMCTL32_Free(ptr);
3452     }
3453
3454     TRACE("inserting button index=%d\n", nIndex);
3455     if (nIndex > infoPtr->nNumButtons) {
3456         nIndex = infoPtr->nNumButtons;
3457         TRACE("adjust index=%d\n", nIndex);
3458     }
3459
3460     oldButtons = infoPtr->buttons;
3461     infoPtr->nNumButtons++;
3462     infoPtr->buttons = COMCTL32_Alloc (sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
3463     /* pre insert copy */
3464     if (nIndex > 0) {
3465         memcpy (&infoPtr->buttons[0], &oldButtons[0],
3466                 nIndex * sizeof(TBUTTON_INFO));
3467     }
3468
3469     /* insert new button */
3470     infoPtr->buttons[nIndex].iBitmap   = lpTbb->iBitmap;
3471     infoPtr->buttons[nIndex].idCommand = lpTbb->idCommand;
3472     infoPtr->buttons[nIndex].fsState   = lpTbb->fsState;
3473     infoPtr->buttons[nIndex].fsStyle   = lpTbb->fsStyle;
3474     infoPtr->buttons[nIndex].dwData    = lpTbb->dwData;
3475     /* if passed string and not index, then add string */
3476     if(HIWORD(lpTbb->iString) && lpTbb->iString!=-1) {
3477         Str_SetPtrW ((LPWSTR *)&infoPtr->buttons[nIndex].iString, (LPWSTR)lpTbb->iString);
3478     }
3479     else
3480         infoPtr->buttons[nIndex].iString   = lpTbb->iString;
3481
3482     if ((infoPtr->hwndToolTip) && !(lpTbb->fsStyle & TBSTYLE_SEP)) {
3483         TTTOOLINFOW ti;
3484
3485         ZeroMemory (&ti, sizeof(TTTOOLINFOW));
3486         ti.cbSize   = sizeof (TTTOOLINFOW);
3487         ti.hwnd     = hwnd;
3488         ti.uId      = lpTbb->idCommand;
3489         ti.hinst    = 0;
3490         ti.lpszText = LPSTR_TEXTCALLBACKW;
3491
3492         SendMessageW (infoPtr->hwndToolTip, TTM_ADDTOOLW,
3493                         0, (LPARAM)&ti);
3494     }
3495
3496     /* post insert copy */
3497     if (nIndex < infoPtr->nNumButtons - 1) {
3498         memcpy (&infoPtr->buttons[nIndex+1], &oldButtons[nIndex],
3499                 (infoPtr->nNumButtons - nIndex - 1) * sizeof(TBUTTON_INFO));
3500     }
3501
3502     COMCTL32_Free (oldButtons);
3503
3504     TOOLBAR_CalcToolbar (hwnd);
3505
3506     InvalidateRect (hwnd, NULL, TRUE);
3507
3508     return TRUE;
3509 }
3510
3511
3512 /* << TOOLBAR_InsertMarkHitTest >> */
3513
3514
3515 static LRESULT
3516 TOOLBAR_IsButtonChecked (HWND hwnd, WPARAM wParam, LPARAM lParam)
3517 {
3518     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3519     INT nIndex;
3520
3521     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
3522     if (nIndex == -1)
3523         return FALSE;
3524
3525     return (infoPtr->buttons[nIndex].fsState & TBSTATE_CHECKED);
3526 }
3527
3528
3529 static LRESULT
3530 TOOLBAR_IsButtonEnabled (HWND hwnd, WPARAM wParam, LPARAM lParam)
3531 {
3532     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3533     INT nIndex;
3534
3535     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
3536     if (nIndex == -1)
3537         return FALSE;
3538
3539     return (infoPtr->buttons[nIndex].fsState & TBSTATE_ENABLED);
3540 }
3541
3542
3543 static LRESULT
3544 TOOLBAR_IsButtonHidden (HWND hwnd, WPARAM wParam, LPARAM lParam)
3545 {
3546     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3547     INT nIndex;
3548
3549     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
3550     if (nIndex == -1)
3551         return TRUE;
3552
3553     return (infoPtr->buttons[nIndex].fsState & TBSTATE_HIDDEN);
3554 }
3555
3556
3557 static LRESULT
3558 TOOLBAR_IsButtonHighlighted (HWND hwnd, WPARAM wParam, LPARAM lParam)
3559 {
3560     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3561     INT nIndex;
3562
3563     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
3564     if (nIndex == -1)
3565         return FALSE;
3566
3567     return (infoPtr->buttons[nIndex].fsState & TBSTATE_MARKED);
3568 }
3569
3570
3571 static LRESULT
3572 TOOLBAR_IsButtonIndeterminate (HWND hwnd, WPARAM wParam, LPARAM lParam)
3573 {
3574     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3575     INT nIndex;
3576
3577     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
3578     if (nIndex == -1)
3579         return FALSE;
3580
3581     return (infoPtr->buttons[nIndex].fsState & TBSTATE_INDETERMINATE);
3582 }
3583
3584
3585 static LRESULT
3586 TOOLBAR_IsButtonPressed (HWND hwnd, WPARAM wParam, LPARAM lParam)
3587 {
3588     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3589     INT nIndex;
3590
3591     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
3592     if (nIndex == -1)
3593         return FALSE;
3594
3595     return (infoPtr->buttons[nIndex].fsState & TBSTATE_PRESSED);
3596 }
3597
3598
3599 /* << TOOLBAR_LoadImages >> */
3600 /* << TOOLBAR_MapAccelerator >> */
3601 /* << TOOLBAR_MarkButton >> */
3602 /* << TOOLBAR_MoveButton >> */
3603
3604
3605 static LRESULT
3606 TOOLBAR_PressButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
3607 {
3608     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3609     TBUTTON_INFO *btnPtr;
3610     INT nIndex;
3611
3612     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
3613     if (nIndex == -1)
3614         return FALSE;
3615
3616     btnPtr = &infoPtr->buttons[nIndex];
3617     if (LOWORD(lParam) == FALSE)
3618         btnPtr->fsState &= ~TBSTATE_PRESSED;
3619     else
3620         btnPtr->fsState |= TBSTATE_PRESSED;
3621
3622     InvalidateRect(hwnd, &btnPtr->rect, TOOLBAR_HasText(infoPtr, btnPtr));
3623
3624     return TRUE;
3625 }
3626
3627
3628 /* << TOOLBAR_ReplaceBitmap >> */
3629
3630
3631 static LRESULT
3632 TOOLBAR_SaveRestoreA (HWND hwnd, WPARAM wParam, LPARAM lParam)
3633 {
3634 #if 0
3635     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3636     LPTBSAVEPARAMSA lpSave = (LPTBSAVEPARAMSA)lParam;
3637
3638     if (lpSave == NULL) return 0;
3639
3640     if ((BOOL)wParam) {
3641         /* save toolbar information */
3642         FIXME("save to \"%s\" \"%s\"\n",
3643                lpSave->pszSubKey, lpSave->pszValueName);
3644
3645
3646     }
3647     else {
3648         /* restore toolbar information */
3649
3650         FIXME("restore from \"%s\" \"%s\"\n",
3651                lpSave->pszSubKey, lpSave->pszValueName);
3652
3653
3654     }
3655 #endif
3656
3657     return 0;
3658 }
3659
3660
3661 static LRESULT
3662 TOOLBAR_SaveRestoreW (HWND hwnd, WPARAM wParam, LPARAM lParam)
3663 {
3664 #if 0
3665     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3666     LPTBSAVEPARAMSW lpSave = (LPTBSAVEPARAMSW)lParam;
3667
3668     if (lpSave == NULL)
3669         return 0;
3670
3671     if ((BOOL)wParam) {
3672         /* save toolbar information */
3673         FIXME("save to \"%s\" \"%s\"\n",
3674                lpSave->pszSubKey, lpSave->pszValueName);
3675
3676
3677     }
3678     else {
3679         /* restore toolbar information */
3680
3681         FIXME("restore from \"%s\" \"%s\"\n",
3682                lpSave->pszSubKey, lpSave->pszValueName);
3683
3684
3685     }
3686 #endif
3687
3688     return 0;
3689 }
3690
3691
3692 static LRESULT
3693 TOOLBAR_SetAnchorHighlight (HWND hwnd, WPARAM wParam)
3694 {
3695     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3696     BOOL bOldAnchor = infoPtr->bAnchor;
3697
3698     infoPtr->bAnchor = (BOOL)wParam;
3699
3700     return (LRESULT)bOldAnchor;
3701 }
3702
3703
3704 static LRESULT
3705 TOOLBAR_SetBitmapSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
3706 {
3707     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3708
3709     if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0))
3710         return FALSE;
3711
3712     if (infoPtr->nNumButtons > 0)
3713         WARN("%d buttons, undoc increase to bitmap size : %d-%d -> %d-%d\n",
3714              infoPtr->nNumButtons,
3715              infoPtr->nBitmapWidth, infoPtr->nBitmapHeight,
3716              LOWORD(lParam), HIWORD(lParam));
3717
3718     infoPtr->nBitmapWidth = (INT)LOWORD(lParam);
3719     infoPtr->nBitmapHeight = (INT)HIWORD(lParam);
3720
3721     /* uses image list internals directly */
3722     if (infoPtr->himlDef) {
3723         infoPtr->himlDef->cx = infoPtr->nBitmapWidth;
3724         infoPtr->himlDef->cy = infoPtr->nBitmapHeight;
3725     }
3726
3727     return TRUE;
3728 }
3729
3730
3731 static LRESULT
3732 TOOLBAR_SetButtonInfoA (HWND hwnd, WPARAM wParam, LPARAM lParam)
3733 {
3734     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3735     LPTBBUTTONINFOA lptbbi = (LPTBBUTTONINFOA)lParam;
3736     TBUTTON_INFO *btnPtr;
3737     INT nIndex;
3738
3739     if (lptbbi == NULL)
3740         return FALSE;
3741     if (lptbbi->cbSize < sizeof(TBBUTTONINFOA))
3742         return FALSE;
3743
3744     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam,
3745                                      lptbbi->dwMask & 0x80000000);
3746     if (nIndex == -1)
3747         return FALSE;
3748
3749     btnPtr = &infoPtr->buttons[nIndex];
3750     if (lptbbi->dwMask & TBIF_COMMAND)
3751         btnPtr->idCommand = lptbbi->idCommand;
3752     if (lptbbi->dwMask & TBIF_IMAGE)
3753         btnPtr->iBitmap = lptbbi->iImage;
3754     if (lptbbi->dwMask & TBIF_LPARAM)
3755         btnPtr->dwData = lptbbi->lParam;
3756 /*    if (lptbbi->dwMask & TBIF_SIZE) */
3757 /*      btnPtr->cx = lptbbi->cx; */
3758     if (lptbbi->dwMask & TBIF_STATE)
3759         btnPtr->fsState = lptbbi->fsState;
3760     if (lptbbi->dwMask & TBIF_STYLE)
3761         btnPtr->fsStyle = lptbbi->fsStyle;
3762
3763     if ((lptbbi->dwMask & TBIF_TEXT) && ((INT)lptbbi->pszText != -1)) {
3764         if ((HIWORD(btnPtr->iString) == 0) || (btnPtr->iString == -1))
3765             /* iString is index, zero it to make Str_SetPtr succeed */
3766             btnPtr->iString=0;
3767
3768          Str_SetPtrAtoW ((LPWSTR *)&btnPtr->iString, lptbbi->pszText);
3769     }
3770     return TRUE;
3771 }
3772
3773
3774 static LRESULT
3775 TOOLBAR_SetButtonInfoW (HWND hwnd, WPARAM wParam, LPARAM lParam)
3776 {
3777     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3778     LPTBBUTTONINFOW lptbbi = (LPTBBUTTONINFOW)lParam;
3779     TBUTTON_INFO *btnPtr;
3780     INT nIndex;
3781
3782     if (lptbbi == NULL)
3783         return FALSE;
3784     if (lptbbi->cbSize < sizeof(TBBUTTONINFOW))
3785         return FALSE;
3786
3787     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam,
3788                                      lptbbi->dwMask & 0x80000000);
3789     if (nIndex == -1)
3790         return FALSE;
3791
3792     btnPtr = &infoPtr->buttons[nIndex];
3793     if (lptbbi->dwMask & TBIF_COMMAND)
3794         btnPtr->idCommand = lptbbi->idCommand;
3795     if (lptbbi->dwMask & TBIF_IMAGE)
3796         btnPtr->iBitmap = lptbbi->iImage;
3797     if (lptbbi->dwMask & TBIF_LPARAM)
3798         btnPtr->dwData = lptbbi->lParam;
3799 /*    if (lptbbi->dwMask & TBIF_SIZE) */
3800 /*      btnPtr->cx = lptbbi->cx; */
3801     if (lptbbi->dwMask & TBIF_STATE)
3802         btnPtr->fsState = lptbbi->fsState;
3803     if (lptbbi->dwMask & TBIF_STYLE)
3804         btnPtr->fsStyle = lptbbi->fsStyle;
3805
3806     if ((lptbbi->dwMask & TBIF_TEXT) && ((INT)lptbbi->pszText != -1)) {
3807         if ((HIWORD(btnPtr->iString) == 0) || (btnPtr->iString == -1))
3808             /* iString is index, zero it to make Str_SetPtr succeed */
3809             btnPtr->iString=0;
3810         Str_SetPtrW ((LPWSTR *)&btnPtr->iString, lptbbi->pszText);
3811     }
3812     return TRUE;
3813 }
3814
3815
3816 static LRESULT
3817 TOOLBAR_SetButtonSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
3818 {
3819     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3820     INT cx = LOWORD(lParam), cy = HIWORD(lParam);
3821
3822     if ((cx < 0) || (cy < 0))
3823     {
3824         ERR("invalid parameter 0x%08lx\n", (DWORD)lParam);
3825         return FALSE;
3826     }
3827
3828     /* The documentation claims you can only change the button size before
3829      * any button has been added. But this is wrong.
3830      * WINZIP32.EXE (ver 8) calls this on one of its buttons after adding
3831      * it to the toolbar, and it checks that the return value is nonzero - mjm
3832      * Further testing shows that we must actually perform the change too.
3833      */
3834     /*
3835      * The documentation also does not mention that if 0 is supplied for
3836      * either size, the system changes it to the default of 24 wide and
3837      * 22 high. Demonstarted in ControlSpy Toolbar. GLA 3/02
3838      */
3839     infoPtr->nButtonWidth = (cx) ? cx : 24;
3840     infoPtr->nButtonHeight = (cy) ? cy : 22;
3841     return TRUE;
3842 }
3843
3844
3845 static LRESULT
3846 TOOLBAR_SetButtonWidth (HWND hwnd, WPARAM wParam, LPARAM lParam)
3847 {
3848     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3849
3850     if (infoPtr == NULL) {
3851         TRACE("Toolbar not initialized yet?????\n");
3852         return FALSE;
3853     }
3854
3855     /* if setting to current values, ignore */
3856     if ((infoPtr->cxMin == (INT)LOWORD(lParam)) &&
3857         (infoPtr->cxMax == (INT)HIWORD(lParam))) {
3858         TRACE("matches current width, min=%d, max=%d, no recalc\n",
3859               infoPtr->cxMin, infoPtr->cxMax);
3860         return TRUE;
3861     }
3862
3863     /* save new values */
3864     infoPtr->cxMin = (INT)LOWORD(lParam);
3865     infoPtr->cxMax = (INT)HIWORD(lParam);
3866
3867     /* if both values are 0 then we are done */
3868     if (lParam == 0) {
3869         TRACE("setting both min and max to 0, norecalc\n");
3870         return TRUE;
3871     }
3872
3873     /* otherwise we need to recalc the toolbar and in some cases
3874        recalc the bounding rectangle (does DrawText w/ DT_CALCRECT
3875        which doesn't actually draw - GA). */
3876     TRACE("number of buttons %d, cx=%d, cy=%d, recalcing\n",
3877         infoPtr->nNumButtons, infoPtr->cxMin, infoPtr->cxMax);
3878
3879     TOOLBAR_CalcToolbar (hwnd);
3880
3881     InvalidateRect (hwnd, NULL, TRUE);
3882
3883     return TRUE;
3884 }
3885
3886
3887 static LRESULT
3888 TOOLBAR_SetCmdId (HWND hwnd, WPARAM wParam, LPARAM lParam)
3889 {
3890     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3891     INT nIndex = (INT)wParam;
3892
3893     if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
3894         return FALSE;
3895
3896     infoPtr->buttons[nIndex].idCommand = (INT)lParam;
3897
3898     if (infoPtr->hwndToolTip) {
3899
3900         FIXME("change tool tip!\n");
3901
3902     }
3903
3904     return TRUE;
3905 }
3906
3907
3908 static LRESULT
3909 TOOLBAR_SetDisabledImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
3910 {
3911     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3912     HIMAGELIST himlTemp;
3913
3914
3915     if (wParam != 0) {
3916         FIXME("no support for multiple image lists\n");
3917         return 0;
3918     }
3919
3920     himlTemp = infoPtr->himlDis;
3921     infoPtr->himlDis = (HIMAGELIST)lParam;
3922
3923     /* FIXME: redraw ? */
3924
3925     return (LRESULT)himlTemp;
3926 }
3927
3928
3929 static LRESULT
3930 TOOLBAR_SetDrawTextFlags (HWND hwnd, WPARAM wParam, LPARAM lParam)
3931 {
3932     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3933     DWORD dwTemp;
3934
3935     dwTemp = infoPtr->dwDTFlags;
3936     infoPtr->dwDTFlags =
3937         (infoPtr->dwDTFlags & (DWORD)wParam) | (DWORD)lParam;
3938
3939     return (LRESULT)dwTemp;
3940 }
3941
3942 static LRESULT
3943 TOOLBAR_SetExtendedStyle (HWND hwnd, WPARAM wParam, LPARAM lParam)
3944 {
3945     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
3946     DWORD dwTemp;
3947
3948     dwTemp = infoPtr->dwExStyle;
3949     infoPtr->dwExStyle = (DWORD)lParam;
3950
3951     if (infoPtr->dwExStyle & (TBSTYLE_EX_MIXEDBUTTONS |
3952                               TBSTYLE_EX_HIDECLIPPEDBUTTONS)) {
3953         FIXME("Extended style not implemented %s %s\n",
3954               (infoPtr->dwExStyle & TBSTYLE_EX_MIXEDBUTTONS) ?
3955               "TBSTYLE_EX_MIXEDBUTTONS" : "",
3956               (infoPtr->dwExStyle & TBSTYLE_EX_HIDECLIPPEDBUTTONS) ?
3957               "TBSTYLE_EX_HIDECLIPPEDBUTTONS" : "");
3958     }
3959
3960     if (infoPtr->dwExStyle & ~TBSTYLE_EX_ALL)
3961         FIXME("Unknown Toolbar Extended Style 0x%08lx. Please report.\n",
3962               (infoPtr->dwExStyle & ~TBSTYLE_EX_ALL));
3963
3964     return (LRESULT)dwTemp;
3965 }
3966
3967
3968 static LRESULT
3969 TOOLBAR_SetHotImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
3970 {
3971     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
3972     HIMAGELIST himlTemp;
3973
3974     if (wParam != 0) {
3975         FIXME("no support for multiple image lists\n");
3976         return 0;
3977     }
3978
3979     himlTemp = infoPtr->himlHot;
3980     infoPtr->himlHot = (HIMAGELIST)lParam;
3981
3982     /* FIXME: redraw ? */
3983
3984     return (LRESULT)himlTemp;
3985 }
3986
3987
3988 static LRESULT
3989 TOOLBAR_SetHotItem (HWND hwnd, WPARAM wParam)
3990 {
3991     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
3992     INT nOldHotItem = infoPtr->nHotItem;
3993     TBUTTON_INFO *btnPtr;
3994
3995     if ((INT) wParam < 0 || (INT)wParam > infoPtr->nNumButtons)
3996         wParam = -2;
3997
3998     if (GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT)
3999     {
4000
4001         infoPtr->nHotItem = (INT)wParam;
4002         if ((INT)wParam >=0)
4003         {
4004             btnPtr = &infoPtr->buttons[(INT)wParam];
4005             btnPtr->bHot = TRUE;
4006                 InvalidateRect (hwnd, &btnPtr->rect,
4007                     TOOLBAR_HasText(infoPtr, btnPtr));
4008         }
4009         if (nOldHotItem>=0)
4010         {
4011             btnPtr = &infoPtr->buttons[nOldHotItem];
4012             btnPtr->bHot = FALSE;
4013                 InvalidateRect (hwnd, &btnPtr->rect,
4014                     TOOLBAR_HasText(infoPtr, btnPtr));
4015         }
4016     }
4017
4018     if (nOldHotItem < 0)
4019         return -1;
4020
4021     return (LRESULT)nOldHotItem;
4022 }
4023
4024
4025 static LRESULT
4026 TOOLBAR_SetImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
4027 {
4028     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4029     HIMAGELIST himlTemp;
4030
4031     if (wParam != 0) {
4032         FIXME("no support for multiple image lists\n");
4033         return 0;
4034     }
4035
4036     himlTemp = infoPtr->himlDef;
4037     infoPtr->himlDef = (HIMAGELIST)lParam;
4038
4039     infoPtr->nNumBitmaps = ImageList_GetImageCount(infoPtr->himlDef);
4040
4041     ImageList_GetIconSize(infoPtr->himlDef, &infoPtr->nBitmapWidth,
4042                           &infoPtr->nBitmapHeight);
4043     TRACE("hwnd %08x, new himl=%08x, count=%d, bitmap w=%d, h=%d\n",
4044           hwnd, (INT)infoPtr->himlDef, infoPtr->nNumBitmaps,
4045           infoPtr->nBitmapWidth, infoPtr->nBitmapHeight);
4046
4047     /* FIXME: redraw ? */
4048     InvalidateRect(hwnd, NULL, TRUE);
4049
4050     return (LRESULT)himlTemp;
4051 }
4052
4053
4054 static LRESULT
4055 TOOLBAR_SetIndent (HWND hwnd, WPARAM wParam, LPARAM lParam)
4056 {
4057     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4058
4059     infoPtr->nIndent = (INT)wParam;
4060
4061     TRACE("\n");
4062
4063     /* process only on indent changing */
4064     if(infoPtr->nIndent != (INT)wParam)
4065     {
4066         infoPtr->nIndent = (INT)wParam;
4067         TOOLBAR_CalcToolbar (hwnd);
4068         InvalidateRect(hwnd, NULL, FALSE);
4069     }
4070
4071     return TRUE;
4072 }
4073
4074
4075 /* << TOOLBAR_SetInsertMark >> */
4076
4077
4078 static LRESULT
4079 TOOLBAR_SetInsertMarkColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
4080 {
4081     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4082
4083     infoPtr->clrInsertMark = (COLORREF)lParam;
4084
4085     /* FIXME : redraw ??*/
4086
4087     return 0;
4088 }
4089
4090
4091 static LRESULT
4092 TOOLBAR_SetMaxTextRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
4093 {
4094     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4095
4096     if (infoPtr == NULL)
4097         return FALSE;
4098
4099     infoPtr->nMaxTextRows = (INT)wParam;
4100
4101     return TRUE;
4102 }
4103
4104
4105 static LRESULT
4106 TOOLBAR_SetPadding (HWND hwnd, WPARAM wParam, LPARAM lParam)
4107 {
4108     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4109     DWORD  oldPad;
4110
4111     oldPad = MAKELONG(infoPtr->szPadding.cx, infoPtr->szPadding.cy);
4112     infoPtr->szPadding.cx = LOWORD((DWORD)lParam);
4113     infoPtr->szPadding.cy = HIWORD((DWORD)lParam);
4114     FIXME("stub - nothing done with values, cx=%ld, cy=%ld\n",
4115           infoPtr->szPadding.cx, infoPtr->szPadding.cy);
4116     return (LRESULT) oldPad;
4117 }
4118
4119
4120 static LRESULT
4121 TOOLBAR_SetParent (HWND hwnd, WPARAM wParam, LPARAM lParam)
4122 {
4123     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4124     HWND hwndOldNotify;
4125
4126     TRACE("\n");
4127
4128     if (infoPtr == NULL)
4129         return 0;
4130     hwndOldNotify = infoPtr->hwndNotify;
4131     infoPtr->hwndNotify = (HWND)wParam;
4132
4133     return hwndOldNotify;
4134 }
4135
4136
4137 static LRESULT
4138 TOOLBAR_SetRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
4139 {
4140     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4141     LPRECT lprc = (LPRECT)lParam;
4142
4143     TRACE("\n");
4144
4145     if (LOWORD(wParam) > 1) {
4146         FIXME("multiple rows not supported!\n");
4147     }
4148
4149     if(infoPtr->nRows != LOWORD(wParam))
4150     {
4151         infoPtr->nRows = LOWORD(wParam);
4152
4153         /* recalculate toolbar */
4154         TOOLBAR_CalcToolbar (hwnd);
4155
4156         /* repaint toolbar */
4157         InvalidateRect(hwnd, NULL, FALSE);
4158     }
4159
4160     /* return bounding rectangle */
4161     if (lprc) {
4162         lprc->left   = infoPtr->rcBound.left;
4163         lprc->right  = infoPtr->rcBound.right;
4164         lprc->top    = infoPtr->rcBound.top;
4165         lprc->bottom = infoPtr->rcBound.bottom;
4166     }
4167
4168     return 0;
4169 }
4170
4171
4172 static LRESULT
4173 TOOLBAR_SetState (HWND hwnd, WPARAM wParam, LPARAM lParam)
4174 {
4175     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4176     TBUTTON_INFO *btnPtr;
4177     INT nIndex;
4178
4179     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
4180     if (nIndex == -1)
4181         return FALSE;
4182
4183     btnPtr = &infoPtr->buttons[nIndex];
4184
4185     /* if hidden state has changed the invalidate entire window and recalc */
4186     if ((btnPtr->fsState & TBSTATE_HIDDEN) != (LOWORD(lParam) & TBSTATE_HIDDEN)) {
4187         btnPtr->fsState = LOWORD(lParam);
4188         TOOLBAR_CalcToolbar (hwnd);
4189         InvalidateRect(hwnd, 0, TOOLBAR_HasText(infoPtr, btnPtr));
4190         return TRUE;
4191     }
4192
4193     /* process state changing if current state doesn't match new state */
4194     if(btnPtr->fsState != LOWORD(lParam))
4195     {
4196         btnPtr->fsState = LOWORD(lParam);
4197         InvalidateRect(hwnd, &btnPtr->rect, TOOLBAR_HasText(infoPtr,
4198             btnPtr));
4199     }
4200
4201     return TRUE;
4202 }
4203
4204
4205 static LRESULT
4206 TOOLBAR_SetStyle (HWND hwnd, WPARAM wParam, LPARAM lParam)
4207 {
4208     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4209     TBUTTON_INFO *btnPtr;
4210     INT nIndex;
4211
4212     nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam, FALSE);
4213     if (nIndex == -1)
4214         return FALSE;
4215
4216     btnPtr = &infoPtr->buttons[nIndex];
4217
4218     /* process style change if current style doesn't match new style */
4219     if(btnPtr->fsStyle != LOWORD(lParam))
4220     {
4221         btnPtr->fsStyle = LOWORD(lParam);
4222         InvalidateRect(hwnd, &btnPtr->rect, TOOLBAR_HasText(infoPtr,
4223             btnPtr));
4224
4225         if (infoPtr->hwndToolTip) {
4226             FIXME("change tool tip!\n");
4227         }
4228     }
4229
4230     return TRUE;
4231 }
4232
4233
4234 inline static LRESULT
4235 TOOLBAR_SetToolTips (HWND hwnd, WPARAM wParam, LPARAM lParam)
4236 {
4237     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4238
4239     if (infoPtr == NULL)
4240         return 0;
4241     infoPtr->hwndToolTip = (HWND)wParam;
4242     return 0;
4243 }
4244
4245
4246 static LRESULT
4247 TOOLBAR_SetUnicodeFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
4248 {
4249     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4250     BOOL bTemp;
4251
4252     TRACE("%s hwnd=0x%04x stub!\n",
4253            ((BOOL)wParam) ? "TRUE" : "FALSE", hwnd);
4254
4255     bTemp = infoPtr->bUnicode;
4256     infoPtr->bUnicode = (BOOL)wParam;
4257
4258     return bTemp;
4259 }
4260
4261
4262 static LRESULT
4263 TOOLBAR_GetColorScheme (HWND hwnd, LPCOLORSCHEME lParam)
4264 {
4265     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4266
4267     lParam->clrBtnHighlight = (infoPtr->clrBtnHighlight == CLR_DEFAULT) ?
4268                                comctl32_color.clrBtnHighlight :
4269                                infoPtr->clrBtnHighlight;
4270     lParam->clrBtnShadow = (infoPtr->clrBtnShadow == CLR_DEFAULT) ?
4271                            comctl32_color.clrBtnShadow : infoPtr->clrBtnShadow;
4272     return 1;
4273 }
4274
4275
4276 static LRESULT
4277 TOOLBAR_SetColorScheme (HWND hwnd, LPCOLORSCHEME lParam)
4278 {
4279     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4280
4281     TRACE("new colors Hl=%lx Shd=%lx, old colors Hl=%lx Shd=%lx\n",
4282           lParam->clrBtnHighlight, lParam->clrBtnShadow,
4283           infoPtr->clrBtnHighlight, infoPtr->clrBtnShadow);
4284
4285     infoPtr->clrBtnHighlight = lParam->clrBtnHighlight;
4286     infoPtr->clrBtnShadow = lParam->clrBtnShadow;
4287     InvalidateRect(hwnd, 0, 0);
4288     return 0;
4289 }
4290
4291
4292 static LRESULT
4293 TOOLBAR_SetVersion (HWND hwnd, INT iVersion)
4294 {
4295     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4296     INT iOldVersion = infoPtr->iVersion;
4297
4298     infoPtr->iVersion = iVersion;
4299
4300     return iOldVersion;
4301 }
4302
4303
4304 /*********************************************************************/
4305 /*                                                                   */
4306 /* This is undocumented and appears to be a "Super" TB_SETHOTITEM    */
4307 /* without the restriction of TBSTYLE_FLAT. This implementation is   */
4308 /* based on relay traces of the native control and IE 5.5            */
4309 /*                                                                   */
4310 /*********************************************************************/
4311 static LRESULT
4312 TOOLBAR_Unkwn45E (HWND hwnd, WPARAM wParam, LPARAM lParam)
4313 {
4314     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
4315     INT nOldHotItem = infoPtr->nHotItem;
4316     TBUTTON_INFO *btnPtr;
4317     INT no_hi = 0;
4318     NMTBHOTITEM nmhotitem;
4319
4320     if ((INT) wParam < 0 || (INT)wParam > infoPtr->nNumButtons)
4321         wParam = -2;
4322
4323     infoPtr->nHotItem = (INT)wParam;
4324     if (nOldHotItem != infoPtr->nHotItem) {
4325         nmhotitem.dwFlags = (DWORD)lParam;
4326         if ( !(nmhotitem.dwFlags & HICF_ENTERING) )
4327             nmhotitem.idOld = (nOldHotItem >= 0) ?
4328                 infoPtr->buttons[nOldHotItem].idCommand : 0;
4329         if ( !(nmhotitem.dwFlags & HICF_LEAVING) )
4330             nmhotitem.idNew = (infoPtr->nHotItem >= 0) ?
4331                 infoPtr->buttons[infoPtr->nHotItem].idCommand : 0;
4332         no_hi = TOOLBAR_SendNotify((NMHDR*)&nmhotitem, infoPtr, TBN_HOTITEMCHANGE);
4333     }
4334     if ((INT)wParam >=0) {
4335         btnPtr = &infoPtr->buttons[(INT)wParam];
4336         btnPtr->bHot = (no_hi) ? FALSE : TRUE;
4337         InvalidateRect (hwnd, &btnPtr->rect,
4338                         TOOLBAR_HasText(infoPtr, btnPtr));
4339     }
4340     if (nOldHotItem>=0) {
4341         btnPtr = &infoPtr->buttons[nOldHotItem];
4342         btnPtr->bHot = FALSE;
4343         InvalidateRect (hwnd, &btnPtr->rect,
4344                         TOOLBAR_HasText(infoPtr, btnPtr));
4345     }
4346     GetFocus();
4347     TRACE("old item=%d, new item=%d, flags=%08lx, notify=%d\n",
4348           nOldHotItem, infoPtr->nHotItem, (DWORD)lParam, no_hi);
4349
4350     if (nOldHotItem < 0)
4351         return -1;
4352
4353     return (LRESULT)nOldHotItem;
4354 }
4355
4356
4357 static LRESULT
4358 TOOLBAR_Unkwn463 (HWND hwnd, WPARAM wParam, LPARAM lParam)
4359 {
4360     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4361     LPSIZE lpsize = (LPSIZE)lParam;
4362
4363     if (lpsize == NULL)
4364         return FALSE;
4365
4366     /*
4367      * Testing shows the following:
4368      *   wParam    = 0 adjust cx value
4369      *             = 1 set cy value to max size.
4370      *   lParam    pointer to SIZE structure
4371      *
4372      */
4373     TRACE("[0463] wParam %d, lParam 0x%08lx -> 0x%08lx 0x%08lx\n",
4374           wParam, lParam, lpsize->cx, lpsize->cy);
4375
4376     switch(wParam) {
4377     case 0:
4378         if (lpsize->cx == -1) {
4379             /* **** this is wrong, native measures each button and sets it */
4380             lpsize->cx = infoPtr->rcBound.right - infoPtr->rcBound.left;
4381         }
4382         else if(HIWORD(lpsize->cx)) {
4383             RECT rc;
4384             HWND hwndParent = GetParent(hwnd);
4385
4386             InvalidateRect(hwnd, 0, 1);
4387             GetWindowRect(hwnd, &rc);
4388             MapWindowPoints(0, hwndParent, (LPPOINT)&rc, 2);
4389             TRACE("mapped to (%d,%d)-(%d,%d)\n",
4390                 rc.left, rc.top, rc.right, rc.bottom);
4391             lpsize->cx = max(rc.right-rc.left,
4392                              infoPtr->rcBound.right - infoPtr->rcBound.left);
4393         }
4394         else {
4395             lpsize->cx = infoPtr->rcBound.right - infoPtr->rcBound.left;
4396         }
4397         break;
4398     case 1:
4399         lpsize->cy = infoPtr->rcBound.bottom - infoPtr->rcBound.top;
4400         /* lpsize->cy = infoPtr->nHeight; */
4401         break;
4402     default:
4403         ERR("Unknown wParam %d for Toolbar message [0463]. Please report\n",
4404             wParam);
4405         return 0;
4406     }
4407     TRACE("[0463] set to -> 0x%08lx 0x%08lx\n",
4408           lpsize->cx, lpsize->cy);
4409     return 1;
4410 }
4411
4412
4413 static LRESULT
4414 TOOLBAR_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
4415 {
4416     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4417     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
4418     LOGFONTA logFont;
4419
4420     /* initialize info structure */
4421     infoPtr->nButtonHeight = 22;
4422     infoPtr->nButtonWidth = 24;
4423     infoPtr->nBitmapHeight = 15;
4424     infoPtr->nBitmapWidth = 16;
4425
4426     infoPtr->nHeight = infoPtr->nButtonHeight + TOP_BORDER + BOTTOM_BORDER;
4427     infoPtr->nRows = 1;
4428     infoPtr->nMaxTextRows = 1;
4429     infoPtr->cxMin = -1;
4430     infoPtr->cxMax = -1;
4431     infoPtr->nNumBitmaps = 0;
4432     infoPtr->nNumStrings = 0;
4433
4434     infoPtr->bCaptured = FALSE;
4435     infoPtr->bUnicode = IsWindowUnicode (hwnd);
4436     infoPtr->nButtonDown = -1;
4437     infoPtr->nOldHit = -1;
4438     infoPtr->nHotItem = -2; /* It has to be initially different from nOldHit */
4439     infoPtr->hwndNotify = GetParent (hwnd);
4440     infoPtr->bTransparent = (dwStyle & TBSTYLE_TRANSPARENT);
4441     infoPtr->bBtnTranspnt = (dwStyle & (TBSTYLE_FLAT | TBSTYLE_LIST));
4442     infoPtr->dwDTFlags = (dwStyle & TBSTYLE_LIST) ? DT_LEFT | DT_VCENTER | DT_SINGLELINE : DT_CENTER;
4443     infoPtr->bAnchor = FALSE; /* no anchor highlighting */
4444     infoPtr->iVersion = 0;
4445     infoPtr->hwndSelf = hwnd;
4446     infoPtr->bDoRedraw = TRUE;
4447     infoPtr->clrBtnHighlight = CLR_DEFAULT;
4448     infoPtr->clrBtnShadow = CLR_DEFAULT;
4449     infoPtr->szPadding.cx = 7;
4450     infoPtr->szPadding.cy = 6;
4451     TOOLBAR_NotifyFormat(infoPtr, (WPARAM)hwnd, (LPARAM)NF_REQUERY);
4452
4453     SystemParametersInfoA (SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
4454     infoPtr->hFont = infoPtr->hDefaultFont = CreateFontIndirectA (&logFont);
4455
4456     if (dwStyle & TBSTYLE_TOOLTIPS) {
4457         /* Create tooltip control */
4458         infoPtr->hwndToolTip =
4459             CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
4460                                CW_USEDEFAULT, CW_USEDEFAULT,
4461                                CW_USEDEFAULT, CW_USEDEFAULT,
4462                                hwnd, 0, 0, 0);
4463
4464         /* Send NM_TOOLTIPSCREATED notification */
4465         if (infoPtr->hwndToolTip) {
4466             NMTOOLTIPSCREATED nmttc;
4467
4468             nmttc.hwndToolTips = infoPtr->hwndToolTip;
4469
4470             TOOLBAR_SendNotify ((NMHDR *) &nmttc, infoPtr,
4471                             NM_TOOLTIPSCREATED);
4472         }
4473     }
4474
4475     TOOLBAR_CheckStyle (hwnd, dwStyle);
4476
4477     TOOLBAR_CalcToolbar(hwnd);
4478
4479     return 0;
4480 }
4481
4482
4483 static LRESULT
4484 TOOLBAR_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
4485 {
4486     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4487
4488     /* delete tooltip control */
4489     if (infoPtr->hwndToolTip)
4490         DestroyWindow (infoPtr->hwndToolTip);
4491
4492     /* delete button data */
4493     if (infoPtr->buttons)
4494         COMCTL32_Free (infoPtr->buttons);
4495
4496     /* delete strings */
4497     if (infoPtr->strings) {
4498         INT i;
4499         for (i = 0; i < infoPtr->nNumStrings; i++)
4500             if (infoPtr->strings[i])
4501                 COMCTL32_Free (infoPtr->strings[i]);
4502
4503         COMCTL32_Free (infoPtr->strings);
4504     }
4505
4506     /* destroy internal image list */
4507     if (infoPtr->himlInt)
4508         ImageList_Destroy (infoPtr->himlInt);
4509
4510     /* delete default font */
4511     if (infoPtr->hFont)
4512         DeleteObject (infoPtr->hDefaultFont);
4513
4514     /* free toolbar info data */
4515     COMCTL32_Free (infoPtr);
4516     SetWindowLongA (hwnd, 0, 0);
4517
4518     return 0;
4519 }
4520
4521
4522 static LRESULT
4523 TOOLBAR_EraseBackground (HWND hwnd, WPARAM wParam, LPARAM lParam)
4524 {
4525     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4526     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
4527     NMTBCUSTOMDRAW tbcd;
4528     INT ret = FALSE;
4529     DWORD ntfret;
4530
4531     if (dwStyle & TBSTYLE_CUSTOMERASE) {
4532         ZeroMemory (&tbcd, sizeof(NMTBCUSTOMDRAW));
4533         tbcd.nmcd.dwDrawStage = CDDS_PREERASE;
4534         tbcd.nmcd.hdc = (HDC)wParam;
4535         ntfret = TOOLBAR_SendNotify ((NMHDR *)&tbcd, infoPtr, NM_CUSTOMDRAW);
4536         infoPtr->dwBaseCustDraw = ntfret & 0xffff;
4537
4538         /* FIXME: in general the return flags *can* be or'ed together */
4539         switch (infoPtr->dwBaseCustDraw)
4540             {
4541             case CDRF_DODEFAULT:
4542                 break;
4543             case CDRF_SKIPDEFAULT:
4544                 return TRUE;
4545             default:
4546                 FIXME("[%04x] response %ld not handled to NM_CUSTOMDRAW (CDDS_PREERASE)\n",
4547                       hwnd, ntfret);
4548             }
4549     }
4550
4551     /* If the toolbar is "transparent" then pass the WM_ERASEBKGND up
4552      * to my parent for processing.
4553      */
4554     if (infoPtr->bTransparent) {
4555         POINT pt, ptorig;
4556         HDC hdc = (HDC)wParam;
4557         HWND parent;
4558
4559         pt.x = 0;
4560         pt.y = 0;
4561         parent = GetParent(hwnd);
4562         MapWindowPoints(hwnd, parent, &pt, 1);
4563         OffsetWindowOrgEx (hdc, pt.x, pt.y, &ptorig);
4564         ret = SendMessageA (parent, WM_ERASEBKGND, wParam, lParam);
4565         SetWindowOrgEx (hdc, ptorig.x, ptorig.y, 0);
4566     }
4567     if (!ret)
4568         ret = DefWindowProcA (hwnd, WM_ERASEBKGND, wParam, lParam);
4569
4570     if ((dwStyle & TBSTYLE_CUSTOMERASE) &&
4571         (infoPtr->dwBaseCustDraw & CDRF_NOTIFYPOSTERASE)) {
4572         ZeroMemory (&tbcd, sizeof(NMTBCUSTOMDRAW));
4573         tbcd.nmcd.dwDrawStage = CDDS_POSTERASE;
4574         tbcd.nmcd.hdc = (HDC)wParam;
4575         ntfret = TOOLBAR_SendNotify ((NMHDR *)&tbcd, infoPtr, NM_CUSTOMDRAW);
4576         infoPtr->dwBaseCustDraw = ntfret & 0xffff;
4577         switch (infoPtr->dwBaseCustDraw)
4578             {
4579             case CDRF_DODEFAULT:
4580                 break;
4581             case CDRF_SKIPDEFAULT:
4582                 return TRUE;
4583             default:
4584                 FIXME("[%04x] response %ld not handled to NM_CUSTOMDRAW (CDDS_PREERASE)\n",
4585                       hwnd, ntfret);
4586             }
4587     }
4588     return ret;
4589 }
4590
4591
4592 static LRESULT
4593 TOOLBAR_GetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
4594 {
4595     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4596
4597     return infoPtr->hFont;
4598 }
4599
4600
4601 static LRESULT
4602 TOOLBAR_LButtonDblClk (HWND hwnd, WPARAM wParam, LPARAM lParam)
4603 {
4604     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4605     TBUTTON_INFO *btnPtr;
4606     POINT pt;
4607     INT   nHit;
4608
4609     pt.x = (INT)LOWORD(lParam);
4610     pt.y = (INT)HIWORD(lParam);
4611     nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
4612
4613     if (nHit >= 0) {
4614         btnPtr = &infoPtr->buttons[nHit];
4615         if (!(btnPtr->fsState & TBSTATE_ENABLED))
4616             return 0;
4617         SetCapture (hwnd);
4618         infoPtr->bCaptured = TRUE;
4619         infoPtr->nButtonDown = nHit;
4620
4621         btnPtr->fsState |= TBSTATE_PRESSED;
4622
4623         InvalidateRect(hwnd, &btnPtr->rect, TOOLBAR_HasText(infoPtr,
4624             btnPtr));
4625     }
4626     else if (GetWindowLongA (hwnd, GWL_STYLE) & CCS_ADJUSTABLE)
4627         TOOLBAR_Customize (hwnd);
4628
4629     return 0;
4630 }
4631
4632
4633 static LRESULT
4634 TOOLBAR_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
4635 {
4636     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4637     TBUTTON_INFO *btnPtr;
4638     POINT pt;
4639     INT   nHit;
4640     NMTOOLBARA nmtb;
4641
4642     if (infoPtr->hwndToolTip)
4643         TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
4644                             WM_LBUTTONDOWN, wParam, lParam);
4645
4646     pt.x = (INT)LOWORD(lParam);
4647     pt.y = (INT)HIWORD(lParam);
4648     nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
4649
4650     if (nHit >= 0) {
4651         RECT arrowRect;
4652         btnPtr = &infoPtr->buttons[nHit];
4653         if (!(btnPtr->fsState & TBSTATE_ENABLED))
4654             return 0;
4655
4656         infoPtr->nOldHit = nHit;
4657
4658         CopyRect(&arrowRect, &btnPtr->rect);
4659         arrowRect.left = max(btnPtr->rect.left, btnPtr->rect.right - DDARROW_WIDTH);
4660
4661         /* for EX_DRAWDDARROWS style,  click must be in the drop-down arrow rect */
4662         if ((btnPtr->fsStyle & TBSTYLE_DROPDOWN) &&
4663              ((TOOLBAR_HasDropDownArrows(infoPtr->dwExStyle) && PtInRect(&arrowRect, pt)) ||
4664               (!TOOLBAR_HasDropDownArrows(infoPtr->dwExStyle))))
4665         {
4666             LRESULT res;
4667             /*
4668              * this time we must force a Redraw, so the btn is
4669              * painted down before CaptureChanged repaints it up
4670              */
4671             RedrawWindow(hwnd,&btnPtr->rect,0,
4672                         RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW);
4673
4674             nmtb.iItem = btnPtr->idCommand;
4675             memset(&nmtb.tbButton, 0, sizeof(TBBUTTON));
4676             nmtb.cchText = 0;
4677             nmtb.pszText = 0;
4678             memset(&nmtb.rcButton, 0, sizeof(RECT));
4679             res = TOOLBAR_SendNotify ((NMHDR *) &nmtb, infoPtr,
4680                                   TBN_DROPDOWN);
4681             if (res != TBDDRET_TREATPRESSED)
4682                 /* ??? guess  (GA)  */
4683                 return 0;
4684             /* otherwise drop through and process as pushed */
4685         }
4686         /* SetCapture (hwnd); */
4687         infoPtr->bCaptured = TRUE;
4688         infoPtr->nButtonDown = nHit;
4689
4690         btnPtr->fsState |= TBSTATE_PRESSED;
4691         btnPtr->bHot = FALSE;
4692
4693         InvalidateRect(hwnd, &btnPtr->rect,
4694                        TOOLBAR_HasText(infoPtr, btnPtr));
4695         UpdateWindow(hwnd);
4696         SetCapture (hwnd);
4697
4698         /* native issues the TBN_BEGINDRAG here */
4699         nmtb.iItem = btnPtr->idCommand;
4700         nmtb.tbButton.iBitmap = btnPtr->iBitmap;
4701         nmtb.tbButton.idCommand = btnPtr->idCommand;
4702         nmtb.tbButton.fsState = btnPtr->fsState;
4703         nmtb.tbButton.fsStyle = btnPtr->fsStyle;
4704         nmtb.tbButton.dwData = btnPtr->dwData;
4705         nmtb.tbButton.iString = btnPtr->iString;
4706         nmtb.cchText = 0;  /* !!! not correct */
4707         nmtb.pszText = 0;  /* !!! not correct */
4708         TOOLBAR_SendNotify ((NMHDR *) &nmtb, infoPtr,
4709                         TBN_BEGINDRAG);
4710     }
4711
4712     return 0;
4713 }
4714
4715 static LRESULT
4716 TOOLBAR_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
4717 {
4718     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4719     TBUTTON_INFO *btnPtr;
4720     POINT pt;
4721     INT   nHit;
4722     INT   nOldIndex = -1;
4723     BOOL  bSendMessage = TRUE;
4724     NMHDR hdr;
4725     NMMOUSE nmmouse;
4726     NMTOOLBARA nmtb;
4727
4728     if (infoPtr->hwndToolTip)
4729         TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
4730                             WM_LBUTTONUP, wParam, lParam);
4731
4732     pt.x = (INT)LOWORD(lParam);
4733     pt.y = (INT)HIWORD(lParam);
4734     nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
4735
4736     /* restore hot effect to hot button disabled by TOOLBAR_LButtonDown() */
4737     /* if the cursor is still inside of the toolbar */
4738     if((infoPtr->nHotItem >= 0) && (nHit != -1))
4739         infoPtr->buttons[infoPtr->nHotItem].bHot = TRUE;
4740
4741         btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
4742         btnPtr->fsState &= ~TBSTATE_PRESSED;
4743
4744         if (btnPtr->fsStyle & TBSTYLE_CHECK) {
4745                 if (btnPtr->fsStyle & TBSTYLE_GROUP) {
4746                     nOldIndex = TOOLBAR_GetCheckedGroupButtonIndex (infoPtr,
4747                         nHit);
4748                     if (nOldIndex == nHit)
4749                         bSendMessage = FALSE;
4750                     if ((nOldIndex != nHit) &&
4751                         (nOldIndex != -1))
4752                         infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
4753                     btnPtr->fsState |= TBSTATE_CHECKED;
4754                 }
4755                 else {
4756                     if (btnPtr->fsState & TBSTATE_CHECKED)
4757                         btnPtr->fsState &= ~TBSTATE_CHECKED;
4758                     else
4759                         btnPtr->fsState |= TBSTATE_CHECKED;
4760                 }
4761         }
4762
4763         if (nOldIndex != -1)
4764         {
4765             InvalidateRect(hwnd, &infoPtr->buttons[nOldIndex].rect,
4766                 TOOLBAR_HasText(infoPtr, &infoPtr->buttons[nOldIndex]));
4767         }
4768
4769         /*
4770          * now we can ReleaseCapture, which triggers CAPTURECHANGED msg,
4771          * that resets bCaptured and btn TBSTATE_PRESSED flags,
4772          * and obliterates nButtonDown and nOldHit (see TOOLBAR_CaptureChanged)
4773          */
4774         if ((infoPtr->bCaptured) && (infoPtr->nButtonDown >= 0))
4775             ReleaseCapture ();
4776
4777         /* Issue NM_RELEASEDCAPTURE to parent to let him know it is released */
4778         TOOLBAR_SendNotify ((NMHDR *) &hdr, infoPtr,
4779                         NM_RELEASEDCAPTURE);
4780
4781         /* native issues TBN_ENDDRAG here, if _LBUTTONDOWN issued the
4782          * TBN_BEGINDRAG
4783          */
4784         nmtb.iItem = btnPtr->idCommand;
4785         nmtb.tbButton.iBitmap = btnPtr->iBitmap;
4786         nmtb.tbButton.idCommand = btnPtr->idCommand;
4787         nmtb.tbButton.fsState = btnPtr->fsState;
4788         nmtb.tbButton.fsStyle = btnPtr->fsStyle;
4789         nmtb.tbButton.dwData = btnPtr->dwData;
4790         nmtb.tbButton.iString = btnPtr->iString;
4791         nmtb.cchText = 0;  /* !!! not correct */
4792         nmtb.pszText = 0;  /* !!! not correct */
4793         TOOLBAR_SendNotify ((NMHDR *) &nmtb, infoPtr,
4794                         TBN_ENDDRAG);
4795
4796         SendMessageA (infoPtr->hwndNotify, WM_COMMAND,
4797           MAKEWPARAM(infoPtr->buttons[nHit].idCommand, 0), (LPARAM)hwnd);
4798
4799         /* !!! Undocumented - toolbar at 4.71 level and above sends
4800          * either NMRCLICK or NM_CLICK with the NMMOUSE structure.
4801          * Only NM_RCLICK is documented.
4802          */
4803         nmmouse.dwItemSpec = btnPtr->idCommand;
4804         nmmouse.dwItemData = btnPtr->dwData;
4805         TOOLBAR_SendNotify ((NMHDR *) &nmmouse, infoPtr,
4806                         NM_CLICK);
4807     return 0;
4808 }
4809
4810 static LRESULT
4811 TOOLBAR_CaptureChanged(HWND hwnd)
4812 {
4813     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4814     TBUTTON_INFO *btnPtr;
4815
4816     infoPtr->bCaptured = FALSE;
4817
4818     if (infoPtr->nButtonDown >= 0)
4819     {
4820         btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
4821         btnPtr->fsState &= ~TBSTATE_PRESSED;
4822
4823         infoPtr->nButtonDown = -1;
4824         infoPtr->nOldHit = -1;
4825
4826         InvalidateRect(hwnd, &btnPtr->rect, TOOLBAR_HasText(infoPtr,
4827             btnPtr));
4828     }
4829     return 0;
4830 }
4831
4832 static LRESULT
4833 TOOLBAR_MouseLeave (HWND hwnd, WPARAM wParam, LPARAM lParam)
4834 {
4835     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4836     TBUTTON_INFO *hotBtnPtr, *btnPtr;
4837     RECT rc1;
4838
4839     if (infoPtr->nOldHit < 0)
4840       return TRUE;
4841
4842     hotBtnPtr = &infoPtr->buttons[infoPtr->nOldHit];
4843
4844     /* Redraw the button if the last button we were over is the hot button and it
4845        is enabled */
4846     if((infoPtr->nOldHit == infoPtr->nHotItem) && (hotBtnPtr->fsState & TBSTATE_ENABLED))
4847     {
4848         hotBtnPtr->bHot = FALSE;
4849         rc1 = hotBtnPtr->rect;
4850         InflateRect (&rc1, 1, 1);
4851         InvalidateRect (hwnd, &rc1, TOOLBAR_HasText(infoPtr,
4852             hotBtnPtr));
4853     }
4854
4855     /* If the last button we were over is depressed then make it not */
4856     /* depressed and redraw it */
4857     if(infoPtr->nOldHit == infoPtr->nButtonDown)
4858     {
4859       btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
4860
4861       btnPtr->fsState &= ~TBSTATE_PRESSED;
4862
4863       rc1 = hotBtnPtr->rect;
4864       InflateRect (&rc1, 1, 1);
4865       InvalidateRect (hwnd, &rc1, TRUE);
4866     }
4867
4868     infoPtr->nOldHit = -1; /* reset the old hit index as we've left the toolbar */
4869     infoPtr->nHotItem = -2; /* It has to be initially different from nOldHit */
4870
4871     return TRUE;
4872 }
4873
4874 static LRESULT
4875 TOOLBAR_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
4876 {
4877     TBUTTON_INFO *btnPtr = NULL, *oldBtnPtr = NULL;
4878     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
4879     POINT pt;
4880     INT   nHit;
4881     TRACKMOUSEEVENT trackinfo;
4882     NMTBHOTITEM nmhotitem;
4883
4884     /* fill in the TRACKMOUSEEVENT struct */
4885     trackinfo.cbSize = sizeof(TRACKMOUSEEVENT);
4886     trackinfo.dwFlags = TME_QUERY;
4887     trackinfo.hwndTrack = hwnd;
4888     trackinfo.dwHoverTime = HOVER_DEFAULT;
4889
4890     /* call _TrackMouseEvent to see if we are currently tracking for this hwnd */
4891     _TrackMouseEvent(&trackinfo);
4892
4893     /* Make sure tracking is enabled so we receive a WM_MOUSELEAVE message */
4894     if(!(trackinfo.dwFlags & TME_LEAVE)) {
4895         trackinfo.dwFlags = TME_LEAVE; /* notify upon leaving */
4896
4897         /* call TRACKMOUSEEVENT so we receive a WM_MOUSELEAVE message */
4898         /* and can properly deactivate the hot toolbar button */
4899         _TrackMouseEvent(&trackinfo);
4900    }
4901
4902     if (infoPtr->hwndToolTip)
4903         TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
4904                             WM_MOUSEMOVE, wParam, lParam);
4905
4906     pt.x = (INT)LOWORD(lParam);
4907     pt.y = (INT)HIWORD(lParam);
4908
4909     nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
4910
4911     if (infoPtr->nOldHit != nHit)
4912     {
4913         /* Remove the effect of an old hot button if the button was enabled and was
4914            drawn with the hot button effect */
4915         if(infoPtr->nOldHit >= 0 && infoPtr->nOldHit == infoPtr->nHotItem &&
4916                 (infoPtr->buttons[infoPtr->nOldHit].fsState & TBSTATE_ENABLED))
4917         {
4918             oldBtnPtr = &infoPtr->buttons[infoPtr->nOldHit];
4919             oldBtnPtr->bHot = FALSE;
4920         }
4921
4922         /* It's not a separator or in nowhere. It's a hot button. */
4923         if (nHit >= 0)
4924         {
4925             btnPtr = &infoPtr->buttons[nHit];
4926
4927             infoPtr->nHotItem = nHit;
4928
4929             /* only enabled buttons show hot effect */
4930             if(infoPtr->buttons[nHit].fsState & TBSTATE_ENABLED)
4931             {
4932                 btnPtr->bHot = TRUE;
4933             }
4934         }
4935
4936         nmhotitem.dwFlags = HICF_MOUSE;
4937         if (oldBtnPtr)
4938             nmhotitem.idOld = oldBtnPtr->idCommand;
4939         else
4940             nmhotitem.dwFlags |= HICF_ENTERING;
4941         if (btnPtr)
4942             nmhotitem.idNew = btnPtr->idCommand;
4943         else
4944             nmhotitem.dwFlags |= HICF_LEAVING;
4945         TOOLBAR_SendNotify((NMHDR*)&nmhotitem, infoPtr, TBN_HOTITEMCHANGE);
4946
4947         /* now invalidate the old and new buttons so they will be painted */
4948         if (oldBtnPtr)
4949             InvalidateRect (hwnd, &oldBtnPtr->rect,
4950                             TOOLBAR_HasText(infoPtr, oldBtnPtr));
4951         if (btnPtr && (btnPtr->fsState & TBSTATE_ENABLED))
4952             InvalidateRect(hwnd, &btnPtr->rect,
4953                            TOOLBAR_HasText(infoPtr, btnPtr));
4954
4955         if (infoPtr->bCaptured) {
4956             btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
4957             if (infoPtr->nOldHit == infoPtr->nButtonDown) {
4958                 btnPtr->fsState &= ~TBSTATE_PRESSED;
4959                 InvalidateRect(hwnd, &btnPtr->rect, TRUE);
4960             }
4961             else if (nHit == infoPtr->nButtonDown) {
4962                 btnPtr->fsState |= TBSTATE_PRESSED;
4963                 InvalidateRect(hwnd, &btnPtr->rect, TRUE);
4964             }
4965         }
4966         infoPtr->nOldHit = nHit;
4967     }
4968     return 0;
4969 }
4970
4971
4972 inline static LRESULT
4973 TOOLBAR_NCActivate (HWND hwnd, WPARAM wParam, LPARAM lParam)
4974 {
4975 /*    if (wndPtr->dwStyle & CCS_NODIVIDER) */
4976         return DefWindowProcA (hwnd, WM_NCACTIVATE, wParam, lParam);
4977 /*    else */
4978 /*      return TOOLBAR_NCPaint (wndPtr, wParam, lParam); */
4979 }
4980
4981
4982 inline static LRESULT
4983 TOOLBAR_NCCalcSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
4984 {
4985     if (!(GetWindowLongA (hwnd, GWL_STYLE) & CCS_NODIVIDER))
4986         ((LPRECT)lParam)->top += GetSystemMetrics(SM_CYEDGE);
4987
4988     return DefWindowProcA (hwnd, WM_NCCALCSIZE, wParam, lParam);
4989 }
4990
4991
4992 static LRESULT
4993 TOOLBAR_NCCreate (HWND hwnd, WPARAM wParam, LPARAM lParam)
4994 {
4995     TOOLBAR_INFO *infoPtr;
4996     LPCREATESTRUCTA cs = (LPCREATESTRUCTA)lParam;
4997     DWORD styleadd = 0;
4998
4999     /* allocate memory for info structure */
5000     infoPtr = (TOOLBAR_INFO *)COMCTL32_Alloc (sizeof(TOOLBAR_INFO));
5001     SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
5002
5003     /* paranoid!! */
5004     infoPtr->dwStructSize = sizeof(TBBUTTON);
5005
5006     /* fix instance handle, if the toolbar was created by CreateToolbarEx() */
5007     if (!GetWindowLongA (hwnd, GWL_HINSTANCE)) {
5008         HINSTANCE hInst = (HINSTANCE)GetWindowLongA (GetParent (hwnd), GWL_HINSTANCE);
5009         SetWindowLongA (hwnd, GWL_HINSTANCE, (DWORD)hInst);
5010     }
5011
5012     /* native control does:
5013      *    Get a lot of colors and brushes
5014      *    WM_NOTIFYFORMAT
5015      *    SystemParametersInfoA(0x1f, 0x3c, adr1, 0)
5016      *    CreateFontIndirectA(adr1)
5017      *    CreateBitmap(0x27, 0x24, 1, 1, 0)
5018      *    hdc = GetDC(toolbar)
5019      *    GetSystemMetrics(0x48)
5020      *    fnt2=CreateFontA(0xe, 0, 0, 0, 0x190, 0, 0, 0, 0, 2,
5021      *                     0, 0, 0, 0, "MARLETT")
5022      *    oldfnt = SelectObject(hdc, fnt2)
5023      *    GetCharWidthA(hdc, 0x36, 0x36, adr2)
5024      *    GetTextMetricsA(hdc, adr3)
5025      *    SelectObject(hdc, oldfnt)
5026      *    DeleteObject(fnt2)
5027      *    ReleaseDC(hdc)
5028      *    InvalidateRect(toolbar, 0, 1)
5029      *    SetWindowLongA(toolbar, 0, addr)
5030      *    SetWindowLongA(toolbar, -16, xxx)  **sometimes**
5031      *                                          WM_STYLECHANGING
5032      *                             CallWinEx   old         new
5033      *                       ie 1  0x56000a4c  0x46000a4c  0x56008a4d
5034      *                       ie 2  0x4600094c  0x4600094c  0x4600894d
5035      *                       ie 3  0x56000b4c  0x46000b4c  0x56008b4d
5036      *                      rebar  0x50008844  0x40008844  0x50008845
5037      *                      pager  0x50000844  0x40000844  0x50008845
5038      *                    IC35mgr  0x5400084e  **nochange**
5039      *           on entry to _NCCREATE         0x5400084e
5040      *                    rowlist  0x5400004e  **nochange**
5041      *           on entry to _NCCREATE         0x5400004e
5042      *
5043      */
5044
5045     /* I think the code below is a bug, but it is the way that the native
5046      * controls seem to work. The effect is that if the user of TBSTYLE_FLAT
5047      * forgets to specify TBSTYLE_TRANSPARENT but does specify either
5048      * CCS_TOP or CCS_BOTTOM (_NOMOVEY and _TOP), then the control
5049      * does *not* set TBSTYLE_TRANSPARENT even though it should!!!!
5050      * Some how, the only cases of this seem to be MFC programs.
5051      *
5052      * Note also that the addition of _TRANSPARENT occurs *only* here. It
5053      * does not occur in the WM_STYLECHANGING routine.
5054      *    (Guy Albertelli   9/2001)
5055      *
5056      */
5057     if ((cs->style & TBSTYLE_FLAT) && !(cs->style & TBSTYLE_TRANSPARENT))
5058         styleadd |= TBSTYLE_TRANSPARENT;
5059     if (!(cs->style & (CCS_TOP | CCS_NOMOVEY))) {
5060         styleadd |= CCS_TOP;   /* default to top */
5061         SetWindowLongA (hwnd, GWL_STYLE, cs->style | styleadd);
5062     }
5063
5064     return DefWindowProcA (hwnd, WM_NCCREATE, wParam, lParam);
5065 }
5066
5067
5068 static LRESULT
5069 TOOLBAR_NCPaint (HWND hwnd, WPARAM wParam, LPARAM lParam)
5070 {
5071     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
5072     RECT rcWindow;
5073     HDC hdc;
5074
5075     if (dwStyle & WS_MINIMIZE)
5076         return 0; /* Nothing to do */
5077
5078     DefWindowProcA (hwnd, WM_NCPAINT, wParam, lParam);
5079
5080     if (!(hdc = GetDCEx (hwnd, 0, DCX_USESTYLE | DCX_WINDOW)))
5081         return 0;
5082
5083     if (!(dwStyle & CCS_NODIVIDER))
5084     {
5085         GetWindowRect (hwnd, &rcWindow);
5086         OffsetRect (&rcWindow, -rcWindow.left, -rcWindow.top);
5087         if( dwStyle & WS_BORDER )
5088             OffsetRect (&rcWindow, 1, 1);
5089         DrawEdge (hdc, &rcWindow, EDGE_ETCHED, BF_TOP);
5090     }
5091
5092     ReleaseDC( hwnd, hdc );
5093
5094     return 0;
5095 }
5096
5097
5098 inline static LRESULT
5099 TOOLBAR_Notify (HWND hwnd, WPARAM wParam, LPARAM lParam)
5100 {
5101     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
5102     LPNMHDR lpnmh = (LPNMHDR)lParam;
5103
5104     if (lpnmh->code == PGN_CALCSIZE) {
5105         LPNMPGCALCSIZE lppgc = (LPNMPGCALCSIZE)lParam;
5106
5107         if (lppgc->dwFlag == PGF_CALCWIDTH) {
5108             lppgc->iWidth = infoPtr->rcBound.right - infoPtr->rcBound.left;
5109             TRACE("processed PGN_CALCSIZE, returning horz size = %d\n",
5110                   lppgc->iWidth);
5111         }
5112         else {
5113             lppgc->iHeight = infoPtr->rcBound.bottom - infoPtr->rcBound.top;
5114             TRACE("processed PGN_CALCSIZE, returning vert size = %d\n",
5115                   lppgc->iHeight);
5116         }
5117         return 0;
5118     }
5119
5120
5121     TRACE("passing WM_NOTIFY!\n");
5122
5123     if ((infoPtr->hwndToolTip) && (lpnmh->hwndFrom == infoPtr->hwndToolTip)) {
5124         if (infoPtr->bNtfUnicode)
5125             return SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
5126                                  wParam, lParam);
5127         else
5128             return SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
5129                                  wParam, lParam);
5130
5131 #if 0
5132         if (lpnmh->code == TTN_GETDISPINFOA) {
5133             LPNMTTDISPINFOA lpdi = (LPNMTTDISPINFOA)lParam;
5134
5135             FIXME("retrieving ASCII string\n");
5136
5137         }
5138         else if (lpnmh->code == TTN_GETDISPINFOW) {
5139             LPNMTTDISPINFOW lpdi = (LPNMTTDISPINFOW)lParam;
5140
5141             FIXME("retrieving UNICODE string\n");
5142
5143         }
5144 #endif
5145     }
5146
5147     return 0;
5148 }
5149
5150
5151 static LRESULT
5152 TOOLBAR_NotifyFormatFake(HWND hwnd, WPARAM wParam, LPARAM lParam)
5153 {
5154     /* remove this routine when Toolbar is improved to pass infoPtr
5155      * around instead of hwnd.
5156      */
5157     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
5158     return TOOLBAR_NotifyFormat(infoPtr, wParam, lParam);
5159 }
5160
5161
5162 static LRESULT
5163 TOOLBAR_NotifyFormat(TOOLBAR_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
5164 {
5165     INT i;
5166
5167     if (lParam == NF_REQUERY) {
5168         i = SendMessageA(GetParent(infoPtr->hwndSelf),
5169                          WM_NOTIFYFORMAT, infoPtr->hwndSelf, NF_QUERY);
5170         if ((i < NFR_ANSI) || (i > NFR_UNICODE)) {
5171             ERR("wrong response to WM_NOTIFYFORMAT (%d), assuming ANSI\n",
5172                 i);
5173             i = NFR_ANSI;
5174         }
5175         infoPtr->bNtfUnicode = (i == NFR_UNICODE) ? 1 : 0;
5176         return (LRESULT)i;
5177     }
5178     return (LRESULT)((infoPtr->bUnicode) ? NFR_UNICODE : NFR_ANSI);
5179 }
5180
5181
5182 static LRESULT
5183 TOOLBAR_Paint (HWND hwnd, WPARAM wParam)
5184 {
5185     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
5186     HDC hdc;
5187     PAINTSTRUCT ps;
5188
5189     /* fill ps.rcPaint with a default rect */
5190     memcpy(&(ps.rcPaint), &(infoPtr->rcBound), sizeof(infoPtr->rcBound));
5191
5192     hdc = wParam==0 ? BeginPaint(hwnd, &ps) : (HDC)wParam;
5193
5194     TRACE("psrect=(%d,%d)-(%d,%d)\n",
5195           ps.rcPaint.left, ps.rcPaint.top,
5196           ps.rcPaint.right, ps.rcPaint.bottom);
5197
5198     TOOLBAR_Refresh (hwnd, hdc, &ps);
5199     if (!wParam) EndPaint (hwnd, &ps);
5200
5201     return 0;
5202 }
5203
5204
5205 static LRESULT
5206 TOOLBAR_SetRedraw (HWND hwnd, WPARAM wParam, LPARAM lParam)
5207      /*****************************************************
5208       *
5209       * Function;
5210       *  Handles the WM_SETREDRAW message.
5211       *
5212       * Documentation:
5213       *  According to testing V4.71 of COMCTL32 returns the
5214       *  *previous* status of the redraw flag (either 0 or 1)
5215       *  instead of the MSDN documented value of 0 if handled.
5216       *  (For laughs see the "consistancy" with same function
5217       *   in rebar.)
5218       *
5219       *****************************************************/
5220 {
5221     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
5222     BOOL oldredraw = infoPtr->bDoRedraw;
5223
5224     TRACE("set to %s\n",
5225           (wParam) ? "TRUE" : "FALSE");
5226     infoPtr->bDoRedraw = (BOOL) wParam;
5227     if (wParam) {
5228         InvalidateRect (infoPtr->hwndSelf, 0, TRUE);
5229     }
5230     return (oldredraw) ? 1 : 0;
5231 }
5232
5233
5234 static LRESULT
5235 TOOLBAR_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
5236 {
5237     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
5238     DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
5239     RECT parent_rect;
5240     RECT window_rect;
5241     HWND parent;
5242     INT  x, y;
5243     INT  cx, cy;
5244     INT  flags;
5245     UINT uPosFlags = 0;
5246
5247     /* Resize deadlock check */
5248     if (infoPtr->bAutoSize) {
5249         infoPtr->bAutoSize = FALSE;
5250         return 0;
5251     }
5252
5253     /* FIXME: optimize to only update size if the new size doesn't */
5254     /* match the current size */
5255
5256     flags = (INT) wParam;
5257
5258     /* FIXME for flags =
5259      * SIZE_MAXIMIZED, SIZE_MAXSHOW, SIZE_MINIMIZED
5260      */
5261
5262     TRACE("sizing toolbar!\n");
5263
5264     if (flags == SIZE_RESTORED) {
5265         /* width and height don't apply */
5266         parent = GetParent (hwnd);
5267         GetClientRect(parent, &parent_rect);
5268         x = parent_rect.left;
5269         y = parent_rect.top;
5270
5271         if (dwStyle & CCS_NORESIZE) {
5272             uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
5273
5274             /*
5275              * this sets the working width of the toolbar, and
5276              * Calc Toolbar will not adjust it, only the height
5277              */
5278             infoPtr->nWidth = parent_rect.right - parent_rect.left;
5279             cy = infoPtr->nHeight;
5280             cx = infoPtr->nWidth;
5281             TOOLBAR_CalcToolbar (hwnd);
5282             infoPtr->nWidth = cx;
5283             infoPtr->nHeight = cy;
5284         }
5285         else {
5286             infoPtr->nWidth = parent_rect.right - parent_rect.left;
5287             TOOLBAR_CalcToolbar (hwnd);
5288             cy = infoPtr->nHeight;
5289             cx = infoPtr->nWidth;
5290
5291             if (dwStyle & CCS_NOMOVEY) {
5292                 GetWindowRect(hwnd, &window_rect);
5293                 ScreenToClient(parent, (LPPOINT)&window_rect.left);
5294                 y = window_rect.top;
5295             }
5296         }
5297
5298         if (dwStyle & CCS_NOPARENTALIGN) {
5299             uPosFlags |= SWP_NOMOVE;
5300             cy = infoPtr->nHeight;
5301             cx = infoPtr->nWidth;
5302         }
5303
5304         if (!(dwStyle & CCS_NODIVIDER))
5305             cy += GetSystemMetrics(SM_CYEDGE);
5306
5307         if (dwStyle & WS_BORDER)
5308         {
5309             x = y = 1;
5310             cy += GetSystemMetrics(SM_CYEDGE);
5311             cx += GetSystemMetrics(SM_CYEDGE);
5312         }
5313
5314         SetWindowPos (hwnd, 0, parent_rect.left - x, parent_rect.top - y,
5315                         cx, cy, uPosFlags | SWP_NOZORDER);
5316     }
5317     return 0;
5318 }
5319
5320
5321 static LRESULT
5322 TOOLBAR_StyleChanged (HWND hwnd, INT nType, LPSTYLESTRUCT lpStyle)
5323 {
5324     TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
5325
5326     if (nType == GWL_STYLE) {
5327         if (lpStyle->styleNew & TBSTYLE_LIST) {
5328             infoPtr->dwDTFlags = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
5329         }
5330         else {
5331             infoPtr->dwDTFlags = DT_CENTER;
5332         }
5333         infoPtr->bTransparent = (lpStyle->styleNew & TBSTYLE_TRANSPARENT);
5334         infoPtr->bBtnTranspnt = (lpStyle->styleNew &
5335                                  (TBSTYLE_FLAT | TBSTYLE_LIST));
5336         TOOLBAR_CheckStyle (hwnd, lpStyle->styleNew);
5337     }
5338
5339     TOOLBAR_AutoSize (hwnd);
5340
5341     InvalidateRect(hwnd, NULL, FALSE);
5342
5343     return 0;
5344 }
5345
5346
5347 static LRESULT
5348 TOOLBAR_SysColorChange (HWND hwnd)
5349 {
5350     COMCTL32_RefreshSysColors();
5351
5352     return 0;
5353 }
5354
5355
5356
5357 static LRESULT WINAPI
5358 ToolbarWindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
5359 {
5360     TRACE("hwnd=%x msg=%x wparam=%x lparam=%lx\n",
5361           hwnd, uMsg, /* SPY_GetMsgName(uMsg), */ wParam, lParam);
5362
5363     if (!TOOLBAR_GetInfoPtr(hwnd) && (uMsg != WM_NCCREATE))
5364         return DefWindowProcA( hwnd, uMsg, wParam, lParam );
5365
5366     switch (uMsg)
5367     {
5368         case TB_ADDBITMAP:
5369             return TOOLBAR_AddBitmap (hwnd, wParam, lParam);
5370
5371         case TB_ADDBUTTONSA:
5372             return TOOLBAR_AddButtonsA (hwnd, wParam, lParam);
5373
5374         case TB_ADDBUTTONSW:
5375             return TOOLBAR_AddButtonsW (hwnd, wParam, lParam);
5376
5377         case TB_ADDSTRINGA:
5378             return TOOLBAR_AddStringA (hwnd, wParam, lParam);
5379
5380         case TB_ADDSTRINGW:
5381             return TOOLBAR_AddStringW (hwnd, wParam, lParam);
5382
5383         case TB_AUTOSIZE:
5384             return TOOLBAR_AutoSize (hwnd);
5385
5386         case TB_BUTTONCOUNT:
5387             return TOOLBAR_ButtonCount (hwnd, wParam, lParam);
5388
5389         case TB_BUTTONSTRUCTSIZE:
5390             return TOOLBAR_ButtonStructSize (hwnd, wParam, lParam);
5391
5392         case TB_CHANGEBITMAP:
5393             return TOOLBAR_ChangeBitmap (hwnd, wParam, lParam);
5394
5395         case TB_CHECKBUTTON:
5396             return TOOLBAR_CheckButton (hwnd, wParam, lParam);
5397
5398         case TB_COMMANDTOINDEX:
5399             return TOOLBAR_CommandToIndex (hwnd, wParam, lParam);
5400
5401         case TB_CUSTOMIZE:
5402             return TOOLBAR_Customize (hwnd);
5403
5404         case TB_DELETEBUTTON:
5405             return TOOLBAR_DeleteButton (hwnd, wParam, lParam);
5406
5407         case TB_ENABLEBUTTON:
5408             return TOOLBAR_EnableButton (hwnd, wParam, lParam);
5409
5410         case TB_GETANCHORHIGHLIGHT:
5411             return TOOLBAR_GetAnchorHighlight (hwnd);
5412
5413         case TB_GETBITMAP:
5414             return TOOLBAR_GetBitmap (hwnd, wParam, lParam);
5415
5416         case TB_GETBITMAPFLAGS:
5417             return TOOLBAR_GetBitmapFlags (hwnd, wParam, lParam);
5418
5419         case TB_GETBUTTON:
5420             return TOOLBAR_GetButton (hwnd, wParam, lParam);
5421
5422         case TB_GETBUTTONINFOA:
5423             return TOOLBAR_GetButtonInfoA (hwnd, wParam, lParam);
5424
5425         case TB_GETBUTTONINFOW:
5426             return TOOLBAR_GetButtonInfoW (hwnd, wParam, lParam);
5427
5428         case TB_GETBUTTONSIZE:
5429             return TOOLBAR_GetButtonSize (hwnd);
5430
5431         case TB_GETBUTTONTEXTA:
5432             return TOOLBAR_GetButtonTextA (hwnd, wParam, lParam);
5433
5434         case TB_GETBUTTONTEXTW:
5435             return TOOLBAR_GetButtonTextW (hwnd, wParam, lParam);
5436
5437         case TB_GETDISABLEDIMAGELIST:
5438             return TOOLBAR_GetDisabledImageList (hwnd, wParam, lParam);
5439
5440         case TB_GETEXTENDEDSTYLE:
5441             return TOOLBAR_GetExtendedStyle (hwnd);
5442
5443         case TB_GETHOTIMAGELIST:
5444             return TOOLBAR_GetHotImageList (hwnd, wParam, lParam);
5445
5446         case TB_GETHOTITEM:
5447             return TOOLBAR_GetHotItem (hwnd);
5448
5449         case TB_GETIMAGELIST:
5450             return TOOLBAR_GetImageList (hwnd, wParam, lParam);
5451
5452 /*      case TB_GETINSERTMARK:                  */ /* 4.71 */
5453 /*      case TB_GETINSERTMARKCOLOR:             */ /* 4.71 */
5454
5455         case TB_GETITEMRECT:
5456             return TOOLBAR_GetItemRect (hwnd, wParam, lParam);
5457
5458         case TB_GETMAXSIZE:
5459             return TOOLBAR_GetMaxSize (hwnd, wParam, lParam);
5460
5461 /*      case TB_GETOBJECT:                      */ /* 4.71 */
5462
5463         case TB_GETPADDING:
5464             return TOOLBAR_GetPadding (hwnd);
5465
5466         case TB_GETRECT:
5467             return TOOLBAR_GetRect (hwnd, wParam, lParam);
5468
5469         case TB_GETROWS:
5470             return TOOLBAR_GetRows (hwnd, wParam, lParam);
5471
5472         case TB_GETSTATE:
5473             return TOOLBAR_GetState (hwnd, wParam, lParam);
5474
5475         case TB_GETSTYLE:
5476             return TOOLBAR_GetStyle (hwnd, wParam, lParam);
5477
5478         case TB_GETTEXTROWS:
5479             return TOOLBAR_GetTextRows (hwnd, wParam, lParam);
5480
5481         case TB_GETTOOLTIPS:
5482             return TOOLBAR_GetToolTips (hwnd, wParam, lParam);
5483
5484         case TB_GETUNICODEFORMAT:
5485             return TOOLBAR_GetUnicodeFormat (hwnd, wParam, lParam);
5486
5487         case TB_HIDEBUTTON:
5488             return TOOLBAR_HideButton (hwnd, wParam, lParam);
5489
5490         case TB_HITTEST:
5491             return TOOLBAR_HitTest (hwnd, wParam, lParam);
5492
5493         case TB_INDETERMINATE:
5494             return TOOLBAR_Indeterminate (hwnd, wParam, lParam);
5495
5496         case TB_INSERTBUTTONA:
5497             return TOOLBAR_InsertButtonA (hwnd, wParam, lParam);
5498
5499         case TB_INSERTBUTTONW:
5500             return TOOLBAR_InsertButtonW (hwnd, wParam, lParam);
5501
5502 /*      case TB_INSERTMARKHITTEST:              */ /* 4.71 */
5503
5504         case TB_ISBUTTONCHECKED:
5505             return TOOLBAR_IsButtonChecked (hwnd, wParam, lParam);
5506
5507         case TB_ISBUTTONENABLED:
5508             return TOOLBAR_IsButtonEnabled (hwnd, wParam, lParam);
5509
5510         case TB_ISBUTTONHIDDEN:
5511             return TOOLBAR_IsButtonHidden (hwnd, wParam, lParam);
5512
5513         case TB_ISBUTTONHIGHLIGHTED:
5514             return TOOLBAR_IsButtonHighlighted (hwnd, wParam, lParam);
5515
5516         case TB_ISBUTTONINDETERMINATE:
5517             return TOOLBAR_IsButtonIndeterminate (hwnd, wParam, lParam);
5518
5519         case TB_ISBUTTONPRESSED:
5520             return TOOLBAR_IsButtonPressed (hwnd, wParam, lParam);
5521
5522         case TB_LOADIMAGES:                        /* 4.70 */
5523             FIXME("missing standard imagelists\n");
5524             return 0;
5525
5526 /*      case TB_MAPACCELERATORA:                */ /* 4.71 */
5527 /*      case TB_MAPACCELERATORW:                */ /* 4.71 */
5528 /*      case TB_MARKBUTTON:                     */ /* 4.71 */
5529 /*      case TB_MOVEBUTTON:                     */ /* 4.71 */
5530
5531         case TB_PRESSBUTTON:
5532             return TOOLBAR_PressButton (hwnd, wParam, lParam);
5533
5534 /*      case TB_REPLACEBITMAP: */
5535
5536         case TB_SAVERESTOREA:
5537             return TOOLBAR_SaveRestoreA (hwnd, wParam, lParam);
5538
5539         case TB_SAVERESTOREW:
5540             return TOOLBAR_SaveRestoreW (hwnd, wParam, lParam);
5541
5542         case TB_SETANCHORHIGHLIGHT:
5543             return TOOLBAR_SetAnchorHighlight (hwnd, wParam);
5544
5545         case TB_SETBITMAPSIZE:
5546             return TOOLBAR_SetBitmapSize (hwnd, wParam, lParam);
5547
5548         case TB_SETBUTTONINFOA:
5549             return TOOLBAR_SetButtonInfoA (hwnd, wParam, lParam);
5550
5551         case TB_SETBUTTONINFOW:
5552             return TOOLBAR_SetButtonInfoW (hwnd, wParam, lParam);
5553
5554         case TB_SETBUTTONSIZE:
5555             return TOOLBAR_SetButtonSize (hwnd, wParam, lParam);
5556
5557         case TB_SETBUTTONWIDTH:
5558             return TOOLBAR_SetButtonWidth (hwnd, wParam, lParam);
5559
5560         case TB_SETCMDID:
5561             return TOOLBAR_SetCmdId (hwnd, wParam, lParam);
5562
5563         case TB_SETDISABLEDIMAGELIST:
5564             return TOOLBAR_SetDisabledImageList (hwnd, wParam, lParam);
5565
5566         case TB_SETDRAWTEXTFLAGS:
5567             return TOOLBAR_SetDrawTextFlags (hwnd, wParam, lParam);
5568
5569         case TB_SETEXTENDEDSTYLE:
5570             return TOOLBAR_SetExtendedStyle (hwnd, wParam, lParam);
5571
5572         case TB_SETHOTIMAGELIST:
5573             return TOOLBAR_SetHotImageList (hwnd, wParam, lParam);
5574
5575         case TB_SETHOTITEM:
5576             return TOOLBAR_SetHotItem (hwnd, wParam);
5577
5578         case TB_SETIMAGELIST:
5579             return TOOLBAR_SetImageList (hwnd, wParam, lParam);
5580
5581         case TB_SETINDENT:
5582             return TOOLBAR_SetIndent (hwnd, wParam, lParam);
5583
5584 /*      case TB_SETINSERTMARK:                  */ /* 4.71 */
5585
5586         case TB_SETINSERTMARKCOLOR:
5587             return TOOLBAR_SetInsertMarkColor (hwnd, wParam, lParam);
5588
5589         case TB_SETMAXTEXTROWS:
5590             return TOOLBAR_SetMaxTextRows (hwnd, wParam, lParam);
5591
5592         case TB_SETPADDING:
5593             return TOOLBAR_SetPadding (hwnd, wParam, lParam);
5594
5595         case TB_SETPARENT:
5596             return TOOLBAR_SetParent (hwnd, wParam, lParam);
5597
5598         case TB_SETROWS:
5599             return TOOLBAR_SetRows (hwnd, wParam, lParam);
5600
5601         case TB_SETSTATE:
5602             return TOOLBAR_SetState (hwnd, wParam, lParam);
5603
5604         case TB_SETSTYLE:
5605             return TOOLBAR_SetStyle (hwnd, wParam, lParam);
5606
5607         case TB_SETTOOLTIPS:
5608             return TOOLBAR_SetToolTips (hwnd, wParam, lParam);
5609
5610         case TB_SETUNICODEFORMAT:
5611             return TOOLBAR_SetUnicodeFormat (hwnd, wParam, lParam);
5612
5613         case TB_UNKWN45E:
5614             return TOOLBAR_Unkwn45E (hwnd, wParam, lParam);
5615
5616         case TB_UNKWN463:
5617             return TOOLBAR_Unkwn463 (hwnd, wParam, lParam);
5618
5619
5620 /* Common Control Messages */
5621
5622 /*      case TB_GETCOLORSCHEME:                 */ /* identical to CCM_ */
5623         case CCM_GETCOLORSCHEME:
5624             return TOOLBAR_GetColorScheme (hwnd, (LPCOLORSCHEME)lParam);
5625
5626 /*      case TB_SETCOLORSCHEME:                 */ /* identical to CCM_ */
5627         case CCM_SETCOLORSCHEME:
5628             return TOOLBAR_SetColorScheme (hwnd, (LPCOLORSCHEME)lParam);
5629
5630         case CCM_GETVERSION:
5631             return TOOLBAR_GetVersion (hwnd);
5632
5633         case CCM_SETVERSION:
5634             return TOOLBAR_SetVersion (hwnd, (INT)wParam);
5635
5636
5637 /*      case WM_CHAR: */
5638
5639         case WM_CREATE:
5640             return TOOLBAR_Create (hwnd, wParam, lParam);
5641
5642         case WM_DESTROY:
5643           return TOOLBAR_Destroy (hwnd, wParam, lParam);
5644
5645         case WM_ERASEBKGND:
5646             return TOOLBAR_EraseBackground (hwnd, wParam, lParam);
5647
5648         case WM_GETFONT:
5649                 return TOOLBAR_GetFont (hwnd, wParam, lParam);
5650
5651 /*      case WM_KEYDOWN: */
5652 /*      case WM_KILLFOCUS: */
5653
5654         case WM_LBUTTONDBLCLK:
5655             return TOOLBAR_LButtonDblClk (hwnd, wParam, lParam);
5656
5657         case WM_LBUTTONDOWN:
5658             return TOOLBAR_LButtonDown (hwnd, wParam, lParam);
5659
5660         case WM_LBUTTONUP:
5661             return TOOLBAR_LButtonUp (hwnd, wParam, lParam);
5662
5663         case WM_MOUSEMOVE:
5664             return TOOLBAR_MouseMove (hwnd, wParam, lParam);
5665
5666         case WM_MOUSELEAVE:
5667             return TOOLBAR_MouseLeave (hwnd, wParam, lParam);
5668
5669         case WM_CAPTURECHANGED:
5670             return TOOLBAR_CaptureChanged(hwnd);
5671
5672         case WM_NCACTIVATE:
5673             return TOOLBAR_NCActivate (hwnd, wParam, lParam);
5674
5675         case WM_NCCALCSIZE:
5676             return TOOLBAR_NCCalcSize (hwnd, wParam, lParam);
5677
5678         case WM_NCCREATE:
5679             return TOOLBAR_NCCreate (hwnd, wParam, lParam);
5680
5681         case WM_NCPAINT:
5682             return TOOLBAR_NCPaint (hwnd, wParam, lParam);
5683
5684         case WM_NOTIFY:
5685             return TOOLBAR_Notify (hwnd, wParam, lParam);
5686
5687         case WM_NOTIFYFORMAT:
5688             TOOLBAR_NotifyFormatFake (hwnd, wParam, lParam);
5689
5690         case WM_PAINT:
5691             return TOOLBAR_Paint (hwnd, wParam);
5692
5693         case WM_SETREDRAW:
5694             return TOOLBAR_SetRedraw (hwnd, wParam, lParam);
5695
5696         case WM_SIZE:
5697             return TOOLBAR_Size (hwnd, wParam, lParam);
5698
5699         case WM_STYLECHANGED:
5700             return TOOLBAR_StyleChanged (hwnd, (INT)wParam, (LPSTYLESTRUCT)lParam);
5701
5702         case WM_SYSCOLORCHANGE:
5703             return TOOLBAR_SysColorChange (hwnd);
5704
5705 /*      case WM_WININICHANGE: */
5706
5707         case WM_CHARTOITEM:
5708         case WM_COMMAND:
5709         case WM_DRAWITEM:
5710         case WM_MEASUREITEM:
5711         case WM_VKEYTOITEM:
5712             {
5713                 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
5714                 if(infoPtr != NULL)
5715                     return SendMessageA (infoPtr->hwndNotify, uMsg, wParam, lParam);
5716                 else
5717                     return SendMessageA (GetParent (hwnd), uMsg, wParam, lParam);
5718             }
5719
5720         /* We see this in Outlook Express 5.x and just does DefWindowProc */
5721         case PGM_FORWARDMOUSE:
5722             return DefWindowProcA (hwnd, uMsg, wParam, lParam);
5723
5724         default:
5725             if (uMsg >= WM_USER)
5726                 ERR("unknown msg %04x wp=%08x lp=%08lx\n",
5727                      uMsg, wParam, lParam);
5728             return DefWindowProcA (hwnd, uMsg, wParam, lParam);
5729     }
5730     return 0;
5731 }
5732
5733
5734 VOID
5735 TOOLBAR_Register (void)
5736 {
5737     WNDCLASSA wndClass;
5738
5739     ZeroMemory (&wndClass, sizeof(WNDCLASSA));
5740     wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS;
5741     wndClass.lpfnWndProc   = (WNDPROC)ToolbarWindowProc;
5742     wndClass.cbClsExtra    = 0;
5743     wndClass.cbWndExtra    = sizeof(TOOLBAR_INFO *);
5744     wndClass.hCursor       = LoadCursorA (0, IDC_ARROWA);
5745     wndClass.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
5746     wndClass.lpszClassName = TOOLBARCLASSNAMEA;
5747
5748     RegisterClassA (&wndClass);
5749 }
5750
5751
5752 VOID
5753 TOOLBAR_Unregister (void)
5754 {
5755     UnregisterClassA (TOOLBARCLASSNAMEA, (HINSTANCE)NULL);
5756 }