winamp/Src/Wasabi/api/wndmgr/layout.cpp

#include <precomp.h>
#include <api/skin/widgets/mb/scriptbrowser.h>
#include <tataki/bitmap/bitmap.h>
#include <api/wnd/popup.h>
#include <api/wndmgr/msgbox.h>
#include <api/skin/widgets/group.h>
#include "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/main.h> //CUT!
#include <api/skin/widgets/compbuck2.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/options.h>
#include <api/script/script.h>
#include <api/script/scriptmgr.h>
#include <bfc/parse/pathparse.h>
#include <api/skin/groupmgr.h>
#include <api/wndmgr/skinembed.h>
#include <api/skin/skinparse.h>
#include <api/service/svcs/svc_action.h>
#include <api/config/items/attrbool.h>
#include <api/config/items/attrint.h>
#include <api/wndmgr/alphamgr.h>
#include <bfc/wasabi_std_wnd.h>
#include <api/wnd/PaintCanvas.h>
#ifdef _WIN32
#include <windowsx.h> // for SetWindowRedraw
#endif

#ifdef WASABINOMAINAPI
#include <api/wndmgr/gc.h>
#include <api/syscb/callbacks/gccb.h>
#endif

#ifndef WM_MOUSEWHEEL
#define WM_MOUSEWHEEL 0x20A
#endif

#define TIMER_SETTINGCHANGED 0x8791
#define TIMER_AUTOOPACIFY 0x8792
#define TIMER_AUTOOPACIFY2 0x8793
#define TIMER_OFFSCREENCHECK 0x8794
#define TIMER_TRANSPARENCY_AUTOON 0x8795
#define TIMER_SAVE_POSITION 0x8796
#define TIMER_SAVE_ALL_POSITIONS 0x8797

#ifdef WASABI_COMPILE_CONFIG
extern _bool cfg_uioptions_linkallalpha;
extern _bool cfg_uioptions_linkallratio;
extern _int cfg_uioptions_autoopacitylinked;
extern _int cfg_uioptions_autoopacitytime;
extern _int cfg_uioptions_extendautoopacity;
extern _int cfg_uioptions_autoopacityfadein;
extern _int cfg_uioptions_autoopacityfadeout;
extern _int cfg_uioptions_linkedalpha;
extern _bool cfg_options_appbarondrag;
#endif

AlphaMgr *alphaMgr = NULL;
XMLParamPair Layout::params[] =
    {
        {LAYOUT_SETALPHA, L"ALPHA"},
        {LAYOUT_SETALPHABACKGROUND, L"ALPHABACKGROUND"},
        {LAYOUT_SETDESKTOPALPHA, L"DESKTOPALPHA"},
        {LAYOUT_FORCEALPHA, L"FORCEALPHA"},
        {LAYOUT_SETINDESKTOP, L"INDESKTOP"},
        {LAYOUT_SETLINKHEIGHT, L"LINKHEIGHT"},
        {LAYOUT_SETLINKWIDTH, L"LINKWIDTH"},
        {LAYOUT_SETLOCKTO, L"LOCKTO"},
        {LAYOUT_SETNOACTIVATION, L"NOACTIVATION"},
        {LAYOUT_NODOCK, L"NODOCK"},
        {LAYOUT_NOOFFSCREENCHECK, L"NOOFFSCREENCHECK"},
        {LAYOUT_NOPARENT, L"NOPARENT"},
        {LAYOUT_SETONTOP, L"ONTOP"},
        {LAYOUT_SETOSFRAME, L"OSFRAME"},
        {LAYOUT_SETOWNER, L"OWNER"},
        {LAYOUT_SNAPADJUSTBOTTOM, L"SNAPADJUSTBOTTOM"},
        {LAYOUT_SNAPADJUSTLEFT, L"SNAPADJUSTLEFT"},
        {LAYOUT_SNAPADJUSTRIGHT, L"SNAPADJUSTRIGHT"},
        {LAYOUT_SNAPADJUSTTOP, L"SNAPADJUSTTOP"},
        {LAYOUT_UNLINKED, L"UNLINKED"},
		{LAYOUT_RESIZABLE, L"RESIZABLE"},
		{LAYOUT_SCALABLE, L"SCALABLE"},
    };

Layout::Layout()
{
	getScriptObject()->vcpu_setInterface(layoutGuid, (void *)static_cast<Layout *>(this));
	getScriptObject()->vcpu_setInterface(guiResizableGuid, (void *)static_cast<GuiResizable *>(this));
	getScriptObject()->vcpu_setClassName(L"Layout");
	getScriptObject()->vcpu_setController(layoutController);
#ifdef _WIN32
	forwardMsgWnd = INVALIDOSWINDOWHANDLE;
#endif
	transparency_reenabled_at = 0;
	transparency_autooff = 0;
	captured = 0; resizing = 0;
	m_forceunlink = 0;
	inresize = 0;
	autoopacify = 0;
	x = 0; y = 0;
#ifdef USEAPPBAR
	appbar_want_autohide = 1;
	appbar_want_alwaysontop = 1;
	m_allowsavedock = 0;
#endif
	size_w = 0; size_h = 0;
	reg = NULL;
	//subregionlayers = new PtrList<Layer>;
	setStartHidden(TRUE);
	moving = 0;
	setVirtual(0);
	indesktop = 0;
	p_container = NULL;
	alpha = 255;
	linkedheight = NULL;
	linkedwidth = NULL;
	inlinkwidth = 0;
	inlinkheight = 0;
	wantactiv = 1;
	wantdesktopalpha = 0;
	alllayouts.addItem(this);
	galphadisabled = 0;
	lockedto = NULL;
	osframe = 0;
	scalelocked = 0;
	initontop = 0;
	wantredrawonresize = 1;
	getGuiObject()->guiobject_setMover(1);
	snap_adjust_left = snap_adjust_right = snap_adjust_top = snap_adjust_bottom = 0;
	disable_auto_alpha = 0;
	unlinked = 0;
	scaling = 0;
	transparencyoverride = -1;
	noparent = 0;
	forcealpha = 0;
	nodock = 0;
	resizable = 1;
	scalable = 1;
	nooffscreencheck = 0;
	m_w = m_h = m_endmovesize = 0;

	xuihandle = newXuiHandle();
	CreateXMLParameters(xuihandle);

	if (!alphaMgr)
	{
		alphaMgr = new AlphaMgr();
    #ifdef WASABI_COMPILE_CONFIG
		alphaMgr->setAllLinked(cfg_uioptions_linkallalpha.getValueAsInt());
		alphaMgr->setAutoOpacify(cfg_uioptions_autoopacitylinked.getValueAsInt());
		alphaMgr->setGlobalAlpha(cfg_uioptions_linkedalpha.getValueAsInt());
		alphaMgr->setHoldTime(cfg_uioptions_autoopacitytime.getValueAsInt());
		alphaMgr->setFadeInTime(cfg_uioptions_autoopacityfadein.getValueAsInt());
		alphaMgr->setFadeOutTime(cfg_uioptions_autoopacityfadeout.getValueAsInt());
		alphaMgr->setExtendAutoOpacity(cfg_uioptions_extendautoopacity.getValueAsInt());
#endif
	}
	alphaMgr->addLayout(this);
}

void Layout::CreateXMLParameters(int master_handle)
{
	//LAYOUT_SCRIPTPARENT::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);
}

Layout::~Layout()
{
	if (transparency_reenabled_at) killTimer(TIMER_TRANSPARENCY_AUTOON);
	alphaMgr->removeLayout(this);
	killTimer(TIMER_OFFSCREENCHECK);
	if (lockedto) lockedto->removeLockedLayout(this);
	WASABI_API_WNDMGR->wndTrackRemove(this);
	if (reg) delete reg;
	alllayouts.removeItem(this);
}

int Layout::setXuiParam(int _xuihandle, int attrid, const wchar_t *paramname, const wchar_t *strvalue)
{
	if (xuihandle != _xuihandle) return LAYOUT_PARENT::setXuiParam(_xuihandle, attrid, paramname, strvalue);
	switch (attrid)
	{
	case LAYOUT_SETDESKTOPALPHA:
		setWantDesktopAlpha(WTOI(strvalue));
		break;
	case LAYOUT_SETINDESKTOP:
		setInDesktop(WTOI(strvalue));
		break;
	case LAYOUT_SETALPHA:
		setAlpha(WTOI(strvalue));
		break;
	case LAYOUT_SETLINKWIDTH:
		setLinkWidth(strvalue);
		if (*strvalue && isPostOnInit() && isVisible()) onResize();
		break;
	case LAYOUT_SETLINKHEIGHT:
		setLinkHeight(strvalue);
		if (*strvalue && isPostOnInit() && isVisible()) onResize();
		break;
	case LAYOUT_SETOWNER:
		owner = strvalue;
		break;
	case LAYOUT_NOPARENT:
		setNoParent(WTOI(strvalue));
		break;
	case LAYOUT_FORCEALPHA:
		forcealpha = WTOI(strvalue);
		break;
	case LAYOUT_SETLOCKTO:
		lockto = strvalue;
		break;
	case LAYOUT_SETOSFRAME:
		osframe = WTOI(strvalue);
		break;
	case LAYOUT_SETALPHABACKGROUND:
		setAlphaBackground(strvalue);
		setWantDesktopAlpha(1);
		setDrawBackground(1);
		break;
	case LAYOUT_SETNOACTIVATION:
		wantactiv = WTOI(strvalue) ? 0 : 1;
		break;
	case LAYOUT_SETONTOP:
		initontop = WTOI(strvalue);
		if (isPostOnInit()) updateOnTop();
		break;
	case LAYOUT_SNAPADJUSTLEFT:
		snap_adjust_left = WTOI(strvalue);
		script_vcpu_onSnapAdjustChanged(SCRIPT_CALL, getScriptObject());
#ifdef USEAPPBAR
		if (appbar_isDocked()) appbar_posChanged();
#endif
		break;
	case LAYOUT_SNAPADJUSTTOP:
		snap_adjust_top = WTOI(strvalue);
		script_vcpu_onSnapAdjustChanged(SCRIPT_CALL, getScriptObject());
    #ifdef USEAPPBAR
		if (appbar_isDocked()) appbar_posChanged();
#endif
		break;
	case LAYOUT_SNAPADJUSTRIGHT:
		snap_adjust_right = WTOI(strvalue);
		script_vcpu_onSnapAdjustChanged(SCRIPT_CALL, getScriptObject());
    #ifdef USEAPPBAR
		if (appbar_isDocked()) appbar_posChanged();
#endif
		break;
	case LAYOUT_SNAPADJUSTBOTTOM:
		snap_adjust_bottom = WTOI(strvalue);
		script_vcpu_onSnapAdjustChanged(SCRIPT_CALL, getScriptObject());
    #ifdef USEAPPBAR
		if (appbar_isDocked()) appbar_posChanged();
#endif
		break;
	case LAYOUT_UNLINKED:
		unlinked = WTOI(strvalue);
		if (!unlinked && isPostOnInit() && isVisible()) onResize();
		break;
	case LAYOUT_NODOCK:
		setNoDock(WTOI(strvalue));
		break;
	case LAYOUT_NOOFFSCREENCHECK:
		setNoOffscreenCheck(WTOI(strvalue));
		break;
	case LAYOUT_RESIZABLE:
		resizable = WTOI(strvalue);
		break;
	case LAYOUT_SCALABLE:
		scalable = WTOI(strvalue);
		break;
	default:
		return 0;
	}
	return 1;
}

