winamp/Src/Wasabi/api/skin/widgets/group.cpp

#include <precomp.h>
#include <tataki/bitmap/bitmap.h>
#include <api/wnd/popup.h>
#include <api/wndmgr/layout.h>
#include <api/skin/skinparse.h>
//#include <api/skin/widgets/button.h>
//#include <api/core/buttons.h>
#include <api/wnd/wndtrack.h>
#include <api/wac/compon.h>
#include <api/skin/skin.h>
#include <api/wnd/notifmsg.h>
#include <api/config/items/intarray.h>
#include <api/config/items/cfgitem.h>
#include <api/config/items/attribute.h>
#include <api/wndmgr/layout.h>
#include <api/script/script.h>
#include <api/script/scriptmgr.h>
#include <bfc/util/profiler.h>
#include <api/wndmgr/resize.h>
#include <bfc/wasabi_std_wnd.h>
#include <api/wnd/PaintCanvas.h>

#ifndef WM_MOUSEWHEEL
#define WM_MOUSEWHEEL 0x20A
#endif

const wchar_t groupXuiObjectStr[] = L"Group"; // This is the xml tag
char groupXuiSvcName[] = "Group xui object"; // this is the name of the xuiservice

#ifdef WASABI_COMPILE_CONFIG
const wchar_t cfgGroupXuiObjectStr[] = L"CfgGroup"; // This is the xml tag
char cfgGroupXuiSvcName[] = "CfgGroup xui object"; // this is the name of the xuiservice
#endif

XMLParamPair Group::groupParams[] =
    {
        {XUIGROUP_AUTOHEIGHTSOURCE, L"AUTOHEIGHTSOURCE"},
        {XUIGROUP_AUTOWIDTHSOURCE, L"AUTOWIDTHSOURCE"},
        {XUIGROUP_BACKGROUND, L"BACKGROUND"},
        {XUIGROUP_DRAWBACKGROUND, L"DRAWBACKGROUND"},
        {XUIGROUP_DEFAULT_W, L"DEFAULT_W"},
        {XUIGROUP_DEFAULT_H, L"DEFAULT_H"},
        {XUIGROUP_DESIGN_H, L"DESIGN_H"},
        {XUIGROUP_DESIGN_W, L"DESIGN_W"},
        {XUIGROUP_EMBED_XUI, L"EMBED_XUI"},
        {XUIGROUP_INHERIT_CONTENT, L"INHERIT_CONTENT"},
        {XUIGROUP_INHERIT_GROUP, L"INHERIT_GROUP"},
        {XUIGROUP_INSTANCEID, L"INSTANCEID"},
        {XUIGROUP_LOCKMINMAX, L"LOCKMINMAX"},
        {XUIGROUP_MAXIMUM_H, L"MAXIMUM_H"},
        {XUIGROUP_MAXIMUM_W, L"MAXIMUM_W"},
        {XUIGROUP_MINIMUM_H, L"MINIMUM_H"},
        {XUIGROUP_MINIMUM_W, L"MINIMUM_W"},
        {XUIGROUP_NAME, L"NAME"},
        {XUIGROUP_PROPAGATESIZE, L"PROPAGATESIZE"},
        {XUIGROUP_XUITAG, L"XUITAG"},
    };

Group::Group()
{
	scripts_enabled = 1;
	getScriptObject()->vcpu_setInterface(groupGuid, (void *)static_cast<Group *>(this));
	getScriptObject()->vcpu_setClassName(L"Group");
	getScriptObject()->vcpu_setController(groupController);
	background = NULL;
	skinpart = 0;
	captured = 0; resizing = 0;
	x = 0; y = 0;
	size_w = 0; size_h = 0;
	lockminmax = 0;
	propagatesize = 0;
	reg = NULL;
	default_h = AUTOWH;
	default_w = AUTOWH;
	//  allreg = NULL;
	//	subregionlayers = new PtrList<api_window>;
	//	subregiongroups = new PtrList<api_window>;
	deleting = 0;
	moving = 0;
	drawbackground = 0;
	groupmaxheight = AUTOWH;
	groupmaxwidth = AUTOWH;
	groupminheight = AUTOWH;
	groupminwidth = AUTOWH;
	//  regionop = 0;
	//  allsubreg = NULL;
	groups.addItem(this);
	scaledreg = NULL;
	scaledregionvalid = 0;
	autoregionop = 1;
	setRectRgn(0);
	disable_update_pos = 0;
	no_init_on_addchild = 0;
	lastheightsource = lastwidthsource = NULL;
	lastgetwidthbasedon = lastgetheightbasedon = AUTOWH;
	content_item = NULL;

	xuihandle = newXuiHandle();
	CreateXMLParameters(xuihandle);

	design_w = AUTOWH;
	design_h = AUTOWH;
}

void Group::CreateXMLParameters(int master_handle)
{
	//GROUP_PARENT::CreateXMLParameters(master_handle);
		int numParams = sizeof(groupParams) / sizeof(groupParams[0]);
	hintNumberOfParams(xuihandle, numParams);
	for (int i = 0;i < numParams;i++)
	{
		addParam(xuihandle, groupParams[i], XUI_ATTRIBUTE_IMPLIED);
	}
}

Group::~Group()
{
	deleteScripts();
	deleting = 1;
	WASABI_API_WND->skin_unregisterBaseTextureWindow(this);
	while (gui_objects.getNumItems() > 0)
	{
		SkinParser::destroyGuiObject(gui_objects.enumItem(0));
		gui_objects.removeByPos(0);
	}
	delete background;
	delete reg;
	delete scaledreg;
	xuiparams.deleteAll();
	/*  subregionlayers->removeAll();
	  delete subregionlayers;
	  subregiongroups->removeAll();
	  delete subregiongroups;*/
	groups.removeItem(this);
	WASABI_API_SYSCB->syscb_deregisterCallback(static_cast<WndCallbackI*>(this));
}

int Group::isGroup(Group *o)
{
	return groups.haveItem(o);
}

int Group::setXmlParam(const wchar_t *paramname, const wchar_t *strvalue)
{
	if (!WCSICMP(paramname, L"id") && !instanceid.isempty())
		return GROUP_PARENT::setXmlParam(paramname, instanceid);
	return GROUP_PARENT::setXmlParam(paramname, strvalue);
}

