* 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.29 2004/04/09 20:03:19 navaraf Exp $
+/* $Id$
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
*/
/* INCLUDES ******************************************************************/
-#include <ddk/ntddk.h>
-#include <win32k/win32k.h>
-#include <internal/safe.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>
-#include <include/scroll.h>
-#include <include/painting.h>
-#include <include/tags.h>
-#ifdef __USE_W32API
-#include <oleacc.h>
-#endif
+#include <w32k.h>
#define NDEBUG
#include <debug.h>
#define SBRG_PAGEDOWNLEFT 4 /* the page down or page left region */
#define SBRG_BOTTOMLEFTBTN 5 /* the bottom or left button */
+#define CHANGERGSTATE(item, status) \
+ if(Info->rgstate[(item)] != (status)) \
+ Chg = TRUE; \
+ Info->rgstate[(item)] = (status);
+
/* FUNCTIONS *****************************************************************/
/* Ported from WINE20020904 */
* '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.
*/
-BOOL STDCALL
+BOOL FASTCALL
IntGetScrollBarRect (PWINDOW_OBJECT Window, INT nBar, PRECT lprect)
{
BOOL vertical;
lprect->left = ClientRect.left - WindowRect.left;
lprect->top = ClientRect.bottom - WindowRect.top;
lprect->right = ClientRect.right - WindowRect.left;
- lprect->bottom = lprect->top + NtUserGetSystemMetrics (SM_CYHSCROLL);
+ lprect->bottom = lprect->top + UserGetSystemMetrics (SM_CYHSCROLL);
vertical = FALSE;
break;
case SB_VERT:
- lprect->left = ClientRect.right - WindowRect.left;
+ if(Window->ExStyle & WS_EX_LEFTSCROLLBAR)
+ {
+ lprect->right = ClientRect.left - WindowRect.left;
+ lprect->left = lprect->right - UserGetSystemMetrics(SM_CXVSCROLL);
+ }
+ else
+ {
+ lprect->left = ClientRect.right - WindowRect.left;
+ lprect->right = lprect->left + UserGetSystemMetrics(SM_CXVSCROLL);
+ }
lprect->top = ClientRect.top - WindowRect.top;
- lprect->right = lprect->left + NtUserGetSystemMetrics(SM_CXVSCROLL);
lprect->bottom = ClientRect.bottom - WindowRect.top;
vertical = TRUE;
break;
break;
default:
- IntReleaseWindowObject(Window);
return FALSE;
}
{
INT Thumb, ThumbBox, ThumbPos, cxy, mx;
RECT ClientRect;
-
+
switch(idObject)
{
case SB_HORZ:
- Thumb = NtUserGetSystemMetrics(SM_CXHSCROLL);
+ Thumb = UserGetSystemMetrics(SM_CXHSCROLL);
cxy = psbi->rcScrollBar.right - psbi->rcScrollBar.left;
break;
case SB_VERT:
- Thumb = NtUserGetSystemMetrics(SM_CYVSCROLL);
+ Thumb = UserGetSystemMetrics(SM_CYVSCROLL);
cxy = psbi->rcScrollBar.bottom - psbi->rcScrollBar.top;
break;
case SB_CTL:
IntGetClientRect (Window, &ClientRect);
if(Window->Style & SBS_VERT)
{
- Thumb = NtUserGetSystemMetrics(SM_CYVSCROLL);
+ Thumb = UserGetSystemMetrics(SM_CYVSCROLL);
cxy = ClientRect.bottom - ClientRect.top;
}
else
{
- Thumb = NtUserGetSystemMetrics(SM_CXHSCROLL);
+ Thumb = UserGetSystemMetrics(SM_CXHSCROLL);
cxy = ClientRect.right - ClientRect.left;
}
break;
}
else
{
- ThumbBox = psi->nPage ? MINTRACKTHUMB : NtUserGetSystemMetrics(SM_CXHTHUMB);
+ ThumbBox = psi->nPage ? MINTRACKTHUMB : UserGetSystemMetrics(SM_CXHTHUMB);
cxy -= (2 * Thumb);
if(cxy >= ThumbBox)
{
{
ThumbBox = max(EngMulDiv(cxy, psi->nPage, psi->nMax - psi->nMin + 1), ThumbBox);
}
-
+
if(cxy > ThumbBox)
{
mx = psi->nMax - max(psi->nPage - 1, 0);
else
ThumbPos = Thumb + ThumbBox;
}
-
+
psbi->xyThumbTop = ThumbPos;
psbi->xyThumbBottom = ThumbPos + ThumbBox;
}
return TRUE;
}
+static VOID FASTCALL
+IntUpdateSBInfo(PWINDOW_OBJECT Window, int wBar)
+{
+ PSCROLLBARINFO sbi;
+ LPSCROLLINFO psi;
+
+ ASSERT(Window);
+ ASSERT(Window->Scroll);
+
+ sbi = IntGetScrollbarInfoFromWindow(Window, wBar);
+ psi = IntGetScrollInfoFromWindow(Window, wBar);
+ IntGetScrollBarRect(Window, wBar, &(sbi->rcScrollBar));
+ IntCalculateThumb(Window, wBar, sbi, psi);
+}
+
static BOOL FASTCALL
-IntGetScrollInfo(PWINDOW_OBJECT Window, INT nBar, LPSCROLLINFO lpsi)
+co_IntGetScrollInfo(PWINDOW_OBJECT Window, INT nBar, LPSCROLLINFO lpsi)
{
UINT Mask;
LPSCROLLINFO psi;
- PSCROLLBARINFO Info;
-
- switch (nBar)
- {
- case SB_HORZ:
- Info = Window->pHScroll;
- break;
- case SB_VERT:
- Info = Window->pVScroll;
- break;
- case SB_CTL:
- if (Window->ExtraDataSize < sizeof(SCROLLBARINFO) + sizeof(SCROLLINFO))
- {
- Info = NULL;
- }
- else
- {
- Info = (PSCROLLBARINFO) Window->ExtraData;
- }
- break;
- default:
- DPRINT1("Trying to get scrollinfo for unknown scrollbar type %d", nBar);
- return FALSE;
- }
- if (NULL == Info)
+ ASSERT_REFS(Window);
+
+ if(!SBID_IS_VALID(nBar))
+ {
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ DPRINT1("Trying to get scrollinfo for unknown scrollbar type %d\n", nBar);
+ return FALSE;
+ }
+
+ if(!co_IntCreateScrollBars(Window))
{
- DPRINT1("No scrollinfo available\n");
return FALSE;
}
-
- psi = (LPSCROLLINFO)(Info + 1);
-
+
+ psi = IntGetScrollInfoFromWindow(Window, nBar);
+
if (lpsi->fMask == SIF_ALL)
{
Mask = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_TRACKPOS;
{
lpsi->nPage = psi->nPage;
}
-
+
if (0 != (Mask & SIF_POS))
{
lpsi->nPos = psi->nPos;
}
-
+
if (0 != (Mask & SIF_RANGE))
{
lpsi->nMin = psi->nMin;
{
lpsi->nTrackPos = psi->nTrackPos;
}
-
+
return TRUE;
}
static DWORD FASTCALL
-IntSetScrollInfo(PWINDOW_OBJECT Window, INT nBar, LPCSCROLLINFO lpsi, BOOL bRedraw)
+co_IntSetScrollInfo(PWINDOW_OBJECT Window, INT nBar, LPCSCROLLINFO lpsi, BOOL bRedraw)
{
/*
* Update the scrollbar state and set action flags according to
/* UINT new_flags;*/
BOOL bChangeParams = FALSE; /* don't show/hide scrollbar if params don't change */
- if (lpsi->cbSize != sizeof(SCROLLINFO) &&
+ ASSERT_REFS(Window);
+
+ if(!SBID_IS_VALID(nBar))
+ {
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ DPRINT1("Trying to set scrollinfo for unknown scrollbar type %d", nBar);
+ return FALSE;
+ }
+
+ if(!co_IntCreateScrollBars(Window))
+ {
+ return FALSE;
+ }
+
+ if (lpsi->cbSize != sizeof(SCROLLINFO) &&
lpsi->cbSize != (sizeof(SCROLLINFO) - sizeof(lpsi->nTrackPos)))
{
SetLastWin32Error(ERROR_INVALID_PARAMETER);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return 0;
}
- switch (nBar)
- {
- case SB_HORZ:
- if (NULL == Window->pHScroll)
- {
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- return 0;
- }
- psbi = Window->pHScroll;
- break;
- case SB_VERT:
- if (NULL == Window->pVScroll)
- {
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- return 0;
- }
- psbi = Window->pVScroll;
- break;
- case SB_CTL:
- if (Window->ExtraDataSize < sizeof(SCROLLBARINFO) + sizeof(SCROLLINFO))
- {
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- return 0;
- }
- psbi = (PSCROLLBARINFO) Window->ExtraData;
- break;
- default:
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- return 0;
- }
- Info = (LPSCROLLINFO)(psbi + 1);
+ psbi = IntGetScrollbarInfoFromWindow(Window, nBar);
+ Info = IntGetScrollInfoFromWindow(Window, nBar);
/* Set the page size */
if (0 != (lpsi->fMask & SIF_PAGE))
/* Check if the scrollbar should be hidden or disabled */
if (0 != (lpsi->fMask & (SIF_RANGE | SIF_PAGE | SIF_DISABLENOSCROLL)))
{
- if (Info->nMin >= Info->nMax - max(Info->nPage - 1, 0))
+ if (Info->nMin >= (int)(Info->nMax - max(Info->nPage - 1, 0)))
{
/* Hide or disable scroll-bar */
if (0 != (lpsi->fMask & SIF_DISABLENOSCROLL))
}
else if ((nBar != SB_CTL) && bChangeParams)
{
- NtUserShowScrollBar(Window->Self, nBar, FALSE);
+ co_UserShowScrollBar(Window, nBar, FALSE);
return Info->nPos;
}
}
/* new_flags = 0;*/
if ((nBar != SB_CTL) && bChangeParams)
{
- NtUserShowScrollBar(Window->Self, nBar, TRUE);
+ co_UserShowScrollBar(Window, nBar, TRUE);
}
}
UpdateRect.right -= Window->ClientRect.left - Window->WindowRect.left;
UpdateRect.top -= Window->ClientRect.top - Window->WindowRect.top;
UpdateRect.bottom -= Window->ClientRect.top - Window->WindowRect.top;
- IntRedrawWindow(Window, &UpdateRect, 0, RDW_INVALIDATE | RDW_FRAME);
+ co_UserRedrawWindow(Window, &UpdateRect, 0, RDW_INVALIDATE | RDW_FRAME);
}
/* Return current position */
}
BOOL FASTCALL
-IntGetScrollBarInfo(PWINDOW_OBJECT Window, LONG idObject, PSCROLLBARINFO psbi)
+co_IntGetScrollBarInfo(PWINDOW_OBJECT Window, LONG idObject, PSCROLLBARINFO psbi)
{
INT Bar;
PSCROLLBARINFO sbi;
LPSCROLLINFO psi;
-
- switch(idObject)
- {
- case OBJID_HSCROLL:
- Bar = SB_HORZ;
- sbi = Window->pHScroll;
- break;
- case OBJID_VSCROLL:
- Bar = SB_VERT;
- sbi = Window->pVScroll;
- break;
- case OBJID_CLIENT:
- Bar = SB_CTL;
- if (Window->ExtraDataSize < sizeof(SCROLLBARINFO) + sizeof(SCROLLINFO))
- {
- sbi = NULL;
- }
- else
- {
- sbi = (PSCROLLBARINFO) Window->ExtraData;
- }
- break;
- default:
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- return FALSE;
- }
- if (NULL == sbi)
+ ASSERT_REFS(Window);
+
+ Bar = SBOBJ_TO_SBID(idObject);
+
+ if(!SBID_IS_VALID(Bar))
+ {
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ DPRINT1("Trying to get scrollinfo for unknown scrollbar type %d\n", Bar);
+ return FALSE;
+ }
+
+ if(!co_IntCreateScrollBars(Window))
{
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
-
- psi = (LPSCROLLINFO)(sbi + 1);
+
+ sbi = IntGetScrollbarInfoFromWindow(Window, Bar);
+ psi = IntGetScrollInfoFromWindow(Window, Bar);
IntGetScrollBarRect(Window, Bar, &(sbi->rcScrollBar));
IntCalculateThumb(Window, Bar, sbi, psi);
-
+
RtlCopyMemory(psbi, sbi, sizeof(SCROLLBARINFO));
-
+
return TRUE;
}
-DWORD FASTCALL
-IntCreateScrollBar(PWINDOW_OBJECT Window, LONG idObject)
+BOOL FASTCALL
+co_IntCreateScrollBars(PWINDOW_OBJECT Window)
{
PSCROLLBARINFO psbi;
LPSCROLLINFO psi;
LRESULT Result;
+ ULONG Size, s;
INT i;
- psbi = ExAllocatePoolWithTag(PagedPool, sizeof(SCROLLBARINFO) + sizeof(SCROLLINFO), TAG_SBARINFO);
- if(!psbi)
+ ASSERT_REFS(Window);
+
+ if(Window->Scroll)
+ {
+ /* no need to create it anymore */
+ return TRUE;
+ }
+
+ /* allocate memory for all scrollbars (HORZ, VERT, CONTROL) */
+ Size = 3 * (sizeof(WINDOW_SCROLLINFO));
+ if(!(Window->Scroll = ExAllocatePoolWithTag(PagedPool, Size, TAG_SBARINFO)))
+ {
+ DPRINT1("Unable to allocate memory for scrollbar information for window 0x%x\n", Window->hSelf);
return FALSE;
-
- psi = (LPSCROLLINFO)((PSCROLLBARINFO)(psbi + 1));
-
- psi->cbSize = sizeof(LPSCROLLINFO);
- psi->nMin = 0;
- psi->nMax = 100;
- psi->nPage = 0;
- psi->nPos = 0;
- psi->nTrackPos = 0;
-
- Result = WinPosGetNonClientSize(Window->Self,
+ }
+
+ RtlZeroMemory(Window->Scroll, Size);
+
+ Result = co_WinPosGetNonClientSize(Window->hSelf,
&Window->WindowRect,
&Window->ClientRect);
- psbi->cbSize = sizeof(SCROLLBARINFO);
+ for(s = SB_HORZ; s <= SB_VERT; s++)
+ {
+ psbi = IntGetScrollbarInfoFromWindow(Window, s);
+ psbi->cbSize = sizeof(SCROLLBARINFO);
+ for (i = 0; i < CCHILDREN_SCROLLBAR + 1; i++)
+ psbi->rgstate[i] = 0;
- for (i = 0; i < CCHILDREN_SCROLLBAR + 1; i++)
- psbi->rgstate[i] = 0;
+ psi = IntGetScrollInfoFromWindow(Window, s);
+ psi->cbSize = sizeof(LPSCROLLINFO);
+ psi->nMax = 100;
- switch(idObject)
- {
- case SB_HORZ:
- Window->pHScroll = psbi;
- break;
- case SB_VERT:
- Window->pVScroll = psbi;
- break;
- case SB_CTL:
- Window->wExtra = psbi;
- break;
- default:
- ExFreePool(psbi);
- return FALSE;
+ IntGetScrollBarRect(Window, s, &(psbi->rcScrollBar));
+ IntCalculateThumb(Window, s, psbi, psi);
}
- IntGetScrollBarRect(Window, idObject, &(psbi->rcScrollBar));
- IntCalculateThumb(Window, idObject, psbi, psi);
-
- return 0;
+ return TRUE;
}
-BOOL FASTCALL
-IntDestroyScrollBar(PWINDOW_OBJECT Window, LONG idObject)
+BOOL FASTCALL
+IntDestroyScrollBars(PWINDOW_OBJECT Window)
{
- switch(idObject)
+ if(Window->Scroll)
{
- case SB_HORZ:
- if(Window->pHScroll)
- {
- ExFreePool(Window->pHScroll);
- Window->pHScroll = NULL;
- return TRUE;
- }
- return FALSE;
- case SB_VERT:
- if(Window->pVScroll)
- {
- ExFreePool(Window->pVScroll);
- Window->pVScroll = NULL;
- return TRUE;
- }
- return FALSE;
- case SB_CTL:
- if(Window->wExtra)
- {
- ExFreePool(Window->wExtra);
- Window->wExtra = NULL;
- return TRUE;
- }
- return FALSE;
+ ExFreePool(Window->Scroll);
+ Window->Scroll = NULL;
+ return TRUE;
}
return FALSE;
}
-#define CHANGERGSTATE(item, status) \
- if(Info->rgstate[(item)] != (status)) \
- Chg = TRUE; \
- Info->rgstate[(item)] = (status);
-
-
BOOL STDCALL
IntEnableScrollBar(BOOL Horz, PSCROLLBARINFO Info, UINT wArrows)
{
SCROLLBARINFO sbi;
PWINDOW_OBJECT Window;
BOOL Ret;
+ DECLARE_RETURN(BOOL);
+
+ DPRINT("Enter NtUserGetScrollBarInfo\n");
+ UserEnterExclusive();
Status = MmCopyFromCaller(&sbi, psbi, sizeof(SCROLLBARINFO));
if(!NT_SUCCESS(Status) || (sbi.cbSize != sizeof(SCROLLBARINFO)))
{
SetLastNtError(Status);
- return FALSE;
+ RETURN(FALSE);
}
- Window = IntGetWindowObject(hWnd);
-
- if(!Window)
+ if(!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
- return FALSE;
+ RETURN(FALSE);
}
- Ret = IntGetScrollBarInfo(Window, idObject, &sbi);
+ UserReferenceWindowObjectCo(Window);
+ Ret = co_IntGetScrollBarInfo(Window, idObject, &sbi);
+ UserDereferenceWindowObjectCo(Window);
Status = MmCopyToCaller(psbi, &sbi, sizeof(SCROLLBARINFO));
if(!NT_SUCCESS(Status))
SetLastNtError(Status);
Ret = FALSE;
}
- IntReleaseWindowObject(Window);
- return Ret;
+
+ RETURN( Ret);
+
+CLEANUP:
+ DPRINT("Leave NtUserGetScrollBarInfo, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
+
}
BOOL
STDCALL
-NtUserGetScrollInfo(HWND hwnd, int fnBar, LPSCROLLINFO lpsi)
+NtUserGetScrollInfo(HWND hWnd, int fnBar, LPSCROLLINFO lpsi)
{
NTSTATUS Status;
PWINDOW_OBJECT Window;
SCROLLINFO psi;
DWORD sz;
BOOL Ret;
+ DECLARE_RETURN(BOOL);
+ DPRINT("Enter NtUserGetScrollInfo\n");
+ UserEnterShared();
+
Status = MmCopyFromCaller(&psi.cbSize, &(lpsi->cbSize), sizeof(UINT));
- if(!NT_SUCCESS(Status) ||
+ if(!NT_SUCCESS(Status) ||
!((psi.cbSize == sizeof(SCROLLINFO)) || (psi.cbSize == sizeof(SCROLLINFO) - sizeof(psi.nTrackPos))))
{
SetLastNtError(Status);
- return FALSE;
+ RETURN(FALSE);
}
sz = psi.cbSize;
Status = MmCopyFromCaller(&psi, lpsi, sz);
if (!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- return FALSE;
+ RETURN(FALSE);
}
-
- Window = IntGetWindowObject(hwnd);
- if(!Window)
+ if(!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
- return FALSE;
+ RETURN(FALSE);
}
-
- Ret = IntGetScrollInfo(Window, fnBar, &psi);
-
- IntReleaseWindowObject(Window);
-
+
+ UserReferenceWindowObjectCo(Window);
+ Ret = co_IntGetScrollInfo(Window, fnBar, &psi);
+ UserDereferenceWindowObjectCo(Window);
+
Status = MmCopyToCaller(lpsi, &psi, sz);
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- return FALSE;
+ RETURN( FALSE);
}
+
+ RETURN( Ret);
- return Ret;
+CLEANUP:
+ DPRINT("Leave NtUserGetScrollInfo, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
}
BOOL
STDCALL
NtUserEnableScrollBar(
- HWND hWnd,
- UINT wSBflags,
+ HWND hWnd,
+ UINT wSBflags,
UINT wArrows)
{
- PWINDOW_OBJECT Window;
+ PWINDOW_OBJECT Window = NULL;
PSCROLLBARINFO InfoV = NULL, InfoH = NULL;
BOOL Chg = FALSE;
+ DECLARE_RETURN(BOOL);
- Window = IntGetWindowObject(hWnd);
+ DPRINT("Enter NtUserEnableScrollBar\n");
+ UserEnterExclusive();
- if(!Window)
+ if(!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
- return FALSE;
+ RETURN(FALSE);
}
-
+ UserReferenceWindowObjectCo(Window);
+
+ if(wSBflags == SB_CTL)
+ {
+ /* FIXME Enable or Disable SB Ctrl*/
+ DPRINT1("Enable Scrollbar SB_CTL\n");
+ InfoV = IntGetScrollbarInfoFromWindow(Window, SB_CTL);
+ Chg = IntEnableScrollBar(FALSE, InfoV ,wArrows);
+ /* Chg? Scrollbar is Refresh in user32/controls/scrollbar.c. */
+
+ RETURN(TRUE);
+ }
+
+ if(wSBflags != SB_BOTH && !SBID_IS_VALID(wSBflags))
+ {
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ DPRINT1("Trying to set scrollinfo for unknown scrollbar type %d", wSBflags);
+ RETURN(FALSE);
+ }
+
+ if(!co_IntCreateScrollBars(Window))
+ {
+ RETURN( FALSE);
+ }
+
switch(wSBflags)
{
case SB_BOTH:
- InfoV = Window->pVScroll;
+ InfoV = IntGetScrollbarInfoFromWindow(Window, SB_VERT);
/* fall through */
case SB_HORZ:
- InfoH = Window->pHScroll;
+ InfoH = IntGetScrollbarInfoFromWindow(Window, SB_HORZ);
break;
case SB_VERT:
- InfoV = Window->pVScroll;
- break;
- case SB_CTL:
- InfoV = Window->wExtra;
+ InfoV = IntGetScrollbarInfoFromWindow(Window, SB_VERT);
break;
default:
- IntReleaseWindowObject(Window);
- return FALSE;
+ RETURN(FALSE);
}
-
+
if(InfoV)
Chg = IntEnableScrollBar(FALSE, InfoV, wArrows);
-
+
if(InfoH)
Chg = (IntEnableScrollBar(TRUE, InfoH, wArrows) || Chg);
//if(Chg && (Window->Style & WS_VISIBLE))
/* FIXME - repaint scrollbars */
- IntReleaseWindowObject(Window);
- return TRUE;
+ RETURN( TRUE);
+
+CLEANUP:
+ if (Window) UserDereferenceWindowObjectCo(Window);
+
+ DPRINT("Leave NtUserEnableScrollBar, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
}
BOOL
STDCALL
NtUserSetScrollBarInfo(
- HWND hwnd,
+ HWND hWnd,
LONG idObject,
SETSCROLLBARINFO *info)
{
- PWINDOW_OBJECT Window;
+ PWINDOW_OBJECT Window = NULL;
SETSCROLLBARINFO Safeinfo;
- PSCROLLBARINFO sbi = NULL;
+ PSCROLLBARINFO sbi;
LPSCROLLINFO psi;
NTSTATUS Status;
-
- Window = IntGetWindowObject(hwnd);
+ LONG Obj;
+ DECLARE_RETURN(BOOL);
+
+ DPRINT("Enter NtUserSetScrollBarInfo\n");
+ UserEnterExclusive();
- if(!Window)
+ if(!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
- return FALSE;
+ RETURN( FALSE);
}
-
+ UserReferenceWindowObjectCo(Window);
+
+ Obj = SBOBJ_TO_SBID(idObject);
+ if(!SBID_IS_VALID(Obj))
+ {
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ DPRINT1("Trying to set scrollinfo for unknown scrollbar type %d", Obj);
+ RETURN( FALSE);
+ }
+
+ if(!co_IntCreateScrollBars(Window))
+ {
+ RETURN(FALSE);
+ }
+
Status = MmCopyFromCaller(&Safeinfo, info, sizeof(SETSCROLLBARINFO));
if(!NT_SUCCESS(Status))
{
- IntReleaseWindowObject(Window);
SetLastNtError(Status);
- return FALSE;
+ RETURN(FALSE);
}
-
- switch(idObject)
- {
- case OBJID_HSCROLL:
- sbi = Window->pHScroll;
- break;
- case OBJID_VSCROLL:
- sbi = Window->pVScroll;
- break;
- case OBJID_CLIENT:
- /* FIXME */
- IntReleaseWindowObject(Window);
- return FALSE;
- default:
- IntReleaseWindowObject(Window);
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- return FALSE;
- }
-
- if(!sbi)
- {
- DPRINT1("SCROLLBARINFO structure not allocated!\n");
- IntReleaseWindowObject(Window);
- return FALSE;
- }
-
- psi = (LPSCROLLINFO)((PSCROLLBARINFO)(sbi + 1));
-
+ sbi = IntGetScrollbarInfoFromWindow(Window, Obj);
+ psi = IntGetScrollInfoFromWindow(Window, Obj);
+
psi->nTrackPos = Safeinfo.nTrackPos;
sbi->reserved = Safeinfo.reserved;
RtlCopyMemory(&sbi->rgstate, &Safeinfo.rgstate, sizeof(Safeinfo.rgstate));
+
+ RETURN(TRUE);
- IntReleaseWindowObject(Window);
- return TRUE;
+CLEANUP:
+ if (Window) UserDereferenceWindowObjectCo(Window);
+
+ DPRINT("Leave NtUserSetScrollBarInfo, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
}
DWORD
STDCALL
NtUserSetScrollInfo(
- HWND hwnd,
- int fnBar,
- LPCSCROLLINFO lpsi,
+ HWND hWnd,
+ int fnBar,
+ LPCSCROLLINFO lpsi,
BOOL bRedraw)
{
- PWINDOW_OBJECT Window;
+ PWINDOW_OBJECT Window = NULL;
NTSTATUS Status;
SCROLLINFO ScrollInfo;
- DWORD Ret;
+ DECLARE_RETURN(DWORD);
- Window = IntGetWindowObject(hwnd);
+ DPRINT("Enter NtUserSetScrollInfo\n");
+ UserEnterExclusive();
- if(!Window)
+ if(!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
- return 0;
+ RETURN( 0);
}
-
+ UserReferenceWindowObjectCo(Window);
+
Status = MmCopyFromCaller(&ScrollInfo, lpsi, sizeof(SCROLLINFO) - sizeof(ScrollInfo.nTrackPos));
if(!NT_SUCCESS(Status))
{
- IntReleaseWindowObject(Window);
SetLastNtError(Status);
- return 0;
+ RETURN( 0);
}
+
+ RETURN(co_IntSetScrollInfo(Window, fnBar, &ScrollInfo, bRedraw));
+
+CLEANUP:
+ if (Window) UserDereferenceWindowObjectCo(Window);
+
+ DPRINT("Leave NtUserSetScrollInfo, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
- Ret = IntSetScrollInfo(Window, fnBar, &ScrollInfo, bRedraw);
- IntReleaseWindowObject(Window);
-
- return Ret;
}
/* Ported from WINE20020904 (SCROLL_ShowScrollBar) */
-DWORD STDCALL
-NtUserShowScrollBar(HWND hWnd, int wBar, DWORD bShow)
+DWORD FASTCALL
+co_UserShowScrollBar(PWINDOW_OBJECT Window, int wBar, DWORD bShow)
{
- PWINDOW_OBJECT Window = IntGetWindowObject(hWnd);
+ DWORD Style, OldStyle;
+
+ ASSERT_REFS(Window);
- if (!Window)
+ switch(wBar)
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
- return FALSE;
+ case SB_HORZ:
+ Style = WS_HSCROLL;
+ break;
+ case SB_VERT:
+ Style = WS_VSCROLL;
+ break;
+ case SB_BOTH:
+ Style = WS_HSCROLL | WS_VSCROLL;
+ break;
+ case SB_CTL:
+ Style = 0;
+ break;
+ default:
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ return( FALSE);
}
+ if(!co_IntCreateScrollBars(Window))
+ {
+ return( FALSE);
+ }
+
if (wBar == SB_CTL)
{
- WinPosShowWindow(hWnd, bShow ? SW_SHOW : SW_HIDE);
- IntReleaseWindowObject(Window);
- return TRUE;
+ IntUpdateSBInfo(Window, SB_CTL);
+
+ co_WinPosShowWindow(Window->hSelf, bShow ? SW_SHOW : SW_HIDE);
+ return( TRUE);
}
- if (wBar == SB_BOTH || wBar == SB_HORZ)
+ OldStyle = Window->Style;
+ if(bShow)
+ Window->Style |= Style;
+ else
+ Window->Style &= ~Style;
+
+ if(Window->Style != OldStyle)
{
- if (bShow)
- {
- Window->Style |= WS_HSCROLL;
- if (!Window->pHScroll)
- IntCreateScrollBar(Window, SB_HORZ);
- }
- else
- {
- Window->Style &= ~WS_HSCROLL;
- }
+ if(Window->Style & WS_HSCROLL)
+ IntUpdateSBInfo(Window, SB_HORZ);
+ if(Window->Style & WS_VSCROLL)
+ IntUpdateSBInfo(Window, SB_VERT);
+
+ if(Window->Style & WS_VISIBLE)
+ {
+ /* Frame has been changed, let the window redraw itself */
+ co_WinPosSetWindowPos(Window->hSelf, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
+ SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOSENDCHANGING);
+ }
}
- if (wBar == SB_BOTH || wBar == SB_VERT)
+ return( TRUE);
+}
+
+
+DWORD STDCALL
+NtUserShowScrollBar(HWND hWnd, int wBar, DWORD bShow)
+{
+ PWINDOW_OBJECT Window;
+ DECLARE_RETURN(DWORD);
+ DWORD ret;
+
+ DPRINT("Enter NtUserShowScrollBar\n");
+ UserEnterExclusive();
+
+ if (!(Window = UserGetWindowObject(hWnd)))
{
- if (bShow)
- {
- Window->Style |= WS_VSCROLL;
- if (!Window->pVScroll)
- IntCreateScrollBar(Window, SB_VERT);
- }
- else
- {
- Window->Style &= ~WS_VSCROLL;
- }
+ RETURN(0);
}
+
+ UserReferenceWindowObjectCo(Window);
+ ret = co_UserShowScrollBar(Window, wBar, bShow);
+ UserDereferenceWindowObjectCo(Window);
+
+ RETURN(ret);
+
+CLEANUP:
+ DPRINT("Leave NtUserShowScrollBar, ret%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
- /* 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 | SWP_NOSENDCHANGING);
-
- IntReleaseWindowObject(Window);
- return TRUE;
}
-
/* EOF */