void Layout::setLinkHeight(const wchar_t *layoutid)
{
	linkedheight = layoutid;
}

void Layout::setLinkWidth(const wchar_t *layoutid)
{
	linkedwidth = layoutid;
}

int Layout::onPostedMove()
{
	updateLockedLayouts();
	int r = LAYOUT_PARENT::onPostedMove();
	Container *c = getParentContainer();
	if (isVisible() && c && c->isMainContainer())
	{
#ifdef WASABI_ON_MAIN_MOVE
		WASABI_ON_MAIN_MOVE(gethWnd());
#endif

	}
	return r;
}

void Layout::cancelCapture()
{
	if (getCapture())
		endCapture();
	captured = 0;
}

int Layout::isOffscreen(ifc_window *w)
{
	if (!w->isVisible()) return 0;
	if (nooffscreencheck) return 0;
#ifdef USEAPPBAR
	if (appbar_isDocked()) return 0;
#endif
	if (lockedto) return 0;
	RECT wr;
	w->getWindowRect(&wr);
	windowTracker->snapAdjustWindowRect(w, &wr);
	RECT r;

	int isontop = 0;
	if (w->getGuiObject())
	{
		isontop = WTOI(w->getGuiObject()->guiobject_getXmlParam(L"ontop"));
#ifndef EXPERIMENTAL_INDEPENDENT_AOT
		if (WTOI(w->getGuiObject()->guiobject_getXmlParam(L"noparent")) == 0)
			isontop = 0;
#endif

	}
	if (!isontop)
	{
#ifdef WASABI_COMPILE_CONFIG
		extern _bool cfg_options_alwaysontop;
		isontop |= cfg_options_alwaysontop.getValueAsInt();
#endif
	}
	Wasabi::Std::getViewport(&r, NULL, &wr, NULL, isontop);
	if (wr.right < r.left + 10 ||
	        wr.bottom < r.top + 10 ||
	        wr.left > r.right - 10 ||
	        wr.top > r.bottom - 10)
	{
		return 1;
	}  //////TO CONTINUE
	return 0;
}

void Layout::offscreenCheck()
{
	int disabled = 0;
#ifdef WASABI_CHECK_OFFSCREENCHECK_DISABLE
	WASABI_CHECK_OFFSCREENCHECK_DISABLE(disabled);
#endif
	if (disabled) return ;
	if (!isVisible()) return ;
	if (moving || scaling || resizing) return ;
	if (isOffscreen(this))
	{
		windowTracker->startCooperativeMove(this);
		for (int i = 0;i < windowTracker->getNumDocked();i++)
		{
			ifc_window *w = windowTracker->enumDocked(i);
			Layout *l = static_cast<Layout*>(w->getInterface(layoutGuid));
			if (l != NULL)
			{
				if (l->getParentContainer() && l->getParentContainer()->isMainContainer())
				{
					if (!isOffscreen(l))
					{
						windowTracker->endCooperativeMove();
						return ;
					}
				}
			}
		}
		windowTracker->endCooperativeMove();
		RECT wr;
		getWindowRect(&wr);
		RECT nr = windowTracker->findOpenRect(wr);
		move(nr.left, nr.top);
	}
}

/**
 * This one only prevents UI resizings from layers!
 */
int Layout::getResizable ()
{
	return this->resizable;
}

/**
 * This one only prevents UI scalings from layers!
 */
int Layout::getScalable ()
{
	return this->scalable;
}

void Layout::setTransparencyOverride(int v)
{
	transparencyoverride = v;
	if (v != -1) setTransparency(v); else updateTransparency();
}

#ifndef PI
#define PI 3.1415926536
#endif

void Layout::timerCallback(int id)
{
	if (id == TIMER_TRANSPARENCY_AUTOON)
	{
		if (!isTransparencySafe(1))
		{
			transparency_reenabled_at = 0;
			return ;
		}
		int n = Wasabi::Std::getTickCount() - transparency_reenabled_at;
		if (n < 1000) return ;
		else
		{
			killTimer(TIMER_TRANSPARENCY_AUTOON);
			transparency_autooff = 0;
			updateTransparency();
			transparency_reenabled_at = 0;
		}
		return ;
	}
	else if (id == TIMER_OFFSCREENCHECK)
	{
		offscreenCheck();
		return ;
	}
	else if (id == TIMER_SETTINGCHANGED)
	{
		killTimer(TIMER_SETTINGCHANGED);
#ifdef _WIN32
		HWND parent;
		webserver = INVALIDOSWINDOWHANDLE;
		listview = INVALIDOSWINDOWHANDLE;
		getExplorerWindows(&parent, &listview, &webserver);
		if (!webserver) // active desktop now off, reposition this window zorder otherwise it will be behind the icons
#ifdef WIN32
			SetWindowPos(gethWnd(), HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_DEFERERASE);
#else
			bringToFront();
#endif
#endif
	}
	else if (id == TIMER_SAVE_ALL_POSITIONS)
	{
		killTimer(TIMER_SAVE_ALL_POSITIONS);
		saveAllPositions();
		// TODO: benski> not 100% sure we want to call into the script on the timer (maybe do it in endMove)
		//script_vcpu_onEndMove(SCRIPT_CALL, getScriptObject());
		return;
	}
	else if (id == TIMER_SAVE_POSITION)
	{
			killTimer(TIMER_SAVE_POSITION);
			savePosition();
			// TODO: benski> not 100% sure we want to call into the script on the timer (maybe do it in endMove)
			//script_vcpu_onEndMove(SCRIPT_CALL, getScriptObject());
		return;
	}
	else LAYOUT_PARENT::timerCallback(id);
}

void Layout::onMouseEnterLayout()
{
	script_vcpu_onMouseEnterLayout(SCRIPT_CALL, getScriptObject());
}

void Layout::onMouseLeaveLayout()
{
	script_vcpu_onMouseLeaveLayout(SCRIPT_CALL, getScriptObject());
}

void Layout::beginMove()
{
	moving = 1;
}

void Layout::beginScale()
{
	scaling = 1;
}

void Layout::beginResize()
{
	resizing = 1;
}

void Layout::endMove()
{
	if (m_endmovesize)
	{
		m_endmovesize = 0;
		RECT r;
		guiresizable_getRootWnd()->getWindowRect(&r);
		r.right = r.left + m_w;
		r.bottom = r.top + m_h;
		guiresizable_getRootWnd()->resizeToRect(&r);
	}
	moving = 0;
	// TODO: benski> do this on a resetable timer so it doesn't go so slowly
	if (WASABI_API_WNDMGR->wndTrackWasCooperative())
		setTimer(TIMER_SAVE_ALL_POSITIONS, 1000);
//		saveAllPositions();
	else
		setTimer(TIMER_SAVE_POSITION, 1000);
		//savePosition();
	// TODO: benski> not 100% sure we want to call into the script on the timer (maybe do it in endMove)
	script_vcpu_onEndMove(SCRIPT_CALL, getScriptObject());
}

void Layout::endScale()
{
	scaling = 0;
	savePosition();
	fixPosition();
}

void Layout::endResize()
{
	resizing = 0;
	RECT r;
	getClientRect(&r);
	RECT wr;
	getWindowRect(&wr);
	script_vcpu_onUserResize(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(wr.left), MAKE_SCRIPT_INT(wr.top), MAKE_SCRIPT_INT(r.right - r.left), MAKE_SCRIPT_INT(r.bottom - r.top));
	savePosition();
}

void Layout::onMove()
{
	script_vcpu_onMove(SCRIPT_CALL, getScriptObject());
}

void Layout::setAutoOpacify(int a)
{
	if (autoopacify == a) return ;
	autoopacify = a != -1 ? a : autoopacify;
	if (getParentContainer() && !getParentContainer()->isTranscient())
	{
		StringW tmp;
		tmp.printf(L"Skin:%s/Container:%s/Layout:%s/autoopacify", WASABI_API_SKIN->getSkinName(), getParentContainer()->getDescriptor(), getGuiObject()->guiobject_getId());
		IntArray::write(tmp, autoopacify);
	}
	updateTransparency();
}

