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

#include <precomp.h>
#include "layer.h"
#include <api/wndmgr/resize.h>
#include <api/wnd/cwndtrack.h>
#ifdef WASABI_COMPILE_WNDMGR
#include <api/wndmgr/layout.h>
#include <api/wac/compon.h>
#endif
#ifdef WASABI_COMPILE_COMPONENTS
#include <api/script/objects/compoobj.h>
#endif
#include <api/skin/skinparse.h>
#if defined(WA3COMPATIBILITY) || defined(GEN_FF)
#include <api/skin/widgets/fx_dmove.h>
#endif
#include <api/script/objects/sregion.h>

#include <api/script/script.h>
#include <api/script/scriptmgr.h>
#include <api/service/svcs/svc_action.h>
#include <api/script/vcpu.h>
#include <api/wnd/notifmsg.h>
#include <tataki/canvas/bltcanvas.h>
#include <api/wnd/PaintCanvas.h>

#define SNAP_X 1
#define SNAP_Y 1
#define FX_TIMER 0x0A1C

const wchar_t layerXuiObjectStr[] = L"Layer"; // This is the xml tag
char layerXuiSvcName[] = "Layer xui object"; // this is the name of the xuiservice

XMLParamPair Layer::params[] =
  {
		{LAYER_SETMYCURSOR, L"CURSOR"},
    {LAYER_SETDBLCLICKACTION, L"DBLCLICKACTION"},
		{LAYER_DBLCLICKPARAM, L"DBLCLICKPARAM"}, 
    {LAYER_SETIMAGE, L"IMAGE"},
    {LAYER_SETINACTIVEIMAGE, L"INACTIVEIMAGE"},
		{LAYER_SETQUALITY, L"QUALITY"},
    {LAYER_SETREGION, L"REGION"},
    {LAYER_SETRESIZE, L"RESIZE"},
    {LAYER_SETSCALE, L"SCALE"},
    {LAYER_SETTILE, L"TILE"},
	
  };

Layer::Layer()
		: resizer(0), resizeway(0), scaler(0), scalerway(0), scaling(0),
		  rgn(NULL), secrgn(NULL), rgnclone(NULL), fx_wrap(0), fx_rect(0),
		  fx_dmove(NULL)
{
	getScriptObject()->vcpu_setInterface(layerGuid, (void *)static_cast<Layer *>(this));
	getScriptObject()->vcpu_setClassName(L"Layer");
	getScriptObject()->vcpu_setController(layerController);
	resizerect = 1;
	tiling = 0;
	l_customcursor = false;
	hasInactiveImage = 0;
	fx_on = 0;
	fx_bgfx = 0;
	fx_grid_x = 16;
	fx_grid_y = 16;
	fx_bilinear = 1;
	fx_alphamode = 0;
	fx_delay = 35;
	fx_timeron = 0;
	fx_clear = 1;
	fx_local = 1;
	fx_realtime = 0;
	last_w = last_h = -1;
	getGuiObject()->guiobject_setMover(1);
	setRectRgn(1);
	xuihandle = newXuiHandle();
CreateXMLParameters(xuihandle);
	
}

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

Layer::~Layer()
{
	WASABI_API_SYSCB->syscb_deregisterCallback(static_cast<SkinCallbackI*>(this));
	delete rgnclone;
	delete rgn;
	delete secrgn;
	delete fx_dmove;
}

int Layer::onInit()
{
	LAYER_PARENT::onInit();
	WASABI_API_SYSCB->syscb_registerCallback(static_cast<SkinCallbackI*>(this));
	return 1;
}


