git.oblomov.eu Git - wine/blob - dlls/comctl32/tests/tab.c

   1 /* Unit test suite for tab control.
   2  *
   3  * Copyright 2003 Vitaliy Margolen
   4  * Copyright 2007 Hagop Hagopian
   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 <windows.h>
  23 #include <commctrl.h>
  24 #include <stdio.h>
  25
  26 #include "wine/test.h"
  27 #include "msg.h"
  28
  29 #define DEFAULT_MIN_TAB_WIDTH 54
  30 #define TAB_PADDING_X 6
  31 #define EXTRA_ICON_PADDING 3
  32 #define MAX_TABLEN 32
  33
  34 #define NUM_MSG_SEQUENCES  2
  35 #define PARENT_SEQ_INDEX   0
  36 #define TAB_SEQ_INDEX      1
  37
  38 #define expect(expected, got) ok ( expected == got, "Expected %d, got %d\n", expected, got)
  39 #define expect_str(expected, got)\
  40  ok ( strcmp(expected, got) == 0, "Expected '%s', got '%s'\n", expected, got)
  41
  42 #define TabWidthPadded(padd_x, num) (DEFAULT_MIN_TAB_WIDTH - (TAB_PADDING_X - (padd_x)) * num)
  43
  44 #define TabCheckSetSize(hwnd, SetWidth, SetHeight, ExpWidth, ExpHeight, Msg)\
  45     SendMessage (hwnd, TCM_SETITEMSIZE, 0,\
  46         (LPARAM) MAKELPARAM((SetWidth >= 0) ? SetWidth:0, (SetHeight >= 0) ? SetHeight:0));\
  47     if (winetest_interactive) RedrawWindow (hwnd, NULL, 0, RDW_UPDATENOW);\
  48     CheckSize(hwnd, ExpWidth, ExpHeight, Msg);
  49
  50 #define CheckSize(hwnd,width,height,msg)\
  51     SendMessage (hwnd, TCM_GETITEMRECT, 0, (LPARAM) &rTab);\
  52     if ((width  >= 0) && (height < 0))\
  53         ok (width  == rTab.right  - rTab.left, "%s: Expected width [%d] got [%d]\n",\
  54         msg, (int)width,  rTab.right  - rTab.left);\
  55     else if ((height >= 0) && (width  < 0))\
  56         ok (height == rTab.bottom - rTab.top,  "%s: Expected height [%d] got [%d]\n",\
  57         msg, (int)height, rTab.bottom - rTab.top);\
  58     else\
  59         ok ((width  == rTab.right  - rTab.left) &&\
  60             (height == rTab.bottom - rTab.top ),\
  61             "%s: Expected [%d,%d] got [%d,%d]\n", msg, (int)width, (int)height,\
  62             rTab.right - rTab.left, rTab.bottom - rTab.top);
  63
  64 static HFONT hFont;
  65 static DRAWITEMSTRUCT g_drawitem;
  66
  67 static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];
  68
  69 static const struct message create_parent_wnd_seq[] = {
  70     { WM_GETMINMAXINFO, sent },
  71     { WM_NCCREATE, sent },
  72     { WM_NCCALCSIZE, sent|wparam, 0 },
  73     { WM_CREATE, sent },
  74     { WM_SHOWWINDOW, sent|wparam, 1 },
  75     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
  76     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
  77     { WM_ACTIVATEAPP, sent|wparam, 1 },
  78     { WM_NCACTIVATE, sent|wparam, 1 },
  79     { WM_ACTIVATE, sent|wparam, 1 },
  80     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
  81     { WM_IME_NOTIFY, sent|defwinproc|optional },
  82     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
  83     /* Win9x adds SWP_NOZORDER below */
  84     { WM_WINDOWPOSCHANGED, sent},
  85     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
  86     { WM_SIZE, sent },
  87     { WM_MOVE, sent },
  88     { 0 }
  89 };
  90
  91 static const struct message add_tab_to_parent[] = {
  92     { TCM_INSERTITEMA, sent },
  93     { TCM_INSERTITEMA, sent|optional },
  94     { WM_NOTIFYFORMAT, sent|defwinproc },
  95     { WM_QUERYUISTATE, sent|wparam|lparam|defwinproc|optional, 0, 0 },
  96     { WM_PARENTNOTIFY, sent|defwinproc },
  97     { TCM_INSERTITEMA, sent },
  98     { TCM_INSERTITEMA, sent },
  99     { TCM_INSERTITEMA, sent },
 100     { TCM_INSERTITEMA, sent|optional },
 101     { 0 }
 102 };
 103
 104 static const struct message add_tab_to_parent_interactive[] = {
 105     { TCM_INSERTITEMA, sent },
 106     { TCM_INSERTITEMA, sent },
 107     { WM_NOTIFYFORMAT, sent|defwinproc },
 108     { WM_QUERYUISTATE, sent|wparam|lparam|defwinproc, 0, 0 },
 109     { WM_PARENTNOTIFY, sent|defwinproc },
 110     { TCM_INSERTITEMA, sent },
 111     { TCM_INSERTITEMA, sent },
 112     { TCM_INSERTITEMA, sent },
 113     { WM_SHOWWINDOW, sent},
 114     { WM_WINDOWPOSCHANGING, sent},
 115     { WM_WINDOWPOSCHANGING, sent},
 116     { WM_NCACTIVATE, sent},
 117     { WM_ACTIVATE, sent},
 118     { WM_IME_SETCONTEXT, sent|defwinproc|optional},
 119     { WM_IME_NOTIFY, sent|defwinproc|optional},
 120     { WM_SETFOCUS, sent|defwinproc},
 121     { WM_WINDOWPOSCHANGED, sent},
 122     { WM_SIZE, sent},
 123     { WM_MOVE, sent},
 124     { 0 }
 125 };
 126
 127 static const struct message add_tab_control_parent_seq[] = {
 128     { WM_NOTIFYFORMAT, sent },
 129     { WM_QUERYUISTATE, sent|wparam|lparam|optional, 0, 0 },
 130     { 0 }
 131 };
 132
 133 static const struct message add_tab_control_parent_seq_interactive[] = {
 134     { WM_NOTIFYFORMAT, sent },
 135     { WM_QUERYUISTATE, sent|wparam|lparam, 0, 0 },
 136     { WM_WINDOWPOSCHANGING, sent|optional},
 137     { WM_NCACTIVATE, sent},
 138     { WM_ACTIVATE, sent},
 139     { WM_WINDOWPOSCHANGING, sent|optional},
 140     { WM_KILLFOCUS, sent},
 141     { WM_IME_SETCONTEXT, sent|optional},
 142     { WM_IME_NOTIFY, sent|optional},
 143     { 0 }
 144 };
 145
 146 static const struct message empty_sequence[] = {
 147     { 0 }
 148 };
 149
 150 static const struct message set_min_tab_width_seq[] = {
 151     { TCM_SETMINTABWIDTH, sent|wparam, 0 },
 152     { TCM_SETMINTABWIDTH, sent|wparam, 0 },
 153     { 0 }
 154 };
 155
 156 static const struct message get_item_count_seq[] = {
 157     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 158     { 0 }
 159 };
 160
 161 static const struct message get_row_count_seq[] = {
 162     { TCM_GETROWCOUNT, sent|wparam|lparam, 0, 0 },
 163     { 0 }
 164 };
 165
 166 static const struct message get_item_rect_seq[] = {
 167     { TCM_GETITEMRECT, sent },
 168     { TCM_GETITEMRECT, sent },
 169     { 0 }
 170 };
 171
 172 static const struct message getset_cur_focus_seq[] = {
 173     { TCM_SETCURFOCUS, sent|lparam, 0 },
 174     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 175     { TCM_SETCURFOCUS, sent|lparam, 0 },
 176     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 177     { TCM_SETCURSEL, sent|lparam, 0 },
 178     { TCM_SETCURFOCUS, sent|lparam, 0 },
 179     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 180     { 0 }
 181 };
 182
 183 static const struct message getset_cur_sel_seq[] = {
 184     { TCM_SETCURSEL, sent|lparam, 0 },
 185     { TCM_GETCURSEL, sent|wparam|lparam, 0, 0 },
 186     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 187     { TCM_SETCURSEL, sent|lparam, 0 },
 188     { TCM_GETCURSEL, sent|wparam|lparam, 0, 0 },
 189     { TCM_SETCURSEL, sent|lparam, 0 },
 190     { TCM_SETCURSEL, sent|lparam, 0 },
 191     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 192     { 0 }
 193 };
 194
 195 static const struct message getset_extended_style_seq[] = {
 196     { TCM_GETEXTENDEDSTYLE, sent|wparam|lparam, 0, 0 },
 197     { TCM_SETEXTENDEDSTYLE, sent },
 198     { TCM_GETEXTENDEDSTYLE, sent|wparam|lparam, 0, 0 },
 199     { TCM_SETEXTENDEDSTYLE, sent },
 200     { TCM_GETEXTENDEDSTYLE, sent|wparam|lparam, 0, 0 },
 201     { 0 }
 202 };
 203
 204 static const struct message getset_unicode_format_seq[] = {
 205     { CCM_SETUNICODEFORMAT, sent|lparam, 0 },
 206     { CCM_GETUNICODEFORMAT, sent|wparam|lparam, 0, 0 },
 207     { CCM_SETUNICODEFORMAT, sent|lparam, 0 },
 208     { CCM_GETUNICODEFORMAT, sent|wparam|lparam, 0, 0 },
 209     { CCM_SETUNICODEFORMAT, sent|lparam, 0 },
 210     { 0 }
 211 };
 212
 213 static const struct message getset_item_seq[] = {
 214     { TCM_SETITEMA, sent },
 215     { TCM_GETITEMA, sent },
 216     { TCM_GETITEMA, sent },
 217     { 0 }
 218 };
 219
 220 static const struct message getset_tooltip_seq[] = {
 221     { WM_NOTIFYFORMAT, sent|optional },
 222     { WM_QUERYUISTATE, sent|wparam|lparam|optional, 0, 0 },
 223     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
 224     { WM_NOTIFYFORMAT, sent|optional },
 225     { TCM_SETTOOLTIPS, sent|lparam, 0 },
 226     { TCM_GETTOOLTIPS, sent|wparam|lparam, 0, 0 },
 227     { TCM_SETTOOLTIPS, sent|lparam, 0 },
 228     { TCM_GETTOOLTIPS, sent|wparam|lparam, 0, 0 },
 229     { 0 }
 230 };
 231
 232 static const struct message getset_tooltip_parent_seq[] = {
 233     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
 234     { 0 }
 235 };
 236
 237 static const struct message insert_focus_seq[] = {
 238     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 239     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 240     { TCM_INSERTITEM, sent|wparam, 1 },
 241     { WM_NOTIFYFORMAT, sent|defwinproc|optional },
 242     { WM_QUERYUISTATE, sent|defwinproc|optional },
 243     { WM_PARENTNOTIFY, sent|defwinproc|optional },
 244     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 245     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 246     { TCM_INSERTITEM, sent|wparam, 2 },
 247     { WM_NOTIFYFORMAT, sent|defwinproc|optional },
 248     { WM_QUERYUISTATE, sent|defwinproc|optional, },
 249     { WM_PARENTNOTIFY, sent|defwinproc|optional },
 250     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 251     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 252     { TCM_SETCURFOCUS, sent|wparam|lparam, -1, 0 },
 253     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 254     { TCM_INSERTITEM, sent|wparam, 3 },
 255     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 256     { 0 }
 257 };
 258
 259 static const struct message delete_focus_seq[] = {
 260     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 261     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 262     { TCM_DELETEITEM, sent|wparam|lparam, 1, 0 },
 263     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 264     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 265     { TCM_SETCURFOCUS, sent|wparam|lparam, -1, 0 },
 266     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 267     { TCM_DELETEITEM, sent|wparam|lparam, 0, 0 },
 268     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 269     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 270     { 0 }
 271 };
 272
 273
 274 static HWND
 275 create_tabcontrol (DWORD style, DWORD mask)
 276 {
 277     HWND handle;
 278     TCITEM tcNewTab;
 279     static char text1[] = "Tab 1",
 280     text2[] = "Wide Tab 2",
 281     text3[] = "T 3";
 282
 283     handle = CreateWindow (
 284         WC_TABCONTROLA,
 285         "TestTab",
 286         WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | style,
 287         10, 10, 300, 100,
 288         NULL, NULL, NULL, 0);
 289
 290     assert (handle);
 291
 292     SetWindowLong(handle, GWL_STYLE, WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | style);
 293     SendMessage (handle, WM_SETFONT, 0, (LPARAM) hFont);
 294
 295     tcNewTab.mask = mask;
 296     tcNewTab.pszText = text1;
 297     tcNewTab.iImage = 0;
 298     SendMessage (handle, TCM_INSERTITEM, 0, (LPARAM) &tcNewTab);
 299     tcNewTab.pszText = text2;
 300     tcNewTab.iImage = 1;
 301     SendMessage (handle, TCM_INSERTITEM, 1, (LPARAM) &tcNewTab);
 302     tcNewTab.pszText = text3;
 303     tcNewTab.iImage = 2;
 304     SendMessage (handle, TCM_INSERTITEM, 2, (LPARAM) &tcNewTab);
 305
 306     if (winetest_interactive)
 307     {
 308         ShowWindow (handle, SW_SHOW);
 309         RedrawWindow (handle, NULL, 0, RDW_UPDATENOW);
 310         Sleep (1000);
 311     }
 312
 313     return handle;
 314 }
 315
 316 static LRESULT WINAPI parentWindowProcess(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 317 {
 318     static LONG defwndproc_counter = 0;
 319     LRESULT ret;
 320     struct message msg;
 321
 322     /* do not log painting messages */
 323     if (message != WM_PAINT &&
 324         message != WM_ERASEBKGND &&
 325         message != WM_NCPAINT &&
 326         message != WM_NCHITTEST &&
 327         message != WM_GETTEXT &&
 328         message != WM_GETICON &&
 329         message != WM_DEVICECHANGE)
 330     {
 331         trace("parent: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 332
 333         msg.message = message;
 334         msg.flags = sent|wparam|lparam;
 335         if (defwndproc_counter) msg.flags |= defwinproc;
 336         msg.wParam = wParam;
 337         msg.lParam = lParam;
 338         add_message(sequences, PARENT_SEQ_INDEX, &msg);
 339     }
 340
 341     /* dump sent structure data */
 342     if (message == WM_DRAWITEM)
 343         g_drawitem = *(DRAWITEMSTRUCT*)lParam;
 344
 345     defwndproc_counter++;
 346     ret = DefWindowProcA(hwnd, message, wParam, lParam);
 347     defwndproc_counter--;
 348
 349     return ret;
 350 }
 351
 352 static BOOL registerParentWindowClass(void)
 353 {
 354     WNDCLASSA cls;
 355
 356     cls.style = 0;
 357     cls.lpfnWndProc = parentWindowProcess;
 358     cls.cbClsExtra = 0;
 359     cls.cbWndExtra = 0;
 360     cls.hInstance = GetModuleHandleA(NULL);
 361     cls.hIcon = 0;
 362     cls.hCursor = LoadCursorA(0, IDC_ARROW);
 363     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
 364     cls.lpszMenuName = NULL;
 365     cls.lpszClassName = "Tab test parent class";
 366     return RegisterClassA(&cls);
 367 }
 368
 369 static HWND createParentWindow(void)
 370 {
 371     if (!registerParentWindowClass())
 372         return NULL;
 373
 374     return CreateWindowEx(0, "Tab test parent class",
 375                           "Tab test parent window",
 376                           WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
 377                           WS_MAXIMIZEBOX | WS_VISIBLE,
 378                           0, 0, 100, 100,
 379                           GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL);
 380 }
 381
 382 static LRESULT WINAPI tabSubclassProcess(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 383 {
 384     WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 385     static LONG defwndproc_counter = 0;
 386     LRESULT ret;
 387     struct message msg;
 388
 389     /* do not log painting messages */
 390     if (message != WM_PAINT &&
 391         message != WM_ERASEBKGND &&
 392         message != WM_NCPAINT &&
 393         message != WM_NCHITTEST &&
 394         message != WM_GETTEXT &&
 395         message != WM_GETICON &&
 396         message != WM_DEVICECHANGE)
 397     {
 398         trace("tab: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 399
 400         msg.message = message;
 401         msg.flags = sent|wparam|lparam;
 402         if (defwndproc_counter) msg.flags |= defwinproc;
 403         msg.wParam = wParam;
 404         msg.lParam = lParam;
 405         add_message(sequences, TAB_SEQ_INDEX, &msg);
 406     }
 407
 408     defwndproc_counter++;
 409     ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
 410     defwndproc_counter--;
 411
 412     return ret;
 413 }
 414
 415 static HWND createFilledTabControl(HWND parent_wnd, DWORD style, DWORD mask, INT nTabs)
 416 {
 417     HWND tabHandle;
 418     TCITEM tcNewTab;
 419     WNDPROC oldproc;
 420     RECT rect;
 421     INT i;
 422
 423     GetClientRect(parent_wnd, &rect);
 424
 425     tabHandle = CreateWindow (
 426         WC_TABCONTROLA,
 427         "TestTab",
 428         WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | style,
 429         0, 0, rect.right, rect.bottom,
 430         parent_wnd, NULL, NULL, 0);
 431
 432     assert(tabHandle);
 433
 434     oldproc = (WNDPROC)SetWindowLongPtrA(tabHandle, GWLP_WNDPROC, (LONG_PTR)tabSubclassProcess);
 435     SetWindowLongPtrA(tabHandle, GWLP_USERDATA, (LONG_PTR)oldproc);
 436
 437     tcNewTab.mask = mask;
 438
 439     for (i = 0; i < nTabs; i++)
 440     {
 441         char tabName[MAX_TABLEN];
 442
 443         sprintf(tabName, "Tab %d", i+1);
 444         tcNewTab.pszText = tabName;
 445         tcNewTab.iImage = i;
 446         SendMessage (tabHandle, TCM_INSERTITEM, i, (LPARAM) &tcNewTab);
 447     }
 448
 449     if (winetest_interactive)
 450     {
 451         ShowWindow (tabHandle, SW_SHOW);
 452         RedrawWindow (tabHandle, NULL, 0, RDW_UPDATENOW);
 453         Sleep (1000);
 454     }
 455
 456     return tabHandle;
 457 }
 458
 459 static HWND create_tooltip (HWND hTab, char toolTipText[])
 460 {
 461     HWND hwndTT;
 462
 463     TOOLINFO ti;
 464     LPTSTR lptstr = toolTipText;
 465     RECT rect;
 466
 467     /* Creating a tooltip window*/
 468     hwndTT = CreateWindowEx(
 469         WS_EX_TOPMOST,
 470         TOOLTIPS_CLASS,
 471         NULL,
 472         WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
 473         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 474         hTab, NULL, 0, NULL);
 475
 476     SetWindowPos(
 477         hwndTT,
 478         HWND_TOPMOST,
 479         0, 0, 0, 0,
 480         SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 481
 482     GetClientRect (hTab, &rect);
 483
 484     /* Initialize members of toolinfo*/
 485     ti.cbSize = sizeof(TOOLINFO);
 486     ti.uFlags = TTF_SUBCLASS;
 487     ti.hwnd = hTab;
 488     ti.hinst = 0;
 489     ti.uId = 0;
 490     ti.lpszText = lptstr;
 491
 492     ti.rect = rect;
 493
 494     /* Add toolinfo structure to the tooltip control */
 495     SendMessage(hwndTT, TTM_ADDTOOL, 0, (LPARAM) &ti);
 496
 497     return hwndTT;
 498 }
 499
 500 static void test_tab(INT nMinTabWidth)
 501 {
 502     HWND hwTab;
 503     RECT rTab;
 504     HIMAGELIST himl = ImageList_Create(21, 21, ILC_COLOR, 3, 4);
 505     SIZE size;
 506     HDC hdc;
 507     HFONT hOldFont;
 508     INT i, dpi, exp;
 509
 510     hwTab = create_tabcontrol(TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE);
 511     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 512     /* Get System default MinTabWidth */
 513     if (nMinTabWidth < 0)
 514         nMinTabWidth = SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 515
 516     hdc = GetDC(hwTab);
 517     dpi = GetDeviceCaps(hdc, LOGPIXELSX);
 518     hOldFont = SelectObject(hdc, (HFONT)SendMessage(hwTab, WM_GETFONT, 0, 0));
 519     GetTextExtentPoint32A(hdc, "Tab 1", strlen("Tab 1"), &size);
 520     trace("Tab1 text size: size.cx=%d size.cy=%d\n", size.cx, size.cy);
 521     SelectObject(hdc, hOldFont);
 522     ReleaseDC(hwTab, hdc);
 523
 524     trace ("  TCS_FIXEDWIDTH tabs no icon...\n");
 525     CheckSize(hwTab, dpi, -1, "default width");
 526     TabCheckSetSize(hwTab, 50, 20, 50, 20, "set size");
 527     TabCheckSetSize(hwTab, 0, 1, 0, 1, "min size");
 528
 529     SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 530
 531     trace ("  TCS_FIXEDWIDTH tabs with icon...\n");
 532     TabCheckSetSize(hwTab, 50, 30, 50, 30, "set size > icon");
 533     TabCheckSetSize(hwTab, 20, 20, 25, 20, "set size < icon");
 534     TabCheckSetSize(hwTab, 0, 1, 25, 1, "min size");
 535
 536     DestroyWindow (hwTab);
 537
 538     hwTab = create_tabcontrol(TCS_FIXEDWIDTH | TCS_BUTTONS, TCIF_TEXT|TCIF_IMAGE);
 539     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 540
 541     hdc = GetDC(hwTab);
 542     dpi = GetDeviceCaps(hdc, LOGPIXELSX);
 543     ReleaseDC(hwTab, hdc);
 544     trace ("  TCS_FIXEDWIDTH buttons no icon...\n");
 545     CheckSize(hwTab, dpi, -1, "default width");
 546     TabCheckSetSize(hwTab, 20, 20, 20, 20, "set size 1");
 547     TabCheckSetSize(hwTab, 10, 50, 10, 50, "set size 2");
 548     TabCheckSetSize(hwTab, 0, 1, 0, 1, "min size");
 549
 550     SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 551
 552     trace ("  TCS_FIXEDWIDTH buttons with icon...\n");
 553     TabCheckSetSize(hwTab, 50, 30, 50, 30, "set size > icon");
 554     TabCheckSetSize(hwTab, 20, 20, 25, 20, "set size < icon");
 555     TabCheckSetSize(hwTab, 0, 1, 25, 1, "min size");
 556     SendMessage(hwTab, TCM_SETPADDING, 0, MAKELPARAM(4,4));
 557     TabCheckSetSize(hwTab, 0, 1, 25, 1, "set padding, min size");
 558
 559     DestroyWindow (hwTab);
 560
 561     hwTab = create_tabcontrol(TCS_FIXEDWIDTH | TCS_BOTTOM, TCIF_TEXT|TCIF_IMAGE);
 562     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 563
 564     hdc = GetDC(hwTab);
 565     dpi = GetDeviceCaps(hdc, LOGPIXELSX);
 566     ReleaseDC(hwTab, hdc);
 567     trace ("  TCS_FIXEDWIDTH | TCS_BOTTOM tabs...\n");
 568     CheckSize(hwTab, dpi, -1, "no icon, default width");
 569
 570     TabCheckSetSize(hwTab, 20, 20, 20, 20, "no icon, set size 1");
 571     TabCheckSetSize(hwTab, 10, 50, 10, 50, "no icon, set size 2");
 572     TabCheckSetSize(hwTab, 0, 1, 0, 1, "no icon, min size");
 573
 574     SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 575
 576     TabCheckSetSize(hwTab, 50, 30, 50, 30, "with icon, set size > icon");
 577     TabCheckSetSize(hwTab, 20, 20, 25, 20, "with icon, set size < icon");
 578     TabCheckSetSize(hwTab, 0, 1, 25, 1, "with icon, min size");
 579     SendMessage(hwTab, TCM_SETPADDING, 0, MAKELPARAM(4,4));
 580     TabCheckSetSize(hwTab, 0, 1, 25, 1, "set padding, min size");
 581
 582     DestroyWindow (hwTab);
 583
 584     hwTab = create_tabcontrol(0, TCIF_TEXT|TCIF_IMAGE);
 585     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 586
 587     trace ("  non fixed width, with text...\n");
 588     exp = max(size.cx +TAB_PADDING_X*2, (nMinTabWidth < 0) ? DEFAULT_MIN_TAB_WIDTH : nMinTabWidth);
 589     SendMessage( hwTab, TCM_GETITEMRECT, 0, (LPARAM)&rTab );
 590     ok( rTab.right  - rTab.left == exp || broken(rTab.right  - rTab.left == DEFAULT_MIN_TAB_WIDTH),
 591         "no icon, default width: Expected width [%d] got [%d]\n", exp, rTab.right - rTab.left );
 592
 593     for (i=0; i<8; i++)
 594     {
 595         INT nTabWidth = (nMinTabWidth < 0) ? TabWidthPadded(i, 2) : nMinTabWidth;
 596
 597         SendMessage(hwTab, TCM_SETIMAGELIST, 0, 0);
 598         SendMessage(hwTab, TCM_SETPADDING, 0, MAKELPARAM(i,i));
 599
 600         TabCheckSetSize(hwTab, 50, 20, max(size.cx + i*2, nTabWidth), 20, "no icon, set size");
 601         TabCheckSetSize(hwTab, 0, 1, max(size.cx + i*2, nTabWidth), 1, "no icon, min size");
 602
 603         SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 604         nTabWidth = (nMinTabWidth < 0) ? TabWidthPadded(i, 3) : nMinTabWidth;
 605
 606         TabCheckSetSize(hwTab, 50, 30, max(size.cx + 21 + i*3, nTabWidth), 30, "with icon, set size > icon");
 607         TabCheckSetSize(hwTab, 20, 20, max(size.cx + 21 + i*3, nTabWidth), 20, "with icon, set size < icon");
 608         TabCheckSetSize(hwTab, 0, 1, max(size.cx + 21 + i*3, nTabWidth), 1, "with icon, min size");
 609     }
 610     DestroyWindow (hwTab);
 611
 612     hwTab = create_tabcontrol(0, TCIF_IMAGE);
 613     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 614
 615     trace ("  non fixed width, no text...\n");
 616     exp = (nMinTabWidth < 0) ? DEFAULT_MIN_TAB_WIDTH : nMinTabWidth;
 617     SendMessage( hwTab, TCM_GETITEMRECT, 0, (LPARAM)&rTab );
 618     ok( rTab.right  - rTab.left == exp || broken(rTab.right  - rTab.left == DEFAULT_MIN_TAB_WIDTH),
 619         "no icon, default width: Expected width [%d] got [%d]\n", exp, rTab.right - rTab.left );
 620
 621     for (i=0; i<8; i++)
 622     {
 623         INT nTabWidth = (nMinTabWidth < 0) ? TabWidthPadded(i, 2) : nMinTabWidth;
 624
 625         SendMessage(hwTab, TCM_SETIMAGELIST, 0, 0);
 626         SendMessage(hwTab, TCM_SETPADDING, 0, MAKELPARAM(i,i));
 627
 628         TabCheckSetSize(hwTab, 50, 20, nTabWidth, 20, "no icon, set size");
 629         TabCheckSetSize(hwTab, 0, 1, nTabWidth, 1, "no icon, min size");
 630
 631         SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 632         if (i > 1 && nMinTabWidth > 0 && nMinTabWidth < DEFAULT_MIN_TAB_WIDTH)
 633             nTabWidth += EXTRA_ICON_PADDING *(i-1);
 634
 635         TabCheckSetSize(hwTab, 50, 30, nTabWidth, 30, "with icon, set size > icon");
 636         TabCheckSetSize(hwTab, 20, 20, nTabWidth, 20, "with icon, set size < icon");
 637         TabCheckSetSize(hwTab, 0, 1, nTabWidth, 1, "with icon, min size");
 638     }
 639
 640     DestroyWindow (hwTab);
 641
 642     ImageList_Destroy(himl);
 643     DeleteObject(hFont);
 644 }
 645
 646 static void test_curfocus(HWND parent_wnd, INT nTabs)
 647 {
 648     INT focusIndex;
 649     HWND hTab;
 650
 651     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, nTabs);
 652     ok(hTab != NULL, "Failed to create tab control\n");
 653
 654     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 655
 656     /* Testing CurFocus with largest appropriate value */
 657     SendMessage(hTab, TCM_SETCURFOCUS, nTabs-1, 0);
 658     focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 659     expect(nTabs-1, focusIndex);
 660
 661     /* Testing CurFocus with negative value */
 662     SendMessage(hTab, TCM_SETCURFOCUS, -10, 0);
 663     focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 664     expect(-1, focusIndex);
 665
 666     /* Testing CurFocus with value larger than number of tabs */
 667     focusIndex = SendMessage(hTab, TCM_SETCURSEL, 1, 0);
 668     expect(-1, focusIndex);
 669
 670     SendMessage(hTab, TCM_SETCURFOCUS, nTabs+1, 0);
 671     focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 672     expect(1, focusIndex);
 673
 674     ok_sequence(sequences, TAB_SEQ_INDEX, getset_cur_focus_seq, "Getset curFoc test sequence", FALSE);
 675
 676     DestroyWindow(hTab);
 677 }
 678
 679 static void test_cursel(HWND parent_wnd, INT nTabs)
 680 {
 681     INT selectionIndex;
 682     INT focusIndex;
 683     TCITEM tcItem;
 684     HWND hTab;
 685
 686     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, nTabs);
 687     ok(hTab != NULL, "Failed to create tab control\n");
 688
 689     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 690
 691     /* Testing CurSel with largest appropriate value */
 692     selectionIndex = SendMessage(hTab, TCM_SETCURSEL, nTabs-1, 0);
 693     expect(0, selectionIndex);
 694     selectionIndex = SendMessage(hTab, TCM_GETCURSEL, 0, 0);
 695     expect(nTabs-1, selectionIndex);
 696
 697     /* Focus should switch with selection */
 698     focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 699     expect(nTabs-1, focusIndex);
 700
 701     /* Testing CurSel with negative value */
 702     SendMessage(hTab, TCM_SETCURSEL, -10, 0);
 703     selectionIndex = SendMessage(hTab, TCM_GETCURSEL, 0, 0);
 704     expect(-1, selectionIndex);
 705
 706     /* Testing CurSel with value larger than number of tabs */
 707     selectionIndex = SendMessage(hTab, TCM_SETCURSEL, 1, 0);
 708     expect(-1, selectionIndex);
 709
 710     selectionIndex = SendMessage(hTab, TCM_SETCURSEL, nTabs+1, 0);
 711     expect(-1, selectionIndex);
 712     selectionIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 713     expect(1, selectionIndex);
 714
 715     ok_sequence(sequences, TAB_SEQ_INDEX, getset_cur_sel_seq, "Getset curSel test sequence", FALSE);
 716     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset curSel test parent sequence", FALSE);
 717
 718     /* selected item should have TCIS_BUTTONPRESSED state
 719        It doesn't depend on button state */
 720     memset(&tcItem, 0, sizeof(TCITEM));
 721     tcItem.mask = TCIF_STATE;
 722     tcItem.dwStateMask = TCIS_BUTTONPRESSED;
 723     selectionIndex = SendMessage(hTab, TCM_GETCURSEL, 0, 0);
 724     SendMessage(hTab, TCM_GETITEM, selectionIndex, (LPARAM) &tcItem);
 725     ok (tcItem.dwState & TCIS_BUTTONPRESSED || broken(tcItem.dwState == 0), /* older comctl32 */
 726         "Selected item should have TCIS_BUTTONPRESSED\n");
 727
 728     DestroyWindow(hTab);
 729 }
 730
 731 static void test_extendedstyle(HWND parent_wnd, INT nTabs)
 732 {
 733     DWORD prevExtendedStyle;
 734     DWORD extendedStyle;
 735     HWND hTab;
 736
 737     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, nTabs);
 738     ok(hTab != NULL, "Failed to create tab control\n");
 739
 740     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 741
 742     /* Testing Flat Separators */
 743     extendedStyle = SendMessage(hTab, TCM_GETEXTENDEDSTYLE, 0, 0);
 744     prevExtendedStyle = SendMessage(hTab, TCM_SETEXTENDEDSTYLE, 0, TCS_EX_FLATSEPARATORS);
 745     expect(extendedStyle, prevExtendedStyle);
 746
 747     extendedStyle = SendMessage(hTab, TCM_GETEXTENDEDSTYLE, 0, 0);
 748     expect(TCS_EX_FLATSEPARATORS, extendedStyle);
 749
 750     /* Testing Register Drop */
 751     prevExtendedStyle = SendMessage(hTab, TCM_SETEXTENDEDSTYLE, 0, TCS_EX_REGISTERDROP);
 752     expect(extendedStyle, prevExtendedStyle);
 753
 754     extendedStyle = SendMessage(hTab, TCM_GETEXTENDEDSTYLE, 0, 0);
 755     todo_wine{
 756         expect(TCS_EX_REGISTERDROP, extendedStyle);
 757     }
 758
 759     ok_sequence(sequences, TAB_SEQ_INDEX, getset_extended_style_seq, "Getset extendedStyle test sequence", FALSE);
 760     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset extendedStyle test parent sequence", FALSE);
 761
 762     DestroyWindow(hTab);
 763 }
 764
 765 static void test_unicodeformat(HWND parent_wnd, INT nTabs)
 766 {
 767     INT unicodeFormat;
 768     HWND hTab;
 769
 770     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, nTabs);
 771     ok(hTab != NULL, "Failed to create tab control\n");
 772
 773     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 774
 775     unicodeFormat = SendMessage(hTab, TCM_SETUNICODEFORMAT, TRUE, 0);
 776     todo_wine{
 777         expect(0, unicodeFormat);
 778     }
 779     unicodeFormat = SendMessage(hTab, TCM_GETUNICODEFORMAT, 0, 0);
 780     expect(1, unicodeFormat);
 781
 782     unicodeFormat = SendMessage(hTab, TCM_SETUNICODEFORMAT, FALSE, 0);
 783     expect(1, unicodeFormat);
 784     unicodeFormat = SendMessage(hTab, TCM_GETUNICODEFORMAT, 0, 0);
 785     expect(0, unicodeFormat);
 786
 787     unicodeFormat = SendMessage(hTab, TCM_SETUNICODEFORMAT, TRUE, 0);
 788     expect(0, unicodeFormat);
 789
 790     ok_sequence(sequences, TAB_SEQ_INDEX, getset_unicode_format_seq, "Getset unicodeFormat test sequence", FALSE);
 791     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset unicodeFormat test parent sequence", FALSE);
 792
 793     DestroyWindow(hTab);
 794 }
 795
 796 static void test_getset_item(HWND parent_wnd, INT nTabs)
 797 {
 798     char szText[32] = "New Label";
 799     TCITEM tcItem;
 800     LPARAM lparam;
 801     DWORD ret;
 802     HWND hTab;
 803
 804     hTab = CreateWindowA(
 805         WC_TABCONTROLA,
 806         "TestTab",
 807         WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | TCS_FIXEDWIDTH | TCS_OWNERDRAWFIXED,
 808         10, 10, 300, 100,
 809         parent_wnd, NULL, NULL, 0);
 810
 811     ok(GetParent(hTab) == NULL, "got %p, expected null parent\n", GetParent(hTab));
 812
 813     ret = SendMessageA(hTab, TCM_SETITEMEXTRA, sizeof(LPARAM)-1, 0);
 814     ok(ret == TRUE, "got %d\n", ret);
 815
 816     /* set some item data */
 817     tcItem.lParam = ~0;
 818     tcItem.mask = TCIF_PARAM;
 819
 820     ret = SendMessageA(hTab, TCM_INSERTITEMA, 0, (LPARAM)&tcItem);
 821     ok(ret == 0, "got %d\n", ret);
 822
 823     /* all sizeof(LPARAM) returned anyway when using sizeof(LPARAM)-1 size */
 824     memset(&lparam, 0xaa, sizeof(lparam));
 825     tcItem.lParam = lparam;
 826     tcItem.mask = TCIF_PARAM;
 827     ret = SendMessage(hTab, TCM_GETITEM, 0, (LPARAM)&tcItem);
 828     expect(TRUE, ret);
 829     /* everything higher specified size is preserved */
 830     memset(&lparam, 0xff, sizeof(lparam)-1);
 831     ok(tcItem.lParam == lparam, "Expected 0x%lx, got 0x%lx\n", lparam, tcItem.lParam);
 832
 833     DestroyWindow(hTab);
 834
 835     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, nTabs);
 836     ok(hTab != NULL, "Failed to create tab control\n");
 837
 838     /* passing invalid index should result in initialization to zero
 839        for members mentioned in mask requested */
 840
 841     /* valid range here is [0,4] */
 842     memset(&tcItem, 0xcc, sizeof(tcItem));
 843     tcItem.mask = TCIF_PARAM;
 844     ret = SendMessage(hTab, TCM_GETITEM, 5, (LPARAM)&tcItem);
 845     expect(FALSE, ret);
 846     ok(tcItem.lParam == 0, "Expected zero lParam, got %lu\n", tcItem.lParam);
 847
 848     memset(&tcItem, 0xcc, sizeof(tcItem));
 849     tcItem.mask = TCIF_IMAGE;
 850     ret = SendMessage(hTab, TCM_GETITEM, 5, (LPARAM)&tcItem);
 851     expect(FALSE, ret);
 852     expect(0, tcItem.iImage);
 853
 854     memset(&tcItem, 0xcc, sizeof(tcItem));
 855     tcItem.mask = TCIF_TEXT;
 856     tcItem.pszText = szText;
 857     szText[0] = 'a';
 858     ret = SendMessage(hTab, TCM_GETITEM, 5, (LPARAM)&tcItem);
 859     expect(FALSE, ret);
 860     expect('a', szText[0]);
 861
 862     memset(&tcItem, 0xcc, sizeof(tcItem));
 863     tcItem.mask = TCIF_STATE;
 864     tcItem.dwStateMask = 0;
 865     tcItem.dwState = TCIS_BUTTONPRESSED;
 866     ret = SendMessage(hTab, TCM_GETITEM, 5, (LPARAM)&tcItem);
 867     expect(FALSE, ret);
 868     ok(tcItem.dwState == 0, "Expected zero dwState, got %u\n", tcItem.dwState);
 869
 870     memset(&tcItem, 0xcc, sizeof(tcItem));
 871     tcItem.mask = TCIF_STATE;
 872     tcItem.dwStateMask = TCIS_BUTTONPRESSED;
 873     tcItem.dwState = TCIS_BUTTONPRESSED;
 874     ret = SendMessage(hTab, TCM_GETITEM, 5, (LPARAM)&tcItem);
 875     expect(FALSE, ret);
 876     ok(tcItem.dwState == 0, "Expected zero dwState\n");
 877
 878     /* check with negative index to be sure */
 879     memset(&tcItem, 0xcc, sizeof(tcItem));
 880     tcItem.mask = TCIF_PARAM;
 881     ret = SendMessage(hTab, TCM_GETITEM, -1, (LPARAM)&tcItem);
 882     expect(FALSE, ret);
 883     ok(tcItem.lParam == 0, "Expected zero lParam, got %lu\n", tcItem.lParam);
 884
 885     memset(&tcItem, 0xcc, sizeof(tcItem));
 886     tcItem.mask = TCIF_PARAM;
 887     ret = SendMessage(hTab, TCM_GETITEM, -2, (LPARAM)&tcItem);
 888     expect(FALSE, ret);
 889     ok(tcItem.lParam == 0, "Expected zero lParam, got %lu\n", tcItem.lParam);
 890
 891     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 892
 893     tcItem.mask = TCIF_TEXT;
 894     tcItem.pszText = &szText[0];
 895     tcItem.cchTextMax = sizeof(szText);
 896
 897     strcpy(szText, "New Label");
 898     ok ( SendMessage(hTab, TCM_SETITEM, 0, (LPARAM) &tcItem), "Setting new item failed.\n");
 899     ok ( SendMessage(hTab, TCM_GETITEM, 0, (LPARAM) &tcItem), "Getting item failed.\n");
 900     expect_str("New Label", tcItem.pszText);
 901
 902     ok ( SendMessage(hTab, TCM_GETITEM, 1, (LPARAM) &tcItem), "Getting item failed.\n");
 903     expect_str("Tab 2", tcItem.pszText);
 904
 905     ok_sequence(sequences, TAB_SEQ_INDEX, getset_item_seq, "Getset item test sequence", FALSE);
 906     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset item test parent sequence", FALSE);
 907
 908     /* TCIS_BUTTONPRESSED doesn't depend on tab style */
 909     memset(&tcItem, 0, sizeof(tcItem));
 910     tcItem.mask = TCIF_STATE;
 911     tcItem.dwStateMask = TCIS_BUTTONPRESSED;
 912     tcItem.dwState = TCIS_BUTTONPRESSED;
 913     ok ( SendMessage(hTab, TCM_SETITEM, 0, (LPARAM) &tcItem), "Setting new item failed.\n");
 914     tcItem.dwState = 0;
 915     ok ( SendMessage(hTab, TCM_GETITEM, 0, (LPARAM) &tcItem), "Getting item failed.\n");
 916     if (tcItem.dwState)
 917     {
 918         ok (tcItem.dwState == TCIS_BUTTONPRESSED, "TCIS_BUTTONPRESSED should be set.\n");
 919         /* next highlight item, test that dwStateMask actually masks */
 920         tcItem.mask = TCIF_STATE;
 921         tcItem.dwStateMask = TCIS_HIGHLIGHTED;
 922         tcItem.dwState = TCIS_HIGHLIGHTED;
 923         ok ( SendMessage(hTab, TCM_SETITEM, 0, (LPARAM) &tcItem), "Setting new item failed.\n");
 924         tcItem.dwState = 0;
 925         ok ( SendMessage(hTab, TCM_GETITEM, 0, (LPARAM) &tcItem), "Getting item failed.\n");
 926         ok (tcItem.dwState == TCIS_HIGHLIGHTED, "TCIS_HIGHLIGHTED should be set.\n");
 927         tcItem.mask = TCIF_STATE;
 928         tcItem.dwStateMask = TCIS_BUTTONPRESSED;
 929         tcItem.dwState = 0;
 930         ok ( SendMessage(hTab, TCM_GETITEM, 0, (LPARAM) &tcItem), "Getting item failed.\n");
 931         ok (tcItem.dwState == TCIS_BUTTONPRESSED, "TCIS_BUTTONPRESSED should be set.\n");
 932     }
 933     else win_skip( "Item state mask not supported\n" );
 934
 935     DestroyWindow(hTab);
 936 }
 937
 938 static void test_getset_tooltips(HWND parent_wnd, INT nTabs)
 939 {
 940     HWND hTab, toolTip;
 941     char toolTipText[32] = "ToolTip Text Test";
 942
 943     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, nTabs);
 944     ok(hTab != NULL, "Failed to create tab control\n");
 945
 946     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 947
 948     toolTip = create_tooltip(hTab, toolTipText);
 949     SendMessage(hTab, TCM_SETTOOLTIPS, (LPARAM) toolTip, 0);
 950     ok (toolTip == (HWND) SendMessage(hTab,TCM_GETTOOLTIPS,0,0), "ToolTip was set incorrectly.\n");
 951
 952     SendMessage(hTab, TCM_SETTOOLTIPS, 0, 0);
 953     ok (NULL  == (HWND) SendMessage(hTab,TCM_GETTOOLTIPS,0,0), "ToolTip was set incorrectly.\n");
 954
 955     ok_sequence(sequences, TAB_SEQ_INDEX, getset_tooltip_seq, "Getset tooltip test sequence", TRUE);
 956     ok_sequence(sequences, PARENT_SEQ_INDEX, getset_tooltip_parent_seq, "Getset tooltip test parent sequence", TRUE);
 957
 958     DestroyWindow(hTab);
 959 }
 960
 961 static void test_misc(HWND parent_wnd, INT nTabs)
 962 {
 963     HWND hTab;
 964     RECT rTab;
 965     INT nTabsRetrieved;
 966     INT rowCount;
 967     INT dpi;
 968     HDC hdc;
 969
 970     ok(parent_wnd != NULL, "no parent window!\n");
 971     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 972
 973     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, nTabs);
 974     ok(hTab != NULL, "Failed to create tab control\n");
 975
 976     if(!winetest_interactive)
 977         ok_sequence(sequences, TAB_SEQ_INDEX, add_tab_to_parent,
 978                     "Tab sequence, after adding tab control to parent", TRUE);
 979     else
 980         ok_sequence(sequences, TAB_SEQ_INDEX, add_tab_to_parent_interactive,
 981                     "Tab sequence, after adding tab control to parent", TRUE);
 982
 983     if(!winetest_interactive)
 984         ok_sequence(sequences, PARENT_SEQ_INDEX, add_tab_control_parent_seq,
 985                     "Parent after sequence, adding tab control to parent", TRUE);
 986     else
 987         ok_sequence(sequences, PARENT_SEQ_INDEX, add_tab_control_parent_seq_interactive,
 988                     "Parent after sequence, adding tab control to parent", TRUE);
 989
 990     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 991     ok(SendMessage(hTab, TCM_SETMINTABWIDTH, 0, -1) > 0,"TCM_SETMINTABWIDTH returned < 0\n");
 992     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Set minTabWidth test parent sequence", FALSE);
 993
 994     /* Testing GetItemCount */
 995     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 996     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
 997     expect(nTabs, nTabsRetrieved);
 998     ok_sequence(sequences, TAB_SEQ_INDEX, get_item_count_seq, "Get itemCount test sequence", FALSE);
 999     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset itemCount test parent sequence", FALSE);
