mirror of
https://github.com/WinampDesktop/winamp.git
synced 2024-09-24 15:54:12 +00:00
946 lines
29 KiB
C++
946 lines
29 KiB
C++
#include <precomp.h>
|
|
#include "wa2wndembed.h"
|
|
#include "wa2frontend.h"
|
|
#include "wa2buckitems.h"
|
|
#include "embedwndguid.h"
|
|
#include "main.h"
|
|
#include <api/wnd/bucketitem.h>
|
|
#include "resource.h"
|
|
#include <api/wnd/wndclass/wndholder.h>
|
|
#include <api/wndmgr/layout.h>
|
|
#include "wa2cfgitems.h"
|
|
#include "gen.h"
|
|
#include "../Agave/Language/api_language.h"
|
|
|
|
extern TList<HWND> forcedoffwnds;
|
|
|
|
#define BUCKETITEM_WNDTYPE L"buck"
|
|
#define WINAMP_OPTIONS_WINDOWSHADE_PL 40266
|
|
ReentryFilterObject wndMsgFilter;
|
|
|
|
int embedTable[] = {
|
|
IPC_GETWND_PE,
|
|
#ifdef MINIBROWSER_SUPPORT
|
|
IPC_GETWND_MB,
|
|
#endif
|
|
|
|
IPC_GETWND_VIDEO};
|
|
|
|
extern int switching_skin;
|
|
extern int going_fixedform;
|
|
extern int going_freeform;
|
|
extern HINSTANCE hInstance;
|
|
//-----------------------------------------------------------------------------------------------
|
|
void WaOsWndHost::onBeforeReparent(int host)
|
|
{
|
|
#if defined(_WIN64)
|
|
embedWindowState *ws = (embedWindowState *)GetWindowLong(getHWND(), GWLP_USERDATA);
|
|
#else
|
|
embedWindowState* ws = (embedWindowState*)GetWindowLong(getHWND(), GWL_USERDATA);
|
|
#endif
|
|
// 0x49474541 is related to keeping windows shown on litestep desktops
|
|
if (ws == NULL || (int)ws == 0x49474541)
|
|
{
|
|
HWND w = getHWND();
|
|
if (w == wa2.getWnd(IPC_GETWND_VIDEO))
|
|
{
|
|
// this tells the video to not trigger its callback on windowposchanged, otherwise it will generate a new IPC_ONSHOW
|
|
SendMessageW(w, WM_USER + 0x2, 0, 1);
|
|
}
|
|
return ;
|
|
}
|
|
ws->extra_data[EMBED_STATE_EXTRA_REPARENTING] = 1; // tell winamp to ignore show/hide events
|
|
if (!host)
|
|
{
|
|
ShowWindow(getHWND(), SW_HIDE);
|
|
if (!transfer && ((switching_skin && !Wa2WndEmbed::hadRememberedWndVisible(getHWND())) || !switching_skin))
|
|
{
|
|
PostMessage(getHWND(), WM_USER + 101, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
void WaOsWndHost::onAfterReparent(int host)
|
|
{
|
|
#if defined(_WIN64)
|
|
embedWindowState *ws = (embedWindowState *)GetWindowLong(getHWND(), GWLP_USERDATA);
|
|
#else
|
|
embedWindowState* ws = (embedWindowState*)GetWindowLong(getHWND(), GWL_USERDATA);
|
|
#endif
|
|
// 0x49474541 is related to keeping windows shown on litestep desktops
|
|
if (ws == NULL || (int)ws == 0x49474541)
|
|
{
|
|
HWND w = getHWND();
|
|
if (w == wa2.getWnd(IPC_GETWND_VIDEO))
|
|
{
|
|
// stop preventing handling of video windowposchanged
|
|
SendMessageW(w, WM_USER + 0x2, 0, 0);
|
|
}
|
|
return ;
|
|
}
|
|
ws->extra_data[EMBED_STATE_EXTRA_REPARENTING] = 0; // tell winamp NOT to ignore show/hide events anymore
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
int WaOsWndHost::onGetFocus()
|
|
{
|
|
XuiOSWndHost::onGetFocus();
|
|
ifc_window *z = findWindowByInterface(windowHolderGuid);
|
|
if (z)
|
|
{
|
|
WindowHolder *wh = static_cast<WindowHolder*>(z->getInterface(windowHolderGuid));
|
|
if (wh && wh->wndholder_wantAutoFocus())
|
|
{
|
|
HWND w = getHWND();
|
|
if (IsWindow(w)) SetFocus(w);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
int WaOsWndHost::wantFocus()
|
|
{
|
|
ifc_window *w = findWindowByInterface(windowHolderGuid);
|
|
if (w)
|
|
{
|
|
WindowHolder *wh = static_cast<WindowHolder*>(w->getInterface(windowHolderGuid));
|
|
if (wh)
|
|
{
|
|
return wh->wndholder_wantAutoFocus();
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
int WaOsWndHost::onMouseWheelUp(int click, int lines)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
int WaOsWndHost::onMouseWheelDown(int click, int lines)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
void VideoLayoutMonitor::hook_onResize(int x, int y, int w, int h)
|
|
{
|
|
SendMessageW(wa2.getWnd(IPC_GETWND_VIDEO), WM_TIMER, 12345, 0);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
void VideoLayoutMonitor::hook_onMove()
|
|
{
|
|
SendMessageW(wa2.getWnd(IPC_GETWND_VIDEO), WM_TIMER, 12345, 0);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
Wa2WndEmbed::Wa2WndEmbed()
|
|
{
|
|
WASABI_API_SYSCB->syscb_registerCallback(static_cast<WndCallbackI*>(this));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
Wa2WndEmbed::~Wa2WndEmbed()
|
|
{
|
|
WASABI_API_SYSCB->syscb_deregisterCallback(static_cast<WndCallbackI*>(this));
|
|
wa2wndstatus.deleteAll();
|
|
}
|
|
|
|
extern int we_have_ml;
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
int Wa2WndEmbed::testGuid(GUID g)
|
|
{
|
|
if (embedWndGuidMgr.testGuid(g)) return 1;
|
|
|
|
/* if (embedWndGuids.Data2 == g.Data2 && // embed wnd check :)
|
|
embedWndGuids.Data3 == g.Data3 &&
|
|
!memcmp(embedWndGuids.Data4,g.Data4,8)) return 1;*/
|
|
|
|
return (g == pleditWndGuid || g == videoWndGuid
|
|
#ifdef MINIBROWSER_SUPPORT
|
|
|| g == minibrowserWndGuid
|
|
#endif
|
|
|| (we_have_ml && g == library_guid)
|
|
);
|
|
}
|
|
|
|
int make_sure_library_is_here_at_startup = 0;
|
|
extern int m_loading_at_startup;
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
ifc_window *Wa2WndEmbed::createWindowByGuid(GUID g, ifc_window *parent)
|
|
{
|
|
if (m_loading_at_startup)
|
|
if (g == library_guid)
|
|
make_sure_library_is_here_at_startup = 1;
|
|
WaOsWndHost *oldhost = NULL;
|
|
if (embedWndGuidMgr.testGuid(g) && !embedWndGuidMgr.getEmbedWindowState(g))
|
|
return NULL;
|
|
// first check if this window is already open in a host, and if so, remove it from the wndholder
|
|
foreach(wndhosts)
|
|
if (wndhosts.getfor()->g == g)
|
|
{
|
|
WaOsWndHost *host = wndhosts.getfor()->host;
|
|
oldhost = host;
|
|
host->setTransfering(1);
|
|
host->oswndhost_unhost();
|
|
Layout *l = static_cast<Layout *>(host->getDesktopParent());
|
|
if (l)
|
|
{
|
|
Container *c = l->getParentContainer();
|
|
if (c)
|
|
{
|
|
if (!WCSCASEEQLSAFE(c->getId(), L"main"))
|
|
{
|
|
c->close(); // deferred if needed
|
|
}
|
|
else
|
|
{
|
|
softclose:
|
|
ifc_window *wnd = host->findWindowByInterface(windowHolderGuid);
|
|
if (wnd != NULL)
|
|
{
|
|
WindowHolder *wh = static_cast<WindowHolder *>(wnd->getInterface(windowHolderGuid));
|
|
if (wh != NULL)
|
|
{
|
|
wh->onRemoveWindow(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else goto softclose;
|
|
}
|
|
}
|
|
endfor;
|
|
// now host the wnd in a new host
|
|
WaOsWndHost *host = new WaOsWndHost();
|
|
viewer_addViewItem(host);
|
|
EmbedEntry *ee = new EmbedEntry();
|
|
wndhosts.addItem(ee);
|
|
ee->g = g;
|
|
ee->host = host;
|
|
ee->monitor = NULL;
|
|
ee->dep = host->getDependencyPtr();
|
|
ee->cmds = NULL;
|
|
if (g == pleditWndGuid)
|
|
{
|
|
RECT r = {10, 20, 5, 38};
|
|
host->oswndhost_setRegionOffsets(&r);
|
|
host->oswndhost_host(wa2.getWnd(IPC_GETWND_PE));
|
|
ee->whichwnd = IPC_GETWND_PE;
|
|
host->setName((L"Playlist Editor")/*(WASABI_API_LNGSTRINGW(IDS_PLAYLIST_EDITOR)*/);
|
|
GuiObject *go = parent->getGuiObject();
|
|
PlaylistAppCmds *plEditAppCmds = new PlaylistAppCmds();
|
|
ee->cmds = plEditAppCmds;
|
|
go->guiobject_addAppCmds(plEditAppCmds);
|
|
plWnd = parent; //parent->getDesktopParent();
|
|
//ShowWindow(host->getHWND(), SW_NORMAL);
|
|
}
|
|
else if (g == videoWndGuid)
|
|
{
|
|
RECT r = {11, 20, 8, 38};
|
|
host->oswndhost_setRegionOffsets(&r);
|
|
#ifdef VIDDEBUG
|
|
DebugString("Video : Window service creates the host\n");
|
|
#endif
|
|
HWND vid = wa2.getWnd(IPC_GETWND_VIDEO);
|
|
host->oswndhost_host(vid);
|
|
((WaOsWndHost *)host)->setNoTransparency();
|
|
ee->whichwnd = IPC_GETWND_VIDEO;
|
|
host->setName(WASABI_API_LNGSTRINGW(IDS_VIDEO));
|
|
ifc_window *lw = parent->getDesktopParent();
|
|
if (lw)
|
|
{
|
|
GuiObject *o = lw->getGuiObject();
|
|
if (o)
|
|
{
|
|
ee->monitor = new VideoLayoutMonitor(o->guiobject_getScriptObject());
|
|
}
|
|
}
|
|
SetTimer(vid, 12345, 250, NULL);
|
|
GuiObject *go = parent->getGuiObject();
|
|
VideoAppCmds *videoAppCmds = new VideoAppCmds();
|
|
ee->cmds = videoAppCmds;
|
|
go->guiobject_addAppCmds(videoAppCmds);
|
|
vidWnd = parent; //parent->getDesktopParent();
|
|
//ShowWindow(host->getHWND(), SW_NORMAL);
|
|
#ifdef MINIBROWSER_SUPPORT
|
|
|
|
}
|
|
else if (g == minibrowserWndGuid)
|
|
{
|
|
RECT r = {10, 20, 5, 38};
|
|
host->oswndhost_setRegionOffsets(&r);
|
|
host->oswndhost_host(wa2.getWnd(IPC_GETWND_MB));
|
|
ee->whichwnd = IPC_GETWND_MB;
|
|
host->setName("Minibrowser");
|
|
GuiObject *go = parent->getGuiObject();
|
|
mbWnd = parent; //parent->getDesktopParent();
|
|
MinibrowserAppCmds *mbAppCmds = new MinibrowserAppCmds();
|
|
ee->cmds = mbAppCmds;
|
|
go->guiobject_addAppCmds(mbAppCmds);
|
|
//ShowWindow(host->getHWND(), SW_NORMAL);
|
|
#endif
|
|
|
|
}
|
|
else if (embedWndGuidMgr.testGuid(g)) /*(embedWndGuids.Data2 == g.Data2 &&
|
|
embedWndGuids.Data3 == g.Data3 &&
|
|
!memcmp(embedWndGuids.Data4,g.Data4,8))*/
|
|
{
|
|
embedWindowState *ws = embedWndGuidMgr.getEmbedWindowState(g);
|
|
ASSERT(ws != NULL);
|
|
|
|
if (0 == (WS_BORDER & GetWindowLongPtrW(ws->me, GWL_STYLE)))
|
|
{
|
|
RECT r = {11, 20, 8, 14};
|
|
host->oswndhost_setRegionOffsets(&r);
|
|
}
|
|
else
|
|
host->oswndhost_setRegionOffsets(NULL);
|
|
|
|
ws->extra_data[EMBED_STATE_EXTRA_HOSTCOUNT]++;
|
|
ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] = (intptr_t)parent; //parent->getDesktopParent();
|
|
ee->whichwnd = (intptr_t)ws;
|
|
if (ws->flags & EMBED_FLAGS_NOTRANSPARENCY) host->setNoTransparency();
|
|
host->oswndhost_host(ws->me);
|
|
wchar_t buf[512] = {0};
|
|
GetWindowTextW(ws->me, buf, 512);
|
|
host->setName(buf);
|
|
}
|
|
else
|
|
{
|
|
wndhosts.removeItem(ee);
|
|
delete host;
|
|
delete ee;
|
|
return NULL;
|
|
}
|
|
wa2.setOnTop(cfg_options_alwaysontop.getValueAsInt());
|
|
return host;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
int Wa2WndEmbed::testType(const wchar_t *windowtype)
|
|
{
|
|
return !_wcsicmp(windowtype, BUCKETITEM_WNDTYPE) || !_wcsicmp(windowtype, L"plsc");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
ifc_window *Wa2WndEmbed::createWindowOfType(const wchar_t *windowtype, ifc_window *parent, int n)
|
|
{
|
|
if (!_wcsicmp(windowtype, BUCKETITEM_WNDTYPE))
|
|
{
|
|
switch (n)
|
|
{
|
|
case 0:
|
|
{
|
|
PlBucketItem *bi = new PlBucketItem();
|
|
bi->setBitmaps(L"winamp.thinger.pledit", NULL, L"winamp.thinger.pledit.hilited", L"winamp.thinger.pledit.selected");
|
|
bucketitems.addItem(bi);
|
|
return bi;
|
|
}
|
|
case 1:
|
|
{
|
|
MlBucketItem *bi = new MlBucketItem();
|
|
bi->setBitmaps(L"winamp.thinger.library", NULL, L"winamp.thinger.library.hilited", L"winamp.thinger.library.selected");
|
|
bucketitems.addItem(bi);
|
|
return bi;
|
|
}
|
|
case 2:
|
|
{
|
|
VidBucketItem *bi = new VidBucketItem();
|
|
bi->setBitmaps(L"winamp.thinger.video", NULL, L"winamp.thinger.video.hilited", L"winamp.thinger.video.selected");
|
|
bucketitems.addItem(bi);
|
|
return bi;
|
|
}
|
|
case 3:
|
|
{
|
|
VisBucketItem *bi = new VisBucketItem();
|
|
bi->setBitmaps(L"winamp.thinger.vis", NULL, L"winamp.thinger.vis.hilited", L"winamp.thinger.vis.selected");
|
|
bucketitems.addItem(bi);
|
|
return bi;
|
|
}
|
|
// cases must be contiguous, enumerator stops at first NULL
|
|
#ifdef MINIBROWSER_SUPPORT
|
|
case 4:
|
|
{
|
|
MbBucketItem *bi = new MbBucketItem();
|
|
bi->setBitmaps(hInstance, IDB_MB_TAB_NORMAL, NULL, IDB_MB_TAB_HILITED, IDB_MB_TAB_SELECTED);
|
|
bucketitems.addItem(bi);
|
|
return bi;
|
|
}
|
|
#endif
|
|
// n is enumertor, not whichwnd
|
|
// we also need some way for the embeddedwnd to expose at least one bitmap (ideally 3) so we can make a nice bucketitem here (this code uses a pledit icon)
|
|
/* default:
|
|
if (n > 1024)
|
|
{
|
|
EmbedBucketItem *bi = new EmbedBucketItem();
|
|
bi->setBitmaps(hInstance, IDB_PLEDIT_TAB_NORMAL, NULL, IDB_PLEDIT_TAB_HILITED, IDB_PLEDIT_TAB_SELECTED);
|
|
bucketitems.addItem(bi);
|
|
return bi;
|
|
}
|
|
break;*/
|
|
}
|
|
}
|
|
else if (!_wcsicmp(windowtype, L"plsc"))
|
|
{
|
|
switch (n)
|
|
{
|
|
case 0:
|
|
pldirs.addItem(new PlDirObject);
|
|
return pldirs.getLast();
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
int Wa2WndEmbed::destroyWindow(ifc_window *w)
|
|
{
|
|
foreach(bucketitems)
|
|
Wa2BucketItem *i = bucketitems.getfor();
|
|
ifc_window *rw = i;
|
|
if (rw == w)
|
|
{
|
|
delete i;
|
|
return 1;
|
|
}
|
|
endfor;
|
|
foreach(wndhosts)
|
|
EmbedEntry *ee = wndhosts.getfor();
|
|
WaOsWndHost *x = ee->host;
|
|
if (WASABI_API_WND->rootwndIsValid(x))
|
|
{
|
|
ifc_window *rw = x;
|
|
if (rw == w)
|
|
{
|
|
ReentryFilter f(&wndMsgFilter, ee->whichwnd);
|
|
if (!f.mustLeave())
|
|
{
|
|
// this would hide the winamp window, which is probably not what we want to do (it should remain visible if it
|
|
// was visible, no?
|
|
|
|
// well, no, because we don't only run this in skin unloading, but also when a window gets destroyed (this is the wndcreation
|
|
// service being called to free what it created) -- this won't happen for mmd3/pledit because mmd3 has a static window for
|
|
// everything, which means that when you click close on it, it doesn't destroy it but hides it, so this code isn't called. but
|
|
// if you load another skin (ie: NonStep), and you close the pledit, it immediately reappears with the wa2 look since oswndhost_unhost
|
|
// reset the flags, region and parent to what they were before the window was embedded
|
|
|
|
// i think that what we need is to save which windows were visible (and their location) before switching to freeform
|
|
// and to restore them when we go back to wa2 mode. this will also be more consistant with the freeform behavior of
|
|
// remembering visible status and coordinates on a per skin basis (since otherwise freeform dockings get screwed)
|
|
// it also makes sense when we consider that we are going to need to remove all windowshade modes from the embedded
|
|
// windows when going freeform.
|
|
|
|
// see new functions: rememberVisibleWindows() and restoreVisibleWindows()
|
|
|
|
// in any case, we need to hide the window here, at least temporarily in the case of skin unloading
|
|
{
|
|
if (ee->whichwnd > 1024)
|
|
{
|
|
embedWindowState *ws = NULL;
|
|
//embedWindowState *ws = (embedWindowState *)ee->whichwnd;
|
|
HWND hHost, hContent;
|
|
hHost = (NULL != x) ? x->getHWND() : NULL;
|
|
hContent = (NULL != hHost) ? (HWND)SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)hHost, IPC_FF_GETCONTENTWND) : NULL;
|
|
|
|
if (NULL != hContent)
|
|
{
|
|
ws = (embedWindowState *)GetWindowLongPtrW(hContent, GWLP_USERDATA);
|
|
}
|
|
else
|
|
{
|
|
embedWndGuidMgr.retireEmbedWindowState((embedWindowState *)ee->whichwnd);
|
|
}
|
|
|
|
if (NULL != ws &&
|
|
!(wa2.isValidEmbedWndState(ws) && --ws->hostcount != 0))
|
|
{
|
|
if (0 != (EMBED_FLAGS_FFCALLBACK & ws->flags) &&
|
|
NULL != ws->callback)
|
|
{
|
|
ws->callback(ws, FFC_DESTROYEMBED, (LPARAM)w);
|
|
}
|
|
|
|
x->oswndhost_unhost();
|
|
if (wa2.isValidEmbedWndState(ws))
|
|
ws->wasabi_window = NULL;
|
|
|
|
if (!x->isTransfering() && wa2.isValidEmbedWndState(ws))
|
|
{
|
|
if (IsWindow(x->getHWND()))
|
|
{
|
|
SendMessageW(ws->me, WM_USER + 101, 0, 0);
|
|
}
|
|
embedWndGuidMgr.retireEmbedWindowState(ws);
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ee->whichwnd == IPC_GETWND_VIDEO) KillTimer(wa2.getWnd(ee->whichwnd), 12345);
|
|
x->oswndhost_unhost();
|
|
if (!x->isTransfering())
|
|
wa2.setWindowVisible(ee->whichwnd, 0);
|
|
#ifdef VIDDEBUG
|
|
if (ee->whichwnd == IPC_GETWND_VIDEO) DebugString("Video : Window service asks WA2 to close the window\n");
|
|
#endif
|
|
|
|
}
|
|
}
|
|
}
|
|
wndhosts.removeItem(ee);
|
|
|
|
embedWindowState *ws = NULL;
|
|
HWND thiswnd = NULL;
|
|
if (ee->whichwnd > 1024)
|
|
{
|
|
if (IsWindow(x->getHWND()))
|
|
thiswnd = x->getHWND();
|
|
//ws=(embedWindowState *)ee->whichwnd;
|
|
//thiswnd=ws->me;
|
|
}
|
|
else thiswnd = wa2.getWnd(ee->whichwnd);
|
|
//moved to xuioswndhost
|
|
//SetWindowLong(thiswnd,GWL_STYLE,GetWindowLong(thiswnd,GWL_STYLE)&~(WS_CHILDWINDOW));
|
|
switch (ee->whichwnd)
|
|
{
|
|
case IPC_GETWND_PE: plWnd = NULL; break;
|
|
#ifdef MINIBROWSER_SUPPORT
|
|
case IPC_GETWND_MB: mbWnd = NULL; break;
|
|
#endif
|
|
case IPC_GETWND_VIDEO:
|
|
#ifdef VIDDEBUG
|
|
DebugString("Video : Window service destroys host\n");
|
|
#endif
|
|
vidWnd = NULL;
|
|
break;
|
|
default:
|
|
if (ee->whichwnd > 1024 && ws && thiswnd != NULL)
|
|
{
|
|
ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] = 0;
|
|
}
|
|
break;
|
|
}
|
|
if (ee->cmds)
|
|
{
|
|
GuiObject *o = w->getParent()->getGuiObject();
|
|
o->guiobject_removeAppCmds(ee->cmds);
|
|
}
|
|
x->oswndhost_unhost(); // ignored if already done by reentryfiltered code
|
|
delete ee->monitor;
|
|
delete ee->cmds;
|
|
delete x;
|
|
|
|
|
|
if (ee->whichwnd > 1024 && ws)
|
|
{
|
|
if (forcedoffwnds.haveItem(ws->me))
|
|
{
|
|
RECT r;
|
|
GetWindowRect(ws->me, &r);
|
|
SetWindowPos(ws->me, NULL, r.left + 20000, r.top + 20000, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOREDRAW | SWP_NOSENDCHANGING | SWP_NOZORDER);
|
|
forcedoffwnds.delItem(ws->me);
|
|
}
|
|
}
|
|
delete ee;
|
|
SetFocus(wa2.getMainWindow());
|
|
|
|
return 1;
|
|
}
|
|
endfor;
|
|
foreach (pldirs)
|
|
PlDirObject *pldir = pldirs.getfor();
|
|
if (pldir == w)
|
|
{
|
|
delete pldir;
|
|
return 1;
|
|
}
|
|
endfor;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
int Wa2WndEmbed::viewer_onEvent(ifc_window *item, int event, intptr_t param, void *ptr, size_t ptrlen)
|
|
{
|
|
if (event == ifc_window::Event_SETVISIBLE)
|
|
{
|
|
/* if (!param) {
|
|
// the wnd may be going away, but then again, it might just be hidden to show an alternate layout of the same
|
|
// container, so before continuing, we need to check if it's actually going away. There is of course an exception
|
|
// in that if the window is hosted by a wndholder with autoclose="1", we should mirror the hiding state regardless
|
|
// of the container state
|
|
|
|
api_window *whr = item->getParent();
|
|
int except = 0;
|
|
if (whr) {
|
|
GuiObject *go = whr->getGuiObject();
|
|
if (go) {
|
|
const char *par = go->guiobject_getXmlParam("autoclose");
|
|
if (!par || (par && ATOI(par) == 1)) except = 1;
|
|
}
|
|
}
|
|
if (!except) {
|
|
api_window *lr = item->getDesktopParent();
|
|
if (lr) {
|
|
Layout *l = static_cast<Layout *>(lr->getInterface(layoutGuid));
|
|
if (l) {
|
|
Container *c = l->getParentContainer();
|
|
if (c) {
|
|
if (c->isVisible()) return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}*/
|
|
foreach(wndhosts)
|
|
EmbedEntry *ee = wndhosts.getfor();
|
|
XuiOSWndHost *x = ee->host;
|
|
ifc_window *rw = x;
|
|
if (rw == item)
|
|
{
|
|
{
|
|
ReentryFilter f(&wndMsgFilter, ee->whichwnd);
|
|
if (f.mustLeave()) continue;
|
|
}
|
|
if (ee->whichwnd > 1024)
|
|
{
|
|
embedWindowState *ws = (embedWindowState *)ee->whichwnd;
|
|
if (!param && wa2.isValidEmbedWndState(ws))
|
|
{
|
|
if (IsWindow(ws->me))
|
|
SendMessageW(ws->me, WM_USER + 101, 0, 0);
|
|
ifc_window *rwh = x->findWindowByInterface(windowHolderGuid);
|
|
if (rwh != NULL)
|
|
{
|
|
WindowHolder *wh = static_cast<WindowHolder *>(rwh->getInterface(windowHolderGuid));
|
|
if (wh != NULL)
|
|
{
|
|
wh->onRemoveWindow(1);
|
|
}
|
|
}
|
|
if (wa2.isValidEmbedWndState(ws)) ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] = NULL;
|
|
}
|
|
else if (wa2.isValidEmbedWndState(ws))
|
|
{
|
|
ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] = (intptr_t)item->getParent();
|
|
ShowWindow(ws->me, SW_NORMAL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ReentryFilter f(&wndMsgFilter, ee->whichwnd);
|
|
#ifdef VIDDEBUG
|
|
if (ee->whichwnd == IPC_GETWND_VIDEO && param != wa2.isWindowVisible(ee->whichwnd)) DebugString("Video : Detected that the host is %s, syncing\n", param ? "shown" : "hidden");
|
|
#endif
|
|
wa2.setWindowVisible(ee->whichwnd, param);
|
|
}
|
|
}
|
|
endfor;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int Wa2WndEmbed::onShowWindow(Container *c, GUID guid, const wchar_t *groupid)
|
|
{
|
|
foreach(wndhosts)
|
|
EmbedEntry *ee = wndhosts.getfor();
|
|
if (ee->g == guid)
|
|
{
|
|
ReentryFilter f(&wndMsgFilter, ee->whichwnd);
|
|
if (f.mustLeave()) return 1;
|
|
if (guid == videoWndGuid) wa2.setWindowVisible(IPC_GETWND_VIDEO, 1);
|
|
#ifdef MINIBROWSER_SUPPORT
|
|
else if (guid == minibrowserWndGuid) wa2.setWindowVisible(IPC_GETWND_MB, 1);
|
|
#endif
|
|
else if (guid == pleditWndGuid) wa2.setWindowVisible(IPC_GETWND_PE, 1);
|
|
}
|
|
endfor;
|
|
return 1;
|
|
}
|
|
|
|
int Wa2WndEmbed::onHideWindow(Container *c, GUID guid, const wchar_t *groupid)
|
|
{
|
|
/* if (guid == INVALID_GUID) return 1;
|
|
embedWindowState *ws = embedWndGuidMgr.getEmbedWindowState(guid);
|
|
if (ws != NULL && wa2.isValidEmbedWndState(ws)) {
|
|
if (IsWindow(ws->me))
|
|
SendMessageW(ws->me,WM_USER+101,0,0);
|
|
api_window *x = (api_window*)ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND];
|
|
if (x && WASABI_API_WND->rootwndIsValid(x)) {
|
|
api_window *rwh = x->findWindowByInterface(windowHolderGuid);
|
|
if (rwh != NULL) {
|
|
WindowHolder *wh = static_cast<WindowHolder *>(rwh->getInterface(windowHolderGuid));
|
|
if (wh != NULL) {
|
|
wh->onRemoveWindow(1);
|
|
}
|
|
}
|
|
}
|
|
ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] = NULL;
|
|
}
|
|
*/
|
|
foreach(wndhosts)
|
|
EmbedEntry *ee = wndhosts.getfor();
|
|
if (ee->g == guid)
|
|
{
|
|
ReentryFilter f(&wndMsgFilter, ee->whichwnd);
|
|
if (f.mustLeave()) return 1;
|
|
if (ee->host->isTransfering()) return 1;
|
|
ifc_window *dp = ee->host->getDesktopParent();
|
|
if (dp)
|
|
{
|
|
Layout *l = static_cast<Layout*>(dp->getInterface(layoutGuid));
|
|
if (l)
|
|
{
|
|
if (l->getParentContainer() != c) return 1;
|
|
}
|
|
}
|
|
if (guid == videoWndGuid) wa2.setWindowVisible(IPC_GETWND_VIDEO, 0);
|
|
#ifdef MINIBROWSER_SUPPORT
|
|
else if (guid == minibrowserWndGuid) wa2.setWindowVisible(IPC_GETWND_MB, 0);
|
|
#endif
|
|
else if (guid == pleditWndGuid) wa2.setWindowVisible(IPC_GETWND_PE, 0);
|
|
}
|
|
endfor;
|
|
|
|
return 1;
|
|
}
|
|
|
|
extern wchar_t *INI_FILE;
|
|
|
|
int Wa2WndEmbed::embedRememberProc(embedWindowState *p, embedEnumStruct *parms)
|
|
{
|
|
WndStatus *ws = new WndStatus;
|
|
ws->wndcode = -1; // if you insert a wnd that is not in embedTable, put -1 as wndcode
|
|
ws->wnd = p->me;
|
|
ws->visible = IsWindowVisible(p->me);
|
|
GetWindowRect(p->me, &ws->position);
|
|
// ws->position=p->r;
|
|
wa2wndstatus.addItem(ws);
|
|
|
|
// only store the ml window position if not loading on startup
|
|
if(going_freeform && !m_loading_at_startup)
|
|
{
|
|
HWND mlwnd = wa2.getMediaLibrary();
|
|
if(GetWindow(p->me, GW_CHILD) == mlwnd)
|
|
{
|
|
WritePrivateProfileStringW(L"gen_ff", L"classicmlwidth", StringPrintfW(L"%d", ws->position.right - ws->position.left), INI_FILE);
|
|
WritePrivateProfileStringW(L"gen_ff", L"classicmlheight", StringPrintfW(L"%d", ws->position.bottom - ws->position.top), INI_FILE);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
extern int m_loading_at_startup;
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
// todo: remember and restore windowshade modes
|
|
void Wa2WndEmbed::rememberVisibleWindows()
|
|
{
|
|
wa2wndstatus.deleteAll();
|
|
for (int i = 0;i < sizeof(embedTable) / sizeof(embedTable[0]);i++)
|
|
{
|
|
HWND w = wa2.getWnd(embedTable[i]);
|
|
WndStatus *ws = new WndStatus;
|
|
ws->wndcode = embedTable[i]; // if you insert a wnd that is not in embedTable, put -1 as wndcode
|
|
ws->wnd = w;
|
|
ws->visible = wa2.isWindowVisible(embedTable[i]);
|
|
GetWindowRect(w, &ws->position);
|
|
if (going_freeform)
|
|
{
|
|
if (embedTable[i] == IPC_GETWND_PE)
|
|
{
|
|
int peheight = ws->position.bottom - ws->position.top;
|
|
int pewidth = ws->position.right - ws->position.left;
|
|
if (!m_loading_at_startup)
|
|
{
|
|
WritePrivateProfileStringW(L"gen_ff", L"classicplwidth", StringPrintfW(L"%d", pewidth), INI_FILE);
|
|
WritePrivateProfileStringW(L"gen_ff", L"classicplheight", StringPrintfW(L"%d", peheight), INI_FILE);
|
|
}
|
|
int classicpews = wa2.isWindowShade(IPC_GETWND_PE);
|
|
if (!m_loading_at_startup || GetPrivateProfileIntW(L"gen_ff", L"classicplws", -1, INI_FILE) == -1)
|
|
WritePrivateProfileStringW(L"gen_ff", L"classicplws", classicpews ? L"1" : L"0", INI_FILE);
|
|
if (classicpews)
|
|
SendMessageW(wa2.getMainWindow(), WM_COMMAND, WINAMP_OPTIONS_WINDOWSHADE_PL, 0);
|
|
GetWindowRect(w, &ws->position);
|
|
}
|
|
}
|
|
wa2wndstatus.addItem(ws);
|
|
}
|
|
embedEnumStruct cs = { embedRememberProc, 0};
|
|
SendMessageW(wa2.getMainWindow(), WM_WA_IPC, (WPARAM)&cs, IPC_EMBED_ENUM);
|
|
}
|
|
|
|
int Wa2WndEmbed::hadRememberedWndVisible(HWND w)
|
|
{
|
|
int n = wa2wndstatus.getNumItems();
|
|
for (int i = 0;i < n;i++)
|
|
{
|
|
WndStatus *ws = wa2wndstatus.enumItem(i);
|
|
if (ws->wnd == w && ws->visible)
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void Wa2WndEmbed::restoreVisibleWindows()
|
|
{
|
|
int n = wa2wndstatus.getNumItems();
|
|
HWND mlwnd = wa2.getMediaLibrary();
|
|
for (int i = 0;i < n;i++)
|
|
{
|
|
WndStatus *ws = wa2wndstatus.enumItem(i);
|
|
if (going_fixedform && !m_loading_at_startup)
|
|
{
|
|
if (embedTable[i] == IPC_GETWND_PE)
|
|
{
|
|
int classicpews = GetPrivateProfileIntW(L"gen_ff", L"classicplws", 0, INI_FILE);
|
|
if (classicpews)
|
|
{
|
|
SendMessageW(wa2.getMainWindow(), WM_COMMAND, WINAMP_OPTIONS_WINDOWSHADE_PL, 0);
|
|
}
|
|
int classicwidth = GetPrivateProfileIntW(L"gen_ff", L"classicplwidth", 275, INI_FILE);
|
|
int classicheight = GetPrivateProfileIntW(L"gen_ff", L"classicplheight", 145, INI_FILE);
|
|
wa2.setPlEditWidthHeight(classicwidth, classicheight);
|
|
}
|
|
|
|
if(GetWindow(ws->wnd, GW_CHILD) == mlwnd)
|
|
{
|
|
// only restore the ml window size if we were able to read in saved values
|
|
int mlwidth = GetPrivateProfileIntW(L"gen_ff", L"classicmlwidth", -1, INI_FILE);
|
|
int mlheight = GetPrivateProfileIntW(L"gen_ff", L"classicmlheight", -1, INI_FILE);
|
|
if(mlwidth != -1 && mlheight != -1)
|
|
SetWindowPos(ws->wnd, 0, 0, 0, mlwidth, mlheight, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE);
|
|
}
|
|
}
|
|
// FG> as of oct19, this function only restores state for windows that WERE visible
|
|
// because there is no reason to hide one, since this function is designed to bring
|
|
// back those windows that were here in one mode, but aren't so anymore in another
|
|
if (ws->visible)
|
|
{
|
|
if (ws->wndcode != -1)
|
|
{
|
|
wa2.setWindowVisible(ws->wndcode, ws->visible);
|
|
}
|
|
else
|
|
{
|
|
ShowWindow(ws->wnd, ws->visible ? SW_SHOWNA : SW_HIDE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
PtrList<WndStatus> Wa2WndEmbed::wa2wndstatus;
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
PlaylistAppCmds::PlaylistAppCmds()
|
|
: addCmd(L"Add", PL_ADD, AppCmds::SIDE_LEFT, 0),
|
|
remCmd(L"Rem", PL_REM, AppCmds::SIDE_LEFT, 0),
|
|
selCmd(L"Sel", PL_SEL, AppCmds::SIDE_LEFT, 0),
|
|
miscCmd(L"Misc", PL_MISC, AppCmds::SIDE_LEFT, 0),
|
|
listCmd(L"List", PL_LIST, AppCmds::SIDE_RIGHT, 0)
|
|
{
|
|
appcmds_addCmd(&addCmd);
|
|
appcmds_addCmd(&remCmd);
|
|
appcmds_addCmd(&selCmd);
|
|
appcmds_addCmd(&miscCmd);
|
|
appcmds_addCmd(&listCmd);
|
|
}
|
|
|
|
void PlaylistAppCmds::appcmds_onCommand(int id, const RECT *buttonRect, int which_button)
|
|
{
|
|
switch (id)
|
|
{
|
|
case PL_ADD:
|
|
wa2.sendPlCmd(Winamp2FrontEnd::WA2_PLEDITPOPUP_ADD, buttonRect->left, buttonRect->top, TPM_BOTTOMALIGN | TPM_LEFTALIGN);
|
|
break;
|
|
case PL_REM:
|
|
wa2.sendPlCmd(Winamp2FrontEnd::WA2_PLEDITPOPUP_REM, buttonRect->left, buttonRect->top, TPM_BOTTOMALIGN | TPM_LEFTALIGN);
|
|
break;
|
|
case PL_SEL:
|
|
wa2.sendPlCmd(Winamp2FrontEnd::WA2_PLEDITPOPUP_SEL, buttonRect->left, buttonRect->top, TPM_BOTTOMALIGN | TPM_LEFTALIGN);
|
|
break;
|
|
case PL_MISC:
|
|
wa2.sendPlCmd(Winamp2FrontEnd::WA2_PLEDITPOPUP_MISC, buttonRect->left, buttonRect->top, TPM_BOTTOMALIGN | TPM_LEFTALIGN);
|
|
break;
|
|
case PL_LIST:
|
|
wa2.sendPlCmd(Winamp2FrontEnd::WA2_PLEDITPOPUP_LIST, buttonRect->right, buttonRect->top, TPM_BOTTOMALIGN | TPM_RIGHTALIGN);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef MINIBROWSER_SUPPORT
|
|
//-----------------------------------------------------------------------------------------------
|
|
MinibrowserAppCmds::MinibrowserAppCmds()
|
|
{
|
|
appcmds_addCmd(new CmdRec("Back", MB_BACK, AppCmds::SIDE_LEFT, 1));
|
|
appcmds_addCmd(new CmdRec("Forward", MB_FORWARD, AppCmds::SIDE_LEFT, 1));
|
|
appcmds_addCmd(new CmdRec("Stop", MB_STOP, AppCmds::SIDE_LEFT, 1));
|
|
appcmds_addCmd(new CmdRec("Reload", MB_RELOAD, AppCmds::SIDE_LEFT, 1));
|
|
appcmds_addCmd(new CmdRec("Misc", MB_MISC, AppCmds::SIDE_RIGHT, 1));
|
|
}
|
|
|
|
void MinibrowserAppCmds::appcmds_onCommand(int id, const RECT *buttonRect, int which_button)
|
|
{
|
|
switch (id)
|
|
{
|
|
case MB_BACK:
|
|
wa2.sendMbCmd(Winamp2FrontEnd::WA2_MBCMD_BACK);
|
|
break;
|
|
case MB_FORWARD:
|
|
wa2.sendMbCmd(Winamp2FrontEnd::WA2_MBCMD_FORWARD);
|
|
break;
|
|
case MB_STOP:
|
|
wa2.sendMbCmd(Winamp2FrontEnd::WA2_MBCMD_STOP);
|
|
break;
|
|
case MB_RELOAD:
|
|
wa2.sendMbCmd(Winamp2FrontEnd::WA2_MBCMD_RELOAD);
|
|
break;
|
|
case MB_MISC:
|
|
wa2.sendMbCmd(Winamp2FrontEnd::WA2_MBPOPUP_MISC, buttonRect->right, buttonRect->top, TPM_BOTTOMALIGN | TPM_RIGHTALIGN);
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------------------------
|
|
VideoAppCmds::VideoAppCmds()
|
|
{
|
|
appcmds_addCmd(new CmdRec(L"Fullscreen", VID_FULLSCREEN, AppCmds::SIDE_LEFT, 1));
|
|
appcmds_addCmd(new CmdRec(L"1x", VID_1X, AppCmds::SIDE_LEFT, 1));
|
|
appcmds_addCmd(new CmdRec(L"2x", VID_2X, AppCmds::SIDE_LEFT, 1));
|
|
appcmds_addCmd(new CmdRec(L"TV", VID_LIB, AppCmds::SIDE_LEFT, 1));
|
|
appcmds_addCmd(new CmdRec(L"Misc", VID_MISC, AppCmds::SIDE_RIGHT, 1));
|
|
}
|
|
|
|
void VideoAppCmds::appcmds_onCommand(int id, const RECT *buttonRect, int which_button)
|
|
{
|
|
switch (id)
|
|
{
|
|
case VID_FULLSCREEN:
|
|
wa2.sendVidCmd(Winamp2FrontEnd::WA2_VIDCMD_FULLSCREEN);
|
|
break;
|
|
case VID_1X:
|
|
wa2.sendVidCmd(Winamp2FrontEnd::WA2_VIDCMD_1X);
|
|
break;
|
|
case VID_2X:
|
|
wa2.sendVidCmd(Winamp2FrontEnd::WA2_VIDCMD_2X);
|
|
break;
|
|
case VID_LIB:
|
|
wa2.sendVidCmd(Winamp2FrontEnd::WA2_VIDCMD_LIB);
|
|
break;
|
|
case VID_MISC:
|
|
wa2.sendVidCmd(Winamp2FrontEnd::WA2_VIDPOPUP_MISC, buttonRect->right, buttonRect->top, TPM_BOTTOMALIGN | TPM_RIGHTALIGN);
|
|
break;
|
|
}
|
|
}
|
|
|