int Group::setXuiParam(int _xuihandle, int xuiid, const wchar_t *paramname, const wchar_t *strvalue)
{
	if (xuihandle == _xuihandle)
	{
		switch (xuiid)
		{
		case XUIGROUP_INSTANCEID:
			instanceid = strvalue;
			getGuiObject()->guiobject_setId(instanceid);
			return 1;
		case XUIGROUP_BACKGROUND:
			setBaseTexture(strvalue);
			setDrawBackground(1);
			return 1;
		case XUIGROUP_DRAWBACKGROUND:
			setDrawBackground(WTOI(strvalue));
			return 1;
		case XUIGROUP_DEFAULT_W:
			{
				int w = WTOI(strvalue);
				//getGuiObject()->guiobject_setGuiPosition(NULL, NULL, &w, NULL, NULL, NULL, NULL, NULL);
				default_w = w;
				return 1;
			}
		case XUIGROUP_DEFAULT_H:
			{
				int h = WTOI(strvalue);
				//getGuiObject()->guiobject_setGuiPosition(NULL, NULL, NULL, &h, NULL, NULL, NULL, NULL);
				default_h = h;
				return 1;
			}

		case XUIGROUP_MAXIMUM_H:
			groupmaxheight = WTOI(strvalue);
			return 1;
		case XUIGROUP_MAXIMUM_W:
			groupmaxwidth = WTOI(strvalue);
			return 1;
		case XUIGROUP_MINIMUM_H:
			groupminheight = WTOI(strvalue);
			return 1;
		case XUIGROUP_MINIMUM_W:
			groupminwidth = WTOI(strvalue);
			return 1;
		case XUIGROUP_PROPAGATESIZE:
			propagatesize = WTOI(strvalue);
			return 1;
		case XUIGROUP_LOCKMINMAX:
			lockminmax = WTOI(strvalue);
			return 1;
		case XUIGROUP_NAME:
			setName(strvalue);
			return 1;
		case XUIGROUP_AUTOWIDTHSOURCE:
			setAutoWidthSource(strvalue);
			return 1;
		case XUIGROUP_AUTOHEIGHTSOURCE:
			setAutoHeightSource(strvalue);
			return 1;
		case XUIGROUP_EMBED_XUI:
			xui_embedded_id = strvalue;
			return 1;
		case XUIGROUP_XUITAG:
			return 1;
		case XUIGROUP_INHERIT_GROUP:
			return 1;
		case XUIGROUP_INHERIT_CONTENT:
			return 1;
		case XUIGROUP_DESIGN_W:
			setDesignWidth(WTOI(strvalue));
			return 1;
		case XUIGROUP_DESIGN_H:
			setDesignHeight(WTOI(strvalue));
			return 1;
		}
	}
	return GROUP_PARENT::setXuiParam(_xuihandle, xuiid, paramname, strvalue);
}

void Group::setDesignWidth(int w)
{
	design_w = w;
	if (isPostOnInit())
		onResize();
}

void Group::setDesignHeight(int h)
{
	design_h = h;
	if (isPostOnInit())
		onResize();
}

int Group::getDesignWidth()
{
	return design_w;
}

int Group::getDesignHeight()
{
	return design_h;
}

int Group::onPostedMove()
{
	return GROUP_PARENT::onPostedMove();
}

#ifdef WASABI_COMPILE_WNDMGR
void Group::beginMove()
{
	if (getGuiObject()->guiobject_getParentGroup())
		getGuiObject()->guiobject_getParentGroup()->beginMove();
}

void Group::beginScale()
{
	if (getGuiObject()->guiobject_getParentGroup())
		getGuiObject()->guiobject_getParentGroup()->beginScale();
}

void Group::beginResize()
{
	if (getGuiObject()->guiobject_getParentGroup())
		getGuiObject()->guiobject_getParentGroup()->beginResize();
}

void Group::endMove()
{
	if (getGuiObject()->guiobject_getParentGroup())
		getGuiObject()->guiobject_getParentGroup()->endMove();
}

void Group::endScale()
{
	if (getGuiObject()->guiobject_getParentGroup())
		getGuiObject()->guiobject_getParentGroup()->endScale();
}

void Group::endResize()
{
	if (getGuiObject()->guiobject_getParentGroup())
		getGuiObject()->guiobject_getParentGroup()->endResize();
}
#endif

void Group::onMinMaxEnforcerChanged()
{
	if (!isPostOnInit()) return ;
	int min_x = getPreferences(MINIMUM_W);
	int min_y = getPreferences(MINIMUM_H);
	int max_x = getPreferences(MAXIMUM_W);
	int max_y = getPreferences(MAXIMUM_H);
	int sug_x = getPreferences(SUGGESTED_W);
	int sug_y = getPreferences(SUGGESTED_H);
	min_x = MAX(RESIZE_MINW, min_x);
	min_y = MAX(RESIZE_MINH, min_y);

	RECT r;
	POINT pt;
	getClientRect(&r);
	int w = r.right - r.left;
	int h = r.bottom - r.top;
	getPosition(&pt);
	if ((w < min_x || h < min_y || w > max_x || h > max_y) && (w != sug_x || h != sug_y))
	{
		//DebugString("reapplying minmax constraints\n");
		resize(pt.x, pt.y, sug_x, sug_y);
	}
}

