winamp/Src/Wasabi/api/skin/skinparse.cpp

#include <precomp.h>
#include <api.h>
#include <api/skin/widgets/mb/scriptbrowser.h>
#include <api/skin/skinparse.h>
#include <api/script/scriptmgr.h>
//#include <api/wac/main.h>//CUT!!
#include <api/skin/skinfont.h>
#include <api/skin/skin.h>
#include <api/skin/skinelem.h>
#include <api/font/font.h>
#include <api/wndmgr/snappnt.h>
#include <bfc/parse/pathparse.h>
#include <api/skin/guitree.h>
#ifdef WASABI_COMPILE_COMPONENTS
#include <api/wac/compon.h>
#endif
#include <api/service/svc_enum.h>
#include <api/script/objects/guiobject.h>
#ifdef WASABI_COMPILE_WNDMGR
#include <api/wndmgr/autopopup.h>
#endif
#include <bfc/parse/paramparser.h>
#include <api/skin/gammamgr.h>
#include <bfc/util/profiler.h>
#ifdef WASABI_COMPILE_LOCALES
#include <api/locales/xlatstr.h>
#include <api/locales/localesmgr.h>
#else
#define _
#endif
#include <bfc/string/stringdict.h>
#include <api/skin/widgets.h>

#ifdef _WIN32
extern HINSTANCE hInstance;
#endif

#define COLOR_WHITE (0xffffff)
#define COLOR_BLACK (0x000000)
#define COLOR_ERROR (0xff00ff)

// with alpha
#define COLOR_WHITEA (0xffffffff)
#define COLOR_BLACKA (0xff000000)
#define COLOR_ERRORA (0xffff00ff)

xml_tag taglist[] = {
                        {L"groupdef", XML_TAG_GROUPDEF, 1},
                        {L"group", XML_TAG_GROUP, 1},
                        {L"cfggroup", XML_TAG_CFGGROUP, 1},
                        {L"elements", XML_TAG_ELEMENTS, 1},
                        {L"snappoint", XML_TAG_SNAPPOINT, 0},
                        {L"script", XML_TAG_SCRIPT, 0},
                        {L"container", XML_TAG_CONTAINER, 1},
                        {L"layout", XML_TAG_LAYOUT, 1},
						{L"elements", XML_ELEMENTTAG_ELEMENTS, 1},
						{L"accelerators", XML_TAG_ACCELERATORS, 1},
						{L"accelerator", XML_TAG_ACCELERATOR, 1},
						{L"stringtable", XML_TAG_STRINGTABLE, 1},
						{L"stringentry", XML_TAG_STRINGENTRY, 1},
                    };

BEGIN_STRINGDICTIONARY(_resizevalues)
SDI(L"top", RESIZE_TOP);
SDI(L"left", RESIZE_LEFT);
SDI(L"right", RESIZE_RIGHT);
SDI(L"bottom", RESIZE_BOTTOM);
SDI(L"topleft", RESIZE_TOPLEFT);
SDI(L"topright", RESIZE_TOPRIGHT);
SDI(L"bottomleft", RESIZE_BOTTOMLEFT);
SDI(L"bottomright", RESIZE_BOTTOMRIGHT);
END_STRINGDICTIONARY(_resizevalues, resizevalues)

BEGIN_STRINGDICTIONARY(_parsetypes)
SDI(L"resize", PARSETYPE_RESIZE);
SDI(L"color", PARSETYPE_COLOR);
SDI(L"coloralpha", PARSETYPE_COLORALPHA);
SDI(L"regionop", PARSETYPE_REGIONOP);
SDI(L"internal_action", PARSETYPE_INTERNALACTION);
SDI(L"group_inheritance", PARSETYPE_GROUPINHERITANCE);
END_STRINGDICTIONARY(_parsetypes, parsetypes)

BEGIN_STRINGDICTIONARY(_actionlist)
SDI(L"none", ACTION_NONE);
#ifdef WA3COMPATIBILITY
SDI(L"about", ACTION_ABOUT);
SDI(L"mb_forward", ACTION_MB_FORWARD);
SDI(L"mb_back", ACTION_MB_BACK);
SDI(L"mb_url", ACTION_MB_URL);
SDI(L"mb_home", ACTION_MB_HOME);
SDI(L"mb_stop", ACTION_MB_STOP);
SDI(L"mb_refresh", ACTION_MB_REFRESH);
SDI(L"text_larger", ACTION_TEXT_LARGER);
SDI(L"text_smaller", ACTION_TEXT_SMALLER);
SDI(L"preferences", ACTION_PREFERENCES);
SDI(L"view_file_info", ACTION_VIEW_FILE_INFO);
SDI(L"doublesize", ACTION_DOUBLESIZE);
SDI(L"add_bookmark", ACTION_ADD_BOOKMARK);
SDI(L"menu", ACTION_MENU);
SDI(L"sysmenu", ACTION_SYSMENU);
SDI(L"windowmenu", ACTION_WINDOWMENU);
SDI(L"controlmenu", ACTION_CONTROLMENU);
#endif // wa3compatibility
#ifdef WASABI_WIDGETS_COMPBUCK
SDI(L"cb_next", ACTION_CB_NEXT);
SDI(L"cb_prev", ACTION_CB_PREV);
SDI(L"cb_prevpage", ACTION_CB_PREVPAGE);
SDI(L"cb_nextpage", ACTION_CB_NEXTPAGE);
#endif
#ifdef WASABI_COMPILE_WNDMGR
SDI(L"endmodal", ACTION_ENDMODAL);
SDI(L"minimize", ACTION_MINIMIZE);
SDI(L"maximize", ACTION_MAXIMIZE);
SDI(L"close", ACTION_CLOSE);
SDI(L"close_window", ACTION_CLOSE_WINDOW);
SDI(L"switch", ACTION_SWITCH);
SDI(L"toggle", ACTION_TOGGLE);
SDI(L"reload_skin", ACTION_RELOAD_SKIN);
SDI(L"enforce_minmax", ACTION_ENFORCEMINMAX);
SDI(L"toggle_always_on_top", ACTION_TOGGLE_ALWAYS_ON_TOP);
#endif // wndmgr
END_STRINGDICTIONARY(_actionlist, actionlist)

#ifdef WASABI_COMPILE_MEDIACORE
BEGIN_STRINGDICTIONARY(_displaylist)
SDI(L"songname", DISPLAY_SONGNAME);
SDI(L"songinfo", DISPLAY_SONGINFO);
SDI(L"songartist", DISPLAY_SONGARTIST);
SDI(L"songtitle", DISPLAY_SONGTITLE);
SDI(L"songalbum", DISPLAY_SONGALBUM);
SDI(L"songlength", DISPLAY_SONGLENGTH);
SDI(L"time", DISPLAY_TIME);
SDI(L"timeelapsed", DISPLAY_TIME);
SDI(L"timeremaining", DISPLAY_TIME);
SDI(L"componentbucket", DISPLAY_CB);
SDI(L"songbitrate", DISPLAY_SONGBITRATE);
SDI(L"songsamplerate", DISPLAY_SONGSAMPLERATE);
SDI(L"songinfo_localise", DISPLAY_SONGINFO_TRANSLATED);
END_STRINGDICTIONARY(_displaylist, displaylist)
#endif // mediacore

static GUID staticguid;

void SkinParser::initialize()
{
	if (!quickxmltaglist.getNumItems())
	{
		for (int i = 0;i < sizeof(taglist) / sizeof(xml_tag);i++)
			quickxmltaglist.addItem(&taglist[i]);
	}

	// first two are for back compatibility
	skinXML.registerCallback(L"WinampAbstractionLayer", xmlReaderCallback);
	skinXML.registerCallback(L"WinampAbstractionLayer\f*", xmlReaderCallback);
	skinXML.registerCallback(L"WasabiXML", xmlReaderCallback);
	skinXML.registerCallback(L"WasabiXML\f*", xmlReaderCallback);

	guiTree = new GuiTree();

	xuiCache = new SvcCacheT<svc_xuiObject>;
}

void SkinParser::shutdown()
{
	skinXML.unregisterCallback((void*)xmlReaderCallback);
	delete guiTree; guiTree = NULL;
	delete xuiCache; xuiCache = NULL;
}

#ifdef WASABI_COMPILE_WNDMGR
void SkinParser::setInitialFocus()
{
	for (int i = 0;i < containers.getNumItems();i++)
	{
		if (containers[i]->isVisible())
		{
			Layout *l = containers[i]->getCurrentLayout();
			if (l)
			{
				l->setFocus();
				return ;
			}
		}
	}
#ifdef WIN32
#ifdef WA3COMPATIBILITY
	SetFocus(Main::gethWnd());
#endif //WA3COMPATIBILITY
#else
	DebugString( "portme -- SkinParser::setInitialFocus\n" );
#endif  //WIN32
}
#endif

#ifdef WASABI_COMPILE_WNDMGR 
// do not forget to popParserState(); before returning
int SkinParser::loadContainers(const wchar_t *skin)
{
	wchar_t olddir[WA_MAX_PATH] = {0};
	Wasabi::Std::getCurDir(olddir, WA_MAX_PATH);
	Wasabi::Std::setCurDir(WASABI_API_APP->path_getAppPath());
	int oldncontains = getNumContainers();
	pushParserState();
	allowscripts = 1;
	centerskin = 1;
	staticloading = 1;
	instantiatinggroup = 0;
	transcientcontainer = 0;
	inContainer = inLayout = 0;
	curGroup = NULL;
	recording_container = 0;
	recording_groupdef = 0;
	inElements = inGroup = inGroupDef = inAccelerators = inStringTable = 0;
	includepath = WASABI_API_SKIN->getSkinPath();
	loading_main_skinfile = 0;
	SkinElementsMgr::onBeforeLoadingSkinElements(includepath);
	GammaMgr::onBeforeLoadingGammaGroups();
	scriptId = WASABI_API_PALETTE->getSkinPartIterator();
	int skinType = Skin::checkSkin(skin);
	int retcode = 0;
	loading_main_skinfile = 1;
	switch (skinType)
	{
	case Skin::CHKSKIN_UNKNOWN:
		popParserState();
		break;
#ifdef WA3COMPATIBILITY
	case Skin::CHKSKIN_ISWA2:
		retcode = XmlReader::loadFile("svc:wa2skinxml", includepath);
		break;
#endif
	default:
		{
			retcode = skinXML.loadFile(StringPathCombine(includepath, L"skin.xml"), includepath);
			break;
		}
	}

	int n = guiTree->getNumObject(XML_TAG_CONTAINER);
	for (int i = 0;i < n;i++)
	{
		SkinItem *item = guiTree->getObject(XML_TAG_CONTAINER, i);
		if (item && item->getParams())
		{
			if (item->getParams()->getItemValueInt(L"dynamic"))
			{
				if (item->getParams()->getItemValueInt(L"default_visible"))
				{
					const wchar_t *name = item->getParams()->getItemValue(L"name");
#ifdef ON_TWEAK_CONTAINER_NAMEW
					ON_TWEAK_CONTAINER_NAMEW(name);
#endif
					wchar_t c[512]=L"-";
#ifdef WASABI_COMPILE_CONFIG
					WASABI_API_CONFIG->getStringPrivate(StringPrintfW(L"everloaded/%s", name), c, 511, L"-");
#endif
					c[510] = 0;
					if (c[0] == '-')
					{
						// never been created, create it now since it has default_visible
						staticloading = 0;
						/*Container *c = */instantiateDynamicContainer(item);
						staticloading = 1;
					}
				}
			}
		}
	}

	loading_main_skinfile = 0;

	Wasabi::Std::setCurDir(olddir);

	int ncontainersloaded = getNumContainers() - oldncontains;
	if (retcode == 0 || ncontainersloaded == 0)
	{
		return 0;
	}

#ifdef WASABI_COMPILE_CONFIG
	WASABI_API_CONFIG->setStringPrivate(L"last_skin", Skin::getSkinName());
#endif

	ASSERT(tha != NULL);
	SkinElementsMgr::onAfterLoadingSkinElements();
	GammaMgr::onAfterLoadingGammaGroups();

#ifdef WASABI_COMPILE_COMPONENTS
	ComponentManager::broadcastNotify(WAC_NOTIFY_SKINGUILOADED, WASABI_API_PALETTE->getSkinPartIterator());
#endif

	Skin::sendGuiLoadedCallback();
	popParserState();
	return ncontainersloaded;
}

void SkinParser::centerSkin()
{
	RECT sr;
	if (centerskin && getSkinRect(&sr))
	{
		int l = getNumContainers();
		int w = (Wasabi::Std::getScreenWidth() - (sr.right - sr.left)) / 2;
		int h = (Wasabi::Std::getScreenHeight() - (sr.bottom - sr.top)) / 2;
		for (int i = 0;i < l;i++)
		{
			Container *c = enumContainer(i);
			if (!c->isVisible()) continue;
			Layout *l = c->getCurrentLayout();
			RECT r;
			l->getWindowRect(&r);
			r.left += w;
			r.right += w;
			r.bottom += h;
			r.top += h;
			l->move(r.left, r.top);
		}
	}
	foreach(containers)
	containers.getfor()->savePositions();
	endfor;
}

int SkinParser::getSkinRect(RECT *r, ifc_window *exclude)
{
	if (!r) return 0;
	ZERO(*r);
	Container *cexcluded = NULL;
	if (exclude != NULL)
	{
		Layout *l = static_cast<Layout *>(exclude->getDesktopParent());
		if (l != NULL) cexcluded = l->getParentContainer();
	}
	int x = 99999, y = 99999, x2 = -1, y2 = -1;
	int l = getNumContainers();
	for (int i = 0;i < l;i++)
	{
		Container *c = enumContainer(i);
		if (c == cexcluded) continue;
		if (!c->isInited()) c->onInit();
		if (c->isDeleting() || !c->getCurrentLayout()) continue;
		int cx = c->getDefaultPositionX();
		int cy = c->getDefaultPositionY();
		if (cx == -1) cx = 0;
		if (cy == -1) cy = 0;
		RECT r;
		c->getWindowRect(&r);
		int cw = r.right - r.left;
		int ch = r.bottom - r.top;
		if (cx < x) x = cx;
		if (cy < y) y = cy;
		if ((cx + cw) > x2) x2 = cx + cw;
		if ((cy + ch) > y2) y2 = cy + ch;
	}
	if (x2 > 0 && y2 > 0 && x != 99999 && y != 99999)
	{
		Wasabi::Std::setRect(r, x, y, x2, y2);
		return 1;
	}
	return 0;
}
#endif

// do not forget to popParserState(); before returning
void SkinParser::loadScriptXml(const wchar_t *filename, int scriptid)
{
	pushParserState();
	allowscripts = 1;
	instantiatinggroup = 0;
#ifdef WASABI_COMPILE_WNDMGR
	transcientcontainer = 0;
	inContainer = inLayout = 0;
#endif
	staticloading = 1;
	recording_container = 0;
	recording_groupdef = 0;
	curGroup = NULL;
	inElements = inGroup = inGroupDef = inAccelerators = inStringTable = 0;
	scriptId = scriptid;

	//CUT  char file[WA_MAX_PATH];
	//CUT  char drive[WA_MAX_PATH];
	//CUT  char dir[WA_MAX_PATH];
	//CUT  char fname[WA_MAX_PATH];
	//CUT  char ext[WA_MAX_PATH];


	includepath.setValue(L"");

	wchar_t olddir[WA_MAX_PATH] = {0};
	Wasabi::Std::getCurDir(olddir, WA_MAX_PATH);
	Wasabi::Std::setCurDir(WASABI_API_APP->path_getAppPath());

	if (!WCSNICMP(filename, L"buf:", 4))
	{
		skinXML.loadFile(filename, includepath);
	}
	else
	{
		//CUT DebugString("filename is %s\n", filename);
		includepath = filename;
		includepath.RemovePath();

		skinXML.loadFile(filename /*file*/, includepath);
	}

	Wasabi::Std::setCurDir(olddir);

	popParserState();
}