int Layer::onPaint(Canvas *canvas)
{
	PaintCanvas paintcanvas;
	if (canvas == NULL)
	{
		if (!paintcanvas.beginPaint(this)) return 0;
		canvas = &paintcanvas;
	}
	LAYER_PARENT::onPaint(canvas);

	if (!getBitmap()) return 0;

	int talpha = getPaintingAlpha();

	RegionI *orig = NULL;

	if (secrgn)
	{
		orig = new RegionI(canvas);
		api_region *clone = orig->clone();
		api_region *secclone = secrgn->clone();
		RECT dr;
		getClientRect(&dr);
		secclone->offset(dr.left, dr.top);
		clone->andRegion(secclone);
		canvas->selectClipRgn(clone);
		orig->disposeClone(clone);
		secrgn->disposeClone(secclone);
	}

	RECT r, srcR, cb, cr;
	getClientRect(&srcR);
	r = cr = srcR;

	if (canvas->getClipBox(&cb))
	{
		r.left = MAX(r.left, cb.left);
		r.top = MAX(r.top, cb.top);
		r.right = MIN(r.right, cb.right);
		r.bottom = MIN(r.bottom, cb.bottom);
		srcR = r;
	}

	layer_adjustDest(&cr);
	layer_adjustDest(&r);


#if defined(WA3COMPATIBILITY) || defined(GEN_FF)
	int bmw = getBitmap()->getWidth();
	int bmh = getBitmap()->getHeight();
	int bmpitch = getBitmap()->getFullWidth();
	int *bmbits = (int*)getBitmap()->getBits();

	if (bmbits) bmbits += getBitmap()->getX() + getBitmap()->getY() * bmpitch;
#endif

	if (getWidth() == (cr.right - cr.left) && getHeight() == (cr.bottom - cr.top))
	{
		int w = r.right - r.left, h = r.bottom - r.top;
		srcR.top = r.top - cr.top;
		srcR.left = r.left - cr.left;
		srcR.top += getSourceOffsetY();
		srcR.left += getSourceOffsetX();
		srcR.bottom = srcR.top + h;
		srcR.right = srcR.left + w;
		// FG> NOT READY FOR OPTIMIZATION YET
#if defined(WA3COMPATIBILITY) || defined(GEN_FF)
		if (fx_on && fx_dmove && bmbits)
		{

			if (fx_bgfx)
			{
				if (!fx_dmove->getBltCanvas() || !fx_dmove->getBltCanvas()->getBits())
					fx_dmove->render(this, getWidth(), getHeight(), bmbits, bmw, bmh, bmpitch);

				int w, h, p, *bits = (int*)canvas->getBits();
				if (bits && !canvas->getDim(&w, &h, &p) &&
				    cr.left + getWidth() < w && cr.top + getHeight() < h && cr.left >= 0 && cr.top >= 0)
				{
					fx_dmove->render(this, getWidth(), getHeight(), bits + cr.left + cr.top*w, getWidth(), getHeight(), w);
				}
				else
				{
					BltCanvas c(getWidth(), getHeight());
					canvas->blit(cr.left, cr.top, &c, 0, 0, getWidth(), getHeight());
					fx_dmove->render(this, getWidth(), getHeight(), (int *)c.getBits(),
					                 getWidth(), getHeight(), getWidth());
				}
				if (fx_dmove->getBltCanvas())
					fx_dmove->getBltCanvas()->blit(0, 0, canvas, cr.left, cr.top, getWidth(), getHeight());

			}
			else
			{ // no bgfx
				if (fx_getClear() && fx_dmove->getBltCanvas() && fx_dmove->getBltCanvas()->getBits())
					fx_dmove->getBltCanvas()->fillBits(0);
				fx_dmove->render(this, getWidth(), getHeight(), bmbits, bmw, bmh, bmpitch);
				//SkinBitmap *b = NULL;
				if (fx_dmove->getBltCanvas())
				{
					fx_dmove->getBltCanvas()->stretchToRectAlpha(canvas, &srcR, &r, talpha);
//					b = fx_dmove->getBltCanvas()->getSkinBitmap();
//					if (b)
//						b->stretchToRectAlpha(canvas, &srcR, &r, talpha);
				}
			}
		}
		else
#endif
			getBitmap()->stretchToRectAlpha(canvas, &srcR, &r, talpha);
	}
	else
	{
		if (r.right == r.left || r.bottom == r.top)
		{
			if (orig)
			{
				canvas->selectClipRgn(orig);
				delete orig;				orig = 0;
			}
			return 0;
		}

		srcR.top = getSourceOffsetY();
		srcR.left = getSourceOffsetX();
		srcR.bottom = srcR.top + getHeight();
		srcR.right = srcR.left + getWidth();

		if (!tiling)
		{

#if defined(WA3COMPATIBILITY) || defined(GEN_FF)
			if (fx_on && fx_dmove && bmbits)
			{
				if (fx_bgfx)
				{
					if (!fx_dmove->getBltCanvas() || !fx_dmove->getBltCanvas()->getBits())
						fx_dmove->render(this, cr.right - cr.left, cr.bottom - cr.top, bmbits, bmw, bmh, bmpitch);

					int w, h, p;
					if (canvas->getBits() && !canvas->getDim(&w, &h, &p) &&
					    cr.right < w && cr.bottom < h && cr.left >= 0 && cr.top >= 0)
					{
						fx_dmove->render(this, cr.right - cr.left, cr.bottom - cr.top, (int *)canvas->getBits() + cr.left + cr.top*w,
						                 cr.right - cr.left, cr.bottom - cr.top, w);
					}
					else
					{
						BltCanvas c(cr.right - cr.left, cr.bottom - cr.top);
						canvas->blit(cr.left, cr.top, &c, 0, 0, cr.right - cr.left, cr.bottom - cr.top);
						fx_dmove->render(this, cr.right - cr.left, cr.bottom - cr.top, (int *)c.getBits(),
						                 cr.right - cr.left, cr.bottom - cr.top, cr.right - cr.left);

					}

					if (fx_dmove->getBltCanvas())
						fx_dmove->getBltCanvas()->blit(0, 0, canvas, cr.left, cr.top, cr.right - cr.left, cr.bottom - cr.top);
				}
				else
				{
					if (fx_getClear() && fx_dmove->getBltCanvas() && fx_dmove->getBltCanvas()->getBits())
						fx_dmove->getBltCanvas()->fillBits(0);
					fx_dmove->render(this, getWidth(), getHeight(), bmbits, bmw, bmh, bmpitch);
					//SkinBitmap *b = NULL;
					if (fx_dmove->getBltCanvas())
					{
						fx_dmove->getBltCanvas()->stretchToRectAlpha(canvas, &srcR, &cr, talpha);
//						b = fx_dmove->getBltCanvas()->getSkinBitmap();
//						if (b)
//							b->stretchToRectAlpha(canvas, &srcR, &cr, talpha);

					}
				}
			}
			else
#endif
			{
				getBitmap()->stretchToRectAlpha(canvas, &srcR, &cr, talpha);
			}

		}
		else
		{
			getBitmap()->blitRectToTile(canvas, &cr, &srcR, 0, 0, talpha);
		}
	}

	if (orig)
	{
		canvas->selectClipRgn(orig);
		delete orig; orig = 0;
	}
	return 1;
}

int Layer::onResize()
{
	LAYER_PARENT::onResize();
	RECT r;
	getClientRect(&r);
	int w = r.right - r.left;
	int h = r.bottom - r.top;
	if (w != last_w || h != last_h)
		invalidateRegionCache();
	return 1;
}

#pragma warning (disable : 4065)
void Layer::timerCallback(int id)
{
	switch (id)
	{
#if defined(WA3COMPATIBILITY) || defined(GEN_FF)
		case FX_TIMER:
			fx_onFrame();
			invalidate();
			break;
#endif

		default:
			LAYER_PARENT::timerCallback(id);
			break;
	}
}
#pragma warning (default: 4065)

void Layer::invalidateRegionCache()
{
	delete rgnclone;
	rgnclone = NULL;
	invalidateWindowRegion();
}

int Layer::setXuiParam(int _xuihandle, int attribid, const wchar_t *paramname, const wchar_t *strvalue)
{
	if (xuihandle != _xuihandle) return LAYER_PARENT::setXuiParam(_xuihandle, attribid, paramname, strvalue);
	switch (attribid)
	{
		case LAYER_SETIMAGE:
			setBitmap(strvalue);
			break;
		case LAYER_SETRESIZE:
			setResize(SkinParser::parseResize(strvalue));
			if (resizer) getGuiObject()->guiobject_setMover(0);
			break;
		case LAYER_SETSCALE:
			setScaler(SkinParser::parseResize(strvalue));
			if (scaler) getGuiObject()->guiobject_setMover(0);
			break;
		case LAYER_SETREGION:
			setRegionFromBitmap(strvalue);
			break;
		case LAYER_SETTILE:
			setTiling(WTOI(strvalue));
			break;
		case LAYER_SETDBLCLICKACTION:
			dblClickAction = strvalue;
			break;
		case LAYER_DBLCLICKPARAM: 
			setDblClickParam(strvalue);
			break;
		case LAYER_SETINACTIVEIMAGE:
			setInactiveBitmap(strvalue);
			break;
		case LAYER_SETMYCURSOR:
			l_customcursor = true;
			getGuiObject()->guiobject_setCursor(strvalue);
			break;
		case LAYER_SETQUALITY:
			bitmap.setResamplingMode(WTOI(strvalue));
			break;
		default:
			return 0;

	}
	return 1;
}

