/*		
 * Interface code to SCROLLBAR widget
 *
 * Copyright  Martin Ayotte, 1993
 *
 * Small fixes and implemented SB_THUMBPOSITION
 * by Peter Broadhurst, 940611
 */

static char Copyright[] = "Copyright Martin Ayotte, 1993";

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "windows.h"
#include "sysmetrics.h"
#include "scroll.h"
#include "heap.h"
#include "win.h"
#include "prototypes.h"
#include "stddebug.h"
/* #define DEBUG_SCROLL */
/* #undef  DEBUG_SCROLL */
#include "debug.h"


HBITMAP hUpArrow = 0;
HBITMAP hDnArrow = 0;
HBITMAP hLfArrow = 0;
HBITMAP hRgArrow = 0;
HBITMAP hUpArrowD = 0;
HBITMAP hDnArrowD = 0;
HBITMAP hLfArrowD = 0;
HBITMAP hRgArrowD = 0;

  /* windows/graphics.c */
extern void GRAPH_DrawReliefRect( HDC hdc, RECT *rect,
                                  int thickness, BOOL pressed );

LPHEADSCROLL ScrollBarGetWindowAndStorage(HWND hWnd, WND **wndPtr);
LPHEADSCROLL ScrollBarGetStorageHeader(HWND hWnd);
LPHEADSCROLL GetScrollObjectStruct(HWND hWnd, int nBar);
void ScrollBarButtonDown(HWND hWnd, int nBar, int x, int y);
void ScrollBarButtonUp(HWND hWnd, int nBar, int x, int y);
void ScrollBarMouseMove(HWND hWnd, int nBar, WORD wParam, int x, int y);
void StdDrawScrollBar(HWND hWnd, HDC hDC, int nBar, LPRECT lprect, LPHEADSCROLL lphs);
int CreateScrollBarStruct(HWND hWnd);
void NC_CreateScrollBars(HWND hWnd);
LPHEADSCROLL AllocScrollBar(DWORD dwStyle, int width, int height);


/***********************************************************************
 *           WIDGETS_ScrollBarWndProc
 */
LONG ScrollBarWndProc( HWND hWnd, WORD message, WORD wParam, LONG lParam )
{    
	WND  	*wndPtr;
	LPHEADSCROLL lphs;
	PAINTSTRUCT ps;
	HDC		hDC;
	RECT 	rect;
	LPCREATESTRUCT lpCreat;
	POINT *pt;
	pt=(POINT*)&lParam;
	switch(message) {
    case WM_CREATE:
		lpCreat = (LPCREATESTRUCT)lParam;
		if (lpCreat->style & SBS_VERT) {
			if (lpCreat->style & SBS_LEFTALIGN)
				SetWindowPos(hWnd, 0, 0, 0, 16, lpCreat->cy, 
								SWP_NOZORDER | SWP_NOMOVE);
			if (lpCreat->style & SBS_RIGHTALIGN)
				SetWindowPos(hWnd, 0, lpCreat->x + lpCreat->cx - 16, 
						lpCreat->y, 16, lpCreat->cy, SWP_NOZORDER);
			}
		if (lpCreat->style & SBS_HORZ) {
			if (lpCreat->style & SBS_TOPALIGN)
				SetWindowPos(hWnd, 0, 0, 0, lpCreat->cx, 16,
								SWP_NOZORDER | SWP_NOMOVE);
			if (lpCreat->style & SBS_BOTTOMALIGN)
				SetWindowPos(hWnd, 0, lpCreat->x, 
						lpCreat->y + lpCreat->cy - 16, 
						lpCreat->cx, 16, SWP_NOZORDER);
			}
		CreateScrollBarStruct(hWnd);
		dprintf_scroll(stddeb,"ScrollBar Creation !\n");
		return 0;
	case WM_DESTROY:
		lphs = ScrollBarGetWindowAndStorage(hWnd, &wndPtr);
		if (lphs == 0) return 0;
		dprintf_scroll(stddeb,"ScrollBar WM_DESTROY %p !\n", lphs);
		free(lphs);
		*((LPHEADSCROLL *)&wndPtr->wExtra[1]) = 0;
		return 0;
	
	case WM_LBUTTONDOWN:
		SetCapture(hWnd);
		ScrollBarButtonDown(hWnd, SB_CTL, pt->x,pt->y);
		break;
	case WM_LBUTTONUP:
		ReleaseCapture();
		ScrollBarButtonUp(hWnd, SB_CTL, pt->x,pt->y);
		break;

	case WM_MOUSEMOVE:
		ScrollBarMouseMove(hWnd, SB_CTL, wParam, pt->x,pt->y);
		break;
	case WM_KEYDOWN:
	case WM_KEYUP:
	case WM_CHAR:
		lphs = ScrollBarGetWindowAndStorage(hWnd, &wndPtr);
		return(SendMessage(wndPtr->hwndParent, message, wParam, lParam));

    case WM_TIMER:
		dprintf_scroll(stddeb,"ScrollBar WM_TIMER wParam=%X lParam=%lX !\n", wParam, lParam);
		lphs = ScrollBarGetWindowAndStorage(hWnd, &wndPtr);
		KillTimer(hWnd, wParam);
		switch(lphs->ButtonDown) {
			case 0:
				lphs->TimerPending = FALSE;
				return 0;
			case 1:
			case 3:
				SendMessage(wndPtr->hwndParent, lphs->Direction, 
				SB_LINEUP, MAKELONG(0, hWnd));
				break;
			case 2:
			case 4:
				SendMessage(wndPtr->hwndParent, lphs->Direction, 
				SB_LINEDOWN, MAKELONG(0, hWnd));
				break;
			case 5:
				SendMessage(wndPtr->hwndParent, lphs->Direction, 
				SB_PAGEUP, MAKELONG(0, hWnd));
				break;
			case 6:
				SendMessage(wndPtr->hwndParent, lphs->Direction, 
				SB_PAGEDOWN, MAKELONG(0, hWnd));
				break;
			}
		SetTimer(hWnd, 1, 100, NULL);
		return 0;

	case WM_SETREDRAW:
#ifdef DEBUG_SCROLL
		printf("ScrollBar WM_SETREDRAW hWnd=%04X w=%04X !\n", hWnd, wParam);
#endif
		lphs = ScrollBarGetStorageHeader(hWnd);
		if (lphs == NULL) return 0;
		lphs->bRedrawFlag = wParam;
		break;

	case WM_PAINT:
		hDC = BeginPaint(hWnd, &ps);
		lphs = ScrollBarGetStorageHeader(hWnd);
		if (lphs != NULL && lphs->bRedrawFlag) {
			GetClientRect(hWnd, &rect);
			StdDrawScrollBar(hWnd, hDC, SB_CTL, &rect, lphs);
			}
		EndPaint(hWnd, &ps);
		break;
	default:
		return DefWindowProc( hWnd, message, wParam, lParam );
	}
	return(0);
}


