Initial community commit

1 files changed, 3527 insertions, 0 deletions

diff --git a/Src/Plugins/General/gen_ff/main.cpp b/Src/Plugins/General/gen_ff/main.cpp
new file mode 100644
index 00000000..728d99a4
--- /dev/null
+++ b/Src/Plugins/General/gen_ff/main.cpp
@@ -0,0 +1,3527 @@
+#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();
+}
\ No newline at end of file