#ifdef WASABI_COMPILE_WNDMGR 
// do not forget to popParserState(); before returning
Container *SkinParser::loadContainerForWindowHolder(const wchar_t *groupid, GUID g, int initit, int transcient, const wchar_t *containerid, int container_flag)
{
	ASSERTPR((g == INVALID_GUID || groupid == NULL) && (g != INVALID_GUID || groupid != NULL), "sorry, one or the other, indulge aristotle");
	pushParserState();
	allowscripts = 1;
	instantiatinggroup = 0;
	transcientcontainer = transcient;
	staticloading = 0;
	recording_container = 0;
	recording_groupdef = 0;
	curContainer = NULL;
	lastCreatedContainer = NULL;
	curGroup = NULL;
	inContainer = inLayout = inElements = inGroup = inGroupDef = inAccelerators = inStringTable = 0;
	scriptId = -1; //WASABI_API_PALETTE->getSkinPartIterator();
	SkinItem *found = NULL;
	SkinItem *generic = NULL;

	for (int i = guiTree->getNumObject(XML_TAG_CONTAINER) - 1;i >= 0 && found == NULL;i--)
	{
		SkinItem *item = guiTree->getObject(XML_TAG_CONTAINER, i);
		if (item == NULL) continue;
		ifc_xmlreaderparams *par = item->getParams();
		if (!par) continue;

		if (g != INVALID_GUID)
		{
			for (size_t j = 0;found == NULL && j != par->getNbItems();j++)
			{
				const wchar_t *p = par->getItemName(j);
				if (!WCSICMP(p, L"component") || !WCSICMP(p, L"hold"))
				{
					ParamParser pp(par->getItemValue(j));
					if (pp.hasGuid(g) && found == NULL)
					{
						found = item;
						break;
					}
					if (generic == NULL && (pp.hasGuid(GENERIC_GUID) || pp.hasString(L"@ALL@")))
					{
						generic = item;
					}
				}
			}
		}
		else if (groupid != NULL)
		{
			for (size_t j = 0;j != par->getNbItems() && found == NULL;j++)
			{
				const wchar_t *p = par->getItemName(j);
				if (!WCSICMP(p, L"hold"))
				{
					ParamParser pp(par->getItemValue(j));
					if (pp.hasString(groupid))
					{
						found = item;
						break;
					}
					if (pp.hasString(L"@ALL@"))
					{
						generic = item;
					}
				}
			}
		}
	}

	if (found == NULL && generic == NULL)
	{
		popParserState();
		return NULL;
	}

	if (!found)
	{
		if (containerid != NULL)
		{
			SkinItem *item = guiTree->getContainerById(containerid);
			if (item != NULL)
			{
				Container *c = instantiateDynamicContainer(item, initit);
				popParserState();
				return c;
			}
		}
		else
		{
			if (container_flag != 0) return NULL;
		}
	}

	Container *c = instantiateDynamicContainer(found != NULL ? found : generic, initit);
	popParserState();
	return c;
}

Container *SkinParser::instantiateDynamicContainer(SkinItem *containeritem, int initit)
{

	int quit = 0;
	int guitreeid = guiTree->getObjectIdx(containeritem);
	for (int i = guitreeid;i < guiTree->getNumObject() && !quit;i++)
	{
		SkinItem *ii = guiTree->getList()->enumItem(i);
		ifc_xmlreaderparams *params = ii->getParams();
		const wchar_t *path = ii->getXmlRootPath();
		if (path)
			includepath = path;
		int object_type = guiTree->getObjectType(ii);
		const wchar_t *name = ii->getName();
		if (!params)
		{
			if (object_type == XML_TAG_CONTAINER)
				quit = 1;
			_onXmlEndElement(object_type, name);
		}
		else
		{
			_onXmlStartElement(object_type, name, params);
		}
	}
	return lastCreatedContainer;
}

// do not forget to popParserState(); before returning
Container *SkinParser::newDynamicContainer(const wchar_t *containerid, int transcient)
{

	pushParserState();

	allowscripts = 1;
	instantiatinggroup = 0;
	transcientcontainer = transcient;
	staticloading = 0;
	recording_container = 0;
	recording_groupdef = 0;
	curContainer = NULL;
	lastCreatedContainer = NULL;
	curGroup = NULL;
	inContainer = inLayout = inElements = inGroup = inGroupDef = inAccelerators = inStringTable = 0;
	scriptId = WASABI_API_PALETTE->getSkinPartIterator();
	SkinItem *found = NULL;

	for (int i = guiTree->getNumObject(XML_TAG_CONTAINER) - 1;i >= 0 && found == NULL;i--)
	{
		SkinItem *item = guiTree->getObject(XML_TAG_CONTAINER, i);
		ifc_xmlreaderparams *par = item->getParams();
		if (!par) continue;
		const wchar_t *p = par->getItemValue(L"id");
		if (!WCSICMP(p, containerid))
		{
			found = item;
			break;
		}
	}

	Container *c = NULL;
	if (found != NULL)
		c = instantiateDynamicContainer(found);

	popParserState();

	return c;
}

#endif

// do not forget to popParserState(); before returning
void SkinParser::fillGroup(Group *group, const wchar_t *groupid, SkinItem *specific_item, int params_only, int no_params, int scripts_enabled)
{
	ASSERT(group != NULL);
	pushParserState();

	instantiatinggroup = 1;

#ifdef WASABI_COMPILE_WNDMGR
	transcientcontainer = 0;
#endif

	allowscripts = scripts_enabled;
	staticloading = 0;
	recording_container = 0;
	recording_groupdef = 0;
	lastCreatedGroup = NULL;
	scriptId = group->getSkinPartId();
	SkinItem *found = NULL;

	PtrList<ifc_xmlreaderparams> ancestor_param_list;

	found = specific_item == NULL ? guiTree->getGroupDef(groupid) : specific_item;

	if (found == NULL)
	{
		popParserState();
		return ;
	}

	curGroup = group;
	inGroup = 1;
	parseGroup(found, &ancestor_param_list, params_only);

	if (!no_params)
	{
		XmlObject *xo = static_cast<XmlObject *>(curGroup->getScriptObject()->vcpu_getInterface(xmlObjectGuid));
		for (int i = ancestor_param_list.getNumItems() - 1;i >= 0;i--)
			initXmlObject(xo, ancestor_param_list.enumItem(i), 1);
	}

	popParserState();
}

GuiObject *SkinParser::newDynamicGroup(const wchar_t *groupid, int grouptype, SkinItem *specific_item, int specific_scriptid, int scripts_enabled)
{
#ifdef WASABI_COMPILE_CONFIG
	int iscfggroup = (grouptype == GROUP_CFGGROUP);
#endif

#ifdef WASABI_COMPILE_WNDMGR
	int islayoutgroup = (grouptype == GROUP_LAYOUTGROUP);
#endif

	Group *r = NULL;
#ifdef WASABI_COMPILE_CONFIG
	if (!iscfggroup)
	{
#endif
#ifdef WASABI_COMPILE_WNDMGR
		if (!islayoutgroup)
			r = new Group;
		else
		{
			Layout *l = new Layout;
			r = l;
			l->setParentContainer(NULL);
		}
#else // wndmgr
		r = new Group;
#endif // wndmgr
#ifdef WASABI_COMPILE_CONFIG

	}
	else
		r = new CfgGroup;
#endif

	r->setSkinPartId(specific_scriptid > -1 ? specific_scriptid : WASABI_API_PALETTE->getSkinPartIterator());

	if (r != NULL)
	{
		r->setXmlParam(L"id", groupid);
		r->setGroupContent(groupid, specific_item, scripts_enabled);
		fillGroup(r, groupid, specific_item, 1, 0, scripts_enabled);
		return r->getGuiObject();
	}
	return NULL;
}

