1838 lines
44 KiB
C++
1838 lines
44 KiB
C++
#include "main.h"
|
|
|
|
#include "../Winamp/gen.h"
|
|
#include "../gen_ml/ml.h"
|
|
#include "../gen_ml/ml_ipc_0313.h"
|
|
|
|
#define WM_EX_GETREALLIST (WM_USER + 0x01)
|
|
#define WM_EX_UNLOCKREDRAW (WM_USER + 0x02)
|
|
#define WM_EX_UPDATESCROLLINFO (WM_USER + 0x03)
|
|
#define WM_EX_GETCOUNTPERPAGE (WM_USER + 0x04)
|
|
|
|
#define LVN_EX_SIZECHANGED (LVN_LAST)
|
|
|
|
#define IWF_NORMAL 0x0000
|
|
#define IWF_ERASE 0x0001
|
|
#define IWF_UPDATENOW 0x0002
|
|
#define IWF_FRAME 0x0004
|
|
|
|
|
|
typedef enum ScrollPosFlags
|
|
{
|
|
SPF_NORMAL = 0,
|
|
SPF_NOREDRAW = (1 << 0),
|
|
SPF_FORCE = (1 << 1),
|
|
SPF_RELATIVE = (1 << 2),
|
|
} ScrollPosFlags;
|
|
DEFINE_ENUM_FLAG_OPERATORS(ScrollPosFlags);
|
|
|
|
BOOL
|
|
CopyListColumnToHeaderItem(const LVCOLUMNW *column, HDITEMW *item);
|
|
BOOL
|
|
CopyHeaderItemToListColumn(const HDITEMW *item, LVCOLUMNW *column);
|
|
|
|
|
|
typedef enum PostProcessKeyCommands
|
|
{
|
|
PostProcessKeyCmd_Nothing = 0,
|
|
PostProcessKeyCmd_UpdateScrollPos = (1 << 0),
|
|
PostProcessKeyCmd_EnsureFocusVisible = (1 << 1),
|
|
} PostProcessKeyCommands;
|
|
DEFINE_ENUM_FLAG_OPERATORS(PostProcessKeyCommands);
|
|
|
|
typedef struct SmoothScrollList
|
|
{
|
|
unsigned int itemHeight;
|
|
unsigned int textHeight;
|
|
long viewHeight;
|
|
unsigned int listFontHeight;
|
|
unsigned int headerFontHeight;
|
|
int wheelCarryover;
|
|
} SmoothScrollList;
|
|
|
|
#define GetUserData(hwnd) ((SmoothScrollList*)(LONG_PTR)GetWindowLongPtrW(hwnd, GWLP_USERDATA))
|
|
|
|
|
|
static LRESULT
|
|
SubclassedListView_CallPrevWndProc(HWND hwnd, unsigned int message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
WNDPROC windowProc;
|
|
|
|
windowProc = (WNDPROC)(LONG_PTR)GetWindowLongPtrW(hwnd,GWLP_USERDATA);
|
|
if (NULL == windowProc)
|
|
return DefWindowProcW(hwnd, message, wParam, lParam);
|
|
|
|
return CallWindowProcW(windowProc, hwnd, message,wParam,lParam);
|
|
}
|
|
|
|
static BOOL
|
|
GetViewRect(HWND hwnd, RECT *prc)
|
|
{
|
|
HWND headerWindow;
|
|
GetClientRect(hwnd, prc);
|
|
headerWindow = GetDlgItem(hwnd, 3);
|
|
if (NULL != headerWindow)
|
|
{
|
|
RECT rh;
|
|
GetWindowRect(headerWindow, &rh);
|
|
MapWindowPoints(HWND_DESKTOP, headerWindow, ((POINT*)&rh) + 1, 1);
|
|
prc->top = rh.bottom;
|
|
}
|
|
|
|
if (prc->right < prc->left)
|
|
prc->right = prc->left;
|
|
|
|
if (prc->bottom < prc->top)
|
|
prc->bottom = prc->top;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static int
|
|
SmoothScrollList_GetScrollPosFromItem(HWND hwnd, int iItem)
|
|
{
|
|
HWND listWindow;
|
|
RECT listRect, viewRect;
|
|
int pos;
|
|
int count;
|
|
|
|
pos = 0;
|
|
|
|
if (FALSE == GetViewRect(hwnd, &viewRect))
|
|
return 0;
|
|
|
|
listWindow = GetDlgItem(hwnd, 2);
|
|
if (NULL == listWindow ||
|
|
FALSE == GetWindowRect(listWindow, &listRect))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
MapWindowPoints(HWND_DESKTOP, hwnd, (POINT*)&listRect, 2);
|
|
|
|
count = (int)SendMessageW(listWindow, LVM_GETITEMCOUNT, 0, 0L);
|
|
if (0 != count)
|
|
{
|
|
SmoothScrollList *self;
|
|
|
|
if (iItem < 0)
|
|
iItem = 0;
|
|
|
|
if (iItem >= count)
|
|
iItem = count - 1;
|
|
|
|
self = GetUserData(hwnd);
|
|
if (NULL != self)
|
|
pos = iItem * self->itemHeight;
|
|
}
|
|
|
|
pos += (viewRect.top - listRect.top);
|
|
return pos;
|
|
}
|
|
|
|
static BOOL
|
|
UpdateScrollInfo(HWND hwndView, UINT fFlags, BOOL bRedraw)
|
|
{
|
|
RECT rv;
|
|
HWND hwndList;
|
|
SCROLLINFO si;
|
|
BOOL needUpdate;
|
|
BOOL needRedraw;
|
|
HRGN regionUpdate, regionTemp;
|
|
|
|
SmoothScrollList* s = GetUserData(hwndView);
|
|
|
|
hwndList = GetDlgItem(hwndView, 2);
|
|
if (!s || !hwndList ) return FALSE;
|
|
|
|
if (FALSE!= bRedraw)
|
|
{
|
|
GetWindowRect(hwndView, &rv);
|
|
MapWindowPoints(HWND_DESKTOP, hwndView, (POINT*)&rv, 2);
|
|
regionUpdate = CreateRectRgnIndirect(&rv);
|
|
GetClientRect(hwndView, &rv);
|
|
regionTemp = CreateRectRgnIndirect(&rv);
|
|
CombineRgn(regionUpdate, regionUpdate, regionTemp, RGN_DIFF);
|
|
}
|
|
else
|
|
{
|
|
regionUpdate = NULL;
|
|
regionTemp = NULL;
|
|
}
|
|
|
|
si.cbSize = sizeof(SCROLLINFO);
|
|
si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
|
|
|
|
if (!GetScrollInfo(hwndView, SB_VERT, &si))
|
|
return FALSE;
|
|
|
|
if (FALSE == GetViewRect(hwndView, &rv))
|
|
SetRectEmpty(&rv);
|
|
|
|
needUpdate = FALSE;
|
|
needRedraw = FALSE;
|
|
|
|
if (SIF_RANGE & fFlags)
|
|
{
|
|
unsigned int count, nPage, nMax;
|
|
|
|
nPage = rv.bottom - rv.top;
|
|
|
|
count = (INT)SendMessageW(hwndList, LVM_GETITEMCOUNT, 0, 0L);
|
|
nMax = count * s->itemHeight;
|
|
|
|
if (si.nPage != nPage || si.nMax != nMax)
|
|
{
|
|
BOOL forcePos;
|
|
unsigned int windowStyle;
|
|
|
|
si.fMask = SIF_PAGE | SIF_RANGE;
|
|
si.nPage = nPage;
|
|
si.nMax = nMax;
|
|
|
|
windowStyle = GetWindowLongPtrW(hwndView, GWL_STYLE);
|
|
|
|
SetScrollInfo(hwndView, SB_VERT, &si, FALSE);
|
|
|
|
needUpdate = TRUE;
|
|
needRedraw = FALSE;
|
|
forcePos = FALSE;
|
|
|
|
if (nPage >= nMax &&
|
|
0 != (WS_VSCROLL & windowStyle))
|
|
{
|
|
SetWindowLongPtrW(hwndView, GWL_STYLE, windowStyle & ~WS_VSCROLL);
|
|
|
|
RECT rc;
|
|
HWND hwndHeader;
|
|
// MLSkinnedScrollWnd_UpdateBars(hwndView, bRedraw);
|
|
GetClientRect(hwndView, &rc);
|
|
hwndHeader = GetDlgItem(hwndView, 3);
|
|
if (hwndHeader)
|
|
{
|
|
HDLAYOUT headerLayout;
|
|
WINDOWPOS headerPos;
|
|
|
|
headerLayout.prc = &rc;
|
|
headerLayout.pwpos = &headerPos;
|
|
|
|
if (FALSE != SendMessageW(hwndHeader, HDM_LAYOUT, 0, (LPARAM)&headerLayout))
|
|
{
|
|
headerPos.flags |= SWP_NOREDRAW | SWP_NOCOPYBITS;
|
|
headerPos.flags &= ~SWP_NOZORDER;
|
|
headerPos.hwndInsertAfter = HWND_TOP;
|
|
SetWindowPos(hwndHeader, headerPos.hwndInsertAfter, headerPos.x, headerPos.y,
|
|
headerPos.cx, headerPos.cy, headerPos.flags);
|
|
|
|
InvalidateRect(hwndHeader, NULL, FALSE);
|
|
}
|
|
}
|
|
rv.right = rc.right;
|
|
forcePos = TRUE;
|
|
needUpdate = FALSE;
|
|
needRedraw = TRUE;
|
|
}
|
|
|
|
if (nPage >= nMax || forcePos)
|
|
{
|
|
RECT rl;
|
|
GetWindowRect(hwndList, &rl);
|
|
MapWindowPoints(HWND_DESKTOP, hwndView, (POINT*)&rl, 2);
|
|
if (rv.top != rl.top || forcePos)
|
|
{
|
|
SetWindowPos(hwndList, NULL, rv.left, rv.top, rv.right - rv.left, rv.bottom - rv.top,
|
|
SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOCOPYBITS);
|
|
needRedraw = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (SIF_POS & fFlags)
|
|
{
|
|
INT nTop;
|
|
|
|
nTop = (INT)SendMessageW(hwndList, LVM_GETTOPINDEX, 0, 0L);
|
|
nTop = SmoothScrollList_GetScrollPosFromItem(hwndView, nTop);
|
|
|
|
if(si.nMax > 0)
|
|
{
|
|
if (nTop >= (si.nMax - (int)si.nPage))
|
|
nTop = (si.nMax - si.nPage) + 1;
|
|
}
|
|
else
|
|
nTop = 0;
|
|
|
|
if (nTop < si.nMin)
|
|
nTop = si.nMin;
|
|
|
|
if (si.nPos != nTop)
|
|
{
|
|
si.fMask = SIF_POS;
|
|
si.nPos = nTop;
|
|
|
|
SetScrollInfo(hwndView, SB_VERT, &si, (FALSE == needRedraw && FALSE != bRedraw));
|
|
|
|
needUpdate = TRUE;
|
|
}
|
|
}
|
|
|
|
if (FALSE != needUpdate)
|
|
MLSkinnedScrollWnd_UpdateBars(hwndView, (FALSE == needRedraw && FALSE != bRedraw));
|
|
|
|
if (FALSE != bRedraw && FALSE != needRedraw)
|
|
{
|
|
HRGN regionTemp2;
|
|
GetWindowRect(hwndView, &rv);
|
|
MapWindowPoints(HWND_DESKTOP, hwndView, (POINT*)&rv, 2);
|
|
SetRectRgn(regionTemp, rv.left, rv.top, rv.right, rv.bottom);
|
|
GetClientRect(hwndView, &rv);
|
|
regionTemp2 = CreateRectRgnIndirect(&rv);
|
|
CombineRgn(regionTemp, regionTemp, regionTemp2, RGN_DIFF);
|
|
CombineRgn(regionUpdate, regionUpdate, regionTemp, RGN_OR);
|
|
DeleteObject(regionTemp2);
|
|
|
|
RedrawWindow(hwndView, NULL, regionUpdate, RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_FRAME);
|
|
}
|
|
|
|
if (NULL != regionUpdate)
|
|
DeleteObject(regionUpdate);
|
|
if (NULL != regionTemp)
|
|
DeleteObject(regionTemp);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL
|
|
SmoothScrollList_SetScrollPos(HWND hwnd, int position, ScrollPosFlags flags)
|
|
{
|
|
SmoothScrollList *self;
|
|
HWND listWindow;
|
|
BOOL invalidate, failed;
|
|
unsigned long viewStyle;
|
|
int y, scrollPos;
|
|
RECT rv, rl;
|
|
SCROLLINFO si;
|
|
|
|
|
|
listWindow = GetDlgItem(hwnd, 2);
|
|
if (NULL == listWindow)
|
|
return FALSE;
|
|
|
|
self = GetUserData(hwnd);
|
|
if (NULL == self)
|
|
return FALSE;
|
|
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_POS | SIF_RANGE | SIF_PAGE;
|
|
if (FALSE == GetScrollInfo(hwnd, SB_VERT, &si))
|
|
return FALSE;
|
|
|
|
scrollPos = si.nPos;
|
|
|
|
viewStyle = GetWindowLongPtrW(hwnd, GWL_STYLE);
|
|
|
|
invalidate = FALSE;
|
|
failed = FALSE;
|
|
y = 0;
|
|
|
|
if (0 != (SPF_RELATIVE & flags))
|
|
{
|
|
position = si.nPos + position;
|
|
if (si.nPos > (si.nMax - (int)si.nPage))
|
|
position -= (si.nPos - (si.nMax - (int)si.nPage));
|
|
}
|
|
|
|
if (position < si.nMin)
|
|
position = si.nMin;
|
|
|
|
if (position > (si.nMax - (INT)si.nPage + 1))
|
|
position = si.nMax - si.nPage + 1;
|
|
|
|
if (position == si.nPos && 0 == (SPF_FORCE & flags))
|
|
return TRUE;
|
|
|
|
if (FALSE == GetViewRect(hwnd, &rv))
|
|
SetRectEmpty(&rv);
|
|
|
|
if (FALSE == GetWindowRect(listWindow, &rl))
|
|
SetRectEmpty(&rl);
|
|
|
|
MapWindowPoints(HWND_DESKTOP, hwnd, (POINT*)&rl, 2);
|
|
|
|
if (0 != (WS_VISIBLE & viewStyle))
|
|
SetWindowLongPtrW(hwnd, GWL_STYLE, viewStyle & ~WS_VISIBLE);
|
|
|
|
if (si.nMin == position)
|
|
{
|
|
if (rl.top != rv.top || rl.bottom != rv.bottom || rl.left != rv.left || rl.right != rv.right)
|
|
{
|
|
SetWindowPos(listWindow, NULL, rv.left, rv.top, rv.right - rv.left, rv.bottom - rv.top,
|
|
SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOCOPYBITS);
|
|
invalidate = TRUE;
|
|
}
|
|
|
|
if (0 != (int)SendMessageW(listWindow, LVM_GETITEMCOUNT, 0, 0L))
|
|
{
|
|
RECT rect;
|
|
rect.left = LVIR_BOUNDS;
|
|
if (FALSE != SendMessageW(listWindow, LVM_GETITEMRECT, 0, (LPARAM)&rect) &&
|
|
0 != rect.top)
|
|
{
|
|
int scrollY;
|
|
scrollY = rect.top;
|
|
failed = !SendMessageW(listWindow, LVM_SCROLL, 0, scrollY);
|
|
invalidate = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int iTop, iPos;
|
|
|
|
iTop = (int)SendMessageW(listWindow, LVM_GETTOPINDEX, 0, 0L);
|
|
if (position > (si.nMax - (int)si.nPage))
|
|
position = (si.nMax - si.nPage);
|
|
|
|
iPos = position/self->itemHeight;
|
|
y = (position - iPos*self->itemHeight);
|
|
|
|
if (iTop > iPos)
|
|
{
|
|
failed = !SendMessageW(listWindow, LVM_SCROLL, 0, (iPos - iTop) * self->itemHeight);
|
|
invalidate = TRUE;
|
|
}
|
|
|
|
if (rl.top != rv.top + y || rl.bottom != rv.bottom || rl.left != rv.left || rl.right != rv.right)
|
|
{
|
|
SetWindowPos(listWindow, NULL, rv.left, rv.top - y, rv.right - rv.left, rv.bottom - rv.top + y,
|
|
SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOCOPYBITS);
|
|
invalidate = TRUE;
|
|
}
|
|
|
|
if (iTop < iPos)
|
|
{
|
|
failed = !SendMessageW(listWindow, LVM_SCROLL, 0, (iPos - iTop)*self->itemHeight);
|
|
invalidate = TRUE;
|
|
}
|
|
|
|
}
|
|
|
|
if (FALSE == failed)
|
|
{
|
|
if (position == si.nMax - si.nPage && 0 != si.nMax)
|
|
position++;
|
|
|
|
if (scrollPos != position)
|
|
{
|
|
si.nPos = position;
|
|
si.fMask = SIF_POS;
|
|
SetScrollInfo(hwnd, SB_VERT, &si, (0 == (SPF_NOREDRAW & flags)));
|
|
}
|
|
|
|
}
|
|
|
|
if (0 != (WS_VISIBLE & viewStyle))
|
|
{
|
|
viewStyle = GetWindowLongPtrW(hwnd, GWL_STYLE);
|
|
if (0 == (WS_VISIBLE & viewStyle))
|
|
{
|
|
viewStyle |= WS_VISIBLE;
|
|
SetWindowLongPtrW(hwnd, GWL_STYLE, viewStyle);
|
|
}
|
|
|
|
if (0 == (SPF_NOREDRAW & flags) &&
|
|
FALSE != invalidate)
|
|
{
|
|
InvalidateRect(listWindow, NULL, TRUE);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL
|
|
SmoothScrollList_EnsureVisible(HWND hwnd, int iItem, BOOL partialOk)
|
|
{
|
|
int itemTop, itemBottom;
|
|
int pageTop, pageBottom, delta;
|
|
SCROLLINFO scrollInfo;
|
|
SmoothScrollList *self;
|
|
|
|
if (NULL == hwnd || iItem < 0)
|
|
return FALSE;
|
|
|
|
self = GetUserData(hwnd);
|
|
if (NULL == self)
|
|
return FALSE;
|
|
|
|
scrollInfo.cbSize = sizeof(scrollInfo);
|
|
scrollInfo.fMask = SIF_POS | SIF_PAGE;
|
|
if (FALSE == GetScrollInfo(hwnd, SB_VERT, &scrollInfo))
|
|
return FALSE;
|
|
|
|
itemTop = iItem * self->itemHeight;
|
|
itemBottom = itemTop + self->itemHeight;
|
|
|
|
pageTop = scrollInfo.nPos;
|
|
pageBottom = pageTop + scrollInfo.nPage;
|
|
|
|
if (FALSE != partialOk)
|
|
{
|
|
if (itemTop < pageBottom &&
|
|
itemBottom > pageTop)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (itemTop >= pageTop &&
|
|
itemBottom <= pageBottom)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
if (itemTop < pageTop)
|
|
delta = itemTop - pageTop;
|
|
else
|
|
{
|
|
delta = itemBottom - pageBottom;
|
|
if ((itemTop - delta) < pageTop)
|
|
delta = itemTop - pageTop;
|
|
}
|
|
|
|
if (FALSE == SmoothScrollList_SetScrollPos(hwnd, delta, SPF_RELATIVE | SPF_FORCE))
|
|
return FALSE;
|
|
|
|
MLSkinnedScrollWnd_UpdateBars(hwnd, TRUE);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static BOOL
|
|
SmoothScrollList_PreProcessKey(HWND hwnd, unsigned int vKey, unsigned int keyFlags, PostProcessKeyCommands *postProcessCommands)
|
|
{
|
|
HWND listWindow;
|
|
RECT viewRect;
|
|
SmoothScrollList *self;
|
|
int iItem, iNextItem, count;
|
|
BOOL shortView;
|
|
|
|
if (NULL != postProcessCommands)
|
|
*postProcessCommands = PostProcessKeyCmd_Nothing;
|
|
|
|
switch(vKey)
|
|
{
|
|
case VK_UP:
|
|
case VK_DOWN:
|
|
case VK_HOME:
|
|
case VK_END:
|
|
case VK_PRIOR:
|
|
case VK_NEXT:
|
|
break;
|
|
|
|
default:
|
|
return TRUE;
|
|
}
|
|
|
|
if (NULL == hwnd || FALSE == GetViewRect(hwnd, &viewRect))
|
|
return FALSE;
|
|
|
|
self = GetUserData(hwnd);
|
|
if (NULL == self)
|
|
return FALSE;
|
|
|
|
listWindow = GetDlgItem(hwnd, 2);
|
|
if (NULL == listWindow)
|
|
return FALSE;
|
|
|
|
iItem = (int)SendMessageW(listWindow, LVM_GETNEXTITEM, (WPARAM)-1, (LPARAM)(LVNI_ALL | LVNI_FOCUSED));
|
|
if (-1 == iItem)
|
|
return FALSE;
|
|
|
|
count = (int)SendMessageW(listWindow, LVM_GETITEMCOUNT, 0, 0L);
|
|
|
|
iNextItem = iItem;
|
|
|
|
shortView = ((viewRect.bottom - viewRect.top) < (long)self->itemHeight);
|
|
|
|
switch(vKey)
|
|
{
|
|
case VK_UP:
|
|
if (iNextItem > 0)
|
|
iNextItem--;
|
|
|
|
if (FALSE != shortView)
|
|
{
|
|
if (NULL != postProcessCommands)
|
|
*postProcessCommands |= PostProcessKeyCmd_EnsureFocusVisible;
|
|
}
|
|
break;
|
|
|
|
case VK_DOWN:
|
|
if (FALSE == shortView)
|
|
{
|
|
if ((iNextItem + 1) < count)
|
|
iNextItem++;
|
|
}
|
|
else
|
|
{
|
|
if (NULL != postProcessCommands)
|
|
*postProcessCommands |= PostProcessKeyCmd_EnsureFocusVisible;
|
|
}
|
|
break;
|
|
|
|
case VK_HOME:
|
|
|
|
if (FALSE == shortView)
|
|
{
|
|
iNextItem = 0;
|
|
}
|
|
else
|
|
{
|
|
iNextItem = 1;
|
|
if (NULL != postProcessCommands)
|
|
*postProcessCommands |= PostProcessKeyCmd_UpdateScrollPos;
|
|
}
|
|
break;
|
|
case VK_END:
|
|
if (FALSE == shortView)
|
|
{
|
|
iNextItem = count - 1;
|
|
}
|
|
else
|
|
{
|
|
iNextItem = -1;
|
|
if (NULL != postProcessCommands)
|
|
*postProcessCommands |= PostProcessKeyCmd_EnsureFocusVisible;
|
|
}
|
|
break;
|
|
case VK_PRIOR:
|
|
{
|
|
RECT listRect;
|
|
|
|
GetWindowRect(listWindow, &listRect);
|
|
MapWindowPoints(HWND_DESKTOP, hwnd, (POINT*)&listRect, 2);
|
|
if (listRect.top != viewRect.top)
|
|
SmoothScrollList_SetScrollPos(hwnd, listRect.top - viewRect.top, SPF_RELATIVE);
|
|
|
|
if (FALSE == shortView)
|
|
{
|
|
iNextItem = (viewRect.bottom - viewRect.top)/self->itemHeight;
|
|
iNextItem = iItem - iNextItem;
|
|
if (iNextItem < 0)
|
|
iNextItem = 0;
|
|
}
|
|
else
|
|
{
|
|
if (0 == iItem)
|
|
iNextItem = 1;
|
|
|
|
if (NULL != postProcessCommands)
|
|
*postProcessCommands |= PostProcessKeyCmd_UpdateScrollPos;
|
|
}
|
|
|
|
}
|
|
break;
|
|
case VK_NEXT:
|
|
{
|
|
RECT listRect;
|
|
int reminder;
|
|
|
|
GetWindowRect(listWindow, &listRect);
|
|
MapWindowPoints(HWND_DESKTOP, hwnd, (POINT*)&listRect, 2);
|
|
|
|
reminder = (listRect.bottom - listRect.top)%self->itemHeight;
|
|
if (0 != reminder)
|
|
SmoothScrollList_SetScrollPos(hwnd, self->itemHeight - reminder, SPF_RELATIVE);
|
|
|
|
if (FALSE == shortView)
|
|
{
|
|
iNextItem = (viewRect.bottom - viewRect.top)/self->itemHeight;
|
|
iNextItem = iItem + iNextItem;
|
|
if (iNextItem >= count)
|
|
iNextItem = count - 1;
|
|
|
|
}
|
|
else
|
|
{
|
|
if (NULL != postProcessCommands)
|
|
*postProcessCommands |= (PostProcessKeyCmd_UpdateScrollPos | PostProcessKeyCmd_EnsureFocusVisible);
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (iNextItem >= 0 && iNextItem < count)
|
|
SmoothScrollList_EnsureVisible(hwnd, iNextItem, FALSE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
SmoothScrollList_PostProcessKey(HWND hwnd, unsigned int vKey, unsigned int keyFlags, PostProcessKeyCommands processCommands)
|
|
{
|
|
if (0 != (PostProcessKeyCmd_UpdateScrollPos & processCommands))
|
|
UpdateScrollInfo(hwnd, SIF_POS, TRUE);
|
|
|
|
if (0 != (PostProcessKeyCmd_EnsureFocusVisible & processCommands))
|
|
{
|
|
HWND listWindow = GetDlgItem(hwnd, 2);
|
|
if (NULL != listWindow)
|
|
{
|
|
int iItem = (int)SendMessageW(listWindow, LVM_GETNEXTITEM, (WPARAM)-1, (LPARAM)(LVNI_ALL | LVNI_FOCUSED));
|
|
if (-1 != iItem)
|
|
{
|
|
SmoothScrollList_EnsureVisible(hwnd, iItem, FALSE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
SmoothScrollList_UpdateFontMetrics(HWND hwnd, BOOL redraw)
|
|
{
|
|
SmoothScrollList *self;
|
|
HWND controlWindow;
|
|
unsigned int windowStyle;
|
|
HFONT font, prevFont;
|
|
HDC hdc;
|
|
TEXTMETRICW textMetrics;
|
|
unsigned int fontHeight;
|
|
|
|
self = GetUserData(hwnd);
|
|
if (NULL == self)
|
|
return;
|
|
|
|
windowStyle = GetWindowLongPtr(hwnd, GWL_STYLE);
|
|
if(0 != (WS_VISIBLE & windowStyle))
|
|
SetWindowLongPtrW(hwnd, GWL_STYLE, windowStyle & ~WS_VISIBLE);
|
|
|
|
hdc = GetDCEx(hwnd, NULL, DCX_CACHE | DCX_NORESETATTRS);
|
|
if (NULL != hdc)
|
|
prevFont = (HFONT)GetCurrentObject(hdc, OBJ_FONT);
|
|
else
|
|
prevFont = NULL;
|
|
|
|
controlWindow = GetDlgItem(hwnd, 3);
|
|
if (NULL != controlWindow)
|
|
{
|
|
font = (HFONT)SendMessageW(controlWindow, WM_GETFONT, 0, 0L);
|
|
fontHeight = 0;
|
|
|
|
if (NULL != hdc)
|
|
{
|
|
SelectObject(hdc, font);
|
|
if (FALSE != GetTextMetricsW(hdc, &textMetrics))
|
|
fontHeight = textMetrics.tmHeight;
|
|
}
|
|
|
|
if (self->headerFontHeight != fontHeight)
|
|
{
|
|
self->headerFontHeight = fontHeight;
|
|
MLSkinnedHeader_SetHeight(controlWindow, -1);
|
|
}
|
|
}
|
|
|
|
controlWindow = GetDlgItem(hwnd, 2);
|
|
if (NULL != controlWindow)
|
|
{
|
|
font = (HFONT)SendMessageW(controlWindow, WM_GETFONT, 0, 0L);
|
|
fontHeight = 0;
|
|
|
|
if (NULL != hdc)
|
|
{
|
|
SelectObject(hdc, font);
|
|
if (FALSE != GetTextMetricsW(hdc, &textMetrics))
|
|
fontHeight = textMetrics.tmHeight;
|
|
}
|
|
|
|
if (self->listFontHeight != fontHeight)
|
|
{
|
|
self->listFontHeight = fontHeight;
|
|
|
|
SmoothScrollList_SetScrollPos(hwnd, 0, SPF_NOREDRAW | SPF_FORCE);
|
|
MLSkinnedScrollWnd_UpdateBars(hwnd, FALSE);
|
|
}
|
|
}
|
|
|
|
|
|
if (NULL != hdc)
|
|
{
|
|
SelectObject(hdc, prevFont);
|
|
ReleaseDC(hwnd, hdc);
|
|
}
|
|
|
|
if (0 != (WS_VISIBLE & windowStyle))
|
|
{
|
|
windowStyle = GetWindowLongPtr(hwnd, GWL_STYLE);
|
|
if (0 == (WS_VISIBLE & windowStyle))
|
|
{
|
|
windowStyle |= WS_VISIBLE;
|
|
SetWindowLongPtrW(hwnd, GWL_STYLE, windowStyle);
|
|
}
|
|
|
|
if (FALSE != redraw)
|
|
RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN);
|
|
}
|
|
}
|
|
|
|
|
|
static HHOOK hook = NULL;
|
|
static HWND hwndToMonitor = NULL;
|
|
static LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
MSG *pMsg = (MSG*)lParam;
|
|
if (pMsg->hwnd == hwndToMonitor)
|
|
{
|
|
static INT lastScrollPos = -1;
|
|
switch(pMsg->message)
|
|
{
|
|
case WM_LBUTTONUP:
|
|
case WM_RBUTTONUP:
|
|
{
|
|
LRESULT result = CallNextHookEx(hook, nCode, wParam, lParam);
|
|
UnhookWindowsHookEx(hook);
|
|
hwndToMonitor = NULL;
|
|
hook = NULL;
|
|
lastScrollPos = -1;
|
|
return result;
|
|
}
|
|
case WM_MOUSEMOVE:
|
|
if ((MK_LBUTTON | MK_RBUTTON) & pMsg->wParam)
|
|
{
|
|
RECT rw;
|
|
POINTS pts(MAKEPOINTS(pMsg->lParam));
|
|
POINT pt;
|
|
POINTSTOPOINT(pt, pts);
|
|
MapWindowPoints(pMsg->hwnd, HWND_DESKTOP, &pt, 1);
|
|
GetWindowRect(pMsg->hwnd, &rw);
|
|
if (pt.y < rw.top || pt.y > rw.bottom)
|
|
{
|
|
HWND hwndParent = GetParent(pMsg->hwnd);
|
|
if (hwndParent)
|
|
{
|
|
SCROLLINFO si;
|
|
si.cbSize = sizeof(SCROLLINFO);
|
|
si.fMask = SIF_RANGE | SIF_POS | SIF_PAGE;
|
|
if (GetScrollInfo(hwndParent, SB_VERT, &si))
|
|
{
|
|
if ((si.nPos > si.nMin && pt.y < rw.top) || (si.nPos <= (si.nMax - (INT)si.nPage) && pt.y > rw.bottom))
|
|
{
|
|
LRESULT result;
|
|
if (lastScrollPos == si.nPos)
|
|
{
|
|
result = CallNextHookEx(hook, nCode, wParam, lParam);
|
|
SmoothScrollList_SetScrollPos(hwndParent, (pt.y < rw.top) ? --si.nPos : ++si.nPos, SPF_NORMAL);
|
|
}
|
|
else
|
|
{
|
|
unsigned long windowStyle;
|
|
windowStyle = GetWindowLongPtrW(hwndParent, GWL_STYLE);
|
|
|
|
if (0 != (WS_VISIBLE & windowStyle))
|
|
SetWindowLongPtrW(hwndParent, GWL_STYLE, windowStyle & ~WS_VISIBLE);
|
|
|
|
result = CallNextHookEx(hook, nCode, wParam, lParam);
|
|
PostMessageW(hwndParent, WM_EX_UPDATESCROLLINFO, SIF_POS, TRUE);
|
|
|
|
if (0 != (WS_VISIBLE & windowStyle))
|
|
PostMessageW(hwndParent, WM_EX_UNLOCKREDRAW, IWF_UPDATENOW | IWF_FRAME, 0L);
|
|
}
|
|
lastScrollPos = si.nPos;
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
SleepEx(1, TRUE);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return CallNextHookEx(hook, nCode, wParam, lParam);
|
|
}
|
|
|
|
static LRESULT CALLBACK ListViewSubclass(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
|
|
if(uMsg == WM_MOUSEMOVE ||
|
|
uMsg == WM_LBUTTONDOWN)
|
|
{
|
|
LVHITTESTINFO ht = {{LOWORD(lParam),HIWORD(lParam)},LVHT_ONITEM,-1,0};
|
|
int item = ListView_SubItemHitTest(hwnd, &ht);
|
|
{
|
|
RECT r={0};
|
|
ListView_GetItemRect(hwnd,item,&r,LVIR_BOUNDS);
|
|
ht.pt.x -= r.left;
|
|
ht.pt.y -= r.top;
|
|
typedef struct {
|
|
int x,y,item;
|
|
HWND hwnd;
|
|
UINT msg;
|
|
} hitinfo;
|
|
hitinfo info = {
|
|
ht.pt.x, ht.pt.y, item, hwnd, uMsg,
|
|
};
|
|
SendMessage(GetParent(GetParent(hwnd)),WM_USER+700,(WPARAM)&info,0);
|
|
}
|
|
}
|
|
|
|
switch(uMsg)
|
|
{
|
|
case WM_HSCROLL:
|
|
case WM_VSCROLL:
|
|
case WM_MOUSEWHEEL:
|
|
{
|
|
HWND parentWindow;
|
|
|
|
KillTimer(hwnd, 43);
|
|
|
|
parentWindow = GetAncestor(hwnd, GA_PARENT);
|
|
if (NULL != parentWindow)
|
|
return SendMessageW(parentWindow, uMsg, wParam, lParam);
|
|
}
|
|
break;
|
|
case WM_TIMER:
|
|
if (43 == wParam)
|
|
{
|
|
HWND parentWindow;
|
|
|
|
KillTimer(hwnd, wParam);
|
|
|
|
parentWindow = GetAncestor(hwnd, GA_PARENT);
|
|
if (NULL != parentWindow)
|
|
{
|
|
int iFocused = (int)SendMessageW(hwnd, LVM_GETNEXTITEM, (WPARAM)-1, (LPARAM)(LVNI_ALL | LVNI_FOCUSED));
|
|
if (-1 != iFocused)
|
|
SmoothScrollList_EnsureVisible(parentWindow, iFocused, FALSE);
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
break;
|
|
case WM_LBUTTONDOWN:
|
|
case WM_RBUTTONDOWN:
|
|
case WM_MBUTTONDOWN:
|
|
case WM_XBUTTONDOWN:
|
|
hwndToMonitor = hwnd;
|
|
hook = SetWindowsHookEx(WH_MSGFILTER, HookProc, NULL, GetCurrentThreadId());
|
|
|
|
{
|
|
unsigned int windowStyle;
|
|
windowStyle = GetWindowLongPtrW(hwnd, GWL_STYLE);
|
|
if (0 != (LVS_OWNERDRAWFIXED & windowStyle))
|
|
{
|
|
LRESULT result;
|
|
|
|
SetWindowLongPtrW(hwnd, GWL_STYLE, windowStyle & ~LVS_OWNERDRAWFIXED);
|
|
|
|
result = SubclassedListView_CallPrevWndProc(hwnd, uMsg, wParam, lParam);
|
|
|
|
windowStyle = GetWindowLongPtrW(hwnd, GWL_STYLE);
|
|
if (0 == (LVS_OWNERDRAWFIXED & windowStyle))
|
|
{
|
|
windowStyle |= LVS_OWNERDRAWFIXED;
|
|
SetWindowLongPtrW(hwnd, GWL_STYLE, windowStyle);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_KEYDOWN:
|
|
{
|
|
HWND parentWindow;
|
|
parentWindow = GetAncestor(hwnd, GA_PARENT);
|
|
if (NULL != parentWindow)
|
|
{
|
|
PostProcessKeyCommands postProcessKeyCommands;
|
|
if (FALSE == SmoothScrollList_PreProcessKey(parentWindow,
|
|
(unsigned int)wParam,
|
|
(unsigned int)lParam,
|
|
&postProcessKeyCommands))
|
|
{
|
|
postProcessKeyCommands = PostProcessKeyCmd_UpdateScrollPos;
|
|
}
|
|
|
|
SubclassedListView_CallPrevWndProc(hwnd, uMsg, wParam, lParam);
|
|
|
|
SmoothScrollList_PostProcessKey(parentWindow,
|
|
(unsigned int)wParam,
|
|
(unsigned int)lParam,
|
|
postProcessKeyCommands);
|
|
return 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_CHAR:
|
|
case WM_UNICHAR:
|
|
{
|
|
HWND parentWindow;
|
|
parentWindow = GetAncestor(hwnd, GA_PARENT);
|
|
if (NULL != parentWindow)
|
|
{
|
|
int iFocused;
|
|
unsigned int windowStyle;
|
|
|
|
windowStyle = GetWindowLongPtrW(hwnd, GWL_STYLE);
|
|
|
|
if (0 != (WS_VISIBLE & windowStyle))
|
|
SetWindowLongPtr(hwnd, GWL_STYLE, windowStyle & ~WS_VISIBLE);
|
|
|
|
SubclassedListView_CallPrevWndProc(hwnd, uMsg, wParam, lParam);
|
|
|
|
iFocused = (int)SendMessageW(hwnd, LVM_GETNEXTITEM, (WPARAM)-1, (LPARAM)(LVNI_ALL | LVNI_FOCUSED));
|
|
|
|
if (-1 != iFocused)
|
|
SmoothScrollList_EnsureVisible(parentWindow, iFocused, FALSE);
|
|
|
|
if (0 != (WS_VISIBLE & windowStyle))
|
|
{
|
|
windowStyle = GetWindowLongPtrW(hwnd, GWL_STYLE);
|
|
windowStyle |= WS_VISIBLE;
|
|
SetWindowLongPtr(hwnd, GWL_STYLE, windowStyle);
|
|
}
|
|
|
|
InvalidateRect(hwnd, NULL, FALSE);
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case LVM_ENSUREVISIBLE:
|
|
{
|
|
HWND parentWindow = GetAncestor(hwnd, GA_PARENT);
|
|
if (NULL != parentWindow)
|
|
return SmoothScrollList_EnsureVisible(parentWindow, (int)wParam, (BOOL)lParam);
|
|
}
|
|
break;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
return SubclassedListView_CallPrevWndProc(hwnd, uMsg, wParam, lParam);
|
|
|
|
|
|
}
|
|
|
|
static LRESULT
|
|
SmoothScrollList_OnCreate(HWND hwnd, CREATESTRUCT *createStruct)
|
|
{
|
|
HWND hwndList, hwndHeader;
|
|
MLSKINWINDOW m = {0};
|
|
RECT rc;
|
|
DWORD style;
|
|
SmoothScrollList *self = (SmoothScrollList *)calloc(1, sizeof(SmoothScrollList));
|
|
if (NULL == self)
|
|
return -1;
|
|
|
|
self->itemHeight = 1;
|
|
self->textHeight = 1;
|
|
SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONGX86)(LONG_PTR)self);
|
|
|
|
m.skinType = SKINNEDWND_TYPE_SCROLLWND;
|
|
m.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS;
|
|
m.hwndToSkin = hwnd;
|
|
MLSkinWindow(g_hwnd, &m);
|
|
|
|
SetScrollRange(hwnd, SB_VERT, 0, 0, FALSE);
|
|
MLSkinnedScrollWnd_UpdateBars(hwnd, FALSE);
|
|
|
|
if (FALSE == GetClientRect(hwnd, &rc))
|
|
SetRectEmpty(&rc);
|
|
|
|
style = WS_CLIPSIBLINGS | WS_CHILD | WS_VISIBLE | HDS_BUTTONS | HDS_FULLDRAG;
|
|
hwndHeader = CreateWindowExW(WS_EX_NOPARENTNOTIFY, WC_HEADERW, NULL, style,
|
|
0, 0, rc.right - rc.left, 0, hwnd, (HMENU)3,0,0);
|
|
|
|
if (NULL != hwndHeader)
|
|
{
|
|
m.hwndToSkin = hwndHeader;
|
|
m.skinType = SKINNEDWND_TYPE_HEADER;
|
|
m.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS;
|
|
MLSkinWindow(g_hwnd, &m);
|
|
}
|
|
|
|
style = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_CHILD | WS_TABSTOP | WS_VISIBLE |
|
|
LVS_REPORT | LVS_SHOWSELALWAYS | LVS_OWNERDRAWFIXED | LVS_OWNERDATA | LVS_NOCOLUMNHEADER;
|
|
|
|
hwndList = CreateWindowExW(WS_EX_NOPARENTNOTIFY, WC_LISTVIEWW, NULL, style,
|
|
0, 0, rc.right - rc.left, rc.bottom - rc.top, hwnd,(HMENU)2,0,0);
|
|
if (NULL != hwndList)
|
|
{
|
|
WNDPROC oldp = (WNDPROC)(LONG_PTR)SetWindowLongPtrW(hwndList, GWLP_WNDPROC, (LONGX86)(LONG_PTR)ListViewSubclass);
|
|
SetWindowLongPtrW(hwndList,GWLP_USERDATA, (LONGX86)(LONG_PTR)oldp);
|
|
|
|
if(NULL != hwndHeader)
|
|
SetWindowPos(hwndHeader, hwndList, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
|
|
|
|
m.skinType = SKINNEDWND_TYPE_LISTVIEW;
|
|
m.hwndToSkin = hwndList;
|
|
m.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS |
|
|
SWLVS_FULLROWSELECT | SWLVS_DOUBLEBUFFER | SWLVS_ALTERNATEITEMS;
|
|
|
|
MLSkinWindow(g_hwnd, &m);
|
|
MLSkinnedScrollWnd_SetMode(hwndList, SCROLLMODE_STANDARD);
|
|
MLSkinnedScrollWnd_ShowHorzBar(hwndList, FALSE);
|
|
MLSkinnedScrollWnd_ShowVertBar(hwndList, FALSE);
|
|
}
|
|
|
|
SmoothScrollList_UpdateFontMetrics(hwnd, FALSE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
SmoothScrollList_OnDestroy(HWND hwnd)
|
|
{
|
|
SmoothScrollList *self;
|
|
|
|
self = (SmoothScrollList*)(LONG_PTR)SetWindowLongPtrW(hwnd, GWLP_USERDATA, 0);
|
|
if (NULL == self)
|
|
return;
|
|
|
|
free(self);
|
|
}
|
|
|
|
static void
|
|
SmoothScrollList_OnWindowPosChanged(HWND hwnd, WINDOWPOS *windowPos)
|
|
{
|
|
HWND controlWindow;
|
|
RECT rect;
|
|
long clientWidth;
|
|
HWND parentWindow;
|
|
SmoothScrollList *self;
|
|
|
|
if ((SWP_NOSIZE | SWP_NOMOVE) == ((SWP_NOSIZE | SWP_NOMOVE | SWP_FRAMECHANGED) & windowPos->flags))
|
|
return;
|
|
|
|
self = GetUserData(hwnd);
|
|
if (NULL == self)
|
|
return;
|
|
|
|
if (FALSE == GetClientRect(hwnd, &rect))
|
|
return;
|
|
|
|
clientWidth = rect.right - rect.left;
|
|
|
|
controlWindow = GetDlgItem(hwnd, 3);
|
|
if (NULL != controlWindow)
|
|
{
|
|
HDLAYOUT headerLayout;
|
|
WINDOWPOS headerPos;
|
|
|
|
headerLayout.prc = ▭
|
|
headerLayout.pwpos = &headerPos;
|
|
|
|
if (FALSE != SendMessageW(controlWindow, HDM_LAYOUT, 0, (LPARAM)&headerLayout))
|
|
{
|
|
headerPos.flags |= ((SWP_NOREDRAW | SWP_NOCOPYBITS) & windowPos->flags);
|
|
headerPos.flags &= ~SWP_NOZORDER;
|
|
headerPos.hwndInsertAfter = HWND_TOP;
|
|
SetWindowPos(controlWindow, headerPos.hwndInsertAfter, headerPos.x, headerPos.y,
|
|
headerPos.cx, headerPos.cy, headerPos.flags);
|
|
}
|
|
}
|
|
|
|
if (self->viewHeight != windowPos->cy ||
|
|
0 != (SWP_FRAMECHANGED & windowPos->flags))
|
|
{
|
|
ScrollPosFlags scrollFlags;
|
|
|
|
scrollFlags = SPF_FORCE | SPF_RELATIVE;
|
|
if (0 != (SWP_NOREDRAW & windowPos->flags))
|
|
scrollFlags |= SPF_NOREDRAW;
|
|
|
|
self->viewHeight = windowPos->cy;
|
|
|
|
UpdateScrollInfo(hwnd, SIF_RANGE | SIF_POS, TRUE);
|
|
|
|
SmoothScrollList_SetScrollPos(hwnd, 0, scrollFlags);
|
|
}
|
|
else
|
|
{
|
|
controlWindow = GetDlgItem(hwnd, 2);
|
|
if (NULL != controlWindow)
|
|
{
|
|
if (FALSE != GetWindowRect(controlWindow, &rect) &&
|
|
(rect.right - rect.left) != clientWidth)
|
|
{
|
|
SetWindowPos(controlWindow, NULL, 0, 0, clientWidth, rect.bottom - rect.top,
|
|
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | ((SWP_NOREDRAW | SWP_NOCOPYBITS) & windowPos->flags));
|
|
}
|
|
}
|
|
}
|
|
|
|
parentWindow = GetAncestor(hwnd, GA_PARENT);
|
|
if (NULL != parentWindow)
|
|
{
|
|
NMHDR hdr;
|
|
hdr.code = LVN_EX_SIZECHANGED;
|
|
hdr.hwndFrom = hwnd;
|
|
hdr.idFrom = GetWindowLongPtrW(hwnd, GWLP_ID);
|
|
SendMessageW(parentWindow, WM_NOTIFY, hdr.idFrom, (LPARAM)&hdr);
|
|
}
|
|
}
|
|
|
|
static void
|
|
SmoothScrollList_OnMouseWheel(HWND hwnd, INT virtualKeys, INT distance, LONG pointer_s)
|
|
{
|
|
SmoothScrollList *self;
|
|
int pos;
|
|
unsigned int wheelScroll;
|
|
int scrollLines;
|
|
|
|
KillTimer(hwnd, 43);
|
|
|
|
self = GetUserData(hwnd);
|
|
if (NULL == self)
|
|
return;
|
|
|
|
if (FALSE == SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &wheelScroll, 0))
|
|
wheelScroll = 3;
|
|
|
|
if (0 == wheelScroll)
|
|
return;
|
|
|
|
if (WHEEL_PAGESCROLL == wheelScroll)
|
|
{
|
|
SendMessageW(hwnd, WM_VSCROLL, MAKEWPARAM(((distance > 0) ? SB_PAGEUP : SB_PAGEDOWN), 0), 0L);
|
|
SendMessageW(hwnd, WM_VSCROLL, MAKEWPARAM(SB_ENDSCROLL, 0), 0L);
|
|
return;
|
|
}
|
|
|
|
distance += self->wheelCarryover;
|
|
scrollLines = distance * (int)wheelScroll / WHEEL_DELTA;
|
|
self->wheelCarryover = distance - scrollLines * WHEEL_DELTA / (int)wheelScroll;
|
|
|
|
pos = scrollLines * (int)self->textHeight;
|
|
|
|
SmoothScrollList_SetScrollPos(hwnd, -pos, SPF_RELATIVE | SPF_NORMAL);
|
|
MLSkinnedScrollWnd_UpdateBars(hwnd, TRUE);
|
|
}
|
|
|
|
static void
|
|
SmoothScrollList_OnVertScroll(HWND hwnd, INT actionLayout, INT trackPosition, HWND scrollBar)
|
|
{
|
|
SmoothScrollList *s;
|
|
SCROLLINFO si;
|
|
int pos;
|
|
ScrollPosFlags scrollFlags;
|
|
unsigned int lineHeight;
|
|
|
|
KillTimer(hwnd, 43);
|
|
|
|
s = GetUserData(hwnd);
|
|
if (NULL == s)
|
|
return;
|
|
|
|
si.cbSize =sizeof(si);
|
|
si.fMask = SIF_PAGE | SIF_POS | SIF_TRACKPOS | SIF_RANGE;
|
|
|
|
if (FALSE == GetScrollInfo(hwnd, SB_VERT, &si))
|
|
return;
|
|
|
|
scrollFlags = SPF_NORMAL;
|
|
|
|
if (si.nPos > (si.nMax - (INT)si.nPage))
|
|
si.nPos = si.nMax - si.nPage;
|
|
|
|
lineHeight = s->textHeight * 3;
|
|
if (lineHeight > s->itemHeight)
|
|
lineHeight = s->itemHeight;
|
|
if (lineHeight > si.nPage)
|
|
lineHeight = si.nPage;
|
|
|
|
switch(actionLayout)
|
|
{
|
|
case SB_TOP: pos = si.nMin; break;
|
|
case SB_BOTTOM: pos = si.nMax; break;
|
|
case SB_LINEDOWN: pos = si.nPos + lineHeight; break;
|
|
case SB_LINEUP: pos = si.nPos - lineHeight; break;
|
|
case SB_PAGEDOWN: pos = si.nPos + (si.nPage / s->itemHeight) * s->itemHeight; break;
|
|
case SB_PAGEUP: pos = si.nPos - (si.nPage / s->itemHeight) * s->itemHeight; break;
|
|
case SB_THUMBPOSITION:
|
|
case SB_THUMBTRACK: pos = si.nTrackPos; scrollFlags |= SPF_FORCE; break;
|
|
case SB_ENDSCROLL: MLSkinnedScrollWnd_UpdateBars(hwnd, TRUE); return;
|
|
default: pos = si.nPos;
|
|
}
|
|
|
|
SmoothScrollList_SetScrollPos(hwnd, pos, scrollFlags);
|
|
}
|
|
|
|
static LRESULT
|
|
SmoothScrollList_OnMeasureItem(HWND hwnd, MEASUREITEMSTRUCT *measureItem)
|
|
{
|
|
LRESULT result;
|
|
HWND parentWindow;
|
|
SmoothScrollList *self;
|
|
unsigned int itemHeight, textHeight;
|
|
BOOL updateScroll;
|
|
|
|
if(2 != measureItem->CtlID)
|
|
return FALSE;
|
|
|
|
self = GetUserData(hwnd);
|
|
|
|
|
|
updateScroll = FALSE;
|
|
itemHeight = measureItem->itemHeight;
|
|
|
|
parentWindow = GetAncestor(hwnd, GA_PARENT);
|
|
if (NULL != parentWindow)
|
|
{
|
|
measureItem->CtlID = GetWindowLongPtrW(hwnd, GWLP_ID);
|
|
result = SendMessageW(parentWindow, WM_MEASUREITEM, measureItem->CtlID, (LPARAM)measureItem);
|
|
itemHeight = measureItem->itemHeight;
|
|
}
|
|
else
|
|
result = 0;
|
|
|
|
textHeight = 12;
|
|
HDC hdc = GetDCEx(hwnd, NULL, DCX_CACHE | DCX_NORESETATTRS);
|
|
if (NULL != hdc)
|
|
{
|
|
HFONT font, fontPrev;
|
|
TEXTMETRIC textMetrics;
|
|
|
|
font = (HFONT)SendMessageW(hwnd, WM_GETFONT, 0, 0L);
|
|
fontPrev = (HFONT)SelectObject(hdc, font);
|
|
|
|
if (FALSE != GetTextMetrics(hdc, &textMetrics))
|
|
textHeight = textMetrics.tmHeight;
|
|
|
|
SelectObject(hdc, fontPrev);
|
|
ReleaseDC(hwnd, hdc);
|
|
}
|
|
|
|
if (NULL != self)
|
|
{
|
|
if (self->itemHeight != itemHeight)
|
|
{
|
|
SmoothScrollList_SetScrollPos(hwnd, 0, SPF_NOREDRAW);
|
|
self->itemHeight = itemHeight;
|
|
updateScroll = TRUE;
|
|
}
|
|
|
|
if (self->textHeight != textHeight)
|
|
{
|
|
self->textHeight = textHeight;
|
|
updateScroll = TRUE;
|
|
}
|
|
}
|
|
|
|
if (FALSE != updateScroll)
|
|
{
|
|
UpdateScrollInfo(hwnd, SIF_RANGE | SIF_POS, TRUE);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static void
|
|
SmoothScrollList_OnSetFont(HWND hwnd, HFONT font, BOOL redraw)
|
|
{
|
|
if (0 == (SWS_USESKINFONT & MLSkinnedWnd_GetStyle(hwnd)))
|
|
{
|
|
HWND controlWindow;
|
|
|
|
controlWindow = GetDlgItem(hwnd,3);
|
|
if (NULL != controlWindow)
|
|
SendMessageW(controlWindow, WM_SETFONT, (WPARAM)font, MAKELPARAM(0, 0L));
|
|
|
|
controlWindow = GetDlgItem(hwnd,2);
|
|
if (NULL != controlWindow)
|
|
SendMessageW(controlWindow, WM_SETFONT, (WPARAM)font, MAKELPARAM(0, 0L));
|
|
|
|
SmoothScrollList_UpdateFontMetrics(hwnd, redraw);
|
|
}
|
|
}
|
|
|
|
|
|
static LRESULT
|
|
SmoothScrollList_OnGetFont(HWND hwnd)
|
|
{
|
|
HWND listWindow;
|
|
|
|
listWindow = GetDlgItem(hwnd, 2);
|
|
if (NULL != listWindow)
|
|
return SendMessageW(listWindow, WM_GETFONT, 0, 0L);
|
|
|
|
return DefWindowProcW(hwnd, WM_GETFONT, 0, 0L);
|
|
}
|
|
|
|
static void
|
|
SmoothScrollList_OnSetRedraw(HWND hwnd, BOOL enableRedraw)
|
|
{
|
|
HWND childWindow;
|
|
|
|
DefWindowProcW(hwnd, WM_SETREDRAW, enableRedraw, 0L);
|
|
|
|
childWindow = GetDlgItem(hwnd, 3);
|
|
if (NULL != childWindow)
|
|
{
|
|
SendMessage(childWindow, WM_SETREDRAW, enableRedraw, 0L);
|
|
if (FALSE != enableRedraw)
|
|
InvalidateRect(childWindow, NULL, TRUE);
|
|
}
|
|
|
|
childWindow = GetDlgItem(hwnd, 2);
|
|
if (NULL != childWindow)
|
|
{
|
|
SendMessage(childWindow, WM_SETREDRAW, enableRedraw, 0L);
|
|
if (FALSE != enableRedraw)
|
|
InvalidateRect(childWindow, NULL, TRUE);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
SmoothScrollList_OnSkinUpdated(HWND hwnd, BOOL notifyChildren, BOOL redraw)
|
|
{
|
|
SmoothScrollList_UpdateFontMetrics(hwnd, redraw);
|
|
}
|
|
|
|
static LRESULT
|
|
SmoothScrollList_OnDisplaySort(HWND hwnd, int sortIndex, BOOL ascendingOrder)
|
|
{
|
|
HWND headerWindow;
|
|
|
|
headerWindow = GetDlgItem(hwnd, 3);
|
|
if (NULL == headerWindow)
|
|
return 0;
|
|
|
|
return SENDMLIPC(headerWindow, ML_IPC_SKINNEDHEADER_DISPLAYSORT, MAKEWPARAM(sortIndex, ascendingOrder));
|
|
}
|
|
|
|
static LRESULT
|
|
SmoothScrollList_OnGetSort(HWND hwnd)
|
|
{
|
|
HWND headerWindow;
|
|
|
|
headerWindow = GetDlgItem(hwnd, 3);
|
|
if (NULL == headerWindow)
|
|
return 0;
|
|
|
|
return SENDMLIPC(headerWindow, ML_IPC_SKINNEDHEADER_GETSORT, 0);
|
|
}
|
|
|
|
static void
|
|
SmoothScrollList_OnKeyDown(HWND hwnd, unsigned int vKey, unsigned int keyFlags)
|
|
{
|
|
HWND listWindow;
|
|
listWindow = GetDlgItem(hwnd, 2);
|
|
|
|
if (NULL != listWindow &&
|
|
WS_VISIBLE == ((WS_VISIBLE | WS_DISABLED) & GetWindowLongPtrW(listWindow, GWL_STYLE)))
|
|
{
|
|
SendMessageW(listWindow, WM_KEYDOWN, vKey, (LPARAM)keyFlags);
|
|
}
|
|
|
|
DefWindowProcW(hwnd, WM_KEYDOWN, vKey, (LPARAM)keyFlags);
|
|
}
|
|
|
|
static LRESULT
|
|
SmoothScrollList_OnMediaLibraryIPC(HWND hwnd, INT msg, INT_PTR param)
|
|
{
|
|
switch(msg)
|
|
{
|
|
case ML_IPC_SKINNEDWND_SKINUPDATED: SmoothScrollList_OnSkinUpdated(hwnd, LOWORD(param), HIWORD(param)); break;
|
|
case ML_IPC_SKINNEDLISTVIEW_DISPLAYSORT: return SmoothScrollList_OnDisplaySort(hwnd, LOWORD(param), HIWORD(param));
|
|
case ML_IPC_SKINNEDLISTVIEW_GETSORT: return SmoothScrollList_OnGetSort(hwnd);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static LRESULT CALLBACK SmoothScrollMsgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
switch(uMsg)
|
|
{
|
|
case WM_CREATE: return SmoothScrollList_OnCreate(hwnd, (CREATESTRUCT*)lParam);
|
|
case WM_DESTROY: SmoothScrollList_OnDestroy(hwnd); return 0;
|
|
case WM_WINDOWPOSCHANGED: SmoothScrollList_OnWindowPosChanged(hwnd, (WINDOWPOS*)lParam); return 0;
|
|
case WM_MOUSEWHEEL: SmoothScrollList_OnMouseWheel(hwnd, LOWORD(wParam), (short)HIWORD(wParam), (LONG)lParam); return 0;
|
|
case WM_VSCROLL: SmoothScrollList_OnVertScroll(hwnd, LOWORD(wParam), (short)HIWORD(wParam), (HWND)lParam); return 0;
|
|
case WM_ERASEBKGND: return 1;
|
|
case WM_MEASUREITEM: return SmoothScrollList_OnMeasureItem(hwnd, (MEASUREITEMSTRUCT*)lParam);
|
|
case WM_SETFONT: SmoothScrollList_OnSetFont(hwnd, (HFONT)wParam, LOWORD(lParam)); return 0;
|
|
case WM_GETFONT: return SmoothScrollList_OnGetFont(hwnd);
|
|
case WM_SETREDRAW: SmoothScrollList_OnSetRedraw(hwnd, (BOOL)wParam); return 0;
|
|
|
|
case LVM_GETHEADER:
|
|
return (LRESULT)GetDlgItem(hwnd,3);
|
|
case LVM_INSERTCOLUMNA:
|
|
case LVM_INSERTCOLUMNW:
|
|
{
|
|
LVCOLUMNW *listColumn = (LVCOLUMNW*)lParam;
|
|
HWND controlWindow;
|
|
LRESULT result;
|
|
|
|
result = -1;
|
|
|
|
controlWindow = GetDlgItem(hwnd,3);
|
|
if (NULL != controlWindow)
|
|
{
|
|
HDITEMW headerItem;
|
|
|
|
if (FALSE == CopyListColumnToHeaderItem(listColumn, &headerItem))
|
|
return -1;
|
|
|
|
if (0 == (HDI_FORMAT & headerItem.mask))
|
|
{
|
|
headerItem.mask |= HDI_FORMAT;
|
|
headerItem.fmt = HDF_LEFT;
|
|
}
|
|
|
|
result = SendMessageW(controlWindow,
|
|
(LVM_INSERTCOLUMNW == uMsg) ? HDM_INSERTITEMW : HDM_INSERTITEMA,
|
|
wParam, (LPARAM)&headerItem);
|
|
|
|
if (-1 == result)
|
|
return result;
|
|
}
|
|
|
|
controlWindow = GetDlgItem(hwnd, 2);
|
|
if (NULL != controlWindow)
|
|
result = SendMessageW(controlWindow, uMsg, wParam, lParam);
|
|
|
|
return result;
|
|
}
|
|
break;
|
|
case LVM_DELETECOLUMN:
|
|
{
|
|
HWND controlWindow;
|
|
controlWindow = GetDlgItem(hwnd,3);
|
|
if (NULL != controlWindow &&
|
|
FALSE ==SendMessageW(controlWindow, HDM_DELETEITEM, wParam, 0L))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
controlWindow = GetDlgItem(hwnd,2);
|
|
if (NULL != controlWindow)
|
|
return SendMessageW(controlWindow ,uMsg,wParam,lParam);
|
|
}
|
|
return FALSE;
|
|
case LVM_GETCOLUMNW:
|
|
case LVM_GETCOLUMNA:
|
|
{
|
|
LVCOLUMNW *l = (LVCOLUMNW *)lParam;
|
|
HDITEMW h;
|
|
HWND headerWindow;
|
|
|
|
headerWindow = GetDlgItem(hwnd, 3);
|
|
if (NULL == headerWindow)
|
|
return FALSE;
|
|
|
|
if (FALSE == CopyListColumnToHeaderItem(l, &h))
|
|
return FALSE;
|
|
|
|
if(!SendMessageW(headerWindow,
|
|
(LVM_GETCOLUMNW == uMsg) ? HDM_GETITEMW : HDM_GETITEMA,
|
|
wParam,
|
|
(LPARAM)&h))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (FALSE == CopyHeaderItemToListColumn(&h, l))
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
case LVM_GETCOLUMNWIDTH:
|
|
{
|
|
HWND controlWindow;
|
|
|
|
controlWindow = GetDlgItem(hwnd,3);
|
|
if (NULL != controlWindow)
|
|
{
|
|
HDITEMW h;
|
|
h.mask = HDI_WIDTH;
|
|
if (FALSE == SendMessageW(controlWindow, HDM_GETITEM, wParam, (LPARAM)&h))
|
|
return 0;
|
|
|
|
return h.cxy;
|
|
}
|
|
|
|
controlWindow = GetDlgItem(hwnd, 2);
|
|
if (NULL != controlWindow)
|
|
return SendMessageW(controlWindow, uMsg, wParam, lParam);
|
|
}
|
|
break;
|
|
case LVM_SETCOLUMNW:
|
|
case LVM_SETCOLUMNA:
|
|
{
|
|
LVCOLUMNW *l = (LVCOLUMNW *)lParam;
|
|
HWND controlWindow;
|
|
LRESULT result;
|
|
|
|
controlWindow = GetDlgItem(hwnd, 3);
|
|
if (NULL != controlWindow)
|
|
{
|
|
HDITEMW h;
|
|
|
|
if (FALSE == CopyListColumnToHeaderItem(l, &h))
|
|
return FALSE;
|
|
|
|
if(!SendMessageW(controlWindow,
|
|
(LVM_SETCOLUMNW == uMsg) ? HDM_SETITEMW : HDM_SETITEMA,
|
|
wParam, (LPARAM)&h))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (FALSE == CopyHeaderItemToListColumn(&h, l))
|
|
return FALSE;
|
|
|
|
result = TRUE;
|
|
}
|
|
else result = FALSE;
|
|
|
|
controlWindow = GetDlgItem(hwnd,2);
|
|
if (NULL != controlWindow)
|
|
result = SendMessageW(controlWindow, uMsg, wParam, lParam);
|
|
|
|
return result;
|
|
}
|
|
break;
|
|
|
|
case LVM_SETCOLUMNWIDTH:
|
|
{
|
|
HWND controlWindow;
|
|
LRESULT result;
|
|
|
|
controlWindow = GetDlgItem(hwnd, 3);
|
|
if (NULL != controlWindow)
|
|
{
|
|
HDITEMW headerItem;
|
|
|
|
if (LVSCW_AUTOSIZE == lParam)
|
|
return FALSE;
|
|
|
|
if (LVSCW_AUTOSIZE_USEHEADER == lParam)
|
|
return FALSE;
|
|
|
|
headerItem.mask = HDI_WIDTH;
|
|
headerItem.cxy = (int)lParam;
|
|
|
|
result = SendMessageW(controlWindow, HDM_SETITEMW, (WPARAM)wParam, (LPARAM)&headerItem);
|
|
if (FALSE == result)
|
|
return FALSE;
|
|
}
|
|
else
|
|
result = FALSE;
|
|
|
|
controlWindow = GetDlgItem(hwnd,2);
|
|
if (NULL != controlWindow)
|
|
result = SendMessageW(controlWindow, uMsg, wParam, lParam);
|
|
|
|
return result;
|
|
}
|
|
break;
|
|
|
|
case LVM_SETITEMCOUNT:
|
|
{
|
|
LRESULT result;
|
|
HWND controlWindow = GetDlgItem(hwnd,2);
|
|
|
|
result = (NULL != controlWindow) ?
|
|
SendMessageW(controlWindow, uMsg, wParam,lParam) :
|
|
0;
|
|
|
|
UpdateScrollInfo(hwnd, SIF_RANGE | SIF_POS, TRUE);
|
|
return result;
|
|
}
|
|
break;
|
|
case LVM_ENSUREVISIBLE:
|
|
return SmoothScrollList_EnsureVisible(hwnd, (int)wParam, (BOOL)lParam);
|
|
|
|
case WM_EX_UPDATESCROLLINFO:
|
|
return UpdateScrollInfo(hwnd, (UINT)wParam, (BOOL)lParam);
|
|
|
|
case WM_EX_UNLOCKREDRAW:
|
|
{
|
|
unsigned long windowStyle;
|
|
unsigned int redrawFlags;
|
|
HRGN regionInvalid;
|
|
RECT rect;
|
|
|
|
windowStyle = GetWindowLongPtrW(hwnd, GWL_STYLE);
|
|
if (0 == (WS_VISIBLE & windowStyle))
|
|
SetWindowLongPtrW(hwnd, GWL_STYLE, windowStyle | WS_VISIBLE);
|
|
|
|
redrawFlags = RDW_INVALIDATE | RDW_ALLCHILDREN;
|
|
|
|
|
|
if (0 != (IWF_FRAME & wParam))
|
|
{
|
|
redrawFlags |= RDW_FRAME;
|
|
GetWindowRect(hwnd, &rect);
|
|
MapWindowPoints(HWND_DESKTOP, hwnd, (POINT*)&rect, 2);
|
|
}
|
|
else
|
|
GetClientRect(hwnd, &rect);
|
|
|
|
if (0 != (IWF_ERASE & wParam))
|
|
redrawFlags |= RDW_ERASE;
|
|
|
|
if (0 != (IWF_UPDATENOW & wParam))
|
|
{
|
|
redrawFlags |= RDW_UPDATENOW;
|
|
if (0 != (IWF_ERASE & wParam))
|
|
redrawFlags |= RDW_ERASENOW;
|
|
}
|
|
|
|
|
|
|
|
regionInvalid = CreateRectRgnIndirect(&rect);
|
|
if (NULL != regionInvalid)
|
|
{
|
|
HWND headerWindow;
|
|
|
|
headerWindow = GetDlgItem(hwnd, 3);
|
|
if (NULL != headerWindow &&
|
|
0 != (WS_VISIBLE & GetWindowLongPtrW(headerWindow, GWL_STYLE)))
|
|
{
|
|
HRGN regionHeader;
|
|
GetWindowRect(headerWindow, &rect);
|
|
MapWindowPoints(HWND_DESKTOP, hwnd, (POINT*)&rect, 2);
|
|
regionHeader = CreateRectRgnIndirect(&rect);
|
|
if (NULL != regionHeader)
|
|
{
|
|
CombineRgn(regionInvalid, regionInvalid, regionHeader, RGN_DIFF);
|
|
DeleteObject(regionHeader);
|
|
}
|
|
}
|
|
}
|
|
|
|
RedrawWindow(hwnd, NULL, regionInvalid, redrawFlags);
|
|
|
|
if (NULL != regionInvalid)
|
|
DeleteObject(regionInvalid);
|
|
}
|
|
break;
|
|
case WM_NOTIFY:
|
|
{
|
|
LPNMHDR l=(LPNMHDR)lParam;
|
|
if(l->idFrom == 2)
|
|
{
|
|
l->idFrom = GetWindowLongPtrW(hwnd,GWLP_ID);
|
|
l->hwndFrom = hwnd; // this is prevents double reflecting
|
|
return SendMessageW(GetParent(hwnd),uMsg,l->idFrom,lParam);
|
|
}
|
|
else if(l->idFrom == 3)
|
|
{
|
|
switch(l->code)
|
|
{
|
|
case HDN_ITEMCLICKA:
|
|
case HDN_ITEMCLICKW:
|
|
{
|
|
NMHEADER *nm = (NMHEADER*)lParam;
|
|
HWND hwndParent;
|
|
hwndParent = GetParent(hwnd);
|
|
if (hwndParent)
|
|
{
|
|
wParam = GetWindowLongPtrW(hwnd,GWLP_ID);
|
|
if(nm->iButton == 0) { // left click
|
|
NMLISTVIEW p = {{hwnd, wParam, LVN_COLUMNCLICK},-1,nm->iItem,0};
|
|
return SendMessageW(hwndParent,WM_NOTIFY,wParam,(LPARAM)&p);
|
|
} else if(nm->iButton == 1) { // right click
|
|
NMHDR p = {nm->hdr.hwndFrom,wParam,NM_RCLICK};
|
|
return SendMessageW(hwndParent,WM_NOTIFY,wParam,(LPARAM)&p);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case HDN_ITEMCHANGINGA:
|
|
case HDN_ITEMCHANGINGW:
|
|
case HDN_ITEMCHANGEDA:
|
|
case HDN_ITEMCHANGEDW:
|
|
{
|
|
LRESULT result;
|
|
NMHEADER *nm = (NMHEADER*)lParam;
|
|
|
|
result = SendMessageW(GetParent(hwnd),uMsg, wParam,lParam);
|
|
if (FALSE != result &&
|
|
(HDN_ITEMCHANGINGW == l->code || HDN_ITEMCHANGINGA == l->code))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
if (NULL != nm->pitem &&
|
|
0 != (HDI_WIDTH & nm->pitem->mask))
|
|
{
|
|
HWND hwndList;
|
|
hwndList = GetDlgItem(hwnd,2);
|
|
if (hwndList)
|
|
{
|
|
unsigned long windowStyle;
|
|
windowStyle = GetWindowLongPtrW(hwnd, GWL_STYLE);
|
|
if (0 != (WS_VISIBLE & windowStyle))
|
|
SetWindowLongPtrW(hwnd, GWL_STYLE, windowStyle & ~WS_VISIBLE);
|
|
|
|
ListView_SetColumnWidth(hwndList, nm->iItem,nm->pitem->cxy);
|
|
|
|
if (0 != (WS_VISIBLE & windowStyle))
|
|
{
|
|
windowStyle = GetWindowLongPtrW(hwnd, GWL_STYLE);
|
|
if (0 == (WS_VISIBLE & windowStyle))
|
|
{
|
|
windowStyle |= WS_VISIBLE;
|
|
SetWindowLongPtrW(hwnd, GWL_STYLE, windowStyle);
|
|
}
|
|
|
|
InvalidateRect(hwndList, NULL, FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
break;
|
|
}
|
|
return SendMessageW(GetParent(hwnd),uMsg, wParam,lParam);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_EX_GETREALLIST:
|
|
return (LRESULT)GetDlgItem(hwnd, 2);
|
|
case WM_EX_GETCOUNTPERPAGE:
|
|
return SendMessageW(GetDlgItem(hwnd, 2), LVM_GETCOUNTPERPAGE, 0, 0L) + 1;
|
|
|
|
case WM_KEYDOWN: SmoothScrollList_OnKeyDown(hwnd, (unsigned int)wParam, (unsigned int)lParam); return 0;
|
|
|
|
case WM_ML_IPC:
|
|
return SmoothScrollList_OnMediaLibraryIPC(hwnd, (INT)lParam, (INT_PTR)wParam);
|
|
|
|
default:
|
|
if(uMsg >= LVM_FIRST && uMsg < LVM_FIRST + 0x100)
|
|
{
|
|
HWND hwndList = GetDlgItem(hwnd,2);
|
|
if (hwndList) return ListViewSubclass(hwndList, uMsg, wParam, lParam);
|
|
}
|
|
break;
|
|
}
|
|
return DefWindowProcW(hwnd,uMsg,wParam,lParam);
|
|
}
|
|
|
|
void InitSmoothScrollList() {
|
|
WNDCLASSW wc = {0, };
|
|
|
|
if (GetClassInfoW(plugin.hDllInstance, L"SmoothScrollList", &wc)) return;
|
|
wc.style = CS_DBLCLKS;
|
|
wc.lpfnWndProc = SmoothScrollMsgProc;
|
|
wc.hInstance = plugin.hDllInstance;
|
|
wc.lpszClassName = L"SmoothScrollList";
|
|
RegisterClassW(&wc);
|
|
}
|