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_DEFAULT_WIDTH 96
  31 #define TAB_PADDING_X 6
  32 #define EXTRA_ICON_PADDING 3
  33 #define MAX_TABLEN 32
  34
  35 #define NUM_MSG_SEQUENCES  2
  36 #define PARENT_SEQ_INDEX   0
  37 #define TAB_SEQ_INDEX      1
  38
  39 #define expect(expected, got) ok ( expected == got, "Expected %d, got %d\n", expected, got)
  40 #define expect_str(expected, got)\
  41  ok ( strcmp(expected, got) == 0, "Expected '%s', got '%s'\n", expected, got)
  42
  43 #define TabWidthPadded(padd_x, num) (DEFAULT_MIN_TAB_WIDTH - (TAB_PADDING_X - (padd_x)) * num)
  44
  45 #define TabCheckSetSize(hwnd, SetWidth, SetHeight, ExpWidth, ExpHeight, Msg)\
  46     SendMessage (hwnd, TCM_SETITEMSIZE, 0,\
  47         (LPARAM) MAKELPARAM((SetWidth >= 0) ? SetWidth:0, (SetHeight >= 0) ? SetHeight:0));\
  48     if (winetest_interactive) RedrawWindow (hwnd, NULL, 0, RDW_UPDATENOW);\
  49     CheckSize(hwnd, ExpWidth, ExpHeight, Msg);
  50
  51 #define CheckSize(hwnd,width,height,msg)\
  52     SendMessage (hwnd, TCM_GETITEMRECT, 0, (LPARAM) &rTab);\
  53     if ((width  >= 0) && (height < 0))\
  54         ok (width  == rTab.right  - rTab.left, "%s: Expected width [%d] got [%d]\n",\
  55         msg, (int)width,  rTab.right  - rTab.left);\
  56     else if ((height >= 0) && (width  < 0))\
  57         ok (height == rTab.bottom - rTab.top,  "%s: Expected height [%d] got [%d]\n",\
  58         msg, (int)height, rTab.bottom - rTab.top);\
  59     else\
  60         ok ((width  == rTab.right  - rTab.left) &&\
  61             (height == rTab.bottom - rTab.top ),\
  62             "%s: Expected [%d,%d] got [%d,%d]\n", msg, (int)width, (int)height,\
  63             rTab.right - rTab.left, rTab.bottom - rTab.top);
  64
  65 static HFONT hFont = 0;
  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 },
  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     { 0 }
 101 };
 102
 103 static const struct message add_tab_to_parent_interactive[] = {
 104     { TCM_INSERTITEMA, sent },
 105     { TCM_INSERTITEMA, sent },
 106     { WM_NOTIFYFORMAT, sent|defwinproc },
 107     { WM_QUERYUISTATE, sent|wparam|lparam|defwinproc, 0, 0 },
 108     { WM_PARENTNOTIFY, sent|defwinproc },
 109     { TCM_INSERTITEMA, sent },
 110     { TCM_INSERTITEMA, sent },
 111     { TCM_INSERTITEMA, sent },
 112     { WM_SHOWWINDOW, sent},
 113     { WM_WINDOWPOSCHANGING, sent},
 114     { WM_WINDOWPOSCHANGING, sent},
 115     { WM_NCACTIVATE, sent},
 116     { WM_ACTIVATE, sent},
 117     { WM_IME_SETCONTEXT, sent|defwinproc|optional},
 118     { WM_IME_NOTIFY, sent|defwinproc|optional},
 119     { WM_SETFOCUS, sent|defwinproc},
 120     { WM_WINDOWPOSCHANGED, sent},
 121     { WM_SIZE, sent},
 122     { WM_MOVE, sent},
 123     { 0 }
 124 };
 125
 126 static const struct message add_tab_control_parent_seq[] = {
 127     { WM_NOTIFYFORMAT, sent },
 128     { WM_QUERYUISTATE, sent|wparam|lparam|optional, 0, 0 },
 129     { 0 }
 130 };
 131
 132 static const struct message add_tab_control_parent_seq_interactive[] = {
 133     { WM_NOTIFYFORMAT, sent },
 134     { WM_QUERYUISTATE, sent|wparam|lparam, 0, 0 },
 135     { WM_WINDOWPOSCHANGING, sent|optional},
 136     { WM_NCACTIVATE, sent},
 137     { WM_ACTIVATE, sent},
 138     { WM_WINDOWPOSCHANGING, sent|optional},
 139     { WM_KILLFOCUS, sent},
 140     { WM_IME_SETCONTEXT, sent|optional},
 141     { WM_IME_NOTIFY, sent|optional},
 142     { 0 }
 143 };
 144
 145 static const struct message empty_sequence[] = {
 146     { 0 }
 147 };
 148
 149 static const struct message set_min_tab_width_seq[] = {
 150     { TCM_SETMINTABWIDTH, sent|wparam, 0 },
 151     { TCM_SETMINTABWIDTH, sent|wparam, 0 },
 152     { 0 }
 153 };
 154
 155 static const struct message get_item_count_seq[] = {
 156     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 157     { 0 }
 158 };
 159
 160 static const struct message get_row_count_seq[] = {
 161     { TCM_GETROWCOUNT, sent|wparam|lparam, 0, 0 },
 162     { 0 }
 163 };
 164
 165 static const struct message get_item_rect_seq[] = {
 166     { TCM_GETITEMRECT, sent },
 167     { TCM_GETITEMRECT, sent },
 168     { 0 }
 169 };
 170
 171 static const struct message getset_cur_focus_seq[] = {
 172     { TCM_SETCURFOCUS, sent|lparam, 0 },
 173     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 174     { TCM_SETCURFOCUS, sent|lparam, 0 },
 175     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 176     { TCM_SETCURSEL, sent|lparam, 0 },
 177     { TCM_SETCURFOCUS, sent|lparam, 0 },
 178     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 179     { 0 }
 180 };
 181
 182 static const struct message getset_cur_sel_seq[] = {
 183     { TCM_SETCURSEL, sent|lparam, 0 },
 184     { TCM_GETCURSEL, sent|wparam|lparam, 0, 0 },
 185     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 186     { TCM_SETCURSEL, sent|lparam, 0 },
 187     { TCM_GETCURSEL, sent|wparam|lparam, 0, 0 },
 188     { TCM_SETCURSEL, sent|lparam, 0 },
 189     { TCM_SETCURSEL, sent|lparam, 0 },
 190     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 191     { 0 }
 192 };
 193
 194 static const struct message getset_extended_style_seq[] = {
 195     { TCM_GETEXTENDEDSTYLE, sent|wparam|lparam, 0, 0 },
 196     { TCM_SETEXTENDEDSTYLE, sent },
 197     { TCM_GETEXTENDEDSTYLE, sent|wparam|lparam, 0, 0 },
 198     { TCM_SETEXTENDEDSTYLE, sent },
 199     { TCM_GETEXTENDEDSTYLE, sent|wparam|lparam, 0, 0 },
 200     { 0 }
 201 };
 202
 203 static const struct message getset_unicode_format_seq[] = {
 204     { CCM_SETUNICODEFORMAT, sent|lparam, 0 },
 205     { CCM_GETUNICODEFORMAT, sent|wparam|lparam, 0, 0 },
 206     { CCM_SETUNICODEFORMAT, sent|lparam, 0 },
 207     { CCM_GETUNICODEFORMAT, sent|wparam|lparam, 0, 0 },
 208     { CCM_SETUNICODEFORMAT, sent|lparam, 0 },
 209     { 0 }
 210 };
 211
 212 static const struct message getset_item_seq[] = {
 213     { TCM_SETITEMA, sent },
 214     { TCM_GETITEMA, sent },
 215     { TCM_GETITEMA, sent },
 216     { 0 }
 217 };
 218
 219 static const struct message getset_tooltip_seq[] = {
 220     { WM_NOTIFYFORMAT, sent|optional },
 221     { WM_QUERYUISTATE, sent|wparam|lparam|optional, 0, 0 },
 222     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
 223     { WM_NOTIFYFORMAT, sent|optional },
 224     { TCM_SETTOOLTIPS, sent|lparam, 0 },
 225     { TCM_GETTOOLTIPS, sent|wparam|lparam, 0, 0 },
 226     { TCM_SETTOOLTIPS, sent|lparam, 0 },
 227     { TCM_GETTOOLTIPS, sent|wparam|lparam, 0, 0 },
 228     { 0 }
 229 };
 230
 231 static const struct message getset_tooltip_parent_seq[] = {
 232     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
 233     { 0 }
 234 };
 235
 236 static const struct message insert_focus_seq[] = {
 237     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 238     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 239     { TCM_INSERTITEM, sent|wparam, 1 },
 240     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 241     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 242     { TCM_INSERTITEM, sent|wparam, 2 },
 243     { WM_NOTIFYFORMAT, sent|defwinproc, },
 244     { WM_QUERYUISTATE, sent|defwinproc|optional, },
 245     { WM_PARENTNOTIFY, sent|defwinproc, },
 246     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 247     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 248     { TCM_SETCURFOCUS, sent|wparam|lparam, -1, 0 },
 249     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 250     { TCM_INSERTITEM, sent|wparam, 3 },
 251     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 252     { 0 }
 253 };
 254
 255 static const struct message delete_focus_seq[] = {
 256     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 257     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 258     { TCM_DELETEITEM, sent|wparam|lparam, 1, 0 },
 259     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 260     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 261     { TCM_SETCURFOCUS, sent|wparam|lparam, -1, 0 },
 262     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 263     { TCM_DELETEITEM, sent|wparam|lparam, 0, 0 },
 264     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 265     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 266     { 0 }
 267 };
 268
 269
 270 static HWND
 271 create_tabcontrol (DWORD style, DWORD mask)
 272 {
 273     HWND handle;
 274     TCITEM tcNewTab;
 275     static char text1[] = "Tab 1",
 276     text2[] = "Wide Tab 2",
 277     text3[] = "T 3";
 278
 279     handle = CreateWindow (
 280         WC_TABCONTROLA,
 281         "TestTab",
 282         WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | style,
 283         10, 10, 300, 100,
 284         NULL, NULL, NULL, 0);
 285
 286     assert (handle);
 287
 288     SetWindowLong(handle, GWL_STYLE, WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | style);
 289     SendMessage (handle, WM_SETFONT, 0, (LPARAM) hFont);
 290
 291     tcNewTab.mask = mask;
 292     tcNewTab.pszText = text1;
 293     tcNewTab.iImage = 0;
 294     SendMessage (handle, TCM_INSERTITEM, 0, (LPARAM) &tcNewTab);
 295     tcNewTab.pszText = text2;
 296     tcNewTab.iImage = 1;
 297     SendMessage (handle, TCM_INSERTITEM, 1, (LPARAM) &tcNewTab);
 298     tcNewTab.pszText = text3;
 299     tcNewTab.iImage = 2;
 300     SendMessage (handle, TCM_INSERTITEM, 2, (LPARAM) &tcNewTab);
 301
 302     if (winetest_interactive)
 303     {
 304         ShowWindow (handle, SW_SHOW);
 305         RedrawWindow (handle, NULL, 0, RDW_UPDATENOW);
 306         Sleep (1000);
 307     }
 308
 309     return handle;
 310 }
 311
 312 static LRESULT WINAPI parentWindowProcess(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 313 {
 314     static long defwndproc_counter = 0;
 315     LRESULT ret;
 316     struct message msg;
 317
 318     /* do not log painting messages */
 319     if (message != WM_PAINT &&
 320         message != WM_ERASEBKGND &&
 321         message != WM_NCPAINT &&
 322         message != WM_NCHITTEST &&
 323         message != WM_GETTEXT &&
 324         message != WM_GETICON &&
 325         message != WM_DEVICECHANGE)
 326     {
 327         trace("parent: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 328
 329         msg.message = message;
 330         msg.flags = sent|wparam|lparam;
 331         if (defwndproc_counter) msg.flags |= defwinproc;
 332         msg.wParam = wParam;
 333         msg.lParam = lParam;
 334         add_message(sequences, PARENT_SEQ_INDEX, &msg);
 335     }
 336
 337     defwndproc_counter++;
 338     ret = DefWindowProcA(hwnd, message, wParam, lParam);
 339     defwndproc_counter--;
 340
 341     return ret;
 342 }
 343
 344 static BOOL registerParentWindowClass(void)
 345 {
 346     WNDCLASSA cls;
 347
 348     cls.style = 0;
 349     cls.lpfnWndProc = parentWindowProcess;
 350     cls.cbClsExtra = 0;
 351     cls.cbWndExtra = 0;
 352     cls.hInstance = GetModuleHandleA(NULL);
 353     cls.hIcon = 0;
 354     cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
 355     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
 356     cls.lpszMenuName = NULL;
 357     cls.lpszClassName = "Tab test parent class";
 358     return RegisterClassA(&cls);
 359 }
 360
 361 static HWND createParentWindow(void)
 362 {
 363     if (!registerParentWindowClass())
 364         return NULL;
 365
 366     return CreateWindowEx(0, "Tab test parent class",
 367                           "Tab test parent window",
 368                           WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
 369                           WS_MAXIMIZEBOX | WS_VISIBLE,
 370                           0, 0, 100, 100,
 371                           GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL);
 372 }
 373
 374 struct subclass_info
 375 {
 376     WNDPROC oldproc;
 377 };
 378
 379 static LRESULT WINAPI tabSubclassProcess(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 380 {
 381     struct subclass_info *info = (struct subclass_info *)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 382     static long defwndproc_counter = 0;
 383     LRESULT ret;
 384     struct message msg;
 385
 386     /* do not log painting messages */
 387     if (message != WM_PAINT &&
 388         message != WM_ERASEBKGND &&
 389         message != WM_NCPAINT &&
 390         message != WM_NCHITTEST &&
 391         message != WM_GETTEXT &&
 392         message != WM_GETICON &&
 393         message != WM_DEVICECHANGE)
 394     {
 395         trace("tab: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 396
 397         msg.message = message;
 398         msg.flags = sent|wparam|lparam;
 399         if (defwndproc_counter) msg.flags |= defwinproc;
 400         msg.wParam = wParam;
 401         msg.lParam = lParam;
 402         add_message(sequences, TAB_SEQ_INDEX, &msg);
 403     }
 404
 405     defwndproc_counter++;
 406     ret = CallWindowProcA(info->oldproc, hwnd, message, wParam, lParam);
 407     defwndproc_counter--;
 408
 409     return ret;
 410 }
 411
 412 static HWND createFilledTabControl(HWND parent_wnd, DWORD style, DWORD mask, INT nTabs)
 413 {
 414     HWND tabHandle;
 415     TCITEM tcNewTab;
 416     struct subclass_info *info;
 417     RECT rect;
 418     INT i;
 419
 420     info = HeapAlloc(GetProcessHeap(), 0, sizeof(struct subclass_info));
 421     if (!info)
 422         return NULL;
 423
 424     GetClientRect(parent_wnd, &rect);
 425
 426     tabHandle = CreateWindow (
 427         WC_TABCONTROLA,
 428         "TestTab",
 429         WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | style,
 430         0, 0, rect.right, rect.bottom,
 431         parent_wnd, NULL, NULL, 0);
 432
 433     assert(tabHandle);
 434
 435     info->oldproc = (WNDPROC)SetWindowLongPtrA(tabHandle, GWLP_WNDPROC, (LONG_PTR)tabSubclassProcess);
 436     SetWindowLongPtrA(tabHandle, GWLP_USERDATA, (LONG_PTR)info);
 437
 438     tcNewTab.mask = mask;
 439
 440     for (i = 0; i < nTabs; i++)
 441     {
 442         char tabName[MAX_TABLEN];
 443
 444         sprintf(tabName, "Tab %d", i+1);
 445         tcNewTab.pszText = tabName;
 446         tcNewTab.iImage = i;
 447         SendMessage (tabHandle, TCM_INSERTITEM, i, (LPARAM) &tcNewTab);
 448     }
 449
 450     if (winetest_interactive)
 451     {
 452         ShowWindow (tabHandle, SW_SHOW);
 453         RedrawWindow (tabHandle, NULL, 0, RDW_UPDATENOW);
 454         Sleep (1000);
 455     }
 456
 457     return tabHandle;
 458 }
 459
 460 static HWND create_tooltip (HWND hTab, char toolTipText[])
 461 {
 462     HWND hwndTT;
 463
 464     TOOLINFO ti;
 465     LPTSTR lptstr = toolTipText;
 466     RECT rect;
 467
 468     /* Creating a tooltip window*/
 469     hwndTT = CreateWindowEx(
 470         WS_EX_TOPMOST,
 471         TOOLTIPS_CLASS,
 472         NULL,
 473         WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
 474         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 475         hTab, NULL, 0, NULL);
 476
 477     SetWindowPos(
 478         hwndTT,
 479         HWND_TOPMOST,
 480         0, 0, 0, 0,
 481         SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 482
 483     GetClientRect (hTab, &rect);
 484
 485     /* Initialize members of toolinfo*/
 486     ti.cbSize = sizeof(TOOLINFO);
 487     ti.uFlags = TTF_SUBCLASS;
 488     ti.hwnd = hTab;
 489     ti.hinst = 0;
 490     ti.uId = 0;
 491     ti.lpszText = lptstr;
 492
 493     ti.rect = rect;
 494
 495     /* Add toolinfo structure to the tooltip control */
 496     SendMessage(hwndTT, TTM_ADDTOOL, 0, (LPARAM) (LPTOOLINFO) &ti);
 497
 498     return hwndTT;
 499 }
 500
 501 static void test_tab(INT nMinTabWidth)
 502 {
 503     HWND hwTab;
 504     RECT rTab;
 505     HIMAGELIST himl = ImageList_Create(21, 21, ILC_COLOR, 3, 4);
 506     SIZE size;
 507     HDC hdc;
 508     HFONT hOldFont;
 509     INT i;
 510
 511     hwTab = create_tabcontrol(TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE);
 512     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 513
 514     hdc = GetDC(hwTab);
 515     hOldFont = SelectObject(hdc, (HFONT)SendMessage(hwTab, WM_GETFONT, 0, 0));
 516     GetTextExtentPoint32A(hdc, "Tab 1", strlen("Tab 1"), &size);
 517     trace("Tab1 text size: size.cx=%d size.cy=%d\n", size.cx, size.cy);
 518     SelectObject(hdc, hOldFont);
 519     ReleaseDC(hwTab, hdc);
 520
 521     trace ("  TCS_FIXEDWIDTH tabs no icon...\n");
 522     CheckSize(hwTab, TAB_DEFAULT_WIDTH, -1, "default width");
 523     TabCheckSetSize(hwTab, 50, 20, 50, 20, "set size");
 524     TabCheckSetSize(hwTab, 0, 1, 0, 1, "min size");
 525
 526     SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 527
 528     trace ("  TCS_FIXEDWIDTH tabs with icon...\n");
 529     TabCheckSetSize(hwTab, 50, 30, 50, 30, "set size > icon");
 530     TabCheckSetSize(hwTab, 20, 20, 25, 20, "set size < icon");
 531     TabCheckSetSize(hwTab, 0, 1, 25, 1, "min size");
 532
 533     DestroyWindow (hwTab);
 534
 535     hwTab = create_tabcontrol(TCS_FIXEDWIDTH | TCS_BUTTONS, TCIF_TEXT|TCIF_IMAGE);
 536     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 537
 538     trace ("  TCS_FIXEDWIDTH buttons no icon...\n");
 539     CheckSize(hwTab, TAB_DEFAULT_WIDTH, -1, "default width");
 540     TabCheckSetSize(hwTab, 20, 20, 20, 20, "set size 1");
 541     TabCheckSetSize(hwTab, 10, 50, 10, 50, "set size 2");
 542     TabCheckSetSize(hwTab, 0, 1, 0, 1, "min size");
 543
 544     SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 545
 546     trace ("  TCS_FIXEDWIDTH buttons with icon...\n");
 547     TabCheckSetSize(hwTab, 50, 30, 50, 30, "set size > icon");
 548     TabCheckSetSize(hwTab, 20, 20, 25, 20, "set size < icon");
 549     TabCheckSetSize(hwTab, 0, 1, 25, 1, "min size");
 550     SendMessage(hwTab, TCM_SETPADDING, 0, MAKELPARAM(4,4));
 551     TabCheckSetSize(hwTab, 0, 1, 25, 1, "set padding, min size");
 552
 553     DestroyWindow (hwTab);
 554
 555     hwTab = create_tabcontrol(TCS_FIXEDWIDTH | TCS_BOTTOM, TCIF_TEXT|TCIF_IMAGE);
 556     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 557
 558     trace ("  TCS_FIXEDWIDTH | TCS_BOTTOM tabs...\n");
 559     CheckSize(hwTab, TAB_DEFAULT_WIDTH, -1, "no icon, default width");
 560
 561     TabCheckSetSize(hwTab, 20, 20, 20, 20, "no icon, set size 1");
 562     TabCheckSetSize(hwTab, 10, 50, 10, 50, "no icon, set size 2");
 563     TabCheckSetSize(hwTab, 0, 1, 0, 1, "no icon, min size");
 564
 565     SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 566
 567     TabCheckSetSize(hwTab, 50, 30, 50, 30, "with icon, set size > icon");
 568     TabCheckSetSize(hwTab, 20, 20, 25, 20, "with icon, set size < icon");
 569     TabCheckSetSize(hwTab, 0, 1, 25, 1, "with icon, min size");
 570     SendMessage(hwTab, TCM_SETPADDING, 0, MAKELPARAM(4,4));
 571     TabCheckSetSize(hwTab, 0, 1, 25, 1, "set padding, min size");
 572
 573     DestroyWindow (hwTab);
 574
 575     hwTab = create_tabcontrol(0, TCIF_TEXT|TCIF_IMAGE);
 576     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 577
 578     trace ("  non fixed width, with text...\n");
 579     CheckSize(hwTab, max(size.cx +TAB_PADDING_X*2, (nMinTabWidth < 0) ? DEFAULT_MIN_TAB_WIDTH : nMinTabWidth), -1,
 580               "no icon, default width");
 581     for (i=0; i<8; i++)
 582     {
 583         INT nTabWidth = (nMinTabWidth < 0) ? TabWidthPadded(i, 2) : nMinTabWidth;
 584
 585         SendMessage(hwTab, TCM_SETIMAGELIST, 0, 0);
 586         SendMessage(hwTab, TCM_SETPADDING, 0, MAKELPARAM(i,i));
 587
 588         TabCheckSetSize(hwTab, 50, 20, max(size.cx + i*2, nTabWidth), 20, "no icon, set size");
 589         TabCheckSetSize(hwTab, 0, 1, max(size.cx + i*2, nTabWidth), 1, "no icon, min size");
 590
 591         SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 592         nTabWidth = (nMinTabWidth < 0) ? TabWidthPadded(i, 3) : nMinTabWidth;
 593
 594         TabCheckSetSize(hwTab, 50, 30, max(size.cx + 21 + i*3, nTabWidth), 30, "with icon, set size > icon");
 595         TabCheckSetSize(hwTab, 20, 20, max(size.cx + 21 + i*3, nTabWidth), 20, "with icon, set size < icon");
 596         TabCheckSetSize(hwTab, 0, 1, max(size.cx + 21 + i*3, nTabWidth), 1, "with icon, min size");
 597     }
 598     DestroyWindow (hwTab);
 599
 600     hwTab = create_tabcontrol(0, TCIF_IMAGE);
 601     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 602
 603     trace ("  non fixed width, no text...\n");
 604     CheckSize(hwTab, (nMinTabWidth < 0) ? DEFAULT_MIN_TAB_WIDTH : nMinTabWidth, -1, "no icon, default width");
 605     for (i=0; i<8; i++)
 606     {
 607         INT nTabWidth = (nMinTabWidth < 0) ? TabWidthPadded(i, 2) : nMinTabWidth;
 608
 609         SendMessage(hwTab, TCM_SETIMAGELIST, 0, 0);
 610         SendMessage(hwTab, TCM_SETPADDING, 0, MAKELPARAM(i,i));
 611
 612         TabCheckSetSize(hwTab, 50, 20, nTabWidth, 20, "no icon, set size");
 613         TabCheckSetSize(hwTab, 0, 1, nTabWidth, 1, "no icon, min size");
 614
 615         SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 616         if (i > 1 && nMinTabWidth > 0 && nMinTabWidth < DEFAULT_MIN_TAB_WIDTH)
 617             nTabWidth += EXTRA_ICON_PADDING *(i-1);
 618
 619         TabCheckSetSize(hwTab, 50, 30, nTabWidth, 30, "with icon, set size > icon");
 620         TabCheckSetSize(hwTab, 20, 20, nTabWidth, 20, "with icon, set size < icon");
 621         TabCheckSetSize(hwTab, 0, 1, nTabWidth, 1, "with icon, min size");
 622     }
 623
 624     DestroyWindow (hwTab);
 625
 626     ImageList_Destroy(himl);
 627     DeleteObject(hFont);
 628 }
 629
 630 static void test_getters_setters(HWND parent_wnd, INT nTabs)
 631 {
 632     HWND hTab;
 633     RECT rTab;
 634     INT nTabsRetrieved;
 635     INT rowCount;
 636
 637     ok(parent_wnd != NULL, "no parent window!\n");
 638     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 639
 640     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, nTabs);
 641     ok(hTab != NULL, "Failed to create tab control\n");
 642
 643     if(!winetest_interactive)
 644         ok_sequence(sequences, TAB_SEQ_INDEX, add_tab_to_parent,
 645                     "Tab sequence, after adding tab control to parent", TRUE);
 646     else
 647         ok_sequence(sequences, TAB_SEQ_INDEX, add_tab_to_parent_interactive,
 648                     "Tab sequence, after adding tab control to parent", TRUE);
 649
 650     if(!winetest_interactive)
 651         ok_sequence(sequences, PARENT_SEQ_INDEX, add_tab_control_parent_seq,
 652                     "Parent after sequence, adding tab control to parent", TRUE);
 653     else
 654         ok_sequence(sequences, PARENT_SEQ_INDEX, add_tab_control_parent_seq_interactive,
 655                     "Parent after sequence, adding tab control to parent", TRUE);
 656
 657     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 658     todo_wine{
 659         expect(DEFAULT_MIN_TAB_WIDTH, (int)SendMessage(hTab, TCM_SETMINTABWIDTH, 0, -1));
 660     }
 661     ok_sequence(sequences, TAB_SEQ_INDEX, set_min_tab_width_seq, "Set minTabWidth test sequence", FALSE);
 662     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Set minTabWidth test parent sequence", FALSE);
 663
 664     /* Testing GetItemCount */
 665     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 666     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
 667     expect(nTabs, nTabsRetrieved);
 668     ok_sequence(sequences, TAB_SEQ_INDEX, get_item_count_seq, "Get itemCount test sequence", FALSE);
 669     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset itemCount test parent sequence", FALSE);
 670
 671     /* Testing GetRowCount */
 672     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 673     rowCount = SendMessage(hTab, TCM_GETROWCOUNT, 0, 0);
 674     expect(1, rowCount);
 675     ok_sequence(sequences, TAB_SEQ_INDEX, get_row_count_seq, "Get rowCount test sequence", FALSE);
 676     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Get rowCount test parent sequence", FALSE);
 677
 678     /* Testing GetItemRect */
 679     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 680     ok(SendMessage(hTab, TCM_GETITEMRECT, 0, (LPARAM) &rTab), "GetItemRect failed.\n");
 681     CheckSize(hTab, TAB_DEFAULT_WIDTH, -1 , "Default Width");
 682     ok_sequence(sequences, TAB_SEQ_INDEX, get_item_rect_seq, "Get itemRect test sequence", FALSE);
 683     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Get itemRect test parent sequence", FALSE);
 684
 685     /* Testing CurFocus */
 686     {
 687         INT focusIndex;
 688
 689         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 690
 691         /* Testing CurFocus with largest appropriate value */
 692         SendMessage(hTab, TCM_SETCURFOCUS, nTabs-1, 0);
 693         focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 694             expect(nTabs-1, focusIndex);
 695
 696         /* Testing CurFocus with negative value */
 697         SendMessage(hTab, TCM_SETCURFOCUS, -10, 0);
 698         focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 699             expect(-1, focusIndex);
 700
 701         /* Testing CurFocus with value larger than number of tabs */
 702         focusIndex = SendMessage(hTab, TCM_SETCURSEL, 1, 0);
 703         todo_wine{
 704             expect(-1, focusIndex);
 705         }
 706
 707         SendMessage(hTab, TCM_SETCURFOCUS, nTabs+1, 0);
 708         focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 709             expect(1, focusIndex);
 710
 711         ok_sequence(sequences, TAB_SEQ_INDEX, getset_cur_focus_seq, "Getset curFoc test sequence", FALSE);
 712     }
 713
 714     /* Testing CurSel */
 715     {
 716         INT selectionIndex;
 717         INT focusIndex;
 718
 719         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 720
 721         /* Testing CurSel with largest appropriate value */
 722         selectionIndex = SendMessage(hTab, TCM_SETCURSEL, nTabs-1, 0);
 723             expect(1, selectionIndex);
 724         selectionIndex = SendMessage(hTab, TCM_GETCURSEL, 0, 0);
 725             expect(nTabs-1, selectionIndex);
 726
 727         /* Focus should switch with selection */
 728         focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 729             expect(nTabs-1, focusIndex);
 730
 731         /* Testing CurSel with negative value */
 732         SendMessage(hTab, TCM_SETCURSEL, -10, 0);
 733         selectionIndex = SendMessage(hTab, TCM_GETCURSEL, 0, 0);
 734             expect(-1, selectionIndex);
 735
 736         /* Testing CurSel with value larger than number of tabs */
 737         selectionIndex = SendMessage(hTab, TCM_SETCURSEL, 1, 0);
 738             expect(-1, selectionIndex);
 739
 740         selectionIndex = SendMessage(hTab, TCM_SETCURSEL, nTabs+1, 0);
 741             expect(-1, selectionIndex);
 742         selectionIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 743             expect(1, selectionIndex);
 744
 745         ok_sequence(sequences, TAB_SEQ_INDEX, getset_cur_sel_seq, "Getset curSel test sequence", FALSE);
 746         ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset curSel test parent sequence", FALSE);
 747     }
 748
 749     /* Testing ExtendedStyle */
 750     {
 751         DWORD prevExtendedStyle;
 752         DWORD extendedStyle;
 753
 754         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 755
 756         /* Testing Flat Separators */
 757         extendedStyle = SendMessage(hTab, TCM_GETEXTENDEDSTYLE, 0, 0);
 758         prevExtendedStyle = SendMessage(hTab, TCM_SETEXTENDEDSTYLE, 0, TCS_EX_FLATSEPARATORS);
 759             expect(extendedStyle, prevExtendedStyle);
 760
 761         extendedStyle = SendMessage(hTab, TCM_GETEXTENDEDSTYLE, 0, 0);
 762         todo_wine{
 763             expect(TCS_EX_FLATSEPARATORS, extendedStyle);
 764         }
 765
 766         /* Testing Register Drop */
 767         prevExtendedStyle = SendMessage(hTab, TCM_SETEXTENDEDSTYLE, 0, TCS_EX_REGISTERDROP);
 768             expect(extendedStyle, prevExtendedStyle);
 769
 770         extendedStyle = SendMessage(hTab, TCM_GETEXTENDEDSTYLE, 0, 0);
 771         todo_wine{
 772             expect(TCS_EX_REGISTERDROP, extendedStyle);
 773         }
 774
 775         ok_sequence(sequences, TAB_SEQ_INDEX, getset_extended_style_seq, "Getset extendedStyle test sequence", FALSE);
 776         ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset extendedStyle test parent sequence", FALSE);
 777     }
 778
 779     /* Testing UnicodeFormat */
 780     {
 781         INT unicodeFormat;
 782
 783         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 784
 785         unicodeFormat = SendMessage(hTab, TCM_SETUNICODEFORMAT, TRUE, 0);
 786         todo_wine{
 787             expect(0, unicodeFormat);
 788         }
 789         unicodeFormat = SendMessage(hTab, TCM_GETUNICODEFORMAT, 0, 0);
 790             expect(1, unicodeFormat);
 791
 792         unicodeFormat = SendMessage(hTab, TCM_SETUNICODEFORMAT, FALSE, 0);
 793             expect(1, unicodeFormat);
 794         unicodeFormat = SendMessage(hTab, TCM_GETUNICODEFORMAT, 0, 0);
 795             expect(0, unicodeFormat);
 796
 797         unicodeFormat = SendMessage(hTab, TCM_SETUNICODEFORMAT, TRUE, 0);
 798             expect(0, unicodeFormat);
 799
 800         ok_sequence(sequences, TAB_SEQ_INDEX, getset_unicode_format_seq, "Getset unicodeFormat test sequence", FALSE);
 801         ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset unicodeFormat test parent sequence", FALSE);
 802     }
 803
 804     /* Testing GetSet Item */
 805     {
 806         TCITEM tcItem;
 807         char szText[32] = "New Label";
 808
 809         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 810
 811         tcItem.mask = TCIF_TEXT;
 812         tcItem.pszText = &szText[0];
 813         tcItem.cchTextMax = sizeof(szText);
 814
 815         ok ( SendMessage(hTab, TCM_SETITEM, 0, (LPARAM) &tcItem), "Setting new item failed.\n");
 816         ok ( SendMessage(hTab, TCM_GETITEM, 0, (LPARAM) &tcItem), "Getting item failed.\n");
 817         expect_str("New Label", tcItem.pszText);
 818
 819         ok ( SendMessage(hTab, TCM_GETITEM, 1, (LPARAM) &tcItem), "Getting item failed.\n");
 820         expect_str("Tab 2", tcItem.pszText);
 821
 822         ok_sequence(sequences, TAB_SEQ_INDEX, getset_item_seq, "Getset item test sequence", FALSE);
 823         ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset item test parent sequence", FALSE);
 824     }
 825
 826     /* Testing GetSet ToolTip */
 827     {
 828         HWND toolTip;
 829         char toolTipText[32] = "ToolTip Text Test";
 830
 831         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 832
 833         toolTip = create_tooltip(hTab, toolTipText);
 834         SendMessage(hTab, TCM_SETTOOLTIPS, (LPARAM) toolTip, 0);
 835         ok (toolTip == (HWND) SendMessage(hTab,TCM_GETTOOLTIPS,0,0), "ToolTip was set incorrectly.\n");
 836
 837         SendMessage(hTab, TCM_SETTOOLTIPS, (LPARAM) NULL, 0);
 838         ok (NULL  == (HWND) SendMessage(hTab,TCM_GETTOOLTIPS,0,0), "ToolTip was set incorrectly.\n");
 839
 840         ok_sequence(sequences, TAB_SEQ_INDEX, getset_tooltip_seq, "Getset tooltip test sequence", TRUE);
 841         ok_sequence(sequences, PARENT_SEQ_INDEX, getset_tooltip_parent_seq, "Getset tooltip test parent sequence", TRUE);
 842     }
 843
 844     DestroyWindow(hTab);
 845 }
 846
 847 static void test_insert_focus(HWND parent_wnd)
 848 {
 849     HWND hTab;
 850     INT nTabsRetrieved;
 851     INT r;
 852     TCITEM tcNewTab;
 853     DWORD mask = TCIF_TEXT|TCIF_IMAGE;
 854     static char tabName[] = "TAB";
 855     tcNewTab.mask = mask;
 856     tcNewTab.pszText = tabName;
 857
 858     ok(parent_wnd != NULL, "no parent window!\n");
 859
 860     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, mask, 0);
 861     ok(hTab != NULL, "Failed to create tab control\n");
 862
 863     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 864
 865     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
 866     expect(0, nTabsRetrieved);
 867
 868     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 869     expect(-1, r);
 870
 871     tcNewTab.iImage = 1;
 872     r = SendMessage(hTab, TCM_INSERTITEM, 1, (LPARAM) &tcNewTab);
 873     expect(0, r);
 874
 875     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
 876     expect(1, nTabsRetrieved);
 877
 878     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 879     expect(0, r);
 880
 881     tcNewTab.iImage = 2;
 882     r = SendMessage(hTab, TCM_INSERTITEM, 2, (LPARAM) &tcNewTab);
 883     expect(1, r);
 884
 885     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
 886     expect(2, nTabsRetrieved);
 887
 888     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 889     expect(0, r);
 890
 891     r = SendMessage(hTab, TCM_SETCURFOCUS, -1, 0);
 892     expect(0, r);
 893
 894     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 895     expect(-1, r);
 896
 897     tcNewTab.iImage = 3;
 898     r = SendMessage(hTab, TCM_INSERTITEM, 3, (LPARAM) &tcNewTab);
 899     expect(2, r);
 900
 901     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 902     expect(2, r);
 903
 904     ok_sequence(sequences, TAB_SEQ_INDEX, insert_focus_seq, "insert_focus test sequence", TRUE);
 905     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "insert_focus parent test sequence", FALSE);
 906
 907     DestroyWindow(hTab);
 908 }
 909
 910 static void test_delete_focus(HWND parent_wnd)
 911 {
 912     HWND hTab;
 913     INT nTabsRetrieved;
 914     INT r;
 915
 916     ok(parent_wnd != NULL, "no parent window!\n");
 917
 918     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, 2);
 919     ok(hTab != NULL, "Failed to create tab control\n");
 920
 921     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 922
 923     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
 924     expect(2, nTabsRetrieved);
 925
 926     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 927     expect(0, r);
 928
 929     r = SendMessage(hTab, TCM_DELETEITEM, 1, 0);
 930     expect(1, r);
 931
 932     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
 933     expect(1, nTabsRetrieved);
 934
 935     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 936     expect(0, r);
 937
 938     r = SendMessage(hTab, TCM_SETCURFOCUS, -1, 0);
 939     expect(0, r);
 940
 941     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 942     expect(-1, r);
 943
 944     r = SendMessage(hTab, TCM_DELETEITEM, 0, 0);
 945     expect(1, r);
 946
 947     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
 948     expect(0, nTabsRetrieved);
 949
 950     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 951     expect(-1, r);
 952
 953     ok_sequence(sequences, TAB_SEQ_INDEX, delete_focus_seq, "delete_focus test sequence", FALSE);
 954     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "delete_focus parent test sequence", FALSE);
 955
 956     DestroyWindow(hTab);
 957 }
 958
 959 START_TEST(tab)
 960 {
 961     HWND parent_wnd;
 962     LOGFONTA logfont;
 963
 964     lstrcpyA(logfont.lfFaceName, "Arial");
 965     memset(&logfont, 0, sizeof(logfont));
 966     logfont.lfHeight = -12;
 967     logfont.lfWeight = FW_NORMAL;
 968     logfont.lfCharSet = ANSI_CHARSET;
 969     hFont = CreateFontIndirectA(&logfont);
 970
 971     InitCommonControls();
 972
 973     trace ("Testing with default MinWidth\n");
 974     test_tab(-1);
 975     trace ("Testing with MinWidth set to -3\n");
 976     test_tab(-3);
 977     trace ("Testing with MinWidth set to 24\n");
 978     test_tab(24);
 979     trace ("Testing with MinWidth set to 54\n");
 980     test_tab(54);
 981     trace ("Testing with MinWidth set to 94\n");
 982     test_tab(94);
 983
 984     init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
 985
 986     parent_wnd = createParentWindow();
 987     ok(parent_wnd != NULL, "Failed to create parent window!\n");
 988
 989     /* Testing getters and setters with 5 tabs */
 990     test_getters_setters(parent_wnd, 5);
 991
 992     test_insert_focus(parent_wnd);
 993     test_delete_focus(parent_wnd);
 994
 995     DestroyWindow(parent_wnd);
 996 }