wined3d: IWineD3DBuffer_Unmap() can't fail.
[wine] / dlls / comctl32 / tests / toolbar.c
1 /* Unit tests for toolbar.
2  *
3  * Copyright 2005 Krzysztof Foltman
4  * Copyright 2007 Mikolaj Zalewski
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <assert.h>
22 #include <stdarg.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "wingdi.h"
27 #include "winuser.h"
28 #include "winnls.h"
29 #include "winreg.h"
30 #include "commctrl.h" 
31
32 #include "resources.h"
33
34 #include "wine/test.h"
35
36 #include "msg.h"
37
38 #define PARENT_SEQ_INDEX       0
39 #define NUM_MSG_SEQUENCES      1
40
41 static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];
42
43 static HWND hMainWnd;
44 static BOOL g_fBlockHotItemChange;
45 static BOOL g_fReceivedHotItemChange;
46 static BOOL g_fExpectedHotItemOld;
47 static BOOL g_fExpectedHotItemNew;
48 static DWORD g_dwExpectedDispInfoMask;
49 static BOOL g_ResetDispTextPtr;
50
51 static const struct message ttgetdispinfo_parent_seq[] = {
52     { WM_NOTIFY, sent|id, 0, 0, TBN_GETINFOTIPA },
53     /* next line is todo, currently TTN_GETDISPINFOW is raised here */
54     { WM_NOTIFY, sent|id, 0, 0, TTN_GETDISPINFOA },
55     { 0 }
56 };
57
58 #define expect(EXPECTED,GOT) ok((GOT)==(EXPECTED), "Expected %d, got %d\n", (EXPECTED), (GOT))
59
60 #define check_rect(name, val, exp) ok(val.top == exp.top && val.bottom == exp.bottom && \
61     val.left == exp.left && val.right == exp.right, "invalid rect (" name ") (%d,%d) (%d,%d) - expected (%d,%d) (%d,%d)\n", \
62     val.left, val.top, val.right, val.bottom, exp.left, exp.top, exp.right, exp.bottom);
63  
64 #define compare(val, exp, format) ok((val) == (exp), #val " value " format " expected " format "\n", (val), (exp));
65
66 static void MakeButton(TBBUTTON *p, int idCommand, int fsStyle, int nString) {
67   p->iBitmap = -2;
68   p->idCommand = idCommand;
69   p->fsState = TBSTATE_ENABLED;
70   p->fsStyle = fsStyle;
71   p->iString = nString;
72 }
73
74 static LRESULT parent_wnd_notify(LPARAM lParam)
75 {
76     NMHDR *hdr = (NMHDR *)lParam;
77     NMTBHOTITEM *nmhi;
78     NMTBDISPINFO *nmdisp;
79     switch (hdr->code)
80     {
81         case TBN_HOTITEMCHANGE:
82             nmhi = (NMTBHOTITEM *)lParam;
83             g_fReceivedHotItemChange = TRUE;
84             if (g_fExpectedHotItemOld != g_fExpectedHotItemNew)
85             {
86                 compare(nmhi->idOld, g_fExpectedHotItemOld, "%d");
87                 compare(nmhi->idNew, g_fExpectedHotItemNew, "%d");
88             }
89             if (g_fBlockHotItemChange)
90                 return 1;
91             break;
92
93         case TBN_GETDISPINFOA:
94             ok(FALSE, "TBN_GETDISPINFOA received\n");
95             break;
96
97         case TBN_GETINFOTIPA:
98         {
99             NMTBGETINFOTIPA *tbgit = (NMTBGETINFOTIPA*)lParam;
100
101             if (g_ResetDispTextPtr)
102             {
103                 tbgit->pszText = NULL;
104                 return 0;
105             }
106             break;
107         }
108         case TBN_GETDISPINFOW:
109             nmdisp = (NMTBDISPINFOA *)lParam;
110
111             compare(nmdisp->dwMask, g_dwExpectedDispInfoMask, "%x");
112             ok(nmdisp->pszText == NULL, "pszText is not NULL\n");
113         break;
114     }
115     return 0;
116 }
117
118 static LRESULT CALLBACK parent_wnd_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
119 {
120     static LONG defwndproc_counter = 0;
121     struct message msg;
122     LRESULT ret;
123
124     msg.message = message;
125     msg.flags = sent|wparam|lparam;
126     if (defwndproc_counter) msg.flags |= defwinproc;
127     msg.wParam = wParam;
128     msg.lParam = lParam;
129     if (message == WM_NOTIFY && lParam) msg.id = ((NMHDR*)lParam)->code;
130
131     /* log system messages, except for painting */
132     if (message < WM_USER &&
133         message != WM_PAINT &&
134         message != WM_ERASEBKGND &&
135         message != WM_NCPAINT &&
136         message != WM_NCHITTEST &&
137         message != WM_GETTEXT &&
138         message != WM_GETICON &&
139         message != WM_DEVICECHANGE)
140     {
141         trace("parent: %p, %04x, %08lx, %08lx\n", hWnd, message, wParam, lParam);
142         add_message(sequences, PARENT_SEQ_INDEX, &msg);
143     }
144
145     switch (message)
146     {
147         case WM_NOTIFY:
148             return parent_wnd_notify(lParam);
149     }
150
151     defwndproc_counter++;
152     ret = DefWindowProcA(hWnd, message, wParam, lParam);
153     defwndproc_counter--;
154
155     return ret;
156 }
157
158 static void basic_test(void)
159 {
160     TBBUTTON buttons[9];
161     HWND hToolbar;
162     int i;
163     for (i=0; i<9; i++)
164         MakeButton(buttons+i, 1000+i, TBSTYLE_CHECKGROUP, 0);
165     MakeButton(buttons+3, 1003, TBSTYLE_SEP|TBSTYLE_GROUP, 0);
166     MakeButton(buttons+6, 1006, TBSTYLE_SEP, 0);
167
168     hToolbar = CreateToolbarEx(hMainWnd,
169         WS_VISIBLE | WS_CLIPCHILDREN | CCS_TOP |
170         WS_CHILD | TBSTYLE_LIST,
171         100,
172         0, NULL, 0,
173         buttons, sizeof(buttons)/sizeof(buttons[0]),
174         0, 0, 20, 16, sizeof(TBBUTTON));
175     ok(hToolbar != NULL, "Toolbar creation\n");
176     SendMessage(hToolbar, TB_ADDSTRINGA, 0, (LPARAM)"test\000");
177
178     /* test for exclusion working inside a separator-separated :-) group */
179     SendMessage(hToolbar, TB_CHECKBUTTON, 1000, 1); /* press A1 */
180     ok(SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1000, 0), "A1 pressed\n");
181     ok(!SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1001, 0), "A2 not pressed\n");
182
183     SendMessage(hToolbar, TB_CHECKBUTTON, 1004, 1); /* press A5, release A1 */
184     ok(SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1004, 0), "A5 pressed\n");
185     ok(!SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1000, 0), "A1 not pressed anymore\n");
186
187     SendMessage(hToolbar, TB_CHECKBUTTON, 1005, 1); /* press A6, release A5 */
188     ok(SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1005, 0), "A6 pressed\n");
189     ok(!SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1004, 0), "A5 not pressed anymore\n");
190
191     /* test for inter-group crosstalk, ie. two radio groups interfering with each other */
192     SendMessage(hToolbar, TB_CHECKBUTTON, 1007, 1); /* press B2 */
193     ok(SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1005, 0), "A6 still pressed, no inter-group crosstalk\n");
194     ok(!SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1000, 0), "A1 still not pressed\n");
195     ok(SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1007, 0), "B2 pressed\n");
196
197     SendMessage(hToolbar, TB_CHECKBUTTON, 1000, 1); /* press A1 and ensure B group didn't suffer */
198     ok(!SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1005, 0), "A6 not pressed anymore\n");
199     ok(SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1000, 0), "A1 pressed\n");
200     ok(SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1007, 0), "B2 still pressed\n");
201
202     SendMessage(hToolbar, TB_CHECKBUTTON, 1008, 1); /* press B3, and ensure A group didn't suffer */
203     ok(!SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1005, 0), "A6 pressed\n");
204     ok(SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1000, 0), "A1 pressed\n");
205     ok(!SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1007, 0), "B2 not pressed\n");
206     ok(SendMessage(hToolbar, TB_ISBUTTONCHECKED, 1008, 0), "B3 pressed\n");
207
208     /* tests with invalid index */
209     compare(SendMessage(hToolbar, TB_ISBUTTONCHECKED, 0xdeadbeef, 0), -1L, "%ld");
210     compare(SendMessage(hToolbar, TB_ISBUTTONPRESSED, 0xdeadbeef, 0), -1L, "%ld");
211     compare(SendMessage(hToolbar, TB_ISBUTTONENABLED, 0xdeadbeef, 0), -1L, "%ld");
212     compare(SendMessage(hToolbar, TB_ISBUTTONINDETERMINATE, 0xdeadbeef, 0), -1L, "%ld");
213     compare(SendMessage(hToolbar, TB_ISBUTTONHIGHLIGHTED, 0xdeadbeef, 0), -1L, "%ld");
214     compare(SendMessage(hToolbar, TB_ISBUTTONHIDDEN, 0xdeadbeef, 0), -1L, "%ld");
215
216     DestroyWindow(hToolbar);
217 }
218
219 static void rebuild_toolbar(HWND *hToolbar)
220 {
221     if (*hToolbar)
222         DestroyWindow(*hToolbar);
223     *hToolbar = CreateWindowEx(0, TOOLBARCLASSNAME, NULL, WS_CHILD | WS_VISIBLE, 0, 0, 0, 0,
224         hMainWnd, (HMENU)5, GetModuleHandle(NULL), NULL);
225     ok(*hToolbar != NULL, "Toolbar creation problem\n");
226     ok(SendMessage(*hToolbar, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0) == 0, "TB_BUTTONSTRUCTSIZE failed\n");
227     ok(SendMessage(*hToolbar, TB_AUTOSIZE, 0, 0) == 0, "TB_AUTOSIZE failed\n");
228     ok(SendMessage(*hToolbar, WM_SETFONT, (WPARAM)GetStockObject(SYSTEM_FONT), 0)==1, "WM_SETFONT\n");
229 }
230
231 static void rebuild_toolbar_with_buttons(HWND *hToolbar)
232 {
233     TBBUTTON buttons[5];
234     rebuild_toolbar(hToolbar);
235     
236     ZeroMemory(&buttons, sizeof(buttons));
237     buttons[0].idCommand = 1;
238     buttons[0].fsStyle = BTNS_BUTTON;
239     buttons[0].fsState = TBSTATE_ENABLED;
240     buttons[0].iString = -1;
241     buttons[1].idCommand = 3;
242     buttons[1].fsStyle = BTNS_BUTTON;
243     buttons[1].fsState = TBSTATE_ENABLED;
244     buttons[1].iString = -1;
245     buttons[2].idCommand = 5;
246     buttons[2].fsStyle = BTNS_SEP;
247     buttons[2].fsState = TBSTATE_ENABLED;
248     buttons[2].iString = -1;
249     buttons[3].idCommand = 7;
250     buttons[3].fsStyle = BTNS_BUTTON;
251     buttons[3].fsState = TBSTATE_ENABLED;
252     buttons[3].iString = -1;
253     buttons[4].idCommand = 9;
254     buttons[4].fsStyle = BTNS_BUTTON;
255     buttons[4].fsState = 0;  /* disabled */
256     buttons[4].iString = -1;
257     ok(SendMessage(*hToolbar, TB_ADDBUTTONS, 5, (LPARAM)buttons) == 1, "TB_ADDBUTTONS failed\n");
258     ok(SendMessage(*hToolbar, TB_AUTOSIZE, 0, 0) == 0, "TB_AUTOSIZE failed\n");
259 }
260
261 static void add_128x15_bitmap(HWND hToolbar, int nCmds)
262 {
263     TBADDBITMAP bmp128;
264     bmp128.hInst = GetModuleHandle(NULL);
265     bmp128.nID = IDB_BITMAP_128x15;
266     ok(SendMessageA(hToolbar, TB_ADDBITMAP, nCmds, (LPARAM)&bmp128) == 0, "TB_ADDBITMAP - unexpected return\n");
267 }
268
269 #define CHECK_IMAGELIST(count, dx, dy) { \
270     int cx, cy; \
271     HIMAGELIST himl = (HIMAGELIST)SendMessageA(hToolbar, TB_GETIMAGELIST, 0, 0); \
272     ok(himl != NULL, "No image list\n"); \
273     if (himl != NULL) {\
274         ok(ImageList_GetImageCount(himl) == count, "Images count mismatch - %d vs %d\n", count, ImageList_GetImageCount(himl)); \
275         ImageList_GetIconSize(himl, &cx, &cy); \
276         ok(cx == dx && cy == dy, "Icon size mismatch - %dx%d vs %dx%d\n", dx, dy, cx, cy); \
277     } \
278 }
279
280 static void test_add_bitmap(void)
281 {
282     HWND hToolbar = NULL;
283     TBADDBITMAP bmp128;
284     TBADDBITMAP bmp80;
285     TBADDBITMAP stdsmall;
286     TBADDBITMAP addbmp;
287     HIMAGELIST himl;
288     INT ret;
289
290     /* empty 128x15 bitmap */
291     bmp128.hInst = GetModuleHandle(NULL);
292     bmp128.nID = IDB_BITMAP_128x15;
293
294     /* empty 80x15 bitmap */
295     bmp80.hInst = GetModuleHandle(NULL);
296     bmp80.nID = IDB_BITMAP_80x15;
297
298     /* standard bitmap - 240x15 pixels */
299     stdsmall.hInst = HINST_COMMCTRL;
300     stdsmall.nID = IDB_STD_SMALL_COLOR;
301
302     rebuild_toolbar(&hToolbar);
303     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 8, (LPARAM)&bmp128) == 0, "TB_ADDBITMAP - unexpected return\n");
304     CHECK_IMAGELIST(8, 16, 16);
305     
306     /* adding more bitmaps */
307     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 5, (LPARAM)&bmp80) == 8, "TB_ADDBITMAP - unexpected return\n");
308     CHECK_IMAGELIST(13, 16, 16);
309     /* adding the same bitmap will simply return the index of the already loaded block */
310     ret = SendMessageA(hToolbar, TB_ADDBITMAP, 8, (LPARAM)&bmp128);
311     ok(ret == 0, "TB_ADDBITMAP - unexpected return %d\n", ret);
312     CHECK_IMAGELIST(13, 16, 16);
313     ret = SendMessageA(hToolbar, TB_ADDBITMAP, 5, (LPARAM)&bmp80);
314     ok(ret == 8, "TB_ADDBITMAP - unexpected return %d\n", ret);
315     CHECK_IMAGELIST(13, 16, 16);
316     /* even if we increase the wParam */
317     ret = SendMessageA(hToolbar, TB_ADDBITMAP, 55, (LPARAM)&bmp80);
318     ok(ret == 8, "TB_ADDBITMAP - unexpected return %d\n", ret);
319     CHECK_IMAGELIST(13, 16, 16);
320
321     /* when the wParam is smaller than the bitmaps count but non-zero, all the bitmaps will be added*/
322     rebuild_toolbar(&hToolbar);
323     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 3, (LPARAM)&bmp128) == 0, "TB_ADDBITMAP - unexpected return\n");
324     CHECK_IMAGELIST(8, 16, 16);
325     ret = SendMessageA(hToolbar, TB_ADDBITMAP, 5, (LPARAM)&bmp80);
326     ok(ret == 3, "TB_ADDBITMAP - unexpected return %d\n", ret);
327     /* the returned value is misleading - id 8 is the id of the first icon from bmp80 */
328     CHECK_IMAGELIST(13, 16, 16);
329
330     /* the same for negative wParam */
331     rebuild_toolbar(&hToolbar);
332     ret = SendMessageA(hToolbar, TB_ADDBITMAP, -143, (LPARAM)&bmp128);
333     ok(ret == 0, "TB_ADDBITMAP - unexpected return %d\n", ret);
334     CHECK_IMAGELIST(8, 16, 16);
335     ret = SendMessageA(hToolbar, TB_ADDBITMAP, 1, (LPARAM)&bmp80);
336     ok(ret == -143, "TB_ADDBITMAP - unexpected return %d\n", ret);
337     CHECK_IMAGELIST(13, 16, 16);
338
339     /* for zero only one bitmap will be added */
340     rebuild_toolbar(&hToolbar);
341     ret = SendMessageA(hToolbar, TB_ADDBITMAP, 0, (LPARAM)&bmp80);
342     ok(ret == 0, "TB_ADDBITMAP - unexpected return %d\n", ret);
343     CHECK_IMAGELIST(1, 16, 16);
344
345     /* if wParam is larger than the amount of icons, the list is grown */
346     rebuild_toolbar(&hToolbar);
347     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 100, (LPARAM)&bmp80) == 0, "TB_ADDBITMAP - unexpected return\n");
348     CHECK_IMAGELIST(100, 16, 16);
349     ret = SendMessageA(hToolbar, TB_ADDBITMAP, 100, (LPARAM)&bmp128);
350     ok(ret == 100, "TB_ADDBITMAP - unexpected return %d\n", ret);
351     CHECK_IMAGELIST(200, 16, 16);
352
353     /* adding built-in items - the wParam is ignored */
354     rebuild_toolbar(&hToolbar);
355     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 5, (LPARAM)&bmp80) == 0, "TB_ADDBITMAP - unexpected return\n");
356     CHECK_IMAGELIST(5, 16, 16);
357     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 0, (LPARAM)&stdsmall) == 5, "TB_ADDBITMAP - unexpected return\n");
358     CHECK_IMAGELIST(20, 16, 16);
359     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 5, (LPARAM)&bmp128) == 20, "TB_ADDBITMAP - unexpected return\n");
360     CHECK_IMAGELIST(28, 16, 16);
361
362     /* when we increase the bitmap size, less icons will be created */
363     rebuild_toolbar(&hToolbar);
364     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(20, 20)) == TRUE, "TB_SETBITMAPSIZE failed\n");
365     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 1, (LPARAM)&bmp128) == 0, "TB_ADDBITMAP - unexpected return\n");
366     CHECK_IMAGELIST(6, 20, 20);
367     ret = SendMessageA(hToolbar, TB_ADDBITMAP, 1, (LPARAM)&bmp80);
368     ok(ret == 1, "TB_ADDBITMAP - unexpected return %d\n", ret);
369     CHECK_IMAGELIST(10, 20, 20);
370     /* the icons can be resized - an UpdateWindow is needed as this probably happens during WM_PAINT */
371     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(8, 8)) == TRUE, "TB_SETBITMAPSIZE failed\n");
372     UpdateWindow(hToolbar);
373     CHECK_IMAGELIST(26, 8, 8);
374     /* loading a standard bitmaps automatically resizes the icons */
375     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 1, (LPARAM)&stdsmall) == 2, "TB_ADDBITMAP - unexpected return\n");
376     UpdateWindow(hToolbar);
377     CHECK_IMAGELIST(28, 16, 16);
378
379     /* two more SETBITMAPSIZE tests */
380     rebuild_toolbar(&hToolbar);
381     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 100, (LPARAM)&bmp128) == 0, "TB_ADDBITMAP - unexpected return\n");
382     CHECK_IMAGELIST(100, 16, 16);
383     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 100, (LPARAM)&bmp80) == 100, "TB_ADDBITMAP - unexpected return\n");
384     CHECK_IMAGELIST(200, 16, 16);
385     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(8, 8)) == TRUE, "TB_SETBITMAPSIZE failed\n");
386     UpdateWindow(hToolbar);
387     CHECK_IMAGELIST(200, 8, 8);
388     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(30, 30)) == TRUE, "TB_SETBITMAPSIZE failed\n");
389     UpdateWindow(hToolbar);
390     CHECK_IMAGELIST(200, 30, 30);
391     rebuild_toolbar(&hToolbar);
392     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 5, (LPARAM)&bmp128) == 0, "TB_ADDBITMAP - unexpected return\n");
393     CHECK_IMAGELIST(8, 16, 16);
394     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 3, (LPARAM)&bmp80) == 5, "TB_ADDBITMAP - unexpected return\n");
395     CHECK_IMAGELIST(13, 16, 16);
396     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(30, 30)) == TRUE, "TB_SETBITMAPSIZE failed\n");
397     UpdateWindow(hToolbar);
398     CHECK_IMAGELIST(8, 30, 30);
399     /* when the width or height is zero, set it to 1 */
400     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(0, 0)) == TRUE, "TB_SETBITMAPSIZE failed\n");
401     UpdateWindow(hToolbar);
402     CHECK_IMAGELIST(208, 1, 1);
403     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(0, 5)) == TRUE, "TB_SETBITMAPSIZE failed\n");
404     UpdateWindow(hToolbar);
405     CHECK_IMAGELIST(208, 1, 5);
406     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(5, 0)) == TRUE, "TB_SETBITMAPSIZE failed\n");
407     UpdateWindow(hToolbar);
408     CHECK_IMAGELIST(41, 5, 1);
409
410     /* the control can add bitmaps to an existing image list */
411     rebuild_toolbar(&hToolbar);
412     himl = ImageList_LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_BITMAP_80x15), 20, 2, CLR_NONE, IMAGE_BITMAP, LR_DEFAULTCOLOR);
413     ok(himl != NULL, "failed to create imagelist\n");
414     ok(SendMessageA(hToolbar, TB_SETIMAGELIST, 0, (LPARAM)himl) == 0, "TB_SETIMAGELIST failed\n");
415     CHECK_IMAGELIST(4, 20, 15);
416     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 1, (LPARAM)&bmp128) == 0, "TB_ADDBITMAP - unexpected return\n");
417     CHECK_IMAGELIST(10, 20, 15);
418     /* however TB_SETBITMAPSIZE/add std bitmap won't change the image size (the button size does change) */
419     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(8, 8)) == TRUE, "TB_SETBITMAPSIZE failed\n");
420     UpdateWindow(hToolbar);
421     compare((int)SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0), MAKELONG(15, 14), "%x");
422     CHECK_IMAGELIST(10, 20, 15);
423     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 0, (LPARAM)&stdsmall) == 1, "TB_SETBITMAPSIZE failed\n");
424     UpdateWindow(hToolbar);
425     compare((int)SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0), MAKELONG(23, 22), "%x");
426     CHECK_IMAGELIST(22, 20, 15);
427
428     /* check standard bitmaps */
429     addbmp.hInst = HINST_COMMCTRL;
430     addbmp.nID = IDB_STD_SMALL_COLOR;
431     rebuild_toolbar(&hToolbar);
432     ImageList_Destroy(himl);
433
434     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 1, (LPARAM)&addbmp) == 0, "TB_ADDBITMAP - unexpected return\n");
435     CHECK_IMAGELIST(15, 16, 16);
436     compare((int)SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0), MAKELONG(23, 22), "%x");
437     addbmp.nID = IDB_STD_LARGE_COLOR;
438     rebuild_toolbar(&hToolbar);
439     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 1, (LPARAM)&addbmp) == 0, "TB_ADDBITMAP - unexpected return\n");
440     CHECK_IMAGELIST(15, 24, 24);
441     compare((int)SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0), MAKELONG(31, 30), "%x");
442
443     addbmp.nID = IDB_VIEW_SMALL_COLOR;
444     rebuild_toolbar(&hToolbar);
445     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 1, (LPARAM)&addbmp) == 0, "TB_ADDBITMAP - unexpected return\n");
446     CHECK_IMAGELIST(12, 16, 16);
447     addbmp.nID = IDB_VIEW_LARGE_COLOR;
448     rebuild_toolbar(&hToolbar);
449     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 1, (LPARAM)&addbmp) == 0, "TB_ADDBITMAP - unexpected return\n");
450     CHECK_IMAGELIST(12, 24, 24);
451
452     addbmp.nID = IDB_HIST_SMALL_COLOR;
453     rebuild_toolbar(&hToolbar);
454     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 1, (LPARAM)&addbmp) == 0, "TB_ADDBITMAP - unexpected return\n");
455     CHECK_IMAGELIST(5, 16, 16);
456     addbmp.nID = IDB_HIST_LARGE_COLOR;
457     rebuild_toolbar(&hToolbar);
458     ok(SendMessageA(hToolbar, TB_ADDBITMAP, 1, (LPARAM)&addbmp) == 0, "TB_ADDBITMAP - unexpected return\n");
459     CHECK_IMAGELIST(5, 24, 24);
460
461
462     DestroyWindow(hToolbar);
463 }
464
465 #define CHECK_STRING_TABLE(count, tab) { \
466         INT _i; \
467         CHAR _buf[260]; \
468         for (_i = 0; _i < (count); _i++) {\
469             ret = SendMessageA(hToolbar, TB_GETSTRING, MAKEWPARAM(260, _i), (LPARAM)_buf); \
470             ok(ret >= 0, "TB_GETSTRING - unexpected return %d while checking string %d\n", ret, _i); \
471             if (ret >= 0) \
472                 ok(strcmp(_buf, (tab)[_i]) == 0, "Invalid string #%d - '%s' vs '%s'\n", _i, (tab)[_i], _buf); \
473         } \
474         ok(SendMessageA(hToolbar, TB_GETSTRING, MAKEWPARAM(260, (count)), (LPARAM)_buf) == -1, \
475             "Too many strings in table\n"); \
476     }
477
478 static void test_add_string(void)
479 {
480     LPCSTR test1 = "a\0b\0";
481     LPCSTR test2 = "|a|b||\0";
482     LPCSTR ret1[] = {"a", "b"};
483     LPCSTR ret2[] = {"a", "b", "|a|b||"};
484     LPCSTR ret3[] = {"a", "b", "|a|b||", "p", "q"};
485     LPCSTR ret4[] = {"a", "b", "|a|b||", "p", "q", "p"};
486     LPCSTR ret5[] = {"a", "b", "|a|b||", "p", "q", "p", "p", "q"};
487     LPCSTR ret6[] = {"a", "b", "|a|b||", "p", "q", "p", "p", "q", "p", "", "q"};
488     LPCSTR ret7[] = {"a", "b", "|a|b||", "p", "q", "p", "p", "q", "p", "", "q", "br", "c", "d"};
489     HWND hToolbar = NULL;
490     TBBUTTON button;
491     int ret;
492     CHAR buf[260];
493
494     rebuild_toolbar(&hToolbar);
495     ret = SendMessageA(hToolbar, TB_ADDSTRINGA, 0, (LPARAM)test1);
496     ok(ret == 0, "TB_ADDSTRINGA - unexpected return %d\n", ret);
497     ret = SendMessageA(hToolbar, TB_GETSTRING, MAKEWPARAM(260, 1), (LPARAM)buf);
498     if (ret == 0)
499     {
500         win_skip("TB_GETSTRING needs 5.80\n");
501         return;
502     }
503     CHECK_STRING_TABLE(2, ret1);
504     ret = SendMessageA(hToolbar, TB_ADDSTRINGA, 0, (LPARAM)test2);
505     ok(ret == 2, "TB_ADDSTRINGA - unexpected return %d\n", ret);
506     CHECK_STRING_TABLE(3, ret2);
507
508     /* null instance handle */
509     ret = SendMessageA(hToolbar, TB_ADDSTRINGA, 0, IDS_TBADD1);
510     ok(ret == -1, "TB_ADDSTRINGA - unexpected return %d\n", ret);
511
512     /* invalid instance handle */
513     ret = SendMessageA(hToolbar, TB_ADDSTRINGA, 0xdeadbeef, IDS_TBADD1);
514     ok(ret == -1, "TB_ADDSTRINGA - unexpected return %d\n", ret);
515
516     ret = SendMessageA(hToolbar, TB_ADDSTRINGA, (WPARAM)GetModuleHandle(NULL), IDS_TBADD1);
517     ok(ret == 3, "TB_ADDSTRINGA - unexpected return %d\n", ret);
518     CHECK_STRING_TABLE(3, ret2);
519     ret = SendMessageA(hToolbar, TB_ADDSTRINGA, (WPARAM)GetModuleHandle(NULL), IDS_TBADD2);
520     ok(ret == 3, "TB_ADDSTRINGA - unexpected return %d\n", ret);
521     CHECK_STRING_TABLE(5, ret3);
522     ret = SendMessageA(hToolbar, TB_ADDSTRINGA, (WPARAM)GetModuleHandle(NULL), IDS_TBADD3);
523     ok(ret == 5, "TB_ADDSTRINGA - unexpected return %d\n", ret);
524     CHECK_STRING_TABLE(6, ret4);
525     ret = SendMessageA(hToolbar, TB_ADDSTRINGA, (WPARAM)GetModuleHandle(NULL), IDS_TBADD4);
526     ok(ret == 6, "TB_ADDSTRINGA - unexpected return %d\n", ret);
527     CHECK_STRING_TABLE(8, ret5);
528     ret = SendMessageA(hToolbar, TB_ADDSTRINGA, (WPARAM)GetModuleHandle(NULL), IDS_TBADD5);
529     ok(ret == 8, "TB_ADDSTRINGA - unexpected return %d\n", ret);
530     CHECK_STRING_TABLE(11, ret6);
531     ret = SendMessageA(hToolbar, TB_ADDSTRINGA, (WPARAM)GetModuleHandle(NULL), IDS_TBADD7);
532     ok(ret == 11, "TB_ADDSTRINGA - unexpected return %d\n", ret);
533     CHECK_STRING_TABLE(14, ret7);
534
535     ZeroMemory(&button, sizeof(button));
536     button.iString = (UINT_PTR)"Test";
537     SendMessageA(hToolbar, TB_INSERTBUTTONA, 0, (LPARAM)&button);
538     CHECK_STRING_TABLE(14, ret7);
539     SendMessageA(hToolbar, TB_ADDBUTTONSA, 1, (LPARAM)&button);
540     CHECK_STRING_TABLE(14, ret7);
541
542     DestroyWindow(hToolbar);
543 }
544
545 static void expect_hot_notify(int idold, int idnew)
546 {
547     g_fExpectedHotItemOld = idold;
548     g_fExpectedHotItemNew = idnew;
549     g_fReceivedHotItemChange = FALSE;
550 }
551
552 #define check_hot_notify() \
553     ok(g_fReceivedHotItemChange, "TBN_HOTITEMCHANGE not received\n"); \
554     g_fExpectedHotItemOld = g_fExpectedHotItemNew = 0;
555
556 static void test_hotitem(void)
557 {
558     HWND hToolbar = NULL;
559     TBBUTTONINFO tbinfo;
560     LRESULT ret;
561
562     g_fBlockHotItemChange = FALSE;
563
564     rebuild_toolbar_with_buttons(&hToolbar);
565     /* set TBSTYLE_FLAT. comctl5 allows hot items only for such toolbars.
566      * comctl6 doesn't have this requirement even when theme == NULL */
567     SetWindowLong(hToolbar, GWL_STYLE, TBSTYLE_FLAT | GetWindowLong(hToolbar, GWL_STYLE));
568     ret = SendMessage(hToolbar, TB_GETHOTITEM, 0, 0);
569     ok(ret == -1, "Hot item: %ld, expected -1\n", ret);
570     ret = SendMessage(hToolbar, TB_SETHOTITEM, 1, 0);
571     ok(ret == -1, "TB_SETHOTITEM returned %ld, expected -1\n", ret);
572     ret = SendMessage(hToolbar, TB_GETHOTITEM, 0, 0);
573     ok(ret == 1, "Hot item: %ld, expected 1\n", ret);
574     ret = SendMessage(hToolbar, TB_SETHOTITEM, 2, 0);
575     ok(ret == 1, "TB_SETHOTITEM returned %ld, expected 1\n", ret);
576
577     ret = SendMessage(hToolbar, TB_SETHOTITEM, 0xbeef, 0);
578     ok(ret == 2, "TB_SETHOTITEM returned %ld, expected 2\n", ret);
579     ret = SendMessage(hToolbar, TB_GETHOTITEM, 0, 0);
580     ok(ret == 2, "Hot item: %lx, expected 2\n", ret);
581     ret = SendMessage(hToolbar, TB_SETHOTITEM, -0xbeef, 0);
582     ok(ret == 2, "TB_SETHOTITEM returned %ld, expected 2\n", ret);
583     ret = SendMessage(hToolbar, TB_GETHOTITEM, 0, 0);
584     ok(ret == -1, "Hot item: %lx, expected -1\n", ret);
585
586     expect_hot_notify(0, 7);
587     ret = SendMessage(hToolbar, TB_SETHOTITEM, 3, 0);
588     ok(ret == -1, "TB_SETHOTITEM returned %ld, expected -1\n", ret);
589     check_hot_notify();
590     ret = SendMessage(hToolbar, TB_GETHOTITEM, 0, 0);
591     ok(ret == 3, "Hot item: %lx, expected 3\n", ret);
592     g_fBlockHotItemChange = TRUE;
593     ret = SendMessage(hToolbar, TB_SETHOTITEM, 2, 0);
594     ok(ret == 3, "TB_SETHOTITEM returned %ld, expected 2\n", ret);
595     ret = SendMessage(hToolbar, TB_GETHOTITEM, 0, 0);
596     ok(ret == 3, "Hot item: %lx, expected 3\n", ret);
597     g_fBlockHotItemChange = FALSE;
598
599     g_fReceivedHotItemChange = FALSE;
600     ret = SendMessage(hToolbar, TB_SETHOTITEM, 0xbeaf, 0);
601     ok(ret == 3, "TB_SETHOTITEM returned %ld, expected 3\n", ret);
602     ok(g_fReceivedHotItemChange == FALSE, "TBN_HOTITEMCHANGE received for invalid parameter\n");
603
604     g_fReceivedHotItemChange = FALSE;
605     ret = SendMessage(hToolbar, TB_SETHOTITEM, 3, 0);
606     ok(ret == 3, "TB_SETHOTITEM returned %ld, expected 3\n", ret);
607     ok(g_fReceivedHotItemChange == FALSE, "TBN_HOTITEMCHANGE received after a duplication\n");
608
609     expect_hot_notify(7, 0);
610     ret = SendMessage(hToolbar, TB_SETHOTITEM, -0xbeaf, 0);
611     ok(ret == 3, "TB_SETHOTITEM returned %ld, expected 3\n", ret);
612     check_hot_notify();
613     SendMessage(hToolbar, TB_SETHOTITEM, 3, 0);
614
615     /* setting disabled buttons will generate a notify with the button id but no button will be hot */
616     expect_hot_notify(7, 9);
617     ret = SendMessage(hToolbar, TB_SETHOTITEM, 4, 0);
618     ok(ret == 3, "TB_SETHOTITEM returned %ld, expected 3\n", ret);
619     check_hot_notify();
620     ret = SendMessage(hToolbar, TB_GETHOTITEM, 0, 0);
621     ok(ret == -1, "Hot item: %lx, expected -1\n", ret);
622     /* enabling the button won't change that */
623     SendMessage(hToolbar, TB_ENABLEBUTTON, 9, TRUE);
624     ret = SendMessage(hToolbar, TB_GETHOTITEM, 0, 0);
625     ok(ret == -1, "TB_SETHOTITEM returned %ld, expected -1\n", ret);
626
627     /* disabling a hot button works */
628     ret = SendMessage(hToolbar, TB_SETHOTITEM, 3, 0);
629     ok(ret == -1, "TB_SETHOTITEM returned %ld, expected -1\n", ret);
630     g_fReceivedHotItemChange = FALSE;
631     SendMessage(hToolbar, TB_ENABLEBUTTON, 7, FALSE);
632     ret = SendMessage(hToolbar, TB_GETHOTITEM, 0, 0);
633     ok(ret == 3, "TB_SETHOTITEM returned %ld, expected 3\n", ret);
634     ok(g_fReceivedHotItemChange == FALSE, "Unexpected TBN_HOTITEMCHANGE\n");
635
636     SendMessage(hToolbar, TB_SETHOTITEM, 1, 0);
637     tbinfo.cbSize = sizeof(TBBUTTONINFO);
638     tbinfo.dwMask = TBIF_STATE;
639     tbinfo.fsState = 0;  /* disabled */
640     g_fReceivedHotItemChange = FALSE;
641     ok(SendMessage(hToolbar, TB_SETBUTTONINFO, 1, (LPARAM)&tbinfo) == TRUE, "TB_SETBUTTONINFO failed\n");
642     ret = SendMessage(hToolbar, TB_GETHOTITEM, 0, 0);
643     ok(ret == 1, "TB_SETHOTITEM returned %ld, expected 1\n", ret);
644     ok(g_fReceivedHotItemChange == FALSE, "Unexpected TBN_HOTITEMCHANGE\n");
645
646     DestroyWindow(hToolbar);
647 }
648
649 #if 0  /* use this to generate more tests*/
650
651 static void dump_sizes(HWND hToolbar)
652 {
653     SIZE sz;
654     RECT r;
655     int count = SendMessage(hToolbar, TB_BUTTONCOUNT, 0, 0);
656     int i;
657
658     GetClientRect(hToolbar, &r);
659     SendMessageA(hToolbar, TB_GETMAXSIZE, 0, &sz);
660     printf("  { {%d, %d, %d, %d}, {%d, %d}, %d, {", r.left, r.top, r.right, r.bottom,
661         sz.cx, sz.cy, count);
662     for (i=0; i<count; i++)
663     {
664         SendMessageA(hToolbar, TB_GETITEMRECT, i, &r);
665         printf("%s{%3d, %3d, %3d, %3d}, ", (i%3==0 ? "\n    " : ""), r.left, r.top, r.right, r.bottom);
666     }
667     printf("\n  }, },\n");
668 }
669
670 #define check_sizes() dump_sizes(hToolbar);
671 #define check_sizes_todo(todomask) dump_sizes(hToolbar);
672
673 #else
674
675 typedef struct
676 {
677     RECT rcClient;
678     SIZE szMin;
679     INT nButtons;
680     RECT rcButtons[100];
681 } tbsize_result_t;
682
683 static tbsize_result_t tbsize_results[] =
684 {
685   { {0, 0, 672, 26}, {100, 22}, 5, {
686     {  0,   2,  23,  24}, { 23,   2,  46,  24}, { 46,   2,  54,  24},
687     { 54,   2,  77,  24}, { 77,   2, 100,  24},
688   }, },
689   { {0, 0, 672, 26}, {146, 22}, 7, {
690     {  0,   2,  23,  24}, { 23,   2,  46,  24}, { 46,   2,  54,  24},
691     { 54,   2,  77,  24}, { 77,   2, 100,  24}, {100,   2, 123,  24},
692     {  0,  24,  23,  46},
693   }, },
694   { {0, 0, 672, 48}, {146, 22}, 7, {
695     {  0,   2,  23,  24}, { 23,   2,  46,  24}, { 46,   2,  54,  24},
696     { 54,   2,  77,  24}, { 77,   2, 100,  24}, {100,   2, 123,  24},
697     {  0,  24,  23,  46},
698   }, },
699   { {0, 0, 672, 26}, {146, 22}, 7, {
700     {  0,   2,  23,  24}, { 23,   2,  46,  24}, { 46,   2,  54,  24},
701     { 54,   2,  77,  24}, { 77,   2, 100,  24}, {100,   2, 123,  24},
702     {123,   2, 146,  24},
703   }, },
704   { {0, 0, 672, 26}, {192, 22}, 9, {
705     {  0,   2,  23,  24}, { 23,   2,  46,  24}, { 46,   2,  54,  24},
706     { 54,   2,  77,  24}, { 77,   2, 100,  24}, {100,   2, 123,  24},
707     {123,   2, 146,  24}, {146,   2, 169,  24}, {169,   2, 192,  24},
708   }, },
709   { {0, 0, 672, 92}, {882, 22}, 39, {
710     {  0,   2,  23,  24}, { 23,   2,  46,  24}, {  0,   2,   8,  29},
711     {  0,  29,  23,  51}, { 23,  29,  46,  51}, { 46,  29,  69,  51},
712     { 69,  29,  92,  51}, { 92,  29, 115,  51}, {115,  29, 138,  51},
713     {138,  29, 161,  51}, {161,  29, 184,  51}, {184,  29, 207,  51},
714     {207,  29, 230,  51}, {230,  29, 253,  51}, {253,  29, 276,  51},
715     {276,  29, 299,  51}, {299,  29, 322,  51}, {322,  29, 345,  51},
716     {345,  29, 368,  51}, {368,  29, 391,  51}, {391,  29, 414,  51},
717     {414,  29, 437,  51}, {437,  29, 460,  51}, {460,  29, 483,  51},
718     {483,  29, 506,  51}, {506,  29, 529,  51}, {529,  29, 552,  51},
719     {552,  29, 575,  51}, {575,  29, 598,  51}, {598,  29, 621,  51},
720     {621,  29, 644,  51}, {644,  29, 667,  51}, {  0,  51,  23,  73},
721     { 23,  51,  46,  73}, { 46,  51,  69,  73}, { 69,  51,  92,  73},
722     { 92,  51, 115,  73}, {115,  51, 138,  73}, {138,  51, 161,  73},
723   }, },
724   { {0, 0, 48, 226}, {23, 140}, 7, {
725     {  0,   2,  23,  24}, { 23,   2,  46,  24}, { 46,   2,  94,  24},
726     { 94,   2, 117,  24}, {117,   2, 140,  24}, {140,   2, 163,  24},
727     {  0,  24,  23,  46},
728   }, },
729   { {0, 0, 92, 226}, {23, 140}, 7, {
730     {  0,   2,  23,  24}, { 23,   2,  46,  24}, {  0,  24,  92,  32},
731     {  0,  32,  23,  54}, { 23,  32,  46,  54}, { 46,  32,  69,  54},
732     { 69,  32,  92,  54},
733   }, },
734   { {0, 0, 672, 26}, {194, 30}, 7, {
735     {  0,   2,  31,  32}, { 31,   2,  62,  32}, { 62,   2,  70,  32},
736     { 70,   2, 101,  32}, {101,   2, 132,  32}, {132,   2, 163,  32},
737     {  0,  32,  31,  62},
738   }, },
739   { {0, 0, 672, 64}, {194, 30}, 7, {
740     {  0,   2,  31,  32}, { 31,   2,  62,  32}, { 62,   2,  70,  32},
741     { 70,   2, 101,  32}, {101,   2, 132,  32}, {132,   2, 163,  32},
742     {  0,  32,  31,  62},
743   }, },
744   { {0, 0, 672, 64}, {194, 30}, 7, {
745     {  0,   0,  31,  30}, { 31,   0,  62,  30}, { 62,   0,  70,  30},
746     { 70,   0, 101,  30}, {101,   0, 132,  30}, {132,   0, 163,  30},
747     {  0,  30,  31,  60},
748   }, },
749   { {0, 0, 124, 226}, {31, 188}, 7, {
750     {  0,   0,  31,  30}, { 31,   0,  62,  30}, {  0,  30, 124,  38},
751     {  0,  38,  31,  68}, { 31,  38,  62,  68}, { 62,  38,  93,  68},
752     { 93,  38, 124,  68},
753   }, },
754   { {0, 0, 672, 26}, {146, 22}, 7, {
755     {  0,   2,  23,  24}, { 23,   2,  46,  24}, { 46,   2,  54,  24},
756     { 54,   2,  77,  24}, { 77,   2, 100,  24}, {100,   2, 123,  24},
757     {123,   2, 146,  24},
758   }, },
759   { {0, 0, 672, 26}, {146, 100}, 7, {
760     {  0,   0,  23, 100}, { 23,   0,  46, 100}, { 46,   0,  54, 100},
761     { 54,   0,  77, 100}, { 77,   0, 100, 100}, {100,   0, 123, 100},
762     {123,   0, 146, 100},
763   }, },
764   { {0, 0, 672, 26}, {215, 100}, 10, {
765     {  0,   0,  23, 100}, { 23,   0,  46, 100}, { 46,   0,  54, 100},
766     { 54,   0,  77, 100}, { 77,   0, 100, 100}, {100,   0, 123, 100},
767     {123,   0, 146, 100}, {146,   0, 169, 100}, {169,   0, 192, 100},
768     {192,   0, 215, 100},
769   }, },
770   { {0, 0, 672, 26}, {238, 39}, 11, {
771     {  0,   0,  23,  39}, { 23,   0,  46,  39}, { 46,   0,  54,  39},
772     { 54,   0,  77,  39}, { 77,   0, 100,  39}, {100,   0, 123,  39},
773     {123,   0, 146,  39}, {146,   0, 169,  39}, {169,   0, 192,  39},
774     {192,   0, 215,  39}, {215,   0, 238,  39},
775   }, },
776   { {0, 0, 672, 26}, {238, 22}, 11, {
777     {  0,   0,  23,  22}, { 23,   0,  46,  22}, { 46,   0,  54,  22},
778     { 54,   0,  77,  22}, { 77,   0, 100,  22}, {100,   0, 123,  22},
779     {123,   0, 146,  22}, {146,   0, 169,  22}, {169,   0, 192,  22},
780     {192,   0, 215,  22}, {215,   0, 238,  22},
781   }, },
782   { {0, 0, 672, 26}, {489, 39}, 3, {
783     {  0,   2, 163,  41}, {163,   2, 330,  41}, {330,   2, 493,  41},
784   }, },
785   { {0, 0, 672, 104}, {978, 24}, 6, {
786     {  0,   2, 163,  26}, {163,   2, 326,  26}, {326,   2, 489,  26},
787     {489,   2, 652,  26}, {652,   2, 819,  26}, {819,   2, 850,  26},
788   }, },
789   { {0, 0, 672, 28}, {978, 38}, 6, {
790     {  0,   0, 163,  38}, {163,   0, 326,  38}, {326,   0, 489,  38},
791     {489,   0, 652,  38}, {652,   0, 819,  38}, {819,   0, 850,  38},
792   }, },
793   { {0, 0, 672, 100}, {239, 102}, 3, {
794     {  0,   2, 100,  102}, {100,   2, 139,  102}, {139, 2, 239,  102},
795   }, },
796   { {0, 0, 672, 42}, {185, 40}, 3, {
797       {  0,   2,  75,  40}, {75,   2, 118, 40}, {118, 2, 185, 40},
798   }, },
799   { {0, 0, 672, 42}, {67, 40}, 1, {
800       {  0,   2,  67,  40},
801   }, },
802   { {0, 0, 672, 42}, {67, 41}, 2, {
803       {  0,   2,  672,  41}, {  0,   41,  672,  80},
804   }, },
805 };
806
807 static int tbsize_numtests = 0;
808
809 typedef struct
810 {
811     int test_num;
812     int rect_index;
813     RECT rcButton;
814 } tbsize_alt_result_t;
815
816 static tbsize_alt_result_t tbsize_alt_results[] =
817 {
818   { 5, 2, { 0, 24, 8, 29 } },
819   { 20, 1, { 100, 2, 107, 102 } },
820   { 20, 2, { 107, 2, 207, 102 } }
821 };
822
823 static int tbsize_alt_numtests = 0;
824
825 #define check_sizes_todo(todomask) { \
826         RECT rc; \
827         int buttonCount, i, mask=(todomask); \
828         tbsize_result_t *res = &tbsize_results[tbsize_numtests]; \
829         assert(tbsize_numtests < sizeof(tbsize_results)/sizeof(tbsize_results[0])); \
830         GetClientRect(hToolbar, &rc); \
831         /*check_rect("client", rc, res->rcClient);*/ \
832         buttonCount = SendMessage(hToolbar, TB_BUTTONCOUNT, 0, 0); \
833         compare(buttonCount, res->nButtons, "%d"); \
834         for (i=0; i<min(buttonCount, res->nButtons); i++) { \
835             ok(SendMessageA(hToolbar, TB_GETITEMRECT, i, (LPARAM)&rc) == 1, "TB_GETITEMRECT\n"); \
836             if (broken(tbsize_alt_numtests < sizeof(tbsize_alt_results)/sizeof(tbsize_alt_results[0]) && \
837                        memcmp(&rc, &tbsize_alt_results[tbsize_alt_numtests].rcButton, sizeof(RECT)) == 0)) { \
838                 win_skip("Alternate rect found\n"); \
839                 tbsize_alt_numtests++; \
840             } else if (!(mask&1)) { \
841                 check_rect("button", rc, res->rcButtons[i]); \
842             } else {\
843                 todo_wine { check_rect("button", rc, res->rcButtons[i]); } \
844             } \
845             mask >>= 1; \
846         } \
847         tbsize_numtests++; \
848     }
849
850 #define check_sizes() check_sizes_todo(0)
851
852 #endif
853
854 static TBBUTTON buttons1[] = {
855     {0, 10, TBSTATE_WRAP|TBSTATE_ENABLED, 0, {0, }, 0, -1},
856     {0, 11, 0, 0, {0, }, 0, -1},
857 };
858 static TBBUTTON buttons2[] = {
859     {0, 20, TBSTATE_ENABLED, 0, {0, }, 0, -1},
860     {0, 21, TBSTATE_ENABLED, 0, {0, }, 0, -1},
861 };
862 static TBBUTTON buttons3[] = {
863     {0, 30, TBSTATE_ENABLED, 0, {0, }, 0, 0},
864     {0, 31, TBSTATE_ENABLED, 0, {0, }, 0, 1},
865     {0, 32, TBSTATE_ENABLED, BTNS_AUTOSIZE, {0, }, 0, 1},
866     {0, 33, TBSTATE_ENABLED, BTNS_AUTOSIZE, {0, }, 0, (UINT_PTR)"Tst"}
867 };
868
869 static void test_sizes(void)
870 {
871     HWND hToolbar = NULL;
872     HIMAGELIST himl, himl2;
873     TBBUTTONINFO tbinfo;
874     int style;
875     int i;
876
877     rebuild_toolbar_with_buttons(&hToolbar);
878     style = GetWindowLong(hToolbar, GWL_STYLE);
879     ok(style == (WS_CHILD|WS_VISIBLE|CCS_TOP), "Invalid style %x\n", style);
880     check_sizes();
881     /* the TBSTATE_WRAP makes a second row */
882     SendMessageA(hToolbar, TB_ADDBUTTONS, 2, (LPARAM)buttons1);
883     check_sizes();
884     SendMessageA(hToolbar, TB_AUTOSIZE, 0, 0);
885     check_sizes();
886     /* after setting the TBSTYLE_WRAPABLE the TBSTATE_WRAP is ignored */
887     SetWindowLong(hToolbar, GWL_STYLE, style|TBSTYLE_WRAPABLE);
888     check_sizes();
889     /* adding new buttons with TBSTYLE_WRAPABLE doesn't add a new row */
890     SendMessageA(hToolbar, TB_ADDBUTTONS, 2, (LPARAM)buttons1);
891     check_sizes();
892     /* only after adding enough buttons the bar will be wrapped on a
893      * separator and then on the first button */
894     for (i=0; i<15; i++)
895         SendMessageA(hToolbar, TB_ADDBUTTONS, 2, (LPARAM)buttons1);
896     check_sizes_todo(0x4);
897
898     rebuild_toolbar_with_buttons(&hToolbar);
899     SendMessageA(hToolbar, TB_ADDBUTTONS, 2, (LPARAM)buttons1);
900     /* setting the buttons vertical will only change the window client size */
901     SetWindowLong(hToolbar, GWL_STYLE, style | CCS_VERT);
902     SendMessage(hToolbar, TB_AUTOSIZE, 0, 0);
903     check_sizes_todo(0x3c);
904     /* with a TBSTYLE_WRAPABLE a wrapping will occur on the separator */
905     SetWindowLong(hToolbar, GWL_STYLE, style | TBSTYLE_WRAPABLE | CCS_VERT);
906     SendMessage(hToolbar, TB_AUTOSIZE, 0, 0);
907     check_sizes_todo(0x7c);
908
909     rebuild_toolbar_with_buttons(&hToolbar);
910     SendMessageA(hToolbar, TB_ADDBUTTONS, 2, (LPARAM)buttons1);
911     /* a TB_SETBITMAPSIZE changes button sizes*/
912     SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(24, 24));
913     check_sizes();
914
915     /* setting a TBSTYLE_FLAT doesn't change anything - even after a TB_AUTOSIZE */
916     SetWindowLong(hToolbar, GWL_STYLE, style | TBSTYLE_FLAT);
917     SendMessageA(hToolbar, TB_AUTOSIZE, 0, 0);
918     check_sizes();
919     /* but after a TB_SETBITMAPSIZE the top margins is changed */
920     SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(20, 20));
921     SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(24, 24));
922     check_sizes();
923     /* some vertical toolbar sizes */
924     SetWindowLong(hToolbar, GWL_STYLE, style | TBSTYLE_FLAT | TBSTYLE_WRAPABLE | CCS_VERT);
925     check_sizes_todo(0x7c);
926
927     rebuild_toolbar_with_buttons(&hToolbar);
928     SetWindowLong(hToolbar, GWL_STYLE, style | TBSTYLE_FLAT);
929     /* newly added buttons will be use the previous margin */
930     SendMessageA(hToolbar, TB_ADDBUTTONS, 2, (LPARAM)buttons2);
931     check_sizes();
932     /* TB_SETBUTTONSIZE can't be used to reduce the size of a button below the default */
933     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(23, 22), "Unexpected button size\n");
934     ok(SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(22, 21))==1, "TB_SETBUTTONSIZE\n");
935     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(23, 22), "Unexpected button size\n");
936     ok(SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(5, 100))==1, "TB_SETBUTTONSIZE\n");
937     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(23, 100), "Unexpected button size\n");
938     ok(SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(3, 3))==1, "TB_SETBUTTONSIZE\n");
939     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(23, 22), "Unexpected button size\n");
940     ok(SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(5, 100))==1, "TB_SETBUTTONSIZE\n");
941     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(23, 100), "Unexpected button size\n");
942     check_sizes();
943     /* add some buttons with non-default sizes */
944     SendMessageA(hToolbar, TB_ADDBUTTONS, 2, (LPARAM)buttons2);
945     SendMessageA(hToolbar, TB_INSERTBUTTON, -1, (LPARAM)&buttons2[0]);
946     check_sizes();
947     SendMessageA(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons3[0]);
948     /* TB_ADDSTRING resets the size */
949     SendMessageA(hToolbar, TB_ADDSTRING, 0, (LPARAM)"A\0MMMMMMMMMMMMM\0");
950     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(23, 39), "Unexpected button size\n");
951     check_sizes();
952     /* TB_SETBUTTONSIZE can be used to crop the text */
953     SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(3, 3));
954     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(23, 22), "Unexpected button size\n");
955     check_sizes();
956     /* the default size is bitmap size + padding */
957     SendMessageA(hToolbar, TB_SETPADDING, 0, MAKELONG(1, 1));
958     SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(3, 3));
959     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(17, 17), "Unexpected button size\n");
960     SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(3, 3));
961     SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(3, 3));
962     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(4, 4), "Unexpected button size\n");
963
964     rebuild_toolbar(&hToolbar);
965     /* sending a TB_SETBITMAPSIZE with the same sizes is enough to make the button smaller */
966     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(23, 22), "Unexpected button size\n");
967     SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(16, 15));
968     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(23, 21), "Unexpected button size\n");
969     /* -1 in TB_SETBITMAPSIZE is a special code meaning that the coordinate shouldn't be changed */
970     add_128x15_bitmap(hToolbar, 16);
971     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(14, -1)), "TB_SETBITMAPSIZE failed\n");
972     compare((int)SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0), MAKELONG(21, 21), "%x");
973     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(-1, 12)), "TB_SETBITMAPSIZE failed\n");
974     compare((int)SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0), MAKELONG(21, 18), "%x");
975     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELONG(-1, -1)), "TB_SETBITMAPSIZE failed\n");
976     compare((int)SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0), MAKELONG(21, 18), "%x");
977     /* check the imagelist */
978     InvalidateRect(hToolbar, NULL, TRUE);
979     UpdateWindow(hToolbar);
980     CHECK_IMAGELIST(16, 14, 12);
981
982     rebuild_toolbar(&hToolbar);
983     SendMessageA(hToolbar, TB_ADDSTRINGA, 0, (LPARAM)"A\0MMMMMMMMMMMMM\0");
984     /* the height is increased after a TB_ADDSTRING */
985     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(23, 39), "Unexpected button size\n");
986     SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(100, 100));
987     /* if a string is in the pool, even adding a button without a string resets the size */
988     SendMessageA(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons2[0]);
989     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(23, 22), "Unexpected button size\n");
990     SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(100, 100));
991     /* an BTNS_AUTOSIZE button is also considered when computing the new size */
992     SendMessageA(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons3[2]);
993     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(163, 39), "Unexpected button size\n");
994     SendMessageA(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons3[0]);
995     check_sizes();
996     /* delete button doesn't change the buttons size */
997     SendMessageA(hToolbar, TB_DELETEBUTTON, 2, 0);
998     SendMessageA(hToolbar, TB_DELETEBUTTON, 1, 0);
999     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(163, 39), "Unexpected button size\n");
1000     /* TB_INSERTBUTTONS will */
1001     SendMessageA(hToolbar, TB_INSERTBUTTON, 1, (LPARAM)&buttons2[0]);
1002     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(23, 22), "Unexpected button size\n");
1003
1004     /* TB_HIDEBUTTON and TB_MOVEBUTTON doesn't force a recalc */
1005     SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(100, 100));
1006     ok(SendMessageA(hToolbar, TB_MOVEBUTTON, 0, 1), "TB_MOVEBUTTON failed\n");
1007     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(100, 100), "Unexpected button size\n");
1008     ok(SendMessageA(hToolbar, TB_HIDEBUTTON, 20, TRUE), "TB_HIDEBUTTON failed\n");
1009     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(100, 100), "Unexpected button size\n");
1010     /* however changing the hidden flag with TB_SETSTATE does */
1011     ok(SendMessageA(hToolbar, TB_SETSTATE, 20, TBSTATE_ENABLED|TBSTATE_HIDDEN), "TB_SETSTATE failed\n");
1012     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(100, 100), "Unexpected button size\n");
1013     ok(SendMessageA(hToolbar, TB_SETSTATE, 20, TBSTATE_ENABLED), "TB_SETSTATE failed\n");
1014     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(23, 22), "Unexpected button size\n");
1015
1016     /* TB_SETIMAGELIST always changes the height but the width only if necessary */
1017     SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(100, 100));
1018     himl = ImageList_LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_BITMAP_80x15), 20, 2, CLR_NONE, IMAGE_BITMAP, LR_DEFAULTCOLOR);
1019     ok(SendMessageA(hToolbar, TB_SETIMAGELIST, 0, (LPARAM)himl) == 0, "TB_SETIMAGELIST failed\n");
1020     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(100, 21), "Unexpected button size\n");
1021     SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(100, 100));
1022     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(100, 100), "Unexpected button size\n");
1023     /* But there are no update when we change imagelist, and image sizes are the same */
1024     himl2 = ImageList_LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_BITMAP_128x15), 20, 2, CLR_NONE, IMAGE_BITMAP, LR_DEFAULTCOLOR);
1025     ok(SendMessageA(hToolbar, TB_SETIMAGELIST, 0, (LRESULT)himl2) == (LRESULT)himl, "TB_SETIMAGELIST failed\n");
1026     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(100, 100), "Unexpected button size\n");
1027     SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(1, 1));
1028     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(27, 21), "Unexpected button size\n");
1029     ok(SendMessageA(hToolbar, TB_SETIMAGELIST, 0, 0) == (LRESULT)himl2, "TB_SETIMAGELIST failed\n");
1030     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(27, 7), "Unexpected button size\n");
1031     SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELONG(1, 1));
1032     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(8, 7), "Unexpected button size\n");
1033     ok(SendMessageA(hToolbar, TB_SETIMAGELIST, 0, (LPARAM)himl) == 0, "TB_SETIMAGELIST failed\n");
1034     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(27, 21), "Unexpected button size\n");
1035     /* the text is taken into account */
1036     SendMessageA(hToolbar, TB_ADDSTRINGA, 0, (LPARAM)"A\0MMMMMMMMMMMMM\0");
1037     SendMessageA(hToolbar, TB_ADDBUTTONS, 4, (LPARAM)buttons3);
1038     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(163, 38), "Unexpected button size\n");
1039     ok(SendMessageA(hToolbar, TB_SETIMAGELIST, 0, 0) == (LRESULT)himl, "TB_SETIMAGELIST failed\n");
1040     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(163, 24), "Unexpected button size\n");
1041     /* the style change also comes into effect */
1042     check_sizes();
1043     SetWindowLong(hToolbar, GWL_STYLE, GetWindowLong(hToolbar, GWL_STYLE) | TBSTYLE_FLAT);
1044     ok(SendMessageA(hToolbar, TB_SETIMAGELIST, 0, (LPARAM)himl) == 0, "TB_SETIMAGELIST failed\n");
1045     check_sizes_todo(0x30);     /* some small problems with BTNS_AUTOSIZE button sizes */
1046
1047     rebuild_toolbar(&hToolbar);
1048     ImageList_Destroy(himl);
1049     ImageList_Destroy(himl2);
1050
1051     SendMessageA(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons3[3]);
1052     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(27, 39), "Unexpected button size\n");
1053     SendMessageA(hToolbar, TB_DELETEBUTTON, 0, 0);
1054     ok(SendMessageA(hToolbar, TB_GETBUTTONSIZE, 0, 0) == MAKELONG(27, 39), "Unexpected button size\n");
1055
1056     rebuild_toolbar(&hToolbar);
1057
1058     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELPARAM(32, 32)) == 1, "TB_SETBITMAPSIZE failed\n");
1059     ok(SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELPARAM(100, 100)) == 1, "TB_SETBUTTONSIZE failed\n");
1060     ok(SendMessageA(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons2[0]) == 1, "TB_ADDBUTTONS failed\n");
1061     ok(SendMessageA(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons3[2]) == 1, "TB_ADDBUTTONS failed\n");
1062     ok(SendMessageA(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons3[0]) == 1, "TB_ADDBUTTONS failed\n");
1063     SendMessageA(hToolbar, TB_AUTOSIZE, 0, 0 );
1064     check_sizes();
1065
1066     rebuild_toolbar(&hToolbar);
1067     SetWindowLong(hToolbar, GWL_STYLE, TBSTYLE_LIST | GetWindowLong(hToolbar, GWL_STYLE));
1068     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELPARAM(32, 32)) == 1, "TB_SETBITMAPSIZE failed\n");
1069     ok(SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELPARAM(100, 100)) == 1, "TB_SETBUTTONSIZE failed\n");
1070     ok(SendMessageA(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons2[0]) == 1, "TB_ADDBUTTONS failed\n");
1071     ok(SendMessageA(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons3[2]) == 1, "TB_ADDBUTTONS failed\n");
1072     ok(SendMessageA(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons3[3]) == 1, "TB_ADDBUTTONS failed\n");
1073     SendMessageA(hToolbar, TB_AUTOSIZE, 0, 0 );
1074     check_sizes_todo(0xff);
1075
1076     rebuild_toolbar(&hToolbar);
1077     SetWindowLong(hToolbar, GWL_STYLE, TBSTYLE_LIST | GetWindowLong(hToolbar, GWL_STYLE));
1078     ok(SendMessageA(hToolbar, TB_SETBITMAPSIZE, 0, MAKELPARAM(32, 32)) == 1, "TB_SETBITMAPSIZE failed\n");
1079     ok(SendMessageA(hToolbar, TB_SETBUTTONSIZE, 0, MAKELPARAM(100, 100)) == 1, "TB_SETBUTTONSIZE failed\n");
1080     ok(SendMessageA(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons3[3]) == 1, "TB_ADDBUTTONS failed\n");
1081     SendMessageA(hToolbar, TB_AUTOSIZE, 0, 0 );
1082     check_sizes();
1083
1084     rebuild_toolbar(&hToolbar);
1085     SetWindowLong(hToolbar, GWL_STYLE, TBSTYLE_WRAPABLE | GetWindowLong(hToolbar, GWL_STYLE));
1086     ok(SendMessageA(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons3[3]) == 1, "TB_ADDBUTTONS failed\n");
1087     ok(SendMessageA(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons3[3]) == 1, "TB_ADDBUTTONS failed\n");
1088     tbinfo.cx = 672;
1089     tbinfo.cbSize = sizeof(TBBUTTONINFO);
1090     tbinfo.dwMask = TBIF_SIZE | TBIF_BYINDEX;
1091     if (SendMessageA(hToolbar, TB_SETBUTTONINFO, 0, (LPARAM)&tbinfo))
1092     {
1093         ok(SendMessageA(hToolbar, TB_SETBUTTONINFO, 1, (LPARAM)&tbinfo) != 0, "TB_SETBUTTONINFO failed\n");
1094         SendMessageA(hToolbar, TB_AUTOSIZE, 0, 0);
1095         check_sizes();
1096     }
1097     else  /* TBIF_BYINDEX probably not supported, confirm that this was the reason for the failure */
1098     {
1099         tbinfo.dwMask = TBIF_SIZE;
1100         ok(SendMessageA(hToolbar, TB_SETBUTTONINFO, 33, (LPARAM)&tbinfo) != 0, "TB_SETBUTTONINFO failed\n");
1101     }
1102
1103     DestroyWindow(hToolbar);
1104 }
1105
1106 /* Toolbar control has two ways of reacting to a change. We call them a
1107  * relayout and recalc. A recalc forces a recompute of values like button size
1108  * and top margin (the latter in comctl32 <v6), while a relayout uses the cached
1109  * values. This functions creates a flat toolbar with a top margin of a non-flat
1110  * toolbar. We will notice a recalc, as it will recompte the top margin and
1111  * change it to zero*/
1112 static void prepare_recalc_test(HWND *phToolbar)
1113 {
1114     RECT rect;
1115     rebuild_toolbar_with_buttons(phToolbar);
1116     SetWindowLong(*phToolbar, GWL_STYLE,
1117         GetWindowLong(*phToolbar, GWL_STYLE) | TBSTYLE_FLAT);
1118     SendMessage(*phToolbar, TB_GETITEMRECT, 1, (LPARAM)&rect);
1119     ok(rect.top == 2, "Test will make no sense because initial top is %d instead of 2\n",
1120         rect.top);
1121 }
1122
1123 static BOOL did_recalc(HWND hToolbar)
1124 {
1125     RECT rect;
1126     SendMessage(hToolbar, TB_GETITEMRECT, 1, (LPARAM)&rect);
1127     ok(rect.top == 2 || rect.top == 0, "Unexpected top margin %d in recalc test\n",
1128         rect.top);
1129     return (rect.top == 0);
1130 }
1131
1132 /* call after a recalc did happen to return to an unstable state */
1133 static void restore_recalc_state(HWND hToolbar)
1134 {
1135     RECT rect;
1136     /* return to style with a 2px top margin */
1137     SetWindowLong(hToolbar, GWL_STYLE,
1138         GetWindowLong(hToolbar, GWL_STYLE) & ~TBSTYLE_FLAT);
1139     /* recalc */
1140     SendMessage(hToolbar, TB_ADDBUTTONS, 1, (LPARAM)&buttons3[3]);
1141     /* top margin will be 0px if a recalc occurs */
1142     SetWindowLong(hToolbar, GWL_STYLE,
1143         GetWindowLong(hToolbar, GWL_STYLE) | TBSTYLE_FLAT);
1144     /* safety check */
1145     SendMessage(hToolbar, TB_GETITEMRECT, 1, (LPARAM)&rect);
1146     ok(rect.top == 2, "Test will make no sense because initial top is %d instead of 2\n",
1147         rect.top);
1148 }
1149
1150 static void test_recalc(void)
1151 {
1152     HWND hToolbar = NULL;
1153     TBBUTTONINFO bi;
1154     CHAR test[] = "Test";
1155     const int EX_STYLES_COUNT = 5;
1156     int i;
1157     BOOL recalc;
1158
1159     /* Like TB_ADDBUTTONS tested in test_sized, inserting a button without text
1160      * results in a relayout, while adding one with text forces a recalc */
1161     prepare_recalc_test(&hToolbar);
1162     SendMessage(hToolbar, TB_INSERTBUTTON, 1, (LPARAM)&buttons3[0]);
1163     recalc = did_recalc(hToolbar);
1164     ok(!recalc, "Unexpected recalc - adding button without text\n");
1165
1166     prepare_recalc_test(&hToolbar);
1167     SendMessage(hToolbar, TB_INSERTBUTTON, 1, (LPARAM)&buttons3[3]);
1168     recalc = did_recalc(hToolbar);
1169     ok(recalc, "Expected a recalc - adding button with text\n");
1170
1171     /* TB_SETBUTTONINFO, even when adding a text, results only in a relayout */
1172     prepare_recalc_test(&hToolbar);
1173     bi.cbSize = sizeof(bi);
1174     bi.dwMask = TBIF_TEXT;
1175     bi.pszText = test;
1176     SendMessage(hToolbar, TB_SETBUTTONINFO, 1, (LPARAM)&bi);
1177     recalc = did_recalc(hToolbar);
1178     ok(!recalc, "Unexpected recalc - setting a button text\n");
1179
1180     /* most extended styled doesn't force a recalc (testing all the bits gives
1181      * the same results, but prints some ERRs while testing) */
1182     for (i = 0; i < EX_STYLES_COUNT; i++)
1183     {
1184         if (i == 1 || i == 3)  /* an undoc style and TBSTYLE_EX_MIXEDBUTTONS */
1185             continue;
1186         prepare_recalc_test(&hToolbar);
1187         expect(0, (int)SendMessage(hToolbar, TB_GETEXTENDEDSTYLE, 0, 0));
1188         SendMessage(hToolbar, TB_SETEXTENDEDSTYLE, 0, (1 << i));
1189         recalc = did_recalc(hToolbar);
1190         ok(!recalc, "Unexpected recalc - setting bit %d\n", i);
1191         SendMessage(hToolbar, TB_SETEXTENDEDSTYLE, 0, 0);
1192         recalc = did_recalc(hToolbar);
1193         ok(!recalc, "Unexpected recalc - clearing bit %d\n", i);
1194         expect(0, (int)SendMessage(hToolbar, TB_GETEXTENDEDSTYLE, 0, 0));
1195     }
1196
1197     /* TBSTYLE_EX_MIXEDBUTTONS does a recalc on change */
1198     prepare_recalc_test(&hToolbar);
1199     SendMessage(hToolbar, TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_MIXEDBUTTONS);
1200     recalc = did_recalc(hToolbar);
1201     if (recalc)
1202     {
1203         ok(recalc, "Expected a recalc - setting TBSTYLE_EX_MIXEDBUTTONS\n");
1204         restore_recalc_state(hToolbar);
1205         SendMessage(hToolbar, TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_MIXEDBUTTONS);
1206         recalc = did_recalc(hToolbar);
1207         ok(!recalc, "Unexpected recalc - setting TBSTYLE_EX_MIXEDBUTTONS again\n");
1208         restore_recalc_state(hToolbar);
1209         SendMessage(hToolbar, TB_SETEXTENDEDSTYLE, 0, 0);
1210         recalc = did_recalc(hToolbar);
1211         ok(recalc, "Expected a recalc - clearing TBSTYLE_EX_MIXEDBUTTONS\n");
1212     }
1213     else win_skip( "No recalc on TBSTYLE_EX_MIXEDBUTTONS\n" );
1214
1215     /* undocumented exstyle 0x2 seems to changes the top margin, what
1216      * interferes with these tests */
1217
1218     DestroyWindow(hToolbar);
1219 }
1220
1221 static void test_getbuttoninfo(void)
1222 {
1223     HWND hToolbar = NULL;
1224     int i;
1225
1226     rebuild_toolbar_with_buttons(&hToolbar);
1227     for (i = 0; i < 128; i++)
1228     {
1229         TBBUTTONINFO tbi;
1230         int ret;
1231
1232         tbi.cbSize = i;
1233         tbi.dwMask = TBIF_COMMAND;
1234         ret = (int)SendMessage(hToolbar, TB_GETBUTTONINFO, 1, (LPARAM)&tbi);
1235         if (i == sizeof(TBBUTTONINFO)) {
1236             compare(ret, 0, "%d");
1237         } else {
1238             compare(ret, -1, "%d");
1239         }
1240     }
1241     DestroyWindow(hToolbar);
1242 }
1243
1244 static void test_createtoolbarex(void)
1245 {
1246     HWND hToolbar;
1247     TBBUTTON btns[3];
1248     ZeroMemory(&btns, sizeof(btns));
1249
1250     hToolbar = CreateToolbarEx(hMainWnd, WS_VISIBLE, 1, 16, GetModuleHandle(NULL), IDB_BITMAP_128x15, btns,
1251         3, 20, 20, 16, 16, sizeof(TBBUTTON));
1252     CHECK_IMAGELIST(16, 20, 20);
1253     compare((int)SendMessage(hToolbar, TB_GETBUTTONSIZE, 0, 0), 0x1a001b, "%x");
1254     DestroyWindow(hToolbar);
1255
1256     hToolbar = CreateToolbarEx(hMainWnd, WS_VISIBLE, 1, 16, GetModuleHandle(NULL), IDB_BITMAP_128x15, btns,
1257         3, 4, 4, 16, 16, sizeof(TBBUTTON));
1258     CHECK_IMAGELIST(32, 4, 4);
1259     compare((int)SendMessage(hToolbar, TB_GETBUTTONSIZE, 0, 0), 0xa000b, "%x");
1260     DestroyWindow(hToolbar);
1261
1262     hToolbar = CreateToolbarEx(hMainWnd, WS_VISIBLE, 1, 16, GetModuleHandle(NULL), IDB_BITMAP_128x15, btns,
1263         3, 0, 8, 12, 12, sizeof(TBBUTTON));
1264     CHECK_IMAGELIST(16, 12, 12);
1265     compare((int)SendMessage(hToolbar, TB_GETBUTTONSIZE, 0, 0), 0x120013, "%x");
1266     DestroyWindow(hToolbar);
1267
1268     hToolbar = CreateToolbarEx(hMainWnd, WS_VISIBLE, 1, 16, GetModuleHandle(NULL), IDB_BITMAP_128x15, btns,
1269         3, -1, 8, 12, 12, sizeof(TBBUTTON));
1270     CHECK_IMAGELIST(16, 12, 8);
1271     compare((int)SendMessage(hToolbar, TB_GETBUTTONSIZE, 0, 0), 0xe0013, "%x");
1272     DestroyWindow(hToolbar);
1273
1274     hToolbar = CreateToolbarEx(hMainWnd, WS_VISIBLE, 1, 16, GetModuleHandle(NULL), IDB_BITMAP_128x15, btns,
1275         3, -1, 8, -1, 12, sizeof(TBBUTTON));
1276     CHECK_IMAGELIST(16, 16, 8);
1277     compare((int)SendMessage(hToolbar, TB_GETBUTTONSIZE, 0, 0), 0xe0017, "%x");
1278     DestroyWindow(hToolbar);
1279
1280     hToolbar = CreateToolbarEx(hMainWnd, WS_VISIBLE, 1, 16, GetModuleHandle(NULL), IDB_BITMAP_128x15, btns,
1281         3, 0, 0, 12, -1, sizeof(TBBUTTON));
1282     CHECK_IMAGELIST(16, 12, 16);
1283     compare((int)SendMessage(hToolbar, TB_GETBUTTONSIZE, 0, 0), 0x160013, "%x");
1284     DestroyWindow(hToolbar);
1285
1286     hToolbar = CreateToolbarEx(hMainWnd, WS_VISIBLE, 1, 16, GetModuleHandle(NULL), IDB_BITMAP_128x15, btns,
1287         3, 0, 0, 0, 12, sizeof(TBBUTTON));
1288     CHECK_IMAGELIST(16, 16, 16);
1289     compare((int)SendMessage(hToolbar, TB_GETBUTTONSIZE, 0, 0), 0x160017, "%x");
1290     DestroyWindow(hToolbar);
1291 }
1292
1293 static void test_dispinfo(void)
1294 {
1295     HWND hToolbar = NULL;
1296     const TBBUTTON buttons_disp[] = {
1297         {-1, 20, TBSTATE_ENABLED, 0, {0, }, 0, -1},
1298         {0,  21, TBSTATE_ENABLED, 0, {0, }, 0, -1},
1299     };
1300     BOOL ret;
1301
1302     rebuild_toolbar(&hToolbar);
1303     SendMessageA(hToolbar, TB_LOADIMAGES, IDB_HIST_SMALL_COLOR, (LPARAM)HINST_COMMCTRL);
1304     SendMessageA(hToolbar, TB_ADDBUTTONS, 2, (LPARAM)buttons_disp);
1305     g_dwExpectedDispInfoMask = TBNF_IMAGE;
1306     /* Some TBN_GETDISPINFO tests will be done in MyWnd_Notify function.
1307      * We will receive TBN_GETDISPINFOW even if the control is ANSI */
1308     compare((BOOL)SendMessageA(hToolbar, CCM_GETUNICODEFORMAT, 0, 0), 0, "%d");
1309     ShowWindow(hToolbar, SW_SHOW);
1310     UpdateWindow(hToolbar);
1311
1312     ret = (BOOL)SendMessageA(hToolbar, CCM_SETUNICODEFORMAT, TRUE, 0);
1313     compare(ret, FALSE, "%d");
1314     compare(SendMessageA(hToolbar, CCM_GETUNICODEFORMAT, 0, 0), 1L, "%ld");
1315     InvalidateRect(hToolbar, NULL, FALSE);
1316     UpdateWindow(hToolbar);
1317
1318     ret = (BOOL)SendMessageA(hToolbar, CCM_SETUNICODEFORMAT, FALSE, 0);
1319     compare(ret, TRUE, "%d");
1320     compare(SendMessageA(hToolbar, CCM_GETUNICODEFORMAT, 0, 0), 0L, "%ld");
1321     InvalidateRect(hToolbar, NULL, FALSE);
1322     UpdateWindow(hToolbar);
1323
1324     DestroyWindow(hToolbar);
1325     g_dwExpectedDispInfoMask = 0;
1326 }
1327
1328 typedef struct
1329 {
1330     int  nRows;
1331     BOOL bLarger;
1332     int  expectedRows;
1333 } tbrows_result_t;
1334
1335 static tbrows_result_t tbrows_results[] =
1336 {
1337     {1, TRUE,  1}, /* 0: Simple case 9 in a row */
1338     {2, TRUE,  2}, /* 1: Another simple case 5 on one row, 4 on another*/
1339     {3, FALSE, 3}, /* 2: 3 lines - should be 3 lines of 3 buttons */
1340     {8, FALSE, 5}, /* 3: 8 lines - should be 5 lines of 2 buttons */
1341     {8, TRUE,  9}, /* 4: 8 lines but grow - should be 9 lines */
1342     {1, TRUE,  1}  /* 5: Back to simple case */
1343 };
1344
1345 static void test_setrows(void)
1346 {
1347     TBBUTTON buttons[9];
1348     HWND hToolbar;
1349     int i;
1350
1351     for (i=0; i<9; i++)
1352         MakeButton(buttons+i, 1000+i, TBSTYLE_FLAT | TBSTYLE_CHECKGROUP, 0);
1353
1354     /* Test 1 - 9 buttons */
1355     hToolbar = CreateToolbarEx(hMainWnd,
1356         WS_VISIBLE | WS_CLIPCHILDREN | WS_CHILD | CCS_NORESIZE | CCS_NOPARENTALIGN
1357         | CCS_NOMOVEY | CCS_TOP,
1358         0,
1359         0, NULL, 0,
1360         buttons, sizeof(buttons)/sizeof(buttons[0]),
1361         20, 20, 0, 0, sizeof(TBBUTTON));
1362     ok(hToolbar != NULL, "Toolbar creation\n");
1363     ok(SendMessageA(hToolbar, TB_AUTOSIZE, 0, 0) == 0, "TB_AUTOSIZE failed\n");
1364
1365     /* test setting rows to each of 1-10 with bLarger true and false */
1366     for (i=0; i<(sizeof(tbrows_results) / sizeof(tbrows_result_t)); i++) {
1367         RECT rc;
1368         int rows;
1369
1370         memset(&rc, 0xCC, sizeof(rc));
1371         SendMessageA(hToolbar, TB_SETROWS,
1372                      MAKELONG(tbrows_results[i].nRows, tbrows_results[i].bLarger),
1373                      (LPARAM) &rc);
1374
1375         rows = SendMessageA(hToolbar, TB_GETROWS, MAKELONG(0,0), MAKELONG(0,0));
1376         ok(rows == tbrows_results[i].expectedRows,
1377                    "[%d] Unexpected number of rows %d (expected %d)\n", i, rows,
1378                    tbrows_results[i].expectedRows);
1379     }
1380
1381     DestroyWindow(hToolbar);
1382 }
1383
1384 static void test_getstring(void)
1385 {
1386     HWND hToolbar = NULL;
1387     char str[10];
1388     WCHAR strW[10];
1389     static const char answer[] = "STR";
1390     static const WCHAR answerW[] = { 'S','T','R',0 };
1391     INT r;
1392
1393     hToolbar = CreateWindowExA(0, TOOLBARCLASSNAME, NULL, WS_CHILD | WS_VISIBLE, 0, 0, 0, 0, hMainWnd, (HMENU)5, GetModuleHandle(NULL), NULL);
1394     ok(hToolbar != NULL, "Toolbar creation problem\n");
1395
1396     r = SendMessage(hToolbar, TB_GETSTRING, MAKEWPARAM(0, 0), 0);
1397     if (r == 0)
1398     {
1399         win_skip("TB_GETSTRING and TB_GETSTRINGW need 5.80\n");
1400         DestroyWindow(hToolbar);
1401         return;
1402     }
1403     expect(-1, r);
1404     r = SendMessage(hToolbar, TB_GETSTRINGW, MAKEWPARAM(0, 0), 0);
1405     expect(-1, r);
1406     r = SendMessage(hToolbar, TB_ADDSTRING, 0, (LPARAM)answer);
1407     expect(0, r);
1408     r = SendMessage(hToolbar, TB_GETSTRING, MAKEWPARAM(0, 0), 0);
1409     expect(lstrlenA(answer), r);
1410     r = SendMessage(hToolbar, TB_GETSTRINGW, MAKEWPARAM(0, 0), 0);
1411     expect(lstrlenA(answer), r);
1412     r = SendMessage(hToolbar, TB_GETSTRING, MAKEWPARAM(sizeof(str), 0), (LPARAM)str);
1413     expect(lstrlenA(answer), r);
1414     expect(0, lstrcmp(answer, str));
1415     r = SendMessage(hToolbar, TB_GETSTRINGW, MAKEWPARAM(sizeof(strW), 0), (LPARAM)strW);
1416     expect(lstrlenA(answer), r);
1417     expect(0, lstrcmpW(answerW, strW));
1418
1419     DestroyWindow(hToolbar);
1420 }
1421
1422 static void test_tooltip(void)
1423 {
1424     HWND hToolbar = NULL;
1425     const TBBUTTON buttons_disp[] = {
1426         {-1, 20, TBSTATE_ENABLED, 0, {0, }, 0, -1},
1427         {0,  21, TBSTATE_ENABLED, 0, {0, }, 0, -1},
1428     };
1429     NMTTDISPINFOW nmtti;
1430
1431     rebuild_toolbar(&hToolbar);
1432
1433     SendMessageA(hToolbar, TB_ADDBUTTONS, 2, (LPARAM)buttons_disp);
1434
1435     /* W used to get through toolbar code that assumes tooltip is always Unicode */
1436     memset(&nmtti, 0, sizeof(nmtti));
1437     nmtti.hdr.code = TTN_GETDISPINFOW;
1438     nmtti.hdr.idFrom = 20;
1439
1440     SendMessageA(hToolbar, CCM_SETUNICODEFORMAT, FALSE, 0);
1441
1442     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1443     SendMessageA(hToolbar, WM_NOTIFY, 0, (LPARAM)&nmtti);
1444     ok_sequence(sequences, PARENT_SEQ_INDEX, ttgetdispinfo_parent_seq,
1445                 "dispinfo from tooltip", TRUE);
1446
1447     g_ResetDispTextPtr = TRUE;
1448     SendMessageA(hToolbar, WM_NOTIFY, 0, (LPARAM)&nmtti);
1449     g_ResetDispTextPtr = FALSE;
1450
1451     DestroyWindow(hToolbar);
1452 }
1453
1454 START_TEST(toolbar)
1455 {
1456     WNDCLASSA wc;
1457     MSG msg;
1458     RECT rc;
1459
1460     init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
1461
1462     InitCommonControls();
1463   
1464     wc.style = CS_HREDRAW | CS_VREDRAW;
1465     wc.cbClsExtra = 0;
1466     wc.cbWndExtra = 0;
1467     wc.hInstance = GetModuleHandleA(NULL);
1468     wc.hIcon = NULL;
1469     wc.hCursor = LoadCursorA(NULL, IDC_IBEAM);
1470     wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
1471     wc.lpszMenuName = NULL;
1472     wc.lpszClassName = "Toolbar test parent";
1473     wc.lpfnWndProc = parent_wnd_proc;
1474     RegisterClassA(&wc);
1475     
1476     hMainWnd = CreateWindowExA(0, "Toolbar test parent", "Blah", WS_OVERLAPPEDWINDOW,
1477       CW_USEDEFAULT, CW_USEDEFAULT, 680, 260, NULL, NULL, GetModuleHandleA(NULL), 0);
1478     GetClientRect(hMainWnd, &rc);
1479     ShowWindow(hMainWnd, SW_SHOW);
1480
1481     basic_test();
1482     test_add_bitmap();
1483     test_add_string();
1484     test_hotitem();
1485     test_sizes();
1486     test_recalc();
1487     test_getbuttoninfo();
1488     test_createtoolbarex();
1489     test_dispinfo();
1490     test_setrows();
1491     test_getstring();
1492     test_tooltip();
1493
1494     PostQuitMessage(0);
1495     while(GetMessageA(&msg,0,0,0)) {
1496         TranslateMessage(&msg);
1497         DispatchMessageA(&msg);
1498     }
1499     DestroyWindow(hMainWnd);
1500 }