#ifdef WASABI_COMPILE_WNDMGR
void Group::mouseResize(int x, int y, int resizeway)
{ // screen coords!

	int min_x = getPreferences(MINIMUM_W);
	int min_y = getPreferences(MINIMUM_H);
	int max_x = getPreferences(MAXIMUM_W);
	int max_y = getPreferences(MAXIMUM_H);
	int sug_x = getPreferences(SUGGESTED_W);
	int sug_y = getPreferences(SUGGESTED_H);

	if (max_x != AUTOWH && min_x != AUTOWH && max_x < min_x) max_x = min_x;
	if (max_y != AUTOWH && min_y != AUTOWH && max_y < min_y) max_y = min_y;
	if (min_x != AUTOWH && max_x != AUTOWH && min_x > max_x) min_x = max_x;
	if (min_y != AUTOWH && max_y != AUTOWH && min_y > max_y) min_y = max_y;
	if (sug_x != AUTOWH && min_x != AUTOWH && sug_x < min_x) sug_x = min_x;
	if (sug_y != AUTOWH && min_y != AUTOWH && sug_y < min_y) sug_y = min_y;
	if (sug_x != AUTOWH && max_x != AUTOWH && sug_x > max_x) sug_x = max_x;
	if (sug_y != AUTOWH && max_y != AUTOWH && sug_y > max_y) sug_y = max_y;

	beginResize();

	int mask = 0;
	if (resizeway & RESIZE_BOTTOM)
	{
		mask |= BOTTOM;
	}
	if (resizeway & RESIZE_RIGHT)
	{
		mask |= RIGHT;
	}
	if (resizeway & RESIZE_TOP)
	{
		mask |= TOP;
	}
	if (resizeway & RESIZE_LEFT)
	{
		mask |= LEFT;
	}

	min_x = MAX(RESIZE_MINW, min_x);
	min_y = MAX(RESIZE_MINH, min_y);

	if (renderRatioActive())
	{
		if (min_x != AUTOWH) multRatio(&min_x);
		if (min_y != AUTOWH) multRatio(NULL, &min_y);
		if (max_x != AUTOWH) multRatio(&max_x);
		if (max_y != AUTOWH) multRatio(NULL, &max_y);
		if (sug_x != AUTOWH) multRatio(&sug_x);
		if (sug_y != AUTOWH) multRatio(NULL, &sug_y);
	}

	if (min_x == AUTOWH) min_x = -1;
	if (max_x == AUTOWH) max_x = -1;
	if (min_y == AUTOWH) min_y = -1;
	if (max_y == AUTOWH) max_y = -1;
	if (sug_x == AUTOWH) sug_x = -1;
	if (sug_y == AUTOWH) sug_y = -1;

	resizeClass rsize(this, min_x, min_y, max_x, max_y, sug_x, sug_y);
	if (rsize.resizeWindow(this, mask | NOINTERSECT))
	{
		RECT r = rsize.getRect();

		if (renderRatioActive())
		{
			r.right = (int)(((double)(r.right - r.left) / getRenderRatio()) + r.left + 0.5f);
			r.bottom = (int)(((double)(r.bottom - r.top) / getRenderRatio()) + r.top + 0.5f);
		}

		int _min_x = getPreferences(MINIMUM_W);
		int _min_y = getPreferences(MINIMUM_H);
		int _max_x = getPreferences(MAXIMUM_W);
		int _max_y = getPreferences(MAXIMUM_H);

		if (_max_x != AUTOWH && _min_x != AUTOWH && _max_x < _min_x) _max_x = _min_x;
		if (_max_y != AUTOWH && _min_y != AUTOWH && _max_y < _min_y) _max_y = _min_y;
		if (_min_x != AUTOWH && _max_x != AUTOWH && _min_x > _max_x) _min_x = _max_x;
		if (_min_y != AUTOWH && _max_y != AUTOWH && _min_y > _max_y) _min_y = _max_y;

		if (r.right - r.left < _min_x) r.right = r.left + _min_x;
		if (r.bottom - r.top < _min_y) r.bottom = r.top + _min_y;
		if (r.right - r.left > _max_x) r.right = r.left + _max_x;
		if (r.bottom - r.top > _max_y) r.bottom = r.top + _max_y;

		resizeToRect(&r);
		invalidate();
		endResize();
	}
}
#endif

void Group::setAutoWidthSource(const wchar_t *obj)
{
	autowidthsource = obj;
}

void Group::setAutoHeightSource(const wchar_t *obj)
{
	autoheightsource = obj;
}

int Group::getAutoWidth()
{
	return default_w == AUTOWH ? GROUP_PARENT::getPreferences(SUGGESTED_W) : default_w;
}

int Group::getAutoHeight()
{
	return default_h == AUTOWH ? GROUP_PARENT::getPreferences(SUGGESTED_H) : default_h;
}

int Group::getWidthBasedOn(GuiObject *o)
{
	if (o == NULL)
	{
		if (lastwidthsource == NULL)
		{
			if (!autowidthsource.isempty())
			{
				lastwidthsource = getObject(autowidthsource);
			}
		}
		o = lastwidthsource;
	}
	if (o == NULL) return AUTOWH;
	if (lastgetwidthbasedon != AUTOWH) return lastgetwidthbasedon;
	int x, rx, w, rw;
	o->guiobject_getGuiPosition(&x, NULL, &w, NULL, &rx, NULL, &rw, NULL);
	int p = o->guiobject_getAutoWidth();
if (w == AUTOWH) { w = p; rw = 0; }
	if (rx == 0 && rw == 1)
		lastgetwidthbasedon = p - w;
	else if (rx == 0 && rw == 0)
		lastgetwidthbasedon = p + x;
	else
		lastgetwidthbasedon = AUTOWH;

	return lastgetwidthbasedon;
}

int Group::getHeightBasedOn(GuiObject *o)
{
	if (o == NULL)
	{
		if (lastheightsource == NULL)
		{
			if (!autoheightsource.isempty())
			{
				lastheightsource = getObject(autoheightsource);
			}
		}
		o = lastheightsource;
	}
	if (o == NULL) return AUTOWH;
	if (lastgetheightbasedon != AUTOWH) return lastgetheightbasedon;
	int y, ry, h, rh;
	o->guiobject_getGuiPosition(NULL, &y, NULL, &h, NULL, &ry, NULL, &rh);
	int p = o->guiobject_getAutoHeight();
if (h == AUTOWH) { h = p; rh = 0; }
	if (ry == 0 && rh == 1)
		lastgetheightbasedon = p - h;
	else if (ry == 0 && rh == 0)
		lastgetheightbasedon = h + y;
	else
		lastgetheightbasedon = AUTOWH;

	return lastgetheightbasedon;
}

int Group::getPreferences(int what)
{
	int _what = what;
	if (lockminmax)
	{
		if (_what == MAXIMUM_W || _what == MINIMUM_W)
			_what = SUGGESTED_W;
		if (_what == MAXIMUM_H || _what == MINIMUM_H)
			_what = SUGGESTED_H;
	}
	switch (_what)
	{
	case SUGGESTED_W:
		{
			int w, rw;
			getGuiObject()->guiobject_getGuiPosition(NULL, NULL, &w, NULL, NULL, NULL, &rw, NULL);

			if (w == AUTOWH)
				w = getWidthBasedOn();

			if (w == AUTOWH || rw == 1)
				w = getAutoWidth();

			if (w == AUTOWH && getBaseTexture())
				w = getBaseTexture()->getWidth();

			if (groupmaxwidth != AUTOWH)
			{
				if (groupminwidth != AUTOWH)
				{
					return MIN(groupmaxwidth, MAX(groupminwidth, w));
				}
				else
				{
					return MIN(groupmaxwidth, w);
				}
			}
			else if (groupminwidth != AUTOWH)
			{
				return MAX(groupminwidth, w);
			}
			return w;
		}
	case SUGGESTED_H:
		{
			int h, rh;
			getGuiObject()->guiobject_getGuiPosition(NULL, NULL, NULL, &h, NULL, NULL, NULL, &rh);

			if (h == AUTOWH)
				h = getHeightBasedOn();

			if (h == AUTOWH || rh == 1)
				h = getAutoHeight();

			if (h == AUTOWH && getBaseTexture())
				h = getBaseTexture()->getHeight();

			if (groupmaxheight != AUTOWH)
			{
				if (groupminheight != AUTOWH)
				{
					return MIN(groupmaxheight, MAX(groupminheight, h));
				}
				else
				{
					return MIN(groupmaxheight, h);
				}
			}
			else if (groupminheight != AUTOWH)
			{
				return MAX(groupminheight, h);
			}
			return h;
		}
	case MAXIMUM_H:
		{
			int h = GROUP_PARENT::getPreferences(what);

			if (h != AUTOWH)
				return MIN(h, groupmaxheight);

			return groupmaxheight;
		}
	case MAXIMUM_W:
		{
			int w = GROUP_PARENT::getPreferences(what);

			if (w != AUTOWH)
				return MIN(w, groupmaxwidth);

			return groupmaxwidth;
		}
	case MINIMUM_H:
		{
			int h = GROUP_PARENT::getPreferences(what);

			if (h != AUTOWH)
				return MAX(h, groupminheight);

			return groupminheight;
		}
	case MINIMUM_W:
		{
			int w = GROUP_PARENT::getPreferences(what);

			if (w != AUTOWH)
				return MAX(w, groupminwidth);

			return groupminwidth;
		}
	}
	return GROUP_PARENT::getPreferences(what);
}