void SkinParser::pushParserState()
{
	parser_status *p = new parser_status;
#ifdef WASABI_COMPILE_WNDMGR
	p->curContainer = curContainer;
	p->curLayout = curLayout;
	p->inContainer = inContainer;
	p->inLayout = inLayout;
	p->transcientcontainer = transcientcontainer;
#endif
	p->staticloading = staticloading;
	p->curGroup = curGroup;
	p->includepath = includepath;
	p->inElements = inElements;
	p->inGroup = inGroup;
	p->inGroupDef = inGroupDef;
	p->instantiatinggroup = instantiatinggroup;
	p->scriptid = scriptId;
	p->allowscripts = allowscripts;
	p->inAccelerators = inAccelerators;
	p->inStringTable = inStringTable;
	statusstack.addItem(p);
}

void SkinParser::popParserState()
{
	ASSERT(statusstack.getNumItems() > 0);
	parser_status *p = statusstack.enumItem(statusstack.getNumItems() - 1);
	statusstack.removeByPos(statusstack.getNumItems() - 1);
	ASSERT(p != NULL);
#ifdef WASABI_COMPILE_WNDMGR
	curContainer = p->curContainer;
	curLayout = p->curLayout;
	inContainer = p->inContainer;
	inLayout = p->inLayout;
	transcientcontainer = p->transcientcontainer;
#endif
	curGroup = p->curGroup;
	includepath = p->includepath;
	inElements = p->inElements;
	inAccelerators = p->inAccelerators;
	inStringTable = p->inStringTable;
	inGroup = p->inGroup;
	inGroupDef = p->inGroupDef;
	staticloading = p->staticloading;
	instantiatinggroup = p->instantiatinggroup;
	scriptId = p->scriptid;
	allowscripts = p->allowscripts;
	delete p;
}

#ifdef WASABI_COMPILE_WNDMGR

Container *SkinParser::getContainer(const wchar_t *id)
{
	for (int i = 0;i < containers.getNumItems();i++)
		if (!WCSICMP(id, containers.enumItem(i)->getId()))
			return containers.enumItem(i);
	return NULL;
}

Layout *SkinParser::getLayout(const wchar_t *contlay)
{
	PathParserW pp(contlay, L",");
	if (pp.getNumStrings() == 2)
	{
		Container *c = SkinParser::getContainer(pp.enumString(0));
		if (c)
		{
			Layout *l = c->getLayout(pp.enumString(1));
			if (l)
			{
				return l;
			}
		}
	}
	return NULL;
}

int SkinParser::script_getNumContainers()
{
	return containers.getNumItems();
}

Container *SkinParser::script_enumContainer(int n)
{
	return containers.enumItem(n);
}

int SkinParser::isContainer(Container *c)
{
	return containers.haveItem(c);
}

Container *SkinParser::script_getContainer(const wchar_t *id)
{
	for (int i = 0;i < containers.getNumItems();i++)
	{
		Container *c = containers.enumItem(i);
		if (c)
		{
			const wchar_t *c_id = containers.enumItem(i)->getId();
			if (c_id && !WCSICMP(id, c_id))
				return containers.enumItem(i);
		}
	}
	return NULL;
}

void SkinParser::componentToggled(GUID *g, int visible)
{
	for (int i = 0;i < containers.getNumItems();i++)
		containers[i]->componentToggled(g, visible);
}

void SkinParser::sendNotifyToAllContainers(int notifymsg, int param1, int param2)
{
	for (int i = 0;i < containers.getNumItems();i++)
		containers[i]->sendNotifyToAllLayouts(notifymsg, param1, param2);
}


void SkinParser::toggleContainer(int num)
{
	if (num < 0) return ;
	if (num > containers.getNumItems()) return ;

	Container *c = containers[num];
	if (!c) return ;
	c->toggle();
}

void SkinParser::startupContainers(int scriptid)
{
	for (int i = 0;i < containers.getNumItems();i++)
	{
		if (scriptid == -1 || containers[i]->getScriptId() == scriptid && !containers[i]->isDynamic())
			containers[i]->onInit();
	}
}

void SkinParser::showContainer(int num, int show)
{
	if (num < 0) return ;
	if (num > containers.getNumItems()) return ;

	Container *c = containers[num];
	c->setVisible(show);
}

#endif // wndmgr

int SkinParser::getHex(const wchar_t *p, int size)
{
	int v = 0, i = 0;
	while (*p != 0 && *p != '-' && *p != '}')
	{
		unsigned int a = *p;
		if (a >= '0' && a <= '9') a -= '0';
		if (a >= 'a' && a <= 'f') a -= 'a' -10;
		if (a >= 'A' && a <= 'F') a -= 'A' -10;
		v = (v * 16) + a;
		p++;
		i++; if (size != -1 && i == size) return v;
	}
	return v;
}

#ifdef WASABI_COMPILE_WNDMGR
int SkinParser::getComponentGuid(GUID *g, const wchar_t *p)
{
	g->Data1 = getHex(p);
	while (*p != 0 && *p != '-') p++;
	if (*p == '-')
	{
		p++;
		g->Data2 = getHex(p);
		while (*p != 0 && *p != '-') p++;
		if (*p == '-')
		{
			p++;
			g->Data3 = getHex(p);
			while (*p != 0 && *p != '-') p++;
			if (*p == '-')
			{
				p++;
				g->Data4[0] = getHex(p, 2); p += 2;
				g->Data4[1] = getHex(p, 2); p += 3;
				g->Data4[2] = getHex(p, 2); p += 2;
				g->Data4[3] = getHex(p, 2); p += 2;
				g->Data4[4] = getHex(p, 2); p += 2;
				g->Data4[5] = getHex(p, 2); p += 2;
				g->Data4[6] = getHex(p, 2); p += 2;
				g->Data4[7] = getHex(p, 2);
				return 1;
			}
		}
	}
	return 0;
}

GUID *SkinParser::getComponentGuid(const wchar_t *id)
{
	static GUID g;
	g = nsGUID::fromCharW(id);
	if (g == INVALID_GUID) return NULL;
	return &g;
}

#endif

int SkinParser::parse(const wchar_t *str, const wchar_t *what)
{
	int a = parsetypes.getId(what);
	if (a < 0) return WTOI(str);
	switch (a)
	{
	case PARSETYPE_RESIZE: return parseResize(str);
	case PARSETYPE_COLOR: return parseColor(str);
	case PARSETYPE_COLORALPHA: return parseColorAlpha(str);
	case PARSETYPE_REGIONOP: return parseRegionOp(str);
	case PARSETYPE_INTERNALACTION: return getAction(str);
	case PARSETYPE_GROUPINHERITANCE: return parseGroupInheritance(str);
	}
	// todo: add svc_intParser
	return 0;
}

int SkinParser::parseGroupInheritance(const wchar_t *str)
{
	if (WCSCASEEQLSAFE(str, L"1")) return GROUP_INHERIT_ALL;
	if (WCSCASEEQLSAFE(str, L"0")) return GROUP_INHERIT_NOTHING;
	ParamParser pp(str);
	int v = 0;
	for (int i = 0;i < pp.getNumItems();i++)
	{
		const wchar_t *s = pp.enumItem(i);
		if (WCSCASEEQLSAFE(s, L"xui")) v |= GROUP_INHERIT_XUIOBJECTS;
		if (WCSCASEEQLSAFE(s, L"scripts")) v |= GROUP_INHERIT_SCRIPTS;
		if (WCSCASEEQLSAFE(s, L"params")) v |= GROUP_INHERIT_PARAMS;
	}
	return v;
}

