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