void Layout::controlMenu()
{
	PopupMenu pop;
	int x = 1;
#ifdef WASABI_CHECK_CAN_EXIT
	WASABI_CHECK_CAN_EXIT(x)
#endif
	if (getParentContainer() && getParentContainer()->isMainContainer())
	{
		if (x)
		{
			pop.addCommand(StringPrintfW(L"Exit %s", WASABI_API_APP->main_getAppName()), ACTION_CLOSE);
			pop.addSeparator();
		}
	}
	else
	{
		if (!getParentContainer() || getParentContainer()->canClose())
		{
			pop.addCommand(L"Close window", ACTION_CLOSE_WINDOW);
			pop.addSeparator();
		}
	}
	PopupMenu *scalemenu = new PopupMenu();
	scalemenu->addCommand(L"50%", ACTION_SCALE_50);
	scalemenu->addCommand(L"75%", ACTION_SCALE_75, FALSE, FALSE);
	scalemenu->addCommand(L"100%", ACTION_SCALE_100);
	scalemenu->addCommand(L"125%", ACTION_SCALE_125);
	scalemenu->addCommand(L"150%", ACTION_SCALE_150);
	scalemenu->addCommand(L"200%", ACTION_SCALE_200);
	scalemenu->addCommand(L"400%", ACTION_SCALE_400, FALSE, FALSE);
	pop.addSubMenu(scalemenu, L"Scale");

	PopupMenu *opaqmenu = new PopupMenu();
	opaqmenu->addCommand(L"Auto-fade", ACTION_AUTOOPACIFY, getAutoOpacify(), FALSE);
	opaqmenu->addSeparator();
	opaqmenu->addCommand(L"100%", ACTION_ALPHA_100, FALSE, FALSE);
	opaqmenu->addCommand(L"90%", ACTION_ALPHA_90, FALSE, FALSE);
	opaqmenu->addCommand(L"80%", ACTION_ALPHA_80, FALSE, FALSE);
	opaqmenu->addCommand(L"70%", ACTION_ALPHA_70, FALSE, FALSE);
	opaqmenu->addCommand(L"60%", ACTION_ALPHA_60, FALSE, FALSE);
	opaqmenu->addCommand(L"50%", ACTION_ALPHA_50, FALSE, FALSE);
	opaqmenu->addCommand(L"40%", ACTION_ALPHA_40, FALSE, FALSE);
	opaqmenu->addCommand(L"30%", ACTION_ALPHA_30, FALSE, FALSE);
	opaqmenu->addCommand(L"20%", ACTION_ALPHA_20, FALSE, FALSE);
	opaqmenu->addCommand(L"10%", ACTION_ALPHA_10, FALSE, FALSE);

	pop.addSubMenu(opaqmenu, L"Opacity", !isTransparencySafe());

#ifdef EXPERIMENTAL_INDEPENDENT_AOT
	pop.addCommand(L"Always on top", ACTION_AOT, getAlwaysOnTop());
#endif

	int r = pop.popAtMouse();
	if (r < 0) return ;
	onActionNotify(r, 0);
}

void Layout::fixPosition()
{
	RECT r;
	getWindowRect(&r);
	RECT orig_r = r;

	RECT vr;
	RegionI reg;

	int i = 0;
	while (Wasabi::Std::enumViewports(i, &vr))
	{
		reg.addRect(&vr);
		i++;
	}

	RECT full;
	reg.getBox(&full);


	int dif = r.bottom - full.bottom;
	if (dif > 0) r.top -= dif;
	dif = r.right - full.right;
	if (dif > 0) r.left -= dif;
	dif = full.top - r.top;
	if (dif > 0) r.top += dif;
	dif = full.left - r.left;
	if (dif > 0) r.left += dif;

	if (orig_r.left != r.left || orig_r.top != r.top)
		resize(r.left, r.top, NOCHANGE, NOCHANGE);
}

void Layout::saveAllPositions()
{
	// The positions are saved from the lastest to the first one
	// The 'Player' windows and the 'Main' windows are using the same prefix
	// In saving in decreasing order we are sure the lastest saved is the one for the Player

	for (int i = 0;i < SkinParser::script_getNumContainers();i++)
	{
		Container *c = SkinParser::script_enumContainer(i);
		for (int j = c->getNumLayouts() - 1;j >= 0 ;--j)
		{
			Layout *l = c->enumLayout(j);
			l->savePosition();
		}
	}
}

int Layout::forceTransparencyFlag()
{
	return alphaMgr->needForcedTransparencyFlag(this);
}

void Layout::savePosition()
{
#ifdef WASABI_COMPILE_CONFIG
	if (!getParentContainer() || getParentContainer()->isTranscient())
		return ;

	if (!Wasabi::Std::Wnd::isValidWnd(getOsWindowHandle()))
		return ;


	StringW        prefix       = MakePrefix();
	StringPrintfW  tmp( L"%s/odim", prefix.v() );

	SkinBitmap    *baseTexture = getBaseTexture();

	if ( baseTexture )
	{
		IntArray::write( tmp, baseTexture->getWidth(), baseTexture->getHeight() );
	}
	else
	{
		IntArray::write( tmp, -2, -2 );
	}

	RECT r, rs;
	getClientRect(&r); // unscaled
	//DebugStringW( L"\nLayout::savePosition()              - x = %d, y = %d, w = %d, h = %d \n", r.left, r.top, r.right - r.left, r.bottom - r.top );

	if (r.left == 0 && r.top == 0 && r.right == 0 && r.bottom == 0)
		return ;

	getWindowRect(&rs); // screen scaled (for x/y)
	tmp.printf(L"%s/rect", prefix.v());
	IntArray::write(tmp, rs.left, rs.top, r.right - r.left, r.bottom - r.top);
	//DebugStringW( L"Layout::savePosition() rect         - x = %d, y = %d, w = %d, h = %d \n", rs.left, rs.top, r.right - r.left, r.bottom - r.top );

	getRestoredRect(&rs);
	tmp.printf(L"%s/restoredrect", prefix.v());
	IntArray::write(tmp, rs.left, rs.top, rs.right - rs.left, rs.bottom - rs.top);

	//DebugStringW( L"Layout::savePosition() restoredrect - x = %d, y = %d, w = %d, h = %d \n", rs.left, rs.top, rs.right - rs.left, rs.bottom - rs.top );

	tmp.printf(L"%s/maximized", prefix.v());
	//  DebugString("isMaximized = %d\n", isMaximized());
	WASABI_API_CONFIG->setIntPrivate(tmp, isMaximized());

	tmp.printf(L"%s/r", prefix.v());
	WASABI_API_CONFIG->setStringPrivate(tmp, StringPrintfW(getRenderRatio()));

	tmp.printf(L"%s/sm", prefix.v());
	TextInfoCanvas textInfoCanvas(this);
	WASABI_API_CONFIG->setStringPrivate(tmp, StringPrintfW(textInfoCanvas.getSystemFontScale()));

	tmp.printf(L"%s/sl", prefix.v());
	WASABI_API_CONFIG->setStringPrivate(tmp, StringPrintfW(scalelocked));

	tmp.printf(L"%s/autoopacify", prefix.v());
	IntArray::write(tmp, autoopacify);

#ifdef USEAPPBAR
	saveAppBarPosition();
#endif

#endif
}
#ifdef USEAPPBAR
void Layout::saveAppBarPosition()
{
	if (m_allowsavedock)
	{
		StringW prefix = MakePrefix();
		StringW wtmp = StringPrintfW(L"%s/appbar", prefix.v());
		WASABI_API_CONFIG->setIntPrivate(wtmp, appbar_getSide());
		wtmp.printf(L"%s/appbarontop", prefix.v());
		WASABI_API_CONFIG->setIntPrivate(wtmp, appbar_wantAlwaysOnTop());
		wtmp.printf(L"%s/appbarhidden", prefix.v());
		WASABI_API_CONFIG->setIntPrivate(wtmp, appbar_isHiding());
		wtmp.printf(L"%s/appbarisautohide", prefix.v());
		WASABI_API_CONFIG->setIntPrivate(wtmp, appbar_isAutoHiding());
		wtmp.printf(L"%s/appbarwantautohide", prefix.v());
		WASABI_API_CONFIG->setIntPrivate(wtmp, appbar_wantAutoHide());
	}
}
#endif
void Layout::lockScale(int locked)
{
	scalelocked = locked;
	StringW tmp;
	StringW prefix = MakePrefix();
	tmp.printf(L"%s/sl", prefix.v());
	WASABI_API_CONFIG->setStringPrivate(tmp, StringPrintfW(scalelocked));
}

void Layout::resize(int x, int y, int w, int h, int wantcb)
{
	if (inresize) return ;
	inresize = 1;
	LAYOUT_PARENT::resize(x, y, w, h, wantcb);
	if (!lockedto)
		getGuiObject()->guiobject_setGuiPosition(&x, &y, &w, &h, NULL, NULL, NULL, NULL);
	inresize = 0;
}

void Layout::move(int x, int y)
{
	//DebugStringW( L"Layout::move( x = %d, y = %d )\n", x, y );

	LAYOUT_PARENT::move(x, y);
	getGuiObject()->guiobject_setGuiPosition(&x, &y, NULL, NULL, NULL, NULL, NULL, NULL);
}

#define DC_CHECKLASTRESIZE 0x109
#ifdef USEAPPBAR
#define DC_LOADSAVEDDOCK 0x10A
#endif
#define DC_INVALIDATE 0x10B

int Layout::onResize()
{
	LAYOUT_PARENT::onResize();
	if (!abortSaving()) savePosition();
	RECT r;
	getClientRect(&r);
	if (!linkedwidth.isempty())
	{
		if (!inlinkwidth)
		{
			inlinkwidth = 1;
			RECT cr;
			Layout *l = getParentContainer() ? getParentContainer()->getLayout(linkedwidth) : NULL;
			if (l)
			{
				int _unlinked = l->isUnlinked();
				_unlinked |= isUnlinked();
				if (!_unlinked)
				{
					l->getClientRect(&cr);
					POINT pt;
					l->getPosition(&pt);
					l->resize(pt.x, pt.y, r.right - r.left, cr.bottom - cr.top);
				}
			}
			inlinkwidth = 0;
		}
	}
	if (!linkedheight.isempty())
	{
		if (!inlinkheight)
		{
			inlinkheight = 1;
			RECT cr;
			Layout *l = getParentContainer() ? getParentContainer()->getLayout(linkedheight) : NULL;
			if (l)
			{
				int _unlinked = l->isUnlinked();
				_unlinked |= isUnlinked();
				if (!_unlinked)
				{
					l->getClientRect(&cr);
					POINT pt;
					l->getPosition(&pt);
					l->resize(pt.x, pt.y, cr.right - cr.left, r.bottom - r.top);
				}
			}
		}
		inlinkheight = 0;
	}
	updateLockedLayouts();

	postDeferredCallback(DC_CHECKLASTRESIZE);

	return 1;
}

