winamp/Src/Plugins/General/gen_ff/main.cpp

#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". <20> 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();
}