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