int Layout::onDeferredCallback(intptr_t p1, intptr_t p2)
{
	/*  if (p1 == DC_CHECKLASTRESIZE) {
	    RECT vr;
	    RECT r;
	    RECT wr;
	    Std::getViewport(&vr, NULL, NULL, gethWnd(), 1);
	    if (renderRatioActive())
	      divRatio(&vr);
	    getClientRect(&r);
	    r.bottom -= snap_adjust_bottom;
	    r.top += snap_adjust_top;
	    r.right -= snap_adjust_right;
	    r.left += snap_adjust_left;
	    getWindowRect(&wr);
	    int n = 0;
	    if (r.right-r.left > vr.right-vr.left) { r.right = r.left + vr.right-vr.left; n++; } 
	    if (r.bottom-r.top > vr.bottom-vr.top) { r.bottom = r.top + vr.bottom-vr.top; n++; }
	    if (n) resize(wr.left, wr.top, r.right-r.left+snap_adjust_left+snap_adjust_right, r.bottom-r.top+snap_adjust_top+snap_adjust_bottom);
	  } else */
#ifdef USEAPPBAR
	if (p1 == DC_LOADSAVEDDOCK)
	{}
#endif

	if (p1 == DC_INVALIDATE)
	{
		invalidate();
	}
	return LAYOUT_PARENT::onDeferredCallback(p1, p2);
	//  return 1;
}

void Layout::updateLockedLayouts()
{
	for (int i = 0;i < getNumLockedLayouts();i++)
	{
		Layout *l = enumLockedLayout(i);

		if (l->getRenderRatio() != getRenderRatio())
			l->setRenderRatio(getRenderRatio());

		int x, y, w, h;
		l->getGuiObject()->guiobject_getGuiPosition(&x, &y, &w, &h, NULL, NULL, NULL, NULL);
		RECT r;
		l->getClientRect(&r);
		if (w == AUTOWH) w = r.right - r.left;
		if (h == AUTOWH) h = r.bottom - r.top;
		POINT pt;
		l->getPosition(&pt);
		if (x == AUTOWH) x = pt.x; else clientToScreen(&x, NULL);
		if (y == AUTOWH) y = pt.y; else clientToScreen(NULL, &y);
		RECT cr;
		l->getWindowRect(&cr);
		if (cr.left != x || cr.top != y || cr.right != cr.left + w || cr.bottom != cr.top + h)
			l->Group::resize(x, y, w, h);
	}
}

int Layout::isClickThrough()
{
	return 0;
}
#ifdef _WIN32
LRESULT Layout::wndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{

#ifdef ON_CUSTOM_ALTF4
	if (uMsg == WM_KEYDOWN || uMsg == WM_SYSKEYDOWN)
		if (wParam == VK_F4)
			if (GetAsyncKeyState(VK_MENU)&0x8000) ON_CUSTOM_ALTF4;
#endif

	if (uMsg == WM_KILLFOCUS || uMsg == WM_SETFOCUS)
	{
		alphaMgr->hoverCheck(this);
	}

	if (forwardMsgWnd != INVALIDOSWINDOWHANDLE)
	{
		switch (uMsg)
		{
		case WM_MOUSEWHEEL:
			return (SendMessageW(forwardMsgWnd, uMsg, wParam, 0x31337)); // 0x31337 avoid main window callback
			//case WM_DESTROY: //FG> commented out, makes wa quit when layout is destroyed
		case WM_CLOSE:
			return (SendMessageW(forwardMsgWnd, uMsg, wParam, lParam));

		case WM_SETTINGCHANGE:
			{
				if (!indesktop) break;
				setTimer(TIMER_SETTINGCHANGED, 1000);
			}
			break; //BU think this should be here eh

#ifdef WIN32
		case 0x0319:
			{	// hehe --BU
				if (lParam & 0x20000)
					FireAction(L"NEXT", NULL, 0, 0, NULL, 0, NULL, FALSE);
				else
					FireAction(L"PREV", NULL, 0, 0, NULL, 0, NULL, FALSE);
			}
			break;
#endif 
			/*
			      WIP: This won't work anymore.  What should we do about it? -- mig
			 
			        childNotify(NULL, CHILD_NOTIFY_LEFTPUSH, ACTION_NEXT);
			        break;
			*/
		}
	}
	return LAYOUT_PARENT::wndProc(hWnd, uMsg, wParam, lParam);
}
#else
OSStatus Layout::eventHandler(EventHandlerCallRef	inHandlerCallRef, EventRef inEvent, void *inUserData)
{
  return LAYOUT_PARENT::eventHandler(inHandlerCallRef, inEvent, inUserData);
}
#warning port me
#endif

/*int Layout::onRightButtonDown(int x, int y) {
  LAYOUT_PARENT::onRightButtonDown(x, y);
//  Main::appContextMenu(this, TRUE, isTransparencySafe());
  return 1;
}*/

ifc_window *Layout::getCustomOwner()
{
	if (noparent) return NULL;
	if (owner.isempty()) return NULL;
	return SkinParser::getLayout(owner);
}

void Layout::addLockedLayout(Layout *l)
{
	locked.addItem(l);
	updateLockedLayouts();
}

void Layout::removeLockedLayout(Layout *l)
{
	locked.removeItem(l);
}

int Layout::getNumLockedLayouts()
{
	return locked.getNumItems();
}

Layout *Layout::enumLockedLayout(int n)
{
	return locked.enumItem(n);
}

int Layout::isLocked()
{
	return (!lockto.isempty() 
          #ifdef USEAPPBAR
          || cfg_options_appbarondrag == 0 && appbar_isDocked()
#endif
          );
}

void Layout::lockTo(Layout *t)
{
	if (t == NULL) return ;
	if (lockedto) lockedto->removeLockedLayout(this);
	lockedto = t;
	t->addLockedLayout(this);
}

Layout *Layout::getLockedTo()
{
	return lockedto;
}

int Layout::reinit(OSMODULEHANDLE inst, OSWINDOWHANDLE parent, int nochild)
{
	StringW osname = getOSWndName();
	ASSERTPR(!indesktop, "in desktop reinit failed");
	if (noparent)
		parent = NULL;
	int r = LAYOUT_PARENT::reinit(inst, parent, nochild);
	setOSWndName(osname);
	return r;
}

int Layout::init(OSMODULEHANDLE inst, OSWINDOWHANDLE parent, int nochild)
{
	if (noparent) parent = NULL;
	if (!indesktop) return LAYOUT_PARENT::init(inst, parent, nochild);

#ifdef _WIN32
	webserver = INVALIDOSWINDOWHANDLE;
	listview = INVALIDOSWINDOWHANDLE;

	getExplorerWindows(&parent, &listview, &webserver);

	if (!parent)
	{
		indesktop = 0;
		return LAYOUT_PARENT::init(inst, parent, nochild);
	}
#endif
	nochild = 0;

#ifdef _WIN32
	// if active desktop is off, that's all we can do, we'll be on top of the icons
	// if active desktop is on, but listview is not, we'll be on top of active desktop
	if (!webserver || !listview) return LAYOUT_PARENT::init(inst, parent, nochild);
#endif

#ifdef WIN32
	// find who we're gonna sit on top of
	HWND behind = listview;
	if (GetWindow(listview, GW_HWNDPREV))
		behind = GetWindow(listview, GW_HWNDPREV);
#else
	DebugString( "portme -- Layout::init\n" );
#endif

	int r = LAYOUT_PARENT::init(inst, parent, nochild);
#ifdef WIN32
	SetWindowPos(gethWnd(), behind, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_DEFERERASE);
#endif

	return r;
}

#ifdef WIN32
void Layout::getExplorerWindows(OSWINDOWHANDLE *parent, OSWINDOWHANDLE *listview, OSWINDOWHANDLE *webserver)
{
	*parent = NULL;
	*listview = NULL;
	*webserver = NULL;

	char classname[256] = "";
	HWND w;

	// find explorer window. todo: litestep support ?
	*parent = FindWindowA(NULL, "Program Manager");
	if (!*parent) return ;

	// find its first child for parenting
	*parent = GetWindow(*parent, GW_CHILD);
	if (!*parent) return ;

	// find the children
	w = GetWindow(*parent, GW_CHILD);

	while (w)
	{
		GetClassNameA(w, classname, 255);
		if (!*webserver && STRCASEEQL("Internet Explorer_Server", classname))
			*webserver = w;
		if (!*listview && STRCASEEQL("SysListView32", classname))
			*listview = w;
		w = GetWindow(w, GW_HWNDNEXT);
	}
}
#endif

int Layout::onInit()
{
	LAYOUT_PARENT::onInit();

	Container *c = getParentContainer();
	if (c != NULL)
	{
		const wchar_t *s = c->getName();
		if (s != NULL)
		{
			setOSWndName(s);
		}
	}

	loadSavedState();

#ifdef WA3COMPATIBILITY
	setIcon(WASABI_API_APP->main_getIcon(TRUE), TRUE);
	setIcon(WASABI_API_APP->main_getIcon(FALSE), FALSE);
#endif

	WASABI_API_WNDMGR->wndTrackAdd(this);

	if (wantDesktopAlpha() && isDesktopAlphaSafe())
		desktopAlpha_autoTurnOn();

	if (getBaseTexture())
	{
		//RECT r = {0, 0, getBaseTexture()->getWidth(), getBaseTexture()->getHeight()};
		delete reg;
#ifdef _WIN32
		reg = new RegionI(getBaseTexture(), NULL, 0, 0, 0, 0, 0, 0, getDesktopAlpha() ? 1 : 255);
		setRegion(reg);
#else
#warning port me
#endif
	}

	SystemObject::onCreateLayout(this);

	if (!lockto.isempty()) lockTo(SkinParser::getLayout(lockto));

	updateOnTop();

	setNoOffscreenCheck( -1);

	return 1;
}

void Layout::updateOnTop()
{
  #ifdef USEAPPBAR
	if (!appbar_isDocked())
#endif
	{
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
		setAlwaysOnTop(initontop);
#else
		if (noparent)
		{
			int disable = 0;
#ifdef WASABI_GET_TEMPDISABLE_AOT
			WASABI_GET_TEMPDISABLE_AOT(disable);
#endif
#ifdef _WIN32
			if (initontop && !disable) SetWindowPos(getOsWindowHandle(), HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOOWNERZORDER | SWP_NOACTIVATE);
			else SetWindowPos(getOsWindowHandle(), HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOOWNERZORDER | SWP_NOACTIVATE);
#else
#warning port me
#endif
		}
#endif

	}
}