void Group::updatePos(GuiObject *o, RECT *r2)
{

	if (disable_update_pos) return ;

	RECT r;
	if (r2 == NULL)
	{
		getClientRect(&r);
		r2 = &r;
	}


	double d = getRenderRatio();
	int w, h;
	int ox, oy, ow, oh, orx, ory, orw, orh;
	int ox1, ox2, oy1, oy2, oanchor;

	if (o->guiobject_getAnchoragePosition(&ox1, &oy1, &ox2, &oy2, &oanchor))
	{
		// anchorage values have not been translated into native values yet, do it now
		int x, y, w, h, rx, ry, rw, rh;
		x = y = w = h = rx = ry = rw = rh = AUTOWH;
		int lw = ox2 - ox1;
		int lh = oy2 - oy1;
		int iw = getDesignWidth();
		int ih = getDesignHeight();
		if (iw == AUTOWH || ih == AUTOWH)
		{
			Wasabi::Std::messageBox(L"anchor coordinate system used without design size for the parent group.\nYour parent group needs the design_w/design_h parameters if you are using x1/y1/x2/y2/anchor parameters on one of its children\nDefaulting to 320x200", L"XML Error", 0);
			iw = 320;
			ih = 200;
		}
		int right_m = iw - ox2;
		int bottom_m = ih - oy2;

		if ((oanchor & ANCHOR_LEFT) == 0 && (oanchor & ANCHOR_RIGHT) == 0) oanchor |= ANCHOR_LEFT;
		if ((oanchor & ANCHOR_TOP) == 0 && (oanchor & ANCHOR_BOTTOM) == 0) oanchor |= ANCHOR_TOP;

		if (oanchor & ANCHOR_LEFT)
		{
			x = ox1;
			rx = 0;
			if (oanchor & ANCHOR_RIGHT)
			{
				w = -((iw - ox2) + ox1);
				rw = 1;
			}
			else
			{
				w = lw;
				rw = 0;
			}
		}
		else
		{
			if (oanchor & ANCHOR_RIGHT)
			{
				x = -(right_m + lw);
				rx = 1;
				w = lw;
				rw = 0;
			}
		}
		if (oanchor & ANCHOR_TOP)
		{
			y = oy1;
			ry = 0;
			if (oanchor & ANCHOR_BOTTOM)
			{
				h = -((ih - oy2) + oy1);
				rh = 1;
			}
			else
			{
				h = lh;
				rh = 0;
			}
		}
		else
		{
			if (oanchor & ANCHOR_BOTTOM)
			{
				y = -(bottom_m + lh);
				ry = 1;
				h = lh;
				rh = 0;
			}
		}
		disable_update_pos = 1;
		o->guiobject_setGuiPosition(&x, &y, &w, &h, &rx, &ry, &rw, &rh);
		o->guiobject_validateAnchorage();
		disable_update_pos = 0;
	}

	o->guiobject_getGuiPosition(&ox, &oy, &ow, &oh, &orx, &ory, &orw, &orh);
	if (ow == AUTOWH) { ow = o->guiobject_getAutoWidth(); orw = 0; }
	if (oh == AUTOWH) { oh = o->guiobject_getAutoHeight(); orh = 0; }

	TextInfoCanvas fontInfoCanvas(this);
	double fontScale = fontInfoCanvas.getSystemFontScale();
	if (o->guiobject_getAutoSysMetricsX())
		ox = (int)((float)ox * fontScale);

	if (o->guiobject_getAutoSysMetricsY())
		oy = (int)((float)oy * fontScale);

	if (o->guiobject_getAutoSysMetricsW())
		ow = (int)((float)ow * fontScale);

	if (o->guiobject_getAutoSysMetricsH())
		oh = (int)((float)oh * fontScale);

	if (!o->guiobject_getRootWnd()->handleRatio())
	{
		if (orw == 1)
			w = (int)((float)(r2->right - r2->left + ow) * d);
		else if (orw == 2)
			w = (int)(((float)(r2->right - r2->left) * ((float)ow / 100.0f)) * d);
		else
			w = (int)((float)(ow) * d);
		if (orh == 1)
			h = (int)((float)(r2->bottom - r2->top + oh) * d);
		else if (orh == 2)
			h = (int)(((float)(r2->bottom - r2->top) * ((float)oh / 100.0f)) * d);
		else
			h = (int)((float)(oh) * d);
		if (orx == 1)
			x = (int)((float)(r2->right - r2->left + ox) * d);
		else if (orx == 2)
			x = (int)(((float)(r2->right - r2->left) * ((float)ox / 100.0f)) * d);
		else
			x = (int)((float)(ox) * d);
		if (ory == 1)
			y = (int)((float)(r2->bottom - r2->top + oy) * d);
		else if (ory == 2)
			y = (int)(((float)(r2->bottom - r2->top) * ((float)oy / 100.0f)) * d);
		else
			y = (int)((float)(oy) * d);
		x += (int)((float)(r2->left) * d);
		y += (int)((float)(r2->top) * d);
	}
	else
	{
		if (orw == 1)
			w = r2->right - r2->left + ow;
		else if (orw == 2)
			w = (int)((float)(r2->right - r2->left) * ((float)ow / 100.0f));
		else
			w = ow;
		if (orh == 1)
			h = r2->bottom - r2->top + oh;
		else if (orh == 2)
			h = (int)((float)(r2->bottom - r2->top) * ((float)oh / 100.0f));
		else
			h = oh;
		if (orx == 1)
			x = r2->right - r2->left + ox;
		else if (orx == 2)
			x = (int)((float)(r2->right - r2->left) * ((float)ox / 100.0f));
		else
			x = ox;
		if (ory == 1)
			y = r2->bottom - r2->top + oy;
		else if (ory == 2)
			y = (int)((float)(r2->bottom - r2->top) * ((float)oy / 100.0f));
		else
			y = oy;
		x += r2->left;
		y += r2->top;
	}

	o->guiobject_getRootWnd()->resize(x, y, w, h);
}


