steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/Plugins/Library/ml_devices/widget.cpp

1285 lines
30 KiB
C++
Raw Blame History

#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);
}
Reference in New Issue View Git Blame Copy Permalink