void Layout::loadSavedState()
{
#ifdef WASABI_COMPILE_CONFIG
	StringW tmp;
#endif
	wchar_t t[64] = L"";

	int ow = -1;
	int oh = -1;
	int ra = -1;

#ifdef WASABI_COMPILE_CONFIG
	if (getParentContainer() && !getParentContainer()->isTranscient())
	{
		StringW prefix = MakePrefix();
		tmp.printf(L"%s/odim", prefix.v());
		IntArray::read(tmp, &ow, &oh);

		tmp.printf(L"%s/alpha", prefix.v());
		IntArray::read(tmp, &ra);

		tmp.printf(L"%s/autoopacify", prefix.v());
		IntArray::read(tmp, &autoopacify);

	}
#endif

	int from_scratch = 0;
	if (Std::keyModifier(STDKEY_SHIFT) && Std::keyModifier(STDKEY_ALT) && Std::keyModifier(STDKEY_CONTROL)) from_scratch = 1;
#ifdef WASABI_COMPILE_CONFIG
	if (getParentContainer() && !getParentContainer()->isTranscient())
	{
		StringW prefix = MakePrefix();
		tmp.printf(L"%s/sl", prefix.v());
		WASABI_API_CONFIG->getStringPrivate(tmp, t, 63, L"0");
		lockScale(WTOI(t));
	}
#endif

	*t = 0;
#ifdef WASABI_COMPILE_CONFIG
	if (getParentContainer() && !getParentContainer()->isTranscient())
	{
		StringW prefix = MakePrefix();
		tmp.printf(L"%s/sm", prefix.v());
	}

	 WASABI_API_CONFIG->getStringPrivate(tmp, t, 63, L"1.");
	//double sm = (float)WTOF(t);
#else
	//double sm = 1.0;
#endif
	/*if (ABS(sm - Canvas::getSystemFontScale()) > 0.001)
	  from_scratch = 1;*/

	if (Group::getBaseTexture() && alphabackground.getBitmap() != NULL)
	{
		if (Group::getBaseTexture()->getWidth() != alphabackground.getWidth() || Group::getBaseTexture()->getHeight() != alphabackground.getHeight())
		{
			ASSERTPR(0, StringPrintf("layout %S should have same size for background and alphabackground", getGuiObject()->guiobject_getParentLayout()->getGuiObject()->guiobject_getId()));
		}
	}

	if ((ow != -2 && oh != -2) && (ow == -1 || oh == -1 || (getBaseTexture() && (ow != getBaseTexture()->getWidth() || oh != getBaseTexture()->getHeight()))))
		from_scratch = 1;

	int w = 0, h = 0;
	int findrect = 0;

	if (from_scratch || (getParentContainer() && getParentContainer()->isTranscient()))
	{
		if (getParentContainer())
		{
			int _x = getParentContainer()->getDefaultPositionX();
			int _y = getParentContainer()->getDefaultPositionY();
			x = _x == -1 ? x : _x;
			y = _y == -1 ? y : _y;
			if (x == -1 && y == -1) findrect = 1;
		}
		else
		{
			int _x, _y;
			getGuiObject()->guiobject_getGuiPosition(&_x, &_y, NULL, NULL, NULL, NULL, NULL, NULL);
			if (_x != AUTOWH && _x != NOCHANGE) x = _x;
			if (_y != AUTOWH && _y != NOCHANGE) y = _y;
		}
		getGuiObject()->guiobject_getGuiPosition(NULL, NULL, &w, &h, NULL, NULL, NULL, NULL);
		if (w == AUTOWH || h == AUTOWH)
		{
			w = getPreferences(SUGGESTED_W);
			h = getPreferences(SUGGESTED_H);
			int _minx = getPreferences(MINIMUM_W);
			int _maxx = getPreferences(MAXIMUM_W);
			int _miny = getPreferences(MINIMUM_H);
			int _maxy = getPreferences(MAXIMUM_H);
			if (_minx != AUTOWH && _maxx != AUTOWH && _minx > _maxx) _minx = _maxx;
			if (_miny != AUTOWH && _maxy != AUTOWH && _miny > _maxy) _miny = _maxy;
			if (w == AUTOWH && _minx != AUTOWH) w = _minx;
			if (h == AUTOWH && _miny != AUTOWH) h = _miny;
			TextInfoCanvas textInfoCanvas(this);
			double fontScale = textInfoCanvas.getSystemFontScale();
			if (w != AUTOWH && getGuiObject()->guiobject_getAutoSysMetricsW())
				w = (int)((float)w * fontScale);
			if (h != AUTOWH && getGuiObject()->guiobject_getAutoSysMetricsH())
				h = (int)((float)h * fontScale);
		}
	}
	else
	{
		if (getParentContainer())
		{

			if (getParentContainer()->isMainContainer()) //FG> could be a new component installed
				SkinParser::noCenterSkin();

#ifdef WASABI_COMPILE_CONFIG
			StringW prefix = MakePrefix();

			tmp.printf(L"%s/rect", prefix.v());
			IntArray::read(tmp, &x, &y, &w, &h);

			RECT rr;
			tmp.printf(L"%s/restoredrect", prefix.v());
			IntArray::read(tmp, (int*)&rr.left, (int*)&rr.top, (int*)&rr.right, (int*)&rr.bottom);
			rr.right += rr.left;
			rr.bottom += rr.top;

			tmp.printf(L"%s/maximized", prefix.v());
			if (WASABI_API_CONFIG->getIntPrivate(tmp, 0)) setRestoredRect(&rr);

#endif

		}
	}

	*t = 0;
	double ratio = 1.0;

	if (!from_scratch)
	{
		if (getParentContainer())
		{
#ifdef WASABI_COMPILE_CONFIG
			StringW prefix = MakePrefix();
			tmp.printf(L"%s/r", prefix.v());

			WASABI_API_CONFIG->getStringPrivate(tmp, t, 63, L"1.");
			ratio = WTOF(t);
#else
			ratio = 1.0f;
#endif

		}
	}

#ifdef ON_TWEAK_RENDER_RATIO
	if (!scalelocked) ON_TWEAK_RENDER_RATIO(ratio);
#endif

	if (w == 0 || h == 0 || from_scratch)
	{
		int _w = getPreferences(SUGGESTED_W);
		w = _w == AUTOWH ? w : _w;
		int _h = getPreferences(SUGGESTED_H);
		h = _h == AUTOWH ? h : _h;

		TextInfoCanvas textInfoCanvas(this);
		double fontScale = textInfoCanvas.getSystemFontScale();

		if (getGuiObject()->guiobject_getAutoSysMetricsW())
			w = (int)((float)w * fontScale);
		if (getGuiObject()->guiobject_getAutoSysMetricsH())
			h = (int)((float)h * fontScale);
		if (w == 0 || h == 0)
		{
			w = getBaseTexture()->getWidth();
			h = getBaseTexture()->getHeight();
		}
		RECT sr = {x, y, x + w, y + h};
		if (findrect)
			sr = windowTracker->findOpenRect(Wasabi::Std::makeRect(0, 0, (int)((float)w * getRenderRatio()), (int)((float)h * getRenderRatio())), this);
		sr.right = sr.left + w;
		sr.bottom = sr.top + h;
		BaseWnd::resize(&sr);
	}
	else
	{
		RECT cr;
		getClientRect(&cr);
		RECT r = {x, y, x + w, y + h};
		BaseWnd::resize(&r);
	}

	setAlpha(from_scratch || ra == -1 ? alpha : ((ra < 254) ? ra : 255));

	Layout *main = SkinParser::getMainLayout();
	if (main != this && main 
      #ifdef WASABI_COMPILE_CONFIG
      && cfg_uioptions_linkallratio.getValueAsInt() 
#endif
      && !noparent)
	{
		setRenderRatio(main->getRenderRatio());
	}
	else setRenderRatio(ratio);

	setAutoOpacify(autoopacify);

#ifdef USEAPPBAR
	postDeferredCallback(DC_LOADSAVEDDOCK);

	if (getParentContainer() && !getParentContainer()->isTranscient())
	{
		StringW prefix = MakePrefix();
		StringW tmp = StringPrintfW(L"%s/appbar", prefix.v());
		int side = WASABI_API_CONFIG->getIntPrivate(tmp, APPBAR_NOTDOCKED);
		tmp.printf(L"%s/appbarisautohide", prefix.v());
		int is_autohide = WASABI_API_CONFIG->getIntPrivate(tmp, 0);
		tmp.printf(L"%s/appbarwantautohide", prefix.v());
		appbar_want_autohide = is_autohide || WASABI_API_CONFIG->getIntPrivate(tmp, 1);
		tmp.printf(L"%s/appbarontop", prefix.v());
		appbar_want_alwaysontop = WASABI_API_CONFIG->getIntPrivate(tmp, 1);
		tmp.printf(L"%s/appbarhidden",prefix.v());
		int curside = appbar_getSide();
		if (side != curside)
		{
			if (side == APPBAR_NOTDOCKED)
				// starting up docked ??
				appbar_dock(side);
			else
			{
				setNoParent(2);
				BaseWnd::reinit();
				appbar_dock(side);
			}
		}
	}
	m_allowsavedock = 1;

#endif
}

void Layout::setBaseTexture(const wchar_t *b, int regis)
{
	LAYOUT_PARENT::setBaseTexture(b, 0); // 0, not regis!
	if (!getDesktopAlpha() || ((wantDesktopAlpha()) && alphabackground.getBitmap() == NULL))
	{
		if (regis) WASABI_API_WND->skin_unregisterBaseTextureWindow(this);
		if (getBaseTexture())
		{
			//RECT r = {0, 0, getBaseTexture()->getWidth(), getBaseTexture()->getHeight()};
			delete reg;
#ifdef _WIN32
			reg = new RegionI(getBaseTexture(), NULL, 0, 0, 0, 0, 0, 0, getDesktopAlpha() ? 1 : 255);
			setRegion(reg);
#else
#warning port me
#endif
		}
		if (regis)
			WASABI_API_WND->skin_registerBaseTextureWindow(this, getBackgroundStr());
	}
}

void Layout::setWantDesktopAlpha(int want)
{
	if (want && !Wasabi::Std::Wnd::isDesktopAlphaAvailable())
	{
		//    WASABI_API_WNDMGR->messageBox("Desktop Alpha Blending is only available for Win2000/WinXP and above", "Sorry", MSGBOX_OK, NULL, NULL);
		return ;
	}
	wantdesktopalpha = want;
	if (wantdesktopalpha && isInited() && isDesktopAlphaSafe())
		desktopAlpha_autoTurnOn();
	else if (!wantdesktopalpha && getDesktopAlpha())
		desktopAlpha_autoTurnOff();
}

int Layout::wantDesktopAlpha()
{
	return wantdesktopalpha;
}

int Layout::handleDesktopAlpha()
{
	return 1;
}

void Layout::onGuiObjectSetVisible(GuiObject *o, int visible)
{
	if (disable_auto_alpha) return ;
	if (!o || !o->guiobject_getRootWnd()) return ;
	if (visible)
	{
		if (getDesktopAlpha())
		{
			if (!o->guiobject_getRootWnd()->handleDesktopAlpha())
			{
				desktopAlpha_autoTurnOff();
			}
		}
		if (!transparency_autooff)
		{
			if (!o->guiobject_getRootWnd()->handleTransparency())
			{
				transparency_autoTurnOff();
			}
		}
	}
	else
	{ // !visible
		if (!getDesktopAlpha() && wantDesktopAlpha())
		{
			if (isDesktopAlphaSafe())
				desktopAlpha_autoTurnOn();
		}
		if (transparency_autooff)
		{
			if (isTransparencySafe(1))
				transparency_autoTurnOn();
		}
	}
}

void Layout::desktopAlpha_autoTurnOn()
{

	setDesktopAlpha(1);

	WASABI_API_WND->skin_unregisterBaseTextureWindow(this);

	if (getBaseTexture())
	{
		//RECT r = {0, 0, getBaseTexture()->getWidth(), getBaseTexture()->getHeight()};
		delete reg;
#ifdef _WIN32
		reg = new RegionI(getBaseTexture(), NULL, 0, 0, 0, 0, 0, 0, 1);
		setRegion(reg);
#else
#warning port me
#endif
	}

	WASABI_API_WND->skin_registerBaseTextureWindow(this, alphabackground.getBitmap() ? alphabackgroundstr.getValue() : getBackgroundStr());

	invalidate();
}

void Layout::desktopAlpha_autoTurnOff()
{
#ifdef WIN32
	SetWindowRedraw(gethWnd(), FALSE);//LockWindowUpdate(gethWnd());
	setDesktopAlpha(0);

	WASABI_API_WND->skin_unregisterBaseTextureWindow(this);

	if (getBaseTexture())
	{
		//RECT r = {0, 0, getBaseTexture()->getWidth(), getBaseTexture()->getHeight()};
		delete reg;
		reg = new RegionI(getBaseTexture(), NULL, 0, 0, 0, 0, 0, 0, 255);
		setRegion(reg);
	}

	WASABI_API_WND->skin_registerBaseTextureWindow(this, getBackgroundStr());
	SetWindowRedraw(gethWnd(), TRUE);//LockWindowUpdate(NULL);

	invalidate();
#else
	DebugString( "portme -- Layout::init\n" );
#endif
}

void Layout::transparency_autoTurnOn()
{
	transparency_reenabled_at = Wasabi::Std::getTickCount();
	setTimer(TIMER_TRANSPARENCY_AUTOON, 500);
}

void Layout::transparency_autoTurnOff()
{
	transparency_autooff = 1;
	killTimer(TIMER_TRANSPARENCY_AUTOON);
	updateTransparency();
}

void Layout::onGlobalEnableDesktopAlpha(int enabled)
{
	foreach(alllayouts)
	alllayouts.getfor()->globalEnableDesktopAlpha(enabled);
	endfor
#ifdef ON_TOGGLE_DESKTOPALPHA
	ON_TOGGLE_DESKTOPALPHA(enabled);
#endif
}

void Layout::globalEnableDesktopAlpha(int enabled)
{
	if (enabled)
	{
		galphadisabled = 0;
		setWantDesktopAlpha(wantdesktopalpha);
	}
	else
	{
		galphadisabled = 1;
		if (getDesktopAlpha())
			desktopAlpha_autoTurnOff();
	}
}

void Layout::setWantRedrawOnResize(int v)
{
	if (wantredrawonresize == v) return ;
	wantredrawonresize = v;
}

PtrList<Layout> Layout::alllayouts;

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

	RECT r;

	if (!canvas->getClipBox(&r))
		getClientRect(&r);

	canvas->fillRect(&r, 0);

	LAYOUT_PARENT::onPaint(canvas);

	return 1;
}

/*WndHolder *Layout::getHolder() {
  return this;
}*/

SkinBitmap *Layout::getBaseTexture()
{
#ifdef WASABI_COMPILE_CONFIG
	// {9149C445-3C30-4e04-8433-5A518ED0FDDE}
	const GUID uioptions_guid =
	    { 0x9149c445, 0x3c30, 0x4e04, { 0x84, 0x33, 0x5a, 0x51, 0x8e, 0xd0, 0xfd, 0xde } };
	int alphaenabled = _intVal(WASABI_API_CONFIG->config_getCfgItemByGuid(uioptions_guid), L"Enable desktop alpha");
#else
	int alphaenabled = WASABI_WNDMGR_DESKTOPALPHA;
#endif
	if (!alphabackground.getBitmap() || !getDesktopAlpha() || !alphaenabled) return LAYOUT_PARENT::getBaseTexture();
	return alphabackground.getBitmap();
}

int Layout::runAction(int actionid, const wchar_t *param)
{
	switch (actionid)
	{
	case ACTION_SWITCH:
		if (getParentContainer())
		{
			getParentContainer()->switchToLayout(param);
		}
		break;
	case ACTION_TOGGLE:
		SkinParser::toggleContainer(param);
		break;
#ifdef WA3COMPATIBILITY
	case ACTION_MENU:
		Main::doMenu(param);
		break;
#endif
	case ACTION_ENDMODAL:
		endModal(WTOI(param));
		break;
	case ACTION_CLOSE:
		onActionNotify(ACTION_CLOSE);
		break;
#ifdef WA3COMPATIBILITY
	default:
		if (actionid != 0)
			Main::doAction(actionid);
		break;
#else
	case ACTION_MINIMIZE:
#ifdef _WIN32
		ShowWindow(WASABI_API_WND->main_getRootWnd()->gethWnd(), SW_MINIMIZE);
#endif
		break;
#endif

	}
	return 0;
}

int Layout::childNotify(ifc_window *child, int msg, intptr_t param1, intptr_t param2)
{
	if (msg == ACTION_ENFORCEMINMAX)
	{
		loadSavedState();
		return 0;
	}
	if (child != NULL)
	{
		int objId = child->getNotifyId();
		if (msg == ChildNotify::BUTTON_LEFTPUSH)
		{
			switch (objId)
			{
			case ACTION_SWITCH:
			case ACTION_TOGGLE:
			case ACTION_MENU:
				runAction(objId, ((Wasabi::Button *)child)->getParam());
				break;
			case ACTION_ENDMODAL:
				{
					StringPrintfW s(L"%d", (static_cast<ButtonWnd *>(child))->getModalRetCode());
					runAction(ACTION_ENDMODAL, s);
				}
				break;
			case ACTION_CLOSE:
				runAction(ACTION_CLOSE);
				break;
				/*
				#ifdef WA3COMPATIBILITY
				        case ACTION_EJECT:
				          runAction(ACTION_EJECT, "0");
				          break;
				#endif
				*/
			default:
				runAction(objId);
				break;
			}
			return 0;
		}
		if (msg == ChildNotify::BUTTON_RIGHTPUSH)
		{
			//FUCKO    child->abortTip();
			//	  POINT pt;
			//	  Std::getMousePos(&pt);
			//	  screenToClient(&pt);
			//	  onRightButtonDown(pt.x, pt.y);
#pragma warning (disable: 4060)
			switch (objId)
			{
				/*
				#ifdef WA3COMPATIBILITY
				        case ACTION_EJECT: {
				          runAction(ACTION_EJECT, "1");
				        }
				        break;
				#endif
				*/
			}
#pragma warning (default: 4060)
			return 0;
		}
	}
	return LAYOUT_PARENT::childNotify(child, msg, param1, param2);
}

int Layout::onActionNotify(int action, intptr_t param)
{
	switch (action)
	{
#ifdef WA3COMPATIBILITY
	case ACTION_SYSMENU:
		Main::appContextMenu(this, TRUE, isDesktopAlphaSafe());
		break;
	case ACTION_CONTROLMENU:
		controlMenu();
		break;
	case ACTION_WINDOWMENU:
		Main::thingerContextMenu(this);
		break;
#elif defined(WASABI_CUSTOM_CONTEXTMENUS)
	case ACTION_SYSMENU:
		extern void appContextMenu(ifc_window *w);
		appContextMenu(this);
		break;
	case ACTION_CONTROLMENU:
		extern void appControlMenu(ifc_window *w);
		appControlMenu(this);
		break;
#endif
	case ACTION_SCALE_50: scaleTo(50); break;
	case ACTION_SCALE_75: scaleTo(75); break;
	case ACTION_SCALE_100: scaleTo(100); break;
	case ACTION_SCALE_125: scaleTo(125); break;
	case ACTION_SCALE_150: scaleTo(150); break;
	case ACTION_SCALE_200: scaleTo(200); break;
	case ACTION_SCALE_400: scaleTo(400); break;
	case ACTION_ALPHA_10: setAlpha(25); break;
	case ACTION_ALPHA_20: setAlpha(51); break;
	case ACTION_ALPHA_30: setAlpha(76); break;
	case ACTION_ALPHA_40: setAlpha(102); break;
	case ACTION_ALPHA_50: setAlpha(127); break;
	case ACTION_ALPHA_60: setAlpha(153); break;
	case ACTION_ALPHA_70: setAlpha(178); break;
	case ACTION_ALPHA_80: setAlpha(204); break;
	case ACTION_ALPHA_90: setAlpha(229); break;
	case ACTION_ALPHA_100: setAlpha(255); break;
	case ACTION_AUTOOPACIFY: setAutoOpacify(!getAutoOpacify()); break;
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
	case ACTION_AOT: setAlwaysOnTop(!getAlwaysOnTop()); break;
#endif
	case ACTION_CLOSE_WINDOW:
	case ACTION_CLOSE:
		if (getParentContainer() && getParentContainer()->isMainContainer())
		{
			int x = 1;
#ifdef WASABI_CHECK_CAN_EXIT
			WASABI_CHECK_CAN_EXIT(x)
#endif
			if (x)
			{
				WASABI_API_APP->main_shutdown();
			}
		}
		else if (WASABI_API_WNDMGR->getModalWnd() != this)
		{
			if (!getParentContainer() || !getParentContainer()->isDynamic() || !getParentContainer()->canClose())
					if (getParentContainer()) getParentContainer()->setVisible(FALSE); else setVisible(FALSE);
			else
				skinEmbedder->destroyContainer(getParentContainer());
		}
		else
		{
			endModal(MSGBOX_ABORTED);
		}
		break;
	default: return 0;
	}
	return 1;
}