int Group::onResize()
{
	GROUP_PARENT::onResize();
	if (!isInited()) return 1;

	RECT wr;
	getWindowRect(&wr);
	RECT r2;
	getClientRect(&r2);
	size_w = r2.right - r2.left; size_h = r2.bottom - r2.top;
	for (int i = 0;i < gui_objects.getNumItems();i++)
	{
		GuiObject *o = gui_objects.enumItem(i);
		updatePos(o, &r2);
	}
	invalidateScaledReg();
	return 1;
}

void Group::invalidateScaledReg()
{
	scaledregionvalid = 0;
	invalidateWindowRegion();
}

int Group::onInit()
{
	GROUP_PARENT::onInit();

	WASABI_API_SYSCB->syscb_registerCallback(static_cast<WndCallbackI*>(this));

	disable_update_pos = 1;
	no_init_on_addchild = 1;

	const wchar_t *id = getGroupContentId();
	SkinItem *item = getGroupContentSkinItem();
	if ((id && *id) || item != NULL)
	{
		SkinParser::fillGroup(this, id, item, 0, 1, scripts_enabled);
	}

	disable_update_pos = 0;
	no_init_on_addchild = 0;

	onFillGroup();

	return 1;
}

void Group::onFillGroup()
{
	reloadDefaults();
	if (xui_embedded_id.len() > 0)
		embeddedxui_onNewEmbeddedContent();
}

int Group::onGroupChange(const wchar_t *id)
{
	GROUP_PARENT::onGroupChange(id);

	if (!isInited()) return 1;
	const wchar_t *cid = getGroupContentId();
	SkinItem *item = getGroupContentSkinItem();
	if (!(cid && *cid) || item != NULL) return 1;

	if (!WCSICMP(id, cid)) return 1;

	deleteScripts();

	WASABI_API_WND->skin_unregisterBaseTextureWindow(this);
	while (gui_objects.getNumItems() > 0)
	{
		SkinParser::destroyGuiObject(gui_objects.enumItem(0));
	}

	delete background; background = NULL;
	delete reg; reg = NULL;
	delete scaledreg; scaledreg = NULL;

	disable_update_pos = 1;
	no_init_on_addchild = 1;

	SkinParser::fillGroup(this, cid, item, 0, 1, scripts_enabled);

	disable_update_pos = 0;
	no_init_on_addchild = 0;

	onFillGroup();
	if (isInited())
		onResize();

	getGuiObject()->guiobject_onStartup();

	return 1;
}

void Group::reloadDefaults()
{
	getGuiObject()->guiobject_getGuiPosition(NULL, NULL, &size_w, &size_h, NULL, NULL, NULL, NULL);
	if (size_w == AUTOWH && size_h == AUTOWH)
	{
		/*    if (!background) {
		      size_w = 250;
		      size_h = 100;
		    } else {
		      size_w = background->getWidth();
		      size_h = background->getHeight();
		    }*/
		if (background)
		{
			setPreferences(SUGGESTED_W, background->getWidth());
			setPreferences(SUGGESTED_H, background->getHeight());
		}
		size_w = GROUP_PARENT::getPreferences(SUGGESTED_W);
		size_h = GROUP_PARENT::getPreferences(SUGGESTED_H);
	}
	//setName(getGuiObject()->guiobject_getId());

	if (propagatesize)
	{
		Layout *l = getGuiObject()->guiobject_getParentLayout();
		if (l) l->addMinMaxEnforcer(this);
	}

	int i;
	for (i = 0;i < gui_objects.getNumItems();i++)
	{

		GuiObject *o = gui_objects.enumItem(i);

		if (o->guiobject_getParentGroup())
		{
			o->guiobject_getRootWnd()->setParent(o->guiobject_getParentGroup());
			if (!o->guiobject_getRootWnd()->isInited())
			{
				o->guiobject_getRootWnd()->init(o->guiobject_getParentGroup());
				o->guiobject_getParentGroup()->onCreateObject(getGuiObject());
			}
		}
	}

	/*  if (getGuiObject()->guiobject_getParentGroup() && regionop)
	    getGuiObject()->guiobject_getParentGroup()->addSubRegionGroup(this);*/

	invalidateWindowRegion();

	startScripts();

	for (i = 0;i < gui_objects.getNumItems();i++)
	{
		GuiObject *o = gui_objects.enumItem(i);
		o->guiobject_onStartup();
	}

	autoResize();

	const wchar_t *name = getName();
	if (name != NULL)
		onSetName();
}

void Group::startScripts()
{
	for (int i = 0;i < getNumScripts();i++)
	{
		int vcpuid = enumScript(i);
		SystemObject *o = SOM::getSystemObjectByScriptId(vcpuid);
		if (o != NULL)
		{
			o->onLoad();
			foreach(xuiparams)
			XuiParam *p = xuiparams.getfor();
			o->onSetXuiParam(p->param, p->value);
			endfor;
		}
	}
}

int Group::onPaint(Canvas *canvas)
{
	PaintCanvas paintcanvas;
	if (canvas == NULL)
	{
		if (!paintcanvas.beginPaint(this)) return 0;
		canvas = &paintcanvas;
	}
	GROUP_PARENT::onPaint(canvas);
	RECT r;
	if (!canvas->getClipBox(&r))
		getClientRect(&r);


	if (getDrawBackground()) RenderBaseTexture(canvas, r);
	return 1;
}

ifc_window *Group::getBaseTextureWindow()
{
	if (reg && !reg->isEmpty()) return this;
	if (getParent()) return getParent()->getBaseTextureWindow();
	return this;
}

void Group::autoResize()
{
	int w = getWidthBasedOn();
	int h = getHeightBasedOn();
	if (h == AUTOWH && w == AUTOWH) return ;
	resize(NOCHANGE, NOCHANGE, w == AUTOWH ? NOCHANGE : w, h == AUTOWH ? NOCHANGE : h);
}

int Group::childNotify(ifc_window *child, int msg, intptr_t p1, intptr_t p2)
{
	if (msg == ChildNotify::AUTOWHCHANGED)
	{
		if (lastwidthsource && child == lastwidthsource->guiobject_getRootWnd() ||
		    lastheightsource && child == lastheightsource->guiobject_getRootWnd())
		{
			lastgetwidthbasedon = AUTOWH;
			lastgetheightbasedon = AUTOWH;
			autoResize();
		}
	}
	if (!getParent())
		return 0;
	return getParent()->childNotify(child, msg, p1, p2);
}