ARGB32 SkinParser::parseColor(const wchar_t *color, int *error)
{
	if (color == NULL || *color == '\0') { if (error) *error = 1; return COLOR_ERROR; }
	if (!WCSICMP(color, L"white")) return COLOR_WHITE;
	if (!WCSICMP(color, L"black")) return COLOR_BLACK;
	if (wcschr(color, ','))
	{
		int r = 0, g = 0, b = 0;
		if (swscanf(color, L"%d,%d,%d", &r, &g, &b) != 3) return COLOR_ERROR;
		return RGB(r, g, b); // our colors are reversed internally
	}
	if (*color == '#')
	{
		int r = 0, g = 0, b = 0;
		if (swscanf(color, L"#%02x%02x%02x", &r, &g, &b) != 3) return COLOR_ERROR;
		return RGB(r, g, b);
	}
	if (error) *error = 1;
	return COLOR_ERROR;
}

ARGB32 SkinParser::parseColorAlpha(const wchar_t *color)
{
	if (color == NULL || *color == '\0') return COLOR_BLACKA;
	if (!WCSICMP(color, L"white")) return COLOR_WHITEA;
	if (!WCSICMP(color, L"black")) return COLOR_BLACKA;
	if (wcschr(color, ','))
	{
		int r = 0, g = 0, b = 0, a = 255;
		// note that 3 params is ok
		if (swscanf(color, L"%d,%d,%d,%d", &r, &g, &b, &a) < 3) return COLOR_ERRORA;
		ARGB32 ret = RGB(r, g, b); // our colors are reversed internally
		ret |= ((a & 0xff) << 24);
		return ret;
	}
	if (*color == '#')
	{
		int r = 0, g = 0, b = 0, a = 255;
		if (swscanf(color, L"#%02x%02x%02x%02x", &r, &g, &b, &a) < 3) return COLOR_ERRORA;
		ARGB32 ret = RGB(r, g, b); // our colors are reversed internally
		ret |= ((a & 0xff) << 24);
		return ret;
	}
	return COLOR_ERRORA;
}

#ifdef WASABI_COMPILE_WNDMGR

void SkinParser::toggleContainer(const wchar_t *id)
{
	// component toggling
	GUID *g;
	if (g = getComponentGuid(id))
	{
		GUID g2;
		MEMCPY(&g2, g, sizeof(GUID));
		WASABI_API_WNDMGR->skinwnd_toggleByGuid(g2);
		return ;
	}
	for (int i = 0;i < containers.getNumItems();i++)
		if (!WCSICMP(id, containers[i]->getId())) toggleContainer(i);
}

void SkinParser::showContainer(const wchar_t *id, int show)
{
	// component guid
	/*  GUID *g;
	  if (g = getComponentGuid(id)) {
	    WASABI_API_WNDMGR->setComponentVisible(*g, show);
	    return;
	  }*/

	foreach(containers)
	if (!WCSICMP(id, containers.getfor()->getId()))
		showContainer(foreach_index, show);
	endfor
}

#endif // wndmgr

#pragma warning( disable : 4065 )
int SkinParser::getAction(const wchar_t *action, const wchar_t **name)
{
	//CT> this should be a binary search for more efficiency
	if (name != NULL) *name = NULL;
	int a = actionlist.getId(action);
	if (a == -1) return ACTION_NONE;

	// these strings are for accessibility when no text has been assigned to the control that triggers these actions
	if (name != NULL)
	{
		switch (a)
		{
#ifdef WASABI_COMPILE_WNDMGR
		case ACTION_RELOAD_SKIN: *name = _(L"Reload skin"); break;
		case ACTION_MINIMIZE: *name = _(L"Minimize window"); break;
		case ACTION_MAXIMIZE: *name = _(L"Maximize window"); break;
		case ACTION_CLOSE: *name = _(L"Close"); break;
		case ACTION_SWITCH: *name = _(L"Switch to"); break;
		case ACTION_TOGGLE: *name = _(L"Toggle"); break;
		case ACTION_CLOSE_WINDOW: *name = _(L"Close window"); break;
#endif

#ifdef WA3COMPATIBILITY
		case ACTION_ABOUT: *name = _(L"About"); break;
		case ACTION_SYSMENU: *name = _(L"Open system menu"); break;
		case ACTION_CONTROLMENU: *name = _(L"Open control menu"); break;
		case ACTION_MENU: *name = _(L"Open menu"); break;
		case ACTION_WINDOWMENU: *name = _(L"Window menu"); break;
		case ACTION_MB_FORWARD: *name = _(L"Forward"); break;
		case ACTION_MB_BACK: *name = _(L"Back"); break;
		case ACTION_MB_URL: *name = _(L"Url"); break;
		case ACTION_MB_HOME: *name = _(L"Home"); break;
		case ACTION_MB_STOP: *name = _(L"Stop loading"); break;
		case ACTION_MB_REFRESH: *name = _(L"Refresh"); break;
		case ACTION_TEXT_LARGER: *name = _(L"Increase text size"); break;
		case ACTION_TEXT_SMALLER: *name = _(L"Decrease text size"); break;
		case ACTION_PREFERENCES: *name = _(L"Preferences"); break;
		case ACTION_TOGGLE_ALWAYS_ON_TOP: *name = _(L"Toggle Always on top"); break;
		case ACTION_VIEW_FILE_INFO: *name = _(L"View file info"); break;
		case ACTION_ADD_BOOKMARK: *name = _(L"Add bookmark"); break;
		case ACTION_DOUBLESIZE: *name = _(L"Toggle double size mode"); break;
#endif
#ifdef WASABI_WIDGETS_COMPBUCK
		case ACTION_CB_NEXT: *name = _(L"More"); break;
		case ACTION_CB_PREV: *name = _(L"More"); break;
#endif
		default: break;
		}
	}
	return a;
}
#pragma warning( default : 4065 )

#ifdef WASABI_COMPILE_MEDIACORE
int SkinParser::getDisplay(const wchar_t *display)
{
	int a = displaylist.getId(display);
	if (a == -1) return DISPLAY_SERVICE;
	return a;
}
#endif

int SkinParser::getAlign(const wchar_t *align)
{
#ifdef _WIN32
	if (!WCSICMP(align, L"LEFT")) return ALIGN_LEFT;
	if (!WCSICMP(align, L"CENTER")) return ALIGN_CENTER;
	if (!WCSICMP(align, L"RIGHT")) return ALIGN_RIGHT;
	if (!WCSICMP(align, L"TOP")) return ALIGN_TOP;
	if (!WCSICMP(align, L"BOTTOM")) return ALIGN_BOTTOM;
#else
#warning port me
#endif
	return DISPLAY_NONE;
}

int SkinParser::getOrientation(const wchar_t *orient)
{
	if (!WCSICMP(orient, L"V") || !WCSICMP(orient, L"VERTICAL"))
		return ORIENTATION_VERTICAL;
	return ORIENTATION_HORIZONTAL;
}

// link guiobject to guiobject
void SkinParser::initGuiObject(GuiObject *g, Group *pgroup)
{
	ASSERT(pgroup);
	pgroup->addObject(g);
}

// This sends the params to the script object through its XmlObject
// interface. Try not to add code here, but instead in setXmlParam/XmlInit
// in the object itself
void SkinParser::initXmlObject(XmlObject *o, ifc_xmlreaderparams *params, int no_id)
{
	ASSERT(o);
	if (params)
		for (size_t i = 0;i != params->getNbItems();i++)
			if (!no_id || WCSICMP(params->getItemName(i), L"id")) // don't pass along id="blah" stuff
				o->setXmlParam(params->getItemName(i), params->getItemValue(i));
	//  o->XmlInit(); //fg> now defered
}

#ifdef WASABI_COMPILE_WNDMGR

// This sends the params to the script object through its XmlObject
// interface. Try not to add code here, but instead in setXmlParam/XmlInit
// in the object itself
void SkinParser::initLayout(Layout *l, Container *pcont)
{
	ASSERT(pcont);
	l->setParentContainer(pcont);
	pcont->addLayout(l);
}