int Layer::getPreferences(int what)
{
	if (what == SUGGESTED_W)
		return getWidth();
	if (what == SUGGESTED_H)
		return getHeight();
	return LAYER_PARENT::getPreferences(what);
}

int Layer::getSourceOffsetX()
{
	return 0;
}

int Layer::getSourceOffsetY()
{
	return 0;
}

void Layer::setBitmap(const wchar_t *name)
{
	bitmapname = name;
	bitmap = name;
	deleteRegion();
	makeRegion();
	notifyParent(ChildNotify::AUTOWHCHANGED);
	if (isInited()) invalidate();
}

void Layer::setInactiveBitmap(const wchar_t *name)
{
	inactiveImageName = name;
	inactiveBitmap = name;
	hasInactiveImage = 1;
}

void Layer::setDblClickParam(const wchar_t *p) 
{
	dblclickparam=p;
}

const wchar_t *Layer::getDblClickParam() 
{
	return dblclickparam;
}

int Layer::getWidth()
{
	if (getBitmap()) return getBitmap()->getWidth();
	return 0;
}

int Layer::getHeight()
{
	if (getBitmap()) return getBitmap()->getHeight();
	return 0;
}

int Layer::onLeftButtonDown(int x, int y)
{
	LAYER_PARENT::onLeftButtonDown(x, y);
	ifc_window *d = getDesktopParent();

#ifdef WASABI_COMPILE_WNDMGR
	Layout *_l = NULL;
	if (d != NULL)
	{
		_l = static_cast<Layout *>(d->getInterface(layoutGuid));
		if (_l && _l->isLocked()) return 1;
	}

	int need_resize = 0, need_scale = 0, need_move = 0;

	int dock = APPBAR_NOTDOCKED;
	int rw = applyResizeRestrictions(resizeway, &dock);
	int sw = (dock == APPBAR_NOTDOCKED) ? scalerway : RESIZE_NONE;

	if (resizer && rw != RESIZE_NONE && (!_l || _l->getResizable()))
	{
		if (scaler && sw != RESIZE_NONE && Std::keyModifier(STDKEY_ALT) && (!_l || _l->getScalable()))
			need_scale = 1;
		else
			need_resize = 1;
	}
	else if (scaler && sw != RESIZE_NONE && (!_l || _l->getScalable()))
	{
		need_scale = 1;
	}
	else if (getGuiObject()->guiobject_getMover())
	{
		need_move = 1;
	}

	Group *l = static_cast<Group *>(_l);

	if (need_move)
	{
		// do nothin'
	}
	else if (need_scale)
	{
		if (l)
		{
			l->beginScale();
			scaling = 1;
		}
		return 1;
	}
	else if (need_resize)
	{
		resizerect = 1;
		if (l)
		{
			clientToScreen(&x, &y);
			l->mouseResize(x, y, resizeway);
		}
	}
#endif
	return 1;
}

int Layer::onLeftButtonUp(int x, int y)
{
	LAYER_PARENT::onLeftButtonUp(x, y);
#ifdef WASABI_COMPILE_WNDMGR
	if (scaling)
	{
		getGuiObject()->guiobject_getParentGroup()->endScale();
		scaling = 0;
	}
#endif
	return 1;
}

void Layer::onCancelCapture()
{
	LAYER_PARENT::onCancelCapture();
	scaling = 0;
}

int Layer::onMouseMove(int x, int y)
{
	LAYER_PARENT::onMouseMove(x, y);
	POINT pos = {x, y};
	clientToScreen(&pos);

#ifdef WASABI_COMPILE_WNDMGR
	if (scaling && getCapture())
	{ // todo: resizing w/no rect
		if (!Std::keyDown(MK_LBUTTON))
			scaling = 0;
		else
		{
			RECT oldRect;
			RECT newRect;
			ifc_window *b = getRootParent();
			b->getWindowRect(&oldRect);
			newRect = oldRect;
			clientToScreen(&x, &y);
			int mask = 0;
			if (scalerway & RESIZE_BOTTOM)
			{
				newRect.bottom = y - y % SNAP_Y;
				mask |= BOTTOM;
			}
			if (scalerway & RESIZE_RIGHT)
			{
				newRect.right = x - x % SNAP_X;
				mask |= RIGHT;
			}
			if (scalerway & RESIZE_TOP)
			{
				newRect.top = y - y % SNAP_Y;
				mask |= TOP;
			}
			if (scalerway & RESIZE_LEFT)
			{
				newRect.left = x - x % SNAP_X;
				mask |= LEFT;
			}

			RECT dr = newRect;
			WASABI_API_WNDMGR->wndTrackDock(b, &dr, &newRect, mask | NOINTERSECT);
			if (dr.right - dr.left < 32) dr.right = dr.left + 32;
			if (dr.bottom - dr.top < 32) dr.bottom = dr.top + 32;
			if (MEMCMP(&dr, &oldRect, sizeof(RECT)))
			{
				RECT origRect;
				b->getClientRect(&origRect);
				double rx = (double)(dr.right - dr.left) / (double)(origRect.right - origRect.left);
				double ry = (double)(dr.bottom - dr.top) / (double)(origRect.bottom - origRect.top);
				double r = MAX(rx, ry);
				if (r != 0) b->setRenderRatio(r);
			}
		}
	}
#endif

	return 1;
}

SkinBitmap *Layer::getBitmap()
{
	return layer_getBitmap();
}

SkinBitmap *Layer::layer_getBitmap()
{
	if (hasInactiveImage)
		if (!isActive())
			return inactiveBitmap.getBitmap();
	return bitmap.getBitmap();
}

const wchar_t *Layer::layer_getBitmapName()
{
	return bitmapname;
}

