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

569 lines
14 KiB
C++
Raw Blame History

#include "./skinnedwnd.h"
#include "../winamp/wa_dlg.h"
#include "../nu/trace.h"
#include "./mldwm.h"
#include "../nu/CGlobalAtom.h"
static CGlobalAtom WNDDATAPROPW(L"SWDATA");
static UINT WINAMP_WM_DIRECT_MOUSE_WHEEL = WM_NULL;
#ifndef LONGX86
#ifdef _WIN64
#define LONGX86 LONG_PTR
#else /*_WIN64*/
#define LONGX86 LONG
#endif /*_WIN64*/
#endif // LONGX86
#define SWS_ATTACHED 0x00010000 // window attached
#define SWS_UNICODE 0x00020000 // winodow is unicode
#define SWS_THEMED 0x00040000 // was themed before
#define SWS_REFLECT 0x00080000 // support message reflection
#define SWS_DIALOG 0x00100000 // treat this as dialog
#define BORDER_WIDTH 1
extern HRESULT(WINAPI *SetWindowTheme)(HWND hwnd, LPCWSTR pszSubAppName, LPCWSTR pszSubIdList); //xp theme shit
extern BOOL (__stdcall *IsAppThemed)(void);
#define DWM_COMPOSITION_CHECK ((UINT)-1)
#define DWM_COMPOSITION_DISABLED ((UINT)0)
#define DWM_COMPOSITION_ENABLED ((UINT)1)
static UINT dwmCompositionEnabled = DWM_COMPOSITION_CHECK;
static BOOL CALLBACK SkinChangedNotifyCB(HWND hwnd, LPARAM param)
{
SendMessageW(hwnd, (UINT)WM_ML_IPC, MAKEWPARAM(TRUE, param), (LPARAM)ML_IPC_SKINNEDWND_SKINCHANGED);
return TRUE;
}
SkinnedWnd *SkinnedWnd::GetFromHWND(HWND hwndSkinned)
{
return (hwndSkinned && IsWindow(hwndSkinned)) ? (SkinnedWnd*)GetPropW(hwndSkinned, WNDDATAPROPW) : NULL;
}
BOOL SkinnedWnd::IsDwmCompositionEnabled()
{
if (DWM_COMPOSITION_CHECK == dwmCompositionEnabled)
{
dwmCompositionEnabled = DWM_COMPOSITION_DISABLED;
BOOL bEnabled;
if (S_OK == MlDwm_LoadLibrary() && S_OK == MlDwm_IsCompositionEnabled(&bEnabled) && bEnabled)
dwmCompositionEnabled = DWM_COMPOSITION_ENABLED;
}
return (DWM_COMPOSITION_ENABLED == dwmCompositionEnabled);
}
SkinnedWnd::SkinnedWnd(BOOL bIsDialog)
: hwnd(NULL), style(SWS_NORMAL), uiState(NULL), redrawLock(0),
fnWndProc(NULL), wnddata(SKINNEDWND_TYPE_WINDOW | ((bIsDialog) ? SWS_DIALOG : 0))
{
minSize.cx = 0;
minSize.cy = 0;
maxSize.cx = 0;
maxSize.cy = 0;
if (WM_NULL == WINAMP_WM_DIRECT_MOUSE_WHEEL)
WINAMP_WM_DIRECT_MOUSE_WHEEL = RegisterWindowMessageW(L"WINAMP_WM_DIRECT_MOUSE_WHEEL");
}
SkinnedWnd::~SkinnedWnd(void)
{
if (!hwnd || !IsWindow(hwnd)) return;
RemovePropW(hwnd, WNDDATAPROPW);
if (fnWndProc)
{
INT index;
index = (SWS_DIALOG & wnddata) ? DWLP_DLGPROC : GWLP_WNDPROC;
(SWS_UNICODE & wnddata) ? SetWindowLongPtrW(hwnd, index, (LONGX86)(LONG_PTR)fnWndProc) : SetWindowLongPtrA(hwnd, index, (LONGX86)(LONG_PTR)fnWndProc);
}
if ((SWS_THEMED & wnddata) && IsAppThemed && IsAppThemed() && SetWindowTheme) SetWindowTheme(hwnd, NULL, NULL);
}
BOOL SkinnedWnd::IsUnicode(void)
{
return ( 0 != (SWS_UNICODE & wnddata));
}
BOOL SkinnedWnd::IsAttached(void)
{
return ( 0 != (SWS_ATTACHED & wnddata));
}
BOOL SkinnedWnd::Attach(HWND hwndToSkin)
{
INT index;
if (hwnd) return FALSE;
hwnd = hwndToSkin;
if(!hwnd || GetPropW(hwnd, WNDDATAPROPW)) return FALSE;
wnddata &= (SKINNEDWND_TYPE_WINDOW | SWS_DIALOG);
if(IsWindowUnicode(hwnd)) wnddata |= SWS_UNICODE;
index = (SWS_DIALOG & wnddata) ? DWLP_DLGPROC : GWLP_WNDPROC;
fnWndProc= (WNDPROC)(LONG_PTR)((SWS_UNICODE & wnddata) ? SetWindowLongPtrW(hwnd, index, (LONGX86)(LONG_PTR)WindowProcReal) : SetWindowLongPtrA(hwnd, index, (LONGX86)(LONG_PTR)WindowProcReal));
if (!fnWndProc || !SetPropW(hwnd, WNDDATAPROPW, this)) return FALSE;
RemoveReflector(hwnd); // we will use this refelector
wnddata |= (SWS_ATTACHED | SWS_REFLECT);
if (S_OK == MlDwm_LoadLibrary())
{
DWMNCRENDERINGPOLICY ncrp = DWMNCRP_DISABLED;
DWORD allow = FALSE;
MlDwm_SetWindowAttribute(hwnd, DWMWA_NCRENDERING_POLICY, &ncrp, sizeof(ncrp));
MlDwm_SetWindowAttribute(hwnd, DWMWA_ALLOW_NCPAINT, &allow, sizeof(allow));
}
if (IsAppThemed && IsAppThemed() && SetWindowTheme)
{
SetWindowTheme(hwnd, NULL, L"");
wnddata |= SWS_THEMED;
}
uiState =(WORD)SendMessageW(hwnd, WM_QUERYUISTATE, 0, 0L);
return TRUE;
}
LRESULT SkinnedWnd::CallPrevWndProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
return (SWS_UNICODE & wnddata) ? CallWindowProcW(fnWndProc, hwnd, uMsg, wParam, lParam) : CallWindowProcA(fnWndProc, hwnd, uMsg, wParam, lParam);
}
LRESULT SkinnedWnd::CallDefWndProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
return (SWS_UNICODE & wnddata) ? DefWindowProcW(hwnd, uMsg, wParam, lParam) : DefWindowProcA(hwnd, uMsg, wParam, lParam);
}
void SkinnedWnd::OnSkinChanged(BOOL bNotifyChildren, BOOL bRedraw)
{
if (SWS_USESKINFONT & style)
{
HFONT skinFont;
skinFont = (HFONT)MlStockObjects_Get(SKIN_FONT);
if (NULL == skinFont)
skinFont = (HFONT)MlStockObjects_Get(DEFAULT_FONT);
if (NULL != skinFont)
{
HFONT windowFont = (HFONT)CallPrevWndProc(WM_GETFONT, 0, 0L);
if (skinFont != windowFont)
{
DisableRedraw();
SendMessageW(hwnd, WM_SETFONT, (WPARAM)skinFont, MAKELPARAM(0, bRedraw));
if (FALSE != bRedraw)
{
SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE |
SWP_FRAMECHANGED | SWP_NOREDRAW);
}
EnableRedraw(SWR_NONE);
}
}
}
if (bNotifyChildren)
EnumChildWindows(hwnd, SkinChangedNotifyCB, bRedraw);
SendMessageW(hwnd, (UINT)WM_ML_IPC,
MAKEWPARAM(bNotifyChildren, bRedraw),
(LPARAM)ML_IPC_SKINNEDWND_SKINUPDATED);
if (bRedraw)
InvalidateRect(hwnd, NULL, TRUE);
}
void SkinnedWnd::OnSkinUpdated(BOOL bNotifyChildren, BOOL bRedraw)
{
}
void SkinnedWnd::SkinChanged(BOOL bNotifyChildren, BOOL bRedraw)
{
OnSkinChanged(bNotifyChildren, bRedraw);
}
void SkinnedWnd::EnableReflection(BOOL bEnable)
{
wnddata = (wnddata & ~SWS_REFLECT) | ((bEnable) ? SWS_REFLECT : 0);
}
BOOL SkinnedWnd::SetStyle(UINT newStyle, BOOL bRedraw)
{
style = newStyle;
if (NULL != hwnd)
SkinChanged(FALSE, bRedraw);
return TRUE;
}
void SkinnedWnd::SetMinMaxInfo(MLSKINNEDMINMAXINFO *minMax)
{
if (NULL != minMax)
{
minSize.cx = minMax->min.cx;
if (minSize.cx < 0)
minSize.cx = 0;
minSize.cy = minMax->min.cy;
if (minSize.cy < 0)
minSize.cy = 0;
maxSize.cx = minMax->max.cx;
if (maxSize.cx < 0)
maxSize.cx = 0;
maxSize.cy = minMax->max.cy;
if (maxSize.cy < 0)
maxSize.cy = 0;
}
else
{
memset(&minSize, 0, sizeof(minSize));
memset(&maxSize, 0, sizeof(maxSize));
}
}
BOOL SkinnedWnd::OnMediaLibraryIPC(INT msg, INT_PTR param, LRESULT *pResult)
{
switch(msg)
{
case ML_IPC_SKINNEDWND_ISSKINNED: *pResult = IsAttached(); return TRUE;
case ML_IPC_SKINNEDWND_SKINCHANGED: SkinChanged(LOWORD(param), HIWORD(param)); *pResult = 1; return TRUE;
case ML_IPC_SKINNEDWND_SKINUPDATED: OnSkinUpdated(LOWORD(param), HIWORD(param)); break;
case ML_IPC_SKINNEDWND_GETTYPE: *pResult = GetType(); return TRUE;
case ML_IPC_SKINNEDWND_ENABLEREFLECTION: EnableReflection((BOOL)param); *pResult = 1; return TRUE;
case ML_IPC_SKINNEDWND_GETPREVWNDPROC:
if (param) *((BOOL*)param) = (SWS_UNICODE & wnddata);
*pResult = (INT_PTR)fnWndProc;
return TRUE;
case ML_IPC_SKINNEDWND_SETSTYLE: *pResult = style; style = (UINT)param; return TRUE;
case ML_IPC_SKINNEDWND_GETSTYLE: *pResult = style; return TRUE;
case ML_IPC_SKINNEDWND_SETMINMAXINFO:
SetMinMaxInfo((MLSKINNEDMINMAXINFO*)param);
*pResult = TRUE;
return TRUE;
}
return FALSE;
}
INT SkinnedWnd::OnNcHitTest(POINTS pts)
{
return (INT)CallPrevWndProc(WM_NCHITTEST, 0, *(LPARAM*)&pts);
}
void SkinnedWnd::DrawBorder(HDC hdc, RECT *prc, UINT type, HPEN pen)
{
HPEN penOld;
INT o = (BORDER_WIDTH/2) + ((BORDER_WIDTH%2) ? 1 : 0);
switch(type)
{
case BORDER_SUNKEN:
case BORDER_FLAT:
penOld = (HPEN)SelectObject(hdc, pen);
MoveToEx(hdc, prc->right - o, prc->top, NULL);
LineTo(hdc, prc->right - o, prc->bottom);
MoveToEx(hdc, prc->right - BORDER_WIDTH, prc->bottom - o, NULL);
LineTo(hdc, prc->left - 1, prc->bottom - o);
if (BORDER_FLAT == type)
{
MoveToEx(hdc, prc->left + BORDER_WIDTH/2, prc->bottom - BORDER_WIDTH, NULL);
LineTo(hdc, prc->left + BORDER_WIDTH/2, prc->top);
MoveToEx(hdc, prc->left, prc->top + BORDER_WIDTH/2, NULL);
LineTo(hdc, prc->right - BORDER_WIDTH, prc->top + BORDER_WIDTH/2);
}
SelectObject(hdc, penOld);
break;
}
}
UINT SkinnedWnd::GetBorderType(void)
{
DWORD ws = (DWORD)GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
if (WS_EX_STATICEDGE & ws) return BORDER_FLAT;
else if (WS_EX_CLIENTEDGE & ws) return BORDER_SUNKEN;
ws = (DWORD)GetWindowLongPtrW(hwnd, GWL_STYLE);
return (WS_BORDER & ws) ? BORDER_FLAT : BORDER_NONE;
}
void SkinnedWnd::DrawBorder(HDC hdc)
{
UINT borderType = GetBorderType();
if (BORDER_NONE != borderType)
{
RECT rc;
GetWindowRect(hwnd, &rc);
OffsetRect(&rc, -rc.left, -rc.top);
DrawBorder(hdc, &rc, borderType, GetBorderPen());
}
}
void SkinnedWnd::OnNcPaint(HRGN rgnUpdate)
{
UINT borderType = GetBorderType();
if (BORDER_NONE == borderType) return;
UINT flags = DCX_PARENTCLIP | DCX_CACHE | DCX_WINDOW | DCX_CLIPSIBLINGS |
DCX_INTERSECTUPDATE | DCX_VALIDATE;
HDC hdc = GetDCEx(hwnd, ((HRGN)NULLREGION != rgnUpdate) ? rgnUpdate : NULL, flags);
if (NULL == hdc) return;
DrawBorder(hdc);
ReleaseDC(hwnd, hdc);
}
INT SkinnedWnd::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS *pncsp)
{
UINT borderType = GetBorderType();
switch(borderType)
{
case BORDER_SUNKEN:
case BORDER_FLAT:
if (bCalcValidRects)
{
SetRect(&pncsp->rgrc[0],
pncsp->lppos->x, pncsp->lppos->y,
pncsp->lppos->x + pncsp->lppos->cx - BORDER_WIDTH, pncsp->lppos->y + pncsp->lppos->cy - BORDER_WIDTH);
}
else
{
GetWindowRect(hwnd, &pncsp->rgrc[0]);
pncsp->rgrc[0].right -= BORDER_WIDTH;
pncsp->rgrc[0].bottom -= BORDER_WIDTH;
}
if (BORDER_FLAT == borderType)
{
pncsp->rgrc[0].left += BORDER_WIDTH;
pncsp->rgrc[0].top += BORDER_WIDTH;
}
break;
}
return 0;
}
void SkinnedWnd::OnPrint(HDC hdc, UINT options)
{
if ((PRF_CHECKVISIBLE & options) && !IsWindowVisible(hwnd)) return;
if (PRF_NONCLIENT & options) DrawBorder(hdc);
if (PRF_CLIENT & options)
{
CallPrevWndProc(WM_PRINT, (WPARAM)hdc, (LPARAM)(~(PRF_NONCLIENT | PRF_CHECKVISIBLE) & options));
}
}
HPEN SkinnedWnd::GetBorderPen(void)
{
return (HPEN)MlStockObjects_Get(HILITE_PEN);
}
void SkinnedWnd::OnUpdateUIState(UINT uAction, UINT uState)
{
CallPrevWndProc(WM_UPDATEUISTATE, MAKEWPARAM(uAction, uState), 0L);
uiState =(WORD)SendMessageW(hwnd, WM_QUERYUISTATE, 0, 0L);
}
void SkinnedWnd::OnStyleChanged(INT styleType, STYLESTRUCT *pss)
{
if (0 != redrawLock)
{
if (0 != (GWL_STYLE & styleType) &&
(WS_VISIBLE & pss->styleOld) != (WS_VISIBLE & pss->styleNew))
{
redrawLock = 0;
}
}
CallPrevWndProc(WM_STYLECHANGED, (WPARAM)styleType, (LPARAM)pss);
}
void SkinnedWnd::OnDwmCompositionChanged(void)
{
dwmCompositionEnabled = DWM_COMPOSITION_CHECK;
}
void SkinnedWnd::DisableRedraw()
{
if (0 == redrawLock)
{
UINT windowStyle = (UINT)GetWindowLongPtrW(hwnd, GWL_STYLE);
if (0 == (WS_VISIBLE & windowStyle))
return;
CallDefWndProc(WM_SETREDRAW, FALSE, 0L);
}
redrawLock++;
}
void SkinnedWnd::EnableRedraw(SkinnedWndRedraw redrawFlags)
{
UINT rdwFlags(0);
if (0 == redrawLock)
return;
redrawLock--;
if (0 != redrawLock)
return;
CallDefWndProc(WM_SETREDRAW, TRUE, 0L);
if (0 != (SWR_INVALIDATE & redrawFlags))
{
rdwFlags |= RDW_INVALIDATE;
if (0 != (SWR_UPDATE & redrawFlags))
rdwFlags |= RDW_UPDATENOW;
}
if (0 != (SWR_ERASE & redrawFlags))
{
rdwFlags |= RDW_ERASE;
if (0 != (SWR_UPDATE & redrawFlags))
rdwFlags |= RDW_ERASENOW;
}
if (0 != rdwFlags)
{
if (0 != (SWR_ALLCHILDREN & redrawFlags))
rdwFlags |= RDW_ALLCHILDREN;
RedrawWindow(hwnd, NULL, NULL, rdwFlags);
}
}
BOOL SkinnedWnd::OnDirectMouseWheel(INT delta, UINT vtKey, POINTS pts)
{
SendMessageW(hwnd, WM_MOUSEWHEEL, MAKEWPARAM(vtKey, delta), *((LPARAM*)&pts));
return TRUE;
}
void SkinnedWnd::OnGetMinMaxInfo(MINMAXINFO *minMax)
{
if (NULL == minMax)
return;
CallPrevWndProc(WM_GETMINMAXINFO, 0, (LPARAM)minMax);
if (0 != minSize.cx)
minMax->ptMinTrackSize.x = minSize.cx;
if (0 != minSize.cy)
minMax->ptMinTrackSize.y = minSize.cy;
if (0 != maxSize.cx)
minMax->ptMaxTrackSize.x = maxSize.cx;
if (0 != maxSize.cy)
minMax->ptMaxTrackSize.y = maxSize.cy;
}
LRESULT SkinnedWnd::WindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_NCHITTEST: return OnNcHitTest(MAKEPOINTS(lParam));
case WM_NCPAINT: OnNcPaint((HRGN)wParam); return 0;
case WM_NCCALCSIZE: return OnNcCalcSize((BOOL)wParam, (NCCALCSIZE_PARAMS*)lParam);
case WM_PRINT: OnPrint((HDC)wParam, (UINT)lParam); return 0;
case WM_UPDATEUISTATE: OnUpdateUIState(LOWORD(wParam), HIWORD(wParam)); return 0;
case WM_STYLECHANGED: OnStyleChanged((INT)wParam, (STYLESTRUCT*)lParam); return 0;
case WM_SUPPORTREFLECT:
{
BOOL reflectionSupported = (0 != (SWS_REFLECT & wnddata) && CanReflect((UINT)wParam));
if (0 != (SWS_DIALOG & wnddata))
{
SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, reflectionSupported);
return TRUE;
}
return reflectionSupported;
}
case WM_ML_IPC:
{
LRESULT result;
if (OnMediaLibraryIPC((INT)lParam, (INT_PTR)wParam, &result))
{
if (SWS_DIALOG & wnddata)
{
SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, (LONGX86)result);
return TRUE;
}
return result;
}
break;
}
case WM_DWMCOMPOSITIONCHANGED: OnDwmCompositionChanged(); return 0;
case WM_GETMINMAXINFO: OnGetMinMaxInfo((MINMAXINFO*)lParam); return 0;
}
// Reflection
if (0 != (SWS_REFLECT & wnddata))
{
LRESULT result;
if (ReflectMessage(hwnd, uMsg, wParam, lParam, (0 != (SWS_DIALOG & wnddata)), &result))
return result;
}
if ( 0 == (SWS_NO_DIRECT_MOUSE_WHEEL & style) &&
WINAMP_WM_DIRECT_MOUSE_WHEEL == uMsg &&
WM_NULL != WINAMP_WM_DIRECT_MOUSE_WHEEL &&
FALSE != OnDirectMouseWheel(GET_WHEEL_DELTA_WPARAM(wParam), GET_KEYSTATE_WPARAM(wParam), MAKEPOINTS(lParam)))
{
if (0 != (SWS_DIALOG & wnddata))
SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, TRUE);
return TRUE;
}
return CallPrevWndProc(uMsg, wParam, lParam);
}
LRESULT WINAPI SkinnedWnd::WindowProcReal(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
SkinnedWnd *pWnd = (SkinnedWnd*)GetPropW(hwnd, WNDDATAPROPW);
if (!pWnd)
return (IsWindowUnicode(hwnd)) ? DefWindowProcW(hwnd, uMsg, wParam, lParam) : DefWindowProcA(hwnd, uMsg, wParam, lParam);
switch(uMsg)
{
case WM_NCDESTROY:
{
WNDPROC fnWndProc = pWnd->fnWndProc;
delete(pWnd);
return IsWindowUnicode(hwnd) ? CallWindowProcW(fnWndProc, hwnd, uMsg, wParam, lParam) : CallWindowProcA(fnWndProc, hwnd, uMsg, wParam, lParam);
}
break;
}
return pWnd->WindowProc(uMsg, wParam, lParam);
}
Reference in New Issue View Git Blame Copy Permalink