void ScrollBarButtonDown(HWND hWnd, int nBar, int x, int y)
{
	LPHEADSCROLL lphs;
	HWND	hWndParent;
	RECT	rect;
	int		width, height;
	LONG	dwOwner;
	lphs = GetScrollObjectStruct(hWnd, nBar);
	if (nBar == SB_CTL) {
		hWndParent = GetParent(hWnd);
		dwOwner = MAKELONG(0, lphs->hWndOwner);
		dprintf_scroll(stddeb,"ScrollBarButtonDown SB_CTL // x=%d y=%d\n", x, y);
		}
	else {
		hWndParent = hWnd;
		dwOwner = 0L; 
		dprintf_scroll(stddeb,"ScrollBarButtonDown SB_?SCROLL // x=%d y=%d\n", x, y);
		}
/*
	SetFocus(lphs->hWndOwner);
*/
	CopyRect(&rect, &lphs->rect);
	dprintf_scroll(stddeb,"ScrollDown / x=%d y=%d left=%d top=%d right=%d bottom=%d \n",
					x, y, rect.left, rect.top, rect.right, rect.bottom);
	if (lphs->Direction == WM_VSCROLL) {
		width = rect.right - rect.left;
		if (y <= lphs->rectUp.bottom) {
			lphs->ButtonDown = 1;
			InvalidateRect(lphs->hWndOwner, &lphs->rectUp, TRUE); 
			dprintf_scroll(stddeb,"ScrollBarButtonDown send SB_LINEUP\n");
			SendMessage(hWndParent, lphs->Direction, 
								SB_LINEUP, dwOwner);
			}
		if (y >= lphs->rectDown.top) {
			lphs->ButtonDown = 2;
			InvalidateRect(lphs->hWndOwner, &lphs->rectDown, TRUE); 
			dprintf_scroll(stddeb,"ScrollBarButtonDown send SB_LINEDOWN\n");
			SendMessage(hWndParent, lphs->Direction, 
							SB_LINEDOWN, dwOwner);
			}
		if (y > lphs->rectUp.bottom && y < (lphs->CurPix + width)) {
			lphs->ButtonDown = 5;
			dprintf_scroll(stddeb,"ScrollBarButtonDown send SB_PAGEUP\n");
			SendMessage(hWndParent, lphs->Direction, 
								SB_PAGEUP, dwOwner);
			}
		if (y < lphs->rectDown.top && y > (lphs->CurPix + (width << 1))) {
			lphs->ButtonDown = 6;
			dprintf_scroll(stddeb,"ScrollBarButtonDown send SB_PAGEDOWN\n");
			SendMessage(hWndParent, lphs->Direction, 
							SB_PAGEDOWN, dwOwner);
			}
		if (lphs->MaxPix > 0 && y > (lphs->CurPix + width) &&
			y < (lphs->CurPix + (width << 1))) {
			lphs->ThumbActive = TRUE;
			dprintf_scroll(stddeb,"THUMB DOWN !\n");
			}
		}
	else {
		height = rect.bottom - rect.top;
		if (x <= lphs->rectUp.right) {
			lphs->ButtonDown = 3;
			InvalidateRect(lphs->hWndOwner, &lphs->rectUp, TRUE); 
			dprintf_scroll(stddeb,"ScrollBarButtonDown send SB_LINEUP\n");
			SendMessage(hWndParent, lphs->Direction, 
								SB_LINEUP, dwOwner);
			}
		if (x >= lphs->rectDown.left) {
			lphs->ButtonDown = 4;
			InvalidateRect(lphs->hWndOwner, &lphs->rectDown, TRUE); 
			dprintf_scroll(stddeb,"ScrollBarButtonDown send SB_LINEDOWN\n");
			SendMessage(hWndParent, lphs->Direction, 
							SB_LINEDOWN, dwOwner);
			}
		if (x > lphs->rectUp.right && x < (lphs->CurPix + height)) {
			lphs->ButtonDown = 5;
			dprintf_scroll(stddeb,"ScrollBarButtonDown send SB_PAGEUP\n");
			SendMessage(hWndParent, lphs->Direction, 
								SB_PAGEUP, dwOwner);
			}
		if (x < lphs->rectDown.left && x > (lphs->CurPix + (height << 1))) {
			lphs->ButtonDown = 6;
			dprintf_scroll(stddeb,"ScrollBarButtonDown send SB_PAGEDOWN\n");
			SendMessage(hWndParent, lphs->Direction, 
							SB_PAGEDOWN, dwOwner);
			}
		if (lphs->MaxPix > 0 && x > (lphs->CurPix + height) &&
			x < (lphs->CurPix + (height << 1))) {
			lphs->ThumbActive = TRUE;
			dprintf_scroll(stddeb,"THUMB DOWN !\n");
			}
		}
	if (lphs->ButtonDown != 0) {
		UpdateWindow(lphs->hWndOwner);
		if (!lphs->TimerPending && nBar == SB_CTL) {
			lphs->TimerPending = TRUE;
			SetTimer(lphs->hWndOwner, 1, 500, NULL);
			}
		}
}