int Layer::applyResizeRestrictions(int way, int *side)
{
	ifc_window *rw = getDesktopParent();
	int dock = APPBAR_NOTDOCKED;
	if (side) *side = dock;
	if (rw)
	{
		Layout *l = (Layout *)rw->getInterface(layoutGuid);
		if (l) dock = l->appbar_getSide();
	}
	if (dock == APPBAR_NOTDOCKED) return way;
	/*
	switch (way) {
	 case RESIZE_TOPLEFT:
	  if (dock == APPBAR_TOP || dock == APPBAR_LEFT) return RESIZE_NONE;
	  break;
	 case RESIZE_BOTTOMRIGHT:
	  if (dock == APPBAR_RIGHT || dock == APPBAR_BOTTOM) return RESIZE_NONE;
	  break;
	 case RESIZE_TOPRIGHT:
	  if (dock == APPBAR_TOP || dock == APPBAR_RIGHT) return RESIZE_NONE;
	  break;
	 case RESIZE_BOTTOMLEFT:
	  if (dock == APPBAR_BOTTOM || dock == APPBAR_LEFT) return RESIZE_NONE;
	  break;
	 case RESIZE_TOP:
	  if (dock == APPBAR_TOP) return RESIZE_NONE;
	  break;
	 case RESIZE_BOTTOM:
	  if (dock == APPBAR_BOTTOM) return RESIZE_NONE;
	  break;
	 case RESIZE_LEFT:
	  if (dock == APPBAR_LEFT) return RESIZE_NONE;
	  break;
	 case RESIZE_RIGHT:
	  if (dock == APPBAR_RIGHT) return RESIZE_NONE;
	  break;
	}
	return way;*/
	if (dock != APPBAR_NOTDOCKED) return RESIZE_NONE;
	return way;
}

int Layer::getCursorType(int x, int y)
{
	// Return our user cursor if we have one (even when we are resizable!)
	if (l_customcursor)
	{
		return BASEWND_CURSOR_USERSET;
	}
	// Then check if our layer is used to resize or scale the wnd
	ifc_window *d = getDesktopParent();
	int scalable = 1;
	int resizable = 1;
	Layout *_l = NULL;
	if (d != NULL)
	{
		_l = static_cast<Layout *>(d->getInterface(layoutGuid));
		if (_l)
		{
			scalable = _l->getScalable();
			resizable = _l->getResizable();
		}
	}

	if (!_l || (!_l->isLocked() && (resizer || scaler)))
		{
		int dock = APPBAR_NOTDOCKED;

		int r = 0;
		if (resizer && resizable)
		{
			if (scaler && scalable)
			{
				if (Std::keyModifier(STDKEY_ALT))
				{
					r = applyResizeRestrictions(scalerway, &dock);
					if (dock != APPBAR_NOTDOCKED) r = RESIZE_NONE;
				}
				else
				{
					r = applyResizeRestrictions(resizeway);
				}
			}
			else
			{
				r = applyResizeRestrictions(resizeway);
			}
		}
		if (scaler && scalable)
		{
			r = applyResizeRestrictions(scalerway, &dock);
			if (dock != APPBAR_NOTDOCKED) r = RESIZE_NONE;
		}

		switch (r)
		{
			case RESIZE_TOPLEFT:
			case RESIZE_BOTTOMRIGHT:
				return BASEWND_CURSOR_NORTHWEST_SOUTHEAST;
			case RESIZE_TOPRIGHT:
			case RESIZE_BOTTOMLEFT:
				return BASEWND_CURSOR_NORTHEAST_SOUTHWEST;
				break;
			case RESIZE_TOP:
			case RESIZE_BOTTOM:
				return BASEWND_CURSOR_NORTHSOUTH;
				break;
			case RESIZE_LEFT:
			case RESIZE_RIGHT:
				return BASEWND_CURSOR_EASTWEST;
				break;
		}
	}
	// At leat we want to have a cursor so spit our the normal pointer
	return BASEWND_CURSOR_POINTER;
}

void Layer::setScaler(int r)
{
	if (r != 0)
	{
		scaler = 1;
		scalerway = r;
	}
	else
	{
		resizer = 0;
		scalerway = 0;
	}
}

void Layer::setResize(int r)
{
	if (r != 0)
	{
		resizer = 1;
		resizeway = r;
	}
	else
	{
		resizer = 0;
		resizeway = 0;
	}
}

api_region *Layer::getBitmapRegion()
{
	return rgn;
}

api_region *Layer::getRegion()
{
	api_region *_rgn = getBitmapRegion();
	if (!_rgn) return NULL;
	if (!rgnclone)
	{
		rgnclone = new RegionI();
		rgnclone->addRegion(_rgn);
	}
	else
		return rgnclone;
	float w, h;
	RECT r;
	getClientRect(&r);
	if (r.right - r.left == 0 || r.bottom - r.top == 0) return NULL;
	last_w = r.right - r.left;
	last_h = r.bottom - r.top;
	if (getWidth() == 0 || getHeight() == 0) return NULL;
	w = (float)(last_w) / (float)getWidth();
	h = (float)(last_h) / (float)getHeight();
	if (!w || !h) return NULL;
	if (!tiling)
	{
		if (w != 1.0 || h != 1.0)
		{
			rgnclone->scale(w, h, TRUE);
		}
	}
	else
	{
		for (int j = 0;j < h;j++)
		{
			for (int i = 0;i < w;i++)
			{
				api_region *t = _rgn->clone();
				t->offset(i*getWidth(), j*getHeight());
				rgnclone->addRegion(t);
				_rgn->disposeClone(t);
			}
		}
	}
	RegionI _r(&r);
	_r.offset(-r.left, -r.top);
	rgnclone->andRegion(&_r);

	return rgnclone;
}

void Layer::setRegionOp(int i)
{
	int old = getRegionOp();
	LAYER_PARENT::setRegionOp(i);
	if (!old && i) setRectRgn(0);
}

void Layer::makeRegion()
{
	if (!bitmap.getBitmap())
		return;
	delete rgn;
	rgn = new RegionI(bitmap);
	invalidateRegionCache();
}

void Layer::deleteRegion()
{
	if (!rgn) return;
	invalidateRegionCache();
	delete rgn;
	rgn = NULL;
}

int Layer::onLeftButtonDblClk(int x, int y)
{
	// Martin> copied and adopted from textbase.cpp
	//if (!dblClickAction.isempty() && !VCPU::getComplete())
	if (dblClickAction)
	{
#ifdef WASABI_COMPILE_WNDMGR
		const wchar_t *toCheck = L"SWITCH;";
		if (!_wcsnicmp(dblClickAction, toCheck, 7))
		{
			onLeftButtonUp(x, y);
			getGuiObject()->guiobject_getParentGroup()->getParentContainer()->switchToLayout(dblClickAction.getValue() + 7);
			return 0;
		}
		else
		{
#endif
			svc_action *act = ActionEnum(dblClickAction).getNext();
			if (act)
			{
				int _x = x;
				int _y = y;
				clientToScreen(&_x, &_y);
				act->onAction(dblClickAction, getDblClickParam(), _x, _y, NULL, 0, this);
				//WASABI_API_WNDMGR->messageBox(L"on action; passed", L"debug", 0, NULL, NULL);
				SvcEnum::release(act);
			}
#ifdef WASABI_COMPILE_WNDMGR

		}
#endif

	}
	int r = LAYER_PARENT::onLeftButtonDblClk(x, y);
	return r;
}


void Layer::setRegionFromMap(SMap *map, int byte, int inversed)
{
	if (secrgn)
	{
		invalidate();
		delete secrgn;
		secrgn = NULL;
	}
	//RECT r = {map->getBitmap()->getX(), map->getBitmap()->getY(), map->getBitmap()->getWidth(), map->getBitmap()->getHeight()};
	secrgn = new RegionI(map->getBitmap(), NULL, 0, 0, FALSE, 1, (unsigned char)byte, inversed);
	if (secrgn)
		invalidate();
}

void Layer::setRegion(SRegion *reg)
{
	invalidate();
	delete secrgn;
	if (!reg)
	{
		secrgn = NULL; invalidate(); return;
	}
	secrgn = new RegionI();
	secrgn->addRegion(reg->getRegion());
	invalidate();
}

int Layer::wantSiblingInvalidations()
{
	return fx_on;
}

int Layer::onSiblingInvalidateRgn(api_region *r, ifc_window *who, int who_idx, int my_idx)
{
	if (!fx_on || !fx_bgfx || who_idx >= my_idx) return 0;
	RECT rr;
	getClientRect(&rr);
	if (rgn)
	{
		api_region *_r = rgn->clone();
		_r->offset(rr.left, rr.top);
		if (fx_local && !_r->doesIntersectRgn(r))
		{
			rgn->disposeClone(_r);
			return 0;
		}
		if (secrgn)
		{
			api_region *_rs = secrgn->clone();
			_rs->offset(rr.left, rr.top);
			_r->andRegion(_rs);
			secrgn->disposeClone(_rs);
		}
		r->addRegion(_r);
		rgn->disposeClone(_r);
	}
	else
	{
		RegionI _r(&rr);
		if (secrgn)
		{
			api_region *_rs = secrgn->clone();
			_rs->offset(rr.left, rr.top);
			_r.andRegion(_rs);
			secrgn->disposeClone(_rs);
		}
		if (fx_local && !_r.doesIntersectRgn(r))
		{
			return 0;
		}
		r->addRegion(&_r);
	}
	return 1;
}

void Layer::onSetVisible(int show)
{
	LAYER_PARENT::onSetVisible(show);
	getGuiObject()->guiobject_onSetVisible(show);
}

int Layer::onActivate()
{
	invalidate();
	return 0;
}

int Layer::onDeactivate()
{
	invalidate();
	return 0;
}

void Layer::setTiling(int t)
{
	if (tiling == t) return;
	tiling = t;
	invalidate();
}

int Layer::getTiling()
{
	return tiling;
}


void Layer::onBeginResize(RECT r)
{
	scriptVar l = SOM::makeVar(SCRIPT_INT);
	SOM::assign(&l, r.left);
	scriptVar t = SOM::makeVar(SCRIPT_INT);
	SOM::assign(&t, r.top);
	scriptVar w = SOM::makeVar(SCRIPT_INT);
	SOM::assign(&w, r.right - r.left);
	scriptVar h = SOM::makeVar(SCRIPT_INT);
	SOM::assign(&h, r.bottom - r.top);
	script_vcpu_onBeginResize(SCRIPT_CALL, getScriptObject(), l, t, w, h);
}

void Layer::onEndResize(RECT r)
{
	scriptVar l = SOM::makeVar(SCRIPT_INT);
	SOM::assign(&l, r.left);
	scriptVar t = SOM::makeVar(SCRIPT_INT);
	SOM::assign(&t, r.top);
	scriptVar w = SOM::makeVar(SCRIPT_INT);
	SOM::assign(&w, r.right - r.left);
	scriptVar h = SOM::makeVar(SCRIPT_INT);
	SOM::assign(&h, r.bottom - r.top);
	script_vcpu_onEndResize(SCRIPT_CALL, getScriptObject(), l, t, w, h);
}

#if defined(WA3COMPATIBILITY) || defined(GEN_FF)
void Layer::fx_setEnabled(int i)
{
	static int inited = 0;
	if (fx_getEnabled() == !!i) return;
	fx_on = !!i;
	if (fx_on)
	{
		if (!inited)
			fx_onInit();
		fx_dmove = new FxDynamicMove;
		fx_dmove->setBilinear(fx_getBilinear());
		if (fx_getAlphaMode())
			fx_dmove->setAlphaMode(1 | (fx_getBgFx() ? 2 : 0));
		else fx_setAlphaMode(0);
		fx_dmove->setAlphaOnce(fx_alphaonce);
		fx_dmove->setRect(fx_getRect());
		fx_dmove->setWrap(fx_getWrap());
		fx_dmove->setGridSize(fx_grid_x, fx_grid_y);
		if (fx_realtime)
		{
			setTimer(FX_TIMER, fx_delay);
			fx_timeron = 1;
		}
	}
	else
	{
		if (fx_timeron)
		{
			killTimer(FX_TIMER);
			fx_timeron = 0;
		}
		delete fx_dmove;
		fx_dmove = NULL;
	}
	invalidate();
}

int Layer::fx_getEnabled(void)
{
	return fx_on;
}

void Layer::fx_setWrap(int i)
{
	if (fx_getWrap() == !!i) return;
	fx_wrap = !!i;
	if (fx_dmove) fx_dmove->setWrap(fx_wrap);
	invalidate();
}

int Layer::fx_getWrap(void)
{
	return fx_wrap;
}

void Layer::fx_setRect(int i)
{
	if (fx_getRect() == !!i) return;
	fx_rect = !!i;
	if (fx_dmove) fx_dmove->setRect(fx_rect);
	invalidate();
}

int Layer::fx_getRect(void)
{
	return fx_rect;
}

int Layer::fx_getAlphaMode()
{
	if (!fx_alphamode) return 0;
	if (fx_alphaonce) return 2;
	return 1;
}

