modules/rostests/winetests/comctl32/trackbar.c

   1 /* Unit tests for the track bar control.
   2  *
   3  * Copyright 2007 Keith Stevens
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <windows.h>
  21 #include <commctrl.h>
  22 #include <stdio.h>
  23
  24 #include "wine/test.h"
  25 #include "msg.h"
  26 #include "v6util.h"
  27
  28 #define expect(expected, got) ok(got == expected, "Expected %d, got %d\n", expected, got)
  29 #define NUM_MSG_SEQUENCE 2
  30 #define PARENT_SEQ_INDEX 0
  31 #define TRACKBAR_SEQ_INDEX 1
  32
  33 static const DWORD defaultstyle = WS_VISIBLE | TBS_TOOLTIPS | TBS_ENABLESELRANGE | TBS_FIXEDLENGTH | TBS_AUTOTICKS;
  34 static HWND hWndParent;
  35
  36 static LRESULT WINAPI trackbar_no_wmpaint_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  37 {
  38     WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
  39
  40     if (message == WM_PAINT)
  41         return 0;
  42
  43     return CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
  44 }
  45
  46 static struct msg_sequence *sequences[NUM_MSG_SEQUENCE];
  47
  48 static const struct message empty_seq[] = {
  49     {0}
  50 };
  51
  52 static const struct message parent_create_trackbar_wnd_seq[] = {
  53     { WM_NOTIFYFORMAT, sent},
  54     { WM_QUERYUISTATE, sent|optional},
  55     { WM_WINDOWPOSCHANGING, sent},
  56     { WM_NCACTIVATE, sent},
  57     { PBT_APMRESUMECRITICAL, sent},
  58     { WM_WINDOWPOSCHANGING, sent},
  59     { PBT_APMRESUMESTANDBY, sent},
  60     { WM_IME_SETCONTEXT, sent|optional},
  61     { WM_IME_NOTIFY, sent|optional},
  62     { WM_CTLCOLORSTATIC, sent},
  63     { WM_NOTIFY, sent},
  64     {0}
  65 };
  66
  67 static const struct message parent_new_window_test_seq[] = {
  68     { WM_QUERYNEWPALETTE, sent|optional },
  69     { WM_WINDOWPOSCHANGING, sent|optional},
  70     { WM_NCACTIVATE, sent|optional},
  71     { PBT_APMRESUMECRITICAL, sent|optional},
  72     { WM_IME_SETCONTEXT, sent|defwinproc|optional},
  73     { WM_IME_NOTIFY, sent|defwinproc|optional},
  74     { WM_SETFOCUS, sent|defwinproc|optional},
  75     { WM_NOTIFYFORMAT, sent},
  76     { WM_QUERYUISTATE, sent|optional},
  77     {0}
  78 };
  79
  80 static const struct message buddy_window_test_seq[] = {
  81     { TBM_GETBUDDY, sent|wparam, TRUE},
  82     { TBM_SETBUDDY, sent|wparam, FALSE},
  83     { WM_PAINT, sent|defwinproc},
  84     { TBM_SETBUDDY, sent|wparam, FALSE},
  85     { WM_PAINT, sent|defwinproc},
  86     { TBM_GETBUDDY, sent|wparam, TRUE},
  87     { TBM_SETBUDDY, sent|wparam, TRUE},
  88     { WM_PAINT, sent|defwinproc},
  89     { TBM_SETBUDDY, sent|wparam, TRUE},
  90     { WM_PAINT, sent|defwinproc},
  91     { TBM_GETBUDDY, sent|wparam, FALSE},
  92     { TBM_GETBUDDY, sent|wparam, TRUE},
  93     {0}
  94 };
  95
  96 static const struct message parent_buddy_window_test_seq[] = {
  97     { WM_CTLCOLORSTATIC, sent},
  98     { WM_NOTIFY, sent},
  99     { WM_CTLCOLORSTATIC, sent},
 100     { WM_NOTIFY, sent},
 101     { WM_CTLCOLORSTATIC, sent},
 102     { WM_NOTIFY, sent},
 103     { WM_CTLCOLORSTATIC, sent},
 104     { WM_NOTIFY, sent},
 105     {0}
 106 };
 107
 108 static const struct message line_size_test_seq[] = {
 109     { TBM_SETLINESIZE, sent|lparam, 0, 10},
 110     { TBM_SETLINESIZE, sent|lparam, 0, 4},
 111     { TBM_GETLINESIZE, sent},
 112     {0}
 113 };
 114
 115 static const struct message page_size_test_seq[] = {
 116     { TBM_SETPAGESIZE, sent|lparam, 0, 10},
 117     { TBM_SETPAGESIZE, sent|lparam, 0, -1},
 118     { TBM_GETPAGESIZE, sent},
 119     {0}
 120 };
 121
 122 static const struct message position_test_seq[] = {
 123     { TBM_SETPOS, sent|wparam|lparam, TRUE, -1},
 124     { WM_PAINT, sent|defwinproc},
 125     { TBM_GETPOS, sent},
 126     { TBM_SETPOS, sent|wparam|lparam, TRUE, 5},
 127     { WM_PAINT, sent|defwinproc},
 128     { TBM_GETPOS, sent},
 129     { TBM_SETPOS, sent|wparam|lparam, TRUE, 5},
 130     { TBM_SETPOS, sent|wparam|lparam, TRUE, 1000},
 131     { WM_PAINT, sent|defwinproc},
 132     { TBM_GETPOS, sent},
 133     { TBM_SETPOS, sent|wparam|lparam, FALSE, 20},
 134     { TBM_GETPOS, sent},
 135     { TBM_SETPOS, sent|wparam|lparam, TRUE, 20},
 136     { TBM_GETPOS, sent},
 137     {0}
 138 };
 139
 140 static const struct message parent_position_test_seq[] = {
 141     { WM_CTLCOLORSTATIC, sent},
 142     { WM_NOTIFY, sent},
 143     { WM_CTLCOLORSTATIC, sent},
 144     { WM_NOTIFY, sent},
 145     { WM_CTLCOLORSTATIC, sent},
 146     { WM_NOTIFY, sent},
 147     {0}
 148 };
 149
 150 static const struct message range_test_seq[] = {
 151     { TBM_SETRANGE, sent|wparam|lparam, TRUE, MAKELONG(0, 10)},
 152     { WM_PAINT, sent|defwinproc},
 153     { TBM_GETRANGEMAX, sent},
 154     { TBM_GETRANGEMIN, sent},
 155     { TBM_SETRANGE, sent|wparam|lparam, TRUE, MAKELONG(-1, 1000)},
 156     { WM_PAINT, sent|defwinproc},
 157     { TBM_GETRANGEMAX, sent},
 158     { TBM_GETRANGEMIN, sent},
 159     { TBM_SETRANGE, sent|wparam|lparam, TRUE, MAKELONG(10, 0)},
 160     { WM_PAINT, sent|defwinproc},
 161     { TBM_GETRANGEMAX, sent},
 162     { TBM_GETRANGEMIN, sent},
 163     { TBM_SETRANGE, sent|wparam|lparam, FALSE, MAKELONG(0, 10)},
 164     { TBM_GETRANGEMAX, sent},
 165     { TBM_GETRANGEMIN, sent},
 166     { TBM_SETRANGEMAX, sent|wparam|lparam, TRUE, 10},
 167     { WM_PAINT, sent|defwinproc},
 168     { TBM_GETRANGEMAX, sent},
 169     { TBM_SETRANGEMAX, sent|wparam|lparam, TRUE, -1},
 170     { WM_PAINT, sent|defwinproc},
 171     { TBM_GETRANGEMAX, sent},
 172     { TBM_SETRANGEMAX, sent|wparam|lparam, FALSE, 10},
 173     { TBM_GETRANGEMAX, sent},
 174     { TBM_SETRANGEMIN, sent|wparam|lparam, TRUE, 0},
 175     { WM_PAINT, sent|defwinproc},
 176     { TBM_GETRANGEMIN, sent},
 177     { TBM_SETRANGEMIN, sent|wparam|lparam, TRUE, 10},
 178     { WM_PAINT, sent|defwinproc},
 179     { TBM_GETRANGEMIN, sent},
 180     { TBM_SETRANGEMIN, sent|wparam|lparam, TRUE, -10},
 181     { WM_PAINT, sent|defwinproc},
 182     { TBM_GETRANGEMIN, sent},
 183     { TBM_SETRANGEMIN, sent|wparam|lparam, FALSE, 5},
 184     { TBM_GETRANGEMIN, sent},
 185     { TBM_GETRANGEMAX, sent},
 186     { TBM_GETRANGEMIN, sent},
 187     {0}
 188 };
 189
 190 static const struct message parent_range_test_seq[] = {
 191     { WM_CTLCOLORSTATIC, sent},
 192     { WM_NOTIFY, sent},
 193     { WM_CTLCOLORSTATIC, sent},
 194     { WM_NOTIFY, sent},
 195     { WM_CTLCOLORSTATIC, sent},
 196     { WM_NOTIFY, sent},
 197     { WM_CTLCOLORSTATIC, sent},
 198     { WM_NOTIFY, sent},
 199     { WM_CTLCOLORSTATIC, sent},
 200     { WM_NOTIFY, sent},
 201     { WM_CTLCOLORSTATIC, sent},
 202     { WM_NOTIFY, sent},
 203     { WM_CTLCOLORSTATIC, sent},
 204     { WM_NOTIFY, sent},
 205     { WM_CTLCOLORSTATIC, sent},
 206     { WM_NOTIFY, sent},
 207     {0}
 208 };
 209
 210 static const struct message selection_test_seq[] = {
 211     { TBM_SETSEL, sent|wparam|lparam, TRUE, MAKELONG(0, 10)},
 212     { WM_PAINT, sent|defwinproc},
 213     { TBM_GETSELEND, sent},
 214     { TBM_GETSELSTART, sent},
 215     { TBM_SETSEL, sent|wparam|lparam, TRUE, MAKELONG(5, 20)},
 216     { WM_PAINT, sent|defwinproc},
 217     { TBM_GETSELEND, sent},
 218     { TBM_GETSELSTART, sent},
 219     { TBM_SETSEL, sent|wparam|lparam, FALSE, MAKELONG(5, 10)},
 220     { TBM_GETSELEND, sent},
 221     { TBM_GETSELSTART, sent},
 222     { TBM_SETSELEND, sent|wparam|lparam, TRUE, 10},
 223     { WM_PAINT, sent|defwinproc},
 224     { TBM_GETSELEND, sent},
 225     { TBM_SETSELEND, sent|wparam|lparam, TRUE, 20},
 226     { WM_PAINT, sent|defwinproc},
 227     { TBM_GETSELEND, sent},
 228     { TBM_SETSELEND, sent|wparam|lparam, TRUE, 4},
 229     { WM_PAINT, sent|defwinproc},
 230     { TBM_GETSELEND, sent},
 231     { TBM_SETSELEND, sent|wparam|lparam, FALSE, 2},
 232     { TBM_GETSELEND, sent},
 233     { TBM_GETSELEND, sent},
 234     { TBM_SETSELSTART, sent|wparam|lparam, TRUE, 5},
 235     { WM_PAINT, sent|defwinproc},
 236     { TBM_GETSELSTART, sent},
 237     { TBM_SETSELSTART, sent|wparam|lparam, TRUE, 0},
 238     { WM_PAINT, sent|defwinproc},
 239     { TBM_GETSELSTART, sent},
 240     { TBM_SETSELSTART, sent|wparam|lparam, TRUE, 20},
 241     { WM_PAINT, sent|defwinproc},
 242     { TBM_GETSELSTART, sent},
 243     { TBM_SETSELSTART, sent|wparam|lparam, FALSE, 8},
 244     { TBM_GETSELSTART, sent},
 245     { TBM_GETSELSTART, sent},
 246     {0}
 247 };
 248
 249 static const struct message parent_selection_test_seq[] = {
 250     { WM_CTLCOLORSTATIC, sent},
 251     { WM_NOTIFY, sent},
 252     { WM_CTLCOLORSTATIC, sent},
 253     { WM_NOTIFY, sent},
 254     { WM_CTLCOLORSTATIC, sent},
 255     { WM_NOTIFY, sent},
 256     { WM_CTLCOLORSTATIC, sent},
 257     { WM_NOTIFY, sent},
 258     { WM_CTLCOLORSTATIC, sent},
 259     { WM_NOTIFY, sent},
 260     { WM_CTLCOLORSTATIC, sent},
 261     { WM_NOTIFY, sent},
 262     { WM_CTLCOLORSTATIC, sent},
 263     { WM_NOTIFY, sent},
 264     { WM_CTLCOLORSTATIC, sent},
 265     { WM_NOTIFY, sent},
 266     {0}
 267 };
 268
 269 static const struct message tic_settings_test_seq[] = {
 270     { TBM_SETTIC, sent|lparam, 0, 0},
 271     { TBM_SETTIC, sent|lparam, 0, 5},
 272     { TBM_SETTIC, sent|lparam, 0, 10},
 273     { TBM_SETTIC, sent|lparam, 0, 20},
 274     { TBM_SETRANGE, sent|wparam|lparam, TRUE, MAKELONG(0,10)},
 275     { WM_PAINT, sent|defwinproc},
 276     { TBM_SETTICFREQ, sent|wparam, 2},
 277     { WM_PAINT, sent|defwinproc},
 278     { TBM_GETNUMTICS, sent},
 279     { TBM_SETTICFREQ, sent|wparam, 5},
 280     { WM_PAINT, sent|defwinproc},
 281     { TBM_GETNUMTICS, sent},
 282     { TBM_SETTICFREQ, sent|wparam, 15},
 283     { WM_PAINT, sent|defwinproc},
 284     { TBM_GETNUMTICS, sent},
 285     { TBM_GETNUMTICS, sent},
 286     {0}
 287 };
 288
 289 static const struct message parent_tic_settings_test_seq[] = {
 290     { WM_CTLCOLORSTATIC, sent},
 291     { WM_NOTIFY, sent},
 292     { WM_CTLCOLORSTATIC, sent},
 293     { WM_NOTIFY, sent},
 294     { WM_CTLCOLORSTATIC, sent},
 295     { WM_NOTIFY, sent},
 296     { WM_CTLCOLORSTATIC, sent},
 297     { WM_NOTIFY, sent},
 298     {0}
 299 };
 300
 301 static const struct message thumb_length_test_seq[] = {
 302     { TBM_SETTHUMBLENGTH, sent|wparam|lparam, 15, 0},
 303     { WM_PAINT, sent|defwinproc},
 304     { TBM_GETTHUMBLENGTH, sent},
 305     { TBM_SETTHUMBLENGTH, sent|wparam|lparam, 20, 0},
 306     { WM_PAINT, sent|defwinproc},
 307     { TBM_GETTHUMBLENGTH, sent},
 308     { TBM_GETTHUMBLENGTH, sent},
 309     { WM_SIZE, sent},
 310     { WM_PAINT, sent|defwinproc},
 311     { TBM_GETTHUMBLENGTH, sent},
 312     { WM_SIZE, sent},
 313     { WM_PAINT, sent|defwinproc},
 314     { TBM_GETTHUMBLENGTH, sent},
 315     {0}
 316 };
 317
 318 static const struct message parent_thumb_length_test_seq[] = {
 319     { WM_CTLCOLORSTATIC, sent},
 320     { WM_NOTIFY, sent},
 321     { WM_CTLCOLORSTATIC, sent},
 322     { WM_NOTIFY, sent},
 323     { WM_CTLCOLORSTATIC, sent},
 324     { WM_NOTIFY, sent},
 325     { WM_CTLCOLORSTATIC, sent},
 326     { WM_NOTIFY, sent},
 327     {0}
 328 };
 329
 330 static const struct message tic_placement_test_seq[] = {
 331     { TBM_GETPTICS, sent},
 332     { TBM_GETTIC, sent|wparam, 0},
 333     { TBM_GETTIC, sent|wparam, 2},
 334     { TBM_GETTIC, sent|wparam, 4},
 335     { TBM_GETTICPOS, sent|wparam, 0},
 336     { TBM_GETTICPOS, sent|wparam, 2},
 337     {0}
 338 };
 339
 340 static const struct message tool_tips_test_seq[] = {
 341     { TBM_SETTIPSIDE, sent|wparam, TBTS_TOP},
 342     { TBM_SETTIPSIDE, sent|wparam, TBTS_LEFT},
 343     { TBM_SETTIPSIDE, sent|wparam, TBTS_BOTTOM},
 344     { TBM_SETTIPSIDE, sent|wparam, TBTS_RIGHT},
 345     { TBM_SETTOOLTIPS, sent},
 346     { TBM_GETTOOLTIPS, sent},
 347     { TBM_SETTOOLTIPS, sent},
 348     { TBM_GETTOOLTIPS, sent},
 349     { TBM_SETTOOLTIPS, sent},
 350     { TBM_GETTOOLTIPS, sent},
 351     { TBM_GETTOOLTIPS, sent},
 352     {0}
 353 };
 354
 355 static const struct message unicode_test_seq[] = {
 356     { TBM_SETUNICODEFORMAT, sent|wparam, TRUE},
 357     { TBM_SETUNICODEFORMAT, sent|wparam, FALSE},
 358     { TBM_GETUNICODEFORMAT, sent},
 359     {0}
 360 };
 361
 362 static const struct message ignore_selection_test_seq[] = {
 363     { TBM_SETSEL, sent|wparam|lparam, TRUE, MAKELONG(0,10)},
 364     { TBM_GETSELEND, sent},
 365     { TBM_GETSELSTART, sent},
 366     { TBM_SETSEL, sent|wparam|lparam, FALSE, MAKELONG(0,10)},
 367     { TBM_GETSELEND, sent},
 368     { TBM_GETSELSTART, sent},
 369     { TBM_SETSELEND, sent|wparam|lparam, TRUE,0},
 370     { TBM_GETSELEND, sent},
 371     { TBM_SETSELEND, sent|wparam|lparam, TRUE, 10},
 372     { TBM_GETSELEND, sent},
 373     { TBM_SETSELEND, sent|wparam|lparam, FALSE,0},
 374     { TBM_GETSELEND, sent},
 375     { TBM_SETSELSTART, sent|wparam|lparam, TRUE,0},
 376     { TBM_GETSELSTART, sent},
 377     { TBM_SETSELSTART, sent|wparam|lparam, TRUE, 10},
 378     { TBM_GETSELSTART, sent},
 379     { TBM_SETSELSTART, sent|wparam|lparam, FALSE,0},
 380     { TBM_GETSELSTART, sent},
 381     {0}
 382 };
 383
 384 static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
 385     static LONG defwndproc_counter = 0;
 386     LRESULT ret;
 387     struct message msg;
 388
 389     /* log system messages, except for painting */
 390     if (message < WM_USER &&
 391         message != WM_PAINT &&
 392         message != WM_ERASEBKGND &&
 393         message != WM_NCPAINT &&
 394         message != WM_NCHITTEST &&
 395         message != WM_GETTEXT &&
 396         message != WM_GETICON &&
 397         message != WM_DEVICECHANGE)
 398     {
 399         msg.message = message;
 400         msg.flags = sent|wparam|lparam;
 401         if (defwndproc_counter) msg.flags |= defwinproc;
 402         msg.wParam = wParam;
 403         msg.lParam = lParam;
 404         msg.id = 0;
 405         add_message(sequences, PARENT_SEQ_INDEX, &msg);
 406     }
 407
 408     defwndproc_counter++;
 409     ret = DefWindowProcA(hwnd, message, wParam, lParam);
 410     defwndproc_counter--;
 411
 412     return ret;
 413 }
 414
 415 static BOOL register_parent_wnd_class(void){
 416     WNDCLASSA cls;
 417
 418     cls.style = 0;
 419     cls.lpfnWndProc = parent_wnd_proc;
 420     cls.cbClsExtra = 0;
 421     cls.cbWndExtra = 0;
 422     cls.hInstance = GetModuleHandleA(NULL);
 423     cls.hIcon = 0;
 424     cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
 425     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
 426     cls.lpszMenuName = NULL;
 427     cls.lpszClassName = "Trackbar test parent class";
 428     return RegisterClassA(&cls);
 429 }
 430
 431 static HWND create_parent_window(void){
 432     if (!register_parent_wnd_class())
 433         return NULL;
 434
 435     return CreateWindowA("Trackbar test parent class", "Trackbar test parent window",
 436                          WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_VISIBLE,
 437                          0, 0, 100, 100, GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL);
 438 }
 439
 440 static LRESULT WINAPI trackbar_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
 441     WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 442     static LONG defwndproc_counter = 0;
 443     struct message msg = { 0 };
 444     LRESULT ret;
 445
 446     msg.message = message;
 447     msg.flags = sent|wparam|lparam;
 448     if (defwndproc_counter) msg.flags |= defwinproc;
 449     msg.wParam = wParam;
 450     msg.lParam = lParam;
 451     add_message(sequences, TRACKBAR_SEQ_INDEX, &msg);
 452
 453     defwndproc_counter++;
 454     ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
 455     defwndproc_counter--;
 456
 457     return ret;
 458 }
 459
 460 static HWND create_trackbar(DWORD style, HWND parent){
 461     HWND hWndTrack;
 462     WNDPROC oldproc;
 463     RECT rect;
 464
 465     GetClientRect(parent, &rect);
 466     hWndTrack = CreateWindowA(TRACKBAR_CLASSA, "Trackbar Control", style,
 467                               rect.right, rect.bottom, 100, 50,
 468                               parent, NULL, GetModuleHandleA(NULL), NULL);
 469
 470     if (!hWndTrack) return NULL;
 471
 472     oldproc = (WNDPROC)SetWindowLongPtrA(hWndTrack, GWLP_WNDPROC, (LONG_PTR)trackbar_subclass_proc);
 473     SetWindowLongPtrA(hWndTrack, GWLP_USERDATA, (LONG_PTR)oldproc);
 474
 475     return hWndTrack;
 476 }
 477
 478 static HWND create_trackbar2(DWORD style, HWND parent)
 479 {
 480     RECT rect;
 481     GetClientRect(parent, &rect);
 482     return CreateWindowA(TRACKBAR_CLASSA, "Trackbar Control", style,
 483                               rect.right, rect.bottom, 100, 50,
 484                               parent, NULL, GetModuleHandleA(NULL), NULL);
 485 }
 486
 487 /* test functions for setters, getters, and sequences */
 488
 489 static void test_trackbar_buddy(void)
 490 {
 491     HWND hWndLeftBuddy, hWndTrackbar;
 492     HWND hWndRightBuddy;
 493     HWND hWndCurrentBuddy;
 494     HWND rTest;
 495
 496     hWndTrackbar = create_trackbar(defaultstyle, hWndParent);
 497     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
 498
 499     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 500
 501     hWndLeftBuddy = CreateWindowA(STATUSCLASSNAMEA, NULL, 0, 0, 0, 300, 20, NULL, NULL, NULL, NULL);
 502     ok(hWndLeftBuddy != NULL, "Expected non NULL value\n");
 503
 504     if (hWndLeftBuddy != NULL){
 505         hWndCurrentBuddy = (HWND) SendMessageA(hWndTrackbar, TBM_GETBUDDY, TRUE, 0);
 506         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_SETBUDDY, FALSE, (LPARAM) hWndLeftBuddy);
 507         ok(rTest == hWndCurrentBuddy, "Expected hWndCurrentBuddy\n");
 508         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_SETBUDDY, FALSE, (LPARAM) hWndLeftBuddy);
 509         ok(rTest == hWndLeftBuddy, "Expected hWndLeftBuddy\n");
 510     } else
 511         skip ("left buddy control not present?\n");
 512
 513     hWndRightBuddy = CreateWindowA(STATUSCLASSNAMEA, NULL, 0, 0, 0, 300, 20, NULL, NULL, NULL, NULL);
 514
 515     ok(hWndRightBuddy != NULL, "expected non NULL value\n");
 516
 517     /* test TBM_SETBUDDY */
 518     if (hWndRightBuddy != NULL){
 519         hWndCurrentBuddy = (HWND) SendMessageA(hWndTrackbar, TBM_GETBUDDY, TRUE, 0);
 520         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_SETBUDDY, TRUE, (LPARAM) hWndRightBuddy);
 521         ok(rTest == hWndCurrentBuddy, "Expected hWndCurrentBuddy\n");
 522         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_SETBUDDY, TRUE, (LPARAM) hWndRightBuddy);
 523         ok(rTest == hWndRightBuddy, "Expected hWndRightbuddy\n");
 524      } else
 525        skip("Right buddy control not present?\n");
 526
 527     /* test TBM_GETBUDDY */
 528     if (hWndLeftBuddy != NULL){
 529         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_GETBUDDY, FALSE, 0);
 530         ok(rTest == hWndLeftBuddy, "Expected hWndLeftBuddy\n");
 531         DestroyWindow(hWndLeftBuddy);
 532     }
 533     if (hWndRightBuddy != NULL){
 534         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_GETBUDDY, TRUE,0);
 535         ok(rTest == hWndRightBuddy, "Expected hWndRightBuddy\n");
 536         DestroyWindow(hWndRightBuddy);
 537     }
 538
 539     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, buddy_window_test_seq, "buddy test sequence", TRUE);
 540     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_buddy_window_test_seq, "parent buddy test seq", TRUE);
 541
 542     DestroyWindow(hWndTrackbar);
 543 }
 544
 545 static void test_line_size(void)
 546 {
 547     HWND hWndTrackbar;
 548     int r;
 549
 550     hWndTrackbar = create_trackbar(defaultstyle, hWndParent);
 551     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
 552
 553     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 554
 555     /* test TBM_SETLINESIZE */
 556     r = SendMessageA(hWndTrackbar, TBM_SETLINESIZE, 0, 10);
 557     expect(1,r);
 558     r = SendMessageA(hWndTrackbar, TBM_SETLINESIZE, 0, 4);
 559     expect(10, r);
 560
 561     /* test TBM_GETLINESIZE */
 562     r = SendMessageA(hWndTrackbar, TBM_GETLINESIZE, 0,0);
 563     expect(4, r);
 564
 565     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, line_size_test_seq, "linesize test sequence", FALSE);
 566     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "parent line test sequence", FALSE);
 567
 568     DestroyWindow(hWndTrackbar);
 569 }
 570
 571
 572 static void test_page_size(void)
 573 {
 574     HWND hWndTrackbar;
 575     int r;
 576
 577     hWndTrackbar = create_trackbar(defaultstyle, hWndParent);
 578     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
 579
 580     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 581     ok(r == 20, "Unexpected page size %d.\n", r);
 582
 583     SendMessageA(hWndTrackbar, TBM_SETRANGE, 0, MAKELPARAM(0, 65));
 584
 585     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 586     ok(r == 13, "Unexpected page size %d.\n", r);
 587
 588     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, 0, 10);
 589
 590     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 591     ok(r == 11, "Unexpected page size %d.\n", r);
 592
 593     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, 0, 50);
 594
 595     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 596     ok(r == 8, "Unexpected page size %d.\n", r);
 597
 598     r = SendMessageA(hWndTrackbar, TBM_SETPAGESIZE, 0, 10);
 599     ok(r == 8, "Unexpected page size %d.\n", r);
 600
 601     SendMessageA(hWndTrackbar, TBM_SETRANGE, 0, MAKELPARAM(0, 30));
 602
 603     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 604     ok(r == 10, "Unexpected page size %d.\n", r);
 605
 606     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, 0, 5);
 607
 608     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 609     ok(r == 10, "Unexpected page size %d.\n", r);
 610
 611     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, 0, 40);
 612
 613     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 614     ok(r == 10, "Unexpected page size %d.\n", r);
 615
 616     r = SendMessageA(hWndTrackbar, TBM_SETPAGESIZE, 0, -1);
 617     ok(r == 10, "Unexpected page size %d.\n", r);
 618
 619     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 620     ok(r == 7, "Unexpected page size %d.\n", r);
 621
 622     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, 0, 100);
 623
 624     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 625     ok(r == 19, "Unexpected page size %d.\n", r);
 626
 627     DestroyWindow(hWndTrackbar);
 628
 629     hWndTrackbar = create_trackbar(defaultstyle, hWndParent);
 630     ok(hWndTrackbar != NULL, "Failed to create trackbar window.\n");
 631
 632     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 633
 634     /* test TBM_SETPAGESIZE */
 635     r = SendMessageA(hWndTrackbar, TBM_SETPAGESIZE, 0, 10);
 636     expect(20, r);
 637     r = SendMessageA(hWndTrackbar, TBM_SETPAGESIZE, 0, -1);
 638     expect(10, r);
 639
 640     /* test TBM_GETPAGESIZE */
 641     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0,0);
 642     expect(20, r);
 643
 644     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, page_size_test_seq, "page size test sequence", FALSE);
 645     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "parent page size test sequence", FALSE);
 646
 647     /* check for zero page size */
 648     r = SendMessageA(hWndTrackbar, TBM_SETPAGESIZE, 0, 0);
 649     expect(20, r);
 650     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 651     expect(0, r);
 652     /* revert to default */
 653     r = SendMessageA(hWndTrackbar, TBM_SETPAGESIZE, 0, -1);
 654     expect(0, r);
 655     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 656     expect(20, r);
 657     /* < -1 */
 658     r = SendMessageA(hWndTrackbar, TBM_SETPAGESIZE, 0, -2);
 659     expect(20, r);
 660     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 661     expect(-2, r);
 662
 663     DestroyWindow(hWndTrackbar);
 664 }
 665
 666 static void test_position(void)
 667 {
 668     HWND hWndTrackbar;
 669     RECT rect, rect2;
 670     WNDPROC oldproc;
 671     int r;
 672
 673     hWndTrackbar = create_trackbar(defaultstyle, hWndParent);
 674     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
 675
 676     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 677
 678     /* test TBM_SETPOS */
 679     SendMessageA(hWndTrackbar, TBM_SETPOS, TRUE, -1);
 680     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0, 0);
 681     expect(0, r);
 682     SendMessageA(hWndTrackbar, TBM_SETPOS, TRUE, 5);
 683     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0,0);
 684     expect(5, r);
 685     SendMessageA(hWndTrackbar, TBM_SETPOS, TRUE, 5);
 686     SendMessageA(hWndTrackbar, TBM_SETPOS, TRUE, 1000);
 687     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0,0);
 688     expect(100, r);
 689     SendMessageA(hWndTrackbar, TBM_SETPOS, FALSE, 20);
 690     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0,0);
 691     expect(20, r);
 692     SendMessageA(hWndTrackbar, TBM_SETPOS, TRUE, 20);
 693
 694     /* test TBM_GETPOS */
 695     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0,0);
 696     expect(20, r);
 697
 698     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, position_test_seq, "position test sequence", TRUE);
 699     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_position_test_seq, "parent position test sequence", TRUE);
 700
 701     DestroyWindow(hWndTrackbar);
 702
 703     hWndTrackbar = create_trackbar2(defaultstyle, hWndParent);
 704     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
 705
 706     /* subclassing procedure blocks WM_PAINT */
 707     oldproc = (WNDPROC)SetWindowLongPtrA(hWndTrackbar, GWLP_WNDPROC, (LONG_PTR)trackbar_no_wmpaint_proc);
 708     SetWindowLongPtrA(hWndTrackbar, GWLP_USERDATA, (LONG_PTR)oldproc);
 709
 710     SetRectEmpty(&rect);
 711     SetRectEmpty(&rect2);
 712
 713     SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect);
 714
 715     /* without repaint */
 716     SendMessageA(hWndTrackbar, TBM_SETPOS, FALSE, 25);
 717     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0, 0);
 718     ok(r == 25, "got %d\n", r);
 719     SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect2);
 720     ok(rect.left == rect2.left, "got %d\n", rect.left);
 721
 722     /* with repaint */
 723     SendMessageA(hWndTrackbar, TBM_SETPOS, TRUE, 30);
 724     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0, 0);
 725     ok(r == 30, "got %d\n", r);
 726     SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect2);
 727     ok(rect.left != rect2.left, "got %d, expected %d\n", rect2.left, rect.left);
 728
 729     /* now move it with keys */
 730     SendMessageA(hWndTrackbar, WM_KEYDOWN, VK_END, 0);
 731     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0, 0);
 732     ok(r == 100, "got %d\n", r);
 733     SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect);
 734     ok(rect.left != rect2.left, "got %d, expected %d\n", rect.left, rect2.left);
 735
 736     DestroyWindow(hWndTrackbar);
 737 }
 738
 739 static void test_range(void)
 740 {
 741     HWND hWndTrackbar;
 742     RECT rect1, rect2;
 743     int r;
 744
 745     hWndTrackbar = create_trackbar(defaultstyle, hWndParent);
 746     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
 747
 748     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 749
 750     /* test TBM_SETRANGE */
 751     SendMessageA(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(0, 10));
 752     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 753     expect(10, r);
 754     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 755     expect(0, r);
 756     SendMessageA(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(-1, 1000));
 757     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 758     expect(1000, r);
 759     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 760     expect(-1, r);
 761     SendMessageA(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(10, 0));
 762     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 763     expect(0, r);
 764     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 765     expect(10, r);
 766     SendMessageA(hWndTrackbar, TBM_SETRANGE, FALSE, MAKELONG(0,10));
 767     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 768     expect(10, r);
 769     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 770     expect(0, r);
 771
 772     /*test TBM_SETRANGEMAX */
 773     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, TRUE, 10);
 774     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 775     expect(10, r);
 776     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, TRUE, -1);
 777     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 778     expect(-1, r);
 779     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, FALSE, 10);
 780     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 781     expect(10, r);
 782
 783     /* testing TBM_SETRANGEMIN */
 784     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, TRUE, 0);
 785     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 786     expect(0, r);
 787     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, TRUE, 10);
 788     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 789     expect(10, r);
 790     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, TRUE, -10);
 791     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 792     expect(-10, r);
 793     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, FALSE, 5);
 794     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 795     expect(5, r);
 796
 797     /* test TBM_GETRANGEMAX */
 798     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 799     expect(10, r);
 800
 801     /* test TBM_GETRANGEMIN */
 802     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 803     expect(5, r);
 804
 805     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, range_test_seq, "range test sequence", TRUE);
 806     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_range_test_seq, "parent range test sequence", TRUE);
 807
 808     /* TBM_SETRANGE updates thumb visual position (rectangle) if needed */
 809     r = SendMessageA(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(-10, 0));
 810     ok(r == 0, "got %d\n", r);
 811     SendMessageA(hWndTrackbar, TBM_SETPOS, TRUE, 0);
 812
 813     RedrawWindow(hWndTrackbar, NULL, 0, RDW_UPDATENOW);
 814     SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect1);
 815
 816     r = SendMessageA(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(-10, 10));
 817     ok(r == 0, "got %d\n", r);
 818     RedrawWindow(hWndTrackbar, NULL, 0, RDW_UPDATENOW);
 819
 820     SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect2);
 821     ok(!EqualRect(&rect1, &rect2), "thumb rectangle not updated\n");
 822
 823     /* change range back, don't force repaint */
 824     r = SendMessageA(hWndTrackbar, TBM_SETRANGE, FALSE, MAKELONG(-10, 0));
 825     ok(r == 0, "got %d\n", r);
 826
 827     SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect1);
 828     ok(EqualRect(&rect1, &rect2), "thumb rectangle not updated\n");
 829
 830     /* test position update on range change */
 831
 832     /* set to [20, 50], position at 30, reduce range to [20,25] */
 833     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, FALSE, 20);
 834     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, FALSE, 50);
 835     SendMessageA(hWndTrackbar, TBM_SETPOS, FALSE, 30);
 836     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, FALSE, 25);
 837     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0, 0);
 838     ok(r == 25, "Unexpected position %d\n", r);
 839
 840     /* set to [20, 50], position at 30, flip max to 10 */
 841     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, FALSE, 20);
 842     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, FALSE, 50);
 843     SendMessageA(hWndTrackbar, TBM_SETPOS, FALSE, 30);
 844     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, FALSE, 10);
 845     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0, 0);
 846     ok(r == 20, "Unexpected position %d\n", r);
 847
 848     /* set to [20, 50], position at 30, flip min to 70 */
 849     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, FALSE, 20);
 850     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, FALSE, 50);
 851     SendMessageA(hWndTrackbar, TBM_SETPOS, FALSE, 30);
 852     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, FALSE, 70);
 853     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0, 0);
 854     ok(r == 70, "Unexpected position %d\n", r);
 855
 856     DestroyWindow(hWndTrackbar);
 857 }
 858
 859 static void test_selection(void)
 860 {
 861     HWND hWndTrackbar;
 862     int r;
 863
 864     hWndTrackbar = create_trackbar(defaultstyle, hWndParent);
 865     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
 866
 867     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, FALSE, 5);
 868     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, FALSE, 10);
 869
 870     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 871
 872     /* test TBM_SETSEL */
 873     SendMessageA(hWndTrackbar, TBM_SETSEL, TRUE, MAKELONG(0,10));
 874     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 875     expect(10, r);
 876     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 877     expect(5, r);
 878     SendMessageA(hWndTrackbar, TBM_SETSEL, TRUE, MAKELONG(5, 20));
 879     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 880     expect(10, r);
 881     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 882     expect(5, r);
 883     SendMessageA(hWndTrackbar, TBM_SETSEL, FALSE, MAKELONG(5, 10));
 884     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 885     expect(10, r);
 886     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 887     expect(5, r);
 888
 889     /* test TBM_SETSELEND */
 890     SendMessageA(hWndTrackbar, TBM_SETSELEND, TRUE, 10);
 891     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 892     expect(10, r);
 893     SendMessageA(hWndTrackbar, TBM_SETSELEND, TRUE, 20);
 894     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 895     expect(10, r);
 896     SendMessageA(hWndTrackbar, TBM_SETSELEND, TRUE, 4);
 897     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 898     expect(4, r);
 899     SendMessageA(hWndTrackbar, TBM_SETSELEND, FALSE, 2);
 900     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 901     expect(2, r);
 902
 903     /* test TBM_GETSELEND */
 904     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 905     expect(2, r);
 906
 907     /* testing TBM_SETSELSTART */
 908     SendMessageA(hWndTrackbar, TBM_SETSELSTART, TRUE, 5);
 909     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 910     expect(5, r);
 911     SendMessageA(hWndTrackbar, TBM_SETSELSTART, TRUE, 0);
 912     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 913     expect(5, r);
 914     SendMessageA(hWndTrackbar, TBM_SETSELSTART, TRUE, 20);
 915     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 916     expect(20, r);
 917     SendMessageA(hWndTrackbar, TBM_SETSELSTART, FALSE, 8);
 918     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 919     expect(8, r);
 920
 921     /* test TBM_GETSELSTART */
 922     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 923     expect(8, r);
 924
 925     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, selection_test_seq, "selection test sequence", TRUE);
 926     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_selection_test_seq, "parent selection test sequence", TRUE);
 927
 928     DestroyWindow(hWndTrackbar);
 929 }
 930
 931 static void test_thumb_length(void)
 932 {
 933     HWND hWndTrackbar;
 934     int r;
 935
 936     hWndTrackbar = create_trackbar(defaultstyle, hWndParent);
 937     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
 938
 939     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 940
 941     /* testing TBM_SETTHUMBLENGTH */
 942     SendMessageA(hWndTrackbar, TBM_SETTHUMBLENGTH, 15, 0);
 943     r = SendMessageA(hWndTrackbar, TBM_GETTHUMBLENGTH, 0,0);
 944     expect(15, r);
 945     SendMessageA(hWndTrackbar, TBM_SETTHUMBLENGTH, 20, 0);
 946     r = SendMessageA(hWndTrackbar, TBM_GETTHUMBLENGTH, 0,0);
 947     expect(20, r);
 948
 949     /* test TBM_GETTHUMBLENGTH */
 950     r = SendMessageA(hWndTrackbar, TBM_GETTHUMBLENGTH, 0,0);
 951     expect(20, r);
 952
 953     r = SendMessageA(hWndTrackbar, WM_SIZE, 0,0);
 954     expect(0, r);
 955     r = SendMessageA(hWndTrackbar, TBM_GETTHUMBLENGTH, 0,0);
 956     expect(20, r);
 957     r = SendMessageA(hWndTrackbar, WM_SIZE, 0, MAKELPARAM(50, 50) );
 958     expect(0, r);
 959     r = SendMessageA(hWndTrackbar, TBM_GETTHUMBLENGTH, 0,0);
 960     expect(20, r);
 961
 962     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, thumb_length_test_seq, "thumb length test sequence", TRUE);
 963     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_thumb_length_test_seq, "parent thumb length test sequence", TRUE);
 964
 965     DestroyWindow(hWndTrackbar);
 966 }
 967
 968 static void test_tic_settings(void)
 969 {
 970     HWND hWndTrackbar;
 971     int r, i;
 972
 973     hWndTrackbar = create_trackbar(defaultstyle, hWndParent);
 974     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
 975
 976     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, FALSE, 5);
 977     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, FALSE, 10);
 978
 979     /* testing TBM_SETTIC */
 980     /* Set tics at 5 and 10 */
 981     /* 0 and 20 are out of range and should not be set */
 982     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0, 0);
 983     expect(10, r);
 984     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0, 0);
 985     expect(5, r);
 986
 987     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 988     r = SendMessageA(hWndTrackbar, TBM_SETTIC, 0, 0);
 989     ok(r == FALSE, "Expected FALSE, got %d\n", r);
 990     r = SendMessageA(hWndTrackbar, TBM_SETTIC, 0, 5);
 991     ok(r == TRUE, "Expected TRUE, got %d\n", r);
 992     r = SendMessageA(hWndTrackbar, TBM_SETTIC, 0, 10);
 993     ok(r == TRUE, "Expected TRUE, got %d\n", r);
 994
 995     r = SendMessageA(hWndTrackbar, TBM_SETTIC, 0, 20);
 996     ok(r == FALSE, "Expected FALSE, got %d\n", r);
 997
 998     /* test TBM_SETTICFREQ */
 999     SendMessageA(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(0, 10));
