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