void Layer::fx_setAlphaMode(int i)
{

	if (i == 2)
	{
		i = 1;
		fx_alphaonce = 1;
		if (fx_dmove) fx_dmove->setAlphaOnce(1);
	}
	else
	{
		fx_alphaonce = 0;
		if (fx_dmove) fx_dmove->setAlphaOnce(0);
	}

	if (fx_getAlphaMode() == !!i)  return;
	fx_alphamode = !!i;
	if (fx_dmove)
	{
		if (fx_getAlphaMode())
			fx_dmove->setAlphaMode(1 | (fx_getBgFx() ? 2 : 0));
		else
			fx_dmove->setAlphaMode(0);
	}
	invalidate();
}


int Layer::fx_getBilinear()
{
	return fx_bilinear;
}

void Layer::fx_setBilinear(int i)
{
	if (fx_getBilinear() == !!i)  return;
	fx_bilinear = !!i;
	if (fx_dmove) fx_dmove->setBilinear(fx_bilinear);
	invalidate();
}

int Layer::fx_getBgFx()
{
	return fx_bgfx;
}

void Layer::fx_setBgFx(int i)
{
	if (fx_getBgFx() == !!i) return;
	fx_bgfx = !!i;
	if (fx_dmove) fx_dmove->setCanCache(!i);
	if (fx_dmove && fx_getAlphaMode())
	{
		fx_dmove->setAlphaMode(1 | (fx_getBgFx() ? 2 : 0));
	}
	invalidate();
}

int Layer::fx_getSpeed()
{
	return fx_delay;
}

void Layer::fx_setSpeed(int s)
{
	if (fx_getSpeed() == s) return;
	fx_delay = s;
	if (fx_timeron)
	{
		killTimer(FX_TIMER);
		fx_timeron = 0;
	}
	if (fx_on && fx_realtime)
	{
		setTimer(FX_TIMER, fx_delay);
		fx_timeron = 1;
	}
}

int Layer::fx_getClear()
{
	return fx_clear;
}

void Layer::fx_setClear(int i)
{
	if (fx_getClear() == !!i) return;
	fx_clear = !!i;
}

int Layer::fx_getRealtime()
{
	return fx_realtime;
}

void Layer::fx_setRealtime(int i)
{
	if (fx_getRealtime() == !!i) return;
	fx_realtime = !!i;
}

int Layer::fx_getLocalized()
{
	return fx_local;
}

void Layer::fx_setLocalized(int i)
{
	if (fx_getLocalized() == !!i) return;
	fx_local = !!i;
}

void Layer::fx_setGridSize(int x, int y)
{
	fx_grid_x = x;
	fx_grid_y = y;
	if (!fx_dmove) return;
	fx_dmove->setGridSize(x, y);
}

void Layer::fx_update(void)
{
	RECT r;
	getClientRect(&r);
	if (fx_realtime && !isMinimized())
		cascadeRepaintRect(&r);
	else
		invalidateRect(&r);
}

void Layer::fx_restart(void)
{
	fx_onInit();
	if (fx_dmove && fx_dmove->getBltCanvas() && fx_dmove->getBltCanvas()->getBits())
		fx_dmove->getBltCanvas()->fillBits(0);
	// todo: reset need_alpha in fx_dmove
}

void Layer::fx_onInit(void)
{
	script_vcpu_fx_onInit(SCRIPT_CALL, getScriptObject());
}

void Layer::fx_onFrame(void)
{
	script_vcpu_fx_onFrame(SCRIPT_CALL, getScriptObject());
}

double Layer::fx_onGetPixelA(double r, double d, double x, double y)
{
	scriptVar _x = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _y = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _r = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _d = SOM::makeVar(SCRIPT_DOUBLE);
	SOM::assign(&_x, x);
	SOM::assign(&_y, y);
	SOM::assign(&_r, r);
	SOM::assign(&_d, d);
	scriptVar v = script_vcpu_fx_onGetPixelA(SCRIPT_CALL, getScriptObject(), _r, _d, _x, _y);
	return (v.type == 0) ? 0.5 : v.data.ddata;
}


double Layer::fx_onGetPixelX(double r, double d, double x, double y)
{
	scriptVar _x = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _y = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _r = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _d = SOM::makeVar(SCRIPT_DOUBLE);
	SOM::assign(&_x, x);
	SOM::assign(&_y, y);
	SOM::assign(&_r, r);
	SOM::assign(&_d, d);
	scriptVar v = script_vcpu_fx_onGetPixelX(SCRIPT_CALL, getScriptObject(), _r, _d, _x, _y);
	return (v.type == 0) ? x : v.data.ddata;
}

double Layer::fx_onGetPixelY(double r, double d, double x, double y)
{
	scriptVar _x = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _y = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _r = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _d = SOM::makeVar(SCRIPT_DOUBLE);
	SOM::assign(&_x, x);
	SOM::assign(&_y, y);
	SOM::assign(&_r, r);
	SOM::assign(&_d, d);
	scriptVar v = script_vcpu_fx_onGetPixelY(SCRIPT_CALL, getScriptObject(), _r, _d, _x, _y);
	return (v.type == 0) ? y : v.data.ddata;
}

double Layer::fx_onGetPixelR(double r, double d, double x, double y)
{
	scriptVar _x = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _y = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _r = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _d = SOM::makeVar(SCRIPT_DOUBLE);
	SOM::assign(&_x, x);
	SOM::assign(&_y, y);
	SOM::assign(&_r, r);
	SOM::assign(&_d, d);
	scriptVar v = script_vcpu_fx_onGetPixelR(SCRIPT_CALL, getScriptObject(), _r, _d, _x, _y);
	return (v.type == 0) ? r : v.data.ddata;
}

double Layer::fx_onGetPixelD(double r, double d, double x, double y)
{
	scriptVar _x = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _y = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _r = SOM::makeVar(SCRIPT_DOUBLE);
	scriptVar _d = SOM::makeVar(SCRIPT_DOUBLE);
	SOM::assign(&_x, x);
	SOM::assign(&_y, y);
	SOM::assign(&_r, r);
	SOM::assign(&_d, d);
	scriptVar v = script_vcpu_fx_onGetPixelD(SCRIPT_CALL, getScriptObject(), _r, _d, _x, _y);
	return (v.type == 0) ? d : v.data.ddata;
}
#endif

int Layer::skincb_onColorThemeChanged(const wchar_t *newcolortheme)
{
  #if defined(WA3COMPATIBILITY) || defined(GEN_FF)
	if (fx_getEnabled())
	{
		fx_dmove->flushCache();
		fx_update();
	}
#endif
	return 0;
}

