Initial community commit
This commit is contained in:
Jef
parent
537bcbc862
commit
fc06254474
16440 changed files with 4239995 additions and 2 deletions
832
Src/Plugins/General/gen_ml/skinnedheader.cpp
Normal file
832
Src/Plugins/General/gen_ml/skinnedheader.cpp
Normal file
|
|
@ -0,0 +1,832 @@
|
|||
#include "main.h"
|
||||
#include "config.h"
|
||||
#include "../winamp/wa_dlg.h"
|
||||
#include "./skinnedheader.h"
|
||||
#include "./skinning.h"
|
||||
#include "./ml_imagelist.h"
|
||||
#include "./imagefilters.h"
|
||||
#include "./ml_cloudcolumn.h"
|
||||
#include "./resource.h"
|
||||
|
||||
// Timers
|
||||
#define TIMER_UNBLOCKREDRAW_ID 1978
|
||||
#define TIMER_ENDTRACK_ID 1979
|
||||
#define TIMER_ENDTRACK_DELAY 5
|
||||
|
||||
// Header internal flags (LOWORD reserved to sort index)
|
||||
#define HIF_ASCENDING 0x00010000
|
||||
#define HIF_OWNPARENTSW 0x00020000 // parent was subclassed by this control
|
||||
#define HIF_REALCXY 0x00040000
|
||||
#define HIF_DEFSIZERULE 0x00100000 // item will use default size rule.
|
||||
#define HIF_BLOCKCHANGING 0x10000000
|
||||
#define HIF_BLOCKCHANGED 0x20000000
|
||||
#define HIF_BLOCKWNDPOS 0x40000000
|
||||
#define HIF_BLOCKREDRAW 0x80000000
|
||||
|
||||
extern HMLIMGFLTRMNGR hmlifMngr; // default gen_ml fitler manager
|
||||
|
||||
typedef struct _HDSIZE
|
||||
{
|
||||
INT instanceRef;
|
||||
INT *pCXY; // stored by index
|
||||
INT *pOrder; // current left-to-right order of items (index values for items in the header).
|
||||
INT count;
|
||||
INT allocated;
|
||||
INT headerCXY;
|
||||
INT lastCXY;
|
||||
HWND hwndParent;
|
||||
HDITEMW hdi; // safe to use duaring size
|
||||
} HDSIZE;
|
||||
|
||||
typedef struct _HDCURSOR
|
||||
{
|
||||
HWND hwndParent;
|
||||
NMMOUSE nm;
|
||||
HDHITTESTINFO hitTest;
|
||||
DWORD pts;
|
||||
} HDCURSOR;
|
||||
|
||||
static HDSIZE hdrSize = {0,0,0, } ;
|
||||
|
||||
static INT GetDefaultSizeRule(void)
|
||||
{
|
||||
INT rule;
|
||||
rule = g_config->ReadInt(L"column_resize_mode", 0);
|
||||
switch(rule)
|
||||
{
|
||||
case 1: return SHS_SIZERULE_ADJUSTONE;
|
||||
case 2: return SHS_SIZERULE_PROPORTIONAL;
|
||||
case 3: return SHS_SIZERULE_ADJUSTALL;
|
||||
}
|
||||
return SHS_SIZERULE_WINDOWS;
|
||||
}
|
||||
|
||||
SkinnedHeader::SkinnedHeader(void) : SkinnedWnd(FALSE), hcurNormal(NULL), cloudColumn(-1)
|
||||
{
|
||||
if (!hdrSize.instanceRef)
|
||||
ZeroMemory(&hdrSize, sizeof(HDSIZE));
|
||||
|
||||
hdrSize.instanceRef++;
|
||||
|
||||
hdrFlags = LOWORD(-1) | HIF_ASCENDING | HIF_DEFSIZERULE;
|
||||
hdrSizeRule = (HIF_DEFSIZERULE & hdrFlags) ? GetDefaultSizeRule() : SHS_SIZERULE_WINDOWS;
|
||||
}
|
||||
|
||||
SkinnedHeader::~SkinnedHeader(void)
|
||||
{
|
||||
if (hdrSize.instanceRef && !--hdrSize.instanceRef)
|
||||
{
|
||||
if (hdrSize.pCXY)
|
||||
free(hdrSize.pCXY); // pOrder - use same buffer
|
||||
ZeroMemory(&hdrSize, sizeof(HDSIZE));
|
||||
}
|
||||
}
|
||||
|
||||
extern HMLIMGLST hmlilCloud;
|
||||
BOOL SkinnedHeader::Attach(HWND hwndHeader)
|
||||
{
|
||||
HWND hwndParent;
|
||||
|
||||
if(!__super::Attach(hwndHeader)) return FALSE;
|
||||
|
||||
SetType(SKINNEDWND_TYPE_HEADER);
|
||||
|
||||
hwndParent = GetParent(hwndHeader);
|
||||
if (hwndParent) SkinWindow(hwndParent, SWS_NORMAL);
|
||||
|
||||
hdrFlags = LOWORD(-1) | HIF_ASCENDING | HIF_DEFSIZERULE;
|
||||
hdrSizeRule = (HIF_DEFSIZERULE & hdrFlags) ? GetDefaultSizeRule() : SHS_SIZERULE_WINDOWS;
|
||||
|
||||
// set default height
|
||||
SetHeight(-1);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
void SkinnedHeader::OnSkinChanged(BOOL bNotifyChildren, BOOL bRedraw)
|
||||
{
|
||||
hcurNormal = (HCURSOR)SendMessageW(plugin.hwndParent, WM_WA_IPC, WACURSOR_NORMAL, IPC_GETSKINCURSORS);
|
||||
__super::OnSkinChanged(bNotifyChildren, bRedraw);
|
||||
}
|
||||
|
||||
void SkinnedHeader::BlockRedraw(BOOL bBlock, UINT unblockDelay)
|
||||
{
|
||||
KillTimer(hwnd, TIMER_UNBLOCKREDRAW_ID);
|
||||
|
||||
if (FALSE != bBlock)
|
||||
hdrFlags |= HIF_BLOCKREDRAW;
|
||||
else
|
||||
hdrFlags &= ~HIF_BLOCKREDRAW;
|
||||
|
||||
CallDefWndProc(WM_SETREDRAW, (WPARAM)!bBlock, 0L);
|
||||
|
||||
if (FALSE != bBlock && -1 != unblockDelay)
|
||||
SetTimer(hwnd, TIMER_UNBLOCKREDRAW_ID, unblockDelay, NULL);
|
||||
}
|
||||
|
||||
DWORD SkinnedHeader::GetSortArrowSize(void)
|
||||
{
|
||||
return MAKELPARAM(7, 8);
|
||||
}
|
||||
|
||||
BOOL SkinnedHeader::DrawSortArrow(HDC hdc, RECT *prc, COLORREF rgbBk, COLORREF rgbFg, BOOL bAscending)
|
||||
{
|
||||
static HMLIMGLST hmlilSort = NULL;
|
||||
IMAGELISTDRAWPARAMS ildp;
|
||||
|
||||
if (!hmlilSort)
|
||||
{
|
||||
DWORD arrowSize = GetSortArrowSize();
|
||||
hmlilSort = MLImageListI_Create(GET_X_LPARAM(arrowSize)*2, GET_Y_LPARAM(arrowSize), MLILC_COLOR24_I, 1, 1, 1, hmlifMngr);
|
||||
if (hmlilSort)
|
||||
{
|
||||
MLIMAGESOURCE_I mlis;
|
||||
ZeroMemory(&mlis, sizeof(MLIMAGESOURCE_I));
|
||||
mlis.type = SRC_TYPE_PNG_I;
|
||||
mlis.hInst = plugin.hDllInstance;
|
||||
mlis.lpszName = MAKEINTRESOURCEW(IDB_SORTARROW);
|
||||
MLImageListI_Add(hmlilSort, &mlis, MLIF_FILTER1_UID, 0);
|
||||
}
|
||||
}
|
||||
|
||||
ZeroMemory(&ildp, sizeof(IMAGELISTDRAWPARAMS));
|
||||
ildp.cbSize = 56; // keep it hardcoded for now - otherwise brakes win2000. sizeof(IMAGELISTDRAWPARAMS);
|
||||
|
||||
ildp.i = MLImageListI_GetRealIndex(hmlilSort, 0, rgbBk, rgbFg);
|
||||
if (-1 != ildp.i)
|
||||
{
|
||||
ildp.hdcDst = hdc;
|
||||
ildp.himl = MLImageListI_GetRealList(hmlilSort);
|
||||
|
||||
ildp.cx = prc->right - prc->left;
|
||||
ildp.cy = prc->bottom - prc->top;
|
||||
ildp.x = prc->left;
|
||||
ildp.y = prc->top;
|
||||
ildp.fStyle = ILD_NORMAL;
|
||||
ildp.dwRop = SRCCOPY;
|
||||
ildp.xBitmap = (bAscending) ? ildp.cx : 0;
|
||||
return ImageList_DrawIndirect(&ildp);
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BOOL SkinnedHeader::DrawCloudIcon(HDC hdc, RECT *prc, COLORREF rgbBk, COLORREF rgbFg)
|
||||
{
|
||||
IMAGELISTDRAWPARAMS ildp;
|
||||
|
||||
ZeroMemory(&ildp, sizeof(IMAGELISTDRAWPARAMS));
|
||||
ildp.cbSize = 56; // keep it hardcoded for now - otherwise brakes win2000. sizeof(IMAGELISTDRAWPARAMS);
|
||||
|
||||
ildp.i = MLImageListI_GetRealIndex(hmlilCloud, 0, rgbBk, rgbFg);
|
||||
if (-1 != ildp.i)
|
||||
{
|
||||
ildp.hdcDst = hdc;
|
||||
ildp.himl = MLImageListI_GetRealList(hmlilCloud);
|
||||
|
||||
ildp.cx = 16;
|
||||
ildp.cy = 16;
|
||||
ildp.x = prc->left - 7;
|
||||
ildp.y = prc->top - 4;
|
||||
ildp.fStyle = ILD_NORMAL;
|
||||
ildp.dwRop = SRCCOPY;
|
||||
ildp.xBitmap = 0;
|
||||
return ImageList_DrawIndirect(&ildp);
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
void SkinnedHeader::DrawHeaderItem(LPNMCUSTOMDRAW pnmcd)
|
||||
{
|
||||
HPEN pen, penOld;
|
||||
HDC hdc;
|
||||
RECT *prc, rcText;
|
||||
INT textRight;
|
||||
INT ox, oy;
|
||||
|
||||
hdc = pnmcd->hdc;
|
||||
prc = &pnmcd->rc;
|
||||
|
||||
ox = (CDIS_SELECTED & pnmcd->uItemState) ? 1 : 0;
|
||||
oy = 0;
|
||||
|
||||
SetBkColor(hdc, WADlg_getColor(WADLG_LISTHEADER_BGCOLOR));
|
||||
ExtTextOutW(hdc, 0, 0, ETO_OPAQUE, prc, L"", 0, 0);
|
||||
|
||||
pen = (HPEN)MlStockObjects_Get((CDIS_SELECTED & pnmcd->uItemState) ? HEADERBOTTOM_PEN : HEADERTOP_PEN);
|
||||
penOld = (HPEN)SelectObject(hdc, pen);
|
||||
|
||||
MoveToEx(hdc, prc->left, prc->top, NULL);
|
||||
LineTo(hdc, prc->right, prc->top);
|
||||
MoveToEx(hdc, prc->left, prc->top, NULL);
|
||||
LineTo(hdc, prc->left, prc->bottom);
|
||||
|
||||
if (0 == (CDIS_SELECTED & pnmcd->uItemState))
|
||||
{
|
||||
SelectObject(hdc, penOld);
|
||||
|
||||
pen = (HPEN)MlStockObjects_Get(HEADERBOTTOM_PEN);
|
||||
penOld = (HPEN)SelectObject(hdc, pen);
|
||||
}
|
||||
|
||||
MoveToEx(hdc, prc->right - 1, prc->top, NULL);
|
||||
LineTo(hdc, prc->right - 1, prc->bottom);
|
||||
MoveToEx(hdc, prc->right - 1, prc->bottom - 1, NULL);
|
||||
LineTo(hdc, prc->left - 1, prc->bottom - 1);
|
||||
|
||||
if (0 == (CDIS_SELECTED & pnmcd->uItemState))
|
||||
{
|
||||
SelectObject(hdc, penOld);
|
||||
|
||||
pen = (HPEN)MlStockObjects_Get(HEADERMIDDLE_PEN);
|
||||
penOld = (HPEN)SelectObject(hdc, pen);
|
||||
|
||||
MoveToEx(hdc, prc->right - 2, prc->top + 1, NULL);
|
||||
LineTo(hdc, prc->right - 2, prc->bottom - 2);
|
||||
MoveToEx(hdc, prc->right - 2, prc->bottom - 2, NULL);
|
||||
LineTo(hdc, prc->left, prc->bottom - 2);
|
||||
}
|
||||
|
||||
textRight = prc->right - 5 + ox;
|
||||
if (LOWORD(hdrFlags) == pnmcd->dwItemSpec || pnmcd->dwItemSpec == cloudColumn)
|
||||
{
|
||||
RECT r;
|
||||
DWORD arrowSize;
|
||||
int dividerArea;
|
||||
|
||||
arrowSize = GetSortArrowSize();
|
||||
SetRect(&r, 0, 0, GET_X_LPARAM(arrowSize), GET_Y_LPARAM(arrowSize));
|
||||
|
||||
dividerArea = 4*GetSystemMetrics(SM_CXEDGE);
|
||||
|
||||
OffsetRect(&r, prc->right - r.right - dividerArea, (((prc->bottom - prc->top) - r.bottom) + 1)/2);
|
||||
|
||||
if (pnmcd->dwItemSpec != cloudColumn && (r.left > (prc->left + 16) && r.top > (prc->top + 2)))
|
||||
{
|
||||
if (DrawSortArrow(hdc, &r,
|
||||
WADlg_getColor(WADLG_LISTHEADER_BGCOLOR),
|
||||
WADlg_getColor(WADLG_LISTHEADER_FONTCOLOR),
|
||||
(HIF_ASCENDING & hdrFlags))) textRight = r.left - 3;
|
||||
}
|
||||
else if (pnmcd->dwItemSpec == cloudColumn)
|
||||
{
|
||||
if ((prc->right - prc->left) >= MLCloudColumnI_GetMinWidth())
|
||||
{
|
||||
DrawCloudIcon(hdc, &r,
|
||||
WADlg_getColor(WADLG_LISTHEADER_BGCOLOR),
|
||||
WADlg_getColor(WADLG_LISTHEADER_FONTCOLOR));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (pnmcd->dwItemSpec != cloudColumn && (textRight > (prc->left + 4 + ox)))
|
||||
{
|
||||
WCHAR buffer[128] = {0};
|
||||
HDITEMW item;
|
||||
|
||||
item.mask = HDI_TEXT | HDI_FORMAT;
|
||||
item.pszText = buffer;
|
||||
item.cchTextMax = sizeof(buffer)/sizeof(wchar_t) -1;
|
||||
|
||||
if (CallPrevWndProc(HDM_GETITEMW, (WPARAM)pnmcd->dwItemSpec, (LPARAM)&item))
|
||||
{
|
||||
DWORD format;
|
||||
SetBkMode(hdc, TRANSPARENT);
|
||||
SetTextColor(hdc, WADlg_getColor(WADLG_LISTHEADER_FONTCOLOR));
|
||||
|
||||
SetRect(&rcText, prc->left + 5 + ox, prc->top + 2 + oy, textRight, prc->bottom - 2);
|
||||
format = DT_VCENTER | DT_SINGLELINE | DT_LEFT | DT_NOCLIP;
|
||||
|
||||
switch(HDF_JUSTIFYMASK & item.fmt)
|
||||
{
|
||||
case HDF_RIGHT: format |= DT_RIGHT; break;
|
||||
case HDF_CENTER: format |= DT_CENTER; break;
|
||||
}
|
||||
// because we draw with DT_NOCLIP, make sure we don't overhang to the right
|
||||
RECT testRect = rcText;
|
||||
DrawTextW(hdc, item.pszText, -1, &testRect, format | DT_CALCRECT);
|
||||
if (testRect.right > textRight)
|
||||
{
|
||||
format &= ~(HDF_JUSTIFYMASK | DT_NOCLIP);
|
||||
format |= DT_LEFT;
|
||||
|
||||
if ((testRect.right - textRight) > 6)
|
||||
format |= DT_END_ELLIPSIS;
|
||||
}
|
||||
|
||||
DrawTextW(hdc, item.pszText, -1, &rcText, format);
|
||||
}
|
||||
}
|
||||
|
||||
SelectObject(hdc, penOld);
|
||||
}
|
||||
|
||||
BOOL SkinnedHeader::OnCustomDraw(HWND hwndFrom, NMCUSTOMDRAW *pnmcd, LRESULT *pResult)
|
||||
{
|
||||
switch(pnmcd->dwDrawStage)
|
||||
{
|
||||
case CDDS_PREPAINT:
|
||||
*pResult = (SWS_USESKINCOLORS & style) ?
|
||||
CDRF_NOTIFYITEMDRAW :
|
||||
CDRF_DODEFAULT;
|
||||
return TRUE;
|
||||
case CDDS_ITEMPREPAINT:
|
||||
DrawHeaderItem(pnmcd);
|
||||
*pResult = CDRF_SKIPDEFAULT;
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
UINT SkinnedHeader::SizeRuleAdjustOne(HDITEMW *phdi, INT index, UINT uMsg)
|
||||
{
|
||||
UINT result, flags;
|
||||
|
||||
flags = hdrFlags;
|
||||
hdrFlags |= HIF_REALCXY;
|
||||
|
||||
result = 0;
|
||||
if (index < hdrSize.count)
|
||||
{
|
||||
INT delta;
|
||||
delta = phdi->cxy - hdrSize.pCXY[index];
|
||||
|
||||
hdrSize.hdi.mask = HDI_WIDTH;
|
||||
phdi = &hdrSize.hdi;
|
||||
|
||||
if (delta)
|
||||
{
|
||||
if(CallPrevWndProc(HDM_GETITEMW, index + 1, (LPARAM)phdi))
|
||||
{
|
||||
INT temp = phdi->cxy;
|
||||
phdi->cxy -= delta;
|
||||
if (CallPrevWndProc(HDM_SETITEMW, index + 1, (LPARAM)phdi)) delta = temp - phdi->cxy;
|
||||
else delta = 0;
|
||||
}
|
||||
hdrSize.pCXY[index] += delta;
|
||||
result = 1;
|
||||
}
|
||||
}
|
||||
|
||||
hdrFlags = flags;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
UINT SkinnedHeader::SizeRuleProportional(HDITEMW *phdi, INT index, UINT uMsg)
|
||||
{
|
||||
UINT flags;
|
||||
INT o, delta;
|
||||
|
||||
if (index >= hdrSize.count ||
|
||||
hdrSize.lastCXY == phdi->cxy ||
|
||||
0 == (phdi->cxy - hdrSize.pCXY[index]))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
flags = hdrFlags;
|
||||
hdrFlags |= HIF_REALCXY;
|
||||
|
||||
delta = phdi->cxy - hdrSize.pCXY[index];
|
||||
|
||||
hdrSize.lastCXY = phdi->cxy;
|
||||
|
||||
for (o = 0; o < hdrSize.count; o++)
|
||||
{
|
||||
if (hdrSize.pOrder[o] == index)
|
||||
break;
|
||||
}
|
||||
|
||||
phdi = &hdrSize.hdi;
|
||||
phdi->mask = HDI_WIDTH;
|
||||
|
||||
for(++o; o < hdrSize.count && 0 != delta; o++)
|
||||
{
|
||||
INT i = hdrSize.pOrder[o];
|
||||
|
||||
INT r = delta / (hdrSize.count - o) + ((delta % (hdrSize.count - o)) ? ((delta >0) ? 1 : -1) : 0);
|
||||
if (0 == r)
|
||||
r = delta;
|
||||
|
||||
phdi->cxy = hdrSize.pCXY[i] - r;
|
||||
INT temp = phdi->cxy;
|
||||
|
||||
CallPrevWndProc(HDM_SETITEMW, i, (LPARAM)phdi);
|
||||
delta -= r;
|
||||
|
||||
// hdrSize.pCXY[i] = phdi->cxy;
|
||||
|
||||
if (phdi->cxy != temp)
|
||||
delta += (phdi->cxy- temp);
|
||||
}
|
||||
|
||||
hdrFlags = flags;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
BOOL SkinnedHeader::OnBeginTrack(HWND hwndFrom, NMHEADERW *phdn, LRESULT *pResult)
|
||||
{
|
||||
if (HIF_DEFSIZERULE & hdrFlags) hdrSizeRule = GetDefaultSizeRule();
|
||||
|
||||
KillTimer(hwnd, TIMER_ENDTRACK_ID);
|
||||
|
||||
hdrSize.headerCXY = 0;
|
||||
hdrSize.lastCXY = -1;
|
||||
hdrSize.hwndParent = hwndFrom;
|
||||
|
||||
hdrSize.count = (INT)CallPrevWndProc(HDM_GETITEMCOUNT, 0, 0L);
|
||||
if (hdrSize.count < 0) hdrSize.count = 0;
|
||||
|
||||
if (hdrSize.count > 0)
|
||||
{
|
||||
HDITEMW item;
|
||||
|
||||
if (hdrSize.count > hdrSize.allocated)
|
||||
{
|
||||
VOID *data;
|
||||
data = realloc(hdrSize.pCXY, sizeof(INT)*hdrSize.count*2);
|
||||
if (data)
|
||||
{
|
||||
hdrSize.pCXY = (INT*)data;
|
||||
hdrSize.pOrder = hdrSize.pCXY + hdrSize.count;
|
||||
hdrSize.allocated = hdrSize.count;
|
||||
}
|
||||
if (!data) hdrSize.count = 0;
|
||||
}
|
||||
|
||||
if (hdrSize.count)
|
||||
{
|
||||
INT i;
|
||||
if (!CallPrevWndProc(HDM_GETORDERARRAY, hdrSize.count, (LPARAM)hdrSize.pOrder))
|
||||
{
|
||||
for (i = 0; i < hdrSize.count; i++) hdrSize.pOrder[i] = i;
|
||||
}
|
||||
|
||||
item.mask = HDI_WIDTH;
|
||||
for (INT o = 0; o < hdrSize.count; o++)
|
||||
{
|
||||
i = hdrSize.pOrder[o];
|
||||
if (SendMessageW(hwnd, HDM_GETITEMW, i, (LPARAM)&item) && item.lParam)
|
||||
{
|
||||
hdrSize.pCXY[i] = item.cxy;
|
||||
hdrSize.headerCXY += item.cxy;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BOOL SkinnedHeader::OnEndTrack(HWND hwndFrom, NMHEADERW *phdn)
|
||||
{
|
||||
if (hdrSize.count)
|
||||
{
|
||||
BlockRedraw(FALSE, 0);
|
||||
hdrFlags &= ~(HIF_BLOCKCHANGING | HIF_BLOCKCHANGED);
|
||||
SetTimer(hwnd, TIMER_ENDTRACK_ID, TIMER_ENDTRACK_DELAY, NULL);
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BOOL SkinnedHeader::OnItemChanging(HWND hwndFrom, NMHEADERW *phdn, LRESULT *pResult)
|
||||
{
|
||||
if (HIF_BLOCKCHANGING & hdrFlags)
|
||||
{
|
||||
*pResult = FALSE;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
if (0 != hdrSize.count &&
|
||||
0 == (HIF_REALCXY & hdrFlags))
|
||||
{
|
||||
switch(hdrSizeRule)
|
||||
{
|
||||
case SHS_SIZERULE_ADJUSTONE:
|
||||
case SHS_SIZERULE_PROPORTIONAL:
|
||||
case SHS_SIZERULE_ADJUSTALL:
|
||||
BlockRedraw(TRUE, 10);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BOOL SkinnedHeader::OnItemChanged(HWND hwndFrom, NMHEADERW *phdn)
|
||||
{
|
||||
UINT result;
|
||||
|
||||
if (HIF_BLOCKCHANGED & hdrFlags)
|
||||
return TRUE;
|
||||
|
||||
if((HIF_REALCXY & hdrFlags) || !phdn->pitem || 0== (HDI_WIDTH & phdn->pitem->mask))
|
||||
return FALSE;
|
||||
|
||||
hdrFlags |= HIF_BLOCKCHANGED;
|
||||
|
||||
switch(hdrSizeRule)
|
||||
{
|
||||
case SHS_SIZERULE_ADJUSTONE: result = SizeRuleAdjustOne(phdn->pitem, phdn->iItem, phdn->hdr.code); break;
|
||||
case SHS_SIZERULE_PROPORTIONAL: result = SizeRuleProportional(phdn->pitem, phdn->iItem, phdn->hdr.code); break;
|
||||
case SHS_SIZERULE_ADJUSTALL: result = 0; break;
|
||||
default: result = 0; break;
|
||||
}
|
||||
|
||||
hdrFlags &= ~HIF_BLOCKCHANGED;
|
||||
|
||||
if (result)
|
||||
{
|
||||
if(hdrSize.count)
|
||||
{
|
||||
INT i;
|
||||
HDITEMW item;
|
||||
item.mask = HDI_WIDTH;
|
||||
i = hdrSize.pOrder[hdrSize.count - 1];
|
||||
if (CallPrevWndProc(HDM_GETITEMW, i, (LPARAM)&item))
|
||||
{
|
||||
long cxy = item.cxy;
|
||||
hdrFlags |= (HIF_BLOCKCHANGING | HIF_BLOCKCHANGED | HIF_REALCXY);
|
||||
item.cxy = cxy + 1;
|
||||
CallPrevWndProc(HDM_SETITEMW, i, (LPARAM)&item);
|
||||
hdrFlags &= ~(HIF_BLOCKCHANGING | HIF_BLOCKCHANGED);
|
||||
item.cxy = cxy;
|
||||
CallPrevWndProc(HDM_SETITEMW, i, (LPARAM)&item);
|
||||
hdrFlags &= ~HIF_REALCXY;
|
||||
}
|
||||
}
|
||||
|
||||
BlockRedraw(FALSE, 0);
|
||||
|
||||
if (NULL != hdrSize.hwndParent)
|
||||
{
|
||||
RedrawWindow(hdrSize.hwndParent, NULL, NULL,
|
||||
RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASENOW | RDW_ALLCHILDREN/*| RDW_VALIDATE*/);
|
||||
}
|
||||
else
|
||||
RedrawWindow(hwnd, NULL, NULL,
|
||||
RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASENOW | RDW_ALLCHILDREN/*| RDW_VALIDATE*/);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BOOL SkinnedHeader::OnCursorNotify(HWND hwndFrom, NMMOUSE *pnm, LRESULT *pResult)
|
||||
{
|
||||
if (0 == ((HHT_ONDIVIDER | HHT_ONDIVOPEN)& pnm->dwHitInfo) && (SWS_USESKINCURSORS & style) && hcurNormal)
|
||||
{
|
||||
SetCursor(hcurNormal);
|
||||
*pResult = TRUE;
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BOOL SkinnedHeader::OnReflectedNotify(INT idCtrl, REFLECTPARAM *rParam)
|
||||
{
|
||||
if (rParam->hwndFrom != GetParent(hwnd)) return FALSE; // controls such as listview forward headers notifications to they parent.
|
||||
|
||||
switch(((NMHDR*)(rParam->lParam))->code)
|
||||
{
|
||||
case NM_CUSTOMDRAW: return OnCustomDraw(rParam->hwndFrom, (NMCUSTOMDRAW*)rParam->lParam, &rParam->result);
|
||||
case HDN_ITEMCHANGINGA:
|
||||
case HDN_ITEMCHANGINGW: return OnItemChanging(rParam->hwndFrom, (NMHEADERW*)rParam->lParam, &rParam->result);
|
||||
case HDN_ITEMCHANGEDA:
|
||||
case HDN_ITEMCHANGEDW: return OnItemChanged(rParam->hwndFrom, (NMHEADERW*)rParam->lParam);
|
||||
case HDN_BEGINTRACKA:
|
||||
case HDN_BEGINTRACKW: return OnBeginTrack(rParam->hwndFrom, (NMHEADERW*)rParam->lParam, &rParam->result);
|
||||
case HDN_ENDTRACKA:
|
||||
case HDN_ENDTRACKW: return OnEndTrack(rParam->hwndFrom, (NMHEADERW*)rParam->lParam);
|
||||
case NM_SETCURSOR: return OnCursorNotify(rParam->hwndFrom, (NMMOUSE*)rParam->lParam, &rParam->result);
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
void SkinnedHeader::OnPaint(void)
|
||||
{
|
||||
if (HIF_BLOCKREDRAW & hdrFlags)
|
||||
{
|
||||
ValidateRgn(hwnd, NULL);
|
||||
}
|
||||
else if (SWS_USESKINCOLORS & style)
|
||||
{
|
||||
//process the grey area with our color
|
||||
RECT rc, ri;
|
||||
int i;
|
||||
GetClientRect(hwnd, &rc);
|
||||
i = (INT)CallPrevWndProc(HDM_GETITEMCOUNT, 0, 0L);
|
||||
if(i > 0)
|
||||
{
|
||||
Header_GetItemRect(hwnd, (INT)CallPrevWndProc(HDM_ORDERTOINDEX, (i-1), 0L), &ri);
|
||||
rc.left = ri.right;
|
||||
}
|
||||
|
||||
if(rc.left < rc.right && GetUpdateRect(hwnd, &ri, FALSE) && IntersectRect(&rc, &rc, &ri))
|
||||
{
|
||||
UINT flags = DCX_PARENTCLIP | DCX_CACHE | DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN |
|
||||
DCX_INTERSECTUPDATE | DCX_VALIDATE;
|
||||
|
||||
HDC hdc = GetDCEx(hwnd, NULL, flags);
|
||||
if(hdc)
|
||||
{
|
||||
COLORREF rgbBkOld;
|
||||
rgbBkOld = SetBkColor(hdc, WADlg_getColor(WADLG_LISTHEADER_EMPTY_BGCOLOR));
|
||||
ExtTextOutW(hdc, 0, 0, ETO_OPAQUE, &rc, L"", 0, 0);
|
||||
SetBkColor(hdc, rgbBkOld);
|
||||
ReleaseDC(hwnd, hdc);
|
||||
ValidateRect(hwnd, &rc);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void SkinnedHeader::OnTimer(UINT_PTR nIDEvent, TIMERPROC lpTimerFunc)
|
||||
{
|
||||
switch (nIDEvent)
|
||||
{
|
||||
case TIMER_UNBLOCKREDRAW_ID:
|
||||
BlockRedraw(FALSE, 0);
|
||||
return;
|
||||
case TIMER_ENDTRACK_ID:
|
||||
KillTimer(hwnd, TIMER_ENDTRACK_ID);
|
||||
hdrSize.count = 0;
|
||||
hdrSize.headerCXY = 0;
|
||||
hdrSize.lastCXY = -1;
|
||||
return;
|
||||
}
|
||||
__super::WindowProc(WM_TIMER, (WPARAM)nIDEvent, (LPARAM)lpTimerFunc);
|
||||
}
|
||||
|
||||
void SkinnedHeader::SetHeight(INT nHeight)
|
||||
{
|
||||
RECT rw;
|
||||
GetWindowRect(hwnd, &rw);
|
||||
|
||||
if (nHeight < 0)
|
||||
{
|
||||
HDC hdc;
|
||||
hdc = GetWindowDC(hwnd);
|
||||
if (hdc)
|
||||
{
|
||||
HFONT hfnt;
|
||||
hfnt = (HFONT)CallPrevWndProc(WM_GETFONT, 0, 0L);
|
||||
if (!hfnt) hfnt = (HFONT)MlStockObjects_Get(DEFAULT_FONT);
|
||||
if (hfnt)
|
||||
{
|
||||
TEXTMETRICW tm = {0};
|
||||
HFONT hfntOld = (HFONT)SelectObject(hdc, hfnt);
|
||||
|
||||
if (GetTextMetricsW(hdc, &tm)) nHeight = tm.tmHeight + 6/*Borders*/;
|
||||
SelectObject(hdc, hfntOld);
|
||||
}
|
||||
ReleaseDC(hwnd, hdc);
|
||||
}
|
||||
}
|
||||
|
||||
if (nHeight != (rw.bottom - rw.top))
|
||||
{
|
||||
INT i;
|
||||
|
||||
SetWindowPos(hwnd, NULL, 0, 0, rw.right - rw.left, nHeight, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
|
||||
if (HDS_HIDDEN & GetWindowLongPtrW(hwnd, GWL_STYLE)) return;
|
||||
|
||||
i = (INT)CallPrevWndProc(HDM_GETITEMCOUNT, 0, 0L);
|
||||
if(i > 0)
|
||||
{
|
||||
HDITEMW item;
|
||||
i = (INT)CallPrevWndProc(HDM_ORDERTOINDEX, (i-1), 0L);
|
||||
item.mask = HDI_WIDTH;
|
||||
if (CallPrevWndProc(HDM_GETITEMW, i, (LPARAM)&item))
|
||||
{
|
||||
hdrFlags |= (HIF_BLOCKCHANGING | HIF_BLOCKCHANGED | HIF_REALCXY);
|
||||
item.cxy++; CallPrevWndProc(HDM_SETITEMW, i, (LPARAM)&item);
|
||||
hdrFlags &= ~(HIF_BLOCKCHANGING | HIF_BLOCKCHANGED);
|
||||
item.cxy--; CallPrevWndProc(HDM_SETITEMW, i, (LPARAM)&item);
|
||||
hdrFlags &= ~HIF_REALCXY;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOL SkinnedHeader::OnLayout(HDLAYOUT *pLayout)
|
||||
{
|
||||
BOOL result;
|
||||
|
||||
result = (BOOL)__super::WindowProc(HDM_LAYOUT, 0, (LPARAM)pLayout);
|
||||
|
||||
if (0 == (HDS_HIDDEN & GetWindowLongPtrW(hwnd, GWL_STYLE)))
|
||||
{
|
||||
RECT rw;
|
||||
|
||||
GetWindowRect(hwnd, &rw);
|
||||
OffsetRect(&rw, -rw.left, -rw.top);
|
||||
|
||||
pLayout->pwpos->cy= rw.bottom;
|
||||
pLayout->prc->top = rw.bottom;
|
||||
|
||||
if (GetClientRect(GetParent(hwnd), &rw))
|
||||
pLayout->pwpos->cx = (rw.right - rw.left) - pLayout->pwpos->x;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
BOOL SkinnedHeader::OnSetCursor(HWND hwdCursor, UINT hitTest, UINT message)
|
||||
{
|
||||
static HDCURSOR hdrCursor;
|
||||
|
||||
hdrCursor.hwndParent = GetParent(hwnd);
|
||||
if (hdrCursor.hwndParent)
|
||||
{
|
||||
hdrCursor.nm.hdr.code = NM_SETCURSOR;
|
||||
hdrCursor.nm.hdr.hwndFrom = hwnd;
|
||||
hdrCursor.nm.hdr.idFrom = GetDlgCtrlID(hwnd);
|
||||
|
||||
hdrCursor.pts = GetMessagePos();
|
||||
POINTSTOPOINT(hdrCursor.nm.pt, hdrCursor.pts);
|
||||
|
||||
hdrCursor.hitTest.pt = hdrCursor.nm.pt;
|
||||
MapWindowPoints(HWND_DESKTOP, hwnd, &hdrCursor.hitTest.pt, 1);
|
||||
CallPrevWndProc(HDM_HITTEST, 0, (LPARAM)&hdrCursor.hitTest);
|
||||
|
||||
hdrCursor.nm.dwItemSpec = hdrCursor.hitTest.iItem;
|
||||
hdrCursor.nm.dwHitInfo = hdrCursor.hitTest.flags;
|
||||
if (SendMessage(hdrCursor.hwndParent, WM_NOTIFY, (WPARAM)hdrCursor.nm.hdr.code, (LPARAM)&hdrCursor.nm))
|
||||
return TRUE;
|
||||
}
|
||||
return (BOOL)__super::WindowProc(WM_SETCURSOR, (WPARAM)hwdCursor, MAKELPARAM(hitTest, message));
|
||||
}
|
||||
|
||||
LRESULT SkinnedHeader::OnSetItem(INT iIndex, HDITEMW *phdItem, BOOL bUnicode)
|
||||
{
|
||||
if (NULL != phdItem &&
|
||||
0 != (HDI_FORMAT & phdItem->mask))
|
||||
{
|
||||
DWORD newFlags = 0x0000FFFF | (hdrFlags & (0xFFFF0000 & ~HIF_ASCENDING));
|
||||
if (0 != ((HDF_SORTDOWN | HDF_SORTUP) & phdItem->fmt) &&
|
||||
iIndex >= 0 && iIndex < 0xFFFF)
|
||||
{
|
||||
newFlags = (newFlags & 0xFFFF0000) | (0xFFFF & iIndex);
|
||||
if (0 != (HDF_SORTUP & phdItem->fmt))
|
||||
newFlags |= HIF_ASCENDING;
|
||||
}
|
||||
|
||||
if ((LOWORD(newFlags) != LOWORD(hdrFlags)) ||
|
||||
((HIF_ASCENDING & newFlags) != (HIF_ASCENDING & hdrFlags)))
|
||||
{
|
||||
hdrFlags = newFlags;
|
||||
RECT rcItem;
|
||||
if (NULL != CallPrevWndProc(HDM_GETITEMRECT, (WPARAM)iIndex, (LPARAM)&rcItem))
|
||||
{
|
||||
InvalidateRect(hwnd, &rcItem, FALSE);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return __super::WindowProc(((bUnicode) ? HDM_SETITEMW : HDM_SETITEMA), (WPARAM)iIndex, (LPARAM)phdItem);
|
||||
}
|
||||
|
||||
BOOL SkinnedHeader::OnMediaLibraryIPC(INT msg, INT_PTR param, LRESULT *pResult)
|
||||
{
|
||||
switch(msg)
|
||||
{
|
||||
case ML_IPC_SKINNEDHEADER_DISPLAYSORT:
|
||||
hdrFlags = (hdrFlags & 0xFFFF0000) | LOWORD(param);
|
||||
hdrFlags = (hdrFlags & ~HIF_ASCENDING) | ((HIWORD(param)) ? HIF_ASCENDING : 0);
|
||||
*pResult = 1;
|
||||
InvalidateRect(hwnd, NULL, FALSE);
|
||||
UpdateWindow(hwnd);
|
||||
return TRUE;
|
||||
case ML_IPC_SKINNEDHEADER_SETHEIGHT: SetHeight((INT)param); *pResult = TRUE; return TRUE;
|
||||
case ML_IPC_SKINNEDHEADER_GETSORT: *pResult = MAKELONG(LOWORD(hdrFlags), 0 != (HIF_ASCENDING & hdrFlags)); return TRUE;
|
||||
case ML_IPC_SKINNEDHEADER_SETCLOUDCOLUMN:
|
||||
cloudColumn = (INT)param;
|
||||
InvalidateRect(hwnd, NULL, FALSE);
|
||||
UpdateWindow(hwnd);
|
||||
return TRUE;
|
||||
}
|
||||
return __super::OnMediaLibraryIPC(msg, param, pResult);
|
||||
}
|
||||
|
||||
LRESULT SkinnedHeader::WindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
|
||||
{
|
||||
switch(uMsg)
|
||||
{
|
||||
case WM_ERASEBKGND: return 1;
|
||||
case WM_PAINT: OnPaint(); break;
|
||||
case WM_TIMER: OnTimer((UINT_PTR)wParam, (TIMERPROC)lParam); return 0;
|
||||
case WM_SETCURSOR: return OnSetCursor((HWND)wParam, LOWORD(lParam), HIWORD(lParam));
|
||||
case WM_CAPTURECHANGED: InvalidateRect(hwnd, NULL, TRUE); break;
|
||||
case WM_WINDOWPOSCHANGING: if (HIF_BLOCKWNDPOS & hdrFlags) return TRUE;
|
||||
break;
|
||||
case REFLECTED_NOTIFY: return OnReflectedNotify((INT)wParam, (REFLECTPARAM*)lParam);
|
||||
case HDM_LAYOUT: return OnLayout((LPHDLAYOUT)lParam);
|
||||
case HDM_SETITEMA:
|
||||
case HDM_SETITEMW:
|
||||
return OnSetItem((INT)wParam, (HDITEMW*)lParam, (HDM_SETITEMW == uMsg));
|
||||
}
|
||||
return __super::WindowProc(uMsg, wParam, lParam);
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue