source: trunk/src/user32/scroll.cpp@ 1348

Last change on this file since 1348 was 1348, checked in by sandervl, 26 years ago

WS_VISIBLE & scrollbar fixes
File size: 58.5 KB
Line 
1/* $Id: scroll.cpp,v 1.11 1999-10-18 10:54:03 sandervl Exp $ */
2/*
3 * Scrollbar control
4 *
5 * Copyright 1999 Christoph Bratschi
6 *
7 * Copyright 1993 Martin Ayotte
8 * Copyright 1994, 1996 Alexandre Julliard
9 *
10 * WINE version: 990923
11 */
12
13#include <stdlib.h>
14#include <os2win.h>
15#include "controls.h"
16#include "scroll.h"
17#include "win32wbase.h"
18#include "oslibwin.h"
19
20static BOOL bitmapsLoaded = FALSE;
21
22static HBITMAP hUpArrow = 0;
23static HBITMAP hDnArrow = 0;
24static HBITMAP hLfArrow = 0;
25static HBITMAP hRgArrow = 0;
26static HBITMAP hUpArrowD = 0;
27static HBITMAP hDnArrowD = 0;
28static HBITMAP hLfArrowD = 0;
29static HBITMAP hRgArrowD = 0;
30static HBITMAP hUpArrowI = 0;
31static HBITMAP hDnArrowI = 0;
32static HBITMAP hLfArrowI = 0;
33static HBITMAP hRgArrowI = 0;
34
35#define TOP_ARROW(flags,pressed) \
36 (((flags)&ESB_DISABLE_UP) ? hUpArrowI : ((pressed) ? hUpArrowD:hUpArrow))
37#define BOTTOM_ARROW(flags,pressed) \
38 (((flags)&ESB_DISABLE_DOWN) ? hDnArrowI : ((pressed) ? hDnArrowD:hDnArrow))
39#define LEFT_ARROW(flags,pressed) \
40 (((flags)&ESB_DISABLE_LEFT) ? hLfArrowI : ((pressed) ? hLfArrowD:hLfArrow))
41#define RIGHT_ARROW(flags,pressed) \
42 (((flags)&ESB_DISABLE_RIGHT) ? hRgArrowI : ((pressed) ? hRgArrowD:hRgArrow))
43
44
45 /* Minimum size of the rectangle between the arrows */
46#define SCROLL_MIN_RECT 4
47
48 /* Minimum size of the thumb in pixels */
49#define SCROLL_MIN_THUMB 6
50
51 /* Overlap between arrows and thumb */
52#define SCROLL_ARROW_THUMB_OVERLAP 0
53
54 /* Delay (in ms) before first repetition when holding the button down */
55#define SCROLL_FIRST_DELAY 200
56
57 /* Delay (in ms) between scroll repetitions */
58#define SCROLL_REPEAT_DELAY 50
59
60 /* Scroll timer id */
61#define SCROLL_TIMER 0
62
63 /* Scroll-bar hit testing */
64enum SCROLL_HITTEST
65{
66 SCROLL_NOWHERE, /* Outside the scroll bar */
67 SCROLL_TOP_ARROW, /* Top or left arrow */
68 SCROLL_TOP_RECT, /* Rectangle between the top arrow and the thumb */
69 SCROLL_THUMB, /* Thumb rectangle */
70 SCROLL_BOTTOM_RECT, /* Rectangle between the thumb and the bottom arrow */
71 SCROLL_BOTTOM_ARROW /* Bottom or right arrow */
72};
73
74 /* What to do after SCROLL_SetScrollInfo() */
75#define SA_SSI_HIDE 0x0001
76#define SA_SSI_SHOW 0x0002
77#define SA_SSI_REFRESH 0x0004
78#define SA_SSI_REPAINT_ARROWS 0x0008
79
80 /* Thumb-tracking info */
81static HWND SCROLL_TrackingWin = 0;
82static INT SCROLL_TrackingBar = 0;
83static INT SCROLL_TrackingPos = 0;
84static INT SCROLL_TrackingVal = 0;
85 /* Hit test code of the last button-down event */
86static enum SCROLL_HITTEST SCROLL_trackHitTest;
87static BOOL SCROLL_trackVertical;
88
89 /* Is the moving thumb being displayed? */
90static BOOL SCROLL_MovingThumb = FALSE;
91
92 /* Local functions */
93static BOOL SCROLL_ShowScrollBar( HWND hwnd, INT nBar,
94 BOOL fShowH, BOOL fShowV );
95static INT SCROLL_SetScrollInfo( HWND hwnd, INT nBar,
96 const SCROLLINFO *info, INT *action );
97static void SCROLL_DrawInterior_9x( HWND hwnd, HDC hdc, INT nBar,
98 RECT *rect, INT arrowSize,
99 INT thumbSize, INT thumbPos,
100 UINT flags, BOOL vertical,
101 BOOL top_selected, BOOL bottom_selected );
102
103/***********************************************************************
104 * SCROLL_LoadBitmaps
105 */
106static void SCROLL_LoadBitmaps(void)
107{
108 HINSTANCE hinst;
109
110 if (bitmapsLoaded) return;
111
112 //CB: Open32 hack to load our own bitmap
113 hinst = LoadLibraryA("USER32.DLL");
114 hUpArrow = NativeLoadBitmap( hinst, MAKEINTRESOURCEA(OBM_UPARROW) );
115 hDnArrow = NativeLoadBitmap( hinst, MAKEINTRESOURCEA(OBM_DNARROW) );
116 hLfArrow = NativeLoadBitmap( hinst, MAKEINTRESOURCEA(OBM_LFARROW) );
117 hRgArrow = NativeLoadBitmap( hinst, MAKEINTRESOURCEA(OBM_RGARROW) );
118 hUpArrowD = NativeLoadBitmap( hinst, MAKEINTRESOURCEA(OBM_UPARROWD) );
119 hDnArrowD = NativeLoadBitmap( hinst, MAKEINTRESOURCEA(OBM_DNARROWD) );
120 hLfArrowD = NativeLoadBitmap( hinst, MAKEINTRESOURCEA(OBM_LFARROWD) );
121 hRgArrowD = NativeLoadBitmap( hinst, MAKEINTRESOURCEA(OBM_RGARROWD) );
122 hUpArrowI = NativeLoadBitmap( hinst, MAKEINTRESOURCEA(OBM_UPARROWI) );
123 hDnArrowI = NativeLoadBitmap( hinst, MAKEINTRESOURCEA(OBM_DNARROWI) );
124 hLfArrowI = NativeLoadBitmap( hinst, MAKEINTRESOURCEA(OBM_LFARROWI) );
125 hRgArrowI = NativeLoadBitmap( hinst, MAKEINTRESOURCEA(OBM_RGARROWI) );
126 FreeLibrary(hinst);
127
128 bitmapsLoaded = TRUE;
129}
130
131/***********************************************************************
132 * SCROLL_GetInfoPtr
133 */
134static SCROLLBAR_INFO *SCROLL_GetInfoPtr( HWND hwnd, INT nBar )
135{
136 Win32BaseWindow *win32wnd;
137 HWND hwndFrame;
138
139 switch(nBar)
140 {
141 case SB_HORZ:
142 case SB_VERT:
143 win32wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
144 if (!win32wnd) return NULL;
145 hwndFrame = OSLibWinQueryWindow(win32wnd->getOS2WindowHandle(),QWOS_PARENT);
146 win32wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwndFrame);
147 if (!win32wnd) return NULL;
148 return win32wnd->getScrollInfo(nBar);
149
150 case SB_CTL:
151 return (SCROLLBAR_INFO*)GetInfoPtr(hwnd);
152 }
153
154 return NULL;
155}
156
157
158/***********************************************************************
159 * SCROLL_GetScrollBarRect
160 *
161 * Compute the scroll bar rectangle, in drawing coordinates (i.e. client
162 * coords for SB_CTL, window coords for SB_VERT and SB_HORZ).
163 * 'arrowSize' returns the width or height of an arrow (depending on
164 * the orientation of the scrollbar), 'thumbSize' returns the size of
165 * the thumb, and 'thumbPos' returns the position of the thumb
166 * relative to the left or to the top.
167 * Return TRUE if the scrollbar is vertical, FALSE if horizontal.
168 */
169static BOOL SCROLL_GetScrollBarRect( HWND hwnd, INT nBar, RECT *lprect,
170 INT *arrowSize, INT *thumbSize,
171 INT *thumbPos )
172{
173 INT pixels;
174 BOOL vertical;
175 RECT rectClient;
176
177 switch(nBar)
178 {
179 case SB_HORZ:
180 case SB_VERT:
181 GetClientRect( hwnd, lprect );
182 vertical = (nBar == SB_VERT);
183 break;
184
185 case SB_CTL:
186 {
187 DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
188
189 GetClientRect( hwnd, lprect );
190 vertical = ((dwStyle & SBS_VERT) != 0);
191 break;
192 }
193
194 default:
195 return FALSE;
196 }
197
198 if (vertical) pixels = lprect->bottom - lprect->top;
199 else pixels = lprect->right - lprect->left;
200
201 if (pixels <= 2*GetSystemMetrics(SM_CXVSCROLL) + SCROLL_MIN_RECT)
202 {
203 if (pixels > SCROLL_MIN_RECT)
204 *arrowSize = (pixels - SCROLL_MIN_RECT) / 2;
205 else
206 *arrowSize = 0;
207 *thumbPos = *thumbSize = 0;
208 }
209 else
210 {
211 SCROLLBAR_INFO *info = SCROLL_GetInfoPtr( hwnd, nBar );
212
213 *arrowSize = GetSystemMetrics(SM_CXVSCROLL);
214 pixels -= (2 * (GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP));
215
216 if (info->Page)
217 {
218 *thumbSize = pixels * info->Page / (info->MaxVal-info->MinVal+1);
219 if (*thumbSize < SCROLL_MIN_THUMB) *thumbSize = SCROLL_MIN_THUMB;
220 }
221 else *thumbSize = GetSystemMetrics(SM_CXVSCROLL);
222
223 if (((pixels -= *thumbSize ) < 0) ||
224 ((info->flags & ESB_DISABLE_BOTH) == ESB_DISABLE_BOTH))
225 {
226 /* Rectangle too small or scrollbar disabled -> no thumb */
227 *thumbPos = *thumbSize = 0;
228 }
229 else
230 {
231 INT max = info->MaxVal - MAX( info->Page-1, 0 );
232 if (info->MinVal >= max)
233 *thumbPos = *arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
234 else
235 *thumbPos = *arrowSize - SCROLL_ARROW_THUMB_OVERLAP
236 + pixels * (info->CurVal-info->MinVal) / (max - info->MinVal);
237 }
238 }
239 return vertical;
240}
241
242
243/***********************************************************************
244 * SCROLL_GetThumbVal
245 *
246 * Compute the current scroll position based on the thumb position in pixels
247 * from the top of the scroll-bar.
248 */
249static UINT SCROLL_GetThumbVal( SCROLLBAR_INFO *infoPtr, RECT *rect,
250 BOOL vertical, INT pos )
251{
252 INT thumbSize;
253 INT pixels = vertical ? rect->bottom-rect->top : rect->right-rect->left;
254
255 if ((pixels -= 2*(GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP)) <= 0)
256 return infoPtr->MinVal;
257
258 if (infoPtr->Page)
259 {
260 thumbSize = pixels * infoPtr->Page/(infoPtr->MaxVal-infoPtr->MinVal+1);
261 if (thumbSize < SCROLL_MIN_THUMB) thumbSize = SCROLL_MIN_THUMB;
262 }
263 else thumbSize = GetSystemMetrics(SM_CXVSCROLL);
264
265 if ((pixels -= thumbSize) <= 0) return infoPtr->MinVal;
266
267 pos = MAX( 0, pos - (GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP) );
268 if (pos > pixels) pos = pixels;
269
270 if (!infoPtr->Page) pos *= infoPtr->MaxVal - infoPtr->MinVal;
271 else pos *= infoPtr->MaxVal - infoPtr->MinVal - infoPtr->Page + 1;
272 return infoPtr->MinVal + ((pos + pixels / 2) / pixels);
273}
274
275/***********************************************************************
276 * SCROLL_PtInRectEx
277 */
278static BOOL SCROLL_PtInRectEx( LPRECT lpRect, POINT pt, BOOL vertical )
279{
280 RECT rect = *lpRect;
281
282 if (vertical)
283 {
284 rect.left -= lpRect->right - lpRect->left;
285 rect.right += lpRect->right - lpRect->left;
286 }
287 else
288 {
289 rect.top -= lpRect->bottom - lpRect->top;
290 rect.bottom += lpRect->bottom - lpRect->top;
291 }
292 return PtInRect( &rect, pt );
293}
294
295/***********************************************************************
296 * SCROLL_ClipPos
297 */
298static POINT SCROLL_ClipPos( LPRECT lpRect, POINT pt )
299{
300 if( pt.x < lpRect->left )
301 pt.x = lpRect->left;
302 else
303 if( pt.x > lpRect->right )
304 pt.x = lpRect->right;
305
306 if( pt.y < lpRect->top )
307 pt.y = lpRect->top;
308 else
309 if( pt.y > lpRect->bottom )
310 pt.y = lpRect->bottom;
311
312 return pt;
313}
314
315
316/***********************************************************************
317 * SCROLL_HitTest
318 *
319 * Scroll-bar hit testing (don't confuse this with WM_NCHITTEST!).
320 */
321static enum SCROLL_HITTEST SCROLL_HitTest( HWND hwnd, INT nBar,
322 POINT pt, BOOL bDragging )
323{
324 INT arrowSize, thumbSize, thumbPos;
325 RECT rect;
326
327 BOOL vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
328 &arrowSize, &thumbSize, &thumbPos );
329
330 if ( (bDragging && !SCROLL_PtInRectEx( &rect, pt, vertical )) ||
331 (!PtInRect( &rect, pt )) ) return SCROLL_NOWHERE;
332
333 if (vertical)
334 {
335 if (pt.y < rect.top + arrowSize) return SCROLL_TOP_ARROW;
336 if (pt.y >= rect.bottom - arrowSize) return SCROLL_BOTTOM_ARROW;
337 if (!thumbPos) return SCROLL_TOP_RECT;
338 pt.y -= rect.top;
339 if (pt.y < thumbPos) return SCROLL_TOP_RECT;
340 if (pt.y >= thumbPos + thumbSize) return SCROLL_BOTTOM_RECT;
341 }
342 else /* horizontal */
343 {
344 if (pt.x < rect.left + arrowSize) return SCROLL_TOP_ARROW;
345 if (pt.x >= rect.right - arrowSize) return SCROLL_BOTTOM_ARROW;
346 if (!thumbPos) return SCROLL_TOP_RECT;
347 pt.x -= rect.left;
348 if (pt.x < thumbPos) return SCROLL_TOP_RECT;
349 if (pt.x >= thumbPos + thumbSize) return SCROLL_BOTTOM_RECT;
350 }
351 return SCROLL_THUMB;
352}
353
354/***********************************************************************
355 * SCROLL_DrawArrows
356 *
357 * Draw the scroll bar arrows.
358 */
359static void SCROLL_DrawArrows_9x( HDC hdc, SCROLLBAR_INFO *infoPtr,
360 RECT *rect, INT arrowSize, BOOL vertical,
361 BOOL top_pressed, BOOL bottom_pressed )
362{
363 RECT r;
364
365 r = *rect;
366 if( vertical )
367 r.bottom = r.top + arrowSize;
368 else
369 r.right = r.left + arrowSize;
370
371 DrawFrameControl( hdc, &r, DFC_SCROLL,
372 (vertical ? DFCS_SCROLLUP : DFCS_SCROLLLEFT)
373 | (top_pressed ? (DFCS_PUSHED | DFCS_FLAT) : 0 )
374 | (infoPtr->flags&ESB_DISABLE_LTUP ? DFCS_INACTIVE : 0 ) );
375
376 r = *rect;
377 if( vertical )
378 r.top = r.bottom-arrowSize;
379 else
380 r.left = r.right-arrowSize;
381
382 DrawFrameControl( hdc, &r, DFC_SCROLL,
383 (vertical ? DFCS_SCROLLDOWN : DFCS_SCROLLRIGHT)
384 | (bottom_pressed ? (DFCS_PUSHED | DFCS_FLAT) : 0 )
385 | (infoPtr->flags&ESB_DISABLE_RTDN ? DFCS_INACTIVE : 0) );
386}
387//******************************************************************************
388//******************************************************************************
389static void SCROLL_DrawArrows( HDC hdc, SCROLLBAR_INFO *infoPtr,
390 RECT *rect, INT arrowSize, BOOL vertical,
391 BOOL top_pressed, BOOL bottom_pressed )
392{
393 SCROLL_DrawArrows_9x( hdc, infoPtr, rect, arrowSize,
394 vertical, top_pressed,bottom_pressed );
395}
396
397
398/***********************************************************************
399 * SCROLL_DrawMovingThumb
400 *
401 * Draw the moving thumb rectangle.
402 */
403static void SCROLL_DrawMovingThumb( HDC hdc, RECT *rect, BOOL vertical,
404 INT arrowSize, INT thumbSize )
405{
406 INT pos = SCROLL_TrackingPos;
407 INT max_size;
408
409 if( vertical )
410 max_size = rect->bottom - rect->top;
411 else
412 max_size = rect->right - rect->left;
413
414 max_size -= (arrowSize-SCROLL_ARROW_THUMB_OVERLAP) + thumbSize;
415
416 if( pos < (arrowSize-SCROLL_ARROW_THUMB_OVERLAP) )
417 pos = (arrowSize-SCROLL_ARROW_THUMB_OVERLAP);
418 else if( pos > max_size )
419 pos = max_size;
420
421 SCROLL_DrawInterior_9x( SCROLL_TrackingWin, hdc, SCROLL_TrackingBar,
422 rect, arrowSize, thumbSize, pos,
423 0, vertical, FALSE, FALSE );
424
425 SCROLL_MovingThumb = !SCROLL_MovingThumb;
426}
427/***********************************************************************
428 * SCROLL_DrawInterior
429 *
430 * Draw the scroll bar interior (everything except the arrows).
431 */
432static void SCROLL_DrawInterior_9x( HWND hwnd, HDC hdc, INT nBar,
433 RECT *rect, INT arrowSize,
434 INT thumbSize, INT thumbPos,
435 UINT flags, BOOL vertical,
436 BOOL top_selected, BOOL bottom_selected )
437{
438 RECT r;
439 HPEN hSavePen;
440 HBRUSH hSaveBrush,hBrush;
441
442 /* Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
443 * The window-owned scrollbars need to call DEFWND_ControlColor
444 * to correctly setup default scrollbar colors
445 */
446 if (nBar == SB_CTL)
447 {
448 hBrush = (HBRUSH)SendMessageA( GetParent(hwnd), WM_CTLCOLORSCROLLBAR,
449 (WPARAM)hdc,(LPARAM)hwnd);
450 }
451 else
452 {
453 hBrush = (HBRUSH)SendMessageA( hwnd, WM_CTLCOLORSCROLLBAR,
454 (WPARAM)hdc,(LPARAM)hwnd);
455 }
456
457 hSavePen = SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
458 hSaveBrush = SelectObject( hdc, hBrush );
459
460 /* Calculate the scroll rectangle */
461 r = *rect;
462 if (vertical)
463 {
464 r.top += arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
465 r.bottom -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
466 }
467 else
468 {
469 r.left += arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
470 r.right -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
471 }
472
473 /* Draw the scroll rectangles and thumb */
474 if (!thumbPos) /* No thumb to draw */
475 {
476 PatBlt( hdc, r.left, r.top,
477 r.right - r.left, r.bottom - r.top,
478 PATCOPY );
479
480 /* cleanup and return */
481 SelectObject( hdc, hSavePen );
482 SelectObject( hdc, hSaveBrush );
483 return;
484 }
485
486 if (vertical)
487 {
488 PatBlt( hdc, r.left, r.top,
489 r.right - r.left,
490 thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP),
491 top_selected ? 0x0f0000 : PATCOPY );
492 r.top += thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
493 PatBlt( hdc, r.left, r.top + thumbSize,
494 r.right - r.left,
495 r.bottom - r.top - thumbSize,
496 bottom_selected ? 0x0f0000 : PATCOPY );
497 r.bottom = r.top + thumbSize;
498 }
499 else /* horizontal */
500 {
501 PatBlt( hdc, r.left, r.top,
502 thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP),
503 r.bottom - r.top,
504 top_selected ? 0x0f0000 : PATCOPY );
505 r.left += thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
506 PatBlt( hdc, r.left + thumbSize, r.top,
507 r.right - r.left - thumbSize,
508 r.bottom - r.top,
509 bottom_selected ? 0x0f0000 : PATCOPY );
510 r.right = r.left + thumbSize;
511 }
512
513 /* Draw the thumb */
514 DrawEdge( hdc, &r, EDGE_RAISED, BF_RECT | BF_MIDDLE );
515
516 /* cleanup */
517 SelectObject( hdc, hSavePen );
518 SelectObject( hdc, hSaveBrush );
519}
520//******************************************************************************
521//******************************************************************************
522static void SCROLL_DrawInterior( HWND hwnd, HDC hdc, INT nBar,
523 RECT *rect, INT arrowSize,
524 INT thumbSize, INT thumbPos,
525 UINT flags, BOOL vertical,
526 BOOL top_selected, BOOL bottom_selected )
527{
528 RECT r;
529 HPEN hSavePen;
530 HBRUSH hSaveBrush,hBrush;
531 BOOL Save_SCROLL_MovingThumb = SCROLL_MovingThumb;
532
533//SCROLL_DrawInterior_9x(hwnd,hdc,nBar,rect,arrowSize,thumbSize,thumbPos,flags,vertical,top_selected,bottom_selected);
534//return; //CB: improve!
535
536 if (Save_SCROLL_MovingThumb &&
537 (SCROLL_TrackingWin == hwnd) &&
538 (SCROLL_TrackingBar == nBar))
539 SCROLL_DrawMovingThumb( hdc, rect, vertical, arrowSize, thumbSize );
540
541 /* Select the correct brush and pen */
542
543 /* Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
544 * The window-owned scrollbars need to call DEFWND_ControlColor
545 * to correctly setup default scrollbar colors
546 */
547 if (nBar == SB_CTL) {
548 hBrush = (HBRUSH)SendMessageA( GetParent(hwnd), WM_CTLCOLORSCROLLBAR,
549 (WPARAM)hdc,(LPARAM)hwnd);
550 } else {
551 hBrush = (HBRUSH)SendMessageA( hwnd, WM_CTLCOLORSCROLLBAR,
552 (WPARAM)hdc,(LPARAM)hwnd);
553
554 }
555
556 hSavePen = SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
557 hSaveBrush = SelectObject( hdc, hBrush );
558
559 /* Calculate the scroll rectangle */
560
561 r = *rect;
562 if (vertical)
563 {
564 r.top += arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
565 r.bottom -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
566 }
567 else
568 {
569 r.left += arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
570 r.right -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
571 }
572
573 /* Draw the scroll bar frame */
574
575 /* Only draw outline if Win 3.1. Mar 24, 1999 - Ronald B. Cemer */
576
577 /* Draw the scroll rectangles and thumb */
578
579 if (!thumbPos) /* No thumb to draw */
580 {
581 INT offset = 0;
582
583 PatBlt( hdc, r.left+offset, r.top+offset,
584 r.right - r.left - 2*offset, r.bottom - r.top - 2*offset,
585 PATCOPY );
586
587 /* cleanup and return */
588 SelectObject( hdc, hSavePen );
589 SelectObject( hdc, hSaveBrush );
590 return;
591 }
592
593 if (vertical)
594 {
595 INT offset = 0;
596
597 PatBlt( hdc, r.left + offset, r.top + offset,
598 r.right - r.left - offset*2,
599 thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP) - offset,
600 top_selected ? 0x0f0000 : PATCOPY );
601 r.top += thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
602 PatBlt( hdc, r.left + offset, r.top + thumbSize,
603 r.right - r.left - offset*2,
604 r.bottom - r.top - thumbSize - offset,
605 bottom_selected ? 0x0f0000 : PATCOPY );
606 r.bottom = r.top + thumbSize;
607 }
608 else /* horizontal */
609 {
610 INT offset = 0;
611
612 PatBlt( hdc, r.left + offset, r.top + offset,
613 thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP),
614 r.bottom - r.top - offset*2,
615 top_selected ? 0x0f0000 : PATCOPY );
616 r.left += thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
617 PatBlt( hdc, r.left + thumbSize, r.top + offset,
618 r.right - r.left - thumbSize - offset,
619 r.bottom - r.top - offset*2,
620 bottom_selected ? 0x0f0000 : PATCOPY );
621 r.right = r.left + thumbSize;
622 }
623
624 /* Draw the thumb */
625
626 SelectObject( hdc, GetSysColorBrush(COLOR_BTNFACE) );
627
628 Rectangle( hdc, r.left+1, r.top+1, r.right-1, r.bottom-1 );
629
630 DrawEdge( hdc, &r, EDGE_RAISED, BF_RECT );
631
632 if (Save_SCROLL_MovingThumb &&
633 (SCROLL_TrackingWin == hwnd) &&
634 (SCROLL_TrackingBar == nBar))
635 SCROLL_DrawMovingThumb( hdc, rect, vertical, arrowSize, thumbSize );
636
637 /* cleanup */
638 SelectObject( hdc, hSavePen );
639 SelectObject( hdc, hSaveBrush );
640}
641/***********************************************************************
642 * SCROLL_DrawScrollBar
643 *
644 * Redraw the whole scrollbar.
645 */
646void SCROLL_DrawScrollBar( HWND hwnd, HDC hdc, INT nBar,
647 BOOL arrows, BOOL interior )
648{
649 INT arrowSize, thumbSize, thumbPos;
650 RECT rect;
651 BOOL vertical;
652 SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
653 BOOL Save_SCROLL_MovingThumb = SCROLL_MovingThumb;
654
655 vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
656 &arrowSize, &thumbSize, &thumbPos );
657
658 if (Save_SCROLL_MovingThumb &&
659 (SCROLL_TrackingWin == hwnd) &&
660 (SCROLL_TrackingBar == nBar))
661 SCROLL_DrawMovingThumb( hdc, &rect, vertical, arrowSize, thumbSize );
662
663 /* Draw the arrows */
664
665 if (arrows && arrowSize)
666 {
667 if( vertical == SCROLL_trackVertical && GetCapture() == hwnd )
668 SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
669 (SCROLL_trackHitTest == SCROLL_TOP_ARROW),
670 (SCROLL_trackHitTest == SCROLL_BOTTOM_ARROW) );
671 else
672 SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
673 FALSE, FALSE );
674 }
675 if( interior )
676 SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
677 thumbPos, infoPtr->flags, vertical, FALSE, FALSE );
678
679 if (Save_SCROLL_MovingThumb &&
680 (SCROLL_TrackingWin == hwnd) &&
681 (SCROLL_TrackingBar == nBar))
682 SCROLL_DrawMovingThumb( hdc, &rect, vertical, arrowSize, thumbSize );
683
684}
685/***********************************************************************
686 * SCROLL_RefreshScrollBar
687 *
688 * Repaint the scroll bar interior after a SetScrollRange() or
689 * SetScrollPos() call.
690 */
691static void SCROLL_RefreshScrollBar( HWND hwnd, INT nBar,
692 BOOL arrows, BOOL interior )
693{
694 Win32BaseWindow *window;
695 HWND hwndScroll;
696 HDC hdc;
697
698 //SvL: Get scrollbar handle from parent window
699 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
700 if(!window && nBar != SB_CTL) {
701 dprintf(("SCROLL_RefreshScrollBar window %x not found!", hwnd));
702 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
703 return;
704 }
705 if(nBar == SB_VERT)
706 {
707 hwndScroll = Win32BaseWindow::OS2ToWin32Handle(window->getVertScrollHandle());
708 }
709 else
710 if(nBar == SB_HORZ)
711 {
712 hwndScroll = Win32BaseWindow::OS2ToWin32Handle(window->getHorzScrollHandle());
713 }
714 else hwndScroll = hwnd;
715
716 if(hwndScroll == 0)
717 return;
718
719 hdc = GetDCEx( hwndScroll, 0, DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW));
720
721 if (!hdc) return;
722
723 SCROLL_DrawScrollBar( hwndScroll, hdc, nBar, arrows, interior );
724 ReleaseDC( hwndScroll, hdc );
725}
726/***********************************************************************
727 * SCROLL_HandleKbdEvent
728 *
729 * Handle a keyboard event (only for SB_CTL scrollbars).
730 */
731static void SCROLL_HandleKbdEvent( HWND hwnd, WPARAM wParam )
732{
733 DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
734 WPARAM msg;
735
736 switch(wParam)
737 {
738 case VK_PRIOR: msg = SB_PAGEUP; break;
739 case VK_NEXT: msg = SB_PAGEDOWN; break;
740 case VK_HOME: msg = SB_TOP; break;
741 case VK_END: msg = SB_BOTTOM; break;
742 case VK_UP: msg = SB_LINEUP; break;
743 case VK_DOWN: msg = SB_LINEDOWN; break;
744 default:
745 return;
746 }
747 SendMessageA( GetParent(hwnd),
748 (dwStyle & SBS_VERT) ? WM_VSCROLL : WM_HSCROLL,
749 msg, hwnd );
750}
751/***********************************************************************
752 * SCROLL_HandleScrollEvent
753 *
754 * Handle a mouse or timer event for the scrollbar.
755 * 'pt' is the location of the mouse event in client (for SB_CTL) or
756 * windows coordinates.
757 */
758void SCROLL_HandleScrollEvent( HWND hwnd, INT nBar, UINT msg, POINT pt)
759{
760 /* Previous mouse position for timer events */
761 static POINT prevPt;
762 /* Thumb position when tracking started. */
763 static UINT trackThumbPos;
764 /* Position in the scroll-bar of the last button-down event. */
765 static INT lastClickPos;
766 /* Position in the scroll-bar of the last mouse event. */
767 static INT lastMousePos;
768
769 enum SCROLL_HITTEST hittest;
770 HWND hwndOwner, hwndCtl;
771 BOOL vertical;
772 INT arrowSize, thumbSize, thumbPos;
773 RECT rect;
774 HDC hdc;
775
776 SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
777 if (!infoPtr) return;
778 if ((SCROLL_trackHitTest == SCROLL_NOWHERE) && (msg != WM_LBUTTONDOWN))
779 return;
780
781 vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
782 &arrowSize, &thumbSize, &thumbPos );
783 if (nBar == SB_CTL) hwndOwner = GetParent(hwnd); else
784 {
785 Win32BaseWindow *win32wnd;
786 HWND hwndFrame;
787
788 win32wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
789 if (!win32wnd) return;
790 hwndFrame = OSLibWinQueryWindow(win32wnd->getOS2WindowHandle(),QWOS_PARENT);
791 win32wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwndFrame);
792 if (!win32wnd) return;
793 hwndOwner = win32wnd->getWindowHandle();
794 }
795
796 hwndCtl = (nBar == SB_CTL) ? hwnd : 0;
797
798 switch(msg)
799 {
800 case WM_LBUTTONDOWN: /* Initialise mouse tracking */
801 SCROLL_trackVertical = vertical;
802 SCROLL_trackHitTest = hittest = SCROLL_HitTest( hwnd, nBar, pt, FALSE );
803 lastClickPos = vertical ? (pt.y - rect.top) : (pt.x - rect.left);
804 lastMousePos = lastClickPos;
805 trackThumbPos = thumbPos;
806 prevPt = pt;
807 SetCapture( hwnd );
808 if (nBar == SB_CTL) SetFocus( hwnd );
809 break;
810
811 case WM_MOUSEMOVE:
812 hittest = SCROLL_HitTest( hwnd, nBar, pt, TRUE );
813 prevPt = pt;
814 break;
815
816 case WM_LBUTTONUP:
817 hittest = SCROLL_NOWHERE;
818 ReleaseCapture();
819 break;
820
821 case WM_SYSTIMER:
822 pt = prevPt;
823 hittest = SCROLL_HitTest( hwnd, nBar, pt, FALSE );
824 break;
825
826 default:
827 return; /* Should never happen */
828 }
829
830 hdc = GetDCEx( hwnd, 0, DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW));
831
832 //TRACE("Event: hwnd=%04x bar=%d msg=%x pt=%ld,%ld hit=%d\n",
833 // hwnd, nBar, msg, pt.x, pt.y, hittest );
834
835 switch(SCROLL_trackHitTest)
836 {
837 case SCROLL_NOWHERE: /* No tracking in progress */
838 break;
839
840 case SCROLL_TOP_ARROW:
841 SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
842 (hittest == SCROLL_trackHitTest), FALSE );
843 if (hittest == SCROLL_trackHitTest)
844 {
845 if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
846 {
847 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
848 SB_LINEUP, hwndCtl );
849 }
850 SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
851 SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
852 (TIMERPROC)0 );
853 }
854 else KillSystemTimer( hwnd, SCROLL_TIMER );
855 break;
856
857 case SCROLL_TOP_RECT:
858 SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
859 thumbPos, infoPtr->flags, vertical,
860 (hittest == SCROLL_trackHitTest), FALSE );
861 if (hittest == SCROLL_trackHitTest)
862 {
863 if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
864 {
865 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
866 SB_PAGEUP, hwndCtl );
867 SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
868 SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
869 (TIMERPROC)0 );
870 }
871 }
872 else KillSystemTimer( hwnd, SCROLL_TIMER );
873 break;
874
875 case SCROLL_THUMB:
876 if (msg == WM_LBUTTONDOWN)
877 {
878 SCROLL_TrackingWin = hwnd;
879 SCROLL_TrackingBar = nBar;
880 SCROLL_TrackingPos = trackThumbPos + lastMousePos - lastClickPos;
881 if (!SCROLL_MovingThumb)
882 SCROLL_DrawMovingThumb(hdc, &rect, vertical, arrowSize, thumbSize);
883 }
884 else if (msg == WM_LBUTTONUP)
885 {
886 if (SCROLL_MovingThumb)
887 SCROLL_DrawMovingThumb(hdc, &rect, vertical, arrowSize, thumbSize);
888 SCROLL_TrackingWin = 0;
889 SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
890 thumbPos, infoPtr->flags, vertical,
891 FALSE, FALSE );
892 }
893 else /* WM_MOUSEMOVE */
894 {
895 UINT pos;
896
897 if (!SCROLL_PtInRectEx( &rect, pt, vertical )) pos = lastClickPos;
898 else
899 {
900 pt = SCROLL_ClipPos( &rect, pt );
901 pos = vertical ? (pt.y - rect.top) : (pt.x - rect.left);
902 }
903 if ( (pos != lastMousePos) || (!SCROLL_MovingThumb) )
904 {
905 if (SCROLL_MovingThumb)
906 SCROLL_DrawMovingThumb( hdc, &rect, vertical,
907 arrowSize, thumbSize );
908 lastMousePos = pos;
909 SCROLL_TrackingPos = trackThumbPos + pos - lastClickPos;
910 SCROLL_TrackingVal = SCROLL_GetThumbVal( infoPtr, &rect,
911 vertical,
912 SCROLL_TrackingPos );
913 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
914 MAKEWPARAM( SB_THUMBTRACK, SCROLL_TrackingVal),
915 hwndCtl );
916 if (!SCROLL_MovingThumb)
917 SCROLL_DrawMovingThumb( hdc, &rect, vertical,
918 arrowSize, thumbSize );
919 }
920 }
921 break;
922
923 case SCROLL_BOTTOM_RECT:
924 SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
925 thumbPos, infoPtr->flags, vertical,
926 FALSE, (hittest == SCROLL_trackHitTest) );
927 if (hittest == SCROLL_trackHitTest)
928 {
929 if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
930 {
931 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
932 SB_PAGEDOWN, hwndCtl );
933 SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
934 SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
935 (TIMERPROC)0 );
936 }
937 }
938 else KillSystemTimer( hwnd, SCROLL_TIMER );
939 break;
940
941 case SCROLL_BOTTOM_ARROW:
942 SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
943 FALSE, (hittest == SCROLL_trackHitTest) );
944 if (hittest == SCROLL_trackHitTest)
945 {
946 if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
947 {
948 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
949 SB_LINEDOWN, hwndCtl );
950 }
951 SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
952 SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
953 (TIMERPROC)0 );
954 }
955 else KillSystemTimer( hwnd, SCROLL_TIMER );
956 break;
957 }
958
959 if (msg == WM_LBUTTONUP)
960 {
961 hittest = SCROLL_trackHitTest;
962 SCROLL_trackHitTest = SCROLL_NOWHERE; /* Terminate tracking */
963
964 if (hittest == SCROLL_THUMB)
965 {
966 UINT val = SCROLL_GetThumbVal( infoPtr, &rect, vertical,
967 trackThumbPos + lastMousePos - lastClickPos );
968 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
969 MAKEWPARAM( SB_THUMBPOSITION, val ), hwndCtl );
970 }
971 else
972 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
973 SB_ENDSCROLL, hwndCtl );
974 }
975
976 ReleaseDC( hwnd, hdc );
977}
978/***********************************************************************
979 * ScrollBarWndProc
980 */
981LRESULT WINAPI ScrollBarWndProc( HWND hwnd, UINT message, WPARAM wParam,
982 LPARAM lParam )
983{
984 switch(message)
985 {
986 case WM_NCCREATE:
987 {
988 SCROLLBAR_INFO *infoPtr = (SCROLLBAR_INFO*)malloc(sizeof(SCROLLBAR_INFO));
989
990 infoPtr->MinVal = infoPtr->CurVal = infoPtr->Page = 0;
991 infoPtr->MaxVal = 100;
992 infoPtr->flags = ESB_ENABLE_BOTH;
993
994 SetInfoPtr(hwnd,(DWORD)infoPtr);
995
996 if (!bitmapsLoaded) SCROLL_LoadBitmaps();
997
998 return TRUE;
999 }
1000 case WM_CREATE:
1001 {
1002 CREATESTRUCTA *lpCreat = (CREATESTRUCTA *)lParam;
1003 if (lpCreat->style & SBS_SIZEBOX)
1004 {
1005 //FIXME("Unimplemented style SBS_SIZEBOX.\n" );
1006 return 0; //CB: implement! (for frames/toolbar already done)
1007 }
1008
1009 if (lpCreat->style & SBS_VERT)
1010 {
1011 if (lpCreat->style & SBS_LEFTALIGN)
1012 MoveWindow( hwnd, lpCreat->x, lpCreat->y,
1013 GetSystemMetrics(SM_CXVSCROLL)+1, lpCreat->cy, FALSE );
1014 else if (lpCreat->style & SBS_RIGHTALIGN)
1015 MoveWindow( hwnd,
1016 lpCreat->x+lpCreat->cx-GetSystemMetrics(SM_CXVSCROLL)-1,
1017 lpCreat->y,
1018 GetSystemMetrics(SM_CXVSCROLL)+1, lpCreat->cy, FALSE );
1019 }
1020 else /* SBS_HORZ */
1021 {
1022 if (lpCreat->style & SBS_TOPALIGN)
1023 MoveWindow( hwnd, lpCreat->x, lpCreat->y,
1024 lpCreat->cx, GetSystemMetrics(SM_CYHSCROLL)+1, FALSE );
1025 else if (lpCreat->style & SBS_BOTTOMALIGN)
1026 MoveWindow( hwnd,
1027 lpCreat->x,
1028 lpCreat->y+lpCreat->cy-GetSystemMetrics(SM_CYHSCROLL)-1,
1029 lpCreat->cx, GetSystemMetrics(SM_CYHSCROLL)+1, FALSE );
1030 }
1031 }
1032
1033 //TRACE("ScrollBar creation, hwnd=%04x\n", hwnd );
1034 return 0;
1035
1036 case WM_LBUTTONDOWN:
1037 case WM_LBUTTONUP:
1038 case WM_MOUSEMOVE:
1039 case WM_SYSTIMER:
1040 {
1041 POINT pt;
1042 CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
1043 SCROLL_HandleScrollEvent( hwnd, SB_CTL, message, pt );
1044 }
1045 break;
1046
1047 case WM_KEYDOWN:
1048 SCROLL_HandleKbdEvent( hwnd, wParam );
1049 break;
1050
1051 case WM_ERASEBKGND:
1052 return 1;
1053
1054 case WM_GETDLGCODE:
1055 return DLGC_WANTARROWS; /* Windows returns this value */
1056
1057 case WM_PAINT:
1058 {
1059 PAINTSTRUCT ps;
1060 HDC hdc = BeginPaint( hwnd, &ps );
1061 SCROLL_DrawScrollBar( hwnd, hdc, SB_CTL, TRUE, TRUE );
1062 EndPaint( hwnd, &ps );
1063 }
1064 break;
1065
1066 case SBM_SETPOS:
1067 return SetScrollPos( hwnd, SB_CTL, wParam, (BOOL)lParam );
1068
1069 case SBM_GETPOS:
1070 return GetScrollPos( hwnd, SB_CTL );
1071
1072 case SBM_SETRANGE:
1073 {
1074 SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_CTL);
1075 INT oldPos = infoPtr->CurVal;
1076
1077 SetScrollRange(hwnd,SB_CTL,wParam,lParam,FALSE);
1078 return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
1079 }
1080
1081 case SBM_GETRANGE:
1082 GetScrollRange( hwnd, SB_CTL, (LPINT)wParam, (LPINT)lParam );
1083 return 0;
1084
1085 case SBM_ENABLE_ARROWS:
1086 return EnableScrollBar( hwnd, SB_CTL, wParam );
1087
1088 case SBM_SETRANGEREDRAW:
1089 {
1090 SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_CTL);
1091 INT oldPos = infoPtr->CurVal;
1092
1093 SetScrollRange(hwnd,SB_CTL,wParam,lParam,TRUE);
1094 return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
1095 }
1096
1097 case SBM_SETSCROLLINFO:
1098 return SetScrollInfo( hwnd, SB_CTL, (SCROLLINFO *)lParam, wParam );
1099
1100 case SBM_GETSCROLLINFO:
1101 return GetScrollInfo( hwnd, SB_CTL, (SCROLLINFO *)lParam );
1102
1103 case 0x00e5:
1104 case 0x00e7:
1105 case 0x00e8:
1106 case 0x00eb:
1107 case 0x00ec:
1108 case 0x00ed:
1109 case 0x00ee:
1110 case 0x00ef:
1111 //ERR("unknown Win32 msg %04x wp=%08x lp=%08lx\n",
1112 // message, wParam, lParam );
1113 break;
1114
1115 default:
1116 return DefWindowProcA( hwnd, message, wParam, lParam );
1117 }
1118 return 0;
1119}
1120
1121/* frame handlers */
1122
1123VOID SCROLL_SubclassScrollBars(HWND hwndHorz,HWND hwndVert)
1124{
1125 if (hwndHorz)
1126 {
1127 SetWindowLongA(hwndHorz,GWL_WNDPROC,(ULONG)HorzScrollBarWndProc);
1128 //windowClass = Win32WndClass::FindClass(cs->hInstance, (LPSTR)classAtom);
1129// InvalidateRect(hwndHorz,NULL,FALSE);
1130 }
1131
1132 if (hwndVert)
1133 {
1134 SetWindowLongA(hwndVert,GWL_WNDPROC,(ULONG)VertScrollBarWndProc);
1135// InvalidateRect(hwndVert,NULL,FALSE);
1136 }
1137
1138 if (!bitmapsLoaded) SCROLL_LoadBitmaps();
1139}
1140
1141LRESULT WINAPI HorzScrollBarWndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam )
1142{
1143 switch (message)
1144 {
1145 case WM_LBUTTONDOWN:
1146 case WM_LBUTTONUP:
1147 case WM_MOUSEMOVE:
1148 case WM_SYSTIMER:
1149 {
1150 POINT pt;
1151 CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
1152 SCROLL_HandleScrollEvent( hwnd, SB_HORZ, message, pt );
1153 if(message == WM_MOUSEMOVE) {
1154 return 1; //SvL: Let PM change the mouse cursor to the default
1155 }
1156 }
1157 break;
1158
1159 case WM_ERASEBKGND:
1160 return 1;
1161
1162 case WM_GETDLGCODE:
1163 return DLGC_WANTARROWS; /* Windows returns this value */
1164
1165 case WM_PAINT:
1166 {
1167 PAINTSTRUCT ps;
1168
1169 HDC hdc = BeginPaint( hwnd, &ps );
1170 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1171 EndPaint( hwnd, &ps );
1172 }
1173 break;
1174
1175 case SBM_SETPOS:
1176 return SetScrollPos( hwnd, SB_HORZ, wParam, (BOOL)lParam );
1177
1178 case SBM_GETPOS:
1179 return GetScrollPos( hwnd, SB_HORZ );
1180
1181 case SBM_SETRANGE:
1182 {
1183 SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_HORZ);
1184 INT oldPos = infoPtr->CurVal;
1185
1186 SetScrollRange(hwnd,SB_HORZ,wParam,lParam,FALSE);
1187 return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
1188 }
1189
1190 case SBM_GETRANGE:
1191 GetScrollRange( hwnd, SB_HORZ, (LPINT)wParam, (LPINT)lParam );
1192 return 0;
1193
1194 case SBM_ENABLE_ARROWS:
1195 return EnableScrollBar( hwnd, SB_HORZ, wParam );
1196
1197 case SBM_SETRANGEREDRAW:
1198 {
1199 SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_HORZ);
1200 INT oldPos = infoPtr->CurVal;
1201
1202 SetScrollRange(hwnd,SB_HORZ,wParam,lParam,TRUE);
1203 return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
1204 }
1205
1206 case SBM_SETSCROLLINFO:
1207 return SetScrollInfo( hwnd, SB_HORZ, (SCROLLINFO *)lParam, wParam );
1208
1209 case SBM_GETSCROLLINFO:
1210 return GetScrollInfo( hwnd, SB_HORZ, (SCROLLINFO *)lParam );
1211
1212 default:
1213 return DefWindowProcA(hwnd,message,wParam,lParam);
1214 }
1215
1216 return 0;
1217}
1218
1219LRESULT WINAPI VertScrollBarWndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam )
1220{
1221 switch (message)
1222 {
1223 case WM_LBUTTONDOWN:
1224 case WM_LBUTTONUP:
1225 case WM_MOUSEMOVE:
1226 case WM_SYSTIMER:
1227 {
1228 POINT pt;
1229 CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
1230 SCROLL_HandleScrollEvent( hwnd, SB_VERT, message, pt );
1231 if(message == WM_MOUSEMOVE) {
1232 return 1; //SvL: Let PM change the mouse cursor to the default
1233 }
1234 }
1235 break;
1236
1237 case WM_ERASEBKGND:
1238 return 1;
1239
1240 case WM_GETDLGCODE:
1241 return DLGC_WANTARROWS; /* Windows returns this value */
1242
1243 case WM_PAINT:
1244 {
1245 PAINTSTRUCT ps;
1246
1247 HDC hdc = BeginPaint( hwnd, &ps );
1248 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1249 EndPaint( hwnd, &ps );
1250 }
1251 break;
1252
1253 case SBM_SETPOS:
1254 return SetScrollPos( hwnd, SB_VERT, wParam, (BOOL)lParam );
1255
1256 case SBM_GETPOS:
1257 return GetScrollPos( hwnd, SB_VERT );
1258
1259 case SBM_SETRANGE:
1260 {
1261 SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_VERT);
1262 INT oldPos = infoPtr->CurVal;
1263
1264 SetScrollRange(hwnd,SB_VERT,wParam,lParam,FALSE);
1265 return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
1266 }
1267
1268 case SBM_GETRANGE:
1269 GetScrollRange( hwnd, SB_VERT, (LPINT)wParam, (LPINT)lParam );
1270 return 0;
1271
1272 case SBM_ENABLE_ARROWS:
1273 return EnableScrollBar( hwnd, SB_VERT, wParam );
1274
1275 case SBM_SETRANGEREDRAW:
1276 {
1277 SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_VERT);
1278 INT oldPos = infoPtr->CurVal;
1279
1280 SetScrollRange(hwnd,SB_VERT,wParam,lParam,TRUE);
1281 return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
1282 }
1283
1284 case SBM_SETSCROLLINFO:
1285 return SetScrollInfo( hwnd, SB_VERT, (SCROLLINFO *)lParam, wParam );
1286
1287 case SBM_GETSCROLLINFO:
1288 return GetScrollInfo( hwnd, SB_VERT, (SCROLLINFO *)lParam );
1289
1290 default:
1291 return DefWindowProcA(hwnd,message,wParam,lParam);
1292 }
1293
1294 return 0;
1295}
1296
1297
1298/*************************************************************************
1299 * SetScrollInfo32 (USER32.501)
1300 * SetScrollInfo32 can be used to set the position, upper bound,
1301 * lower bound, and page size of a scrollbar control.
1302 *
1303 * RETURNS
1304 * Scrollbar position
1305 *
1306 * NOTE
1307 * For 100 lines of text to be displayed in a window of 25 lines,
1308 * one would for instance use info->nMin=0, info->nMax=75
1309 * (corresponding to the 76 different positions of the window on
1310 * the text), and info->nPage=25.
1311 */
1312INT WINAPI SetScrollInfo(
1313 HWND hwnd /* [I] Handle of window whose scrollbar will be affected */,
1314 INT nBar /* [I] One of SB_HORZ, SB_VERT, or SB_CTL */,
1315 const SCROLLINFO *info /* [I] Specifies what to change and new values */,
1316 BOOL bRedraw /* [I] Should scrollbar be redrawn afterwards ? */)
1317{
1318 Win32BaseWindow *window;
1319 INT action;
1320 INT retVal;
1321
1322 retVal = SCROLL_SetScrollInfo( hwnd, nBar, info, &action );
1323 if( action & SA_SSI_HIDE )
1324 SCROLL_ShowScrollBar( hwnd, nBar, FALSE, FALSE );
1325 else
1326 {
1327 if( action & SA_SSI_SHOW )
1328 if( SCROLL_ShowScrollBar( hwnd, nBar, TRUE, TRUE ) )
1329 return retVal; /* SetWindowPos() already did the painting */
1330
1331 if( bRedraw && (action & SA_SSI_REFRESH))
1332 SCROLL_RefreshScrollBar( hwnd, nBar, TRUE, TRUE );
1333 else if( action & SA_SSI_REPAINT_ARROWS )
1334 SCROLL_RefreshScrollBar( hwnd, nBar, TRUE, FALSE );
1335 }
1336 return retVal;
1337}
1338//******************************************************************************
1339//******************************************************************************
1340INT SCROLL_SetScrollInfo( HWND hwnd, INT nBar,
1341 const SCROLLINFO *info, INT *action )
1342{
1343 /* Update the scrollbar state and set action flags according to
1344 * what has to be done graphics wise. */
1345
1346 SCROLLBAR_INFO *infoPtr;
1347 UINT new_flags;
1348
1349 *action = 0;
1350
1351 if (!(infoPtr = SCROLL_GetInfoPtr(hwnd, nBar))) return 0;
1352 if (info->fMask & ~(SIF_ALL | SIF_DISABLENOSCROLL)) return 0;
1353 if ((info->cbSize != sizeof(*info)) &&
1354 (info->cbSize != sizeof(*info)-sizeof(info->nTrackPos))) return 0;
1355
1356 /* Set the page size */
1357 if (info->fMask & SIF_PAGE)
1358 {
1359 if( infoPtr->Page != info->nPage )
1360 {
1361 infoPtr->Page = info->nPage;
1362 *action |= SA_SSI_REFRESH;
1363 }
1364 }
1365
1366 /* Set the scroll pos */
1367 if (info->fMask & SIF_POS)
1368 {
1369 //dsprintf(scroll, " pos=%d", info->nPos );
1370 if( infoPtr->CurVal != info->nPos )
1371 {
1372 infoPtr->CurVal = info->nPos;
1373 *action |= SA_SSI_REFRESH;
1374 }
1375 }
1376
1377 /* Set the scroll range */
1378 if (info->fMask & SIF_RANGE)
1379 {
1380 /* Invalid range -> range is set to (0,0) */
1381 if ((info->nMin > info->nMax) ||
1382 ((UINT)(info->nMax - info->nMin) >= 0x80000000))
1383 {
1384 infoPtr->MinVal = 0;
1385 infoPtr->MaxVal = 0;
1386 }
1387 else
1388 {
1389 if( infoPtr->MinVal != info->nMin ||
1390 infoPtr->MaxVal != info->nMax )
1391 {
1392 *action |= SA_SSI_REFRESH;
1393 infoPtr->MinVal = info->nMin;
1394 infoPtr->MaxVal = info->nMax;
1395 }
1396 }
1397 }
1398
1399 /* Make sure the page size is valid */
1400
1401 if (infoPtr->Page < 0) infoPtr->Page = 0;
1402 else if (infoPtr->Page > infoPtr->MaxVal - infoPtr->MinVal + 1 )
1403 infoPtr->Page = infoPtr->MaxVal - infoPtr->MinVal + 1;
1404
1405 /* Make sure the pos is inside the range */
1406
1407 if (infoPtr->CurVal < infoPtr->MinVal)
1408 infoPtr->CurVal = infoPtr->MinVal;
1409 else if (infoPtr->CurVal > infoPtr->MaxVal - MAX( infoPtr->Page-1, 0 ))
1410 infoPtr->CurVal = infoPtr->MaxVal - MAX( infoPtr->Page-1, 0 );
1411
1412 //TRACE(" new values: page=%d pos=%d min=%d max=%d\n",
1413 // infoPtr->Page, infoPtr->CurVal,
1414 // infoPtr->MinVal, infoPtr->MaxVal );
1415
1416 /* Check if the scrollbar should be hidden or disabled */
1417 if (info->fMask & (SIF_RANGE | SIF_PAGE | SIF_DISABLENOSCROLL))
1418 {
1419 new_flags = infoPtr->flags;
1420 if (infoPtr->MinVal >= infoPtr->MaxVal - MAX( infoPtr->Page-1, 0 ))
1421 {
1422 /* Hide or disable scroll-bar */
1423 if (info->fMask & SIF_DISABLENOSCROLL)
1424 {
1425 new_flags = ESB_DISABLE_BOTH;
1426 *action |= SA_SSI_REFRESH;
1427 }
1428 else if (nBar != SB_CTL)
1429 {
1430 *action = SA_SSI_HIDE;
1431 goto done;
1432 }
1433 }
1434 else /* Show and enable scroll-bar */
1435 {
1436 new_flags = 0;
1437 if (nBar != SB_CTL)
1438 *action |= SA_SSI_SHOW;
1439 }
1440
1441 if (infoPtr->flags != new_flags) /* check arrow flags */
1442 {
1443 infoPtr->flags = new_flags;
1444 *action |= SA_SSI_REPAINT_ARROWS;
1445 }
1446 }
1447
1448done:
1449 /* Return current position */
1450
1451 return infoPtr->CurVal;
1452}
1453/*************************************************************************
1454 * GetScrollInfo32 (USER32.284)
1455 * GetScrollInfo32 can be used to retrieve the position, upper bound,
1456 * lower bound, and page size of a scrollbar control.
1457 *
1458 * RETURNS STD
1459 */
1460BOOL WINAPI GetScrollInfo(
1461 HWND hwnd /* [I] Handle of window */ ,
1462 INT nBar /* [I] One of SB_HORZ, SB_VERT, or SB_CTL */,
1463 LPSCROLLINFO info /* [IO] (info.fMask [I] specifies which values are to retrieve) */)
1464{
1465 SCROLLBAR_INFO *infoPtr;
1466
1467 if (!(infoPtr = SCROLL_GetInfoPtr( hwnd, nBar ))) return FALSE;
1468 if (info->fMask & ~(SIF_ALL | SIF_DISABLENOSCROLL)) return FALSE;
1469 if ((info->cbSize != sizeof(*info)) &&
1470 (info->cbSize != sizeof(*info)-sizeof(info->nTrackPos))) return FALSE;
1471
1472 if (info->fMask & SIF_PAGE) info->nPage = infoPtr->Page;
1473 if (info->fMask & SIF_POS) info->nPos = infoPtr->CurVal;
1474 if ((info->fMask & SIF_TRACKPOS) && (info->cbSize == sizeof(*info)))
1475 info->nTrackPos = (SCROLL_TrackingWin==hwnd) ? SCROLL_TrackingVal : infoPtr->CurVal;
1476 if (info->fMask & SIF_RANGE)
1477 {
1478 info->nMin = infoPtr->MinVal;
1479 info->nMax = infoPtr->MaxVal;
1480 }
1481 return (info->fMask & SIF_ALL) != 0;
1482}
1483/*************************************************************************
1484 * SetScrollPos32 (USER32.502)
1485 *
1486 * RETURNS
1487 * Success: Scrollbar position
1488 * Failure: 0
1489 *
1490 * REMARKS
1491 * Note the ambiguity when 0 is returned. Use GetLastError
1492 * to make sure there was an error (and to know which one).
1493 */
1494INT WINAPI SetScrollPos(
1495 HWND hwnd /* [I] Handle of window whose scrollbar will be affected */,
1496 INT nBar /* [I] One of SB_HORZ, SB_VERT, or SB_CTL */,
1497 INT nPos /* [I] New value */,
1498 BOOL bRedraw /* [I] Should scrollbar be redrawn afterwards ? */ )
1499{
1500 SCROLLINFO info;
1501 SCROLLBAR_INFO *infoPtr;
1502 INT oldPos;
1503
1504 dprintf(("SetScrollPos %x %d %d %d", hwnd, nBar, nPos, bRedraw));
1505 if (!(infoPtr = SCROLL_GetInfoPtr( hwnd, nBar ))) return 0;
1506 oldPos = infoPtr->CurVal;
1507 info.cbSize = sizeof(info);
1508 info.nPos = nPos;
1509 info.fMask = SIF_POS;
1510 SetScrollInfo( hwnd, nBar, &info, bRedraw );
1511 return oldPos;
1512}
1513/*************************************************************************
1514 * GetScrollPos32 (USER32.285)
1515 *
1516 * RETURNS
1517 * Success: Current position
1518 * Failure: 0
1519 *
1520 * REMARKS
1521 * Note the ambiguity when 0 is returned. Use GetLastError
1522 * to make sure there was an error (and to know which one).
1523 */
1524INT WINAPI GetScrollPos(
1525 HWND hwnd, /* [I] Handle of window */
1526 INT nBar /* [I] One of SB_HORZ, SB_VERT, or SB_CTL */)
1527{
1528 SCROLLBAR_INFO *infoPtr;
1529
1530 dprintf(("GetScrollPos %x %d", hwnd, nBar));
1531
1532 infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
1533 if (!infoPtr) return 0;
1534
1535 return infoPtr->CurVal;
1536}
1537/*************************************************************************
1538 * SetScrollRange32 (USER32.503)
1539 *
1540 * RETURNS STD
1541 */
1542BOOL WINAPI SetScrollRange(
1543 HWND hwnd, /* [I] Handle of window whose scrollbar will be affected */
1544 INT nBar, /* [I] One of SB_HORZ, SB_VERT, or SB_CTL */
1545 INT MinVal, /* [I] New minimum value */
1546 INT MaxVal, /* [I] New maximum value */
1547 BOOL bRedraw /* [I] Should scrollbar be redrawn afterwards ? */)
1548{
1549 SCROLLINFO info;
1550
1551 dprintf(("SetScrollRange %x %x %d %d %d", hwnd, nBar, MinVal, MaxVal, bRedraw));
1552 info.cbSize = sizeof(info);
1553 info.nMin = MinVal;
1554 info.nMax = MaxVal;
1555 info.fMask = SIF_RANGE;
1556 SetScrollInfo( hwnd, nBar, &info, bRedraw );
1557 return TRUE;
1558}
1559/*************************************************************************
1560 * SCROLL_SetNCSbState
1561 *
1562 * Updates both scrollbars at the same time. Used by MDI CalcChildScroll().
1563 */
1564INT SCROLL_SetNCSbState(HWND hwnd, int vMin, int vMax, int vPos,
1565 int hMin, int hMax, int hPos)
1566{
1567 INT vA, hA;
1568 SCROLLINFO vInfo, hInfo;
1569
1570 vInfo.cbSize = hInfo.cbSize = sizeof(SCROLLINFO);
1571 vInfo.nMin = vMin; hInfo.nMin = hMin;
1572 vInfo.nMax = vMax; hInfo.nMax = hMax;
1573 vInfo.nPos = vPos; hInfo.nPos = hPos;
1574 vInfo.fMask = hInfo.fMask = SIF_RANGE | SIF_POS;
1575
1576 SCROLL_SetScrollInfo( hwnd, SB_VERT, &vInfo, &vA );
1577 SCROLL_SetScrollInfo( hwnd, SB_HORZ, &hInfo, &hA );
1578
1579 if( !SCROLL_ShowScrollBar( hwnd, SB_BOTH,
1580 (hA & SA_SSI_SHOW),(vA & SA_SSI_SHOW) ) )
1581 {
1582 /* SetWindowPos() wasn't called, just redraw the scrollbars if needed */
1583 if( vA & SA_SSI_REFRESH )
1584 SCROLL_RefreshScrollBar( hwnd, SB_VERT, FALSE, TRUE );
1585
1586 if( hA & SA_SSI_REFRESH )
1587 SCROLL_RefreshScrollBar( hwnd, SB_HORZ, FALSE, TRUE );
1588 }
1589 return 0;
1590}
1591
1592
1593/*************************************************************************
1594 * GetScrollRange32 (USER32.286)
1595 *
1596 * RETURNS STD
1597 */
1598BOOL WINAPI GetScrollRange(
1599 HWND hwnd, /* [I] Handle of window */
1600 INT nBar, /* [I] One of SB_HORZ, SB_VERT, or SB_CTL */
1601 LPINT lpMin, /* [O] Where to store minimum value */
1602 LPINT lpMax /* [O] Where to store maximum value */)
1603{
1604 SCROLLBAR_INFO *infoPtr;
1605
1606 infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
1607 if (!infoPtr)
1608 {
1609 if (lpMin) lpMin = 0;
1610 if (lpMax) lpMax = 0;
1611 return FALSE;
1612 }
1613 if (lpMin) *lpMin = infoPtr->MinVal;
1614 if (lpMax) *lpMax = infoPtr->MaxVal;
1615 return TRUE;
1616}
1617/*************************************************************************
1618 * SCROLL_ShowScrollBar()
1619 *
1620 * Back-end for ShowScrollBar(). Returns FALSE if no action was taken.
1621 * NOTE: fShowV/fShowH must be zero when nBar is SB_HORZ/SB_VERT.
1622 */
1623BOOL SCROLL_ShowScrollBar(HWND hwnd, INT nBar,
1624 BOOL fShowH, BOOL fShowV )
1625{
1626 BOOL retvalue = FALSE;
1627 DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
1628
1629 //TRACE("hwnd=%04x bar=%d horz=%d, vert=%d\n",
1630 // hwnd, nBar, fShowH, fShowV );
1631
1632 switch(nBar)
1633 {
1634 case SB_CTL:
1635 ShowWindow( hwnd, fShowH ? SW_SHOW : SW_HIDE );
1636 retvalue = TRUE;
1637 goto END;
1638
1639 case SB_BOTH:
1640 case SB_HORZ:
1641 if (fShowH)
1642 {
1643 fShowH = !(dwStyle & WS_HSCROLL);
1644 dwStyle |= WS_HSCROLL;
1645 }
1646 else /* hide it */
1647 {
1648 fShowH = (dwStyle & WS_HSCROLL);
1649 dwStyle &= ~WS_HSCROLL;
1650 }
1651 SetWindowLongA(hwnd,GWL_STYLE,dwStyle);
1652 if( nBar == SB_HORZ ) {
1653 fShowV = FALSE;
1654 break;
1655 }
1656 /* fall through */
1657
1658 case SB_VERT:
1659 if (fShowV)
1660 {
1661 fShowV = !(dwStyle & WS_VSCROLL);
1662 dwStyle |= WS_VSCROLL;
1663 }
1664 else /* hide it */
1665 {
1666 fShowV = (dwStyle & WS_VSCROLL);
1667 dwStyle &= ~WS_VSCROLL;
1668 }
1669 SetWindowLongA(hwnd,GWL_STYLE,dwStyle);
1670 if ( nBar == SB_VERT )
1671 fShowH = FALSE;
1672 break;
1673
1674 default:
1675 retvalue = FALSE; /* Nothing to do! */
1676 goto END;
1677 }
1678
1679 if( fShowH || fShowV ) /* frame has been changed, let the window redraw itself */
1680 {
1681 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE
1682 | SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
1683 retvalue = TRUE;
1684 goto END;
1685 }
1686
1687 retvalue = FALSE; /* no frame changes */
1688END:
1689 return retvalue;
1690}
1691
1692
1693/*************************************************************************
1694 * ShowScrollBar32 (USER32.532)
1695 *
1696 * RETURNS STD
1697 */
1698BOOL WINAPI ShowScrollBar(
1699 HWND hwnd, /* [I] Handle of window whose scrollbar(s) will be affected */
1700 INT nBar, /* [I] One of SB_HORZ, SB_VERT, SB_BOTH or SB_CTL */
1701 BOOL fShow /* [I] TRUE = show, FALSE = hide */)
1702{
1703 Win32BaseWindow *window;
1704
1705 dprintf(("ShowScrollBar %04x %d %d\n", hwnd, nBar, fShow));
1706
1707 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1708 if(!window && nBar != SB_CTL) {
1709 dprintf(("ShowScrollBar window not found!"));
1710 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1711 return 0;
1712 }
1713 if(nBar != SB_CTL || (window->getStyle() & (WM_HSCROLL|WM_VSCROLL) != 0))
1714 {
1715 BOOL rc;
1716
1717 if(nBar == SB_HORZ || nBar == SB_BOTH)
1718 rc = OSLibWinShowScrollBar(window->getOS2FrameWindowHandle(),
1719 window->getHorzScrollHandle(),
1720 OSLIB_HSCROLL, fShow);
1721
1722 if(nBar == SB_VERT || ( rc == TRUE && nBar == SB_BOTH))
1723 rc = OSLibWinShowScrollBar(window->getOS2FrameWindowHandle(),
1724 window->getVertScrollHandle(),
1725 OSLIB_VSCROLL, fShow);
1726
1727 return rc;
1728 }
1729
1730 SCROLL_ShowScrollBar( hwnd, nBar, (nBar == SB_VERT) ? 0 : fShow,
1731 (nBar == SB_HORZ) ? 0 : fShow );
1732 return TRUE;
1733}
1734/*************************************************************************
1735 * EnableScrollBar32 (USER32.171)
1736 */
1737BOOL WINAPI EnableScrollBar( HWND hwnd, INT nBar, UINT flags)
1738{
1739 Win32BaseWindow *window;
1740 BOOL bFineWithMe;
1741 SCROLLBAR_INFO *infoPtr;
1742
1743 dprintf(("EnableScrollBar %04x %d %d\n", hwnd, nBar, flags));
1744
1745 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
1746 if(!window && nBar != SB_CTL) {
1747 dprintf(("EnableScrollBar window not found!"));
1748 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
1749 return 0;
1750 }
1751 if(nBar != SB_CTL || (window->getStyle() & (WM_HSCROLL|WM_VSCROLL) != 0))
1752 {
1753 BOOL fEnable, rc;
1754
1755 //hwnd = parent window with default scrollbar(s)
1756 switch(flags) {
1757 case ESB_ENABLE_BOTH:
1758 fEnable = TRUE;
1759 break;
1760 case ESB_DISABLE_BOTH:
1761 case ESB_DISABLE_RTDN:
1762 case ESB_DISABLE_LTUP:
1763 fEnable = FALSE;
1764 break;
1765 default:
1766 SetLastError(ERROR_INVALID_PARAMETER);
1767 return 0;
1768 }
1769 if(nBar == SB_HORZ || nBar == SB_BOTH)
1770 rc = OSLibWinEnableScrollBar(window->getOS2FrameWindowHandle(), OSLIB_HSCROLL, fEnable);
1771
1772 if(nBar == SB_VERT || ( rc == TRUE && nBar == SB_BOTH))
1773 rc = OSLibWinEnableScrollBar(window->getOS2FrameWindowHandle(), OSLIB_VSCROLL, fEnable);
1774
1775 return rc;
1776 }
1777 flags &= ESB_DISABLE_BOTH;
1778
1779 if (nBar == SB_BOTH)
1780 {
1781 if (!(infoPtr = SCROLL_GetInfoPtr( hwnd, SB_VERT ))) return FALSE;
1782 if (!(bFineWithMe = (infoPtr->flags == flags)) )
1783 {
1784 infoPtr->flags = flags;
1785 SCROLL_RefreshScrollBar( hwnd, SB_VERT, TRUE, TRUE );
1786 }
1787 nBar = SB_HORZ;
1788 }
1789 else
1790 bFineWithMe = TRUE;
1791
1792 if (!(infoPtr = SCROLL_GetInfoPtr( hwnd, nBar ))) return FALSE;
1793 if (bFineWithMe && infoPtr->flags == flags) return FALSE;
1794 infoPtr->flags = flags;
1795
1796 SCROLL_RefreshScrollBar( hwnd, nBar, TRUE, TRUE );
1797 return TRUE;
1798}
1799//******************************************************************************
1800//******************************************************************************
1801BOOL SCROLLBAR_Register()
1802{
1803 WNDCLASSA wndClass;
1804
1805 if (GlobalFindAtomA(SCROLLBARCLASSNAME)) return FALSE;
1806
1807 ZeroMemory(&wndClass,sizeof(WNDCLASSA));
1808 wndClass.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW | CS_PARENTDC;
1809 wndClass.lpfnWndProc = (WNDPROC)ScrollBarWndProc;
1810 wndClass.cbClsExtra = 0;
1811 wndClass.cbWndExtra = sizeof(SCROLLBAR_INFO);
1812 wndClass.hCursor = LoadCursorA(0,IDC_ARROWA);
1813 wndClass.hbrBackground = (HBRUSH)0;
1814 wndClass.lpszClassName = SCROLLBARCLASSNAME;
1815
1816 return RegisterClassA(&wndClass);
1817}
1818//******************************************************************************
1819//******************************************************************************
1820BOOL SCROLLBAR_Unregister()
1821{
1822 if (GlobalFindAtomA(SCROLLBARCLASSNAME))
1823 return UnregisterClassA(SCROLLBARCLASSNAME,(HINSTANCE)NULL);
1824 else return FALSE;
1825}
1826//******************************************************************************
1827//******************************************************************************
1828
Note: See TracBrowser for help on using the repository browser.