#include "precomp__gen_ff.h"
#include <windows.h>
#include <commctrl.h>
#include "main.h"
#include "resource.h"
#include "prefs.h"
#include "wa2frontend.h"
#include "wa2groupdefs.h"
#include "wa2wndembed.h"
#include "wa2cfgitems.h"
#include "wa2coreactions.h"
#include "wa2pledit.h"
#include "embedwndguid.h"
#include "gen_ff_ipc.h"
#include "fsmonitor.h"
#include <api/wnd/wndclass/foreignwnd.h>
#include "../winamp/wa_ipc.h"
#include "../gen_hotkeys/wa_hotkeys.h"
#include <api/script/objects/c_script/c_group.h>
#include <api/script/objects/c_script/c_text.h>
#include <api/apiinit.h>
#include <api/wnd/rootwnd.h>
#include <api/script/objects/guiobject.h>
#include <api/core/coreactions.h>
#include "menuactions.h"
#include <api/wnd/wndclass/oswndhost.h>
#include <api/script/scriptobj.h>
#include <api/service/svcs/svc_wndcreate.h>
#include <bfc/reentryfilter.h>
#include <api/skin/skinparse.h>
#include <api/wndmgr/skinembed.h>
#include <api/skin/widgets/xuiwndholder.h>
#include <api/skin/widgets/text.h>
#include <api/script/scriptmgr.h>
#include <api/wac/compon.h>
#include <api/application/version.h>
#include <bfc/parse/pathparse.h>
#include <tataki/blending/blending.h>
#include "skininfo.h"
#include <api/skin/guitree.h>
#include <bfc/wasabi_std_wnd.h>
#include "wa2core.h"
#include <api/locales/xlatstr.h>
#include <api/wndmgr/gc.h>
#include <api/syscb/callbacks/gccb.h>
#include <api/script/vcpu.h>
#include <tataki/canvas/bltcanvas.h>
#include "../nu/AutoWide.h"
#include <shlwapi.h>
#include <windowsx.h>
//wtf?
#define _WAFE_H_
#define ___HOTAMP3_H___
#include "../gen_hotkeys/hotkey.h"
int embedCreateProc(embedWindowState *p, embedEnumStruct *parms);
DECLARE_MODULE_SVCMGR;
#define VERSION L"1.55"
//#define VIDDEBUG
//#define DEBUG_CAPTURES
#include "../gen_ml/ml_ipc.h"
librarySendToMenuStruct mainSendTo;
#include "../Agave/Language/api_language.h"
// wasabi based services for localisation support
api_language *WASABI_API_LNG = 0;
HINSTANCE WASABI_API_LNG_HINST = 0, WASABI_API_ORIG_HINST;
static wchar_t szDescription[256];
//-----------------------------------------------------------------------------------------------
#define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))
#define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp))
#define ID_FILE_SHOWLIBRARY 40379
#define WINAMP_OPTIONS_PREFS 40012
#define WINAMP_HELP_ABOUT 40041
#define WINAMP_LIGHTNING_CLICK 40339
#define WINAMP
#define UPDATE_EGG 0xC0DE+2
#define VIEWPORT 0xC0DE+3
static int DEFERREDCALLBACKMSG;
static int UPDATEDIALOGBOXPARENTMSG;
//-----------------------------------------------------------------------------------------------
void config();
void quit();
int init();
void quit_inst();
void init_inst();
void ToggleLayout(const wchar_t *containerName);
void RestoreClassicWinamp(int was_loaded);
extern "C" winampGeneralPurposePlugin plugin =
{
GPPHDR_VER_U,
"nullsoft(gen_ff.dll)",
init,
config,
quit,
};
//-----------------------------------------------------------------------------------------------
int wantContainerInMenu(Container *cont)
{
wchar_t tmpBuf[96] = {0};
GUID g = cont->getGUID();
if (WCSCASEEQLSAFE(cont->getId(), L"main")) return 0;
if (cont->getNoMenu()) return 0;
if (g == pleditWndGuid) return 0;
if (g == videoWndGuid) return 0;
if (g == avs_guid) return 0;
if (g == library_guid) return 0;
if (WCSCASEEQLSAFE(cont->getName(), L":componenttitle")) return 0;
if (WCSCASEEQLSAFE(cont->getName(), L"Playlist Editor") || WCSCASEEQLSAFE(cont->getName(), L"Playlist") || WCSCASEEQLSAFE(cont->getId(), L"pledit")) return 0;
if (WCSCASEEQLSAFE(cont->getName(), L"Video Window") || WCSCASEEQLSAFE(cont->getName(), L"Video") || WCSCASEEQLSAFE(cont->getId(), L"Video")) return 0;
if (WCSCASEEQLSAFE(cont->getName(), WASABI_API_LNG->GetStringFromGUIDW(GenMlLangGUID,plugin.hDllInstance,18)) ||
WCSCASEEQLSAFE(cont->getName(), L"Media Library") ||
WCSCASEEQLSAFE(cont->getId(), L"Library") ||
WCSCASEEQLSAFE(cont->getName(),WASABI_API_LNGSTRINGW_BUF(IDS_MEDIA_LIBRARY,tmpBuf,96))) return 0;
if (WCSCASEEQLSAFE(cont->getName(), L"AVS") || WCSCASEEQLSAFE(cont->getName(), WASABI_API_LNGSTRINGW(IDS_VISUALIZATIONS)) || WCSCASEEQLSAFE(cont->getName(), L"Vis") || WCSCASEEQLSAFE(cont->getId(), L"Avs") || WCSCASEEQLSAFE(cont->getId(), L"Vis")) return 0;
return 1;
}
//-----------------------------------------------------------------------------------------------
api_playlists *AGAVE_API_PLAYLISTS = 0;
api_playlistmanager *AGAVE_API_PLAYLISTMANAGER = 0;
api_albumart *AGAVE_API_ALBUMART = 0;
api_downloadManager *WAC_API_DOWNLOADMANAGER = 0;
api_colorthemes *WASABI_API_COLORTHEMES = 0;
api_palette *WASABI_API_PALETTE = 0;
api_threadpool *WASABI_API_THREADPOOL = 0;
StringW m_lastskin_nam, m_lastskin_dir;
inline int lumidiff(int a, int b) {
int r1 = (a & 0xFF0000) >> 16;
int r2 = (b & 0xFF0000) >> 16;
int g1 = (a & 0xFF00) >> 8;
int g2 = (b & 0xFF00) >> 8;
int b1 = a & 0xFF;
int b2 = b & 0xFF;
return MIN((ABS(r1 - r2), ABS(g1 - g2)), ABS(b1 - b2));
}
static void doplaylistcolors()
{
int interpolate = 0;
if (SkinParser::getSkinVersion()*10 < 10) interpolate = 1;
// update colors
int buf[6] = {0};
waSetPlColorsStruct s = {0, };
extern COLORREF getWindowBackground(COLORREF *);
COLORREF windowbackground;
buf[5] = getWindowBackground(&windowbackground); // auto inverted
int need_cols = 1, need_bms = 1;
if (!m_lastskin_dir.isempty())
{
StringPathCombine bitmapfilename(m_lastskin_dir, L"pledit.bmp");
HANDLE h = CreateFileW(bitmapfilename, 0, 0, 0, OPEN_EXISTING, 0, 0);
if (h != INVALID_HANDLE_VALUE)
{
CloseHandle(h);
need_bms = 0;
}
bitmapfilename = StringPathCombine(m_lastskin_dir, L"pledit.txt");
h = CreateFileW(bitmapfilename, 0, 0, 0, OPEN_EXISTING, 0, 0);
if (h != INVALID_HANDLE_VALUE)
{
CloseHandle(h);
need_cols = 0;
}
}
if (need_cols)
{
s.numElems = 6;
s.elems = buf;
// list background
if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.list.background"))
buf[2] = SkinColor(L"wasabi.list.background") & 0xFFFFFF;
else
buf[2] = RGBTOBGR(WASABI_API_SKIN->skin_getBitmapColor(L"wasabi.list.background")) & 0xFFFFFF; // inverted coz coming from bitmap
// normal text
if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.list.text"))
buf[0] = SkinColor(L"wasabi.list.text") & 0xFFFFFF;
else
buf[0] = SkinColor(L"wasabi.edit.text") & 0xFFFFFF;
if (interpolate)
{
int c = buf[0];
c = lumidiff(c, buf[2]) < 0x1F ? Blenders::BLEND_AVG(buf[0], 0xFF7F7F7F) : c;
c = lumidiff(c, buf[2]) < 0x1F ? Blenders::BLEND_AVG(buf[0], 0xFF101010) : c;
buf[0] = c & 0xFFFFFF;
}
COLORREF selected;
// selected items background
if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.list.text.selected.background"))
{
selected = SkinColor(L"wasabi.list.text.selected.background");
buf[3] = selected;
}
else
{
// inverted twice, see bellow
if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.list.item.selected"))
selected = RGBTOBGR(SkinColor(L"wasabi.list.item.selected"));
else
selected = RGBTOBGR(SkinColor(SKINCOLOR_TREE_SELITEMBKG));
COLORREF col = RGBTOBGR(SkinColor(SKINCOLOR_LIST_COLUMNBKG));
int a = MAX((col & 0xFF0000) >> 16, MAX((col & 0xFF00) >> 8, col & 0xFF));
col = a < 0x1F ? Blenders::BLEND_AVG(windowbackground, 0xFF000000) : col;
int listbkg = RGBTOBGR(buf[2]);
selected = lumidiff(selected, listbkg) < 0x2F ? Blenders::BLEND_AVG(windowbackground, 0xFF7F7F7F) : selected;
selected = lumidiff(selected, listbkg) < 0x2F ? Blenders::BLEND_AVG(listbkg, 0xFF7F7F7F) : selected;
selected = lumidiff(selected, listbkg) < 0x2F ? Blenders::BLEND_AVG(windowbackground, 0xFFF0F0F0) : selected;
selected = lumidiff(selected, listbkg) < 0x2F ? Blenders::BLEND_AVG(listbkg, 0xFFF0F0F0) : selected;
selected = lumidiff(selected, listbkg) < 0x2F ? Blenders::BLEND_AVG(col, 0xFFF0F0F0) : selected;
selected = lumidiff(selected, listbkg) < 0x2F ? Blenders::BLEND_AVG(col, 0xFF101010) : selected;
selected = lumidiff(selected, RGBTOBGR(buf[0])) < 0x1F ? Blenders::BLEND_AVG(selected, 0xFF101010) : selected;
selected = lumidiff(selected, RGBTOBGR(buf[0])) < 0x1F ? Blenders::BLEND_AVG(selected, 0xFFF0F0F0) : selected;
selected &= 0xFFFFFF;
buf[3] = RGBTOBGR(selected);
}
// active text
if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.list.text.current"))
buf[1] = SkinColor(L"wasabi.list.text.current");
else
{
COLORREF act = Blenders::BLEND_AVG(selected, buf[0]);
act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(buf[2], 0xFFFFFFFF) : act;
act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(buf[2], 0xFF101010) : act;
act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(selected, buf[0]) : act;
act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(selected, buf[2]) : act;
act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(buf[0], buf[2]) : act;
buf[1] = act & 0xFFFFFF;
}
}
if (need_bms)
{
BltCanvas c(280, 186);
c.fillBits(windowbackground); // already inverted
void blitButtonToCanvas(int w, int h, int state, const wchar_t *overlayelement, int xpos, int ypos, BltCanvas *c);
blitButtonToCanvas(8, 18, 0, L"wasabi.scrollbar.vertical.grip", 52, 53, &c);
blitButtonToCanvas(8, 18, 1, L"wasabi.scrollbar.vertical.grip", 61, 53, &c);
int xpos, ypos;
//w=8,h=29
int cols[2];
int *fb = (int*)c.getBits() + 280 * 42;
// inverted colors because going into bitmap
if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.scrollbar.background.inverted"))
cols[0] = RGBTOBGR(SkinColor(L"wasabi.scrollbar.background.inverted"));
else
{
if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.list.column.empty"))
cols[0] = RGBTOBGR(SkinColor(L"wasabi.list.column.empty"));
else
{
COLORREF col = SkinColor(SKINCOLOR_LIST_COLUMNBKG);
int a = MAX((col & 0xFF0000) >> 16, MAX((col & 0xFF00) >> 8, col & 0xFF));
col = a < 0x1F ? Blenders::BLEND_AVG(windowbackground, 0xFF000000) : col;
cols[0] = RGBTOBGR(Blenders::BLEND_AVG(col, 0xFF000000));
}
}
if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.border.sunken"))
cols[1] = RGBTOBGR(SkinColor(L"wasabi.border.sunken"));
else
{
int a = MAX((windowbackground & 0xFF0000) >> 16, MAX((windowbackground & 0xFF00) >> 8, windowbackground & 0xFF));
cols[1] = Blenders::BLEND_AVG(windowbackground, a > 0xE0 ? 0xFF000000 : 0xFFFFFFFF);
}
for (ypos = 42;ypos < 42 + 29; ypos ++)
{
for (xpos = 36; xpos < 36 + 8; xpos ++)
{
fb[xpos] = cols[(xpos == 36 || xpos == 36 + 8 - 1)];
}
fb += 280;
}
extern HBITMAP CreateBitmapDIB(int w, int h, int planes, int bpp, void *data);
s.bm = CreateBitmapDIB(280, 186, 1, 32, c.getBits());
}
if (s.bm || s.elems) SendMessageW(wa2.getMainWindow(), WM_WA_IPC, (WPARAM)&s, IPC_SETPLEDITCOLORS);
}
static prefsDlgRecW ffPrefsItem;
//-----------------------------------------------------------------------------------------------
// a guid for our app : {4BE592C7-6937-426a-A388-ACF0EBC88E93}
static const GUID GEN_FREEFORM =
{ 0x4be592c7, 0x6937, 0x426a, { 0xa3, 0x88, 0xac, 0xf0, 0xeb, 0xc8, 0x8e, 0x93 } };
Wa2Groupdefs *groups;
static WNDPROC wa_oldWndProc;
Wa2CfgItems *cfgitems=0;
HINSTANCE hInstance = NULL;
HWND last_dlg_parent = NULL;
void populateWindowsMenus();
void unpopulateWindowsMenus();
void addWindowOptionsToContextMenu(ifc_window *w);
void removeWindowOptionsFromContextMenu();
void controlOpacity(int v);
void controlScaling(double v);
void customScaling();
void customOpacity();
void autoOpacifyHover();
void autoOpacifyFocus();
ifc_window *g_controlMenuTarget = NULL;
HMENU controlmenu = NULL;
void lockScaling(int lock);
int ffwindowsitempos = -1;
int ffoptionstop = -1;
int ffwoptionstop = -1;
int ffwindowstop = -1;
int ffwindowsitempos2 = -1;
int eqremoved = 0;
void removeEq();
void restoreEq();
int g_timedisplaymode = 0;
ifc_window *lastFocused = NULL;
int before_startup_callback = 0;
void loadExtraColorThemes();
extern _int last_page;
int gothrueqmsg = 0;
void unhookOutputIPC();
int we_have_ml = 0;
void checkMlPresent();
char eggstr[9] = {0};
int eggstat = 0;
int eggfallout = 0;
void initEgg();
void toggleEgg();
Layout *lastlayoutegg = NULL;
int disable_send_visrandom = 0;
void registerGlobalHotkeys();
int processGenericHotkey(const char *hk);
const char *getSkinInfo();
const wchar_t *getSkinInfoW();
void controlAppBar(int side);
void controlAppBarAOT();
void controlAppBarAH();
void updateAppBarMenu(ifc_window *w);
void startFSMonitor();
void stopFSMonitor();
void onGoFullscreen();
void onCancelFullscreen();
FullScreenMonitor *g_fsmonitor = NULL;
class Wa5FSCallback : public FSCallback
{
public:
virtual void onGoFullscreen()
{
::onGoFullscreen();
}
virtual void onCancelFullscreen()
{
::onCancelFullscreen();
}
};
Wa5FSCallback *g_fscallback = NULL;
int getAOTTempDisable()
{
return g_fsmonitor->isFullScreen();
}
LRESULT CallWinampWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
return CallWindowProcW(wa_oldWndProc, hwnd, msg, wParam, lParam);
}
//-----------------------------------------------------------------------------------------------
BOOL WINAPI dll_main_raw_fn(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
hInstance = hinstDLL;
Wasabi::Std::Initialize();
return TRUE;
}
extern "C"
{
void *_pRawDllMain = &dll_main_raw_fn;
};
__declspec(dllexport) BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
hInstance = hinstDLL;
return TRUE;
}
//-----------------------------------------------------------------------------------------------
// core actions implement "play", "stop", etc. wndEmbedded embed wa2 windows into GUID-based wnds
//-----------------------------------------------------------------------------------------------
BEGIN_SERVICES(Winamp2_Svcs);
DECLARE_SERVICETSINGLE(svc_action, CoreActions);
DECLARE_SERVICETSINGLE(svc_action, MenuActions);
DECLARE_SERVICETSINGLE(svc_windowCreate, Wa2WndEmbed);
END_SERVICES(Winamp2_Svcs, _Winamp2_Svcs);
//-----------------------------------------------------------------------------------------------
// functions called by the overriden windowproc to create and destroy wndembedders
//-----------------------------------------------------------------------------------------------
ifc_window *plWnd = NULL;
#ifdef MINIBROWSER_SUPPORT
ifc_window *mbWnd = NULL;
#endif
ifc_window *vidWnd = NULL;
TList<HWND> forcedoffwnds;
int going_freeform = 0;
int going_fixedform = 0;
wchar_t *INI_FILE = 0, *INI_DIR = 0;
void ToggleLayout(const wchar_t *containerName)
{
Container *c = SkinParser::getContainer(containerName);
if (c)
{
int numLayouts = c->getNumLayouts();
for (int i = 0;i < numLayouts;i++)
{
if (c->enumLayout(i) == c->getCurrentLayout())
{
int nextLayout = (i + 1) % numLayouts;
Layout *layout = c->enumLayout(nextLayout);
c->switchToLayout(layout->getId());
return ;
}
}
}
}
int updatePl()
{
// find out if this GUID is already shown.
WindowHolder *wh = skinEmbedder->getSuitableWindowHolder(pleditWndGuid, NULL, NULL, NULL, 1, -1, 0, 1, -1);
if (wh != NULL)
{
wh->cancelDeferredRemove();
GuiObject *go = wh->getRootWndPtr()->getGuiObject();
if (go)
{
Layout *l = go->guiobject_getParentLayout();
if (l)
{
Container *c = l->getParentContainer();
if (c)
{
DebugStringW(L"Container is %s\n", c->getId());
SkinEmbedder::cancelDestroyContainer(c);
}
}
}
plWnd = wh->getRootWndPtr(); //->getDesktopParent();
return 1;
}
return 0;
}
int createPl()
{
if (updatePl())
{
ShowWindow(wa2.getWnd(IPC_GETWND_PE), SW_SHOWNA);
return 1;
}
ReentryFilter f(&wndMsgFilter, IPC_GETWND_PE);
if (f.mustLeave()) return 1;
plWnd = WASABI_API_WNDMGR->skinwnd_createByGuid(pleditWndGuid, L"resizable_status");
if (plWnd != NULL)
{
plWnd->setVisible(1);
}
return plWnd != NULL;
}
static ifc_window *updateEmb(GUID thisguid, embedWindowState *ws)
{
WindowHolder *wh = skinEmbedder->getSuitableWindowHolder(thisguid, NULL, NULL, NULL, 1, -1, 0, 1, -1);
if (wh != NULL && !(ws->flags & EMBED_FLAGS_LEGACY_WND))
{
ifc_window *p = wh->getRootWndPtr(); //->getDesktopParent();
// p->getGuiScriptObject()->vcpu_setInterface(embeddedWndStateGuid, ws, INTERFACE_GENERICVOIDPTR);
ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] = (intptr_t)p;
return p;
}
return 0;
}
static ifc_window *createEmb(embedWindowState *ws, bool startHidden)
{
GUID thisguid = EmbedWndGuid(ws).getGuid();
if (thisguid == INVALID_GUID || (ws->flags & EMBED_FLAGS_LEGACY_WND))
return 0;
//thisguid.Data1 = (int)ws->me;
ifc_window *update = updateEmb(thisguid, ws);
if (update)
return update;
ReentryFilter f(&wndMsgFilter, (intptr_t)ws);
if (f.mustLeave())
return 0;
RECT r;
if (!GetWindowRect(ws->me, &r))
SetRectEmpty(&r);
ifc_window *p = NULL;
if (ws->flags & EMBED_FLAGS_NORESIZE)
p = WASABI_API_WNDMGR->skinwnd_createByGuid(thisguid, L"static", 0, NULL, 0, startHidden, NULL);
else
p = WASABI_API_WNDMGR->skinwnd_createByGuid(thisguid, L"resizable_nostatus", 0, NULL, 0, startHidden, NULL);
ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] = (intptr_t) p;
if (p != NULL)
{
// p->getGuiScriptObject()->vcpu_setInterface(embeddedWndStateGuid, ws, INTERFACE_GENERICVOIDPTR);
if (NULL != WASABI_API_APP)
WASABI_API_APP->app_unregisterGlobalWindow(p->getDesktopParent()->gethWnd());
if (!startHidden)
p->setVisible(1);
GuiObject *go = p->getGuiObject();
if (go)
{
Layout *l = go->guiobject_getParentLayout();
if (l)
{
Container *c = l->getParentContainer();
if (c)
{
if (ws->flags & EMBED_FLAGS_NOWINDOWMENU)
c->setXmlParam(L"nomenu", L"1");
else
c->setXmlParam(L"nomenu", L"0");
}
}
}
}
if (p == NULL)
{
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 | SWP_NOCOPYBITS );
SetWindowPos( ws->me, NULL, r.left, r.top, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOREDRAW | SWP_NOSENDCHANGING | SWP_NOZORDER | SWP_NOCOPYBITS );
forcedoffwnds.addItem(ws->me);
//if (0 != (WS_VISIBLE & windowStyle))
//RedrawWindow(GetDesktopWindow(), &r, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_UPDATENOW | RDW_NOERASE);
}
RedrawWindow(GetDesktopWindow(), &r, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_UPDATENOW | RDW_NOERASE);
return p;
}
#ifdef MINIBROWSER_SUPPORT
int updateMb()
{
WindowHolder *wh = skinEmbedder->getSuitableWindowHolder(minibrowserWndGuid, NULL, NULL, NULL, 1, -1, 0, 1, -1);
if (wh != NULL)
{
mbWnd = wh->getRootWndPtr(); //->getDesktopParent();
ShowWindow(wa2.getWnd(IPC_GETWND_MB), SW_SHOWNA);
return 1;
}
return 0;
}
int createMb()
{
// see cratePl()
if (updateMb()) return 1;
ReentryFilter f(&wndMsgFilter, IPC_GETWND_MB);
if (f.mustLeave()) return 1;
mbWnd = WASABI_API_WNDMGR->skinwnd_createByGuid(minibrowserWndGuid, "resizable_status");
if (mbWnd != NULL) mbWnd->setVisible(1);
return mbWnd != NULL;
}
#endif
static HWND oldVideoWnd;
static WNDPROC oldVideoWndProc;
static DWORD WINAPI newVideoWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (uMsg == WM_USER + 0x100 && wParam == 1 && lParam)
return 0;
return CallWindowProc(oldVideoWndProc, hwnd, uMsg, wParam, lParam);
}
int updateVid()
{
WindowHolder *wh = skinEmbedder->getSuitableWindowHolder(videoWndGuid, NULL, NULL, NULL, 1, -1, 0, 1, -1);
if (wh != NULL)
{
#ifdef VIDDEBUG
DebugString("Video : Host already exists and window already shown in it\n");
#endif
wh->cancelDeferredRemove();
GuiObject *go = wh->getRootWndPtr()->getGuiObject();
if (go)
{
Layout *l = go->guiobject_getParentLayout();
if (l)
{
Container *c = l->getParentContainer();
if (c)
{
DebugStringW(L"Container is %s\n", c->getId());
SkinEmbedder::cancelDestroyContainer(c);
}
}
}
vidWnd = wh->getRootWndPtr(); //->getDesktopParent();
return 1;
}
return 0;
}
int createVid()
{
ShowWindow(WASABI_API_WND->main_getRootWnd()->gethWnd(), SW_RESTORE);
SetForegroundWindow(WASABI_API_WND->main_getRootWnd()->gethWnd());
if (updateVid())
{
ShowWindow(wa2.getWnd(IPC_GETWND_VIDEO), SW_SHOWNA);
return 1;
}
if (vidWnd == NULL)
{
ReentryFilter f(&wndMsgFilter, IPC_GETWND_VIDEO);
if (f.mustLeave()) return 1;
#ifdef VIDDEBUG
DebugString("Video : Trying to find a host or creating it if needed\n");
#endif
vidWnd = WASABI_API_WNDMGR->skinwnd_createByGuid(videoWndGuid, L"resizable_status");
}
if (vidWnd != NULL)
{
vidWnd->setVisible(1);
}
return vidWnd != NULL;
}
int destroyPl(HWND hwndDlg, int uMsg, WPARAM wParam, LPARAM lParam)
{
ReentryFilter f(&wndMsgFilter, IPC_GETWND_PE);
int r = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam);
if (f.mustLeave()) return r;
if (plWnd != NULL && WASABI_API_WND->rootwndIsValid(plWnd))
{
WASABI_API_WNDMGR->skinwnd_destroy(plWnd);
r = !WASABI_API_WND->rootwndIsValid(plWnd);
}
else
r = !SOM::checkAbortShowHideWindow(pleditWndGuid, 0);
if (r)
plWnd = NULL;
return r;
}
int destroyEmb(HWND hwndDlg, int uMsg, WPARAM wParam, LPARAM lParam, embedWindowState *ws)
{
ReentryFilter f(&wndMsgFilter, (intptr_t)ws);
int r = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam);
if (f.mustLeave() || (ws->flags & EMBED_FLAGS_LEGACY_WND)) return r;
if (ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] == NULL) return r;
if (ws->extra_data[EMBED_STATE_EXTRA_REPARENTING] == 1) return r;
ifc_window *w = (ifc_window*)ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND];
#if 1
if (WASABI_API_WND->rootwndIsValid(w))
{
WASABI_API_WNDMGR->skinwnd_destroy(w);
r = !WASABI_API_WND->rootwndIsValid(w);
}
else
{
r = !SOM::checkAbortShowHideWindow(embedWndGuidMgr.getGuid(ws), 0);
}
if (r)
ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] = NULL;
#else
if (WASABI_API_WND->rootwndIsValid(w)) WASABI_API_WNDMGR->skinwnd_destroy(w);
else SOM::checkAbortShowHideWindow(embedWndGuidMgr.getGuid(ws), 0);
ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] = NULL;
#endif
return r;
}
#ifdef MINIBROWSER_SUPPORT
int destroyMb(HWND hwndDlg, int uMsg, WPARAM wParam, LPARAM lParam)
{
ReentryFilter f(&wndMsgFilter, IPC_GETWND_MB);
int r = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam);
if (f.mustLeave()) return r;
if (mbWnd != NULL && WASABI_API_WND->rootwndIsValid(mbWnd)) WASABI_API_WNDMGR->skinwnd_destroy(mbWnd);
else SOM::checkAbortShowHideWindow(minibrowserWndGuid, 0);
mbWnd = NULL;
return r;
}
#endif
int destroyVid(HWND hwndDlg, int uMsg, WPARAM wParam, LPARAM lParam)
{
ReentryFilter f(&wndMsgFilter, IPC_GETWND_VIDEO);
int r = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam);
if (f.mustLeave()) return r;
if (vidWnd != NULL && WASABI_API_WND->rootwndIsValid(vidWnd))
{
WASABI_API_WNDMGR->skinwnd_destroy(vidWnd);
r = !WASABI_API_WND->rootwndIsValid(vidWnd);
}
else
r = !SOM::checkAbortShowHideWindow(videoWndGuid, 0);
if (r)
vidWnd = NULL;
return r;
}
int m_loading_at_startup;
int m_are_we_loaded;
#define WINAMP_REFRESHSKIN 40291
#define WINAMP_OPTIONS_EQ 40036
#define WINAMP_OPTIONS_DSIZE 40165
#define WINAMP_OPTIONS_ELAPSED 40037
#define WINAMP_OPTIONS_REMAINING 40038
//-----------------------------------------------------------------------------------------------
class MainLayoutMonitor : public H_Layout
{
public:
MainLayoutMonitor(HWND _w, ScriptObject *o) : H_Layout(o) { hwnd= _w; }
void hook_onResize(int x, int y, int w, int h);
HWND hwnd;
};
void MainLayoutMonitor::hook_onResize(int x, int y, int w, int h)
{
PostMessage(wa2.getMainWindow(), WM_WA_IPC, (WPARAM)hwnd, UPDATEDIALOGBOXPARENTMSG);
}
//-----------------------------------------------------------------------------------------------
// must be called after switching to a new freeform skin
// should also be called when the main container changes its visible layout
//-----------------------------------------------------------------------------------------------
Layout *GetMainLayout()
{
Container *container = SkinParser::getContainer(L"main");
if (container != NULL)
{
return container->getCurrentLayout();
}
return 0;
}
HWND GetMainContainerHWND()
{
Layout *l = GetMainLayout();
if (l != NULL)
return l->gethWnd();
return 0;
}
static MainLayoutMonitor *mainLayoutMonitor = 0;
void setDialogBoxesParent()
{
Layout *l = GetMainLayout();
if (l != NULL)
{
HWND hwnd = l->gethWnd();
delete mainLayoutMonitor;
mainLayoutMonitor = new MainLayoutMonitor(hwnd, l->getScriptObject());
wa2.setDialogBoxParent(hwnd);
PostMessage(wa2.getMainWindow(), WM_WA_IPC, (WPARAM)hwnd, UPDATEDIALOGBOXPARENTMSG);
lastFocused = l;
}
}
static void removeSkinExtension(StringW &skinname)
{
int x = skinname.len() - 4;
if (x > 0)
{
const wchar_t *p = ((const wchar_t *)skinname) + x;
if (!_wcsicmp(p, L".zip") || !_wcsicmp(p, L".wal") || !_wcsicmp(p, L".wsz"))
skinname.trunc(x);
}
}
extern HWND subWnd, tabwnd;
extern int subWndId;
extern int toggle_from_wa2;
int switching_skin = 0;
void shutdownFFApi();
/*-----------------------------------------------------------------------------------------------
* Winamp2 message processor
*/
static void RerouteMessage(MSG *pMsg, ifc_window *wnd)
{
if (NULL == wnd)
return;
HWND hReroute = NULL;
if (pMsg->hwnd == GetMainContainerHWND())
{
hReroute = WASABI_API_WND->main_getRootWnd()->gethWnd();
if (NULL != hReroute)
{
pMsg->hwnd = hReroute;
}
return;
}
if (wnd->gethWnd() != pMsg->hwnd)
return;
ifc_window *parent = wnd->getRootParent();
if (NULL == parent)
return;
Layout *l = static_cast<Layout *>(parent->getInterface(layoutGuid));
if (NULL == l)
return;
Container *c = l->getParentContainer();
if (NULL == c)
return;
GUID g = c->getDefaultContent();
if (INVALID_GUID == g)
return;
if (g == playerWndGuid)
hReroute = wa2.getMainWindow();
else if (g == pleditWndGuid)
hReroute = wa2.getWnd(IPC_GETWND_PE);
else if (g == videoWndGuid)
hReroute = wa2.getWnd(IPC_GETWND_VIDEO);
else
{
embedWindowState *ews = embedWndGuidMgr.getEmbedWindowState(g);
if (ews)
hReroute = ews->me;
}
if (NULL != hReroute)
pMsg->hwnd = hReroute;
}
class WaMessageProccessor : public ifc_messageprocessor
{
public:
WaMessageProccessor() {}
~WaMessageProccessor(void) {}
public:
bool ProcessMessage(MSG *pMsg)
{
if (WM_KEYDOWN == pMsg->message ||
WM_KEYUP == pMsg->message ||
WM_SYSKEYDOWN == pMsg->message ||
WM_SYSKEYUP == pMsg->message)
{
ifc_window *wnd;
HWND h = pMsg->hwnd;
do
{
wnd = WASABI_API_WND->rootWndFromOSHandle(h);
} while (!wnd && NULL!= (h = GetAncestor(h, GA_PARENT)));
if (wnd)
{
if (!wnd->isVirtual())
{
while (wnd)
{
const wchar_t *pid = wnd->getId();
if (pid && *pid) break;
wnd = wnd->getParent();
}
}
if (wnd && wnd->getCurVirtualChildFocus())
wnd = wnd->getCurVirtualChildFocus();
}
if (wnd)
DebugStringW(L"target wnd 0x%08X, id: %s", wnd, wnd->getId());
INT keyMsg = -1;
switch(pMsg->message)
{
case WM_KEYDOWN:
static int pos;
if (toupper((int)pMsg->wParam) == eggstr[pos])
{
if (!eggstr[++pos])
{
toggleEgg();
pos = 0;
}
}
else pos = 0;
keyMsg = (0 != WASABI_API_WND->forwardOnKeyDown(wnd, (int)pMsg->wParam, pMsg->lParam));
break;
case WM_KEYUP: keyMsg = (wnd && 0 != WASABI_API_WND->forwardOnKeyUp(wnd, (int)pMsg->wParam, pMsg->lParam)); break;
case WM_SYSKEYDOWN: keyMsg = ( 0 != WASABI_API_WND->forwardOnSysKeyDown(wnd, (int)pMsg->wParam, pMsg->lParam)); break;
case WM_SYSKEYUP: keyMsg = (wnd && 0 != WASABI_API_WND->forwardOnSysKeyUp(wnd, (int)pMsg->wParam, pMsg->lParam)); break;
}
if (-1 != keyMsg)
{
if (keyMsg > 0)
return true;
RerouteMessage(pMsg, wnd);
}
}
return false;
}
protected:
RECVS_DISPATCH;
};
#define CBCLASS WaMessageProccessor
START_DISPATCH;
CB(IFC_MESSAGEPROCESSOR_PROCESS_MESSAGE, ProcessMessage)
END_DISPATCH;
#undef CBCLASS
static WaMessageProccessor waMessageProcessor;
#define TabCtrl_InsertItemW(hwnd, iItem, pitem) \
(int)SNDMSG((hwnd), TCM_INSERTITEMW, (WPARAM)(int)(iItem), (LPARAM)(const TC_ITEMW *)(pitem))
//-----------------------------------------------------------------------------------------------
void onSkinSwitch()
{
switching_skin = 1;
int lastloaded = m_are_we_loaded;
Wa2WndEmbed::rememberVisibleWindows();
// get skin name
wchar_t buf[MAX_PATH] = {0};
wchar_t *p = (wchar_t *) SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)buf, IPC_GETSKINW);
{
m_lastskin_nam.setValue(p);
m_lastskin_dir.setValue(buf);
StringPathCombine t(m_lastskin_dir, L"skin.xml");
if (!m_lastskin_nam.isempty()
&& _waccess(t.getValue(), 0))
{
t.setValue(m_lastskin_dir);
StringW n = m_lastskin_nam;
removeSkinExtension(n);
t.AppendPath(n);
t.AppendPath(L"skin.xml");
if (!_waccess(t.getValue(), 0))
m_lastskin_dir.AppendPath(n);
}
if (!_waccess(t.getValue(), 0))
{
if (!m_are_we_loaded) init_inst();
else
{
// load new skin
StringW skinname = m_lastskin_nam;
removeSkinExtension(skinname);
before_startup_callback = 1;
WASABI_API_SKIN->skin_switchSkin(skinname, m_lastskin_dir);
if (DEFERREDCALLBACKMSG > 65536)
PostMessage(wa2.getMainWindow(), WM_WA_IPC, 2, DEFERREDCALLBACKMSG);
//embedEnumStruct cs = { embedCreateProc, 0 };
//SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)&cs, IPC_EMBED_ENUM);
doplaylistcolors();
setDialogBoxesParent();
populateWindowsMenus();
}
}
else
{
going_fixedform = 1;
quit_inst();
}
}
if (subWnd != NULL && IsWindow(subWnd)) SendMessageW(subWnd, WM_INITDIALOG, 0, 0);
if (IsWindow(tabwnd))
{
if (!m_are_we_loaded)
{
if (subWndId == 5)
{
DestroyWindow(subWnd);
TabCtrl_SetCurSel(tabwnd,0);
_dosetsel(GetParent(tabwnd));
}
if (TabCtrl_GetItemCount(tabwnd) == 5)
{
TabCtrl_DeleteItem(tabwnd,4);
TabCtrl_DeleteItem(tabwnd,3);
}
}
else
{
if (TabCtrl_GetItemCount(tabwnd) == 3)
{
TCITEMW item = {0};
item.mask=TCIF_TEXT;
item.pszText=WASABI_API_LNGSTRINGW(IDS_COLOR_THEMES);
TabCtrl_InsertItemW(tabwnd,3,&item);
item.pszText=WASABI_API_LNGSTRINGW(IDS_CURRENT_SKIN);
TabCtrl_InsertItemW(tabwnd,4,&item);
}
}
}
if (m_are_we_loaded || lastloaded) // dont call this if going from classic->classic
Wa2WndEmbed::restoreVisibleWindows();
if (m_are_we_loaded && WASABI_API_SYSCB)
WASABI_API_SYSCB->syscb_issueCallback(SysCallback::GC, GarbageCollectCallback::GARBAGECOLLECT);
if (WASABI_API_APP)
{
if (m_are_we_loaded) WASABI_API_APP->app_addMessageProcessor(&waMessageProcessor);
else WASABI_API_APP->app_removeMessageProcessor(&waMessageProcessor);
}
/* TODO: benski> want to add this, but it's causing a weird crash
if (going_fixedform)
shutdownFFApi();
*/
switching_skin = 0;
going_fixedform = 0;
before_startup_callback = 0;
}
static int embedUpdateColorProc(embedWindowState *p, embedEnumStruct *parms)
{
SendMessageW(p->me, WM_DISPLAYCHANGE, 0, 0);
return 0;
}
int embedCreateProc(embedWindowState *ws, embedEnumStruct *parms)
{
ifc_window *rw = reinterpret_cast<ifc_window*>(ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND]);
if (!rw && IsWindow(ws->me) && IsWindowVisible(ws->me) && !(ws->flags & EMBED_FLAGS_LEGACY_WND))
{
ifc_window *windowParent = createEmb(ws, true);
if (NULL != windowParent)
{
GuiObject *uiObject = windowParent->getGuiObject();
if (NULL != uiObject)
{
if (0 != (EMBED_FLAGS_FFCALLBACK & ws->flags) &&
NULL != ws->callback)
{
ws->callback(ws, FFC_CREATEEMBED, (LPARAM)windowParent);
}
Layout *layout = uiObject->guiobject_getParentLayout();
if (NULL != layout)
{
Container *container = layout->getParentContainer();
if (NULL != container) container->setVisible(1);
else layout->setVisible(1);
windowParent->setVisible(1);
}
}
}
if (NULL == windowParent)
ShowWindow(ws->me, SW_HIDE);
}
return 0;
}
//-----------------------------------------------------------------------------------------------
void syncDoubleSize(int loading = 0)
{
if (!cfg_uioptions_uselocks.getValueAsInt()) return ;
int isdsize = wa2.isDoubleSize();
int i;
for (i = 0;i < SkinParser::getNumContainers();i++)
{
Container *c = SkinParser::enumContainer(i);
if (c != NULL)
{
int j;
for (j = 0;j < c->getNumLayouts();j++)
{
Layout *l = c->enumLayout(j);
if (l != NULL)
{
if (l->isScaleLocked()) continue;
l->setRenderRatio(isdsize ? 2.0f : 1.0f);
}
}
}
}
}
//-----------------------------------------------------------------------------------------------
class syncDisplayModeEnumerator : public FindObjectCallbackI
{
public:
int findobjectcb_matchObject(ifc_window *object)
{
ScriptObject *s = NULL;
GuiObject *g = object->getGuiObject();
if (g)
{
ScriptObject *_s = g->guiobject_getScriptObject();
if (_s)
{
void *v = _s->vcpu_getInterfaceObject(textGuid, &s);
if (v && !s)
{
(static_cast<Text*>(v))->setTimeDisplayMode(g_timedisplaymode);
}
}
}
return 0;
}
};
//-----------------------------------------------------------------------------------------------
void syncDisplayMode()
{
if (switching_skin) return ;
g_timedisplaymode = wa2.getTimeDisplayMode();
int i;
syncDisplayModeEnumerator enumerator;
for (i = 0;i < SkinParser::getNumContainers();i++)
{
Container *c = SkinParser::enumContainer(i);
if (c != NULL)
{
int j;
for (j = 0;j < c->getNumLayouts();j++)
{
Layout *l = c->enumLayout(j);
if (!WASABI_API_WND->rootwndIsValid(l)) continue;
l->findWindowByCallback(&enumerator);
}
}
}
}
static POINT viewPort;
VOID CALLBACK ViewPortChanged(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
KillTimer(hwnd, idEvent);
if (viewPort.x && viewPort.y)
{
SystemObject::onViewPortChanged(viewPort.x, viewPort.y);
}
}
//-----------------------------------------------------------------------------------------------
// Winamp2 main window subclass
//-----------------------------------------------------------------------------------------------
static LRESULT WINAPI wa_newWndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static int m_in_skinrefresh;
if (uMsg == WM_COMMAND && LOWORD(wParam) == WINAMP_REFRESHSKIN)
{
HWND prefs = wa2.getPreferencesWindow();
RECT prefrect = {0};
if (prefs)
{
GetWindowRect(prefs, &prefrect);
HWND hOwner = (HWND)(LONG_PTR)GetWindowLongPtrW(prefs, GWLP_HWNDPARENT);
if (NULL != hOwner && hOwner != hwndDlg)
SetWindowLongPtrW(prefs, GWLP_HWNDPARENT, (LONG_PTR)hwndDlg);
}
m_in_skinrefresh++;
DWORD b = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam);
onSkinSwitch();
if (m_are_we_loaded) doplaylistcolors();
m_in_skinrefresh--;
if (prefs && !wa2.getPreferencesWindow())
{
SendMessageW(wa2.getMainWindow(), WM_COMMAND, WINAMP_OPTIONS_PREFS, 0);
SetWindowPos(wa2.getPreferencesWindow(), NULL, prefrect.left, prefrect.top, prefrect.right - prefrect.left, prefrect.bottom - prefrect.top, SWP_NOZORDER | SWP_NOACTIVATE | SWP_DEFERERASE);
}
return b;
}
if (g_Core)
{
if (uMsg == WM_WA_IPC && lParam == IPC_CB_MISC) g_Core->gotCallback(wParam);
#define WINAMP_FILE_REPEAT 40022
#define WINAMP_FILE_SHUFFLE 40023
#define WINAMP_FILE_MANUALPLADVANCE 40395
#define UPDATE_DISPLAY_TIMER 38
if (uMsg == WM_TIMER)
{
if (LOWORD(wParam) == UPDATE_EGG)
{
for (int i = 0;i < SkinParser::getNumContainers();i++)
{
Container *cont = SkinParser::enumContainer(i);
if (cont->isMainContainer())
{
Layout *l = cont->getCurrentLayout();
if (lastlayoutegg && l != lastlayoutegg)
{
if (WASABI_API_WND->rootwndIsValid(lastlayoutegg))
{
lastlayoutegg->updateTransparency();
lastlayoutegg->setTransparencyOverride(-1);
}
}
lastlayoutegg = l;
int v = (WASABI_API_MEDIACORE->core_getLeftVuMeter(0) + WASABI_API_MEDIACORE->core_getRightVuMeter(0)) / 4;
eggfallout -= 4;
if (v > eggfallout) eggfallout = v;
lastlayoutegg->setTransparencyOverride(255 - eggfallout);
break;
}
}
return 0;
}
if (LOWORD(wParam) == UPDATE_DISPLAY_TIMER + 4)
{
syncDisplayMode();
}
if (LOWORD(wParam) == 0xC0DE)
{
if (!wa2.isVisRunning())
{
KillTimer(wa2.getMainWindow(), 0xC0DE);
KillTimer(wa2.getMainWindow(), 0xC0DE + 1);
wa2.toggleVis();
}
}
if (LOWORD(wParam) == 0xC0DE + 1)
{
KillTimer(wa2.getMainWindow(), 0xC0DE);
KillTimer(wa2.getMainWindow(), 0xC0DE + 1);
}
}
if (!my_set && (uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) == WINAMP_FILE_SHUFFLE)
{
DWORD v = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam);
int shuf = wa2.getShuffle();
if (!shuffle.getValueAsInt() != !shuf) shuffle.setValueAsInt(shuf);
return v;
}
if (!my_set && (uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) &&
(LOWORD(wParam) == WINAMP_FILE_REPEAT) ||
(LOWORD(wParam) == WINAMP_FILE_MANUALPLADVANCE))
{
DWORD v = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam);
int rep = wa2.getRepeat();
int manadv = wa2.getManualPlaylistAdvance();
int _v = (rep && manadv) ? -1 : rep;
if (repeat.getValueAsInt() != _v) repeat.setValueAsInt(_v);
return v;
}
if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) == WINAMP_OPTIONS_DSIZE)
{
int v = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam);
syncDoubleSize();
return v;
}
if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && (LOWORD(wParam) == WINAMP_OPTIONS_ELAPSED || LOWORD(wParam) == WINAMP_OPTIONS_REMAINING))
{
int v = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam);
syncDisplayMode();
return v;
}
}
if (m_are_we_loaded)
{
if (uMsg == WM_COMMAND && LOWORD(wParam) == 40266)
{
ToggleLayout(L"pledit");
return 0;
}
else if (uMsg == WM_COMMAND && LOWORD(wParam) == 40064)
{
ToggleLayout(L"main");
return 0;
}
else if (uMsg == WM_CLOSE && wParam == 0xDEADBEEF && lParam == 0xDEADF00D)
{
//if (/*todo: configurable */ 1)
{
uMsg = WM_COMMAND;
wParam = WINAMP_MAIN_WINDOW;
}
}
else if (uMsg == WM_SETTINGCHANGE)
{
// used to track viewport changes so we can update
// e.g. when removing Win8's side-by-side app mode
if (wParam == SPI_SETWORKAREA)
{
KillTimer(wa2.getMainWindow(), VIEWPORT);
viewPort.x = -1;
viewPort.y = -1;
SetTimer(wa2.getMainWindow(), VIEWPORT, 100, ViewPortChanged);
}
}
else if (uMsg == WM_DISPLAYCHANGE)
{
DWORD b = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam);
if (!m_in_skinrefresh) doplaylistcolors();
// filter out our internal skin updates
if (wParam && lParam)
{
KillTimer(wa2.getMainWindow(), VIEWPORT);
viewPort.x = LOWORD(lParam);
viewPort.y = HIWORD(lParam);
SetTimer(wa2.getMainWindow(), VIEWPORT, 100, ViewPortChanged);
}
return b;
}
else if (uMsg == WM_INITMENUPOPUP)
{
HMENU hmenuPopup = (HMENU) wParam;
if (hmenuPopup && hmenuPopup == mainSendTo.build_hMenu && mainSendTo.mode == 1)
{
int IPC_LIBRARY_SENDTOMENU = SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)&"LibrarySendToMenu", IPC_REGISTER_WINAMP_IPCMESSAGE);
if (IPC_LIBRARY_SENDTOMENU > 65536 && SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)&mainSendTo, IPC_LIBRARY_SENDTOMENU) == 0xffffffff)
mainSendTo.mode = 2;
}
if(hmenuPopup == wa2.getMenuBarMenu(Winamp2FrontEnd::WA2_MAINMENUBAR_PLAY))
{
CheckMenuItem((HMENU)wParam, WINAMP_FILE_SHUFFLE, wa2.getShuffle() ? MF_CHECKED : MF_UNCHECKED);
CheckMenuItem((HMENU)wParam, WINAMP_FILE_REPEAT, wa2.getRepeat() ? MF_CHECKED : MF_UNCHECKED);
}
if (hmenuPopup == wa2.getPopupMenu() ||
hmenuPopup == wa2.getMenuBarMenu(Winamp2FrontEnd::WA2_MAINMENUBAR_OPTIONS) ||
hmenuPopup == wa2.getMenuBarMenu(Winamp2FrontEnd::WA2_MAINMENUBAR_WINDOWS))
{
if (hmenuPopup == wa2.getMenuBarMenu(Winamp2FrontEnd::WA2_MAINMENUBAR_OPTIONS)) {
EnableMenuItem(hmenuPopup, WINAMP_OPTIONS_DSIZE,
MF_BYCOMMAND | (cfg_uioptions_uselocks.getValueAsInt() ? MF_ENABLED : MF_GRAYED));
}
if (hmenuPopup == wa2.getPopupMenu()){
EnableMenuItem(GetSubMenu(hmenuPopup, 11 + wa2.adjustOptionsPopupMenu(0)), WINAMP_OPTIONS_DSIZE,
MF_BYCOMMAND | (cfg_uioptions_uselocks.getValueAsInt() ? MF_ENABLED : MF_GRAYED));
}
populateWindowsMenus();
if ((HMENU)wParam == wa2.getPopupMenu())
{
for (int i = 0;i < SkinParser::getNumContainers();i++)
{
Container *cont = SkinParser::enumContainer(i);
if (!_wcsicmp(cont->getId(), L"main"))
{
CheckMenuItem((HMENU)wParam, WINAMP_MAIN_WINDOW, cont->isVisible() ? MF_CHECKED : MF_UNCHECKED);
break;
}
}
}
}
}
else if (uMsg == WM_SETFOCUS)
{
if (m_are_we_loaded && !switching_skin)
{
Container *c = SkinParser::getContainer(L"main");
if (c)
{
Layout *l = c->enumLayout(0);
if (l) l->setFocus();
}
return 1;
}
}
else if (uMsg == WM_WA_IPC)
{
if (lParam == DEFERREDCALLBACKMSG && DEFERREDCALLBACKMSG > 65536)
{
if (wParam == 1)
{
setDialogBoxesParent();
return 1;
}
else if (wParam == 2)
{
// embed the windows that are currently visible because at the time the window were originally shown,
// we hadn't been loaded yet
// but then again, we might if it's only a switch skin and not a app load, so let's check anyway
populateWindowsMenus();
doplaylistcolors();
if (plWnd == NULL && wa2.isWindowVisible(IPC_GETWND_PE))
if (!createPl()) wa2.setWindowVisible(IPC_GETWND_PE, 0);
#ifdef MINIBROWSER_SUPPORT
if (mbWnd == NULL && wa2.isWindowVisible(IPC_GETWND_MB))
if (!createMb()) wa2.setWindowVisible(IPC_GETWND_MB, 0);
#endif
if (vidWnd == NULL && wa2.isWindowVisible(IPC_GETWND_VIDEO))
if (!createVid()) wa2.setWindowVisible(IPC_GETWND_VIDEO, 0);
embedEnumStruct cs = { embedCreateProc, 0 };
SendMessageW(hwndDlg, WM_WA_IPC, (WPARAM)&cs, IPC_EMBED_ENUM);
for (int i = 0;i < SkinParser::getNumContainers();i++)
{
Container *cont = SkinParser::enumContainer(i);
if (!_wcsicmp(cont->getId(), L"main"))
{
for (int j = 0;j < cont->getNumLayouts();j++)
{
Layout *l = cont->enumLayout(j);
if (l && l->isVisible())
{
SetFocus(l->gethWnd());
break;
}
}
}
}
Crossfader::onOutputChanged();
extern int make_sure_library_is_here_at_startup;
if (make_sure_library_is_here_at_startup)
SendMessageW(wa2.getMainWindow(), WM_COMMAND, ID_FILE_SHOWLIBRARY, 0);
make_sure_library_is_here_at_startup = 0;
before_startup_callback = 0;
registerGlobalHotkeys();
// force a title update since it's not always correct
// if gen_ml hasn't loaded fully when we're loading
if (wa2.isPlaying())
g_Core->gotCallback(IPC_CB_MISC_TITLE, 2);
return 1;
}
}
else if (lParam == UPDATEDIALOGBOXPARENTMSG && UPDATEDIALOGBOXPARENTMSG > 65536)
{
wa2.updateDialogBoxParent((HWND)wParam);
}
else switch (lParam)
{
case IPC_GETSKININFO:
return (LRESULT)getSkinInfo();
case IPC_GETSKININFOW:
return (LRESULT)getSkinInfoW();
case IPC_SHOW_NOTIFICATION:
return SystemObject::onShowNotification();
case IPC_CB_VISRANDOM:
{
int v = wParam;
extern _bool visrandom;
if (!!v == !!visrandom.getValueAsInt()) break;
disable_send_visrandom = 1;
visrandom.setValueAsInt(v);
disable_send_visrandom = 0;
break;
}
case IPC_CB_OUTPUTCHANGED:
Crossfader::onOutputChanged();
break;
case IPC_CB_ONTOGGLEAOT:
{
if ((WPARAM)cfg_options_alwaysontop.getValueAsInt() != wParam)
cfg_options_alwaysontop.setValueAsInt(wParam);
break;
}
case IPC_SETIDEALVIDEOSIZE:
{
wa2.setIdealVideoSize(HIWORD(wParam), LOWORD(wParam));
break;
}
// this is where we detect that wa2 wants to open one of its windows (thru popup menu, button, whatever)
// when this happens, we create a freeform wndembedder if one doesn't already exist. that embedder will
// reparent and resize the wa2 window on its own. when we return, winamp then shows the HWND inside our frame
// as it would show the HWND as a popup normally.
case IPC_CB_ONSHOWWND:
switch (wParam)
{
case IPC_CB_WND_PE:
if (!createPl()) return 0;
break;
#ifdef MINIBROWSER_SUPPORT
case IPC_CB_WND_MB:
if (!createMb()) return 0;
break;
#endif
case IPC_CB_WND_VIDEO:
#ifdef VIDDEBUG
DebugString("Video : Got IPC_ONSHOW\n");
#endif
if (!createVid())
{
#ifdef VIDDEBUG
DebugString("Video : SHOW was cancelled by script\n");
#endif
return 0;
}
break;
default:
DebugStringW(L"embedWnd : Got IPC_ONSHOW\n");
if (IsWindow((HWND)wParam))
{
HWND hTarget = (HWND)wParam;
embedWindowState *ws = (embedWindowState*)GetWindowLongPtrW(hTarget, GWLP_USERDATA);
if (ws && ws->me == hTarget)
{
GUID thisguid = EmbedWndGuid(ws).getGuid();
if (INVALID_GUID == thisguid || NULL == updateEmb(thisguid, ws))
{
ifc_window *windowParent = createEmb(ws, true);
if (NULL != windowParent)
{
GuiObject *uiObject = windowParent->getGuiObject();
if (NULL != uiObject)
{
if (0 != (EMBED_FLAGS_FFCALLBACK & ws->flags) &&
NULL != ws->callback)
{
ws->callback(ws, FFC_CREATEEMBED, (LPARAM)windowParent);
}
Layout *layout = uiObject->guiobject_getParentLayout();
if (NULL != layout)
{
Container *container = layout->getParentContainer();
if (NULL != container) container->setVisible(1);
else layout->setVisible(1);
windowParent->setVisible(1);
}
}
}
return (NULL != windowParent);
}
}
}
break;
}
break;
// here we do the reverse, we detect that wa2 wants to close one of its windows, so we destroy our window
// embedder (it will reparent the wa2 window back to its former parent and resize it back to where it was
// on its own). when we return, winamp then hides the window.
// NOTE! because of this, there might be a split second where the window is seen on the screen as a popup
// after you closed the window (this won't happen for static containers [ie: pledit/video in mmd3] since
// they are hidden rather than destroyed). this can be fixed in the future
case IPC_CB_ONHIDEWND:
switch (wParam)
{
case IPC_CB_WND_PE:
destroyPl(hwndDlg, uMsg, wParam, lParam);
break;
#ifdef MINIBROWSER_SUPPORT
case IPC_CB_WND_MB:
return destroyMb(hwndDlg, uMsg, wParam, lParam);
#endif
case IPC_CB_WND_VIDEO:
#ifdef VIDDEBUG
DebugString("Video : Got IPC_ONHIDE\n");
#endif
return destroyVid(hwndDlg, uMsg, wParam, lParam);
default:
DebugStringW(L"embedWnd : Got IPC_ONHIDE\n");
if (IsWindow((HWND)wParam))
{
HWND h = (HWND)wParam;
embedWindowState *ws = (embedWindowState *)GetWindowLongPtrW(h, GWLP_USERDATA);
if (ws) return destroyEmb(hwndDlg, uMsg, wParam, lParam, ws);
}
break;
}
break;
case IPC_FF_ISMAINWND:
{
for (int i = 0;i < SkinParser::getNumContainers();i++)
{
Container *cont = SkinParser::enumContainer(i);
if (!_wcsicmp(cont->getId(), L"main"))
{
for (int j = 0;j < cont->getNumLayouts();j++)
{
if (cont->enumLayout(j)->gethWnd() == (HWND)wParam) return 1;
}
break;
}
}
return 0;
}
case IPC_FF_GETCONTENTWND:
return (LRESULT)ff_ipc_getContentWnd((HWND)wParam);
case IPC_FF_GETSKINCOLOR:
ff_ipc_getSkinColor((ff_skincolor*)wParam);
return 1;
case IPC_FF_GENSKINBITMAP:
ff_ipc_genSkinBitmap((ff_skinbitmap*)wParam);
return 1;
case IPC_FF_NOTIFYHOTKEY:
if (processGenericHotkey((const char *)wParam)) return 0; // prevent gen_hotkey from processing the hotkey
return 1; // let gen_hotkey process the hotkey
case IPC_GET_GENSKINBITMAP:
if (m_are_we_loaded)
{
if (wParam == 0)
{
if (m_lastskin_dir[0])
{
HBITMAP bm;
wchar_t bitmapfilename[MAX_PATH] = {0};
PathCombineW(bitmapfilename, m_lastskin_dir, L"genex.bmp");
bm = (HBITMAP)LoadImageW(NULL, bitmapfilename, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_LOADFROMFILE);
if (bm) return (LRESULT)bm;
}
return (LRESULT)ff_genwa2skinbitmap();
}
else if (wParam == 4)
{
// TODO need to make sure we're covering everything needed for all of this!!
int buf[6] = {0};
// active text
if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.list.text.current"))
buf[1] = SkinColor(L"wasabi.list.text.current");
/*else
{
COLORREF act = Blenders::BLEND_AVG(selected, buf[0]);
act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(buf[2], 0xFFFFFFFF) : act;
act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(buf[2], 0xFF101010) : act;
act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(selected, buf[0]) : act;
act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(selected, buf[2]) : act;
act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(buf[0], buf[2]) : act;
buf[1] = act & 0xFFFFFF;
}*/
return buf[1];
}
}
break;
case IPC_FF_ONCOLORTHEMECHANGED:
{
embedEnumStruct cs = { embedUpdateColorProc, 0 };
SendMessageW(hwndDlg, WM_WA_IPC, (WPARAM)&cs, IPC_EMBED_ENUM);
if (wParam != 0xf00d) doplaylistcolors();
}
break;
case IPC_PLAYLIST_MODIFIED:
{
Wa2PlaylistEditor::_onPlaylistModified();
}
break;
}
}
else if (uMsg == WM_COMMAND && (LOWORD(wParam) == 40144 || LOWORD(wParam) == 40148))
{
// seek left/right, we need to disable them if we are in a menu, because this is a
// plugin (ie: milkdrop) sending us the command manually as a forward rather than
// sending us the WM_KEY* directly
if (WASABI_API_WND->isKeyboardLocked()) return 0;
}
else if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) >= 43000 && LOWORD(wParam) < ffwindowstop)
{
int id = LOWORD(wParam) - 43000;
int n = SkinParser::getNumContainers();
if (id < n)
{
Container *cont = SkinParser::enumContainer(id);
if (cont) cont->toggle();
return 1;
}
id -= n;
n = WASABI_API_WNDMGR->autopopup_getNumGuids();
if (id < n)
{
GUID guid = WASABI_API_WNDMGR->autopopup_enumGuid(id);
if (guid != INVALID_GUID)
WASABI_API_WNDMGR->skinwnd_toggleByGuid(guid);
return 1;
}
id -= n;
n = WASABI_API_WNDMGR->autopopup_getNumGroups();
if (id < n)
{
const wchar_t *gid = WASABI_API_WNDMGR->autopopup_enumGroup(id);
if (gid && *gid)
WASABI_API_WNDMGR->skinwnd_toggleByGroupId(gid);
return 1;
}
/* for (int c=0;c<SkinParser::getNumContainers();c++) {
Container *cont = SkinParser::enumContainer(c);
if (cont && wantContainerInMenu(cont)) {
if (cont->getName() == NULL) continue;
if (id == 0) {
if (cont)
cont->toggle();
return 1;
}
id--;
}
}
int n = WASABI_API_WNDMGR->autopopup_getNumGuids();
for (c=0;c<n;c++) {
GUID guid = WASABI_API_WNDMGR->autopopup_enumGuid(c);
const char *groupdesc = WASABI_API_WNDMGR->autopopup_enumGuidDescription(c);
if (guid != INVALID_GUID && groupdesc && *groupdesc) {
if (id == 0) {
WASABI_API_WNDMGR->skinwnd_toggleByGuid(guid);
return 1;
}
id--;
}
}
n = WASABI_API_WNDMGR->autopopup_getNumGroups();
for (c=0;c<n;c++) {
const char *gid = WASABI_API_WNDMGR->autopopup_enumGroup(c);
const char *groupdesc = WASABI_API_WNDMGR->autopopup_enumGroupDescription(c);
if (id && groupdesc && *gid && *groupdesc) {
if (id == 0) {
WASABI_API_WNDMGR->skinwnd_toggleByGroupId(gid);
return 1;
}
id--;
}
}*/
return 0;
}
else if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) >= 44000 && LOWORD(wParam) < ffoptionstop)
{
int id = LOWORD(wParam);
MenuActions::toggleOption(id - 44000);
}
else if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) >= 44500 && LOWORD(wParam) < 45000)
{
int id = LOWORD(wParam) - 44500;
WASABI_API_SKIN->colortheme_setColorSet(WASABI_API_SKIN->colortheme_enumColorSet(id));
}
else if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) >= 42000 && LOWORD(wParam) < ffwoptionstop)
{
int id = LOWORD(wParam);
MenuActions::toggleWindowOption(id - 42000);
}
else if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) == WINAMP_MAIN_WINDOW)
{
for (int i = 0;i < SkinParser::getNumContainers();i++)
{
Container *cont = SkinParser::enumContainer(i);
if (!_wcsicmp(cont->getId(), L"main"))
{
cont->toggle();
return 1;
}
}
}
else if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) == WINAMP_OPTIONS_EQ)
{
if (!gothrueqmsg)
return 0;
}
else if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND))
{
switch (LOWORD(wParam))
{
case ID_CONTROLMENU_OPACITY_10: controlOpacity(10); return 0;
case ID_CONTROLMENU_OPACITY_20: controlOpacity(20); return 0;
case ID_CONTROLMENU_OPACITY_30: controlOpacity(30); return 0;
case ID_CONTROLMENU_OPACITY_40: controlOpacity(40); return 0;
case ID_CONTROLMENU_OPACITY_50: controlOpacity(50); return 0;
case ID_CONTROLMENU_OPACITY_60: controlOpacity(60); return 0;
case ID_CONTROLMENU_OPACITY_70: controlOpacity(70); return 0;
case ID_CONTROLMENU_OPACITY_80: controlOpacity(80); return 0;
case ID_CONTROLMENU_OPACITY_90: controlOpacity(90); return 0;
case ID_CONTROLMENU_OPACITY_100: controlOpacity(100); return 0;
case ID_CONTROLMENU_SCALING_50: controlScaling(0.5); return 0;
case ID_CONTROLMENU_SCALING_75: controlScaling(0.75); return 0;
case ID_CONTROLMENU_SCALING_100: controlScaling(1.0); return 0;
case ID_CONTROLMENU_SCALING_125: controlScaling(1.25); return 0;
case ID_CONTROLMENU_SCALING_150: controlScaling(1.5); return 0;
case ID_CONTROLMENU_SCALING_200: controlScaling(2.0); return 0;
case ID_CONTROLMENU_SCALING_250: controlScaling(2.5); return 0;
case ID_CONTROLMENU_SCALING_300: controlScaling(3.0); return 0;
case ID_CONTROLMENU_SCALING_LOCKED: lockScaling(1); return 0;
case ID_CONTROLMENU_SCALING_FOLLOWDOUBLESIZE: lockScaling(0); return 0;
case ID_CONTROLMENU_SCALING_CUSTOM: customScaling(); return 0;
case ID_CONTROLMENU_OPACITY_CUSTOM: customOpacity(); return 0;
case ID_CONTROLMENU_OPACITY_AUTO100_HOVER: autoOpacifyHover(); return 0;
case ID_CONTROLMENU_OPACITY_AUTO100_FOCUS: autoOpacifyFocus(); return 0;
case SC_MOVE:
{
Layout *l = SkinParser::getMainLayout();
if (l != NULL)
{
Container *c = l->getParentContainer();
if (c)
{
Layout *ll = c->getCurrentLayout();
if (ll) l = ll;
if (l)
{
if (!l->isVisible()) l->setVisible(1);
return SendMessageW(l->gethWnd(), WM_SYSCOMMAND, wParam, lParam);
}
}
}
break;
}
case ID_CONTROLMENU_TOOLBAR_DISABLED: controlAppBar(APPBAR_NOTDOCKED); break;
case ID_CONTROLMENU_TOOLBAR_TOP: controlAppBar(APPBAR_TOP); break;
case ID_CONTROLMENU_TOOLBAR_LEFT: controlAppBar(APPBAR_LEFT); break;
case ID_CONTROLMENU_TOOLBAR_RIGHT: controlAppBar(APPBAR_RIGHT); break;
case ID_CONTROLMENU_TOOLBAR_BOTTOM: controlAppBar(APPBAR_BOTTOM); break;
case ID_CONTROLMENU_TOOLBAR_ALWAYSONTOP: controlAppBarAOT(); break;
case ID_CONTROLMENU_TOOLBAR_AUTOHIDE: controlAppBarAH(); break;
case ID_CONTROLMENU_TOOLBAR_AUTODOCKONDRAG: cfg_options_appbarondrag = !cfg_options_appbarondrag; break;
}
}
}
return CallWinampWndProc(hwndDlg, uMsg, wParam, lParam);
}
void onLayoutChanged()
{
if (DEFERREDCALLBACKMSG > 65536)
PostMessage(wa2.getMainWindow(), WM_WA_IPC, 1, DEFERREDCALLBACKMSG);
}
#ifdef DEBUG_CAPTURES
int tid = 0;
VOID TimerProc(HWND hwnd, UINT uMsg, UINT idEvent, DWORD time)
{
DebugString("Capture belongs to %x (foregroundwnd = %x)\n", GetCapture(), GetForegroundWindow());
}
#endif
template <class api_T>
static void ServiceBuild(api_T *&api_t, GUID factoryGUID_t)
{
if (WASABI_API_SVC)
{
waServiceFactory *factory = WASABI_API_SVC->service_getServiceByGuid(factoryGUID_t);
if (factory)
api_t = reinterpret_cast<api_T *>( factory->getInterface() );
}
}
template <class api_T>
static void ServiceRelease(api_T *api_t, GUID factoryGUID_t)
{
if (WASABI_API_SVC && api_t)
{
waServiceFactory *factory = WASABI_API_SVC->service_getServiceByGuid(factoryGUID_t);
if (factory)
factory->releaseInterface(api_t);
}
api_t = NULL;
}
//-----------------------------------------------------------------------------------------------
// initializes freeform library
//-----------------------------------------------------------------------------------------------
int m_loaded_at_all = 0;
StringW g_resourcepath;
void initFFApi()
{
if ( !m_loaded_at_all )
{
m_loaded_at_all = 1;
api_service *svc = (api_service *)SendMessageW( wa2.getMainWindow(), WM_WA_IPC, 0, IPC_GET_API_SERVICE );
ServiceBuild( AGAVE_API_PLAYLISTS, api_playlistsGUID );
ServiceBuild( AGAVE_API_ALBUMART, albumArtGUID );
ServiceBuild( AGAVE_API_PLAYLISTMANAGER, api_playlistmanagerGUID );
ServiceBuild( WAC_API_DOWNLOADMANAGER, DownloadManagerGUID );
ServiceBuild( WASABI_API_COLORTHEMES, ColorThemesAPIGUID );
ServiceBuild( WASABI_API_PALETTE, PaletteManagerGUID );
ServiceBuild( WASABI_API_THREADPOOL, ThreadPoolGUID );
ApiInit::init( hInstance, wa2.getMainWindow(), svc );
cfgitems = new Wa2CfgItems();
#ifdef DEBUG_CAPTURES
tid = SetTimer( NULL, 0x159, 50, (TIMERPROC)TimerProc );
#endif
wchar_t filename[ WA_MAX_PATH ] = { 0 };
GetModuleFileNameW( hInstance, filename, WA_MAX_PATH );
PathParserW pp( filename );
StringW path;
for ( int i = 0; i < pp.getNumStrings() - 1; i++ )
{
path.AppendPath( pp.enumString( i ) );
}
path.AppendPath( L"freeform" );
path.AppendFolder( L"wacs" );
// we can load a somewhat restricted version of the wac format
ComponentManager::loadAll( path );
ComponentManager::postLoad();
ApiInit::widgets->loadResources();
startFSMonitor();
}
cfg_options_alwaysontop.setValueAsInt( wa2.isOnTop() );
}
//-----------------------------------------------------------------------------------------------
// shutdown ff lib
//-----------------------------------------------------------------------------------------------
void shutdownFFApi()
{
if (m_loaded_at_all)
{
ServiceRelease( AGAVE_API_PLAYLISTS, api_playlistsGUID);
ServiceRelease( AGAVE_API_ALBUMART, albumArtGUID);
ServiceRelease( AGAVE_API_PLAYLISTMANAGER, api_playlistmanagerGUID);
ServiceRelease( WAC_API_DOWNLOADMANAGER, DownloadManagerGUID);
ServiceRelease( WASABI_API_COLORTHEMES, ColorThemesAPIGUID);
ServiceRelease( WASABI_API_PALETTE, PaletteManagerGUID);
ServiceRelease( WASABI_API_THREADPOOL, ThreadPoolGUID);
stopFSMonitor();
// shutdown the library
#ifdef DEBUG_CAPTURES
KillTimer(NULL, tid);
#endif
delete cfgitems; cfgitems = NULL;
ApiInit::shutdown();
ComponentManager::unloadAll();
m_loaded_at_all = 0;
}
}
static void MakeControlMenu()
{
if (controlmenu)
return ;
controlmenu = WASABI_API_LOADMENU(IDR_CONTROLMENU);
if (!Wasabi::Std::Wnd::isDesktopAlphaAvailable())
EnableMenuItem(controlmenu, 0, MF_BYPOSITION | MF_GRAYED);
}
//-----------------------------------------------------------------------------------------------
// go freeform
//-----------------------------------------------------------------------------------------------
void init_inst()
{
if ( m_are_we_loaded )
return;
// set the classic main window to be transparent
// so we can move it around the screen to allow
// certain Windows 8 modes as well as improving
// where it is placed for some multi-mon setups
Wasabi::Std::Wnd::setLayeredWnd( wa2.getMainWindow(), 1 );
Wasabi::Std::Wnd::setLayeredAlpha( wa2.getMainWindow(), 0 );
initEgg();
wa2.setDrawBorders( 0 );
wa2.disableSkinnedCursors( 1 );
int wasminimized = IsIconic( wa2.getMainWindow() );
if ( wasminimized )
ShowWindow( wa2.getMainWindow(), SW_RESTORE );
MakeControlMenu();
going_freeform = 1;
Wa2WndEmbed::rememberVisibleWindows();
if ( wa2.isWindowVisible( IPC_GETWND_PE ) )
{
if ( !m_loading_at_startup ) WritePrivateProfileStringW( L"gen_ff", L"classicpe", L"1", INI_FILE );
}
else
if ( !m_loading_at_startup ) WritePrivateProfileStringW( L"gen_ff", L"classicpe", L"0", INI_FILE );
if ( wa2.isWindowVisible( IPC_GETWND_EQ ) )
{
gothrueqmsg = 1;
SendMessageW( plugin.hwndParent, WM_COMMAND, WINAMP_OPTIONS_EQ, 0 );
gothrueqmsg = 0;
if ( !m_loading_at_startup ) WritePrivateProfileStringW( L"gen_ff", L"classiceq", L"1", INI_FILE );
}
else
if ( !m_loading_at_startup ) WritePrivateProfileStringW( L"gen_ff", L"classiceq", L"0", INI_FILE );
removeEq();
if ( SendMessageW( plugin.hwndParent, WM_WA_IPC, 0, IPC_ISMAINWNDVISIBLE ) )
{
SendMessageW( plugin.hwndParent, WM_COMMAND, WINAMP_MAIN_WINDOW, 0 );
if ( !m_loading_at_startup ) WritePrivateProfileStringW( L"gen_ff", L"classicmw", L"1", INI_FILE );
}
else
if ( !m_loading_at_startup ) WritePrivateProfileStringW( L"gen_ff", L"classicmw", L"0", INI_FILE );
m_are_we_loaded = 1;
initFFApi();
// redirect drag and drop to winamp2 by default
WASABI_API_WND->setDefaultDropTarget( (void *)wa2.getDropTarget() );
// this installs a bunch of predefined groups to map wa3 to wa2 functionnality
groups = new Wa2Groupdefs();
// now load a skin ! the path to the skin is extracted and temporarilly becomes the official skins directory
StringW skinname = m_lastskin_nam;
removeSkinExtension( skinname );
before_startup_callback = 1;
WASABI_API_SKIN->skin_switchSkin( skinname, m_lastskin_dir );
/* // if we wanted to have drag&drop support for just the main window, we'd do it this way :-)
Container *maincontainer = SkinParser::getContainer("main");
if (maincontainer != NULL) {
for (int i=0;i<maincontainer->getNumLayouts();i++) {
Layout *layout = maincontainer->enumLayout(i);
if (layout != NULL) {
layout->setDropTarget((void *)wa2.getDropTarget());
}
}
}*/
// send event for dialog parent
onLayoutChanged();
if ( wa2.export_sa_setreq )
wa2.export_sa_setreq( 1 );
shuffle.setValueAsInt( wa2.getShuffle() );
int rep = wa2.getRepeat();
int manadv = wa2.getManualPlaylistAdvance();
disable_set_wa2_repeat = 1;
repeat.setValueAsInt( ( rep && manadv ) ? -1 : rep );
disable_set_wa2_repeat = 0;
if ( DEFERREDCALLBACKMSG > 65536 )
PostMessage( wa2.getMainWindow(), WM_WA_IPC, 2, DEFERREDCALLBACKMSG );
// so if some embedwindows are already visible, they update their look
PostMessage( wa2.getMainWindow(), WM_WA_IPC, 0xf00d, IPC_FF_ONCOLORTHEMECHANGED );
// monitor color theme
colorThemeMonitor = new ColorThemeMonitor();
syncDoubleSize( 1 );
syncDisplayMode();
going_freeform = 0;
if ( wa2.getWnd( IPC_GETWND_VIDEO ) )
{
oldVideoWnd = wa2.getWnd( IPC_GETWND_VIDEO );
if ( !oldVideoWndProc )
oldVideoWndProc = (WNDPROC)SetWindowLongPtrW( oldVideoWnd, GWLP_WNDPROC, (LONG_PTR)newVideoWndProc );
}
if ( wasminimized )
ShowWindow( wa2.getMainWindow(), SW_MINIMIZE );
if ( eggstat )
SetTimer( wa2.getMainWindow(), UPDATE_EGG, 25, NULL );
}
void quit_inst()
{
if (!m_are_we_loaded) return ;
KillTimer(wa2.getMainWindow(), UPDATE_EGG);
wa2.setDrawBorders(1);
wa2.disableSkinnedCursors(0);
KillTimer(wa2.getMainWindow(), 0xC0DE);
KillTimer(wa2.getMainWindow(), 0xC0DE + 1);
EnableMenuItem(wa2.getMenuBarMenu(Winamp2FrontEnd::WA2_MAINMENUBAR_OPTIONS), WINAMP_OPTIONS_DSIZE, MF_ENABLED);
EnableMenuItem(GetSubMenu(wa2.getPopupMenu(), 11 + wa2.adjustOptionsPopupMenu(0)), WINAMP_OPTIONS_DSIZE, MF_ENABLED);
if (oldVideoWnd && oldVideoWndProc)
SetWindowLongPtrW(oldVideoWnd, GWLP_WNDPROC, (LONG_PTR)oldVideoWndProc);
oldVideoWndProc = 0;
oldVideoWnd = 0;
removeWindowOptionsFromContextMenu();
delete mainLayoutMonitor;
mainLayoutMonitor=0;
wa2.setDialogBoxParent(NULL);
unpopulateWindowsMenus();
restoreEq();
// unload the skin -- skinspath is restored to default
WASABI_API_SKIN->skin_unloadSkin();
// delete predefined groups service
delete groups; groups = NULL;
// delete options
delete ffoptions; ffoptions = NULL;
// stop monitoring color theme
delete colorThemeMonitor; colorThemeMonitor = NULL;
if (wa2.export_sa_setreq) wa2.export_sa_setreq(0);
m_are_we_loaded = 0;
int classicmw = GetPrivateProfileIntW(L"gen_ff", L"classicmw", 1, INI_FILE);
if (classicmw && !SendMessageW(plugin.hwndParent, WM_WA_IPC, 0, IPC_ISMAINWNDVISIBLE))
SendMessageW(plugin.hwndParent, WM_COMMAND, WINAMP_MAIN_WINDOW, 0);
CheckMenuItem(wa2.getPopupMenu(), WINAMP_MAIN_WINDOW, classicmw ? MF_CHECKED : MF_UNCHECKED);
if (GetPrivateProfileIntW(L"gen_ff", L"classiceq", 1, INI_FILE) && !wa2.isWindowVisible(IPC_GETWND_EQ))
{
gothrueqmsg = 1;
SendMessageW(plugin.hwndParent, WM_COMMAND, WINAMP_OPTIONS_EQ, 0);
gothrueqmsg = 0;
}
if (GetPrivateProfileIntW(L"gen_ff", L"classicpe", 1, INI_FILE) && !wa2.isWindowVisible(IPC_GETWND_PE))
{
SendMessageW(plugin.hwndParent, WM_COMMAND, WINAMP_OPTIONS_PLEDIT, 0);
}
// restore the classic main window to be solid
Wasabi::Std::Wnd::setLayeredWnd(wa2.getMainWindow(), 0);
}
//-----------------------------------------------------------------------------------------------
// init (from Winamp2)
//-----------------------------------------------------------------------------------------------
int init()
{
// loader so that we can get the localisation service api for use
WASABI_API_SVC = (api_service*) SendMessageW(plugin.hwndParent, WM_WA_IPC, 0, IPC_GET_API_SERVICE);
if (WASABI_API_SVC == (api_service*)1) WASABI_API_SVC = NULL;
if (!WASABI_API_SVC || WASABI_API_SVC == (api_service *)1)
return GEN_INIT_FAILURE;
static wchar_t modskin[128];
INI_FILE = (wchar_t*) SendMessageW(plugin.hwndParent, WM_WA_IPC, 0, IPC_GETINIFILEW);
INI_DIR = (wchar_t*) SendMessageW(plugin.hwndParent, WM_WA_IPC, 0, IPC_GETINIDIRECTORYW);
waServiceFactory *sf = WASABI_API_SVC->service_getServiceByGuid(languageApiGUID);
if (sf) WASABI_API_LNG = reinterpret_cast<api_language*>(sf->getInterface());
// need to have this initialised before we try to do anything with localisation features
WASABI_API_START_LANG(plugin.hDllInstance,GenFFLangGUID);
swprintf(szDescription, ARRAYSIZE(szDescription),
WASABI_API_LNGSTRINGW(IDS_NULLSOFT_MODERN_SKINS), VERSION);
plugin.description = (char*)szDescription;
wa2.init(plugin.hwndParent);
DEFERREDCALLBACKMSG = SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)"gen_ff_deferred", IPC_REGISTER_WINAMP_IPCMESSAGE);
UPDATEDIALOGBOXPARENTMSG = SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)"gen_ff_update", IPC_REGISTER_WINAMP_IPCMESSAGE);
// subclass the Winamp2 main window to receive our callbacks
wa_oldWndProc = (WNDPROC) SetWindowLongPtrW(wa2.getMainWindow(), GWLP_WNDPROC, (LONG_PTR)wa_newWndProc);
ffPrefsItem.dlgID = IDD_PREFS;
ffPrefsItem.name = WASABI_API_LNGSTRINGW_BUF(IDS_MODERN_SKINS,modskin,128);
ffPrefsItem.proc = (void*)ffPrefsProc;
ffPrefsItem.hInst = WASABI_API_LNG_HINST;
ffPrefsItem.where = 2; //skins subtreeitem
SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)&ffPrefsItem, IPC_ADD_PREFS_DLGW);
checkMlPresent();
m_loading_at_startup = 1;
onSkinSwitch();
m_loading_at_startup = 0;
return 0;
}
void RestoreClassicWinamp(int was_loaded)
{
// JF> my proposed fix to the problems :)
// investigating doing this from winamp.exe on startup, gotta figure it out
if (INI_FILE && was_loaded) // restore winamp.ini to about what it shoulda been
{
int classicpews = GetPrivateProfileIntW(L"gen_ff", L"classicplws", 0, INI_FILE);
int classicwidth = GetPrivateProfileIntW(L"gen_ff", L"classicplwidth", 275, INI_FILE);
int classicheight = GetPrivateProfileIntW(L"gen_ff", L"classicplheight", 145, INI_FILE);
int classicmw = GetPrivateProfileIntW(L"gen_ff", L"classicmw", 1, INI_FILE);
int classiceq = GetPrivateProfileIntW(L"gen_ff", L"classiceq", 1, INI_FILE);
wchar_t buf[64] = {0};
wsprintfW(buf, L"%d", classicheight);
if (classicpews)
{
WritePrivateProfileStringW(L"winamp", L"pe_height", L"14", INI_FILE);
WritePrivateProfileStringW(L"winamp", L"pe_height_ws", buf, INI_FILE);
}
else
{
WritePrivateProfileStringW(L"winamp", L"pe_height", buf, INI_FILE);
WritePrivateProfileStringW(L"winamp", L"pe_height_ws", L"", INI_FILE);
}
wsprintfW(buf, L"%d", classicwidth);
WritePrivateProfileStringW(L"winamp", L"pe_width", buf, INI_FILE);
WritePrivateProfileStringW(L"winamp", L"eq_open", classiceq ? L"1" : L"0", INI_FILE);
WritePrivateProfileStringW(L"winamp", L"mw_open", classicmw ? L"1" : L"0", INI_FILE);
}
}
//-----------------------------------------------------------------------------------------------
// quit (from Winamp 2)
//-----------------------------------------------------------------------------------------------
void quit()
{
int was_loaded = m_are_we_loaded;
quit_inst();
RestoreClassicWinamp(was_loaded);
// restore wa2's windowproc
//SetWindowLong(wa2.getMainWindow(), GWL_WNDPROC, (LONG)wa_oldWndProc);
shutdownFFApi();
}
//-----------------------------------------------------------------------------------------------
// About box wndproc
//-----------------------------------------------------------------------------------------------
ifc_window *about_group = NULL;
StringW oldrenderer;
BOOL CALLBACK aboutProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
oldrenderer = cfg_options_fontrenderer.getValue();
if (!WCSCASEEQLSAFE(cfg_options_fontrenderer.getValue(), L"FreeType"))
cfg_options_fontrenderer.setValue(L"FreeType");
about_group = WASABI_API_SKIN->group_create(L"wasabi.gen_ff.about");
about_group->setVirtual(0);
HWND w = GetDlgItem(hwndDlg, IDC_STATIC_GROUP);
about_group->setStartHidden(1);
about_group->init(WASABI_API_WND->main_getRootWnd(), 1);
SetWindowLong(about_group->gethWnd(), GWL_STYLE, GetWindowLong(about_group->gethWnd(), GWL_STYLE) | WS_CHILD);
SetParent(about_group->gethWnd(), w);
SetWindowLong(w, GWL_STYLE, GetWindowLong(w, GWL_STYLE) | WS_CLIPCHILDREN);
RECT r;
GetClientRect(w, &r);
about_group->resize(r.left + 1, r.top + 1, r.right - r.left - 2, r.bottom - r.top - 2);
about_group->setVisible(1);
C_Group g(about_group->getGuiObject()->guiobject_getScriptObject());
ScriptObject *ver = g.findObject(L"version");
if (ver)
{
C_Text t(ver);
t.setText(StringPrintfW(L". � 2003-2023 Winamp SA %s", VERSION));
}
ShowWindow(about_group->gethWnd(), SW_NORMAL);
return 1;
}
case WM_DESTROY:
WASABI_API_SKIN->group_destroy(about_group);
about_group = NULL;
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK: case IDCANCEL:
if (!WCSCASEEQLSAFE(cfg_options_fontrenderer.getValue(), oldrenderer))
cfg_options_fontrenderer.setValue(oldrenderer);
EndDialog(hwndDlg, 0);
return 0;
}
return 0;
}
return 0;
}
//-----------------------------------------------------------------------------------------------
// configure plugin (from Winamp 2)
//-----------------------------------------------------------------------------------------------
void config()
{
if (m_loaded_at_all)
{
StringW skin = WASABI_API_SKIN->getSkinName();
wchar_t _skName[64] = {0};
WASABI_API_LNGSTRINGW_BUF(IDS_NO_SKIN_LOADED_,_skName,64);
if ((!skin.iscaseequal(_skName)) || guiTree->getNumObject() > 0)
{
WASABI_API_DIALOGBOXW(IDD_ABOUT, wa2.getPreferencesWindow(), aboutProc);
return ;
}
}
MSGBOXPARAMSW msgbx = {sizeof(MSGBOXPARAMS),0};
msgbx.lpszText = WASABI_API_LNGSTRINGW(IDS_MODERN_SKIN_SUPPORT_CLASSIC);
msgbx.lpszCaption = szDescription;
msgbx.lpszIcon = MAKEINTRESOURCEW(102);
msgbx.hInstance = GetModuleHandle(0);
msgbx.dwStyle = MB_USERICON;
MessageBoxIndirectW(&msgbx);
}
//-----------------------------------------------------------------------------------------------
// expose the genpurp plugin interface to dll
//-----------------------------------------------------------------------------------------------
extern "C" __declspec(dllexport) winampGeneralPurposePlugin * winampGetGeneralPurposePlugin() { return &plugin; }
//-----------------------------------------------------------------------------------------------
// a window was right clicked where there was no custom context menu available, spawn Wa2's menu
//-----------------------------------------------------------------------------------------------
void appContextMenu(ifc_window *w)
{
if (!WASABI_API_WND->rootwndIsValid(w)) return ;
WASABI_API_WND->appdeactivation_setbypass(1);
SetCursor(LoadCursor(NULL, IDC_ARROW));
w->setFocus();
DWORD p = GetMessagePos();
int x = GET_X_LPARAM(p);
int y = GET_Y_LPARAM(p);
addWindowOptionsToContextMenu(w);
wa2.triggerPopupMenu(x, y);
WASABI_API_WND->appdeactivation_setbypass(0);
}
//-----------------------------------------------------------------------------------------------
void updateControlMenu(ifc_window *w)
{
int curalpha = 255;
double curratio = 1.;
int opacitysafe = 0;
int scalelocked = 0;
int auto100_hover = 0;
int auto100_focus = 0;
if (g_controlMenuTarget == NULL) return ;
if (w)
{
ifc_window *rootparent = g_controlMenuTarget->getDesktopParent();
if (rootparent && rootparent->getInterface(layoutGuid))
{
Layout *l = static_cast<Layout*>(rootparent);
opacitysafe = l->isTransparencySafe();
scalelocked = l->isScaleLocked();
curratio = w->getRenderRatio();
if (!cfg_uioptions_linkallalpha.getValueAsInt())
{
auto100_hover = l->getAutoOpacify() == 1;
auto100_focus = l->getAutoOpacify() == 2;
curalpha = l->getAlpha();
}
else
{
auto100_hover = l->getAlphaMgr()->getAutoOpacify() == 1;
auto100_focus = l->getAlphaMgr()->getAutoOpacify() == 2;
curalpha = l->getAlphaMgr()->getGlobalAlpha();
}
}
}
HMENU ctrlmenu = GetSubMenu(controlmenu, 0);
EnableMenuItem(ctrlmenu, 0, MF_BYPOSITION | (opacitysafe ? MF_ENABLED : MF_GRAYED));
HMENU scalemenu = GetSubMenu(ctrlmenu, 1);
HMENU alphamenu = GetSubMenu(ctrlmenu, 0);
int uselocks = cfg_uioptions_uselocks.getValueAsInt();
CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_LOCKED, MF_BYCOMMAND | ((scalelocked || !uselocks) ? MF_CHECKED : MF_UNCHECKED));
EnableMenuItem(scalemenu, ID_CONTROLMENU_SCALING_LOCKED, MF_BYCOMMAND | (uselocks ? MF_ENABLED : MF_GRAYED));
CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_FOLLOWDOUBLESIZE, MF_BYCOMMAND | (scalelocked || !uselocks ? MF_UNCHECKED : MF_CHECKED));
EnableMenuItem(scalemenu, ID_CONTROLMENU_SCALING_FOLLOWDOUBLESIZE, MF_BYCOMMAND | (uselocks ? MF_ENABLED : MF_GRAYED));
CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_AUTO100_HOVER, MF_BYCOMMAND | (auto100_hover ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_AUTO100_FOCUS, MF_BYCOMMAND | (auto100_focus ? MF_CHECKED : MF_UNCHECKED));
int v = (int)((curalpha / 255.0f * 100.0f) + 0.5f);
int u = (int)((curratio * 100.0f) + 0.5f);
CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_10, MF_BYCOMMAND | (v == 10 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_20, MF_BYCOMMAND | (v == 20 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_30, MF_BYCOMMAND | (v == 30 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_40, MF_BYCOMMAND | (v == 40 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_50, MF_BYCOMMAND | (v == 50 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_60, MF_BYCOMMAND | (v == 60 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_70, MF_BYCOMMAND | (v == 70 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_80, MF_BYCOMMAND | (v == 80 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_90, MF_BYCOMMAND | (v == 90 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_100, MF_BYCOMMAND | (v == 100 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_50, MF_BYCOMMAND | (u == 50 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_75, MF_BYCOMMAND | (u == 75 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_100, MF_BYCOMMAND | (u == 100 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_125, MF_BYCOMMAND | (u == 125 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_150, MF_BYCOMMAND | (u == 150 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_200, MF_BYCOMMAND | (u == 200 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_250, MF_BYCOMMAND | (u == 250 ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_300, MF_BYCOMMAND | (u == 300 ? MF_CHECKED : MF_UNCHECKED));
if (u != 50 && u != 75 && u != 100 && u != 125 && u != 150 && u != 200 && u != 250 && u != 300)
{
ModifyMenuW(scalemenu, ID_CONTROLMENU_SCALING_CUSTOM, MF_BYCOMMAND | MF_STRING, ID_CONTROLMENU_SCALING_CUSTOM, StringPrintfW(WASABI_API_LNGSTRINGW(IDS_CUSTOM_X_PERCENT), u));
CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_CUSTOM, MF_BYCOMMAND | MF_CHECKED);
}
else
{
ModifyMenuW(scalemenu, ID_CONTROLMENU_SCALING_CUSTOM, MF_BYCOMMAND | MF_STRING, ID_CONTROLMENU_SCALING_CUSTOM, WASABI_API_LNGSTRINGW(IDS_CUSTOM));
CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_CUSTOM, MF_BYCOMMAND | MF_UNCHECKED);
}
if (((float)v / 10.0) - (v / 10) != 0.0)
{
ModifyMenuW(alphamenu, ID_CONTROLMENU_OPACITY_CUSTOM, MF_BYCOMMAND | MF_STRING, ID_CONTROLMENU_OPACITY_CUSTOM, StringPrintfW(WASABI_API_LNGSTRINGW(IDS_CUSTOM_X_PERCENT), v));
CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_CUSTOM, MF_BYCOMMAND | MF_CHECKED);
}
else
{
ModifyMenuW(alphamenu, ID_CONTROLMENU_OPACITY_CUSTOM, MF_BYCOMMAND | MF_STRING, ID_CONTROLMENU_OPACITY_CUSTOM, WASABI_API_LNGSTRINGW(IDS_CUSTOM));
CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_CUSTOM, MF_BYCOMMAND | MF_UNCHECKED);
}
}
//-----------------------------------------------------------------------------------------------
// a window has triggered the control menu (control scale & alpha)
//-----------------------------------------------------------------------------------------------
void appControlMenu(ifc_window *w)
{
WASABI_API_WND->appdeactivation_setbypass(1);
int x, y;
if (w)
{
Wasabi::Std::getMousePos(&x, &y);
g_controlMenuTarget = w;
updateControlMenu(w);
updateAppBarMenu(w);
HMENU ctrlmenu = GetSubMenu(controlmenu, 0);
DoTrackPopup(ctrlmenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_LEFTBUTTON, x, y, wa2.getMainWindow());
}
WASABI_API_WND->appdeactivation_setbypass(0);
}
//-----------------------------------------------------------------------------------------------
// a close application button was clicked
//-----------------------------------------------------------------------------------------------
void appQuit()
{
if (!wa2.isExitEnabled()) return ;
wa2.quit(); // this is in fact *posting* a quit message
}
//-----------------------------------------------------------------------------------------------
// a fatal skin error occured, we should revert to the wa2 skin (deferred)
//-----------------------------------------------------------------------------------------------
#define DCB_UNLOADSKIN 64
class deferredUnloadSkin : public TimerClientDI
{
public:
deferredUnloadSkin()
{
timerclient_postDeferredCallback(DCB_UNLOADSKIN, 0);
}
virtual int timerclient_onDeferredCallback(intptr_t param1, intptr_t param2)
{
if (param1 == DCB_UNLOADSKIN)
{
quit_inst();
delete this;
return 1;
}
else return TimerClientDI::timerclient_onDeferredCallback(param1, param2);
}
};
//-----------------------------------------------------------------------------------------------
// this is the actual event for skin fata errors, it is called when a try/except block failed
// upon calling a skin operation which should not be able to fail (ie: calling a script function pointer)
//-----------------------------------------------------------------------------------------------
void onFatalSkinError()
{
new deferredUnloadSkin();
}
//-----------------------------------------------------------------------------------------------
// map a GUID to the toggling of a window for which there is no permanent wndCreationService,
// ie: library, prefs, avs
//-----------------------------------------------------------------------------------------------
// called by a skinwnd_toggle call when the guid isn't found in the wndcreation services
int onCreateExternalWindowGuid(GUID g)
{
if (g == library_guid)
{
SendMessageW(wa2.getMainWindow(), WM_COMMAND, ID_FILE_SHOWLIBRARY, 0);
return 1;
}
else if (g == preferences_guid)
{
SendMessageW(wa2.getMainWindow(), WM_COMMAND, WINAMP_OPTIONS_PREFS, 0);
return 1;
}
else if (g == about_guid)
{
SendMessageW(wa2.getMainWindow(), WM_COMMAND, WINAMP_HELP_ABOUT, 0);
return 1;
}
else if (g == lightning_bolt_guid)
{
SendMessageW(wa2.getMainWindow(), WM_COMMAND, WINAMP_LIGHTNING_CLICK, 0);
return 1;
}
else if (g == colorthemes_guid)
{
last_page.setData(L"3");
SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)&ffPrefsItem, IPC_OPENPREFSTOPAGE);
return 1;
}
else if (g == avs_guid)
{
if (wa2.isVisRunning())
{
SetTimer(wa2.getMainWindow(), 0xC0DE, 50, NULL);
SetTimer(wa2.getMainWindow(), 0xC0DE + 1, 5000, NULL);
}
else
wa2.toggleVis();
return 1;
}
return 0;
}
//-----------------------------------------------------------------------------------------------
void onToggleDesktopAlpha(int v)
{
if (!toggle_from_wa2 && subWndId == 0 && IsWindow(subWnd)) SendMessageW(subWnd, WM_INITDIALOG, 0, 0);
}
//-----------------------------------------------------------------------------------------------
// changes the name of a container so that static containers with the wrong name don't load the config
// values off the wrong name. this should match the WindowText of the embededwindow. note: this is only
// necessary for static containers holding an internal embedwnd (ie: library, avs, but not third party wnds
// as they can't be refered to by GUID anyway [if they can't be refered to by GUID, you can't make a static
// container for them])
//-----------------------------------------------------------------------------------------------
const wchar_t *onTweakContainerNameW(const wchar_t *name)
{
static wchar_t tweaked[96];
ZERO(tweaked);
if (!_wcsicmp(name, WASABI_API_LNG->GetStringFromGUIDW(GenMlLangGUID, plugin.hDllInstance, 18, tweaked, sizeof(tweaked)/sizeof(wchar_t))) ||
!_wcsicmp(name, L"Media Library") ||
!_wcsicmp(name, L"Winamp Library") ||
!_wcsicmp(name, L"Library"))
{
return WASABI_API_LNGSTRINGW_BUF(IDS_MEDIA_LIBRARY,tweaked, sizeof(tweaked)/sizeof(wchar_t));
}
if (!_wcsicmp(name, L"Avs")) return WASABI_API_LNGSTRINGW_BUF(IDS_VISUALIZATIONS,tweaked, sizeof(tweaked)/sizeof(wchar_t));
return name;
}
const wchar_t *GetMenuItemString(HMENU menu, int id, int bypos)
{
static StringW rtn;
rtn.trunc(0);
MENUITEMINFOW info = {sizeof(info), MIIM_DATA | MIIM_TYPE | MIIM_STATE | MIIM_ID, MFT_STRING, };
GetMenuItemInfoW(menu, id, bypos, &info);
if (info.cch > 0)
{
info.dwTypeData = WMALLOC(++info.cch + 1);
GetMenuItemInfoW(menu, id, bypos, &info);
info.dwTypeData[info.cch] = 0;
rtn = info.dwTypeData;
FREE(info.dwTypeData);
}
return rtn;
}
StringW eqmenustring;
//-----------------------------------------------------------------------------------------------
void removeEq()
{
if (eqremoved) return ;
eqremoved = 1;
eqmenustring = GetMenuItemString(wa2.getPopupMenu(), WINAMP_OPTIONS_EQ, FALSE);
RemoveMenu(wa2.getPopupMenu(), WINAMP_OPTIONS_EQ, MF_BYCOMMAND);
wa2.adjustOptionsPopupMenu(-1);
}
//-----------------------------------------------------------------------------------------------
void restoreEq()
{
if (!eqremoved) return ;
MENUITEMINFOW i = {sizeof(i), MIIM_ID | MIIM_STATE | MIIM_TYPE, MFT_STRING, wa2.isWindowVisible(IPC_GETWND_EQ) ? MFS_CHECKED : 0, WINAMP_OPTIONS_EQ};
i.dwTypeData = eqmenustring.getNonConstVal();
InsertMenuItemW(wa2.getPopupMenu(), 8, TRUE, &i);
wa2.adjustOptionsPopupMenu(1);
eqremoved = 0;
}
//-----------------------------------------------------------------------------------------------
void unpopulateWindowsMenus()
{
if (ffwindowsitempos == -1) return ;
HMENU menuBarMenu = wa2.getMenuBarMenu(Winamp2FrontEnd::WA2_MAINMENUBAR_WINDOWS);
for(int i = GetMenuItemCount(menuBarMenu)-1; i >= 0; i--)
{
MENUITEMINFOW info = {sizeof(info), MIIM_DATA, 0, };
if(GetMenuItemInfoW(menuBarMenu,i,TRUE,&info))
{
if(info.dwItemData == 0xD01){
RemoveMenu(menuBarMenu,i,MF_BYPOSITION);
wa2.adjustFFWindowsMenu(-1);
}
}
}
HMENU menuPopupMenu = wa2.getPopupMenu();
for(int i = GetMenuItemCount(menuPopupMenu)-1; i >= 0; i--)
{
MENUITEMINFOW info = {sizeof(info), MIIM_DATA, 0, };
if(GetMenuItemInfoW(menuPopupMenu,i,TRUE,&info))
{
if(info.dwItemData == 0xD01){
RemoveMenu(menuPopupMenu,i,MF_BYPOSITION);
wa2.adjustOptionsPopupMenu(-1);
}
}
}
ffwindowsitempos = -1;
ffwindowsitempos2 = -1;
MenuActions::removeSkinWindowOptions();
MenuActions::removeSkinOptions();
}
//-----------------------------------------------------------------------------------------------
void populateWindowsMenus()
{
if (ffwindowsitempos != -1) unpopulateWindowsMenus();
MenuActions::installSkinOptions();
MenuActions::installSkinWindowOptions();
ffwindowsitempos = wa2.adjustFFWindowsMenu(0) + NUMSTATICWINDOWS;
ffwindowsitempos2 = wa2.adjustOptionsPopupMenu(0) + 6 + NUMSTATICWINDOWS + 1;
MENUITEMINFOW i = {sizeof(i), };
i.fMask = MIIM_TYPE | MIIM_DATA | MIIM_ID | MIIM_STATE;
i.fType = MFT_STRING;
i.wID = 43000;
i.dwItemData = 0xD01; // use this as a check so we're only removing the correct items!!
int pos = ffwindowsitempos;
int pos2 = ffwindowsitempos2;
PtrListQuickSorted<StringW, StringWComparator> items;
HMENU hMenu = wa2.getMenuBarMenu(Winamp2FrontEnd::WA2_MAINMENUBAR_WINDOWS);
HMENU hMenu2 = wa2.getPopupMenu();
for (int c = 0;c < SkinParser::getNumContainers();c++)
{
Container *cont = SkinParser::enumContainer(c);
if (cont && wantContainerInMenu(cont))
{
i.dwTypeData = const_cast<wchar_t *>(cont->getName());
if (i.dwTypeData != NULL)
{
if (!items.findItem(i.dwTypeData))
{
items.addItem(new StringW(i.dwTypeData));
i.cch = wcslen(i.dwTypeData);
i.fState = cont->isVisible() ? MFS_CHECKED : 0;
InsertMenuItemW(hMenu, pos++, TRUE, &i);
wa2.adjustFFWindowsMenu(1);
InsertMenuItemW(hMenu2, pos2++, TRUE, &i);
wa2.adjustOptionsPopupMenu(1);
}
}
}
i.wID++;
}
int n = WASABI_API_WNDMGR->autopopup_getNumGuids();
for (int c = 0;c < n;c++)
{
GUID guid = WASABI_API_WNDMGR->autopopup_enumGuid(c);
const wchar_t *groupdesc = WASABI_API_WNDMGR->autopopup_enumGuidDescription(c);
if (guid != INVALID_GUID && groupdesc && *groupdesc)
{
i.dwTypeData = const_cast<wchar_t *>(groupdesc);
if (!items.findItem(i.dwTypeData))
{
items.addItem(new StringW(i.dwTypeData));
i.cch = wcslen(i.dwTypeData);
i.fState = WASABI_API_WNDMGR->skinwnd_getNumByGuid(guid) ? MFS_CHECKED : 0;
InsertMenuItemW(hMenu, pos++, TRUE, &i);
wa2.adjustFFWindowsMenu(1);
InsertMenuItemW(hMenu2, pos2++, TRUE, &i);
wa2.adjustOptionsPopupMenu(1);
}
}
i.wID++;
}
n = WASABI_API_WNDMGR->autopopup_getNumGroups();
for (int c = 0;c < n;c++)
{
const wchar_t *id = WASABI_API_WNDMGR->autopopup_enumGroup(c);
const wchar_t *groupdesc = WASABI_API_WNDMGR->autopopup_enumGroupDescription(c);
if (id && groupdesc && *id && *groupdesc)
{
i.dwTypeData = const_cast<wchar_t *>(groupdesc);
// allow localisation of the color editor menu item
i.dwTypeData = const_cast<wchar_t *>(MenuActions::localizeSkinWindowName(i.dwTypeData));
if (!items.findItem(i.dwTypeData))
{
items.addItem(new StringW(i.dwTypeData));
i.cch = wcslen(i.dwTypeData);
i.fState = WASABI_API_WNDMGR->skinwnd_getNumByGroupId(id) ? MFS_CHECKED : 0;
InsertMenuItemW(hMenu, pos++, TRUE, &i);
wa2.adjustFFWindowsMenu(1);
InsertMenuItemW(hMenu2, pos2++, TRUE, &i);
wa2.adjustOptionsPopupMenu(1);
}
}
i.wID++;
}
items.deleteAll();
ffwindowstop = i.wID;
}
//-----------------------------------------------------------------------------------------------
void switchSkin(const wchar_t *skinname)
{
wa2.switchSkin(skinname);
}
//-----------------------------------------------------------------------------------------------
void addWindowOptionsToContextMenu(ifc_window *w)
{
if (g_controlMenuTarget != NULL)
removeWindowOptionsFromContextMenu();
if (w == NULL && WASABI_API_WND->rootwndIsValid(lastFocused))
w = lastFocused;
g_controlMenuTarget = w;
if (g_controlMenuTarget == NULL) return ;
/*int opacitysafe = 1;
int scalelocked = 0;
ifc_window *rootparent = g_controlMenuTarget->getDesktopParent();
if (rootparent && rootparent->getInterface(layoutGuid))
{
Layout *l = static_cast<Layout*>(rootparent);
opacitysafe = l->isTransparencySafe();
scalelocked = l->isScaleLocked();
}*/
updateControlMenu(w);
updateAppBarMenu(w);
HMENU menu = wa2.getPopupMenu();
HMENU ctrlmenu = GetSubMenu(controlmenu, 0);
// JF> Francis, made this use command IDs (inserts it right before the help ID in the main menu).
// does this look OK? if you want, revert back to the old one. I just thought this seemed a tiny
// bit cleaner... :)
#define ID_HELP_HELPTOPICS 40347
InsertMenuW(menu, ID_HELP_HELPTOPICS, MF_BYCOMMAND | MF_POPUP, (UINT_PTR)ctrlmenu, WASABI_API_LNGSTRINGW(IDS_WINDOW_SETTINGS));
InsertMenu(menu, ID_HELP_HELPTOPICS, MF_BYCOMMAND | MF_SEPARATOR, 0, NULL);
}
//-----------------------------------------------------------------------------------------------
void removeWindowOptionsFromContextMenu()
{
if (g_controlMenuTarget == NULL) return ;
g_controlMenuTarget = NULL;
HMENU menu = wa2.getPopupMenu();
HMENU ctrlmenu = GetSubMenu(controlmenu, 0);
if (ctrlmenu)
{
int l = GetMenuItemCount(menu);
while (l-- > 0 && GetSubMenu(menu, l) != ctrlmenu);
if (l >= 0)
{
RemoveMenu(menu, l, MF_BYPOSITION);
RemoveMenu(menu, l, MF_BYPOSITION); // remove sep
}
}
}
//-----------------------------------------------------------------------------------------------
void controlOpacity(int v)
{
if (!g_controlMenuTarget) return ;
if (!WASABI_API_WND->rootwndIsValid(g_controlMenuTarget)) return ;
v = (int)(((float)v / 100.0f) * 255.0f + 0.5f);
ifc_window *rootparent = g_controlMenuTarget->getDesktopParent();
if (rootparent && rootparent->getInterface(layoutGuid))
{
Layout *l = static_cast<Layout*>(rootparent);
if (!cfg_uioptions_linkallalpha.getValueAsInt())
{
l->setAlpha(v);
}
else
{
cfg_uioptions_linkedalpha.setValueAsInt(v);
}
}
}
//-----------------------------------------------------------------------------------------------
void controlScaling(double v)
{
if (!g_controlMenuTarget) return ;
if (!WASABI_API_WND->rootwndIsValid(g_controlMenuTarget)) return ;
ifc_window *rootparent = g_controlMenuTarget->getDesktopParent();
if (rootparent) rootparent->setRenderRatio(v);
}
//-----------------------------------------------------------------------------------------------
void lockScaling(int lock)
{
ifc_window *rootparent = g_controlMenuTarget->getDesktopParent();
if (!WASABI_API_WND->rootwndIsValid(g_controlMenuTarget)) return ;
if (rootparent && rootparent->getInterface(layoutGuid))
{
Layout *l = static_cast<Layout*>(rootparent);
l->lockScale(lock);
}
}
//-----------------------------------------------------------------------------------------------
void controlAppBar(int side)
{
ifc_window *rootparent = g_controlMenuTarget->getDesktopParent();
if (rootparent)
{
AppBar *ab = (AppBar *)rootparent->getInterface(appBarGuid);
if (ab)
{
ab->appbar_dock(side);
}
}
}
//-----------------------------------------------------------------------------------------------
void controlAppBarAOT()
{
ifc_window *rootparent = g_controlMenuTarget->getDesktopParent();
if (rootparent)
{
Layout *l = (Layout *)rootparent->getInterface(layoutGuid);
if (l)
{
int curaot = l->getAppBarAlwaysOnTop();
l->setAppBarAlwaysOnTop(!curaot);
}
}
}
//-----------------------------------------------------------------------------------------------
void controlAppBarAH()
{
ifc_window *rootparent = g_controlMenuTarget->getDesktopParent();
if (rootparent)
{
Layout *l = (Layout *)rootparent->getInterface(layoutGuid);
if (l)
{
int curah = l->getAppBarAutoHide();
l->setAppBarAutoHide(!curah);
}
}
}
//-----------------------------------------------------------------------------------------------
void updateAppBarMenu(ifc_window *w)
{
if (g_controlMenuTarget == NULL) return ;
ifc_window *rootparent = g_controlMenuTarget->getDesktopParent();
if (rootparent)
{
Layout *l = (Layout *)rootparent->getInterface(layoutGuid);
if (l)
{
HMENU ctrlmenu = GetSubMenu(controlmenu, 0);
HMENU appbarmenu = GetSubMenu(ctrlmenu, 2);
if (l->appbar_getEnabledSides() == 0)
{
EnableMenuItem(ctrlmenu, 2, MF_BYPOSITION | MF_GRAYED);
return ;
}
else
EnableMenuItem(ctrlmenu, 2, MF_BYPOSITION | MF_ENABLED);
int docked = l->appbar_isDocked();
int side = l->appbar_getSide();
CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_ALWAYSONTOP, MF_BYCOMMAND | (l->appbar_wantAlwaysOnTop() ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_AUTOHIDE, MF_BYCOMMAND | (l->appbar_wantAutoHide() ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_LEFT, MF_BYCOMMAND | ((docked && side == APPBAR_LEFT) ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_TOP, MF_BYCOMMAND | ((docked && side == APPBAR_TOP) ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_RIGHT, MF_BYCOMMAND | ((docked && side == APPBAR_RIGHT) ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_BOTTOM, MF_BYCOMMAND | ((docked && side == APPBAR_BOTTOM) ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_DISABLED, MF_BYCOMMAND | (!docked ? MF_CHECKED : MF_UNCHECKED));
EnableMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_AUTOHIDE, MF_BYCOMMAND | ((!docked || l->appbar_isSideAutoHideSafe(side)) ? MF_ENABLED : MF_GRAYED));
EnableMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_LEFT, MF_BYCOMMAND | (l->appbar_isSideEnabled(APPBAR_LEFT) ? MF_ENABLED : MF_GRAYED));
EnableMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_TOP, MF_BYCOMMAND | (l->appbar_isSideEnabled(APPBAR_TOP) ? MF_ENABLED : MF_GRAYED));
EnableMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_RIGHT, MF_BYCOMMAND | (l->appbar_isSideEnabled(APPBAR_RIGHT) ? MF_ENABLED : MF_GRAYED));
EnableMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_BOTTOM, MF_BYCOMMAND | (l->appbar_isSideEnabled(APPBAR_BOTTOM) ? MF_ENABLED : MF_GRAYED));
CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_AUTODOCKONDRAG, MF_BYCOMMAND | (cfg_options_appbarondrag ? MF_CHECKED : MF_UNCHECKED));
}
}
}
//-----------------------------------------------------------------------------------------------
double onTweakRenderRatio(double v)
{
if (!cfg_uioptions_uselocks.getValueAsInt())
return v;
return wa2.isDoubleSize() ? 2.0 : 1.0;
}
//-----------------------------------------------------------------------------------------------
void onCustomAltF4()
{
SendMessageW(wa2.getMainWindow(), WM_CLOSE, 0, 0);
}
int isSkinStillLoading()
{
return before_startup_callback;
}
//-----------------------------------------------------------------------------------------------
void loadExtraColorThemes()
{
wchar_t filename[WA_MAX_PATH] = {0};
GetModuleFileNameW(hInstance, filename, WA_MAX_PATH);
PathParserW pp(filename);
StringW path;
for (int i = 0;i < pp.getNumStrings() - 1;i++)
{
path.AppendPath(pp.enumString(i));
}
StringW file = path;
file.AppendPath(L"ColorThemes");
file.AppendPath(WASABI_API_SKIN->getSkinName());
file.AppendPath(L"*.xml");
WASABI_API_SKIN->loadSkinFile(file);
}
double oldscale = 1.;
//-----------------------------------------------------------------------------------------------
static BOOL CALLBACK customScaleProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
//CUT: double curratio=1.;
ifc_window *rootparent = g_controlMenuTarget->getDesktopParent();
if (!rootparent || !WASABI_API_WND->rootwndIsValid(rootparent))
{
g_controlMenuTarget = NULL; return TRUE;
}
oldscale = rootparent->getRenderRatio();
int u = (int)((oldscale * 100.0f) + 0.5f);
SendMessageW(GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMSCALE), TBM_SETRANGEMAX, 0, 300);
SendMessageW(GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMSCALE), TBM_SETRANGEMIN, 0, 10);
SendMessageW(GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMSCALE), TBM_SETPOS, 1, u);
SetDlgItemTextW(hwndDlg, IDC_STATIC_SCALE, StringPrintfW(WASABI_API_LNGSTRINGW(IDS_SCALE_X_PERCENT), u));
return TRUE;
}
case WM_HSCROLL:
{
int t = (int)SendMessageW((HWND) lParam, TBM_GETPOS, 0, 0);
if ((HWND) lParam == GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMSCALE))
{
SetDlgItemTextW(hwndDlg, IDC_STATIC_SCALE, StringPrintfW(WASABI_API_LNGSTRINGW(IDS_SCALE_X_PERCENT), t));
controlScaling((double)t / 100.0);
if (g_controlMenuTarget)
{
ifc_window *w = g_controlMenuTarget->getDesktopParent();
UpdateWindow(w->gethWnd());
}
}
break;
}
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
EndDialog(hwndDlg, IDOK);
return 0;
case IDCANCEL:
EndDialog(hwndDlg, IDCANCEL);
return 0;
}
break;
}
return FALSE;
}
double oldalpha = 255.;
//-----------------------------------------------------------------------------------------------
static BOOL CALLBACK customAlphaProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
ifc_window *rootparent = g_controlMenuTarget->getDesktopParent();
if (!rootparent || !WASABI_API_WND->rootwndIsValid(rootparent))
{
g_controlMenuTarget = NULL; return TRUE;
}
int v = 100;
if (!cfg_uioptions_linkallalpha.getValueAsInt())
{
Layout *l = static_cast<Layout *>(rootparent);
if (l != NULL)
oldalpha = static_cast<double>(l->getAlpha());
}
else
{
oldalpha = static_cast<double>(cfg_uioptions_linkedalpha.getValueAsInt());
}
v = (int)((oldalpha / 255.0f * 100.0f) + 0.5f);
SendMessageW(GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMALPHA), TBM_SETRANGEMAX, 0, 100);
SendMessageW(GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMALPHA), TBM_SETRANGEMIN, 0, 10);
SendMessageW(GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMALPHA), TBM_SETPOS, 1, v);
SetDlgItemTextW(hwndDlg, IDC_STATIC_ALPHA, StringPrintfW(WASABI_API_LNGSTRINGW(IDS_OPACITY_X_PERCENT), v));
return TRUE;
}
case WM_HSCROLL:
{
int t = (int)SendMessageW((HWND) lParam, TBM_GETPOS, 0, 0);
if ((HWND) lParam == GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMALPHA))
{
SetDlgItemTextW(hwndDlg, IDC_STATIC_ALPHA, StringPrintfW(WASABI_API_LNGSTRINGW(IDS_OPACITY_X_PERCENT), t));
controlOpacity(t);
}
break;
}
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
EndDialog(hwndDlg, IDOK);
return 0;
case IDCANCEL:
EndDialog(hwndDlg, IDCANCEL);
return 0;
}
break;
}
return FALSE;
}
void customScaling()
{
if (!g_controlMenuTarget) return ;
if (!WASABI_API_WND->rootwndIsValid(g_controlMenuTarget)) return ;
ifc_window *w = g_controlMenuTarget->getDesktopParent();
if (!w || !WASABI_API_WND->rootwndIsValid(w)) return ;
int r = WASABI_API_DIALOGBOXW(IDD_CUSTOMSCALE, w->gethWnd(), customScaleProc);
if (r != IDOK)
controlScaling(oldscale);
}
void customOpacity()
{
if (!g_controlMenuTarget) return ;
if (!WASABI_API_WND->rootwndIsValid(g_controlMenuTarget)) return ;
ifc_window *w = g_controlMenuTarget->getDesktopParent();
if (!w || !WASABI_API_WND->rootwndIsValid(w)) return ;
int r = WASABI_API_DIALOGBOXW(IDD_CUSTOMALPHA, w->gethWnd(), customAlphaProc);
if (r != IDOK)
controlOpacity((int)((oldalpha / 255.0f * 100.0f) + 0.5f));
}
void autoOpacifyHover()
{
if (!g_controlMenuTarget) return ;
if (!WASABI_API_WND->rootwndIsValid(g_controlMenuTarget)) return ;
ifc_window *w = g_controlMenuTarget->getDesktopParent();
Layout *l = static_cast<Layout*>(w->getInterface(layoutGuid));
if (l)
{
if (!cfg_uioptions_linkallalpha.getValueAsInt())
{
int a = l->getAutoOpacify();
if (a == 2) a = 1;
else a = !a;
l->setAutoOpacify(a);
}
else
{
int a = cfg_uioptions_autoopacitylinked.getValueAsInt();
if (a == 2) a = 1;
else a = !a;
cfg_uioptions_autoopacitylinked.setValueAsInt(a);
}
}
}
void autoOpacifyFocus()
{
if (!g_controlMenuTarget) return ;
if (!WASABI_API_WND->rootwndIsValid(g_controlMenuTarget)) return ;
ifc_window *w = g_controlMenuTarget->getDesktopParent();
Layout *l = static_cast<Layout*>(w->getInterface(layoutGuid));
if (l)
{
if (!cfg_uioptions_linkallalpha.getValueAsInt())
{
int a = l->getAutoOpacify();
if (a == 1) a = 2;
else if (a == 0) a = 2;
else if (a == 2) a = 0;
l->setAutoOpacify(a);
}
else
{
int a = cfg_uioptions_autoopacitylinked.getValueAsInt();
if (a == 1) a = 2;
else if (a == 0) a = 2;
else if (a == 2) a = 0;
cfg_uioptions_autoopacitylinked.setValueAsInt(a);
}
}
}
StringW langpackfilename;
const wchar_t *localesCustomGetFile()
{
const wchar_t *langDir = WASABI_API_LNG->GetLanguageFolder();
if (!langDir || !*langDir)
return NULL;
langpackfilename = StringPathCombine(langDir, L"freeform");
return langpackfilename;
#if 0 // old code
wchar_t buf[256] = L"";
GetPrivateProfileStringW(L"Winamp", L"langpack", L"", buf, 256, AutoWide(INI_FILE)); // TODO: maybe we should change all ini file stuff to W versions
if (*buf == 0)
return NULL;
wchar_t *p = wcschr(buf, '.');
if (p)
*p = 0;
wchar_t filename[WA_MAX_PATH] = {0};
GetModuleFileNameW(hInstance, filename, WA_MAX_PATH);
PathParserW pp(filename);
langpackfilename = L"";
for (int i = 0;i < pp.getNumStrings() - 1;i++)
{
langpackfilename.AppendPath(pp.enumString(i));
}
langpackfilename.AppendPath(L"freeform");
langpackfilename.AppendPath(L"langpacks");
langpackfilename.AppendPath(StringPrintfW(L"%s.xml", buf));
return langpackfilename;
#endif
}
const wchar_t *getCustomVar(const wchar_t *var)
{
static StringW ret;
if (WCSCASEEQLSAFE(var, L"@HAVE_LIBRARY@"))
{
ret = StringPrintfW(L"%d", we_have_ml);
return ret;
}
return NULL;
}
void checkMlPresent()
{
wchar_t filename[WA_MAX_PATH] = {0};
GetModuleFileNameW(hInstance, filename, WA_MAX_PATH);
PathParserW pp(filename);
StringW path;
for (int i = 0;i < pp.getNumStrings() - 1;i++)
{
path.AppendPath(pp.enumString(i));
}
path.AppendPath(L"gen_ml.dll");
we_have_ml = !WACCESS(path, 0);
}
void initEgg()
{
eggstr[0] = ~'N';
eggstr[1] = ~'U';
eggstr[2] = ~'L';
eggstr[3] = ~'L';
eggstr[4] = ~'S';
eggstr[5] = ~'O';
eggstr[6] = ~'F';
eggstr[7] = ~'T';
eggstr[8] = 0;
{
int x;
for (x = 0; x < 8; x ++) eggstr[x] ^= 255;
}
}
void toggleEgg()
{
eggstat = !eggstat;
if (!eggstat)
{
KillTimer(wa2.getMainWindow(), UPDATE_EGG);
if (lastlayoutegg && WASABI_API_WND->rootwndIsValid(lastlayoutegg)) lastlayoutegg->setTransparencyOverride(-1);
lastlayoutegg = NULL;
}
else SetTimer(wa2.getMainWindow(), UPDATE_EGG, 25, NULL);
}
void getCustomMetaData(const wchar_t *field, wchar_t *buf, int len)
{
StringW curfile = WASABI_API_MEDIACORE->core_getCurrent(0);
if (curfile.isempty())
{
buf[0] = 0;
return ;
}
if (!_wcsnicmp(curfile, L"file://", 7))
curfile = StringW(curfile.getValue() + 7);
buf[0] = 0;
if (WCSCASEEQLSAFE(field, L"filename"))
{
WCSCPYN(buf, curfile, len);
}
else
{
wa2.getMetaData(curfile, field, buf, len);
}
}
void registerGlobalHotkeys()
{
static int registered = 0;
if (!registered)
{
static wchar_t ghkStr[96];
wa2.registerGlobalHotkey((char*)WASABI_API_LNGSTRINGW_BUF(IDS_GHK_SHOW_NOTIFICATION,ghkStr,96), WM_WA_IPC, 0, IPC_SHOW_NOTIFICATION, HKF_UNICODE_NAME, "genff shn");
registered = 1;
}
}
const wchar_t *getSongInfoText()
{
return Core::getSongInfoText();
}
const wchar_t *getSongInfoTextTranslated()
{
return Core::getSongInfoTextTranslated();
}
OSWINDOWHANDLE getKeyboardForwardWnd(GUID g)
{
if (g != INVALID_GUID)
{
if (g == playerWndGuid)
return wa2.getMainWindow();
else if (g == pleditWndGuid)
return wa2.getWnd(IPC_GETWND_PE);
else if (g == videoWndGuid)
return wa2.getWnd(IPC_GETWND_VIDEO);
else
{
embedWindowState *ews = embedWndGuidMgr.getEmbedWindowState(g);
if (ews && wa2.isValidEmbedWndState(ews)) return ews->me;
}
}
return WASABI_API_WND->main_getRootWnd()->gethWnd();
}
void onAppBarDockChanged(ifc_window *w)
{
setDialogBoxesParent();
}
void onMainLayoutMove(HWND w)
{
// for Winamp to appear on the correct taskbar on Windows 8
// its necessary to set the classic main window to appear on
// that monitor and to be on-screen (but hidden) otherwise
// Windows will ignore it and it then makes us look buggy.
RECT r;
Wasabi::Std::getViewport(&r, w, 1);
SetWindowPos(wa2.getMainWindow(), NULL, r.left, r.bottom - 1, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW);
}
void updateAll()
{
updatePl();
#ifdef MINIBROWSER_SUPPORT
updateMb();
#endif
updateVid();
int n = embedWndGuidMgr.getNumWindowStates();
for (int i = 0;i < n;i++)
{
embedWindowState *ws = NULL;
GUID g = embedWndGuidMgr.enumWindowState(i, &ws);
if (g != INVALID_GUID)
{
updateEmb(g, ws);
}
}
}
void onReParent(HWND wnd)
{
updateAll();
}
void onReInit(HWND wnd)
{
updateAll();
}
void startFSMonitor()
{
g_fsmonitor = new FullScreenMonitor();
g_fscallback = new Wa5FSCallback();
g_fsmonitor->registerCallback(g_fscallback);
}
void stopFSMonitor()
{
delete g_fsmonitor;
g_fsmonitor = NULL;
delete g_fscallback;
g_fscallback = NULL;
}
void updateParentlessOnTop()
{
int i;
for (i = 0;i < SkinParser::getNumContainers();i++)
{
Container *c = SkinParser::enumContainer(i);
if (c != NULL)
{
int j;
for (j = 0;j < c->getNumLayouts();j++)
{
Layout *l = c->enumLayout(j);
if (l != NULL)
{
// skip windows owned by winamp
// skip appbars, they take care of themselves
if (l->getNoParent() && !l->appbar_isDocked())
{
l->updateOnTop();
}
}
}
}
}
}
void onGoFullscreen()
{
// hidden windows will not receive APPBAR_CALLBACK, so forward it to winamp's main
SendMessageW(wa2.getMainWindow(), APPBAR_CALLBACK, ABN_FULLSCREENAPP, 1);
// update ontop flag for windows that are not parented to winamp
updateParentlessOnTop();
}
void onCancelFullscreen()
{
// hidden windows will not receive APPBAR_CALLBACK, so forward it to winamp's main
SendMessageW(wa2.getMainWindow(), APPBAR_CALLBACK, ABN_FULLSCREENAPP, 0);
// update ontop flag for windows that are not owned by winamp
updateParentlessOnTop();
}
int processGenericHotkey(const char *hk)
{
if (!m_are_we_loaded) return 0;
SystemObject::onKeyDown(AutoWide(StringPrintf("HOTKEY: %s", hk)));
if (VCPU::getComplete())
{
DebugStringW(L"HOTKEY: %s trapped by script\n", hk);
return 1;
}
return 0;
}
int canExitWinamp()
{
return wa2.isExitEnabled();
}
int fsMonitorIsFS()
{
return g_fsmonitor->isFullScreen();
}
void modalPush()
{
wa2.pushExitDisabled();
}
void modalPop()
{
wa2.popExitDisabled();
}