?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
New debug scheme with explicit debug channels declaration.
[wine.git] / dlls / comctl32 / toolbar.c
blob5e772b5b397dd3bc25ced878337835056baeb8af
1
2 /*
3 * Toolbar control
4 *
5 * Copyright 1998 Eric Kohl
6 *
7 * TODO:
8 * - A little bug in TOOLBAR_DrawMasked()
9 * - Button wrapping (under construction).
10 * - Messages.
11 * - Notifications.
12 * - Fix TB_SETROWS.
13 * - Tooltip support (almost complete).
14 * - Unicode suppport.
15 * - Internal COMMCTL32 bitmaps.
16 * - Fix TOOLBAR_SetButtonInfo32A.
17 * - Fix TOOLBAR_Customize. (Customize dialog.)
18 *
19 * Testing:
20 * - Run tests using Waite Group Windows95 API Bible Volume 2.
21 * The second cdrom contains executables addstr.exe, btncount.exe,
22 * btnstate.exe, butstrsz.exe, chkbtn.exe, chngbmp.exe, customiz.exe,
23 * enablebtn.exe, getbmp.exe, getbtn.exe, getflags.exe, hidebtn.exe,
24 * indetbtn.exe, insbtn.exe, pressbtn.exe, setbtnsz.exe, setcmdid.exe,
25 * setparnt.exe, setrows.exe, toolwnd.exe.
26 * - Microsofts controlspy examples.
27 */
28
29 #include <string.h>
30
31 #include "winbase.h"
32 #include "commctrl.h"
33 #include "sysmetrics.h"
34 #include "cache.h"
35 #include "toolbar.h"
36 #include "debug.h"
37
38 DEFAULT_DEBUG_CHANNEL(toolbar)
39
40 /* #define __NEW_WRAP_CODE__ */
41
42 #define SEPARATOR_WIDTH 8
43 #define SEPARATOR_HEIGHT 5
44 #define TOP_BORDER 2
45 #define BOTTOM_BORDER 2
46
47
48
49 #define TOOLBAR_GetInfoPtr(wndPtr) ((TOOLBAR_INFO *)GetWindowLongA(hwnd,0))
50
51
52 static void
53 TOOLBAR_DrawFlatSeparator (LPRECT lpRect, HDC hdc)
54 {
55 INT x = (lpRect->left + lpRect->right) / 2 - 1;
56 INT yBottom = lpRect->bottom - 3;
57 INT yTop = lpRect->top + 1;
58
59 SelectObject ( hdc, GetSysColorPen (COLOR_3DSHADOW));
60 MoveToEx (hdc, x, yBottom, NULL);
61 LineTo (hdc, x, yTop);
62 x++;
63 SelectObject ( hdc, GetSysColorPen (COLOR_3DHILIGHT));
64 MoveToEx (hdc, x, yBottom, NULL);
65 LineTo (hdc, x, yTop);
66 }
67
68
69 static void
70 TOOLBAR_DrawString (TOOLBAR_INFO *infoPtr, TBUTTON_INFO *btnPtr,
71 HDC hdc, INT nState)
72 {
73 RECT rcText = btnPtr->rect;
74 HFONT hOldFont;
75 INT nOldBkMode;
76 COLORREF clrOld;
77
78 /* draw text */
79 if ((btnPtr->iString > -1) && (btnPtr->iString < infoPtr->nNumStrings)) {
80 InflateRect (&rcText, -3, -3);
81 rcText.top += infoPtr->nBitmapHeight;
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 HDC hdcImageList = CreateCompatibleDC (0);
135 HDC hdcMask = CreateCompatibleDC (0);
136 HIMAGELIST himl = infoPtr->himlStd;
137 HBITMAP hbmMask;
138
139 /* create new bitmap */
140 hbmMask = CreateBitmap (himl->cx, himl->cy, 1, 1, NULL);
141 SelectObject (hdcMask, hbmMask);
142
143 /* copy the mask bitmap */
144 SelectObject (hdcImageList, himl->hbmMask);
145 SetBkColor (hdcImageList, RGB(255, 255, 255));
146 SetTextColor (hdcImageList, RGB(0, 0, 0));
147 BitBlt (hdcMask, 0, 0, himl->cx, himl->cy,
148 hdcImageList, himl->cx * btnPtr->iBitmap, 0, SRCCOPY);
149
150 #if 0
151 /* add white mask from image */
152 SelectObject (hdcImageList, himl->hbmImage);
153 SetBkColor (hdcImageList, RGB(0, 0, 0));
154 BitBlt (hdcMask, 0, 0, himl->cx, himl->cy,
155 hdcImageList, himl->cx * btnPtr->iBitmap, 0, MERGEPAINT);
156 #endif
157
158 /* draw the new mask */
159 SelectObject (hdc, GetSysColorBrush (COLOR_3DHILIGHT));
160 BitBlt (hdc, x+1, y+1, himl->cx, himl->cy,
161 hdcMask, 0, 0, 0xB8074A);
162
163 SelectObject (hdc, GetSysColorBrush (COLOR_3DSHADOW));
164 BitBlt (hdc, x, y, himl->cx, himl->cy,
165 hdcMask, 0, 0, 0xB8074A);
166
167 DeleteObject (hbmMask);
168 DeleteDC (hdcMask);
169 DeleteDC (hdcImageList);
170 }
171
172
173 static void
174 TOOLBAR_DrawButton (HWND hwnd, TBUTTON_INFO *btnPtr, HDC hdc)
175 {
176 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
177 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
178 RECT rc;
179
180 if (btnPtr->fsState & TBSTATE_HIDDEN)
181 return;
182
183 rc = btnPtr->rect;
184 if (btnPtr->fsStyle & TBSTYLE_SEP) {
185 if ((dwStyle & TBSTYLE_FLAT) && (btnPtr->idCommand == 0))
186 TOOLBAR_DrawFlatSeparator (&btnPtr->rect, hdc);
187 return;
188 }
189
190 /* disabled */
191 if (!(btnPtr->fsState & TBSTATE_ENABLED)) {
192 DrawEdge (hdc, &rc, EDGE_RAISED,
193 BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
194
195 if (dwStyle & TBSTYLE_FLAT) {
196 /* if (infoPtr->himlDis) */
197 ImageList_Draw (infoPtr->himlDis, btnPtr->iBitmap, hdc,
198 rc.left+1, rc.top+1, ILD_NORMAL);
199 /* else */
200 /* TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1); */
201 }
202 else
203 TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1);
204
205 TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
206 return;
207 }
208
209 /* pressed TBSTYLE_BUTTON */
210 if (btnPtr->fsState & TBSTATE_PRESSED) {
211 DrawEdge (hdc, &rc, EDGE_SUNKEN, BF_RECT | BF_MIDDLE | BF_ADJUST);
212 ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
213 rc.left+2, rc.top+2, ILD_NORMAL);
214 TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
215 return;
216 }
217
218 /* checked TBSTYLE_CHECK*/
219 if ((btnPtr->fsStyle & TBSTYLE_CHECK) &&
220 (btnPtr->fsState & TBSTATE_CHECKED)) {
221 if (dwStyle & TBSTYLE_FLAT)
222 DrawEdge (hdc, &rc, BDR_SUNKENOUTER,
223 BF_RECT | BF_MIDDLE | BF_ADJUST);
224 else
225 DrawEdge (hdc, &rc, EDGE_SUNKEN,
226 BF_RECT | BF_MIDDLE | BF_ADJUST);
227
228 TOOLBAR_DrawPattern (hdc, &rc);
229 if (dwStyle & TBSTYLE_FLAT)
230 {
231 if (infoPtr->himlDef != NULL)
232 ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
233 rc.left+2, rc.top+2, ILD_NORMAL);
234 else
235 ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
236 rc.left+2, rc.top+2, ILD_NORMAL);
237 }
238 else
239 ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
240 rc.left+2, rc.top+2, ILD_NORMAL);
241 TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
242 return;
243 }
244
245 /* indeterminate */
246 if (btnPtr->fsState & TBSTATE_INDETERMINATE) {
247 DrawEdge (hdc, &rc, EDGE_RAISED,
248 BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
249
250 TOOLBAR_DrawPattern (hdc, &rc);
251 TOOLBAR_DrawMasked (infoPtr, btnPtr, hdc, rc.left+1, rc.top+1);
252 TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
253 return;
254 }
255
256 if (dwStyle & TBSTYLE_FLAT)
257 {
258 if(btnPtr->bHot)
259 DrawEdge (hdc, &rc, BDR_RAISEDINNER,
260 BF_RECT | BF_MIDDLE | BF_SOFT);
261
262 if(infoPtr->himlDef != NULL)
263 ImageList_Draw (infoPtr->himlDef, btnPtr->iBitmap, hdc,
264 rc.left +2, rc.top +2, ILD_NORMAL);
265 else
266 ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
267 rc.left +2, rc.top +2, ILD_NORMAL);
268 }
269 else{
270 /* normal state */
271 DrawEdge (hdc, &rc, EDGE_RAISED,
272 BF_SOFT | BF_RECT | BF_MIDDLE | BF_ADJUST);
273
274 ImageList_Draw (infoPtr->himlStd, btnPtr->iBitmap, hdc,
275 rc.left+1, rc.top+1, ILD_NORMAL);
276 }
277
278 TOOLBAR_DrawString (infoPtr, btnPtr, hdc, btnPtr->fsState);
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 (toolbar, "string size %d x %d!\n", lpSize->cx, lpSize->cy);
329 }
330
331
332 static void
333 TOOLBAR_CalcToolbar (HWND hwnd)
334 {
335 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
336 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
337 TBUTTON_INFO *btnPtr;
338 INT i, nRows;
339 INT x, y, cx, cy;
340 BOOL bWrap;
341 SIZE sizeString;
342 /* --- new --- */
343 #ifdef __NEW_WRAP_CODE__
344 INT nGrpCount = 0;
345 INT grpX,j;
346 TBUTTON_INFO *grpPtr;
347 #endif
348 /* --- end new --- */
349
350 TOOLBAR_CalcStrings (hwnd, &sizeString);
351
352 if (sizeString.cy > 0)
353 infoPtr->nButtonHeight = sizeString.cy + infoPtr->nBitmapHeight + 6;
354 else if (infoPtr->nButtonHeight < infoPtr->nBitmapHeight + 6)
355 infoPtr->nButtonHeight = infoPtr->nBitmapHeight + 6;
356
357 if (sizeString.cx > infoPtr->nBitmapWidth)
358 infoPtr->nButtonWidth = sizeString.cx + 6;
359 else if (infoPtr->nButtonWidth < infoPtr->nBitmapWidth + 6)
360 infoPtr->nButtonWidth = infoPtr->nBitmapWidth + 6;
361
362 x = infoPtr->nIndent;
363 y = TOP_BORDER;
364 cx = infoPtr->nButtonWidth;
365 cy = infoPtr->nButtonHeight;
366 nRows = 0;
367
368 /* calculate the size of each button according to it's style */
369 /* TOOLBAR_CalcButtons (hwnd); */
370
371 infoPtr->rcBound.top = y;
372 infoPtr->rcBound.left = x;
373 infoPtr->rcBound.bottom = y + cy;
374 infoPtr->rcBound.right = x;
375
376 btnPtr = infoPtr->buttons;
377 for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
378 bWrap = FALSE;
379
380 if (btnPtr->fsState & TBSTATE_HIDDEN) {
381 SetRectEmpty (&btnPtr->rect);
382 continue;
383 }
384
385 #ifdef __NEW_WRAP_CODE__
386 /*#if 0 */
387 if (btnPtr->fsStyle & TBSTYLE_SEP) {
388 /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
389 /* it is the actual width of the separator. This is used for */
390 /* custom controls in toolbars. */
391 if ((dwStyle & TBSTYLE_WRAPABLE) &&
392 (btnPtr->fsState & TBSTATE_WRAP)) {
393 x = 0;
394 y += cy;
395 cx = infoPtr->nWidth;
396 cy = ((btnPtr->iBitmap > 0) ?
397 btnPtr->iBitmap : SEPARATOR_WIDTH) * 2 / 3;
398 /* nRows++; */
399 /* bWrap = TRUE; */
400 }
401 else
402 cx = (btnPtr->iBitmap > 0) ?
403 btnPtr->iBitmap : SEPARATOR_WIDTH;
404 }
405 else {
406 /* this must be a button */
407 cx = infoPtr->nButtonWidth;
408 }
409 /*#endif */
410
411 /* --- begin test --- */
412 if ((i >= nGrpCount) && (btnPtr->fsStyle & TBSTYLE_GROUP)) {
413 for (j = i, grpX = x, nGrpCount = 0; j < infoPtr->nNumButtons; j++) {
414 grpPtr = &infoPtr->buttons[j];
415 if (grpPtr->fsState & TBSTATE_HIDDEN)
416 continue;
417
418 grpX += cx;
419
420 if ((grpPtr->fsStyle & TBSTYLE_SEP) ||
421 !(grpPtr->fsStyle & TBSTYLE_GROUP) ||
422 (grpX > infoPtr->nWidth)) {
423 nGrpCount = j;
424 break;
425 }
426 else if (grpX + x > infoPtr->nWidth) {
427 bWrap = TRUE;
428 nGrpCount = j;
429 break;
430 }
431 }
432 }
433
434 bWrap = ((bWrap || (x + cx > infoPtr->nWidth)) &&
435 (dwStyle & TBSTYLE_WRAPABLE));
436 if (bWrap) {
437 nRows++;
438 y += cy;
439 x = infoPtr->nIndent;
440 bWrap = FALSE;
441 }
442
443 SetRect (&btnPtr->rect, x, y, x + cx, y + cy);
444
445 btnPtr->nRow = nRows;
446 x += cx;
447
448 if (btnPtr->fsState & TBSTATE_WRAP) {
449 nRows++;
450 y += (cy + SEPARATOR_HEIGHT);
451 x = infoPtr->nIndent;
452 }
453
454 infoPtr->nRows = nRows + 1;
455
456 /* --- end test --- */
457 #else
458 if (btnPtr->fsStyle & TBSTYLE_SEP) {
459 /* UNDOCUMENTED: If a separator has a non zero bitmap index, */
460 /* it is the actual width of the separator. This is used for */
461 /* custom controls in toolbars. */
462 if ((dwStyle & TBSTYLE_WRAPABLE) &&
463 (btnPtr->fsState & TBSTATE_WRAP)) {
464 x = 0;
465 y += cy;
466 cx = infoPtr->nWidth;
467 cy = ((btnPtr->iBitmap > 0) ?
468 btnPtr->iBitmap : SEPARATOR_WIDTH) * 2 / 3;
469 nRows++;
470 bWrap = TRUE;
471 }
472 else
473 cx = (btnPtr->iBitmap > 0) ?
474 btnPtr->iBitmap : SEPARATOR_WIDTH;
475 }
476 else {
477 /* this must be a button */
478 cx = infoPtr->nButtonWidth;
479 }
480
481 btnPtr->rect.left = x;
482 btnPtr->rect.top = y;
483 btnPtr->rect.right = x + cx;
484 btnPtr->rect.bottom = y + cy;
485
486 if (infoPtr->rcBound.left > x)
487 infoPtr->rcBound.left = x;
488 if (infoPtr->rcBound.right < x + cx)
489 infoPtr->rcBound.right = x + cx;
490 if (infoPtr->rcBound.bottom < y + cy)
491 infoPtr->rcBound.bottom = y + cy;
492
493 if (infoPtr->hwndToolTip) {
494 TTTOOLINFOA ti;
495
496 ZeroMemory (&ti, sizeof(TTTOOLINFOA));
497 ti.cbSize = sizeof(TTTOOLINFOA);
498 ti.hwnd = hwnd;
499 ti.uId = btnPtr->idCommand;
500 ti.rect = btnPtr->rect;
501 SendMessageA (infoPtr->hwndToolTip, TTM_NEWTOOLRECTA,
502 0, (LPARAM)&ti);
503 }
504
505 if (bWrap) {
506 x = 0;
507 y += cy;
508 if (i < infoPtr->nNumButtons)
509 nRows++;
510 }
511 else
512 x += cx;
513 #endif
514 }
515
516 infoPtr->nHeight = y + cy + BOTTOM_BORDER;
517 TRACE (toolbar, "toolbar height %d\n", infoPtr->nHeight);
518 }
519
520
521 static INT
522 TOOLBAR_InternalHitTest (HWND hwnd, LPPOINT lpPt)
523 {
524 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
525 TBUTTON_INFO *btnPtr;
526 INT i;
527
528 btnPtr = infoPtr->buttons;
529 for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
530 if (btnPtr->fsState & TBSTATE_HIDDEN)
531 continue;
532
533 if (btnPtr->fsStyle & TBSTYLE_SEP) {
534 if (PtInRect (&btnPtr->rect, *lpPt)) {
535 TRACE (toolbar, " ON SEPARATOR %d!\n", i);
536 return -i;
537 }
538 }
539 else {
540 if (PtInRect (&btnPtr->rect, *lpPt)) {
541 TRACE (toolbar, " ON BUTTON %d!\n", i);
542 return i;
543 }
544 }
545 }
546
547 TRACE (toolbar, " NOWHERE!\n");
548 return -1;
549 }
550
551
552 static INT
553 TOOLBAR_GetButtonIndex (TOOLBAR_INFO *infoPtr, INT idCommand)
554 {
555 TBUTTON_INFO *btnPtr;
556 INT i;
557
558 btnPtr = infoPtr->buttons;
559 for (i = 0; i < infoPtr->nNumButtons; i++, btnPtr++) {
560 if (btnPtr->idCommand == idCommand) {
561 TRACE (toolbar, "command=%d index=%d\n", idCommand, i);
562 return i;
563 }
564 }
565 TRACE (toolbar, "no index found for command=%d\n", idCommand);
566 return -1;
567 }
568
569
570 static INT
571 TOOLBAR_GetCheckedGroupButtonIndex (TOOLBAR_INFO *infoPtr, INT nIndex)
572 {
573 TBUTTON_INFO *btnPtr;
574 INT nRunIndex;
575
576 if ((nIndex < 0) || (nIndex > infoPtr->nNumButtons))
577 return -1;
578
579 /* check index button */
580 btnPtr = &infoPtr->buttons[nIndex];
581 if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
582 if (btnPtr->fsState & TBSTATE_CHECKED)
583 return nIndex;
584 }
585
586 /* check previous buttons */
587 nRunIndex = nIndex - 1;
588 while (nRunIndex >= 0) {
589 btnPtr = &infoPtr->buttons[nRunIndex];
590 if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
591 if (btnPtr->fsState & TBSTATE_CHECKED)
592 return nRunIndex;
593 }
594 else
595 break;
596 nRunIndex--;
597 }
598
599 /* check next buttons */
600 nRunIndex = nIndex + 1;
601 while (nRunIndex < infoPtr->nNumButtons) {
602 btnPtr = &infoPtr->buttons[nRunIndex];
603 if ((btnPtr->fsStyle & TBSTYLE_CHECKGROUP) == TBSTYLE_CHECKGROUP) {
604 if (btnPtr->fsState & TBSTATE_CHECKED)
605 return nRunIndex;
606 }
607 else
608 break;
609 nRunIndex++;
610 }
611
612 return -1;
613 }
614
615
616 static VOID
617 TOOLBAR_RelayEvent (HWND hwndTip, HWND hwndMsg, UINT uMsg,
618 WPARAM wParam, LPARAM lParam)
619 {
620 MSG msg;
621
622 msg.hwnd = hwndMsg;
623 msg.message = uMsg;
624 msg.wParam = wParam;
625 msg.lParam = lParam;
626 msg.time = GetMessageTime ();
627 msg.pt.x = LOWORD(GetMessagePos ());
628 msg.pt.y = HIWORD(GetMessagePos ());
629
630 SendMessageA (hwndTip, TTM_RELAYEVENT, 0, (LPARAM)&msg);
631 }
632
633 /***********************************************************************
634 * TOOLBAR_AddBitmap: Add the bitmaps to the default image list.
635 *
636 */
637 static LRESULT
638 TOOLBAR_AddBitmap (HWND hwnd, WPARAM wParam, LPARAM lParam)
639 {
640 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
641 LPTBADDBITMAP lpAddBmp = (LPTBADDBITMAP)lParam;
642 INT nIndex = 0;
643
644 if ((!lpAddBmp) || ((INT)wParam <= 0))
645 return -1;
646
647 TRACE (toolbar, "adding %d bitmaps!\n", wParam);
648
649 if (!(infoPtr->himlStd)) {
650 /* create new standard image list */
651
652 TRACE (toolbar, "creating standard image list!\n");
653
654
655 /* Windows resize all the buttons to the size of a newly added STandard Image*/
656 /* TODO: The resizing should be done each time a standard image is added*/
657 if (lpAddBmp->hInst == HINST_COMMCTRL)
658 {
659
660 if (lpAddBmp->nID & 1)
661 {
662 SendMessageA (hwnd, TB_SETBITMAPSIZE, 0,
663 MAKELPARAM((WORD)26, (WORD)26));
664 SendMessageA (hwnd, TB_SETBUTTONSIZE, 0,
665 MAKELPARAM((WORD)33, (WORD)33));
666 }
667 else
668 {
669 SendMessageA (hwnd, TB_SETBITMAPSIZE, 0,
670 MAKELPARAM((WORD)16, (WORD)16));
671
672 SendMessageA (hwnd, TB_SETBUTTONSIZE, 0,
673 MAKELPARAM((WORD)22, (WORD)22));
674 }
675
676 TOOLBAR_CalcToolbar (hwnd);
677 }
678
679 infoPtr->himlStd =
680 ImageList_Create (infoPtr->nBitmapWidth, infoPtr->nBitmapHeight,
681 ILC_COLOR | ILC_MASK, (INT)wParam, 2);
682 }
683
684 /* Add bitmaps to the standard image list */
685 if (lpAddBmp->hInst == (HINSTANCE)0) {
686 nIndex =
687 ImageList_AddMasked (infoPtr->himlStd, (HBITMAP)lpAddBmp->nID,
688 CLR_DEFAULT);
689 }
690 else if (lpAddBmp->hInst == HINST_COMMCTRL) {
691 /* add internal bitmaps */
692
693 FIXME (toolbar, "internal bitmaps not supported!\n");
694 /* TODO: Resize all the buttons when a new standard image is added */
695
696 /* Hack to "add" some reserved images within the image list
697 to get the right image indices */
698 nIndex = ImageList_GetImageCount (infoPtr->himlStd);
699 ImageList_SetImageCount (infoPtr->himlStd, nIndex + (INT)wParam);
700
701 }
702 else {
703 HBITMAP hBmp =
704 LoadBitmapA (lpAddBmp->hInst, (LPSTR)lpAddBmp->nID);
705 nIndex = ImageList_AddMasked (infoPtr->himlStd, hBmp, CLR_DEFAULT);
706
707 DeleteObject (hBmp);
708 }
709
710 infoPtr->nNumBitmaps += (INT)wParam;
711
712 return nIndex;
713 }
714
715
716 static LRESULT
717 TOOLBAR_AddButtonsA (HWND hwnd, WPARAM wParam, LPARAM lParam)
718 {
719 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
720 LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
721 INT nOldButtons, nNewButtons, nAddButtons, nCount;
722 HDC hdc;
723
724 TRACE (toolbar, "adding %d buttons!\n", wParam);
725
726 nAddButtons = (UINT)wParam;
727 nOldButtons = infoPtr->nNumButtons;
728 nNewButtons = nOldButtons + nAddButtons;
729
730 if (infoPtr->nNumButtons == 0) {
731 infoPtr->buttons =
732 COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
733 }
734 else {
735 TBUTTON_INFO *oldButtons = infoPtr->buttons;
736 infoPtr->buttons =
737 COMCTL32_Alloc (sizeof(TBUTTON_INFO) * nNewButtons);
738 memcpy (&infoPtr->buttons[0], &oldButtons[0],
739 nOldButtons * sizeof(TBUTTON_INFO));
740 COMCTL32_Free (oldButtons);
741 }
742
743 infoPtr->nNumButtons = nNewButtons;
744
745 /* insert new button data */
746 for (nCount = 0; nCount < nAddButtons; nCount++) {
747 TBUTTON_INFO *btnPtr = &infoPtr->buttons[nOldButtons+nCount];
748 btnPtr->iBitmap = lpTbb[nCount].iBitmap;
749 btnPtr->idCommand = lpTbb[nCount].idCommand;
750 btnPtr->fsState = lpTbb[nCount].fsState;
751 btnPtr->fsStyle = lpTbb[nCount].fsStyle;
752 btnPtr->dwData = lpTbb[nCount].dwData;
753 btnPtr->iString = lpTbb[nCount].iString;
754 btnPtr->bHot = FALSE;
755
756 if ((infoPtr->hwndToolTip) && !(btnPtr->fsStyle & TBSTYLE_SEP)) {
757 TTTOOLINFOA ti;
758
759 ZeroMemory (&ti, sizeof(TTTOOLINFOA));
760 ti.cbSize = sizeof (TTTOOLINFOA);
761 ti.hwnd = hwnd;
762 ti.uId = btnPtr->idCommand;
763 ti.hinst = 0;
764 ti.lpszText = LPSTR_TEXTCALLBACKA;
765
766 SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
767 0, (LPARAM)&ti);
768 }
769 }
770
771 TOOLBAR_CalcToolbar (hwnd);
772
773 hdc = GetDC (hwnd);
774 TOOLBAR_Refresh (hwnd, hdc);
775 ReleaseDC (hwnd, hdc);
776
777 return TRUE;
778 }
779
780
781 /* << TOOLBAR_AddButtons32W >> */
782
783
784 static LRESULT
785 TOOLBAR_AddStringA (HWND hwnd, WPARAM wParam, LPARAM lParam)
786 {
787 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
788 INT nIndex;
789
790 if ((wParam) && (HIWORD(lParam) == 0)) {
791 char szString[256];
792 INT len;
793 TRACE (toolbar, "adding string from resource!\n");
794
795 len = LoadStringA ((HINSTANCE)wParam, (UINT)lParam,
796 szString, 256);
797
798 TRACE (toolbar, "len=%d \"%s\"\n", len, szString);
799 nIndex = infoPtr->nNumStrings;
800 if (infoPtr->nNumStrings == 0) {
801 infoPtr->strings =
802 COMCTL32_Alloc (sizeof(LPWSTR));
803 }
804 else {
805 LPWSTR *oldStrings = infoPtr->strings;
806 infoPtr->strings =
807 COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
808 memcpy (&infoPtr->strings[0], &oldStrings[0],
809 sizeof(LPWSTR) * infoPtr->nNumStrings);
810 COMCTL32_Free (oldStrings);
811 }
812
813 infoPtr->strings[infoPtr->nNumStrings] =
814 COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
815 lstrcpyAtoW (infoPtr->strings[infoPtr->nNumStrings], szString);
816 infoPtr->nNumStrings++;
817 }
818 else {
819 LPSTR p = (LPSTR)lParam;
820 INT len;
821
822 if (p == NULL)
823 return -1;
824 TRACE (toolbar, "adding string(s) from array!\n");
825 nIndex = infoPtr->nNumStrings;
826 while (*p) {
827 len = lstrlenA (p);
828 TRACE (toolbar, "len=%d \"%s\"\n", len, p);
829
830 if (infoPtr->nNumStrings == 0) {
831 infoPtr->strings =
832 COMCTL32_Alloc (sizeof(LPWSTR));
833 }
834 else {
835 LPWSTR *oldStrings = infoPtr->strings;
836 infoPtr->strings =
837 COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
838 memcpy (&infoPtr->strings[0], &oldStrings[0],
839 sizeof(LPWSTR) * infoPtr->nNumStrings);
840 COMCTL32_Free (oldStrings);
841 }
842
843 infoPtr->strings[infoPtr->nNumStrings] =
844 COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
845 lstrcpyAtoW (infoPtr->strings[infoPtr->nNumStrings], p);
846 infoPtr->nNumStrings++;
847
848 p += (len+1);
849 }
850 }
851
852 return nIndex;
853 }
854
855
856 static LRESULT
857 TOOLBAR_AddStringW (HWND hwnd, WPARAM wParam, LPARAM lParam)
858 {
859 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
860 INT nIndex;
861
862 if ((wParam) && (HIWORD(lParam) == 0)) {
863 WCHAR szString[256];
864 INT len;
865 TRACE (toolbar, "adding string from resource!\n");
866
867 len = LoadStringW ((HINSTANCE)wParam, (UINT)lParam,
868 szString, 256);
869
870 TRACE (toolbar, "len=%d \"%s\"\n", len, debugstr_w(szString));
871 nIndex = infoPtr->nNumStrings;
872 if (infoPtr->nNumStrings == 0) {
873 infoPtr->strings =
874 COMCTL32_Alloc (sizeof(LPWSTR));
875 }
876 else {
877 LPWSTR *oldStrings = infoPtr->strings;
878 infoPtr->strings =
879 COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
880 memcpy (&infoPtr->strings[0], &oldStrings[0],
881 sizeof(LPWSTR) * infoPtr->nNumStrings);
882 COMCTL32_Free (oldStrings);
883 }
884
885 infoPtr->strings[infoPtr->nNumStrings] =
886 COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
887 lstrcpyW (infoPtr->strings[infoPtr->nNumStrings], szString);
888 infoPtr->nNumStrings++;
889 }
890 else {
891 LPWSTR p = (LPWSTR)lParam;
892 INT len;
893
894 if (p == NULL)
895 return -1;
896 TRACE (toolbar, "adding string(s) from array!\n");
897 nIndex = infoPtr->nNumStrings;
898 while (*p) {
899 len = lstrlenW (p);
900 TRACE (toolbar, "len=%d \"%s\"\n", len, debugstr_w(p));
901
902 if (infoPtr->nNumStrings == 0) {
903 infoPtr->strings =
904 COMCTL32_Alloc (sizeof(LPWSTR));
905 }
906 else {
907 LPWSTR *oldStrings = infoPtr->strings;
908 infoPtr->strings =
909 COMCTL32_Alloc (sizeof(LPWSTR) * (infoPtr->nNumStrings + 1));
910 memcpy (&infoPtr->strings[0], &oldStrings[0],
911 sizeof(LPWSTR) * infoPtr->nNumStrings);
912 COMCTL32_Free (oldStrings);
913 }
914
915 infoPtr->strings[infoPtr->nNumStrings] =
916 COMCTL32_Alloc (sizeof(WCHAR)*(len+1));
917 lstrcpyW (infoPtr->strings[infoPtr->nNumStrings], p);
918 infoPtr->nNumStrings++;
919
920 p += (len+1);
921 }
922 }
923
924 return nIndex;
925 }
926
927
928 static LRESULT
929 TOOLBAR_AutoSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
930 {
931 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
932 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
933 RECT parent_rect;
934 HWND parent;
935 /* INT32 x, y; */
936 INT cx, cy;
937 UINT uPosFlags = 0;
938
939 TRACE (toolbar, "resize forced!\n");
940
941 parent = GetParent (hwnd);
942 GetClientRect(parent, &parent_rect);
943
944 if (dwStyle & CCS_NORESIZE) {
945 uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
946 cx = 0;
947 cy = 0;
948 }
949 else {
950 infoPtr->nWidth = parent_rect.right - parent_rect.left;
951 TOOLBAR_CalcToolbar (hwnd);
952 cy = infoPtr->nHeight;
953 cx = infoPtr->nWidth;
954 }
955
956 if (dwStyle & CCS_NOPARENTALIGN)
957 uPosFlags |= SWP_NOMOVE;
958
959 if (!(dwStyle & CCS_NODIVIDER))
960 cy += sysMetrics[SM_CYEDGE];
961
962 infoPtr->bAutoSize = TRUE;
963 SetWindowPos (hwnd, HWND_TOP, parent_rect.left, parent_rect.top,
964 cx, cy, uPosFlags);
965
966 return 0;
967 }
968
969
970 static LRESULT
971 TOOLBAR_ButtonCount (HWND hwnd, WPARAM wParam, LPARAM lParam)
972 {
973 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
974
975 return infoPtr->nNumButtons;
976 }
977
978
979 static LRESULT
980 TOOLBAR_ButtonStructSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
981 {
982 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
983
984 if (infoPtr == NULL) {
985 ERR (toolbar, "(0x%x, 0x%x, 0x%lx)\n", hwnd, wParam, lParam);
986 ERR (toolbar, "infoPtr == NULL!\n");
987 return 0;
988 }
989
990 infoPtr->dwStructSize = (DWORD)wParam;
991
992 return 0;
993 }
994
995
996 static LRESULT
997 TOOLBAR_ChangeBitmap (HWND hwnd, WPARAM wParam, LPARAM lParam)
998 {
999 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1000 TBUTTON_INFO *btnPtr;
1001 HDC hdc;
1002 INT nIndex;
1003
1004 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1005 if (nIndex == -1)
1006 return FALSE;
1007
1008 btnPtr = &infoPtr->buttons[nIndex];
1009 btnPtr->iBitmap = LOWORD(lParam);
1010
1011 hdc = GetDC (hwnd);
1012 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
1013 ReleaseDC (hwnd, hdc);
1014
1015 return TRUE;
1016 }
1017
1018
1019 static LRESULT
1020 TOOLBAR_CheckButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
1021 {
1022 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1023 TBUTTON_INFO *btnPtr;
1024 HDC hdc;
1025 INT nIndex;
1026 INT nOldIndex = -1;
1027
1028 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1029 if (nIndex == -1)
1030 return FALSE;
1031
1032 btnPtr = &infoPtr->buttons[nIndex];
1033
1034 if (!(btnPtr->fsStyle & TBSTYLE_CHECK))
1035 return FALSE;
1036
1037 if (LOWORD(lParam) == FALSE)
1038 btnPtr->fsState &= ~TBSTATE_CHECKED;
1039 else {
1040 if (btnPtr->fsStyle & TBSTYLE_GROUP) {
1041 nOldIndex =
1042 TOOLBAR_GetCheckedGroupButtonIndex (infoPtr, nIndex);
1043 if (nOldIndex == nIndex)
1044 return 0;
1045 if (nOldIndex != -1)
1046 infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
1047 }
1048 btnPtr->fsState |= TBSTATE_CHECKED;
1049 }
1050
1051 hdc = GetDC (hwnd);
1052 if (nOldIndex != -1)
1053 TOOLBAR_DrawButton (hwnd, &infoPtr->buttons[nOldIndex], hdc);
1054 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
1055 ReleaseDC (hwnd, hdc);
1056
1057 /* FIXME: Send a WM_NOTIFY?? */
1058
1059 return TRUE;
1060 }
1061
1062
1063 static LRESULT
1064 TOOLBAR_CommandToIndex (HWND hwnd, WPARAM wParam, LPARAM lParam)
1065 {
1066 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1067
1068 return TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1069 }
1070
1071
1072 static LRESULT
1073 TOOLBAR_Customize (HWND hwnd)
1074 {
1075 FIXME (toolbar, "customization not implemented!\n");
1076
1077 return 0;
1078 }
1079
1080
1081 static LRESULT
1082 TOOLBAR_DeleteButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
1083 {
1084 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1085 INT nIndex = (INT)wParam;
1086
1087 if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
1088 return FALSE;
1089
1090 if ((infoPtr->hwndToolTip) &&
1091 !(infoPtr->buttons[nIndex].fsStyle & TBSTYLE_SEP)) {
1092 TTTOOLINFOA ti;
1093
1094 ZeroMemory (&ti, sizeof(TTTOOLINFOA));
1095 ti.cbSize = sizeof (TTTOOLINFOA);
1096 ti.hwnd = hwnd;
1097 ti.uId = infoPtr->buttons[nIndex].idCommand;
1098
1099 SendMessageA (infoPtr->hwndToolTip, TTM_DELTOOLA, 0, (LPARAM)&ti);
1100 }
1101
1102 if (infoPtr->nNumButtons == 1) {
1103 TRACE (toolbar, " simple delete!\n");
1104 COMCTL32_Free (infoPtr->buttons);
1105 infoPtr->buttons = NULL;
1106 infoPtr->nNumButtons = 0;
1107 }
1108 else {
1109 TBUTTON_INFO *oldButtons = infoPtr->buttons;
1110 TRACE(toolbar, "complex delete! [nIndex=%d]\n", nIndex);
1111
1112 infoPtr->nNumButtons--;
1113 infoPtr->buttons = COMCTL32_Alloc (sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
1114 if (nIndex > 0) {
1115 memcpy (&infoPtr->buttons[0], &oldButtons[0],
1116 nIndex * sizeof(TBUTTON_INFO));
1117 }
1118
1119 if (nIndex < infoPtr->nNumButtons) {
1120 memcpy (&infoPtr->buttons[nIndex], &oldButtons[nIndex+1],
1121 (infoPtr->nNumButtons - nIndex) * sizeof(TBUTTON_INFO));
1122 }
1123
1124 COMCTL32_Free (oldButtons);
1125 }
1126
1127 TOOLBAR_CalcToolbar (hwnd);
1128
1129 InvalidateRect (hwnd, NULL, TRUE);
1130 UpdateWindow (hwnd);
1131
1132 return TRUE;
1133 }
1134
1135
1136 static LRESULT
1137 TOOLBAR_EnableButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
1138 {
1139 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1140 TBUTTON_INFO *btnPtr;
1141 HDC hdc;
1142 INT nIndex;
1143
1144 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1145 if (nIndex == -1)
1146 return FALSE;
1147
1148 btnPtr = &infoPtr->buttons[nIndex];
1149 if (LOWORD(lParam) == FALSE)
1150 btnPtr->fsState &= ~(TBSTATE_ENABLED | TBSTATE_PRESSED);
1151 else
1152 btnPtr->fsState |= TBSTATE_ENABLED;
1153
1154 hdc = GetDC (hwnd);
1155 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
1156 ReleaseDC (hwnd, hdc);
1157
1158 return TRUE;
1159 }
1160
1161
1162 /* << TOOLBAR_GetAnchorHighlight >> */
1163
1164
1165 static LRESULT
1166 TOOLBAR_GetBitmap (HWND hwnd, WPARAM wParam, LPARAM lParam)
1167 {
1168 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1169 INT nIndex;
1170
1171 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1172 if (nIndex == -1)
1173 return -1;
1174
1175 return infoPtr->buttons[nIndex].iBitmap;
1176 }
1177
1178
1179 static __inline__ LRESULT
1180 TOOLBAR_GetBitmapFlags (HWND hwnd, WPARAM wParam, LPARAM lParam)
1181 {
1182 return (GetDeviceCaps (0, LOGPIXELSX) >= 120) ? TBBF_LARGE : 0;
1183 }
1184
1185
1186 static LRESULT
1187 TOOLBAR_GetButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
1188 {
1189 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1190 LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
1191 INT nIndex = (INT)wParam;
1192 TBUTTON_INFO *btnPtr;
1193
1194 if (infoPtr == NULL)
1195 return FALSE;
1196
1197 if (lpTbb == NULL)
1198 return FALSE;
1199
1200 if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
1201 return FALSE;
1202
1203 btnPtr = &infoPtr->buttons[nIndex];
1204 lpTbb->iBitmap = btnPtr->iBitmap;
1205 lpTbb->idCommand = btnPtr->idCommand;
1206 lpTbb->fsState = btnPtr->fsState;
1207 lpTbb->fsStyle = btnPtr->fsStyle;
1208 lpTbb->dwData = btnPtr->dwData;
1209 lpTbb->iString = btnPtr->iString;
1210
1211 return TRUE;
1212 }
1213
1214
1215 static LRESULT
1216 TOOLBAR_GetButtonInfoA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1217 {
1218 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1219 LPTBBUTTONINFOA lpTbInfo = (LPTBBUTTONINFOA)lParam;
1220 TBUTTON_INFO *btnPtr;
1221 INT nIndex;
1222
1223 if (infoPtr == NULL)
1224 return -1;
1225 if (lpTbInfo == NULL)
1226 return -1;
1227 if (lpTbInfo->cbSize < sizeof(LPTBBUTTONINFOA))
1228 return -1;
1229
1230 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1231 if (nIndex == -1)
1232 return -1;
1233
1234 btnPtr = &infoPtr->buttons[nIndex];
1235
1236 if (lpTbInfo->dwMask & TBIF_COMMAND)
1237 lpTbInfo->idCommand = btnPtr->idCommand;
1238 if (lpTbInfo->dwMask & TBIF_IMAGE)
1239 lpTbInfo->iImage = btnPtr->iBitmap;
1240 if (lpTbInfo->dwMask & TBIF_LPARAM)
1241 lpTbInfo->lParam = btnPtr->dwData;
1242 if (lpTbInfo->dwMask & TBIF_SIZE)
1243 lpTbInfo->cx = (WORD)(btnPtr->rect.right - btnPtr->rect.left);
1244 if (lpTbInfo->dwMask & TBIF_STATE)
1245 lpTbInfo->fsState = btnPtr->fsState;
1246 if (lpTbInfo->dwMask & TBIF_STYLE)
1247 lpTbInfo->fsStyle = btnPtr->fsStyle;
1248 if (lpTbInfo->dwMask & TBIF_TEXT) {
1249 if ((btnPtr->iString >= 0) || (btnPtr->iString < infoPtr->nNumStrings))
1250 lstrcpynA (lpTbInfo->pszText,
1251 (LPSTR)infoPtr->strings[btnPtr->iString],
1252 lpTbInfo->cchText);
1253 }
1254
1255 return nIndex;
1256 }
1257
1258
1259 /* << TOOLBAR_GetButtonInfo32W >> */
1260
1261
1262 static LRESULT
1263 TOOLBAR_GetButtonSize (HWND hwnd)
1264 {
1265 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1266
1267 return MAKELONG((WORD)infoPtr->nButtonWidth,
1268 (WORD)infoPtr->nButtonHeight);
1269 }
1270
1271
1272 static LRESULT
1273 TOOLBAR_GetButtonTextA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1274 {
1275 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1276 INT nIndex, nStringIndex;
1277
1278 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1279 if (nIndex == -1)
1280 return -1;
1281
1282 nStringIndex = infoPtr->buttons[nIndex].iString;
1283
1284 TRACE (toolbar, "index=%d stringIndex=%d\n", nIndex, nStringIndex);
1285
1286 if ((nStringIndex < 0) || (nStringIndex >= infoPtr->nNumStrings))
1287 return -1;
1288
1289 if (lParam == 0) return -1;
1290
1291 lstrcpyA ((LPSTR)lParam, (LPSTR)infoPtr->strings[nStringIndex]);
1292
1293 return lstrlenA ((LPSTR)infoPtr->strings[nStringIndex]);
1294 }
1295
1296
1297 /* << TOOLBAR_GetButtonText32W >> */
1298 /* << TOOLBAR_GetColorScheme >> */
1299
1300
1301 static LRESULT
1302 TOOLBAR_GetDisabledImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
1303 {
1304 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1305
1306 if (GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT)
1307 return (LRESULT)infoPtr->himlDis;
1308 else
1309 return 0;
1310 }
1311
1312
1313 __inline__ static LRESULT
1314 TOOLBAR_GetExtendedStyle (HWND hwnd)
1315 {
1316 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1317
1318 return infoPtr->dwExStyle;
1319 }
1320
1321
1322 static LRESULT
1323 TOOLBAR_GetHotImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
1324 {
1325 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1326
1327 if (GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT)
1328 return (LRESULT)infoPtr->himlHot;
1329 else
1330 return 0;
1331 }
1332
1333
1334 /* << TOOLBAR_GetHotItem >> */
1335
1336
1337 static LRESULT
1338 TOOLBAR_GetImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
1339 {
1340 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1341
1342 if (GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT)
1343 return (LRESULT)infoPtr->himlDef;
1344 else
1345 return 0;
1346 }
1347
1348
1349 /* << TOOLBAR_GetInsertMark >> */
1350 /* << TOOLBAR_GetInsertMarkColor >> */
1351
1352
1353 static LRESULT
1354 TOOLBAR_GetItemRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
1355 {
1356 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1357 TBUTTON_INFO *btnPtr;
1358 LPRECT lpRect;
1359 INT nIndex;
1360
1361 if (infoPtr == NULL)
1362 return FALSE;
1363 nIndex = (INT)wParam;
1364 btnPtr = &infoPtr->buttons[nIndex];
1365 if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
1366 return FALSE;
1367 lpRect = (LPRECT)lParam;
1368 if (lpRect == NULL)
1369 return FALSE;
1370 if (btnPtr->fsState & TBSTATE_HIDDEN)
1371 return FALSE;
1372
1373 lpRect->left = btnPtr->rect.left;
1374 lpRect->right = btnPtr->rect.right;
1375 lpRect->bottom = btnPtr->rect.bottom;
1376 lpRect->top = btnPtr->rect.top;
1377
1378 return TRUE;
1379 }
1380
1381
1382 static LRESULT
1383 TOOLBAR_GetMaxSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
1384 {
1385 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1386 LPSIZE lpSize = (LPSIZE)lParam;
1387
1388 if (lpSize == NULL)
1389 return FALSE;
1390
1391 lpSize->cx = infoPtr->rcBound.right - infoPtr->rcBound.left;
1392 lpSize->cy = infoPtr->rcBound.bottom - infoPtr->rcBound.top;
1393
1394 TRACE (toolbar, "maximum size %d x %d\n",
1395 infoPtr->rcBound.right - infoPtr->rcBound.left,
1396 infoPtr->rcBound.bottom - infoPtr->rcBound.top);
1397
1398 return TRUE;
1399 }
1400
1401
1402 /* << TOOLBAR_GetObject >> */
1403 /* << TOOLBAR_GetPadding >> */
1404
1405
1406 static LRESULT
1407 TOOLBAR_GetRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
1408 {
1409 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1410 TBUTTON_INFO *btnPtr;
1411 LPRECT lpRect;
1412 INT nIndex;
1413
1414 if (infoPtr == NULL)
1415 return FALSE;
1416 nIndex = (INT)wParam;
1417 btnPtr = &infoPtr->buttons[nIndex];
1418 if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
1419 return FALSE;
1420 lpRect = (LPRECT)lParam;
1421 if (lpRect == NULL)
1422 return FALSE;
1423
1424 lpRect->left = btnPtr->rect.left;
1425 lpRect->right = btnPtr->rect.right;
1426 lpRect->bottom = btnPtr->rect.bottom;
1427 lpRect->top = btnPtr->rect.top;
1428
1429 return TRUE;
1430 }
1431
1432
1433 static LRESULT
1434 TOOLBAR_GetRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
1435 {
1436 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1437
1438 if (GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_WRAPABLE)
1439 return infoPtr->nRows;
1440 else
1441 return 1;
1442 }
1443
1444
1445 static LRESULT
1446 TOOLBAR_GetState (HWND hwnd, WPARAM wParam, LPARAM lParam)
1447 {
1448 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1449 INT nIndex;
1450
1451 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1452 if (nIndex == -1)
1453 return -1;
1454
1455 return infoPtr->buttons[nIndex].fsState;
1456 }
1457
1458
1459 static LRESULT
1460 TOOLBAR_GetStyle (HWND hwnd, WPARAM wParam, LPARAM lParam)
1461 {
1462 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1463 INT nIndex;
1464
1465 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1466 if (nIndex == -1)
1467 return -1;
1468
1469 return infoPtr->buttons[nIndex].fsStyle;
1470 }
1471
1472
1473 static LRESULT
1474 TOOLBAR_GetTextRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
1475 {
1476 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1477
1478 if (infoPtr == NULL)
1479 return 0;
1480
1481 return infoPtr->nMaxTextRows;
1482 }
1483
1484
1485 static LRESULT
1486 TOOLBAR_GetToolTips (HWND hwnd, WPARAM wParam, LPARAM lParam)
1487 {
1488 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1489
1490 if (infoPtr == NULL)
1491 return 0;
1492 return infoPtr->hwndToolTip;
1493 }
1494
1495
1496 static LRESULT
1497 TOOLBAR_GetUnicodeFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
1498 {
1499 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1500
1501 TRACE (toolbar, "%s hwnd=0x%x stub!\n",
1502 infoPtr->bUnicode ? "TRUE" : "FALSE", hwnd);
1503
1504 return infoPtr->bUnicode;
1505 }
1506
1507
1508 static LRESULT
1509 TOOLBAR_HideButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
1510 {
1511 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1512 TBUTTON_INFO *btnPtr;
1513 INT nIndex;
1514
1515 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1516 if (nIndex == -1)
1517 return FALSE;
1518
1519 btnPtr = &infoPtr->buttons[nIndex];
1520 if (LOWORD(lParam) == FALSE)
1521 btnPtr->fsState &= ~TBSTATE_HIDDEN;
1522 else
1523 btnPtr->fsState |= TBSTATE_HIDDEN;
1524
1525 TOOLBAR_CalcToolbar (hwnd);
1526
1527 InvalidateRect (hwnd, NULL, TRUE);
1528 UpdateWindow (hwnd);
1529
1530 return TRUE;
1531 }
1532
1533
1534 __inline__ static LRESULT
1535 TOOLBAR_HitTest (HWND hwnd, WPARAM wParam, LPARAM lParam)
1536 {
1537 return TOOLBAR_InternalHitTest (hwnd, (LPPOINT)lParam);
1538 }
1539
1540
1541 static LRESULT
1542 TOOLBAR_Indeterminate (HWND hwnd, WPARAM wParam, LPARAM lParam)
1543 {
1544 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1545 TBUTTON_INFO *btnPtr;
1546 HDC hdc;
1547 INT nIndex;
1548
1549 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1550 if (nIndex == -1)
1551 return FALSE;
1552
1553 btnPtr = &infoPtr->buttons[nIndex];
1554 if (LOWORD(lParam) == FALSE)
1555 btnPtr->fsState &= ~TBSTATE_INDETERMINATE;
1556 else
1557 btnPtr->fsState |= TBSTATE_INDETERMINATE;
1558
1559 hdc = GetDC (hwnd);
1560 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
1561 ReleaseDC (hwnd, hdc);
1562
1563 return TRUE;
1564 }
1565
1566
1567 static LRESULT
1568 TOOLBAR_InsertButtonA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1569 {
1570 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1571 LPTBBUTTON lpTbb = (LPTBBUTTON)lParam;
1572 INT nIndex = (INT)wParam;
1573 TBUTTON_INFO *oldButtons;
1574 HDC hdc;
1575
1576 if (lpTbb == NULL)
1577 return FALSE;
1578 if (nIndex < 0)
1579 return FALSE;
1580
1581 TRACE (toolbar, "inserting button index=%d\n", nIndex);
1582 if (nIndex > infoPtr->nNumButtons) {
1583 nIndex = infoPtr->nNumButtons;
1584 TRACE (toolbar, "adjust index=%d\n", nIndex);
1585 }
1586
1587 oldButtons = infoPtr->buttons;
1588 infoPtr->nNumButtons++;
1589 infoPtr->buttons = COMCTL32_Alloc (sizeof (TBUTTON_INFO) * infoPtr->nNumButtons);
1590 /* pre insert copy */
1591 if (nIndex > 0) {
1592 memcpy (&infoPtr->buttons[0], &oldButtons[0],
1593 nIndex * sizeof(TBUTTON_INFO));
1594 }
1595
1596 /* insert new button */
1597 infoPtr->buttons[nIndex].iBitmap = lpTbb->iBitmap;
1598 infoPtr->buttons[nIndex].idCommand = lpTbb->idCommand;
1599 infoPtr->buttons[nIndex].fsState = lpTbb->fsState;
1600 infoPtr->buttons[nIndex].fsStyle = lpTbb->fsStyle;
1601 infoPtr->buttons[nIndex].dwData = lpTbb->dwData;
1602 infoPtr->buttons[nIndex].iString = lpTbb->iString;
1603
1604 if ((infoPtr->hwndToolTip) && !(lpTbb->fsStyle & TBSTYLE_SEP)) {
1605 TTTOOLINFOA ti;
1606
1607 ZeroMemory (&ti, sizeof(TTTOOLINFOA));
1608 ti.cbSize = sizeof (TTTOOLINFOA);
1609 ti.hwnd = hwnd;
1610 ti.uId = lpTbb->idCommand;
1611 ti.hinst = 0;
1612 ti.lpszText = LPSTR_TEXTCALLBACKA;
1613
1614 SendMessageA (infoPtr->hwndToolTip, TTM_ADDTOOLA,
1615 0, (LPARAM)&ti);
1616 }
1617
1618 /* post insert copy */
1619 if (nIndex < infoPtr->nNumButtons - 1) {
1620 memcpy (&infoPtr->buttons[nIndex+1], &oldButtons[nIndex],
1621 (infoPtr->nNumButtons - nIndex - 1) * sizeof(TBUTTON_INFO));
1622 }
1623
1624 COMCTL32_Free (oldButtons);
1625
1626 TOOLBAR_CalcToolbar (hwnd);
1627
1628 hdc = GetDC (hwnd);
1629 TOOLBAR_Refresh (hwnd, hdc);
1630 ReleaseDC (hwnd, hdc);
1631
1632 return TRUE;
1633 }
1634
1635
1636 /* << TOOLBAR_InsertButton32W >> */
1637 /* << TOOLBAR_InsertMarkHitTest >> */
1638
1639
1640 static LRESULT
1641 TOOLBAR_IsButtonChecked (HWND hwnd, WPARAM wParam, LPARAM lParam)
1642 {
1643 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1644 INT nIndex;
1645
1646 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1647 if (nIndex == -1)
1648 return FALSE;
1649
1650 return (infoPtr->buttons[nIndex].fsState & TBSTATE_CHECKED);
1651 }
1652
1653
1654 static LRESULT
1655 TOOLBAR_IsButtonEnabled (HWND hwnd, WPARAM wParam, LPARAM lParam)
1656 {
1657 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1658 INT nIndex;
1659
1660 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1661 if (nIndex == -1)
1662 return FALSE;
1663
1664 return (infoPtr->buttons[nIndex].fsState & TBSTATE_ENABLED);
1665 }
1666
1667
1668 static LRESULT
1669 TOOLBAR_IsButtonHidden (HWND hwnd, WPARAM wParam, LPARAM lParam)
1670 {
1671 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1672 INT nIndex;
1673
1674 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1675 if (nIndex == -1)
1676 return FALSE;
1677
1678 return (infoPtr->buttons[nIndex].fsState & TBSTATE_HIDDEN);
1679 }
1680
1681
1682 static LRESULT
1683 TOOLBAR_IsButtonHighlighted (HWND hwnd, WPARAM wParam, LPARAM lParam)
1684 {
1685 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1686 INT nIndex;
1687
1688 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1689 if (nIndex == -1)
1690 return FALSE;
1691
1692 return (infoPtr->buttons[nIndex].fsState & TBSTATE_MARKED);
1693 }
1694
1695
1696 static LRESULT
1697 TOOLBAR_IsButtonIndeterminate (HWND hwnd, WPARAM wParam, LPARAM lParam)
1698 {
1699 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1700 INT nIndex;
1701
1702 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1703 if (nIndex == -1)
1704 return FALSE;
1705
1706 return (infoPtr->buttons[nIndex].fsState & TBSTATE_INDETERMINATE);
1707 }
1708
1709
1710 static LRESULT
1711 TOOLBAR_IsButtonPressed (HWND hwnd, WPARAM wParam, LPARAM lParam)
1712 {
1713 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1714 INT nIndex;
1715
1716 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1717 if (nIndex == -1)
1718 return FALSE;
1719
1720 return (infoPtr->buttons[nIndex].fsState & TBSTATE_PRESSED);
1721 }
1722
1723
1724 /* << TOOLBAR_LoadImages >> */
1725 /* << TOOLBAR_MapAccelerator >> */
1726 /* << TOOLBAR_MarkButton >> */
1727 /* << TOOLBAR_MoveButton >> */
1728
1729
1730 static LRESULT
1731 TOOLBAR_PressButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
1732 {
1733 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1734 TBUTTON_INFO *btnPtr;
1735 HDC hdc;
1736 INT nIndex;
1737
1738 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1739 if (nIndex == -1)
1740 return FALSE;
1741
1742 btnPtr = &infoPtr->buttons[nIndex];
1743 if (LOWORD(lParam) == FALSE)
1744 btnPtr->fsState &= ~TBSTATE_PRESSED;
1745 else
1746 btnPtr->fsState |= TBSTATE_PRESSED;
1747
1748 hdc = GetDC (hwnd);
1749 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
1750 ReleaseDC (hwnd, hdc);
1751
1752 return TRUE;
1753 }
1754
1755
1756 /* << TOOLBAR_ReplaceBitmap >> */
1757
1758
1759 static LRESULT
1760 TOOLBAR_SaveRestoreA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1761 {
1762 #if 0
1763 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1764 LPTBSAVEPARAMSA lpSave = (LPTBSAVEPARAMSA)lParam;
1765
1766 if (lpSave == NULL) return 0;
1767
1768 if ((BOOL)wParam) {
1769 /* save toolbar information */
1770 FIXME (toolbar, "save to \"%s\" \"%s\"\n",
1771 lpSave->pszSubKey, lpSave->pszValueName);
1772
1773
1774 }
1775 else {
1776 /* restore toolbar information */
1777
1778 FIXME (toolbar, "restore from \"%s\" \"%s\"\n",
1779 lpSave->pszSubKey, lpSave->pszValueName);
1780
1781
1782 }
1783 #endif
1784
1785 return 0;
1786 }
1787
1788
1789 /* << TOOLBAR_SaveRestore32W >> */
1790 /* << TOOLBAR_SetAnchorHighlight >> */
1791
1792
1793 static LRESULT
1794 TOOLBAR_SetBitmapSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
1795 {
1796 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1797
1798 if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0))
1799 return FALSE;
1800
1801 infoPtr->nBitmapWidth = (INT)LOWORD(lParam);
1802 infoPtr->nBitmapHeight = (INT)HIWORD(lParam);
1803
1804 return TRUE;
1805 }
1806
1807
1808 static LRESULT
1809 TOOLBAR_SetButtonInfoA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1810 {
1811 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1812 LPTBBUTTONINFOA lptbbi = (LPTBBUTTONINFOA)lParam;
1813 TBUTTON_INFO *btnPtr;
1814 INT nIndex;
1815
1816 if (lptbbi == NULL)
1817 return FALSE;
1818 if (lptbbi->cbSize < sizeof(LPTBBUTTONINFOA))
1819 return FALSE;
1820
1821 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
1822 if (nIndex == -1)
1823 return FALSE;
1824
1825 btnPtr = &infoPtr->buttons[nIndex];
1826 if (lptbbi->dwMask & TBIF_COMMAND)
1827 btnPtr->idCommand = lptbbi->idCommand;
1828 if (lptbbi->dwMask & TBIF_IMAGE)
1829 btnPtr->iBitmap = lptbbi->iImage;
1830 if (lptbbi->dwMask & TBIF_LPARAM)
1831 btnPtr->dwData = lptbbi->lParam;
1832 /* if (lptbbi->dwMask & TBIF_SIZE) */
1833 /* btnPtr->cx = lptbbi->cx; */
1834 if (lptbbi->dwMask & TBIF_STATE)
1835 btnPtr->fsState = lptbbi->fsState;
1836 if (lptbbi->dwMask & TBIF_STYLE)
1837 btnPtr->fsStyle = lptbbi->fsStyle;
1838
1839 if (lptbbi->dwMask & TBIF_TEXT) {
1840 if ((btnPtr->iString >= 0) ||
1841 (btnPtr->iString < infoPtr->nNumStrings)) {
1842 #if 0
1843 CHAR **lpString = &infoPtr->strings[btnPtr->iString];
1844 INT len = lstrlenA (lptbbi->pszText);
1845 *lpString = COMCTL32_ReAlloc (lpString, sizeof(char)*(len+1));
1846 #endif
1847
1848 /* this is the ultimate sollution */
1849 /* Str_SetPtrA (&infoPtr->strings[btnPtr->iString], lptbbi->pszText); */
1850 }
1851 }
1852
1853 return TRUE;
1854 }
1855
1856
1857 /* << TOOLBAR_SetButtonInfo32W >> */
1858
1859
1860 static LRESULT
1861 TOOLBAR_SetButtonSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
1862 {
1863 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1864
1865 if ((LOWORD(lParam) <= 0) || (HIWORD(lParam)<=0))
1866 return FALSE;
1867
1868 infoPtr->nButtonWidth = (INT)LOWORD(lParam);
1869 infoPtr->nButtonHeight = (INT)HIWORD(lParam);
1870
1871 return TRUE;
1872 }
1873
1874
1875 static LRESULT
1876 TOOLBAR_SetButtonWidth (HWND hwnd, WPARAM wParam, LPARAM lParam)
1877 {
1878 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1879
1880 if (infoPtr == NULL)
1881 return FALSE;
1882
1883 infoPtr->cxMin = (INT)LOWORD(lParam);
1884 infoPtr->cxMax = (INT)HIWORD(lParam);
1885
1886 return TRUE;
1887 }
1888
1889
1890 static LRESULT
1891 TOOLBAR_SetCmdId (HWND hwnd, WPARAM wParam, LPARAM lParam)
1892 {
1893 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1894 INT nIndex = (INT)wParam;
1895
1896 if ((nIndex < 0) || (nIndex >= infoPtr->nNumButtons))
1897 return FALSE;
1898
1899 infoPtr->buttons[nIndex].idCommand = (INT)lParam;
1900
1901 if (infoPtr->hwndToolTip) {
1902
1903 FIXME (toolbar, "change tool tip!\n");
1904
1905 }
1906
1907 return TRUE;
1908 }
1909
1910
1911 /* << TOOLBAR_SetColorScheme >> */
1912
1913
1914 static LRESULT
1915 TOOLBAR_SetDisabledImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
1916 {
1917 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1918 HIMAGELIST himlTemp;
1919
1920 if (!(GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT))
1921 return 0;
1922
1923 himlTemp = infoPtr->himlDis;
1924 infoPtr->himlDis = (HIMAGELIST)lParam;
1925
1926 /* FIXME: redraw ? */
1927
1928 return (LRESULT)himlTemp;
1929 }
1930
1931
1932 static LRESULT
1933 TOOLBAR_SetDrawTextFlags (HWND hwnd, WPARAM wParam, LPARAM lParam)
1934 {
1935 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1936 DWORD dwTemp;
1937
1938 dwTemp = infoPtr->dwDTFlags;
1939 infoPtr->dwDTFlags =
1940 (infoPtr->dwDTFlags & (DWORD)wParam) | (DWORD)lParam;
1941
1942 return (LRESULT)dwTemp;
1943 }
1944
1945
1946 static LRESULT
1947 TOOLBAR_SetExtendedStyle (HWND hwnd, WPARAM wParam, LPARAM lParam)
1948 {
1949 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1950 DWORD dwTemp;
1951
1952 dwTemp = infoPtr->dwExStyle;
1953 infoPtr->dwExStyle = (DWORD)lParam;
1954
1955 return (LRESULT)dwTemp;
1956 }
1957
1958
1959 static LRESULT
1960 TOOLBAR_SetHotImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
1961 {
1962 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr(hwnd);
1963 HIMAGELIST himlTemp;
1964
1965 if (!(GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT))
1966 return 0;
1967
1968 himlTemp = infoPtr->himlHot;
1969 infoPtr->himlHot = (HIMAGELIST)lParam;
1970
1971 /* FIXME: redraw ? */
1972
1973 return (LRESULT)himlTemp;
1974 }
1975
1976
1977 /* << TOOLBAR_SetHotItem >> */
1978
1979
1980 static LRESULT
1981 TOOLBAR_SetImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
1982 {
1983 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
1984 HIMAGELIST himlTemp;
1985
1986 if (!(GetWindowLongA (hwnd, GWL_STYLE) & TBSTYLE_FLAT))
1987 return 0;
1988
1989 himlTemp = infoPtr->himlDef;
1990 infoPtr->himlDef = (HIMAGELIST)lParam;
1991
1992 /* FIXME: redraw ? */
1993
1994 return (LRESULT)himlTemp;
1995 }
1996
1997
1998 static LRESULT
1999 TOOLBAR_SetIndent (HWND hwnd, WPARAM wParam, LPARAM lParam)
2000 {
2001 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2002 HDC hdc;
2003
2004 infoPtr->nIndent = (INT)wParam;
2005
2006 TOOLBAR_CalcToolbar (hwnd);
2007
2008 hdc = GetDC (hwnd);
2009 TOOLBAR_Refresh (hwnd, hdc);
2010 ReleaseDC (hwnd, hdc);
2011
2012 return TRUE;
2013 }
2014
2015
2016 /* << TOOLBAR_SetInsertMark >> */
2017
2018
2019 static LRESULT
2020 TOOLBAR_SetInsertMarkColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
2021 {
2022 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2023
2024 infoPtr->clrInsertMark = (COLORREF)lParam;
2025
2026 /* FIXME : redraw ??*/
2027
2028 return 0;
2029 }
2030
2031
2032 static LRESULT
2033 TOOLBAR_SetMaxTextRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
2034 {
2035 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2036
2037 if (infoPtr == NULL)
2038 return FALSE;
2039
2040 infoPtr->nMaxTextRows = (INT)wParam;
2041
2042 return TRUE;
2043 }
2044
2045
2046 /* << TOOLBAR_SetPadding >> */
2047
2048
2049 static LRESULT
2050 TOOLBAR_SetParent (HWND hwnd, WPARAM wParam, LPARAM lParam)
2051 {
2052 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2053 HWND hwndOldNotify;
2054
2055 if (infoPtr == NULL)
2056 return 0;
2057 hwndOldNotify = infoPtr->hwndNotify;
2058 infoPtr->hwndNotify = (HWND)wParam;
2059
2060 return hwndOldNotify;
2061 }
2062
2063
2064 static LRESULT
2065 TOOLBAR_SetRows (HWND hwnd, WPARAM wParam, LPARAM lParam)
2066 {
2067 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2068 LPRECT lprc = (LPRECT)lParam;
2069 HDC hdc;
2070
2071 if (LOWORD(wParam) > 1) {
2072
2073 FIXME (toolbar, "multiple rows not supported!\n");
2074
2075 }
2076
2077 /* recalculate toolbar */
2078 TOOLBAR_CalcToolbar (hwnd);
2079
2080 /* return bounding rectangle */
2081 if (lprc) {
2082 lprc->left = infoPtr->rcBound.left;
2083 lprc->right = infoPtr->rcBound.right;
2084 lprc->top = infoPtr->rcBound.top;
2085 lprc->bottom = infoPtr->rcBound.bottom;
2086 }
2087
2088 /* repaint toolbar */
2089 hdc = GetDC (hwnd);
2090 TOOLBAR_Refresh (hwnd, hdc);
2091 ReleaseDC (hwnd, hdc);
2092
2093 return 0;
2094 }
2095
2096
2097 static LRESULT
2098 TOOLBAR_SetState (HWND hwnd, WPARAM wParam, LPARAM lParam)
2099 {
2100 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2101 TBUTTON_INFO *btnPtr;
2102 HDC hdc;
2103 INT nIndex;
2104
2105 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2106 if (nIndex == -1)
2107 return FALSE;
2108
2109 btnPtr = &infoPtr->buttons[nIndex];
2110 btnPtr->fsState = LOWORD(lParam);
2111
2112 hdc = GetDC (hwnd);
2113 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
2114 ReleaseDC (hwnd, hdc);
2115
2116 return TRUE;
2117 }
2118
2119
2120 static LRESULT
2121 TOOLBAR_SetStyle (HWND hwnd, WPARAM wParam, LPARAM lParam)
2122 {
2123 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2124 TBUTTON_INFO *btnPtr;
2125 HDC hdc;
2126 INT nIndex;
2127
2128 nIndex = TOOLBAR_GetButtonIndex (infoPtr, (INT)wParam);
2129 if (nIndex == -1)
2130 return FALSE;
2131
2132 btnPtr = &infoPtr->buttons[nIndex];
2133 btnPtr->fsStyle = LOWORD(lParam);
2134
2135 hdc = GetDC (hwnd);
2136 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
2137 ReleaseDC (hwnd, hdc);
2138
2139 if (infoPtr->hwndToolTip) {
2140
2141 FIXME (toolbar, "change tool tip!\n");
2142
2143 }
2144
2145 return TRUE;
2146 }
2147
2148
2149 __inline__ static LRESULT
2150 TOOLBAR_SetToolTips (HWND hwnd, WPARAM wParam, LPARAM lParam)
2151 {
2152 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2153
2154 if (infoPtr == NULL)
2155 return 0;
2156 infoPtr->hwndToolTip = (HWND)wParam;
2157 return 0;
2158 }
2159
2160
2161 static LRESULT
2162 TOOLBAR_SetUnicodeFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
2163 {
2164 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2165 BOOL bTemp;
2166
2167 TRACE (toolbar, "%s hwnd=0x%04x stub!\n",
2168 ((BOOL)wParam) ? "TRUE" : "FALSE", hwnd);
2169
2170 bTemp = infoPtr->bUnicode;
2171 infoPtr->bUnicode = (BOOL)wParam;
2172
2173 return bTemp;
2174 }
2175
2176
2177 static LRESULT
2178 TOOLBAR_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
2179 {
2180 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2181 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
2182 LOGFONTA logFont;
2183
2184 /* initialize info structure */
2185 infoPtr->nButtonHeight = 22;
2186 infoPtr->nButtonWidth = 23;
2187 infoPtr->nBitmapHeight = 15;
2188 infoPtr->nBitmapWidth = 16;
2189
2190 infoPtr->nHeight = infoPtr->nButtonHeight + TOP_BORDER + BOTTOM_BORDER;
2191 infoPtr->nRows = 1;
2192 infoPtr->nMaxTextRows = 1;
2193 infoPtr->cxMin = -1;
2194 infoPtr->cxMax = -1;
2195
2196 infoPtr->bCaptured = FALSE;
2197 infoPtr->bUnicode = IsWindowUnicode (hwnd);
2198 infoPtr->nButtonDown = -1;
2199 infoPtr->nOldHit = -1;
2200 infoPtr->nHotItem = -2; // It has to be initially different from nOldHit
2201 infoPtr->hwndNotify = GetParent (hwnd);
2202 infoPtr->bTransparent = (dwStyle & TBSTYLE_FLAT);
2203 infoPtr->dwDTFlags = DT_CENTER;
2204
2205 SystemParametersInfoA (SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
2206 infoPtr->hFont = CreateFontIndirectA (&logFont);
2207
2208 if (dwStyle & TBSTYLE_TOOLTIPS) {
2209 /* Create tooltip control */
2210 infoPtr->hwndToolTip =
2211 CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
2212 CW_USEDEFAULT, CW_USEDEFAULT,
2213 CW_USEDEFAULT, CW_USEDEFAULT,
2214 hwnd, 0, 0, 0);
2215
2216 /* Send NM_TOOLTIPSCREATED notification */
2217 if (infoPtr->hwndToolTip) {
2218 NMTOOLTIPSCREATED nmttc;
2219
2220 nmttc.hdr.hwndFrom = hwnd;
2221 nmttc.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
2222 nmttc.hdr.code = NM_TOOLTIPSCREATED;
2223 nmttc.hwndToolTips = infoPtr->hwndToolTip;
2224
2225 SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
2226 (WPARAM)nmttc.hdr.idFrom, (LPARAM)&nmttc);
2227 }
2228 }
2229
2230 return 0;
2231 }
2232
2233
2234 static LRESULT
2235 TOOLBAR_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
2236 {
2237 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2238
2239 /* delete tooltip control */
2240 if (infoPtr->hwndToolTip)
2241 DestroyWindow (infoPtr->hwndToolTip);
2242
2243 /* delete button data */
2244 if (infoPtr->buttons)
2245 COMCTL32_Free (infoPtr->buttons);
2246
2247 /* delete strings */
2248 if (infoPtr->strings) {
2249 INT i;
2250 for (i = 0; i < infoPtr->nNumStrings; i++)
2251 if (infoPtr->strings[i])
2252 COMCTL32_Free (infoPtr->strings[i]);
2253
2254 COMCTL32_Free (infoPtr->strings);
2255 }
2256
2257 /* destroy default image list */
2258 if (infoPtr->himlDef)
2259 ImageList_Destroy (infoPtr->himlDef);
2260
2261 /* destroy disabled image list */
2262 if (infoPtr->himlDis)
2263 ImageList_Destroy (infoPtr->himlDis);
2264
2265 /* destroy hot image list */
2266 if (infoPtr->himlHot)
2267 ImageList_Destroy (infoPtr->himlHot);
2268
2269 /* delete default font */
2270 if (infoPtr->hFont)
2271 DeleteObject (infoPtr->hFont);
2272
2273 /* free toolbar info data */
2274 COMCTL32_Free (infoPtr);
2275
2276 return 0;
2277 }
2278
2279
2280 static LRESULT
2281 TOOLBAR_EraseBackground (HWND hwnd, WPARAM wParam, LPARAM lParam)
2282 {
2283 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2284
2285 if (infoPtr->bTransparent)
2286 return SendMessageA (GetParent (hwnd), WM_ERASEBKGND, wParam, lParam);
2287
2288 return DefWindowProcA (hwnd, WM_ERASEBKGND, wParam, lParam);
2289 }
2290
2291
2292 static LRESULT
2293 TOOLBAR_LButtonDblClk (HWND hwnd, WPARAM wParam, LPARAM lParam)
2294 {
2295 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2296 TBUTTON_INFO *btnPtr;
2297 POINT pt;
2298 INT nHit;
2299 HDC hdc;
2300
2301 pt.x = (INT)LOWORD(lParam);
2302 pt.y = (INT)HIWORD(lParam);
2303 nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
2304
2305 if (nHit >= 0) {
2306 btnPtr = &infoPtr->buttons[nHit];
2307 if (!(btnPtr->fsState & TBSTATE_ENABLED))
2308 return 0;
2309 SetCapture (hwnd);
2310 infoPtr->bCaptured = TRUE;
2311 infoPtr->nButtonDown = nHit;
2312
2313 btnPtr->fsState |= TBSTATE_PRESSED;
2314
2315 hdc = GetDC (hwnd);
2316 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
2317 ReleaseDC (hwnd, hdc);
2318 }
2319 else if (GetWindowLongA (hwnd, GWL_STYLE) & CCS_ADJUSTABLE)
2320 TOOLBAR_Customize (hwnd);
2321
2322 return 0;
2323 }
2324
2325
2326 static LRESULT
2327 TOOLBAR_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
2328 {
2329 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2330 TBUTTON_INFO *btnPtr;
2331 POINT pt;
2332 INT nHit;
2333 HDC hdc;
2334
2335 if (infoPtr->hwndToolTip)
2336 TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
2337 WM_LBUTTONDOWN, wParam, lParam);
2338
2339 pt.x = (INT)LOWORD(lParam);
2340 pt.y = (INT)HIWORD(lParam);
2341 nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
2342
2343 if (nHit >= 0) {
2344 btnPtr = &infoPtr->buttons[nHit];
2345 if (!(btnPtr->fsState & TBSTATE_ENABLED))
2346 return 0;
2347
2348 SetCapture (hwnd);
2349 infoPtr->bCaptured = TRUE;
2350 infoPtr->nButtonDown = nHit;
2351 infoPtr->nOldHit = nHit;
2352
2353 btnPtr->fsState |= TBSTATE_PRESSED;
2354
2355 hdc = GetDC (hwnd);
2356 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
2357 ReleaseDC (hwnd, hdc);
2358 }
2359
2360 return 0;
2361 }
2362
2363
2364 static LRESULT
2365 TOOLBAR_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
2366 {
2367 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2368 TBUTTON_INFO *btnPtr;
2369 POINT pt;
2370 INT nHit;
2371 INT nOldIndex = -1;
2372 HDC hdc;
2373 BOOL bSendMessage = TRUE;
2374
2375 if (infoPtr->hwndToolTip)
2376 TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
2377 WM_LBUTTONUP, wParam, lParam);
2378
2379 pt.x = (INT)LOWORD(lParam);
2380 pt.y = (INT)HIWORD(lParam);
2381 nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
2382
2383 if ((infoPtr->bCaptured) && (infoPtr->nButtonDown >= 0)) {
2384 infoPtr->bCaptured = FALSE;
2385 ReleaseCapture ();
2386 btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
2387 btnPtr->fsState &= ~TBSTATE_PRESSED;
2388
2389 if (nHit == infoPtr->nButtonDown) {
2390 if (btnPtr->fsStyle & TBSTYLE_CHECK) {
2391 if (btnPtr->fsStyle & TBSTYLE_GROUP) {
2392 nOldIndex = TOOLBAR_GetCheckedGroupButtonIndex (infoPtr,
2393 infoPtr->nButtonDown);
2394 if (nOldIndex == infoPtr->nButtonDown)
2395 bSendMessage = FALSE;
2396 if ((nOldIndex != infoPtr->nButtonDown) &&
2397 (nOldIndex != -1))
2398 infoPtr->buttons[nOldIndex].fsState &= ~TBSTATE_CHECKED;
2399 btnPtr->fsState |= TBSTATE_CHECKED;
2400 }
2401 else {
2402 if (btnPtr->fsState & TBSTATE_CHECKED)
2403 btnPtr->fsState &= ~TBSTATE_CHECKED;
2404 else
2405 btnPtr->fsState |= TBSTATE_CHECKED;
2406 }
2407 }
2408 }
2409 else
2410 bSendMessage = FALSE;
2411
2412 hdc = GetDC (hwnd);
2413 if (nOldIndex != -1)
2414 TOOLBAR_DrawButton (hwnd, &infoPtr->buttons[nOldIndex], hdc);
2415 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
2416 ReleaseDC (hwnd, hdc);
2417
2418 if (bSendMessage)
2419 SendMessageA (infoPtr->hwndNotify, WM_COMMAND,
2420 MAKEWPARAM(btnPtr->idCommand, 0), (LPARAM)hwnd);
2421
2422 infoPtr->nButtonDown = -1;
2423 infoPtr->nOldHit = -1;
2424 }
2425
2426 return 0;
2427 }
2428
2429
2430 static LRESULT
2431 TOOLBAR_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
2432 {
2433 TBUTTON_INFO *btnPtr, *oldBtnPtr;
2434 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2435 POINT pt;
2436 INT nHit;
2437 HDC hdc;
2438
2439 if (infoPtr->hwndToolTip)
2440 TOOLBAR_RelayEvent (infoPtr->hwndToolTip, hwnd,
2441 WM_MOUSEMOVE, wParam, lParam);
2442
2443 pt.x = (INT)LOWORD(lParam);
2444 pt.y = (INT)HIWORD(lParam);
2445
2446 nHit = TOOLBAR_InternalHitTest (hwnd, &pt);
2447
2448 if (infoPtr->nOldHit != nHit)
2449 {
2450 //Remove the effect of an old hot button
2451 if(infoPtr->nOldHit == infoPtr->nHotItem)
2452 {
2453 oldBtnPtr = &infoPtr->buttons[infoPtr->nOldHit];
2454 oldBtnPtr->bHot = FALSE;
2455
2456 InvalidateRect (hwnd, &oldBtnPtr->rect, TRUE);
2457 }
2458
2459 // It's not a separator or in nowhere. It's a hot button.
2460 if (nHit >= 0)
2461 {
2462 btnPtr = &infoPtr->buttons[nHit];
2463 btnPtr->bHot = TRUE;
2464
2465 hdc = GetDC (hwnd);
2466 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
2467 ReleaseDC (hwnd, hdc);
2468
2469 infoPtr->nHotItem = nHit;
2470 }
2471
2472 if (infoPtr->bCaptured) {
2473 btnPtr = &infoPtr->buttons[infoPtr->nButtonDown];
2474 if (infoPtr->nOldHit == infoPtr->nButtonDown) {
2475 btnPtr->fsState &= ~TBSTATE_PRESSED;
2476 hdc = GetDC (hwnd);
2477 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
2478 ReleaseDC (hwnd, hdc);
2479 }
2480 else if (nHit == infoPtr->nButtonDown) {
2481 btnPtr->fsState |= TBSTATE_PRESSED;
2482 hdc = GetDC (hwnd);
2483 TOOLBAR_DrawButton (hwnd, btnPtr, hdc);
2484 ReleaseDC (hwnd, hdc);
2485 }
2486 }
2487 infoPtr->nOldHit = nHit;
2488 }
2489 return 0;
2490 }
2491
2492
2493 __inline__ static LRESULT
2494 TOOLBAR_NCActivate (HWND hwnd, WPARAM wParam, LPARAM lParam)
2495 {
2496 /* if (wndPtr->dwStyle & CCS_NODIVIDER) */
2497 return DefWindowProcA (hwnd, WM_NCACTIVATE, wParam, lParam);
2498 /* else */
2499 /* return TOOLBAR_NCPaint (wndPtr, wParam, lParam); */
2500 }
2501
2502
2503 __inline__ static LRESULT
2504 TOOLBAR_NCCalcSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
2505 {
2506 if (!(GetWindowLongA (hwnd, GWL_STYLE) & CCS_NODIVIDER))
2507 ((LPRECT)lParam)->top += sysMetrics[SM_CYEDGE];
2508
2509 return DefWindowProcA (hwnd, WM_NCCALCSIZE, wParam, lParam);
2510 }
2511
2512
2513 static LRESULT
2514 TOOLBAR_NCCreate (HWND hwnd, WPARAM wParam, LPARAM lParam)
2515 {
2516 TOOLBAR_INFO *infoPtr;
2517
2518 /* allocate memory for info structure */
2519 infoPtr = (TOOLBAR_INFO *)COMCTL32_Alloc (sizeof(TOOLBAR_INFO));
2520 SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
2521
2522 /* paranoid!! */
2523 infoPtr->dwStructSize = sizeof(TBBUTTON);
2524
2525 /* fix instance handle, if the toolbar was created by CreateToolbarEx() */
2526 if (!GetWindowLongA (hwnd, GWL_HINSTANCE)) {
2527 HINSTANCE hInst = (HINSTANCE)GetWindowLongA (GetParent (hwnd), GWL_HINSTANCE);
2528 SetWindowLongA (hwnd, GWL_HINSTANCE, (DWORD)hInst);
2529 }
2530
2531 return DefWindowProcA (hwnd, WM_NCCREATE, wParam, lParam);
2532 }
2533
2534
2535 static LRESULT
2536 TOOLBAR_NCPaint (HWND hwnd, WPARAM wParam, LPARAM lParam)
2537 {
2538 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
2539 RECT rcWindow;
2540 HDC hdc;
2541
2542 if (dwStyle & WS_MINIMIZE)
2543 return 0; /* Nothing to do */
2544
2545 DefWindowProcA (hwnd, WM_NCPAINT, wParam, lParam);
2546
2547 if (!(hdc = GetDCEx (hwnd, 0, DCX_USESTYLE | DCX_WINDOW)))
2548 return 0;
2549
2550 if (!(dwStyle & CCS_NODIVIDER))
2551 {
2552 GetWindowRect (hwnd, &rcWindow);
2553 OffsetRect (&rcWindow, -rcWindow.left, -rcWindow.top);
2554 DrawEdge (hdc, &rcWindow, EDGE_ETCHED, BF_TOP);
2555 }
2556
2557 ReleaseDC( hwnd, hdc );
2558
2559 return 0;
2560 }
2561
2562
2563 __inline__ static LRESULT
2564 TOOLBAR_Notify (HWND hwnd, WPARAM wParam, LPARAM lParam)
2565 {
2566 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2567 LPNMHDR lpnmh = (LPNMHDR)lParam;
2568
2569 TRACE (toolbar, "passing WM_NOTIFY!\n");
2570
2571 if ((infoPtr->hwndToolTip) && (lpnmh->hwndFrom == infoPtr->hwndToolTip)) {
2572 SendMessageA (infoPtr->hwndNotify, WM_NOTIFY, wParam, lParam);
2573
2574 #if 0
2575 if (lpnmh->code == TTN_GETDISPINFOA) {
2576 LPNMTTDISPINFOA lpdi = (LPNMTTDISPINFOA)lParam;
2577
2578 FIXME (toolbar, "retrieving ASCII string\n");
2579
2580 }
2581 else if (lpnmh->code == TTN_GETDISPINFOW) {
2582 LPNMTTDISPINFOW lpdi = (LPNMTTDISPINFOW)lParam;
2583
2584 FIXME (toolbar, "retrieving UNICODE string\n");
2585
2586 }
2587 #endif
2588 }
2589
2590 return 0;
2591 }
2592
2593
2594 static LRESULT
2595 TOOLBAR_Paint (HWND hwnd, WPARAM wParam)
2596 {
2597 HDC hdc;
2598 PAINTSTRUCT ps;
2599
2600 hdc = wParam==0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
2601 TOOLBAR_Refresh (hwnd, hdc);
2602 if (!wParam)
2603 EndPaint (hwnd, &ps);
2604 return 0;
2605 }
2606
2607
2608 static LRESULT
2609 TOOLBAR_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
2610 {
2611 TOOLBAR_INFO *infoPtr = TOOLBAR_GetInfoPtr (hwnd);
2612 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
2613 RECT parent_rect;
2614 HWND parent;
2615 /* INT32 x, y; */
2616 INT cx, cy;
2617 INT flags;
2618 UINT uPosFlags = 0;
2619
2620 /* Resize deadlock check */
2621 if (infoPtr->bAutoSize) {
2622 infoPtr->bAutoSize = FALSE;
2623 return 0;
2624 }
2625
2626 flags = (INT) wParam;
2627
2628 /* FIXME for flags =
2629 * SIZE_MAXIMIZED, SIZE_MAXSHOW, SIZE_MINIMIZED
2630 */
2631
2632 TRACE (toolbar, "sizing toolbar!\n");
2633
2634 if (flags == SIZE_RESTORED) {
2635 /* width and height don't apply */
2636 parent = GetParent (hwnd);
2637 GetClientRect(parent, &parent_rect);
2638
2639 if (dwStyle & CCS_NORESIZE) {
2640 uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
2641
2642 /* FIXME */
2643 /* infoPtr->nWidth = parent_rect.right - parent_rect.left; */
2644 cy = infoPtr->nHeight;
2645 cx = infoPtr->nWidth;
2646 TOOLBAR_CalcToolbar (hwnd);
2647 infoPtr->nWidth = cx;
2648 infoPtr->nHeight = cy;
2649 }
2650 else {
2651 infoPtr->nWidth = parent_rect.right - parent_rect.left;
2652 TOOLBAR_CalcToolbar (hwnd);
2653 cy = infoPtr->nHeight;
2654 cx = infoPtr->nWidth;
2655 }
2656
2657 if (dwStyle & CCS_NOPARENTALIGN) {
2658 uPosFlags |= SWP_NOMOVE;
2659 cy = infoPtr->nHeight;
2660 cx = infoPtr->nWidth;
2661 }
2662
2663 if (!(dwStyle & CCS_NODIVIDER))
2664 cy += sysMetrics[SM_CYEDGE];
2665
2666 SetWindowPos (hwnd, 0, parent_rect.left, parent_rect.top,
2667 cx, cy, uPosFlags | SWP_NOZORDER);
2668 }
2669 return 0;
2670 }
2671
2672
2673 static LRESULT
2674 TOOLBAR_StyleChanged (HWND hwnd, WPARAM wParam, LPARAM lParam)
2675 {
2676 HDC hdc;
2677
2678 TOOLBAR_AutoSize (hwnd, wParam, lParam);
2679
2680 hdc = GetDC (hwnd);
2681 TOOLBAR_Refresh (hwnd, hdc);
2682 ReleaseDC (hwnd, hdc);
2683
2684 return 0;
2685 }
2686
2687
2688
2689 LRESULT WINAPI
2690 ToolbarWindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
2691 {
2692 switch (uMsg)
2693 {
2694 case TB_ADDBITMAP:
2695 return TOOLBAR_AddBitmap (hwnd, wParam, lParam);
2696
2697 case TB_ADDBUTTONSA:
2698 return TOOLBAR_AddButtonsA (hwnd, wParam, lParam);
2699
2700 /* case TB_ADDBUTTONS32W: */
2701
2702 case TB_ADDSTRINGA:
2703 return TOOLBAR_AddStringA (hwnd, wParam, lParam);
2704
2705 case TB_ADDSTRINGW:
2706 return TOOLBAR_AddStringW (hwnd, wParam, lParam);
2707
2708 case TB_AUTOSIZE:
2709 return TOOLBAR_AutoSize (hwnd, wParam, lParam);
2710
2711 case TB_BUTTONCOUNT:
2712 return TOOLBAR_ButtonCount (hwnd, wParam, lParam);
2713
2714 case TB_BUTTONSTRUCTSIZE:
2715 return TOOLBAR_ButtonStructSize (hwnd, wParam, lParam);
2716
2717 case TB_CHANGEBITMAP:
2718 return TOOLBAR_ChangeBitmap (hwnd, wParam, lParam);
2719
2720 case TB_CHECKBUTTON:
2721 return TOOLBAR_CheckButton (hwnd, wParam, lParam);
2722
2723 case TB_COMMANDTOINDEX:
2724 return TOOLBAR_CommandToIndex (hwnd, wParam, lParam);
2725
2726 case TB_CUSTOMIZE:
2727 return TOOLBAR_Customize (hwnd);
2728
2729 case TB_DELETEBUTTON:
2730 return TOOLBAR_DeleteButton (hwnd, wParam, lParam);
2731
2732 case TB_ENABLEBUTTON:
2733 return TOOLBAR_EnableButton (hwnd, wParam, lParam);
2734
2735 /* case TB_GETANCHORHIGHLIGHT: */ /* 4.71 */
2736
2737 case TB_GETBITMAP:
2738 return TOOLBAR_GetBitmap (hwnd, wParam, lParam);
2739
2740 case TB_GETBITMAPFLAGS:
2741 return TOOLBAR_GetBitmapFlags (hwnd, wParam, lParam);
2742
2743 case TB_GETBUTTON:
2744 return TOOLBAR_GetButton (hwnd, wParam, lParam);
2745
2746 case TB_GETBUTTONINFOA:
2747 return TOOLBAR_GetButtonInfoA (hwnd, wParam, lParam);
2748
2749 /* case TB_GETBUTTONINFO32W: */ /* 4.71 */
2750
2751 case TB_GETBUTTONSIZE:
2752 return TOOLBAR_GetButtonSize (hwnd);
2753
2754 case TB_GETBUTTONTEXTA:
2755 return TOOLBAR_GetButtonTextA (hwnd, wParam, lParam);
2756
2757 /* case TB_GETBUTTONTEXT32W: */
2758 /* case TB_GETCOLORSCHEME: */ /* 4.71 */
2759
2760 case TB_GETDISABLEDIMAGELIST:
2761 return TOOLBAR_GetDisabledImageList (hwnd, wParam, lParam);
2762
2763 case TB_GETEXTENDEDSTYLE:
2764 return TOOLBAR_GetExtendedStyle (hwnd);
2765
2766 case TB_GETHOTIMAGELIST:
2767 return TOOLBAR_GetHotImageList (hwnd, wParam, lParam);
2768
2769 /* case TB_GETHOTITEM: */ /* 4.71 */
2770
2771 case TB_GETIMAGELIST:
2772 return TOOLBAR_GetImageList (hwnd, wParam, lParam);
2773
2774 /* case TB_GETINSERTMARK: */ /* 4.71 */
2775 /* case TB_GETINSERTMARKCOLOR: */ /* 4.71 */
2776
2777 case TB_GETITEMRECT:
2778 return TOOLBAR_GetItemRect (hwnd, wParam, lParam);
2779
2780 case TB_GETMAXSIZE:
2781 return TOOLBAR_GetMaxSize (hwnd, wParam, lParam);
2782
2783 /* case TB_GETOBJECT: */ /* 4.71 */
2784 /* case TB_GETPADDING: */ /* 4.71 */
2785
2786 case TB_GETRECT:
2787 return TOOLBAR_GetRect (hwnd, wParam, lParam);
2788
2789 case TB_GETROWS:
2790 return TOOLBAR_GetRows (hwnd, wParam, lParam);
2791
2792 case TB_GETSTATE:
2793 return TOOLBAR_GetState (hwnd, wParam, lParam);
2794
2795 case TB_GETSTYLE:
2796 return TOOLBAR_GetStyle (hwnd, wParam, lParam);
2797
2798 case TB_GETTEXTROWS:
2799 return TOOLBAR_GetTextRows (hwnd, wParam, lParam);
2800
2801 case TB_GETTOOLTIPS:
2802 return TOOLBAR_GetToolTips (hwnd, wParam, lParam);
2803
2804 case TB_GETUNICODEFORMAT:
2805 return TOOLBAR_GetUnicodeFormat (hwnd, wParam, lParam);
2806
2807 case TB_HIDEBUTTON:
2808 return TOOLBAR_HideButton (hwnd, wParam, lParam);
2809
2810 case TB_HITTEST:
2811 return TOOLBAR_HitTest (hwnd, wParam, lParam);
2812
2813 case TB_INDETERMINATE:
2814 return TOOLBAR_Indeterminate (hwnd, wParam, lParam);
2815
2816 case TB_INSERTBUTTONA:
2817 return TOOLBAR_InsertButtonA (hwnd, wParam, lParam);
2818
2819 /* case TB_INSERTBUTTON32W: */
2820 /* case TB_INSERTMARKHITTEST: */ /* 4.71 */
2821
2822 case TB_ISBUTTONCHECKED:
2823 return TOOLBAR_IsButtonChecked (hwnd, wParam, lParam);
2824
2825 case TB_ISBUTTONENABLED:
2826 return TOOLBAR_IsButtonEnabled (hwnd, wParam, lParam);
2827
2828 case TB_ISBUTTONHIDDEN:
2829 return TOOLBAR_IsButtonHidden (hwnd, wParam, lParam);
2830
2831 case TB_ISBUTTONHIGHLIGHTED:
2832 return TOOLBAR_IsButtonHighlighted (hwnd, wParam, lParam);
2833
2834 case TB_ISBUTTONINDETERMINATE:
2835 return TOOLBAR_IsButtonIndeterminate (hwnd, wParam, lParam);
2836
2837 case TB_ISBUTTONPRESSED:
2838 return TOOLBAR_IsButtonPressed (hwnd, wParam, lParam);
2839
2840 /* case TB_LOADIMAGES: */ /* 4.70 */
2841 /* case TB_MAPACCELERATOR32A: */ /* 4.71 */
2842 /* case TB_MAPACCELERATOR32W: */ /* 4.71 */
2843 /* case TB_MARKBUTTON: */ /* 4.71 */
2844 /* case TB_MOVEBUTTON: */ /* 4.71 */
2845
2846 case TB_PRESSBUTTON:
2847 return TOOLBAR_PressButton (hwnd, wParam, lParam);
2848
2849 /* case TB_REPLACEBITMAP: */
2850
2851 case TB_SAVERESTOREA:
2852 return TOOLBAR_SaveRestoreA (hwnd, wParam, lParam);
2853
2854 /* case TB_SAVERESTORE32W: */
2855 /* case TB_SETANCHORHIGHLIGHT: */ /* 4.71 */
2856
2857 case TB_SETBITMAPSIZE:
2858 return TOOLBAR_SetBitmapSize (hwnd, wParam, lParam);
2859
2860 case TB_SETBUTTONINFOA:
2861 return TOOLBAR_SetButtonInfoA (hwnd, wParam, lParam);
2862
2863 /* case TB_SETBUTTONINFO32W: */ /* 4.71 */
2864
2865 case TB_SETBUTTONSIZE:
2866 return TOOLBAR_SetButtonSize (hwnd, wParam, lParam);
2867
2868 case TB_SETBUTTONWIDTH:
2869 return TOOLBAR_SetButtonWidth (hwnd, wParam, lParam);
2870
2871 case TB_SETCMDID:
2872 return TOOLBAR_SetCmdId (hwnd, wParam, lParam);
2873
2874 /* case TB_SETCOLORSCHEME: */ /* 4.71 */
2875
2876 case TB_SETDISABLEDIMAGELIST:
2877 return TOOLBAR_SetDisabledImageList (hwnd, wParam, lParam);
2878
2879 case TB_SETDRAWTEXTFLAGS:
2880 return TOOLBAR_SetDrawTextFlags (hwnd, wParam, lParam);
2881
2882 case TB_SETEXTENDEDSTYLE:
2883 return TOOLBAR_SetExtendedStyle (hwnd, wParam, lParam);
2884
2885 case TB_SETHOTIMAGELIST:
2886 return TOOLBAR_SetHotImageList (hwnd, wParam, lParam);
2887
2888 /* case TB_SETHOTITEM: */ /* 4.71 */
2889
2890 case TB_SETIMAGELIST:
2891 return TOOLBAR_SetImageList (hwnd, wParam, lParam);
2892
2893 case TB_SETINDENT:
2894 return TOOLBAR_SetIndent (hwnd, wParam, lParam);
2895
2896 /* case TB_SETINSERTMARK: */ /* 4.71 */
2897
2898 case TB_SETINSERTMARKCOLOR:
2899 return TOOLBAR_SetInsertMarkColor (hwnd, wParam, lParam);
2900
2901 case TB_SETMAXTEXTROWS:
2902 return TOOLBAR_SetMaxTextRows (hwnd, wParam, lParam);
2903
2904 /* case TB_SETPADDING: */ /* 4.71 */
2905
2906 case TB_SETPARENT:
2907 return TOOLBAR_SetParent (hwnd, wParam, lParam);
2908
2909 case TB_SETROWS:
2910 return TOOLBAR_SetRows (hwnd, wParam, lParam);
2911
2912 case TB_SETSTATE:
2913 return TOOLBAR_SetState (hwnd, wParam, lParam);
2914
2915 case TB_SETSTYLE:
2916 return TOOLBAR_SetStyle (hwnd, wParam, lParam);
2917
2918 case TB_SETTOOLTIPS:
2919 return TOOLBAR_SetToolTips (hwnd, wParam, lParam);
2920
2921 case TB_SETUNICODEFORMAT:
2922 return TOOLBAR_SetUnicodeFormat (hwnd, wParam, lParam);
2923
2924
2925 /* case WM_CHAR: */
2926
2927 case WM_CREATE:
2928 return TOOLBAR_Create (hwnd, wParam, lParam);
2929
2930 case WM_DESTROY:
2931 return TOOLBAR_Destroy (hwnd, wParam, lParam);
2932
2933 case WM_ERASEBKGND:
2934 return TOOLBAR_EraseBackground (hwnd, wParam, lParam);
2935
2936 /* case WM_GETFONT: */
2937 /* case WM_KEYDOWN: */
2938 /* case WM_KILLFOCUS: */
2939
2940 case WM_LBUTTONDBLCLK:
2941 return TOOLBAR_LButtonDblClk (hwnd, wParam, lParam);
2942
2943 case WM_LBUTTONDOWN:
2944 return TOOLBAR_LButtonDown (hwnd, wParam, lParam);
2945
2946 case WM_LBUTTONUP:
2947 return TOOLBAR_LButtonUp (hwnd, wParam, lParam);
2948
2949 case WM_MOUSEMOVE:
2950 return TOOLBAR_MouseMove (hwnd, wParam, lParam);
2951
2952 case WM_NCACTIVATE:
2953 return TOOLBAR_NCActivate (hwnd, wParam, lParam);
2954
2955 case WM_NCCALCSIZE:
2956 return TOOLBAR_NCCalcSize (hwnd, wParam, lParam);
2957
2958 case WM_NCCREATE:
2959 return TOOLBAR_NCCreate (hwnd, wParam, lParam);
2960
2961 case WM_NCPAINT:
2962 return TOOLBAR_NCPaint (hwnd, wParam, lParam);
2963
2964 case WM_NOTIFY:
2965 return TOOLBAR_Notify (hwnd, wParam, lParam);
2966
2967 /* case WM_NOTIFYFORMAT: */
2968
2969 case WM_PAINT:
2970 return TOOLBAR_Paint (hwnd, wParam);
2971
2972 case WM_SIZE:
2973 return TOOLBAR_Size (hwnd, wParam, lParam);
2974
2975 case WM_STYLECHANGED:
2976 return TOOLBAR_StyleChanged (hwnd, wParam, lParam);
2977
2978 /* case WM_SYSCOLORCHANGE: */
2979
2980 /* case WM_WININICHANGE: */
2981
2982 case WM_CHARTOITEM:
2983 case WM_COMMAND:
2984 case WM_DRAWITEM:
2985 case WM_MEASUREITEM:
2986 case WM_VKEYTOITEM:
2987 return SendMessageA (GetParent (hwnd), uMsg, wParam, lParam);
2988
2989 default:
2990 if (uMsg >= WM_USER)
2991 ERR (toolbar, "unknown msg %04x wp=%08x lp=%08lx\n",
2992 uMsg, wParam, lParam);
2993 return DefWindowProcA (hwnd, uMsg, wParam, lParam);
2994 }
2995 return 0;
2996 }
2997
2998
2999 VOID
3000 TOOLBAR_Register (VOID)
3001 {
3002 WNDCLASSA wndClass;
3003
3004 if (GlobalFindAtomA (TOOLBARCLASSNAMEA)) return;
3005
3006 ZeroMemory (&wndClass, sizeof(WNDCLASSA));
3007 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
3008 wndClass.lpfnWndProc = (WNDPROC)ToolbarWindowProc;
3009 wndClass.cbClsExtra = 0;
3010 wndClass.cbWndExtra = sizeof(TOOLBAR_INFO *);
3011 wndClass.hCursor = LoadCursorA (0, IDC_ARROWA);
3012 wndClass.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
3013 wndClass.lpszClassName = TOOLBARCLASSNAMEA;
3014
3015 RegisterClassA (&wndClass);
3016 }
3017
3018
3019 VOID
3020 TOOLBAR_Unregister (VOID)
3021 {
3022 if (GlobalFindAtomA (TOOLBARCLASSNAMEA))
3023 UnregisterClassA (TOOLBARCLASSNAMEA, (HINSTANCE)NULL);
3024 }
3025
Windows API implementation