void Layout::containerToggled(const wchar_t *id, int visible)
{
  #ifdef _WIN32
	sendNotifyToAllChildren(WM_WA_CONTAINER_TOGGLED, (intptr_t)id, visible);
#else
#warning port me
#endif
}

void Layout::componentToggled(GUID *guid, int visible)
{
#ifdef _WIN32
	sendNotifyToAllChildren(WM_WA_COMPONENT_TOGGLED, (intptr_t)guid, visible);
#else
#warning port me
#endif
}

void Layout::setAlphaBackground(const wchar_t *b)
{
	alphabackgroundstr = b;
	alphabackground.setBitmap(b);
#ifdef _WIN32
	RegionI r(alphabackground.getBitmap());
	setRegion(&r);
#else
#warning port me
#endif
}

/*void Layout::setWindowRegion(api_region *reg) {
  LAYOUT_PARENT::setWindowRegion(reg);
  if (getDesktopAlpha()) {
    SetWindowRgn(gethWnd(), NULL, FALSE);
    return;
  }
  if (!isInited()) return;
  api_region *_r = getRegion();
  if (getRenderRatio() != 1.0 && reg) {
    api_region *clone = _r->clone();
    clone->scale(getRenderRatio());
    SetWindowRgn(gethWnd(), clone->makeWindowRegion(), TRUE); 
    _r->disposeClone(clone);
  } else {
    SetWindowRgn(gethWnd(), _r ? _r->makeWindowRegion() : NULL, TRUE); 
  }
}*/

void Layout::onSetDesktopAlpha(int a)
{
	invalidateWindowRegion();
}

void Layout::onShow(void)
{
	savePosition();
	if (!WASABI_API_MAKI->vcpu_getComplete()) SystemObject::onShowLayout(this);
}

void Layout::onHide(void)
{
	savePosition();
	if (!WASABI_API_MAKI->vcpu_getComplete()) SystemObject::onHideLayout(this);
#ifndef WASABINOMAINAPI
	api->hintGarbageCollect();
#else
	WASABI_API_SYSCB->syscb_issueCallback(SysCallback::GC, GarbageCollectCallback::GARBAGECOLLECT);
#endif
	if (getParentContainer() && getParentContainer()->wantRefocusApp()) SkinParser::focusFirst();
}

#ifdef _WIN32
LPARAM Layout::wndHolder_getParentParam(int i)
{
	switch (i)
	{
	case 0: return (LPARAM)gethWnd();
	case 1: return (LPARAM)static_cast<BaseWnd*>(this);
	}
	return 0;
}
#endif

void Layout::onSetVisible( int show )
{
	disable_auto_alpha = 1;
	LAYOUT_PARENT::onSetVisible( show );

	if ( show )
		onShow();
	else
		onHide();

	Container *p = getParentContainer();

	if ( p )
		p->onChildSetLayoutVisible( this, show );

	disable_auto_alpha = 0;

	if ( wantDesktopAlpha() && isDesktopAlphaSafe() )
		desktopAlpha_autoTurnOn();
}

void Layout::scaleTo(int s)
{
	beginScale();
	setRenderRatio((double)s / 100.0);
	endScale();
}

void Layout::setRenderRatio(double s)
{
	if (isPostOnInit()
      #ifdef WASABI_COMPILE_CONFIG
      && cfg_uioptions_linkallratio.getValueAsInt() == 1 
#endif
      && !broadcasting)
	{
		broadcasting = 1;
		SkinParser::setAllLayoutsRatio(s);
		broadcasting = 0;
		return ;
	}
	if (getRenderRatio() == s) return ;
	LAYOUT_PARENT::setRenderRatio(s);
	if (reg) invalidateWindowRegion();
	invalidate();
	foreach(locked)
	locked.getfor()->setRenderRatio(s);
	endfor;
	if (lockedto && lockedto->getRenderRatio() != getRenderRatio())
		lockedto->setRenderRatio(getRenderRatio());
	script_vcpu_onScale(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_DOUBLE(s));
	if (!abortSaving()) savePosition();
}

void Layout::setAlpha(int a)
{
	int old = alpha;
	alpha = a;
	updateTransparency();
#ifdef WASABI_COMPILE_CONFIG
	if (old != alpha && getParentContainer())
	{
		StringPrintfW tmp(L"Skin:%s/Container:%s/Layout:%s/alpha", WASABI_API_SKIN->getSkinName(), getParentContainer()->getDescriptor(), getGuiObject()->guiobject_getId());
		IntArray::write(tmp, alpha);
	}
#endif
}

int Layout::getAlpha()
{
	return alpha;
}

void Layout::setPaintingAlpha(int activealpha, int inactivealpha)
{ // from basewnd, called by gui object
	LAYOUT_PARENT::setAlpha(activealpha, inactivealpha);
	updateTransparency();
}

int Layout::getPaintingAlpha()
{ // from basewnd, called by gui object
	return getAlpha();
}

int Layout::onActivate()
{
	LAYOUT_PARENT::onActivate();
	//  activateChildren(1);
	updateTransparency();
	return 1;
}

int Layout::onKillFocus()
{
	alphaMgr->hoverCheck(this);
	int r = LAYOUT_PARENT::onKillFocus();
	return r;
}

int Layout::onGetFocus()
{
	alphaMgr->hoverCheck(this);
	int r = LAYOUT_PARENT::onGetFocus();
	return r;
}

int Layout::onDeactivate()
{
	LAYOUT_PARENT::onDeactivate();
	//  activateChildren(0);
	updateTransparency();
	return 1;
}

void Layout::updateTransparency()
{
	alphaMgr->updateTransparency(this);
}

/*
void Layout::activateChildren(int act) {
  for (int i=0;i<gui_objects.getNumItems();i++) {
    GuiObject *o = gui_objects.enumItem(i);
    BaseWnd *b = NULL;
    if (o) 
      b = o->getBaseWnd();
    else
      ASSERT(0);
    if (b) {
      if (act)
        b->onActivate();
      else
        b->onDeactivate();
    }
  }
}*/

void Layout::center()
{
	RECT r;
	getNonClientRect(&r);
	RECT vw;
	Wasabi::Std::getViewport(&vw, NULL, NULL, gethWnd());
	int x = ((vw.right - vw.left) - (r.right - r.left)) / 2;
	int y = ((vw.bottom - vw.top) - (r.bottom - r.top)) / 2;
	move(x, y);
}

void Layout::setParentContainer(Container *c)
{
	p_container = c;
}

Container *Layout::getParentContainer()
{
	return p_container;
}

int Layout::isLayout()
{
	return 1;
}

void Layout::setInDesktop(int a)
{
	ASSERTPR(!isInited(), "cannot change indesktop after init");
	indesktop = a;
}

int Layout::getInDesktop()
{
	return indesktop;
}

int Layout::isDesktopAlphaSafe()
{
#ifdef WASABI_COMPILE_CONFIG
	if (galphadisabled) return 0;
	// {9149C445-3C30-4e04-8433-5A518ED0FDDE}
	const GUID uioptions_guid =
	    { 0x9149c445, 0x3c30, 0x4e04, { 0x84, 0x33, 0x5a, 0x51, 0x8e, 0xd0, 0xfd, 0xde } };
	if (!_intVal(WASABI_API_CONFIG->config_getCfgItemByGuid(uioptions_guid), L"Enable desktop alpha")) return 0;
#else
	if (!WASABI_WNDMGR_DESKTOPALPHA) return 0;
#endif
	return LAYOUT_PARENT::isDesktopAlphaSafe();
}

void Layout::setStatusText(const wchar_t *txt, int overlay)
{
	foreach(statuscbs)
	statuscbs.getfor()->onSetStatusText(txt, overlay);
	endfor;
}

void Layout::addAppCmds(AppCmds *commands)
{
	foreach(statuscbs)
	statuscbs.getfor()->onAddAppCmds(commands);
	endfor;
}

void Layout::removeAppCmds(AppCmds *commands)
{
	foreach(statuscbs)
	statuscbs.getfor()->onRemoveAppCmds(commands);
	endfor;
}

void Layout::pushCompleted(int max)
{
	foreach(statuscbs)
	statuscbs.getfor()->pushCompleted(max);
	endfor;
}
void Layout::incCompleted(int add)
{
	foreach(statuscbs)
	statuscbs.getfor()->incCompleted(add);
	endfor;
}
void Layout::setCompleted(int pos)
{
	foreach(statuscbs)
	statuscbs.getfor()->setCompleted(pos);
	endfor;
}
void Layout::popCompleted()
{
	foreach(statuscbs)
	statuscbs.getfor()->popCompleted();
	endfor;
}

void Layout::registerStatusCallback(GuiStatusCallback *lcb)
{
	statuscbs.addItem(lcb);
	viewer_addViewItem(lcb->status_getDependencyPtr());
}

int Layout::viewer_onItemDeleted(api_dependent *item)
{
	for (int i = 0;i < statuscbs.getNumItems();i++)
		if (statuscbs.enumItem(i)->status_getDependencyPtr() == item)
		{
			statuscbs.removeByPos(i--);
		}
	return 1;
}

void Layout::snapAdjust(int left, int right, int top, int bottom)
{
	snap_adjust_left = left;
	snap_adjust_top = top;
	snap_adjust_right = right;
	snap_adjust_bottom = bottom;
	script_vcpu_onSnapAdjustChanged(SCRIPT_CALL, getScriptObject());
  #ifdef USEAPPBAR
	if (appbar_isDocked()) appbar_posChanged();
#endif
	if (forceTransparencyFlag() || getAlpha() < 255) postDeferredCallback(DC_INVALIDATE);
}

void Layout::getSnapAdjust(RECT *r)
{
	if (!r) return ;
	r->left = snap_adjust_left;
	r->top = snap_adjust_top;
	r->right = snap_adjust_right;
	r->bottom = snap_adjust_bottom;
}

int Layout::abortSaving()
{
	GuiObject *o = getGuiObject();
	if (o->guiobject_movingToTarget()) return 1;
	return 0;
}

void Layout::setNoOffscreenCheck(int nocheck)
{
	killTimer(TIMER_OFFSCREENCHECK);

	if (nocheck != -1) nooffscreencheck = nocheck;

	setTimer(TIMER_OFFSCREENCHECK, 2500);
}

#ifdef USEAPPBAR

void Layout::onDock(int side)
{
	script_vcpu_onDock(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(side));
}

void Layout::onUnDock()
{
	script_vcpu_onUndock(SCRIPT_CALL, getScriptObject());
}

void Layout::appbar_onDock(int side)
{
	onDock(side);
	savePosition();
}

void Layout::appbar_onUnDock()
{
	onUnDock();
	savePosition();
}

void Layout::appbar_onSlide()
{
	savePosition();
}

int Layout::getAppBarAutoHide()
{
	return appbar_want_autohide;
}

void Layout::setAppBarAutoHide(int ah)
{
	appbar_want_autohide = ah;
	if (appbar_isDocked()) appbar_updateAutoHide();
	savePosition();
}

int Layout::getAppBarAlwaysOnTop()
{
	return appbar_want_alwaysontop;
}

void Layout::setAppBarAlwaysOnTop(int aot)
{
	appbar_want_alwaysontop = aot;
	if (appbar_isDocked()) appbar_updateAlwaysOnTop();
	savePosition();
}
#endif


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

LayoutScriptController _layoutController;
LayoutScriptController *layoutController = &_layoutController;

// -- Functions table -------------------------------------
function_descriptor_struct LayoutScriptController::exportedFunction[] = {
            {L"onDock", 1, (void*)Layout::script_vcpu_onDock },
            {L"onUndock", 0, (void*)Layout::script_vcpu_onUndock },
            {L"getScale", 0, (void*)Layout::script_vcpu_getScale },
            {L"setScale", 1, (void*)Layout::script_vcpu_setScale },
            {L"onScale", 1, (void*)Layout::script_vcpu_onScale },
            {L"setDesktopAlpha", 1, (void*)Layout::script_vcpu_setDesktopAlpha },
            {L"getDesktopAlpha", 0, (void*)Layout::script_vcpu_getDesktopAlpha },
            {L"isTransparencySafe", 0, (void*)Layout::script_vcpu_isTransparencySafe},
            {L"isLayoutAnimationSafe", 0, (void*)Layout::script_vcpu_isLayoutAnimationSafe},
            {L"getContainer", 0, (void*)Layout::script_vcpu_getContainer },
            {L"center", 0, (void*)Layout::script_vcpu_center},
            {L"onMove", 0, (void*)Layout::script_vcpu_onMove},
            {L"onEndMove", 0, (void*)Layout::script_vcpu_onEndMove},
            {L"snapAdjust", 4, (void*)Layout::script_vcpu_snapAdjust},
            {L"getSnapAdjustTop", 0, (void*)Layout::script_vcpu_getSnapAdjustTop},
            {L"getSnapAdjustLeft", 0, (void*)Layout::script_vcpu_getSnapAdjustLeft},
            {L"getSnapAdjustRight", 0, (void*)Layout::script_vcpu_getSnapAdjustRight},
            {L"getSnapAdjustBottom", 0, (void*)Layout::script_vcpu_getSnapAdjustBottom},
            {L"onUserResize", 4, (void*)Layout::script_vcpu_onUserResize},
            {L"setRedrawOnResize", 1, (void*)Layout::script_vcpu_setRedrawOnResize},
            {L"beforeRedock", 0, (void*)Layout::script_vcpu_beforeRedock},
            {L"redock", 0, (void*)Layout::script_vcpu_redock},
            {L"onMouseEnterLayout", 0, (void*)Layout::script_vcpu_onMouseEnterLayout},
            {L"onMouseLeaveLayout", 0, (void*)Layout::script_vcpu_onMouseLeaveLayout},
            {L"onSnapAdjustChanged", 0, (void*)Layout::script_vcpu_onSnapAdjustChanged},
        };
// --------------------------------------------------------


const wchar_t *LayoutScriptController::getClassName()
{
	return L"Layout";
}

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

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

ScriptObject *LayoutScriptController::instantiate()
{
	Layout *l = new Layout;
	return l->getScriptObject();
}

void LayoutScriptController::destroy(ScriptObject *o)
{
	Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid));
	if (g && GroupMgr::hasGroup(g))
	{
		GroupMgr::destroy(g);
		return ;
	}
	ASSERTALWAYS("you cannot destroy a static layout");
}

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

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

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

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

GUID LayoutScriptController::getClassGuid()
{
	return layoutGuid;
}

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

scriptVar Layout::script_vcpu_onDock(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar side)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS1(o, layoutController, side);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT1(o, side);
}

scriptVar Layout::script_vcpu_onUndock(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS0(o, layoutController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

scriptVar Layout::script_vcpu_getScale(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	double r = 0;
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l) r = l->getRenderRatio();
	return MAKE_SCRIPT_DOUBLE(r);
}

scriptVar Layout::script_vcpu_setScale(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar s)
{
	SCRIPT_FUNCTION_INIT
	double a = GET_SCRIPT_DOUBLE(s);
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l) l->setRenderRatio(a);
	RETURN_SCRIPT_VOID;
}

scriptVar Layout::script_vcpu_onScale(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar s)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS1(o, layoutController, s);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT1(o, s);
}

scriptVar Layout::script_vcpu_setDesktopAlpha(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar s)
{
	SCRIPT_FUNCTION_INIT
	bool a = GET_SCRIPT_BOOLEAN(s);
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l) l->setWantDesktopAlpha(a);
	RETURN_SCRIPT_VOID;
}

scriptVar Layout::script_vcpu_getDesktopAlpha(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l) return MAKE_SCRIPT_BOOLEAN(l->wantDesktopAlpha() && l->isDesktopAlphaSafe());
	RETURN_SCRIPT_ZERO;
}

scriptVar Layout::script_vcpu_isTransparencySafe(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l) return MAKE_SCRIPT_BOOLEAN(l->isTransparencySafe());
	RETURN_SCRIPT_ZERO;
}

scriptVar Layout::script_vcpu_isLayoutAnimationSafe(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l) return MAKE_SCRIPT_BOOLEAN(!l->forceTransparencyFlag() && (l->getAlphaMgr()->getAlpha(l) == 255));
	RETURN_SCRIPT_ZERO;
}

scriptVar Layout::script_vcpu_getContainer(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l)
	{
		Container *c = l->getParentContainer();
		return MAKE_SCRIPT_OBJECT(c ? c->getScriptObject() : NULL);
	}
	return MAKE_SCRIPT_OBJECT(NULL);
}

scriptVar Layout::script_vcpu_center(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l) l->center();
	RETURN_SCRIPT_VOID;
}

scriptVar Layout::script_vcpu_setRedrawOnResize(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar v)
{
	SCRIPT_FUNCTION_INIT
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l) l->setWantRedrawOnResize(GET_SCRIPT_INT(v));
	RETURN_SCRIPT_VOID;
}

scriptVar Layout::script_vcpu_beforeRedock(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l) windowTracker->beforeRedock(l, &l->redock);
	RETURN_SCRIPT_VOID;
}

scriptVar Layout::script_vcpu_redock(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l) windowTracker->afterRedock(l, &l->redock);
	RETURN_SCRIPT_VOID;
}

scriptVar Layout::script_vcpu_onEndMove(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS0(o, layoutController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

scriptVar Layout::script_vcpu_onMouseEnterLayout(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS0(o, layoutController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

scriptVar Layout::script_vcpu_onMouseLeaveLayout(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS0(o, layoutController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

scriptVar Layout::script_vcpu_onSnapAdjustChanged(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS0(o, layoutController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

scriptVar Layout::script_vcpu_onUserResize(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar x, scriptVar y, scriptVar w, scriptVar h)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS4(o, layoutController, x, y, w, h);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT4(o, x, y, w, h);
}

scriptVar Layout::script_vcpu_onMove(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT;
	PROCESS_HOOKS0(o, layoutController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

scriptVar Layout::script_vcpu_snapAdjust(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar left, scriptVar top, scriptVar right, scriptVar bottom)
{
	SCRIPT_FUNCTION_INIT
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l) l->snapAdjust(GET_SCRIPT_INT(left), GET_SCRIPT_INT(top), GET_SCRIPT_INT(right), GET_SCRIPT_INT(bottom));
	RETURN_SCRIPT_VOID;
}

scriptVar Layout::script_vcpu_getSnapAdjustLeft(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l)
	{
		RECT r;
		l->getSnapAdjust(&r);
		return MAKE_SCRIPT_INT(r.left);
	}
	RETURN_SCRIPT_VOID;
}

scriptVar Layout::script_vcpu_getSnapAdjustTop(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l)
	{
		RECT r;
		l->getSnapAdjust(&r);
		return MAKE_SCRIPT_INT(r.top);
	}
	RETURN_SCRIPT_VOID;
}

scriptVar Layout::script_vcpu_getSnapAdjustRight(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l)
	{
		RECT r;
		l->getSnapAdjust(&r);
		return MAKE_SCRIPT_INT(r.right);
	}
	RETURN_SCRIPT_VOID;
}

scriptVar Layout::script_vcpu_getSnapAdjustBottom(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
	if (l)
	{
		RECT r;
		l->getSnapAdjust(&r);
		return MAKE_SCRIPT_INT(r.bottom);
	}
	RETURN_SCRIPT_VOID;
}

int Layout::broadcasting = 0;

StringW Layout::MakePrefix()
{
	return StringPrintfW(L"Skin:%s/Container:%s/Layout:%s", WASABI_API_SKIN->getSkinName(), getParentContainer()->getDescriptor(), getGuiObject()->guiobject_getId());
}