dlls/comctl32/tests/tab.c

   1 /* Unit test suite for tab control.
   2  *
   3  * Copyright 2003 Vitaliy Margolen
   4  * Copyright 2007 Hagop Hagopian
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <assert.h>
  22 #include <windows.h>
  23 #include <commctrl.h>
  24 #include <stdio.h>
  25
  26 #include "wine/test.h"
  27 #include "msg.h"
  28
  29 #define DEFAULT_MIN_TAB_WIDTH 54
  30 #define TAB_DEFAULT_WIDTH 96
  31 #define TAB_PADDING_X 6
  32 #define EXTRA_ICON_PADDING 3
  33 #define MAX_TABLEN 32
  34
  35 #define NUM_MSG_SEQUENCES  2
  36 #define PARENT_SEQ_INDEX   0
  37 #define TAB_SEQ_INDEX      1
  38
  39 #define expect(expected, got) ok ( expected == got, "Expected %d, got %d\n", expected, got)
  40 #define expect_str(expected, got)\
  41  ok ( strcmp(expected, got) == 0, "Expected '%s', got '%s'\n", expected, got)
  42
  43 #define TabWidthPadded(padd_x, num) (DEFAULT_MIN_TAB_WIDTH - (TAB_PADDING_X - (padd_x)) * num)
  44
  45 #define TabCheckSetSize(hwnd, SetWidth, SetHeight, ExpWidth, ExpHeight, Msg)\
  46     SendMessage (hwnd, TCM_SETITEMSIZE, 0,\
  47         (LPARAM) MAKELPARAM((SetWidth >= 0) ? SetWidth:0, (SetHeight >= 0) ? SetHeight:0));\
  48     if (winetest_interactive) RedrawWindow (hwnd, NULL, 0, RDW_UPDATENOW);\
  49     CheckSize(hwnd, ExpWidth, ExpHeight, Msg);
  50
  51 #define CheckSize(hwnd,width,height,msg)\
  52     SendMessage (hwnd, TCM_GETITEMRECT, 0, (LPARAM) &rTab);\
  53     if ((width  >= 0) && (height < 0))\
  54         ok (width  == rTab.right  - rTab.left, "%s: Expected width [%d] got [%d]\n",\
  55         msg, (int)width,  rTab.right  - rTab.left);\
  56     else if ((height >= 0) && (width  < 0))\
  57         ok (height == rTab.bottom - rTab.top,  "%s: Expected height [%d] got [%d]\n",\
  58         msg, (int)height, rTab.bottom - rTab.top);\
  59     else\
  60         ok ((width  == rTab.right  - rTab.left) &&\
  61             (height == rTab.bottom - rTab.top ),\
  62             "%s: Expected [%d,%d] got [%d,%d]\n", msg, (int)width, (int)height,\
  63             rTab.right - rTab.left, rTab.bottom - rTab.top);
  64
  65 static HFONT hFont = 0;
  66
  67 static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];
  68
  69 static const struct message create_parent_wnd_seq[] = {
  70     { WM_GETMINMAXINFO, sent },
  71     { WM_NCCREATE, sent },
  72     { WM_NCCALCSIZE, sent|wparam, 0 },
  73     { WM_CREATE, sent },
  74     { WM_SHOWWINDOW, sent|wparam, 1 },
  75     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
  76     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
  77     { WM_ACTIVATEAPP, sent|wparam, 1 },
  78     { WM_NCACTIVATE, sent|wparam, 1 },
  79     { WM_ACTIVATE, sent|wparam, 1 },
  80     { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
  81     { WM_IME_NOTIFY, sent|defwinproc|optional },
  82     { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
  83     /* Win9x adds SWP_NOZORDER below */
  84     { WM_WINDOWPOSCHANGED, sent},
  85     { WM_NCCALCSIZE, sent|wparam|optional, 1 },
  86     { WM_SIZE, sent },
  87     { WM_MOVE, sent },
  88     { 0 }
  89 };
  90
  91 static const struct message add_tab_to_parent[] = {
  92     { TCM_INSERTITEMA, sent },
  93     { TCM_INSERTITEMA, sent },
  94     { WM_NOTIFYFORMAT, sent|defwinproc },
  95     { WM_QUERYUISTATE, sent|wparam|lparam|defwinproc, 0, 0 },
  96     { WM_PARENTNOTIFY, sent|defwinproc },
  97     { TCM_INSERTITEMA, sent },
  98     { TCM_INSERTITEMA, sent },
  99     { TCM_INSERTITEMA, sent },
 100     { 0 }
 101 };
 102
 103 static const struct message add_tab_to_parent_interactive[] = {
 104     { TCM_INSERTITEMA, sent },
 105     { TCM_INSERTITEMA, sent },
 106     { WM_NOTIFYFORMAT, sent|defwinproc },
 107     { WM_QUERYUISTATE, sent|wparam|lparam|defwinproc, 0, 0 },
 108     { WM_PARENTNOTIFY, sent|defwinproc },
 109     { TCM_INSERTITEMA, sent },
 110     { TCM_INSERTITEMA, sent },
 111     { TCM_INSERTITEMA, sent },
 112     { WM_SHOWWINDOW, sent},
 113     { WM_WINDOWPOSCHANGING, sent},
 114     { WM_WINDOWPOSCHANGING, sent},
 115     { WM_NCACTIVATE, sent},
 116     { WM_ACTIVATE, sent},
 117     { WM_IME_SETCONTEXT, sent|defwinproc|optional},
 118     { WM_IME_NOTIFY, sent|defwinproc|optional},
 119     { WM_SETFOCUS, sent|defwinproc},
 120     { WM_WINDOWPOSCHANGED, sent},
 121     { WM_SIZE, sent},
 122     { WM_MOVE, sent},
 123     { 0 }
 124 };
 125
 126 static const struct message add_tab_control_parent_seq[] = {
 127     { WM_NOTIFYFORMAT, sent },
 128     { WM_QUERYUISTATE, sent|wparam|lparam, 0, 0 },
 129     { 0 }
 130 };
 131
 132 static const struct message add_tab_control_parent_seq_interactive[] = {
 133     { WM_NOTIFYFORMAT, sent },
 134     { WM_QUERYUISTATE, sent|wparam|lparam, 0, 0 },
 135     { WM_WINDOWPOSCHANGING, sent|optional},
 136     { WM_NCACTIVATE, sent},
 137     { WM_ACTIVATE, sent},
 138     { WM_WINDOWPOSCHANGING, sent|optional},
 139     { WM_KILLFOCUS, sent},
 140     { WM_IME_SETCONTEXT, sent|optional},
 141     { WM_IME_NOTIFY, sent|optional},
 142     { 0 }
 143 };
 144
 145 static const struct message empty_sequence[] = {
 146     { 0 }
 147 };
 148
 149 static const struct message set_min_tab_width_seq[] = {
 150     { TCM_SETMINTABWIDTH, sent|wparam, 0 },
 151     { TCM_SETMINTABWIDTH, sent|wparam, 0 },
 152     { 0 }
 153 };
 154
 155 static const struct message get_item_count_seq[] = {
 156     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 157     { 0 }
 158 };
 159
 160 static const struct message get_row_count_seq[] = {
 161     { TCM_GETROWCOUNT, sent|wparam|lparam, 0, 0 },
 162     { 0 }
 163 };
 164
 165 static const struct message get_item_rect_seq[] = {
 166     { TCM_GETITEMRECT, sent },
 167     { TCM_GETITEMRECT, sent },
 168     { 0 }
 169 };
 170
 171 static const struct message getset_cur_focus_seq[] = {
 172     { TCM_SETCURFOCUS, sent|lparam, 0 },
 173     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 174     { TCM_SETCURFOCUS, sent|lparam, 0 },
 175     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 176     { TCM_SETCURSEL, sent|lparam, 0 },
 177     { TCM_SETCURFOCUS, sent|lparam, 0 },
 178     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 179     { 0 }
 180 };
 181
 182 static const struct message getset_cur_sel_seq[] = {
 183     { TCM_SETCURSEL, sent|lparam, 0 },
 184     { TCM_GETCURSEL, sent|wparam|lparam, 0, 0 },
 185     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 186     { TCM_SETCURSEL, sent|lparam, 0 },
 187     { TCM_GETCURSEL, sent|wparam|lparam, 0, 0 },
 188     { TCM_SETCURSEL, sent|lparam, 0 },
 189     { TCM_SETCURSEL, sent|lparam, 0 },
 190     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 191     { 0 }
 192 };
 193
 194 static const struct message getset_extended_style_seq[] = {
 195     { TCM_GETEXTENDEDSTYLE, sent|wparam|lparam, 0, 0 },
 196     { TCM_SETEXTENDEDSTYLE, sent },
 197     { TCM_GETEXTENDEDSTYLE, sent|wparam|lparam, 0, 0 },
 198     { TCM_SETEXTENDEDSTYLE, sent },
 199     { TCM_GETEXTENDEDSTYLE, sent|wparam|lparam, 0, 0 },
 200     { 0 }
 201 };
 202
 203 static const struct message getset_unicode_format_seq[] = {
 204     { CCM_SETUNICODEFORMAT, sent|lparam, 0 },
 205     { CCM_GETUNICODEFORMAT, sent|wparam|lparam, 0, 0 },
 206     { CCM_SETUNICODEFORMAT, sent|lparam, 0 },
 207     { CCM_GETUNICODEFORMAT, sent|wparam|lparam, 0, 0 },
 208     { CCM_SETUNICODEFORMAT, sent|lparam, 0 },
 209     { 0 }
 210 };
 211
 212 static const struct message getset_item_seq[] = {
 213     { TCM_SETITEMA, sent },
 214     { TCM_GETITEMA, sent },
 215     { TCM_GETITEMA, sent },
 216     { 0 }
 217 };
 218
 219 static const struct message getset_tooltip_seq[] = {
 220     { WM_NOTIFYFORMAT, sent },
 221     { WM_QUERYUISTATE, sent|wparam|lparam, 0, 0 },
 222     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
 223     { WM_NOTIFYFORMAT, sent },
 224     { TCM_SETTOOLTIPS, sent|lparam, 0 },
 225     { TCM_GETTOOLTIPS, sent|wparam|lparam, 0, 0 },
 226     { TCM_SETTOOLTIPS, sent|lparam, 0 },
 227     { TCM_GETTOOLTIPS, sent|wparam|lparam, 0, 0 },
 228     { 0 }
 229 };
 230
 231 static const struct message getset_tooltip_parent_seq[] = {
 232     { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
 233     { 0 }
 234 };
 235
 236 static HWND
 237 create_tabcontrol (DWORD style, DWORD mask)
 238 {
 239     HWND handle;
 240     TCITEM tcNewTab;
 241     static char text1[] = "Tab 1",
 242     text2[] = "Wide Tab 2",
 243     text3[] = "T 3";
 244
 245     handle = CreateWindow (
 246         WC_TABCONTROLA,
 247         "TestTab",
 248         WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | style,
 249         10, 10, 300, 100,
 250         NULL, NULL, NULL, 0);
 251
 252     assert (handle);
 253
 254     SetWindowLong(handle, GWL_STYLE, WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | style);
 255     SendMessage (handle, WM_SETFONT, 0, (LPARAM) hFont);
 256
 257     tcNewTab.mask = mask;
 258     tcNewTab.pszText = text1;
 259     tcNewTab.iImage = 0;
 260     SendMessage (handle, TCM_INSERTITEM, 0, (LPARAM) &tcNewTab);
 261     tcNewTab.pszText = text2;
 262     tcNewTab.iImage = 1;
 263     SendMessage (handle, TCM_INSERTITEM, 1, (LPARAM) &tcNewTab);
 264     tcNewTab.pszText = text3;
 265     tcNewTab.iImage = 2;
 266     SendMessage (handle, TCM_INSERTITEM, 2, (LPARAM) &tcNewTab);
 267
 268     if (winetest_interactive)
 269     {
 270         ShowWindow (handle, SW_SHOW);
 271         RedrawWindow (handle, NULL, 0, RDW_UPDATENOW);
 272         Sleep (1000);
 273     }
 274
 275     return handle;
 276 }
 277
 278 static LRESULT WINAPI parentWindowProcess(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 279 {
 280     static long defwndproc_counter = 0;
 281     LRESULT ret;
 282     struct message msg;
 283
 284     /* do not log painting messages */
 285     if (message != WM_PAINT &&
 286         message != WM_ERASEBKGND &&
 287         message != WM_NCPAINT &&
 288         message != WM_NCHITTEST &&
 289         message != WM_GETTEXT &&
 290         message != WM_GETICON &&
 291         message != WM_DEVICECHANGE)
 292     {
 293         trace("parent: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 294
 295         msg.message = message;
 296         msg.flags = sent|wparam|lparam;
 297         if (defwndproc_counter) msg.flags |= defwinproc;
 298         msg.wParam = wParam;
 299         msg.lParam = lParam;
 300         add_message(sequences, PARENT_SEQ_INDEX, &msg);
 301     }
 302
 303     defwndproc_counter++;
 304     ret = DefWindowProcA(hwnd, message, wParam, lParam);
 305     defwndproc_counter--;
 306
 307     return ret;
 308 }
 309
 310 static BOOL registerParentWindowClass(void)
 311 {
 312     WNDCLASSA cls;
 313
 314     cls.style = 0;
 315     cls.lpfnWndProc = parentWindowProcess;
 316     cls.cbClsExtra = 0;
 317     cls.cbWndExtra = 0;
 318     cls.hInstance = GetModuleHandleA(NULL);
 319     cls.hIcon = 0;
 320     cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
 321     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
 322     cls.lpszMenuName = NULL;
 323     cls.lpszClassName = "Tab test parent class";
 324     return RegisterClassA(&cls);
 325 }
 326
 327 static HWND createParentWindow(void)
 328 {
 329     if (!registerParentWindowClass())
 330         return NULL;
 331
 332     return CreateWindowEx(0, "Tab test parent class",
 333                           "Tab test parent window",
 334                           WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
 335                           WS_MAXIMIZEBOX | WS_VISIBLE,
 336                           0, 0, 100, 100,
 337                           GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL);
 338 }
 339
 340 struct subclass_info
 341 {
 342     WNDPROC oldproc;
 343 };
 344
 345 static LRESULT WINAPI tabSubclassProcess(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 346 {
 347     struct subclass_info *info = (struct subclass_info *)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 348     static long defwndproc_counter = 0;
 349     LRESULT ret;
 350     struct message msg;
 351
 352     /* do not log painting messages */
 353     if (message != WM_PAINT &&
 354         message != WM_ERASEBKGND &&
 355         message != WM_NCPAINT &&
 356         message != WM_NCHITTEST &&
 357         message != WM_GETTEXT &&
 358         message != WM_GETICON &&
 359         message != WM_DEVICECHANGE)
 360     {
 361         trace("tab: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 362
 363         msg.message = message;
 364         msg.flags = sent|wparam|lparam;
 365         if (defwndproc_counter) msg.flags |= defwinproc;
 366         msg.wParam = wParam;
 367         msg.lParam = lParam;
 368         add_message(sequences, TAB_SEQ_INDEX, &msg);
 369     }
 370
 371     defwndproc_counter++;
 372     ret = CallWindowProcA(info->oldproc, hwnd, message, wParam, lParam);
 373     defwndproc_counter--;
 374
 375     return ret;
 376 }
 377
 378 static HWND createFilledTabControl(HWND parent_wnd, DWORD style, DWORD mask, INT nTabs)
 379 {
 380     HWND tabHandle;
 381     TCITEM tcNewTab;
 382     struct subclass_info *info;
 383     RECT rect;
 384     INT i;
 385
 386     info = HeapAlloc(GetProcessHeap(), 0, sizeof(struct subclass_info));
 387     if (!info)
 388         return NULL;
 389
 390     GetClientRect(parent_wnd, &rect);
 391
 392     tabHandle = CreateWindow (
 393         WC_TABCONTROLA,
 394         "TestTab",
 395         WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | style,
 396         0, 0, rect.right, rect.bottom,
 397         parent_wnd, NULL, NULL, 0);
 398
 399     assert(tabHandle);
 400
 401     info->oldproc = (WNDPROC)SetWindowLongPtrA(tabHandle, GWLP_WNDPROC, (LONG_PTR)tabSubclassProcess);
 402     SetWindowLongPtrA(tabHandle, GWLP_USERDATA, (LONG_PTR)info);
 403
 404     tcNewTab.mask = mask;
 405
 406     for (i = 0; i < nTabs; i++)
 407     {
 408         char tabName[MAX_TABLEN];
 409
 410         sprintf(tabName, "Tab %d", i+1);
 411         tcNewTab.pszText = tabName;
 412         tcNewTab.iImage = i;
 413         SendMessage (tabHandle, TCM_INSERTITEM, i, (LPARAM) &tcNewTab);
 414     }
 415
 416     if (winetest_interactive)
 417     {
 418         ShowWindow (tabHandle, SW_SHOW);
 419         RedrawWindow (tabHandle, NULL, 0, RDW_UPDATENOW);
 420         Sleep (1000);
 421     }
 422
 423     return tabHandle;
 424 }
 425
 426 static HWND create_tooltip (HWND hTab, char toolTipText[])
 427 {
 428     HWND hwndTT;
 429
 430     TOOLINFO ti;
 431     LPTSTR lptstr = toolTipText;
 432     RECT rect;
 433
 434     /* Creating a tooltip window*/
 435     hwndTT = CreateWindowEx(
 436         WS_EX_TOPMOST,
 437         TOOLTIPS_CLASS,
 438         NULL,
 439         WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
 440         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 441         hTab, NULL, 0, NULL);
 442
 443     SetWindowPos(
 444         hwndTT,
 445         HWND_TOPMOST,
 446         0, 0, 0, 0,
 447         SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 448
 449     GetClientRect (hTab, &rect);
 450
 451     /* Initialize members of toolinfo*/
 452     ti.cbSize = sizeof(TOOLINFO);
 453     ti.uFlags = TTF_SUBCLASS;
 454     ti.hwnd = hTab;
 455     ti.hinst = 0;
 456     ti.uId = 0;
 457     ti.lpszText = lptstr;
 458
 459     ti.rect = rect;
 460
 461     /* Add toolinfo structure to the tooltip control */
 462     SendMessage(hwndTT, TTM_ADDTOOL, 0, (LPARAM) (LPTOOLINFO) &ti);
 463
 464     return hwndTT;
 465 }
 466
 467 static void test_tab(INT nMinTabWidth)
 468 {
 469     HWND hwTab;
 470     RECT rTab;
 471     HIMAGELIST himl = ImageList_Create(21, 21, ILC_COLOR, 3, 4);
 472     SIZE size;
 473     HDC hdc;
 474     HFONT hOldFont;
 475     INT i;
 476
 477     hwTab = create_tabcontrol(TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE);
 478     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 479
 480     hdc = GetDC(hwTab);
 481     hOldFont = SelectObject(hdc, (HFONT)SendMessage(hwTab, WM_GETFONT, 0, 0));
 482     GetTextExtentPoint32A(hdc, "Tab 1", strlen("Tab 1"), &size);
 483     trace("Tab1 text size: size.cx=%d size.cy=%d\n", size.cx, size.cy);
 484     SelectObject(hdc, hOldFont);
 485     ReleaseDC(hwTab, hdc);
 486
 487     trace ("  TCS_FIXEDWIDTH tabs no icon...\n");
 488     CheckSize(hwTab, TAB_DEFAULT_WIDTH, -1, "default width");
 489     TabCheckSetSize(hwTab, 50, 20, 50, 20, "set size");
 490     TabCheckSetSize(hwTab, 0, 1, 0, 1, "min size");
 491
 492     SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 493
 494     trace ("  TCS_FIXEDWIDTH tabs with icon...\n");
 495     TabCheckSetSize(hwTab, 50, 30, 50, 30, "set size > icon");
 496     TabCheckSetSize(hwTab, 20, 20, 25, 20, "set size < icon");
 497     TabCheckSetSize(hwTab, 0, 1, 25, 1, "min size");
 498
 499     DestroyWindow (hwTab);
 500
 501     hwTab = create_tabcontrol(TCS_FIXEDWIDTH | TCS_BUTTONS, TCIF_TEXT|TCIF_IMAGE);
 502     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 503
 504     trace ("  TCS_FIXEDWIDTH buttons no icon...\n");
 505     CheckSize(hwTab, TAB_DEFAULT_WIDTH, -1, "default width");
 506     TabCheckSetSize(hwTab, 20, 20, 20, 20, "set size 1");
 507     TabCheckSetSize(hwTab, 10, 50, 10, 50, "set size 2");
 508     TabCheckSetSize(hwTab, 0, 1, 0, 1, "min size");
 509
 510     SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 511
 512     trace ("  TCS_FIXEDWIDTH buttons with icon...\n");
 513     TabCheckSetSize(hwTab, 50, 30, 50, 30, "set size > icon");
 514     TabCheckSetSize(hwTab, 20, 20, 25, 20, "set size < icon");
 515     TabCheckSetSize(hwTab, 0, 1, 25, 1, "min size");
 516     SendMessage(hwTab, TCM_SETPADDING, 0, MAKELPARAM(4,4));
 517     TabCheckSetSize(hwTab, 0, 1, 25, 1, "set padding, min size");
 518
 519     DestroyWindow (hwTab);
 520
 521     hwTab = create_tabcontrol(TCS_FIXEDWIDTH | TCS_BOTTOM, TCIF_TEXT|TCIF_IMAGE);
 522     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 523
 524     trace ("  TCS_FIXEDWIDTH | TCS_BOTTOM tabs...\n");
 525     CheckSize(hwTab, TAB_DEFAULT_WIDTH, -1, "no icon, default width");
 526
 527     TabCheckSetSize(hwTab, 20, 20, 20, 20, "no icon, set size 1");
 528     TabCheckSetSize(hwTab, 10, 50, 10, 50, "no icon, set size 2");
 529     TabCheckSetSize(hwTab, 0, 1, 0, 1, "no icon, min size");
 530
 531     SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 532
 533     TabCheckSetSize(hwTab, 50, 30, 50, 30, "with icon, set size > icon");
 534     TabCheckSetSize(hwTab, 20, 20, 25, 20, "with icon, set size < icon");
 535     TabCheckSetSize(hwTab, 0, 1, 25, 1, "with icon, min size");
 536     SendMessage(hwTab, TCM_SETPADDING, 0, MAKELPARAM(4,4));
 537     TabCheckSetSize(hwTab, 0, 1, 25, 1, "set padding, min size");
 538
 539     DestroyWindow (hwTab);
 540
 541     hwTab = create_tabcontrol(0, TCIF_TEXT|TCIF_IMAGE);
 542     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 543
 544     trace ("  non fixed width, with text...\n");
 545     CheckSize(hwTab, max(size.cx +TAB_PADDING_X*2, (nMinTabWidth < 0) ? DEFAULT_MIN_TAB_WIDTH : nMinTabWidth), -1,
 546               "no icon, default width");
 547     for (i=0; i<8; i++)
 548     {
 549         INT nTabWidth = (nMinTabWidth < 0) ? TabWidthPadded(i, 2) : nMinTabWidth;
 550
 551         SendMessage(hwTab, TCM_SETIMAGELIST, 0, 0);
 552         SendMessage(hwTab, TCM_SETPADDING, 0, MAKELPARAM(i,i));
 553
 554         TabCheckSetSize(hwTab, 50, 20, max(size.cx + i*2, nTabWidth), 20, "no icon, set size");
 555         TabCheckSetSize(hwTab, 0, 1, max(size.cx + i*2, nTabWidth), 1, "no icon, min size");
 556
 557         SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 558         nTabWidth = (nMinTabWidth < 0) ? TabWidthPadded(i, 3) : nMinTabWidth;
 559
 560         TabCheckSetSize(hwTab, 50, 30, max(size.cx + 21 + i*3, nTabWidth), 30, "with icon, set size > icon");
 561         TabCheckSetSize(hwTab, 20, 20, max(size.cx + 21 + i*3, nTabWidth), 20, "with icon, set size < icon");
 562         TabCheckSetSize(hwTab, 0, 1, max(size.cx + 21 + i*3, nTabWidth), 1, "with icon, min size");
 563     }
 564     DestroyWindow (hwTab);
 565
 566     hwTab = create_tabcontrol(0, TCIF_IMAGE);
 567     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 568
 569     trace ("  non fixed width, no text...\n");
 570     CheckSize(hwTab, (nMinTabWidth < 0) ? DEFAULT_MIN_TAB_WIDTH : nMinTabWidth, -1, "no icon, default width");
 571     for (i=0; i<8; i++)
 572     {
 573         INT nTabWidth = (nMinTabWidth < 0) ? TabWidthPadded(i, 2) : nMinTabWidth;
 574
 575         SendMessage(hwTab, TCM_SETIMAGELIST, 0, 0);
 576         SendMessage(hwTab, TCM_SETPADDING, 0, MAKELPARAM(i,i));
 577
 578         TabCheckSetSize(hwTab, 50, 20, nTabWidth, 20, "no icon, set size");
 579         TabCheckSetSize(hwTab, 0, 1, nTabWidth, 1, "no icon, min size");
 580
 581         SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 582         if (i > 1 && nMinTabWidth > 0 && nMinTabWidth < DEFAULT_MIN_TAB_WIDTH)
 583             nTabWidth += EXTRA_ICON_PADDING *(i-1);
 584
 585         TabCheckSetSize(hwTab, 50, 30, nTabWidth, 30, "with icon, set size > icon");
 586         TabCheckSetSize(hwTab, 20, 20, nTabWidth, 20, "with icon, set size < icon");
 587         TabCheckSetSize(hwTab, 0, 1, nTabWidth, 1, "with icon, min size");
 588     }
 589
 590     DestroyWindow (hwTab);
 591
 592     ImageList_Destroy(himl);
 593     DeleteObject(hFont);
 594 }
 595
 596 static void test_getters_setters(INT nTabs)
 597 {
 598     HWND hTab;
 599     HWND parent_wnd;
 600     RECT rTab;
 601     INT nTabsRetrieved;
 602     INT rowCount;
 603
 604     parent_wnd = createParentWindow();
 605     ok(parent_wnd != NULL, "Failed to create parent window!\n");
 606     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 607
 608     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, nTabs);
 609     ok(hTab != NULL, "Failed to create tab control\n");
 610
 611     if(!winetest_interactive)
 612         ok_sequence(sequences, TAB_SEQ_INDEX, add_tab_to_parent,
 613                     "Tab sequence, after adding tab control to parent", TRUE);
 614     else
 615         ok_sequence(sequences, TAB_SEQ_INDEX, add_tab_to_parent_interactive,
 616                     "Tab sequence, after adding tab control to parent", TRUE);
 617
 618     if(!winetest_interactive)
 619         ok_sequence(sequences, PARENT_SEQ_INDEX, add_tab_control_parent_seq,
 620                     "Parent after sequence, adding tab control to parent", TRUE);
 621     else
 622         ok_sequence(sequences, PARENT_SEQ_INDEX, add_tab_control_parent_seq_interactive,
 623                     "Parent after sequence, adding tab control to parent", TRUE);
 624
 625     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 626     todo_wine{
 627         expect(DEFAULT_MIN_TAB_WIDTH, (int)SendMessage(hTab, TCM_SETMINTABWIDTH, 0, -1));
 628     }
 629     ok_sequence(sequences, TAB_SEQ_INDEX, set_min_tab_width_seq, "Set minTabWidth test sequence", FALSE);
 630     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Set minTabWidth test parent sequence", FALSE);
 631
 632     /* Testing GetItemCount */
 633     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 634     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
 635     expect(nTabs, nTabsRetrieved);
 636     ok_sequence(sequences, TAB_SEQ_INDEX, get_item_count_seq, "Get itemCount test sequence", FALSE);
 637     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset itemCount test parent sequence", FALSE);
 638
 639     /* Testing GetRowCount */
 640     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 641     rowCount = SendMessage(hTab, TCM_GETROWCOUNT, 0, 0);
 642     expect(1, rowCount);
 643     ok_sequence(sequences, TAB_SEQ_INDEX, get_row_count_seq, "Get rowCount test sequence", FALSE);
 644     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Get rowCount test parent sequence", FALSE);
 645
 646     /* Testing GetItemRect */
 647     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 648     ok(SendMessage(hTab, TCM_GETITEMRECT, 0, (LPARAM) &rTab), "GetItemRect failed.\n");
 649     CheckSize(hTab, TAB_DEFAULT_WIDTH, -1 , "Default Width");
 650     ok_sequence(sequences, TAB_SEQ_INDEX, get_item_rect_seq, "Get itemRect test sequence", FALSE);
 651     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Get itemRect test parent sequence", FALSE);
 652
 653     /* Testing CurFocus */
 654     {
 655         INT focusIndex;
 656
 657         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 658
 659         /* Testing CurFocus with largest appropriate value */
 660         SendMessage(hTab, TCM_SETCURFOCUS, nTabs-1, 0);
 661         focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 662             expect(nTabs-1, focusIndex);
 663
 664         /* Testing CurFocus with negative value */
 665         SendMessage(hTab, TCM_SETCURFOCUS, -10, 0);
 666         focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 667             expect(-1, focusIndex);
 668
 669         /* Testing CurFocus with value larger than number of tabs */
 670         focusIndex = SendMessage(hTab, TCM_SETCURSEL, 1, 0);
 671         todo_wine{
 672             expect(-1, focusIndex);
 673         }
 674
 675         SendMessage(hTab, TCM_SETCURFOCUS, nTabs+1, 0);
 676         focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 677             expect(1, focusIndex);
 678
 679         ok_sequence(sequences, TAB_SEQ_INDEX, getset_cur_focus_seq, "Getset curFoc test sequence", FALSE);
 680     }
 681
 682     /* Testing CurSel */
 683     {
 684         INT selectionIndex;
 685         INT focusIndex;
 686
 687         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 688
 689         /* Testing CurSel with largest appropriate value */
 690         selectionIndex = SendMessage(hTab, TCM_SETCURSEL, nTabs-1, 0);
 691             expect(1, selectionIndex);
 692         selectionIndex = SendMessage(hTab, TCM_GETCURSEL, 0, 0);
 693             expect(nTabs-1, selectionIndex);
 694
 695         /* Focus should switch with selection */
 696         focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 697             expect(nTabs-1, focusIndex);
 698
 699         /* Testing CurSel with negative value */
 700         SendMessage(hTab, TCM_SETCURSEL, -10, 0);
 701         selectionIndex = SendMessage(hTab, TCM_GETCURSEL, 0, 0);
 702             expect(-1, selectionIndex);
 703
 704         /* Testing CurSel with value larger than number of tabs */
 705         selectionIndex = SendMessage(hTab, TCM_SETCURSEL, 1, 0);
 706             expect(-1, selectionIndex);
 707
 708         selectionIndex = SendMessage(hTab, TCM_SETCURSEL, nTabs+1, 0);
 709             expect(-1, selectionIndex);
 710         selectionIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 711             expect(1, selectionIndex);
 712
 713         ok_sequence(sequences, TAB_SEQ_INDEX, getset_cur_sel_seq, "Getset curSel test sequence", FALSE);
 714         ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset curSel test parent sequence", FALSE);
 715     }
 716
 717     /* Testing ExtendedStyle */
 718     {
 719         DWORD prevExtendedStyle;
 720         DWORD extendedStyle;
 721
 722         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 723
 724         /* Testing Flat Separators */
 725         extendedStyle = SendMessage(hTab, TCM_GETEXTENDEDSTYLE, 0, 0);
 726         prevExtendedStyle = SendMessage(hTab, TCM_SETEXTENDEDSTYLE, 0, TCS_EX_FLATSEPARATORS);
 727             expect(extendedStyle, prevExtendedStyle);
 728
 729         extendedStyle = SendMessage(hTab, TCM_GETEXTENDEDSTYLE, 0, 0);
 730         todo_wine{
 731             expect(TCS_EX_FLATSEPARATORS, extendedStyle);
 732         }
 733
 734         /* Testing Register Drop */
 735         prevExtendedStyle = SendMessage(hTab, TCM_SETEXTENDEDSTYLE, 0, TCS_EX_REGISTERDROP);
 736             expect(extendedStyle, prevExtendedStyle);
 737
 738         extendedStyle = SendMessage(hTab, TCM_GETEXTENDEDSTYLE, 0, 0);
 739         todo_wine{
 740             expect(TCS_EX_REGISTERDROP, extendedStyle);
 741         }
 742
 743         ok_sequence(sequences, TAB_SEQ_INDEX, getset_extended_style_seq, "Getset extendedStyle test sequence", FALSE);
 744         ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset extendedStyle test parent sequence", FALSE);
 745     }
 746
 747     /* Testing UnicodeFormat */
 748     {
 749         INT unicodeFormat;
 750
 751         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 752
 753         unicodeFormat = SendMessage(hTab, TCM_SETUNICODEFORMAT, TRUE, 0);
 754         todo_wine{
 755             expect(0, unicodeFormat);
 756         }
 757         unicodeFormat = SendMessage(hTab, TCM_GETUNICODEFORMAT, 0, 0);
 758             expect(1, unicodeFormat);
 759
 760         unicodeFormat = SendMessage(hTab, TCM_SETUNICODEFORMAT, FALSE, 0);
 761             expect(1, unicodeFormat);
 762         unicodeFormat = SendMessage(hTab, TCM_GETUNICODEFORMAT, 0, 0);
 763             expect(0, unicodeFormat);
 764
 765         unicodeFormat = SendMessage(hTab, TCM_SETUNICODEFORMAT, TRUE, 0);
 766             expect(0, unicodeFormat);
 767
 768         ok_sequence(sequences, TAB_SEQ_INDEX, getset_unicode_format_seq, "Getset unicodeFormat test sequence", FALSE);
 769         ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset unicodeFormat test parent sequence", FALSE);
 770     }
 771
 772     /* Testing GetSet Item */
 773     {
 774         TCITEM tcItem;
 775         char szText[32] = "New Label";
 776
 777         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 778
 779         tcItem.mask = TCIF_TEXT;
 780         tcItem.pszText = &szText[0];
 781         tcItem.cchTextMax = sizeof(szText);
 782
 783         ok ( SendMessage(hTab, TCM_SETITEM, 0, (LPARAM) &tcItem), "Setting new item failed.\n");
 784         ok ( SendMessage(hTab, TCM_GETITEM, 0, (LPARAM) &tcItem), "Getting item failed.\n");
 785         expect_str("New Label", tcItem.pszText);
 786
 787         ok ( SendMessage(hTab, TCM_GETITEM, 1, (LPARAM) &tcItem), "Getting item failed.\n");
 788         expect_str("Tab 2", tcItem.pszText);
 789
 790         ok_sequence(sequences, TAB_SEQ_INDEX, getset_item_seq, "Getset item test sequence", FALSE);
 791         ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset item test parent sequence", FALSE);
 792     }
 793
 794     /* Testing GetSet ToolTip */
 795     {
 796         HWND toolTip;
 797         char toolTipText[32] = "ToolTip Text Test";
 798
 799         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 800
 801         toolTip = create_tooltip(hTab, toolTipText);
 802         SendMessage(hTab, TCM_SETTOOLTIPS, (LPARAM) toolTip, 0);
 803         ok (toolTip == (HWND) SendMessage(hTab,TCM_GETTOOLTIPS,0,0), "ToolTip was set incorrectly.\n");
 804
 805         SendMessage(hTab, TCM_SETTOOLTIPS, (LPARAM) NULL, 0);
 806         ok (NULL  == (HWND) SendMessage(hTab,TCM_GETTOOLTIPS,0,0), "ToolTip was set incorrectly.\n");
 807
 808         ok_sequence(sequences, TAB_SEQ_INDEX, getset_tooltip_seq, "Getset tooltip test sequence", TRUE);
 809         ok_sequence(sequences, PARENT_SEQ_INDEX, getset_tooltip_parent_seq, "Getset tooltip test parent sequence", TRUE);
 810     }
 811
 812     DestroyWindow(hTab);
 813     DestroyWindow(parent_wnd);
 814 }
 815
 816 START_TEST(tab)
 817 {
 818     LOGFONTA logfont;
 819
 820     lstrcpyA(logfont.lfFaceName, "Arial");
 821     memset(&logfont, 0, sizeof(logfont));
 822     logfont.lfHeight = -12;
 823     logfont.lfWeight = FW_NORMAL;
 824     logfont.lfCharSet = ANSI_CHARSET;
 825     hFont = CreateFontIndirectA(&logfont);
 826
 827     InitCommonControls();
 828
 829     trace ("Testing with default MinWidth\n");
 830     test_tab(-1);
 831     trace ("Testing with MinWidth set to -3\n");
 832     test_tab(-3);
 833     trace ("Testing with MinWidth set to 24\n");
 834     test_tab(24);
 835     trace ("Testing with MinWidth set to 54\n");
 836     test_tab(54);
 837     trace ("Testing with MinWidth set to 94\n");
 838     test_tab(94);
 839
 840     init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
 841
 842     /* Testing getters and setters with 5 tabs */
 843     test_getters_setters(5);
 844 }