void ScrollBarButtonUp(HWND hWnd, int nBar, int x, int y)
{
	LPHEADSCROLL lphs;
	RECT	rect;
	HDC		hDC;
	dprintf_scroll(stddeb,"ScrollBarButtonUp // x=%d y=%d\n", x, y); 
	lphs = GetScrollObjectStruct(hWnd, nBar);
	if(lphs->ThumbActive)
	  {
	    HWND hWndOwner,hWndParent;
	    if (nBar == SB_CTL) {
		hWndParent = GetParent(hWnd);
		hWndOwner = lphs->hWndOwner;
		}
	    else {
		hWndParent = hWnd;
		hWndOwner = 0;
		}

	
	    SendMessage(hWndParent, lphs->Direction, 
			SB_THUMBPOSITION, MAKELONG(lphs->ThumbVal, hWndOwner));
	    lphs->ThumbActive = FALSE;
	  }
	  
	if (lphs->ButtonDown != 0) {
		lphs->ButtonDown = 0;
		if (nBar == SB_CTL) {
			GetClientRect(lphs->hWndOwner, &rect);
			InvalidateRect(lphs->hWndOwner, &rect, TRUE);
			UpdateWindow(lphs->hWndOwner);
			}
		else {
			hDC = GetWindowDC(lphs->hWndOwner);
			StdDrawScrollBar(lphs->hWndOwner, hDC, nBar, &lphs->rect, lphs);
			ReleaseDC(lphs->hWndOwner, hDC);
			}
		}
}


void ScrollBarMouseMove(HWND hWnd, int nBar, WORD wParam, int x, int y)
{
	LPHEADSCROLL lphs;
	HWND	hWndParent;
	HWND	hWndOwner;

	if ((wParam & MK_LBUTTON) == 0) return;
	lphs = GetScrollObjectStruct(hWnd, nBar);
	if (lphs->ThumbActive == 0) return;
	if (nBar == SB_CTL) {
		hWndParent = GetParent(hWnd);
		hWndOwner = lphs->hWndOwner;
		dprintf_scroll(stddeb,"ScrollBarButtonMove SB_CTL // x=%d y=%d\n", x, y);
		}
	else {
		hWndParent = hWnd;
		hWndOwner = 0;
		dprintf_scroll(stddeb,"ScrollBarButtonMove SB_?SCROLL // x=%d y=%d\n", x, y);
		}

	if(x<lphs->rect.left||x>lphs->rect.right||
	   y<lphs->rect.top||y>lphs->rect.bottom)
	  {

	    dprintf_scroll(stddeb,"Rejecting thumb position !\n");
	    lphs->ThumbVal=lphs->CurVal;/*revert to last set position*/
	  }
	else
	  {
	
	    if (lphs->Direction == WM_VSCROLL) {
	      int butsiz = lphs->rect.right - lphs->rect.left;
	      y = y - butsiz - (butsiz >> 1);
	    }
	    else {
	      int butsiz = lphs->rect.bottom - lphs->rect.top;
	      y = x - butsiz - (butsiz >> 1);
	    }
	    if(y<0)y=0;
	    if(y>lphs->MaxPix)y=lphs->MaxPix;
	    lphs->ThumbVal = (y * (lphs->MaxVal - lphs->MinVal) / 
			      lphs->MaxPix) + lphs->MinVal;
	  }

	dprintf_scroll(stddeb,"Scroll WM_MOUSEMOVE val=%d pix=%d\n", 
		       lphs->ThumbVal, y);
	SendMessage(hWndParent, lphs->Direction, 
		SB_THUMBTRACK, MAKELONG(lphs->ThumbVal, hWndOwner));
}


LPHEADSCROLL ScrollBarGetWindowAndStorage(HWND hWnd, WND **wndPtr)
{
    WND  *Ptr;
    LPHEADSCROLL lphs;
    *(wndPtr) = Ptr = WIN_FindWndPtr(hWnd);
    if (Ptr == 0) {
    	fprintf(stderr,"Bad Window handle on ScrollBar !\n");
    	return 0;
    	}
    lphs = *((LPHEADSCROLL *)&Ptr->wExtra[1]);
    return lphs;
}


LPHEADSCROLL ScrollBarGetStorageHeader(HWND hWnd)
{
    WND  *wndPtr;
    LPHEADSCROLL lphs;
    wndPtr = WIN_FindWndPtr(hWnd);
    if (wndPtr == 0) {
    	fprintf(stderr,"Bad Window handle on ScrollBar !\n");
    	return 0;
    	}
    lphs = *((LPHEADSCROLL *)&wndPtr->wExtra[1]);
    return lphs;
}