void Group::sendNotifyToAllChildren(int notifymsg, intptr_t param1, intptr_t param2)
{
	for (int i = 0;i < gui_objects.getNumItems();i++)
		gui_objects.enumItem(i)->guiobject_getRootWnd()->childNotify(this, notifymsg, param1, param2);
}

void Group::addScript(int scriptid)
{
	scripts.addItem(scriptid);
}

int Group::getNumScripts()
{
	return scripts.getNumItems();
}

int Group::enumScript(int n)
{
	return scripts.enumItem(n);
}

void Group::deleteScripts()
{
	for (int i = 0;i < scripts.getNumItems();i++)
		Script::unloadScript(scripts.enumItem(i));
	scripts.removeAll();
}

SkinBitmap *Group::getBaseTexture()
{
	if (!background) return NULL;
	return background->getBitmap();
}

void Group::setBaseTexture(const wchar_t *b, int regis)
{
	backgroundstr = b;
	if (regis) WASABI_API_WND->skin_unregisterBaseTextureWindow(this);
	delete background;
	background = NULL;
	if (b != NULL && *b)
	{
		background = new AutoSkinBitmap();
		background->setBitmap(b);
#ifdef _WIN32
		RegionI r(background->getBitmap());
		setRegion(&r);
#else
#warning port me!
#endif

		if (regis) WASABI_API_WND->skin_registerBaseTextureWindow(this, b);
	}
	else
	{
		delete reg;
		reg = NULL;
		delete scaledreg;
		scaledreg = NULL;
		invalidateWindowRegion();
	}

}

const wchar_t *Group::getBackgroundStr()
{
	return backgroundstr;
}

int Group::onUnknownXuiParam(const wchar_t *xmlattributename, const wchar_t *value)
{
	int r = GROUP_PARENT::onUnknownXuiParam(xmlattributename, value);
	if (r == 0)
	{
		if (!isInited())
		{
			xuiparams.addItem(new XuiParam(xmlattributename, value));
		}
		else
		{
			for (int i = 0;i < getNumScripts();i++)
			{
				int vcpuid = enumScript(i);
				SystemObject *o = SOM::getSystemObjectByScriptId(vcpuid);
				if (o != NULL) o->onSetXuiParam(xmlattributename, value);
			}
		}
	}
	return r;
}

api_region *Group::getRegion()
{
	ensureScaledRegValid();
	return scaledreg;
}

void Group::ensureScaledRegValid()
{
	if (!scaledregionvalid)
	{
		scaledregionvalid = 1;
		if (!reg) return ;
		if (!scaledreg) scaledreg = new RegionI;
		scaledreg->empty();
		scaledreg->addRegion(reg);
		RECT rr;
		getNonClientRect(&rr);
		if (background)
		{
			float w = (float)(rr.right - rr.left) / (float)background->getWidth();
			float h = (float)(rr.bottom - rr.top) / (float)background->getHeight();
			if (w && h && (ABS(w - 1.0f) > 0.01f || ABS(h - 1.0f) > 0.01f))
				scaledreg->scale(w, h, 1);
			else if (w == 0 || h == 0)
			{
				RECT r = {0, 0, 0, 0};
				scaledreg->setRect(&r);
			}
		}
	}
}

void Group::setRegion(api_region *r)
{
	ASSERT(r != NULL);
	if (!reg) reg = new RegionI;

	reg->empty();
	reg->addRegion(r); // background

	invalidateWindowRegion();
	invalidateScaledReg();
}

Container *Group::getParentContainer()
{
	if (!getGuiObject()->guiobject_getParentGroup())
	{
		ifc_window *r = getDesktopParent();
		if (r != NULL)
		{
			//ASSERT(r != NULL);
			Layout *l = static_cast<Layout *>(r->getInterface(layoutGuid));
			if (!l) return NULL;
			return l->getParentContainer();
		}
	}
	Group *g = getGuiObject()->guiobject_getParentGroup();
	if (g) return g->getParentContainer();
	return NULL;
}

ifc_window *Group::enumObjects(int i)
{
	if (i >= gui_objects.getNumItems()) return NULL;
	return gui_objects.enumItem(i)->guiobject_getRootWnd();
}

int Group::getNumObjects()
{
	return gui_objects.getNumItems();
}

void Group::addChild(GuiObject *g)
{
	gui_objects.addItem(g);
	script_objects.addItem((ScriptObject *)g);
	g->guiobject_setParentGroup(this);
	g->guiobject_getRootWnd()->setParent(this);
	if (!no_init_on_addchild && isInited()
		&& !g->guiobject_getRootWnd()->isInited()) 
		g->guiobject_getRootWnd()->init(this);
}

void Group::removeChild(GuiObject *g)
{
	if (!deleting)
		gui_objects.removeItem(g);
	script_objects.removeItem((ScriptObject *)g);
}

void Group::onCreateObject(GuiObject *o)
{
	script_vcpu_onCreateObject(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_OBJECT(o->guiobject_getScriptObject()));
}

int Group::getDrawBackground()
{
	return drawbackground;
}

void Group::setDrawBackground(int t)
{
	drawbackground = t;
}

int Group::isLayout()
{
	return 0;
}

int Group::isDesktopAlphaSafe()
{
	if (!Wasabi::Std::Wnd::isDesktopAlphaAvailable()) return 0;
	for (int i = 0;i < getNumObjects();i++)
	{
		ifc_window *w = enumObjects(i);
		Group *cg = static_cast<Group *>(w);
		if (Group::isGroup(cg))
			if (!cg->isDesktopAlphaSafe()) return 0;
		if (!w->handleDesktopAlpha()) return 0;
	}
	return 1;
}

int Group::isTransparencySafe(int excludeme)
{
	if (!Wasabi::Std::Wnd::isTransparencyAvailable()) return 0;
	if (!excludeme && isTransparencyForcedOff()) return 0;
	for (int i = 0;i < getNumObjects();i++)
	{
		ifc_window *w = enumObjects(i);
		Group *cg = static_cast<Group *>(w);
		if (Group::isGroup(cg))
			if (!cg->isTransparencySafe()) return 0;
		if (!w->handleTransparency()) return 0;
	}
	return 1;
}

GuiObject *Group::getObject(const wchar_t *id)
{
	for (int i = 0;i < script_objects.getNumItems();i++)
	{
		if (!WCSICMP(id, gui_objects.enumItem(i)->guiobject_getId()))
		{
			return gui_objects.enumItem(i);
		}
	}
	return NULL;
}

void Group::setGroupContent(const wchar_t *id, SkinItem *item, int allowscripts)
{
	content_id = id;
	content_item = item;
	scripts_enabled = allowscripts;
}

