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