void StdDrawScrollBar(HWND hWnd, HDC hDC, int nBar, LPRECT lprect, LPHEADSCROLL lphs)
{
	HWND	hWndParent;
	HBRUSH 	hBrush;
	HDC 	hMemDC;
        HBITMAP hOldBmp;
	BITMAP	bm;
	RECT 	rect;
	UINT  	w, w2, h, h2;

	if (lphs == NULL) return;
	if (!lphs->bRedrawFlag) return;
	dprintf_scroll(stddeb,"StdDrawScrollBar nBar=%04X !\n", nBar);
	if (lphs->Direction == WM_VSCROLL)
		dprintf_scroll(stddeb,"StdDrawScrollBar Vertical left=%d top=%d right=%d bottom=%d !\n", 
			lprect->left, lprect->top, lprect->right, lprect->bottom);
	else
		dprintf_scroll(stddeb,"StdDrawScrollBar Horizontal left=%d top=%d right=%d bottom=%d !\n", 
			lprect->left, lprect->top, lprect->right, lprect->bottom);
	if (nBar == SB_CTL)
		hWndParent = GetParent(hWnd);
	else
		hWndParent = lphs->hWndOwner;
	hBrush = SendMessage(hWndParent, WM_CTLCOLOR, (WORD)hDC,
					MAKELONG(hWnd, CTLCOLOR_SCROLLBAR));
	if (hBrush == (HBRUSH)NULL)  hBrush = GetStockObject(LTGRAY_BRUSH);
	CopyRect(&lphs->rect, lprect);
	CopyRect(&lphs->rectUp, lprect);
	CopyRect(&lphs->rectDown, lprect);
	CopyRect(&rect, lprect);
	w = rect.right - rect.left;
	h = rect.bottom - rect.top;
	if (w == 0 || h == 0) return;
	if (lphs->Direction == WM_VSCROLL) {
		if (h > 3 * w)
			lphs->MaxPix = h - 3 * w;
		else
			lphs->MaxPix = 0;
		if (h > 2 * w)
			h2 = w;
		else
			h2 = (h - 4) / 2;
		lphs->rectUp.bottom = h2;
		lphs->rectDown.top = rect.bottom - h2;
		}
	else {
		if (w > 3 * h)
			lphs->MaxPix = w - 3 * h;
		else
			lphs->MaxPix = 0;
		if (w > 2 * h)
			w2 = h;
		else
			w2 = (w - 4) / 2;
		lphs->rectUp.right = w2;
		lphs->rectDown.left = rect.right - w2;
		}
	if (lphs->MaxVal != lphs->MinVal)
	lphs->CurPix = lphs->MaxPix * (lphs->CurVal - lphs->MinVal) / 
    		(lphs->MaxVal - lphs->MinVal);
	if(lphs->CurPix <0)lphs->CurPix=0;
	if (lphs->CurPix > lphs->MaxPix)  lphs->CurPix = lphs->MaxPix;

	hMemDC = CreateCompatibleDC(hDC);
	if (lphs->Direction == WM_VSCROLL) {
		GetObject(hUpArrow, sizeof(BITMAP), (LPSTR)&bm);
		if (lphs->ButtonDown == 1)
			hOldBmp = SelectObject(hMemDC, hUpArrowD);
		else
			hOldBmp = SelectObject(hMemDC, hUpArrow);
		StretchBlt(hDC, rect.left, rect.top, w, h2, hMemDC, 
			0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);
		GetObject(hDnArrow, sizeof(BITMAP), (LPSTR)&bm);
		if (lphs->ButtonDown == 2)
			SelectObject(hMemDC, hDnArrowD);
		else
			SelectObject(hMemDC, hDnArrow);
		StretchBlt(hDC, rect.left, rect.bottom - h2, w, h2, hMemDC, 
			0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);
		rect.top += h2;
		rect.bottom -= h2;
		}
	else {
		GetObject(hLfArrow, sizeof(BITMAP), (LPSTR)&bm);
		if (lphs->ButtonDown == 3)
			hOldBmp = SelectObject(hMemDC, hLfArrowD);
		else
			hOldBmp = SelectObject(hMemDC, hLfArrow);
		StretchBlt(hDC, rect.left, rect.top, w2, h, hMemDC, 
			0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);
		GetObject(hRgArrow, sizeof(BITMAP), (LPSTR)&bm);
		if (lphs->ButtonDown == 4)
			SelectObject(hMemDC, hRgArrowD);
		else
			SelectObject(hMemDC, hRgArrow);
		StretchBlt(hDC, rect.right - w2, rect.top, w2, h, hMemDC, 
			0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);
		rect.left += w2;
		rect.right -= w2;
		}
        SelectObject( hMemDC, hOldBmp );
	DeleteDC(hMemDC);
	FillRect(hDC, &rect, hBrush);
	if (lphs->MaxPix != 0) {
		if (lphs->Direction == WM_VSCROLL)
			SetRect(&rect, rect.left, rect.top + lphs->CurPix, 
				rect.left + w, rect.top + lphs->CurPix + h2);
		else
			SetRect(&rect, rect.left + lphs->CurPix, rect.top, 
				rect.left + lphs->CurPix + w2, rect.top + h);
		FrameRect(hDC, &rect, GetStockObject(BLACK_BRUSH));
		InflateRect(&rect, -1, -1);
		FillRect(hDC, &rect, GetStockObject(LTGRAY_BRUSH));
		GRAPH_DrawReliefRect(hDC, &rect, 2, 0);
		InflateRect(&rect, -3, -3);
		GRAPH_DrawReliefRect(hDC, &rect, 1, 1);
		}
}