const wchar_t *Group::getGroupContentId()
{
	return content_id;
}

SkinItem *Group::getGroupContentSkinItem()
{
	return content_item;
}

ScriptObject *Group::script_cast(GUID g)
{
	GuiObject *o = embeddedxui_getEmbeddedObject();
	if (o != NULL)
	{
		void *r = o->guiobject_getScriptObject()->vcpu_getInterface(g);
		if (r != NULL)
		{
			return o->guiobject_getScriptObject();
		}
	}
	return NULL;
}

// -----------------------------------------------------------------------

GroupScriptController _groupController;
GroupScriptController *groupController = &_groupController;

// -- Functions table -------------------------------------
function_descriptor_struct GroupScriptController::exportedFunction[] = {
            {L"getObject", 1, (void*)Group::script_vcpu_getObject },
            {L"enumObject", 1, (void*)Group::script_vcpu_enumObject },
            {L"getNumObjects", 0, (void*)Group::script_vcpu_getNumObjects },
            {L"onCreateObject", 1, (void*)Group::script_vcpu_onCreateObject },
            {L"getMousePosX", 0, (void*)Group::script_vcpu_getMousePosX },
            {L"getMousePosY", 0, (void*)Group::script_vcpu_getMousePosY },
            {L"isLayout", 0, (void*)Group::script_vcpu_isLayout },
            {L"autoResize", 0, (void*)Group::script_vcpu_autoResize},
        };
// --------------------------------------------------------

ScriptObject *GroupScriptController::cast(ScriptObject *o, GUID g)
{
	Group *grp = static_cast<Group *>(o->vcpu_getInterface(groupGuid));
	if (grp != NULL)
		return grp->script_cast(g);
	return NULL;
}

const wchar_t *GroupScriptController::getClassName()
{
	return L"Group";
}

const wchar_t *GroupScriptController::getAncestorClassName()
{
	return L"GuiObject";
}

int GroupScriptController::getInstantiable()
{
	return 1;
}

ScriptObject *GroupScriptController::instantiate()
{
	return NULL;
}

void GroupScriptController::destroy(ScriptObject *o)
{}

void *GroupScriptController::encapsulate(ScriptObject *o)
{
	return NULL;
}

void GroupScriptController::deencapsulate(void *o)
{}

int GroupScriptController::getNumFunctions()
{
	return sizeof(exportedFunction) / sizeof(function_descriptor_struct);
}

const function_descriptor_struct *GroupScriptController::getExportedFunctions()
{
	return exportedFunction;
}

GUID GroupScriptController::getClassGuid()
{
	return groupGuid;
}


const wchar_t *Group::vcpu_getClassName()
{
	return L"Group";
}


void Group::addObject(GuiObject *o)
{
	addChild(o);
}

void Group::removeObject(GuiObject *o)
{
	removeChild(o);
}

void Group::setRegionOp(int o)
{
	GROUP_PARENT::setRegionOp(o);
	autoregionop = 0;
}

void Group::invalidateWindowRegion()
{
	GROUP_PARENT::invalidateWindowRegion();
	if (!isInited() || isLayout()) return ;
	if (autoregionop)
	{
		int yes = 0;
		for (int i = 0;i < gui_objects.getNumItems();i++)
		{
			if (gui_objects.enumItem(i)->guiobject_getRegionOp() != REGIONOP_NONE)
			{
				yes = 1;
				break;
			}
		}
		if (yes)
			GROUP_PARENT::setRegionOp(REGIONOP_OR);
		else
			GROUP_PARENT::setRegionOp(REGIONOP_NONE);
	}
}

// VCPU

scriptVar Group::script_vcpu_onCreateObject(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar ob)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS1(o, groupController, ob);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT1(o, ob);
}

// Get an object from its ID
scriptVar Group::script_vcpu_getObject(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar obj)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(obj.type == SCRIPT_STRING); // compiler discarded
	Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid));
	GuiObject *ob = NULL;
	if (g)
		ob = g->getObject(GET_SCRIPT_STRING(obj));
	return MAKE_SCRIPT_OBJECT(ob ? ob->guiobject_getScriptObject() : NULL);
}

scriptVar Group::script_vcpu_getMousePosX(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid));
	if (g)
	{
		POINT pt;
		Wasabi::Std::getMousePos(&pt);
		g->screenToClient(&pt);
		return MAKE_SCRIPT_INT(pt.x);
	}
	RETURN_SCRIPT_ZERO;
}

scriptVar Group::script_vcpu_getMousePosY(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid));
	if (g)
	{
		POINT pt;
		Wasabi::Std::getMousePos(&pt);
		g->screenToClient(&pt);
		return MAKE_SCRIPT_INT(pt.y);
	}
	RETURN_SCRIPT_ZERO;
}

scriptVar Group::script_vcpu_getNumObjects(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid));
	if (g) return MAKE_SCRIPT_INT(g->getNumObjects());
	RETURN_SCRIPT_ZERO;
}

scriptVar Group::script_vcpu_enumObject(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar i)
{
	SCRIPT_FUNCTION_INIT
	Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid));
	GuiObject *obj = NULL;
	if (g)
		obj = g->gui_objects.enumItem(GET_SCRIPT_INT(i));
	return MAKE_SCRIPT_OBJECT(obj ? obj->guiobject_getScriptObject() : NULL);
}

scriptVar Group::script_vcpu_isLayout(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid));
	return MAKE_SCRIPT_BOOLEAN(g ? g->isLayout() : NULL);
}

scriptVar Group::script_vcpu_autoResize(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid));
	if (g != NULL) g->autoResize();
	RETURN_SCRIPT_VOID
}

#ifdef WASABI_COMPILE_CONFIG

int Group::isCfgGroup(Group *ptr)
{
	CfgGroup *g = static_cast<CfgGroup *>(ptr);
	return cfggrouplist.haveItem(g);
}

#endif

PtrList<CfgGroup> Group::cfggrouplist;
PtrList<Group> Group::groups;

// ---------------------------------------------------------------
// Config Groups


#ifdef WASABI_COMPILE_CONFIG

CfgGroup::CfgGroup()
{
	getScriptObject()->vcpu_setInterface(cfgGroupGuid, (void *)static_cast<CfgGroup *>(this));
	getScriptObject()->vcpu_setClassName(L"CfgGroup");
	getScriptObject()->vcpu_setController(cfgGroupController);
	cfgitem = NULL;
	cfggrouplist.addItem(this);
}

CfgGroup::~CfgGroup()
{
	if (cfgitem) viewer_delViewItem(cfgitem);
	cfggrouplist.removeItem(this);
}

