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

Initial scrollbar code

Browse source 
svn path=/trunk/; revision=3786
This commit is contained in:
Jason Filby 2002-11-24 20:15:37 +00:00
parent e676e56f6d
commit 683e4a3c99
10 changed files with 667 additions and 136 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
reactos/apps/tests/winhello/winhello.c
View file

@ -70,7 +70,9 @@ LRESULT CALLBACK MainWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hDC;
RECT clr, wir;
char spr[100], sir[100];
switch(msg)
{
case WM_LBUTTONUP:
@ -93,6 +95,12 @@ LRESULT CALLBACK MainWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
hDC = BeginPaint(hWnd, &ps);
SelectObject(hDC, tf);
TextOut(hDC, 10, 10, "Hello World from ReactOS!", strlen("Hello World from ReactOS!"));
GetClientRect(hWnd, &clr);
GetWindowRect(hWnd, &wir);
sprintf(spr, "%d,%d,%d,%d ", clr.left, clr.top, clr.right, clr.bottom);
sprintf(sir, "%d,%d,%d,%d ", wir.left, wir.top, wir.right, wir.bottom);
TextOut(hDC, 10, 30, spr, 20);
TextOut(hDC, 10, 50, sir, 20);
EndPaint(hWnd, &ps);
break;

2
reactos/boot.bat
View file

@ -1 +1 @@
loadros system32\ntoskrnl.exe system32\hal.dll /DEBUGPORT=SCREEN bootc.lst
loadros system32\ntoskrnl.exe system32\hal.dll /DEBUGPORT=BOCHS bootc.lst

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

@ -772,10 +772,7 @@ NtUserGetProcessWindowStation(VOID);
DWORD
STDCALL
NtUserGetScrollBarInfo(
DWORD Unknown0,
DWORD Unknown1,
DWORD Unknown2);
NtUserGetScrollBarInfo(HWND hWnd, LONG idObject, PSCROLLBARINFO psbi);
DWORD
STDCALL
@ -1515,10 +1512,7 @@ NtUserShowCaret(
DWORD
STDCALL
NtUserShowScrollBar(
DWORD Unknown0,
DWORD Unknown1,
DWORD Unknown2);
NtUserShowScrollBar(HWND hWnd, int wBar, DWORD bShow);
BOOL
STDCALL

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

@ -1,30 +1,14 @@
/*
* ReactOS kernel
* Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
/* $Id: scrollbar.c,v 1.4 2002/11/24 20:13:43 jfilby Exp $
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: scrollbar.c,v 1.3 2002/09/08 10:23:09 chorns Exp $
*
* PROJECT: ReactOS user32.dll
* FILE: lib/user32/controls/scrollbar.c
* PURPOSE: Scroll bar
* PROGRAMMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
* UPDATE HISTORY:
* 09-05-2001 CSH Created
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Windows
* FILE: subsys/win32k/ntuser/window.c
* PROGRAMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
* REVISION HISTORY:
* 06-06-2001 CSH Created
*/
/* INCLUDES ******************************************************************/
/* INCLUDES ******************************************************************/
@ -32,72 +16,350 @@
#include <user32.h>
#include <debug.h>
/* GLOBAL VARIABLES **********************************************************/
/*
static HBITMAP hUpArrow;
static HBITMAP hDnArrow;
static HBITMAP hLfArrow;
static HBITMAP hRgArrow;
static HBITMAP hUpArrowD;
static HBITMAP hDnArrowD;
static HBITMAP hLfArrowD;
static HBITMAP hRgArrowD;
static HBITMAP hUpArrowI;
static HBITMAP hDnArrowI;
static HBITMAP hLfArrowI;
static HBITMAP hRgArrowI;
*/
#define TOP_ARROW(flags,pressed) \
(((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_ARROW_THUMB_OVERLAP 0 /* Overlap between arrows and thumb */
#define SCROLL_MIN_THUMB 6 /* Minimum size of the thumb in pixels */
#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 */
enum SCROLL_HITTEST
{
SCROLL_NOWHERE, /* Outside the scroll bar */
SCROLL_TOP_ARROW, /* Top or left arrow */
SCROLL_TOP_RECT, /* Rectangle between the top arrow and the thumb */
SCROLL_THUMB, /* Thumb rectangle */
SCROLL_BOTTOM_RECT, /* Rectangle between the thumb and the bottom arrow */
SCROLL_BOTTOM_ARROW /* 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 enum SCROLL_HITTEST SCROLL_trackHitTest; /* Hit test code of the last button-down event */
static BOOL SCROLL_trackVertical;
/* FUNCTIONS *****************************************************************/
HBRUSH DefWndControlColor (HDC hDC, UINT ctlType);
HPEN STDCALL GetSysColorPen (int nIndex);
WINBOOL STDCALL
GetScrollBarInfo(HWND hwnd,
LONG idObject,
PSCROLLBARINFO psbi)
GetScrollBarInfo (HWND hwnd, LONG idObject, PSCROLLBARINFO psbi)
{
return FALSE;
int ret = NtUserGetScrollBarInfo (hwnd, idObject, psbi);
DbgPrint("GetScrollBarInfo: psbi: %08x\n", psbi);
return ret;
}
/* Ported from WINE20020904 */
/* Draw the scroll bar interior (everything except the arrows). */
static void
SCROLL_DrawInterior (HWND hwnd, HDC hdc, INT nBar,
RECT * rect, INT arrowSize,
INT thumbSize, INT thumbPos,
UINT flags, BOOL top_selected, BOOL bottom_selected)
{
RECT r;
HPEN hSavePen;
HBRUSH hSaveBrush, hBrush;
/* 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) NtUserSendMessage (GetParent (hwnd), WM_CTLCOLORSCROLLBAR,
(WPARAM) hdc, (LPARAM) hwnd);
}
else
{
/* hBrush = DefWndControlColor (hdc, CTLCOLOR_SCROLLBAR); */
}
hSavePen = SelectObject (hdc, GetSysColorPen (COLOR_WINDOWFRAME));
hSaveBrush = SelectObject (hdc, hBrush);
/* Calculate the scroll rectangle */
r = *rect;
DbgPrint ("[DrawInterior:r1:%d,%d,%d,%d]", r.left, r.top, r.right, r.bottom);
if (nBar == SB_VERT)
{
r.top += arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
r.bottom -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
}
else if (nBar == SB_HORZ)
{
r.left += arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
r.right -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
}
/* Draw the scroll rectangles and thumb */
if (!thumbPos) /* No thumb to draw */
{
PatBlt (hdc, r.left, r.top, r.right - r.left, r.bottom - r.top, PATCOPY);
/* cleanup and return */
SelectObject (hdc, hSavePen);
SelectObject (hdc, hSaveBrush);
return;
}
if (nBar == SB_VERT)
{
PatBlt (hdc, r.left, r.top, r.right - r.left, thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP),
top_selected ? 0x0f0000 : PATCOPY);
r.top += thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
PatBlt (hdc, r.left, r.top + thumbSize, r.right - r.left,
r.bottom - r.top - thumbSize,
bottom_selected ? 0x0f0000 : PATCOPY);
r.bottom = r.top + thumbSize;
}
else if (nBar == SB_HORZ)
{
PatBlt (hdc, r.left, r.top, thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP),
r.bottom - r.top, top_selected ? 0x0f0000 : PATCOPY);
r.left += thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
PatBlt (hdc, r.left + thumbSize, r.top,
r.right - r.left - thumbSize,
r.bottom - r.top, bottom_selected ? 0x0f0000 : PATCOPY);
r.right = r.left + thumbSize;
}
DbgPrint ("[DrawInterior:r2:%d,%d,%d,%d]", r.left, r.top, r.right, r.bottom);
/* Draw the thumb */
DrawEdge (hdc, &r, EDGE_RAISED, BF_RECT | BF_MIDDLE);
/* cleanup */
SelectObject (hdc, hSavePen);
SelectObject (hdc, hSaveBrush);
}
/* Ported from WINE20020904 */
static void
SCROLL_DrawMovingThumb (HDC hdc, RECT * rect, int nBar,
INT arrowSize, INT thumbSize)
{
INT pos = SCROLL_TrackingPos;
INT max_size;
DbgPrint ("[SCROLL_DrawMovingThumb:0 - no PAUSE!]");
/* for (;;); */
if (nBar == SB_VERT)
max_size = rect->bottom - rect->top;
else if (nBar == SB_HORZ)
max_size = rect->right - rect->left;
max_size -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP) + thumbSize;
DbgPrint ("[SCROLL_DrawMovingThumb:1]");
if (pos < (arrowSize - SCROLL_ARROW_THUMB_OVERLAP))
pos = (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
else if (pos > max_size)
pos = max_size;
DbgPrint ("[SCROLL_DrawMovingThumb:2]");
SCROLL_DrawInterior (SCROLL_TrackingWin, hdc, SCROLL_TrackingBar,
rect, arrowSize, thumbSize, pos,
0, FALSE, FALSE);
DbgPrint ("[SCROLL_DrawMovingThumb:3]");
SCROLL_MovingThumb = !SCROLL_MovingThumb;
DbgPrint ("[SCROLL_DrawMovingThumb:e]");
}
/* Ported from WINE20020904 */
/* Draw the scroll bar arrows. */
static void
SCROLL_DrawArrows (HDC hdc, PSCROLLBARINFO info,
RECT * rect, INT arrowSize, int nBar,
BOOL top_pressed, BOOL bottom_pressed)
{
RECT r;
int scrollDirFlag1, scrollDirFlag2;
if (nBar == SB_VERT)
{
scrollDirFlag1 = DFCS_SCROLLUP;
scrollDirFlag2 = DFCS_SCROLLDOWN;
}
else if (nBar == SB_HORZ)
{
scrollDirFlag1 = DFCS_SCROLLLEFT;
scrollDirFlag2 = DFCS_SCROLLRIGHT;
}
r = *rect;
if (nBar == SB_VERT)
r.bottom = r.top + arrowSize;
else if (nBar == SB_HORZ)
r.right = r.left + arrowSize;
DrawFrameControl (hdc, &r, DFC_SCROLL,
scrollDirFlag1 | (top_pressed ? (DFCS_PUSHED | DFCS_FLAT) : 0)
/* | (info->flags&ESB_DISABLE_LTUP ? DFCS_INACTIVE : 0) */
);
r = *rect;
if (nBar == SB_VERT)
r.top = r.bottom - arrowSize;
else if (nBar == SB_HORZ)
r.left = r.right - arrowSize;
DrawFrameControl (hdc, &r, 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
SCROLL_DrawScrollBar (HWND hwnd, HDC hdc, INT nBar,
BOOL arrows, BOOL interior)
{
INT arrowSize, thumbSize, thumbPos;
/* WND *wndPtr = WIN_FindWndPtr( hwnd ); */
PSCROLLBARINFO info;
BOOL Save_SCROLL_MovingThumb = SCROLL_MovingThumb;
DbgPrint("[SCROLL_DrawScrollBar:0]");
GetScrollBarInfo (hwnd, nBar, info);
DbgPrint("[SCROLL_DrawScrollBar:1]");
DbgPrint("info: %08x\n", info);
DbgPrint("info->rcScrollBar: %d,%d,%d,%d\n", info->rcScrollBar.left, info->rcScrollBar.top, info->rcScrollBar.right, info->rcScrollBar.bottom);
/* if (!wndPtr || !info ||
((nBar == SB_VERT) && !(wndPtr->dwStyle & WS_VSCROLL)) ||
((nBar == SB_HORZ) && !(wndPtr->dwStyle & WS_HSCROLL))) goto END;
if (!WIN_IsWindowDrawable( hwnd, FALSE )) goto END;
hwnd = wndPtr->hwndSelf; */ /* make it a full handle */
if (IsRectEmpty (&(info->rcScrollBar))) goto END;
DbgPrint("[SCROLL_DrawScrollBar:2]");
if (Save_SCROLL_MovingThumb && (SCROLL_TrackingWin == hwnd) && (SCROLL_TrackingBar == nBar))
{
DbgPrint("[SCROLL_DrawScrollBar:2a]");
SCROLL_DrawMovingThumb (hdc, &info->rcScrollBar, nBar, arrowSize, thumbSize);
}
DbgPrint("[SCROLL_DrawScrollBar:3]");
/* Draw the arrows */
if (arrows && arrowSize)
{
if (SCROLL_trackVertical == TRUE /* && GetCapture () == hwnd */)
{
SCROLL_DrawArrows (hdc, info, &info->rcScrollBar, arrowSize, nBar,
(SCROLL_trackHitTest == SCROLL_TOP_ARROW),
(SCROLL_trackHitTest == SCROLL_BOTTOM_ARROW));
}
else
{
SCROLL_DrawArrows (hdc, info, &info->rcScrollBar, arrowSize, nBar, FALSE, FALSE);
}
}
if (interior)
{
SCROLL_DrawInterior (hwnd, hdc, nBar, &info->rcScrollBar, arrowSize, thumbSize,
thumbPos, /* info->flags FIXME */ 0, FALSE, FALSE);
}
if (Save_SCROLL_MovingThumb &&
(SCROLL_TrackingWin == hwnd) && (SCROLL_TrackingBar == nBar))
SCROLL_DrawMovingThumb (hdc, &info->rcScrollBar, nBar, arrowSize, thumbSize);
/* if scroll bar has focus, reposition the caret */
/* if (hwnd == GetFocus () && (nBar == SB_CTL))
{
if (nBar == SB_HORZ)
{
SetCaretPos (thumbPos + 1, info->rcScrollBar.top + 1);
}
else if (nBAR == SB_VERT)
{
SetCaretPos (info->rcScrollBar.top + 1, thumbPos + 1);
}
} */
END:
/* WIN_ReleaseWndPtr(wndPtr); */
}
WINBOOL STDCALL
GetScrollInfo(HWND hwnd,
int fnBar,
LPSCROLLINFO lpsi)
GetScrollInfo (HWND hwnd, int fnBar, LPSCROLLINFO lpsi)
{
UNIMPLEMENTED;
return FALSE;
}
int STDCALL
GetScrollPos(HWND hWnd,
int nBar)
GetScrollPos (HWND hWnd, int nBar)
{
UNIMPLEMENTED;
return 0;
}
WINBOOL STDCALL
GetScrollRange(HWND hWnd,
int nBar,
LPINT lpMinPos,
LPINT lpMaxPos)
GetScrollRange (HWND hWnd, int nBar, LPINT lpMinPos, LPINT lpMaxPos)
{
UNIMPLEMENTED;
return FALSE;
}
int STDCALL
SetScrollInfo(HWND hwnd,
int fnBar,
LPCSCROLLINFO lpsi,
WINBOOL fRedraw)
SetScrollInfo (HWND hwnd, int fnBar, LPCSCROLLINFO lpsi, WINBOOL fRedraw)
{
UNIMPLEMENTED;
return 0;
}
int STDCALL
SetScrollPos(HWND hWnd,
int nBar,
int nPos,
WINBOOL bRedraw)
SetScrollPos (HWND hWnd, int nBar, int nPos, WINBOOL bRedraw)
{
UNIMPLEMENTED;
return 0;
}
WINBOOL STDCALL
SetScrollRange(HWND hWnd,
int nBar,
int nMinPos,
int nMaxPos,
WINBOOL bRedraw)
SetScrollRange (HWND hWnd,
int nBar, int nMinPos, int nMaxPos, WINBOOL bRedraw)
{
UNIMPLEMENTED;
return FALSE;
}
/* Ported from WINE20020904 */
WINBOOL STDCALL
ShowScrollBar(HWND hWnd,
int wBar,
WINBOOL bShow)
ShowScrollBar (HWND hWnd, int wBar, WINBOOL bShow)
{
return FALSE;
DbgPrint("[ShowScrollBar]");
NtUserShowScrollBar (hWnd, wBar, bShow);
return TRUE;
}

12
reactos/lib/user32/windows/defwnd.c
View file

@ -1,4 +1,4 @@
/* $Id: defwnd.c,v 1.15 2002/11/10 18:17:40 chorns Exp $
/* $Id: defwnd.c,v 1.16 2002/11/24 20:13:43 jfilby Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS user32.dll
@ -166,7 +166,7 @@ UserHasBigFrameStyle(ULONG Style, ULONG ExStyle)
(ExStyle & WS_EX_DLGMODALFRAME));
}
static void UserGetInsideRectNC( HWND hwnd, RECT *rect )
void UserGetInsideRectNC( HWND hwnd, RECT *rect )
{
RECT WindowRect;
ULONG Style;
@ -411,6 +411,8 @@ UserDrawFrameNC(HDC hdc, RECT* rect, BOOL dlgFrame, BOOL active)
}
}
void SCROLL_DrawScrollBar (HWND hwnd, HDC hdc, INT nBar, BOOL arrows, BOOL interior);
VOID
DefWndDoPaintNC(HWND hWnd, HRGN clip)
{
@ -466,7 +468,11 @@ DefWndDoPaintNC(HWND hWnd, HRGN clip)
/* FIXME: Draw menu bar. */
/* FIXME: Draw scroll bars. */
/* Draw scrollbars */
if (Style & WS_VSCROLL)
SCROLL_DrawScrollBar(hWnd, hDc, SB_VERT, TRUE, TRUE);
if (Style & WS_HSCROLL)
SCROLL_DrawScrollBar(hWnd, hDc, SB_HORZ, TRUE, TRUE);
/* FIXME: Draw size box. */

4
reactos/subsys/win32k/include/window.h
View file

@ -77,6 +77,10 @@ typedef struct _WINDOW_OBJECT
PDCE Dce;
/* Property list head.*/
LIST_ENTRY PropListHead;
/* Scrollbar info */
PSCROLLBARINFO pHScroll;
PSCROLLBARINFO pVScroll;
PSCROLLBARINFO wExtra;
} WINDOW_OBJECT, *PWINDOW_OBJECT;
/* Window flags. */

5
reactos/subsys/win32k/makefile
View file

@ -1,4 +1,4 @@
# $Id: makefile,v 1.52 2002/09/13 20:36:05 jfilby Exp $
# $Id: makefile,v 1.53 2002/11/24 20:13:44 jfilby Exp $
PATH_TO_TOP = ../..
@ -31,7 +31,8 @@ NTUSER_OBJECTS = ntuser/class.o ntuser/guicheck.o ntuser/hook.o \
ntuser/userobj.o ntuser/window.o ntuser/winsta.o \
ntuser/input.o ntuser/keyboard.o ntuser/callback.o \
ntuser/winpos.o ntuser/painting.o ntuser/metric.o \
ntuser/windc.o ntuser/prop.o
ntuser/windc.o ntuser/prop.o ntuser/scrollbar.o \
ntuser/uitools.o
OBJECTS_OBJECTS = objects/bitmaps.o objects/brush.o objects/cliprgn.o \
objects/color.o objects/coord.o objects/dc.o \
objects/fillshap.o objects/gdiobj.o objects/icm.o \

306
reactos/subsys/win32k/ntuser/scrollbar.c Normal file
View file

@ -0,0 +1,306 @@
/* $Id: scrollbar.c,v 1.1 2002/11/24 20:15:37 jfilby Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Scrollbars
* FILE: subsys/win32k/ntuser/scrollbar.c
* PROGRAMER: Jason Filby (jasonfilby@yahoo.com)
* REVISION HISTORY:
* 16-11-2002 Jason Filby Created
*/
/* INCLUDES ******************************************************************/
#include <ddk/ntddk.h>
#include <win32k/win32k.h>
#include <include/object.h>
#include <include/window.h>
#include <include/class.h>
#include <include/error.h>
#include <include/winsta.h>
#include <include/winpos.h>
#include <include/rect.h>
//#define NDEBUG
#include <debug.h>
#define SCROLL_MIN_RECT 4 /* Minimum size of the rectangle between the arrows */
#define SCROLL_ARROW_THUMB_OVERLAP 0 /* Overlap between arrows and thumb */
/* FUNCTIONS *****************************************************************/
/* Ported from WINE20020904 */
/* Compute the scroll bar rectangle, in drawing coordinates (i.e. client coords for SB_CTL, window coords for SB_VERT and
* SB_HORZ). 'arrowSize' returns the width or height of an arrow (depending on * the orientation of the scrollbar),
* 'thumbSize' returns the size of the thumb, and 'thumbPos' returns the position of the thumb relative to the left or to
* the top. Return TRUE if the scrollbar is vertical, FALSE if horizontal.
*/
static BOOL
SCROLL_GetScrollBarRect (PWINDOW_OBJECT Window, INT nBar, PRECT lprect,
PINT arrowSize, PINT thumbSize, PINT thumbPos)
{
INT pixels;
BOOL vertical;
RECT ClientRect;
ULONG Style;
DbgPrint("[SCROLL_GetScrollBarRect]");
W32kGetClientRect (Window, &ClientRect);
DbgPrint("[WindowRect:%d,%d,%d,%d]\n", Window->WindowRect.left, Window->WindowRect.top, Window->WindowRect.right, Window->WindowRect.bottom);
DbgPrint("[ClientRect:%d,%d,%d,%d]\n", ClientRect.left, ClientRect.top, ClientRect.right, ClientRect.bottom);
switch (nBar)
{
case SB_HORZ:
DbgPrint ("[SCROLL_GetScrollBarRect:SB_HORZ]");
lprect->left = ClientRect.left - Window->WindowRect.left;
lprect->top = ClientRect.bottom - Window->WindowRect.top;
lprect->right = ClientRect.right - Window->WindowRect.left;
lprect->bottom = lprect->top + NtUserGetSystemMetrics (SM_CYHSCROLL);
if (Window->Style & WS_BORDER)
{
lprect->left--;
lprect->right++;
}
else if (Window->Style & WS_VSCROLL)
lprect->right++;
vertical = FALSE;
break;
case SB_VERT:
DbgPrint ("[SCROLL_GetScrollBarRect:SB_VERT]\n");
/* lprect->left = ClientRect.right - Window->WindowRect.left;
lprect->top = ClientRect.top - Window->WindowRect.top;
lprect->right = lprect->left + NtUserGetSystemMetrics (SM_CXVSCROLL);
lprect->bottom = ClientRect.bottom - WindowRect.top; */
lprect->left = Window->WindowRect.left + ClientRect.right;
lprect->top = Window->WindowRect.bottom - ClientRect.bottom;
lprect->right = lprect->left + NtUserGetSystemMetrics (SM_CXVSCROLL);
lprect->bottom = Window->WindowRect.bottom;
if (Window->Style & WS_BORDER)
{
lprect->top--;
lprect->bottom++;
}
else if (Window->Style & WS_HSCROLL)
lprect->bottom++;
DbgPrint ("[VERTDIMEN:%d,%d,%d,%d]\n", lprect->left, lprect->top,
lprect->right, lprect->bottom);
DbgPrint ("[Window:%d,%d,%d,%d]\n", Window->WindowRect.left, Window->WindowRect.top,
Window->WindowRect.right, Window->WindowRect.bottom);
DbgPrint ("[Client:%d,%d,%d,%d]\n", ClientRect.left, ClientRect.top,
ClientRect.right, ClientRect.bottom);
DbgPrint ("[NtUserGetSystemMetrics(SM_CXVSCROLL):%d]\n",
NtUserGetSystemMetrics (SM_CXVSCROLL));
vertical = TRUE;
break;
case SB_CTL:
DbgPrint ("[SCROLL_GetScrollBarRect:SB_CTL]");
W32kGetClientRect (Window, lprect);
vertical = ((Window->Style & SBS_VERT) != 0);
break;
default:
DbgPrint ("[SCROLL_GetScrollBarRect:FAIL]");
W32kReleaseWindowObject(Window);
return FALSE;
}
if (vertical)
pixels = lprect->bottom - lprect->top;
else
pixels = lprect->right - lprect->left;
if (pixels <= 2 * NtUserGetSystemMetrics (SM_CXVSCROLL) + SCROLL_MIN_RECT)
{
if (pixels > SCROLL_MIN_RECT)
*arrowSize = (pixels - SCROLL_MIN_RECT) / 2;
else
*arrowSize = 0;
*thumbPos = *thumbSize = 0;
}
else
{
/* PSCROLLBARINFO info;
NtUserGetScrollBarInfo (hWnd, nBar, info); recursive loop.. since called function calls this function */
*arrowSize = NtUserGetSystemMetrics (SM_CXVSCROLL);
pixels -=
(2 * (NtUserGetSystemMetrics (SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP));
/* if (info->Page)
{
thumbSize = MulDiv(pixels,info->Page,(info->MaxVal-info->MinVal+1));
if (*thumbSize < SCROLL_MIN_THUMB) *thumbSize = SCROLL_MIN_THUMB;
}
else *thumbSize = NtUserGetSystemMetrics(SM_CXVSCROLL); */
/*
if (((pixels -= *thumbSize ) < 0) ||
((info->flags & ESB_DISABLE_BOTH) == ESB_DISABLE_BOTH))
{ */
/* Rectangle too small or scrollbar disabled -> no thumb */
/* *thumbPos = *thumbSize = 0;
}
else
{ */
/* INT max = info->MaxVal - max( info->Page-1, 0 );
if (info->MinVal >= max)
*thumbPos = *arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
else
*thumbPos = *arrowSize - SCROLL_ARROW_THUMB_OVERLAP
+ MulDiv(pixels, (info->CurVal-info->MinVal),(max - info->MinVal));
} */
}
W32kReleaseWindowObject(Window);
return vertical;
}
DWORD
STDCALL
NtUserGetScrollBarInfo(HWND hWnd, LONG idObject, PSCROLLBARINFO psbi)
{
PWINDOW_OBJECT Window = W32kGetWindowObject(hWnd);
int thumbSize = 20, arrowSize = 20, thumbPos = 0;
if (!Window) return FALSE;
switch(idObject)
{
case SB_HORZ: psbi = Window->pHScroll; break;
case SB_VERT: psbi = Window->pVScroll; break;
case SB_CTL: psbi = Window->wExtra; break;
default:
W32kReleaseWindowObject(Window);
return FALSE;
}
if (!psbi) /* Create the info structure if needed */
{
if ((psbi = ExAllocatePool(NonPagedPool, sizeof(SCROLLBARINFO))))
{
DbgPrint("Creating PSCROLLBARINFO for %d - psbi: %08x\n", idObject, psbi);
SCROLL_GetScrollBarRect (Window, idObject, &(psbi->rcScrollBar), &arrowSize, &thumbSize, &thumbPos);
DbgPrint("NtUserGetScrollBarInfo: Creating with rect (%d,%d,%d,%d)\n",
psbi->rcScrollBar.left, psbi->rcScrollBar.top, psbi->rcScrollBar.right, psbi->rcScrollBar.bottom);
if (idObject == SB_HORZ) Window->pHScroll = psbi;
else Window->pVScroll = psbi;
}
/* if (!hUpArrow) SCROLL_LoadBitmaps(); FIXME: This must be moved somewhere in user32 code */
}
DbgPrint("z1: psbi: %08x\n", psbi);
W32kReleaseWindowObject(Window);
DbgPrint("z2: psbi: %08x\n", psbi);
return TRUE;
}
/* Ported from WINE20020904 */
BOOL
SCROLL_ShowScrollBar (HWND hwnd, INT nBar, BOOL fShowH, BOOL fShowV)
{
PWINDOW_OBJECT Window = W32kGetWindowObject(hwnd);
switch (nBar)
{
case SB_CTL:
NtUserShowWindow (hwnd, fShowH ? SW_SHOW : SW_HIDE);
return TRUE;
case SB_BOTH:
case SB_HORZ:
if (fShowH)
{
fShowH = !(Window->Style & WS_HSCROLL);
Window->Style |= WS_HSCROLL;
}
else /* hide it */
{
fShowH = (Window->Style & WS_HSCROLL);
Window->Style &= ~WS_HSCROLL;
}
if (nBar == SB_HORZ)
{
fShowV = FALSE;
break;
}
/* fall through */
case SB_VERT:
if (fShowV)
{
fShowV = !(Window->Style & WS_VSCROLL);
Window->Style |= WS_VSCROLL;
}
else /* hide it */
{
fShowV = (Window->Style & WS_VSCROLL);
Window->Style &= ~WS_VSCROLL;
}
if (nBar == SB_VERT)
fShowH = FALSE;
break;
default:
return FALSE; /* Nothing to do! */
}
if (fShowH || fShowV) /* frame has been changed, let the window redraw itself */
{
NtUserSetWindowPos (hwnd, 0, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED);
return TRUE;
}
return FALSE; /* no frame changes */
}
DWORD
STDCALL
NtUserEnableScrollBar(
DWORD Unknown0,
DWORD Unknown1,
DWORD Unknown2)
{
return 0;
}
DWORD
STDCALL
NtUserScrollDC(
DWORD Unknown0,
DWORD Unknown1,
DWORD Unknown2,
DWORD Unknown3,
DWORD Unknown4,
DWORD Unknown5,
DWORD Unknown6)
{
UNIMPLEMENTED
return 0;
}
DWORD
STDCALL
NtUserSetScrollInfo(
DWORD Unknown0,
DWORD Unknown1,
DWORD Unknown2,
DWORD Unknown3)
{
UNIMPLEMENTED
return 0;
}
DWORD
STDCALL
NtUserShowScrollBar(HWND hWnd, int wBar, DWORD bShow)
{
DbgPrint("[NtUserShowScrollBar:%d]", bShow);
SCROLL_ShowScrollBar (hWnd, wBar, (wBar == SB_VERT) ? 0 : bShow, (wBar == SB_HORZ) ? 0 : bShow);
return 0;
}
/* EOF */

66
reactos/subsys/win32k/ntuser/stubs.c
View file

@ -534,18 +534,6 @@ NtUserEnableMenuItem(
return 0;
}
DWORD
STDCALL
NtUserEnableScrollBar(
DWORD Unknown0,
DWORD Unknown1,
DWORD Unknown2)
{
UNIMPLEMENTED
return 0;
}
DWORD
STDCALL
NtUserEndMenu(VOID)
@ -999,18 +987,6 @@ NtUserGetPriorityClipboardFormat(
return 0;
}
DWORD
STDCALL
NtUserGetScrollBarInfo(
DWORD Unknown0,
DWORD Unknown1,
DWORD Unknown2)
{
UNIMPLEMENTED
return 0;
}
DWORD
STDCALL
NtUserGetSystemMenu(
@ -1371,23 +1347,6 @@ NtUserSBGetParms(
return 0;
}
DWORD
STDCALL
NtUserScrollDC(
DWORD Unknown0,
DWORD Unknown1,
DWORD Unknown2,
DWORD Unknown3,
DWORD Unknown4,
DWORD Unknown5,
DWORD Unknown6)
{
UNIMPLEMENTED
return 0;
}
DWORD
STDCALL
NtUserSendInput(
@ -1589,19 +1548,6 @@ NtUserSetRipFlags(
return 0;
}
DWORD
STDCALL
NtUserSetScrollInfo(
DWORD Unknown0,
DWORD Unknown1,
DWORD Unknown2,
DWORD Unknown3)
{
UNIMPLEMENTED
return 0;
}
DWORD
STDCALL
NtUserSetSysColors(
@ -1684,18 +1630,6 @@ NtUserShowCaret(
return 0;
}
DWORD
STDCALL
NtUserShowScrollBar(
DWORD Unknown0,
DWORD Unknown1,
DWORD Unknown2)
{
UNIMPLEMENTED
return 0;
}
DWORD
STDCALL
NtUserSystemParametersInfo(

16
reactos/subsys/win32k/objects/color.c
View file

@ -50,6 +50,22 @@ const PALETTEENTRY COLOR_sysPalTemplate[NB_RESERVED_COLORS] =
{ 0xff, 0xff, 0xff, PC_SYS_USED } // last 10
};
ULONG W32kGetSysColor(int nIndex)
{
PALETTEENTRY *p = COLOR_sysPalTemplate + (nIndex * sizeof(PALETTEENTRY));
return RGB(p->peRed, p->peGreen, p->peBlue);
}
HPEN STDCALL W32kGetSysColorPen(int nIndex)
{
return(W32kCreatePen(PS_SOLID, 1, COLOR_sysPalTemplate[nIndex]));
}
HBRUSH STDCALL W32kGetSysColorBrush(int nIndex)
{
return(W32kCreateSolidBrush(COLOR_sysPalTemplate[nIndex]));
}
//forward declarations
COLORREF COLOR_LookupNearestColor( PALETTEENTRY* palPalEntry, int size, COLORREF color );