1311 lines
35 KiB
C++
1311 lines
35 KiB
C++
#include <windowsx.h>
|
|
|
|
#include "main.h"
|
|
#include "./api.h"
|
|
#include "./wa_dlg.h"
|
|
#include "./skinWindow.h"
|
|
#include "./skinWindowIPC.h"
|
|
#include "./wintheme.h"
|
|
#include "./draw.h"
|
|
|
|
#ifndef ARRAYSIZE
|
|
#define ARRAYSIZE(blah) (sizeof(blah)/sizeof(*blah))
|
|
#endif
|
|
|
|
#ifndef OCR_NORMAL
|
|
#define OCR_NORMAL 32512
|
|
#endif
|
|
|
|
#ifndef LONGX86
|
|
#ifdef _WIN64
|
|
#define LONGX86 LONG_PTR
|
|
#else /*_WIN64*/
|
|
#define LONGX86 LONG
|
|
#endif /*_WIN64*/
|
|
#endif // LONGX86
|
|
|
|
#ifdef __cplusplus
|
|
#define SENDMSG(__hwnd, __msgId, __wParam, __lParam) ::SendMessageW((__hwnd), (__msgId), (__wParam), (__lParam))
|
|
#else
|
|
#define SENDMSG(__hwnd, __msgId, __wParam, __lParam) SendMessageW((__hwnd), (__msgId), (__wParam), (__lParam))
|
|
#endif // __cplusplus
|
|
|
|
#define SENDWAIPC(__ipcMsgId, __param) SENDMSG(hMainWindow, WM_WA_IPC, (WPARAM)(__param), (LPARAM)(__ipcMsgId))
|
|
|
|
#ifndef WM_NCUAHDRAWCAPTION
|
|
#define WM_NCUAHDRAWCAPTION 0x00AE
|
|
#define WM_NCUAHDRAWFRAME 0x00AF
|
|
#endif //WM_NCUAHDRAWCAPTION
|
|
|
|
// additional WM_SYSCOMMAND commands
|
|
#define SC_DRAGMOVE 0xF012
|
|
#define SC_DRAGSIZE_N 0xF003
|
|
#define SC_DRAGSIZE_S 0xF006
|
|
#define SC_DRAGSIZE_E 0xF002
|
|
#define SC_DRAGSIZE_W 0xF001
|
|
#define SC_DRAGSIZE_NW 0xF004
|
|
#define SC_DRAGSIZE_NE 0xF005
|
|
#define SC_DRAGSIZE_SW 0xF007
|
|
#define SC_DRAGSIZE_SE 0xF008
|
|
|
|
#define MSGRESULT(__hwnd, __result) { SetWindowLongPtrW((__hwnd), DWL_MSGRESULT, ((LONGX86)(LONG_PTR)(__result))); return TRUE; }
|
|
#define CSTR_INVARIANT MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT)
|
|
|
|
#define RESIZESTEP_CX 25
|
|
#define RESIZESTEP_CY 29
|
|
|
|
static ATOM SKINNEDWND_ATOM = 0;
|
|
|
|
// this flags for iternal use
|
|
#define SWS_EX_MASK 0xFFFF0000
|
|
#define SWS_EX_ATTACHED 0x00010000 // window attached
|
|
#define SWS_EX_UNICODE 0x00020000 // winodow is unicode
|
|
#define SWS_EX_THEMED 0x00040000 // was themed before
|
|
#define SWS_EX_DIALOG 0x00100000 // treat this as dialog
|
|
|
|
#define BORDERWIDTH_LEFT 11
|
|
#define BORDERWIDTH_TOP 20
|
|
#define BORDERWIDTH_RIGHT 8
|
|
#define BORDERWIDTH_BOTTOM 14
|
|
|
|
#define CHILDBORDER_LEFT 1
|
|
#define CHILDBORDER_TOP 1
|
|
#define CHILDBORDER_RIGHT 1
|
|
#define CHILDBORDER_BOTTOM 1
|
|
|
|
#define CLOSEBUTTON_HEIGHT 9
|
|
#define CLOSEBUTTON_WIDTH 9
|
|
#define CLOSEBUTTON_OFFSET_X -11
|
|
#define CLOSEBUTTON_OFFSET_Y 3
|
|
|
|
#define SIZERGRIP_WIDTH 20
|
|
#define SIZERGRIP_HEIGHT 20
|
|
|
|
#define MOVEABLEAREA_HEIGHT 13
|
|
|
|
#define BUTTON_NORMAL 0
|
|
#define BUTTON_PUSHED 1
|
|
#define BUTTON_DISABLED (-1)
|
|
|
|
#ifndef TME_NONCLIENT
|
|
#define TME_NONCLIENT 0x00000010
|
|
#define WM_NCMOUSELEAVE 0x02A2
|
|
#endif
|
|
|
|
#define WAMSG_CLOSE (WM_USER + 101)
|
|
|
|
typedef struct __SKINNEDWND
|
|
{
|
|
HWND hwnd;
|
|
WNDPROC fnWndProc;
|
|
DWORD flags;
|
|
POINT movingOffset;
|
|
INT buttonState;
|
|
embedWindowState embedData;
|
|
} SKINNEDWND;
|
|
|
|
#define GetSkinnedWnd(__hwnd) ((SKINNEDWND*)GetPropW((__hwnd), ((LPCWSTR)MAKEINTATOM(SKINNEDWND_ATOM))))
|
|
#define IsDialog(__skinnedWindow) (0 != (SWS_EX_DIALOG & (__skinnedWindow)->flags))
|
|
#define IsUnicode(__skinnedWindow) (0 != (SWS_EX_UNICODE & (__skinnedWindow)->flags))
|
|
|
|
#define SetWndLongPtr(__skinnedWnd, __index, __data)\
|
|
((LONG_PTR)(IsUnicode(__skinnedWnd) ? SetWindowLongPtrW((__skinnedWnd)->hwnd, (__index), ((LONGX86)(LONG_PTR)(__data))) :\
|
|
SetWindowLongPtrA((__skinnedWnd)->hwnd, (__index), ((LONGX86)(LONG_PTR)(__data)))))
|
|
|
|
#define CallWndProc(__skinnedWnd, __uMsg, __wParam, __lParam)\
|
|
(IsUnicode(__skinnedWnd) ?\
|
|
CallWindowProcW((__skinnedWnd)->fnWndProc, (__skinnedWnd)->hwnd, (__uMsg), (__wParam), (__lParam)) :\
|
|
CallWindowProcA((__skinnedWnd)->fnWndProc, (__skinnedWnd)->hwnd, (__uMsg), (__wParam), (__lParam)))
|
|
|
|
#define DefWndProc(__skinnedWnd, __uMsg, __wParam, __lParam)\
|
|
(IsUnicode(__skinnedWnd) ?\
|
|
DefWindowProcW((__skinnedWnd)->hwnd, (__uMsg), (__wParam), (__lParam)) :\
|
|
DefWindowProcA((__skinnedWnd)->hwnd, (__uMsg), (__wParam), (__lParam)))
|
|
|
|
void draw_embed_tbar(HWND hwnd, int state, int w);
|
|
void SnapWindowToAllWindows(RECT *outrc, HWND hwndNoSnap);
|
|
|
|
static LRESULT CALLBACK SkinnedWnd_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
static void SkinnedWindow_Delete(SKINNEDWND *pWnd)
|
|
{
|
|
HWND hDetached = NULL;
|
|
if (NULL == pWnd) return;
|
|
|
|
hDetached = pWnd->hwnd;
|
|
SetWndLongPtr(pWnd, GWLP_USERDATA, NULL);
|
|
RemovePropW(pWnd->hwnd, ((LPCWSTR)MAKEINTATOM(SKINNEDWND_ATOM)));
|
|
|
|
if (NULL != pWnd->embedData.me)
|
|
{
|
|
EnterCriticalSection(&embedcs);
|
|
embedWindowState *p = embedwndlist;
|
|
if (p == &pWnd->embedData)
|
|
{
|
|
embedwndlist=pWnd->embedData.link; // remove ourselves
|
|
embedwndlist_cnt--;
|
|
}
|
|
else
|
|
{
|
|
while (p)
|
|
{
|
|
if (p->link == &pWnd->embedData)
|
|
{
|
|
p->link=pWnd->embedData.link;
|
|
embedwndlist_cnt--;
|
|
break;
|
|
}
|
|
p=p->link;
|
|
}
|
|
}
|
|
LeaveCriticalSection(&embedcs);
|
|
}
|
|
|
|
if (NULL != pWnd->fnWndProc)
|
|
{
|
|
SetWndLongPtr(pWnd, GWLP_WNDPROC, pWnd->fnWndProc);
|
|
pWnd->fnWndProc = NULL;
|
|
}
|
|
free(pWnd);
|
|
|
|
if (NULL != hDetached)
|
|
{
|
|
SetWindowPos(hDetached, NULL, 0, 0, 0, 0,
|
|
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
|
|
}
|
|
}
|
|
|
|
static SKINNEDWND *SkinnedWindow_Cerate(HWND hwndToSkin)
|
|
{
|
|
if (NULL == hwndToSkin || !IsWindow(hwndToSkin))
|
|
return NULL;
|
|
|
|
if (NULL != GetSkinnedWnd(hwndToSkin))
|
|
return NULL;
|
|
|
|
if (0 == SKINNEDWND_ATOM)
|
|
{
|
|
SKINNEDWND_ATOM = GlobalAddAtomW(L"WASKINNEDWND");
|
|
if (0 == SKINNEDWND_ATOM)
|
|
return NULL;
|
|
}
|
|
|
|
SKINNEDWND *pWnd = (SKINNEDWND*)calloc(1, sizeof(SKINNEDWND));
|
|
if (NULL == pWnd)
|
|
return NULL;
|
|
|
|
pWnd->hwnd = hwndToSkin;
|
|
if (IsWindowUnicode(hwndToSkin)) pWnd->flags |= SWS_EX_UNICODE;
|
|
|
|
WCHAR szName[128] = {0};
|
|
if (GetClassNameW(hwndToSkin, szName, ARRAYSIZE(szName)))
|
|
{
|
|
if (CSTR_EQUAL == CompareStringW(CSTR_INVARIANT, NORM_IGNORECASE, szName, -1, L"#32770", -1))
|
|
pWnd->flags |= SWS_EX_DIALOG;
|
|
}
|
|
|
|
pWnd->fnWndProc = (WNDPROC)SetWndLongPtr(pWnd, GWLP_WNDPROC, SkinnedWnd_WindowProc);
|
|
if (NULL == pWnd->fnWndProc || !SetPropW(hwndToSkin, ((LPCWSTR)MAKEINTATOM(SKINNEDWND_ATOM)), pWnd))
|
|
{
|
|
SkinnedWindow_Delete(pWnd);
|
|
return NULL;
|
|
}
|
|
pWnd->flags |= SWS_EX_ATTACHED;
|
|
|
|
if (S_OK == Dwm_LoadLibrary())
|
|
{
|
|
DWMNCRENDERINGPOLICY ncrp = DWMNCRP_DISABLED;
|
|
DWORD allow = FALSE;
|
|
DwmSetWindowAttribute(pWnd->hwnd, DWMWA_NCRENDERING_POLICY, &ncrp, sizeof(ncrp));
|
|
DwmSetWindowAttribute(pWnd->hwnd, DWMWA_ALLOW_NCPAINT, &allow, sizeof(allow));
|
|
}
|
|
|
|
if (S_OK == UxTheme_LoadLibrary() && IsAppThemed())
|
|
{
|
|
SetWindowTheme(pWnd->hwnd, NULL, L"");
|
|
pWnd->flags |= SWS_EX_THEMED;
|
|
}
|
|
|
|
if (!config_embedwnd_freesize &&
|
|
0 == (WS_CHILD & GetWindowLongPtrW(pWnd->hwnd, GWL_STYLE)))
|
|
{
|
|
RECT rc;
|
|
if (GetWindowRect(hwndToSkin, &rc))
|
|
{
|
|
LONG w, h;
|
|
OffsetRect(&rc, -rc.left, -rc.top);
|
|
|
|
w = rc.right + (RESIZESTEP_CX - 1);
|
|
w -= w % RESIZESTEP_CX;
|
|
h = rc.bottom + (RESIZESTEP_CY - 1);
|
|
h -= h % RESIZESTEP_CY;
|
|
|
|
if (w != rc.right || h != rc.bottom)
|
|
SetWindowPos(hwndToSkin, NULL, 0, 0, w, h, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE);
|
|
}
|
|
}
|
|
|
|
return pWnd;
|
|
}
|
|
|
|
BOOL SkinWindow(HWND hwndToSkin, REFGUID windowGuid, UINT flagsEx, FFCALLBACK callbackFF)
|
|
{
|
|
SKINNEDWND *pWnd = SkinnedWindow_Cerate(hwndToSkin);
|
|
|
|
if (NULL == pWnd)
|
|
return FALSE;
|
|
|
|
pWnd->embedData.me = pWnd->hwnd;
|
|
pWnd->embedData.user_ptr = pWnd;
|
|
pWnd->embedData.flags |= (EMBED_FLAGS_GUID | flagsEx);
|
|
pWnd->embedData.guid = windowGuid;
|
|
|
|
pWnd->embedData.callback = callbackFF;
|
|
if (NULL != pWnd->embedData.callback)
|
|
pWnd->embedData.flags |= EMBED_FLAGS_FFCALLBACK;
|
|
|
|
GetWindowRect(pWnd->hwnd, &pWnd->embedData.r);
|
|
|
|
EnterCriticalSection(&embedcs);
|
|
|
|
pWnd->embedData.link = embedwndlist;
|
|
embedwndlist = &pWnd->embedData;
|
|
embedwndlist_cnt++;
|
|
|
|
LeaveCriticalSection(&embedcs);
|
|
|
|
SetWndLongPtr(pWnd, GWLP_USERDATA, &pWnd->embedData);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static int SkinnedWindow_GetTextWidth(LPCTSTR pszText, INT cchText)
|
|
{
|
|
int w = 0;
|
|
while (cchText--)
|
|
{
|
|
char c = *pszText++;
|
|
if (c >= 'a' && c <= 'z') c+='A'-'a';
|
|
|
|
if (c >= 'A' && c <= 'Z' && titlebar_font_widths[c-'A'])
|
|
w+=titlebar_font_widths[c-'A'];
|
|
else if (c >= '0' && c <= '9' && titlebar_font_widths[c-'0'] && Skin_UseGenNums)
|
|
w+=titlebar_font_num_widths[c-'0'];
|
|
else if (c == '-' && titlebar_font_widths[10] && Skin_UseGenNums)
|
|
w+=titlebar_font_num_widths[10];
|
|
else if (c == ':' && titlebar_font_widths[11] && Skin_UseGenNums)
|
|
w+=titlebar_font_num_widths[11];
|
|
else w+=titlebar_font_unknown_width;
|
|
|
|
}
|
|
return w;
|
|
}
|
|
|
|
static void SkinnedWindow_DrawText(HDC hdc, HDC hdcSrc, int xp, int yp, LPCTSTR pszText, INT cchText, RECT *prc, BOOL bActive)
|
|
{
|
|
int w;
|
|
int srcY = 88 + ((bActive) ? 8 : 0);
|
|
int srcYnum = 72 + ((bActive) ? 8 : 0);
|
|
int bgsrcY = ((bActive) ? 21 : 0);
|
|
int bgX = prc->left;
|
|
int maxw = prc->right;
|
|
while (cchText-- && maxw > 0)
|
|
{
|
|
char c = *pszText++;
|
|
|
|
if (bgX <= xp)
|
|
{
|
|
int bgW = 25;
|
|
if (bgW + bgX > prc->right) bgW = prc->right - bgX;
|
|
BitBlt(hdc, bgX, prc->top, bgW, (prc->bottom - prc->top), hdcSrc, 52, bgsrcY, SRCCOPY);
|
|
bgX += bgW;
|
|
}
|
|
|
|
if (c >= 'a' && c <= 'z') c+='A'-'a';
|
|
if (c >= 'A' && c <= 'Z' && titlebar_font_widths[c-'A'])
|
|
{
|
|
w = titlebar_font_widths[c - 'A'];
|
|
if (w > maxw) break;
|
|
|
|
if (bgX <= (xp + w))
|
|
{
|
|
int bgW = 25;
|
|
if (bgW + bgX > prc->right) bgW = prc->right - bgX;
|
|
BitBlt(hdc, bgX, prc->top, bgW, (prc->bottom - prc->top), hdcSrc, 52, bgsrcY, SRCCOPY);
|
|
bgX += bgW;
|
|
}
|
|
|
|
BitBlt(hdc, xp, yp, w, 7, hdcSrc, titlebar_font_offsets[c - 'A'], srcY, SRCCOPY);
|
|
}
|
|
else if (c >= '0' && c <= '9' && titlebar_font_num_widths[c - '0'] && Skin_UseGenNums)
|
|
{
|
|
w = titlebar_font_num_widths[c - '0'];
|
|
if (w > maxw) break;
|
|
|
|
if (bgX <= (xp + w))
|
|
{
|
|
int bgW = 25;
|
|
if (bgW + bgX > prc->right) bgW = prc->right - bgX;
|
|
BitBlt(hdc, bgX, prc->top, bgW, (prc->bottom - prc->top), hdcSrc, 52, bgsrcY, SRCCOPY);
|
|
bgX += bgW;
|
|
}
|
|
|
|
BitBlt(hdc, xp, yp, w, 7, hdcSrc, titlebar_font_num_offsets[c - '0'], srcYnum, SRCCOPY);
|
|
}
|
|
else if (c == '-' && titlebar_font_num_widths[10] && Skin_UseGenNums)
|
|
{
|
|
w = titlebar_font_num_widths[10];
|
|
if (w > maxw) break;
|
|
|
|
if (bgX <= (xp + w))
|
|
{
|
|
int bgW = 25;
|
|
if (bgW + bgX > prc->right) bgW = prc->right - bgX;
|
|
BitBlt(hdc, bgX, prc->top, bgW, (prc->bottom - prc->top), hdcSrc, 52, bgsrcY, SRCCOPY);
|
|
bgX += bgW;
|
|
}
|
|
|
|
BitBlt(hdc, xp, yp, w, 7, hdcSrc, titlebar_font_num_offsets[10], srcYnum, SRCCOPY);
|
|
}
|
|
else if (c == ':' && titlebar_font_num_widths[11] && Skin_UseGenNums)
|
|
{
|
|
w = titlebar_font_num_widths[11];
|
|
if (w > maxw) break;
|
|
|
|
if (bgX <= (xp + w))
|
|
{
|
|
int bgW = 25;
|
|
if (bgW + bgX > prc->right) bgW = prc->right - bgX;
|
|
BitBlt(hdc, bgX, prc->top, bgW, (prc->bottom - prc->top), hdcSrc, 52, bgsrcY, SRCCOPY);
|
|
bgX += bgW;
|
|
}
|
|
|
|
BitBlt(hdc, xp, yp, w, 7, hdcSrc, titlebar_font_num_offsets[11], srcYnum, SRCCOPY);
|
|
}
|
|
else
|
|
w = titlebar_font_unknown_width;
|
|
|
|
xp += w;
|
|
maxw -= w;
|
|
}
|
|
}
|
|
|
|
static void SkinnedWindow_DrawCloseButton(HDC hdc, HDC hdcSrc, RECT *prcWindow, BOOL bActive, INT buttonState)
|
|
{
|
|
INT srcX, srcY;
|
|
|
|
switch(buttonState)
|
|
{
|
|
case BUTTON_PUSHED:
|
|
srcX = 148; srcY = 42;
|
|
break;
|
|
case BUTTON_NORMAL:
|
|
srcX = 144; srcY = 3;
|
|
if (!bActive) srcY += 21;
|
|
break;
|
|
case BUTTON_DISABLED:
|
|
default:
|
|
srcX = 144; srcY = 3;
|
|
break;
|
|
}
|
|
BitBlt(hdc, prcWindow->right - 11,prcWindow->top + 3, 9, 9, hdcSrc,srcX, srcY, SRCCOPY);
|
|
}
|
|
|
|
static void SkinnedWindow_DrawCaptionEx(HDC hdc, HDC hdcSrc, LPCTSTR pszText, INT cchText, int state, int w, int h)
|
|
{
|
|
state = state ? 0 : 21;
|
|
int nt;
|
|
int xp=0;
|
|
int textw_exact = 0, textw = 0;
|
|
int cchTextOrig = cchText;
|
|
if (cchText > 0)
|
|
{
|
|
for(;cchText > 0; cchText--)
|
|
{
|
|
textw_exact = SkinnedWindow_GetTextWidth(pszText, cchText);
|
|
textw = textw_exact + 24;
|
|
textw -= textw % 25;
|
|
if ((w - textw) > 100) break;
|
|
textw = 0;
|
|
}
|
|
}
|
|
|
|
BitBlt(hdc,xp,0,25,20, hdcSrc, 0, state,SRCCOPY);
|
|
xp+=25;
|
|
nt = (w - 100 - textw)/25;
|
|
if (nt > 0)
|
|
{
|
|
if (nt&1)
|
|
{
|
|
BitBlt(hdc,xp,0,12,20,hdcSrc,104,state,SRCCOPY);
|
|
xp+=12;
|
|
}
|
|
nt/=2;
|
|
while (nt-->0)
|
|
{
|
|
BitBlt(hdc,xp,0,25,20,hdcSrc,104,state,SRCCOPY);
|
|
xp+=25;
|
|
}
|
|
}
|
|
|
|
if (cchText > 0)
|
|
{
|
|
BitBlt(hdc,xp,0,25,20,hdcSrc,26,state,SRCCOPY);
|
|
xp+=25;
|
|
nt = textw/25;
|
|
if (nt > 0)
|
|
{
|
|
|
|
RECT rt;
|
|
SetRect(&rt, xp, 0, xp + textw, 20);
|
|
|
|
SkinnedWindow_DrawText(hdc, hdcSrc,
|
|
rt.left + ((cchText == cchTextOrig) ? (textw - textw_exact)/2 : 0), 4,
|
|
pszText, cchText, &rt, state);
|
|
xp += nt*25;
|
|
}
|
|
|
|
BitBlt(hdc,xp,0,25,20,hdcSrc,78,state,SRCCOPY);
|
|
xp+=25;
|
|
}
|
|
else
|
|
{
|
|
nt = (w - 50)/2;
|
|
if (nt > 25) nt = 25;
|
|
if (nt > 0)
|
|
{
|
|
BitBlt(hdc,xp, 0, nt,20,hdcSrc,104,state,SRCCOPY);
|
|
xp+=nt;
|
|
if (nt < 25 && 0 != (w - 50)%2)nt++;
|
|
BitBlt(hdc,xp, 0, nt, 20, hdcSrc,104 + (25- nt),state,SRCCOPY);
|
|
xp+=nt;
|
|
}
|
|
}
|
|
|
|
nt = (w - 100 - textw)/25;
|
|
if (nt > 0)
|
|
{
|
|
if (nt&1)
|
|
{
|
|
BitBlt(hdc,xp,0,13,20,hdcSrc,104,state,SRCCOPY);
|
|
xp+=13;
|
|
}
|
|
nt/=2;
|
|
while (nt-->0)
|
|
{
|
|
BitBlt(hdc,xp,0,25,20,hdcSrc,104,state,SRCCOPY);
|
|
xp+=25;
|
|
}
|
|
}
|
|
nt = (w - 100 - textw) % 25;
|
|
if (nt > 0)
|
|
{
|
|
BitBlt(hdc,xp,0,nt,20,hdcSrc,104,state,SRCCOPY);
|
|
//StretchBlt(hdc,xp,0,nt,20,hdcSrc,104,state,25,20,SRCCOPY);
|
|
xp += nt;
|
|
}
|
|
BitBlt(hdc,xp,0,25,20,hdcSrc,130,state,SRCCOPY);
|
|
}
|
|
|
|
static void SkinnedWindow_DrawCaption(SKINNEDWND *pWnd, BOOL bActive, POINT *cursor)
|
|
{
|
|
RECT rc;
|
|
GetWindowRect(pWnd->hwnd, &rc);
|
|
OffsetRect(&rc, -rc.left, -rc.top);
|
|
|
|
|
|
UINT flags = DCX_PARENTCLIP | DCX_CACHE | DCX_WINDOW | DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN |
|
|
DCX_INTERSECTUPDATE | DCX_VALIDATE | DCX_NORESETATTRS;
|
|
HDC hdc = GetDCEx(pWnd->hwnd, NULL, flags);
|
|
if (NULL == hdc)
|
|
return;
|
|
|
|
do_palmode(hdc);
|
|
setSrcBM(embedBM);
|
|
|
|
char szTitle[128] = {0};
|
|
INT cchTitle = GetWindowTextA(pWnd->hwnd, szTitle, ARRAYSIZE(szTitle));
|
|
|
|
INT state = pWnd->buttonState;
|
|
if (BUTTON_PUSHED == state)
|
|
{
|
|
if (NULL == cursor || HTCLOSE != SendMessageW(pWnd->hwnd, WM_NCHITTEST, 0, MAKELPARAM(cursor->x, cursor->y)))
|
|
state = BUTTON_NORMAL;
|
|
}
|
|
|
|
SkinnedWindow_DrawCaptionEx(hdc, bmDC, (LPCTSTR)szTitle, cchTitle, bActive ? 1 : (config_hilite?0:1),
|
|
rc.right - rc.left, rc.bottom - rc.top);
|
|
SkinnedWindow_DrawCloseButton(hdc, bmDC, &rc, bActive, state);
|
|
|
|
unsetSrcBM();
|
|
ReleaseDC(pWnd->hwnd, hdc);
|
|
|
|
}
|
|
|
|
static void SkinnedWindow_DrawBorder(SKINNEDWND *pWnd, HDC hdc, HRGN rgnUpdate, POINT *cursor)
|
|
{
|
|
|
|
DWORD style = GetWindowLongPtrW(pWnd->hwnd, GWL_STYLE);
|
|
if (0 == (WS_BORDER & style))
|
|
return;
|
|
|
|
RECT rc;
|
|
GetWindowRect(pWnd->hwnd, &rc);
|
|
OffsetRect(&rc, -rc.left, -rc.top);
|
|
LONG w = rc.right, h = rc.bottom;
|
|
|
|
do_palmode(hdc);
|
|
setSrcBM(embedBM);
|
|
|
|
if (0 != (WS_CHILD & style))
|
|
{
|
|
if (!WADlg_initted())
|
|
WADlg_init(hMainWindow);
|
|
COLORREF rgbOld = SetBkColor(hdc, WADlg_getColor(WADLG_HILITE));
|
|
|
|
RECT part;
|
|
SetRect(&part, rc.left, rc.top, rc.right, rc.top + CHILDBORDER_TOP);
|
|
ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &part, NULL, 0, NULL);
|
|
SetRect(&part, rc.right - CHILDBORDER_RIGHT, rc.top + CHILDBORDER_TOP, rc.right, rc.bottom - CHILDBORDER_BOTTOM);
|
|
ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &part, NULL, 0, NULL);
|
|
SetRect(&part, rc.left, rc.bottom - CHILDBORDER_BOTTOM, rc.right, rc.bottom);
|
|
ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &part, NULL, 0, NULL);
|
|
SetRect(&part, rc.left, rc.top + CHILDBORDER_TOP, rc.left + CHILDBORDER_LEFT, rc.bottom - CHILDBORDER_BOTTOM);
|
|
ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &part, NULL, 0, NULL);
|
|
|
|
SetBkColor(hdc, rgbOld);
|
|
return;
|
|
}
|
|
|
|
if (0 != (WS_CAPTION & style))
|
|
{
|
|
char szTitle[128] = {0};
|
|
INT cchTitle = GetWindowTextA(pWnd->hwnd, szTitle, ARRAYSIZE(szTitle));
|
|
|
|
INT state = pWnd->buttonState;
|
|
if (BUTTON_PUSHED == state)
|
|
{
|
|
if (NULL == cursor || HTCLOSE != SendMessageW(pWnd->hwnd, WM_NCHITTEST, 0, MAKELPARAM(cursor->x, cursor->y)))
|
|
state = BUTTON_NORMAL;
|
|
}
|
|
|
|
BOOL bActive = (GetActiveWindow()==pWnd->hwnd) ? 1 : ((0 != config_hilite) ? 0 : 1);
|
|
SkinnedWindow_DrawCaptionEx(hdc, bmDC, (LPCTSTR)szTitle, cchTitle, bActive, w, h);
|
|
if (BUTTON_NORMAL != state)
|
|
SkinnedWindow_DrawCloseButton(hdc, bmDC, &rc, bActive, state);
|
|
}
|
|
|
|
int y=(h-20-38)/29;
|
|
int yp=20,x,xp;
|
|
while (y-->0)
|
|
{
|
|
BitBlt(hdc,0,yp,11,29,bmDC,127,42,SRCCOPY);
|
|
BitBlt(hdc,w-8,yp,8,29,bmDC,139,42,SRCCOPY);
|
|
yp += 29;
|
|
}
|
|
y=(h-20-38)%29;
|
|
if (y)
|
|
{
|
|
BitBlt(hdc,0,yp,11,y,bmDC,127,42,SRCCOPY);
|
|
//StretchBlt(hdc,0,yp,11,y,bmDC,127,42,11,29,SRCCOPY);
|
|
BitBlt(hdc,w-8,yp,8,y,bmDC,139,42,SRCCOPY);
|
|
//StretchBlt(hdc,w-8,yp,8,y,bmDC,139,42,8,29,SRCCOPY);
|
|
yp += y;
|
|
}
|
|
|
|
// 24 pixel lamity
|
|
BitBlt(hdc,0,yp,11,24,bmDC,158,42,SRCCOPY);
|
|
BitBlt(hdc,w-8,yp,8,24,bmDC,170,42,SRCCOPY);
|
|
yp += 24;
|
|
|
|
int realW = (w < 250) ? (w/2) : 125;
|
|
BitBlt(hdc,0,yp,realW,14,bmDC,0,42,SRCCOPY);
|
|
|
|
x=(w-125*2)/25;
|
|
xp=realW;
|
|
while (x-->0)
|
|
{
|
|
BitBlt(hdc,xp,yp,25,14,bmDC,127,72,SRCCOPY);
|
|
xp+=25;
|
|
}
|
|
x=(w-125*2)%25;
|
|
if (x > 0)
|
|
{
|
|
BitBlt(hdc,xp,yp,x,14,bmDC,127,72,SRCCOPY);
|
|
//StretchBlt(hdc,xp,yp,x,14,bmDC,127,72,25,14,SRCCOPY);
|
|
xp+=x;
|
|
}
|
|
|
|
if (realW < 125 && 0 != (w%2)) realW++;
|
|
BitBlt(hdc,xp,yp,realW,14,bmDC, (125 - realW),57,SRCCOPY);
|
|
|
|
if (0 != (EMBED_FLAGS_NORESIZE & pWnd->embedData.flags))
|
|
{
|
|
BitBlt(hdc,xp+112,yp+2,7,7,bmDC,118,72,SRCCOPY);
|
|
}
|
|
|
|
unsetSrcBM();
|
|
}
|
|
|
|
static BOOL SkinnedWindow_OnShowWindow(SKINNEDWND *pWnd, BOOL bShow, UINT flags)
|
|
{
|
|
if (pWnd->embedData.reparenting)
|
|
return TRUE;
|
|
|
|
SENDWAIPC(((bShow) ? IPC_CB_ONSHOWWND : IPC_CB_ONHIDEWND), pWnd->hwnd);
|
|
return FALSE;
|
|
}
|
|
|
|
static LRESULT SkinnedWindow_OnNcCalcSize(SKINNEDWND *pWnd, BOOL bCalcValidRects, NCCALCSIZE_PARAMS *pncsp)
|
|
{
|
|
|
|
DWORD style = (DWORD)GetWindowLongPtrW(pWnd->hwnd, GWL_STYLE);
|
|
|
|
RECT rc;
|
|
CopyRect(&rc, &pncsp->rgrc[0]);
|
|
CallWndProc(pWnd, WM_NCCALCSIZE, bCalcValidRects, (LPARAM)pncsp);
|
|
CopyRect(&pncsp->rgrc[0], &rc);
|
|
|
|
if (bCalcValidRects)
|
|
SetRect(&pncsp->rgrc[0], pncsp->lppos->x, pncsp->lppos->y,
|
|
pncsp->lppos->x + pncsp->lppos->cx, pncsp->lppos->y + pncsp->lppos->cy);
|
|
else
|
|
{
|
|
GetWindowRect(pWnd->hwnd, &pncsp->rgrc[0]);
|
|
if (0 != (WS_CHILD & style))
|
|
{
|
|
HWND hParent = GetParent(pWnd->hwnd);
|
|
if (NULL != hParent)
|
|
MapWindowPoints(HWND_DESKTOP, hParent, (POINT*)&pncsp->rgrc[0], 2);
|
|
}
|
|
}
|
|
|
|
if (0 != (WS_BORDER & style))
|
|
{
|
|
if (0 != (WS_CHILD & style))
|
|
{
|
|
pncsp->rgrc[0].top += CHILDBORDER_TOP;
|
|
pncsp->rgrc[0].left += CHILDBORDER_LEFT;
|
|
pncsp->rgrc[0].right -= CHILDBORDER_RIGHT;
|
|
pncsp->rgrc[0].bottom -= CHILDBORDER_BOTTOM;
|
|
}
|
|
else
|
|
{
|
|
pncsp->rgrc[0].top += BORDERWIDTH_TOP;
|
|
pncsp->rgrc[0].left += BORDERWIDTH_LEFT;
|
|
pncsp->rgrc[0].right -= BORDERWIDTH_RIGHT;
|
|
pncsp->rgrc[0].bottom -= BORDERWIDTH_BOTTOM;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void SkinnedWindow_OnNcPaint(SKINNEDWND *pWnd, HRGN rgnUpdate)
|
|
{
|
|
if (0 == (WS_BORDER & GetWindowLongPtrW(pWnd->hwnd, GWL_STYLE)))
|
|
return;
|
|
|
|
UINT flags = DCX_PARENTCLIP | DCX_CACHE | DCX_WINDOW | DCX_CLIPSIBLINGS |
|
|
DCX_INTERSECTUPDATE | DCX_VALIDATE | DCX_NORESETATTRS;
|
|
|
|
HDC hdc = GetDCEx(pWnd->hwnd, ((HRGN)NULLREGION != rgnUpdate) ? rgnUpdate : NULL, flags);
|
|
if (NULL == hdc)
|
|
return;
|
|
POINT pt;
|
|
GetCursorPos(&pt);
|
|
SkinnedWindow_DrawBorder(pWnd, hdc, rgnUpdate, &pt);
|
|
ReleaseDC(pWnd->hwnd, hdc);
|
|
}
|
|
|
|
static void SkinnedWindow_OnPrint(SKINNEDWND *pWnd, HDC hdc, UINT options)
|
|
{
|
|
if ((PRF_CHECKVISIBLE & options) && !IsWindowVisible(pWnd->hwnd)) return;
|
|
if (PRF_NONCLIENT & options)
|
|
{
|
|
POINT pt = {0, 0};
|
|
SkinnedWindow_DrawBorder(pWnd, hdc, (HRGN)NULLREGION, &pt);
|
|
}
|
|
if (PRF_CLIENT & options)
|
|
CallWndProc(pWnd, WM_PRINT, (WPARAM)hdc, (LPARAM)(~(PRF_NONCLIENT | PRF_CHECKVISIBLE) & options));
|
|
}
|
|
|
|
static LRESULT SkinnedWindow_OnNcHitTest(SKINNEDWND *pWnd, POINTS pts)
|
|
{
|
|
POINT pt;
|
|
RECT rw, rt;
|
|
POINTSTOPOINT(pt, pts);
|
|
|
|
DWORD style = (DWORD)GetWindowLongPtrW(pWnd->hwnd, GWL_STYLE);
|
|
|
|
if (0 != (WS_DISABLED & style))
|
|
return HTERROR;
|
|
|
|
if (0 != (WS_CHILD & style))
|
|
{
|
|
if (0 != (WS_BORDER & style))
|
|
{
|
|
GetWindowRect(pWnd->hwnd, &rw);
|
|
rw.left += CHILDBORDER_LEFT;
|
|
rw.top += CHILDBORDER_TOP;
|
|
rw.right -= CHILDBORDER_RIGHT;
|
|
rw.bottom -= CHILDBORDER_BOTTOM;
|
|
if (PtInRect(&rt, pt))
|
|
return HTBORDER;
|
|
}
|
|
return HTCLIENT;
|
|
}
|
|
|
|
GetWindowRect(pWnd->hwnd, &rw);
|
|
|
|
if (0 != (WS_CAPTION & style))
|
|
{
|
|
SetRect(&rt, rw.left, rw.top, rw.right, rw.top + BORDERWIDTH_TOP);
|
|
if (PtInRect(&rt, pt)) // caption
|
|
{
|
|
SetRect(&rt, rw.right + CLOSEBUTTON_OFFSET_X, rw.top + CLOSEBUTTON_OFFSET_Y,
|
|
rw.right + CLOSEBUTTON_OFFSET_X + CLOSEBUTTON_WIDTH, rw.top + CLOSEBUTTON_OFFSET_Y + CLOSEBUTTON_HEIGHT);
|
|
if (PtInRect(&rt, pt)) // close button
|
|
return HTCLOSE;
|
|
return HTCAPTION;
|
|
}
|
|
}
|
|
|
|
if (0 != (WS_BORDER & style))
|
|
{
|
|
SetRect(&rt, rw.left, rw.top + BORDERWIDTH_TOP, rw.left + BORDERWIDTH_LEFT, rw.bottom - BORDERWIDTH_BOTTOM);
|
|
if (PtInRect(&rt, pt))
|
|
return HTBORDER; // left side (non resizable)
|
|
|
|
SetRect(&rt, rw.right - BORDERWIDTH_RIGHT, rw.top + BORDERWIDTH_TOP, rw.right, rw.bottom - SIZERGRIP_HEIGHT);
|
|
if (PtInRect(&rt, pt))
|
|
return HTBORDER; // right side (non resizable)
|
|
|
|
SetRect(&rt, rw.right - BORDERWIDTH_RIGHT, rw.bottom - SIZERGRIP_HEIGHT, rw.right, rw.bottom);
|
|
if (PtInRect(&rt, pt))
|
|
return (0 == (EMBED_FLAGS_NORESIZE & pWnd->embedData.flags)) ? HTBOTTOMRIGHT : HTBORDER; // sizer bottomright
|
|
|
|
SetRect(&rt, rw.left, rw.bottom - BORDERWIDTH_BOTTOM, rw.right -SIZERGRIP_WIDTH, rw.bottom);
|
|
if (PtInRect(&rt, pt))
|
|
return HTBORDER; // bottom_left + bottom (non resizable)
|
|
|
|
SetRect(&rt, rw.right - SIZERGRIP_WIDTH, rw.bottom - BORDERWIDTH_BOTTOM, rw.right, rw.bottom);
|
|
if (PtInRect(&rt, pt))
|
|
return (0 == (EMBED_FLAGS_NORESIZE & pWnd->embedData.flags)) ? HTBOTTOMRIGHT : HTBORDER; // sizer bottomright
|
|
}
|
|
|
|
SetRect(&rt, rw.left, rw.top, rw.right, rw.bottom);
|
|
if (PtInRect(&rt, pt))
|
|
return HTCLIENT; // client
|
|
|
|
return HTNOWHERE;
|
|
}
|
|
|
|
static LRESULT SkinnedWindow_OnSetCursor(SKINNEDWND *pWnd, HWND hwndCursor, INT hitTest, UINT uMsg)
|
|
{
|
|
HCURSOR hCursor = NULL;
|
|
|
|
switch(uMsg)
|
|
{
|
|
case WM_LBUTTONDOWN:
|
|
case WM_RBUTTONDOWN:
|
|
case WM_MBUTTONDOWN:
|
|
case WM_XBUTTONDOWN:
|
|
DisabledWindow_OnMouseClick(pWnd->hwnd);
|
|
break;
|
|
}
|
|
|
|
if (config_usecursors && !disable_skin_cursors)
|
|
{
|
|
int index = 15+5; // PNormal.cur
|
|
switch(hitTest)
|
|
{
|
|
case HTCAPTION:
|
|
{ // this is required to emulate old behavior
|
|
POINT pt;
|
|
RECT rw;
|
|
GetCursorPos(&pt);
|
|
GetWindowRect(pWnd->hwnd, &rw);
|
|
rw.bottom = rw.top + MOVEABLEAREA_HEIGHT;
|
|
index = 15 + ((PtInRect(&rw, pt)) ? 2 : 5); // PTBar.cur
|
|
}
|
|
break;
|
|
case HTCLOSE:
|
|
index = 15 + 1; // PClose.cur
|
|
break;
|
|
case HTLEFT:
|
|
case HTRIGHT:
|
|
case HTTOP:
|
|
case HTTOPLEFT:
|
|
case HTTOPRIGHT:
|
|
case HTBOTTOM:
|
|
case HTBOTTOMLEFT:
|
|
case HTBOTTOMRIGHT:
|
|
index = 15 + 4;// PSize.cur
|
|
break;
|
|
}
|
|
hCursor = Skin_Cursors[index];
|
|
}
|
|
|
|
if (NULL != hCursor)
|
|
{
|
|
SetCursor(hCursor);
|
|
return TRUE;
|
|
}
|
|
return CallWndProc(pWnd, WM_SETCURSOR, (WPARAM)hwndCursor, MAKELPARAM(hitTest, uMsg));
|
|
}
|
|
|
|
static LRESULT SkinnedWindow_OnNcActivate(SKINNEDWND *pWnd, BOOL bActivate)
|
|
{
|
|
if (0 == (WS_CAPTION & GetWindowLongPtrW(pWnd->hwnd, GWL_STYLE)))
|
|
return TRUE;
|
|
|
|
POINT pt;
|
|
GetCursorPos(&pt);
|
|
SkinnedWindow_DrawCaption(pWnd, bActivate, &pt);
|
|
return TRUE;
|
|
}
|
|
|
|
static void SkinnedWindow_OnActivate(SKINNEDWND *pWnd, unsigned int action, BOOL minimized, HWND otherWindow)
|
|
{
|
|
if (NULL == pWnd)
|
|
return;
|
|
|
|
if (NULL != WASABI_API_APP)
|
|
{
|
|
if (WA_INACTIVE == action)
|
|
WASABI_API_APP->ActiveDialog_Unregister(pWnd->hwnd);
|
|
else
|
|
WASABI_API_APP->ActiveDialog_Register(pWnd->hwnd);
|
|
}
|
|
}
|
|
|
|
static BOOL SkinnedWindow_OnNcLButtonDown(SKINNEDWND *pWnd, INT hitTest, POINTS pts)
|
|
{
|
|
switch(hitTest)
|
|
{
|
|
case HTCLOSE:
|
|
{
|
|
pWnd->buttonState = BUTTON_PUSHED;
|
|
|
|
TRACKMOUSEEVENT tm;
|
|
ZeroMemory(&tm, sizeof(TRACKMOUSEEVENT));
|
|
tm.cbSize = sizeof(TRACKMOUSEEVENT);
|
|
tm.dwFlags = TME_LEAVE | TME_NONCLIENT;
|
|
tm.hwndTrack = pWnd->hwnd;
|
|
TrackMouseEvent(&tm);
|
|
|
|
RedrawWindow(pWnd->hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_UPDATENOW);
|
|
}
|
|
return TRUE;
|
|
case HTCAPTION:
|
|
if (IsWindowEnabled(pWnd->hwnd) &&
|
|
GetActiveWindow() != pWnd->hwnd)
|
|
SetActiveWindow(pWnd->hwnd);
|
|
{
|
|
RECT rw;
|
|
if (GetWindowRect(pWnd->hwnd, &rw))
|
|
{
|
|
pWnd->movingOffset.x = pts.x - rw.left;
|
|
pWnd->movingOffset.y = pts.y - rw.top;
|
|
}
|
|
}
|
|
SendMessageW(pWnd->hwnd, WM_SYSCOMMAND, (SC_MOVE | 0x0002), (*(LPARAM*)&pts));
|
|
return TRUE;
|
|
case HTBOTTOM:
|
|
case HTBOTTOMLEFT:
|
|
case HTBOTTOMRIGHT:
|
|
if (IsWindowEnabled(pWnd->hwnd) &&
|
|
GetActiveWindow() != pWnd->hwnd)
|
|
SetActiveWindow(pWnd->hwnd);
|
|
SendMessageW(pWnd->hwnd, WM_SYSCOMMAND, SC_SIZE + hitTest - (HTLEFT - WMSZ_LEFT), (*(LPARAM*)&pts));
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static BOOL SkinnedWindow_OnNcLButtonUp(SKINNEDWND *pWnd, INT hitTest, POINTS pts)
|
|
{
|
|
BOOL bProcessed = FALSE;
|
|
if (HTCLOSE == hitTest && BUTTON_PUSHED == pWnd->buttonState)
|
|
{
|
|
SNDMSG(pWnd->hwnd, WM_SYSCOMMAND, SC_CLOSE, *(LPARAM*)&pts);
|
|
bProcessed = TRUE;
|
|
}
|
|
|
|
if (BUTTON_PUSHED == pWnd->buttonState)
|
|
{
|
|
pWnd->buttonState = BUTTON_NORMAL;
|
|
RedrawWindow(pWnd->hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME);
|
|
}
|
|
|
|
return bProcessed;
|
|
}
|
|
|
|
static BOOL SkinnedWindow_OnNcRButtonDown(SKINNEDWND *pWnd, INT hitTest, POINTS pts)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL SkinnedWindow_OnNcRButtonUp(SKINNEDWND *pWnd, INT hitTest, POINTS pts)
|
|
{
|
|
int ret = DoTrackPopup(main_menu, TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD, pts.x, pts.y, pWnd->hwnd);
|
|
if (ret)
|
|
SendMessageW(hMainWindow,WM_COMMAND,ret,0);
|
|
return TRUE;
|
|
}
|
|
|
|
static void SkinnedWindow_OnNcMouseMove(SKINNEDWND *pWnd, INT hitTest, POINTS pts)
|
|
{
|
|
if (BUTTON_PUSHED == pWnd->buttonState && HTCLOSE == hitTest)
|
|
{
|
|
RedrawWindow(pWnd->hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME);
|
|
}
|
|
}
|
|
|
|
static void SkinnedWindow_OnNcMouseLeave(SKINNEDWND *pWnd)
|
|
{
|
|
if (BUTTON_PUSHED == pWnd->buttonState)
|
|
{
|
|
if(0 != (0x8000 & GetAsyncKeyState(GetSystemMetrics(SM_SWAPBUTTON) ? VK_RBUTTON : VK_LBUTTON)))
|
|
{
|
|
TRACKMOUSEEVENT tm;
|
|
ZeroMemory(&tm, sizeof(TRACKMOUSEEVENT));
|
|
tm.cbSize = sizeof(TRACKMOUSEEVENT);
|
|
tm.dwFlags = TME_LEAVE | TME_NONCLIENT;
|
|
tm.hwndTrack = pWnd->hwnd;
|
|
TrackMouseEvent(&tm);
|
|
}
|
|
else
|
|
{
|
|
pWnd->buttonState = BUTTON_NORMAL;
|
|
RedrawWindow(pWnd->hwnd, NULL, NULL, RDW_INVALIDATE | RDW_FRAME);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void SkinnedWindow_OnWinampCustomClose(SKINNEDWND *pWnd, POINTS pts)
|
|
{
|
|
if (0 != pWnd->embedData.reparenting)
|
|
return;
|
|
|
|
SNDMSG(pWnd->hwnd, WM_SYSCOMMAND, SC_CLOSE, *(LPARAM*)&pts);
|
|
}
|
|
|
|
static void SkinnedWindow_OnWindowPosChanging(SKINNEDWND *pWnd, WINDOWPOS *pwp)
|
|
{
|
|
if (SWP_NOSIZE != ((SWP_NOSIZE | SWP_FRAMECHANGED) & pwp->flags))
|
|
{
|
|
if (!config_embedwnd_freesize &&
|
|
0 == (WS_CHILD & GetWindowLongPtrW(pWnd->hwnd, GWL_STYLE)))
|
|
{
|
|
pwp->cx += (RESIZESTEP_CX - 1);
|
|
pwp->cx -= pwp->cx % RESIZESTEP_CX;
|
|
pwp->cy += (RESIZESTEP_CY - 1);
|
|
pwp->cy -= pwp->cy % RESIZESTEP_CY;
|
|
}
|
|
if (pwp->cx < RESIZESTEP_CX*2) pwp->cx = RESIZESTEP_CX*2;
|
|
if (pwp->cy < RESIZESTEP_CY*2) pwp->cy = RESIZESTEP_CY*2;
|
|
}
|
|
CallWndProc(pWnd, WM_WINDOWPOSCHANGING, 0, (LPARAM)pwp);
|
|
}
|
|
|
|
static void SkinnedWindow_OnWindowPosChanged(SKINNEDWND *pWnd, WINDOWPOS *pwp)
|
|
{
|
|
if ((SWP_NOSIZE | SWP_NOMOVE) != ((SWP_NOSIZE | SWP_NOMOVE | SWP_FRAMECHANGED) & pwp->flags))
|
|
{
|
|
SetRect(&pWnd->embedData.r, pwp->x, pwp->y, pwp->x + pwp->cx, pwp->y + pwp->cy);
|
|
}
|
|
|
|
CallWndProc(pWnd, WM_WINDOWPOSCHANGED, 0, (LPARAM)pwp);
|
|
}
|
|
|
|
static void SkinnedWindow_OnMoving(SKINNEDWND *pWnd, RECT *prc)
|
|
{
|
|
if (0 == (SWS_EX_NOSNAP & pWnd->flags) &&
|
|
(0xFFFF != pWnd->movingOffset.x && 0xFFFF != pWnd->movingOffset.y) &&
|
|
(!!config_snap + (0 != (0x8000 & GetAsyncKeyState(VK_SHIFT))) == 1))
|
|
{
|
|
POINT pt;
|
|
GetCursorPos(&pt);
|
|
INT cx = prc->right - prc->left;
|
|
INT cy = prc->bottom - prc->top;
|
|
prc->left = pt.x - pWnd->movingOffset.x;
|
|
prc->top = pt.y - pWnd->movingOffset.y;
|
|
prc->right = prc->left + cx;
|
|
prc->bottom = prc->top + cy;
|
|
SnapWindowToAllWindows(prc, pWnd->hwnd);
|
|
}
|
|
}
|
|
|
|
static void SkinnedWindow_OnSizing(SKINNEDWND *pWnd, UINT edge, RECT *prc)
|
|
{
|
|
LONG cx, cy;
|
|
cx = prc->right - prc->left;
|
|
cy = prc->bottom - prc->top;
|
|
|
|
if (!config_embedwnd_freesize &&
|
|
0 == (0x8000 & GetAsyncKeyState(VK_SHIFT)))
|
|
{
|
|
cx += (RESIZESTEP_CX - 1);
|
|
cx -= cx % RESIZESTEP_CX;
|
|
cy += (RESIZESTEP_CY - 1);
|
|
cy -= cy % RESIZESTEP_CY;
|
|
}
|
|
|
|
if (cx < RESIZESTEP_CX*2) cx = RESIZESTEP_CX*2;
|
|
if (cy < RESIZESTEP_CY*2) cy = RESIZESTEP_CY*2;
|
|
prc->right = prc->left + cx;
|
|
prc->bottom = prc->top + cy;
|
|
}
|
|
|
|
static void SkinnedWindow_OnEnterSizeMove(SKINNEDWND *pWnd)
|
|
{
|
|
POINT pt;
|
|
RECT rw;
|
|
GetCursorPos(&pt);
|
|
GetWindowRect(pWnd->hwnd, &rw);
|
|
if (0xFFFF == pWnd->movingOffset.x)
|
|
pWnd->movingOffset.x = pt.x - rw.left;
|
|
if (0xFFFF == pWnd->movingOffset.y)
|
|
pWnd->movingOffset.y = pt.y - rw.top;
|
|
}
|
|
|
|
static void SkinnedWindow_OnExitSizeMove(SKINNEDWND *pWnd)
|
|
{
|
|
pWnd->movingOffset.x = 0xFFFF;
|
|
pWnd->movingOffset.y = 0xFFFF;
|
|
}
|
|
|
|
static void SkinnedWindow_PatchCursor(SKINNEDWND *pWnd)
|
|
{
|
|
RECT rc;
|
|
POINT ptOrig, pt;
|
|
|
|
if (!GetCursorPos(&ptOrig) ||
|
|
!GetWindowRect(pWnd->hwnd, &rc))
|
|
return;
|
|
|
|
pt.x = rc.right + 1;
|
|
pt.y = ptOrig.y;
|
|
|
|
ShowCursor(FALSE);
|
|
SetCursorPos(pt.x, pt.y);
|
|
ShowCursor(TRUE);
|
|
SetCursorPos(ptOrig.x, ptOrig.y);
|
|
}
|
|
|
|
static void SkinnedWindow_OnEnterMenuLoop(SKINNEDWND *pWnd, BOOL bTrackPopup)
|
|
{
|
|
PostMessageW(pWnd->hwnd, WM_SETCURSOR, (WPARAM)pWnd->hwnd, MAKELPARAM(HTCLIENT,WM_ENTERMENULOOP));
|
|
}
|
|
|
|
static void SkinnedWindow_OnExitMenuLoop(SKINNEDWND *pWnd, BOOL bShortcut)
|
|
{
|
|
}
|
|
|
|
static void SkinnedWindow_OnUnskin(SKINNEDWND *pWnd)
|
|
{
|
|
if (NULL == pWnd) return;
|
|
|
|
HWND hwnd = pWnd->hwnd;
|
|
|
|
BOOL restoreVisible = FALSE;
|
|
DWORD windowStyle = GetWindowLongPtrW(hwnd, GWL_STYLE);
|
|
if (0 != (WS_VISIBLE & windowStyle))
|
|
{
|
|
restoreVisible = TRUE;
|
|
SetWindowLongPtrW(hwnd, GWL_STYLE, windowStyle & ~WS_VISIBLE);
|
|
}
|
|
|
|
if (NULL != pWnd->embedData.wasabi_window)
|
|
{
|
|
SENDWAIPC(IPC_CB_ONHIDEWND, pWnd->hwnd);
|
|
// start looping till we get callback
|
|
|
|
MSG msg;
|
|
BOOL stopLoop = FALSE;
|
|
|
|
while(FALSE == stopLoop)
|
|
{
|
|
DWORD status = MsgWaitForMultipleObjectsEx(0, NULL, INFINITE, QS_ALLINPUT, MWMO_ALERTABLE | MWMO_INPUTAVAILABLE);
|
|
if (WAIT_OBJECT_0 == status)
|
|
{
|
|
while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
if (WAMSG_CLOSE == msg.message && msg.hwnd == pWnd->hwnd)
|
|
{
|
|
stopLoop = TRUE;
|
|
break;
|
|
}
|
|
else if (!CallMsgFilter(&msg, MSGF_DIALOGBOX))
|
|
{
|
|
if (msg.message == WM_QUIT)
|
|
{
|
|
PostQuitMessage((INT)msg.wParam);
|
|
stopLoop = TRUE;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessageW(&msg);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SkinnedWindow_Delete(pWnd);
|
|
|
|
if (FALSE != restoreVisible)
|
|
SetWindowLongPtrW(hwnd, GWL_STYLE, WS_VISIBLE | GetWindowLongPtrW(hwnd, GWL_STYLE));
|
|
}
|
|
|
|
static LRESULT SkinnedWindow_OnWinampIPC(SKINNEDWND *pWnd, UINT uCmd, WPARAM param)
|
|
{
|
|
switch(uCmd)
|
|
{
|
|
case IPC_SKINWINDOW_SETEXSTYLE:
|
|
pWnd->flags = (SWS_EX_MASK & pWnd->flags) | (~SWS_EX_MASK & param);
|
|
return 0;
|
|
|
|
case IPC_SKINWINDOW_GETEXSTYLE:
|
|
return (~SWS_EX_MASK & pWnd->flags);
|
|
|
|
case IPC_SKINWINDOW_SETEMBEDFLAGS:
|
|
pWnd->embedData.flags = (INT)param;
|
|
return 0;
|
|
|
|
case IPC_SKINWINDOW_GETEMBEDFLAGS:
|
|
return pWnd->embedData.flags;
|
|
|
|
case IPC_SKINWINDOW_GETWASABIWND:
|
|
return (LRESULT)pWnd->embedData.wasabi_window;
|
|
|
|
case IPC_SKINWINDOW_UNSKIN:
|
|
SkinnedWindow_OnUnskin(pWnd);
|
|
break;
|
|
|
|
case IPC_SKINWINDOW_GETGUID:
|
|
if (NULL != param)
|
|
{
|
|
CopyMemory((void*)param, &pWnd->embedData.guid, sizeof(GUID));
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
case IPC_SKINWINDOW_GETEMBEDNUMS:
|
|
return Skin_UseGenNums;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void SkinnedWindow_OnSysCommand(SKINNEDWND *pWnd, UINT uCmd, LPARAM param)
|
|
{
|
|
CallWndProc(pWnd, WM_SYSCOMMAND, (WPARAM)uCmd, param);
|
|
|
|
switch(uCmd)
|
|
{
|
|
case SC_MOVE:
|
|
case SC_SIZE:
|
|
case SC_DRAGMOVE:
|
|
case SC_DRAGSIZE_N:
|
|
case SC_DRAGSIZE_S:
|
|
case SC_DRAGSIZE_E:
|
|
case SC_DRAGSIZE_W:
|
|
case SC_DRAGSIZE_NW:
|
|
case SC_DRAGSIZE_NE:
|
|
case SC_DRAGSIZE_SW:
|
|
case SC_DRAGSIZE_SE:
|
|
SkinnedWindow_PatchCursor(pWnd);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static LRESULT SkinnedWindow_OnSetText(SKINNEDWND *pWnd, LPCWSTR pszText)
|
|
{
|
|
LRESULT result = CallWndProc(pWnd, WM_SETTEXT, 0, (LPARAM)pszText);
|
|
ifc_window *wnd = pWnd->embedData.wasabi_window;
|
|
if (NULL != wnd)
|
|
{
|
|
ifc_window *parent = wnd->getRootParent();
|
|
if (NULL == parent) parent = wnd;
|
|
parent->setWindowTitle(pszText);
|
|
}
|
|
else
|
|
{
|
|
SetWindowPos(pWnd->hwnd, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static LRESULT CALLBACK SkinnedWnd_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
SKINNEDWND *pWnd = GetSkinnedWnd(hwnd);
|
|
if (NULL == pWnd)
|
|
{
|
|
return ((IsWindowUnicode(hwnd)) ? DefWindowProcW(hwnd, uMsg, wParam, lParam) :
|
|
DefWindowProcA(hwnd, uMsg, wParam, lParam));
|
|
}
|
|
|
|
switch(uMsg)
|
|
{
|
|
case WM_DESTROY:
|
|
{
|
|
BOOL unicode = IsUnicode(pWnd);
|
|
WNDPROC wndProc = pWnd->fnWndProc;
|
|
SkinnedWindow_Delete(pWnd);
|
|
return ((unicode) ? CallWindowProcW(wndProc, hwnd, uMsg, wParam, lParam) :
|
|
CallWindowProcA(wndProc, hwnd, uMsg, wParam, lParam));
|
|
}
|
|
break;
|
|
|
|
case WAMSG_CLOSE: SkinnedWindow_OnWinampCustomClose(pWnd, MAKEPOINTS(lParam)); return 0;
|
|
case WM_NCHITTEST: return SkinnedWindow_OnNcHitTest(pWnd, MAKEPOINTS(lParam));
|
|
case WM_NCCALCSIZE: return SkinnedWindow_OnNcCalcSize(pWnd, (BOOL)wParam, (NCCALCSIZE_PARAMS*)lParam);
|
|
case WM_NCPAINT: SkinnedWindow_OnNcPaint(pWnd, (HRGN)wParam); return 0;
|
|
case WM_NCACTIVATE: return SkinnedWindow_OnNcActivate(pWnd, (BOOL)wParam);
|
|
case WM_ACTIVATE: SkinnedWindow_OnActivate(pWnd, LOWORD(wParam), HIWORD(wParam), (HWND)lParam); return 0;
|
|
case WM_PRINT: SkinnedWindow_OnPrint(pWnd, (HDC)wParam, (UINT)lParam); return 0;
|
|
case WM_SETCURSOR: return SkinnedWindow_OnSetCursor(pWnd, (HWND)wParam, LOWORD(lParam), HIWORD(lParam));
|
|
case WM_NCLBUTTONDOWN: if (SkinnedWindow_OnNcLButtonDown(pWnd, (INT)wParam, MAKEPOINTS(lParam))) return 0; break;
|
|
case WM_NCLBUTTONUP: if (SkinnedWindow_OnNcLButtonUp(pWnd, (INT)wParam, MAKEPOINTS(lParam))) return 0; break;
|
|
case WM_NCRBUTTONDOWN: if (SkinnedWindow_OnNcRButtonDown(pWnd, (INT)wParam, MAKEPOINTS(lParam))) return 0; break;
|
|
case WM_NCRBUTTONUP: if (SkinnedWindow_OnNcRButtonUp(pWnd, (INT)wParam, MAKEPOINTS(lParam))) return 0; break;
|
|
case WM_NCMOUSEMOVE: SkinnedWindow_OnNcMouseMove(pWnd, (INT)wParam, MAKEPOINTS(lParam)); break;
|
|
case WM_NCMOUSELEAVE: SkinnedWindow_OnNcMouseLeave(pWnd); break;
|
|
case WM_SHOWWINDOW: if (SkinnedWindow_OnShowWindow(pWnd, (BOOL)wParam, (UINT)lParam)) return 0; break;
|
|
case WM_WINDOWPOSCHANGING: SkinnedWindow_OnWindowPosChanging(pWnd, (WINDOWPOS*)lParam); return 0;
|
|
case WM_WINDOWPOSCHANGED: SkinnedWindow_OnWindowPosChanged(pWnd, (WINDOWPOS*)lParam); return 0;
|
|
case WM_ENTERSIZEMOVE: SkinnedWindow_OnEnterSizeMove(pWnd); break;
|
|
case WM_EXITSIZEMOVE: SkinnedWindow_OnExitSizeMove(pWnd); break;
|
|
case WM_MOVING: SkinnedWindow_OnMoving(pWnd, (RECT*)lParam); break;
|
|
case WM_SIZING: SkinnedWindow_OnSizing(pWnd, (UINT)wParam, (RECT*)lParam); break;
|
|
case WM_ENTERMENULOOP: SkinnedWindow_OnEnterMenuLoop(pWnd, (BOOL)wParam); break;
|
|
case WM_EXITMENULOOP: SkinnedWindow_OnExitMenuLoop(pWnd, (BOOL)wParam); break;
|
|
case WM_NCUAHDRAWCAPTION: return 0;
|
|
case WM_NCUAHDRAWFRAME: return 0;
|
|
case WM_WA_IPC: return SkinnedWindow_OnWinampIPC(pWnd, (UINT)lParam, wParam);
|
|
case WM_SYSCOMMAND: SkinnedWindow_OnSysCommand(pWnd, (UINT)wParam, lParam); return 0;
|
|
case WM_SETTEXT: return SkinnedWindow_OnSetText(pWnd, (LPCWSTR)lParam);
|
|
}
|
|
|
|
if (FALSE != IsDirectMouseWheelMessage(uMsg))
|
|
{
|
|
if (0 == (WS_CHILD & GetWindowStyle(hwnd)))
|
|
return TRUE;
|
|
else
|
|
{
|
|
HWND hParent;
|
|
hParent = GetAncestor(hwnd, GA_PARENT);
|
|
if (NULL != hParent)
|
|
return SendMessageW(hwnd, uMsg, wParam, lParam);
|
|
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return CallWndProc(pWnd, uMsg, wParam, lParam);
|
|
} |