const wchar_t *CfgGroup::vcpu_getClassName()
{
	return L"CfgGroup";
}

void CfgGroup::setAttr(CfgItem *item, const wchar_t *name)
{
	if (cfgitem) viewer_delViewItem(cfgitem);
	cfgitem = item;
	attrname = name;
	if (cfgitem != NULL)
	{
		wchar_t t[256] = L"";
		nsGUID::toCharW(cfgitem->getGuid(), t);
		cfgguid = t;
	}
	if (cfgitem) viewer_addViewItem(cfgitem);
	dataChanged();
}

int CfgGroup::viewer_onEvent(CfgItem *item, int event, intptr_t param, void *ptr, size_t ptrlen)
{
	dataChanged();
	return 1;
}

int CfgGroup::onInit()
{
	int r = Group::onInit();
	dataChanged();
	return r;
}

void CfgGroup::dataChanged()
{
	script_vcpu_onCfgChanged(SCRIPT_CALL, getScriptObject());
}

CfgItem *CfgGroup::getCfgItem()
{
	return cfgitem;
}

const wchar_t *CfgGroup::getAttributeName()
{
	return attrname;
}

scriptVar CfgGroup::script_vcpu_cfgGetInt(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid));
	if (cg)
	{
		CfgItem *i = cg->getCfgItem();
		const wchar_t *attrname = cg->getAttributeName();
		if (o != NULL && attrname != NULL)
			return MAKE_SCRIPT_INT(i->getDataAsInt(attrname, 0));
	}
	return MAKE_SCRIPT_INT(0);
}

scriptVar CfgGroup::script_vcpu_cfgSetInt(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar v)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(SOM::isNumeric(&v));
	CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid));
	if (cg)
	{
		CfgItem *i = cg->getCfgItem();
		const wchar_t *attrname = cg->getAttributeName();
		if (o != NULL && attrname != NULL)
		{
			i->setDataAsInt(attrname, GET_SCRIPT_INT(v));
		}
	}
	RETURN_SCRIPT_VOID;
}

scriptVar CfgGroup::script_vcpu_cfgGetString(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid));
	if (cg)
	{
		CfgItem *i = cg->getCfgItem();
		const wchar_t *a = cg->getAttributeName();
		*txt = 0;
		if (!i || !a) 
			return MAKE_SCRIPT_STRING(txt);
		if (o != NULL && a != NULL)
		{
			i->getData(a, txt, 512);
		}
		return MAKE_SCRIPT_STRING(txt);
	}
	return MAKE_SCRIPT_STRING(L"");
}

scriptVar CfgGroup::script_vcpu_cfgSetString(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar v)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(!SOM::isNumeric(&v));
	CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid));
	if (cg)
	{
		CfgItem *i = cg->getCfgItem();
		const wchar_t *a = cg->getAttributeName();
		if (!i || !a) RETURN_SCRIPT_VOID;
		if (o != NULL && a != NULL)
		{
			i->setData(a, GET_SCRIPT_STRING(v));
		}
	}
	RETURN_SCRIPT_VOID;
}

scriptVar CfgGroup::script_vcpu_cfgGetFloat(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid));
	if (cg)
	{
		CfgItem *i = cg->getCfgItem();
		const wchar_t *attrname = cg->getAttributeName();
		if (o != NULL && attrname != NULL)
			return MAKE_SCRIPT_FLOAT((float)i->getDataAsFloat(attrname, 0));
	}
	return MAKE_SCRIPT_FLOAT(0);
}

scriptVar CfgGroup::script_vcpu_cfgSetFloat(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar v)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(SOM::isNumeric(&v));
	CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid));
	if (cg)
	{
		CfgItem *i = cg->getCfgItem();
		const wchar_t *attrname = cg->getAttributeName();
		if (o != NULL && attrname != NULL)
		{
			i->setDataAsFloat(attrname, GET_SCRIPT_FLOAT(v));
		}
	}
	RETURN_SCRIPT_VOID;
}

scriptVar CfgGroup::script_vcpu_cfgGetName(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid));

	if (cg) 
	{
		return MAKE_SCRIPT_STRING(cg->getAttributeName()); 
	}
	return MAKE_SCRIPT_STRING(L"");
}

scriptVar CfgGroup::script_vcpu_cfgGetGuid(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid));
	if (cg) 
		return MAKE_SCRIPT_STRING(cg->getCfgGuid()); 
	return MAKE_SCRIPT_STRING(L"");
}


scriptVar CfgGroup::script_vcpu_onCfgChanged(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS0(o, cfgGroupController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

CfgGroupScriptController _cfgGroupController;
CfgGroupScriptController *cfgGroupController = &_cfgGroupController;

// -- Functions table -------------------------------------
function_descriptor_struct CfgGroupScriptController::exportedFunction[] = {
            {L"cfgGetInt", 0, (void*)CfgGroup::script_vcpu_cfgGetInt },
            {L"cfgSetInt", 1, (void*)CfgGroup::script_vcpu_cfgSetInt },
            {L"cfgGetFloat", 0, (void*)CfgGroup::script_vcpu_cfgGetFloat },
            {L"cfgSetFloat", 1, (void*)CfgGroup::script_vcpu_cfgSetFloat },
            {L"cfgGetString", 0, (void*)CfgGroup::script_vcpu_cfgGetString },
            {L"cfgSetString", 1, (void*)CfgGroup::script_vcpu_cfgSetString },
            {L"onCfgChanged", 0, (void*)CfgGroup::script_vcpu_onCfgChanged },
            {L"cfgGetName", 0, (void*)CfgGroup::script_vcpu_cfgGetName },
            {L"cfgGetGuid", 0, (void*)CfgGroup::script_vcpu_cfgGetGuid},
        };

/*SET_HIERARCHY(Group, SCRIPT_LAYOUT);
SET_HIERARCHY2(Group, SCRIPT_LAYOUT, LAYOUT_SCRIPTPARENT);*/

const wchar_t *CfgGroupScriptController::getClassName()
{
	return L"CfgGroup";
}

const wchar_t *CfgGroupScriptController::getAncestorClassName()
{
	return L"Group";
}

int CfgGroupScriptController::getInstantiable()
{
	return 1;
}

ScriptObject *CfgGroupScriptController::instantiate()
{
	return NULL;
}

int CfgGroupScriptController::getNumFunctions()
{
	return sizeof(exportedFunction) / sizeof(function_descriptor_struct);
}

const function_descriptor_struct *CfgGroupScriptController::getExportedFunctions()
{
	return exportedFunction;
}

GUID CfgGroupScriptController::getClassGuid()
{
	return cfgGroupGuid;
}

wchar_t CfgGroup::txt[512] = L"";

#endif // config