void Layer::setRegionFromBitmap(const wchar_t *bmpid)
{
	delete secrgn;
	secrgn = NULL;
	if (bmpid == NULL || *bmpid == '\0')
		return;
	bool invert = (*bmpid == '!');
	if (invert) bmpid++;
	SkinBitmap b(bmpid);
	secrgn = new RegionI(&b, NULL, 0, 0, invert);
}

LayerScriptController _layerController;
LayerScriptController *layerController = &_layerController;

// -- Functions table -------------------------------------
function_descriptor_struct LayerScriptController::exportedFunction[] = {
      {L"setRegionFromMap",  3, (void*)Layer::script_vcpu_setRegionFromMap },
      {L"setRegion",         1, (void*)Layer::script_vcpu_setRegion },
			{L"isInvalid",       0, (void*)Layer::script_vcpu_isInvalid },
#ifdef WASABI_COMPILE_WNDMGR
      {L"onBeginResize",     4, (void*)Layer::script_vcpu_onBeginResize },
      {L"onEndResize",       4, (void*)Layer::script_vcpu_onEndResize },
#endif
#if defined(WA3COMPATIBILITY) || defined(GEN_FF)
      {
        L"fx_setEnabled",     1, (void*)Layer::script_vcpu_fx_setEnabled
      },
      {L"fx_getEnabled",     0, (void*)Layer::script_vcpu_fx_getEnabled },
      {L"fx_onInit",         0, (void*)Layer::script_vcpu_fx_onInit },
      {L"fx_onFrame",        0, (void*)Layer::script_vcpu_fx_onFrame },
      {L"fx_onGetPixelR",    4, (void*)Layer::script_vcpu_fx_onGetPixelR },
      {L"fx_onGetPixelD",    4, (void*)Layer::script_vcpu_fx_onGetPixelD },
      {L"fx_onGetPixelX",    4, (void*)Layer::script_vcpu_fx_onGetPixelX },
      {L"fx_onGetPixelY",    4, (void*)Layer::script_vcpu_fx_onGetPixelY },
      {L"fx_onGetPixelA",    4, (void*)Layer::script_vcpu_fx_onGetPixelA },
      {L"fx_setWrap",        1, (void*)Layer::script_vcpu_fx_setWrap },
      {L"fx_getWrap",        0, (void*)Layer::script_vcpu_fx_getWrap },
      {L"fx_setRect",        1, (void*)Layer::script_vcpu_fx_setRect },
      {L"fx_getRect",        0, (void*)Layer::script_vcpu_fx_getRect },
      {L"fx_setBgFx",        1, (void*)Layer::script_vcpu_fx_setBgFx },
      {L"fx_getBgFx",        0, (void*)Layer::script_vcpu_fx_getBgFx },
      {L"fx_setClear",       1, (void*)Layer::script_vcpu_fx_setClear },
      {L"fx_getClear",       0, (void*)Layer::script_vcpu_fx_getClear },
      {L"fx_setSpeed",       1, (void*)Layer::script_vcpu_fx_setSpeed },
      {L"fx_getSpeed",       0, (void*)Layer::script_vcpu_fx_getSpeed },
      {L"fx_setRealtime",    1, (void*)Layer::script_vcpu_fx_setRealtime },
      {L"fx_getRealtime",    0, (void*)Layer::script_vcpu_fx_getRealtime },
      {L"fx_setLocalized",   1, (void*)Layer::script_vcpu_fx_setLocalized },
      {L"fx_getLocalized",   0, (void*)Layer::script_vcpu_fx_getLocalized },
      {L"fx_setBilinear",    1, (void*)Layer::script_vcpu_fx_setBilinear },
      {L"fx_getBilinear",    0, (void*)Layer::script_vcpu_fx_getBilinear },
      {L"fx_setAlphaMode",   1, (void*)Layer::script_vcpu_fx_setAlphaMode },
      {L"fx_getAlphaMode",   0, (void*)Layer::script_vcpu_fx_getAlphaMode },
      {L"fx_setGridSize",    2, (void*)Layer::script_vcpu_fx_setGridSize },
      {L"fx_update",         0, (void*)Layer::script_vcpu_fx_update },
      {L"fx_restart",        0, (void*)Layer::script_vcpu_fx_restart },
#endif
    };
// --------------------------------------------------------

const wchar_t *LayerScriptController::getClassName()
{
	return L"Layer";
}

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

ScriptObject *LayerScriptController::instantiate()
{
	Layer *l = new Layer;
	ASSERT(l != NULL);
	return l->getScriptObject();
}

void LayerScriptController::destroy(ScriptObject *o)
{
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	ASSERT(l != NULL);
	delete l;
}

void *LayerScriptController::encapsulate(ScriptObject *o)
{
	return NULL; // no encapsulation for layer yet
}

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

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

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

GUID LayerScriptController::getClassGuid()
{
	return layerGuid;
}


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

scriptVar Layer::script_vcpu_onBeginResize(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar left, scriptVar top, scriptVar width, scriptVar height)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS4(o, layerController, left, top, width, height);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT4(o, left, top, width, height);
}

scriptVar Layer::script_vcpu_onEndResize(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar left, scriptVar top, scriptVar width, scriptVar height)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS4(o, layerController, left, top, width, height);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT4(o, left, top, width, height);
}

scriptVar Layer::script_vcpu_setRegionFromMap(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar map, scriptVar byte, scriptVar inv)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(SOM::isNumeric(&byte));
	ASSERT(SOM::isNumeric(&inv));
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	SMap *m = static_cast<SMap *>(GET_SCRIPT_OBJECT_AS(map, mapGuid));
	if (l) l->setRegionFromMap(m, GET_SCRIPT_INT(byte), GET_SCRIPT_INT(inv));
	RETURN_SCRIPT_VOID;
}

scriptVar Layer::script_vcpu_setRegion(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar reg)
{
	SCRIPT_FUNCTION_INIT
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	SRegion *r = static_cast<SRegion *>(GET_SCRIPT_OBJECT_AS(reg, regionGuid));
	if (l) l->setRegion(r);
	RETURN_SCRIPT_VOID;
}

bool Layer::layer_isInvalid()
{
		SkinBitmap *b =  layer_getBitmap();
		if (b)
			return !!b->isInvalid();
		else
			return true;
}