#endif

void SkinParser::xmlReaderCallback(int start, const wchar_t *xmltag, skin_xmlreaderparams *params)
{
	if (start) onXmlStartElement(xmltag, params);
	else onXmlEndElement(xmltag);
}

void SkinParser::onXmlStartElement(const wchar_t *name, skin_xmlreaderparams *params)
{
	xml_tag *i = quickxmltaglist.findItem(name);
	if (i) _onXmlStartElement(i->id, name, params);
	else _onXmlStartElement(XML_TAG_UNKNOWN, name, params);
}

void SkinParser::onXmlEndElement(const wchar_t *name)
{
	xml_tag *i = quickxmltaglist.findItem(name);
	if (i)
	{
		if (i->needclosetag)
			_onXmlEndElement(i->id, name);
	} /*else
		    _onXmlEndElement(XML_TAG_UNKNOWN, name);*/ // not needed yet
}



void SkinParser::parseGroup(SkinItem *groupitem, PtrList<ifc_xmlreaderparams> *ancestor_param_list, int params_only, int overriding_inheritance_flags)
{
	ifc_xmlreaderparams *par = groupitem->getParams();
	const wchar_t *groupid = par->getItemValue(L"id");
	const wchar_t *ic = par->getItemValue(L"inherit_content");
	const wchar_t *og = par->getItemValue(L"inherit_group");
	const wchar_t *ip = par->getItemValue(L"inherit_params");

	int inheritance_flags = parseGroupInheritance(ic);
	int inherit_params = 1;
	if (ip != NULL && *ip != 0) inherit_params = WTOI(ip);
	if ((og && *og) && (!ic || !*ic)) inheritance_flags = GROUP_INHERIT_ALLCONTENT;

	if (inherit_params) inheritance_flags |= GROUP_INHERIT_PARAMS;

	if (WCSCASEEQLSAFE(og, groupid)) og = NULL;


	if (inheritance_flags != GROUP_INHERIT_NOTHING)
	{
		SkinItem *prior_item = NULL;
		if (og != NULL && *og)
			prior_item = guiTree->getGroupDef(og);
		else
			prior_item = guiTree->getGroupDefAncestor(groupitem);
		if (prior_item != NULL)
			parseGroup(prior_item, ancestor_param_list, params_only, inheritance_flags);
	}

	if (overriding_inheritance_flags & GROUP_INHERIT_PARAMS)
		ancestor_param_list->addItem(groupitem->getParams());

	if (!params_only)
	{
		int guitreeid = guiTree->getObjectIdx(groupitem);
		for (int i = guitreeid + 1;i < guiTree->getNumObject();i++)
		{
			SkinItem *item = guiTree->getList()->enumItem(i);
			ifc_xmlreaderparams *params = item->getParams();;
			const wchar_t *path = item->getXmlRootPath();
			if (path)
				includepath = path;
			int object_type = guiTree->getObjectType(item);
			if (object_type == XML_TAG_GROUPDEF && !params) break;
			if (object_type == XML_TAG_SCRIPT && !(overriding_inheritance_flags & GROUP_INHERIT_SCRIPTS)) continue;
			if (object_type != XML_TAG_SCRIPT && !(overriding_inheritance_flags & GROUP_INHERIT_XUIOBJECTS)) continue;
			const wchar_t *name = item->getName();
			if (!params)
				_onXmlEndElement(object_type, name);
			else
				_onXmlStartElement(object_type, name, params);
		}
	}

}

