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 const struct message insert_focus_seq[] = {
 237     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 238     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 239     { TCM_INSERTITEM, sent|wparam, 1 },
 240     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 241     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 242     { TCM_INSERTITEM, sent|wparam, 2 },
 243     { WM_NOTIFYFORMAT, sent|defwinproc, },
 244     { WM_QUERYUISTATE, sent|defwinproc, },
 245     { WM_PARENTNOTIFY, sent|defwinproc, },
 246     { TCM_GETITEMCOUNT, sent|wparam|lparam, 0, 0 },
 247     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 248     { TCM_SETCURFOCUS, sent|wparam|lparam, -1, 0 },
 249     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 250     { TCM_INSERTITEM, sent|wparam, 3 },
 251     { TCM_GETCURFOCUS, sent|wparam|lparam, 0, 0 },
 252     { 0 }
 253 };
 254
 255
 256 static HWND
 257 create_tabcontrol (DWORD style, DWORD mask)
 258 {
 259     HWND handle;
 260     TCITEM tcNewTab;
 261     static char text1[] = "Tab 1",
 262     text2[] = "Wide Tab 2",
 263     text3[] = "T 3";
 264
 265     handle = CreateWindow (
 266         WC_TABCONTROLA,
 267         "TestTab",
 268         WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | style,
 269         10, 10, 300, 100,
 270         NULL, NULL, NULL, 0);
 271
 272     assert (handle);
 273
 274     SetWindowLong(handle, GWL_STYLE, WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | style);
 275     SendMessage (handle, WM_SETFONT, 0, (LPARAM) hFont);
 276
 277     tcNewTab.mask = mask;
 278     tcNewTab.pszText = text1;
 279     tcNewTab.iImage = 0;
 280     SendMessage (handle, TCM_INSERTITEM, 0, (LPARAM) &tcNewTab);
 281     tcNewTab.pszText = text2;
 282     tcNewTab.iImage = 1;
 283     SendMessage (handle, TCM_INSERTITEM, 1, (LPARAM) &tcNewTab);
 284     tcNewTab.pszText = text3;
 285     tcNewTab.iImage = 2;
 286     SendMessage (handle, TCM_INSERTITEM, 2, (LPARAM) &tcNewTab);
 287
 288     if (winetest_interactive)
 289     {
 290         ShowWindow (handle, SW_SHOW);
 291         RedrawWindow (handle, NULL, 0, RDW_UPDATENOW);
 292         Sleep (1000);
 293     }
 294
 295     return handle;
 296 }
 297
 298 static LRESULT WINAPI parentWindowProcess(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 299 {
 300     static long defwndproc_counter = 0;
 301     LRESULT ret;
 302     struct message msg;
 303
 304     /* do not log painting messages */
 305     if (message != WM_PAINT &&
 306         message != WM_ERASEBKGND &&
 307         message != WM_NCPAINT &&
 308         message != WM_NCHITTEST &&
 309         message != WM_GETTEXT &&
 310         message != WM_GETICON &&
 311         message != WM_DEVICECHANGE)
 312     {
 313         trace("parent: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 314
 315         msg.message = message;
 316         msg.flags = sent|wparam|lparam;
 317         if (defwndproc_counter) msg.flags |= defwinproc;
 318         msg.wParam = wParam;
 319         msg.lParam = lParam;
 320         add_message(sequences, PARENT_SEQ_INDEX, &msg);
 321     }
 322
 323     defwndproc_counter++;
 324     ret = DefWindowProcA(hwnd, message, wParam, lParam);
 325     defwndproc_counter--;
 326
 327     return ret;
 328 }
 329
 330 static BOOL registerParentWindowClass(void)
 331 {
 332     WNDCLASSA cls;
 333
 334     cls.style = 0;
 335     cls.lpfnWndProc = parentWindowProcess;
 336     cls.cbClsExtra = 0;
 337     cls.cbWndExtra = 0;
 338     cls.hInstance = GetModuleHandleA(NULL);
 339     cls.hIcon = 0;
 340     cls.hCursor = LoadCursorA(0, (LPSTR)IDC_ARROW);
 341     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
 342     cls.lpszMenuName = NULL;
 343     cls.lpszClassName = "Tab test parent class";
 344     return RegisterClassA(&cls);
 345 }
 346
 347 static HWND createParentWindow(void)
 348 {
 349     if (!registerParentWindowClass())
 350         return NULL;
 351
 352     return CreateWindowEx(0, "Tab test parent class",
 353                           "Tab test parent window",
 354                           WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
 355                           WS_MAXIMIZEBOX | WS_VISIBLE,
 356                           0, 0, 100, 100,
 357                           GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL);
 358 }
 359
 360 struct subclass_info
 361 {
 362     WNDPROC oldproc;
 363 };
 364
 365 static LRESULT WINAPI tabSubclassProcess(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 366 {
 367     struct subclass_info *info = (struct subclass_info *)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 368     static long defwndproc_counter = 0;
 369     LRESULT ret;
 370     struct message msg;
 371
 372     /* do not log painting messages */
 373     if (message != WM_PAINT &&
 374         message != WM_ERASEBKGND &&
 375         message != WM_NCPAINT &&
 376         message != WM_NCHITTEST &&
 377         message != WM_GETTEXT &&
 378         message != WM_GETICON &&
 379         message != WM_DEVICECHANGE)
 380     {
 381         trace("tab: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 382
 383         msg.message = message;
 384         msg.flags = sent|wparam|lparam;
 385         if (defwndproc_counter) msg.flags |= defwinproc;
 386         msg.wParam = wParam;
 387         msg.lParam = lParam;
 388         add_message(sequences, TAB_SEQ_INDEX, &msg);
 389     }
 390
 391     defwndproc_counter++;
 392     ret = CallWindowProcA(info->oldproc, hwnd, message, wParam, lParam);
 393     defwndproc_counter--;
 394
 395     return ret;
 396 }
 397
 398 static HWND createFilledTabControl(HWND parent_wnd, DWORD style, DWORD mask, INT nTabs)
 399 {
 400     HWND tabHandle;
 401     TCITEM tcNewTab;
 402     struct subclass_info *info;
 403     RECT rect;
 404     INT i;
 405
 406     info = HeapAlloc(GetProcessHeap(), 0, sizeof(struct subclass_info));
 407     if (!info)
 408         return NULL;
 409
 410     GetClientRect(parent_wnd, &rect);
 411
 412     tabHandle = CreateWindow (
 413         WC_TABCONTROLA,
 414         "TestTab",
 415         WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_FOCUSNEVER | style,
 416         0, 0, rect.right, rect.bottom,
 417         parent_wnd, NULL, NULL, 0);
 418
 419     assert(tabHandle);
 420
 421     info->oldproc = (WNDPROC)SetWindowLongPtrA(tabHandle, GWLP_WNDPROC, (LONG_PTR)tabSubclassProcess);
 422     SetWindowLongPtrA(tabHandle, GWLP_USERDATA, (LONG_PTR)info);
 423
 424     tcNewTab.mask = mask;
 425
 426     for (i = 0; i < nTabs; i++)
 427     {
 428         char tabName[MAX_TABLEN];
 429
 430         sprintf(tabName, "Tab %d", i+1);
 431         tcNewTab.pszText = tabName;
 432         tcNewTab.iImage = i;
 433         SendMessage (tabHandle, TCM_INSERTITEM, i, (LPARAM) &tcNewTab);
 434     }
 435
 436     if (winetest_interactive)
 437     {
 438         ShowWindow (tabHandle, SW_SHOW);
 439         RedrawWindow (tabHandle, NULL, 0, RDW_UPDATENOW);
 440         Sleep (1000);
 441     }
 442
 443     return tabHandle;
 444 }
 445
 446 static HWND create_tooltip (HWND hTab, char toolTipText[])
 447 {
 448     HWND hwndTT;
 449
 450     TOOLINFO ti;
 451     LPTSTR lptstr = toolTipText;
 452     RECT rect;
 453
 454     /* Creating a tooltip window*/
 455     hwndTT = CreateWindowEx(
 456         WS_EX_TOPMOST,
 457         TOOLTIPS_CLASS,
 458         NULL,
 459         WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
 460         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 461         hTab, NULL, 0, NULL);
 462
 463     SetWindowPos(
 464         hwndTT,
 465         HWND_TOPMOST,
 466         0, 0, 0, 0,
 467         SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 468
 469     GetClientRect (hTab, &rect);
 470
 471     /* Initialize members of toolinfo*/
 472     ti.cbSize = sizeof(TOOLINFO);
 473     ti.uFlags = TTF_SUBCLASS;
 474     ti.hwnd = hTab;
 475     ti.hinst = 0;
 476     ti.uId = 0;
 477     ti.lpszText = lptstr;
 478
 479     ti.rect = rect;
 480
 481     /* Add toolinfo structure to the tooltip control */
 482     SendMessage(hwndTT, TTM_ADDTOOL, 0, (LPARAM) (LPTOOLINFO) &ti);
 483
 484     return hwndTT;
 485 }
 486
 487 static void test_tab(INT nMinTabWidth)
 488 {
 489     HWND hwTab;
 490     RECT rTab;
 491     HIMAGELIST himl = ImageList_Create(21, 21, ILC_COLOR, 3, 4);
 492     SIZE size;
 493     HDC hdc;
 494     HFONT hOldFont;
 495     INT i;
 496
 497     hwTab = create_tabcontrol(TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE);
 498     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 499
 500     hdc = GetDC(hwTab);
 501     hOldFont = SelectObject(hdc, (HFONT)SendMessage(hwTab, WM_GETFONT, 0, 0));
 502     GetTextExtentPoint32A(hdc, "Tab 1", strlen("Tab 1"), &size);
 503     trace("Tab1 text size: size.cx=%d size.cy=%d\n", size.cx, size.cy);
 504     SelectObject(hdc, hOldFont);
 505     ReleaseDC(hwTab, hdc);
 506
 507     trace ("  TCS_FIXEDWIDTH tabs no icon...\n");
 508     CheckSize(hwTab, TAB_DEFAULT_WIDTH, -1, "default width");
 509     TabCheckSetSize(hwTab, 50, 20, 50, 20, "set size");
 510     TabCheckSetSize(hwTab, 0, 1, 0, 1, "min size");
 511
 512     SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 513
 514     trace ("  TCS_FIXEDWIDTH tabs with icon...\n");
 515     TabCheckSetSize(hwTab, 50, 30, 50, 30, "set size > icon");
 516     TabCheckSetSize(hwTab, 20, 20, 25, 20, "set size < icon");
 517     TabCheckSetSize(hwTab, 0, 1, 25, 1, "min size");
 518
 519     DestroyWindow (hwTab);
 520
 521     hwTab = create_tabcontrol(TCS_FIXEDWIDTH | TCS_BUTTONS, TCIF_TEXT|TCIF_IMAGE);
 522     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 523
 524     trace ("  TCS_FIXEDWIDTH buttons no icon...\n");
 525     CheckSize(hwTab, TAB_DEFAULT_WIDTH, -1, "default width");
 526     TabCheckSetSize(hwTab, 20, 20, 20, 20, "set size 1");
 527     TabCheckSetSize(hwTab, 10, 50, 10, 50, "set size 2");
 528     TabCheckSetSize(hwTab, 0, 1, 0, 1, "min size");
 529
 530     SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 531
 532     trace ("  TCS_FIXEDWIDTH buttons 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     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(TCS_FIXEDWIDTH | TCS_BOTTOM, TCIF_TEXT|TCIF_IMAGE);
 542     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 543
 544     trace ("  TCS_FIXEDWIDTH | TCS_BOTTOM tabs...\n");
 545     CheckSize(hwTab, TAB_DEFAULT_WIDTH, -1, "no icon, default width");
 546
 547     TabCheckSetSize(hwTab, 20, 20, 20, 20, "no icon, set size 1");
 548     TabCheckSetSize(hwTab, 10, 50, 10, 50, "no icon, set size 2");
 549     TabCheckSetSize(hwTab, 0, 1, 0, 1, "no icon, min size");
 550
 551     SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 552
 553     TabCheckSetSize(hwTab, 50, 30, 50, 30, "with icon, set size > icon");
 554     TabCheckSetSize(hwTab, 20, 20, 25, 20, "with icon, set size < icon");
 555     TabCheckSetSize(hwTab, 0, 1, 25, 1, "with icon, 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(0, TCIF_TEXT|TCIF_IMAGE);
 562     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 563
 564     trace ("  non fixed width, with text...\n");
 565     CheckSize(hwTab, max(size.cx +TAB_PADDING_X*2, (nMinTabWidth < 0) ? DEFAULT_MIN_TAB_WIDTH : nMinTabWidth), -1,
 566               "no icon, default width");
 567     for (i=0; i<8; i++)
 568     {
 569         INT nTabWidth = (nMinTabWidth < 0) ? TabWidthPadded(i, 2) : nMinTabWidth;
 570
 571         SendMessage(hwTab, TCM_SETIMAGELIST, 0, 0);
 572         SendMessage(hwTab, TCM_SETPADDING, 0, MAKELPARAM(i,i));
 573
 574         TabCheckSetSize(hwTab, 50, 20, max(size.cx + i*2, nTabWidth), 20, "no icon, set size");
 575         TabCheckSetSize(hwTab, 0, 1, max(size.cx + i*2, nTabWidth), 1, "no icon, min size");
 576
 577         SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 578         nTabWidth = (nMinTabWidth < 0) ? TabWidthPadded(i, 3) : nMinTabWidth;
 579
 580         TabCheckSetSize(hwTab, 50, 30, max(size.cx + 21 + i*3, nTabWidth), 30, "with icon, set size > icon");
 581         TabCheckSetSize(hwTab, 20, 20, max(size.cx + 21 + i*3, nTabWidth), 20, "with icon, set size < icon");
 582         TabCheckSetSize(hwTab, 0, 1, max(size.cx + 21 + i*3, nTabWidth), 1, "with icon, min size");
 583     }
 584     DestroyWindow (hwTab);
 585
 586     hwTab = create_tabcontrol(0, TCIF_IMAGE);
 587     SendMessage(hwTab, TCM_SETMINTABWIDTH, 0, nMinTabWidth);
 588
 589     trace ("  non fixed width, no text...\n");
 590     CheckSize(hwTab, (nMinTabWidth < 0) ? DEFAULT_MIN_TAB_WIDTH : nMinTabWidth, -1, "no icon, default width");
 591     for (i=0; i<8; i++)
 592     {
 593         INT nTabWidth = (nMinTabWidth < 0) ? TabWidthPadded(i, 2) : nMinTabWidth;
 594
 595         SendMessage(hwTab, TCM_SETIMAGELIST, 0, 0);
 596         SendMessage(hwTab, TCM_SETPADDING, 0, MAKELPARAM(i,i));
 597
 598         TabCheckSetSize(hwTab, 50, 20, nTabWidth, 20, "no icon, set size");
 599         TabCheckSetSize(hwTab, 0, 1, nTabWidth, 1, "no icon, min size");
 600
 601         SendMessage(hwTab, TCM_SETIMAGELIST, 0, (LPARAM)himl);
 602         if (i > 1 && nMinTabWidth > 0 && nMinTabWidth < DEFAULT_MIN_TAB_WIDTH)
 603             nTabWidth += EXTRA_ICON_PADDING *(i-1);
 604
 605         TabCheckSetSize(hwTab, 50, 30, nTabWidth, 30, "with icon, set size > icon");
 606         TabCheckSetSize(hwTab, 20, 20, nTabWidth, 20, "with icon, set size < icon");
 607         TabCheckSetSize(hwTab, 0, 1, nTabWidth, 1, "with icon, min size");
 608     }
 609
 610     DestroyWindow (hwTab);
 611
 612     ImageList_Destroy(himl);
 613     DeleteObject(hFont);
 614 }
 615
 616 static void test_getters_setters(HWND parent_wnd, INT nTabs)
 617 {
 618     HWND hTab;
 619     RECT rTab;
 620     INT nTabsRetrieved;
 621     INT rowCount;
 622
 623     ok(parent_wnd != NULL, "no parent window!\n");
 624     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 625
 626     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, TCIF_TEXT|TCIF_IMAGE, nTabs);
 627     ok(hTab != NULL, "Failed to create tab control\n");
 628
 629     if(!winetest_interactive)
 630         ok_sequence(sequences, TAB_SEQ_INDEX, add_tab_to_parent,
 631                     "Tab sequence, after adding tab control to parent", TRUE);
 632     else
 633         ok_sequence(sequences, TAB_SEQ_INDEX, add_tab_to_parent_interactive,
 634                     "Tab sequence, after adding tab control to parent", TRUE);
 635
 636     if(!winetest_interactive)
 637         ok_sequence(sequences, PARENT_SEQ_INDEX, add_tab_control_parent_seq,
 638                     "Parent after sequence, adding tab control to parent", TRUE);
 639     else
 640         ok_sequence(sequences, PARENT_SEQ_INDEX, add_tab_control_parent_seq_interactive,
 641                     "Parent after sequence, adding tab control to parent", TRUE);
 642
 643     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 644     todo_wine{
 645         expect(DEFAULT_MIN_TAB_WIDTH, (int)SendMessage(hTab, TCM_SETMINTABWIDTH, 0, -1));
 646     }
 647     ok_sequence(sequences, TAB_SEQ_INDEX, set_min_tab_width_seq, "Set minTabWidth test sequence", FALSE);
 648     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Set minTabWidth test parent sequence", FALSE);
 649
 650     /* Testing GetItemCount */
 651     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 652     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
 653     expect(nTabs, nTabsRetrieved);
 654     ok_sequence(sequences, TAB_SEQ_INDEX, get_item_count_seq, "Get itemCount test sequence", FALSE);
 655     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset itemCount test parent sequence", FALSE);
 656
 657     /* Testing GetRowCount */
 658     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 659     rowCount = SendMessage(hTab, TCM_GETROWCOUNT, 0, 0);
 660     expect(1, rowCount);
 661     ok_sequence(sequences, TAB_SEQ_INDEX, get_row_count_seq, "Get rowCount test sequence", FALSE);
 662     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Get rowCount test parent sequence", FALSE);
 663
 664     /* Testing GetItemRect */
 665     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 666     ok(SendMessage(hTab, TCM_GETITEMRECT, 0, (LPARAM) &rTab), "GetItemRect failed.\n");
 667     CheckSize(hTab, TAB_DEFAULT_WIDTH, -1 , "Default Width");
 668     ok_sequence(sequences, TAB_SEQ_INDEX, get_item_rect_seq, "Get itemRect test sequence", FALSE);
 669     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Get itemRect test parent sequence", FALSE);
 670
 671     /* Testing CurFocus */
 672     {
 673         INT focusIndex;
 674
 675         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 676
 677         /* Testing CurFocus with largest appropriate value */
 678         SendMessage(hTab, TCM_SETCURFOCUS, nTabs-1, 0);
 679         focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 680             expect(nTabs-1, focusIndex);
 681
 682         /* Testing CurFocus with negative value */
 683         SendMessage(hTab, TCM_SETCURFOCUS, -10, 0);
 684         focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 685             expect(-1, focusIndex);
 686
 687         /* Testing CurFocus with value larger than number of tabs */
 688         focusIndex = SendMessage(hTab, TCM_SETCURSEL, 1, 0);
 689         todo_wine{
 690             expect(-1, focusIndex);
 691         }
 692
 693         SendMessage(hTab, TCM_SETCURFOCUS, nTabs+1, 0);
 694         focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 695             expect(1, focusIndex);
 696
 697         ok_sequence(sequences, TAB_SEQ_INDEX, getset_cur_focus_seq, "Getset curFoc test sequence", FALSE);
 698     }
 699
 700     /* Testing CurSel */
 701     {
 702         INT selectionIndex;
 703         INT focusIndex;
 704
 705         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 706
 707         /* Testing CurSel with largest appropriate value */
 708         selectionIndex = SendMessage(hTab, TCM_SETCURSEL, nTabs-1, 0);
 709             expect(1, selectionIndex);
 710         selectionIndex = SendMessage(hTab, TCM_GETCURSEL, 0, 0);
 711             expect(nTabs-1, selectionIndex);
 712
 713         /* Focus should switch with selection */
 714         focusIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 715             expect(nTabs-1, focusIndex);
 716
 717         /* Testing CurSel with negative value */
 718         SendMessage(hTab, TCM_SETCURSEL, -10, 0);
 719         selectionIndex = SendMessage(hTab, TCM_GETCURSEL, 0, 0);
 720             expect(-1, selectionIndex);
 721
 722         /* Testing CurSel with value larger than number of tabs */
 723         selectionIndex = SendMessage(hTab, TCM_SETCURSEL, 1, 0);
 724             expect(-1, selectionIndex);
 725
 726         selectionIndex = SendMessage(hTab, TCM_SETCURSEL, nTabs+1, 0);
 727             expect(-1, selectionIndex);
 728         selectionIndex = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 729             expect(1, selectionIndex);
 730
 731         ok_sequence(sequences, TAB_SEQ_INDEX, getset_cur_sel_seq, "Getset curSel test sequence", FALSE);
 732         ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset curSel test parent sequence", FALSE);
 733     }
 734
 735     /* Testing ExtendedStyle */
 736     {
 737         DWORD prevExtendedStyle;
 738         DWORD extendedStyle;
 739
 740         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 741
 742         /* Testing Flat Separators */
 743         extendedStyle = SendMessage(hTab, TCM_GETEXTENDEDSTYLE, 0, 0);
 744         prevExtendedStyle = SendMessage(hTab, TCM_SETEXTENDEDSTYLE, 0, TCS_EX_FLATSEPARATORS);
 745             expect(extendedStyle, prevExtendedStyle);
 746
 747         extendedStyle = SendMessage(hTab, TCM_GETEXTENDEDSTYLE, 0, 0);
 748         todo_wine{
 749             expect(TCS_EX_FLATSEPARATORS, extendedStyle);
 750         }
 751
 752         /* Testing Register Drop */
 753         prevExtendedStyle = SendMessage(hTab, TCM_SETEXTENDEDSTYLE, 0, TCS_EX_REGISTERDROP);
 754             expect(extendedStyle, prevExtendedStyle);
 755
 756         extendedStyle = SendMessage(hTab, TCM_GETEXTENDEDSTYLE, 0, 0);
 757         todo_wine{
 758             expect(TCS_EX_REGISTERDROP, extendedStyle);
 759         }
 760
 761         ok_sequence(sequences, TAB_SEQ_INDEX, getset_extended_style_seq, "Getset extendedStyle test sequence", FALSE);
 762         ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset extendedStyle test parent sequence", FALSE);
 763     }
 764
 765     /* Testing UnicodeFormat */
 766     {
 767         INT unicodeFormat;
 768
 769         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 770
 771         unicodeFormat = SendMessage(hTab, TCM_SETUNICODEFORMAT, TRUE, 0);
 772         todo_wine{
 773             expect(0, unicodeFormat);
 774         }
 775         unicodeFormat = SendMessage(hTab, TCM_GETUNICODEFORMAT, 0, 0);
 776             expect(1, unicodeFormat);
 777
 778         unicodeFormat = SendMessage(hTab, TCM_SETUNICODEFORMAT, FALSE, 0);
 779             expect(1, unicodeFormat);
 780         unicodeFormat = SendMessage(hTab, TCM_GETUNICODEFORMAT, 0, 0);
 781             expect(0, unicodeFormat);
 782
 783         unicodeFormat = SendMessage(hTab, TCM_SETUNICODEFORMAT, TRUE, 0);
 784             expect(0, unicodeFormat);
 785
 786         ok_sequence(sequences, TAB_SEQ_INDEX, getset_unicode_format_seq, "Getset unicodeFormat test sequence", FALSE);
 787         ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset unicodeFormat test parent sequence", FALSE);
 788     }
 789
 790     /* Testing GetSet Item */
 791     {
 792         TCITEM tcItem;
 793         char szText[32] = "New Label";
 794
 795         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 796
 797         tcItem.mask = TCIF_TEXT;
 798         tcItem.pszText = &szText[0];
 799         tcItem.cchTextMax = sizeof(szText);
 800
 801         ok ( SendMessage(hTab, TCM_SETITEM, 0, (LPARAM) &tcItem), "Setting new item failed.\n");
 802         ok ( SendMessage(hTab, TCM_GETITEM, 0, (LPARAM) &tcItem), "Getting item failed.\n");
 803         expect_str("New Label", tcItem.pszText);
 804
 805         ok ( SendMessage(hTab, TCM_GETITEM, 1, (LPARAM) &tcItem), "Getting item failed.\n");
 806         expect_str("Tab 2", tcItem.pszText);
 807
 808         ok_sequence(sequences, TAB_SEQ_INDEX, getset_item_seq, "Getset item test sequence", FALSE);
 809         ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "Getset item test parent sequence", FALSE);
 810     }
 811
 812     /* Testing GetSet ToolTip */
 813     {
 814         HWND toolTip;
 815         char toolTipText[32] = "ToolTip Text Test";
 816
 817         flush_sequences(sequences, NUM_MSG_SEQUENCES);
 818
 819         toolTip = create_tooltip(hTab, toolTipText);
 820         SendMessage(hTab, TCM_SETTOOLTIPS, (LPARAM) toolTip, 0);
 821         ok (toolTip == (HWND) SendMessage(hTab,TCM_GETTOOLTIPS,0,0), "ToolTip was set incorrectly.\n");
 822
 823         SendMessage(hTab, TCM_SETTOOLTIPS, (LPARAM) NULL, 0);
 824         ok (NULL  == (HWND) SendMessage(hTab,TCM_GETTOOLTIPS,0,0), "ToolTip was set incorrectly.\n");
 825
 826         ok_sequence(sequences, TAB_SEQ_INDEX, getset_tooltip_seq, "Getset tooltip test sequence", TRUE);
 827         ok_sequence(sequences, PARENT_SEQ_INDEX, getset_tooltip_parent_seq, "Getset tooltip test parent sequence", TRUE);
 828     }
 829
 830     DestroyWindow(hTab);
 831 }
 832
 833 static void test_insert_focus(HWND parent_wnd)
 834 {
 835     HWND hTab;
 836     INT nTabsRetrieved;
 837     INT r;
 838     TCITEM tcNewTab;
 839     DWORD mask = TCIF_TEXT|TCIF_IMAGE;
 840     static char tabName[] = "TAB";
 841     tcNewTab.mask = mask;
 842     tcNewTab.pszText = tabName;
 843
 844     ok(parent_wnd != NULL, "no parent window!\n");
 845
 846     hTab = createFilledTabControl(parent_wnd, TCS_FIXEDWIDTH, mask, 0);
 847     ok(hTab != NULL, "Failed to create tab control\n");
 848
 849     flush_sequences(sequences, NUM_MSG_SEQUENCES);
 850
 851     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
 852     expect(0, nTabsRetrieved);
 853
 854     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 855     expect(-1, r);
 856
 857     tcNewTab.iImage = 1;
 858     r = SendMessage(hTab, TCM_INSERTITEM, 1, (LPARAM) &tcNewTab);
 859     expect(0, r);
 860
 861     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
 862     expect(1, nTabsRetrieved);
 863
 864     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 865     todo_wine {
 866         expect(0, r);
 867     }
 868
 869     tcNewTab.iImage = 2;
 870     r = SendMessage(hTab, TCM_INSERTITEM, 2, (LPARAM) &tcNewTab);
 871     expect(1, r);
 872
 873     nTabsRetrieved = SendMessage(hTab, TCM_GETITEMCOUNT, 0, 0);
 874     expect(2, nTabsRetrieved);
 875
 876     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 877     todo_wine {
 878         expect(0, r);
 879     }
 880
 881     r = SendMessage(hTab, TCM_SETCURFOCUS, -1, 0);
 882     expect(0, r);
 883
 884     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 885     expect(-1, r);
 886
 887     tcNewTab.iImage = 3;
 888     r = SendMessage(hTab, TCM_INSERTITEM, 3, (LPARAM) &tcNewTab);
 889     expect(2, r);
 890
 891     r = SendMessage(hTab, TCM_GETCURFOCUS, 0, 0);
 892     todo_wine {
 893         expect(2, r);
 894     }
 895
 896     ok_sequence(sequences, TAB_SEQ_INDEX, insert_focus_seq, "insert_focus test sequence", TRUE);
 897     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_sequence, "insert_focus parent test sequence", FALSE);
 898
 899     DestroyWindow(hTab);
 900 }
 901
 902 START_TEST(tab)
 903 {
 904     HWND parent_wnd;
 905     LOGFONTA logfont;
 906
 907     lstrcpyA(logfont.lfFaceName, "Arial");
 908     memset(&logfont, 0, sizeof(logfont));
 909     logfont.lfHeight = -12;
 910     logfont.lfWeight = FW_NORMAL;
 911     logfont.lfCharSet = ANSI_CHARSET;
 912     hFont = CreateFontIndirectA(&logfont);
 913
 914     InitCommonControls();
 915
 916     trace ("Testing with default MinWidth\n");
 917     test_tab(-1);
 918     trace ("Testing with MinWidth set to -3\n");
 919     test_tab(-3);
 920     trace ("Testing with MinWidth set to 24\n");
 921     test_tab(24);
 922     trace ("Testing with MinWidth set to 54\n");
 923     test_tab(54);
 924     trace ("Testing with MinWidth set to 94\n");
 925     test_tab(94);
 926
 927     init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
 928
 929     parent_wnd = createParentWindow();
 930     ok(parent_wnd != NULL, "Failed to create parent window!\n");
 931
 932     /* Testing getters and setters with 5 tabs */
 933     test_getters_setters(parent_wnd, 5);
 934
 935     test_insert_focus(parent_wnd);
 936
 937     DestroyWindow(parent_wnd);
 938 }