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