int CreateScrollBarStruct(HWND hWnd)
{
    int		width, height;
    WND  *wndPtr;
    LPHEADSCROLL lphs;
    wndPtr = WIN_FindWndPtr(hWnd);
    width = wndPtr->rectClient.right - wndPtr->rectClient.left;
    height = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
    if (width <= height)
	lphs = AllocScrollBar(WS_VSCROLL, width, height);
    else
	lphs = AllocScrollBar(WS_HSCROLL, width, height);
    dprintf_scroll(stddeb,"CreateScrollBarStruct %p !\n", lphs);
    *((LPHEADSCROLL *)&wndPtr->wExtra[1]) = lphs;
    lphs->hWndOwner = hWnd;
    CopyRect(&lphs->rect, &wndPtr->rectClient);
    return TRUE;
}


LPHEADSCROLL AllocScrollBar(DWORD dwStyle, int width, int height)
{
	LPHEADSCROLL lphs;
	if (hUpArrow == (HBITMAP)NULL) 
		hUpArrow = LoadBitmap((HINSTANCE)NULL, MAKEINTRESOURCE(OBM_UPARROWI));
	if (hDnArrow == (HBITMAP)NULL) 
		hDnArrow = LoadBitmap((HINSTANCE)NULL, MAKEINTRESOURCE(OBM_DNARROWI));
	if (hLfArrow == (HBITMAP)NULL) 
		hLfArrow = LoadBitmap((HINSTANCE)NULL, MAKEINTRESOURCE(OBM_LFARROWI));
	if (hRgArrow == (HBITMAP)NULL) 
		hRgArrow = LoadBitmap((HINSTANCE)NULL, MAKEINTRESOURCE(OBM_RGARROWI));
	if (hUpArrowD == (HBITMAP)NULL) 
		hUpArrowD = LoadBitmap((HINSTANCE)NULL, MAKEINTRESOURCE(OBM_UPARROWD));
	if (hDnArrowD == (HBITMAP)NULL) 
		hDnArrowD = LoadBitmap((HINSTANCE)NULL, MAKEINTRESOURCE(OBM_DNARROWD));
	if (hLfArrowD == (HBITMAP)NULL) 
		hLfArrowD = LoadBitmap((HINSTANCE)NULL, MAKEINTRESOURCE(OBM_LFARROWD));
	if (hRgArrowD == (HBITMAP)NULL) 
		hRgArrowD = LoadBitmap((HINSTANCE)NULL, MAKEINTRESOURCE(OBM_RGARROWD));
	lphs = (LPHEADSCROLL)malloc(sizeof(HEADSCROLL));
	if (lphs == 0) {
		fprintf(stderr,"Bad Memory Alloc on ScrollBar !\n");
		return NULL;
		}
	lphs->bRedrawFlag = TRUE;
	lphs->ThumbActive = FALSE;
	lphs->TimerPending = FALSE;
	lphs->ButtonDown = 0;
	lphs->MinVal = 0;
	lphs->MaxVal = 100;
	lphs->CurVal = 0;
	lphs->CurPix = 0;
	SetRect(&lphs->rect, 0, 0, width, height);
	if (dwStyle & WS_VSCROLL) {
		if (height > 3 * width)
			lphs->MaxPix = height - 3 * width;
		else
			lphs->MaxPix = 0;
		lphs->Direction = WM_VSCROLL;
		}
	else {
		if (width > 3 * height)
			lphs->MaxPix = width - 3 * height;
		else
			lphs->MaxPix = 0;
		lphs->Direction = WM_HSCROLL;
		}
	if (lphs->MaxPix < 1)  lphs->MaxPix = 1;
	return lphs;
}