1000     SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 2, 0);
1001     r = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
1002     expect(6, r);
1003     SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 5, 0);
1004     r = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
1005     expect(3, r);
1006     SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 15, 0);
1007     r = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
1008     expect(2, r);
1009
1010     /* test TBM_GETNUMTICS */
1011     /* since TIC FREQ is 15, there should be only 2 tics now */
1012     r = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
1013     expect(2, r);
1014
1015     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, tic_settings_test_seq, "tic settings test sequence", TRUE);
1016     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_tic_settings_test_seq, "parent tic settings test sequence", TRUE);
1017
1018     /* range [0,0], freq = 1 */
1019     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, TRUE, 0);
1020     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, TRUE, 0);
1021     SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 1, 0);
1022     r = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
1023     expect(2, r);
1024     /* range [0,1], freq = 1 */
1025     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, TRUE, 1);
1026     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, TRUE, 0);
1027     SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 1, 0);
1028     r = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
1029     expect(2, r);
1030     /* range [0,2], freq = 1 */
1031     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, TRUE, 2);
1032     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, TRUE, 0);
1033     SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 1, 0);
1034     r = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
1035     expect(3, r);
1036
1037     DestroyWindow(hWndTrackbar);
1038
1039     /* Test to show that TBM_SETTICFREQ updates thumb */
1040     for (i = 0; i < 2; i++)
1041     {
1042         DWORD style = i ? defaultstyle : defaultstyle & ~TBS_AUTOTICKS;
1043         RECT rect, rect1;
1044         WNDPROC oldproc;
1045
1046         hWndTrackbar = create_trackbar2(style, hWndParent);
1047         ok(hWndTrackbar != NULL, "Expected non NULL value\n");
1048
1049         oldproc = (WNDPROC)SetWindowLongPtrA(hWndTrackbar, GWLP_WNDPROC, (LONG_PTR)trackbar_no_wmpaint_proc);
1050         SetWindowLongPtrA(hWndTrackbar, GWLP_USERDATA, (LONG_PTR)oldproc);
1051
1052         SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect);
1053         SendMessageA(hWndTrackbar, TBM_SETPOS, FALSE, 0);
1054         SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect1);
1055         ok(EqualRect(&rect, &rect1), "Unexpected thumb rectangle %s, previous %s\n",
1056             wine_dbgstr_rect(&rect1), wine_dbgstr_rect(&rect));
1057
1058         SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect);
1059         SendMessageA(hWndTrackbar, TBM_SETRANGE, FALSE, MAKELONG(-100, 100));
1060         SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect1);
1061         ok(EqualRect(&rect, &rect1), "Unexpected thumb rectangle %s, previous %s\n",
1062             wine_dbgstr_rect(&rect1), wine_dbgstr_rect(&rect));
1063         /* Old position is also 0, but thumb position will be different after range change */
1064         SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect);
1065         SendMessageA(hWndTrackbar, TBM_SETPOS, TRUE, 0);
1066         SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect1);
1067         ok(EqualRect(&rect, &rect1), "Unexpected thumb rectangle %s, previous %s\n",
1068             wine_dbgstr_rect(&rect1), wine_dbgstr_rect(&rect));
1069         /* Previous frequency is also 1, yet thumb is updated */
1070         SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect);
1071         SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 1, 0);
1072         SendMessageA(hWndTrackbar, TBM_GETTHUMBRECT, 0, (LPARAM)&rect1);
1073         ok(!EqualRect(&rect, &rect1), "Unexpected thumb rectangle %s, previous %s\n",
1074             wine_dbgstr_rect(&rect1), wine_dbgstr_rect(&rect));
1075
1076         SetWindowLongPtrA(hWndTrackbar, GWLP_WNDPROC, (LONG_PTR)oldproc);
1077
1078         DestroyWindow(hWndTrackbar);
1079     }
1080 }
1081
1082 static void test_tic_placement(void)
1083 {
1084     HWND hWndTrackbar;
1085     int r;
1086     DWORD *rPTics;
1087     DWORD numtics;
1088
1089     hWndTrackbar = create_trackbar(defaultstyle, hWndParent);
1090     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
1091
1092     SendMessageA(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(1, 6));
1093     SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 1, 0);
1094
1095     numtics = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
1096     ok(numtics == 6, "Expected 6, got %d\n", numtics);
1097
1098     flush_sequences(sequences, NUM_MSG_SEQUENCE);
1099     /* test TBM_GETPTICS */
1100     rPTics = (DWORD *) SendMessageA(hWndTrackbar, TBM_GETPTICS, 0,0);
1101     expect(2, rPTics[0]);
1102     expect(3, rPTics[1]);
1103     expect(4, rPTics[2]);
1104     expect(5, rPTics[3]);
1105
1106     /* test TBM_GETTIC */
1107     r = SendMessageA(hWndTrackbar, TBM_GETTIC, 0,0);
1108     expect(2, r);
1109     r = SendMessageA(hWndTrackbar, TBM_GETTIC, 2,0);
1110     expect(4, r);
1111     r = SendMessageA(hWndTrackbar, TBM_GETTIC, 4,0);
1112     expect(-1, r);
1113
1114     /* test TBM_GETTICPIC */
1115     r = SendMessageA(hWndTrackbar, TBM_GETTICPOS, 0, 0);
1116     ok(r > 0, "Expected r > 0, got %d\n", r);
1117     r = SendMessageA(hWndTrackbar, TBM_GETTICPOS, 2, 0);
1118     ok(r > 0, "Expected r > 0, got %d\n", r);
1119
1120     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, tic_placement_test_seq, "get tic placement test sequence", FALSE);
1121     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "parent get tic placement test sequence", FALSE);
1122
1123     DestroyWindow(hWndTrackbar);
1124 }
1125
1126 static void test_tool_tips(void)
1127 {
1128     HWND hWndTooltip, hWndTrackbar;
1129     HWND rTest;
1130     int r;
1131
1132     hWndTrackbar = create_trackbar(defaultstyle, hWndParent);
1133     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
1134
1135     flush_sequences(sequences, NUM_MSG_SEQUENCE);
1136
1137     /* testing TBM_SETTIPSIDE */
1138     r = SendMessageA(hWndTrackbar, TBM_SETTIPSIDE, TBTS_TOP, 0);
1139     expect(TBTS_TOP, r);
1140     r = SendMessageA(hWndTrackbar, TBM_SETTIPSIDE, TBTS_LEFT, 0);
1141     expect(TBTS_TOP, r);
1142     r = SendMessageA(hWndTrackbar, TBM_SETTIPSIDE, TBTS_BOTTOM, 0);
1143     expect(TBTS_LEFT, r);
1144     r = SendMessageA(hWndTrackbar, TBM_SETTIPSIDE, TBTS_RIGHT, 0);
1145     expect(TBTS_BOTTOM, r);
1146
1147     /* testing TBM_SETTOOLTIPS */
1148     hWndTooltip = CreateWindowExA(WS_EX_TOPMOST, TOOLTIPS_CLASSA, NULL, 0,
1149                                   CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
1150                                   NULL, NULL, NULL, NULL);
1151
1152     ok(hWndTooltip != NULL, "Expected non NULL value\n");
1153     if (hWndTooltip != NULL){
1154         SendMessageA(hWndTrackbar, TBM_SETTOOLTIPS, (LPARAM) hWndTooltip, 0);
1155         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_GETTOOLTIPS, 0,0);
1156         ok(rTest == hWndTooltip, "Expected hWndToolTip, got\n");
1157         SendMessageA(hWndTrackbar, TBM_SETTOOLTIPS, 0, 0);
1158         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_GETTOOLTIPS, 0,0);
1159         ok(rTest == NULL, "Expected NULL\n");
1160         SendMessageA(hWndTrackbar, TBM_SETTOOLTIPS, (LPARAM) hWndTooltip, 5);
1161         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_GETTOOLTIPS, 0,0);
1162         ok(rTest == hWndTooltip, "Expected hWndTooltip, got\n");
1163     } else
1164         skip("tool tip control not present?\n");
1165
1166     /* test TBM_GETTOOLTIPS */
1167     rTest = (HWND) SendMessageA(hWndTrackbar, TBM_GETTOOLTIPS, 0,0);
1168     ok(rTest == hWndTooltip, "Expected hWndTooltip\n");
1169
1170     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, tool_tips_test_seq, "tool tips test sequence", FALSE);
1171     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "parent tool tips test sequence", FALSE);
1172
1173     DestroyWindow(hWndTrackbar);
1174 }
1175
1176
1177 static void test_unicode(void)
1178 {
1179     HWND hWndTrackbar;
1180     int r;
1181
1182     hWndTrackbar = create_trackbar(defaultstyle, hWndParent);
1183     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
1184
1185     flush_sequences(sequences, NUM_MSG_SEQUENCE);
1186
1187     /* testing TBM_SETUNICODEFORMAT */
1188     r = SendMessageA(hWndTrackbar, TBM_SETUNICODEFORMAT, TRUE, 0);
1189     ok(r == FALSE, "Expected FALSE, got %d\n",r);
1190     r = SendMessageA(hWndTrackbar, TBM_SETUNICODEFORMAT, FALSE, 0);
1191     ok(r == TRUE, "Expected TRUE, got %d\n",r);
1192
1193     /* test TBM_GETUNICODEFORMAT */
1194     r = SendMessageA(hWndTrackbar, TBM_GETUNICODEFORMAT, 0,0);
1195     ok(r == FALSE, "Expected FALSE, got %d\n",r);
1196
1197     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, unicode_test_seq, "unicode test sequence", FALSE);
1198     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "parent unicode test sequence", FALSE);
1199
1200     DestroyWindow(hWndTrackbar);
1201 }
1202
1203 static void test_ignore_selection(void)
1204 {
1205     HWND hWndTrackbar;
1206     int r;
1207
1208     hWndTrackbar = create_trackbar(0, hWndParent);
1209     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
1210
1211     flush_sequences(sequences, NUM_MSG_SEQUENCE);
1212     /* test TBM_SETSEL  ensure that it is ignored */
1213     SendMessageA(hWndTrackbar, TBM_SETSEL, TRUE, MAKELONG(0,10));
1214     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
1215     expect(0, r);
1216     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
1217     expect(0, r);
1218     SendMessageA(hWndTrackbar, TBM_SETSEL, FALSE, MAKELONG(0,10));
1219     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
1220     expect(0, r);
1221     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
1222     expect(0, r);
1223
1224     /* test TBM_SETSELEND, ensure that it is ignored */
1225     SendMessageA(hWndTrackbar, TBM_SETSELEND, TRUE, 0);
1226     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
1227     expect(0, r);
1228     SendMessageA(hWndTrackbar, TBM_SETSELEND, TRUE, 10);
1229     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
1230     expect(0,r);
1231     SendMessageA(hWndTrackbar, TBM_SETSELEND, FALSE, 0);
1232     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
1233     expect(0, r);
1234
1235     /* test TBM_SETSELSTART, ensure that it is ignored */
1236     SendMessageA(hWndTrackbar, TBM_SETSELSTART, TRUE, 0);
1237     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
1238     expect(0, r);
1239     SendMessageA(hWndTrackbar, TBM_SETSELSTART, TRUE, 10);
1240     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
1241     expect(0,r);
1242     SendMessageA(hWndTrackbar, TBM_SETSELSTART, FALSE, 0);
1243     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
1244     expect(0, r);
1245
1246     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, ignore_selection_test_seq, "ignore selection setting test sequence", FALSE);
1247     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "parent ignore selection setting test sequence", FALSE);
1248
1249     DestroyWindow(hWndTrackbar);
1250 }
1251
1252 static void test_initial_state(void)
1253 {
1254     HWND hWnd;
1255     int ret;
1256
1257     hWnd = create_trackbar(0, hWndParent);
1258
1259     ret = SendMessageA(hWnd, TBM_GETNUMTICS, 0, 0);
1260     expect(2, ret);
1261     ret = SendMessageA(hWnd, TBM_GETTIC, 0, 0);
1262     expect(-1, ret);
1263     ret = SendMessageA(hWnd, TBM_GETTICPOS, 0, 0);
1264     expect(-1, ret);
1265     ret = SendMessageA(hWnd, TBM_GETRANGEMIN, 0, 0);
1266     expect(0, ret);
1267     ret = SendMessageA(hWnd, TBM_GETRANGEMAX, 0, 0);
1268     expect(100, ret);
1269
1270     ret = SendMessageA(hWnd, TBM_SETRANGEMAX, TRUE, 200);
1271     expect(0, ret);
1272
1273     ret = SendMessageA(hWnd, TBM_GETNUMTICS, 0, 0);
1274     expect(2, ret);
1275
1276     ret = SendMessageA(hWnd, TBM_SETRANGEMIN, TRUE, 10);
1277     expect(0, ret);
1278
1279     ret = SendMessageA(hWnd, TBM_GETNUMTICS, 0, 0);
1280     expect(2, ret);
1281
1282     DestroyWindow(hWnd);
1283 }
1284
1285 static void test_TBS_AUTOTICKS(void)
1286 {
1287     HWND hWnd;
1288     int ret;
1289
1290     hWnd = create_trackbar(TBS_AUTOTICKS, hWndParent);
1291
1292     ret = SendMessageA(hWnd, TBM_GETNUMTICS, 0, 0);
1293     expect(2, ret);
1294     ret = SendMessageA(hWnd, TBM_GETTIC, 0, 0);
1295     expect(-1, ret);
1296     ret = SendMessageA(hWnd, TBM_GETTICPOS, 0, 0);
1297     expect(-1, ret);
1298     ret = SendMessageA(hWnd, TBM_GETRANGEMIN, 0, 0);
1299     expect(0, ret);
1300     ret = SendMessageA(hWnd, TBM_GETRANGEMAX, 0, 0);
1301     expect(100, ret);
1302
1303     /* TBM_SETRANGEMAX rebuilds tics */
1304     ret = SendMessageA(hWnd, TBM_SETRANGEMAX, TRUE, 200);
1305     expect(0, ret);
1306     ret = SendMessageA(hWnd, TBM_GETNUMTICS, 0, 0);
1307     expect(201, ret);
1308
1309     /* TBM_SETRANGEMIN rebuilds tics */
1310     ret = SendMessageA(hWnd, TBM_SETRANGEMAX, TRUE, 100);
1311     expect(0, ret);
1312     ret = SendMessageA(hWnd, TBM_SETRANGEMIN, TRUE, 10);
1313     expect(0, ret);
1314     ret = SendMessageA(hWnd, TBM_GETNUMTICS, 0, 0);
1315     expect(91, ret);
1316
1317     ret = SendMessageA(hWnd, TBM_SETRANGEMIN, TRUE, 0);
1318     expect(0, ret);
1319
1320     /* TBM_SETRANGE rebuilds tics */
1321     ret = SendMessageA(hWnd, TBM_SETRANGE, TRUE, MAKELONG(10, 200));
1322     expect(0, ret);
1323     ret = SendMessageA(hWnd, TBM_GETNUMTICS, 0, 0);
1324     expect(191, ret);
1325
1326     DestroyWindow(hWnd);
1327 }
1328
1329 static void test_create(void)
1330 {
1331     HWND hWndTrackbar;
1332
1333     flush_sequences(sequences, NUM_MSG_SEQUENCE);
1334
1335     hWndTrackbar = create_trackbar(defaultstyle, hWndParent);
1336     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
1337     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, empty_seq, "create Trackbar Window", FALSE);
1338     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_create_trackbar_wnd_seq, "parent trackbar window", TRUE);
1339
1340     DestroyWindow(hWndTrackbar);
1341
1342     /* no style bits */
1343     flush_sequences(sequences, NUM_MSG_SEQUENCE);
1344     hWndTrackbar = create_trackbar(0, hWndParent);
1345     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
1346     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_new_window_test_seq, "new trackbar window test sequence", TRUE);
1347     DestroyWindow(hWndTrackbar);
1348 }
1349
1350 START_TEST(trackbar)
1351 {
1352     ULONG_PTR cookie;
1353     HANDLE ctxt;
1354
1355     LoadLibraryA("comctl32.dll");
1356
1357     init_msg_sequences(sequences, NUM_MSG_SEQUENCE);
1358
1359     /* create parent window */
1360     hWndParent = create_parent_window();
1361     ok(hWndParent != NULL, "Failed to create parent Window!\n");
1362
1363     if(!hWndParent){
1364         skip("parent window not present\n");
1365         return;
1366     }
1367
1368     test_create();
1369     test_trackbar_buddy();
1370     test_line_size();
1371     test_page_size();
1372     test_position();
1373     test_range();
1374     test_selection();
1375     test_thumb_length();
1376     test_tic_settings();
1377     test_tic_placement();
1378     test_tool_tips();
1379     test_unicode();
1380     test_TBS_AUTOTICKS();
1381     test_ignore_selection();
1382     test_initial_state();
1383
1384     if (!load_v6_module(&cookie, &ctxt))
1385         return;
1386
1387     test_trackbar_buddy();
1388     test_line_size();
1389     test_page_size();
1390     test_position();
1391     test_range();
1392     test_selection();
1393     test_thumb_length();
1394     test_tic_settings();
1395     test_tic_placement();
1396     test_tool_tips();
1397     test_unicode();
1398     test_TBS_AUTOTICKS();
1399     test_ignore_selection();
1400     test_initial_state();
1401
1402     unload_v6_module(cookie, ctxt);
1403
1404     DestroyWindow(hWndParent);
1405 }