Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-01 02:10:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Minor work on scrollbars.

Browse source 
svn path=/trunk/; revision=7181
This commit is contained in:
Filip Navara 2003-12-22 19:55:39 +00:00
parent 2e9b3c4ad3
commit 6cb2390fa6
3 changed files with 565 additions and 594 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
reactos/include/win32k/ntuser.h
View file

@ -1468,8 +1468,8 @@ STDCALL
NtUserSetScrollInfo( NtUserSetScrollInfo(
HWND hwnd, HWND hwnd,
int fnBar, int fnBar,
LPSCROLLINFO lpsi, LPCSCROLLINFO lpsi,
DWORD *Changed); BOOL bRedraw);
BOOL BOOL
STDCALL STDCALL

872
reactos/lib/user32/controls/scrollbar.c
View file

@ -1,15 +1,33 @@
/* $Id: scrollbar.c,v 1.21 2003/12/14 11:36:42 gvg Exp $ /*
* ReactOS User32 Library
* - ScrollBar control
* *
* COPYRIGHT: See COPYING in the top level directory * Copyright 2001 Casper S. Hornstrup
* PROJECT: ReactOS kernel * Copyright 2003 Thomas Weidenmueller
* PURPOSE: Windows * Copyright 2003 Filip Navara
* FILE: subsys/win32k/ntuser/window.c *
* PROGRAMER: Casper S. Hornstrup (chorns@users.sourceforge.net) * Portions based on Wine code.
* Thomas Weidenmueller (w3seek@users.sourceforge.net) *
* REVISION HISTORY: * Copyright 1993 Martin Ayotte
* 06-06-2001 CSH Created * Copyright 1994, 1996 Alexandre Julliard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; see the file COPYING.LIB.
* If not, write to the Free Software Foundation,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/ */
/* INCLUDES ******************************************************************/
/* INCLUDES *******************************************************************/
#include <windows.h> #include <windows.h>
#include <user32.h> #include <user32.h>
@ -18,461 +36,315 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
/* GLOBAL VARIABLES **********************************************************/ /* GLOBAL VARIABLES ***********************************************************/
#define SBU_TOPRIGHT 0x10 /* Definitions for scrollbar hit testing [See SCROLLBARINFO in MSDN] */
#define SBU_BOTTOMLEFT 0x20 #define SCROLL_NOWHERE 0x00 /* Outside the scroll bar */
#define SBU_SCROLLBOX 0x40 #define SCROLL_TOP_ARROW 0x01 /* Top or left arrow */
#define SCROLL_TOP_RECT 0x02 /* Rectangle between the top arrow and the thumb */
#define SCROLL_THUMB 0x03 /* Thumb rectangle */
#define SCROLL_BOTTOM_RECT 0x04 /* Rectangle between the thumb and the bottom arrow */
#define SCROLL_BOTTOM_ARROW 0x05 /* Bottom or right arrow */
#define TOP_ARROW(flags,pressed) \ HBRUSH DefWndControlColor(HDC hDC, UINT ctlType);
(((flags)&ESB_DISABLE_UP) ? hUpArrowI : ((pressed) ? hUpArrowD:hUpArrow))
#define BOTTOM_ARROW(flags,pressed) \
(((flags)&ESB_DISABLE_DOWN) ? hDnArrowI : ((pressed) ? hDnArrowD:hDnArrow))
#define LEFT_ARROW(flags,pressed) \
(((flags)&ESB_DISABLE_LEFT) ? hLfArrowI : ((pressed) ? hLfArrowD:hLfArrow))
#define RIGHT_ARROW(flags,pressed) \
(((flags)&ESB_DISABLE_RIGHT) ? hRgArrowI : ((pressed) ? hRgArrowD:hRgArrow))
#define SCROLL_MIN_THUMB 6 /* Minimum size of the thumb in pixels */ /* PRIVATE FUNCTIONS **********************************************************/
#define SCROLL_FIRST_DELAY 200 /* Delay (in ms) before first repetition when holding the button down */
#define SCROLL_REPEAT_DELAY 50 /* Delay (in ms) between scroll repetitions */
#define SCROLL_TIMER 0 /* Scroll timer id */
/* What to do after SCROLL_SetScrollInfo() */
#define SA_SSI_HIDE 0x0001
#define SA_SSI_SHOW 0x0002
#define SA_SSI_REFRESH 0x0004
#define SA_SSI_REPAINT_ARROWS 0x0008
/* Scroll-bar hit testing */
#define SCROLL_NOWHERE 0x00 /* Outside the scroll bar */
#define SCROLL_TOP_ARROW 0x01 /* Top or left arrow */
#define SCROLL_TOP_RECT 0x02 /* Rectangle between the top arrow and the thumb */
#define SCROLL_THUMB 0x03 /* Thumb rectangle */
#define SCROLL_BOTTOM_RECT 0x04 /* Rectangle between the thumb and the bottom arrow */
#define SCROLL_BOTTOM_ARROW 0x05 /* Bottom or right arrow */
static BOOL SCROLL_MovingThumb = FALSE; /* Is the moving thumb being displayed? */
/* Thumb-tracking info */
static HWND SCROLL_TrackingWin = 0;
static INT SCROLL_TrackingBar = 0;
static INT SCROLL_TrackingPos = 0;
/* static INT SCROLL_TrackingVal = 0; */
static DWORD SCROLL_trackHitTest; /* Hit test code of the last button-down event */
static BOOL SCROLL_trackVertical;
/* INTERNAL FUNCTIONS *********************************************************/
HBRUSH DefWndControlColor (HDC hDC, UINT ctlType);
void
SCROLL_DrawScrollBar (HWND hwnd, HDC hdc, INT nBar,
BOOL arrows, BOOL interior);
static void static void
SCROLL_DrawChanges(HWND hwnd, int sBar, DWORD Changes) IntDrawScrollInterior(HWND hWnd, HDC hDC, INT nBar, BOOL Vertical,
INT ArrowSize, PSCROLLBARINFO ScrollBarInfo)
{ {
HDC dc; INT ThumbSize = ScrollBarInfo->xyThumbBottom - ScrollBarInfo->xyThumbTop;
SCROLLBARINFO sbi; RECT Rect;
BOOL btns = FALSE, interior = FALSE; HPEN hSavePen;
HBRUSH hSaveBrush, hBrush;
BOOL TopSelected = FALSE, BottomSelected = FALSE;
if (ScrollBarInfo->rgstate[SCROLL_TOP_RECT] & STATE_SYSTEM_PRESSED)
TopSelected = TRUE;
if (ScrollBarInfo->rgstate[SCROLL_BOTTOM_RECT] & STATE_SYSTEM_PRESSED)
BottomSelected = TRUE;
/*
* Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
* The window-owned scrollbars need to call DefWndControlColor
* to correctly setup default scrollbar colors
*/
if (nBar == SB_CTL)
{
hBrush = (HBRUSH)SendMessageW(GetParent(hWnd), WM_CTLCOLORSCROLLBAR, (WPARAM)hDC, (LPARAM)hWnd);
if (!hBrush)
hBrush = GetSysColorBrush(COLOR_SCROLLBAR);
}
else
{
hBrush = DefWndControlColor(hDC, CTLCOLOR_SCROLLBAR);
}
hSavePen = SelectObject(hDC, GetSysColorPen(COLOR_WINDOWFRAME));
hSaveBrush = SelectObject(hDC, hBrush);
/* Calculate the scroll rectangle */
if (Vertical)
{
Rect.top = ScrollBarInfo->rcScrollBar.top + ArrowSize;
Rect.bottom = ScrollBarInfo->rcScrollBar.bottom - ArrowSize;
Rect.left = ScrollBarInfo->rcScrollBar.left;
Rect.right = ScrollBarInfo->rcScrollBar.right;
}
else
{
Rect.top = ScrollBarInfo->rcScrollBar.top;
Rect.bottom = ScrollBarInfo->rcScrollBar.bottom;
Rect.left = ScrollBarInfo->rcScrollBar.left + ArrowSize;
Rect.right = ScrollBarInfo->rcScrollBar.right - ArrowSize;
}
/* Draw the scroll rectangles and thumb */
if (!ScrollBarInfo->xyThumbBottom)
{
PatBlt(hDC, Rect.left, Rect.top, Rect.right - Rect.left,
Rect.bottom - Rect.top, PATCOPY);
/* Cleanup and return */
SelectObject(hDC, hSavePen);
SelectObject(hDC, hSaveBrush);
return;
}
sbi.cbSize = sizeof(SCROLLBARINFO); ScrollBarInfo->xyThumbTop -= ArrowSize;
switch(sBar)
{
case SB_VERT:
NtUserGetScrollBarInfo (hwnd, OBJID_HSCROLL, &sbi);
break;
case SB_HORZ:
NtUserGetScrollBarInfo (hwnd, OBJID_VSCROLL, &sbi);
break;
case SB_CTL:
NtUserGetScrollBarInfo (hwnd, OBJID_CLIENT, &sbi);
break;
}
dc = GetWindowDC(hwnd);
if(dc)
{
if(Changes & SBU_TOPRIGHT)
{
btns = TRUE;
}
if(Changes & SBU_BOTTOMLEFT)
{
btns = TRUE;
}
if(Changes & SBU_SCROLLBOX)
{
interior = TRUE;
}
/* FIXME - draw it directly */
SCROLL_DrawScrollBar(hwnd, dc, sBar, btns, interior);
ReleaseDC(hwnd, dc);
}
}
/* Ported from WINE20020904 */ if (ScrollBarInfo->dxyLineButton)
/* Draw the scroll bar interior (everything except the arrows). */ {
static void if (Vertical)
SCROLL_DrawInterior (HWND hwnd, HDC hdc, INT nBar, BOOL vertical, INT
arrowSize, PSCROLLBARINFO psbi)
{
INT thumbSize = psbi->xyThumbBottom - psbi->xyThumbTop;
RECT rc;
HPEN hSavePen;
HBRUSH hSaveBrush, hBrush;
BOOLEAN top_selected = FALSE, bottom_selected = FALSE;
if(psbi->rgstate[SCROLL_TOP_RECT] & STATE_SYSTEM_PRESSED)
{
top_selected = TRUE;
}
if(psbi->rgstate[SCROLL_BOTTOM_RECT] & STATE_SYSTEM_PRESSED)
{
bottom_selected = TRUE;
}
/* Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
* The window-owned scrollbars need to call DefWndControlColor
* to correctly setup default scrollbar colors
*/
if ( nBar == SB_CTL )
{
hBrush = (HBRUSH) SendMessageW(GetParent (hwnd), WM_CTLCOLORSCROLLBAR, (WPARAM) hdc, (LPARAM) hwnd);
if(!hBrush)
hBrush = GetSysColorBrush(COLOR_SCROLLBAR);
}
else
{
/* hBrush = NtUserGetControlColor (hdc, CTLCOLOR_SCROLLBAR); FIXME
*/ /* DefWndControlColor */
hBrush = GetSysColorBrush(COLOR_SCROLLBAR);
}
hSavePen = SelectObject (hdc, GetSysColorPen (COLOR_WINDOWFRAME));
hSaveBrush = SelectObject (hdc, hBrush);
/* Calculate the scroll rectangle */
if (vertical)
{
rc.top = psbi->rcScrollBar.top + arrowSize;
rc.bottom = psbi->rcScrollBar.bottom - arrowSize;
rc.left = psbi->rcScrollBar.left;
rc.right = psbi->rcScrollBar.right;
}
else
{
rc.top = psbi->rcScrollBar.top;
rc.bottom = psbi->rcScrollBar.bottom;
rc.left = psbi->rcScrollBar.left + arrowSize;
rc.right = psbi->rcScrollBar.right - arrowSize;
}
/* Draw the scroll rectangles and thumb */
if (!psbi->xyThumbBottom) /* No thumb to draw */
{
PatBlt (hdc,
rc.left,
rc.top,
rc.right - rc.left,
rc.bottom - rc.top,
PATCOPY);
/* cleanup and return */
SelectObject (hdc, hSavePen);
SelectObject (hdc, hSaveBrush);
return;
}
psbi->xyThumbTop -= arrowSize;
if(psbi->dxyLineButton)
{
if (vertical)
{ {
if(thumbSize) if (ThumbSize)
{ {
PatBlt (hdc, PatBlt(hDC, Rect.left, Rect.top, Rect.right - Rect.left,
rc.left, ScrollBarInfo->xyThumbTop, TopSelected ? BLACKNESS : PATCOPY);
rc.top, Rect.top += ScrollBarInfo->xyThumbTop;
rc.right - rc.left, PatBlt(hDC, Rect.left, Rect.top + ThumbSize, Rect.right - Rect.left,
psbi->xyThumbTop, Rect.bottom - Rect.top - ThumbSize, BottomSelected ? BLACKNESS : PATCOPY);
top_selected ? 0x0f0000 : PATCOPY); Rect.bottom = Rect.top + ThumbSize;
rc.top += psbi->xyThumbTop; }
PatBlt (hdc, else
rc.left, {
rc.top + thumbSize, if (ScrollBarInfo->xyThumbTop)
rc.right - rc.left, {
rc.bottom - rc.top - thumbSize, PatBlt(hDC, Rect.left, ScrollBarInfo->dxyLineButton,
bottom_selected ? 0x0f0000 : PATCOPY); Rect.right - Rect.left, Rect.bottom - Rect.bottom, PATCOPY);
rc.bottom = rc.top + thumbSize; }
} }
else
{
if(psbi->xyThumbTop)
PatBlt (hdc,
rc.left,
psbi->dxyLineButton,
rc.right - rc.left,
rc.bottom - rc.bottom,
PATCOPY);
}
} }
else else
{ {
if(thumbSize) if (ThumbSize)
{ {
PatBlt (hdc, PatBlt(hDC, Rect.left, Rect.top, ScrollBarInfo->xyThumbTop,
rc.left, Rect.bottom - Rect.top, TopSelected ? BLACKNESS : PATCOPY);
rc.top, Rect.left += ScrollBarInfo->xyThumbTop;
psbi->xyThumbTop, PatBlt(hDC, Rect.left + ThumbSize, Rect.top,
rc.bottom - rc.top, Rect.right - Rect.left - ThumbSize, Rect.bottom - Rect.top,
top_selected ? 0x0f0000 : PATCOPY); BottomSelected ? BLACKNESS : PATCOPY);
rc.left += psbi->xyThumbTop; Rect.right = Rect.left + ThumbSize;
PatBlt (hdc, }
rc.left + thumbSize, else
rc.top, {
rc.right - rc.left - thumbSize, if (ScrollBarInfo->xyThumbTop)
rc.bottom - rc.top, {
bottom_selected ? 0x0f0000 : PATCOPY); PatBlt(hDC, ScrollBarInfo->dxyLineButton, Rect.top,
rc.right = rc.left + thumbSize; Rect.right - Rect.left, Rect.bottom - Rect.top, PATCOPY);
} }
else }
{
if(psbi->xyThumbTop)
PatBlt (hdc,
psbi->dxyLineButton,
rc.top,
rc.right - rc.left,
rc.bottom - rc.top,
PATCOPY);
}
} }
} }
/* Draw the thumb */ /* Draw the thumb */
if(thumbSize) if (ThumbSize)
DrawEdge (hdc, &rc, EDGE_RAISED, BF_RECT | BF_MIDDLE); DrawEdge(hDC, &Rect, EDGE_RAISED, BF_RECT | BF_MIDDLE);
/* cleanup */ /* Cleanup */
SelectObject (hdc, hSavePen); SelectObject(hDC, hSavePen);
SelectObject (hdc, hSaveBrush); SelectObject(hDC, hSaveBrush);
} }
/* Ported from WINE20020904 */
static void static void
SCROLL_DrawMovingThumb (HDC hdc, RECT * rect, BOOL vertical, int arrowSize, int thumbSize, PSCROLLBARINFO psbi) IntDrawScrollArrows(HDC hDC, PSCROLLBARINFO ScrollBarInfo, LPRECT Rect,
INT ArrowSize, BOOL Vertical)
{ {
INT pos = SCROLL_TrackingPos; RECT RectLT, RectRB;
INT max_size; INT ScrollDirFlagLT, ScrollDirFlagRB;
if ( vertical ) RectLT = RectRB = *Rect;
max_size = psbi->rcScrollBar.bottom - psbi->rcScrollBar.top; if (Vertical)
else {
max_size = psbi->rcScrollBar.right - psbi->rcScrollBar.left; ScrollDirFlagLT = DFCS_SCROLLUP;
ScrollDirFlagRB = DFCS_SCROLLDOWN;
RectLT.bottom = RectLT.top + ArrowSize;
RectRB.top = RectRB.bottom - ArrowSize;
}
else
{
ScrollDirFlagLT = DFCS_SCROLLLEFT;
ScrollDirFlagRB = DFCS_SCROLLRIGHT;
RectLT.right = RectLT.left + ArrowSize;
RectRB.left = RectRB.right - ArrowSize;
}
max_size -= arrowSize + thumbSize; if (ScrollBarInfo->rgstate[SCROLL_TOP_ARROW] & STATE_SYSTEM_PRESSED)
ScrollDirFlagLT |= DFCS_PUSHED | DFCS_FLAT;
if (ScrollBarInfo->rgstate[SCROLL_TOP_ARROW] & STATE_SYSTEM_UNAVAILABLE)
ScrollDirFlagLT |= DFCS_INACTIVE;
if (ScrollBarInfo->rgstate[SCROLL_BOTTOM_ARROW] & STATE_SYSTEM_PRESSED)
ScrollDirFlagRB |= DFCS_PUSHED | DFCS_FLAT;
if (ScrollBarInfo->rgstate[SCROLL_BOTTOM_ARROW] & STATE_SYSTEM_UNAVAILABLE)
ScrollDirFlagRB |= DFCS_INACTIVE;
if (pos < arrowSize) DrawFrameControl(hDC, &RectLT, DFC_SCROLL, ScrollDirFlagLT);
pos = arrowSize; DrawFrameControl(hDC, &RectRB, DFC_SCROLL, ScrollDirFlagRB);
else if (pos > max_size)
pos = max_size;
SCROLL_DrawInterior (SCROLL_TrackingWin, hdc, SCROLL_TrackingBar, vertical, arrowSize, psbi);
SCROLL_MovingThumb = !SCROLL_MovingThumb;
} }
/* Ported from WINE20020904 */
/* Draw the scroll bar arrows. */
static void
SCROLL_DrawArrows (HDC hdc, PSCROLLBARINFO info,
RECT * rect, INT arrowSize, BOOL vertical,
BOOL top_pressed, BOOL bottom_pressed)
{
RECT r1, r2;
int scrollDirFlag1, scrollDirFlag2;
r1 = r2 = *rect;
if (vertical)
{
scrollDirFlag1 = DFCS_SCROLLUP;
scrollDirFlag2 = DFCS_SCROLLDOWN;
r1.bottom = r1.top + arrowSize;
r2.top = r2.bottom - arrowSize;
}
else
{
scrollDirFlag1 = DFCS_SCROLLLEFT;
scrollDirFlag2 = DFCS_SCROLLRIGHT;
r1.right = r1.left + arrowSize;
r2.left = r2.right - arrowSize;
}
DrawFrameControl (hdc, &r1, DFC_SCROLL,
scrollDirFlag1 | (top_pressed ? (DFCS_PUSHED | DFCS_FLAT) : 0)
/* | (info.flags&ESB_DISABLE_LTUP ? DFCS_INACTIVE : 0) */
);
DrawFrameControl (hdc, &r2, DFC_SCROLL,
scrollDirFlag2 | (bottom_pressed ? (DFCS_PUSHED | DFCS_FLAT) : 0)
/* | (info.flags&ESB_DISABLE_RTDN ? DFCS_INACTIVE : 0) */
);
}
/* Ported from WINE20020904 */
/* Redraw the whole scrollbar. */
void void
SCROLL_DrawScrollBar (HWND hwnd, HDC hdc, INT nBar, IntDrawScrollBar(HWND hWnd, HDC hDC, INT nBar)
BOOL arrows, BOOL interior)
{ {
INT arrowSize = 0; INT ArrowSize = 0;
INT thumbSize; INT ThumbSize;
SCROLLBARINFO info; SCROLLBARINFO Info;
BOOL Save_SCROLL_MovingThumb = SCROLL_MovingThumb; BOOL Vertical;
BOOL vertical;
info.cbSize = sizeof(SCROLLBARINFO); /*
* Get scroll bar info.
*/
switch ( nBar ) Info.cbSize = sizeof(SCROLLBARINFO);
{ switch (nBar)
case SB_HORZ: {
vertical = FALSE; case SB_HORZ:
NtUserGetScrollBarInfo (hwnd, OBJID_HSCROLL, &info); Vertical = FALSE;
break; NtUserGetScrollBarInfo(hWnd, OBJID_HSCROLL, &Info);
case SB_VERT: break;
vertical = TRUE;
NtUserGetScrollBarInfo (hwnd, OBJID_VSCROLL, &info); case SB_VERT:
break; Vertical = TRUE;
case SB_CTL: NtUserGetScrollBarInfo(hWnd, OBJID_VSCROLL, &Info);
vertical = (GetWindowLongW(hwnd,GWL_STYLE)&SBS_VERT) != 0; break;
NtUserGetScrollBarInfo (hwnd, OBJID_CLIENT, &info);
break; case SB_CTL:
#ifdef DBG Vertical = (GetWindowLongW(hWnd, GWL_STYLE) & SBS_VERT) != 0;
default: NtUserGetScrollBarInfo(hWnd, OBJID_CLIENT, &Info);
DASSERT(!"SCROLL_DrawScrollBar() called with invalid nBar"); break;
break; }
#endif /* DBG */
}
thumbSize = info.xyThumbBottom - info.xyThumbTop; if (IsRectEmpty(&Info.rcScrollBar))
{
return;
}
arrowSize = info.dxyLineButton; ArrowSize = Info.dxyLineButton;
ThumbSize = Info.xyThumbBottom - Info.xyThumbTop;
if (IsRectEmpty (&(info.rcScrollBar))) goto END; /*
* Draw the arrows.
*/
if (Save_SCROLL_MovingThumb && (SCROLL_TrackingWin == hwnd) && (SCROLL_TrackingBar == nBar)) if (ArrowSize)
{ IntDrawScrollArrows(hDC, &Info, &Info.rcScrollBar, ArrowSize, Vertical);
SCROLL_DrawMovingThumb (hdc, &(info.rcScrollBar), vertical, arrowSize, thumbSize, &info);
}
/* Draw the arrows */ /*
if (arrows && arrowSize) * Draw the interior.
{ */
if (SCROLL_trackVertical == TRUE /* && GetCapture () == hwnd */)
{
SCROLL_DrawArrows (hdc, &info, &(info.rcScrollBar), arrowSize, vertical,
(SCROLL_trackHitTest == SCROLL_TOP_ARROW),
(SCROLL_trackHitTest == SCROLL_BOTTOM_ARROW));
}
else
{
SCROLL_DrawArrows (hdc, &info, &(info.rcScrollBar), arrowSize, vertical, FALSE, FALSE);
}
}
if (interior) IntDrawScrollInterior(hWnd, hDC, nBar, Vertical, ArrowSize, &Info);
{
SCROLL_DrawInterior (hwnd, hdc, nBar, vertical, arrowSize, &info);
}
if (Save_SCROLL_MovingThumb && /*
(SCROLL_TrackingWin == hwnd) && (SCROLL_TrackingBar == nBar)) * If scroll bar has focus, reposition the caret.
SCROLL_DrawMovingThumb (hdc, &info.rcScrollBar, vertical, arrowSize, thumbSize, &info); */
/* if scroll bar has focus, reposition the caret */
/* if (hwnd == GetFocus () && (nBar == SB_CTL)) if (hWnd == GetFocus() && nBar == SB_CTL)
{ {
if (nBar == SB_HORZ) if (nBar == SB_HORZ)
{ SetCaretPos(Info.dxyLineButton + 1, Info.rcScrollBar.top + 1);
SetCaretPos (info.dxyLineButton + 1, info.rcScrollBar.top + 1); else if (nBar == SB_VERT)
} SetCaretPos(Info.rcScrollBar.top + 1, Info.dxyLineButton + 1);
else if (nBAR == SB_VERT) }
{
SetCaretPos (info.rcScrollBar.top + 1, info.dxyLineButton + 1);
}
} */
END:;
/* WIN_ReleaseWndPtr(wndPtr); */
} }
static BOOL static BOOL
SCROLL_PtInRectEx( LPRECT lpRect, POINT pt, BOOL vertical ) IntScrollPtInRectEx(LPRECT lpRect, POINT pt, BOOL Vertical)
{ {
RECT rect = *lpRect; RECT Rect = *lpRect;
if (Vertical)
if (vertical) {
{ Rect.left -= lpRect->right - lpRect->left;
rect.left -= lpRect->right - lpRect->left; Rect.right += lpRect->right - lpRect->left;
rect.right += lpRect->right - lpRect->left; }
} else
else {
{ Rect.top -= lpRect->bottom - lpRect->top;
rect.top -= lpRect->bottom - lpRect->top; Rect.bottom += lpRect->bottom - lpRect->top;
rect.bottom += lpRect->bottom - lpRect->top; }
} return PtInRect(&Rect, pt);
return PtInRect( &rect, pt );
} }
DWORD DWORD
SCROLL_HitTest( HWND hwnd, INT nBar, POINT pt, BOOL bDragging ) IntScrollHitTest(HWND hWnd, INT nBar, POINT pt, BOOL bDragging)
{ {
SCROLLBARINFO sbi; SCROLLBARINFO ScrollButtonInfo;
RECT wndrect; RECT WindowRect;
INT arrowSize, thumbSize, thumbPos; INT ArrowSize, ThumbSize, ThumbPos;
BOOL vertical = (nBar == SB_VERT); /* FIXME - ((Window->Style & SBS_VERT) != 0) */ BOOL Vertical = (nBar == SB_VERT); /* FIXME - ((Window->Style & SBS_VERT) != 0) */
NtUserGetWindowRect(hwnd, &wndrect);
sbi.cbSize = sizeof(SCROLLBARINFO);
NtUserGetScrollBarInfo(hwnd, vertical ? OBJID_VSCROLL : OBJID_HSCROLL, &sbi);
OffsetRect(&sbi.rcScrollBar, wndrect.left, wndrect.top);
if ( (bDragging && !SCROLL_PtInRectEx( &sbi.rcScrollBar, pt, vertical )) || NtUserGetWindowRect(hWnd, &WindowRect);
(!PtInRect( &sbi.rcScrollBar, pt )) ) return SCROLL_NOWHERE;
ScrollButtonInfo.cbSize = sizeof(SCROLLBARINFO);
NtUserGetScrollBarInfo(hWnd, Vertical ? OBJID_VSCROLL : OBJID_HSCROLL,
&ScrollButtonInfo);
OffsetRect(&ScrollButtonInfo.rcScrollBar, WindowRect.left, WindowRect.top);
thumbPos = sbi.xyThumbTop; if ((bDragging && !IntScrollPtInRectEx(&ScrollButtonInfo.rcScrollBar, pt, Vertical)) ||
thumbSize = sbi.xyThumbBottom - thumbPos; !PtInRect(&ScrollButtonInfo.rcScrollBar, pt))
arrowSize = sbi.dxyLineButton; {
return SCROLL_NOWHERE;
}
if (vertical) ThumbPos = ScrollButtonInfo.xyThumbTop;
{ ThumbSize = ScrollButtonInfo.xyThumbBottom - ThumbPos;
if (pt.y < sbi.rcScrollBar.top + arrowSize) return SCROLL_TOP_ARROW; ArrowSize = ScrollButtonInfo.dxyLineButton;
if (pt.y >= sbi.rcScrollBar.bottom - arrowSize) return SCROLL_BOTTOM_ARROW;
if (!thumbPos) return SCROLL_TOP_RECT; if (Vertical)
pt.y -= sbi.rcScrollBar.top; {
if (pt.y < thumbPos) return SCROLL_TOP_RECT; if (pt.y < ScrollButtonInfo.rcScrollBar.top + ArrowSize)
if (pt.y >= thumbPos + thumbSize) return SCROLL_BOTTOM_RECT; return SCROLL_TOP_ARROW;
} if (pt.y >= ScrollButtonInfo.rcScrollBar.bottom - ArrowSize)
else /* horizontal */ return SCROLL_BOTTOM_ARROW;
{ if (!ThumbPos)
if (pt.x < sbi.rcScrollBar.left + arrowSize) return SCROLL_TOP_ARROW; return SCROLL_TOP_RECT;
if (pt.x >= sbi.rcScrollBar.right - arrowSize) return SCROLL_BOTTOM_ARROW; pt.y -= ScrollButtonInfo.rcScrollBar.top;
if (!thumbPos) return SCROLL_TOP_RECT; if (pt.y < ThumbPos)
pt.x -= sbi.rcScrollBar.left; return SCROLL_TOP_RECT;
if (pt.x < thumbPos) return SCROLL_TOP_RECT; if (pt.y >= ThumbPos + ThumbSize)
if (pt.x >= thumbPos + thumbSize) return SCROLL_BOTTOM_RECT; return SCROLL_BOTTOM_RECT;
} }
return SCROLL_THUMB; else
{
if (pt.x < ScrollButtonInfo.rcScrollBar.left + ArrowSize)
return SCROLL_TOP_ARROW;
if (pt.x >= ScrollButtonInfo.rcScrollBar.right - ArrowSize)
return SCROLL_BOTTOM_ARROW;
if (!ThumbPos)
return SCROLL_TOP_RECT;
pt.x -= ScrollButtonInfo.rcScrollBar.left;
if (pt.x < ThumbPos)
return SCROLL_TOP_RECT;
if (pt.x >= ThumbPos + ThumbSize)
return SCROLL_BOTTOM_RECT;
}
return SCROLL_THUMB;
} }
/* PUBLIC FUNCTIONS ***********************************************************/
/* FUNCTIONS ******************************************************************/
/* /*
* @implemented * @implemented
@ -480,163 +352,129 @@ SCROLL_HitTest( HWND hwnd, INT nBar, POINT pt, BOOL bDragging )
WINBOOL STDCALL WINBOOL STDCALL
EnableScrollBar(HWND hWnd, UINT wSBflags, UINT wArrows) EnableScrollBar(HWND hWnd, UINT wSBflags, UINT wArrows)
{ {
return NtUserEnableScrollBar(hWnd, wSBflags, wArrows); return NtUserEnableScrollBar(hWnd, wSBflags, wArrows);
} }
/* /*
* @implemented * @implemented
*/ */
WINBOOL STDCALL BOOL STDCALL
GetScrollBarInfo(HWND hwnd, LONG idObject, PSCROLLBARINFO psbi) GetScrollBarInfo(HWND hWnd, LONG idObject, PSCROLLBARINFO psbi)
{ {
return NtUserGetScrollBarInfo (hwnd, idObject, psbi); return NtUserGetScrollBarInfo(hWnd, idObject, psbi);
} }
/* /*
* @implemented * @implemented
*/ */
WINBOOL STDCALL BOOL STDCALL
GetScrollInfo (HWND hwnd, int fnBar, LPSCROLLINFO lpsi) GetScrollInfo(HWND hWnd, INT nBar, LPSCROLLINFO lpsi)
{ {
return (WINBOOL)NtUserGetScrollInfo(hwnd, fnBar, lpsi); return NtUserGetScrollInfo(hWnd, nBar, lpsi);
} }
/* /*
* @implemented * @implemented
*/ */
int STDCALL INT STDCALL
GetScrollPos (HWND hWnd, int nBar) GetScrollPos(HWND hWnd, INT nBar)
{ {
SCROLLINFO si; SCROLLINFO ScrollInfo;
BOOL ret;
int res = 0;
si.cbSize = sizeof(SCROLLINFO); ScrollInfo.cbSize = sizeof(SCROLLINFO);
si.fMask = SIF_POS; ScrollInfo.fMask = SIF_POS;
ret = NtUserGetScrollInfo(hWnd, nBar, &si); if (NtUserGetScrollInfo(hWnd, nBar, &ScrollInfo))
if(ret) return ScrollInfo.nPos;
res = si.nPos; return 0;
return res;
} }
/* /*
* @implemented * @implemented
*/ */
WINBOOL STDCALL BOOL STDCALL
GetScrollRange (HWND hWnd, int nBar, LPINT lpMinPos, LPINT lpMaxPos) GetScrollRange(HWND hWnd, int nBar, LPINT lpMinPos, LPINT lpMaxPos)
{ {
WINBOOL ret; BOOL Result;
SCROLLINFO si; SCROLLINFO ScrollInfo;
if(!lpMinPos || !lpMaxPos) if (!lpMinPos || !lpMaxPos)
{ {
SetLastError(ERROR_INVALID_PARAMETER); SetLastError(ERROR_INVALID_PARAMETER);
return FALSE; return FALSE;
} }
si.cbSize = sizeof(SCROLLINFO); ScrollInfo.cbSize = sizeof(SCROLLINFO);
si.fMask = SIF_RANGE; ScrollInfo.fMask = SIF_RANGE;
ret = NtUserGetScrollInfo(hWnd, nBar, &si); Result = NtUserGetScrollInfo(hWnd, nBar, &ScrollInfo);
if(ret) if (Result)
{ {
*lpMinPos = si.nMin; *lpMinPos = ScrollInfo.nMin;
*lpMaxPos = si.nMax; *lpMaxPos = ScrollInfo.nMax;
} }
return ret; return Result;
} }
/* /*
* @implemented * @implemented
*/ */
int STDCALL INT STDCALL
SetScrollInfo (HWND hwnd, int fnBar, LPCSCROLLINFO lpsi, WINBOOL fRedraw) SetScrollInfo(HWND hWnd, int nBar, LPCSCROLLINFO lpsi, BOOL bRedraw)
{ {
DWORD Changed; return NtUserSetScrollInfo(hWnd, nBar, lpsi, bRedraw);
int Ret = (int)NtUserSetScrollInfo(hwnd, fnBar, (LPSCROLLINFO)lpsi, &Changed);
if(fRedraw && Changed)
{
SCROLL_DrawChanges(hwnd, fnBar, Changed);
}
return Ret;
} }
/* /*
* @implemented * @implemented
*/ */
int STDCALL INT STDCALL
SetScrollPos (HWND hWnd, int nBar, int nPos, WINBOOL bRedraw) SetScrollPos(HWND hWnd, INT nBar, INT nPos, BOOL bRedraw)
{ {
int Res = 0; INT Result = 0;
BOOL ret; SCROLLINFO ScrollInfo;
DWORD Action;
SCROLLINFO si;
si.cbSize = sizeof(SCROLLINFO); ScrollInfo.cbSize = sizeof(SCROLLINFO);
si.fMask = SIF_POS; ScrollInfo.fMask = SIF_POS;
/* call NtUserGetScrollInfo() because we need to return the previous position */ /*
ret = NtUserGetScrollInfo(hWnd, nBar, &si); * Call NtUserGetScrollInfo() to get the previous position that
* we will later return.
if(ret) */
{ if (NtUserGetScrollInfo(hWnd, nBar, &ScrollInfo))
Res = si.nPos; {
Result = ScrollInfo.nPos;
if(Res != nPos) if (Result != nPos)
{
si.nPos = nPos;
/* finally set the new position */
NtUserSetScrollInfo(hWnd, nBar, &si, &Action);
if(Action && bRedraw)
{ {
SCROLL_DrawChanges(hWnd, nBar, Action); ScrollInfo.nPos = nPos;
/* Finally set the new position */
NtUserSetScrollInfo(hWnd, nBar, &ScrollInfo, bRedraw);
} }
} }
}
return Res; return Result;
} }
/* /*
* @implemented * @implemented
*/ */
WINBOOL STDCALL BOOL STDCALL
SetScrollRange (HWND hWnd, SetScrollRange(HWND hWnd, INT nBar, INT nMinPos, INT nMaxPos, BOOL bRedraw)
int nBar, int nMinPos, int nMaxPos, WINBOOL bRedraw)
{ {
SCROLLINFO si; SCROLLINFO ScrollInfo;
DWORD Action;
si.cbSize = sizeof(SCROLLINFO);
si.fMask = SIF_RANGE;
si.nMin = nMinPos;
si.nMax = nMaxPos;
NtUserSetScrollInfo(hWnd, nBar, &si, &Action);
/* FIXME - check if called successfully */
if(Action && bRedraw)
{
SCROLL_DrawChanges(hWnd, nBar, Action);
}
return TRUE;
}
ScrollInfo.cbSize = sizeof(SCROLLINFO);
ScrollInfo.fMask = SIF_RANGE;
ScrollInfo.nMin = nMinPos;
ScrollInfo.nMax = nMaxPos;
NtUserSetScrollInfo(hWnd, nBar, &ScrollInfo, bRedraw);
return TRUE;
}
/* /*
* @implemented * @implemented
*/ */
WINBOOL STDCALL BOOL STDCALL
ShowScrollBar (HWND hWnd, int wBar, WINBOOL bShow) ShowScrollBar(HWND hWnd, INT wBar, BOOL bShow)
{ {
return (WINBOOL)NtUserShowScrollBar (hWnd, wBar, bShow); return NtUserShowScrollBar(hWnd, wBar, bShow);
} }