void NC_CreateScrollBars(HWND hWnd)
{
	RECT	rect;
	int		width, height;
	WND  	*wndPtr;
	LPHEADSCROLL lphs;
	wndPtr = WIN_FindWndPtr(hWnd);
	GetWindowRect(hWnd, &rect);
	width = rect.right - rect.left;
	height = rect.bottom - rect.top;
	if (wndPtr->dwStyle & WS_VSCROLL) {
		if (wndPtr->dwStyle & WS_HSCROLL) height -= SYSMETRICS_CYHSCROLL;
		lphs = AllocScrollBar(WS_VSCROLL, SYSMETRICS_CXVSCROLL, height);
		dprintf_scroll(stddeb,"NC_CreateScrollBars Vertical %p !\n", 
			       lphs);
		lphs->rect.left = width - SYSMETRICS_CYVSCROLL;
		lphs->rect.right = width;
		lphs->hWndOwner = hWnd;
		wndPtr->VScroll = lphs;
	    wndPtr->scroll_flags |= 0x0001;
		if (wndPtr->dwStyle & WS_HSCROLL) height += SYSMETRICS_CYHSCROLL;
		}
	if (wndPtr->dwStyle & WS_HSCROLL) {
		if (wndPtr->dwStyle & WS_VSCROLL) width -= SYSMETRICS_CYVSCROLL;
		lphs = AllocScrollBar(WS_HSCROLL, width, SYSMETRICS_CYHSCROLL);
		dprintf_scroll(stddeb,"NC_CreateScrollBars Horizontal %p !\n", lphs);
		lphs->rect.top = height - SYSMETRICS_CYHSCROLL;
		lphs->rect.bottom = height;
		lphs->hWndOwner = hWnd;
		wndPtr->HScroll = lphs;
	    wndPtr->scroll_flags |= 0x0002;
		}
}


/*************************************************************************
 *			GetScrollObjectStruct [internal]
 */
LPHEADSCROLL GetScrollObjectStruct(HWND hWnd, int nBar)
{
    WND *wndPtr;
    if (nBar != SB_CTL) {
	wndPtr = WIN_FindWndPtr(hWnd);
    	if (nBar == SB_VERT) return (LPHEADSCROLL)wndPtr->VScroll;
    	if (nBar == SB_HORZ) return (LPHEADSCROLL)wndPtr->HScroll;
    	return NULL;
	}
    return ScrollBarGetStorageHeader(hWnd);
}


/*************************************************************************
 *			SetScrollPos [USER.62]
 */
int SetScrollPos(HWND hWnd, int nBar, int nPos, BOOL bRedraw)
{
	LPHEADSCROLL lphs;
	HDC		hDC;
	int 	nRet;
	lphs = GetScrollObjectStruct(hWnd, nBar);
	if (lphs == NULL) return 0;
	nRet = lphs->CurVal;
	lphs->CurVal = (short)nPos;
	if (lphs->MaxVal != lphs->MinVal)
	lphs->CurPix = lphs->MaxPix * (lphs->CurVal - lphs->MinVal) / 
    		(lphs->MaxVal - lphs->MinVal);
	if(lphs->CurPix <0)lphs->CurPix=0;

    if (lphs->CurPix > lphs->MaxPix)  lphs->CurPix = lphs->MaxPix;
    dprintf_scroll(stddeb,"SetScrollPos val=%d pixval=%d pixmax%d\n",
	    (short)nPos, lphs->CurPix, lphs->MaxPix);
    dprintf_scroll(stddeb,"SetScrollPos min=%d max=%d\n", 
	    lphs->MinVal, lphs->MaxVal);
    if ((bRedraw) && (IsWindowVisible(lphs->hWndOwner))) {
		if (nBar == SB_CTL) {
	        InvalidateRect(lphs->hWndOwner, &lphs->rect, TRUE);
	        UpdateWindow(lphs->hWndOwner);
			}
		else {
			if (lphs->rect.right != 0 && lphs->rect.bottom != 0) {
				hDC = GetWindowDC(lphs->hWndOwner);
				StdDrawScrollBar(lphs->hWndOwner, hDC, nBar, &lphs->rect, lphs);
				ReleaseDC(lphs->hWndOwner, hDC);
				}
			}
        }
    return nRet;
}


