Initial community commit

1 files changed, 1284 insertions, 0 deletions

diff --git a/Src/Plugins/Library/ml_devices/widget.cpp b/Src/Plugins/Library/ml_devices/widget.cpp
new file mode 100644
index 00000000..c5e99c6e
--- /dev/null
+++ b/Src/Plugins/Library/ml_devices/widget.cpp
@@ -0,0 +1,1284 @@
+#include "main.h"
+#include "./widget.h"
+
+typedef 
+enum WidgetState
+{
+	WIDGET_STATE_MOUSE_MOVE_TRACKED = (1 << 0),
+	WIDGET_STATE_DISABLE_CHILDREN_SCROLL = (1 << 1),
+} WidgetState;
+
+DEFINE_ENUM_FLAG_OPERATORS(WidgetState);
+
+#define WIDGET_IS_FROZEN(_widget) (0 != (_widget)->freezer)
+
+#define WIDGET_IS_MOUSE_MOVE_TRACKED(_widget) (0 != (WIDGET_STATE_MOUSE_MOVE_TRACKED & (_widget)->state))
+#define WIDGET_SET_MOUSE_MOVE_TRACK(_widget) (((_widget)->state) |= WIDGET_STATE_MOUSE_MOVE_TRACKED)
+#define WIDGET_UNSET_MOUSE_MOVE_TRACK(_widget) (((_widget)->state) &= ~WIDGET_STATE_MOUSE_MOVE_TRACKED)
+
+
+#define WIDGET_IS_CHILDREN_SCROLL_DISABLED(_widget) (0 != (WIDGET_STATE_DISABLE_CHILDREN_SCROLL & (_widget)->state))
+#define WIDGET_SET_DISABLE_CHILDREN_SCROLL(_widget) (((_widget)->state) |= WIDGET_STATE_DISABLE_CHILDREN_SCROLL)
+#define WIDGET_UNSET_DISABLE_CHILDREN_SCROLL(_widget) (((_widget)->state) &= ~WIDGET_STATE_DISABLE_CHILDREN_SCROLL)
+
+typedef struct Widget
+{
+	unsigned int type;
+	WidgetState state;
+	const WidgetInterface *callbacks;
+	void *object;
+	WidgetStyle *style;
+	wchar_t *text;
+	HFONT font;
+	SIZE viewSize;
+	POINT viewOrigin;
+	int	wheelCarryover;
+	size_t freezer;
+} Widget;
+
+typedef struct WidgetCreateParam
+{
+	unsigned int type;
+	const WidgetInterface *callbacks;
+	void *param;
+	const wchar_t *text;
+} WidgetCreateParam;
+
+#define WIDGET(_hwnd) ((Widget*)(LONGX86)GetWindowLongPtrW((_hwnd), 0))
+#define WIDGET_RET_VOID(_view, _hwnd) {(_view) = WIDGET((_hwnd)); if (NULL == (_view)) return;}
+#define WIDGET_RET_VAL(_view, _hwnd, _error) {(_view) = WIDGET((_hwnd)); if (NULL == (_view)) return (_error);}
+
+#define WIDGETSTYLE(_widget) (((Widget*)(_widget))->style)
+#define WIDGETOBJECT(_widget) (((Widget*)(_widget))->object)
+#define WIDGETCALLBACKS(_widget) (((Widget*)(_widget))->callbacks)
+
+static UINT WINAMP_WM_DIRECT_MOUSE_WHEEL = WM_NULL;
+
+static LRESULT CALLBACK 
+Widget_WindowProc(HWND hwnd, unsigned int uMsg, WPARAM wParam, LPARAM lParam);
+
+
+static ATOM 
+Widget_GetClassAtom(HINSTANCE instance)
+{
+	WNDCLASSEXW klass;
+	ATOM klassAtom;
+
+	klassAtom = (ATOM)GetClassInfoExW(instance, WIDGET_WINDOW_CLASS, &klass);
+	if (0 != klassAtom)
+		return klassAtom;
+
+	memset(&klass, 0, sizeof(klass));
+	klass.cbSize = sizeof(klass);
+	klass.style = CS_DBLCLKS;
+	klass.lpfnWndProc = Widget_WindowProc;
+	klass.cbClsExtra = 0;
+	klass.cbWndExtra = sizeof(Widget*);
+	klass.hInstance = instance;
+	klass.hIcon = NULL;
+	klass.hCursor = LoadCursorW(NULL, (LPCWSTR)IDC_ARROW);
+	klass.hbrBackground = NULL;
+	klass.lpszMenuName = NULL;
+	klass.lpszClassName = WIDGET_WINDOW_CLASS;
+	klass.hIconSm = NULL;
+	klassAtom = RegisterClassExW(&klass);
+	
+	return klassAtom;
+}
+
+HWND 
+Widget_CreateWindow(unsigned int type, const WidgetInterface *callbacks,
+					const wchar_t *text, unsigned long windowExStyle, unsigned long windowStyle, 
+					int x, int y, int width, int height, 
+					HWND parentWindow, unsigned int controlId, void *param)
+{
+	HINSTANCE instance;
+	ATOM klassAtom;
+	HWND hwnd;
+	WidgetCreateParam createParam;
+		
+	if (NULL == parentWindow || FALSE == IsWindow(parentWindow))
+		return NULL;
+
+	instance = GetModuleHandleW(NULL);
+	klassAtom = Widget_GetClassAtom(instance);
+	if (0 == klassAtom)
+		return NULL;
+	
+	createParam.type = type;
+	createParam.param = param;
+	createParam.callbacks = callbacks;
+	createParam.text = text;
+
+	hwnd = CreateWindowExW(WS_EX_NOPARENTNOTIFY | windowExStyle, (LPCWSTR)MAKEINTATOM(klassAtom), NULL,
+							WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | windowStyle,
+							x, y, width, height, 
+							parentWindow, (HMENU)controlId, instance, &createParam);
+
+	return hwnd;
+}
+
+
+static LRESULT
+Widget_DefWindowProc(HWND hwnd, unsigned int uMsg, WPARAM wParam, LPARAM lParam)
+{
+	Widget *self;
+	
+	self = WIDGET(hwnd);
+
+	if (NULL != self && NULL != self->callbacks->messageProc)
+	{
+		LRESULT result;
+		result = 0;
+		if (FALSE != self->callbacks->messageProc(self->object, 
+							hwnd, uMsg, wParam, lParam, &result))
+		{
+			return result;
+		}
+	}
+
+	return DefWindowProc(hwnd, uMsg, wParam, lParam);
+}
+
+static void 
+Widget_Freeze(Widget *self)
+{
+	if (NULL != self)
+		self->freezer++;
+}
+
+static void 
+Widget_Thaw(Widget *self)
+{
+	if (NULL != self && 0 != self->freezer)
+		self->freezer--;
+}
+
+static INT
+Widget_ScrollBarOffsetPos(HWND hwnd, INT barType, INT delta, BOOL redraw)
+{
+	Widget *self;
+	INT position;
+	SCROLLINFO scrollInfo;
+	
+	self = WIDGET(hwnd);
+
+	scrollInfo.cbSize = sizeof(scrollInfo);
+	scrollInfo.fMask = SIF_POS | SIF_RANGE | SIF_PAGE;
+
+	if (FALSE == GetScrollInfo(hwnd, barType, &scrollInfo))
+		return 0;
+
+	position = scrollInfo.nPos + delta;
+
+	if (position < scrollInfo.nMin)
+		position = scrollInfo.nMin;
+	else if (position > (scrollInfo.nMax - (INT)scrollInfo.nPage))
+		position = scrollInfo.nMax - (INT)scrollInfo.nPage + 1;
+	
+	delta = position - scrollInfo.nPos;
+
+	scrollInfo.fMask = SIF_POS;
+	scrollInfo.nPos = position;
+	SetScrollInfo(hwnd, barType, &scrollInfo, redraw);
+
+	if (NULL != self)
+	{
+		if (SB_HORZ == barType)
+			self->viewOrigin.x = -position;
+		else 
+			self->viewOrigin.y = -position;
+	}
+
+	return delta;
+}
+
+static BOOL 
+Widget_ScrollContent(HWND hwnd, int dx, int dy, BOOL redraw)
+{
+	Widget *self;
+	UINT scrollFlags;
+	HRGN invalidRgn;
+	INT scrollError;
+
+	if (0 == dx && 0 == dy)
+		return FALSE;
+
+	self = WIDGET(hwnd);
+	if (NULL != self &&
+		NULL != self->callbacks &&
+		NULL != self->callbacks->scrollBefore)
+	{
+		self->callbacks->scrollBefore(WIDGETOBJECT(self), hwnd, &dx, &dy);
+		if (0 == dx && 0 == dy)
+			return FALSE;
+	}
+
+
+	scrollFlags = (FALSE == WIDGET_IS_CHILDREN_SCROLL_DISABLED(self)) ? SW_SCROLLCHILDREN : 0;
+	if (FALSE != redraw)
+	{
+		invalidRgn = CreateRectRgn(0, 0, 0, 0);
+		scrollFlags |= SW_INVALIDATE | SW_ERASE;
+	}
+	else
+	{
+		invalidRgn = NULL;
+	}
+	
+	scrollError = ScrollWindowEx(hwnd, -dx, -dy, NULL, NULL, invalidRgn, NULL, scrollFlags);
+	if (ERROR != scrollError)
+	{
+		if (NULL != self && 
+			NULL != self->callbacks &&
+			NULL != self->callbacks->scroll)
+		{
+			self->callbacks->scroll(WIDGETOBJECT(self), hwnd, &dx, &dy);
+		}
+
+		if (FALSE != redraw && NULLREGION != scrollError)
+		{
+			RedrawWindow(hwnd, NULL, invalidRgn, 
+							RDW_ERASENOW | RDW_UPDATENOW | RDW_ALLCHILDREN);
+		}
+	}
+
+	if (NULL != invalidRgn)
+		DeleteObject(invalidRgn);
+
+	return (ERROR != scrollError);
+}
+
+static BOOL
+Widget_SyncContentOrigin(HWND hwnd, BOOL redraw)
+{
+	Widget *self;
+	RECT clientRect;
+	SCROLLINFO scrollInfo;
+	INT dx, dy;
+
+	WIDGET_RET_VAL(self, hwnd, FALSE);
+	
+	
+	scrollInfo.cbSize = sizeof(scrollInfo);
+	scrollInfo.fMask = SIF_POS;
+
+	if (FALSE == GetClientRect(hwnd, &clientRect))
+		SetRectEmpty(&clientRect);
+
+	if (self->viewSize.cx < RECTWIDTH(clientRect))
+	{
+		scrollInfo.nPos = 0;
+		dx = scrollInfo.nPos + self->viewOrigin.x;
+		self->viewOrigin.x = 0;
+	}
+	else if (FALSE != GetScrollInfo(hwnd, SB_HORZ, &scrollInfo))
+	{
+		dx = scrollInfo.nPos + self->viewOrigin.x;
+		self->viewOrigin.x = -scrollInfo.nPos;
+	}
+	else
+		dx = 0;
+
+	if (FALSE != GetScrollInfo(hwnd, SB_VERT, &scrollInfo))
+	{
+		dy = scrollInfo.nPos + self->viewOrigin.y;
+		self->viewOrigin.y = -scrollInfo.nPos;
+	}
+	else
+		dy = 0;
+
+	if (0 == dx && 0 == dy)
+		return FALSE;
+
+	return Widget_ScrollContent(hwnd, dx, dy, redraw);
+}
+
+
+static BOOL
+Widget_ScrollWindow(HWND hwnd, INT dx, INT dy, BOOL redraw)
+{		
+	if (0 != dx)
+		dx = Widget_ScrollBarOffsetPos(hwnd, SB_HORZ, dx, redraw);
+	
+	if (0 != dy)
+		dy = Widget_ScrollBarOffsetPos(hwnd, SB_VERT, dy, redraw);
+
+	return Widget_ScrollContent(hwnd, dx, dy, redraw);
+}
+
+static BOOL
+Widget_ScrollBarAction(HWND hwnd, INT barType, INT actionLayout, INT line, BOOL redraw)
+{
+	INT delta;
+	SCROLLINFO scrollInfo;
+
+	scrollInfo.cbSize = sizeof(scrollInfo);
+	scrollInfo.fMask = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_TRACKPOS;
+	
+	if (FALSE == GetScrollInfo(hwnd, barType, &scrollInfo))
+		return FALSE;
+	
+	switch(actionLayout)
+	{
+		case SB_BOTTOM:
+			delta = scrollInfo.nMax - scrollInfo.nPos;
+			break;
+		case SB_TOP:
+			delta = scrollInfo.nMin - scrollInfo.nPos;
+			break;
+		case SB_LINEDOWN:
+			delta = line;
+			break;
+		case SB_LINEUP:
+			delta = -line;
+			break;
+		case SB_PAGEDOWN:
+			delta = (INT)scrollInfo.nPage;
+			break;
+		case SB_PAGEUP:
+			delta = -(INT)scrollInfo.nPage;
+			break;
+		case SB_THUMBTRACK:
+			delta = scrollInfo.nTrackPos - scrollInfo.nPos;
+			break;
+		case SB_THUMBPOSITION:
+		case SB_ENDSCROLL:
+			delta = 0;
+			break;
+		default:
+			return FALSE;
+	}
+	
+	if(0 != delta)
+	{
+		Widget_ScrollWindow(hwnd,  
+					(SB_HORZ == barType) ? delta : 0, 
+					(SB_VERT == barType) ? delta : 0,
+					redraw);
+	}
+	else
+		Widget_SyncContentOrigin(hwnd, redraw);
+
+	return TRUE;
+}
+
+static BOOL
+Widget_ScrollBarUpdate(HWND hwnd, INT barType, UINT page, INT max, BOOL redraw)
+{
+	Widget *self;
+	SCROLLINFO scrollInfo;
+	UINT windowStyle, styleFilter;
+
+	WIDGET_RET_VAL(self, hwnd, FALSE);
+
+	windowStyle = GetWindowStyle(hwnd);
+	
+	switch(barType)
+	{
+		case SB_HORZ:	styleFilter = WS_HSCROLL; break;
+		case SB_VERT:	styleFilter = WS_VSCROLL; break;
+		default:		return FALSE;
+	}
+	
+	scrollInfo.cbSize = sizeof(SCROLLINFO);
+	scrollInfo.fMask = SIF_PAGE | SIF_RANGE;
+
+	if (page >= (UINT)max)
+	{
+		if (0 == (styleFilter & windowStyle))
+			return FALSE;
+		
+		scrollInfo.nPage = page + 1;
+		scrollInfo.nMin = 0;
+		scrollInfo.nMax = max;
+		scrollInfo.nPos = scrollInfo.nMin;
+		scrollInfo.nTrackPos = scrollInfo.nPos;
+		scrollInfo.fMask |= (SIF_POS | SIF_TRACKPOS);
+
+		Widget_Freeze(self);
+		SetScrollInfo(hwnd, barType, &scrollInfo, redraw);
+		Widget_Thaw(self);
+
+		windowStyle = GetWindowStyle(hwnd);
+		if (0 != (styleFilter & windowStyle))
+			SetWindowStyle(hwnd, windowStyle & ~styleFilter);
+
+		return TRUE;
+	}
+
+	
+
+	if (FALSE == GetScrollInfo(hwnd, barType, &scrollInfo))
+	{
+		if (ERROR_NO_SCROLLBARS == GetLastError())
+		{			
+			scrollInfo.nPage = 0;
+			scrollInfo.nMax = 0;
+			scrollInfo.nMin = 0;
+			scrollInfo.nPos = scrollInfo.nMin;
+			scrollInfo.nTrackPos = scrollInfo.nPos;
+		}
+		else
+			return FALSE;
+	}
+	
+	scrollInfo.fMask = 0;
+	
+	if (scrollInfo.nPage != page)
+	{
+		scrollInfo.nPage = page;
+		scrollInfo.fMask |= SIF_PAGE;
+	}
+	
+	if (scrollInfo.nMax != max)
+	{
+		scrollInfo.nMax = max;
+		scrollInfo.fMask |= SIF_RANGE;
+	}
+	
+	if (0 == (styleFilter & windowStyle))
+	{
+		scrollInfo.fMask |= (SIF_POS | SIF_TRACKPOS);
+		scrollInfo.nPos = scrollInfo.nMin;
+		scrollInfo.nTrackPos = scrollInfo.nMin;
+	}
+
+	if (0 == scrollInfo.fMask)
+		return FALSE;
+	
+	Widget_Freeze(self);
+	SetScrollInfo(hwnd, barType, &scrollInfo, redraw);
+	Widget_Thaw(self);
+
+	
+	if (0 == (styleFilter & windowStyle))
+	{
+		windowStyle = GetWindowStyle(hwnd);
+		if (0 == (styleFilter & windowStyle))
+			SetWindowStyle(hwnd, windowStyle | styleFilter);
+
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+static void 
+Widget_Layout(HWND hwnd, BOOL redraw)
+{
+	Widget *self;
+	RECT rect;
+	size_t iteration;
+
+	WIDGET_RET_VOID(self, hwnd);
+
+	iteration = 0;
+	do
+	{
+		if (iteration++ > 2)
+			break;
+
+		if (FALSE == GetClientRect(hwnd, &rect))
+			break;
+
+		SetSize(&self->viewSize, 0, 0);
+	
+		if (NULL != self->callbacks->layout)
+		{
+			self->callbacks->layout(self->object, hwnd, self->style, &rect, &self->viewSize, redraw);
+		}
+
+		if (FALSE != IsSizeEmpty(&self->viewSize))
+			SetSize(&self->viewSize, RECTWIDTH(rect), RECTHEIGHT(rect));
+
+	}
+	while(FALSE != Widget_ScrollBarUpdate(hwnd, SB_HORZ, RECTWIDTH(rect), self->viewSize.cx, redraw) ||
+		  FALSE != Widget_ScrollBarUpdate(hwnd, SB_VERT, RECTHEIGHT(rect), self->viewSize.cy, redraw));
+
+	Widget_SyncContentOrigin(hwnd, redraw);
+}
+
+static BOOL
+Widget_Paint(HWND hwnd, HDC hdc, const RECT *paintRect, BOOL erase)
+{
+	Widget *self;
+	BOOL result;
+		
+	self = WIDGET(hwnd);
+	if (NULL == self || NULL == self->style)
+		return FALSE;
+			
+	
+	if (NULL != self->callbacks->paint)
+	{
+		POINT prevOrigin;
+		RECT viewRect;
+
+		CopyRect(&viewRect, paintRect);
+		OffsetRect(&viewRect, -self->viewOrigin.x, -self->viewOrigin.y);
+
+		OffsetViewportOrgEx(hdc, self->viewOrigin.x, self->viewOrigin.y, &prevOrigin);
+
+		result = self->callbacks->paint(self->object, hwnd, 
+							self->style, hdc, &viewRect, erase);
+
+		SetViewportOrgEx(hdc, prevOrigin.x, prevOrigin.y, NULL);
+	}
+	else
+		result = FALSE;
+	
+	if (FALSE == result)
+	{
+		if (FALSE != erase)
+			result = FillRect(hdc, paintRect, WIDGETSTYLE_BACK_BRUSH(self->style));
+		else
+			result = TRUE;
+	}
+
+	return result;
+}
+
+static void
+Widget_FocusChanged(HWND hwnd, HWND focusWindow, BOOL focusReceived)
+{
+	Widget *self;
+	WIDGET_RET_VOID(self, hwnd);
+
+	if (NULL != self->callbacks && 
+		NULL != self->callbacks->focusChanged)
+	{
+		self->callbacks->focusChanged(self->object, hwnd, focusWindow, focusReceived);
+	}
+}
+
+static LRESULT
+Widget_OnCreate(HWND hwnd, CREATESTRUCT *createStruct)
+{	
+	Widget *self;
+	WidgetCreateParam *createParam;
+	
+	if (NULL == createStruct)
+		return -1;
+
+	createParam = (WidgetCreateParam*)createStruct->lpCreateParams;
+	if (NULL == createParam)
+		return -1;
+
+	self = (Widget*)malloc(sizeof(Widget));
+	if (NULL == self)
+		return -1;
+
+	SetLastError(ERROR_SUCCESS);
+	if (!SetWindowLongPtr(hwnd, 0, (LONGX86)self) && ERROR_SUCCESS != GetLastError())
+		return -1;
+
+	memset(self, 0, sizeof(Widget));
+
+	if (WM_NULL == WINAMP_WM_DIRECT_MOUSE_WHEEL)
+		WINAMP_WM_DIRECT_MOUSE_WHEEL = RegisterWindowMessageW(L"WINAMP_WM_DIRECT_MOUSE_WHEEL");
+
+	self->type = createParam->type;
+	self->callbacks = createParam->callbacks;
+	
+	Widget_Freeze(self);
+
+	if (NULL != createParam->text)
+		SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM)createParam->text);
+
+	MLSkinWindow2(Plugin_GetLibraryWindow(), hwnd, SKINNEDWND_TYPE_SCROLLWND, 
+				SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS);
+
+	if (NULL != self->callbacks->init &&
+		FALSE == self->callbacks->init(hwnd, &self->object, createParam->param))
+	{
+		return -1;
+	}
+	
+	Widget_Thaw(self);
+
+	return 0;
+}
+
+static void
+Widget_OnDestroy(HWND hwnd)
+{
+	Widget *self;
+
+	self = WIDGET(hwnd);
+	SetWindowLongPtr(hwnd, 0, 0);
+	
+	if (NULL == self)
+		return;
+	
+	Widget_Freeze(self);
+
+	if (NULL != self->callbacks->destroy)
+		self->callbacks->destroy(self->object, hwnd);
+
+	String_Free(self->text);
+
+	free(self);
+}
+
+static void
+Widget_OnPaint(HWND hwnd)
+{
+	PAINTSTRUCT ps;
+	
+	if (NULL != BeginPaint(hwnd, &ps))
+	{		
+		if (FALSE == Widget_Paint(hwnd, ps.hdc, &ps.rcPaint, ps.fErase))
+		{
+			COLORREF backColor, prevBackColor;
+
+			backColor = Graphics_GetSkinColor(WADLG_WNDBG);
+			prevBackColor = SetBkColor(ps.hdc, backColor);
+
+			ExtTextOut(ps.hdc, 0, 0, ETO_OPAQUE, &ps.rcPaint, NULL, 0, NULL);
+			SetBkColor(ps.hdc, prevBackColor);
+		}
+		EndPaint(hwnd, &ps);
+	}
+}
+
+static void 
+Widget_OnPrintClient(HWND hwnd, HDC hdc, UINT options)
+{	
+	RECT clientRect;
+	if (GetClientRect(hwnd, &clientRect))
+	{
+		Widget_Paint(hwnd, hdc, &clientRect, TRUE);
+	}
+}
+
+static void
+Widget_OnWindowPosChanged(HWND hwnd, WINDOWPOS *windowPos)
+{
+	if ((SWP_NOSIZE | SWP_NOMOVE) != ((SWP_NOSIZE | SWP_NOMOVE | SWP_FRAMECHANGED) & windowPos->flags))
+	{
+		Widget *self;
+		WIDGET_RET_VOID(self, hwnd);
+
+		if (FALSE != WIDGET_IS_FROZEN(self))
+			return;
+
+		Widget_Layout(hwnd, 0 == (SWP_NOREDRAW & windowPos->flags));
+	}
+}
+
+static LRESULT 
+Widget_OnSetText(HWND hwnd, LPCWSTR text)
+{
+	Widget *self;
+	WIDGET_RET_VAL(self, hwnd, FALSE);
+	
+	String_Free(self->text);
+
+	if (NULL == text)
+		self->text = NULL;
+	else if (FALSE != IS_INTRESOURCE(text))
+	{
+		WCHAR buffer[4096] = {0};
+		ResourceString_CopyTo(buffer, text, ARRAYSIZE(buffer));
+		self->text = String_Duplicate(buffer);
+	}
+	else
+		self->text = String_Duplicate(text);
+
+	return TRUE;
+}
+
+static LRESULT 
+Widget_OnGetText(HWND hwnd, LPWSTR buffer, size_t bufferMax)
+{
+	Widget *self;
+
+	WIDGET_RET_VAL(self, hwnd, 0);
+
+	return String_CopyTo(buffer, self->text, bufferMax);
+}
+
+static LRESULT 
+Widget_OnGetTextLength(HWND hwnd)
+{
+	Widget *self;
+	WIDGET_RET_VAL(self, hwnd, 0);
+
+	return ( NULL != self->text) ? lstrlenW(self->text) : 0;
+}
+
+
+static void 
+Widget_OnSetFont(HWND hwnd, HFONT font, BOOL redraw)
+{
+	Widget *self;
+
+	WIDGET_RET_VOID(self, hwnd);
+
+	self->font = font;
+
+	if (NULL != redraw)
+		InvalidateRect(hwnd, NULL, TRUE);
+}
+
+static HFONT
+Widget_OnGetFont(HWND hwnd)
+{
+	Widget *self;
+	WIDGET_RET_VAL(self, hwnd, NULL);
+
+	return self->font;
+}
+
+static void
+Widget_OnVertScroll(HWND hwnd, INT actionLayout, INT trackPosition, HWND scrollBar)
+{
+	Widget *self;
+	WIDGET_RET_VOID(self, hwnd);
+
+	Widget_ScrollBarAction(hwnd, SB_VERT, actionLayout, self->style->unitSize.cy, TRUE);
+}
+
+static void
+Widget_OnHorzScroll(HWND hwnd, INT actionLayout, INT trackPosition, HWND scrollBar)
+{
+	Widget *self;
+	WIDGET_RET_VOID(self, hwnd);
+
+	Widget_ScrollBarAction(hwnd, SB_HORZ, actionLayout, self->style->unitSize.cx, TRUE);
+}
+
+static void
+Widget_OnMouseWheel(HWND hwnd, INT virtualKeys, INT distance, LONG pointer_s)
+{
+	Widget *self;
+	UINT wheelScroll;
+	INT  scrollLines;
+	UINT windowStyle;
+	INT barType;
+
+	WIDGET_RET_VOID(self, hwnd);
+
+	windowStyle = GetWindowStyle(hwnd);
+
+	if (0 != (WS_VSCROLL & windowStyle))
+		barType = SB_VERT;
+	else if (0 != (WS_HSCROLL & windowStyle))
+		barType = SB_HORZ;
+	else
+		return;
+
+	if (FALSE == SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &wheelScroll, 0))
+        wheelScroll = 3; 
+
+	if (0 == wheelScroll)
+		return;
+    
+	if (WHEEL_PAGESCROLL == wheelScroll)
+	{
+		RECT clientRect;
+		GetClientRect(hwnd, &clientRect);
+		if (SB_VERT == barType)
+			wheelScroll = RECTHEIGHT(clientRect)/self->style->unitSize.cy;
+		else
+			wheelScroll = RECTWIDTH(clientRect)/self->style->unitSize.cx;
+    }
+
+	distance += self->wheelCarryover; 
+	scrollLines = distance * (INT)wheelScroll / WHEEL_DELTA;
+
+	self->wheelCarryover = distance - scrollLines * WHEEL_DELTA / (INT)wheelScroll;
+	
+	if (FALSE != Widget_ScrollWindow(hwnd, 
+						(SB_HORZ == barType) ? -(scrollLines * self->style->unitSize.cx) : 0,
+						(SB_VERT == barType) ? -(scrollLines * self->style->unitSize.cy) : 0,
+						TRUE))
+	{
+		
+	}
+
+}
+
+
+static void
+Widget_OnMouseMove(HWND hwnd, unsigned int vKeys, long cursor_s)
+{
+	Widget *self;
+	WIDGET_RET_VOID(self, hwnd);
+
+	if (NULL != self->callbacks && NULL != self->callbacks->mouseMove)
+	{
+		BOOL processed;
+		POINT cursor;
+		POINTSTOPOINT(cursor, cursor_s);
+		
+		
+		processed = self->callbacks->mouseMove(self->object, hwnd, vKeys, &cursor);
+
+		if (FALSE == WIDGET_IS_MOUSE_MOVE_TRACKED(self))
+		{
+			TRACKMOUSEEVENT trackMouse;
+			trackMouse.cbSize = sizeof(trackMouse);
+			trackMouse.dwFlags = TME_LEAVE;
+			trackMouse.hwndTrack = hwnd;
+			if (FALSE != TrackMouseEvent(&trackMouse))
+				WIDGET_SET_MOUSE_MOVE_TRACK(self);
+		}
+
+		if (FALSE != processed)
+			return;
+	}
+
+	DefWindowProc(hwnd, WM_MOUSEMOVE, (WPARAM)vKeys, (LPARAM)cursor_s);
+}
+
+static void
+Widget_OnMouseLeave(HWND hwnd)
+{
+	Widget *self;
+	WIDGET_RET_VOID(self, hwnd);
+
+	WIDGET_UNSET_MOUSE_MOVE_TRACK(self);
+
+	if (NULL != self->callbacks && NULL != self->callbacks->mouseMove)
+	{
+		POINT cursor;
+		cursor.x = 0xEFFFFFFF;
+		cursor.y = 0xEFFFFFFF;
+			
+		if (FALSE != self->callbacks->mouseMove(self->object, hwnd, 0, &cursor))
+			return;
+	}
+	
+	DefWindowProc(hwnd, WM_MOUSELEAVE, 0, 0L);
+
+}
+
+static void
+Widget_OnLeftButtonDown(HWND hwnd, unsigned int vKeys, long cursor_s)
+{
+	Widget *self;
+	WIDGET_RET_VOID(self, hwnd);
+	
+	if (NULL != self->callbacks && NULL != self->callbacks->leftButtonDown)
+	{
+		POINT cursor;
+		POINTSTOPOINT(cursor, cursor_s);
+		if (FALSE != self->callbacks->leftButtonDown(self->object, hwnd, vKeys, &cursor))
+			return;
+	}
+
+	DefWindowProc(hwnd, WM_LBUTTONDOWN, (WPARAM)vKeys, (LPARAM)cursor_s);
+
+}
+
+static void
+Widget_OnLeftButtonUp(HWND hwnd, unsigned int vKeys, long cursor_s)
+{
+	Widget *self;
+	WIDGET_RET_VOID(self, hwnd);
+
+	if (NULL != self->callbacks && NULL != self->callbacks->leftButtonUp)
+	{
+		POINT cursor;
+		POINTSTOPOINT(cursor, cursor_s);
+		if (FALSE != self->callbacks->leftButtonUp(self->object, hwnd, vKeys, &cursor))
+			return;
+	}
+
+	DefWindowProc(hwnd, WM_LBUTTONUP, (WPARAM)vKeys, (LPARAM)cursor_s);
+}
+
+static void
+Widget_OnLeftButtonDblClk(HWND hwnd, unsigned int vKeys, long cursor_s)
+{
+	Widget *self;
+	WIDGET_RET_VOID(self, hwnd);
+	
+	if (NULL != self->callbacks && NULL != self->callbacks->leftButtonDblClk)
+	{
+		POINT cursor;
+		POINTSTOPOINT(cursor, cursor_s);
+		if (FALSE != self->callbacks->leftButtonDblClk(self->object, hwnd, vKeys, &cursor))
+			return;
+	}
+	DefWindowProc(hwnd, WM_LBUTTONDBLCLK, (WPARAM)vKeys, (LPARAM)cursor_s);
+}
+
+static void
+Widget_OnRightButtonDown(HWND hwnd, unsigned int vKeys, long cursor_s)
+{
+	Widget *self;
+	WIDGET_RET_VOID(self, hwnd);
+	
+	if (NULL != self->callbacks && NULL != self->callbacks->rightButtonDown)
+	{
+		POINT cursor;
+		POINTSTOPOINT(cursor, cursor_s);
+		if (FALSE != self->callbacks->rightButtonDown(self->object, hwnd, vKeys, &cursor))
+			return;
+	}
+
+	DefWindowProc(hwnd, WM_RBUTTONDOWN, (WPARAM)vKeys, (LPARAM)cursor_s);
+
+}
+
+static void
+Widget_OnRightButtonUp(HWND hwnd, unsigned int vKeys, long cursor_s)
+{
+	Widget *self;
+	WIDGET_RET_VOID(self, hwnd);
+
+	if (NULL != self->callbacks && NULL != self->callbacks->rightButtonUp)
+	{
+		POINT cursor;
+		POINTSTOPOINT(cursor, cursor_s);
+		if (FALSE != self->callbacks->rightButtonUp(self->object, hwnd, vKeys, &cursor))
+			return;
+	}
+
+	DefWindowProc(hwnd, WM_RBUTTONUP, (WPARAM)vKeys, (LPARAM)cursor_s);
+}
+
+static void
+Widget_OnKeyDown(HWND hwnd, unsigned int vKey, unsigned int flags)
+{
+	Widget *self;
+	WIDGET_RET_VOID(self, hwnd);
+
+	if (NULL != self->callbacks && 
+		NULL != self->callbacks->keyDown &&
+		FALSE != self->callbacks->keyDown(self->object, hwnd, vKey, flags))
+	{
+		return;
+	}
+
+	DefWindowProc(hwnd, WM_KEYDOWN, (WPARAM)vKey, (LPARAM)flags);
+
+}
+
+static void
+Widget_OnKeyUp(HWND hwnd, unsigned int vKey, unsigned int flags)
+{
+	Widget *self;
+	self = WIDGET(hwnd);
+
+	if (NULL !=  self &&
+		NULL != self->callbacks && 
+		NULL != self->callbacks->keyUp &&
+		FALSE != self->callbacks->keyUp(self->object, hwnd, vKey, flags))
+	{
+		return;
+	}
+
+	DefWindowProc(hwnd, WM_KEYUP, (WPARAM)vKey, (LPARAM)flags);
+}
+
+static void
+Widget_OnChar(HWND hwnd, unsigned int vKey, unsigned int flags)
+{
+	Widget *self;
+	self = WIDGET(hwnd);
+
+	if (NULL !=  self &&
+		NULL != self->callbacks && 
+		NULL != self->callbacks->character &&
+		FALSE != self->callbacks->character(self->object, hwnd, vKey, flags))
+	{
+		return;
+	}
+
+	DefWindowProc(hwnd, WM_CHAR, (WPARAM)vKey, (LPARAM)flags);
+}
+
+static unsigned int
+Widget_OnGetDlgCode(HWND hwnd, unsigned int vKey, MSG *message)
+{
+	Widget *self;
+	self = WIDGET(hwnd);
+	
+	if (NULL != self &&
+		NULL != self->callbacks && 
+		NULL != self->callbacks->inputRequest)
+	{
+		return self->callbacks->inputRequest(self->object, hwnd, vKey, message);
+	}
+
+	return (unsigned int)DefWindowProc(hwnd, WM_GETDLGCODE, (WPARAM)vKey, (LPARAM)message);
+}
+
+
+static void
+Widget_OnSetFocus(HWND hwnd, HWND focusWindow)
+{
+	Widget_FocusChanged(hwnd, focusWindow, TRUE);
+}
+
+static void
+Widget_OnKillFocus(HWND hwnd, HWND focusWindow)
+{
+	Widget_FocusChanged(hwnd, focusWindow, FALSE);
+}
+
+static void
+Widget_OnContextMenu(HWND hwnd, HWND targetWindow, long cursor_s)
+{
+	BOOL processed;
+	Widget *self;
+	WIDGET_RET_VOID(self, hwnd);
+	
+	if (NULL != self->callbacks && NULL != self->callbacks->contextMenu)
+	{
+		POINT cursor;
+		POINTSTOPOINT(cursor, cursor_s);
+		processed = self->callbacks->contextMenu(self->object, hwnd, targetWindow, &cursor);
+	}
+	else
+		processed = FALSE;
+
+	if (FALSE == processed)
+		Widget_DefWindowProc(hwnd, WM_CONTEXTMENU, (WPARAM)targetWindow, (LPARAM)cursor_s);
+}
+
+static unsigned int
+Widget_OnGetType(HWND hwnd)
+{
+	Widget *self;
+	WIDGET_RET_VAL(self, hwnd, WIDGET_TYPE_UNKNOWN);
+
+	return self->type;
+}
+
+static void*
+Widget_OnGetSelf(HWND hwnd)
+{
+	Widget *self;
+	WIDGET_RET_VAL(self, hwnd, NULL);
+	
+	return self->object;
+}
+
+static BOOL
+Widget_OnSetStyle(HWND hwnd, WidgetStyle *style)
+{
+	Widget *self;
+	BOOL styleChanged;
+
+	WIDGET_RET_VAL(self, hwnd, FALSE);
+
+	styleChanged = (self->style != style);
+
+	self->style = style;
+
+	if (FALSE != styleChanged)
+	{
+		if (NULL != WIDGETCALLBACKS(self))
+		{			
+			if (NULL != WIDGETCALLBACKS(self)->styleColorChanged)
+				 WIDGETCALLBACKS(self)->styleColorChanged(WIDGETOBJECT(self), hwnd, WIDGETSTYLE(self));
+
+			if (NULL != WIDGETCALLBACKS(self)->styleFontChanged)
+				 WIDGETCALLBACKS(self)->styleFontChanged(WIDGETOBJECT(self), hwnd, WIDGETSTYLE(self));
+		}
+	}
+	
+	return TRUE;
+}
+
+static WidgetStyle *
+Widget_OnGetStyle(HWND hwnd)
+{
+	Widget *self;
+	WIDGET_RET_VAL(self, hwnd, NULL);
+
+	return self->style;
+}
+
+static void 
+Widget_OnStyleColorChanged(HWND hwnd)
+{
+	Widget *self;
+	
+	WIDGET_RET_VOID(self, hwnd);
+
+	if (FALSE != WIDGET_IS_FROZEN(self))
+			return;
+
+	if (NULL != WIDGETCALLBACKS(self) &&
+		NULL != WIDGETCALLBACKS(self)->styleColorChanged)
+	{
+		 WIDGETCALLBACKS(self)->styleColorChanged(WIDGETOBJECT(self), hwnd, WIDGETSTYLE(self));
+	}
+}
+
+static void
+Widget_OnStyleFontChanged(HWND hwnd)
+{
+	Widget *self;
+	
+	WIDGET_RET_VOID(self, hwnd);
+
+	if (FALSE != WIDGET_IS_FROZEN(self))
+			return;
+
+	if (NULL != WIDGETCALLBACKS(self) &&
+		NULL != WIDGETCALLBACKS(self)->styleFontChanged)
+	{
+		 WIDGETCALLBACKS(self)->styleFontChanged(WIDGETOBJECT(self), hwnd, WIDGETSTYLE(self));
+	}
+}
+
+static void
+Widget_OnFreeze(HWND hwnd, BOOL freeze)
+{
+	Widget *self;
+	
+	WIDGET_RET_VOID(self, hwnd);
+
+	if (FALSE == freeze)
+		Widget_Thaw(self);
+	else
+		Widget_Freeze(self);
+}
+
+static BOOL
+Widget_OnScroll(HWND hwnd, int dx, int dy, BOOL redraw)
+{
+	return Widget_ScrollWindow(hwnd, dx, dy, redraw);
+}
+
+static LRESULT
+Widget_OnSetScrollPos(HWND hwnd, int dx, int dy, BOOL redraw)
+{
+	if (0 != dx)
+		dx = Widget_ScrollBarOffsetPos(hwnd, SB_HORZ, dx, redraw);
+	
+	if (0 != dy)
+		dy = Widget_ScrollBarOffsetPos(hwnd, SB_VERT, dy, redraw);
+
+	return (LRESULT)MAKELONG(dx, dy);
+
+}
+
+static void
+Widget_OnZoomSliderPosChanging(HWND hwnd, NMTRBTHUMBPOSCHANGING *sliderInfo)
+{
+	Widget *self;
+	WIDGET_RET_VOID(self, hwnd);
+
+	if (NULL != WIDGETCALLBACKS(self) &&
+		NULL != WIDGETCALLBACKS(self)->zoomChanging)
+	{
+		WIDGETCALLBACKS(self)->zoomChanging(WIDGETOBJECT(self), hwnd, sliderInfo);
+	}
+}
+
+static LRESULT
+Widget_OnNotify(HWND hwnd, NMHDR *notification)
+{
+	Widget *self;
+
+	self = WIDGET(hwnd);
+	if (NULL != self && 
+		NULL != self->callbacks && 
+		NULL != self->callbacks->notify)
+	{
+		LRESULT result;
+		if (FALSE != self->callbacks->notify(WIDGETOBJECT(self), hwnd, notification, &result))
+			return result;
+	}
+	
+	return Widget_DefWindowProc(hwnd, WM_NOTIFY, 
+				(WPARAM)notification->idFrom, (LPARAM)notification);
+}
+
+static BOOL
+Widget_OnEnableChildrenScroll(HWND hwnd, BOOL enable)
+{
+	Widget *self;
+	BOOL previous;
+
+	WIDGET_RET_VAL(self, hwnd, FALSE);
+
+	previous = (FALSE == WIDGET_IS_CHILDREN_SCROLL_DISABLED(self));
+	
+	if (FALSE != enable)
+		WIDGET_UNSET_DISABLE_CHILDREN_SCROLL(self);
+	else
+		WIDGET_SET_DISABLE_CHILDREN_SCROLL(self);
+
+	return previous;
+}
+
+static BOOL
+Widget_OnGetChildrenScrollEnabled(HWND hwnd)
+{
+	Widget *self;
+	WIDGET_RET_VAL(self, hwnd, FALSE);
+
+	return (FALSE == WIDGET_IS_CHILDREN_SCROLL_DISABLED(self));
+
+}
+static LRESULT CALLBACK 
+Widget_WindowProc(HWND hwnd, unsigned int uMsg, WPARAM wParam, LPARAM lParam)
+{
+	switch(uMsg)
+	{
+		case WM_CREATE:				return Widget_OnCreate(hwnd, (CREATESTRUCT*)lParam);
+		case WM_DESTROY:			Widget_OnDestroy(hwnd); return 0;
+		case WM_PAINT:				Widget_OnPaint(hwnd); return 0;
+		case WM_PRINTCLIENT:		Widget_OnPrintClient(hwnd, (HDC)wParam, (UINT)lParam); return 0;
+		case WM_PRINT:				return 0;
+		case WM_ERASEBKGND:			return 0;
+		case WM_WINDOWPOSCHANGED:	Widget_OnWindowPosChanged(hwnd, (WINDOWPOS*)lParam); return 0;
+		case WM_SIZE:				return 0;
+		case WM_MOVE:				return 0;
+		case WM_SETTEXT:			return Widget_OnSetText(hwnd, (LPCWSTR)lParam);
+		case WM_GETTEXT:			return Widget_OnGetText(hwnd, (LPWSTR)lParam, (INT)wParam);
+		case WM_GETTEXTLENGTH:		return Widget_OnGetTextLength(hwnd);
+		case WM_SETFONT:			Widget_OnSetFont(hwnd, (HFONT)wParam, (BOOL)LOWORD(lParam)); return 0;
+		case WM_GETFONT:			return (LRESULT)Widget_OnGetFont(hwnd);
+		case WM_VSCROLL:			Widget_OnVertScroll(hwnd, LOWORD(wParam), (short)HIWORD(wParam), (HWND)lParam); return 0;
+		case WM_HSCROLL:			Widget_OnHorzScroll(hwnd, LOWORD(wParam), (short)HIWORD(wParam), (HWND)lParam); return 0;
+		case WM_MOUSEWHEEL:			Widget_OnMouseWheel(hwnd, LOWORD(wParam), (short)HIWORD(wParam), (LONG)lParam); return 0;
+		case WM_MOUSEMOVE:			Widget_OnMouseMove(hwnd, (unsigned int)wParam, (long)lParam); return 0;
+		case WM_MOUSELEAVE:			Widget_OnMouseLeave(hwnd); return 0;
+		case WM_LBUTTONDOWN:		Widget_OnLeftButtonDown(hwnd, (unsigned int)wParam, (long)lParam); return 0;
+		case WM_LBUTTONUP:			Widget_OnLeftButtonUp(hwnd, (unsigned int)wParam, (long)lParam); return 0;
+		case WM_LBUTTONDBLCLK:		Widget_OnLeftButtonDblClk(hwnd, (unsigned int)wParam, (long)lParam); return 0;
+		case WM_RBUTTONDOWN:		Widget_OnRightButtonDown(hwnd, (unsigned int)wParam, (long)lParam); return 0;
+		case WM_RBUTTONUP:			Widget_OnRightButtonUp(hwnd, (unsigned int)wParam, (long)lParam); return 0;
+		case WM_KEYDOWN:			Widget_OnKeyDown(hwnd, (unsigned int)wParam, (unsigned int)lParam); return 0;			
+		case WM_KEYUP:				Widget_OnKeyUp(hwnd, (unsigned int)wParam, (unsigned int)lParam); return 0;
+		case WM_CHAR:				Widget_OnChar(hwnd, (unsigned int)wParam, (unsigned int)lParam); return 0;
+		case WM_GETDLGCODE:			return Widget_OnGetDlgCode(hwnd, (unsigned int)wParam, (MSG*)lParam);
+		case WM_SETFOCUS:			Widget_OnSetFocus(hwnd, (HWND)wParam); return 0;
+		case WM_KILLFOCUS:			Widget_OnKillFocus(hwnd, (HWND)wParam); return 0;
+		case WM_CONTEXTMENU:		Widget_OnContextMenu(hwnd, (HWND)wParam, (long)lParam); return 0;
+		case WM_NOTIFY:				return Widget_OnNotify(hwnd, (NMHDR*)lParam);
+
+		case WIDGET_WM_GET_TYPE:			return (LRESULT)Widget_OnGetType(hwnd);
+		case WIDGET_WM_GET_SELF:			return (LRESULT)Widget_OnGetSelf(hwnd);
+		case WIDGET_WM_SET_STYLE:			return Widget_OnSetStyle(hwnd, (WidgetStyle*)lParam); 
+		case WIDGET_WM_GET_STYLE:			return (LRESULT)Widget_OnGetStyle(hwnd);
+		case WIDGET_WM_STYLE_COLOR_CHANGED: Widget_OnStyleColorChanged(hwnd); return 0;
+		case WIDGET_WM_STYLE_FONT_CHANGED:	Widget_OnStyleFontChanged(hwnd); return 0;
+		case WIDGET_WM_FREEZE:				Widget_OnFreeze(hwnd, (BOOL)wParam); return 0;
+		case WIDGET_WM_SET_SCROLL_POS:		return Widget_OnSetScrollPos(hwnd, (short)LOWORD(lParam), (short)HIWORD(lParam), (BOOL)wParam);
+		case WIDGET_WM_SCROLL:				return Widget_OnScroll(hwnd, (short)LOWORD(lParam), (short)HIWORD(lParam), (BOOL)wParam);
+		case WIDGET_WM_ZOOM_SLIDER_POS_CHANGING: Widget_OnZoomSliderPosChanging(hwnd, (NMTRBTHUMBPOSCHANGING*)lParam); return 0;
+		case WIDGET_WM_ENABLE_CHILDREN_SCROLL:		return Widget_OnEnableChildrenScroll(hwnd, (BOOL)lParam);
+		case WIDGET_WM_GET_CHILDREN_SCROLL_ENABLED:	return Widget_OnGetChildrenScrollEnabled(hwnd);
+	}
+
+	if (WINAMP_WM_DIRECT_MOUSE_WHEEL == uMsg && 
+		WM_NULL != WINAMP_WM_DIRECT_MOUSE_WHEEL)
+	{
+		Widget_OnMouseWheel(hwnd, LOWORD(wParam), (SHORT)HIWORD(wParam), (LONG)lParam);
+		return TRUE;
+	}
+
+	return Widget_DefWindowProc(hwnd, uMsg, wParam, lParam);
+}
+