Initial community commit

1 files changed, 2391 insertions, 0 deletions

diff --git a/Src/Plugins/General/gen_ml/scrollwnd.cpp b/Src/Plugins/General/gen_ml/scrollwnd.cpp
new file mode 100644
index 00000000..61a78761
--- /dev/null
+++ b/Src/Plugins/General/gen_ml/scrollwnd.cpp
@@ -0,0 +1,2391 @@
+// some code taken from (freeware) Cool ScrollBar library by J Brown
+#include "main.h"
+#include <windowsx.h>
+#include <tchar.h>
+#include "scrollwnd.h"
+#include "../winamp/wa_dlg.h"
+
+#ifndef WM_MOUSEWHEEL
+#define WM_MOUSEWHEEL                   0x020A
+#endif
+
+
+extern HRESULT(WINAPI *SetWindowTheme)(HWND hwnd, LPCWSTR pszSubAppName, LPCWSTR pszSubIdList);  //xp theme shit
+extern HRESULT(WINAPI *IsAppThemed)(void);
+
+static TCHAR szPropStr[] = _T("CoolSBSubclassPtr");
+
+//
+//	Special thumb-tracking variables
+//
+//
+static UINT uCurrentScrollbar = COOLSB_NONE;	//SB_HORZ / SB_VERT
+static UINT uCurrentScrollPortion = HTSCROLL_NONE;
+static UINT uCurrentButton = 0;
+
+static RECT rcThumbBounds;		//area that the scroll thumb can travel in
+static int  nThumbSize;			//(pixels)
+static int  nThumbPos;			//(pixels)
+static int  nThumbMouseOffset;	//(pixels)
+static int  nLastPos = -1;		//(scrollbar units)
+static int  nThumbPos0;			//(pixels) initial thumb position
+
+//
+//	Temporary state used to auto-generate timer messages
+//
+static UINT uMouseOverId = 0;
+static UINT uMouseOverScrollbar = COOLSB_NONE;
+static UINT uHitTestPortion = HTSCROLL_NONE;
+static UINT uLastHitTestPortion = HTSCROLL_NONE;
+static RECT MouseOverRect;
+
+static UINT uScrollTimerMsg = 0;
+static UINT uScrollTimerPortion = HTSCROLL_NONE;
+static UINT_PTR uScrollTimerId = 0;
+static HWND hwndCurCoolSB = 0;
+
+ScrollWnd *GetScrollWndFromHwnd(HWND hwnd)
+{
+	return (ScrollWnd *)GetProp(hwnd, szPropStr);
+}
+
+//
+//	swap the rectangle's x coords with its y coords
+//
+static void __stdcall RotateRect(RECT *rect)
+{
+	int temp;
+	temp = rect->left;
+	rect->left = rect->top;
+	rect->top = temp;
+
+	temp = rect->right;
+	rect->right = rect->bottom;
+	rect->bottom = temp;
+}
+
+//
+//	swap the coords if the scrollbar is a SB_VERT
+//
+static void __stdcall RotateRect0(SCROLLBAR *sb, RECT *rect)
+{
+	if (sb->nBarType == SB_VERT)
+		RotateRect(rect);
+}
+
+//
+//	Calculate if the SCROLLINFO members produce
+//  an enabled or disabled scrollbar
+//
+static BOOL IsScrollInfoActive(SCROLLINFO *si)
+{
+	if ((si->nPage > (UINT)si->nMax
+	     || si->nMax <= si->nMin || si->nMax == 0))
+		return FALSE;
+	else
+		return TRUE;
+}
+
+//
+//	Return if the specified scrollbar is enabled or not
+//
+static BOOL IsScrollbarActive(SCROLLBAR *sb)
+{
+	SCROLLINFO *si = &sb->scrollInfo;
+	if (((sb->fScrollFlags & ESB_DISABLE_BOTH) == ESB_DISABLE_BOTH) ||
+	    !(sb->fScrollFlags & CSBS_THUMBALWAYS) && !IsScrollInfoActive(si))
+		return FALSE;
+	else
+		return TRUE;
+}
+
+BOOL drawFrameControl(HDC hdc, LPRECT lprc, UINT uType, UINT state)
+{
+	HDC hdcbmp;
+	HBITMAP hbmpOld, hbmp;
+	int startx, starty;
+
+	hbmp = WADlg_getBitmap();
+	if (!hbmp) return FALSE;
+
+	hdcbmp = CreateCompatibleDC(hdc);
+	if (!hdcbmp) return FALSE;
+
+	hbmpOld = (HBITMAP)SelectObject(hdcbmp, hbmp);
+	
+	startx = 0;
+	starty = 31;
+	switch (state&3)
+	{
+		case DFCS_SCROLLRIGHT: startx = 14; starty = 45; break;
+		case DFCS_SCROLLLEFT: startx = 0; starty = 45; break;
+		case DFCS_SCROLLDOWN: startx = 14; starty = 31; break;
+	}
+	if (state&DFCS_PUSHED) startx += 28;
+	StretchBlt(hdc, lprc->left, lprc->top, lprc->right - lprc->left, lprc->bottom - lprc->top, hdcbmp, startx, starty, 14, 14, SRCCOPY);
+	
+	SelectObject(hdcbmp, hbmpOld);
+	DeleteDC(hdcbmp);
+	return 1;
+}
+
+//
+//	Draw a standard scrollbar arrow
+//
+static int DrawScrollArrow(SCROLLBAR *sbar, HDC hdc, RECT *rect, UINT arrow, BOOL fMouseDown, BOOL fMouseOver)
+{
+	UINT ret;
+	UINT flags = arrow;
+
+	//HACKY bit so this routine can be called by vertical and horizontal code
+	if (sbar->nBarType == SB_VERT)
+	{
+		if (flags & DFCS_SCROLLLEFT)		flags = flags & ~DFCS_SCROLLLEFT  | DFCS_SCROLLUP;
+		if (flags & DFCS_SCROLLRIGHT)	flags = flags & ~DFCS_SCROLLRIGHT | DFCS_SCROLLDOWN;
+	}
+
+	if (fMouseDown) flags |= (DFCS_FLAT | DFCS_PUSHED);
+
+	ret = drawFrameControl(hdc, rect, DFC_SCROLL, flags);
+
+	return ret;
+}
+
+//
+//	Return the size in pixels for the specified scrollbar metric,
+//  for the specified scrollbar
+//
+static int GetScrollMetric(SCROLLBAR *sbar, int metric)
+{
+	if (sbar->nBarType == SB_HORZ)
+	{
+		if (metric == SM_CXHORZSB)
+		{
+			if (sbar->nArrowLength < 0)
+				return -sbar->nArrowLength * 14; //GetSystemMetrics(SM_CXHSCROLL);
+			else
+				return sbar->nArrowLength;
+		}
+		else
+		{
+			if (sbar->nArrowWidth < 0)
+				return -sbar->nArrowWidth * 14; //GetSystemMetrics(SM_CYHSCROLL);
+			else
+				return sbar->nArrowWidth;
+		}
+	}
+	else if (sbar->nBarType == SB_VERT)
+	{
+		if (metric == SM_CYVERTSB)
+		{
+			if (sbar->nArrowLength < 0)
+				return -sbar->nArrowLength * 14;//GetSystemMetrics(SM_CYVSCROLL);
+			else
+				return sbar->nArrowLength;
+		}
+		else
+		{
+			if (sbar->nArrowWidth < 0)
+				return -sbar->nArrowWidth * 14;//GetSystemMetrics(SM_CXVSCROLL);
+			else
+				return sbar->nArrowWidth;
+		}
+	}
+
+	return 0;
+}
+
+//
+//
+//
+static COLORREF GetSBForeColor(void)
+{
+	return WADlg_getColor(WADLG_SCROLLBAR_FGCOLOR);
+}
+
+static COLORREF GetSBBackColor(void)
+{
+	return WADlg_getColor(WADLG_SCROLLBAR_BGCOLOR);
+}
+
+//
+//	Paint a checkered rectangle, with each alternate
+//	pixel being assigned a different colour
+//
+static void DrawCheckedRect(HDC hdc, RECT *rect, COLORREF fg, COLORREF bg)
+{
+	static WORD wCheckPat[8] =
+	  {
+	    0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555
+	  };
+
+	HBITMAP hbmp;
+	HBRUSH  hbr, hbrold;
+	COLORREF fgold, bgold;
+
+	hbmp = CreateBitmap(8, 8, 1, 1, wCheckPat);
+	hbr  = CreatePatternBrush(hbmp);
+
+	UnrealizeObject(hbr);
+	SetBrushOrgEx(hdc, rect->left, rect->top, 0);
+
+	hbrold = (HBRUSH)SelectObject(hdc, hbr);
+
+	fgold = SetTextColor(hdc, fg);
+	bgold = SetBkColor(hdc, bg);
+
+	PatBlt(hdc, rect->left, rect->top,
+	       rect->right - rect->left,
+	       rect->bottom - rect->top,
+	       PATCOPY);
+
+	SetBkColor(hdc, bgold);
+	SetTextColor(hdc, fgold);
+
+	SelectObject(hdc, hbrold);
+	DeleteObject(hbr);
+	DeleteObject(hbmp);
+}
+
+//
+//	Fill the specifed rectangle using a solid colour
+//
+static void PaintRect(HDC hdc, RECT *rect, COLORREF color)
+{
+	COLORREF oldcol = SetBkColor(hdc, color);
+	ExtTextOut(hdc, 0, 0, ETO_OPAQUE, rect, _T(""), 0, 0);
+	SetBkColor(hdc, oldcol);
+}
+
+//
+//	Draw a simple blank scrollbar push-button. Can be used
+//	to draw a push button, or the scrollbar thumb
+//	drawflag - could set to BF_FLAT to make flat scrollbars
+//
+void DrawBlankButton(HDC hdc, const RECT *rect, UINT drawflag, int pushed, int vertical)
+{
+	HBITMAP hbmp, hbmpOld;
+	hbmp = WADlg_getBitmap();
+	if (!hbmp) return;
+
+	HDC hdcbmp = CreateCompatibleDC(hdc);
+	if (!hdcbmp) return;
+
+	hbmpOld = (HBITMAP)SelectObject(hdcbmp, hbmp);
+
+#define PART1SIZE 4  //copied top
+#define PART2SIZE 5  //stretched top
+#define PART3SIZE 10  //copied middle
+#define PART4SIZE 5  //stretched bottom
+#define PART5SIZE 4  //copied bottom
+
+	if (vertical)
+	{
+		int middle = (rect->bottom - rect->top) / 2;
+		int startx = pushed ? 70 : 56;
+		//top
+		StretchBlt(hdc, rect->left, rect->top, rect->right - rect->left, PART1SIZE, hdcbmp, startx, 31, 14, PART1SIZE, SRCCOPY);
+		int p = PART1SIZE;
+		//stretched top
+		int l = middle - PART1SIZE - (PART3SIZE / 2);
+		if (l > 0)
+		{
+			StretchBlt(hdc, rect->left, rect->top + p, rect->right - rect->left, l, hdcbmp, startx, 31 + PART1SIZE, 14, PART2SIZE, SRCCOPY);
+			p += middle - PART1SIZE - (PART3SIZE / 2);
+		}
+		//copied middle
+		int m = (rect->bottom - rect->top) - PART1SIZE - PART5SIZE; //space that's available for middle
+		m = min(m, PART3SIZE);
+		if (m > 0)
+		{
+			StretchBlt(hdc, rect->left, rect->top + p, rect->right - rect->left, m, hdcbmp, startx, 31 + PART1SIZE + PART2SIZE, 14, m, SRCCOPY);
+			p += m;
+		}
+		//stretched bottom
+		l = rect->bottom - rect->top - p - PART5SIZE;
+		if (l > 0) StretchBlt(hdc, rect->left, rect->top + p, rect->right - rect->left, l, hdcbmp, startx, 31 + PART1SIZE + PART2SIZE + PART3SIZE, 14, PART4SIZE, SRCCOPY);
+		//bottom
+		StretchBlt(hdc, rect->left, rect->bottom - PART5SIZE, rect->right - rect->left, PART5SIZE, hdcbmp, startx, 31 + PART1SIZE + PART2SIZE + PART3SIZE + PART4SIZE, 14, PART5SIZE, SRCCOPY);
+	}
+	else
+	{
+		int middle = (rect->right - rect->left) / 2;
+		int starty = pushed ? 45 : 31;
+		//top
+		StretchBlt(hdc, rect->left, rect->top, PART1SIZE, rect->bottom - rect->top, hdcbmp, 84, starty, PART1SIZE, 14, SRCCOPY);
+		int p = PART1SIZE;
+		//stretched top
+		int l = middle - PART1SIZE - (PART3SIZE / 2);
+		if (l > 0)
+		{
+			StretchBlt(hdc, rect->left + p, rect->top, l, rect->bottom - rect->top, hdcbmp, 84 + PART1SIZE, starty, PART2SIZE, 14, SRCCOPY);
+			p += middle - PART1SIZE - (PART3SIZE / 2);
+		}
+		//copied middle
+		int m = (rect->right - rect->left) - PART1SIZE - PART5SIZE; //space that's available for middle
+		m = min(m, PART3SIZE);
+		if (m > 0)
+		{
+			StretchBlt(hdc, rect->left + p, rect->top, m, rect->bottom - rect->top, hdcbmp, 84 + PART1SIZE + PART2SIZE, starty, m, 14, SRCCOPY);
+			p += m;
+		}
+		//stretched bottom
+		l = rect->right - rect->left - p - PART5SIZE;
+		if (l > 0) StretchBlt(hdc, rect->left + p, rect->top, l, rect->bottom - rect->top, hdcbmp, 84 + PART1SIZE + PART2SIZE + PART3SIZE, starty, PART4SIZE, 14, SRCCOPY);
+		//bottom
+		StretchBlt(hdc, rect->right - PART5SIZE, rect->top, PART5SIZE, rect->bottom - rect->top, hdcbmp, 84 + PART1SIZE + PART2SIZE + PART3SIZE + PART4SIZE, starty, PART5SIZE, 14, SRCCOPY);
+	}
+
+	SelectObject(hdcbmp, hbmpOld);
+	DeleteDC(hdcbmp);
+}
+
+//
+//	Send a WM_VSCROLL or WM_HSCROLL message
+//
+static void SendScrollMessage(HWND hwnd, UINT scrMsg, UINT scrId, UINT pos)
+{
+	SendMessage(hwnd, scrMsg, MAKEWPARAM(scrId, pos), 0);
+}
+
+//
+//	Calculate the screen coordinates of the area taken by
+//  the horizontal scrollbar. Take into account the size
+//  of the window borders
+//
+static BOOL GetHScrollRect(ScrollWnd *sw, HWND hwnd, RECT *rect)
+{
+	GetWindowRect(hwnd, rect);
+
+	if (sw->fLeftScrollbar)
+	{
+		rect->left  += sw->cxLeftEdge + (sw->sbarVert.fScrollVisible ?
+		                                 GetScrollMetric(&sw->sbarVert, SM_CXVERTSB) : 0);
+		rect->right -= sw->cxRightEdge;
+	}
+	else
+	{
+		rect->left   += sw->cxLeftEdge;					//left window edge
+
+		rect->right  -= sw->cxRightEdge +				//right window edge
+		                (sw->sbarVert.fScrollVisible ?
+		                 GetScrollMetric(&sw->sbarVert, SM_CXVERTSB) : 0);
+	}
+
+	rect->bottom -= sw->cyBottomEdge;				//bottom window edge
+
+	rect->top	  = rect->bottom -
+	              (sw->sbarHorz.fScrollVisible ?
+	               GetScrollMetric(&sw->sbarHorz, SM_CYHORZSB) : 0);
+
+	return TRUE;
+}
+
+//
+//	Calculate the screen coordinates of the area taken by the
+//  vertical scrollbar
+//
+static BOOL GetVScrollRect(ScrollWnd *sw, HWND hwnd, RECT *rect)
+{
+	GetWindowRect(hwnd, rect);
+	rect->top	 += sw->cyTopEdge;						//top window edge
+
+	rect->bottom -= sw->cyBottomEdge +
+	                (sw->sbarHorz.fScrollVisible ?		//bottom window edge
+	                 GetScrollMetric(&sw->sbarHorz, SM_CYHORZSB) : 0);
+
+	if (sw->fLeftScrollbar)
+	{
+		rect->left	+= sw->cxLeftEdge;
+		rect->right = rect->left + (sw->sbarVert.fScrollVisible ?
+		                            GetScrollMetric(&sw->sbarVert, SM_CXVERTSB) : 0);
+	}
+	else
+	{
+		rect->right  -= sw->cxRightEdge;
+		rect->left    = rect->right - (sw->sbarVert.fScrollVisible ?
+		                               GetScrollMetric(&sw->sbarVert, SM_CXVERTSB) : 0);
+	}
+
+	return TRUE;
+}
+
+//	Depending on what type of scrollbar nBar refers to, call the
+//  appropriate Get?ScrollRect function
+//
+BOOL GetScrollRect(ScrollWnd *sw, UINT nBar, HWND hwnd, RECT *rect)
+{
+	if (nBar == SB_HORZ)
+		return GetHScrollRect(sw, hwnd, rect);
+	else if (nBar == SB_VERT)
+		return GetVScrollRect(sw, hwnd, rect);
+	else
+		return FALSE;
+}
+
+//
+//	Work out the scrollbar width/height for either type of scrollbar (SB_HORZ/SB_VERT)
+//	rect - coords of the scrollbar.
+//	store results into *thumbsize and *thumbpos
+//
+static int CalcThumbSize(SCROLLBAR *sbar, const RECT *rect, int *pthumbsize, int *pthumbpos)
+{
+	SCROLLINFO *si;
+	int scrollsize;			//total size of the scrollbar including arrow buttons
+	int workingsize;		//working area (where the thumb can slide)
+	int siMaxMin;
+	int butsize;
+	int startcoord;
+	int thumbpos = 0, thumbsize = 0;
+
+	//work out the width (for a horizontal) or the height (for a vertical)
+	//of a standard scrollbar button
+	butsize = GetScrollMetric(sbar, SM_SCROLL_LENGTH);
+
+	if (1) //sbar->nBarType == SB_HORZ)
+	{
+		scrollsize = rect->right - rect->left;
+		startcoord = rect->left;
+	}
+	/*else if(sbar->nBarType == SB_VERT)
+	{
+		scrollsize = rect->bottom - rect->top;
+		startcoord = rect->top;
+	}
+	else
+	{
+		return 0;
+	}*/
+
+	si = &sbar->scrollInfo;
+	siMaxMin = si->nMax - si->nMin + 1;
+	workingsize = scrollsize - butsize * 2;
+
+	//
+	// Work out the scrollbar thumb SIZE
+	//
+	if (si->nPage == 0)
+	{
+		thumbsize = butsize;
+	}
+	else if (siMaxMin > 0)
+	{
+		thumbsize = MulDiv(si->nPage, workingsize, siMaxMin);
+
+		if (thumbsize < sbar->nMinThumbSize)
+			thumbsize = sbar->nMinThumbSize;
+	}
+
+	//
+	// Work out the scrollbar thumb position
+	//
+	if (siMaxMin > 0)
+	{
+		int pagesize = max(1, si->nPage);
+		thumbpos = MulDiv(si->nPos - si->nMin, workingsize - thumbsize, siMaxMin - pagesize);
+
+		if (thumbpos < 0)
+			thumbpos = 0;
+
+		if (thumbpos >= workingsize - thumbsize)
+			thumbpos = workingsize - thumbsize;
+	}
+
+	thumbpos += startcoord + butsize;
+
+	*pthumbpos  = thumbpos;
+	*pthumbsize = thumbsize;
+
+	return 1;
+}
+
+//
+//	return a hit-test value for whatever part of the scrollbar x,y is located in
+//	rect, x, y: SCREEN coordinates
+//	the rectangle must not include space for any inserted buttons
+//	(i.e, JUST the scrollbar area)
+//
+static UINT GetHorzScrollPortion(SCROLLBAR *sbar, HWND hwnd, const RECT *rect, int x, int y)
+{
+	int thumbwidth, thumbpos;
+	int butwidth = GetScrollMetric(sbar, SM_SCROLL_LENGTH);
+	int scrollwidth  = rect->right - rect->left;
+	int workingwidth = scrollwidth - butwidth * 2;
+
+	if (y < rect->top || y >= rect->bottom)
+		return HTSCROLL_NONE;
+
+	CalcThumbSize(sbar, rect, &thumbwidth, &thumbpos);
+
+	//if we have had to scale the buttons to fit in the rect,
+	//then adjust the button width accordingly
+	if (scrollwidth <= butwidth * 2)
+	{
+		butwidth = scrollwidth / 2;
+	}
+
+	//check for left button click
+	if (x >= rect->left && x < rect->left + butwidth)
+	{
+		return HTSCROLL_LEFT;
+	}
+	//check for right button click
+	else if (x >= rect->right - butwidth && x < rect->right)
+	{
+		return HTSCROLL_RIGHT;
+	}
+
+	//if the thumb is too big to fit (i.e. it isn't visible)
+	//then return a NULL scrollbar area
+	if (thumbwidth >= workingwidth)
+		return HTSCROLL_NONE;
+
+	//check for point in the thumbbar
+	if (x >= thumbpos && x < thumbpos + thumbwidth)
+	{
+		return HTSCROLL_THUMB;
+	}
+	//check for left margin
+	else if (x >= rect->left + butwidth && x < thumbpos)
+	{
+		return HTSCROLL_PAGELEFT;
+	}
+	else if (x >= thumbpos + thumbwidth && x < rect->right - butwidth)
+	{
+		return HTSCROLL_PAGERIGHT;
+	}
+
+	return HTSCROLL_NONE;
+}
+
+//
+//	For vertical scrollbars, rotate all coordinates by -90 degrees
+//	so that we can use the horizontal version of this function
+//
+static UINT GetVertScrollPortion(SCROLLBAR *sb, HWND hwnd, RECT *rect, int x, int y)
+{
+	UINT r;
+
+	RotateRect(rect);
+	r = GetHorzScrollPortion(sb, hwnd, rect, y, x);
+	RotateRect(rect);
+	return r;
+}
+
+//
+//	CUSTOM DRAW support
+//
+static LRESULT PostCustomPrePostPaint0(HWND hwnd, HDC hdc, SCROLLBAR *sb, UINT dwStage)
+{
+	return 0;
+}
+
+static LRESULT PostCustomDrawNotify0(HWND hwnd, HDC hdc, UINT nBar, RECT *prect, UINT nItem, BOOL fMouseDown, BOOL fMouseOver, BOOL fInactive)
+{
+	return 0;
+}
+
+// Depending on if we are supporting custom draw, either define
+// a macro to the function name, or to nothing at all. If custom draw
+// is turned off, then we can save ALOT of code space by binning all
+// calls to the custom draw support.
+//
+#define PostCustomDrawNotify	1 ? (void)0 : PostCustomDrawNotify0
+#define PostCustomPrePostPaint	1 ? (void)0 : PostCustomPrePostPaint0
+
+static LRESULT PostMouseNotify0(HWND hwnd, UINT msg, UINT nBar, RECT *prect, UINT nCmdId, POINT pt)
+{
+	return 0;
+}
+
+#ifdef NOTIFY_MOUSE
+#define PostMouseNotify			PostMouseNotify0
+#else
+#define PostMouseNotify			1 ? (void)0 : PostMouseNotify0
+#endif
+
+
+
+//
+//	Draw a complete HORIZONTAL scrollbar in the given rectangle
+//	Don't draw any inserted buttons in this procedure
+//
+//	uDrawFlags - hittest code, to say if to draw the
+//  specified portion in an active state or not.
+//
+//
+static LRESULT NCDrawHScrollbar(SCROLLBAR *sb, HWND hwnd, HDC hdc, const RECT *rect, UINT uDrawFlags)
+{
+	SCROLLINFO *si;
+	RECT ctrl, thumb;
+	RECT sbm;
+	int butwidth	 = GetScrollMetric(sb, SM_SCROLL_LENGTH);
+	int scrollwidth  = rect->right - rect->left;
+	int workingwidth = scrollwidth - butwidth * 2;
+	int thumbwidth   = 0, thumbpos = 0;
+	BOOL fCustomDraw = 0;
+
+	BOOL fMouseDownL = 0, fMouseOverL = 0;
+	BOOL fMouseDownR = 0, fMouseOverR = 0;
+
+	COLORREF crCheck1   = GetSBForeColor();
+	COLORREF crCheck2   = GetSBBackColor();
+	COLORREF crInverse1 = WADlg_getColor(WADLG_SCROLLBAR_INV_FGCOLOR);
+	COLORREF crInverse2 = WADlg_getColor(WADLG_SCROLLBAR_INV_BGCOLOR);
+
+	UINT uDEFlat  = sb->fFlatScrollbar ? BF_FLAT   : 0;
+
+	//drawing flags to modify the appearance of the scrollbar buttons
+	UINT uLeftButFlags  = DFCS_SCROLLLEFT;
+	UINT uRightButFlags = DFCS_SCROLLRIGHT;
+
+	if (scrollwidth <= 0)
+		return 0;
+
+	si = &sb->scrollInfo;
+
+	if (hwnd != hwndCurCoolSB)
+		uDrawFlags = HTSCROLL_NONE;
+	//
+	// work out the thumb size and position
+	//
+	CalcThumbSize(sb, rect, &thumbwidth, &thumbpos);
+
+	if (sb->fScrollFlags & ESB_DISABLE_LEFT)		uLeftButFlags  |= DFCS_INACTIVE;
+	if (sb->fScrollFlags & ESB_DISABLE_RIGHT)	uRightButFlags |= DFCS_INACTIVE;
+
+	//if we need to grey the arrows because there is no data to scroll
+	if (!IsScrollInfoActive(si) && !(sb->fScrollFlags & CSBS_THUMBALWAYS))
+	{
+		uLeftButFlags  |= DFCS_INACTIVE;
+		uRightButFlags |= DFCS_INACTIVE;
+	}
+
+	if (hwnd == hwndCurCoolSB)
+	{
+		fMouseDownL = (uDrawFlags == HTSCROLL_LEFT);
+		fMouseDownR = (uDrawFlags == HTSCROLL_RIGHT);
+	}
+
+	//
+	// Draw the scrollbar now
+	//
+	if (scrollwidth > butwidth*2)
+	{
+		//LEFT ARROW
+		SetRect(&ctrl, rect->left, rect->top, rect->left + butwidth, rect->bottom);
+
+		RotateRect0(sb, &ctrl);
+
+		if (fCustomDraw)
+			PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_LINELEFT, fMouseDownL, fMouseOverL, uLeftButFlags & DFCS_INACTIVE);
+		else
+			DrawScrollArrow(sb, hdc, &ctrl, uLeftButFlags, fMouseDownL, fMouseOverL);
+
+		RotateRect0(sb, &ctrl);
+
+		//MIDDLE PORTION
+		//if we can fit the thumbbar in, then draw it
+		if (thumbwidth > 0 && thumbwidth <= workingwidth
+		    && IsScrollInfoActive(si) && ((sb->fScrollFlags & ESB_DISABLE_BOTH) != ESB_DISABLE_BOTH))
+		{
+			//Draw the scrollbar margin above the thumb
+			SetRect(&sbm, rect->left + butwidth, rect->top, thumbpos, rect->bottom);
+
+			RotateRect0(sb, &sbm);
+
+			if (fCustomDraw)
+			{
+				PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &sbm, SB_PAGELEFT, uDrawFlags == HTSCROLL_PAGELEFT, FALSE, FALSE);
+			}
+			else
+			{
+				if (uDrawFlags == HTSCROLL_PAGELEFT)
+					DrawCheckedRect(hdc, &sbm, crInverse1, crInverse2);
+				else
+					DrawCheckedRect(hdc, &sbm, crCheck1, crCheck2);
+
+			}
+
+			RotateRect0(sb, &sbm);
+
+			//Draw the margin below the thumb
+			sbm.left = thumbpos + thumbwidth;
+			sbm.right = rect->right - butwidth;
+
+			RotateRect0(sb, &sbm);
+			if (fCustomDraw)
+			{
+				PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &sbm, SB_PAGERIGHT, uDrawFlags == HTSCROLL_PAGERIGHT, 0, 0);
+			}
+			else
+			{
+				if (uDrawFlags == HTSCROLL_PAGERIGHT)
+					DrawCheckedRect(hdc, &sbm, crInverse1, crInverse2);
+				else
+					DrawCheckedRect(hdc, &sbm, crCheck1, crCheck2);
+
+			}
+			RotateRect0(sb, &sbm);
+
+			//Draw the THUMB finally
+			SetRect(&thumb, thumbpos, rect->top, thumbpos + thumbwidth, rect->bottom);
+
+			RotateRect0(sb, &thumb);
+
+			if (fCustomDraw)
+			{
+				PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &thumb, SB_THUMBTRACK, uDrawFlags == HTSCROLL_THUMB, uHitTestPortion == HTSCROLL_THUMB, FALSE);
+			}
+			else
+			{
+				int track = 0;
+				if (uCurrentScrollbar == (UINT)sb->nBarType) track = GetScrollWndFromHwnd(hwnd)->fThumbTracking;
+				DrawBlankButton(hdc, &thumb, uDEFlat, track, sb->nBarType == SB_VERT);
+			}
+			RotateRect0(sb, &thumb);
+
+		}
+		//otherwise, just leave that whole area blank
+		else
+		{
+			OffsetRect(&ctrl, butwidth, 0);
+			ctrl.right = rect->right - butwidth;
+
+			//if we always show the thumb covering the whole scrollbar,
+			//then draw it that way
+			if (!IsScrollInfoActive(si)	&& (sb->fScrollFlags & CSBS_THUMBALWAYS)
+			    && ctrl.right - ctrl.left > sb->nMinThumbSize)
+			{
+				//leave a 1-pixel gap between the thumb + right button
+				ctrl.right --;
+				RotateRect0(sb, &ctrl);
+
+				if (fCustomDraw)
+					PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_THUMBTRACK, fMouseDownL, FALSE, FALSE);
+				else
+				{
+					DrawBlankButton(hdc, &ctrl, uDEFlat, 0, sb->nBarType == SB_VERT);
+
+				}
+				RotateRect0(sb, &ctrl);
+
+				//draw the single-line gap
+				ctrl.left = ctrl.right;
+				ctrl.right += 1;
+
+				RotateRect0(sb, &ctrl);
+
+				if (fCustomDraw)
+					PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_PAGERIGHT, 0, 0, 0);
+				else
+					PaintRect(hdc, &ctrl, GetSysColor(COLOR_SCROLLBAR));
+
+				RotateRect0(sb, &ctrl);
+			}
+			//otherwise, paint a blank if the thumb doesn't fit in
+			else
+			{
+				RotateRect0(sb, &ctrl);
+
+				if (fCustomDraw)
+					PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_PAGERIGHT, 0, 0, 0);
+				else
+					DrawCheckedRect(hdc, &ctrl, crCheck1, crCheck2);
+
+				RotateRect0(sb, &ctrl);
+			}
+		}
+
+		//RIGHT ARROW
+		SetRect(&ctrl, rect->right - butwidth, rect->top, rect->right, rect->bottom);
+
+		RotateRect0(sb, &ctrl);
+
+		if (fCustomDraw)
+			PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_LINERIGHT, fMouseDownR, fMouseOverR, uRightButFlags & DFCS_INACTIVE);
+		else
+			DrawScrollArrow(sb, hdc, &ctrl, uRightButFlags, fMouseDownR, fMouseOverR);
+
+		RotateRect0(sb, &ctrl);
+	}
+	//not enough room for the scrollbar, so just draw the buttons (scaled in size to fit)
+	else
+	{
+		butwidth = scrollwidth / 2;
+
+		//LEFT ARROW
+		SetRect(&ctrl, rect->left, rect->top, rect->left + butwidth, rect->bottom);
+
+		RotateRect0(sb, &ctrl);
+		if (fCustomDraw)
+			PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_LINELEFT, fMouseDownL, fMouseOverL, uLeftButFlags & DFCS_INACTIVE);
+		else
+			DrawScrollArrow(sb, hdc, &ctrl, uLeftButFlags, fMouseDownL, fMouseOverL);
+		RotateRect0(sb, &ctrl);
+
+		//RIGHT ARROW
+		OffsetRect(&ctrl, scrollwidth - butwidth, 0);
+
+		RotateRect0(sb, &ctrl);
+		if (fCustomDraw)
+			PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_LINERIGHT, fMouseDownR, fMouseOverR, uRightButFlags & DFCS_INACTIVE);
+		else
+			DrawScrollArrow(sb, hdc, &ctrl, uRightButFlags, fMouseDownR, fMouseOverR);
+		RotateRect0(sb, &ctrl);
+
+		//if there is a gap between the buttons, fill it with a solid color
+		//if(butwidth & 0x0001)
+		if (ctrl.left != rect->left + butwidth)
+		{
+			ctrl.left --;
+			ctrl.right -= butwidth;
+			RotateRect0(sb, &ctrl);
+
+			if (fCustomDraw)
+				PostCustomDrawNotify(hwnd, hdc, sb->nBarType, &ctrl, SB_PAGERIGHT, 0, 0, 0);
+			else
+				DrawCheckedRect(hdc, &ctrl, crCheck1, crCheck2);
+
+			RotateRect0(sb, &ctrl);
+		}
+
+	}
+
+	return fCustomDraw;
+}
+
+//
+//	Draw a vertical scrollbar using the horizontal draw routine, but
+//	with the coordinates adjusted accordingly
+//
+static LRESULT NCDrawVScrollbar(SCROLLBAR *sb, HWND hwnd, HDC hdc, const RECT *rect, UINT uDrawFlags)
+{
+	LRESULT ret;
+	RECT rc;
+
+	rc = *rect;
+	RotateRect(&rc);
+	ret = NCDrawHScrollbar(sb, hwnd, hdc, &rc, uDrawFlags);
+	RotateRect(&rc);
+
+	return ret;
+}
+
+//
+//	Generic wrapper function for the scrollbar drawing
+//
+static LRESULT NCDrawScrollbar(SCROLLBAR *sb, HWND hwnd, HDC hdc, const RECT *rect, UINT uDrawFlags)
+{
+	if (sb->nBarType == SB_HORZ)
+		return NCDrawHScrollbar(sb, hwnd, hdc, rect, uDrawFlags);
+	else
+		return NCDrawVScrollbar(sb, hwnd, hdc, rect, uDrawFlags);
+}
+
+//
+//	Define these two for proper processing of NCPAINT
+//	NOT needed if we don't bother to mask the scrollbars we draw
+//	to prevent the old window procedure from accidently drawing over them
+//
+HDC CoolSB_GetDC(HWND hwnd, WPARAM wParam)
+{
+	// I just can't figure out GetDCEx, so I'll just use this:
+	return GetWindowDC(hwnd);
+}
+
+static LRESULT NCPaint(ScrollWnd *sw, HWND hwnd, WPARAM wParam, LPARAM lParam)
+{
+	SCROLLBAR *sb;
+	HDC hdc;
+	HRGN hrgn;
+	RECT winrect, rect;
+	HRGN clip;
+	BOOL fUpdateAll = ((LONG)wParam == 1);
+	BOOL fCustomDraw = FALSE;
+	LRESULT ret;
+	DWORD dwStyle;
+
+	GetWindowRect(hwnd, &winrect);
+
+	//if entire region needs painting, then make a region to cover the entire window
+	hrgn = (HRGN)wParam;
+
+	//hdc = GetWindowDC(hwnd);
+	hdc = CoolSB_GetDC(hwnd, wParam);
+
+	//
+	//	Only draw the horizontal scrollbar if the window is tall enough
+	//
+	sb = &sw->sbarHorz;
+	if (sb->fScrollVisible)
+	{
+		//get the screen coordinates of the whole horizontal scrollbar area
+		GetHScrollRect(sw, hwnd, &rect);
+
+		//make the coordinates relative to the window for drawing
+		OffsetRect(&rect, -winrect.left, -winrect.top);
+
+		if (uCurrentScrollbar == SB_HORZ)
+			fCustomDraw |= NCDrawHScrollbar(sb, hwnd, hdc, &rect, uScrollTimerPortion);
+		else
+			fCustomDraw |= NCDrawHScrollbar(sb, hwnd, hdc, &rect, HTSCROLL_NONE);
+	}
+
+	//
+	// Only draw the vertical scrollbar if the window is wide enough to accomodate it
+	//
+	sb = &sw->sbarVert;
+	if (sb->fScrollVisible)
+	{
+		//get the screen cooridinates of the whole horizontal scrollbar area
+		GetVScrollRect(sw, hwnd, &rect);
+
+		//make the coordinates relative to the window for drawing
+		OffsetRect(&rect, -winrect.left, -winrect.top);
+
+		if (uCurrentScrollbar == SB_VERT)
+			fCustomDraw |= NCDrawVScrollbar(sb, hwnd, hdc, &rect, uScrollTimerPortion);
+		else
+			fCustomDraw |= NCDrawVScrollbar(sb, hwnd, hdc, &rect, HTSCROLL_NONE);
+	}
+
+	//Call the default window procedure for WM_NCPAINT, with the
+	//new window region. ** region must be in SCREEN coordinates **
+	dwStyle = GetWindowLongPtr(hwnd, GWL_STYLE);
+
+	// If the window has WS_(H-V)SCROLL bits set, we should reset them
+	// to avoid windows taking the scrollbars into account.
+	// We temporarily set a flag preventing the subsecuent
+	// WM_STYLECHANGING/WM_STYLECHANGED to be forwarded to
+	// the original window procedure
+	if (dwStyle & (WS_VSCROLL | WS_HSCROLL))
+	{
+		sw->bPreventStyleChange = TRUE;
+		SetWindowLongPtr(hwnd, GWL_STYLE, dwStyle & ~(WS_VSCROLL | WS_HSCROLL));
+	}
+
+	ret = (sw->fWndUnicode) ? CallWindowProcW(sw->oldproc, hwnd, WM_NCPAINT, (WPARAM)hrgn, lParam) : 
+									CallWindowProcA(sw->oldproc, hwnd, WM_NCPAINT, (WPARAM)hrgn, lParam);
+	if (dwStyle & (WS_VSCROLL | WS_HSCROLL))
+	{
+		SetWindowLong(hwnd, GWL_STYLE, dwStyle);
+		sw->bPreventStyleChange = FALSE;
+	}
+
+
+	// DRAW THE DEAD AREA
+	// only do this if the horizontal and vertical bars are visible
+	if (sw->sbarHorz.fScrollVisible && sw->sbarVert.fScrollVisible)
+	{
+		GetWindowRect(hwnd, &rect);
+		OffsetRect(&rect, -winrect.left, -winrect.top);
+
+		rect.bottom -= sw->cyBottomEdge;
+		rect.top  = rect.bottom - GetScrollMetric(&sw->sbarHorz, SM_CYHORZSB);
+
+		if (sw->fLeftScrollbar)
+		{
+			rect.left += sw->cxLeftEdge;
+			rect.right = rect.left + GetScrollMetric(&sw->sbarVert, SM_CXVERTSB);
+		}
+		else
+		{
+			rect.right -= sw->cxRightEdge;
+			rect.left = rect.right  - GetScrollMetric(&sw->sbarVert, SM_CXVERTSB);
+		}
+
+		if (fCustomDraw)
+			PostCustomDrawNotify(hwnd, hdc, SB_BOTH, &rect, 32, 0, 0, 0);
+		else
+		{
+			//calculate the position of THIS window's dead area
+			//with the position of the PARENT window's client rectangle.
+			//if THIS window has been positioned such that its bottom-right
+			//corner sits in the parent's bottom-right corner, then we should
+			//show the sizing-grip.
+			//Otherwise, assume this window is not in the right place, and
+			//just draw a blank rectangle
+			RECT parent;
+			RECT rect2;
+			HWND hwndParent = GetParent(hwnd);
+
+			GetClientRect(hwndParent, &parent);
+			MapWindowPoints(hwndParent, 0, (POINT *)&parent, 2);
+
+			CopyRect(&rect2, &rect);
+			OffsetRect(&rect2, winrect.left, winrect.top);
+
+			if (!sw->fLeftScrollbar && parent.right == rect2.right + sw->cxRightEdge && parent.bottom == rect2.bottom + sw->cyBottomEdge
+			    || sw->fLeftScrollbar && parent.left  == rect2.left - sw->cxLeftEdge  && parent.bottom == rect2.bottom + sw->cyBottomEdge)
+				drawFrameControl(hdc, &rect, DFC_SCROLL, sw->fLeftScrollbar ? DFCS_SCROLLSIZEGRIPRIGHT : DFCS_SCROLLSIZEGRIP);
+			else
+				PaintRect(hdc, &rect, WADlg_getColor(WADLG_SCROLLBAR_DEADAREA_COLOR));
+		}
+	}
+
+	UNREFERENCED_PARAMETER(clip);
+
+	ReleaseDC(hwnd, hdc);
+	return ret;
+}
+
+//
+// Need to detect if we have clicked in the scrollbar region or not
+//
+static LRESULT NCHitTest(ScrollWnd *sw, HWND hwnd, WPARAM wParam, LPARAM lParam)
+{
+	RECT hrect;
+	RECT vrect;
+	POINT pt;
+
+	pt.x = GET_X_LPARAM(lParam);
+	pt.y = GET_Y_LPARAM(lParam);
+
+	//work out exactly where the Horizontal and Vertical scrollbars are
+	GetHScrollRect(sw, hwnd, &hrect);
+	GetVScrollRect(sw, hwnd, &vrect);
+
+	//Clicked in the horizontal scrollbar area
+	if (sw->sbarHorz.fScrollVisible && PtInRect(&hrect, pt))
+	{
+		return HTHSCROLL;
+	}
+	//Clicked in the vertical scrollbar area
+	else if (sw->sbarVert.fScrollVisible && PtInRect(&vrect, pt))
+	{
+		return HTVSCROLL;
+	}
+	//clicked somewhere else
+	else
+	{
+		return (sw->fWndUnicode) ? CallWindowProcW(sw->oldproc, hwnd, WM_NCHITTEST, wParam, lParam) : 
+									CallWindowProcA(sw->oldproc, hwnd, WM_NCHITTEST, wParam, lParam);
+
+	}
+}
+
+//
+//	Return a HT* value indicating what part of the scrollbar was clicked
+//	Rectangle is not adjusted
+//
+static UINT GetHorzPortion(SCROLLBAR *sb, HWND hwnd, RECT *rect, int x, int y)
+{
+	RECT rc = *rect;
+
+	if (y < rc.top || y >= rc.bottom) return HTSCROLL_NONE;
+
+	//Now we have the rectangle for the scrollbar itself, so work out
+	//what part we clicked on.
+	return GetHorzScrollPortion(sb, hwnd, &rc, x, y);
+}
+
+//
+//	Just call the horizontal version, with adjusted coordinates
+//
+static UINT GetVertPortion(SCROLLBAR *sb, HWND hwnd, RECT *rect, int x, int y)
+{
+	UINT ret;
+	RotateRect(rect);
+	ret = GetHorzPortion(sb, hwnd, rect, y, x);
+	RotateRect(rect);
+	return ret;
+}
+
+//
+//	Wrapper function for GetHorzPortion and GetVertPortion
+//
+static UINT GetPortion(SCROLLBAR *sb, HWND hwnd, RECT *rect, int x, int y)
+{
+	if (sb->nBarType == SB_HORZ)
+		return GetHorzPortion(sb, hwnd, rect, x, y);
+	else if (sb->nBarType == SB_VERT)
+		return GetVertPortion(sb, hwnd, rect, x, y);
+	else
+		return HTSCROLL_NONE;
+}
+
+//
+//	Input: rectangle of the total scrollbar area
+//	Output: adjusted to take the inserted buttons into account
+//
+static void GetRealHorzScrollRect(SCROLLBAR *sb, RECT *rect)
+{
+	if (sb->fButVisibleBefore) rect->left += sb->nButSizeBefore;
+	if (sb->fButVisibleAfter)  rect->right -= sb->nButSizeAfter;
+}
+
+//
+//	Input: rectangle of the total scrollbar area
+//	Output: adjusted to take the inserted buttons into account
+//
+static void GetRealVertScrollRect(SCROLLBAR *sb, RECT *rect)
+{
+	if (sb->fButVisibleBefore) rect->top += sb->nButSizeBefore;
+	if (sb->fButVisibleAfter)  rect->bottom -= sb->nButSizeAfter;
+}
+
+//
+//	Decide which type of scrollbar we have before calling
+//  the real function to do the job
+//
+static void GetRealScrollRect(SCROLLBAR *sb, RECT *rect)
+{
+	if (sb->nBarType == SB_HORZ)
+	{
+		GetRealHorzScrollRect(sb, rect);
+	}
+	else if (sb->nBarType == SB_VERT)
+	{
+		GetRealVertScrollRect(sb, rect);
+	}
+}
+
+//
+//	Left button click in the non-client area
+//
+static LRESULT NCLButtonDown(ScrollWnd *sw, HWND hwnd, WPARAM wParam, LPARAM lParam)
+{
+	RECT rect, winrect;
+	HDC hdc;
+	SCROLLBAR *sb;
+	POINT pt;
+
+	pt.x = GET_X_LPARAM(lParam);
+	pt.y = GET_Y_LPARAM(lParam);
+
+	hwndCurCoolSB = hwnd;
+
+	//
+	//	HORIZONTAL SCROLLBAR PROCESSING
+	//
+	if (wParam == HTHSCROLL)
+	{
+		uScrollTimerMsg = WM_HSCROLL;
+		uCurrentScrollbar = SB_HORZ;
+		sb = &sw->sbarHorz;
+
+		//get the total area of the normal Horz scrollbar area
+		GetHScrollRect(sw, hwnd, &rect);
+		uCurrentScrollPortion = GetHorzPortion(sb, hwnd, &rect, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
+	}
+	//
+	//	VERTICAL SCROLLBAR PROCESSING
+	//
+	else if (wParam == HTVSCROLL)
+	{
+		uScrollTimerMsg = WM_VSCROLL;
+		uCurrentScrollbar = SB_VERT;
+		sb = &sw->sbarVert;
+
+		//get the total area of the normal Horz scrollbar area
+		GetVScrollRect(sw, hwnd, &rect);
+		uCurrentScrollPortion = GetVertPortion(sb, hwnd, &rect, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
+	}
+	//
+	//	NORMAL PROCESSING
+	//
+	else
+	{
+		uCurrentScrollPortion = HTSCROLL_NONE;
+		return (sw->fWndUnicode) ? CallWindowProcW(sw->oldproc, hwnd, WM_NCLBUTTONDOWN, wParam, lParam) : 
+									CallWindowProcA(sw->oldproc, hwnd, WM_NCLBUTTONDOWN, wParam, lParam);
+	}
+
+	//
+	// we can now share the same code for vertical
+	// and horizontal scrollbars
+	//
+	switch (uCurrentScrollPortion)
+	{
+			//inserted buttons to the left/right
+		case HTSCROLL_THUMB:
+
+			//if the scrollbar is disabled, then do no further processing
+			if (!IsScrollbarActive(sb))
+				return 0;
+
+			GetRealScrollRect(sb, &rect);
+			RotateRect0(sb, &rect);
+			CalcThumbSize(sb, &rect, &nThumbSize, &nThumbPos);
+			RotateRect0(sb, &rect);
+
+			//remember the bounding rectangle of the scrollbar work area
+			rcThumbBounds = rect;
+
+			sw->fThumbTracking = TRUE;
+			sb->scrollInfo.nTrackPos = sb->scrollInfo.nPos;
+
+			if (wParam == HTVSCROLL)
+				nThumbMouseOffset = pt.y - nThumbPos;
+			else
+				nThumbMouseOffset = pt.x - nThumbPos;
+
+			nLastPos = -sb->scrollInfo.nPos;
+			nThumbPos0 = nThumbPos;
+
+			//if(sb->fFlatScrollbar)
+			//{
+			GetWindowRect(hwnd, &winrect);
+			OffsetRect(&rect, -winrect.left, -winrect.top);
+			hdc = GetWindowDC(hwnd);
+			NCDrawScrollbar(sb, hwnd, hdc, &rect, HTSCROLL_THUMB);
+			ReleaseDC(hwnd, hdc);
+			//}
+
+			break;
+
+			//Any part of the scrollbar
+		case HTSCROLL_LEFT:
+			if (sb->fScrollFlags & ESB_DISABLE_LEFT)		return 0;
+			else										goto target1;
+
+		case HTSCROLL_RIGHT:
+			if (sb->fScrollFlags & ESB_DISABLE_RIGHT)	return 0;
+			else										goto target1;
+
+			goto target1;
+
+	case HTSCROLL_PAGELEFT:  case HTSCROLL_PAGERIGHT:
+
+target1:
+
+			//if the scrollbar is disabled, then do no further processing
+			if (!IsScrollbarActive(sb))
+				break;
+
+			//ajust the horizontal rectangle to NOT include
+			//any inserted buttons
+			GetRealScrollRect(sb, &rect);
+
+			SendScrollMessage(hwnd, uScrollTimerMsg, uCurrentScrollPortion, 0);
+
+			// Check what area the mouse is now over :
+			// If the scroll thumb has moved under the mouse in response to
+			// a call to SetScrollPos etc, then we don't hilight the scrollbar margin
+			if (uCurrentScrollbar == SB_HORZ)
+				uScrollTimerPortion = GetHorzScrollPortion(sb, hwnd, &rect, pt.x, pt.y);
+			else
+				uScrollTimerPortion = GetVertScrollPortion(sb, hwnd, &rect, pt.x, pt.y);
+
+			GetWindowRect(hwnd, &winrect);
+			OffsetRect(&rect, -winrect.left, -winrect.top);
+			hdc = GetWindowDC(hwnd);
+
+			//if we aren't hot-tracking, then don't highlight
+			//the scrollbar thumb unless we click on it
+			if (uScrollTimerPortion == HTSCROLL_THUMB)
+				uScrollTimerPortion = HTSCROLL_NONE;
+			NCDrawScrollbar(sb, hwnd, hdc, &rect, uScrollTimerPortion);
+			ReleaseDC(hwnd, hdc);
+
+			//Post the scroll message!!!!
+			uScrollTimerPortion = uCurrentScrollPortion;
+
+			//set a timer going on the first click.
+			//if this one expires, then we can start off a more regular timer
+			//to generate the auto-scroll behaviour
+			uScrollTimerId = SetTimer(hwnd, COOLSB_TIMERID1, COOLSB_TIMERINTERVAL1, 0);
+			sw->update();
+			break;
+		default:
+			return (sw->fWndUnicode) ? CallWindowProcW(sw->oldproc, hwnd, WM_NCLBUTTONDOWN, wParam, lParam) : 
+									CallWindowProcA(sw->oldproc, hwnd, WM_NCLBUTTONDOWN, wParam, lParam);
+			//return 0;
+	}
+
+	SetCapture(hwnd);
+	return 0;
+}
+
+//
+//	Left button released
+//
+static LRESULT LButtonUp(ScrollWnd *sw, HWND hwnd, WPARAM wParam, LPARAM lParam)
+{
+	RECT rect;
+	POINT pt;
+	RECT winrect;
+
+	//current scrollportion is the button that we clicked down on
+	if (uCurrentScrollPortion != HTSCROLL_NONE)
+	{
+		SCROLLBAR *sb = &sw->sbarHorz;
+		lParam = GetMessagePos();
+		ReleaseCapture();
+
+		GetWindowRect(hwnd, &winrect);
+		pt.x = GET_X_LPARAM(lParam);
+		pt.y = GET_Y_LPARAM(lParam);
+
+		//emulate the mouse input on a scrollbar here...
+		if (uCurrentScrollbar == SB_HORZ)
+		{
+			//get the total area of the normal Horz scrollbar area
+			sb = &sw->sbarHorz;
+			GetHScrollRect(sw, hwnd, &rect);
+		}
+		else if (uCurrentScrollbar == SB_VERT)
+		{
+			//get the total area of the normal Horz scrollbar area
+			sb = &sw->sbarVert;
+			GetVScrollRect(sw, hwnd, &rect);
+		}
+
+		//we need to do different things depending on if the
+		//user is activating the scrollbar itself, or one of
+		//the inserted buttons
+		switch (uCurrentScrollPortion)
+		{
+				//The scrollbar is active
+		case HTSCROLL_LEFT:  case HTSCROLL_RIGHT:
+		case HTSCROLL_PAGELEFT:  case HTSCROLL_PAGERIGHT:
+			case HTSCROLL_NONE:
+
+				KillTimer(hwnd, uScrollTimerId);
+
+			case HTSCROLL_THUMB:
+
+				sw->update();
+
+				//In case we were thumb tracking, make sure we stop NOW
+				if (sw->fThumbTracking == TRUE)
+				{
+					SendScrollMessage(hwnd, uScrollTimerMsg, SB_THUMBPOSITION, nLastPos);
+					sw->fThumbTracking = FALSE;
+				}
+
+				//send the SB_ENDSCROLL message now that scrolling has finished
+				SendScrollMessage(hwnd, uScrollTimerMsg, SB_ENDSCROLL, 0);
+
+				//adjust the total scroll area to become where the scrollbar
+				//really is (take into account the inserted buttons)
+				GetRealScrollRect(sb, &rect);
+				OffsetRect(&rect, -winrect.left, -winrect.top);
+				HDC hdc = GetWindowDC(hwnd);
+
+				//draw whichever scrollbar sb is
+				NCDrawScrollbar(sb, hwnd, hdc, &rect, HTSCROLL_NORMAL);
+
+				ReleaseDC(hwnd, hdc);
+				break;
+		}
+
+		//reset our state to default
+		uCurrentScrollPortion = HTSCROLL_NONE;
+		uScrollTimerPortion	  = HTSCROLL_NONE;
+		uScrollTimerId		  = 0;
+
+		uScrollTimerMsg       = 0;
+		uCurrentScrollbar     = COOLSB_NONE;
+
+		return 0;
+	}
+	else
+	{
+		/*
+		// Can't remember why I did this!
+		if(GetCapture() == hwnd)
+		{
+			ReleaseCapture();
+		}*/
+	}
+
+	//sw->update();
+
+	return (sw->fWndUnicode) ? CallWindowProcW(sw->oldproc, hwnd, WM_LBUTTONUP, wParam, lParam) : 
+									CallWindowProcA(sw->oldproc, hwnd, WM_LBUTTONUP, wParam, lParam);
+}
+
+//
+//	This function is called whenever the mouse is moved and
+//  we are dragging the scrollbar thumb about.
+//
+static LRESULT ThumbTrackHorz(SCROLLBAR *sbar, HWND hwnd, int x, int y)
+{
+	POINT pt;
+	RECT rc, winrect, rc2;
+	COLORREF crCheck1 = GetSBForeColor();
+	COLORREF crCheck2 = GetSBBackColor();
+	HDC hdc;
+	int thumbpos = nThumbPos;
+	int pos;
+	int siMaxMin = 0;
+	UINT flatflag = sbar->fFlatScrollbar ? BF_FLAT : 0;
+	BOOL fCustomDraw = FALSE;
+
+	SCROLLINFO *si;
+	si = &sbar->scrollInfo;
+
+	pt.x = x;
+	pt.y = y;
+
+	//draw the thumb at whatever position
+	rc = rcThumbBounds;
+
+	SetRect(&rc2, rc.left -  THUMBTRACK_SNAPDIST*2, rc.top -    THUMBTRACK_SNAPDIST,
+	        rc.right + THUMBTRACK_SNAPDIST*2, rc.bottom + THUMBTRACK_SNAPDIST);
+
+	rc.left +=  GetScrollMetric(sbar, SM_CXHORZSB);
+	rc.right -= GetScrollMetric(sbar, SM_CXHORZSB);
+
+	//if the mouse is not in a suitable distance of the scrollbar,
+	//then "snap" the thumb back to its initial position
+#ifdef SNAP_THUMB_BACK
+	if (!PtInRect(&rc2, pt))
+	{
+		thumbpos = nThumbPos0;
+	}
+	//otherwise, move the thumb to where the mouse is
+	else
+#endif //SNAP_THUMB_BACK
+	{
+		//keep the thumb within the scrollbar limits
+		thumbpos = pt.x - nThumbMouseOffset;
+		if (thumbpos < rc.left) thumbpos = rc.left;
+		if (thumbpos > rc.right - nThumbSize) thumbpos = rc.right - nThumbSize;
+	}
+
+	GetWindowRect(hwnd, &winrect);
+
+	if (sbar->nBarType == SB_VERT)
+		RotateRect(&winrect);
+
+	hdc = GetWindowDC(hwnd);
+
+	OffsetRect(&rc, -winrect.left, -winrect.top);
+	thumbpos -= winrect.left;
+
+	//draw the margin before the thumb
+	SetRect(&rc2, rc.left, rc.top, thumbpos, rc.bottom);
+	RotateRect0(sbar, &rc2);
+
+	if (fCustomDraw)
+		PostCustomDrawNotify(hwnd, hdc, sbar->nBarType, &rc2, SB_PAGELEFT, 0, 0, 0);
+	else
+		DrawCheckedRect(hdc, &rc2, crCheck1, crCheck2);
+
+	RotateRect0(sbar, &rc2);
+
+	//draw the margin after the thumb
+	SetRect(&rc2, thumbpos + nThumbSize, rc.top, rc.right, rc.bottom);
+
+	RotateRect0(sbar, &rc2);
+
+	if (fCustomDraw)
+		PostCustomDrawNotify(hwnd, hdc, sbar->nBarType, &rc2, SB_PAGERIGHT, 0, 0, 0);
+	else
+		DrawCheckedRect(hdc, &rc2, crCheck1, crCheck2);
+
+	RotateRect0(sbar, &rc2);
+
+	//finally draw the thumb itelf. This is how it looks on win2000, anyway
+	SetRect(&rc2, thumbpos, rc.top, thumbpos + nThumbSize, rc.bottom);
+
+	RotateRect0(sbar, &rc2);
+
+	if (fCustomDraw)
+		PostCustomDrawNotify(hwnd, hdc, sbar->nBarType, &rc2, SB_THUMBTRACK, TRUE, TRUE, FALSE);
+	else
+	{
+		DrawBlankButton(hdc, &rc2, flatflag, 1, sbar->nBarType == SB_VERT);
+	}
+
+	RotateRect0(sbar, &rc2);
+	ReleaseDC(hwnd, hdc);
+
+	//post a SB_TRACKPOS message!!!
+	siMaxMin = si->nMax - si->nMin;
+
+	if (siMaxMin > 0)
+		pos = MulDiv(thumbpos - rc.left, siMaxMin - si->nPage + 1, rc.right - rc.left - nThumbSize);
+	else
+		pos = thumbpos - rc.left;
+
+	if (pos != nLastPos)
+	{
+
+		if (sbar->flags & SCROLLBAR_LISTVIEW)
+		{
+		// only for listviews
+		if (sbar->nBarType == SB_HORZ)
+		{
+			SCROLLINFO info;
+			info.cbSize = sizeof(SCROLLINFO);
+			info.fMask = SIF_TRACKPOS;
+			if (GetScrollInfo(hwnd, SB_HORZ, &info))
+			{
+				int nPos = info.nTrackPos;
+				SendMessage(hwnd, LVM_SCROLL, pos - nPos, 0);
+				SetScrollInfo(hwnd, sbar->nBarType, &info, FALSE);
+			}
+		}
+		else if (sbar->nBarType == SB_VERT)
+		{
+			SCROLLINFO info;
+			info.cbSize = sizeof(SCROLLINFO);
+			info.fMask = SIF_TRACKPOS;
+			if (GetScrollInfo(hwnd, SB_VERT, &info))
+			{
+				int nPos = info.nTrackPos;
+				SendMessage(hwnd, LVM_SCROLL, 0, (pos - nPos)*14); //BIG FUCKO: get the text height size
+				SetScrollInfo(hwnd, sbar->nBarType, &info, FALSE);
+			}
+		}
+		}
+		else
+		{
+			si->nTrackPos = pos;
+			SCROLLINFO info;
+			info.cbSize = sizeof(SCROLLINFO);
+			info.fMask = SIF_TRACKPOS;
+			info.nTrackPos = pos;
+	
+			SetScrollInfo(hwnd, sbar->nBarType, &info, FALSE);
+			SendScrollMessage(hwnd, uScrollTimerMsg, SB_THUMBTRACK, pos);
+		}
+	}
+
+	nLastPos = pos;
+
+	return 0;
+}
+
+//
+//	remember to rotate the thumb bounds rectangle!!
+//
+static LRESULT ThumbTrackVert(SCROLLBAR *sb, HWND hwnd, int x, int y)
+{
+	//sw->swapcoords = TRUE;
+	RotateRect(&rcThumbBounds);
+	ThumbTrackHorz(sb, hwnd, y, x);
+	RotateRect(&rcThumbBounds);
+	//sw->swapcoords = FALSE;
+
+	return 0;
+}
+
+//
+//	Called when we have set the capture from the NCLButtonDown(...)
+//
+static LRESULT MouseMove(ScrollWnd *sw, HWND hwnd, WPARAM wParam, LPARAM lParam)
+{
+	RECT rect;
+	POINT pt;
+	RECT winrect;
+
+	if (sw->fThumbTracking == TRUE)
+	{
+		int x, y;
+		lParam = GetMessagePos();
+		x = GET_X_LPARAM(lParam);
+		y = GET_Y_LPARAM(lParam);
+
+		if (uCurrentScrollbar == SB_HORZ)
+			return ThumbTrackHorz(&sw->sbarHorz, hwnd, x, y);
+
+
+		else if (uCurrentScrollbar == SB_VERT)
+			return ThumbTrackVert(&sw->sbarVert, hwnd, x, y);
+	}
+
+	if (uCurrentScrollPortion == HTSCROLL_NONE)
+	{
+
+		return (sw->fWndUnicode) ? CallWindowProcW(sw->oldproc, hwnd, WM_MOUSEMOVE, wParam, lParam) : 
+									CallWindowProcA(sw->oldproc, hwnd, WM_MOUSEMOVE, wParam, lParam);
+	}
+	else
+	{
+		LPARAM nlParam;
+		SCROLLBAR *sb = &sw->sbarHorz;
+
+		nlParam = GetMessagePos();
+
+		GetWindowRect(hwnd, &winrect);
+
+		pt.x = GET_X_LPARAM(nlParam);
+		pt.y = GET_Y_LPARAM(nlParam);
+
+		//emulate the mouse input on a scrollbar here...
+		if (uCurrentScrollbar == SB_HORZ)
+		{
+			sb = &sw->sbarHorz;
+		}
+		else if (uCurrentScrollbar == SB_VERT)
+		{
+			sb = &sw->sbarVert;
+		}
+
+		//get the total area of the normal scrollbar area
+		GetScrollRect(sw, sb->nBarType, hwnd, &rect);
+
+		//see if we clicked in the inserted buttons / normal scrollbar
+		//thisportion = GetPortion(sb, hwnd, &rect, LOWORD(lParam), HIWORD(lParam));
+		UINT thisportion = GetPortion(sb, hwnd, &rect, pt.x, pt.y);
+
+		//we need to do different things depending on if the
+		//user is activating the scrollbar itself, or one of
+		//the inserted buttons
+		static UINT lastportion = 0;
+		switch (uCurrentScrollPortion)
+		{
+				//The scrollbar is active
+	case HTSCROLL_LEFT:		 case HTSCROLL_RIGHT: case HTSCROLL_THUMB:
+		case HTSCROLL_PAGELEFT:  case HTSCROLL_PAGERIGHT:
+			case HTSCROLL_NONE:
+
+				//adjust the total scroll area to become where the scrollbar
+				//really is (take into account the inserted buttons)
+				GetRealScrollRect(sb, &rect);
+
+				OffsetRect(&rect, -winrect.left, -winrect.top);
+				HDC hdc = GetWindowDC(hwnd);
+
+				if (thisportion != uCurrentScrollPortion)
+				{
+					uScrollTimerPortion = HTSCROLL_NONE;
+
+					if (lastportion != thisportion)
+						NCDrawScrollbar(sb, hwnd, hdc, &rect, HTSCROLL_NORMAL);
+				}
+				//otherwise, draw the button in its depressed / clicked state
+				else
+				{
+					uScrollTimerPortion = uCurrentScrollPortion;
+
+					if (lastportion != thisportion)
+						NCDrawScrollbar(sb, hwnd, hdc, &rect, thisportion);
+				}
+
+				ReleaseDC(hwnd, hdc);
+
+				break;
+		}
+
+
+		lastportion = thisportion;
+
+		//must return zero here, because we might get cursor anomilies
+		//CallWindowProc(sw->oldproc, hwnd, WM_MOUSEMOVE, wParam, lParam);
+		return 0;
+
+	}
+}
+
+//
+//	We must allocate from in the non-client area for our scrollbars
+//	Call the default window procedure first, to get the borders (if any)
+//	allocated some space, then allocate the space for the scrollbars
+//	if they fit
+//
+static LRESULT NCCalcSize(ScrollWnd *sw, HWND hwnd, WPARAM wParam, LPARAM lParam)
+{
+	NCCALCSIZE_PARAMS *nccsp;
+	RECT *rect;
+	RECT oldrect;
+	//BOOL fCalcValidRects = (wParam == TRUE);
+	SCROLLBAR *sb;
+	LRESULT ret;
+	DWORD dwStyle;
+
+	//Regardless of the value of fCalcValidRects, the first rectangle
+	//in the array specified by the rgrc structure member of the
+	//NCCALCSIZE_PARAMS structure contains the coordinates of the window,
+	//so we can use the exact same code to modify this rectangle, when
+	//wParam is TRUE and when it is FALSE.
+	nccsp = (NCCALCSIZE_PARAMS *)lParam;
+	rect = &nccsp->rgrc[0];
+	oldrect = *rect;
+
+	dwStyle = GetWindowLong(hwnd, GWL_STYLE);
+
+	// TURN OFF SCROLL-STYLES.
+	if (dwStyle & (WS_VSCROLL | WS_HSCROLL))
+	{
+		sw->bPreventStyleChange = TRUE;
+		SetWindowLong(hwnd, GWL_STYLE, dwStyle & ~(WS_VSCROLL | WS_HSCROLL));
+	}
+
+	//call the default procedure to get the borders allocated
+
+	ret = (sw->fWndUnicode) ? CallWindowProcW(sw->oldproc, hwnd, WM_NCCALCSIZE, wParam, lParam) : 
+									CallWindowProcA(sw->oldproc, hwnd, WM_NCCALCSIZE, wParam, lParam);
+
+	// RESTORE PREVIOUS STYLES (if present at all)
+	if (dwStyle & (WS_VSCROLL | WS_HSCROLL))
+	{
+		SetWindowLong(hwnd, GWL_STYLE, dwStyle);
+		sw->bPreventStyleChange = FALSE;
+	}
+
+	// calculate what the size of each window border is,
+	sw->cxLeftEdge   = rect->left     - oldrect.left;
+	sw->cxRightEdge  = oldrect.right  - rect->right;
+	sw->cyTopEdge    = rect->top      - oldrect.top;
+	sw->cyBottomEdge = oldrect.bottom - rect->bottom;
+
+	sb = &sw->sbarHorz;
+
+	//if there is room, allocate some space for the horizontal scrollbar
+	//NOTE: Change the ">" to a ">=" to make the horz bar totally fill the
+	//window before disappearing
+	if ((sb->fScrollFlags & CSBS_VISIBLE) &&
+#ifdef COOLSB_FILLWINDOW
+	    rect->bottom - rect->top >= GetScrollMetric(sb, SM_CYHORZSB))
+#else
+	    rect->bottom - rect->top > GetScrollMetric(sb, SM_CYHORZSB))
+#endif
+	{
+		rect->bottom -= GetScrollMetric(sb, SM_CYHORZSB);
+		sb->fScrollVisible = TRUE;
+	}
+	else
+		sb->fScrollVisible = FALSE;
+
+	sb = &sw->sbarVert;
+
+	//if there is room, allocate some space for the vertical scrollbar
+	if ((sb->fScrollFlags & CSBS_VISIBLE) &&
+	    rect->right - rect->left >= GetScrollMetric(sb, SM_CXVERTSB))
+	{
+		if (sw->fLeftScrollbar)
+			rect->left  += GetScrollMetric(sb, SM_CXVERTSB);
+		else
+			rect->right -= GetScrollMetric(sb, SM_CXVERTSB);
+
+		sb->fScrollVisible = TRUE;
+	}
+	else
+		sb->fScrollVisible = FALSE;
+
+	//don't return a value unless we actually modify the other rectangles
+	//in the NCCALCSIZE_PARAMS structure. In this case, we return 0
+	//no matter what the value of fCalcValidRects is
+	return ret;//FALSE;
+}
+
+//
+//	used for hot-tracking over the scroll buttons
+//
+static LRESULT NCMouseMove(ScrollWnd *sw, HWND hwnd, WPARAM wHitTest, LPARAM lParam)
+{
+	//install a timer for the mouse-over events, if the mouse moves
+	//over one of the scrollbars
+	return (sw->fWndUnicode) ? CallWindowProcW(sw->oldproc, hwnd, WM_NCMOUSEMOVE, wHitTest, lParam) : 
+									CallWindowProcA(sw->oldproc, hwnd, WM_NCMOUSEMOVE, wHitTest, lParam);
+}
+
+//
+//	Timer routine to generate scrollbar messages
+//
+static LRESULT CoolSB_Timer(ScrollWnd *swnd, HWND hwnd, WPARAM wTimerId, LPARAM lParam)
+{
+	//let all timer messages go past if we don't have a timer installed ourselves
+	if (uScrollTimerId == 0 && uMouseOverId == 0)
+	{
+		return (swnd->fWndUnicode) ? CallWindowProcW(swnd->oldproc, hwnd, WM_TIMER, wTimerId, lParam) : 
+								CallWindowProcA(swnd->oldproc, hwnd, WM_TIMER, wTimerId, lParam);
+
+	}
+
+	//if the first timer goes off, then we can start a more
+	//regular timer interval to auto-generate scroll messages
+	//this gives a slight pause between first pressing the scroll arrow, and the
+	//actual scroll starting
+	if (wTimerId == COOLSB_TIMERID1)
+	{
+		KillTimer(hwnd, uScrollTimerId);
+		uScrollTimerId = SetTimer(hwnd, COOLSB_TIMERID2, COOLSB_TIMERINTERVAL2, 0);
+		return 0;
+	}
+	//send the scrollbar message repeatedly
+	else if (wTimerId == COOLSB_TIMERID2)
+	{
+		//need to process a spoof WM_MOUSEMOVE, so that
+		//we know where the mouse is each time the scroll timer goes off.
+		//This is so we can stop sending scroll messages if the thumb moves
+		//under the mouse.
+		POINT pt;
+		GetCursorPos(&pt);
+		ScreenToClient(hwnd, &pt);
+
+		MouseMove(swnd, hwnd, MK_LBUTTON, MAKELPARAM(pt.x, pt.y));
+
+		if (uScrollTimerPortion != HTSCROLL_NONE)
+			SendScrollMessage(hwnd, uScrollTimerMsg, uScrollTimerPortion, 0);
+
+		swnd->update();
+		return 0;
+	}
+	else
+	{
+		return (swnd->fWndUnicode) ? CallWindowProcW(swnd->oldproc, hwnd, WM_TIMER, wTimerId, lParam) : 
+								CallWindowProcA(swnd->oldproc, hwnd, WM_TIMER, wTimerId, lParam);
+	}
+}
+
+//
+//	We must intercept any calls to SetWindowLong, to check if
+//  left-scrollbars are taking effect or not
+//
+static LRESULT CoolSB_StyleChange(ScrollWnd *swnd, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+	STYLESTRUCT *ss = (STYLESTRUCT *)lParam;
+
+	if (wParam == GWL_EXSTYLE)
+	{
+		if (ss->styleNew & WS_EX_LEFTSCROLLBAR)
+			swnd->fLeftScrollbar = TRUE;
+		else
+			swnd->fLeftScrollbar = FALSE;
+	}
+
+	return (swnd->fWndUnicode) ? CallWindowProcW(swnd->oldproc, hwnd, msg, wParam, lParam) : 
+								CallWindowProcA(swnd->oldproc, hwnd, msg, wParam, lParam);
+}
+
+static UINT curTool = -1;
+static LRESULT CoolSB_Notify(ScrollWnd *swnd, HWND hwnd, WPARAM wParam, LPARAM lParam)
+{
+	return (swnd->fWndUnicode) ? CallWindowProcW(swnd->oldproc, hwnd, WM_NOTIFY, wParam, lParam) : 
+								CallWindowProcA(swnd->oldproc, hwnd, WM_NOTIFY, wParam, lParam);
+}
+
+static LRESULT SendToolTipMessage0(HWND hwndTT, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	return SendMessage(hwndTT, message, wParam, lParam);
+}
+
+#ifdef COOLSB_TOOLTIPS
+#define SendToolTipMessage		SendToolTipMessage0
+#else
+#define SendToolTipMessage		1 ? (void)0 : SendToolTipMessage0
+#endif
+
+
+//
+//	We must intercept any calls to SetWindowLong, to make sure that
+//	the user does not set the WS_VSCROLL or WS_HSCROLL styles
+//
+static LRESULT CoolSB_SetCursor(ScrollWnd *swnd, HWND hwnd, WPARAM wParam, LPARAM lParam)
+{
+	return (swnd->fWndUnicode) ? CallWindowProcW(swnd->oldproc, hwnd, WM_SETCURSOR, wParam, lParam) : 
+								CallWindowProcA(swnd->oldproc, hwnd, WM_SETCURSOR, wParam, lParam);
+}
+
+//
+//  CoolScrollbar subclass procedure.
+//	Handle all messages needed to mimick normal windows scrollbars
+//
+LRESULT CALLBACK CoolSBWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	WNDPROC oldproc;
+
+	ScrollWnd *swnd = GetScrollWndFromHwnd(hwnd);
+
+	if (!swnd || !swnd->oldproc)
+	{
+		return (IsWindowUnicode(hwnd)) ? DefWindowProcW(hwnd, message, wParam, lParam) : 
+										DefWindowProcA(hwnd, message, wParam, lParam);
+	}
+
+	switch (message)
+	{
+		case WM_NCDESTROY:
+			//this should NEVER be called, because the user
+			//should have called Uninitialize() themselves.
+
+			//However, if the user tries to call Uninitialize()..
+			//after this window is destroyed, this window's entry in the lookup
+			//table will not be there, and the call will fail
+			oldproc = swnd->oldproc;
+			delete(swnd);
+
+			//we must call the original window procedure, otherwise it
+			//will never get the WM_NCDESTROY message, and it wouldn't
+			//be able to clean up etc.
+			return (IsWindowUnicode(hwnd)) ? CallWindowProcW(oldproc, hwnd, message, wParam, lParam) : CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
+
+		case WM_NCCALCSIZE:
+			return NCCalcSize(swnd, hwnd, wParam, lParam);
+
+		case WM_NCPAINT:
+			return NCPaint(swnd, hwnd, wParam, lParam);
+
+		case WM_NCHITTEST:
+			return NCHitTest(swnd, hwnd, wParam, lParam);
+
+	case WM_NCRBUTTONDOWN: case WM_NCRBUTTONUP:
+	case WM_NCMBUTTONDOWN: case WM_NCMBUTTONUP:
+			if (wParam == HTHSCROLL || wParam == HTVSCROLL)
+				return 0;
+			else
+				break;
+
+		case WM_NCLBUTTONDBLCLK:
+			//TRACE("WM_NCLBUTTONDBLCLK %d\n", count++);
+			if (wParam == HTHSCROLL || wParam == HTVSCROLL)
+				return NCLButtonDown(swnd, hwnd, wParam, lParam);
+			else
+				break;
+
+		case WM_NCLBUTTONDOWN:
+			//TRACE("WM_NCLBUTTONDOWN%d\n", count++);
+			return NCLButtonDown(swnd, hwnd, wParam, lParam);
+
+
+		case WM_LBUTTONUP:
+			//TRACE("WM_LBUTTONUP %d\n", count++);
+			return LButtonUp(swnd, hwnd, wParam, lParam);
+
+		case WM_NOTIFY:
+			return CoolSB_Notify(swnd, hwnd, wParam, lParam);
+
+			//Mouse moves are received when we set the mouse capture,
+			//even when the mouse moves over the non-client area
+		case WM_MOUSEMOVE:
+			//TRACE("WM_MOUSEMOVE %d\n", count++);
+			return MouseMove(swnd, hwnd, wParam, lParam);
+
+		case WM_TIMER:
+			return CoolSB_Timer(swnd, hwnd, wParam, lParam);
+
+			//case WM_STYLECHANGING:
+			//	return CoolSB_StyleChange(swnd, hwnd, WM_STYLECHANGING, wParam, lParam);
+		case WM_STYLECHANGED:
+			if (swnd->bPreventStyleChange)
+			{
+				// the NCPAINT handler has told us to eat this message!
+				return 0;
+			}
+			else
+			{
+				if (message == WM_STYLECHANGED)
+					return CoolSB_StyleChange(swnd, hwnd, WM_STYLECHANGED, wParam, lParam);
+			}
+			break;
+
+		case WM_NCMOUSEMOVE:
+		{
+			static LPARAM lastpos = -1;
+
+			//TRACE("WM_NCMOUSEMOVE %d\n", count++);
+
+			//The problem with NCMOUSEMOVE is that it is sent continuously
+			//even when the mouse is stationary (under win2000 / win98)
+			//
+			//Tooltips don't like being sent a continous stream of mouse-moves
+			//if the cursor isn't moving, because they will think that the mouse
+			//is moving position, and the internal timer will never expire
+			//
+			if (lastpos != lParam)
+			{
+				lastpos = lParam;
+			}
+		}
+
+		return NCMouseMove(swnd, hwnd, wParam, lParam);
+
+
+		case WM_SETCURSOR:
+			return CoolSB_SetCursor(swnd, hwnd, wParam, lParam);
+
+		case WM_CAPTURECHANGED:
+			break;
+
+		case WM_ERASEBKGND:
+			if (swnd && !swnd->fThumbTracking && uCurrentScrollPortion == HTSCROLL_NONE)
+			{
+				//disable windows scrollbar painting (fixes gfx repainting weirdness)
+				int style = GetWindowLong(hwnd, GWL_STYLE);
+				if (style&(WS_HSCROLL | WS_VSCROLL))
+				{
+					SetWindowLong(hwnd, GWL_STYLE, style&~(WS_HSCROLL | WS_VSCROLL));
+				}
+
+				LRESULT ret = (swnd->fWndUnicode) ? CallWindowProcW(swnd->oldproc, hwnd, message, wParam, lParam) : 
+													CallWindowProcA(swnd->oldproc, hwnd, message, wParam, lParam);
+				swnd->update();
+				return ret;
+			}
+			break;
+
+			//needed if we want mousewheel to work properly because we disable the styles in WM_ERASEBKGND...
+		case WM_MOUSEWHEEL:
+		{
+			int style = GetWindowLong(hwnd, GWL_STYLE);
+			swnd->bPreventStyleChange = TRUE;
+			SetWindowLong(hwnd, GWL_STYLE, style | (swnd->sbarHorz.fScrollVisible ? WS_HSCROLL : 0) | (swnd->sbarVert.fScrollVisible ? WS_VSCROLL : 0));
+			LRESULT ret = (swnd->fWndUnicode) ? CallWindowProcW(swnd->oldproc, hwnd, message, wParam, lParam) : 
+													CallWindowProcA(swnd->oldproc, hwnd, message, wParam, lParam);
+			SetWindowLongPtr(hwnd, GWL_STYLE, style);
+			swnd->bPreventStyleChange = FALSE;
+			return ret;
+		}
+
+		case WM_USER + 0x3443: //manually sent by other windows (like columns header for ex.)
+			if (swnd) swnd->update();
+			break;
+
+		default:
+			break;
+	}
+	return (swnd->fWndUnicode) ? CallWindowProcW(swnd->oldproc, hwnd, message, wParam, lParam) : 
+						CallWindowProcA(swnd->oldproc, hwnd, message, wParam, lParam);
+}
+
+SCROLLBAR *GetScrollBarFromHwnd(HWND hwnd, UINT nBar)
+{
+	ScrollWnd *sw = GetScrollWndFromHwnd(hwnd);
+
+	if (!sw) return 0;
+
+	if (nBar == SB_HORZ)
+		return &sw->sbarHorz;
+	else if (nBar == SB_VERT)
+		return &sw->sbarVert;
+	else
+		return 0;
+}
+
+//
+//	return the default minimum size of a scrollbar thumb
+//
+int WINAPI CoolSB_GetDefaultMinThumbSize(void)
+{
+	DWORD dwVersion = GetVersion();
+
+	// set the minimum thumb size for a scrollbar. This
+	// differs between NT4 and 2000, so need to check to see
+	// which platform we are running under
+	if (dwVersion < 0x80000000)             // Windows NT/2000
+	{
+		if (LOBYTE(LOWORD(dwVersion)) >= 5)
+			return MINTHUMBSIZE_2000;
+		else
+			return MINTHUMBSIZE_NT4;
+	}
+	else
+	{
+		return MINTHUMBSIZE_NT4;
+	}
+}
+
+//
+//	Set the minimum size, in pixels, that the thumb box will shrink to.
+//
+BOOL WINAPI CoolSB_SetMinThumbSize(HWND hwnd, UINT wBar, UINT size)
+{
+	SCROLLBAR *sbar;
+
+	if (!GetScrollWndFromHwnd(hwnd))
+		return FALSE;
+
+	if (size == -1)
+		size = CoolSB_GetDefaultMinThumbSize();
+
+	if ((wBar == SB_HORZ || wBar == SB_BOTH) &&
+	    (sbar = GetScrollBarFromHwnd(hwnd, SB_HORZ)))
+	{
+		sbar->nMinThumbSize = size;
+	}
+
+	if ((wBar == SB_VERT || wBar == SB_BOTH) &&
+	    (sbar = GetScrollBarFromHwnd(hwnd, SB_VERT)))
+	{
+		sbar->nMinThumbSize = size;
+	}
+
+	return TRUE;
+}
+
+static void RedrawNonClient(HWND hwnd, BOOL fFrameChanged)
+{
+	if (fFrameChanged == FALSE)
+	{
+		SendMessage(hwnd, WM_NCPAINT, (WPARAM)1, 0);
+	}
+	else
+	{
+		SetWindowPos(hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE
+		             | SWP_FRAMECHANGED | SWP_DRAWFRAME);
+	}
+}
+
+ScrollWnd::ScrollWnd(HWND hwnd, int flags)
+{
+	SCROLLINFO *si;
+	RECT rect;
+	DWORD dwCurStyle;
+
+	bars = 0;
+	oldproc = NULL;
+	memset(&sbarHorz, 0, sizeof(sbarHorz));
+	memset(&sbarVert, 0, sizeof(sbarVert));
+	sbarHorz.flags = flags;
+	sbarVert.flags = flags;
+	fThumbTracking = 0;
+	fLeftScrollbar = 0;
+	cxLeftEdge = cxRightEdge = cyTopEdge = cyBottomEdge = 0;
+	bPreventStyleChange = 0;
+	m_disable_hscroll = 0;
+	m_xp_theme_disabled = 0;
+
+	m_hwnd = hwnd;
+
+	GetClientRect(hwnd, &rect);
+
+	si = &sbarHorz.scrollInfo;
+	si->cbSize = sizeof(SCROLLINFO);
+	si->fMask  = SIF_ALL;
+	GetScrollInfo(hwnd, SB_HORZ, si);
+
+	si = &sbarVert.scrollInfo;
+	si->cbSize = sizeof(SCROLLINFO);
+	si->fMask  = SIF_ALL;
+	GetScrollInfo(hwnd, SB_VERT, si);
+
+	//check to see if the window has left-aligned scrollbars
+	if (GetWindowLong(hwnd, GWL_EXSTYLE) & WS_EX_LEFTSCROLLBAR)
+		fLeftScrollbar = TRUE;
+	else
+		fLeftScrollbar = FALSE;
+
+	dwCurStyle = GetWindowLong(hwnd, GWL_STYLE);
+
+	SetProp(hwnd, szPropStr, (HANDLE)this);
+
+	//scrollbars will automatically get enabled, even if
+	//they aren't to start with....sorry, but there isn't an
+	//easy alternative.
+	if (dwCurStyle & WS_HSCROLL)
+		sbarHorz.fScrollFlags = CSBS_VISIBLE;
+
+	if (dwCurStyle & WS_VSCROLL)
+		sbarVert.fScrollFlags = CSBS_VISIBLE;
+
+	//need to be able to distinguish between horizontal and vertical
+	//scrollbars in some instances
+	sbarHorz.nBarType	     = SB_HORZ;
+	sbarVert.nBarType	     = SB_VERT;
+
+	sbarHorz.fFlatScrollbar  = CSBS_NORMAL;
+	sbarVert.fFlatScrollbar  = CSBS_NORMAL;
+
+	//set the default arrow sizes for the scrollbars
+	sbarHorz.nArrowLength	 = SYSTEM_METRIC;
+	sbarHorz.nArrowWidth	 = SYSTEM_METRIC;
+	sbarVert.nArrowLength	 = SYSTEM_METRIC;
+	sbarVert.nArrowWidth	 = SYSTEM_METRIC;
+
+	bPreventStyleChange		 = FALSE;
+
+	fWndUnicode = IsWindowUnicode(hwnd);
+	oldproc = (WNDPROC)(LONG_PTR) ((fWndUnicode) ? SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONGX86)(LONG_PTR)CoolSBWndProc) :
+														SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONGX86)(LONG_PTR)CoolSBWndProc));
+	
+	CoolSB_SetMinThumbSize(hwnd, SB_BOTH, CoolSB_GetDefaultMinThumbSize());
+
+	//send the window a frame changed message to update the scrollbars
+	RedrawNonClient(hwnd, TRUE);
+
+	//disable XP styles
+	if (SetWindowTheme && !m_xp_theme_disabled)
+	{
+		SetWindowTheme(m_hwnd, L" ", L" ");
+		m_xp_theme_disabled = 1;
+
+	}
+
+}
+
+BOOL WINAPI CoolSB_ShowScrollBar(HWND hwnd, int wBar, BOOL fShow)
+{
+	SCROLLBAR *sbar;
+	BOOL bFailed = FALSE;
+	DWORD dwStyle = GetWindowLong(hwnd, GWL_STYLE);
+
+	if ((wBar == SB_HORZ || wBar == SB_BOTH) &&
+	    (sbar = GetScrollBarFromHwnd(hwnd, SB_HORZ)))
+	{
+		sbar->fScrollFlags  =  sbar->fScrollFlags & ~CSBS_VISIBLE;
+		sbar->fScrollFlags |= (fShow == TRUE ? CSBS_VISIBLE : 0);
+		//bFailed = TRUE;
+
+		if (fShow)	SetWindowLong(hwnd, GWL_STYLE, dwStyle | WS_HSCROLL);
+		else		SetWindowLong(hwnd, GWL_STYLE, dwStyle & ~WS_HSCROLL);
+	}
+
+	if ((wBar == SB_VERT || wBar == SB_BOTH) &&
+	    (sbar = GetScrollBarFromHwnd(hwnd, SB_VERT)))
+	{
+		sbar->fScrollFlags  =  sbar->fScrollFlags & ~CSBS_VISIBLE;
+		sbar->fScrollFlags |= (fShow == TRUE ? CSBS_VISIBLE : 0);
+		//bFailed = TRUE;
+
+		if (fShow)	SetWindowLong(hwnd, GWL_STYLE, dwStyle | WS_VSCROLL);
+		else		SetWindowLong(hwnd, GWL_STYLE, dwStyle & ~WS_VSCROLL);
+	}
+
+	if (bFailed)
+	{
+		return FALSE;
+	}
+	else
+	{
+		SetWindowPos(hwnd, 0, 0, 0, 0, 0,
+		             SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
+		             SWP_NOACTIVATE | SWP_FRAMECHANGED);
+
+		return TRUE;
+	}
+}
+
+ScrollWnd::~ScrollWnd()
+{
+	if (oldproc)
+	{
+		((fWndUnicode) ? SetWindowLongPtrW(m_hwnd, GWLP_WNDPROC, (LONGX86)(LONG_PTR)oldproc) :
+														SetWindowLongPtrA(m_hwnd, GWLP_WNDPROC, (LONGX86)(LONG_PTR)oldproc));
+	}
+	RemoveProp(m_hwnd, szPropStr);
+	RedrawNonClient(m_hwnd, TRUE);
+}
+
+void ScrollWnd::update()
+{
+	int dohorz = 0, dovert = 0;
+
+	SCROLLINFO tsi = {sizeof(SCROLLINFO), SIF_ALL, };
+
+	if (!m_disable_hscroll)
+	{
+		GetScrollInfo(m_hwnd, SB_HORZ, &tsi);
+		if (memcmp(&tsi, &sbarHorz.scrollInfo, sizeof(SCROLLINFO)))
+		{
+			memcpy(&sbarHorz.scrollInfo, &tsi, sizeof(SCROLLINFO));
+			dohorz = 1;
+		}
+	}
+	GetScrollInfo(m_hwnd, SB_VERT, &tsi);
+	if (memcmp(&tsi, &sbarVert.scrollInfo, sizeof(SCROLLINFO)))
+	{
+		memcpy(&sbarVert.scrollInfo, &tsi, sizeof(SCROLLINFO));
+		dovert = 1;
+	}
+
+	BOOL fRecalcFrame = FALSE;
+	if (dohorz) updatesb(SB_HORZ, &fRecalcFrame);
+	if (dovert) updatesb(SB_VERT, &fRecalcFrame);
+
+	if (dohorz || dovert) RedrawNonClient(m_hwnd, fRecalcFrame);
+}
+
+void ScrollWnd::updatesb(int fnBar, BOOL *fRecalcFrame)
+{
+	SCROLLBAR *sbar = (fnBar == SB_HORZ ? &sbarHorz : &sbarVert);
+	SCROLLINFO *mysi = &sbar->scrollInfo;
+
+	if (mysi->nPage > (UINT)mysi->nMax
+	    || (mysi->nPage == (UINT)mysi->nMax && mysi->nMax == 0)
+	    || mysi->nMax  <= mysi->nMin)
+	{
+		if (sbar->fScrollVisible)
+		{
+			CoolSB_ShowScrollBar(m_hwnd, fnBar, FALSE);
+			*fRecalcFrame = TRUE;
+		}
+	}
+	else
+	{
+		if (!sbar->fScrollVisible && mysi->nPage > 0)
+		{
+			CoolSB_ShowScrollBar(m_hwnd, fnBar, TRUE);
+			*fRecalcFrame = TRUE;
+		}
+		else if (sbar->fScrollVisible && mysi->nPage == 0)
+		{
+			CoolSB_ShowScrollBar(m_hwnd, fnBar, FALSE);
+			*fRecalcFrame = TRUE;
+		}
+	}
+}
+
+void ScrollWnd::disableHorzScroll()
+{
+	m_disable_hscroll = 1;
+	sbarHorz.fScrollFlags = 0;
+}
+
+#if 0 // unused
+int ScrollWnd::setScrollInfo(int fnBar, LPSCROLLINFO lpsi, BOOL fRedraw)
+{
+	SCROLLINFO *mysi;
+	SCROLLBAR *sbar;
+	BOOL       fRecalcFrame = FALSE;
+
+	if (!lpsi)
+		return FALSE;
+
+	if (fnBar == SB_HORZ) mysi = &sbarHorz.scrollInfo;
+	else mysi = &sbarVert.scrollInfo;
+
+	if (lpsi->fMask & SIF_RANGE)
+	{
+		mysi->nMin = lpsi->nMin;
+		mysi->nMax = lpsi->nMax;
+	}
+
+	//The nPage member must specify a value from 0 to nMax - nMin +1.
+	if (lpsi->fMask & SIF_PAGE)
+	{
+		UINT t = (UINT)(mysi->nMax - mysi->nMin + 1);
+		mysi->nPage = min(max(0, lpsi->nPage), t);
+	}
+
+	//The nPos member must specify a value between nMin and nMax - max(nPage - 1, 0).
+	if (lpsi->fMask & SIF_POS)
+	{
+		mysi->nPos = max(lpsi->nPos, mysi->nMin);
+		mysi->nPos = min((UINT)mysi->nPos, mysi->nMax - max(mysi->nPage - 1, 0));
+	}
+
+	sbar = GetScrollBarFromHwnd(m_hwnd, fnBar);
+
+	if ((lpsi->fMask & SIF_DISABLENOSCROLL) || (sbar->fScrollFlags & CSBS_THUMBALWAYS))
+	{
+		if (!sbar->fScrollVisible)
+		{
+			CoolSB_ShowScrollBar(m_hwnd, fnBar, TRUE);
+			fRecalcFrame = TRUE;
+		}
+	}
+	else
+	{
+		if (mysi->nPage > (UINT)mysi->nMax
+		    || mysi->nPage == (UINT)mysi->nMax && mysi->nMax == 0
+		    || mysi->nMax  <= mysi->nMin)
+		{
+			if (sbar->fScrollVisible)
+			{
+				CoolSB_ShowScrollBar(m_hwnd, fnBar, FALSE);
+				fRecalcFrame = TRUE;
+			}
+		}
+		else
+		{
+			if (!sbar->fScrollVisible)
+			{
+				CoolSB_ShowScrollBar(m_hwnd, fnBar, TRUE);
+				fRecalcFrame = TRUE;
+			}
+		}
+	}
+
+	if (fRedraw && !fThumbTracking)
+		RedrawNonClient(m_hwnd, fRecalcFrame);
+
+	return mysi->nPos;
+}
+#endif
\ No newline at end of file