/*************************************************************************
 *			GetScrollPos [USER.63]
 */
int GetScrollPos(HWND hWnd, int nBar)
{
    LPHEADSCROLL lphs;
    lphs = GetScrollObjectStruct(hWnd, nBar);
    if (lphs == NULL) return 0;
    return lphs->CurVal;
}


/*************************************************************************
 *			SetScrollRange [USER.64]
 */
void SetScrollRange(HWND hWnd, int nBar, int MinPos, int MaxPos, BOOL bRedraw)
{
    LPHEADSCROLL lphs;
	HDC		hDC;
    lphs = GetScrollObjectStruct(hWnd, nBar);
    if (lphs == NULL) return;

/*    should a bad range be rejected here? 
 */
    lphs->MinVal = (short)MinPos;
    lphs->MaxVal = (short)MaxPos;
    if (lphs->MaxVal != lphs->MinVal)
      lphs->CurPix = lphs->MaxPix * (lphs->CurVal - lphs->MinVal) / 
	  (lphs->MaxVal - lphs->MinVal);
    if(lphs->CurPix <0)lphs->CurPix=0;
    if (lphs->CurPix > lphs->MaxPix)  lphs->CurPix = lphs->MaxPix;
    dprintf_scroll(stddeb,"SetScrollRange min=%d max=%d\n", 
		   lphs->MinVal, lphs->MaxVal);
    if ((bRedraw) && (IsWindowVisible(lphs->hWndOwner))) {
		if (nBar == SB_CTL) {
	        InvalidateRect(lphs->hWndOwner, &lphs->rect, TRUE);
	        UpdateWindow(lphs->hWndOwner);
			}
		else {
			if (lphs->rect.right != 0 && lphs->rect.bottom != 0) {
				hDC = GetWindowDC(lphs->hWndOwner);
				StdDrawScrollBar(lphs->hWndOwner, hDC, nBar, &lphs->rect, lphs);
				ReleaseDC(lphs->hWndOwner, hDC);
				}
			}
        }
}


/*************************************************************************
 *			GetScrollRange [USER.65]
 */
void GetScrollRange(HWND hWnd, int nBar, LPINT lpMin, LPINT lpMax)
{
    LPHEADSCROLL lphs;
    lphs = GetScrollObjectStruct(hWnd, nBar);
    if (lphs == NULL) return;
    *lpMin = lphs->MinVal;
    *lpMax = lphs->MaxVal;
}


/*************************************************************************
 *			ShowScrollBar [USER.267]
 */
void ShowScrollBar(HWND hWnd, WORD wBar, BOOL bFlag)
{
	WND  *wndPtr;
	dprintf_scroll(stddeb,"ShowScrollBar hWnd=%04X wBar=%d bFlag=%d\n", 
		       hWnd, wBar, bFlag);
	if (wBar == SB_CTL) {
		if (bFlag)
			ShowWindow(hWnd, SW_SHOW);
		else
			ShowWindow(hWnd, SW_HIDE);
		return;
		}
	wndPtr = WIN_FindWndPtr(hWnd);
	if ((wBar == SB_VERT) || (wBar == SB_BOTH)) {
		if (bFlag)
			wndPtr->scroll_flags |= 1;
		else
			wndPtr->scroll_flags &= ~1;
		}
	if ((wBar == SB_HORZ) || (wBar == SB_BOTH)) {
		if (bFlag)
			wndPtr->scroll_flags |= 2;
		else
			wndPtr->scroll_flags &= ~2;
		}
	SetWindowPos(hWnd, 0, 0, 0, 0, 0, 
		SWP_NOZORDER | SWP_NOMOVE | 
		SWP_NOSIZE | SWP_FRAMECHANGED);
}