scriptVar Layer::script_vcpu_isInvalid(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l)
	{
		return MAKE_SCRIPT_INT(l->layer_isInvalid()?1:0);
	}
	return MAKE_SCRIPT_INT(1);
}


#if defined(WA3COMPATIBILITY) || defined(GEN_FF)
scriptVar Layer::script_vcpu_fx_setEnabled(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar a)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(SOM::isNumeric(&a));
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) l->fx_setEnabled(GET_SCRIPT_INT(a));
	RETURN_SCRIPT_VOID;
}

scriptVar Layer::script_vcpu_fx_getEnabled(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) return MAKE_SCRIPT_INT(l->fx_getEnabled());
	RETURN_SCRIPT_ZERO;
}

scriptVar Layer::script_vcpu_fx_setWrap(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar a)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(SOM::isNumeric(&a));
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) l->fx_setWrap(SOM::makeInt(&a));
	RETURN_SCRIPT_VOID;
}

scriptVar Layer::script_vcpu_fx_getWrap(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) return MAKE_SCRIPT_INT(l->fx_getWrap());
	RETURN_SCRIPT_ZERO;
}

scriptVar Layer::script_vcpu_fx_setRect(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar a)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(SOM::isNumeric(&a));
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) l->fx_setRect(SOM::makeInt(&a));
	RETURN_SCRIPT_VOID;
}

scriptVar Layer::script_vcpu_fx_getRect(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) return MAKE_SCRIPT_INT(l->fx_getRect());
	RETURN_SCRIPT_ZERO;
}

scriptVar Layer::script_vcpu_fx_setAlphaMode(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar a)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(SOM::isNumeric(&a));
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) l->fx_setAlphaMode(SOM::makeInt(&a));
	RETURN_SCRIPT_VOID;
}

scriptVar Layer::script_vcpu_fx_getAlphaMode(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) return MAKE_SCRIPT_INT(l->fx_getAlphaMode());
	RETURN_SCRIPT_ZERO;
}

scriptVar Layer::script_vcpu_fx_setBilinear(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar a)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(SOM::isNumeric(&a));
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) l->fx_setBilinear(SOM::makeInt(&a));
	RETURN_SCRIPT_VOID;
}

scriptVar Layer::script_vcpu_fx_getBilinear(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) return MAKE_SCRIPT_INT(l->fx_getBilinear());
	RETURN_SCRIPT_ZERO;
}

scriptVar Layer::script_vcpu_fx_setBgFx(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar a)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(SOM::isNumeric(&a));
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) l->fx_setBgFx(SOM::makeInt(&a));
	RETURN_SCRIPT_VOID;
}

scriptVar Layer::script_vcpu_fx_getBgFx(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) return MAKE_SCRIPT_INT(((Layer *)o)->fx_getBgFx());
	RETURN_SCRIPT_ZERO;
}

scriptVar Layer::script_vcpu_fx_setSpeed(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar s)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(SOM::isNumeric(&s));
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) l->fx_setSpeed(SOM::makeInt(&s));
	RETURN_SCRIPT_VOID;
}

scriptVar Layer::script_vcpu_fx_getSpeed(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) return MAKE_SCRIPT_INT(((Layer *)o)->fx_getSpeed());
	RETURN_SCRIPT_ZERO;
}

scriptVar Layer::script_vcpu_fx_setRealtime(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar s)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(SOM::isNumeric(&s));
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) l->fx_setRealtime(SOM::makeInt(&s));
	RETURN_SCRIPT_VOID;
}

scriptVar Layer::script_vcpu_fx_getRealtime(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) return MAKE_SCRIPT_INT(((Layer *)o)->fx_getRealtime());
	RETURN_SCRIPT_ZERO;
}

scriptVar Layer::script_vcpu_fx_setClear(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar s)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(SOM::isNumeric(&s));
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) l->fx_setClear(SOM::makeInt(&s));
	RETURN_SCRIPT_VOID;
}

scriptVar Layer::script_vcpu_fx_getClear(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) return MAKE_SCRIPT_INT(l->fx_getClear());
	RETURN_SCRIPT_ZERO;
}

scriptVar Layer::script_vcpu_fx_setLocalized(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar s)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(SOM::isNumeric(&s));
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) l->fx_setLocalized(SOM::makeInt(&s));
	RETURN_SCRIPT_VOID;
}

scriptVar Layer::script_vcpu_fx_getLocalized(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) return MAKE_SCRIPT_INT(l->fx_getLocalized());
	RETURN_SCRIPT_ZERO;
}

scriptVar Layer::script_vcpu_fx_setGridSize(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar x, scriptVar y)
{
	SCRIPT_FUNCTION_INIT
	ASSERT(SOM::isNumeric(&x));
	ASSERT(SOM::isNumeric(&y));
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) l->fx_setGridSize(SOM::makeInt(&x), SOM::makeInt(&y));
	RETURN_SCRIPT_VOID;
}

scriptVar Layer::script_vcpu_fx_update(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) l->fx_update();
	RETURN_SCRIPT_VOID;
}

scriptVar Layer::script_vcpu_fx_restart(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid));
	if (l) l->fx_restart();
	RETURN_SCRIPT_VOID;
}

scriptVar Layer::script_vcpu_fx_onInit(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS0(o, layerController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

scriptVar Layer::script_vcpu_fx_onFrame(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS0(o, layerController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

scriptVar Layer::script_vcpu_fx_onGetPixelA(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar r, scriptVar d, scriptVar x, scriptVar y)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS4(o, layerController, r, d, x, y);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT4(o, r, d, x, y);
}


scriptVar Layer::script_vcpu_fx_onGetPixelX(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar r, scriptVar d, scriptVar x, scriptVar y)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS4(o, layerController, r, d, x, y);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT4(o, r, d, x, y);
}

scriptVar Layer::script_vcpu_fx_onGetPixelY(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar r, scriptVar d, scriptVar x, scriptVar y)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS4(o, layerController, r, d, x, y);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT4(o, r, d, x, y);
}

scriptVar Layer::script_vcpu_fx_onGetPixelR(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar r, scriptVar d, scriptVar x, scriptVar y)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS4(o, layerController, r, d, x, y);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT4(o, r, d, x, y);
}

scriptVar Layer::script_vcpu_fx_onGetPixelD(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar r, scriptVar d, scriptVar x, scriptVar y)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS4(o, layerController, r, d, x, y);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT4(o, r, d, x, y);
}

#endif //WA3COMPATIBILITY || GEN_FF