#include <w32k.h>
-#ifdef __USE_W32API
-#include <oleacc.h>
-#endif
-
#define NDEBUG
#include <debug.h>
#define CHANGERGSTATE(item, status) \
if(Info->rgstate[(item)] != (status)) \
Chg = TRUE; \
- Info->rgstate[(item)] = (status);
+ Info->rgstate[(item)] = (status);
/* FUNCTIONS *****************************************************************/
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;
if(Window->ExStyle & WS_EX_LEFTSCROLLBAR)
{
lprect->right = ClientRect.left - WindowRect.left;
- lprect->left = lprect->right - NtUserGetSystemMetrics(SM_CXVSCROLL);
+ lprect->left = lprect->right - UserGetSystemMetrics(SM_CXVSCROLL);
}
else
{
lprect->left = ClientRect.right - WindowRect.left;
- lprect->right = lprect->left + NtUserGetSystemMetrics(SM_CXVSCROLL);
+ lprect->right = lprect->left + UserGetSystemMetrics(SM_CXVSCROLL);
}
lprect->top = ClientRect.top - WindowRect.top;
lprect->bottom = ClientRect.bottom - WindowRect.top;
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;
}
{
PSCROLLBARINFO sbi;
LPSCROLLINFO psi;
-
+
ASSERT(Window);
ASSERT(Window->Scroll);
-
+
sbi = IntGetScrollbarInfoFromWindow(Window, wBar);
psi = IntGetScrollInfoFromWindow(Window, wBar);
IntGetScrollBarRect(Window, wBar, &(sbi->rcScrollBar));
}
static BOOL FASTCALL
-IntGetScrollInfo(PWINDOW_OBJECT Window, INT nBar, LPSCROLLINFO lpsi)
+co_IntGetScrollInfo(PWINDOW_OBJECT Window, INT nBar, LPSCROLLINFO lpsi)
{
UINT Mask;
LPSCROLLINFO psi;
-
+
+ ASSERT_REFS(Window);
+
if(!SBID_IS_VALID(nBar))
{
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
- if(!IntCreateScrollBars(Window))
+ if(!co_IntCreateScrollBars(Window))
{
return FALSE;
}
-
+
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 */
+ ASSERT_REFS(Window);
+
if(!SBID_IS_VALID(nBar))
{
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
- if(!IntCreateScrollBars(Window))
+ if(!co_IntCreateScrollBars(Window))
{
return FALSE;
}
-
- if (lpsi->cbSize != sizeof(SCROLLINFO) &&
+
+ if (lpsi->cbSize != sizeof(SCROLLINFO) &&
lpsi->cbSize != (sizeof(SCROLLINFO) - sizeof(lpsi->nTrackPos)))
{
SetLastWin32Error(ERROR_INVALID_PARAMETER);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return 0;
}
-
+
psbi = IntGetScrollbarInfoFromWindow(Window, nBar);
Info = IntGetScrollInfoFromWindow(Window, nBar);
/* 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;
-
+
+ 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(!IntCreateScrollBars(Window))
+
+ if(!co_IntCreateScrollBars(Window))
{
return FALSE;
}
-
+
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;
}
-BOOL FASTCALL
-IntCreateScrollBars(PWINDOW_OBJECT Window)
+BOOL FASTCALL
+co_IntCreateScrollBars(PWINDOW_OBJECT Window)
{
PSCROLLBARINFO psbi;
LPSCROLLINFO psi;
LRESULT Result;
ULONG Size, s;
INT i;
-
+
+ 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->Self);
+ DPRINT1("Unable to allocate memory for scrollbar information for window 0x%x\n", Window->hSelf);
return FALSE;
}
-
+
RtlZeroMemory(Window->Scroll, Size);
- Result = WinPosGetNonClientSize(Window->Self,
+ Result = co_WinPosGetNonClientSize(Window->hSelf,
&Window->WindowRect,
&Window->ClientRect);
-
+
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;
-
+
psi = IntGetScrollInfoFromWindow(Window, s);
psi->cbSize = sizeof(LPSCROLLINFO);
psi->nMax = 100;
-
+
IntGetScrollBarRect(Window, s, &(psbi->rcScrollBar));
IntCalculateThumb(Window, s, psbi, psi);
}
return TRUE;
}
-BOOL FASTCALL
+BOOL FASTCALL
IntDestroyScrollBars(PWINDOW_OBJECT Window)
{
if(Window->Scroll)
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 */
- IntReleaseWindowObject(Window);
- return FALSE;
+ /* 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))
{
- IntReleaseWindowObject(Window);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
DPRINT1("Trying to set scrollinfo for unknown scrollbar type %d", wSBflags);
- return FALSE;
+ RETURN(FALSE);
}
-
- if(!IntCreateScrollBars(Window))
+
+ if(!co_IntCreateScrollBars(Window))
{
- IntReleaseWindowObject(Window);
- return FALSE;
+ RETURN( FALSE);
}
-
+
switch(wSBflags)
{
case SB_BOTH:
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;
LPSCROLLINFO psi;
NTSTATUS Status;
LONG Obj;
-
- Window = IntGetWindowObject(hwnd);
+ 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))
{
- IntReleaseWindowObject(Window);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
DPRINT1("Trying to set scrollinfo for unknown scrollbar type %d", Obj);
- return FALSE;
+ RETURN( FALSE);
}
- if(!IntCreateScrollBars(Window))
+ if(!co_IntCreateScrollBars(Window))
{
- IntReleaseWindowObject(Window);
- return FALSE;
+ RETURN(FALSE);
}
-
+
Status = MmCopyFromCaller(&Safeinfo, info, sizeof(SETSCROLLBARINFO));
if(!NT_SUCCESS(Status))
{
- IntReleaseWindowObject(Window);
SetLastNtError(Status);
- return FALSE;
+ RETURN(FALSE);
}
-
+
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)
{
DWORD Style, OldStyle;
- PWINDOW_OBJECT Window = IntGetWindowObject(hWnd);
- if (!Window)
- {
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
- return FALSE;
- }
-
+ ASSERT_REFS(Window);
+
switch(wBar)
{
case SB_HORZ:
Style = 0;
break;
default:
- IntReleaseWindowObject(Window);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
- return FALSE;
+ return( FALSE);
}
-
- if(!IntCreateScrollBars(Window))
+
+ if(!co_IntCreateScrollBars(Window))
{
- IntReleaseWindowObject(Window);
- return FALSE;
+ return( FALSE);
}
if (wBar == SB_CTL)
{
IntUpdateSBInfo(Window, SB_CTL);
-
- WinPosShowWindow(hWnd, bShow ? SW_SHOW : SW_HIDE);
- IntReleaseWindowObject(Window);
- return TRUE;
+
+ co_WinPosShowWindow(Window->hSelf, bShow ? SW_SHOW : SW_HIDE);
+ return( TRUE);
}
-
+
OldStyle = Window->Style;
if(bShow)
Window->Style |= Style;
else
Window->Style &= ~Style;
-
+
if(Window->Style != OldStyle)
{
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 */
- WinPosSetWindowPos(hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
+ co_WinPosSetWindowPos(Window->hSelf, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOSENDCHANGING);
}
}
-
- IntReleaseWindowObject(Window);
- return TRUE;
+
+ 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)))
+ {
+ 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;
+
+}
/* EOF */
projects / reactos.git / blobdiff