Initial community commit

1 files changed, 3285 insertions, 0 deletions

diff --git a/Src/Plugins/General/gen_ml/skinnedscrollwnd.cpp b/Src/Plugins/General/gen_ml/skinnedscrollwnd.cpp
new file mode 100644
index 00000000..64a409b9
--- /dev/null
+++ b/Src/Plugins/General/gen_ml/skinnedscrollwnd.cpp
@@ -0,0 +1,3285 @@
+// some code taken from (freeware) Cool ScrollBar library by J Brown
+#include "./skinnedscrollwnd.h"
+#include "main.h"
+#include <commctrl.h>
+#include <windowsx.h>
+#include "../winamp/wa_dlg.h"
+#include "api__gen_ml.h"
+#include "./colors.h"
+#include <tataki/bitmap/bitmap.h>
+#include <tataki/bitmap/autobitmap.h>
+#include <tataki/canvas/canvas.h>
+#include <api/wnd/api_window.h>
+#include "./stockobjects.h"
+
+
+/* minimum size of scrollbar before inserted buttons are hidden to make room when the window is sized too small */
+#define MIN_COOLSB_SIZE  24
+/* min size of scrollbar when resizing a button, before the  resize is stopped because the scrollbar has gotten too small */
+#define MINSCROLLSIZE   50
+/* a normal scrollbar "snaps" its scroll-thumb back into position if
+   you move the mouse too far away from the window, whilst you are
+   dragging the thumb, that is. #undeffing this results in the thumb
+   never snapping back into position, no matter how far away you move
+   the mouse */
+#define SNAP_THUMB_BACK
+/* distance (in pixels) the mouse must move away from the thumb
+   during tracking to cause the thumb bar to snap back to its
+   starting place. Has no effect unless SNAP_THUMB_BACK is defined */
+#define THUMBTRACK_SNAPDIST 128
+// To complement the exisiting SB_HORZ, SB_VERT, SB_BOTH
+// scrollbar identifiers
+#define COOLSB_NONE (-1)
+#define SB_INSBUT	(-2)
+
+//	Arrow size defines
+#define SYSTEM_METRIC (-1)
+
+
+// general scrollbar styles
+//
+// use the standard ESB_DISABLE_xxx flags to represent the
+// enabled / disabled states. (defined in winuser.h)
+//
+#define CSBS_THUMBALWAYS			0x0004
+#define CSBS_VISIBLE			0x0008
+#define CSBS_TRACKING			0x0010
+#define CSBS_FLATSB				0x0020
+#define CSBS_BTNVISBEFORE		0x0040	//if the buttons to the left are visible
+#define CSBS_BTNVISAFTER		0x0080	//if the buttons to the right are visible
+#define CSBS_HOVERING       0x0100	//if the buttons to the right are visible
+
+//cool scrollbar styles for Flat scrollbars
+#define CSBS_NORMAL			0
+#define CSBS_FLAT			1
+#define CSBS_HOTTRACKED		2
+
+
+//	Button mask flags for indicating which members of SCROLLBUT
+//	to use during a button insertion / modification
+#define SBBF_TYPE			0x0001
+#define SBBF_ID				0x0002
+#define SBBF_PLACEMENT		0x0004
+#define SBBF_SIZE			0x0008
+#define SBBF_BITMAP			0x0010
+#define SBBF_ENHMETAFILE	0x0020
+//#define SBBF_OWNERDRAW		0x0040	//unused at present
+#define SBBF_CURSOR			0x0080
+#define SBBF_BUTMINMAX		0x0100
+#define SBBF_STATE			0x0200
+
+//button styles (states)
+#define SBBS_NORMAL			0
+#define SBBS_PUSHED			1
+#define SBBS_CHECKED		SBBS_PUSHED
+
+// scrollbar button types
+#define SBBT_PUSHBUTTON		1	//standard push button
+#define SBBT_TOGGLEBUTTON	2	//toggle button
+#define SBBT_FIXED			3	//fixed button (non-clickable)
+#define SBBT_FLAT			4	//blank area (flat, with border)
+#define SBBT_BLANK			5	//blank area (flat, no border)
+#define SBBT_DARK			6	//dark blank area (flat)
+#define SBBT_OWNERDRAW		7	//user draws the button via a WM_NOTIFY
+
+#define SBBT_MASK			0x1f	//mask off low 5 bits
+
+//button type modifiers
+#define SBBM_RECESSED		0x0020	//recessed when clicked (like Word 97)
+#define SBBM_LEFTARROW		0x0040
+#define SBBM_RIGHTARROW		0x0080
+#define SBBM_UPARROW			0x0100
+#define SBBM_DOWNARROW		0x0200
+#define SBBM_RESIZABLE		0x0400
+#define SBBM_TYPE2			0x0800
+#define SBBM_TYPE3			0x1000
+#define SBBM_TOOLTIPS		0x2000	//currently unused (define COOLSB_TOOLTIPS in userdefs.h)
+
+//button placement flags
+#define SBBP_LEFT	1
+#define SBBP_RIGHT  2
+#define SBBP_TOP	1	//3
+#define SBBP_BOTTOM 2	//4
+
+#define DFCS_HOVER 0x800
+//
+//	Button command notification codes
+//	for sending with a WM_COMMAND message
+//
+#define CSBN_BASE	0
+#define CSBN_CLICKED (1 + CSBN_BASE)
+#define CSBN_HILIGHT (2 + CSBN_BASE)
+
+//	Minimum size in pixels of a scrollbar thumb
+#define MINTHUMBSIZE_NT4   9
+#define MINTHUMBSIZE_2000  7
+
+//define some more hittest values for our cool-scrollbar
+#define HTSCROLL_LEFT		(SB_LINELEFT)
+#define HTSCROLL_RIGHT		(SB_LINERIGHT)
+#define HTSCROLL_UP			(SB_LINEUP)
+#define HTSCROLL_DOWN		(SB_LINEDOWN)
+#define HTSCROLL_THUMB		(SB_THUMBTRACK)
+#define HTSCROLL_PAGEGUP	(SB_PAGEUP)
+#define HTSCROLL_PAGEGDOWN	(SB_PAGEDOWN)
+#define HTSCROLL_PAGELEFT	(SB_PAGELEFT)
+#define HTSCROLL_PAGERIGHT	(SB_PAGERIGHT)
+
+#define HTSCROLL_NONE		(-1)
+#define HTSCROLL_NORMAL		(-1)
+
+#define HTSCROLL_INSERTED	(128)
+#define HTSCROLL_PRE		(32 | HTSCROLL_INSERTED)
+#define HTSCROLL_POST		(64 | HTSCROLL_INSERTED)
+
+//	SCROLLBAR datatype. There are two of these structures per window
+typedef struct _SCROLLBAR
+{
+	UINT		fScrollFlags;		//flags
+	BOOL		fScrollVisible;		//if this scrollbar visible?
+	SCROLLINFO	scrollInfo;			//positional data (range, position, page size etc)
+
+	//data for inserted buttons
+	int			nButSizeBefore;		//size to the left / above the bar
+	int			nButSizeAfter;		//size to the right / below the bar
+
+	int			nMinThumbSize;
+	int			nBarType;			//SB_HORZ / SB_VERT
+
+} SCROLLBAR;
+
+static WORD wCheckPat[8] =
+{
+	0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555
+};
+
+
+// scrollwnd styles
+#define SWS_UPDATEFRAME			0x0001
+#define SWS_LEFT					0x0002
+#define SWS_DISABLENOSCROLL		0x0004
+#define SWS_HIDEHSCROLL			0x0008
+#define SWS_LISTVIEW				0x0010
+#define SWS_TREEVIEW				0x0020
+#define SWS_HIDEVSCROLL			0x0040
+#define SWS_COMBOLBOX			0x0080
+#define SWS_USEFREEFORM			0x0100
+
+//
+//	PRIVATE INTERNAL FUNCTIONS
+//
+#define COOLSB_TIMERID1			65533		//initial timer
+#define COOLSB_TIMERID2			65534		//scroll message timer
+#define COOLSB_TIMERID3			-14			//mouse hover timer
+#define COOLSB_TIMERINTERVAL1	300
+#define COOLSB_TIMERINTERVAL2	55
+#define COOLSB_TIMERINTERVAL3	20			//mouse hover time
+
+//
+//	direction: 0 - same axis as scrollbar (i.e.  width of a horizontal bar)
+//             1 - perpendicular dimesion (i.e. height of a horizontal bar)
+//
+#define SM_CXVERTSB 1
+#define SM_CYVERTSB 0
+#define SM_CXHORZSB 0
+#define SM_CYHORZSB 1
+#define SM_SCROLL_WIDTH	1
+#define SM_SCROLL_LENGTH 0
+
+#ifndef WM_MOUSEWHEEL
+#define WM_MOUSEWHEEL                   0x020A
+#endif
+
+
+#define INACTIVEBAR_ALPHA			127
+
+//
+//	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
+static int 	trackThumbPos;
+//
+//	Temporary state used to auto-generate timer messages
+//
+static UINT uScrollTimerMsg = 0;
+static UINT uScrollTimerPortion = HTSCROLL_NONE;
+static UINT_PTR uScrollTimerId = 0;
+static HWND hwndCurCoolSB = 0;
+
+static INT bUseUpdateRgn = -1;
+static BOOL bDoHover=FALSE;
+static BOOL ignoreCaptureChange = FALSE;
+static BOOL captureSet = FALSE;
+static HBRUSH hbrChecked = NULL;
+
+#define GetSBForeColor() WADlg_getColor(WADLG_SCROLLBAR_FGCOLOR)
+#define GetSBBackColor() WADlg_getColor(WADLG_SCROLLBAR_BGCOLOR)
+
+//	Send a WM_VSCROLL or WM_HSCROLL message
+#define SendScrollMessage(__hwnd, __srcMsg, __srcId, __pos) ::SendMessageW(__hwnd, __srcMsg, (MAKEWPARAM(__srcId, __pos)), 0)
+
+static UINT GetPortion(SCROLLBAR *sb, HWND hwnd, RECT *rect, int x, int y, DWORD scrollFlags);
+
+static void RenderBaseTexture(Canvas *canvas, const RECT *r, HWND hwnd)
+{
+	// TODO: find the ifc_window * object for the media library container, and call renderBaseTexture on it
+	if (WASABI_API_WND)
+	{
+		HWND checkWnd = GetParent(hwnd);
+		while (checkWnd)
+		{
+			ifc_window *window = WASABI_API_WND->rootWndFromOSHandle(checkWnd);
+			if (window && window->getRenderBaseTexture())
+			{
+				window->renderBaseTexture(canvas, r);
+				return;
+			}
+			checkWnd = GetParent(checkWnd);
+		}
+	}
+
+	// fallback code
+	COLORREF bgcolor =  WADlg_getColor(WADLG_WNDBG/*WADLG_SCROLLBAR_BGCOLOR*/);
+	canvas->fillRect(r, bgcolor);
+}
+
+//	swap the rectangle's x coords with its y coords
+static void __stdcall RotateRect(RECT *rect)
+{
+	LONG 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
+#define RotateRect0(__psb, __prc) ((__psb && __psb->nBarType == SB_VERT) ? RotateRect(__prc) : 0)
+
+static bool UseFreeformScrollbars()
+{
+	if (config_use_ff_scrollbars && WASABI_API_SKIN && WASABI_API_SKIN->skin_isLoaded())
+	{
+		return WASABI_API_SKIN->skin_getVersion() >= 1.3;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+//	Calculate if the SCROLLINFO members produce an enabled or disabled scrollbar
+static BOOL IsScrollInfoActive(SCROLLINFO *si)
+{
+	return (si->nPage <= (UINT)si->nMax && si->nMax > si->nMin && si->nMax != 0);
+}
+
+//	Return if the specified scrollbar is enabled or not
+static BOOL IsScrollbarActive(SCROLLBAR *sb)
+{
+	return (((sb->fScrollFlags & ESB_DISABLE_BOTH) == ESB_DISABLE_BOTH) ||
+	        !(sb->fScrollFlags & CSBS_THUMBALWAYS) && !IsScrollInfoActive(&sb->scrollInfo)) ? FALSE : TRUE;
+}
+
+enum
+{
+	HORIZ_LEFT,
+	HORIZ_LEFT_PRESSED,
+	HORIZ_LEFT_HOVER,
+	HORIZ_LEFT_INACTIVE,
+	HORIZ_RIGHT,
+	HORIZ_RIGHT_PRESSED,
+	HORIZ_RIGHT_HOVER,
+	HORIZ_RIGHT_INACTIVE,
+	VERT_UP,
+	VERT_UP_PRESSED,
+	VERT_UP_HOVER,
+	VERT_UP_INACTIVE,
+	VERT_DOWN,
+	VERT_DOWN_PRESSED,
+	VERT_DOWN_HOVER,
+	VERT_DOWN_INACTIVE,
+};
+
+static int GetBitmapEnum(UINT state, BOOL hover)
+{
+	int offset=0;
+	if (state&DFCS_PUSHED)
+		offset=1;
+	if (state&DFCS_INACTIVE)
+		offset=3;
+	else if (hover)
+		offset=2;
+
+	switch (state&3)
+	{
+	case DFCS_SCROLLRIGHT:
+		return HORIZ_RIGHT+offset;
+	case DFCS_SCROLLLEFT:
+		return HORIZ_LEFT+offset;
+	case DFCS_SCROLLDOWN:
+		return VERT_DOWN+offset;
+	default://case DFCS_SCROLLUP:
+		return VERT_UP+offset;
+	}
+}
+
+class ScrollBitmaps
+{
+public:
+	ScrollBitmaps() : v_up(L"wasabi.scrollbar.vertical.background.top"),
+					  v_down(L"wasabi.scrollbar.vertical.background.bottom"),
+					  v_mid(L"wasabi.scrollbar.vertical.background.middle"),
+					  h_left(L"wasabi.scrollbar.horizontal.background.left"),
+					  h_mid(L"wasabi.scrollbar.horizontal.background.middle"),
+					  h_right(L"wasabi.scrollbar.horizontal.background.right")
+	{
+	}
+	AutoSkinBitmap v_up, v_down, v_mid, h_left, h_mid, h_right;
+};
+
+static ScrollBitmaps *scrollBitmaps=0;
+
+void SkinnedScrollWnd_Init()
+{
+	scrollBitmaps = new ScrollBitmaps();
+}
+
+void SkinnedScrollWnd_Quit()
+{
+	if (scrollBitmaps)
+	{
+		delete scrollBitmaps;
+		scrollBitmaps=0;
+	}
+}
+
+static HBITMAP hbmpCachedDib = NULL;
+
+//	Paint a checkered rectangle, with each alternate pixel being assigned a different colour
+
+static BOOL DrawFrameCtrl(HDC hdc, LPRECT lprc, UINT uType, UINT state, BOOL hover, BOOL freeform)
+{
+	int startx, starty, alpha = 255;
+
+	const wchar_t *bitmapid=0;
+	const wchar_t *backgroundid=0;
+	SkinBitmap *bg=0;
+	switch (GetBitmapEnum(state, hover))
+	{
+	case HORIZ_LEFT:
+		bitmapid = L"wasabi.scrollbar.horizontal.left";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->h_left.getBitmap();
+		startx = 0; starty = 45; break;
+	case HORIZ_LEFT_PRESSED:
+		bitmapid = L"wasabi.scrollbar.horizontal.left.pressed";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->h_left.getBitmap();
+		startx = 28; starty = 45; break;
+	case HORIZ_LEFT_HOVER:
+		bitmapid = L"wasabi.scrollbar.horizontal.left.hover";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->h_left.getBitmap();
+		startx = 0; starty = 45; break;
+	case HORIZ_LEFT_INACTIVE:
+		alpha = INACTIVEBAR_ALPHA;
+		bitmapid = L"wasabi.scrollbar.horizontal.left";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->h_left.getBitmap();
+		startx = 0; starty = 45; break;
+	case HORIZ_RIGHT:
+		bitmapid = L"wasabi.scrollbar.horizontal.right";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->h_right.getBitmap();
+		startx = 14; starty = 45; break;
+	case HORIZ_RIGHT_PRESSED:
+		bitmapid = L"wasabi.scrollbar.horizontal.right.pressed";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->h_right.getBitmap();
+		startx = 42; starty = 45; break;
+	case HORIZ_RIGHT_HOVER:
+		bitmapid = L"wasabi.scrollbar.horizontal.right.hover";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->h_right.getBitmap();
+		startx = 14; starty = 45; break;
+	case HORIZ_RIGHT_INACTIVE:
+		alpha = INACTIVEBAR_ALPHA;
+		bitmapid = L"wasabi.scrollbar.horizontal.right";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->h_right.getBitmap();
+		startx = 14; starty = 45; break;
+	case VERT_UP:
+		bitmapid = L"wasabi.scrollbar.vertical.left";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->v_up.getBitmap();
+		startx = 0;	starty = 31;	break;
+	case VERT_UP_PRESSED:
+		bitmapid = L"wasabi.scrollbar.vertical.left.pressed";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->v_up.getBitmap();
+		startx = 28;	starty = 31;	break;
+	case VERT_UP_HOVER:
+		bitmapid = L"wasabi.scrollbar.vertical.left.hover";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->v_up.getBitmap();
+		startx = 0;	starty = 31;	break;
+	case VERT_UP_INACTIVE:
+		alpha = INACTIVEBAR_ALPHA;
+		bitmapid = L"wasabi.scrollbar.vertical.left";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->v_up.getBitmap();
+		startx = 0;	starty = 31;	break;
+
+	case VERT_DOWN:
+		bitmapid = L"wasabi.scrollbar.vertical.right";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->v_down.getBitmap();
+		startx = 14; starty = 31; break;
+	case VERT_DOWN_PRESSED:
+		bitmapid = L"wasabi.scrollbar.vertical.right.pressed";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->v_down.getBitmap();
+		startx = 42; starty = 31; break;
+	case VERT_DOWN_HOVER:
+		bitmapid = L"wasabi.scrollbar.vertical.right.hover";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->v_down.getBitmap();
+		startx = 14; starty = 31; break;
+	case VERT_DOWN_INACTIVE:
+		alpha = INACTIVEBAR_ALPHA;
+		bitmapid = L"wasabi.scrollbar.vertical.right";
+		if (scrollBitmaps)
+		bg=scrollBitmaps->v_down.getBitmap();
+		startx = 14; starty = 31; break;
+	}
+
+	if (freeform)
+	{
+		SkinBitmap bmp(bitmapid);
+		if (!bmp.isInvalid() && bg && !bg->isInvalid())
+		{
+			DCCanvas canvas(hdc);
+			bg->stretchToRectAlpha(&canvas, lprc, alpha);
+			bmp.stretchToRectAlpha(&canvas, lprc, alpha);
+			return 1;
+		}
+	}
+
+	// fallback code
+	HDC hdcbmp;
+	HBITMAP hbmpOld, hbmp;
+
+	hbmp = WADlg_getBitmap();
+	if (!hbmp) return FALSE;
+
+	hdcbmp = (HDC)MlStockObjects_Get(CACHED_DC);
+	if (!hdcbmp) return FALSE;
+
+	hbmpOld = (HBITMAP)SelectObject(hdcbmp, hbmp);
+
+
+	
+	if (255 == alpha) 
+		StretchBlt(hdc, lprc->left, lprc->top, lprc->right - lprc->left, lprc->bottom - lprc->top, hdcbmp, startx, starty, 14, 14, SRCCOPY);
+	else
+	{	
+		HDC hdcTmp = CreateCompatibleDC(hdc);
+
+		DIBSECTION dibSection;
+		if (NULL == hbmpCachedDib || 
+			sizeof(DIBSECTION) != GetObjectW(hbmpCachedDib, sizeof(DIBSECTION), &dibSection)
+			|| dibSection.dsBm.bmWidth < (lprc->right - lprc->left) || ABS(dibSection.dsBm.bmHeight) < (lprc->bottom - lprc->top))
+		{
+			if (hbmpCachedDib) DeleteObject(hbmpCachedDib);
+
+			BITMAPINFOHEADER bi;
+			ZeroMemory(&bi, sizeof(BITMAPINFOHEADER));
+			bi.biSize = sizeof(BITMAPINFOHEADER);
+			bi.biWidth = lprc->right - lprc->left;
+			bi.biHeight = -(lprc->bottom - lprc->top);
+			bi.biPlanes = 1;
+			bi.biBitCount = 32;
+			bi.biCompression = BI_RGB;
+			hbmpCachedDib = CreateDIBSection(hdc, (BITMAPINFO*)&bi, DIB_RGB_COLORS, (VOID**)&dibSection.dsBm.bmBits, NULL, 0);
+			dibSection.dsBm.bmHeight = bi.biHeight;
+			dibSection.dsBm.bmWidth = bi.biWidth;
+		}		
+		
+		ASSERT(hbmpCachedDib != 0);
+
+		HBITMAP hbmpTmp = (HBITMAP)SelectObject(hdcTmp, hbmpCachedDib);
+	
+		StretchBlt(hdcTmp, 0, 0, lprc->right - lprc->left, lprc->bottom - lprc->top, hdcbmp, startx, starty, 14, 14, SRCCOPY);
+			
+		LONG pitch = dibSection.dsBm.bmWidth*4, cy = lprc->bottom - lprc->top, x;
+		LPBYTE cursor, line;
+
+		COLORREF rgbBk = WADlg_getColor(WADLG_WNDBG);// BlendColors(GetSBBackColor(), WADlg_getColor(WADLG_ITEMBG), ((float)INACTIVEBAR_ALPHA)/255.0f);
+
+		BYTE k = (((255 - alpha)*255 + 127)/255);
+		BYTE r = (GetRValue(rgbBk)*k + 127)/255, g = (GetGValue(rgbBk)*k + 127)>>8, b = (GetBValue(rgbBk)*k + 127)/255;
+			
+		for (line = (BYTE*)dibSection.dsBm.bmBits; cy-- != 0; line += pitch )
+		{	
+			for (x = (lprc->right - lprc->left), cursor = line; x-- != 0; cursor += 4) 
+			{
+				cursor[0] = (cursor[0]*alpha)/255 + b;
+				cursor[1] = (cursor[1]*alpha)/255 + g;
+				cursor[2] = (cursor[2]*alpha)/255 + r;
+				cursor[3] = 0xFF;
+			}
+		}
+		
+		BitBlt(hdc, lprc->left, lprc->top, lprc->right - lprc->left, lprc->bottom - lprc->top, hdcTmp, 0, 0, SRCCOPY);
+		SelectObject(hdcTmp, hbmpTmp);
+		DeleteDC(hdcTmp);
+	}
+
+	SelectObject(hdcbmp, hbmpOld);
+
+	return 1;
+}
+
+//	Draw a standard scrollbar arrow
+static int DrawScrollArrow(SCROLLBAR *sbar, HDC hdc, RECT *rect, UINT arrow, BOOL fMouseDown, BOOL fMouseOver, BOOL freeform)
+{
+	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 = DrawFrameCtrl(hdc, rect, DFC_SCROLL, flags, fMouseOver, freeform);
+
+	return ret;
+}
+
+//	Return the size in pixels for the specified scrollbar metric, for the specified scrollbar
+static int GetScrollMetric(SCROLLBAR *psb, int metric, DWORD scrollFlags)
+{
+	int type (psb ? psb->nBarType : SB_VERT);
+	switch (type)
+	{
+		case SB_HORZ:
+		{
+			switch (metric)
+			{
+				case SM_CXHORZSB:
+					if (SWS_USEFREEFORM & scrollFlags)
+					{
+						SkinBitmap button(L"wasabi.scrollbar.horizontal.left"); // we assume symmetry which isn't necessary safe
+						if (!button.isInvalid())
+							return WASABI_API_APP->getScaleX(button.getWidth());
+					}
+					return WASABI_API_APP->getScaleX(14); // classic skin fixes this at 14
+				default:
+					if (SWS_USEFREEFORM & scrollFlags)
+					{
+						SkinBitmap button(L"wasabi.scrollbar.horizontal.left"); // we assume symmetry which isn't necessary safe
+						if (!button.isInvalid())
+							return WASABI_API_APP->getScaleY(button.getHeight());
+					}
+					return WASABI_API_APP->getScaleY(14); // classic skin fixes this at 14
+					break;
+			}
+		}
+		break;
+
+		default: // case SB_VERT:
+		{
+			switch (metric)
+			{
+				case SM_CYVERTSB:
+					if (SWS_USEFREEFORM & scrollFlags)
+					{
+						SkinBitmap button(L"wasabi.scrollbar.vertical.left"); // we assume symmetry which isn't necessary safe
+						if (!button.isInvalid())
+							return WASABI_API_APP->getScaleY(button.getHeight());
+					}
+					return WASABI_API_APP->getScaleY(14); // classic skin fixes this at 14
+				default:
+					if (SWS_USEFREEFORM & scrollFlags)
+					{
+						SkinBitmap button(L"wasabi.scrollbar.vertical.left"); // we assume symmetry which isn't necessary safe
+						if (!button.isInvalid())
+							return WASABI_API_APP->getScaleX(button.getWidth());
+					}
+					return WASABI_API_APP->getScaleX(14); // classic skin fixes this at 14
+					break;
+			}
+		}
+		break;
+	}
+
+	/*
+		if ((SB_HORZ == psb->nBarType && metric == SM_CXHORZSB) || (SB_VERT == psb->nBarType && metric == SM_CYVERTSB))
+			return (psb->nArrowLength == SYSTEM_METRIC) * ((psb->nArrowLength < 0) ? -14 : 1);
+		else return psb->nArrowWidth * ((psb->nArrowWidth < 0) ? -14 : 1);
+		*/
+}
+
+//	Fill the specifed rectangle using a solid colour
+static void PaintRect(HDC hdc, RECT *rect, COLORREF color)
+{
+	COLORREF oldcol = SetBkColor(hdc, color);
+	ExtTextOutW(hdc, 0, 0, ETO_OPAQUE, rect, L"", 0, 0);
+	SetBkColor(hdc, oldcol);
+}
+
+//
+//	Set the minimum size, in pixels, that the thumb box will shrink to.
+//
+
+//	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
+static void DrawBlankButton(HDC hdc, const RECT *rect, UINT drawflag, int pushed, int vertical)
+{
+	HBITMAP hbmp, hbmpOld;
+	hbmp = WADlg_getBitmap();
+	if (!hbmp) return;
+
+	HDC hdcbmp = (HDC)MlStockObjects_Get(CACHED_DC);
+	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);
+}
+
+
+//	Calculate the screen coordinates of the area taken by
+//  the horizontal scrollbar. Take into account the size
+//  of the window borders
+static BOOL GetHScrollRect(SkinnedScrollWnd *pWnd, RECT *prc)
+{	
+	if (pWnd->psbHorz->fScrollVisible)
+	{
+		GetClientRect(pWnd->hwnd, prc);
+		MapWindowPoints(pWnd->hwnd, HWND_DESKTOP, (POINT*)prc, 2);
+		prc->top = prc->bottom;
+		prc->bottom += GetScrollMetric(pWnd->psbHorz, SM_CYHORZSB, pWnd->scrollFlags);
+	}
+	else SetRect(prc, 0, 0, 0, 0);
+	return TRUE;
+}
+
+//	Calculate the screen coordinates of the area taken by the
+//  vertical scrollbar
+static BOOL GetVScrollRect(SkinnedScrollWnd *pWnd, RECT *prc)
+{
+	if (pWnd->psbVert->fScrollVisible)
+	{
+		GetClientRect(pWnd->hwnd, prc);
+		MapWindowPoints(pWnd->hwnd, HWND_DESKTOP, (POINT*)prc, 2);
+		if (SWS_LEFT & pWnd->scrollFlags)
+		{
+			prc->right = prc->left;
+			prc->left -= GetScrollMetric(pWnd->psbVert, SM_CXVERTSB, pWnd->scrollFlags);
+		}
+		else 
+		{
+			prc->left = prc->right;
+			prc->right += GetScrollMetric(pWnd->psbVert, SM_CXVERTSB, pWnd->scrollFlags);
+		}
+	}
+	else SetRect(prc, 0, 0, 0, 0);
+
+	
+	return TRUE;
+}
+
+//	Depending on what type of scrollbar nBar refers to, call the
+//  appropriate Get?ScrollRect function
+//
+static BOOL GetScrollRect(SkinnedScrollWnd *pWnd, UINT nBar, RECT *prc)
+{
+	if (nBar == SB_HORZ) return GetHScrollRect(pWnd, prc);
+	else if (nBar == SB_VERT) return GetVScrollRect(pWnd, prc);
+	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, DWORD scrollFlags)
+{
+	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, scrollFlags);
+
+	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)
+	{
+		/*if (SWS_HIDEHSCROLL & scrollFlags)
+			thumbsize = MulDiv(si->nPage, workingsize, si->nMax);
+		else*/
+			thumbsize = MulDiv(si->nPage, workingsize, siMaxMin);
+
+		if (SWS_USEFREEFORM & scrollFlags)
+		{
+			SkinBitmap thumb((sbar->nBarType == SB_VERT)?L"wasabi.scrollbar.vertical.button":L"wasabi.scrollbar.horizontal.button");
+			if (!thumb.isInvalid())
+				thumbsize = (sbar->nBarType == SB_VERT)?thumb.getHeight():thumb.getWidth();
+		}
+
+		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 (SWS_HIDEHSCROLL & scrollFlags)
+		{
+			thumbpos = (si->nPos == (si->nMax - si->nPage)) ? 
+					(workingsize - thumbsize) : MulDiv(si->nPos, workingsize, si->nMax);
+		}*/
+
+		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, DWORD scrollFlags)
+{
+	int thumbwidth, thumbpos;
+	int butwidth = GetScrollMetric(sbar, SM_SCROLL_LENGTH, scrollFlags);
+	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, scrollFlags);
+
+	//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 (ESB_DISABLE_LEFT & sbar->fScrollFlags) ? HTSCROLL_NONE : HTSCROLL_LEFT;
+	}
+	//check for right button click
+	else if (x >= rect->right - butwidth && x < rect->right)
+	{
+		return (ESB_DISABLE_RIGHT & sbar->fScrollFlags) ? HTSCROLL_NONE : 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, DWORD scrollFlags)
+{
+	UINT r;
+
+	RotateRect(rect);
+	r = GetHorzScrollPortion(sb, hwnd, rect, y, x, scrollFlags);
+	RotateRect(rect);
+	return r;
+}
+
+static const wchar_t *GetThumbID(UINT barType, UINT scrollFlags, BOOL hover)
+{
+	if (barType == SB_VERT)
+	{
+		if (scrollFlags & CSBS_TRACKING)
+			return L"wasabi.scrollbar.vertical.button.pressed";
+		else if (hover)
+			return L"wasabi.scrollbar.vertical.button.hover";
+		else
+			return L"wasabi.scrollbar.vertical.button";
+	}
+	else
+	{
+		if (scrollFlags & CSBS_TRACKING)
+			return L"wasabi.scrollbar.horizontal.button.pressed";
+		else if (hover)
+			return L"wasabi.scrollbar.horizontal.button.hover";
+		else
+			return L"wasabi.scrollbar.horizontal.button";
+	}
+}
+
+static HBRUSH SetWindowPatternBrush(HWND hwnd, HDC hdc, UINT nBarType)
+{
+	RECT rw;
+	GetWindowRect(hwnd, &rw);
+	HWND hwndAncestor = GetAncestor(hwnd, GA_ROOT);
+	if (hwndAncestor) MapWindowPoints(HWND_DESKTOP, hwndAncestor, (POINT*)&rw, 2);
+	POINT ptOrg;
+	if (GetViewportOrgEx(hdc, &ptOrg)) OffsetRect(&rw, ptOrg.x, ptOrg.y);
+	if (nBarType == SB_VERT)
+	{
+		if (0 == (GetWindowLongPtrW(hwnd, GWL_EXSTYLE) & WS_EX_LEFTSCROLLBAR)) rw.left = rw.right;
+	}
+	else rw.top = rw.bottom;
+
+	SetBrushOrgEx(hdc, rw.left, rw.top, (POINT*)&rw);
+	return (HBRUSH)SelectObject(hdc, hbrChecked);
+}
+
+//
+//	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, UINT hoverFlags, DWORD scrollFlags)
+{
+	SCROLLINFO *si;
+	RECT ctrl, thumb;
+	RECT sbm;
+	int butwidth	 = GetScrollMetric(sb, SM_SCROLL_LENGTH, scrollFlags);
+	int scrollwidth  = rect->right - rect->left;
+	int workingwidth = scrollwidth - butwidth * 2;
+	int thumbwidth   = 0, thumbpos = 0;
+	int siMaxMin;
+
+	BOOL fMouseDownL = 0, fMouseOverL = (hoverFlags == HTSCROLL_LEFT);
+	BOOL fMouseDownR = 0, fMouseOverR = (hoverFlags == HTSCROLL_RIGHT);
+	BOOL fMouseOverThumb = (hoverFlags == HTSCROLL_THUMB);
+
+	COLORREF crCheck1   = GetSBForeColor();
+	COLORREF crCheck2   = GetSBBackColor();
+	COLORREF crInverse1 = WADlg_getColor(WADLG_SCROLLBAR_INV_FGCOLOR);
+	COLORREF crInverse2 = WADlg_getColor(WADLG_SCROLLBAR_INV_BGCOLOR);
+
+	UINT uDFCFlat = (CSBS_FLATSB & sb->fScrollFlags) ? DFCS_FLAT : 0;
+	UINT uDEFlat  = (CSBS_FLATSB & sb->fScrollFlags) ? 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;
+	siMaxMin = si->nMax - si->nMin;
+
+	if (hwnd != hwndCurCoolSB)
+		uDrawFlags = HTSCROLL_NONE;
+	//
+	// work out the thumb size and position
+	//
+	CalcThumbSize(sb, rect, &thumbwidth, &thumbpos, scrollFlags);
+	if ((CSBS_TRACKING & sb->fScrollFlags) && trackThumbPos != -1)
+	{
+		thumbpos=trackThumbPos;
+	}
+
+	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 ((0 == (DFCS_INACTIVE & uLeftButFlags) || 0 == (DFCS_INACTIVE & uRightButFlags)) &&
+		!(sb->fScrollFlags & CSBS_THUMBALWAYS) && !IsScrollInfoActive(si))
+	{
+		uLeftButFlags  |= DFCS_INACTIVE;
+		uRightButFlags |= DFCS_INACTIVE;
+	}
+
+	if ((DFCS_INACTIVE & uLeftButFlags) &&  (DFCS_INACTIVE & uRightButFlags))
+	{
+		COLORREF rgbBk = WADlg_getColor(WADLG_WNDBG);
+		crCheck1 = BlendColors(crCheck1, rgbBk, INACTIVEBAR_ALPHA);
+		crCheck2 = BlendColors(crCheck2, rgbBk, INACTIVEBAR_ALPHA);
+	}
+
+	if (hwnd == hwndCurCoolSB)
+	{
+		fMouseDownL = (uDrawFlags == HTSCROLL_LEFT);
+		fMouseDownR = (uDrawFlags == HTSCROLL_RIGHT);
+	}
+
+	if (NULL == hbrChecked) //recreate pattern brush if needed
+	{
+		HBITMAP hbmp = CreateBitmap(8, 8, 1, 1, wCheckPat);
+		hbrChecked = CreatePatternBrush(hbmp);
+		DeleteObject(hbmp);
+		if (NULL == hbrChecked) return 0;
+	}
+
+	
+
+	HBRUSH  hbrOld = NULL;
+
+	COLORREF rgbFgOld, rgbBkOld;
+	rgbFgOld = SetTextColor(hdc, crCheck1);
+	rgbBkOld = SetBkColor(hdc, crCheck2);
+
+	//
+	// Draw the scrollbar now
+	//
+	if (scrollwidth > butwidth*2)
+	{
+		DCCanvas canvas(hdc);
+		if (SWS_USEFREEFORM & scrollFlags)
+		{
+			CopyRect(&ctrl, rect);
+			RotateRect0(sb, &ctrl);
+			RenderBaseTexture(&canvas, &ctrl, hwnd);
+		}
+			
+		//LEFT ARROW
+		SetRect(&ctrl, rect->left, rect->top, rect->left + butwidth, rect->bottom);
+
+		RotateRect0(sb, &ctrl);
+
+		DrawScrollArrow(sb, hdc, &ctrl, uLeftButFlags, fMouseDownL, fMouseOverL, (SWS_USEFREEFORM & scrollFlags));
+
+		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))
+		{
+			SkinBitmap *bg = (scrollBitmaps && (SWS_USEFREEFORM & scrollFlags)) ? 
+				((sb->nBarType== SB_VERT) ? scrollBitmaps->v_mid.getBitmap(): scrollBitmaps->h_mid.getBitmap())
+				: 0;
+
+			if ((SWS_USEFREEFORM & scrollFlags) && bg && !bg->isInvalid())
+			{
+				SetRect(&sbm, rect->left + butwidth, rect->top, rect->right-butwidth, rect->bottom);
+				RotateRect0(sb, &sbm);
+
+				bg->stretchToRectAlpha(&canvas, &sbm);
+
+				SkinBitmap thumbBitmap(GetThumbID(sb->nBarType, sb->fScrollFlags, fMouseOverThumb));
+				SetRect(&sbm, thumbpos, rect->top, thumbpos+thumbwidth, rect->bottom);
+				RotateRect0(sb, &sbm);
+				if (!thumbBitmap.isInvalid())
+					thumbBitmap.stretchToRectAlpha(&canvas, &sbm);
+				else
+					DrawBlankButton(hdc, &sbm, uDEFlat, (CSBS_TRACKING & sb->fScrollFlags), sb->nBarType == SB_VERT);
+			}
+			else
+			{
+				//Draw the scrollbar margin above the thumb
+				SetRect(&sbm, rect->left + butwidth, rect->top, thumbpos, rect->bottom);
+
+				RotateRect0(sb, &sbm);
+
+				if (HTSCROLL_PAGELEFT == uDrawFlags)
+				{
+					SetTextColor(hdc, crInverse1);
+					SetBkColor(hdc, crInverse2);
+				}
+				
+				if (GetTextColor(hdc) == GetBkColor(hdc)) ExtTextOutW(hdc, 0, 0, ETO_OPAQUE, &sbm, NULL, 0, NULL); 
+				else 
+				{
+					if (NULL == hbrOld) hbrOld = SetWindowPatternBrush(hwnd, hdc, sb->nBarType);
+					PatBlt(hdc, sbm.left, sbm.top, sbm.right - sbm.left, sbm.bottom - sbm.top, PATCOPY);
+				}
+				
+				if (HTSCROLL_PAGELEFT == uDrawFlags)
+				{
+					SetTextColor(hdc, crCheck1);
+					SetBkColor(hdc, crCheck2);
+				}
+
+				RotateRect0(sb, &sbm);
+
+				//Draw the margin below the thumb
+				sbm.left = thumbpos + thumbwidth;
+				sbm.right = rect->right - butwidth;
+
+				RotateRect0(sb, &sbm);
+				
+				if (HTSCROLL_PAGERIGHT == uDrawFlags)
+				{
+					SetTextColor(hdc, crInverse1);
+					SetBkColor(hdc, crInverse2);
+				}
+				
+				if (GetTextColor(hdc) == GetBkColor(hdc)) ExtTextOutW(hdc, 0, 0, ETO_OPAQUE, &sbm, NULL, 0, NULL); 
+				else 
+				{
+					if (NULL == hbrOld) hbrOld = SetWindowPatternBrush(hwnd, hdc, sb->nBarType);
+					PatBlt(hdc, sbm.left, sbm.top, sbm.right - sbm.left, sbm.bottom - sbm.top, PATCOPY);
+				}
+				
+				if (HTSCROLL_PAGERIGHT == uDrawFlags)
+				{
+					SetTextColor(hdc, crCheck1);
+					SetBkColor(hdc, crCheck2);
+				}
+
+				RotateRect0(sb, &sbm);
+
+				//Draw the THUMB finally
+				SetRect(&thumb, thumbpos, rect->top, thumbpos + thumbwidth, rect->bottom);
+
+				RotateRect0(sb, &thumb);
+
+				DrawBlankButton(hdc, &thumb, uDEFlat, (CSBS_TRACKING & sb->fScrollFlags), 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);
+
+				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);
+
+				PaintRect(hdc, &ctrl, GetSysColor(COLOR_SCROLLBAR));
+
+				RotateRect0(sb, &ctrl);
+			}
+			//otherwise, paint a blank if the thumb doesn't fit in
+			else
+			{
+				RotateRect0(sb, &ctrl);
+				BOOL classic(TRUE);
+				if (SWS_USEFREEFORM & scrollFlags)
+				{
+					SkinBitmap background(sb->nBarType== SB_VERT?L"wasabi.scrollbar.vertical.background.middle":L"wasabi.scrollbar.horizontal.background.middle");
+					if (!background.isInvalid()) 
+					{	
+						background.stretchToRectAlpha(&canvas, &ctrl,  
+									((DFCS_INACTIVE & uLeftButFlags) && (DFCS_INACTIVE & uRightButFlags)) ? INACTIVEBAR_ALPHA : 255);
+						classic = FALSE;
+					}
+				}
+
+				if (classic)
+				{
+					if (crCheck1 == crCheck2) ExtTextOutW(hdc, 0, 0, ETO_OPAQUE, &ctrl, NULL, 0, NULL); 
+					else 
+					{
+						if (NULL == hbrOld) hbrOld = SetWindowPatternBrush(hwnd, hdc, sb->nBarType);
+						PatBlt(hdc, ctrl.left, ctrl.top, ctrl.right - ctrl.left, ctrl.bottom - ctrl.top, PATCOPY);
+					}
+				}
+				
+
+				RotateRect0(sb, &ctrl);
+			}
+		}
+
+		//RIGHT ARROW
+		SetRect(&ctrl, rect->right - butwidth, rect->top, rect->right, rect->bottom);
+
+		RotateRect0(sb, &ctrl);
+
+		DrawScrollArrow(sb, hdc, &ctrl, uRightButFlags, fMouseDownR, fMouseOverR, (SWS_USEFREEFORM & scrollFlags));
+
+		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);
+		DrawScrollArrow(sb, hdc, &ctrl, uLeftButFlags, fMouseDownL, fMouseOverL, (SWS_USEFREEFORM & scrollFlags));
+		RotateRect0(sb, &ctrl);
+
+		//RIGHT ARROW
+		OffsetRect(&ctrl, scrollwidth - butwidth, 0);
+
+		RotateRect0(sb, &ctrl);
+		DrawScrollArrow(sb, hdc, &ctrl, uRightButFlags, fMouseDownR, fMouseOverR, (SWS_USEFREEFORM & scrollFlags));
+		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);
+			BOOL classic(TRUE);
+
+			if (SWS_USEFREEFORM & scrollFlags)
+			{
+				SkinBitmap background(sb->nBarType== SB_VERT?L"wasabi.scrollbar.vertical.background.middle":L"wasabi.scrollbar.horizontal.background.middle");
+				if (!background.isInvalid())
+				{
+					DCCanvas canvas(hdc);
+					RenderBaseTexture(&canvas, &ctrl, hwnd);
+					background.stretchToRectAlpha(&canvas, &ctrl, 
+							((DFCS_INACTIVE & uLeftButFlags) && (DFCS_INACTIVE & uRightButFlags)) ? INACTIVEBAR_ALPHA : 255);
+					classic = FALSE;
+				}
+			}
+
+			if (classic)
+			{
+				if (crCheck1 == crCheck2) ExtTextOutW(hdc, 0, 0, ETO_OPAQUE, &ctrl, NULL, 0, NULL); 
+				else 
+				{
+					if (NULL == hbrOld) hbrOld = SetWindowPatternBrush(hwnd, hdc, sb->nBarType);
+					PatBlt(hdc, ctrl.left, ctrl.top, ctrl.right - ctrl.left, ctrl.bottom - ctrl.top, PATCOPY);
+				}
+			}
+
+			RotateRect0(sb, &ctrl);
+		}
+
+	}
+
+	SetBkColor(hdc, rgbBkOld);
+	SetTextColor(hdc, rgbFgOld);
+	if (hbrOld)
+	{
+		SelectObject(hdc, hbrOld);
+		SetBrushOrgEx(hdc, 0, 0, NULL);
+	}
+	return 0;
+}
+
+//
+//	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, UINT hoverFlags, DWORD scrollFlags)
+{
+	LRESULT ret;
+	RECT rc;
+
+	rc = *rect;
+	RotateRect(&rc);
+	ret = NCDrawHScrollbar(sb, hwnd, hdc, &rc, uDrawFlags, hoverFlags, scrollFlags);
+	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, UINT hoverFlags, DWORD scrollFlags)
+{
+	if (sb->nBarType == SB_HORZ)
+		return NCDrawHScrollbar(sb, hwnd, hdc, rect, uDrawFlags, hoverFlags, scrollFlags);
+	else
+		return NCDrawVScrollbar(sb, hwnd, hdc, rect, uDrawFlags, hoverFlags, scrollFlags);
+}
+
+
+
+void SkinnedScrollWnd::PaintNonClient(HDC hdc)
+{
+	RECT winrect, rcH, rcV;
+	BOOL drawH = FALSE, drawV = FALSE;
+
+	if (!psbHorz->fScrollVisible && !psbVert->fScrollVisible)
+	{
+		DrawBorder(hdc);
+		return;
+	}
+	
+	if (0 == (SWS_UPDATEFRAME & scrollFlags))
+	{
+		HWND hwndActive;
+		hwndActive = GetActiveWindow();
+		if (hwndActive != hwnd && !IsChild(hwndActive, hwnd)) scrollFlags |= SWS_UPDATEFRAME;
+	}
+
+	GetWindowRect(hwnd, &winrect);
+
+
+	if (psbHorz->fScrollVisible)
+	{
+		GetHScrollRect(this, &rcH);
+		OffsetRect(&rcH, -winrect.left, -winrect.top);
+		if (rcH.right > rcH.left && rcH.bottom > rcH.top && RectVisible(hdc, &rcH)) drawH = TRUE;
+	}
+
+	if (psbVert->fScrollVisible)
+	{
+		GetVScrollRect(this, &rcV);
+		OffsetRect(&rcV, -winrect.left, -winrect.top);
+		
+		if (rcV.right > rcV.left && rcV.bottom > rcV.top && RectVisible(hdc, &rcV)) drawV = TRUE;
+	}
+	DrawBorder(hdc);
+	
+	POINT ptOrg;
+	GetViewportOrgEx(hdc, &ptOrg);
+
+	if (drawH)
+	{		
+        UINT fDraw, fHover;
+		if (uCurrentScrollbar == SB_HORZ) { fDraw = uScrollTimerPortion; fHover = HTSCROLL_NONE; }
+		else 
+		{ 
+			fDraw = HTSCROLL_NONE; 
+			fHover = (NULL != psbHorz && 0 != (CSBS_HOVERING & psbHorz->fScrollFlags)) ? scrollPortionHover : HTSCROLL_NONE;
+		}
+
+		if (SWS_USEFREEFORM & scrollFlags)
+		{
+			DCBltCanvas buffer;
+			buffer.cloneDC(hdc, &rcH);
+			NCDrawHScrollbar(psbHorz, hwnd, buffer.getHDC(), &rcH, fDraw, fHover, scrollFlags);
+		}
+		else
+		{				
+			SetViewportOrgEx(hdc, ptOrg.x + rcH.left, ptOrg.y + rcH.top, NULL);	
+			OffsetRect(&rcH, -rcH.left, -rcH.top);
+			NCDrawHScrollbar(psbHorz, hwnd, hdc, &rcH, fDraw, fHover, scrollFlags);
+			SetViewportOrgEx(hdc, ptOrg.x, ptOrg.y, NULL);
+		}
+	}
+
+	if (drawV)
+	{					
+		UINT fDraw, fHover;
+		if (uCurrentScrollbar == SB_VERT) { fDraw = uScrollTimerPortion; fHover = HTSCROLL_NONE; }
+		else 
+		{ 
+			fDraw = HTSCROLL_NONE; 
+			fHover = (NULL != psbVert && 0 != (CSBS_HOVERING & psbVert->fScrollFlags)) ? scrollPortionHover : HTSCROLL_NONE; 
+		}
+
+		if (SWS_USEFREEFORM & scrollFlags)
+		{
+			DCBltCanvas buffer;
+			buffer.cloneDC(hdc, &rcV);
+			NCDrawVScrollbar(psbVert, hwnd, buffer.getHDC(), &rcV, fDraw, fHover, scrollFlags);
+			
+		}
+		else
+		{				
+			SetViewportOrgEx(hdc, ptOrg.x + rcV.left, ptOrg.y + rcV.top, NULL);	
+			OffsetRect(&rcV, -rcV.left, -rcV.top);
+			NCDrawVScrollbar(psbVert, hwnd, hdc, &rcV, fDraw, fHover, scrollFlags);
+			SetViewportOrgEx(hdc, ptOrg.x, ptOrg.y, NULL);
+		}
+		
+	}
+
+	SetViewportOrgEx(hdc, ptOrg.x, ptOrg.y, NULL);
+
+	// DRAW THE DEAD AREA
+	// only do this if the horizontal and vertical bars are visible
+	if (psbHorz->fScrollVisible && psbVert->fScrollVisible)
+	{
+		GetClientRect(hwnd, &rcH);
+		MapWindowPoints(hwnd, HWND_DESKTOP, (POINT*)&rcH, 2);
+		OffsetRect(&rcH, -winrect.left, -winrect.top);
+
+		rcH.top  = rcH.bottom;
+		rcH.bottom += GetScrollMetric(psbHorz, SM_CYHORZSB, scrollFlags);
+
+		if (SWS_LEFT & scrollFlags)
+		{
+			rcH.right = rcH.left;
+			rcH.left -= GetScrollMetric(psbVert, SM_CXVERTSB, scrollFlags);
+		}
+		else
+		{
+			rcH.left = rcH.right;
+			rcH.right += GetScrollMetric(psbVert, SM_CXVERTSB, scrollFlags);
+		}
+
+		if (RectVisible(hdc, &rcH))
+		{
+			
+			PaintRect(hdc, &rcH, WADlg_getColor(WADLG_SCROLLBAR_DEADAREA_COLOR));
+		}
+	}
+
+	
+}
+
+void SkinnedScrollWnd::OnNcPaint(HRGN rgnUpdate)
+{		
+	UINT flags = DCX_PARENTCLIP | DCX_CACHE | DCX_WINDOW | DCX_CLIPSIBLINGS |
+				DCX_INTERSECTUPDATE | DCX_VALIDATE;
+	
+	HDC hdc = GetDCEx(hwnd, ((HRGN)NULLREGION != rgnUpdate) ? rgnUpdate : NULL, flags);
+		
+
+	if (NULL == hdc) 
+	{
+		return;
+	}
+
+		
+	PaintNonClient(hdc);
+	
+	
+	ReleaseDC(hwnd, hdc);
+}
+
+//
+// Need to detect if we have clicked in the scrollbar region or not
+//
+INT SkinnedScrollWnd::OnNcHitTest(POINTS pts)
+{
+	RECT rc;
+	
+	INT r = __super::OnNcHitTest(pts);
+	if (r == HTTRANSPARENT) 
+	{		
+		
+		
+		return r;
+	}
+
+	if (psbHorz->fScrollVisible && GetHScrollRect(this, &rc) &&
+	    pts.x >= rc.left && pts.x <= rc.right && pts.y >= rc.top && pts.y <= rc.bottom) return HTHSCROLL;
+	if (psbVert->fScrollVisible && GetVScrollRect(this, &rc) &&
+	    pts.x >= rc.left && pts.x <= rc.right && pts.y >= rc.top && pts.y <= rc.bottom) return HTVSCROLL;
+
+	return r;
+}
+
+//
+//	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, DWORD scrollFlags)
+{
+	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, scrollFlags);
+}
+
+//
+//	Just call the horizontal version, with adjusted coordinates
+//
+static UINT GetVertPortion(SCROLLBAR *sb, HWND hwnd, RECT *rect, int x, int y, DWORD scrollFlags)
+{
+	UINT ret;
+	RotateRect(rect);
+	ret = GetHorzPortion(sb, hwnd, rect, y, x, scrollFlags);
+	RotateRect(rect);
+	return ret;
+}
+
+//
+//	Wrapper function for GetHorzPortion and GetVertPortion
+//
+static UINT GetPortion(SCROLLBAR *sb, HWND hwnd, RECT *rect, int x, int y, DWORD scrollFlags)
+{
+	if (sb->nBarType == SB_HORZ) return GetHorzPortion(sb, hwnd, rect, x, y, scrollFlags);
+	else if (sb->nBarType == SB_VERT) return GetVertPortion(sb, hwnd, rect, x, y, scrollFlags);
+	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 (CSBS_BTNVISBEFORE & sb->fScrollFlags) rect->left += sb->nButSizeBefore;
+	if (CSBS_BTNVISAFTER & sb->fScrollFlags)  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 (CSBS_BTNVISBEFORE & sb->fScrollFlags) rect->top += sb->nButSizeBefore;
+	if (CSBS_BTNVISAFTER & sb->fScrollFlags)  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, DWORD scrollFlags)
+{
+	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
+//
+void SkinnedScrollWnd::OnNcLButtonDown(UINT nHitTest, POINTS pts)
+{
+	RECT rect, winrect;
+	SCROLLBAR *psb;
+
+	hwndCurCoolSB = hwnd;
+
+	//
+	//	HORIZONTAL SCROLLBAR PROCESSING
+	//
+	if (HTHSCROLL == nHitTest)
+	{
+		psb = psbHorz;
+		uScrollTimerMsg = WM_HSCROLL;
+		uCurrentScrollbar = SB_HORZ;
+		//get the total area of the normal Horz scrollbar area
+		GetHScrollRect(this, &rect);
+		uCurrentScrollPortion = GetHorzPortion(psbHorz, hwnd, &rect, pts.x, pts.y, scrollFlags);
+	}
+	//
+	//	VERTICAL SCROLLBAR PROCESSING
+	//
+	else if (HTVSCROLL== nHitTest)
+	{
+		psb = psbVert;
+		uScrollTimerMsg = WM_VSCROLL;
+		uCurrentScrollbar = SB_VERT;
+		//get the total area of the normal Horz scrollbar area
+		GetVScrollRect(this, &rect);
+		uCurrentScrollPortion = GetVertPortion(psbVert, hwnd, &rect, pts.x, pts.y, scrollFlags);
+	}
+	//
+	//	NORMAL PROCESSING
+	//
+	else
+	{
+		uCurrentScrollPortion = HTSCROLL_NONE;
+		__super::WindowProc(WM_NCLBUTTONDOWN, (WPARAM)nHitTest, *(LPARAM*)&pts);
+		return;
+	}
+
+	//
+	// 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(psb)) return;
+
+		GetRealScrollRect(psb, &rect, scrollFlags);
+		RotateRect0(psb, &rect);
+		CalcThumbSize(psb, &rect, &nThumbSize, &nThumbPos, scrollFlags);
+		RotateRect0(psb, &rect);
+
+		//remember the bounding rectangle of the scrollbar work area
+		rcThumbBounds = rect;
+
+		trackThumbPos=-1;
+		psb->fScrollFlags |= CSBS_TRACKING;
+		psb->scrollInfo.nTrackPos = psb->scrollInfo.nPos;
+
+		if (nHitTest == HTVSCROLL) nThumbMouseOffset = pts.y - nThumbPos;
+		else nThumbMouseOffset = pts.x - nThumbPos;
+
+		nLastPos = psb->scrollInfo.nPos;
+		nThumbPos0 = nThumbPos;
+
+		SCROLLINFO info;
+		info.cbSize = sizeof(SCROLLINFO);
+		info.fMask = SIF_POS;
+		info.nPos = nLastPos;
+
+		SetScrollInfo(hwnd, psb->nBarType, &info, FALSE);
+
+		SendScrollMessage(hwnd, uScrollTimerMsg, SB_THUMBTRACK, nLastPos);
+		//if(sb->fFlatScrollbar)
+		//{
+		GetWindowRect(hwnd, &winrect);
+		OffsetRect(&rect, -winrect.left, -winrect.top);
+		InvalidateNC(InvalidateFlag_Normal, uCurrentScrollbar);
+		//}
+
+		break;
+
+		//Any part of the scrollbar
+	case HTSCROLL_LEFT:
+		if (psb->fScrollFlags & ESB_DISABLE_LEFT) return;
+		goto target1;
+
+	case HTSCROLL_RIGHT:
+		if (psb->fScrollFlags & ESB_DISABLE_RIGHT) return;
+		goto target1;
+
+
+	case HTSCROLL_PAGELEFT:
+	case HTSCROLL_PAGERIGHT:
+
+target1:
+
+		//if the scrollbar is disabled, then do no further processing
+		if (!IsScrollbarActive(psb))
+			break;
+
+		//ajust the horizontal rectangle to NOT include
+		//any inserted buttons
+		GetRealScrollRect(psb, &rect, scrollFlags);
+
+		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(psb, hwnd, &rect, pts.x, pts.y, scrollFlags);
+		else
+			uScrollTimerPortion = GetVertScrollPortion(psb, hwnd, &rect, pts.x, pts.y, scrollFlags);
+
+		GetWindowRect(hwnd, &winrect);
+		OffsetRect(&rect, -winrect.left, -winrect.top);
+
+
+		//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;
+
+		InvalidateNC(InvalidateFlag_Normal, uCurrentScrollbar);
+
+		//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);
+		UpdateScrollBars(FALSE);
+		break;
+	default:
+		__super::WindowProc(WM_NCLBUTTONDOWN, (WPARAM)nHitTest, *(LPARAM*)&pts);
+		return;
+
+	}
+
+	if ((0 == (SWS_COMBOLBOX & scrollFlags)) && hwnd != GetCapture()) 
+	{		
+		ignoreCaptureChange = TRUE;
+		SetCapture(hwnd);
+		ignoreCaptureChange = FALSE;
+		captureSet = TRUE;
+		
+	}
+}
+
+//
+//	Left button released
+//
+void SkinnedScrollWnd::Emulate_LeftButtonUp(UINT nFlags, POINTS pts, BOOL forwardMessage)
+{
+	//current scrollportion is the button that we clicked down on
+	if (uCurrentScrollPortion != HTSCROLL_NONE)
+	{
+		RECT rect;
+		//UINT thisportion;
+		POINT pt;
+		RECT winrect;
+
+		SCROLLBAR *psb;
+
+		if (captureSet && (0 == (SWS_COMBOLBOX & scrollFlags)) && hwnd == GetCapture()) 
+		{
+			ignoreCaptureChange = TRUE;
+			ReleaseCapture();
+			ignoreCaptureChange = FALSE;
+		}
+		captureSet = FALSE;
+
+		GetWindowRect(hwnd, &winrect);
+		POINTSTOPOINT(pt, pts);
+
+		//emulate the mouse input on a scrollbar here...
+		if (SB_VERT == uCurrentScrollbar)
+		{
+			//get the total area of the normal Horz scrollbar area
+			psb = psbVert;
+			GetVScrollRect(this, &rect);
+		}
+		else
+		{
+			//get the total area of the normal Horz scrollbar area
+			psb = psbHorz;
+			GetHScrollRect(this, &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:
+			UpdateScrollBars(FALSE);
+
+			//In case we were thumb tracking, make sure we stop NOW
+			if (CSBS_TRACKING & psb->fScrollFlags)
+			{
+				SCROLLINFO info;
+				info.cbSize = sizeof(SCROLLINFO);
+				info.fMask = SIF_POS;
+				info.nPos = nLastPos;
+
+				SetScrollInfo(hwnd, psb->nBarType, &info, FALSE);
+				SendScrollMessage(hwnd, uScrollTimerMsg, SB_THUMBPOSITION, nLastPos);
+				psb->fScrollFlags &= ~CSBS_TRACKING;
+			}
+
+			//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(psb, &rect, scrollFlags);
+			OffsetRect(&rect, -winrect.left, -winrect.top);
+			InvalidateNC(InvalidateFlag_Normal, uCurrentScrollbar);
+			break;
+		}
+
+		//reset our state to default
+		uCurrentScrollPortion = HTSCROLL_NONE;
+		uScrollTimerPortion	  = HTSCROLL_NONE;
+		uScrollTimerId		  = 0;
+
+		uScrollTimerMsg       = 0;
+		uCurrentScrollbar     = COOLSB_NONE;
+
+		return;
+	}
+	else
+	{
+	
+		/*
+		// Can't remember why I did this!
+		if(GetCapture() == hwnd)
+		{
+			ReleaseCapture();
+		}*/
+	}
+
+	//sw->update();
+
+	if (FALSE != forwardMessage)
+	{
+		__super::WindowProc(WM_LBUTTONUP, (WPARAM)nFlags, *(LPARAM*)&pts);
+	}
+}
+void SkinnedScrollWnd::OnLButtonUp(UINT nFlags, POINTS pts)
+{
+	Emulate_LeftButtonUp(nFlags, pts, TRUE);
+}
+
+static int
+ListView_ScrollWindow(HWND hwnd, int dy)
+{
+	RECT rect;
+
+	if (0 == dy)
+		return NULLREGION;
+	
+	if (FALSE == GetClientRect(hwnd, &rect))
+		return ERROR;
+	
+	if (0 == (LVS_NOCOLUMNHEADER & GetWindowLongPtrW(hwnd, GWL_STYLE)))
+	{
+		HWND headerWindow;
+		headerWindow = (HWND)SendMessageW(hwnd, LVM_GETHEADER, 0, 0L);
+		if (NULL != headerWindow && 
+			0 != (WS_VISIBLE & GetWindowLongPtrW(headerWindow, GWL_STYLE)))
+		{
+			HDLAYOUT headerLayout;
+			WINDOWPOS headerPos;
+
+			headerLayout.prc = &rect;
+			headerLayout.pwpos = &headerPos;
+			SendMessageW(headerWindow, HDM_LAYOUT, 0, (LPARAM)&headerLayout);
+		}
+	}
+
+	return ScrollWindowEx(hwnd, 0, dy, &rect, &rect, NULL, NULL, SW_INVALIDATE);
+}
+
+static BOOL ListView_ScrollReportModeVert(HWND hwnd, INT linesVert, BOOL horzBarHidden)
+{
+	int max, pos, page;
+	int itemHeight, prevPos, dy;
+	RECT rect;
+	unsigned long windowStyle;
+	
+	if (0 == linesVert)
+		return TRUE;
+	
+	windowStyle = GetWindowLongPtrW(hwnd, GWL_STYLE);
+
+	pos = (int)SendMessageW(hwnd, LVM_GETTOPINDEX, 0, 0L);
+	max = (int)SendMessageW(hwnd, LVM_GETITEMCOUNT, 0, 0L);
+	page = (int)SendMessageW(hwnd, LVM_GETCOUNTPERPAGE, 0, 0L);
+
+	if (FALSE == horzBarHidden)
+		max++;
+	
+	if ((linesVert < 0  && pos <= 0) ||
+	   (linesVert > 0 && (pos + page) >= max))
+	{
+		return TRUE;
+	}
+
+	if (linesVert < 0 && (pos + linesVert) < 0)
+		linesVert = -pos;
+	else if (linesVert > 0 && (pos + page + linesVert) > max)
+		linesVert = max - (page + pos);
+	
+	rect.left = LVIR_BOUNDS;
+	if (!SendMessageW(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect))
+		return FALSE;
+
+	if (rect.top < 0) 
+		OffsetRect(&rect, 0, -rect.top);
+
+    itemHeight = rect.bottom - rect.top;
+
+	if (0 != (WS_VISIBLE & windowStyle))
+		SetWindowLongPtrW(hwnd, GWL_STYLE, windowStyle & ~WS_VISIBLE);
+				
+	dy = linesVert * itemHeight;
+	SendMessageW(hwnd, LVM_SCROLL, 0, dy);
+				
+	if (0 == (WS_VISIBLE & windowStyle))
+		return TRUE;
+
+	SetWindowLongPtrW(hwnd, GWL_STYLE, windowStyle);
+
+	prevPos = pos;
+	pos = (int)SendMessageW(hwnd, LVM_GETTOPINDEX, 0, 0L);
+	linesVert = pos - prevPos;
+	
+	dy = linesVert * itemHeight;
+
+	if (ERROR == ListView_ScrollWindow(hwnd, -dy))
+		InvalidateRect(hwnd, NULL, FALSE);
+	
+	return TRUE;
+}
+
+static BOOL
+ListView_ScrollReportModeVertPx(HWND hwnd, int dy, BOOL horzBarHidden)
+{
+	int itemHeight, lines;
+	RECT rect;
+	unsigned long windowStyle;
+
+	if (0 == dy)
+		return TRUE;
+
+	windowStyle = GetWindowLongPtrW(hwnd, GWL_STYLE);
+
+	rect.left = LVIR_BOUNDS;
+	if (!SendMessageW(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rect))
+		return FALSE;
+
+	if (rect.top < 0) 
+		OffsetRect(&rect, 0, -rect.top);
+
+    itemHeight = rect.bottom - rect.top;
+
+
+	lines = dy / itemHeight;
+	if (0 != lines)
+	{
+		if (0 != (WS_VISIBLE & windowStyle))
+			SetWindowLongPtrW(hwnd, GWL_STYLE, windowStyle & ~WS_VISIBLE);
+
+		SendMessageW(hwnd, LVM_SCROLL, 0, lines);
+				
+		if (0 != (WS_VISIBLE & windowStyle))
+		{
+			windowStyle = GetWindowLongPtrW(hwnd, GWL_STYLE);
+			windowStyle |= WS_VISIBLE;
+			SetWindowLongPtrW(hwnd, GWL_STYLE, windowStyle);
+		}
+	}
+
+	if (0 != (WS_VISIBLE & windowStyle))
+	{		
+		if (ERROR == ListView_ScrollWindow(hwnd, -dy))
+			InvalidateRect(hwnd, NULL, FALSE);
+	}
+	
+	return TRUE;
+}
+
+//
+//	This function is called whenever the mouse is moved and
+//  we are dragging the scrollbar thumb about.
+//
+static void ThumbTrack(SCROLLBAR *sbar, HWND hwnd, POINTS pts, UINT scrollFlags)
+{
+	POINT pt;
+	RECT rc, winrect, rc2;
+	int thumbpos = nThumbPos;
+	//int thumbDelta;
+	int pos;
+	int siMaxMin = 0;
+	//UINT flatflag = (CSBS_FLATSB & sbar->fScrollFlags) ? BF_FLAT : 0;
+
+	SCROLLINFO *si;
+	si = &sbar->scrollInfo;
+
+	POINTSTOPOINT(pt, pts);
+	MapWindowPoints(hwnd, HWND_DESKTOP, &pt, 1);
+
+	if (SB_VERT == sbar->nBarType)
+	{
+		LONG t;
+		t= pt.x; pt.x = pt.y; pt.y = t;
+		RotateRect(&rcThumbBounds);
+	}
+
+	//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);
+
+	int cxH =  GetScrollMetric(sbar, SM_CXHORZSB, scrollFlags);
+
+	rc.left += cxH;
+	rc.right -= cxH;
+
+	//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;
+	}
+
+	GetClientRect(hwnd, &winrect);
+
+	MapWindowPoints(hwnd, HWND_DESKTOP, (POINT*)&winrect, 2);
+
+	RotateRect0(sbar, &winrect);
+
+	OffsetRect(&rc, -winrect.left, -winrect.top);
+	thumbpos -= winrect.left;
+
+	/*if (-1 == trackThumbPos)
+		thumbDelta = thumbpos - rc.left;
+	else
+		thumbDelta = thumbpos - trackThumbPos;*/
+
+	trackThumbPos = thumbpos;
+
+	//post a SB_TRACKPOS message!!!
+	siMaxMin = si->nMax - si->nMin;
+	pos = (siMaxMin > 0) ? MulDiv(thumbpos - rc.left, siMaxMin - si->nPage + 1, rc.right - rc.left - nThumbSize) : (thumbpos - rc.left);
+
+	if (si->nPage == 0)
+		pos = 0; // this supposed to protect from moving on empty scrollbar
+
+	if (pos != nLastPos)
+	{
+		if (SWS_LISTVIEW & scrollFlags) // list view specific
+		{
+			// 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 dx = pos - info.nTrackPos;
+					if (LVS_LIST == (LVS_TYPEMASK & GetWindowLongPtrW(hwnd, GWL_STYLE)))
+					{
+						INT cw = (INT)(INT_PTR)SendMessageW(hwnd, LVM_GETCOLUMNWIDTH, 0, 0L);
+						dx = dx * cw;
+					}
+					SendMessageW(hwnd, LVM_SCROLL, dx, 0);
+				}
+			}
+			else if (sbar->nBarType == SB_VERT)
+			{
+				SCROLLINFO info;
+				info.cbSize = sizeof(SCROLLINFO);
+				info.fMask = SIF_TRACKPOS;
+				if (GetScrollInfo(hwnd, SB_VERT, &info) && pos != info.nTrackPos)
+				{
+					INT dy = pos - info.nTrackPos;
+					if (LVS_REPORT == (LVS_TYPEMASK & GetWindowLongPtrW(hwnd, GWL_STYLE)))
+					{
+						ListView_ScrollReportModeVert(hwnd, dy, (0 != (SWS_HIDEHSCROLL & scrollFlags)));
+					}
+					else
+					{
+						SendMessageW(hwnd, LVM_SCROLL, 0, dy);
+					}
+				}
+			}
+		}
+		else if ((SWS_TREEVIEW & scrollFlags) && 
+				  SB_VERT == sbar->nBarType &&
+				  ABS(nLastPos - pos) < 2)
+		{
+			INT i, cmd;
+			i = nLastPos - pos;
+			cmd = (i < 0) ? SB_LINEDOWN : SB_LINEUP;
+			if (i < 0) i = -i;
+			while (i--) 
+			{
+				SendMessageW(hwnd, WM_VSCROLL, cmd, 0L);
+			}
+		}
+		else
+		{
+			si->nTrackPos = pos;
+			SCROLLINFO info;
+			info.cbSize = sizeof(SCROLLINFO);
+			info.fMask = SIF_TRACKPOS|SIF_POS;
+			info.nTrackPos = pos;
+			info.nPos = pos;
+
+			SetScrollInfo(hwnd, sbar->nBarType, &info, FALSE);
+			SendScrollMessage(hwnd, uScrollTimerMsg, SB_THUMBTRACK, pos);
+		}
+	}
+
+	nLastPos = pos;
+
+	if (SB_VERT == sbar->nBarType) RotateRect(&rcThumbBounds);
+}
+
+//
+//	remember to rotate the thumb bounds rectangle!!
+//
+
+//
+//	Called when we have set the capture from the NCLButtonDown(...)
+//
+void SkinnedScrollWnd::OnMouseMove(UINT nFlags, POINTS pts)
+{
+	RECT rect;
+	//static UINT lastbutton = 0;
+	RECT winrect;
+	//UINT buttonIdx = 0;
+	SCROLLBAR *psb;
+
+	if (nFlags)
+	{
+		if (MK_LBUTTON & nFlags)
+		{
+			UpdateScrollBars(TRUE);
+		}
+	}
+	psb = (uCurrentScrollbar == SB_VERT) ? psbVert : psbHorz;
+	if (CSBS_TRACKING & psb->fScrollFlags)
+	{
+		ThumbTrack(psb, hwnd, pts, scrollFlags);
+		InvalidateNC(InvalidateFlag_Normal, uCurrentScrollbar);
+		return;
+	}
+	if (uCurrentScrollPortion == HTSCROLL_NONE)
+	{
+		__super::WindowProc(WM_MOUSEMOVE, (WPARAM)nFlags, *(LPARAM*)&pts);
+		return;
+	}
+	else
+	{
+		static UINT lastportion = 0;
+		POINT pt;
+
+		POINTSTOPOINT(pt, pts);
+
+		MapWindowPoints(hwnd, HWND_DESKTOP, &pt, 1);
+
+		GetWindowRect(hwnd, &winrect);
+
+		//get the total area of the normal scrollbar area
+		GetScrollRect(this, psb->nBarType, &rect);
+
+		//see if we clicked in the inserted buttons / normal scrollbar
+		//thisportion = GetPortion(sb, hwnd, &rect, LOWORD(lParam), HIWORD(lParam));
+		UINT thisportion = GetPortion(psb, hwnd, &rect, pt.x, pt.y, scrollFlags);
+
+		//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_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(psb, &rect, scrollFlags);
+
+			OffsetRect(&rect, -winrect.left, -winrect.top);
+
+			if (thisportion != uCurrentScrollPortion)
+			{
+				uScrollTimerPortion = HTSCROLL_NONE;
+				if (lastportion != thisportion)
+				{
+					InvalidateNC(InvalidateFlag_Normal, uCurrentScrollbar);
+				}
+			}
+			//otherwise, draw the button in its depressed / clicked state
+			else
+			{
+				uScrollTimerPortion = uCurrentScrollPortion;
+				if (lastportion != thisportion)
+				{
+					InvalidateNC(InvalidateFlag_Normal, uCurrentScrollbar);
+				}
+			}
+			break;
+		}
+
+		lastportion = thisportion;
+		//lastbutton  = buttonIdx;
+
+		//must return zero here, because we might get cursor anomilies
+		//CallWindowProc(sw->oldproc, hwnd, WM_MOUSEMOVE, wParam, lParam);
+
+		return;
+	}
+}
+
+//
+//	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
+//
+INT SkinnedScrollWnd::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS *pncsp)
+{
+	RECT *prc;
+	INT hcy, vcx, result;
+	BOOL bSizingDown;
+	prc = &pncsp->rgrc[0];
+	UINT updateBars = -1;
+	
+	hcy = GetScrollMetric(psbHorz, SM_CYHORZSB, scrollFlags);
+	vcx = GetScrollMetric(psbVert, SM_CXVERTSB, scrollFlags);
+
+
+	if (SWS_UPDATEFRAME & scrollFlags)
+	{
+		// need to reset style
+		DWORD style;
+
+		scrollFlags &= ~SWS_UPDATEFRAME;
+		style = (DWORD)GetWindowLongPtrW(hwnd, GWL_STYLE);
+		if ((WS_HSCROLL | WS_VSCROLL) & style) SetWindowLongPtrW(hwnd, GWL_STYLE, style & ~(WS_HSCROLL | WS_VSCROLL));
+		CallDefWndProc(WM_NCCALCSIZE, (WPARAM)bCalcValidRects, (LPARAM)pncsp);
+		if ((WS_HSCROLL | WS_VSCROLL) & style) SetWindowLongPtrW(hwnd, GWL_STYLE, style);
+	}
+
+	result = __super::OnNcCalcSize(bCalcValidRects, pncsp);
+	bSizingDown = (bCalcValidRects && 
+	               ((pncsp->rgrc[0].right - pncsp->rgrc[0].left) < (pncsp->rgrc[1].right - pncsp->rgrc[1].left) ||
+	                (pncsp->rgrc[0].bottom - pncsp->rgrc[0].top) < (pncsp->rgrc[1].bottom - pncsp->rgrc[1].top)));
+
+
+	//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 ((psbHorz->fScrollFlags & CSBS_VISIBLE) && (prc->bottom - prc->top)
+#ifdef COOLSB_FILLWINDOW
+	    >=
+#else
+	    >
+#endif
+	    hcy)
+	{
+		prc->bottom -= hcy;
+		if (TRUE != psbHorz->fScrollVisible)
+		{
+			psbHorz->fScrollVisible = TRUE;
+			updateBars = SB_HORZ;
+		}
+	}
+	else
+	{
+		if (FALSE != psbHorz->fScrollVisible)
+		{
+			psbHorz->fScrollVisible = FALSE; 
+			updateBars = SB_HORZ;
+		}
+	}
+
+	//if there is room, allocate some space for the vertical scrollbar
+	if ((psbVert->fScrollFlags & CSBS_VISIBLE) && (prc->right - prc->left) >= vcx)
+	{
+		if (SWS_LEFT & scrollFlags) 	prc->left += vcx;
+		else prc->right -= vcx;
+		if (TRUE != psbVert->fScrollVisible)
+		{
+			psbVert->fScrollVisible = TRUE;
+			updateBars = (SB_HORZ == updateBars) ? SB_BOTH : SB_VERT;
+		}
+
+	}
+	else
+	{
+		if (FALSE != psbVert->fScrollVisible)
+		{
+			psbVert->fScrollVisible = FALSE; 
+			updateBars = (SB_HORZ == updateBars) ? SB_BOTH : SB_VERT;
+		}
+	}
+
+	if (-1 != updateBars)
+	{		
+		if (SWS_COMBOLBOX & scrollFlags)
+		{
+			InvalidateNC(InvalidateFlag_RedrawNow, updateBars);
+		}
+		else if (bSizingDown) 
+		{
+			PostMessageW(hwnd, WM_ML_IPC, TRUE, IPC_ML_SKINNEDSCROLLWND_UPDATEBARS);
+		}
+			
+	}
+
+	return result;
+}
+
+void SkinnedScrollWnd::OnNcMouseLeave()
+{
+	if (HTSCROLL_NONE != scrollPortionHover)
+	{
+		scrollPortionHover=HTSCROLL_NONE;
+		InvalidateNC(InvalidateFlag_Normal, SB_BOTH);
+	}
+}
+//
+//	used for hot-tracking over the scroll buttons
+//
+void SkinnedScrollWnd::OnNcMouseMove(UINT nHitTest, POINTS pts)
+{
+	if (!bDoHover)
+	{
+		__super::WindowProc(WM_NCMOUSEMOVE, nHitTest, *(LPARAM*)&pts);
+		return;
+	}
+	SCROLLBAR *psb=0;
+	UINT scrollbar=0;
+	RECT rect;	
+	
+	if (psbHorz) psbHorz->fScrollFlags &= ~CSBS_HOVERING;
+	if (psbVert) psbVert->fScrollFlags &= ~CSBS_HOVERING;
+	if (HTHSCROLL == nHitTest)
+	{
+		psb = psbHorz;
+		scrollbar = SB_HORZ;
+		//get the total area of the normal Horz scrollbar area
+		GetHScrollRect(this, &rect);
+	}
+	//
+	//	VERTICAL SCROLLBAR PROCESSING
+	//
+	else if (HTVSCROLL== nHitTest)
+	{
+		psb = psbVert;
+		scrollbar = SB_VERT;
+		//get the total area of the normal Horz scrollbar area
+		GetVScrollRect(this, &rect);
+	}
+	//
+	//	NORMAL PROCESSING
+	//
+	else
+	{
+
+		scrollPortionHover=HTSCROLL_NONE;
+		__super::WindowProc(WM_NCMOUSEMOVE, nHitTest, *(LPARAM*)&pts);
+
+		return;
+	}
+
+	if (NULL != psb)
+	{
+		psb->fScrollFlags |= CSBS_HOVERING;
+		UINT thisportion = GetPortion(psb, hwnd, &rect, pts.x, pts.y, scrollFlags);
+		if (thisportion != scrollPortionHover)
+		{
+			TRACKMOUSEEVENT tracker;
+			tracker.cbSize = sizeof(tracker);
+			tracker.hwndTrack = hwnd;
+			tracker.dwHoverTime=0;
+			tracker.dwFlags = TME_LEAVE |TME_NONCLIENT; // benski> TME_NONCLIENT doesn't work on NT4.0, and we can work around it anyway
+			if (TrackMouseEvent(&tracker))
+			{
+				scrollPortionHover=thisportion;
+				InvalidateNC(InvalidateFlag_Normal, scrollbar);
+			}
+		}
+	}
+
+	__super::WindowProc(WM_NCMOUSEMOVE, nHitTest, *(LPARAM*)&pts);
+}
+
+//
+//	Timer routine to generate scrollbar messages
+//
+void SkinnedScrollWnd::OnTimer(UINT_PTR idEvent, TIMERPROC fnTimer)
+{
+	//let all timer messages go past if we don't have a timer installed ourselves
+	if (uScrollTimerId != 0)
+	{
+		//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 (idEvent == COOLSB_TIMERID1)
+		{
+			KillTimer(hwnd, uScrollTimerId);
+			uScrollTimerId = SetTimer(hwnd, COOLSB_TIMERID2, COOLSB_TIMERINTERVAL2, 0);
+			return;
+		}
+		//send the scrollbar message repeatedly
+		else if (idEvent == 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);
+			MapWindowPoints(HWND_DESKTOP, hwnd, &pt, 1);
+			pt.x = POINTTOPOINTS(pt);
+			OnMouseMove(MK_LBUTTON, MAKEPOINTS(pt.x));
+			if (uScrollTimerPortion != HTSCROLL_NONE) SendScrollMessage(hwnd, uScrollTimerMsg, uScrollTimerPortion, 0);
+			UpdateScrollBars(TRUE);
+			return;
+		}
+	}
+	__super::WindowProc(WM_TIMER, (WPARAM)idEvent, (LPARAM)fnTimer);
+}
+
+//
+//	We must intercept any calls to SetWindowLong, to check if
+//  left-scrollbars are taking effect or not
+//
+
+static UINT curTool = -1;
+
+static LRESULT SendToolTipMessage0(HWND hwndTT, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	return SendMessageW(hwndTT, message, wParam, lParam);
+}
+
+#ifdef COOLSB_TOOLTIPS
+#define SendToolTipMessage		SendToolTipMessage0
+#else
+#define SendToolTipMessage		1 ? (void)0 : SendToolTipMessage0
+#endif
+
+void SkinnedScrollWnd::OnStyleChanged(INT styleType, STYLESTRUCT *pss)
+{
+	if (styleType == GWL_EXSTYLE) scrollFlags = (scrollFlags & ~SWS_LEFT) | ((WS_EX_LEFTSCROLLBAR & pss->styleNew) ? SWS_LEFT : 0);
+	__super::OnStyleChanged(styleType, pss);
+}
+
+LRESULT SkinnedScrollWnd::OnEraseBackground(HDC hdc)
+{
+	if (0 == (CSBS_TRACKING & psbVert->fScrollFlags) && 0 == (CSBS_TRACKING & psbHorz->fScrollFlags) && uCurrentScrollPortion == HTSCROLL_NONE)
+	{
+		LRESULT result;
+		result =  __super::WindowProc(WM_ERASEBKGND, (WPARAM)hdc, 0L);
+		UpdateScrollBars(TRUE);
+		return result;
+	}
+	return __super::WindowProc(WM_ERASEBKGND, (WPARAM)hdc, 0L);
+}
+
+
+void SkinnedScrollWnd::OnPrint(HDC hdc, UINT options)
+{
+	if ((PRF_NONCLIENT & options) &&
+			(0 == (PRF_CHECKVISIBLE & options) || IsWindowVisible(hwnd))) 
+	{
+		PaintNonClient(hdc);
+		if (PRF_CLIENT & options) 
+			CallPrevWndProc(WM_PRINT, (WPARAM)hdc, (LPARAM)(~(PRF_NONCLIENT | PRF_CHECKVISIBLE) & options));
+	}
+	else __super::OnPrint(hdc, options);
+}
+
+LRESULT SkinnedScrollWnd::OnListViewScroll(INT dx, INT dy)
+{
+	if (0 != dy && 
+		0 != (SWS_LISTVIEW & scrollFlags) &&
+		0 != (SWS_HIDEHSCROLL & scrollFlags) &&
+		(psbHorz->scrollInfo.nPage <= (UINT)psbHorz->scrollInfo.nMax))
+	{
+		DWORD windowStyle = GetWindowLongPtr(hwnd, GWL_STYLE);
+		if (LVS_REPORT == (LVS_TYPEMASK & windowStyle))
+		{
+			SCROLLINFO scrollInfo;
+			scrollInfo.cbSize = sizeof(SCROLLINFO);
+			scrollInfo.fMask = SIF_RANGE | SIF_POS | SIF_PAGE;
+			if (GetScrollInfo(hwnd, SB_VERT, &scrollInfo))
+			{			
+				if (0 == dy ||
+					(scrollInfo.nPos == scrollInfo.nMin && dy < 0) || 
+					(scrollInfo.nPos >= (scrollInfo.nMax - (INT)scrollInfo.nPage) && dy > 0))
+					return TRUE;
+				
+				RECT rc;
+				rc.left = LVIR_BOUNDS;
+				if (SendMessageW(hwnd, LVM_GETITEMRECT, 0, (LPARAM)&rc))
+				{
+					dy = dy / (rc.bottom - rc.top);
+					if (dy < 0)
+					{
+						if ((scrollInfo.nPos - dy) < scrollInfo.nMin)
+							dy = scrollInfo.nMin - scrollInfo.nPos;
+					}
+					else if (dy > 0)
+					{
+						if ((scrollInfo.nPos + dy) >= (scrollInfo.nMax - (INT)scrollInfo.nPage))
+							dy = scrollInfo.nMax - (INT)scrollInfo.nPage - scrollInfo.nPos;
+					}
+					
+					dy = dy * (rc.bottom - rc.top);
+
+					if (0 == dy)
+						return TRUE;
+				}
+			}
+		}
+	}
+
+	LRESULT result = __super::WindowProc(LVM_SCROLL, (WPARAM)dx, (LPARAM)dy);
+	if (result) UpdateScrollBars(TRUE);
+	return result;
+}
+
+void SkinnedScrollWnd::OnVertScroll(UINT code, UINT pos, HWND hwndSB)
+{
+	if (0 != (SWS_LISTVIEW & scrollFlags) &&
+		0 != (SWS_HIDEHSCROLL & scrollFlags) &&
+		(psbHorz->scrollInfo.nPage <= (UINT)psbHorz->scrollInfo.nMax))
+	{
+		DWORD windowStyle = GetWindowLongPtr(hwnd, GWL_STYLE);
+		if (LVS_REPORT == (LVS_TYPEMASK & windowStyle))
+		{
+			SCROLLINFO scrollInfo;
+			scrollInfo.cbSize = sizeof(SCROLLINFO);
+
+			switch(code)
+			{
+				case SB_LINEDOWN:
+					scrollInfo.fMask = SIF_RANGE | SIF_POS | SIF_PAGE;
+					if (GetScrollInfo(hwnd, SB_VERT, &scrollInfo) 
+						&& scrollInfo.nPos >= (scrollInfo.nMax - (INT)scrollInfo.nPage))
+						return;
+					break;
+			}
+		}
+	}
+	__super::WindowProc(WM_VSCROLL, MAKEWPARAM(code, pos), (LPARAM)hwndSB);
+}
+
+
+void SkinnedScrollWnd::OnMouseWheel(INT delta, UINT vtKey, POINTS pts)
+{
+	if (0 == delta) 
+		return;
+
+	if (0 != (SWS_LISTVIEW & scrollFlags))
+	{
+		DWORD windowStyle = GetWindowLongPtr(hwnd, GWL_STYLE);
+		if (LVS_REPORT == (LVS_TYPEMASK & windowStyle))
+		{
+			if (0 != (WS_VSCROLL & windowStyle))
+			{	
+				unsigned int wheelScroll;
+				int scrollLines, distance;
+
+				if (!SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &wheelScroll, 0)) 
+					wheelScroll = 3;
+
+				if (0 == wheelScroll)
+					return;
+
+				if (WHEEL_PAGESCROLL == wheelScroll)
+				{				
+					SendMessageW(hwnd, WM_VSCROLL, MAKEWPARAM(((delta > 0) ? SB_PAGEUP : SB_PAGEDOWN), 0), 0L);
+					SendMessageW(hwnd, WM_VSCROLL, MAKEWPARAM(SB_ENDSCROLL, 0), 0L);
+					return;
+				}
+
+				distance = delta + wheelCarryover; 
+				scrollLines = distance * (INT)wheelScroll / WHEEL_DELTA;
+
+				wheelCarryover = distance - scrollLines * WHEEL_DELTA / (INT)wheelScroll;
+
+				if (ListView_ScrollReportModeVert(hwnd, -scrollLines, (0 != (SWS_HIDEHSCROLL & scrollFlags))))
+				{
+					InvalidateNC(InvalidateFlag_RedrawNow, SB_VERT);
+					return;
+				}
+			}
+			else if (0 != (SWS_HIDEHSCROLL & scrollFlags))
+			{
+				return;
+			}
+		}
+
+	}
+	__super::WindowProc(WM_MOUSEWHEEL, MAKEWPARAM(vtKey, delta), *(LPARAM*)&pts);
+}
+
+void SkinnedScrollWnd::UpdateFrame()
+{
+	if (SWS_UPDATEFRAME & scrollFlags)
+	{
+		SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER  | SWP_NOACTIVATE | SWP_FRAMECHANGED | SWP_NOSENDCHANGING | SWP_NOREDRAW);
+	}
+}
+
+void SkinnedScrollWnd::OnSkinChanged(BOOL bNotifyChildren, BOOL bRedraw)
+{
+	UINT newFlag = scrollFlags & ~SWS_USEFREEFORM;
+	if (UseFreeformScrollbars()) 
+		newFlag |= SWS_USEFREEFORM;
+	
+	if (newFlag != scrollFlags)
+	{
+		RECT rcOld;
+		GetClientRect(hwnd, &rcOld);
+
+		scrollFlags = newFlag;
+		SetWindowPos(hwnd, NULL, 0, 0, 0, 0, 
+			SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOREDRAW);
+	
+	}
+	__super::OnSkinChanged(bNotifyChildren, bRedraw);
+
+	if (FALSE != bRedraw)
+		RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE |RDW_ERASE | RDW_FRAME);
+}
+
+LRESULT SkinnedScrollWnd::WindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	switch (uMsg)
+	{
+		/*case SBM_GETSCROLLINFO:
+		{
+			SCROLLINFO *scrollInfo = (SCROLLINFO *)lParam;
+			int x=0;
+			x=0;
+		}
+		break;*/
+
+		case WM_NCMOUSEMOVE:		OnNcMouseMove((UINT)wParam, MAKEPOINTS(lParam)); return 0;
+		case WM_NCRBUTTONDOWN:
+		case WM_NCRBUTTONUP:
+		case WM_NCMBUTTONDOWN:
+		case WM_NCMBUTTONUP:		if (wParam == HTHSCROLL || wParam == HTVSCROLL) return 0;
+			break;
+		case WM_NCLBUTTONDBLCLK:	if (wParam != HTHSCROLL && wParam != HTVSCROLL)	break; // else fall to the nclbuttondown
+		case WM_NCLBUTTONDOWN:	OnNcLButtonDown((UINT)wParam, MAKEPOINTS(lParam)); return 0;
+		case WM_NCMOUSELEAVE:
+		case WM_MOUSELEAVE:		OnNcMouseLeave(); break;
+		case WM_LBUTTONUP:		OnLButtonUp((UINT)wParam, MAKEPOINTS(lParam)); return 0;
+		case WM_MOUSEMOVE:		OnMouseMove((UINT)wParam, MAKEPOINTS(lParam)); return 0;
+		case WM_TIMER:			OnTimer((UINT_PTR)wParam, (TIMERPROC)lParam); return 0;
+		case WM_ERASEBKGND:		return 	OnEraseBackground((HDC)wParam);
+		case WM_DISPLAYCHANGE:
+			SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER  | SWP_NOACTIVATE | SWP_FRAMECHANGED | SWP_NOSENDCHANGING);
+			break;
+		case WM_CAPTURECHANGED:
+			if (!ignoreCaptureChange) 
+			{
+				LONG pts = GetMessagePos();
+				POINT pt;
+				POINTSTOPOINT(pt, pts);
+				MapWindowPoints(HWND_DESKTOP, hwnd, &pt, 1);
+				pts = POINTTOPOINTS(pt);
+				Emulate_LeftButtonUp((UINT)wParam, MAKEPOINTS(pts), FALSE);
+			}
+			break;
+			// sometimes update frame required when this messges arrive
+		case WM_ACTIVATE:
+		case WM_SETFOCUS:
+		case WM_HSCROLL:
+			{
+				LRESULT result = __super::WindowProc(uMsg, wParam, lParam);
+				UpdateFrame();
+				return result;
+			}
+			break;
+		case WM_MOUSEWHEEL:
+			OnMouseWheel(GET_WHEEL_DELTA_WPARAM(wParam), GET_KEYSTATE_WPARAM(wParam), MAKEPOINTS(lParam));
+			UpdateFrame();
+			return 0;
+		case WM_VSCROLL:
+			OnVertScroll(LOWORD(wParam), HIWORD(wParam), (HWND)lParam); 
+			UpdateFrame();
+			return 0;
+		case LVM_SCROLL:
+			if (SWS_LISTVIEW & scrollFlags)
+				return OnListViewScroll((INT)wParam, (INT)lParam); 
+			break;
+		case WM_KEYDOWN:
+			if (0 != ((SWS_LISTVIEW | SWS_TREEVIEW ) & scrollFlags))
+			{
+				LRESULT result = __super::WindowProc(uMsg, wParam, lParam);	
+				switch(wParam)
+				{
+					case VK_PRIOR:
+					case VK_NEXT:
+					case VK_UP:
+					case VK_DOWN:
+					case VK_HOME:
+					case VK_END:
+						UpdateScrollBars(TRUE);
+						break;
+				}
+				return result;
+			}
+			break;
+		case WM_USER + 0x3443:
+			UpdateScrollBars(TRUE);
+			break;
+	}
+	return __super::WindowProc(uMsg, wParam, lParam);
+}
+
+//
+//	return the default minimum size of a scrollbar thumb
+//
+static 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
+	return (dwVersion >= 0x80000000 && LOBYTE(LOWORD(dwVersion)) >= 5) ? MINTHUMBSIZE_2000 : MINTHUMBSIZE_NT4;
+}
+
+BOOL SkinnedScrollWnd::ShowScrollBar(int wBar, BOOL fShow)
+{
+	DWORD styleOld, styleNew;
+
+	styleOld = GetWindowLongPtrW(hwnd, GWL_STYLE);
+	styleNew = styleOld;
+
+	if (wBar == SB_HORZ || wBar == SB_BOTH)
+	{
+		psbHorz->fScrollFlags = (psbHorz->fScrollFlags & ~CSBS_VISIBLE) | ((fShow) ? CSBS_VISIBLE : 0);
+		styleNew = (styleNew & ~WS_HSCROLL) | ((fShow) ? WS_HSCROLL :0);
+	}
+
+	if (wBar == SB_VERT || wBar == SB_BOTH)
+	{
+		psbVert->fScrollFlags = (psbVert->fScrollFlags & ~CSBS_VISIBLE) | ((fShow) ? CSBS_VISIBLE : 0);
+		styleNew = (styleNew & ~WS_VSCROLL) | ((fShow) ? WS_VSCROLL :0);
+	}
+
+	if (styleNew != styleOld)
+	{
+		SetWindowLongPtrW(hwnd, GWL_STYLE, styleNew);
+		SetWindowPos(hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED | SWP_NOREDRAW);
+	}
+
+	return TRUE;
+}
+
+SkinnedScrollWnd::SkinnedScrollWnd(BOOL bIsDialog) 
+	: SkinnedWnd(bIsDialog), psbHorz(0), psbVert(0),
+	  scrollFlags(0), scrollPortionHover(0), wheelCarryover(0)
+{
+	if (-1 == bUseUpdateRgn)
+	{
+		OSVERSIONINFO osver = {0};
+		osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+		if (::GetVersionEx(&osver))
+		{
+			bUseUpdateRgn =
+			  ((VER_PLATFORM_WIN32_NT != osver.dwPlatformId ||
+			    (osver.dwMajorVersion < 6 && osver.dwMinorVersion != 2)));
+			bDoHover = !(VER_PLATFORM_WIN32_NT == osver.dwPlatformId && osver.dwMajorVersion == 4); // can't use TrackMouseEvent with non-client areas on Windows NT 4.0
+		}
+	}
+}
+
+BOOL SkinnedScrollWnd::Attach(HWND hwndToSkin)
+{
+	DWORD style;
+
+	if (!SkinnedWnd::Attach(hwndToSkin)) 
+		return FALSE;
+
+	SetType(SKINNEDWND_TYPE_SCROLLWND);
+
+	psbHorz = (SCROLLBAR*)calloc(1, sizeof(SCROLLBAR));
+	psbVert = (SCROLLBAR*)calloc(1, sizeof(SCROLLBAR));
+	if (!psbHorz || !psbVert) return FALSE;
+
+	scrollFlags = 0;
+	wheelCarryover = 0;
+
+	psbHorz->scrollInfo.cbSize = sizeof(SCROLLINFO);
+	psbHorz->scrollInfo.fMask  = SIF_ALL;
+	if (!GetScrollInfo(hwnd, SB_HORZ, &psbHorz->scrollInfo))
+		ZeroMemory(&psbHorz->scrollInfo, sizeof(SCROLLINFO));
+
+	psbVert->scrollInfo.cbSize = sizeof(SCROLLINFO);
+	psbVert->scrollInfo.fMask  = SIF_ALL;
+	if (!GetScrollInfo(hwnd, SB_VERT, &psbVert->scrollInfo))
+		ZeroMemory(&psbVert->scrollInfo, sizeof(SCROLLINFO));
+
+	scrollPortionHover = HTSCROLL_NONE;
+
+	//check to see if the window has left-aligned scrollbars
+	if (GetWindowLongPtrW(hwnd, GWL_EXSTYLE) & WS_EX_LEFTSCROLLBAR) scrollFlags |= SWS_LEFT;
+
+	style = GetWindowLongPtrW(hwnd, GWL_STYLE);
+
+	if (WS_HSCROLL & style) psbHorz->fScrollFlags = CSBS_VISIBLE;
+	if (WS_VSCROLL & style) psbVert->fScrollFlags = CSBS_VISIBLE;
+
+	psbHorz->nBarType	= SB_HORZ;
+	psbVert->nBarType	= SB_VERT;
+
+	//set the default arrow sizes for the scrollbars
+	psbHorz->nMinThumbSize = CoolSB_GetDefaultMinThumbSize();
+	psbVert->nMinThumbSize = psbHorz->nMinThumbSize;
+
+	scrollFlags |= SWS_UPDATEFRAME;
+	SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER  | SWP_NOACTIVATE | SWP_FRAMECHANGED | SWP_NOSENDCHANGING | SWP_NOREDRAW);
+	InvalidateNC(InvalidateFlag_Frame | InvalidateFlag_RedrawNow, SB_BOTH);
+
+	return TRUE;
+}
+
+SkinnedScrollWnd::~SkinnedScrollWnd(void)
+{
+	InvalidateNC(InvalidateFlag_Frame | InvalidateFlag_RedrawNow, SB_BOTH);
+	if (psbHorz) free(psbHorz);
+	if (psbVert) free(psbVert);
+	if (hbrChecked) 
+	{
+		DeleteObject(hbrChecked);
+		hbrChecked = NULL; 
+	}
+}
+
+void SkinnedScrollWnd::DisableNoScroll(BOOL bDisable)
+{
+	if (bDisable) scrollFlags |= SWS_DISABLENOSCROLL; 
+	else scrollFlags &= ~SWS_DISABLENOSCROLL; 
+}
+BOOL SkinnedScrollWnd::IsNoScrollDisabled()
+{
+	return (0 != (SWS_DISABLENOSCROLL & scrollFlags));
+}
+
+void SkinnedScrollWnd::InvalidateNC(InvalidateFlags invalidate, UINT bars)
+{
+	HRGN rgnH = NULL, rgnV = NULL;
+	RECT rc;
+	int scrollLength;
+	unsigned int flags;
+	long frameEdge, clientEdge;
+
+	if (0 != (InvalidateFlag_Frame & invalidate))
+	{
+		flags = SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | 
+				SWP_FRAMECHANGED | SWP_NOSENDCHANGING | SWP_NOREDRAW;
+	
+		SetWindowPos(hwnd, NULL, 0, 0, 0, 0, flags);
+	}
+
+	if (FALSE == GetClientRect(hwnd, &rc))
+		return;
+
+	if (SB_HORZ == bars || SB_BOTH == bars)
+	{
+		scrollLength = GetScrollMetric(psbHorz, SM_CYVERTSB, scrollFlags);
+
+		clientEdge = rc.bottom;
+		if (0 != (InvalidateFlag_HorzBarRemoved & invalidate))
+			clientEdge -= scrollLength;
+
+		frameEdge = clientEdge + scrollLength;
+
+		rgnH = CreateRectRgn(rc.left, clientEdge, rc.right, frameEdge);
+	}
+	else 
+		rgnH = NULL;
+
+	if (SB_VERT == bars || SB_BOTH == bars)
+	{
+		scrollLength = GetScrollMetric(psbVert, SM_CXVERTSB, scrollFlags);
+
+		if (0 != (SWS_LEFT & scrollFlags))
+		{
+			clientEdge = rc.left;
+			if (0 == (InvalidateFlag_VertBarRemoved & invalidate))
+				clientEdge -= scrollLength;
+		}
+		else
+		{
+			clientEdge = rc.right;
+			if (0 != (InvalidateFlag_VertBarRemoved & invalidate))
+				clientEdge -= scrollLength;
+
+			frameEdge = clientEdge + scrollLength;
+		}
+
+		rgnV = CreateRectRgn(clientEdge, rc.top, frameEdge, rc.bottom);
+
+		if (NULL != rgnV && SB_BOTH == bars) 
+			CombineRgn(rgnH, rgnH, rgnV, RGN_OR);
+	}
+	else 
+		rgnV = NULL;
+
+	flags = RDW_INVALIDATE | /*RDW_INTERNALPAINT  | RDW_ERASE |*/ RDW_FRAME | RDW_NOCHILDREN;
+	if (0 != (InvalidateFlag_RedrawNow & invalidate))
+		flags |= (RDW_UPDATENOW | RDW_ERASENOW);
+
+	HRGN rgn = ((NULL != rgnH) ? rgnH : rgnV);
+	if (rgn)
+		RedrawWindow(hwnd, NULL, rgn, flags);
+
+	if (rgnH) 
+		DeleteRgn(rgnH);
+
+	if (rgnV) 
+		DeleteRgn(rgnV);
+}
+
+void SkinnedScrollWnd::UpdateScrollBars(BOOL fInvalidate)
+{
+	UINT bars;
+	InvalidateFlags invalidateFlags;
+
+	SCROLLINFO tsi;
+	tsi.cbSize = sizeof(SCROLLINFO);
+	tsi.fMask = SIF_ALL;
+
+	bars = -1;
+	invalidateFlags = InvalidateFlag_Normal /*| InvalidateFlag_RedrawNow*/;
+
+	if (0 == (SWS_HIDEHSCROLL & scrollFlags))
+	{
+		if (GetScrollInfo(hwnd, SB_HORZ, &tsi) &&
+			memcmp(&tsi, &psbHorz->scrollInfo, sizeof(SCROLLINFO)))
+		{
+			memcpy(&psbHorz->scrollInfo, &tsi, sizeof(SCROLLINFO));
+			UpdateScrollBar(psbHorz, &invalidateFlags);
+			
+			psbHorz->scrollInfo.cbSize = sizeof(SCROLLINFO);
+			psbHorz->scrollInfo.fMask = SIF_ALL;
+			if (!GetScrollInfo(hwnd, SB_HORZ, &psbHorz->scrollInfo))
+				ZeroMemory(&psbHorz->scrollInfo, sizeof(SCROLLINFO));
+
+			bars = SB_HORZ;
+		}
+	}
+	else
+	{
+		psbHorz->scrollInfo.cbSize = sizeof(SCROLLINFO);
+		psbHorz->scrollInfo.fMask = SIF_ALL;
+		if (!GetScrollInfo(hwnd, SB_HORZ, &psbHorz->scrollInfo))
+			ZeroMemory(&psbHorz->scrollInfo, sizeof(SCROLLINFO));
+	}
+
+	if (0 == (SWS_HIDEVSCROLL & scrollFlags))
+	{
+		if (GetScrollInfo(hwnd, SB_VERT, &tsi))
+		{
+			if (0 != (SWS_LISTVIEW & scrollFlags) &&
+				LVS_REPORT == (LVS_TYPEMASK & GetWindowLongPtrW(hwnd, GWL_STYLE)))
+			{
+				if (0 != (SWS_HIDEHSCROLL & scrollFlags))
+				{
+					tsi.nMax = (int)SendMessageW(hwnd, LVM_GETITEMCOUNT, 0, 0L);
+					tsi.nPage = (unsigned int)SendMessageW(hwnd, LVM_GETCOUNTPERPAGE, 0, 0L);
+					if(tsi.nMax > 0)
+						tsi.nMax--;
+											
+				//	if (psbHorz->scrollInfo.nPage <= (UINT)psbHorz->scrollInfo.nMax)
+				
+				}
+			}
+
+			if (memcmp(&tsi, &psbVert->scrollInfo, sizeof(SCROLLINFO)))
+			{
+				memcpy(&psbVert->scrollInfo, &tsi, sizeof(SCROLLINFO));
+
+				UpdateScrollBar(psbVert, &invalidateFlags);
+				bars = (SB_HORZ == bars) ? SB_BOTH : SB_VERT;
+			}
+		}
+	}
+	else
+	{
+		psbVert->scrollInfo.cbSize = sizeof(SCROLLINFO);
+		psbVert->scrollInfo.fMask = SIF_ALL;
+		if (!GetScrollInfo(hwnd, SB_VERT, &psbVert->scrollInfo))
+			ZeroMemory(&psbVert->scrollInfo, sizeof(SCROLLINFO));
+	}
+
+	if ((fInvalidate || 0 != (InvalidateFlag_Frame & invalidateFlags)) &&
+		-1 != bars) 
+	{
+		InvalidateNC(invalidateFlags, bars);
+
+		if (0 != (InvalidateFlag_Frame & invalidateFlags) && 
+			0 != (SWS_LISTVIEW & scrollFlags) &&
+			LVS_REPORT == (LVS_TYPEMASK & GetWindowLongPtrW(hwnd, GWL_STYLE)))
+		{
+			if (0 == (LVS_NOCOLUMNHEADER & GetWindowLongPtrW(hwnd, GWL_STYLE)))
+			{
+				HWND hHeader = (HWND)SendMessageW(hwnd, LVM_GETHEADER, 0, 0L);
+				if (NULL != hHeader)
+				{
+					RECT clientRect;
+					WINDOWPOS wp;
+
+					GetClientRect(hwnd, &clientRect);
+
+					SCROLLINFO si;
+					si.cbSize = sizeof(si);
+					si.fMask = SIF_POS;
+					if (0 != GetScrollInfo(hwnd, SB_HORZ, &si))
+						clientRect.left -= si.nPos;	
+
+					HDLAYOUT layout;
+					layout.prc = &clientRect;
+					layout.pwpos = &wp;
+					if (FALSE != SendMessageW(hHeader, HDM_LAYOUT, 0, (LPARAM)&layout))
+					{
+						if (FALSE == fInvalidate) 
+							wp.flags |= SWP_NOREDRAW;
+						SetWindowPos(hHeader, wp.hwndInsertAfter, wp.x, wp.y, wp.cx, wp.cy, wp.flags | SWP_NOZORDER | SWP_NOACTIVATE);
+					}
+				}
+			}
+		}
+	}
+}
+
+void SkinnedScrollWnd::UpdateScrollBar(SCROLLBAR *psb, InvalidateFlags *invalidateFlags)
+{
+	SCROLLINFO *psi;
+	psi = &psb->scrollInfo;
+
+	if ((psi->nPage > (UINT)psi->nMax || (psi->nPage == (UINT)psi->nMax && psi->nMax == 0) || psi->nMax <= psi->nMin))
+	{
+		if (psb->fScrollVisible)
+		{
+			if (SWS_DISABLENOSCROLL & scrollFlags)
+			{
+				psb->fScrollFlags |= (ESB_DISABLE_LEFT | ESB_DISABLE_RIGHT);
+			}
+			else
+			{
+				ShowScrollBar(psb->nBarType, FALSE);
+				*invalidateFlags |= InvalidateFlag_Frame;
+				if (SB_VERT == psb->nBarType)
+					*invalidateFlags |= InvalidateFlag_VertBarRemoved;
+				else
+					*invalidateFlags |= InvalidateFlag_HorzBarRemoved;
+			}
+		}
+	}
+	else 
+	{
+		if ((!psb->fScrollVisible || ((ESB_DISABLE_LEFT | ESB_DISABLE_RIGHT) & psb->fScrollFlags)) && psi->nPage > 0)
+		{
+			if ((SWS_DISABLENOSCROLL & scrollFlags) && ((ESB_DISABLE_LEFT | ESB_DISABLE_RIGHT) & psb->fScrollFlags))
+			{
+				psb->fScrollFlags &= ~(ESB_DISABLE_LEFT | ESB_DISABLE_RIGHT);
+			}
+
+			if (!psb->fScrollVisible)
+			{
+				if (SWS_LISTVIEW & scrollFlags)
+				{
+					DWORD ws = GetWindowLongPtrW(hwnd, GWL_STYLE);
+					if (LVS_ICON == (LVS_TYPEMASK & ws) || LVS_SMALLICON == (LVS_TYPEMASK & ws))
+					{
+						switch(LVS_ALIGNMASK & ws)
+						{
+							case LVS_ALIGNLEFT:
+								if (SB_HORZ != psb->nBarType) psb->nBarType = ((SB_BOTH == psb->nBarType) ? SB_HORZ : -1);
+								break;
+							case LVS_ALIGNTOP:
+								if (SB_VERT != psb->nBarType) psb->nBarType = ((SB_BOTH == psb->nBarType) ? SB_VERT : -1);
+								break;
+						}
+					}
+				}
+				if (-1 != psb->nBarType)
+				{
+					ShowScrollBar(psb->nBarType, TRUE);
+					*invalidateFlags |= InvalidateFlag_Frame;
+					if (SB_VERT == psb->nBarType)
+						*invalidateFlags |= InvalidateFlag_VertBarAppeared;
+					else
+						*invalidateFlags |= InvalidateFlag_HorzBarAppeared;
+				}
+			}
+		}
+		else if (psb->fScrollVisible && 0 == psi->nPage)
+		{
+			if (SWS_DISABLENOSCROLL & scrollFlags)
+			{
+				psb->fScrollFlags |= (ESB_DISABLE_LEFT | ESB_DISABLE_RIGHT);
+			}
+			else
+			{
+				ShowScrollBar(psb->nBarType, FALSE);
+				*invalidateFlags |= InvalidateFlag_Frame;
+				if (SB_VERT == psb->nBarType)
+					*invalidateFlags |= InvalidateFlag_VertBarRemoved;
+				else
+					*invalidateFlags |= InvalidateFlag_HorzBarRemoved;
+			}
+		}
+	}
+}
+
+void SkinnedScrollWnd::ShowHorzScroll(BOOL fEnable)
+{
+	scrollFlags = (scrollFlags & ~SWS_HIDEHSCROLL) | ((fEnable) ? 0 : SWS_HIDEHSCROLL);
+	psbHorz->fScrollFlags = 0;
+	InvalidateNC(InvalidateFlag_Frame | InvalidateFlag_RedrawNow, SB_HORZ);
+}
+
+BOOL SkinnedScrollWnd::IsHorzBarHidden()
+{
+	return (0 != (SWS_HIDEHSCROLL & scrollFlags));
+}
+
+BOOL SkinnedScrollWnd::IsVertBarHidden()
+{
+	return (0 != (SWS_HIDEVSCROLL & scrollFlags));
+}
+
+void SkinnedScrollWnd::ShowVertScroll(BOOL fEnable)
+{
+	scrollFlags = (scrollFlags & ~SWS_HIDEVSCROLL) | ((fEnable) ? 0 : SWS_HIDEVSCROLL);
+	psbVert->fScrollFlags = 0;
+	InvalidateNC(InvalidateFlag_Frame | InvalidateFlag_RedrawNow, SB_VERT);
+}
+
+BOOL SkinnedScrollWnd::SetMode(UINT nMode)
+{
+	scrollFlags &= ~(SWS_LISTVIEW | SWS_TREEVIEW | SWS_COMBOLBOX);
+	switch (0xFF & nMode)
+	{
+		case SCROLLMODE_STANDARD_I: return TRUE;
+		case SCROLLMODE_LISTVIEW_I: scrollFlags |= SWS_LISTVIEW; return TRUE;
+		case SCROLLMODE_TREEVIEW_I: scrollFlags |= SWS_TREEVIEW; return TRUE;
+		case SCROLLMODE_COMBOLBOX_I: scrollFlags |= SWS_COMBOLBOX; return TRUE;
+	}
+
+	return FALSE;
+}
+
+UINT SkinnedScrollWnd::GetMode()
+{
+	if (0 != (SWS_LISTVIEW & scrollFlags))
+		return SCROLLMODE_STANDARD_I;
+
+	if (0 != (SWS_TREEVIEW & scrollFlags))
+		return SCROLLMODE_TREEVIEW_I;
+
+	if (0 != (SWS_COMBOLBOX & scrollFlags))
+		return SCROLLMODE_COMBOLBOX_I;
+
+	return SCROLLMODE_STANDARD_I;
+}
+
+INT SkinnedScrollWnd::AdjustHover(UINT nHitTest, POINTS pts)
+{
+	SCROLLBAR *psb = NULL;
+	RECT rect;
+
+	if (psbHorz) psbHorz->fScrollFlags &= ~CSBS_HOVERING;
+	if (psbVert) psbVert->fScrollFlags &= ~CSBS_HOVERING;
+	scrollPortionHover = HTSCROLL_NONE;
+
+	if (HTHSCROLL == nHitTest)
+	{
+		psb = psbHorz;
+		GetHScrollRect(this, &rect);
+	}
+	else if (HTVSCROLL== nHitTest)
+	{
+		psb = psbVert;
+		GetVScrollRect(this, &rect);
+	}
+
+	if (psb)
+	{
+		psb->fScrollFlags |= CSBS_HOVERING;
+		scrollPortionHover = GetPortion(psb, hwnd, &rect, pts.x, pts.y, scrollFlags);
+	}
+	return scrollPortionHover;
+}
+
+BOOL SkinnedScrollWnd::OnMediaLibraryIPC(INT msg, INT_PTR param, LRESULT *pResult)
+{
+	switch (msg)
+	{
+		case IPC_ML_SKINNEDSCROLLWND_UPDATEBARS:
+			UpdateScrollBars((BOOL)param); 
+			*pResult = 1; 
+			return TRUE;
+		case IPC_ML_SKINNEDSCROLLWND_SHOWHORZBAR:
+			ShowHorzScroll((BOOL)param); 
+			*pResult = 1; 
+			return TRUE;
+		case IPC_ML_SKINNEDSCROLLWND_SHOWVERTBAR:
+			ShowVertScroll((BOOL)param); 
+			*pResult = 1; 
+			return TRUE;
+		case IPC_ML_SKINNEDSCROLLWND_SETMODE:
+			*pResult = SetMode((UINT)param); 
+			return TRUE;
+		case IPC_ML_SKINNEDSCROLLWND_DISABLENOSCROLL: 
+			DisableNoScroll(0 != param);
+			*pResult = -1; 
+			return TRUE;
+		case IPC_ML_SKINNEDSCROLLWND_ADJUSTHOVER:
+			((SBADJUSTHOVER*)param)->nResult = AdjustHover(((SBADJUSTHOVER*)param)->hitTest, ((SBADJUSTHOVER*)param)->ptMouse); 
+			*pResult = TRUE;
+			return TRUE;
+		case IPC_ML_SKINNEDSCROLLWND_GETHORZBARHIDDEN:
+			*pResult = IsHorzBarHidden();
+			return TRUE;
+		case IPC_ML_SKINNEDSCROLLWND_GETVERTBARHIDDEN:
+			*pResult = IsVertBarHidden();
+			return TRUE;
+		case IPC_ML_SKINNEDSCROLLWND_GETMODE:
+			*pResult = GetMode();
+			return TRUE;
+		case IPC_ML_SKINNEDSCROLLWND_GETNOSCROLLDISABLED:
+			*pResult = IsNoScrollDisabled();
+			return TRUE;
+	}
+	return __super::OnMediaLibraryIPC(msg, param, pResult);
+}
\ No newline at end of file