void SkinParser::_onXmlStartElement(int object_type, const wchar_t *object_name, ifc_xmlreaderparams *params)
{
	GuiObject *g = NULL;                                // We'll need to build a GUI object
	XmlObject *x = NULL;
	Group *g_group = NULL;

	if (object_type == XML_TAG_UNKNOWN)
	{
		if (loading_main_skinfile && (!WCSICMP(object_name, L"WinampAbstractionLayer") || !WCSICMP(object_name, L"WasabiXML")))
		{
			skinversion = WTOF(params->getItemValue(L"version"));
		}
	}

/*#ifdef WASABI_COMPILE_WNDMGR
	int isacontainer = 0;
#endif // wndmgr*/

	if (object_type == XML_TAG_GROUPDEF)
	{
		if (staticloading)
		{
			recording_groupdef++;
		}
		inGroupDef++;
	}

	if (object_type == XML_TAG_ACCELERATORS)
	{
		const wchar_t *section = params->getItemValue(L"section");
		if (!section)
			LocalesManager::setAcceleratorSection(L"general");
		else
			LocalesManager::setAcceleratorSection(section);

		inAccelerators = 1;
	}

	if (object_type == XML_TAG_STRINGTABLE)
	{
		const wchar_t *section = params->getItemValue(L"id");
		if (!section)
			LocalesManager::SetStringTable(L"nullsoft.wasabi");
		else
			LocalesManager::SetStringTable(section);

		inStringTable = 1;
	}

	if (inStringTable && object_type == XML_TAG_STRINGENTRY)
	{
		const wchar_t *b = params->getItemValue(L"id");
		const wchar_t *a = params->getItemValue(L"string");
		if (b && a)
		{
			LocalesManager::AddString(WTOI(b), a);
		}
	}

	if (inAccelerators && object_type == XML_TAG_ACCELERATOR)
	{
		const wchar_t *b = params->getItemValue(L"bind");
		const wchar_t *a = params->getItemValue(L"action");
		if (b && a)
		{
			//LocalesManager::addAccelerator(b, a);
			//Martin> this is a temporary fix to protect skin.xml from overriding the language pack accels
			LocalesManager::addAcceleratorFromSkin(b, a);
		}
	}

	if ((!recording_container && !recording_groupdef) && !inGroupDef)
	{
		if (object_type == XML_TAG_SCRIPT)
		{
			//      const char *id = params->getItemValue(L"id");
			if (1)
			{
				if (allowscripts)
				{
					int vcpuid = Script::addScript(includepath, params->getItemValue(L"file"), params->getItemValue(L"id"));
					if (vcpuid != -1)
					{
						Script::setScriptParam(vcpuid, params->getItemValue(L"param"));
						Script::setParentGroup(vcpuid, curGroup);
						Script::setSkinPartId(vcpuid, scriptId);
						if (curGroup != NULL)
							curGroup->addScript(vcpuid);
						else // todo: schedule this for the end of skinparse, after all layouts are inited
							SOM::getSystemObjectByScriptId(vcpuid)->onLoad();
					}
				}
			}
		}
	}

#ifdef WASABI_COMPILE_WNDMGR
	if ((!recording_groupdef && !recording_container) && (inContainer || inGroup) && !inGroupDef)
	{     // Am I in a container definition ?
		if (inLayout || inGroup)
		{ // Am I in a layout or in a group ?
#else // wndmgr
	if ((!recording_groupdef && !recording_container) && inGroup && !inGroupDef)
	{
		{    // Am I in definition ?
#endif // wndmgr


			// Create appropriate GuiObject descendant
			if (object_type == XML_TAG_GROUP || object_type == XML_TAG_CFGGROUP)
			{
				Group *old = curGroup;
				GuiObject *newgrp = newDynamicGroup(params->getItemValue(L"id"), (object_type == XML_TAG_CFGGROUP) ? GROUP_CFGGROUP : GROUP_GROUP);
				if (newgrp)
				{
					x = static_cast<XmlObject *>(newgrp->guiobject_getScriptObject()->vcpu_getInterface(xmlObjectGuid));
					g = newgrp;
				}
				curGroup = old;
			}
#ifdef WASABI_COMPILE_WNDMGR
			else if (object_type == XML_TAG_SNAPPOINT)
			{
				x = new SnapPoint(curLayout, curContainer);
			}
#endif
			else if (object_type != XML_TAG_UNKNOWN)
			{
				g = NULL;
			}
			else
			{
				SkinItem *item = guiTree->getXuiGroupDef(object_name);
				if (item != NULL)
				{
					Group *old = curGroup;
					const wchar_t *grpid = NULL;
					if (item->getParams() != NULL)
						grpid = item->getParams()->getItemValue(L"id");
					GuiObject *newgrp = NULL;
					if (grpid == NULL)
						newgrp = newDynamicGroup(params->getItemValue(L"id"), GROUP_GROUP, item);
					else
						newgrp = newDynamicGroup(grpid, GROUP_GROUP, NULL, -1, allowscripts);
					if (newgrp)
					{
						x = static_cast<XmlObject *>(newgrp->guiobject_getScriptObject()->vcpu_getInterface(xmlObjectGuid));
						g = newgrp;
					}
					curGroup = old;
				}
				else
				{
					g = createExternalGuiObject(object_name, &x, params);
				}
			}
		}
#ifdef WASABI_COMPILE_WNDMGR
		else
		{ // if inlayout

			if (object_type == XML_TAG_LAYOUT)
			{                   // Now enters a new layout
				curLayout = new Layout;
				curGroup = curLayout;
				inLayout = 1;
				initLayout(curLayout, curContainer);
				x = static_cast<XmlObject *>(curLayout->getGuiObject()->guiobject_getScriptObject()->vcpu_getInterface(xmlObjectGuid));
			}
		}
#endif // wndmgr

	}
#ifdef WASABI_COMPILE_WNDMGR
	else
	{ // if inContainer

		if (inElements)
		{
			// do nothing
		}
		else if (object_type == XML_TAG_CONTAINER)
		{
			//isacontainer = 1;
			const wchar_t *d = params->getItemValue(L"dynamic");
			int dyn = WASABI_WNDMGR_ALLCONTAINERSDYNAMIC ? 1 : (d ? WTOI(d) : 0);

			if (dyn && staticloading)
			{
				recording_container = 1;
			}
			else
			{
				inContainer = 1;
				curContainer = new Container(scriptId);
				curContainer->setId(params->getItemValue(L"id"));
				containers.addItem(curContainer);
#ifdef _DEBUG
				DebugStringW(L"new Container - skinpartid = %d\n", scriptId);
#endif
				if (transcientcontainer) curContainer->setTranscient(1);
				x = curContainer;
			}
		}
		else
		{
			if (object_type == XML_TAG_SCRIPTS)
				inScripts = 1;
			else if (object_type == XML_TAG_ELEMENTS)
				inElements = 1;
		}

	} // if container else
#endif // wndmgr

	if (g_group)
	{
		curGroup = g_group;
	}
	else if (g)
		initGuiObject(g, curGroup);

	if (x)
		initXmlObject(x, params);

	if (recording_container || recording_groupdef)
		guiTree->addItem(object_type, object_name, params, scriptId, includepath.v());
}

void SkinParser::_onXmlEndElement(int object_type, const wchar_t *name)
{
	if (recording_container || recording_groupdef)
		guiTree->addItem(object_type, name, NULL, scriptId, includepath);

	if (object_type == XML_TAG_GROUPDEF)
	{
		lastCreatedGroup = curGroup;
		if (staticloading)
			recording_groupdef--;
		if (recording_groupdef < 0) recording_groupdef = 0;
		inGroup = 0;
		inGroupDef--;
		curGroup = NULL;
	}

#ifdef WASABI_COMPILE_WNDMGR
	if (object_type == XML_TAG_CONTAINER)
	{
		if (inContainer)
		{
			//if (!curContainer->isDynamic()) containers.addItem(curContainer); //FG>script
			//containers.addItem(curContainer);
			lastCreatedContainer = curContainer;
			curContainer = NULL;
			inContainer = 0;
		}
		recording_container = 0;
		if (recording_groupdef)
		{
			WASABI_API_WNDMGR->messageBox(L"container closed but group still open, closing group", L"error in xml data", 0, NULL, NULL);
			recording_groupdef = 0;
		}
	}

	if (inLayout && object_type == XML_TAG_LAYOUT)
	{
#ifdef WA3COMPATIBILITY
		curLayout->setForwardMsgWnd(WASABI_API_WND->main_getRootWnd()->gethWnd());
#endif
		curLayout->setAutoResizeAfterInit(1);
#ifndef WA3COMPATIBILITY
#ifdef _WIN32
		curLayout->init(hInstance, curLayout->getCustomOwner() ? curLayout->getCustomOwner()->gethWnd() : WASABI_API_WND->main_getRootWnd()->gethWnd(), TRUE);
#else
#warning port me
		curLayout->init(0, curLayout->getCustomOwner() ? curLayout->getCustomOwner()->gethWnd() : WASABI_API_WND->main_getRootWnd()->gethWnd(), TRUE);
#endif
#else
		curLayout->init(hInstance, curLayout->getCustomOwner() ? curLayout->getCustomOwner()->gethWnd() : Main::gethWnd(), TRUE);
#endif
		curLayout->getGuiObject()->guiobject_onStartup();
		curLayout = NULL;
		inLayout = 0;
		curGroup = NULL;
	}
#endif

	if (inScripts && object_type == XML_TAG_SCRIPTS)
	{
		inScripts = 0;
	}

	if (inElements && object_type == XML_TAG_ELEMENTS)
	{
		inElements = 0;
	}

	if (inAccelerators && object_type == XML_TAG_ACCELERATORS)
	{
		LocalesManager::setAcceleratorSection(L"");
		inAccelerators = 0;
	}

	if (inStringTable && object_type == XML_TAG_STRINGTABLE)
	{
		LocalesManager::SetStringTable(L"");
		inStringTable = 0;
	}
}

#ifdef WASABI_COMPILE_WNDMGR
int SkinParser::verifyContainer(Container *c)
{
	for (int i = 0;i < containers.getNumItems();i++)
	{
		if (containers.enumItem(i) == c)
			return 1;
	}
	return 0;
}
#endif

int SkinParser::parseResize(const wchar_t *r)
{
	int a = resizevalues.getId(r);
	if (a < 0) return WTOI(r);
	return a;
}

int SkinParser::parseRegionOp(const wchar_t *r)
{
	if (!WCSICMP(r, L"or")) return REGIONOP_OR;
	if (!WCSICMP(r, L"and")) return REGIONOP_AND;
	if (!WCSICMP(r, L"sub")) return REGIONOP_SUB;
	if (!WCSICMP(r, L"sub2")) return REGIONOP_SUB2;
	return WTOI(r);
}

void SkinParser::cleanupScript(int scriptid)
{
	if (scriptid == -1) scriptid = WASABI_API_PALETTE->getSkinPartIterator();
	int i;
	for (i = 0;i < SOM::getNumSystemObjects();i++)
	{
		if (SOM::getSystemObject(i)->getSkinPartId() == scriptid)
		{
			int vcpu = SOM::getSystemObject(i)->getScriptId();
			Script::unloadScript(vcpu);
			i--;
		}
	}
#ifdef WASABI_COMPILE_WNDMGR
	for (i = 0;i < containers.getNumItems();i++)
	{
		Container *c = containers[i];
		if (c->getScriptId() == scriptid)
		{
			c->setDeleting();
			delete c; // c autodeletes from containers
			i--;
		}
	}
#endif
	guiTree->removeSkinPart(scriptid);
#ifdef WASABI_COMPILE_WNDMGR
	AutoPopup::removeSkinPart(scriptid);
#endif
}

#ifdef WASABI_COMPILE_WNDMGR
void SkinParser::unloadAllContainers()
{
	foreach(containers)
	containers.getfor()->setDeleting();
	endfor;
	containers.deleteAllSafe();
	//script_containers.removeAll();
}
#endif

void SkinParser::cleanUp()
{
#ifdef WASABI_COMPILE_WNDMGR
	AutoPopup::removeAllAddons();
#endif
	Script::unloadAllScripts();
#ifdef WASABI_COMPILE_WNDMGR
	unloadAllContainers();
#endif
	guiTree->reset();
}

#ifdef WASABI_COMPILE_WNDMGR
int SkinParser::getNumContainers()
{
	return containers.getNumItems();
}

Container *SkinParser::enumContainer(int n)
{
	return containers.enumItem(n);
}
#endif

const wchar_t *SkinParser::getXmlRootPath()
{
	return includepath;
}

#ifdef WASABI_COMPILE_WNDMGR
const wchar_t *SkinParser::getCurrentContainerId()
{
	if (curContainer) return curContainer->getId();
	return NULL;
}

const wchar_t *SkinParser::getCurrentGroupId()
{
	if (curGroup) return curGroup->getGuiObject()->guiobject_getId();
	return NULL;
}
#endif

GuiObject *SkinParser::createExternalGuiObject(const wchar_t *object_name, XmlObject **x, ifc_xmlreaderparams *params)
{
	svc_xuiObject *svc = NULL;
	waServiceFactory *sf = xuiCache->findServiceFactory(object_name);
	if (sf != NULL)
		svc = castService<svc_xuiObject>(sf, FALSE);
	else
	{
		XuiObjectSvcEnum xose(object_name);
		svc = xose.getNext(FALSE);
		sf = xose.getLastFactory();
	}
	if (svc != NULL)
	{
		GuiObject *go = svc->instantiate(object_name, params);
		if (!go) return NULL;
		go->guiobject_setXuiService(svc);
		go->guiobject_setXuiServiceFactory(sf);
		ScriptObject *so = go->guiobject_getScriptObject();
		ASSERTPR(so != NULL, "tell francis to fix scriptobjectless xuiobjects");
		if (x) *x = static_cast<XmlObject *>(so->vcpu_getInterface(xmlObjectGuid));
		return go;
	}
	return NULL;
}

void SkinParser::destroyGuiObject(GuiObject *o)
{
	svc_xuiObject *svc = o->guiobject_getXuiService();
	if (!svc)
	{
		ScriptObject *so = o->guiobject_getScriptObject();
		ASSERT(so != NULL);
		GuiObjectWnd *go = static_cast<GuiObjectWnd *>(so->vcpu_getInterface(guiObjectWndGuid));
		ASSERT(go != NULL);
		delete go;
	}
	else
	{
		waServiceFactory *sf = o->guiobject_getXuiServiceFactory();
		svc->destroy(o);
		sf->releaseInterface(svc);
	}
}

#ifdef WASABI_COMPILE_WNDMGR
void SkinParser::focusFirst()
{
	foreach(containers)
	for (int j = 0;j < containers.getfor()->getNumLayouts();j++)
	{
		Layout *l = containers.getfor()->enumLayout(j);
		if (l != NULL && l->isVisible())
		{
			l->setFocus();
			return ;
		}
	}
	endfor;
}

#ifdef WA3COMPATIBILITY 
// non portable, the skin might be missing/buggy as hell, we need to use the os' msgbox
void SkinParser::emmergencyReloadDefaultSkin()
{
	if (!Main::revert_on_error)
	{
		if (!STRCASEEQLSAFE("Default", WASABI_API_SKIN->getSkinName()))
		{
			WASABI_API_WND->appdeactivation_setbypass(1);
			Std::messageBox(StringPrintfW(L"Failed to load the skin (%s). Did you remove it ?\nThis could also be due to missing components (ie: wa2skin.wac for winamp 2 skins), please check the skin's documentation.\nReverting to default skin.", WASABI_API_SKIN->getSkinName()), "Error", 0);
			WASABI_API_WND->appdeactivation_setbypass(0);
			Skin::toggleSkin("Default");
		}
		else
		{
			WASABI_API_WND->appdeactivation_setbypass(1);
			Std::messageBox("The default skin did not load any user interface! Ooch! What should I do ? Oh well, good luck...", "Danger Danger Will Robinson!", 0);
			WASABI_API_WND->appdeactivation_setbypass(0);
		}
	}
}
#endif
#endif

GuiObject *SkinParser::xui_new(const wchar_t *classname)
{
	SkinItem *item = guiTree->getXuiGroupDef(classname);
	if (item != NULL)
	{
		Group *old = curGroup;
		const wchar_t *grpid = NULL;
		if (item->getParams() != NULL)
			grpid = item->getParams()->getItemValue(L"id");
		GuiObject *newgrp = NULL;
		if (grpid != NULL)
			newgrp = newDynamicGroup(grpid, GROUP_GROUP);
		curGroup = old;
		if (newgrp != NULL) return newgrp;
	}
	return createExternalGuiObject(classname, NULL, NULL);
}

void SkinParser::xui_delete(GuiObject *o)
{
	destroyGuiObject(o);
}

double SkinParser::getSkinVersion()
{
	return skinversion;
}

void SkinParser::setAllLayoutsRatio(double ra)
{
	foreach(containers)
	Container *c = containers.getfor();
	int n = c->getNumLayouts();
	for (int i = 0;i < n;i++)
	{
		Layout *l = c->enumLayout(i);
		if (l->getNoParent() != 1)
			l->setRenderRatio(ra);
	}
	endfor;
}

void SkinParser::setAllLayoutsTransparency(int v)
{
	foreach(containers)
	Container *c = containers.getfor();
	int n = c->getNumLayouts();
	for (int i = 0;i < n;i++)
	{
		Layout *l = c->enumLayout(i);
		if (l->getNoParent() != 1)
			l->setAlpha(v);
	}
	endfor;
}

Layout *SkinParser::getMainLayout()
{
	foreach(containers)
	Container *c = containers.getfor();
	if (!c->isMainContainer()) continue;
	return c->enumLayout(0);
	endfor;
	return NULL;
}

/*
void SkinParser::setAllLayoutsAutoOpacify(int ao, int force) {
  foreach(containers)
    Container *c = containers.getfor();
    int n = c->getNumLayouts();
    for (int i=0;i<n;i++) {
      Layout *l = c->enumLayout(i);
      if (l->getNoParent() != 1)
        l->setAutoOpacify(ao, force);
    }
  endfor;
}
 
void SkinParser::setAllLayoutsOverrideAlpha(int oa) {
  foreach(containers)
    Container *c = containers.getfor();
    int n = c->getNumLayouts();
    for (int i=0;i<n;i++) {
      Layout *l = c->enumLayout(i);
      if (l->isInited() && l->isTransparencySafe() && l->getTransparencyOverride() == -1) {
        if (l->getNoParent() != 1)
          l->setTransparency(oa);
      }
    }
  endfor;
}
*/

Group *SkinParser::curGroup, *SkinParser::lastCreatedGroup;
int SkinParser::inScripts = 0, SkinParser::inElements = 0, SkinParser::inGroupDef = 0, SkinParser::inGroup = 0, SkinParser::inAccelerators = 0, SkinParser::inStringTable = 0;
int SkinParser::scriptId = 0;
int SkinParser::recording_container = 0;
int SkinParser::recording_groupdef = 0;
int SkinParser::staticloading = 0;
PtrList<parser_status> SkinParser::statusstack;
int SkinParser::instantiatinggroup = 0;
int SkinParser::allowscripts = 0;
skin_xmlreaderparams *SkinParser::groupparams = NULL;
PtrListQuickSorted<xml_tag, XmlTagComp> SkinParser::quickxmltaglist;
double SkinParser::skinversion = 0.0;

#ifdef WASABI_COMPILE_WNDMGR
Container *SkinParser::curContainer, *SkinParser::lastCreatedContainer;
Layout *SkinParser::curLayout;
int SkinParser::inContainer, SkinParser::inLayout;
//PtrList<Container> SkinParser::script_containers;
PtrList<Container> SkinParser::containers;
int SkinParser::centerskin;
int SkinParser::transcientcontainer;
SvcCacheT<svc_xuiObject> *SkinParser::xuiCache;
int SkinParser::loading_main_skinfile = 0;
StringW SkinParser::includepath;
#endif