283
reactos/subsys/win32k/ntuser/scrollbar.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
/* $Id: scrollbar.c,v 1.19 2003/12/08 18:21:25 navaraf Exp $ /* $Id: scrollbar.c,v 1.20 2003/12/22 19:55:39 navaraf Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -53,6 +53,11 @@
#define SBRG_PAGEDOWNLEFT 4 /* the page down or page left region */ #define SBRG_PAGEDOWNLEFT 4 /* the page down or page left region */
#define SBRG_BOTTOMLEFTBTN 5 /* the bottom or left button */ #define SBRG_BOTTOMLEFTBTN 5 /* the bottom or left button */
#define SA_SSI_HIDE 0x0001
#define SA_SSI_SHOW 0x0002
#define SA_SSI_REFRESH 0x0004
#define SA_SSI_REPAINT_ARROWS 0x0008
#define SBU_TOPRIGHT 0x10 #define SBU_TOPRIGHT 0x10
#define SBU_BOTTOMLEFT 0x20 #define SBU_BOTTOMLEFT 0x20
#define SBU_SCROLLBOX 0x40 #define SBU_SCROLLBOX 0x40
@ -307,8 +312,9 @@ IntGetScrollInfo(PWINDOW_OBJECT Window, INT nBar, LPSCROLLINFO lpsi)
} }
DWORD FASTCALL DWORD FASTCALL
IntSetScrollInfo(PWINDOW_OBJECT Window, INT nBar, LPSCROLLINFO lpsi, DWORD *Action) IntSetScrollInfo(PWINDOW_OBJECT Window, INT nBar, LPCSCROLLINFO lpsi, BOOL bRedraw)
{ {
#if 0
PSCROLLBARINFO Info = NULL; PSCROLLBARINFO Info = NULL;
LPSCROLLINFO psi; LPSCROLLINFO psi;
BOOL Chg = FALSE; BOOL Chg = FALSE;
@ -428,6 +434,171 @@ IntSetScrollInfo(PWINDOW_OBJECT Window, INT nBar, LPSCROLLINFO lpsi, DWORD *Acti
Ret = psi->nPos; Ret = psi->nPos;
return Ret; return Ret;
#else
/*
* Update the scrollbar state and set action flags according to
* what has to be done graphics wise.
*/
LPSCROLLINFO Info;
/* UINT new_flags;*/
BOOL bChangeParams = FALSE; /* don't show/hide scrollbar if params don't change */
if (lpsi->cbSize != sizeof(SCROLLINFO) &&
lpsi->cbSize != (sizeof(SCROLLINFO) - sizeof(lpsi->nTrackPos)))
{
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return 0;
}
if (lpsi->fMask & ~(SIF_ALL | SIF_DISABLENOSCROLL))
{
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return 0;
}
switch(nBar)
{
case SB_HORZ:
if (Window->pHScroll == NULL)
{
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return 0;
}
Info = (LPSCROLLINFO)(Window->pHScroll + 1);
break;
case SB_VERT:
if (Window->pVScroll == NULL)
{
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return 0;
}
Info = (LPSCROLLINFO)(Window->pVScroll + 1);
break;
case SB_CTL:
UNIMPLEMENTED;
break;
default:
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return 0;
}
/* Set the page size */
if (lpsi->fMask & SIF_PAGE)
{
if (Info->nPage != lpsi->nPage)
{
Info->nPage = lpsi->nPage;
#if 0
*Action |= SA_SSI_REFRESH;
#endif
bChangeParams = TRUE;
}
}
/* Set the scroll pos */
if (lpsi->fMask & SIF_POS)
{
if (Info->nPos != lpsi->nPos)
{
Info->nPos = lpsi->nPos;
#if 0
*Action |= SA_SSI_REFRESH;
#endif
}
}
/* Set the scroll range */
if (lpsi->fMask & SIF_RANGE)
{
/* Invalid range -> range is set to (0,0) */
if (lpsi->nMin > lpsi->nMax ||
(UINT)(lpsi->nMax - lpsi->nMin) >= 0x80000000)
{
Info->nMin = 0;
Info->nMax = 0;
bChangeParams = TRUE;
}
else
{
if (Info->nMin != lpsi->nMin || Info->nMax != lpsi->nMax)
{
#if 0
*Action |= SA_SSI_REFRESH;
#endif
Info->nMin = lpsi->nMin;
Info->nMax = lpsi->nMax;
bChangeParams = TRUE;
}
}
}
/* Make sure the page size is valid */
if (Info->nPage < 0)
{
Info->nPage = 0;
}
else if (Info->nPage > Info->nMax - Info->nMin + 1)
{
Info->nPage = Info->nMax - Info->nMin + 1;
}
/* Make sure the pos is inside the range */
if (Info->nPos < Info->nMin)
{
Info->nPos = Info->nMin;
}
else if (Info->nPos > Info->nMax - max(Info->nPage - 1, 0))
{
Info->nPos = Info->nMax - max(Info->nPage - 1, 0);
}
/*
* Don't change the scrollbar state if SetScrollInfo is just called
* with SIF_DISABLENOSCROLL
*/
if (!(lpsi->fMask & SIF_ALL))
{
return Info->nPos;
}
/* Check if the scrollbar should be hidden or disabled */
if (lpsi->fMask & (SIF_RANGE | SIF_PAGE | SIF_DISABLENOSCROLL))
{
/* new_flags = Info->flags;*/
if (Info->nMin >= Info->nMax - max(Info->nPage - 1, 0))
{
/* Hide or disable scroll-bar */
if (lpsi->fMask & SIF_DISABLENOSCROLL)
{
/* new_flags = ESB_DISABLE_BOTH;*/
#if 0
*Action |= SA_SSI_REFRESH;
#endif
}
else if ((nBar != SB_CTL) && bChangeParams)
{
NtUserShowScrollBar(Window->Self, nBar, FALSE);
return Info->nPos;
}
}
else /* Show and enable scroll-bar */
{
/* new_flags = 0;*/
if ((nBar != SB_CTL) && bChangeParams)
NtUserShowScrollBar(Window->Self, nBar, TRUE);
}
#if 0
if (infoPtr->flags != new_flags) /* check arrow flags */
{
infoPtr->flags = new_flags;
*Action |= SA_SSI_REPAINT_ARROWS;
}
#endif
}
/* Return current position */
return Info->nPos;
#endif
} }
BOOL FASTCALL BOOL FASTCALL
@ -750,13 +921,13 @@ STDCALL
NtUserSetScrollInfo( NtUserSetScrollInfo(
HWND hwnd, HWND hwnd,
int fnBar, int fnBar,
LPSCROLLINFO lpsi, LPCSCROLLINFO lpsi,
DWORD *Changed) BOOL bRedraw)
{ {
PWINDOW_OBJECT Window; PWINDOW_OBJECT Window;
NTSTATUS Status; NTSTATUS Status;
SCROLLINFO ScrollInfo; SCROLLINFO ScrollInfo;
DWORD Ret, Action; DWORD Ret;
Window = IntGetWindowObject(hwnd); Window = IntGetWindowObject(hwnd);
@ -774,20 +945,7 @@ NtUserSetScrollInfo(
return 0; return 0;
} }
Ret = IntSetScrollInfo(Window, fnBar, &ScrollInfo, &Action); Ret = IntSetScrollInfo(Window, fnBar, &ScrollInfo, bRedraw);
if(Changed)
{
if(Action && (Window->Style & WS_VISIBLE))
{
MmCopyToCaller(Changed, &Action, sizeof(DWORD));
}
else
{
MmCopyToCaller(Changed, &Action, sizeof(DWORD));
}
}
IntReleaseWindowObject(Window); IntReleaseWindowObject(Window);
return Ret; return Ret;
@ -798,68 +956,43 @@ DWORD
STDCALL STDCALL
NtUserShowScrollBar(HWND hWnd, int wBar, DWORD bShow) NtUserShowScrollBar(HWND hWnd, int wBar, DWORD bShow)
{ {
BOOL fShowV = (wBar == SB_VERT) ? 0 : bShow; PWINDOW_OBJECT Window = IntGetWindowObject(hWnd);
BOOL fShowH = (wBar == SB_HORZ) ? 0 : bShow;
PWINDOW_OBJECT Window = IntGetWindowObject(hWnd);
if(!Window)
{
SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
return FALSE;
}
switch (wBar) if (!Window)
{ {
case SB_CTL: SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
WinPosShowWindow (hWnd, fShowH ? SW_SHOW : SW_HIDE); return FALSE;
}
if (wBar == SB_CTL)
{
WinPosShowWindow(hWnd, bShow ? SW_SHOW : SW_HIDE);
IntReleaseWindowObject(Window);
return TRUE; return TRUE;
}
case SB_BOTH: if (wBar == SB_BOTH || wBar == SB_HORZ)
case SB_HORZ: {
if (fShowH) if (bShow)
{ Window->Style |= WS_HSCROLL;
fShowH = !(Window->Style & WS_HSCROLL); else
Window->Style |= WS_HSCROLL; Window->Style &= ~WS_HSCROLL;
} }
else /* hide it */
{
fShowH = (Window->Style & WS_HSCROLL);
Window->Style &= ~WS_HSCROLL;
}
if (wBar == SB_HORZ)
{
fShowV = FALSE;
break;
}
/* fall through */
case SB_VERT: if (wBar == SB_BOTH || wBar == SB_VERT)
if (fShowV) {
{ if (bShow)
fShowV = !(Window->Style & WS_VSCROLL); Window->Style |= WS_VSCROLL;
Window->Style |= WS_VSCROLL; else
} Window->Style &= ~WS_VSCROLL;
else /* hide it */ }
{
fShowV = (Window->Style & WS_VSCROLL);
Window->Style &= ~WS_VSCROLL;
}
if (wBar == SB_VERT)
fShowH = FALSE;
break;
default: /* Frame has been changed, let the window redraw itself */
return FALSE; /* Nothing to do! */ WinPosSetWindowPos(hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
} SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED);
IntReleaseWindowObject(Window); IntReleaseWindowObject(Window);
return TRUE;
if (fShowH || fShowV) /* frame has been changed, let the window redraw itself */
{
WinPosSetWindowPos (hWnd, 0, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED);
return TRUE;
}
return FALSE; /* no frame changes */
} }
/* EOF */ /* EOF */