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

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