diff options
Diffstat (limited to 'Src/Plugins/Library/ml_devices/widget.cpp')
| -rw-r--r-- | Src/Plugins/Library/ml_devices/widget.cpp | 1284 |
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); +} + |