dlls/comctl32/tests/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
  27 #define expect(expected, got) ok(got == expected, "Expected %d, got %d\n", expected, got)
  28 #define NUM_MSG_SEQUENCE 2
  29 #define PARENT_SEQ_INDEX 0
  30 #define TRACKBAR_SEQ_INDEX 1
  31
  32 static HWND hWndParent;
  33
  34 static struct msg_sequence *sequences[NUM_MSG_SEQUENCE];
  35
  36 static const struct message empty_seq[] = {
  37     {0}
  38 };
  39
  40 static const struct message parent_create_trackbar_wnd_seq[] = {
  41     { WM_NOTIFYFORMAT, sent},
  42     { WM_QUERYUISTATE, sent|optional},
  43     { WM_WINDOWPOSCHANGING, sent},
  44     { WM_NCACTIVATE, sent},
  45     { PBT_APMRESUMECRITICAL, sent},
  46     { WM_WINDOWPOSCHANGING, sent},
  47     { PBT_APMRESUMESTANDBY, sent},
  48     { WM_IME_SETCONTEXT, sent|optional},
  49     { WM_IME_NOTIFY, sent|optional},
  50     { WM_CTLCOLORSTATIC, sent},
  51     { WM_NOTIFY, sent},
  52     {0}
  53 };
  54
  55 static const struct message parent_new_window_test_seq[] = {
  56     { WM_QUERYNEWPALETTE, sent|optional },
  57     { WM_WINDOWPOSCHANGING, sent|optional},
  58     { WM_NCACTIVATE, sent|optional},
  59     { PBT_APMRESUMECRITICAL, sent|optional},
  60     { WM_IME_SETCONTEXT, sent|defwinproc|optional},
  61     { WM_IME_NOTIFY, sent|defwinproc|optional},
  62     { WM_SETFOCUS, sent|defwinproc|optional},
  63     { WM_NOTIFYFORMAT, sent},
  64     { WM_QUERYUISTATE, sent|optional},
  65     {0}
  66 };
  67
  68 static const struct message buddy_window_test_seq[] = {
  69     { TBM_GETBUDDY, sent|wparam, TRUE},
  70     { TBM_SETBUDDY, sent|wparam, FALSE},
  71     { WM_PAINT, sent|defwinproc},
  72     { TBM_SETBUDDY, sent|wparam, FALSE},
  73     { WM_PAINT, sent|defwinproc},
  74     { TBM_GETBUDDY, sent|wparam, TRUE},
  75     { TBM_SETBUDDY, sent|wparam, TRUE},
  76     { WM_PAINT, sent|defwinproc},
  77     { TBM_SETBUDDY, sent|wparam, TRUE},
  78     { WM_PAINT, sent|defwinproc},
  79     { TBM_GETBUDDY, sent|wparam, FALSE},
  80     { TBM_GETBUDDY, sent|wparam, TRUE},
  81     {0}
  82 };
  83
  84 static const struct message parent_buddy_window_test_seq[] = {
  85     { WM_CTLCOLORSTATIC, sent},
  86     { WM_NOTIFY, sent},
  87     { WM_CTLCOLORSTATIC, sent},
  88     { WM_NOTIFY, sent},
  89     { WM_CTLCOLORSTATIC, sent},
  90     { WM_NOTIFY, sent},
  91     { WM_CTLCOLORSTATIC, sent},
  92     { WM_NOTIFY, sent},
  93     {0}
  94 };
  95
  96 static const struct message line_size_test_seq[] = {
  97     { TBM_SETLINESIZE, sent|lparam, 0, 10},
  98     { TBM_SETLINESIZE, sent|lparam, 0, 4},
  99     { TBM_GETLINESIZE, sent},
 100     {0}
 101 };
 102
 103 static const struct message page_size_test_seq[] = {
 104     { TBM_SETPAGESIZE, sent|lparam, 0, 10},
 105     { TBM_SETPAGESIZE, sent|lparam, 0, -1},
 106     { TBM_GETPAGESIZE, sent},
 107     {0}
 108 };
 109
 110 static const struct message position_test_seq[] = {
 111     { TBM_SETPOS, sent|wparam|lparam, TRUE, -1},
 112     { WM_PAINT, sent|defwinproc},
 113     { TBM_GETPOS, sent},
 114     { TBM_SETPOS, sent|wparam|lparam, TRUE, 5},
 115     { WM_PAINT, sent|defwinproc},
 116     { TBM_GETPOS, sent},
 117     { TBM_SETPOS, sent|wparam|lparam, TRUE, 5},
 118     { TBM_SETPOS, sent|wparam|lparam, TRUE, 1000},
 119     { WM_PAINT, sent|defwinproc},
 120     { TBM_GETPOS, sent},
 121     { TBM_SETPOS, sent|wparam|lparam, FALSE, 20},
 122     { TBM_GETPOS, sent},
 123     { TBM_SETPOS, sent|wparam|lparam, TRUE, 20},
 124     { TBM_GETPOS, sent},
 125     {0}
 126 };
 127
 128 static const struct message parent_position_test_seq[] = {
 129     { WM_CTLCOLORSTATIC, sent},
 130     { WM_NOTIFY, sent},
 131     { WM_CTLCOLORSTATIC, sent},
 132     { WM_NOTIFY, sent},
 133     { WM_CTLCOLORSTATIC, sent},
 134     { WM_NOTIFY, sent},
 135     {0}
 136 };
 137
 138 static const struct message range_test_seq[] = {
 139     { TBM_SETRANGE, sent|wparam|lparam, TRUE, MAKELONG(0, 10)},
 140     { WM_PAINT, sent|defwinproc},
 141     { TBM_GETRANGEMAX, sent},
 142     { TBM_GETRANGEMIN, sent},
 143     { TBM_SETRANGE, sent|wparam|lparam, TRUE, MAKELONG(-1, 1000)},
 144     { WM_PAINT, sent|defwinproc},
 145     { TBM_GETRANGEMAX, sent},
 146     { TBM_GETRANGEMIN, sent},
 147     { TBM_SETRANGE, sent|wparam|lparam, TRUE, MAKELONG(10, 0)},
 148     { WM_PAINT, sent|defwinproc},
 149     { TBM_GETRANGEMAX, sent},
 150     { TBM_GETRANGEMIN, sent},
 151     { TBM_SETRANGE, sent|wparam|lparam, FALSE, MAKELONG(0, 10)},
 152     { TBM_GETRANGEMAX, sent},
 153     { TBM_GETRANGEMIN, sent},
 154     { TBM_SETRANGEMAX, sent|wparam|lparam, TRUE, 10},
 155     { WM_PAINT, sent|defwinproc},
 156     { TBM_GETRANGEMAX, sent},
 157     { TBM_SETRANGEMAX, sent|wparam|lparam, TRUE, -1},
 158     { WM_PAINT, sent|defwinproc},
 159     { TBM_GETRANGEMAX, sent},
 160     { TBM_SETRANGEMAX, sent|wparam|lparam, FALSE, 10},
 161     { TBM_GETRANGEMAX, sent},
 162     { TBM_SETRANGEMIN, sent|wparam|lparam, TRUE, 0},
 163     { WM_PAINT, sent|defwinproc},
 164     { TBM_GETRANGEMIN, sent},
 165     { TBM_SETRANGEMIN, sent|wparam|lparam, TRUE, 10},
 166     { WM_PAINT, sent|defwinproc},
 167     { TBM_GETRANGEMIN, sent},
 168     { TBM_SETRANGEMIN, sent|wparam|lparam, TRUE, -10},
 169     { WM_PAINT, sent|defwinproc},
 170     { TBM_GETRANGEMIN, sent},
 171     { TBM_SETRANGEMIN, sent|wparam|lparam, FALSE, 5},
 172     { TBM_GETRANGEMIN, sent},
 173     { TBM_GETRANGEMAX, sent},
 174     { TBM_GETRANGEMIN, sent},
 175     {0}
 176 };
 177
 178 static const struct message parent_range_test_seq[] = {
 179     { WM_CTLCOLORSTATIC, sent},
 180     { WM_NOTIFY, sent},
 181     { WM_CTLCOLORSTATIC, sent},
 182     { WM_NOTIFY, sent},
 183     { WM_CTLCOLORSTATIC, sent},
 184     { WM_NOTIFY, sent},
 185     { WM_CTLCOLORSTATIC, sent},
 186     { WM_NOTIFY, sent},
 187     { WM_CTLCOLORSTATIC, sent},
 188     { WM_NOTIFY, sent},
 189     { WM_CTLCOLORSTATIC, sent},
 190     { WM_NOTIFY, sent},
 191     { WM_CTLCOLORSTATIC, sent},
 192     { WM_NOTIFY, sent},
 193     { WM_CTLCOLORSTATIC, sent},
 194     { WM_NOTIFY, sent},
 195     {0}
 196 };
 197
 198 static const struct message selection_test_seq[] = {
 199     { TBM_SETSEL, sent|wparam|lparam, TRUE, MAKELONG(0, 10)},
 200     { WM_PAINT, sent|defwinproc},
 201     { TBM_GETSELEND, sent},
 202     { TBM_GETSELSTART, sent},
 203     { TBM_SETSEL, sent|wparam|lparam, TRUE, MAKELONG(5, 20)},
 204     { WM_PAINT, sent|defwinproc},
 205     { TBM_GETSELEND, sent},
 206     { TBM_GETSELSTART, sent},
 207     { TBM_SETSEL, sent|wparam|lparam, FALSE, MAKELONG(5, 10)},
 208     { TBM_GETSELEND, sent},
 209     { TBM_GETSELSTART, sent},
 210     { TBM_SETSELEND, sent|wparam|lparam, TRUE, 10},
 211     { WM_PAINT, sent|defwinproc},
 212     { TBM_GETSELEND, sent},
 213     { TBM_SETSELEND, sent|wparam|lparam, TRUE, 20},
 214     { WM_PAINT, sent|defwinproc},
 215     { TBM_GETSELEND, sent},
 216     { TBM_SETSELEND, sent|wparam|lparam, TRUE, 4},
 217     { WM_PAINT, sent|defwinproc},
 218     { TBM_GETSELEND, sent},
 219     { TBM_SETSELEND, sent|wparam|lparam, FALSE, 2},
 220     { TBM_GETSELEND, sent},
 221     { TBM_GETSELEND, sent},
 222     { TBM_SETSELSTART, sent|wparam|lparam, TRUE, 5},
 223     { WM_PAINT, sent|defwinproc},
 224     { TBM_GETSELSTART, sent},
 225     { TBM_SETSELSTART, sent|wparam|lparam, TRUE, 0},
 226     { WM_PAINT, sent|defwinproc},
 227     { TBM_GETSELSTART, sent},
 228     { TBM_SETSELSTART, sent|wparam|lparam, TRUE, 20},
 229     { WM_PAINT, sent|defwinproc},
 230     { TBM_GETSELSTART, sent},
 231     { TBM_SETSELSTART, sent|wparam|lparam, FALSE, 8},
 232     { TBM_GETSELSTART, sent},
 233     { TBM_GETSELSTART, sent},
 234     {0}
 235 };
 236
 237 static const struct message parent_selection_test_seq[] = {
 238     { WM_CTLCOLORSTATIC, sent},
 239     { WM_NOTIFY, sent},
 240     { WM_CTLCOLORSTATIC, sent},
 241     { WM_NOTIFY, sent},
 242     { WM_CTLCOLORSTATIC, sent},
 243     { WM_NOTIFY, sent},
 244     { WM_CTLCOLORSTATIC, sent},
 245     { WM_NOTIFY, sent},
 246     { WM_CTLCOLORSTATIC, sent},
 247     { WM_NOTIFY, sent},
 248     { WM_CTLCOLORSTATIC, sent},
 249     { WM_NOTIFY, sent},
 250     { WM_CTLCOLORSTATIC, sent},
 251     { WM_NOTIFY, sent},
 252     { WM_CTLCOLORSTATIC, sent},
 253     { WM_NOTIFY, sent},
 254     {0}
 255 };
 256
 257 static const struct message tic_settings_test_seq[] = {
 258     { TBM_SETTIC, sent|lparam, 0, 0},
 259     { TBM_SETTIC, sent|lparam, 0, 5},
 260     { TBM_SETTIC, sent|lparam, 0, 10},
 261     { TBM_SETTIC, sent|lparam, 0, 20},
 262     { TBM_SETRANGE, sent|wparam|lparam, TRUE, MAKELONG(0,10)},
 263     { WM_PAINT, sent|defwinproc},
 264     { TBM_SETTICFREQ, sent|wparam, 2},
 265     { WM_PAINT, sent|defwinproc},
 266     { TBM_GETNUMTICS, sent},
 267     { TBM_SETTICFREQ, sent|wparam, 5},
 268     { WM_PAINT, sent|defwinproc},
 269     { TBM_GETNUMTICS, sent},
 270     { TBM_SETTICFREQ, sent|wparam, 15},
 271     { WM_PAINT, sent|defwinproc},
 272     { TBM_GETNUMTICS, sent},
 273     { TBM_GETNUMTICS, sent},
 274     {0}
 275 };
 276
 277 static const struct message parent_tic_settings_test_seq[] = {
 278     { WM_CTLCOLORSTATIC, sent},
 279     { WM_NOTIFY, sent},
 280     { WM_CTLCOLORSTATIC, sent},
 281     { WM_NOTIFY, sent},
 282     { WM_CTLCOLORSTATIC, sent},
 283     { WM_NOTIFY, sent},
 284     { WM_CTLCOLORSTATIC, sent},
 285     { WM_NOTIFY, sent},
 286     {0}
 287 };
 288
 289 static const struct message thumb_length_test_seq[] = {
 290     { TBM_SETTHUMBLENGTH, sent|wparam|lparam, 15, 0},
 291     { WM_PAINT, sent|defwinproc},
 292     { TBM_GETTHUMBLENGTH, sent},
 293     { TBM_SETTHUMBLENGTH, sent|wparam|lparam, 20, 0},
 294     { WM_PAINT, sent|defwinproc},
 295     { TBM_GETTHUMBLENGTH, sent},
 296     { TBM_GETTHUMBLENGTH, sent},
 297     { WM_SIZE, sent},
 298     { WM_PAINT, sent|defwinproc},
 299     { TBM_GETTHUMBLENGTH, sent},
 300     { WM_SIZE, sent},
 301     { WM_PAINT, sent|defwinproc},
 302     { TBM_GETTHUMBLENGTH, sent},
 303     {0}
 304 };
 305
 306 static const struct message parent_thumb_length_test_seq[] = {
 307     { WM_CTLCOLORSTATIC, sent},
 308     { WM_NOTIFY, sent},
 309     { WM_CTLCOLORSTATIC, sent},
 310     { WM_NOTIFY, sent},
 311     { WM_CTLCOLORSTATIC, sent},
 312     { WM_NOTIFY, sent},
 313     { WM_CTLCOLORSTATIC, sent},
 314     { WM_NOTIFY, sent},
 315     {0}
 316 };
 317
 318 static const struct message tic_placement_test_seq[] = {
 319     { TBM_GETPTICS, sent},
 320     { TBM_GETTIC, sent|wparam, 0},
 321     { TBM_GETTIC, sent|wparam, 2},
 322     { TBM_GETTIC, sent|wparam, 4},
 323     { TBM_GETTICPOS, sent|wparam, 0},
 324     { TBM_GETTICPOS, sent|wparam, 2},
 325     {0}
 326 };
 327
 328 static const struct message tool_tips_test_seq[] = {
 329     { TBM_SETTIPSIDE, sent|wparam, TBTS_TOP},
 330     { TBM_SETTIPSIDE, sent|wparam, TBTS_LEFT},
 331     { TBM_SETTIPSIDE, sent|wparam, TBTS_BOTTOM},
 332     { TBM_SETTIPSIDE, sent|wparam, TBTS_RIGHT},
 333     { TBM_SETTOOLTIPS, sent},
 334     { TBM_GETTOOLTIPS, sent},
 335     { TBM_SETTOOLTIPS, sent},
 336     { TBM_GETTOOLTIPS, sent},
 337     { TBM_SETTOOLTIPS, sent},
 338     { TBM_GETTOOLTIPS, sent},
 339     { TBM_GETTOOLTIPS, sent},
 340     {0}
 341 };
 342
 343 static const struct message unicode_test_seq[] = {
 344     { TBM_SETUNICODEFORMAT, sent|wparam, TRUE},
 345     { TBM_SETUNICODEFORMAT, sent|wparam, FALSE},
 346     { TBM_GETUNICODEFORMAT, sent},
 347     {0}
 348 };
 349
 350 static const struct message ignore_selection_test_seq[] = {
 351     { TBM_SETSEL, sent|wparam|lparam, TRUE, MAKELONG(0,10)},
 352     { TBM_GETSELEND, sent},
 353     { TBM_GETSELSTART, sent},
 354     { TBM_SETSEL, sent|wparam|lparam, FALSE, MAKELONG(0,10)},
 355     { TBM_GETSELEND, sent},
 356     { TBM_GETSELSTART, sent},
 357     { TBM_SETSELEND, sent|wparam|lparam, TRUE,0},
 358     { TBM_GETSELEND, sent},
 359     { TBM_SETSELEND, sent|wparam|lparam, TRUE, 10},
 360     { TBM_GETSELEND, sent},
 361     { TBM_SETSELEND, sent|wparam|lparam, FALSE,0},
 362     { TBM_GETSELEND, sent},
 363     { TBM_SETSELSTART, sent|wparam|lparam, TRUE,0},
 364     { TBM_GETSELSTART, sent},
 365     { TBM_SETSELSTART, sent|wparam|lparam, TRUE, 10},
 366     { TBM_GETSELSTART, sent},
 367     { TBM_SETSELSTART, sent|wparam|lparam, FALSE,0},
 368     { TBM_GETSELSTART, sent},
 369     {0}
 370 };
 371
 372 static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
 373     static LONG defwndproc_counter = 0;
 374     LRESULT ret;
 375     struct message msg;
 376
 377     /* log system messages, except for painting */
 378     if (message < WM_USER &&
 379         message != WM_PAINT &&
 380         message != WM_ERASEBKGND &&
 381         message != WM_NCPAINT &&
 382         message != WM_NCHITTEST &&
 383         message != WM_GETTEXT &&
 384         message != WM_GETICON &&
 385         message != WM_DEVICECHANGE)
 386     {
 387         trace("parent: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 388
 389         msg.message = message;
 390         msg.flags = sent|wparam|lparam;
 391         if (defwndproc_counter) msg.flags |= defwinproc;
 392         msg.wParam = wParam;
 393         msg.lParam = lParam;
 394         msg.id = 0;
 395         add_message(sequences, PARENT_SEQ_INDEX, &msg);
 396     }
 397
 398     defwndproc_counter++;
 399     ret = DefWindowProcA(hwnd, message, wParam, lParam);
 400     defwndproc_counter--;
 401
 402     return ret;
 403 }
 404
 405 static BOOL register_parent_wnd_class(void){
 406     WNDCLASSA cls;
 407
 408     cls.style = 0;
 409     cls.lpfnWndProc = parent_wnd_proc;
 410     cls.cbClsExtra = 0;
 411     cls.cbWndExtra = 0;
 412     cls.hInstance = GetModuleHandleA(NULL);
 413     cls.hIcon = 0;
 414     cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
 415     cls.hbrBackground = GetStockObject(WHITE_BRUSH);
 416     cls.lpszMenuName = NULL;
 417     cls.lpszClassName = "Trackbar test parent class";
 418     return RegisterClassA(&cls);
 419 }
 420
 421 static HWND create_parent_window(void){
 422     if (!register_parent_wnd_class())
 423         return NULL;
 424
 425     return CreateWindowA("Trackbar test parent class", "Trackbar test parent window",
 426                          WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_VISIBLE,
 427                          0, 0, 100, 100, GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL);
 428 }
 429
 430 static LRESULT WINAPI trackbar_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
 431     WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 432     static LONG defwndproc_counter = 0;
 433     LRESULT ret;
 434     struct message msg;
 435
 436     trace("trackbar: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
 437
 438     msg.message = message;
 439     msg.flags = sent|wparam|lparam;
 440     if (defwndproc_counter) msg.flags |= defwinproc;
 441     msg.wParam = wParam;
 442     msg.lParam = lParam;
 443     msg.id = 0;
 444     add_message(sequences, TRACKBAR_SEQ_INDEX, &msg);
 445
 446     defwndproc_counter++;
 447     ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
 448     defwndproc_counter--;
 449
 450     return ret;
 451 }
 452
 453 static HWND create_trackbar(DWORD style, HWND parent){
 454     HWND hWndTrack;
 455     WNDPROC oldproc;
 456     RECT rect;
 457
 458     GetClientRect(parent, &rect);
 459     hWndTrack = CreateWindowA(TRACKBAR_CLASSA, "Trackbar Control", style,
 460                               rect.right, rect.bottom, 100, 50,
 461                               parent, NULL, GetModuleHandleA(NULL), NULL);
 462
 463     if (!hWndTrack) return NULL;
 464
 465     oldproc = (WNDPROC)SetWindowLongPtrA(hWndTrack, GWLP_WNDPROC, (LONG_PTR)trackbar_subclass_proc);
 466     SetWindowLongPtrA(hWndTrack, GWLP_USERDATA, (LONG_PTR)oldproc);
 467
 468     return hWndTrack;
 469 }
 470
 471 /* test functions for setters, getters, and sequences */
 472
 473 static void test_trackbar_buddy(HWND hWndTrackbar){
 474     HWND hWndLeftBuddy;
 475     HWND hWndRightBuddy;
 476     HWND hWndCurrentBuddy;
 477     HWND rTest;
 478
 479     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 480
 481     hWndLeftBuddy = CreateWindowA(STATUSCLASSNAMEA, NULL, 0, 0, 0, 300, 20, NULL, NULL, NULL, NULL);
 482     ok(hWndLeftBuddy != NULL, "Expected non NULL value\n");
 483
 484     if (hWndLeftBuddy != NULL){
 485         hWndCurrentBuddy = (HWND) SendMessageA(hWndTrackbar, TBM_GETBUDDY, TRUE, 0);
 486         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_SETBUDDY, FALSE, (LPARAM) hWndLeftBuddy);
 487         ok(rTest == hWndCurrentBuddy, "Expected hWndCurrentBuddy\n");
 488         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_SETBUDDY, FALSE, (LPARAM) hWndLeftBuddy);
 489         ok(rTest == hWndLeftBuddy, "Expected hWndLeftBuddy\n");
 490     } else
 491         skip ("left buddy control not present?\n");
 492
 493     hWndRightBuddy = CreateWindowA(STATUSCLASSNAMEA, NULL, 0, 0, 0, 300, 20, NULL, NULL, NULL, NULL);
 494
 495     ok(hWndRightBuddy != NULL, "expected non NULL value\n");
 496
 497     /* test TBM_SETBUDDY */
 498     if (hWndRightBuddy != NULL){
 499         hWndCurrentBuddy = (HWND) SendMessageA(hWndTrackbar, TBM_GETBUDDY, TRUE, 0);
 500         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_SETBUDDY, TRUE, (LPARAM) hWndRightBuddy);
 501         ok(rTest == hWndCurrentBuddy, "Expected hWndCurrentBuddy\n");
 502         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_SETBUDDY, TRUE, (LPARAM) hWndRightBuddy);
 503         ok(rTest == hWndRightBuddy, "Expected hWndRightbuddy\n");
 504      } else
 505        skip("Right buddy control not present?\n");
 506
 507     /* test TBM_GETBUDDY */
 508     if (hWndLeftBuddy != NULL){
 509         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_GETBUDDY, FALSE, 0);
 510         ok(rTest == hWndLeftBuddy, "Expected hWndLeftBuddy\n");
 511         DestroyWindow(hWndLeftBuddy);
 512     }
 513     if (hWndRightBuddy != NULL){
 514         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_GETBUDDY, TRUE,0);
 515         ok(rTest == hWndRightBuddy, "Expected hWndRightBuddy\n");
 516         DestroyWindow(hWndRightBuddy);
 517     }
 518
 519     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, buddy_window_test_seq, "buddy test sequence", TRUE);
 520     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_buddy_window_test_seq, "parent buddy test seq", TRUE);
 521
 522 }
 523
 524 static void test_line_size(HWND hWndTrackbar){
 525     int r;
 526
 527     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 528
 529     /* test TBM_SETLINESIZE */
 530     r = SendMessageA(hWndTrackbar, TBM_SETLINESIZE, 0, 10);
 531     expect(1,r);
 532     r = SendMessageA(hWndTrackbar, TBM_SETLINESIZE, 0, 4);
 533     expect(10, r);
 534
 535     /* test TBM_GETLINESIZE */
 536     r = SendMessageA(hWndTrackbar, TBM_GETLINESIZE, 0,0);
 537     expect(4, r);
 538
 539     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, line_size_test_seq, "linesize test sequence", FALSE);
 540     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "parent line test sequence", FALSE);
 541 }
 542
 543
 544 static void test_page_size(HWND hWndTrackbar){
 545     int r;
 546
 547     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 548
 549     /* test TBM_SETPAGESIZE */
 550     r = SendMessageA(hWndTrackbar, TBM_SETPAGESIZE, 0, 10);
 551     expect(20, r);
 552     r = SendMessageA(hWndTrackbar, TBM_SETPAGESIZE, 0, -1);
 553     expect(10, r);
 554
 555     /* test TBM_GETPAGESIZE */
 556     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0,0);
 557     expect(20, r);
 558
 559     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, page_size_test_seq, "page size test sequence", FALSE);
 560     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "parent page size test sequence", FALSE);
 561
 562     /* check for zero page size */
 563     r = SendMessageA(hWndTrackbar, TBM_SETPAGESIZE, 0, 0);
 564     expect(20, r);
 565     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 566     expect(0, r);
 567     /* revert to default */
 568     r = SendMessageA(hWndTrackbar, TBM_SETPAGESIZE, 0, -1);
 569     expect(0, r);
 570     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 571     expect(20, r);
 572     /* < -1 */
 573     r = SendMessageA(hWndTrackbar, TBM_SETPAGESIZE, 0, -2);
 574     expect(20, r);
 575     r = SendMessageA(hWndTrackbar, TBM_GETPAGESIZE, 0, 0);
 576     expect(-2, r);
 577 }
 578
 579 static void test_position(HWND hWndTrackbar){
 580     int r;
 581
 582     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 583     /* test TBM_SETPOS */
 584     SendMessageA(hWndTrackbar, TBM_SETPOS, TRUE, -1);
 585     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0, 0);
 586     expect(0, r);
 587     SendMessageA(hWndTrackbar, TBM_SETPOS, TRUE, 5);
 588     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0,0);
 589     expect(5, r);
 590     SendMessageA(hWndTrackbar, TBM_SETPOS, TRUE, 5);
 591     SendMessageA(hWndTrackbar, TBM_SETPOS, TRUE, 1000);
 592     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0,0);
 593     expect(100, r);
 594     SendMessageA(hWndTrackbar, TBM_SETPOS, FALSE, 20);
 595     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0,0);
 596     expect(20, r);
 597     SendMessageA(hWndTrackbar, TBM_SETPOS, TRUE, 20);
 598
 599     /* test TBM_GETPOS */
 600     r = SendMessageA(hWndTrackbar, TBM_GETPOS, 0,0);
 601     expect(20, r);
 602
 603     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, position_test_seq, "position test sequence", TRUE);
 604     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_position_test_seq, "parent position test sequence", TRUE);
 605 }
 606
 607 static void test_range(HWND hWndTrackbar){
 608     int r;
 609
 610     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 611     /* test TBM_SETRANGE */
 612     SendMessageA(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(0, 10));
 613     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 614     expect(10, r);
 615     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 616     expect(0, r);
 617     SendMessageA(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(-1, 1000));
 618     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 619     expect(1000, r);
 620     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 621     expect(-1, r);
 622     SendMessageA(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(10, 0));
 623     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 624     expect(0, r);
 625     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 626     expect(10, r);
 627     SendMessageA(hWndTrackbar, TBM_SETRANGE, FALSE, MAKELONG(0,10));
 628     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 629     expect(10, r);
 630     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 631     expect(0, r);
 632
 633     /*test TBM_SETRANGEMAX */
 634     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, TRUE, 10);
 635     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 636     expect(10, r);
 637     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, TRUE, -1);
 638     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 639     expect(-1, r);
 640     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, FALSE, 10);
 641     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 642     expect(10, r);
 643
 644     /* testing TBM_SETRANGEMIN */
 645     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, TRUE, 0);
 646     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 647     expect(0, r);
 648     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, TRUE, 10);
 649     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 650     expect(10, r);
 651     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, TRUE, -10);
 652     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 653     expect(-10, r);
 654     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, FALSE, 5);
 655     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 656     expect(5, r);
 657
 658     /* test TBM_GETRANGEMAX */
 659     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0,0);
 660     expect(10, r);
 661
 662     /* test TBM_GETRANGEMIN */
 663     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0,0);
 664     expect(5, r);
 665
 666     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, range_test_seq, "range test sequence", TRUE);
 667     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_range_test_seq, "parent range test sequence", TRUE);
 668 }
 669
 670 static void test_selection(HWND hWndTrackbar){
 671     int r;
 672
 673     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 674     /* test TBM_SETSEL */
 675     SendMessageA(hWndTrackbar, TBM_SETSEL, TRUE, MAKELONG(0,10));
 676     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 677     expect(10, r);
 678     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 679     expect(5, r);
 680     SendMessageA(hWndTrackbar, TBM_SETSEL, TRUE, MAKELONG(5, 20));
 681     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 682     expect(10, r);
 683     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 684     expect(5, r);
 685     SendMessageA(hWndTrackbar, TBM_SETSEL, FALSE, MAKELONG(5, 10));
 686     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 687     expect(10, r);
 688     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 689     expect(5, r);
 690
 691     /* test TBM_SETSELEND */
 692     SendMessageA(hWndTrackbar, TBM_SETSELEND, TRUE, 10);
 693     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 694     expect(10, r);
 695     SendMessageA(hWndTrackbar, TBM_SETSELEND, TRUE, 20);
 696     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 697     expect(10, r);
 698     SendMessageA(hWndTrackbar, TBM_SETSELEND, TRUE, 4);
 699     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 700     expect(4, r);
 701     SendMessageA(hWndTrackbar, TBM_SETSELEND, FALSE, 2);
 702     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 703     expect(2, r);
 704
 705     /* test TBM_GETSELEND */
 706     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 707     expect(2, r);
 708
 709     /* testing TBM_SETSELSTART */
 710     SendMessageA(hWndTrackbar, TBM_SETSELSTART, TRUE, 5);
 711     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 712     expect(5, r);
 713     SendMessageA(hWndTrackbar, TBM_SETSELSTART, TRUE, 0);
 714     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 715     expect(5, r);
 716     SendMessageA(hWndTrackbar, TBM_SETSELSTART, TRUE, 20);
 717     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 718     expect(20, r);
 719     SendMessageA(hWndTrackbar, TBM_SETSELSTART, FALSE, 8);
 720     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 721     expect(8, r);
 722
 723     /* test TBM_GETSELSTART */
 724     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 725     expect(8, r);
 726
 727     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, selection_test_seq, "selection test sequence", TRUE);
 728     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_selection_test_seq, "parent selection test sequence", TRUE);
 729 }
 730
 731 static void test_thumb_length(HWND hWndTrackbar){
 732     int r;
 733
 734     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 735     /* testing TBM_SETTHUMBLENGTH */
 736     SendMessageA(hWndTrackbar, TBM_SETTHUMBLENGTH, 15, 0);
 737     r = SendMessageA(hWndTrackbar, TBM_GETTHUMBLENGTH, 0,0);
 738     expect(15, r);
 739     SendMessageA(hWndTrackbar, TBM_SETTHUMBLENGTH, 20, 0);
 740     r = SendMessageA(hWndTrackbar, TBM_GETTHUMBLENGTH, 0,0);
 741     expect(20, r);
 742
 743     /* test TBM_GETTHUMBLENGTH */
 744     r = SendMessageA(hWndTrackbar, TBM_GETTHUMBLENGTH, 0,0);
 745     expect(20, r);
 746
 747     r = SendMessageA(hWndTrackbar, WM_SIZE, 0,0);
 748     expect(0, r);
 749     r = SendMessageA(hWndTrackbar, TBM_GETTHUMBLENGTH, 0,0);
 750     expect(20, r);
 751     r = SendMessageA(hWndTrackbar, WM_SIZE, 0, MAKELPARAM(50, 50) );
 752     expect(0, r);
 753     r = SendMessageA(hWndTrackbar, TBM_GETTHUMBLENGTH, 0,0);
 754     expect(20, r);
 755
 756     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, thumb_length_test_seq, "thumb length test sequence", TRUE);
 757     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_thumb_length_test_seq, "parent thumb length test sequence", TRUE);
 758 }
 759
 760 static void test_tic_settings(HWND hWndTrackbar){
 761     int r;
 762
 763     /* testing TBM_SETTIC */
 764     /* Set tics at 5 and 10 */
 765     /* 0 and 20 are out of range and should not be set */
 766     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMAX, 0, 0);
 767     expect(10, r);
 768     r = SendMessageA(hWndTrackbar, TBM_GETRANGEMIN, 0, 0);
 769     expect(5, r);
 770
 771     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 772     r = SendMessageA(hWndTrackbar, TBM_SETTIC, 0, 0);
 773     ok(r == FALSE, "Expected FALSE, got %d\n", r);
 774     r = SendMessageA(hWndTrackbar, TBM_SETTIC, 0, 5);
 775     ok(r == TRUE, "Expected TRUE, got %d\n", r);
 776     r = SendMessageA(hWndTrackbar, TBM_SETTIC, 0, 10);
 777     ok(r == TRUE, "Expected TRUE, got %d\n", r);
 778
 779     r = SendMessageA(hWndTrackbar, TBM_SETTIC, 0, 20);
 780     ok(r == FALSE, "Expected FALSE, got %d\n", r);
 781
 782     /* test TBM_SETTICFREQ */
 783     SendMessageA(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(0, 10));
 784     SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 2, 0);
 785     r = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
 786     expect(6, r);
 787     SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 5, 0);
 788     r = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
 789     expect(3, r);
 790     SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 15, 0);
 791     r = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
 792     expect(2, r);
 793
 794     /* test TBM_GETNUMTICS */
 795     /* since TIC FREQ is 15, there should be only 2 tics now */
 796     r = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
 797     expect(2, r);
 798
 799     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, tic_settings_test_seq, "tic settings test sequence", TRUE);
 800     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_tic_settings_test_seq, "parent tic settings test sequence", TRUE);
 801
 802     /* range [0,0], freq = 1 */
 803     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, TRUE, 0);
 804     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, TRUE, 0);
 805     SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 1, 0);
 806     r = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
 807     expect(2, r);
 808     /* range [0,1], freq = 1 */
 809     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, TRUE, 1);
 810     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, TRUE, 0);
 811     SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 1, 0);
 812     r = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
 813     expect(2, r);
 814     /* range [0,2], freq = 1 */
 815     SendMessageA(hWndTrackbar, TBM_SETRANGEMAX, TRUE, 2);
 816     SendMessageA(hWndTrackbar, TBM_SETRANGEMIN, TRUE, 0);
 817     SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 1, 0);
 818     r = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
 819     expect(3, r);
 820 }
 821
 822 static void test_tic_placement(HWND hWndTrackbar){
 823     int r;
 824     DWORD *rPTics;
 825     DWORD numtics;
 826
 827     SendMessageA(hWndTrackbar, TBM_SETRANGE, TRUE, MAKELONG(1, 6));
 828     SendMessageA(hWndTrackbar, TBM_SETTICFREQ, 1, 0);
 829
 830     numtics = SendMessageA(hWndTrackbar, TBM_GETNUMTICS, 0, 0);
 831     ok(numtics == 6, "Expected 6, got %d\n", numtics);
 832
 833     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 834     /* test TBM_GETPTICS */
 835     rPTics = (DWORD *) SendMessageA(hWndTrackbar, TBM_GETPTICS, 0,0);
 836     expect(2, rPTics[0]);
 837     expect(3, rPTics[1]);
 838     expect(4, rPTics[2]);
 839     expect(5, rPTics[3]);
 840
 841     /* test TBM_GETTIC */
 842     r = SendMessageA(hWndTrackbar, TBM_GETTIC, 0,0);
 843     expect(2, r);
 844     r = SendMessageA(hWndTrackbar, TBM_GETTIC, 2,0);
 845     expect(4, r);
 846     r = SendMessageA(hWndTrackbar, TBM_GETTIC, 4,0);
 847     expect(-1, r);
 848
 849     /* test TBM_GETTICPIC */
 850     r = SendMessageA(hWndTrackbar, TBM_GETTICPOS, 0, 0);
 851     ok(r > 0, "Expected r > 0, got %d\n", r);
 852     r = SendMessageA(hWndTrackbar, TBM_GETTICPOS, 2, 0);
 853     ok(r > 0, "Expected r > 0, got %d\n", r);
 854
 855     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, tic_placement_test_seq, "get tic placement test sequence", FALSE);
 856     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "parent get tic placement test sequence", FALSE);
 857 }
 858
 859
 860 static void test_tool_tips(HWND hWndTrackbar){
 861     int r;
 862     HWND hWndTooltip;
 863     HWND rTest;
 864
 865     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 866     /* testing TBM_SETTIPSIDE */
 867     r = SendMessageA(hWndTrackbar, TBM_SETTIPSIDE, TBTS_TOP, 0);
 868     expect(TBTS_TOP, r);
 869     r = SendMessageA(hWndTrackbar, TBM_SETTIPSIDE, TBTS_LEFT, 0);
 870     expect(TBTS_TOP, r);
 871     r = SendMessageA(hWndTrackbar, TBM_SETTIPSIDE, TBTS_BOTTOM, 0);
 872     expect(TBTS_LEFT, r);
 873     r = SendMessageA(hWndTrackbar, TBM_SETTIPSIDE, TBTS_RIGHT, 0);
 874     expect(TBTS_BOTTOM, r);
 875
 876     /* testing TBM_SETTOOLTIPS */
 877     hWndTooltip = CreateWindowExA(WS_EX_TOPMOST, TOOLTIPS_CLASSA, NULL, 0,
 878                                   CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 879                                   NULL, NULL, NULL, NULL);
 880
 881     ok(hWndTooltip != NULL, "Expected non NULL value\n");
 882     if (hWndTooltip != NULL){
 883         SendMessageA(hWndTrackbar, TBM_SETTOOLTIPS, (LPARAM) hWndTooltip, 0);
 884         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_GETTOOLTIPS, 0,0);
 885         ok(rTest == hWndTooltip, "Expected hWndToolTip, got\n");
 886         SendMessageA(hWndTrackbar, TBM_SETTOOLTIPS, 0, 0);
 887         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_GETTOOLTIPS, 0,0);
 888         ok(rTest == NULL, "Expected NULL\n");
 889         SendMessageA(hWndTrackbar, TBM_SETTOOLTIPS, (LPARAM) hWndTooltip, 5);
 890         rTest = (HWND) SendMessageA(hWndTrackbar, TBM_GETTOOLTIPS, 0,0);
 891         ok(rTest == hWndTooltip, "Expected hWndTooltip, got\n");
 892     } else
 893         skip("tool tip control not present?\n");
 894
 895     /* test TBM_GETTOOLTIPS */
 896     rTest = (HWND) SendMessageA(hWndTrackbar, TBM_GETTOOLTIPS, 0,0);
 897     ok(rTest == hWndTooltip, "Expected hWndTooltip\n");
 898
 899     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, tool_tips_test_seq, "tool tips test sequence", FALSE);
 900     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "parent tool tips test sequence", FALSE);
 901 }
 902
 903
 904 static void test_unicode(HWND hWndTrackbar){
 905     int r;
 906
 907     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 908     /* testing TBM_SETUNICODEFORMAT */
 909     r = SendMessageA(hWndTrackbar, TBM_SETUNICODEFORMAT, TRUE, 0);
 910     ok(r == FALSE, "Expected FALSE, got %d\n",r);
 911     r = SendMessageA(hWndTrackbar, TBM_SETUNICODEFORMAT, FALSE, 0);
 912     ok(r == TRUE, "Expected TRUE, got %d\n",r);
 913
 914     /* test TBM_GETUNICODEFORMAT */
 915     r = SendMessageA(hWndTrackbar, TBM_GETUNICODEFORMAT, 0,0);
 916     ok(r == FALSE, "Expected FALSE, got %d\n",r);
 917
 918     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, unicode_test_seq, "unicode test sequence", FALSE);
 919     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "parent unicode test sequence", FALSE);
 920 }
 921
 922 static void test_ignore_selection(HWND hWndTrackbar){
 923     int r;
 924
 925     flush_sequences(sequences, NUM_MSG_SEQUENCE);
 926     /* test TBM_SETSEL  ensure that it is ignored */
 927     SendMessageA(hWndTrackbar, TBM_SETSEL, TRUE, MAKELONG(0,10));
 928     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 929     expect(0, r);
 930     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 931     expect(0, r);
 932     SendMessageA(hWndTrackbar, TBM_SETSEL, FALSE, MAKELONG(0,10));
 933     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 934     expect(0, r);
 935     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 936     expect(0, r);
 937
 938     /* test TBM_SETSELEND, ensure that it is ignored */
 939     SendMessageA(hWndTrackbar, TBM_SETSELEND, TRUE, 0);
 940     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 941     expect(0, r);
 942     SendMessageA(hWndTrackbar, TBM_SETSELEND, TRUE, 10);
 943     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 944     expect(0,r);
 945     SendMessageA(hWndTrackbar, TBM_SETSELEND, FALSE, 0);
 946     r = SendMessageA(hWndTrackbar, TBM_GETSELEND, 0,0);
 947     expect(0, r);
 948
 949     /* test TBM_SETSELSTART, ensure that it is ignored */
 950     SendMessageA(hWndTrackbar, TBM_SETSELSTART, TRUE, 0);
 951     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 952     expect(0, r);
 953     SendMessageA(hWndTrackbar, TBM_SETSELSTART, TRUE, 10);
 954     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 955     expect(0,r);
 956     SendMessageA(hWndTrackbar, TBM_SETSELSTART, FALSE, 0);
 957     r = SendMessageA(hWndTrackbar, TBM_GETSELSTART, 0,0);
 958     expect(0, r);
 959
 960     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, ignore_selection_test_seq, "ignore selection setting test sequence", FALSE);
 961     ok_sequence(sequences, PARENT_SEQ_INDEX, empty_seq, "parent ignore selection setting test sequence", FALSE);
 962 }
 963
 964 static void test_initial_state(void)
 965 {
 966     HWND hWnd;
 967     int ret;
 968
 969     hWnd = create_trackbar(0, hWndParent);
 970
 971     ret = SendMessageA(hWnd, TBM_GETNUMTICS, 0, 0);
 972     expect(2, ret);
 973     ret = SendMessageA(hWnd, TBM_GETTIC, 0, 0);
 974     expect(-1, ret);
 975     ret = SendMessageA(hWnd, TBM_GETTICPOS, 0, 0);
 976     expect(-1, ret);
 977     ret = SendMessageA(hWnd, TBM_GETRANGEMIN, 0, 0);
 978     expect(0, ret);
 979     ret = SendMessageA(hWnd, TBM_GETRANGEMAX, 0, 0);
 980     expect(100, ret);
 981
 982     ret = SendMessageA(hWnd, TBM_SETRANGEMAX, TRUE, 200);
 983     expect(0, ret);
 984
 985     ret = SendMessageA(hWnd, TBM_GETNUMTICS, 0, 0);
 986     expect(2, ret);
 987
 988     ret = SendMessageA(hWnd, TBM_SETRANGEMIN, TRUE, 10);
 989     expect(0, ret);
 990
 991     ret = SendMessageA(hWnd, TBM_GETNUMTICS, 0, 0);
 992     expect(2, ret);
 993
 994     DestroyWindow(hWnd);
 995 }
 996
 997 static void test_TBS_AUTOTICKS(void)
 998 {
 999     HWND hWnd;
1000     int ret;
1001
1002     hWnd = create_trackbar(TBS_AUTOTICKS, hWndParent);
1003
1004     ret = SendMessageA(hWnd, TBM_GETNUMTICS, 0, 0);
1005     expect(2, ret);
1006     ret = SendMessageA(hWnd, TBM_GETTIC, 0, 0);
1007     expect(-1, ret);
1008     ret = SendMessageA(hWnd, TBM_GETTICPOS, 0, 0);
1009     expect(-1, ret);
1010     ret = SendMessageA(hWnd, TBM_GETRANGEMIN, 0, 0);
1011     expect(0, ret);
1012     ret = SendMessageA(hWnd, TBM_GETRANGEMAX, 0, 0);
1013     expect(100, ret);
1014
1015     /* TBM_SETRANGEMAX rebuilds tics */
1016     ret = SendMessageA(hWnd, TBM_SETRANGEMAX, TRUE, 200);
1017     expect(0, ret);
1018     ret = SendMessageA(hWnd, TBM_GETNUMTICS, 0, 0);
1019     expect(201, ret);
1020
1021     /* TBM_SETRANGEMIN rebuilds tics */
1022     ret = SendMessageA(hWnd, TBM_SETRANGEMAX, TRUE, 100);
1023     expect(0, ret);
1024     ret = SendMessageA(hWnd, TBM_SETRANGEMIN, TRUE, 10);
1025     expect(0, ret);
1026     ret = SendMessageA(hWnd, TBM_GETNUMTICS, 0, 0);
1027     expect(91, ret);
1028
1029     ret = SendMessageA(hWnd, TBM_SETRANGEMIN, TRUE, 0);
1030     expect(0, ret);
1031
1032     /* TBM_SETRANGE rebuilds tics */
1033     ret = SendMessageA(hWnd, TBM_SETRANGE, TRUE, MAKELONG(10, 200));
1034     expect(0, ret);
1035     ret = SendMessageA(hWnd, TBM_GETNUMTICS, 0, 0);
1036     expect(191, ret);
1037
1038     DestroyWindow(hWnd);
1039 }
1040
1041 START_TEST(trackbar)
1042 {
1043     DWORD style = WS_VISIBLE | TBS_TOOLTIPS | TBS_ENABLESELRANGE | TBS_FIXEDLENGTH | TBS_AUTOTICKS;
1044     HWND hWndTrackbar;
1045
1046     init_msg_sequences(sequences, NUM_MSG_SEQUENCE);
1047     InitCommonControls();
1048
1049     /* create parent window */
1050     hWndParent = create_parent_window();
1051     ok(hWndParent != NULL, "Failed to create parent Window!\n");
1052
1053     if(!hWndParent){
1054         skip("parent window not present\n");
1055         return;
1056     }
1057
1058     flush_sequences(sequences, NUM_MSG_SEQUENCE);
1059
1060     /* create trackbar with set styles */
1061     hWndTrackbar = create_trackbar(style, hWndParent);
1062
1063     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
1064
1065     if (!hWndTrackbar){
1066         skip("trackbar control not present?\n");
1067         return;
1068     }
1069
1070     ok_sequence(sequences, TRACKBAR_SEQ_INDEX, empty_seq, "create Trackbar Window", FALSE);
1071     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_create_trackbar_wnd_seq, "parent trackbar window", TRUE);
1072     flush_sequences(sequences, NUM_MSG_SEQUENCE);
1073
1074     /* TEST OF ALL SETTER and GETTER MESSAGES with required styles turned on*/
1075     test_trackbar_buddy(hWndTrackbar);
1076     test_line_size(hWndTrackbar);
1077     test_page_size(hWndTrackbar);
1078     test_position(hWndTrackbar);
1079     test_range(hWndTrackbar);
1080     test_selection(hWndTrackbar);
1081     test_thumb_length(hWndTrackbar);
1082     test_tic_settings(hWndTrackbar);
1083     test_tic_placement(hWndTrackbar);
1084     test_tool_tips(hWndTrackbar);
1085     test_unicode(hWndTrackbar);
1086     test_TBS_AUTOTICKS();
1087
1088     flush_sequences(sequences, NUM_MSG_SEQUENCE);
1089     DestroyWindow(hWndTrackbar);
1090
1091     /* test getters and setters without styles set */
1092     hWndTrackbar = create_trackbar(0, hWndParent);
1093
1094     ok(hWndTrackbar != NULL, "Expected non NULL value\n");
1095
1096     if (!hWndTrackbar){
1097         skip("trackbar control not present?\n");
1098         return;
1099     }
1100
1101     ok_sequence(sequences, PARENT_SEQ_INDEX, parent_new_window_test_seq, "new trackbar window test sequence", TRUE);
1102
1103     test_ignore_selection(hWndTrackbar);
1104
1105     DestroyWindow(hWndTrackbar);
1106
1107     test_initial_state();
1108
1109     DestroyWindow(hWndParent);
1110 }