1000
1001     /* Testing GetRowCount */
1002     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1003     rowCount = SendMessage(hTab, TCM_GETROWCOUNT, 0, 0);
1004     expect(1, rowCount);
1005     ok_sequence(sequences, TAB_SEQ_INDEX, get_row_count_seq, "Get rowCount test sequence", FALSE);
1006     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Get rowCount test parent sequence", FALSE);
1007
1008     /* Testing GetItemRect */
1009     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1010     ok(SendMessage(hTab, TCM_GETITEMRECT, 0, (LPARAM) &rTab), "GetItemRect failed.\n");
1011
1012     hdc = GetDC(hTab);
1013     dpi = GetDeviceCaps(hdc, LOGPIXELSX);
1014     ReleaseDC(hTab, hdc);
1015     CheckSize(hTab, dpi, -1 , "Default Width");
1016     ok_sequence(sequences, TAB_SEQ_INDEX, get_item_rect_seq, "Get itemRect test sequence", FALSE);
1017     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Get itemRect test parent sequence", FALSE);
1018
1019     DestroyWindow(hTab);
1020 }
1021
1022 static void test_adjustrect(HWND parent_wnd)
1023 {
1024     HWND hTab;
1025     INT r;
1026
1027     ok(parent_wnd != NULL, "no parent window!\n");
1028
1029     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, 0, 0);
1030     ok(hTab != NULL, "Failed to create tab control\n");
1031
1032     r = SendMessage(hTab, TCM_ADJUSTRECT, FALSE, 0);
1033     expect(-1, r);
1034
1035     r = SendMessage(hTab, TCM_ADJUSTRECT, TRUE, 0);
1036     expect(-1, r);
1037 }
1038
1039 static void test_insert_focus(HWND parent_wnd)
1040 {
1041     HWND hTab;
1042     INT nTabsRetrieved;
1043     INT r;
1044     TCITEM tcNewTab;
1045     DWORD mask = TCIF_TEXT|TCIF_IMAGE;
1046     static char tabName[] = "TAB";
1047     tcNewTab.mask = mask;
1048     tcNewTab.pszText = tabName;
1049
1050     ok(parent_wnd != NULL, "no parent window!\n");
1051
1052     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, mask, 0);
1053     ok(hTab != NULL, "Failed to create tab control\n");
1054
1055     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1056
1057     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
1058     expect(0, nTabsRetrieved);
1059
1060     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
1061     expect(-1, r);
1062
1063     tcNewTab.iImage = 1;
1064     r = SendMessage(hTab, TCM_INSERTITEM, 1, (LPARAM) &tcNewTab);
1065     expect(0, r);
1066
1067     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
1068     expect(1, nTabsRetrieved);
1069
1070     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
1071     expect(0, r);
1072
1073     tcNewTab.iImage = 2;
1074     r = SendMessage(hTab, TCM_INSERTITEM, 2, (LPARAM) &tcNewTab);
1075     expect(1, r);
1076
1077     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
1078     expect(2, nTabsRetrieved);
1079
1080     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
1081     expect(0, r);
1082
1083     r = SendMessage(hTab, TCM_SETCURFOCUS, -1, 0);
1084     expect(0, r);
1085
1086     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
1087     expect(-1, r);
1088
1089     tcNewTab.iImage = 3;
1090     r = SendMessage(hTab, TCM_INSERTITEM, 3, (LPARAM) &tcNewTab);
1091     expect(2, r);
1092
1093     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
1094     expect(2, r);
1095
1096     ok_sequence(sequences, TAB_SEQ_INDEX, insert_focus_seq, "insert_focus test sequence", FALSE);
1097     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "insert_focus parent test sequence", TRUE);
1098
1099     DestroyWindow(hTab);
1100 }
1101
1102 static void test_delete_focus(HWND parent_wnd)
1103 {
1104     HWND hTab;
1105     INT nTabsRetrieved;
1106     INT r;
1107
1108     ok(parent_wnd != NULL, "no parent window!\n");
1109
1110     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, 2);
1111     ok(hTab != NULL, "Failed to create tab control\n");
1112
1113     flush_sequences(sequences, NUM_MSG_SEQUENCES);
1114
1115     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
1116     expect(2, nTabsRetrieved);
1117
1118     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
1119     expect(0, r);
1120
1121     r = SendMessage(hTab, TCM_DELETEITEM, 1, 0);
1122     expect(1, r);
1123
1124     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
1125     expect(1, nTabsRetrieved);
1126
1127     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
1128     expect(0, r);
1129
1130     r = SendMessage(hTab, TCM_SETCURFOCUS, -1, 0);
1131     expect(0, r);
1132
1133     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
1134     expect(-1, r);
1135
1136     r = SendMessage(hTab, TCM_DELETEITEM, 0, 0);
1137     expect(1, r);
1138
1139     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
1140     expect(0, nTabsRetrieved);
1141
1142     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
1143     expect(-1, r);
1144
1145     ok_sequence(sequences, TAB_SEQ_INDEX, delete_focus_seq, "delete_focus test sequence", FALSE);
1146     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "delete_focus parent test sequence", TRUE);
1147
1148     DestroyWindow(hTab);
1149 }
1150
1151 static void test_removeimage(void)
1152 {
1153     static const BYTE bits[32];
1154     HWND hwTab;
1155     INT i;
1156     TCITEM item;
1157     HICON hicon;
1158     HIMAGELIST himl = ImageList_Create(16, 16, ILC_COLOR, 3, 4);
1159
1160     hicon = CreateIcon(NULL, 16, 16, 1, 1, bits, bits);
1161     ImageList_AddIcon(himl, hicon);
1162     ImageList_AddIcon(himl, hicon);
1163     ImageList_AddIcon(himl, hicon);
1164
1165     hwTab = create_tabcontrol(TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE);
1166     SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
1167
1168     memset(&item, 0, sizeof(TCITEM));
1169     item.mask = TCIF_IMAGE;
1170
1171     for(i = 0; i < 3; i++) {
1172         SendMessage(hwTab, TCM_GETITEM, i, (LPARAM)&item);
1173         expect(i, item.iImage);
1174     }
1175
1176     /* remove image middle image */
1177     SendMessage(hwTab, TCM_REMOVEIMAGE, 1, 0);
1178     expect(2, ImageList_GetImageCount(himl));
1179     item.iImage = -1;
1180     SendMessage(hwTab, TCM_GETITEM, 0, (LPARAM)&item);
1181     expect(0, item.iImage);
1182     item.iImage = 0;
1183     SendMessage(hwTab, TCM_GETITEM, 1, (LPARAM)&item);
1184     expect(-1, item.iImage);
1185     item.iImage = 0;
1186     SendMessage(hwTab, TCM_GETITEM, 2, (LPARAM)&item);
1187     expect(1, item.iImage);
1188     /* remove first image */
1189     SendMessage(hwTab, TCM_REMOVEIMAGE, 0, 0);
1190     expect(1, ImageList_GetImageCount(himl));
1191     item.iImage = 0;
1192     SendMessage(hwTab, TCM_GETITEM, 0, (LPARAM)&item);
1193     expect(-1, item.iImage);
1194     item.iImage = 0;
1195     SendMessage(hwTab, TCM_GETITEM, 1, (LPARAM)&item);
1196     expect(-1, item.iImage);
1197     item.iImage = -1;
1198     SendMessage(hwTab, TCM_GETITEM, 2, (LPARAM)&item);
1199     expect(0, item.iImage);
1200     /* remove the last one */
1201     SendMessage(hwTab, TCM_REMOVEIMAGE, 0, 0);
1202     expect(0, ImageList_GetImageCount(himl));
1203     for(i = 0; i < 3; i++) {
1204         item.iImage = 0;
1205         SendMessage(hwTab, TCM_GETITEM, i, (LPARAM)&item);
1206         expect(-1, item.iImage);
1207     }
1208
1209     DestroyWindow(hwTab);
1210     ImageList_Destroy(himl);
1211     DestroyIcon(hicon);
1212 }
1213
1214 static void test_delete_selection(HWND parent_wnd)
1215 {
1216     HWND hTab;
1217     DWORD ret;
1218
1219     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, 4);
1220     ok(hTab != NULL, "Failed to create tab control\n");
1221
1222     ret = SendMessage(hTab, TCM_SETCURSEL, 3, 0);
1223     expect(0, ret);
1224     ret = SendMessage(hTab, TCM_GETCURSEL, 0, 0);
1225     expect(3, ret);
1226     /* delete selected item - selection goes to -1 */
1227     ret = SendMessage(hTab, TCM_DELETEITEM, 3, 0);
1228     expect(TRUE, ret);
1229
1230     ret = SendMessage(hTab, TCM_GETCURSEL, 0, 0);
1231     expect(-1, ret);
1232
1233     DestroyWindow(hTab);
1234 }
1235
1236 static void test_TCM_SETITEMEXTRA(HWND parent_wnd)
1237 {
1238     HWND hTab;
1239     DWORD ret;
1240
1241     hTab = CreateWindowA(
1242         WC_TABCONTROLA,
1243         "TestTab",
1244         WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | TCS_FIXEDWIDTH,
1245         10, 10, 300, 100,
1246         parent_wnd, NULL, NULL, 0);
1247
1248     /* zero is valid size too */
1249     ret = SendMessageA(hTab, TCM_SETITEMEXTRA, 0, 0);
1250     if (ret == FALSE)
1251     {
1252         win_skip("TCM_SETITEMEXTRA not supported\n");
1253         DestroyWindow(hTab);
1254         return;
1255     }
1256
1257     ret = SendMessageA(hTab, TCM_SETITEMEXTRA, -1, 0);
1258     ok(ret == FALSE, "got %d\n", ret);
1259
1260     ret = SendMessageA(hTab, TCM_SETITEMEXTRA, 2, 0);
1261     ok(ret == TRUE, "got %d\n", ret);
1262     DestroyWindow(hTab);
1263
1264     /* it's not possible to change extra data size for control with tabs */
1265     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, 4);
1266     ok(hTab != NULL, "Failed to create tab control\n");
1267
1268     ret = SendMessageA(hTab, TCM_SETITEMEXTRA, 2, 0);
1269     ok(ret == FALSE, "got %d\n", ret);
1270     DestroyWindow(hTab);
1271 }
1272
1273 static void test_TCS_OWNERDRAWFIXED(HWND parent_wnd)
1274 {
1275     LPARAM lparam, lparam2;
1276     TCITEMA item;
1277     HWND hTab;
1278     BOOL ret;
1279
1280     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH|TCS_OWNERDRAWFIXED, TCIF_TEXT|TCIF_IMAGE, 4);
1281     ok(hTab != NULL, "Failed to create tab control\n");
1282
1283     ok(GetParent(hTab) == NULL, "got %p, expected null parent\n", GetParent(hTab));
1284
1285     /* set some item data */
1286     memset(&lparam, 0xde, sizeof(LPARAM));
1287
1288     item.mask = TCIF_PARAM;
1289     item.lParam = lparam;
1290     ret = SendMessageA(hTab, TCM_SETITEMA, 0, (LPARAM)&item);
1291     ok(ret == TRUE, "got %d\n", ret);
1292
1293     memset(&g_drawitem, 0, sizeof(g_drawitem));
1294
1295     ShowWindow(hTab, SW_SHOW);
1296     RedrawWindow(hTab, NULL, 0, RDW_UPDATENOW);
1297
1298     lparam = 0;
1299     memset(&lparam, 0xde, 4);
1300     ok(g_drawitem.itemData == lparam, "got %lx, expected %lx\n", g_drawitem.itemData, lparam);
1301
1302     DestroyWindow(hTab);
1303
1304     /* now with custom extra data length */
1305     hTab = CreateWindowA(
1306         WC_TABCONTROLA,
1307         "TestTab",
1308         WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | TCS_FIXEDWIDTH | TCS_OWNERDRAWFIXED,
1309         10, 10, 300, 100,
1310         parent_wnd, NULL, NULL, 0);
1311
1312     ok(GetParent(hTab) == NULL, "got %p, expected null parent\n", GetParent(hTab));
1313
1314     ret = SendMessageA(hTab, TCM_SETITEMEXTRA, sizeof(LPARAM)+1, 0);
1315     ok(ret == TRUE, "got %d\n", ret);
1316
1317     /* set some item data */
1318     memset(&lparam, 0xde, sizeof(LPARAM));
1319     item.mask = TCIF_PARAM;
1320     item.lParam = lparam;
1321
1322     ret = SendMessageA(hTab, TCM_INSERTITEMA, 0, (LPARAM)&item);
1323     ok(ret == 0, "got %d\n", ret);
1324
1325     memset(&g_drawitem, 0, sizeof(g_drawitem));
1326
1327     ShowWindow(hTab, SW_SHOW);
1328     RedrawWindow(hTab, NULL, 0, RDW_UPDATENOW);
1329
1330     ok(*(ULONG_PTR*)g_drawitem.itemData == lparam, "got %lx, expected %lx\n", g_drawitem.itemData, lparam);
1331
1332     DestroyWindow(hTab);
1333
1334     /* same thing, but size smaller than default */
1335     hTab = CreateWindowA(
1336         WC_TABCONTROLA,
1337         "TestTab",
1338         WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | TCS_FIXEDWIDTH | TCS_OWNERDRAWFIXED,
1339         10, 10, 300, 100,
1340         parent_wnd, NULL, NULL, 0);
1341
1342     ok(GetParent(hTab) == NULL, "got %p, expected null parent\n", GetParent(hTab));
1343
1344     ret = SendMessageA(hTab, TCM_SETITEMEXTRA, sizeof(LPARAM)-1, 0);
1345     ok(ret == TRUE, "got %d\n", ret);
1346
1347     memset(&lparam, 0xde, sizeof(lparam));
1348     item.mask = TCIF_PARAM;
1349     item.lParam = lparam;
1350
1351     ret = SendMessageA(hTab, TCM_INSERTITEMA, 0, (LPARAM)&item);
1352     ok(ret == 0, "got %d\n", ret);
1353
1354     memset(&g_drawitem, 0, sizeof(g_drawitem));
1355
1356     ShowWindow(hTab, SW_SHOW);
1357     RedrawWindow(hTab, NULL, 0, RDW_UPDATENOW);
1358
1359     lparam = 0;
1360     memset(&lparam, 0xde, 4);
1361     memset(&lparam2, 0xde, sizeof(LPARAM)-1);
1362     ok(g_drawitem.itemData == lparam || broken(g_drawitem.itemData == lparam2) /* win98 */,
1363         "got 0x%lx, expected 0x%lx\n", g_drawitem.itemData, lparam);
1364
1365     DestroyWindow(hTab);
1366 }
1367
1368 START_TEST(tab)
1369 {
1370     HWND parent_wnd;
1371     LOGFONTA logfont;
1372
1373     lstrcpyA(logfont.lfFaceName, "Arial");
1374     memset(&logfont, 0, sizeof(logfont));
1375     logfont.lfHeight = -12;
1376     logfont.lfWeight = FW_NORMAL;
1377     logfont.lfCharSet = ANSI_CHARSET;
1378     hFont = CreateFontIndirectA(&logfont);
1379
1380     InitCommonControls();
1381
1382     trace ("Testing with default MinWidth\n");
1383     test_tab(-1);
1384     trace ("Testing with MinWidth set to -3\n");
1385     test_tab(-3);
1386     trace ("Testing with MinWidth set to 24\n");
1387     test_tab(24);
1388     trace ("Testing with MinWidth set to 54\n");
1389     test_tab(54);
1390     trace ("Testing with MinWidth set to 94\n");
1391     test_tab(94);
1392
1393     init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
1394
1395     parent_wnd = createParentWindow();
1396     ok(parent_wnd != NULL, "Failed to create parent window!\n");
1397
1398     test_curfocus(parent_wnd, 5);
1399     test_cursel(parent_wnd, 5);
1400     test_extendedstyle(parent_wnd, 5);
1401     test_unicodeformat(parent_wnd, 5);
1402     test_getset_item(parent_wnd, 5);
1403     test_getset_tooltips(parent_wnd, 5);
1404     test_misc(parent_wnd, 5);
1405
1406     test_adjustrect(parent_wnd);
1407
1408     test_insert_focus(parent_wnd);
1409     test_delete_focus(parent_wnd);
1410     test_delete_selection(parent_wnd);
1411     test_removeimage();
1412     test_TCM_SETITEMEXTRA(parent_wnd);
1413     test_TCS_OWNERDRAWFIXED(parent_wnd);
1414
1415     DestroyWindow(parent_wnd);
1416 }