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