random-mirrors
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/Winamp/embwnd.cpp

937 lines
25 KiB
C++
Raw Blame History

/** (c) Nullsoft, Inc. C O N F I D E N T I A L
** Filename:
** Project:
** Description:
** Author:
** Created:
**/
#include <windowsx.h>
#include "main.h"
#include "api.h"
void draw_paint_emb( HWND, int, int, int );
void draw_embed_tbar( HWND, int, int );
void draw_embed_tbutton( HWND, int, int );
void draw_embed( HDC, int, int );
// all of this stuff is barely working. I will be fixing it soon soon.
/// embed ui shit
#define inreg(x,y,x2,y2) \
((mouse_x <= ( x2 ) && mouse_x >= ( x ) && \
mouse_y <= ( y2 ) && mouse_y >= ( y )))
enum
{
NO_CAP, TITLE_CAP, TB_CAP, SZ_CAP
};
static void do_titlebar( HWND hwnd, embedWindowState *state );
static void do_titlebuttons( HWND hwnd, embedWindowState *state );
static void do_size( HWND hwnd, embedWindowState *state );
static int mouse_x, mouse_y, mouse_type, mouse_stats;
static int which_cap = 0;
static HWND capwnd;
void embedui_handlemouseevent( HWND hwnd, int x, int y, int type, int stats, embedWindowState *state )
{
if ( which_cap != NO_CAP && hwnd != capwnd ) return;
mouse_x = x;
mouse_y = y;
mouse_type = type;
mouse_stats = stats;
switch ( which_cap )
{
case TITLE_CAP: do_titlebar( hwnd, state ); return;
case TB_CAP: do_titlebuttons( hwnd, state ); return;
case SZ_CAP: do_size( hwnd, state ); return;
default: break;
}
do_titlebuttons( hwnd, state );
do_size( hwnd, state );
do_titlebar( hwnd, state );
if ( which_cap != NO_CAP ) capwnd = hwnd; // not sure if this is gonna work
}
static void do_titlebar( HWND hwnd, embedWindowState *state )
{
if ( which_cap == TITLE_CAP || ( !which_cap && ( config_easymove || mouse_y < 14 ) ) )
{
static int clickx, clicky;
switch ( mouse_type )
{
case 1:
{
which_cap = TITLE_CAP;
clickx = mouse_x;
clicky = mouse_y;
}
break;
case -1:
which_cap = 0;
break;
case 0:
if ( which_cap == TITLE_CAP && mouse_stats & MK_LBUTTON )
{
// TODO need to convert this into an API method so
// we can call it externally e.g. enhancer...
// or something like it to allow state->r to
// be updated once the move has been finished
POINT p = { mouse_x, mouse_y };
ClientToScreen( hwnd, &p );
int w = state->r.right - state->r.left;
int h = state->r.bottom - state->r.top;
state->r.left = p.x - clickx;
state->r.top = p.y - clicky;
state->r.right = state->r.left + w;
state->r.bottom = state->r.top + h;
if ( !!config_snap + !!( mouse_stats & MK_SHIFT ) == 1 )
{
SnapWindowToAllWindows( &state->r, hwnd );
}
POINT pt = { state->r.left, state->r.top };
SendMessageW( hwnd, WM_USER + 0x100, 1, (LPARAM) &pt );
SetWindowPos( hwnd, 0, state->r.left, state->r.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
}
break;
}
}
}
static void do_titlebuttons( HWND hwnd, embedWindowState *state )
{
int w = 0;
w = inreg( state->r.right - state->r.left - 10, 3, state->r.right - state->r.left - 1, 3 + 9 ) ? 1 : 0;
if ( w ) // kill button
{
if ( mouse_type == -1 && which_cap == TB_CAP )
{
which_cap = 0;
draw_embed_tbutton( hwnd, 0, ( state->r.right - state->r.left ) );
SendMessageW( hwnd, WM_USER + 101, 0, 0 );
}
else if ( mouse_stats & MK_LBUTTON )
{
which_cap = TB_CAP;
draw_embed_tbutton( hwnd, w ? 1 : 0, ( state->r.right - state->r.left ) );
}
}
else if ( which_cap == TB_CAP )
{
which_cap = 0;
draw_embed_tbutton( hwnd, 0, ( state->r.right - state->r.left ) );
}
}
typedef struct _WNDREPAINT
{
HWND hwndSender;
RECT rwR;
RECT rwB;
} WNDREPAINT;
static BOOL CALLBACK EnumWndRepaintProc( HWND hwnd, LPARAM param )
{
WNDREPAINT *pwp = (WNDREPAINT *) param;
if ( hwnd != pwp->hwndSender && IsWindowVisible( hwnd ) )
{
RECT rw;
GetWindowRect( hwnd, &rw );
if ( ( rw.left < pwp->rwR.right && rw.right > pwp->rwR.left && rw.top < pwp->rwR.bottom && rw.bottom > pwp->rwR.top ) ||
( rw.top < pwp->rwB.bottom && rw.bottom > pwp->rwB.top && rw.left < pwp->rwB.right && rw.right > pwp->rwB.left ) )
{
UpdateWindow( hwnd );
}
}
return TRUE;
}
static void do_size( HWND hwnd, embedWindowState *state )
{
if ( state->flags & EMBED_FLAGS_NORESIZE )
{
if ( which_cap == SZ_CAP ) which_cap = 0;
return;
}
if ( which_cap == SZ_CAP || ( !which_cap &&
mouse_x > ( state->r.right - state->r.left ) - 20 && mouse_y > ( state->r.bottom - state->r.top ) - 20 &&
( ( ( state->r.right - state->r.left ) - mouse_x + ( state->r.bottom - state->r.top ) - mouse_y ) <= 30 ) ) )
{
static int dx, dy;
if ( !which_cap && mouse_type == 1 )
{
dx = ( state->r.right - state->r.left ) - mouse_x;
dy = ( state->r.bottom - state->r.top ) - mouse_y;
which_cap = SZ_CAP;
}
if ( which_cap == SZ_CAP )
{
if ( mouse_type == -1 ) which_cap = 0;
int x = mouse_x + dx;
int y = mouse_y + dy;
// if (x >= GetSystemMetrics(SM_CXSCREEN)) x = GetSystemMetrics(SM_CXSCREEN)-24;
// if (y >= GetSystemMetrics(SM_CYSCREEN)) y = GetSystemMetrics(SM_CYSCREEN)-28;
if ( !config_embedwnd_freesize )
{
x += 24;
x -= x % 25;
y += 28;
y -= y % 29;
}
if ( x < 275 ) x = 275;
if ( y < 20 + 38 + 29 + 29 ) y = 20 + 38 + 29 + 29;
if ( x != ( state->r.right - state->r.left ) || y != ( state->r.bottom - state->r.top ) )
{
// TODO need to ensure this isn't used when freesize is disabled
// isn't keeping track of the positions correctly on change
// as some windows only part snap e.g. ml won't dock to edges or to bottom of main window
RECT rw = { 0 }, r = { 0 };
POINT pt = { x, y };
SendMessageW( hwnd, WM_USER + 0x101, 1, (LPARAM) &pt );
GetWindowRect( hwnd, &rw );
// trying to get classic skins to dock to other windows on resizing
/*rw.left = state->r.left;
rw.top = state->r.top;
rw.right = state->r.left + x;
rw.bottom = state->r.top + y;
CopyRect(&r, &rw);
//if (!!config_snap + !!(mouse_stats & MK_SHIFT) == 1)
{
SnapWindowToAllWindows(&rw, hwnd);
}
x += (rw.right - r.right);
y += (rw.bottom - r.bottom);
SetWindowPos(hwnd, 0, 0, 0, x, y, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);*/
SetWindowPos( hwnd, 0, 0, 0, x, y, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE );
if ( x < ( rw.right - rw.left ) || y < ( rw.bottom - rw.top ) )
{
WNDREPAINT wrp;
wrp.hwndSender = hwnd;
SetRect( &wrp.rwR, min( rw.left + x, rw.right ), rw.top, rw.right, rw.bottom );
SetRect( &wrp.rwB, rw.left, min( rw.top + y, rw.bottom ), rw.right, rw.bottom );
EnumThreadWindows( GetCurrentThreadId(), EnumWndRepaintProc, (LPARAM) &wrp );
}
}
}
}
}
//// embed window shut
static int emb_OnLButtonUp( HWND hwnd, int x, int y, UINT flags );
static int emb_OnRButtonUp( HWND hwnd, int x, int y, UINT flags );
static int emb_OnLButtonDown( HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags );
static int emb_OnMouseMove( HWND hwnd, int x, int y, UINT keyFlags );
static int emb_OnLButtonDblClk( HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags );
static BOOL emb_OnNCActivate( HWND hwnd, BOOL fActive, HWND hwndActDeact, BOOL fMinimized );
static int emb_OnRButtonUp( HWND hwnd, int x, int y, UINT flags )
{
//display winamp's main popup menu
POINT p;
GetCursorPos( &p );
int ret = DoTrackPopup( main_menu, TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD, p.x, p.y, hwnd );
if ( ret ) SendMessageW( hMainWindow, WM_COMMAND, ret, 0 );
return 1;
}
static int emb_OnLButtonUp( HWND hwnd, int x, int y, UINT flags )
{
ReleaseCapture();
embedui_handlemouseevent( hwnd, x, y, -1, flags, (embedWindowState *) GetWindowLongPtrW( hwnd, GWLP_USERDATA ) );
return 1;
}
static int emb_OnLButtonDown( HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags )
{
SetCapture( hwnd );
embedui_handlemouseevent( hwnd, x, y, 1, keyFlags, (embedWindowState *) GetWindowLongPtrW( hwnd, GWLP_USERDATA ) );
return 1;
}
static int emb_OnMouseMove( HWND hwnd, int x, int y, UINT keyFlags )
{
embedui_handlemouseevent( hwnd, x, y, 0, keyFlags, (embedWindowState *) GetWindowLongPtrW( hwnd, GWLP_USERDATA ) );
return 1;
}
static BOOL emb_OnNCActivate( HWND hwnd, BOOL fActive, HWND hwndActDeact, BOOL fMinimized )
{
embedWindowState *state = (embedWindowState *) GetWindowLongPtrW( hwnd, GWLP_USERDATA );
if ( fActive == FALSE )
{
draw_embed_tbar( hwnd, config_hilite ? 0 : 1, ( state->r.right - state->r.left ) );
which_cap = NO_CAP;
capwnd = 0;
}
else
{
draw_embed_tbar( hwnd, 1, ( state->r.right - state->r.left ) );
}
return TRUE;
}
static int emb_OnLButtonDblClk( HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags )
{
return 1;
}
CRITICAL_SECTION embedcs;
embedWindowState *embedwndlist; // linked list
int embedwndlist_cnt;
static void EmbedWindow_OnShowWindow( HWND hwnd, BOOL fShow, UINT status )
{
if ( 0 != status )
{
SetPropW( hwnd, L"EmbedWnd_ShowStatus", (HANDLE) status );
DefWindowProcW( hwnd, WM_SHOWWINDOW, (WPARAM) fShow, (LPARAM) status );
RemovePropW( hwnd, L"EmbedWnd_ShowStatus" );
return;
}
embedWindowState *state = (embedWindowState *) GetWindowLongPtrW( hwnd, GWLP_USERDATA );
HWND hChild = FindWindowExW( hwnd, NULL, NULL, NULL );
INT toggleResult = 1;
if ( state && FALSE == state->reparenting )
{
INT result = Ipc_WindowToggle( (INT_PTR) hwnd, ( FALSE != fShow ) ? 1 : 0 );
if ( fShow ) toggleResult = result;
}
if ( NULL != hChild && 0 != toggleResult )
{
if ( FALSE != fShow && NULL != state )
{
SetWindowPos( hChild, NULL, 11, 20,
( state->r.right - state->r.left ) - 11 - 8,
( state->r.bottom - state->r.top ) - 20 - 14,
SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW | SWP_NOOWNERZORDER );
}
EMBEDSHOW embedShow;
embedShow.hdr.code = EWN_SHOWWINDOW;
embedShow.hdr.hwndFrom = hwnd;
embedShow.hdr.idFrom = GetDlgCtrlID( hwnd );
embedShow.fShow = fShow;
embedShow.nStatus = (UINT) (UINT_PTR) GetPropW( hwnd, L"EmbedWnd_ShowStatus" );
SendMessageW( hChild, WM_NOTIFY, (WPARAM) embedShow.hdr.idFrom, (LPARAM) &embedShow );
}
}
typedef struct __EMBEDWNDPART
{
INT id;
RECT rect;
}EMBEDWNDPART;
static INT EmbedWindow_HitTest( HWND hwnd, POINT pt )
{
DWORD windowStyle = GetWindowLongPtrW( hwnd, GWL_STYLE );
if ( 0 != ( WS_DISABLED & windowStyle ) )
return HTERROR;
MapWindowPoints( HWND_DESKTOP, hwnd, &pt, 1 );
RECT clientRect;
if ( !GetClientRect( hwnd, &clientRect ) )
return HTERROR;
if ( 0 != ( WS_CHILD & windowStyle ) )
{
return ( PtInRect( &clientRect, pt ) ) ? HTCLIENT : HTNOWHERE;
}
static EMBEDWNDPART embedWindowParts[] =
{
{ HTCLOSE, {-( 275 - 264 ), 3,-( 275 - 272 ), 12}},
{ HTCAPTION, {0, 0, -1, 13}},
{ HTBOTTOMRIGHT, {-20,-20,-1,-1}},
};
INT hitTest = HTCLIENT;
RECT part;
for ( INT i = 0; i < ARRAYSIZE( embedWindowParts ); i++ )
{
CopyRect( &part, &embedWindowParts[ i ].rect );
if ( part.left < 0 ) part.left += clientRect.right;
if ( part.right < 0 ) part.right += clientRect.right;
if ( part.top < 0 ) part.top += clientRect.bottom;
if ( part.bottom < 0 ) part.bottom += clientRect.bottom;
if ( PtInRect( &part, pt ) )
{
hitTest = embedWindowParts[ i ].id;
break;
}
}
if ( HTBOTTOMRIGHT == hitTest )
{
embedWindowState *state = (embedWindowState *) GetWindowLongPtrW( hwnd, GWLP_USERDATA );
if ( 0 != ( EMBED_FLAGS_NORESIZE & state->flags ) )
hitTest = HTBORDER;
}
return hitTest;
}
static LRESULT EmbedWindow_OnSetCursor( HWND hwnd, 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( hwnd );
break;
}
if ( config_usecursors && !disable_skin_cursors )
{
int index = 15 + 5; // PNormal.cur
POINT pt;
GetCursorPos( &pt );
hitTest = EmbedWindow_HitTest( hwnd, pt );
switch ( hitTest )
{
case HTCAPTION:
index = 15 + 2; // 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 DefWindowProcW( hwnd, WM_SETCURSOR, (WPARAM) hwndCursor, MAKELPARAM( hitTest, uMsg ) );
}
extern "C"
{
LRESULT CALLBACK emb_WndProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
switch ( uMsg )
{
case WM_INITMENUPOPUP:
return SendMessageW( hMainWindow, uMsg, wParam, lParam ); // for popup menus
HANDLE_MSG( hwnd, WM_QUERYNEWPALETTE, Main_OnQueryNewPalette );
HANDLE_MSG( hwnd, WM_PALETTECHANGED, Main_OnPaletteChanged );
HANDLE_MSG( hwnd, WM_LBUTTONUP, emb_OnLButtonUp );
HANDLE_MSG( hwnd, WM_RBUTTONUP, emb_OnRButtonUp );
HANDLE_MSG( hwnd, WM_LBUTTONDOWN, emb_OnLButtonDown );
HANDLE_MSG( hwnd, WM_MOUSEMOVE, emb_OnMouseMove );
HANDLE_MSG( hwnd, WM_NCACTIVATE, emb_OnNCActivate );
HANDLE_MSG( hwnd, WM_LBUTTONDBLCLK, emb_OnLButtonDblClk );
case WM_SYSCOMMAND:
if ( ( wParam & 0xfff0 ) == SC_SCREENSAVE || ( wParam & 0xfff0 ) == SC_MONITORPOWER )
return SendMessageW( hMainWindow, uMsg, wParam, lParam );
case WM_COMMAND:
case WM_KEYDOWN:
case WM_KEYUP:
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
{
if ( ( GetAsyncKeyState( VK_CONTROL ) & 0x8000 ) && wParam == VK_F4 )
{
if ( uMsg == WM_KEYDOWN || uMsg == WM_SYSKEYDOWN )
SendMessageW( hwnd, WM_USER + 101, 0, 0 );
}
else
{
// HWND hh=FindWindowExW(hwnd,NULL,NULL,NULL);
// if (hh) PostMessageW(hh,uMsg,wParam,lParam);
// else PostMessageW(hMainWindow,uMsg,wParam,lParam);
}
}
break;
case WM_USER + 101:
{
HWND hh = FindWindowExW( hwnd, NULL, NULL, NULL );
if ( hh ) PostMessageW( hh, WM_CLOSE, 0, 0 );
}
return 0;
case WM_USER + 102:
{
embedWindowState *state = (embedWindowState *) GetWindowLongPtrW( hwnd, GWLP_USERDATA );
if ( !state || !state->reparenting )
ShowWindow( hwnd, SW_SHOWNA );
}
break;
case WM_USER + 103:
SetFocus( hwnd );
break;
case WM_SHOWWINDOW:
EmbedWindow_OnShowWindow( hwnd, (BOOL) wParam, (UINT) lParam );
RefreshIconicThumbnail();
return 0;
case WM_DISPLAYCHANGE:
{
HWND hh = FindWindowExW( hwnd, NULL, NULL, NULL );
if ( hh )
SendMessageW( hh, uMsg, wParam, lParam );
}
InvalidateRect( hwnd, NULL, TRUE );
return 0;
case WM_CLOSE:
SendMessageW( GetParent( hwnd ), WM_CLOSE, 0, 0 );
return 0;
case WM_PAINT:
{
embedWindowState *state = (embedWindowState *) GetWindowLongPtrW( hwnd, GWLP_USERDATA );
if ( state ) draw_paint_emb( hwnd, ( state->r.right - state->r.left ), ( state->r.bottom - state->r.top ), state->flags );
}
return 0;
case WM_WINDOWPOSCHANGING:
{
/*
if extra_data[EMBED_STATE_EXTRA_REPARENTING] is set, we are being reparented by the freeform lib, so we should
just ignore this message because our visibility will not change once the freeform
takeover/restoration is complete
*/
WINDOWPOS *windowPos = (WINDOWPOS *) lParam;
embedWindowState *state = (embedWindowState *) GetWindowLongPtrW( hwnd, GWLP_USERDATA );
if ( state && state->reparenting )
{
if ( 0 != ( WS_CHILD & GetWindowLongPtrW( windowPos->hwnd, GWL_STYLE ) ) )
windowPos->flags |= ( SWP_NOREDRAW );
break;
}
}
break;
case WM_WINDOWPOSCHANGED:
{
embedWindowState *state = (embedWindowState *) GetWindowLongPtrW( hwnd, GWLP_USERDATA );
if ( state && 0 == ( SWP_NOSIZE & ( (WINDOWPOS *) lParam )->flags ) )
{
HWND hh;
HRGN rgnChild;
INT cx, cy, ox;//, oy;
RECT rv;
ox = state->r.right - state->r.left;
//oy = state->r.bottom - state->r.top;
cx = ( (WINDOWPOS *) lParam )->cx;
cy = ( (WINDOWPOS *) lParam )->cy;
state->r.right = state->r.left + cx;
state->r.bottom = state->r.top + cy;
hh = FindWindowExW( hwnd, NULL, NULL, NULL );
if ( 0 == ( SWP_NOREDRAW & ( (WINDOWPOS *) lParam )->flags ) )
InvalidateRect( hwnd, NULL, FALSE );
if ( hh )
{
INT cx, cy;
cx = ( state->r.right - state->r.left ) - 11 - 8;
cy = ( state->r.bottom - state->r.top ) - 20 - 14;
SetRect( &rv, 11, 20, 11 + cx, 20 + cy );
ValidateRect( hwnd, &rv );
rgnChild = CreateRectRgn( 0, 0, cx, cy );
if ( IsWindowVisible( hh ) )
SendMessageW( hh, WM_USER + 0x201, MAKEWPARAM( 0, 0 ), (LPARAM) rgnChild );
SetWindowPos( hh, NULL, 0, 0, cx, cy, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW | SWP_NOCOPYBITS );
if ( IsWindowVisible( hh ) )
SendMessageW( hh, WM_USER + 0x201, 0, (LPARAM) NULL );
}
else rgnChild = NULL;
if ( ox == cx )
{
SetRect( &rv, 0, 0, cx, 14 );
ValidateRect( hwnd, &rv );
}
if ( 0 == ( SWP_NOREDRAW & ( (WINDOWPOS *) lParam )->flags ) )
{
HRGN rgnWnd;
rgnWnd = CreateRectRgn( 0, 0, 0, 0 );
if ( GetUpdateRect( hwnd, NULL, FALSE ) )
GetUpdateRgn( hwnd, rgnWnd, FALSE );
if ( rgnChild )
{
OffsetRgn( rgnChild, 11, 20 );
CombineRgn( rgnWnd, rgnWnd, rgnChild, RGN_OR );
}
RedrawWindow( hwnd, NULL, rgnWnd, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASENOW | RDW_ALLCHILDREN );
if ( rgnWnd )
DeleteObject( rgnWnd );
}
if ( rgnChild )
DeleteObject( rgnChild );
}
}
return 0;
case WM_CREATE:
{
EMBEDWND *pew = (EMBEDWND *) calloc( 1, sizeof( EMBEDWND ) );
SetPropW( hwnd, EMBEDWND_PROPW, pew );
SetWindowLongPtrW( hwnd, GWLP_USERDATA, (LONG_PTR) ( (LPCREATESTRUCT) lParam )->lpCreateParams );
embedWindowState *state = (embedWindowState *) ( (LPCREATESTRUCT) lParam )->lpCreateParams;
state->me = hwnd;
int w = ( state->r.right - state->r.left );
int h = ( state->r.bottom - state->r.top );
if ( !config_embedwnd_freesize )
{
w -= w % 25;
h -= h % 29;
}
if ( w < 275 ) w = 275;
if ( h < 116 ) h = 116;
state->r.right = state->r.left + w;
state->r.bottom = state->r.top + h;
EnterCriticalSection( &embedcs );
GUID temp = GUID_NULL;
if ( state->flags & EMBED_FLAGS_GUID )
temp = state->guid;
memset( state->extra_data, 0, sizeof( state->extra_data ) );
if ( state->flags & EMBED_FLAGS_GUID )
state->guid = temp;
state->link = embedwndlist;
embedwndlist = state;
embedwndlist_cnt++;
LeaveCriticalSection( &embedcs );
SetWindowLong( hwnd, GWL_STYLE, GetWindowLongW( hwnd, GWL_STYLE ) & ~( WS_CAPTION ) );
SetWindowPos( hwnd, 0, state->r.left, state->r.top, state->r.right - state->r.left, state->r.bottom - state->r.top, SWP_NOACTIVATE | SWP_NOZORDER );
}
return 0;
case WM_DESTROY:
{
embedWindowState *state = (embedWindowState *) GetWindowLongPtrW( hwnd, GWLP_USERDATA );
if ( state )
{
EnterCriticalSection( &embedcs );
embedWindowState *p = embedwndlist;
if ( p == state )
{
embedwndlist = state->link;// remove ourselves
embedwndlist_cnt--;
}
else
{
while ( p )
{
if ( p->link == state )
{
p->link = state->link;
embedwndlist_cnt--;
break;
}
p = p->link;
}
}
LeaveCriticalSection( &embedcs );
}
HWND hh = FindWindowExW( hwnd, NULL, NULL, NULL );
if ( hh ) DestroyWindow( hh );
EMBEDWND *pew = GetEmbedWnd( hwnd );
if ( pew )
{
RemovePropW( hwnd, EMBEDWND_PROPW );
free( pew );
}
}
return 0;
case WM_SETCURSOR:
return EmbedWindow_OnSetCursor( hwnd, (HWND) wParam, LOWORD( lParam ), HIWORD( lParam ) );
case WM_GETMINMAXINFO:
{
MINMAXINFO *p = (MINMAXINFO *) lParam;
if ( NULL != p )
{
p->ptMaxTrackSize.x = 16384;
p->ptMaxTrackSize.y = 16384;
}
}
return 0;
case WM_MOUSEACTIVATE:
if ( NULL != WASABI_API_APP )
WASABI_API_APP->ActiveDialog_Register( hwnd );
break;
case WM_CHILDACTIVATE:
if ( NULL != WASABI_API_APP )
WASABI_API_APP->ActiveDialog_Register( hwnd );
break;
case WM_ACTIVATE:
if ( WA_INACTIVE == LOWORD( wParam ) )
{
EMBEDWND *pew = GetEmbedWnd( hwnd );
if ( pew )
{
pew->hLastFocus = GetFocus();
if ( !IsChild( hwnd, pew->hLastFocus ) )
pew->hLastFocus = NULL;
}
if ( NULL != WASABI_API_APP )
WASABI_API_APP->ActiveDialog_Unregister( hwnd );
}
else
{
if ( WA_CLICKACTIVE == LOWORD( wParam ) )
{
EMBEDWND *pew = GetEmbedWnd( hwnd );
if ( pew )
{
POINT pt;
DWORD pts = GetMessagePos();
POINTSTOPOINT( pt, pts );
MapWindowPoints( HWND_DESKTOP, hwnd, &pt, 1 );
HWND hTarget = ChildWindowFromPointEx( hwnd, pt, CWP_SKIPINVISIBLE | CWP_SKIPDISABLED | CWP_SKIPTRANSPARENT );
if ( hTarget && hTarget != hwnd )
pew->hLastFocus = hTarget;
}
}
if ( NULL != WASABI_API_APP )
WASABI_API_APP->ActiveDialog_Register( hwnd );
}
break;
case WM_SETFOCUS:
{
HWND hChild, hTab;
EMBEDWND *pew;
hChild = FindWindowExW( hwnd, NULL, NULL, NULL );
pew = GetEmbedWnd( hwnd );
hTab = NULL;
if ( pew )
{
while ( pew->hLastFocus && IsChild( hwnd, pew->hLastFocus ) )
{
if ( IsWindowEnabled( pew->hLastFocus ) && IsWindowVisible( pew->hLastFocus ) && 0 != ( WS_TABSTOP & GetWindowLongPtrW( pew->hLastFocus, GWL_STYLE ) ) )
{
hTab = pew->hLastFocus;
break;
}
pew->hLastFocus = GetParent( pew->hLastFocus );
}
}
if ( !hTab )
hTab = ( hChild ) ? GetNextDlgTabItem( hwnd, hChild, FALSE ) : hwnd;
if ( hTab && hTab != hwnd )
{
WCHAR szName[ 128 ] = { 0 };
DWORD lcid = MAKELCID( MAKELANGID( LANG_ENGLISH, SUBLANG_ENGLISH_US ), SORT_DEFAULT );
if ( GetClassNameW( hChild, szName, sizeof( szName ) / sizeof( WCHAR ) ) && CSTR_EQUAL == CompareStringW( lcid, NORM_IGNORECASE, szName, -1, L"#32770", -1 ) )
SendMessageW( hChild, WM_NEXTDLGCTL, (WPARAM) hTab, TRUE );
else
SetFocus( hTab );
//return 0;
}
}
break;
case WM_KILLFOCUS:
{
EMBEDWND *pew = GetEmbedWnd( hwnd );
if ( pew )
{
pew->hLastFocus = GetFocus();
if ( !IsChild( hwnd, pew->hLastFocus ) )
pew->hLastFocus = NULL;
}
}
break;
}
if ( FALSE != IsDirectMouseWheelMessage( uMsg ) )
{
if ( ( WS_CHILD & GetWindowStyle( hwnd ) ) == 0 )
return TRUE;
else
{
HWND hParent;
hParent = GetAncestor( hwnd, GA_PARENT );
if ( hParent != NULL )
return SendMessageW( hwnd, uMsg, wParam, lParam );
return FALSE;
}
}
return DefWindowProcW( hwnd, uMsg, wParam, lParam );
}
HWND embedWindow( embedWindowState *state )
{
HWND hwnd;
if ( !state ) return NULL;
hwnd = CreateWindowExW( WS_EX_NOPARENTNOTIFY /*| WS_EX_CONTROLPARENT | WS_EX_TOOLWINDOW*/,
L"Winamp Gen",
L"",
WS_OVERLAPPED | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
0, 0, 200, 200,
hMainWindow,
NULL,
hMainInstance,
state );
return hwnd;
}
BOOL SnapToScreen( RECT *outrc )
{
if ( config_keeponscreen & 1 )
{
RECT rc;
int w = outrc->right - outrc->left;
int h = outrc->bottom - outrc->top;
getViewport( &rc, NULL, 0, outrc );
if ( outrc->left < ( rc.left + config_snaplen ) && outrc->left >( rc.left - config_snaplen ) )
{
outrc->left = rc.left;
outrc->right = rc.left + w;
}
if ( outrc->top < ( rc.top + config_snaplen ) && outrc->top >( rc.top - config_snaplen ) )
{
outrc->top = rc.top;
outrc->bottom = rc.top + h;
}
if ( outrc->right > rc.right - config_snaplen && outrc->right < rc.right + config_snaplen )
{
outrc->left = rc.right - w;
outrc->right = rc.right;
}
if ( outrc->bottom > rc.bottom - config_snaplen && outrc->bottom < rc.bottom + config_snaplen )
{
outrc->top = rc.bottom - h;
outrc->bottom = rc.bottom;
return TRUE;
}
}
return FALSE;
}
void SnapWindowToAllWindows( RECT *outrc, HWND hwndNoSnap )
{
RECT rc;
SnapToScreen( outrc );
if ( config_pe_open && hwndNoSnap != hPLWindow )
{
GetWindowRect( hPLWindow, &rc );
SnapWindowToWindow( outrc, rc );
}
if ( config_eq_open && hwndNoSnap != hEQWindow )
{
GetWindowRect( hEQWindow, &rc );
SnapWindowToWindow( outrc, rc );
}
if ( config_mw_open && hwndNoSnap != hMainWindow )
{
GetWindowRect( hMainWindow, &rc );
FixMainWindowRect( &rc );
SnapWindowToWindow( outrc, rc );
}
if ( config_video_open && hwndNoSnap != hVideoWindow )
{
GetWindowRect( hVideoWindow, &rc );
SnapWindowToWindow( outrc, rc );
}
EnterCriticalSection( &embedcs );
embedWindowState *state = embedwndlist;
while ( state )
{
if ( state->me != hwndNoSnap && IsWindowVisible( state->me ) )
SnapWindowToWindow( outrc, state->r );
state = state->link;
}
LeaveCriticalSection( &embedcs );
}
};
Reference in New Issue View Git Blame Copy Permalink