[ADVAPI32_WINETEST] Revert service.c changes from 3c1b7834e1 to avoid testbot hangs...
[reactos.git] / modules / rostests / winetests / user32 / scroll.c
1 /*
2 * Unit tests for scrollbar
3 *
4 * Copyright 2008 Lyutin Anatoly (Etersoft)
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "precomp.h"
22
23 static HWND hScroll;
24 static BOOL bThemeActive = FALSE;
25
26 static LRESULT CALLBACK MyWndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
27 {
28 switch(msg)
29 {
30
31 case WM_CREATE:
32 {
33 hScroll = CreateWindowA( "SCROLLBAR", "", WS_CHILD | WS_VISIBLE, 0, 0, 120, 100, hWnd, (HMENU)100, GetModuleHandleA(0), 0 );
34
35 return 0;
36 }
37 case WM_DESTROY:
38 PostQuitMessage(0);
39 break;
40 case WM_HSCROLL:
41 case WM_VSCROLL:
42 /* stop tracking */
43 ReleaseCapture();
44 return 0;
45 default:
46 return DefWindowProcA(hWnd, msg, wParam, lParam);
47 }
48 return 0;
49 }
50
51 static HWND create_main_test_wnd(void)
52 {
53 HWND hMainWnd;
54
55 hScroll = NULL;
56 hMainWnd = CreateWindowExA( 0, "MyTestWnd", "Scroll",
57 WS_OVERLAPPEDWINDOW|WS_VSCROLL|WS_HSCROLL,
58 CW_USEDEFAULT, CW_USEDEFAULT, 100, 100, NULL, NULL, GetModuleHandleA(NULL), 0 );
59 ok(hMainWnd != NULL, "Failed to create parent window. Tests aborted.\n");
60 ok(hScroll != NULL, "got NULL scroll bar handle\n");
61
62 return hMainWnd;
63 }
64
65 static void scrollbar_test_track(void)
66 {
67 HWND mainwnd;
68
69 mainwnd = create_main_test_wnd();
70
71 /* test that scrollbar tracking is terminated when
72 * the control loses mouse capture */
73 SendMessageA( hScroll, WM_LBUTTONDOWN, 0, MAKELPARAM( 1, 1));
74 /* a normal return from SendMessage */
75 /* not normal for instances such as closing the window */
76 ok( IsWindow( hScroll), "Scrollbar has gone!\n");
77
78 DestroyWindow(hScroll);
79 DestroyWindow(mainwnd);
80 }
81
82 static void test_EnableScrollBar(void)
83 {
84 HWND mainwnd;
85 BOOL ret;
86
87 mainwnd = create_main_test_wnd();
88
89 ret = EnableScrollBar( hScroll, SB_CTL, ESB_DISABLE_BOTH );
90 ok( ret, "The scrollbar should be disabled.\n" );
91 ok( !IsWindowEnabled( hScroll ), "The scrollbar window should be disabled.\n" );
92
93 ret = EnableScrollBar( hScroll, SB_CTL, ESB_ENABLE_BOTH );
94 ok( ret, "The scrollbar should be enabled.\n" );
95 ok( IsWindowEnabled( hScroll ), "The scrollbar window should be enabled.\n" );
96
97 /* test buttons separately */
98 ret = EnableScrollBar( hScroll, SB_CTL, ESB_DISABLE_LTUP );
99 ok( ret, "The scrollbar LTUP button should be disabled.\n" );
100 ok( IsWindowEnabled( hScroll ), "The scrollbar window should be enabled.\n" );
101 ret = EnableScrollBar( hScroll, SB_CTL, ESB_ENABLE_BOTH );
102 ok( ret, "The scrollbar should be enabled.\n" );
103 ok( IsWindowEnabled( hScroll ), "The scrollbar window should be enabled.\n" );
104
105 ret = EnableScrollBar( hScroll, SB_CTL, ESB_DISABLE_RTDN );
106 ok( ret, "The scrollbar RTDN button should be disabled.\n" );
107 ok( IsWindowEnabled( hScroll ), "The scrollbar window should be enabled.\n" );
108 ret = EnableScrollBar( hScroll, SB_CTL, ESB_ENABLE_BOTH );
109 ok( ret, "The scrollbar should be enabled.\n" );
110 ok( IsWindowEnabled( hScroll ), "The scrollbar window should be enabled.\n" );
111
112 /* disable window, try to re-enable */
113 ret = EnableWindow( hScroll, FALSE );
114 ok( !ret, "got %d\n", ret );
115 ok( !IsWindowEnabled( hScroll ), "The scrollbar window should be disabled.\n" );
116
117 ret = EnableScrollBar( hScroll, SB_CTL, ESB_ENABLE_BOTH );
118 ok( ret, "got %d\n", ret );
119 ok( IsWindowEnabled( hScroll ), "The scrollbar window should be disabled.\n" );
120
121 DestroyWindow(hScroll);
122 DestroyWindow(mainwnd);
123 }
124
125 static void test_SetScrollPos(void)
126 {
127 HWND mainwnd;
128 int ret;
129
130 mainwnd = create_main_test_wnd();
131
132 EnableWindow( hScroll, FALSE );
133 ok( !IsWindowEnabled( hScroll ), "The scroll should be disabled.\n" );
134
135 ret = SetScrollPos( hScroll, SB_CTL, 30, TRUE);
136 ok( !ret, "The position should not be set.\n" );
137
138 ret = GetScrollPos( hScroll, SB_CTL);
139 ok( !ret, "The position should be equal to zero\n");
140
141 ret = SetScrollRange( hScroll, SB_CTL, 0, 100, TRUE );
142 ok( ret, "The range should be set.\n" );
143
144 ret = SetScrollPos( hScroll, SB_CTL, 30, TRUE);
145 ok( !ret , "The position should not be set.\n" );
146
147 ret = GetScrollPos( hScroll, SB_CTL);
148 ok( ret == 30, "The position should be set!!!\n");
149
150 EnableWindow( hScroll, TRUE );
151 ok( IsWindowEnabled( hScroll ), "The scroll should be enabled.\n" );
152
153 ret = SetScrollPos( hScroll, SB_CTL, 30, TRUE);
154 ok( ret == 30, "The position should be set.\n" );
155
156 ret = GetScrollPos( hScroll, SB_CTL);
157 ok( ret == 30, "The position should not be equal to zero\n");
158
159 ret = SetScrollRange( hScroll, SB_CTL, 0, 100, TRUE );
160 ok( ret, "The range should be set.\n" );
161
162 ret = SetScrollPos( hScroll, SB_CTL, 30, TRUE);
163 ok( ret == 30, "The position should be set.\n" );
164
165 ret = GetScrollPos( hScroll, SB_CTL);
166 ok( ret == 30, "The position should not be equal to zero\n");
167
168 DestroyWindow(hScroll);
169 DestroyWindow(mainwnd);
170 }
171
172 static void test_ShowScrollBar(void)
173 {
174 HWND mainwnd;
175 BOOL ret;
176
177 mainwnd = create_main_test_wnd();
178
179 ret = ShowScrollBar( hScroll, SB_CTL, FALSE );
180 ok( ret, "The ShowScrollBar() should not failed.\n" );
181 ok( !IsWindowVisible( hScroll ), "The scrollbar window should not be visible\n" );
182
183 ret = ShowScrollBar( hScroll, SB_CTL, TRUE );
184 ok( ret, "The ShowScrollBar() should not failed.\n" );
185 ok( !IsWindowVisible( hScroll ), "The scrollbar window should be visible\n" );
186
187 ret = ShowScrollBar( NULL, SB_CTL, TRUE );
188 ok( !ret, "The ShowScrollBar() should failed.\n" );
189
190 DestroyWindow(hScroll);
191 DestroyWindow(mainwnd);
192 }
193
194 static void test_GetScrollBarInfo(void)
195 {
196 HWND hMainWnd;
197 BOOL ret;
198 SCROLLBARINFO sbi;
199 RECT rect;
200 BOOL (WINAPI *pGetScrollBarInfo)(HWND, LONG, LPSCROLLBARINFO);
201
202 pGetScrollBarInfo = (void*)GetProcAddress(GetModuleHandleA("user32.dll"), "GetScrollBarInfo");
203 if (!pGetScrollBarInfo)
204 {
205 win_skip("GetScrollBarInfo is not available\n");
206 return;
207 }
208
209 hMainWnd = create_main_test_wnd();
210
211 /* Test GetScrollBarInfo to make sure it returns rcScrollBar in screen
212 * coordinates. */
213 sbi.cbSize = sizeof(sbi);
214 ret = pGetScrollBarInfo( hScroll, OBJID_CLIENT, &sbi);
215 ok( ret, "The GetScrollBarInfo() call should not fail.\n" );
216 GetWindowRect( hScroll, &rect );
217 ok( ret, "The GetWindowRect() call should not fail.\n" );
218 ok( !(sbi.rgstate[0] & (STATE_SYSTEM_INVISIBLE|STATE_SYSTEM_OFFSCREEN)),
219 "unexpected rgstate(0x%x)\n", sbi.rgstate[0]);
220 ok(EqualRect(&rect, &sbi.rcScrollBar), "WindowRect %s != rcScrollBar %s\n",
221 wine_dbgstr_rect(&rect), wine_dbgstr_rect(&sbi.rcScrollBar));
222
223 /* Test windows horizontal and vertical scrollbar to make sure rcScrollBar
224 * is still returned in screen coordinates by moving the window, and
225 * making sure that it shifts the rcScrollBar value. */
226 ShowWindow( hMainWnd, SW_SHOW );
227 sbi.cbSize = sizeof(sbi);
228 ret = pGetScrollBarInfo( hMainWnd, OBJID_HSCROLL, &sbi);
229 ok( ret, "The GetScrollBarInfo() call should not fail.\n" );
230 GetWindowRect( hMainWnd, &rect );
231 ok( ret, "The GetWindowRect() call should not fail.\n" );
232 MoveWindow( hMainWnd, rect.left+5, rect.top+5,
233 rect.right-rect.left, rect.bottom-rect.top, TRUE );
234 rect = sbi.rcScrollBar;
235 OffsetRect(&rect, 5, 5);
236 ret = pGetScrollBarInfo( hMainWnd, OBJID_HSCROLL, &sbi);
237 ok( ret, "The GetScrollBarInfo() call should not fail.\n" );
238 ok(EqualRect(&rect, &sbi.rcScrollBar), "PreviousRect %s != CurrentRect %s\n",
239 wine_dbgstr_rect(&rect), wine_dbgstr_rect(&sbi.rcScrollBar));
240
241 sbi.cbSize = sizeof(sbi);
242 ret = pGetScrollBarInfo( hMainWnd, OBJID_VSCROLL, &sbi);
243 ok( ret, "The GetScrollBarInfo() call should not fail.\n" );
244 GetWindowRect( hMainWnd, &rect );
245 ok( ret, "The GetWindowRect() call should not fail.\n" );
246 MoveWindow( hMainWnd, rect.left+5, rect.top+5,
247 rect.right-rect.left, rect.bottom-rect.top, TRUE );
248 rect = sbi.rcScrollBar;
249 OffsetRect(&rect, 5, 5);
250 ret = pGetScrollBarInfo( hMainWnd, OBJID_VSCROLL, &sbi);
251 ok( ret, "The GetScrollBarInfo() call should not fail.\n" );
252 ok(EqualRect(&rect, &sbi.rcScrollBar), "PreviousRect %s != CurrentRect %s\n",
253 wine_dbgstr_rect(&rect), wine_dbgstr_rect(&sbi.rcScrollBar));
254
255 DestroyWindow(hScroll);
256 DestroyWindow(hMainWnd);
257 }
258
259 /* some tests designed to show that Horizontal and Vertical
260 * window scroll bar info are not created independently */
261 static void scrollbar_test_default( DWORD style)
262 {
263 INT min, max, ret;
264 DWORD winstyle;
265 HWND hwnd;
266 SCROLLINFO si = { sizeof( SCROLLINFO), SIF_TRACKPOS };
267
268 hwnd = CreateWindowExA( 0, "static", "", WS_POPUP | style,
269 0, 0, 10, 10, 0, 0, 0, NULL);
270 assert( hwnd != 0);
271
272 ret = GetScrollRange( hwnd, SB_VERT, &min, &max);
273 ok( ret ||
274 broken( !ret) /* Win 9x/ME */ , "GetScrollRange failed.\n");
275 /* range is 0,0 if there are no H or V scroll bars. 0,100 otherwise */
276 if( !( style & ( WS_VSCROLL | WS_HSCROLL)))
277 ok( min == 0 && max == 0,
278 "Scroll bar range is %d,%d. Expected 0,0. Style %08x\n", min, max, style);
279 else
280 ok(( min == 0 && max == 100) ||
281 broken( min == 0 && max == 0), /* Win 9x/ME */
282 "Scroll bar range is %d,%d. Expected 0,100. Style %08x\n", min, max, style);
283 ret = GetScrollRange( hwnd, SB_HORZ, &min, &max);
284 ok( ret ||
285 broken( !ret) /* Win 9x/ME */ , "GetScrollRange failed.\n");
286 /* range is 0,0 if there are no H or V scroll bars. 0,100 otherwise */
287 if( !( style & ( WS_VSCROLL | WS_HSCROLL)))
288 ok( min == 0 && max == 0,
289 "Scroll bar range is %d,%d. Expected 0,0. Style %08x\n", min, max, style);
290 else
291 ok(( min == 0 && max == 100) ||
292 broken( min == 0 && max == 0), /* Win 9x/ME */
293 "Scroll bar range is %d,%d. Expected 0,100. Style %08x\n", min, max, style);
294 /* test GetScrollInfo, vist for vertical SB */
295 ret = GetScrollInfo( hwnd, SB_VERT, &si);
296 /* should fail if no H or V scroll bar styles are present. Succeed otherwise */
297 if( !( style & ( WS_VSCROLL | WS_HSCROLL)))
298 ok( !ret, "GetScrollInfo succeeded unexpectedly. Style is %08x\n", style);
299 else
300 ok( ret ||
301 broken( !ret), /* Win 9x/ME */
302 "GetScrollInfo failed unexpectedly. Style is %08x\n", style);
303 /* Same for Horizontal SB */
304 ret = GetScrollInfo( hwnd, SB_HORZ, &si);
305 /* should fail if no H or V scroll bar styles are present. Succeed otherwise */
306 if( !( style & ( WS_VSCROLL | WS_HSCROLL)))
307 ok( !ret, "GetScrollInfo succeeded unexpectedly. Style is %08x\n", style);
308 else
309 ok( ret ||
310 broken( !ret), /* Win 9x/ME */
311 "GetScrollInfo failed unexpectedly. Style is %08x\n", style);
312 /* now set the Vertical Scroll range to something that could be the default value it
313 * already has */;
314 ret = SetScrollRange( hwnd, SB_VERT, 0, 100, FALSE);
315 ok( ret, "SetScrollRange failed.\n");
316 /* and request the Horizontal range */
317 ret = GetScrollRange( hwnd, SB_HORZ, &min, &max);
318 ok( ret, "GetScrollRange failed.\n");
319 /* now the range should be 0,100 in ALL cases */
320 ok( min == 0 && max == 100,
321 "Scroll bar range is %d,%d. Expected 0,100. Style %08x\n", min, max, style);
322 /* See what is different now for GetScrollRange */
323 ret = GetScrollInfo( hwnd, SB_HORZ, &si);
324 /* should succeed in ALL cases */
325 ok( ret, "GetScrollInfo failed unexpectedly. Style is %08x\n", style);
326 ret = GetScrollInfo( hwnd, SB_VERT, &si);
327 /* should succeed in ALL cases */
328 ok( ret, "GetScrollInfo failed unexpectedly. Style is %08x\n", style);
329 /* report the windows style */
330 winstyle = GetWindowLongA( hwnd, GWL_STYLE );
331 /* WS_VSCROLL added to the window style */
332 if( !(style & WS_VSCROLL))
333 {
334 if (bThemeActive || style != WS_HSCROLL)
335 todo_wine
336 ok( (winstyle & (WS_HSCROLL|WS_VSCROLL)) == ( style | WS_VSCROLL),
337 "unexpected style change %08x/%08x\n", winstyle, style);
338 else
339 ok( (winstyle & (WS_HSCROLL|WS_VSCROLL)) == style,
340 "unexpected style change %08x/%08x\n", winstyle, style);
341 }
342 /* do the test again with H and V reversed.
343 * Start with a clean window */
344 DestroyWindow( hwnd);
345 hwnd = CreateWindowExA( 0, "static", "", WS_POPUP | style,
346 0, 0, 10, 10, 0, 0, 0, NULL);
347 assert( hwnd != 0);
348 /* Set Horizontal Scroll range to something that could be the default value it
349 * already has */;
350 ret = SetScrollRange( hwnd, SB_HORZ, 0, 100, FALSE);
351 ok( ret, "SetScrollRange failed.\n");
352 /* and request the Vertical range */
353 ret = GetScrollRange( hwnd, SB_VERT, &min, &max);
354 ok( ret, "GetScrollRange failed.\n");
355 /* now the range should be 0,100 in ALL cases */
356 ok( min == 0 && max == 100,
357 "Scroll bar range is %d,%d. Expected 0,100. Style %08x\n", min, max, style);
358 /* See what is different now for GetScrollRange */
359 ret = GetScrollInfo( hwnd, SB_HORZ, &si);
360 /* should succeed in ALL cases */
361 ok( ret, "GetScrollInfo failed unexpectedly. Style is %08x\n", style);
362 ret = GetScrollInfo( hwnd, SB_VERT, &si);
363 /* should succeed in ALL cases */
364 ok( ret, "GetScrollInfo failed unexpectedly. Style is %08x\n", style);
365 /* report the windows style */
366 winstyle = GetWindowLongA( hwnd, GWL_STYLE );
367 /* WS_HSCROLL added to the window style */
368 if( !(style & WS_HSCROLL))
369 {
370 if (bThemeActive || style != WS_VSCROLL)
371 todo_wine
372 ok( (winstyle & (WS_HSCROLL|WS_VSCROLL)) == ( style | WS_HSCROLL),
373 "unexpected style change %08x/%08x\n", winstyle, style);
374 else
375 ok( (winstyle & (WS_HSCROLL|WS_VSCROLL)) == style,
376 "unexpected style change %08x/%08x\n", winstyle, style);
377 }
378 /* Slightly change the test to use SetScrollInfo
379 * Start with a clean window */
380 DestroyWindow( hwnd);
381 hwnd = CreateWindowExA( 0, "static", "", WS_POPUP | style,
382 0, 0, 10, 10, 0, 0, 0, NULL);
383 assert( hwnd != 0);
384 /* set Horizontal position with SetScrollInfo */
385 si.nPos = 0;
386 si.nMin = 11;
387 si.nMax = 22;
388 si.fMask |= SIF_RANGE;
389 ret = SetScrollInfo( hwnd, SB_HORZ, &si, FALSE);
390 ok( ret, "SetScrollInfo failed. Style is %08x\n", style);
391 /* and request the Vertical range */
392 ret = GetScrollRange( hwnd, SB_VERT, &min, &max);
393 ok( ret, "GetScrollRange failed.\n");
394 /* now the range should be 0,100 in ALL cases */
395 ok( min == 0 && max == 100,
396 "Scroll bar range is %d,%d. Expected 0,100. Style %08x\n", min, max, style);
397 /* See what is different now for GetScrollRange */
398 ret = GetScrollInfo( hwnd, SB_HORZ, &si);
399 /* should succeed in ALL cases */
400 ok( ret, "GetScrollInfo failed unexpectedly. Style is %08x\n", style);
401 ret = GetScrollInfo( hwnd, SB_VERT, &si);
402 /* should succeed in ALL cases */
403 ok( ret, "GetScrollInfo failed unexpectedly. Style is %08x\n", style);
404 /* also test if the window scroll bars are enabled */
405 ret = EnableScrollBar( hwnd, SB_VERT, ESB_ENABLE_BOTH);
406 ok( !ret, "Vertical window scroll bar was not enabled\n");
407 ret = EnableScrollBar( hwnd, SB_HORZ, ESB_ENABLE_BOTH);
408 ok( !ret, "Horizontal window scroll bar was not enabled\n");
409 DestroyWindow( hwnd);
410 /* finally, check if adding a WS_[HV]SCROLL style of a window makes the scroll info
411 * available */
412 if( style & (WS_HSCROLL | WS_VSCROLL)) return;/* only test if not yet set */
413 /* Start with a clean window */
414 DestroyWindow( hwnd);
415 hwnd = CreateWindowExA( 0, "static", "", WS_POPUP ,
416 0, 0, 10, 10, 0, 0, 0, NULL);
417 assert( hwnd != 0);
418 ret = GetScrollInfo( hwnd, SB_VERT, &si);
419 /* should fail */
420 ok( !ret, "GetScrollInfo succeeded unexpectedly. Style is %08x\n", style);
421 /* add scroll styles */
422 winstyle = GetWindowLongA( hwnd, GWL_STYLE );
423 SetWindowLongW( hwnd, GWL_STYLE, winstyle | WS_VSCROLL | WS_HSCROLL);
424 ret = GetScrollInfo( hwnd, SB_VERT, &si);
425 /* should still fail */
426 ok( !ret, "GetScrollInfo succeeded unexpectedly. Style is %08x\n", style);
427 /* clean up */
428 DestroyWindow( hwnd);
429 }
430
431 static LRESULT CALLBACK scroll_init_proc(HWND hwnd, UINT msg,
432 WPARAM wparam, LPARAM lparam)
433 {
434 SCROLLINFO horz, vert;
435 CREATESTRUCTA *cs = (CREATESTRUCTA *)lparam;
436 BOOL h_ret, v_ret;
437
438 switch(msg)
439 {
440 case WM_NCCREATE:
441 return cs->lpCreateParams ? DefWindowProcA(hwnd, msg, wparam, lparam) :
442 TRUE;
443
444 case WM_CREATE:
445 horz.cbSize = sizeof horz;
446 horz.fMask = SIF_ALL;
447 horz.nMin = 0xdeadbeaf;
448 horz.nMax = 0xbaadc0de;
449 vert = horz;
450 h_ret = GetScrollInfo(hwnd, SB_HORZ, &horz);
451 v_ret = GetScrollInfo(hwnd, SB_VERT, &vert);
452
453 if(cs->lpCreateParams)
454 {
455 /* WM_NCCREATE was passed to DefWindowProc */
456 if(cs->style & (WS_VSCROLL | WS_HSCROLL))
457 {
458 ok(h_ret && v_ret, "GetScrollInfo() should return NON-zero "
459 "but got h_ret=%d v_ret=%d\n", h_ret, v_ret);
460 ok(vert.nMin == 0 && vert.nMax == 100,
461 "unexpected init values(SB_VERT): min=%d max=%d\n",
462 vert.nMin, vert.nMax);
463 ok(horz.nMin == 0 && horz.nMax == 100,
464 "unexpected init values(SB_HORZ): min=%d max=%d\n",
465 horz.nMin, horz.nMax);
466 }
467 else
468 {
469 ok(!h_ret && !v_ret, "GetScrollInfo() should return zeru, "
470 "but got h_ret=%d v_ret=%d\n", h_ret, v_ret);
471 ok(vert.nMin == 0xdeadbeaf && vert.nMax == 0xbaadc0de,
472 "unexpected initialization(SB_VERT): min=%d max=%d\n",
473 vert.nMin, vert.nMax);
474 ok(horz.nMin == 0xdeadbeaf && horz.nMax == 0xbaadc0de,
475 "unexpected initialization(SB_HORZ): min=%d max=%d\n",
476 horz.nMin, horz.nMax);
477 }
478 }
479 else
480 {
481 ok(!h_ret && !v_ret, "GetScrollInfo() should return zeru, "
482 "but got h_ret=%d v_ret=%d\n", h_ret, v_ret);
483 ok(horz.nMin == 0xdeadbeaf && horz.nMax == 0xbaadc0de &&
484 vert.nMin == 0xdeadbeaf && vert.nMax == 0xbaadc0de,
485 "unexpected initialization\n");
486 }
487 return FALSE; /* abort creation */
488
489 default:
490 /* need for WM_GETMINMAXINFO, which precedes WM_NCCREATE */
491 return 0;
492 }
493 }
494
495 static void scrollbar_test_init(void)
496 {
497 WNDCLASSEXA wc;
498 CHAR cls_name[] = "scroll_test_class";
499 LONG style[] = {WS_VSCROLL, WS_HSCROLL, WS_VSCROLL | WS_HSCROLL, 0};
500 int i;
501
502 memset( &wc, 0, sizeof wc );
503 wc.cbSize = sizeof wc;
504 wc.style = CS_VREDRAW | CS_HREDRAW;
505 wc.hInstance = GetModuleHandleA(0);
506 wc.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
507 wc.hbrBackground = GetStockObject(WHITE_BRUSH);
508 wc.lpszClassName = cls_name;
509 wc.lpfnWndProc = scroll_init_proc;
510 RegisterClassExA(&wc);
511
512 for(i = 0; i < sizeof style / sizeof style[0]; i++)
513 {
514 /* need not to destroy these windows due creation abort */
515 CreateWindowExA(0, cls_name, NULL, style[i],
516 100, 100, 100, 100, NULL, NULL, wc.hInstance, (LPVOID)TRUE);
517 CreateWindowExA(0, cls_name, NULL, style[i],
518 100, 100, 100, 100, NULL, NULL, wc.hInstance, (LPVOID)FALSE);
519 }
520 UnregisterClassA(cls_name, wc.hInstance);
521 }
522
523 static void test_SetScrollInfo(void)
524 {
525 SCROLLINFO si;
526 HWND mainwnd;
527 BOOL ret;
528
529 mainwnd = create_main_test_wnd();
530
531 ret = IsWindowEnabled(hScroll);
532 ok(ret, "scroll bar disabled\n");
533
534 EnableScrollBar(hScroll, SB_CTL, ESB_DISABLE_BOTH);
535
536 ret = IsWindowEnabled(hScroll);
537 ok(!ret, "scroll bar enabled\n");
538
539 memset(&si, 0, sizeof(si));
540 si.cbSize = sizeof(si);
541 si.fMask = 0xf;
542 ret = GetScrollInfo(hScroll, SB_CTL, &si);
543 ok(ret, "got %d\n", ret);
544
545 /* SetScrollInfo */
546 memset(&si, 0, sizeof(si));
547 si.cbSize = sizeof(si);
548 ret = IsWindowEnabled(hScroll);
549 ok(!ret, "scroll bar enabled\n");
550 si.fMask = SIF_POS|SIF_RANGE|SIF_PAGE|SIF_DISABLENOSCROLL;
551 si.nMax = 100;
552 si.nMin = 10;
553 si.nPos = 0;
554 si.nPage = 100;
555 SetScrollInfo(hScroll, SB_CTL, &si, TRUE);
556 ret = IsWindowEnabled(hScroll);
557 ok(!ret, "scroll bar enabled\n");
558
559 si.fMask = 0xf;
560 ret = GetScrollInfo(hScroll, SB_CTL, &si);
561 ok(ret, "got %d\n", ret);
562
563 EnableScrollBar(hScroll, SB_CTL, ESB_ENABLE_BOTH);
564 ok(IsWindowEnabled(hScroll), "expected enabled scrollbar\n");
565
566 si.fMask = SIF_POS|SIF_RANGE|SIF_PAGE|SIF_DISABLENOSCROLL;
567 si.nMax = 10;
568 si.nMin = 100;
569 si.nPos = 0;
570 si.nPage = 100;
571 SetScrollInfo(hScroll, SB_CTL, &si, TRUE);
572 ret = IsWindowEnabled(hScroll);
573 ok(ret, "scroll bar disabled\n");
574
575 DestroyWindow(hScroll);
576 DestroyWindow(mainwnd);
577 }
578
579 START_TEST ( scroll )
580 {
581 WNDCLASSA wc;
582 HMODULE hUxtheme;
583 BOOL (WINAPI * pIsThemeActive)(VOID);
584
585 wc.style = CS_HREDRAW | CS_VREDRAW;
586 wc.cbClsExtra = 0;
587 wc.cbWndExtra = 0;
588 wc.hInstance = GetModuleHandleA(NULL);
589 wc.hIcon = NULL;
590 wc.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_IBEAM);
591 wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
592 wc.lpszMenuName = NULL;
593 wc.lpszClassName = "MyTestWnd";
594 wc.lpfnWndProc = MyWndProc;
595 RegisterClassA(&wc);
596
597 test_EnableScrollBar();
598 test_SetScrollPos();
599 test_ShowScrollBar();
600 test_GetScrollBarInfo();
601 scrollbar_test_track();
602 test_SetScrollInfo();
603
604 /* Some test results vary depending of theming being active or not */
605 hUxtheme = LoadLibraryA("uxtheme.dll");
606 if (hUxtheme)
607 {
608 pIsThemeActive = (void*)GetProcAddress(hUxtheme, "IsThemeActive");
609 if (pIsThemeActive)
610 bThemeActive = pIsThemeActive();
611 FreeLibrary(hUxtheme);
612 }
613
614 scrollbar_test_default( 0);
615 scrollbar_test_default( WS_HSCROLL);
616 scrollbar_test_default( WS_VSCROLL);
617 scrollbar_test_default( WS_HSCROLL | WS_VSCROLL);
618
619 scrollbar_test_init();
620 }