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

#include <precomp.h>
#include "xuitree.h"

#include <api/service/svc_enum.h>
#include <bfc/parse/hierarchyparser.h>
#include <api/script/scriptguid.h>
#include <api/skin/feeds/TextFeedEnum.h>

// The temporary memory buffer to hold our string returns.
StringW GuiTreeScriptController::staticStr;

class ScriptTreeItem;

// -----------------------------------------------------------------------
// class TreeItemScript -- This is the tree item type inserted into
//    the tree if a script or XML piece is inserting items into the tree.
class TreeItemScript : public TreeItem
{
public:
	TreeItemScript(const wchar_t *label = NULL, ScriptTreeItem *_scriptitem = NULL) : scriptitem(_scriptitem), TreeItem(label)
	{}
	virtual ~TreeItemScript()
	{}
	virtual void onTreeAdd()
	{
		if (scriptitem) TreeItemScriptController::treeitem_onTreeAdd(SCRIPT_CALL, scriptitem->getScriptObject());
	}
	virtual void onTreeRemove()
	{
		if (scriptitem) TreeItemScriptController::treeitem_onTreeRemove(SCRIPT_CALL, scriptitem->getScriptObject());
	}
	virtual void onSelect()
	{
		if (scriptitem) TreeItemScriptController::treeitem_onSelect(SCRIPT_CALL, scriptitem->getScriptObject());
	}
	virtual void onDeselect()
	{
		if (scriptitem) TreeItemScriptController::treeitem_onDeselect(SCRIPT_CALL, scriptitem->getScriptObject());
	}
	virtual int onLeftDoubleClick()
	{
		scriptVar retval;
		if (scriptitem) 
			retval = TreeItemScriptController::treeitem_onLeftDoubleClick(SCRIPT_CALL, scriptitem->getScriptObject());
		if ((retval.type == SCRIPT_VOID)
			|| (retval.type == SCRIPT_OBJECT) 
			|| (retval.type == SCRIPT_STRING)) 
			return 0;
		return GET_SCRIPT_INT(retval);
	}
	virtual int onRightDoubleClick()
	{
		scriptVar retval;
		if (scriptitem) retval = TreeItemScriptController::treeitem_onRightDoubleClick(SCRIPT_CALL, scriptitem->getScriptObject());
		if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING)) return 0;
		return GET_SCRIPT_INT(retval);
	}
	// return 1 if you eat the key
	virtual int onChar(UINT key)
	{
		scriptVar retval;
		if (scriptitem) retval = TreeItemScriptController::treeitem_onChar(SCRIPT_CALL, scriptitem->getScriptObject(), MAKE_SCRIPT_INT(key));
		if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING)) return 0;
		return GET_SCRIPT_INT(retval);
	}
	// these are called after the expand/collapse happens
	virtual void onExpand()
	{
		if (scriptitem) TreeItemScriptController::treeitem_onExpand(SCRIPT_CALL, scriptitem->getScriptObject());
	}
	virtual void onCollapse()
	{
		if (scriptitem) TreeItemScriptController::treeitem_onCollapse(SCRIPT_CALL, scriptitem->getScriptObject());
	}
	virtual int onBeginLabelEdit()
	{
		scriptVar retval;
		if (scriptitem) retval = TreeItemScriptController::treeitem_onBeginLabelEdit(SCRIPT_CALL, scriptitem->getScriptObject());
		int retv = 0;
		if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
		{
			retv = -1;
		}
		if (!retv)
		{
			retv = GET_SCRIPT_INT(retval);
		}
		if (retv < 1)
		{
			retv = TreeItem::onBeginLabelEdit();
		}
		return retv;
	}
	virtual int onEndLabelEdit(const wchar_t *newlabel)
	{
		scriptVar retval;
		if (scriptitem) 
			retval = TreeItemScriptController::treeitem_onEndLabelEdit(SCRIPT_CALL, scriptitem->getScriptObject(), MAKE_SCRIPT_STRING(newlabel));
		int retv = 0;
		if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
		{
			retv = -1;
		}
		if (!retv)
		{
			retv = GET_SCRIPT_INT(retval);
		}
		if (retv < 1)
		{
			retv = TreeItem::onEndLabelEdit(newlabel);
		}
		return retv;
	}
	virtual int onContextMenu(int x, int y)
	{
		scriptVar retval;
		if (scriptitem) retval = TreeItemScriptController::treeitem_onContextMenu(SCRIPT_CALL, scriptitem->getScriptObject(), MAKE_SCRIPT_INT(x), MAKE_SCRIPT_INT(y) );
		int retv = 0;
		if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
		{
			retv = -1;
		}
		if (!retv)
		{
			retv = GET_SCRIPT_INT(retval);
		}
		if (retv < 1)
		{
			retv = TreeItem::onContextMenu(x, y);
		}
		return retv;
	}
protected:
	ScriptTreeItem *scriptitem;
};


// -----------------------------------------------------------------------
const wchar_t ScriptTreeXuiObjectStr[] = L"Tree"; // This is the xml tag
char ScriptTreeXuiSvcName[] = "Tree xui object";


XMLParamPair ScriptTree::params[] = {
                                        {SCRIPTTREE_CHILDTABS, L"CHILDTABS"},
                                        {SCRIPTTREE_EXPANDROOT, L"EXPANDROOT"},
                                        {SCRIPTTREE_FEED, L"FEED"},
                                        {SCRIPTTREE_SETITEMS, L"ITEMS"},
                                        {SCRIPTTREE_SORTED, L"SORTED"},
                                    };
// -----------------------------------------------------------------------
ScriptTree::ScriptTree()
{
	getScriptObject()->vcpu_setInterface(guitreeGuid, (void *)static_cast<ScriptTree *>(this));
	getScriptObject()->vcpu_setClassName(L"GuiTree"); // this is the script class name
	getScriptObject()->vcpu_setController(guiTreeController);

	myxuihandle = newXuiHandle();
	CreateXMLParameters(myxuihandle);
	
	feed = NULL;
	childtabs = 1;
	expandroot = 1;
}

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

// -----------------------------------------------------------------------
ScriptTree::~ScriptTree()
{
	closeFeed();

	// Clean up the ScriptTreeItems owned by this guy.
	TreeItem *item = enumRootItem(0);
	while (item != NULL)
	{
		// Delete this item.
		ScriptTreeItem *dead = NULL;
		//if (TISC::g_scriptitems.getItem(item, &dead) && (dead != NULL))
		//{ // true if it found something.
		//	TISC::g_scriptitems.delItem(item);
		//	delete dead;
		//	//      DebugString(" === deleting tree item (%08X, %08X, %08X)\n", item, dead, this);
		//	continue;
		//}
		auto it = TISC::g_scriptitems.find(item);
		if (TISC::g_scriptitems.end() != it)
		{
			dead = it->second;
			delete dead;
			TISC::g_scriptitems.erase(it);
			continue;
		}
		else
		{
			//      DebugString(" !!! ORPHAN TREE ITEM (%08X, %08X, %08X)\n", item, 0, this);
		}

		// Figure out who the next item to process should be.

		// 1) Children first.
		TreeItem *child = item->getChild();
		if (child != NULL)
		{
			item = child;
		}
		else
		{
			// 2) Siblings next.
			TreeItem *sibling = item->getSibling();
			if (sibling != NULL)
			{
				item = sibling;
			}
			else
			{
				// 3) Zip up parent chain last.
				TreeItem *item_parent, *parent_sibling;
				item_parent = item->getParent();
				item = NULL; // at this point if we do not assign, we are NULL.
				while (item_parent != NULL)
				{
					parent_sibling = item_parent->getSibling();
					if (parent_sibling != NULL)
					{
						item = parent_sibling;
						break;
					}
					item_parent = item_parent->getParent();
				}
				// 4) Uhhh.... you're null.  All done.  Go home.
			}
		}
	}

	/*
	 
	  // delete all of our script items from g_scriptitems
	  int i = 0;
	  TreeItem *next = enumRootItem(0);
	  while (next) { // go through all of our items
	    ScriptTreeItem *dead = NULL;
	    if (TISC::g_scriptitems.getItem(next, &dead) && (dead != NULL)) { // true if it found something.
	      TISC::g_scriptitems.delItem(next);
	      delete dead;
	//      DebugString(" === deleting tree item (%08X, %08X)\n", next, dead);
	    } else {
	//      DebugString(" !!! ORPHAN TREE ITEM (%08X, %08X)\n", next, i);
	    }
	    TreeItem *next = enumAllItems(i++);
	  }
	 
	*/ 
	// some items will wind up leaked into g_scriptitems, most likely.
}

// -----------------------------------------------------------------------
int ScriptTree::setXuiParam(int xuihandle, int xmlattributeid, const wchar_t *xmlattributename, const wchar_t *value)
{
	if (xuihandle != myxuihandle)
		return SCRIPTTREE_PARENT::setXuiParam(xuihandle, xmlattributeid, xmlattributename, value);

	switch (xmlattributeid)
	{
	case SCRIPTTREE_SETITEMS:
		items = value;
		fillFromParams();
#ifdef WASABI_COMPILE_CONFIG
		if (getGuiObject()->guiobject_hasCfgAttrib())
			selectFromConfig();
#endif
		break;
	case SCRIPTTREE_FEED:
		{
			closeFeed();
			openFeed(value);
			break;
		}
	case SCRIPTTREE_SORTED:
		{
			setSorted(WTOB(value));
			break;
		}
	case SCRIPTTREE_CHILDTABS:
		{
			childtabs = WTOI(value);
			break;
		}
	case SCRIPTTREE_EXPANDROOT:
		{
			expandRoot(WTOI(value));
			break;
		}
	default:
		return 0;
	}
	return 1;
}

// -----------------------------------------------------------------------
int ScriptTree::onInit()
{
	SCRIPTTREE_PARENT::onInit();

	fillFromParams();
	return 1;
}

// -----------------------------------------------------------------------
int ScriptTree::onAction(const wchar_t *action, const wchar_t *param, int x, int y, intptr_t p1, intptr_t p2, void *data, size_t datalen, ifc_window *source)
{
	SCRIPTTREE_PARENT::onAction(action, param, x, y, p1, p2, data, datalen, source);
	if (!WCSICMP(action, L"get_selection"))
	{
		if (source != NULL)
		{
			StringW res(L"");

			// Hmmmmm..... multiselection trees?

			sendAction(source, L"set_selection", res);
		}
	}
	return 1;
}

// -----------------------------------------------------------------------
ScriptTreeItem *ScriptTree::bindScriptTreeItem(TreeItem *item)
{
	ASSERT(item != NULL);
	// find this tree item in our map of tree items.
	ScriptTreeItem *si = NULL;
	//TISC::g_scriptitems.getItem(item, &si);
	auto it = TISC::g_scriptitems.find(item);
	if (TISC::g_scriptitems.end() == it)
	{
		// if there was no scriptobject in our map already, make one
		// for this tree item and place it in our map.
		si = new ScriptTreeItem(item, this);
		TISC::g_scriptitems.insert({ item, si });
	}
	else
	{
		si = it->second;
	}
	return si;
}

// -----------------------------------------------------------------------
int ScriptTree::destroyScriptTreeItem(ScriptTreeItem *item)
{
	ASSERT(item != NULL);
	// find this tree item in our map of tree items.
	TreeItem *ti = item->getItem();
	if (ti)
	{
		ScriptTreeItem *check = NULL;
		//TISC::g_scriptitems.getItem(ti, &check);  // this is a doublecheck on who owns who.
		auto it = TISC::g_scriptitems.find(ti);
		
		if (TISC::g_scriptitems.end() != it)
		{
			// remove the treeitem from the tree
			this->removeTreeItem(ti); // (removes without deleting)
			// remove the scripttreeitem from the map
			TISC::g_scriptitems.erase(it);
			// and delete.(phew!  bomb disposal!)
			delete ti;
			delete item;
			return 1; // yes, we deleted it.
		}
	}
	return 0; // Not ours, don't wanna delete it.  Someone else can Deal With It.
}

// -----------------------------------------------------------------------
void ScriptTree::onSetVisible(int i)
{
	SCRIPTTREE_PARENT::onSetVisible(i);
}

#ifdef WASABI_COMPILE_CONFIG 
// -----------------------------------------------------------------------
int ScriptTree::onReloadConfig()
{
	SCRIPTTREE_PARENT::onReloadConfig();
	selectFromConfig();
	return 1;
}

// -----------------------------------------------------------------------
void ScriptTree::saveToConfig()
{}

// -----------------------------------------------------------------------
void ScriptTree::selectFromConfig()
{}
#endif

// -----------------------------------------------------------------------
int ScriptTree::selectEntry(const wchar_t *e, int cb)
{
	return -1;
}

// -----------------------------------------------------------------------
void ScriptTree::expandRoot(int val)
{
	if (val)
	{
		expandroot = 1;
		int count;
		TreeItem *rootitem;
		for (count = 0, rootitem = enumRootItem(count); rootitem; rootitem = enumRootItem(++count))
		{
			rootitem->expand();
		}
	}
	else
	{
		expandroot = 0;
	}
}

// -----------------------------------------------------------------------
void ScriptTree::fillFromHPNode(HPNode *node, TreeItem *parent)
{
	// Go through the given node's children and add items for them
	// to the corresponding parent item.
	int i, n = node->getNumChildren();
	for (i = 0; i < n; i++)
	{
		// Here's a child node
		HPNode *child_node = static_cast<HPNode *>(node->enumChild(i));
		// Make a script-aware tree item and script item to correspond to it, labelled with the child_node's name
		ScriptTreeItem *si = new ScriptTreeItem;
		TreeItem *child_item = new TreeItemScript((*child_node)(), si);
		si->setItem(child_item);
		si->setScriptTree(this);
		// Add the script and tree items to the scriptitems map
		TISC::g_scriptitems.insert({ child_item, si });
		//    DebugString(StringPrintf(" === NEW NODE ITEM (%08X, %08X, %08X)\n", child_item, si, this);
		// Add the child item to either ourselves or the given parent.
		addTreeItem(child_item, parent, getSorted(), childtabs);
		// And then continue to fill from that node.
		fillFromHPNode(child_node, child_item);
	}
}

// -----------------------------------------------------------------------
void ScriptTree::fillFromParams()
{
	deleteAllItems();
	if (!items.isempty())
	{
		HierarchyParser hierarchy(items);
		fillFromHPNode(hierarchy.rootNode());
	}
	// If we want our roots opened, do so now.
	expandRoot(expandroot);
}

// -----------------------------------------------------------------------
void ScriptTree::selectEntries(const wchar_t *entries, int cb)
{}

// -----------------------------------------------------------------------
void ScriptTree::openFeed(const wchar_t *feedid)
{
	if (!_wcsicmp(feedid, last_feed)) return ;
	feed = TextFeedEnum(feedid).getFirst();
	if (feed != NULL)
	{
		viewer_addViewItem(feed->getDependencyPtr());
		setXuiParam(myxuihandle, SCRIPTTREE_SETITEMS, L"items", feed->getFeedText(feedid));
	}
	last_feed = feedid;
}

// -----------------------------------------------------------------------
void ScriptTree::closeFeed()
{
	if (feed)
	{
		viewer_delViewItem(feed->getDependencyPtr());
		SvcEnum::release(feed);
	}
	feed = NULL;
	last_feed = L"";
}

// -----------------------------------------------------------------------
int ScriptTree::viewer_onEvent(api_dependent *item, const GUID *classguid, int event, intptr_t param, void *ptr, size_t ptrlen)
{
	if (feed == dynamic_guid_cast<svc_textFeed>(item, classguid))
	{
		if (event == svc_textFeed::Event_TEXTCHANGE)
		{
			setXuiParam(myxuihandle, SCRIPTTREE_SETITEMS, L"items", (const wchar_t *)ptr);
			return 1;
		}
	}
	return 0;
}

// -----------------------------------------------------------------------
// Callback methods that send hooks into the Script system

int ScriptTree::onLeftButtonDown(int x, int y)
{
	scriptVar retval;
	retval = GuiTreeScriptController::guitree_onLeftButtonDown(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(x), MAKE_SCRIPT_INT(y) );
	int retv = 0;
	if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
	{
		retv = -1;
	}
	if (!retv)
	{
		retv = GET_SCRIPT_INT(retval);
	}
	if (retv < 1)
	{
		retv = SCRIPTTREE_PARENT::onLeftButtonDown(x, y);
	}
	return retv;
}

int ScriptTree::onLeftButtonUp(int x, int y)
{
	scriptVar retval;
	retval = GuiTreeScriptController::guitree_onLeftButtonUp(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(x), MAKE_SCRIPT_INT(y) );
	int retv = 0;
	if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
	{
		retv = -1;
	}
	if (!retv)
	{
		retv = GET_SCRIPT_INT(retval);
	}
	if (retv < 1)
	{
		retv = SCRIPTTREE_PARENT::onLeftButtonUp(x, y);
	}
	return retv;
}

int ScriptTree::onRightButtonUp(int x, int y)
{
	scriptVar retval;
	retval = GuiTreeScriptController::guitree_onRightButtonUp(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(x), MAKE_SCRIPT_INT(y) );
	int retv = 0;
	if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
	{
		retv = -1;
	}
	if (!retv)
	{
		retv = GET_SCRIPT_INT(retval);
	}
	if (retv < 1)
	{
		retv = SCRIPTTREE_PARENT::onRightButtonUp(x, y);
	}
	return retv;
}

int ScriptTree::onMouseMove(int x, int y)
{
	scriptVar retval;
	retval = GuiTreeScriptController::guitree_onMouseMove(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(x), MAKE_SCRIPT_INT(y) );
	int retv = 0;
	if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
	{
		retv = -1;
	}
	if (!retv)
	{
		retv = GET_SCRIPT_INT(retval);
	}
	if (retv < 1)
	{
		retv = SCRIPTTREE_PARENT::onMouseMove(x, y);
	}
	return retv;
}

int ScriptTree::wantAutoContextMenu()
{
	scriptVar retval;
	retval = GuiTreeScriptController::guitree_wantAutoContextMenu(SCRIPT_CALL, getScriptObject() );
	int retv = 0;
	if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
	{
		retv = -1;
	}
	if (!retv)
	{
		retv = GET_SCRIPT_INT(retval);
	}
	if (retv < 1)
	{
		retv = SCRIPTTREE_PARENT::wantAutoContextMenu();
	}
	return retv;
}

int ScriptTree::onLeftButtonDblClk(int x, int y)
{
	scriptVar retval;
	retval = GuiTreeScriptController::guitree_onLeftButtonDblClk(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(x), MAKE_SCRIPT_INT(y) );
	int retv = 0;
	if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
	{
		retv = -1;
	}
	if (!retv)
	{
		retv = GET_SCRIPT_INT(retval);
	}
	if (retv < 1)
	{
		retv = SCRIPTTREE_PARENT::onLeftButtonDblClk(x, y);
	}
	return retv;
}

int ScriptTree::onRightButtonDblClk(int x, int y)
{
	scriptVar retval;
	retval = GuiTreeScriptController::guitree_onRightButtonDblClk(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(x), MAKE_SCRIPT_INT(y) );
	int retv = 0;
	if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
	{
		retv = -1;
	}
	if (!retv)
	{
		retv = GET_SCRIPT_INT(retval);
	}
	if (retv < 1)
	{
		retv = SCRIPTTREE_PARENT::onRightButtonDblClk(x, y);
	}
	return retv;
}

int ScriptTree::onMouseWheelUp(int clicked, int lines)
{
	scriptVar retval;
	retval = GuiTreeScriptController::guitree_onMouseWheelUp(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(clicked), MAKE_SCRIPT_INT(lines) );
	int retv = 0;
	if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
	{
		retv = -1;
	}
	if (!retv)
	{
		retv = GET_SCRIPT_INT(retval);
	}
	if (retv < 1)
	{
		retv = SCRIPTTREE_PARENT::onMouseWheelUp(clicked, lines);
	}
	return retv;
}

int ScriptTree::onMouseWheelDown(int clicked, int lines)
{
	scriptVar retval;
	retval = GuiTreeScriptController::guitree_onMouseWheelDown(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(clicked), MAKE_SCRIPT_INT(lines) );
	int retv = 0;
	if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
	{
		retv = -1;
	}
	if (!retv)
	{
		retv = GET_SCRIPT_INT(retval);
	}
	if (retv < 1)
	{
		retv = SCRIPTTREE_PARENT::onMouseWheelDown(clicked, lines);
	}
	return retv;
}

int ScriptTree::onContextMenu(int x, int y)
{
	scriptVar retval;
	retval = GuiTreeScriptController::guitree_onContextMenu(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(x), MAKE_SCRIPT_INT(y) );
	int retv = 0;
	if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
	{
		retv = -1;
	}
	if (!retv)
	{
		retv = GET_SCRIPT_INT(retval);
	}
	if (retv < 1)
	{
		retv = SCRIPTTREE_PARENT::onContextMenu(x, y);
	}
	return retv;
}

int ScriptTree::onChar(wchar_t c)
{
	scriptVar retval;
	retval = GuiTreeScriptController::guitree_onChar(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(c));
	int retv = 0;
	if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
	{
		retv = -1;
	}
	if (!retv)
	{
		retv = GET_SCRIPT_INT(retval);
	}
	if (retv < 1)
	{
		retv = SCRIPTTREE_PARENT::onChar(c);
	}
	return retv;
}

int ScriptTree::onKeyDown(int keycode)
{
	scriptVar retval;
	retval = GuiTreeScriptController::guitree_onKeyDown(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(keycode) );
	int retv = 0;
	if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
	{
		retv = -1;
	}
	if (!retv)
	{
		retv = GET_SCRIPT_INT(retval);
	}
	if (retv < 1)
	{
		retv = SCRIPTTREE_PARENT::onKeyDown(keycode);
	}
	return retv;
}

void ScriptTree::onItemRecvDrop(TreeItem *item)
{
	ScriptTreeItem *sti_item = bindScriptTreeItem(item);
	GuiTreeScriptController::guitree_onItemRecvDrop(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_OBJECT(sti_item->getScriptObject()) );
}

void ScriptTree::onLabelChange(TreeItem *item)
{
	ScriptTreeItem *sti_item = bindScriptTreeItem(item);
	GuiTreeScriptController::guitree_onLabelChange(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_OBJECT(sti_item->getScriptObject()) );
}

void ScriptTree::onItemSelected(TreeItem *item)
{
	ScriptTreeItem *sti_item = bindScriptTreeItem(item);
	GuiTreeScriptController::guitree_onItemSelected(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_OBJECT(sti_item->getScriptObject()) );
}

void ScriptTree::onItemDeselected(TreeItem *item)
{
	ScriptTreeItem *sti_item = bindScriptTreeItem(item);
	GuiTreeScriptController::guitree_onItemDeselected(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_OBJECT(sti_item->getScriptObject()) );
}

int ScriptTree::onKillFocus()
{
	scriptVar retval;
	retval = GuiTreeScriptController::guitree_onKillFocus(SCRIPT_CALL, getScriptObject() );
	int retv = 0;
	if ((retval.type == SCRIPT_VOID) || (retval.type == SCRIPT_OBJECT) || (retval.type == SCRIPT_STRING))
	{
		retv = -1;
	}
	if (!retv)
	{
		retv = GET_SCRIPT_INT(retval);
	}
	if (retv < 1)
	{
		retv = SCRIPTTREE_PARENT::onKillFocus();
	}
	return retv;
}





// -----------------------------------------------------------------------
// Script Object

GuiTreeScriptController _guiTreeController;
GuiTreeScriptController *guiTreeController = &_guiTreeController;

// -- Functions table -------------------------------------
function_descriptor_struct GuiTreeScriptController::exportedFunction[] = {
            {L"getNumRootItems", 0, (void*)GuiTreeScriptController::guitree_getNumRootItems },
            {L"enumRootItem", 1, (void*)GuiTreeScriptController::guitree_enumRootItem },

            {L"onLeftButtonDown", 2, (void*)GuiTreeScriptController::guitree_onLeftButtonDown },  // , /*Int*/ scriptVar x, /*Int*/ scriptVar y);
            {L"onLeftButtonUp", 2, (void*)GuiTreeScriptController::guitree_onLeftButtonUp },  // , /*Int*/ scriptVar x, /*Int*/ scriptVar y);
            {L"onRightButtonUp", 2, (void*)GuiTreeScriptController::guitree_onRightButtonUp },  // , /*Int*/ scriptVar x, /*Int*/ scriptVar y);
            {L"onMouseMove", 2, (void*)GuiTreeScriptController::guitree_onMouseMove },  // , /*Int*/ scriptVar x, /*Int*/ scriptVar y);
            {L"onWantAutoContextMenu", 0, (void*)GuiTreeScriptController::guitree_wantAutoContextMenu },  // );
            {L"onLeftButtonDblClk", 2, (void*)GuiTreeScriptController::guitree_onLeftButtonDblClk },  // , /*Int*/ scriptVar x, /*Int*/ scriptVar y);
            {L"onRightButtonDblClk", 2, (void*)GuiTreeScriptController::guitree_onRightButtonDblClk },  // , /*Int*/ scriptVar x, /*Int*/ scriptVar y);
            {L"onMouseWheelUp", 2, (void*)GuiTreeScriptController::guitree_onMouseWheelUp },  // , /*Int*/ scriptVar clicked, /*Int*/ scriptVar lines);
            {L"onMouseWheelDown", 2, (void*)GuiTreeScriptController::guitree_onMouseWheelDown },  // , /*Int*/ scriptVar clicked, /*Int*/ scriptVar lines);
            {L"onContextMenu", 2, (void*)GuiTreeScriptController::guitree_onContextMenu },  // , /*Int*/ scriptVar x, /*Int*/ scriptVar y);
            {L"onChar", 1, (void*)GuiTreeScriptController::guitree_onChar },  // , /*Int*/ scriptVar c);
            {L"onKeyDown", 1, (void*)GuiTreeScriptController::guitree_onKeyDown },  // , /*Int*/ scriptVar keycode);
            {L"onItemRecvDrop", 1, (void*)GuiTreeScriptController::guitree_onItemRecvDrop },  // , /*TreeItem*/ scriptVar item);
            {L"onLabelChange", 1, (void*)GuiTreeScriptController::guitree_onLabelChange },  // , /*TreeItem*/ scriptVar item);
            {L"onItemSelected", 1, (void*)GuiTreeScriptController::guitree_onItemSelected },  // , /*TreeItem*/ scriptVar item);
            {L"onItemDeselected", 1, (void*)GuiTreeScriptController::guitree_onItemDeselected },  // , /*TreeItem*/ scriptVar item);
            {L"onKillFocus", 0, (void*)GuiTreeScriptController::guitree_onKillFocus },  // );
            {L"jumpToNext", 1, (void*)GuiTreeScriptController::guitree_jumpToNext },  // , /*Int*/ scriptVar c);
            {L"ensureItemVisible", 1, (void*)GuiTreeScriptController::guitree_ensureItemVisible },  // , /*TreeItem*/ scriptVar item);
            {L"getContentsWidth", 0, (void*)GuiTreeScriptController::guitree_getContentsWidth },  // );
            {L"getContentsHeight", 0, (void*)GuiTreeScriptController::guitree_getContentsHeight },  // );
            {L"addTreeItem", 4, (void*)GuiTreeScriptController::guitree_addTreeItem },  // , /*TreeItem*/ scriptVar item, /*TreeItem*/ scriptVar par, /*Int*/ scriptVar sorted, /*Int*/ scriptVar haschildtab);
            {L"removeTreeItem", 1, (void*)GuiTreeScriptController::guitree_removeTreeItem },  // , /*TreeItem*/ scriptVar item);
            {L"moveTreeItem", 2, (void*)GuiTreeScriptController::guitree_moveTreeItem },  // , /*TreeItem*/ scriptVar item, /*TreeItem*/ scriptVar newparent);
            {L"deleteAllItems", 0, (void*)GuiTreeScriptController::guitree_deleteAllItems },  // );
            {L"expandItem", 1, (void*)GuiTreeScriptController::guitree_expandItem },  // , /*TreeItem*/ scriptVar item);
            {L"expandItemDeferred", 1, (void*)GuiTreeScriptController::guitree_expandItemDeferred },  // , /*TreeItem*/ scriptVar item);
            {L"collapseItem", 1, (void*)GuiTreeScriptController::guitree_collapseItem },  // , /*TreeItem*/ scriptVar item);
            {L"collapseItemDeferred", 1, (void*)GuiTreeScriptController::guitree_collapseItemDeferred },  // , /*TreeItem*/ scriptVar item);
            {L"selectItem", 1, (void*)GuiTreeScriptController::guitree_selectItem },  // , /*TreeItem*/ scriptVar item);
            {L"selectItemDeferred", 1, (void*)GuiTreeScriptController::guitree_selectItemDeferred },  // , /*TreeItem*/ scriptVar item);
            {L"delItemDeferred", 1, (void*)GuiTreeScriptController::guitree_delItemDeferred },  // , /*TreeItem*/ scriptVar item);
            {L"hiliteItem", 1, (void*)GuiTreeScriptController::guitree_hiliteItem },  // , /*TreeItem*/ scriptVar item);
            {L"unhiliteItem", 1, (void*)GuiTreeScriptController::guitree_unhiliteItem },  // , /*TreeItem*/ scriptVar item);
            {L"getCurItem", 0, (void*)GuiTreeScriptController::guitree_getCurItem },  // );
            {L"hitTest", 2, (void*)GuiTreeScriptController::guitree_hitTest },  // , /*Int*/ scriptVar x, /*Int*/ scriptVar y);
            {L"editItemLabel", 1, (void*)GuiTreeScriptController::guitree_editItemLabel },  // , /*TreeItem*/ scriptVar item);
            {L"cancelEditLabel", 1, (void*)GuiTreeScriptController::guitree_cancelEditLabel },  // , /*Int*/ scriptVar destroyit);
            {L"setAutoEdit", 1, (void*)GuiTreeScriptController::guitree_setAutoEdit },  // , /*Int*/ scriptVar ae);
            {L"getAutoEdit", 0, (void*)GuiTreeScriptController::guitree_getAutoEdit },  // );
            {L"getByLabel", 2, (void*)GuiTreeScriptController::guitree_getByLabel },  // , /*TreeItem*/ scriptVar item, /*String*/ scriptVar  name);
            {L"setSorted", 1, (void*)GuiTreeScriptController::guitree_setSorted },  // , /*Int*/ scriptVar dosort);
            {L"getSorted", 0, (void*)GuiTreeScriptController::guitree_getSorted },  // );
            {L"sortTreeItems", 0, (void*)GuiTreeScriptController::guitree_sortTreeItems },  // );
            {L"getSibling", 1, (void*)GuiTreeScriptController::guitree_getSibling },  // , /*TreeItem*/ scriptVar item);
            {L"setAutoCollapse", 1, (void*)GuiTreeScriptController::guitree_setAutoCollapse },  // , /*Int*/ scriptVar doautocollapse);
            {L"setFontSize", 1, (void*)GuiTreeScriptController::guitree_setFontSize },  // , /*Int*/ scriptVar newsize);
            {L"getFontSize", 0, (void*)GuiTreeScriptController::guitree_getFontSize },  // );
            {L"getNumVisibleChildItems", 1, (void*)GuiTreeScriptController::guitree_getNumVisibleChildItems },  // , /*TreeItem*/ scriptVar c);
            {L"getNumVisibleItems", 0, (void*)GuiTreeScriptController::guitree_getNumVisibleItems },  // );
            {L"enumVisibleItems", 1, (void*)GuiTreeScriptController::guitree_enumVisibleItems },  // , /*Int*/ scriptVar n);
            {L"enumVisibleChildItems", 2, (void*)GuiTreeScriptController::guitree_enumVisibleChildItems },  // , /*TreeItem*/ scriptVar c, /*Int*/ scriptVar n);
            {L"enumAllItems", 1, (void*)GuiTreeScriptController::guitree_enumAllItems },  // , /*Int*/ scriptVar n);
            {L"getItemRectX", 1, (void*)GuiTreeScriptController::guitree_getItemRectX },  // , /*TreeItem*/ scriptVar item);
            {L"getItemRectY", 1, (void*)GuiTreeScriptController::guitree_getItemRectY },  // , /*TreeItem*/ scriptVar item);
            {L"getItemRectW", 1, (void*)GuiTreeScriptController::guitree_getItemRectW },  // , /*TreeItem*/ scriptVar item);
            {L"getItemRectH", 1, (void*)GuiTreeScriptController::guitree_getItemRectH },  // , /*TreeItem*/ scriptVar item);
            //  {L"getItemFromPoint",       2, (void*)GuiTreeScriptController::guitree_getItemFromPoint }, // , /*Int*/ scriptVar x, /*Int*/ scriptVar y);

        };

ScriptObject *GuiTreeScriptController::instantiate()
{
	ScriptTree *sp = new ScriptTree;
	ASSERT(sp != NULL);
	return sp->getScriptObject();
}

void GuiTreeScriptController::destroy(ScriptObject *o)
{
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	ASSERT(sp != NULL);
	delete sp;
}

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

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

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

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

/*int*/ scriptVar GuiTreeScriptController::guitree_getNumRootItems(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree*>(o->vcpu_getInterface(guitreeGuid));
	int a = 0;
	if (sp != NULL)
	{
		a = sp->getNumRootItems();
	}
	return MAKE_SCRIPT_INT(a);
}

/*TreeItem*/ scriptVar GuiTreeScriptController::guitree_enumRootItem(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*int*/ scriptVar which)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree*>(o->vcpu_getInterface(guitreeGuid));
	scriptVar retval = MAKE_SCRIPT_OBJECT(NULL);
	if (sp != NULL)
	{
		TreeItem *a = NULL;
		int _which = GET_SCRIPT_INT(which);
		a = sp->enumRootItem(_which);
		if (a != NULL)
		{
			ScriptTreeItem *item = sp->bindScriptTreeItem(a);
			if (item != NULL)
			{
				retval = MAKE_SCRIPT_OBJECT(item->getScriptObject());
			}
		}
	}
	return retval;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_onLeftButtonDown(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*Int*/ scriptVar x,  /*Int*/ scriptVar y)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS2(o, guiTreeController, x, y);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT2(o, x, y);
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_onLeftButtonUp(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*Int*/ scriptVar x,  /*Int*/ scriptVar y)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS2(o, guiTreeController, x, y);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT2(o, x, y);
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_onRightButtonUp(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*Int*/ scriptVar x,  /*Int*/ scriptVar y)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS2(o, guiTreeController, x, y);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT2(o, x, y);
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_onMouseMove(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*Int*/ scriptVar x,  /*Int*/ scriptVar y)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS2(o, guiTreeController, x, y);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT2(o, x, y);
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_wantAutoContextMenu(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS0(o, guiTreeController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_onLeftButtonDblClk(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*Int*/ scriptVar x,  /*Int*/ scriptVar y)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS2(o, guiTreeController, x, y);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT2(o, x, y);
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_onRightButtonDblClk(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*Int*/ scriptVar x,  /*Int*/ scriptVar y)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS2(o, guiTreeController, x, y);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT2(o, x, y);
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_onMouseWheelUp(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*Int*/ scriptVar clicked,  /*Int*/ scriptVar lines)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS2(o, guiTreeController, clicked, lines);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT2(o, clicked, lines);
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_onMouseWheelDown(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*Int*/ scriptVar clicked,  /*Int*/ scriptVar lines)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS2(o, guiTreeController, clicked, lines);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT2(o, clicked, lines);
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_onContextMenu(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*Int*/ scriptVar x,  /*Int*/ scriptVar y)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS2(o, guiTreeController, x, y);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT2(o, x, y);
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_onChar(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*Int*/ scriptVar c)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS1(o, guiTreeController, c);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT1(o, c);
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_onKeyDown(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*Int*/ scriptVar keycode)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS1(o, guiTreeController, keycode);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT1(o, keycode);
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_onItemRecvDrop(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*TreeItem*/ scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS1(o, guiTreeController, item);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT1(o, item);
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_onLabelChange(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*TreeItem*/ scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS1(o, guiTreeController, item);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT1(o, item);
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_onItemSelected(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*TreeItem*/ scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS1(o, guiTreeController, item);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT1(o, item);
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_onItemDeselected(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*TreeItem*/ scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS1(o, guiTreeController, item);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT1(o, item);
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_onKillFocus(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS0(o, guiTreeController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

// -------------------------------------------------------------------------
/*Void*/ scriptVar GuiTreeScriptController::guitree_jumpToNext(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar c)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	int _c = GET_SCRIPT_INT(c);
	if (sp != NULL)
	{
		sp->jumpToNext(_c);
	}
	RETURN_SCRIPT_VOID;
}


/*Void*/ scriptVar GuiTreeScriptController::guitree_ensureItemVisible(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	if (sp != NULL)
	{
		sp->ensureItemVisible(_item);
	}
	RETURN_SCRIPT_VOID;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_getContentsWidth(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	scriptVar retval = MAKE_SCRIPT_INT(0);
	if (sp != NULL)
	{
		int a = 0;
		a = sp->getContentsWidth();
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_getContentsHeight(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	scriptVar retval = MAKE_SCRIPT_INT(0);
	if (sp != NULL)
	{
		int a = 0;
		a = sp->getContentsHeight();
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

/*TreeItem*/ scriptVar GuiTreeScriptController::guitree_addTreeItem(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item,  scriptVar par,  scriptVar sorted,  scriptVar haschildtab)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_par = NULL;
	ScriptObject *so_par = GET_SCRIPT_OBJECT(par);
	if (so_par)
	{
		ScriptTreeItem *sti_par = static_cast<ScriptTreeItem *>(so_par->vcpu_getInterface(treeitemGuid));
		if (sti_par)
		{
			_par = sti_par->getItem();
		}
	}
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	int _haschildtab = GET_SCRIPT_INT(haschildtab);
	int _sorted = GET_SCRIPT_INT(sorted);
	scriptVar retval = MAKE_SCRIPT_OBJECT(NULL);
	if (sp != NULL)
	{
		TreeItem *a = NULL;
		a = sp->addTreeItem(_item, _par, _sorted, _haschildtab);
		if (a != NULL)
		{
			ScriptTreeItem *item = sp->bindScriptTreeItem(a);
			if (item != NULL)
			{
				retval = MAKE_SCRIPT_OBJECT(item->getScriptObject());
			}
		}
	}
	return retval;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_removeTreeItem(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	scriptVar retval = MAKE_SCRIPT_INT(0);
	if (sp != NULL)
	{
		int a = 0;
		a = sp->removeTreeItem(_item);
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_moveTreeItem(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item,  scriptVar newparent)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_newparent = NULL;
	ScriptObject *so_newparent = GET_SCRIPT_OBJECT(newparent);
	if (so_newparent)
	{
		ScriptTreeItem *sti_newparent = static_cast<ScriptTreeItem *>(so_newparent->vcpu_getInterface(treeitemGuid));
		if (sti_newparent)
		{
			_newparent = sti_newparent->getItem();
		}
	}
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	if (sp != NULL)
	{
		sp->moveTreeItem(_item, _newparent);
	}
	RETURN_SCRIPT_VOID;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_deleteAllItems(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	if (sp != NULL)
	{
		sp->deleteAllItems();
	}
	RETURN_SCRIPT_VOID;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_expandItem(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	scriptVar retval = MAKE_SCRIPT_INT(0);
	if (sp != NULL)
	{
		int a = 0;
		a = sp->expandItem(_item);
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_expandItemDeferred(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	if (sp != NULL)
	{
		sp->expandItemDeferred(_item);
	}
	RETURN_SCRIPT_VOID;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_collapseItem(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	scriptVar retval = MAKE_SCRIPT_INT(0);
	if (sp != NULL)
	{
		int a = 0;
		a = sp->collapseItem(_item);
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_collapseItemDeferred(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	if (sp != NULL)
	{
		sp->collapseItemDeferred(_item);
	}
	RETURN_SCRIPT_VOID;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_selectItem(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	if (sp != NULL)
	{
		sp->selectItem(_item);
	}
	RETURN_SCRIPT_VOID;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_selectItemDeferred(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	if (sp != NULL)
	{
		sp->selectItemDeferred(_item);
	}
	RETURN_SCRIPT_VOID;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_delItemDeferred(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	if (sp != NULL)
	{
		sp->delItemDeferred(_item);
	}
	RETURN_SCRIPT_VOID;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_hiliteItem(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	if (sp != NULL)
	{
		sp->hiliteItem(_item);
	}
	RETURN_SCRIPT_VOID;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_unhiliteItem(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	if (sp != NULL)
	{
		sp->unhiliteItem(_item);
	}
	RETURN_SCRIPT_VOID;
}

/*TreeItem*/ scriptVar GuiTreeScriptController::guitree_getCurItem(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	scriptVar retval = MAKE_SCRIPT_OBJECT(NULL);
	if (sp != NULL)
	{
		TreeItem *a = NULL;
		a = sp->getCurItem();
		if (a != NULL)
		{
			ScriptTreeItem *item = sp->bindScriptTreeItem(a);
			if (item != NULL)
			{
				retval = MAKE_SCRIPT_OBJECT(item->getScriptObject());
			}
		}
	}
	return retval;
}

/*TreeItem*/ scriptVar GuiTreeScriptController::guitree_hitTest(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar x,  scriptVar y)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	int _y = GET_SCRIPT_INT(y);
	int _x = GET_SCRIPT_INT(x);
	scriptVar retval = MAKE_SCRIPT_OBJECT(NULL);
	if (sp != NULL)
	{
		TreeItem *a = NULL;
		a = sp->hitTest(_x, _y);
		if (a != NULL)
		{
			ScriptTreeItem *item = sp->bindScriptTreeItem(a);
			if (item != NULL)
			{
				retval = MAKE_SCRIPT_OBJECT(item->getScriptObject());
			}
		}
	}
	return retval;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_editItemLabel(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	if (sp != NULL)
	{
		sp->editItemLabel(_item);
	}
	RETURN_SCRIPT_VOID;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_cancelEditLabel(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar destroyit)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	int _destroyit = GET_SCRIPT_INT(destroyit);
	if (sp != NULL)
	{
		sp->cancelEditLabel(_destroyit);
	}
	RETURN_SCRIPT_VOID;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_setAutoEdit(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar ae)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	int _ae = GET_SCRIPT_INT(ae);
	if (sp != NULL)
	{
		sp->setAutoEdit(_ae);
	}
	RETURN_SCRIPT_VOID;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_getAutoEdit(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	scriptVar retval = MAKE_SCRIPT_INT(0);
	if (sp != NULL)
	{
		int a = 0;
		a = sp->getAutoEdit();
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

/*TreeItem*/ scriptVar GuiTreeScriptController::guitree_getByLabel(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item,  /*String*/ scriptVar name)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	StringW _name = GET_SCRIPT_STRING(name);
	scriptVar retval = MAKE_SCRIPT_OBJECT(NULL);
	if (sp != NULL)
	{
		TreeItem *a = NULL;
		a = sp->getByLabel(_item, _name);
		if (a != NULL)
		{
			ScriptTreeItem *item = sp->bindScriptTreeItem(a);
			if (item != NULL)
			{
				retval = MAKE_SCRIPT_OBJECT(item->getScriptObject());
			}
		}
	}
	return retval;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_setSorted(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar dosort)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	int _dosort = GET_SCRIPT_INT(dosort);
	if (sp != NULL)
	{
		sp->setSorted(!!_dosort);
	}
	RETURN_SCRIPT_VOID;
}

/*Int*/ scriptVar  GuiTreeScriptController::guitree_getSorted(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	scriptVar retval = MAKE_SCRIPT_OBJECT(NULL);
	if (sp != NULL)
	{
		int a = NULL;
		a = sp->getSorted();
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_sortTreeItems(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	if (sp != NULL)
	{
		sp->sortTreeItems();
	}
	RETURN_SCRIPT_VOID;
}

/*TreeItem*/ scriptVar GuiTreeScriptController::guitree_getSibling(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	scriptVar retval = MAKE_SCRIPT_OBJECT(NULL);
	if (sp != NULL)
	{
		TreeItem *a = NULL;
		a = sp->getSibling(_item);
		if (a != NULL)
		{
			ScriptTreeItem *item = sp->bindScriptTreeItem(a);
			if (item != NULL)
			{
				retval = MAKE_SCRIPT_OBJECT(item->getScriptObject());
			}
		}
	}
	return retval;
}

/*Void*/ scriptVar GuiTreeScriptController::guitree_setAutoCollapse(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar doautocollapse)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	int _doautocollapse = GET_SCRIPT_INT(doautocollapse);
	if (sp != NULL)
	{
		sp->setAutoCollapse(!!_doautocollapse);
	}
	RETURN_SCRIPT_VOID;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_setFontSize(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar newsize)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	int _newsize = GET_SCRIPT_INT(newsize);
	scriptVar retval = MAKE_SCRIPT_INT(0);
	if (sp != NULL)
	{
		int a = 0;
		a = sp->setFontSize(_newsize);
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_getFontSize(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	scriptVar retval = MAKE_SCRIPT_INT(0);
	if (sp != NULL)
	{
		int a = 0;
		a = sp->getFontSize();
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_getNumVisibleChildItems(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar c)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_c = NULL;
	ScriptObject *so_c = GET_SCRIPT_OBJECT(c);
	if (so_c)
	{
		ScriptTreeItem *sti_c = static_cast<ScriptTreeItem *>(so_c->vcpu_getInterface(treeitemGuid));
		if (sti_c)
		{
			_c = sti_c->getItem();
		}
	}
	scriptVar retval = MAKE_SCRIPT_INT(0);
	if (sp != NULL)
	{
		int a = 0;
		a = sp->getNumVisibleChildItems(_c);
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_getNumVisibleItems(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	scriptVar retval = MAKE_SCRIPT_INT(0);
	if (sp != NULL)
	{
		int a = 0;
		a = sp->getNumVisibleItems();
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

/*TreeItem*/ scriptVar GuiTreeScriptController::guitree_enumVisibleItems(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar n)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	int _n = GET_SCRIPT_INT(n);
	scriptVar retval = MAKE_SCRIPT_OBJECT(NULL);
	if (sp != NULL)
	{
		TreeItem *a = NULL;
		a = sp->enumVisibleItems(_n);
		if (a != NULL)
		{
			ScriptTreeItem *item = sp->bindScriptTreeItem(a);
			if (item != NULL)
			{
				retval = MAKE_SCRIPT_OBJECT(item->getScriptObject());
			}
		}
	}
	return retval;
}

/*TreeItem*/ scriptVar GuiTreeScriptController::guitree_enumVisibleChildItems(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar c,  scriptVar n)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_c = NULL;
	ScriptObject *so_c = GET_SCRIPT_OBJECT(c);
	if (so_c)
	{
		ScriptTreeItem *sti_c = static_cast<ScriptTreeItem *>(so_c->vcpu_getInterface(treeitemGuid));
		if (sti_c)
		{
			_c = sti_c->getItem();
		}
	}
	int _n = GET_SCRIPT_INT(n);
	scriptVar retval = MAKE_SCRIPT_OBJECT(NULL);
	if (sp != NULL)
	{
		TreeItem *a = NULL;
		a = sp->enumVisibleChildItems(_c, _n);
		if (a != NULL)
		{
			ScriptTreeItem *item = sp->bindScriptTreeItem(a);
			if (item != NULL)
			{
				retval = MAKE_SCRIPT_OBJECT(item->getScriptObject());
			}
		}
	}
	return retval;
}

/*TreeItem*/ scriptVar GuiTreeScriptController::guitree_enumAllItems(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar n)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	int _n = GET_SCRIPT_INT(n);
	scriptVar retval = MAKE_SCRIPT_OBJECT(NULL);
	if (sp != NULL)
	{
		TreeItem *a = NULL;
		a = sp->enumAllItems(_n);
		if (a != NULL)
		{
			ScriptTreeItem *item = sp->bindScriptTreeItem(a);
			if (item != NULL)
			{
				retval = MAKE_SCRIPT_OBJECT(item->getScriptObject());
			}
		}
	}
	return retval;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_getItemRectX(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	scriptVar retval = MAKE_SCRIPT_INT(0);
	if (sp != NULL)
	{
		int a = 0;
		RECT r;
		sp->getItemRect(_item, &r);
		a = r.left;
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_getItemRectY(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	scriptVar retval = MAKE_SCRIPT_INT(0);
	if (sp != NULL)
	{
		int a = 0;
		RECT r;
		sp->getItemRect(_item, &r);
		a = r.top;
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_getItemRectW(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	scriptVar retval = MAKE_SCRIPT_INT(0);
	if (sp != NULL)
	{
		int a = 0;
		RECT r;
		sp->getItemRect(_item, &r);
		a = r.left - r.right;
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

/*Int*/ scriptVar GuiTreeScriptController::guitree_getItemRectH(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  scriptVar item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	TreeItem *_item = NULL;
	ScriptObject *so_item = GET_SCRIPT_OBJECT(item);
	if (so_item)
	{
		ScriptTreeItem *sti_item = static_cast<ScriptTreeItem *>(so_item->vcpu_getInterface(treeitemGuid));
		if (sti_item)
		{
			_item = sti_item->getItem();
		}
	}
	scriptVar retval = MAKE_SCRIPT_INT(0);
	if (sp != NULL)
	{
		int a = 0;
		RECT r;
		sp->getItemRect(_item, &r);
		a = r.bottom - r.top;
		retval = MAKE_SCRIPT_INT(a);
	}
	return retval;
}

#if 0 // Not implemented in TreeWnd, dammit. 
/*TreeItem*/ scriptVar GuiTreeScriptController::guitree_getItemFromPoint(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar x, scriptVar y)
{
	SCRIPT_FUNCTION_INIT
	ScriptTree *sp = static_cast<ScriptTree *>(o->vcpu_getInterface(guitreeGuid));
	int _y = GET_SCRIPT_INT(y);
	int _x = GET_SCRIPT_INT(x);
	scriptVar retval = MAKE_SCRIPT_OBJECT(NULL);
	if (sp != NULL)
	{
		TreeItem *a = NULL;
		POINT p = {_x, _y};
		a = sp->getItemFromPoint(&p);
		if (a != NULL)
		{
			ScriptTreeItem *item = sp->bindScriptTreeItem(a);
			if (item != NULL)
			{
				retval = MAKE_SCRIPT_OBJECT(item->getScriptObject());
			}
		}
	}
	return retval;
}
#endif

// -----------------------------------------------------------------------
// Script Object For The Tree Item

ScriptTreeItem::ScriptTreeItem(TreeItem *_item, ScriptTree *_tree) : item(_item), tree(_tree), SCRIPTTREEITEM_SCRIPTPARENT()
{
	getScriptObject()->vcpu_setInterface(treeitemGuid, (void *)static_cast<ScriptTreeItem *>(this));
	getScriptObject()->vcpu_setClassName(L"TreeItem");
	getScriptObject()->vcpu_setController(treeItemController);
}

ScriptTreeItem::~ScriptTreeItem()
{}

int ScriptTreeItem::getNumChildren()
{
	ASSERT(item);
	return item->getNumChildren();
}

void ScriptTreeItem::setLabel(const wchar_t *label)
{
	ASSERT(item);
	item->setLabel(label);
}

const wchar_t *ScriptTreeItem::getLabel()
{
	ASSERT(item);
	return item->getLabel();
}

void ScriptTreeItem::ensureVisible()
{
	ASSERT(item);
	item->ensureVisible();
}

TreeItem *ScriptTreeItem::getNthChild(int nth)
{
	ASSERT(item);
	return item->getNthChild(nth);
}

TreeItem *ScriptTreeItem::getChild()
{
	ASSERT(item);
	return item->getChild();
}

TreeItem *ScriptTreeItem::getChildSibling(TreeItem *_item)
{
	ASSERT(item);
	return item->getChildSibling(_item);
}

TreeItem *ScriptTreeItem::getSibling()
{
	ASSERT(item);
	return item->getSibling();
}

TreeItem *ScriptTreeItem::getParent()
{
	ASSERT(item);
	return item->getParent();
}

void ScriptTreeItem::editLabel()
{
	ASSERT(item);
	item->editLabel();
}

bool ScriptTreeItem::hasSubItems()
{
	ASSERT(item);
	return item->hasSubItems();
}

void ScriptTreeItem::setSorted(int issorted)
{
	ASSERT(item);
	item->setSorted(issorted);
}

void ScriptTreeItem::setChildTab(int haschildtab)
{
	ASSERT(item);
	item->setChildTab(haschildtab);
}

bool ScriptTreeItem::isSorted()
{
	ASSERT(item);
	return item->isSorted();
}

bool ScriptTreeItem::isCollapsed()
{
	ASSERT(item);
	return item->isCollapsed();
}

bool ScriptTreeItem::isExpanded()
{
	ASSERT(item);
	return item->isExpanded();
}

void ScriptTreeItem::invalidate()
{
	ASSERT(item);
	item->invalidate();
}

bool ScriptTreeItem::isSelected()
{
	ASSERT(item);
	return item->isSelected();
}

bool ScriptTreeItem::isHilited()
{
	ASSERT(item);
	return item->isHilited();
}

void ScriptTreeItem::setHilited(bool ishilited)
{
	ASSERT(item);
	item->setHilited(ishilited);
}

int ScriptTreeItem::collapse()
{
	ASSERT(item);
	return item->collapse();
}

int ScriptTreeItem::expand()
{
	ASSERT(item);
	return item->expand();
}

#if 0 
//    This was never implemented!
void ScriptTreeItem::setCurrent(bool tf)
{
	ASSERT(item);
	item->setCurrent(tf);
}
#endif

TreeWnd *ScriptTreeItem::getTree()
{
	ASSERT(item);
	return item->getTree();
}

// -----------------------------------------------------------------------
// Script Controller For The Tree Item

TreeItemScriptController _treeItemController;
TreeItemScriptController *treeItemController = &_treeItemController;

// -- Functions table -------------------------------------
function_descriptor_struct TreeItemScriptController::exportedFunction[] = {
            {L"getNumChildren", 0, (void*)TreeItemScriptController::treeitem_getNumChildren },
            {L"setLabel", 1, (void*)TreeItemScriptController::treeitem_setLabel },
            {L"getLabel", 0, (void*)TreeItemScriptController::treeitem_getLabel },
            {L"ensureVisible", 0, (void*)TreeItemScriptController::treeitem_ensureVisible },
            {L"getNthChild", 1, (void*)TreeItemScriptController::treeitem_getNthChild },
            {L"getChild", 0, (void*)TreeItemScriptController::treeitem_getChild },
            {L"getChildSibling", 1, (void*)TreeItemScriptController::treeitem_getChildSibling },
            {L"getSibling", 0, (void*)TreeItemScriptController::treeitem_getSibling },
            {L"getParent", 0, (void*)TreeItemScriptController::treeitem_getParent },
            {L"editLabel", 0, (void*)TreeItemScriptController::treeitem_editLabel },
            {L"hasSubItems", 0, (void*)TreeItemScriptController::treeitem_hasSubItems },
            {L"setSorted", 1, (void*)TreeItemScriptController::treeitem_setSorted },
            {L"setChildTab", 1, (void*)TreeItemScriptController::treeitem_setChildTab },
            {L"isSorted", 0, (void*)TreeItemScriptController::treeitem_isSorted },
            {L"isCollapsed", 0, (void*)TreeItemScriptController::treeitem_isCollapsed },
            {L"isExpanded", 0, (void*)TreeItemScriptController::treeitem_isExpanded },
            {L"invalidate", 0, (void*)TreeItemScriptController::treeitem_invalidate },
            {L"isSelected", 0, (void*)TreeItemScriptController::treeitem_isSelected },
            {L"isHilited", 0, (void*)TreeItemScriptController::treeitem_isHilited },
            {L"setHilited", 1, (void*)TreeItemScriptController::treeitem_setHilited },
            {L"collapse", 0, (void*)TreeItemScriptController::treeitem_collapse },
            {L"expand", 0, (void*)TreeItemScriptController::treeitem_expand },
            {L"getTree", 0, (void*)TreeItemScriptController::treeitem_getTree },

            {L"onTreeAdd", 0, (void*)TreeItemScriptController::treeitem_onTreeAdd },
            {L"onTreeRemove", 0, (void*)TreeItemScriptController::treeitem_onTreeRemove },
            {L"onSelect", 0, (void*)TreeItemScriptController::treeitem_onSelect },
            {L"onDeselect", 0, (void*)TreeItemScriptController::treeitem_onDeselect },
            {L"onLeftDoubleClick", 0, (void*)TreeItemScriptController::treeitem_onLeftDoubleClick },
            {L"onRightDoubleClick", 0, (void*)TreeItemScriptController::treeitem_onRightDoubleClick },
            {L"onChar", 1, (void*)TreeItemScriptController::treeitem_onChar },
            {L"onExpand", 0, (void*)TreeItemScriptController::treeitem_onExpand },
            {L"onCollapse", 0, (void*)TreeItemScriptController::treeitem_onCollapse },
            {L"onBeginLabelEdit", 0, (void*)TreeItemScriptController::treeitem_onBeginLabelEdit },
            {L"onEndLabelEdit", 1, (void*)TreeItemScriptController::treeitem_onEndLabelEdit },
            {L"onContextMenu", 2, (void*)TreeItemScriptController::treeitem_onContextMenu },

        };

StringW TreeItemScriptController::staticStr;
ScriptTreeMap TreeItemScriptController::g_scriptitems;

ScriptObject *TreeItemScriptController::instantiate()
{
	ScriptTreeItem *sp = new ScriptTreeItem;
	ASSERT(sp != NULL);
	TreeItem *child_item = new TreeItemScript(L"", sp);
	ASSERT(child_item != NULL);
	sp->setItem(child_item);
	TISC::g_scriptitems.insert({ child_item, sp });
	// We're not attached to a tree.  that's okay!
	return sp->getScriptObject();
}

// If the script asks to delete the item, delete the internal item as well.
// We tell the owning ScriptTree to remove this object.
void TreeItemScriptController::destroy(ScriptObject *o)
{
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	ASSERT(sp != NULL);
	if (!sp->destroyScriptTreeItem())
	{
		auto item = sp->getItem();
		// Ask the owner tree to do it for us, but if not owned, we do it ourselves.
		if (item)
		{
			//TISC::g_scriptitems.delItem(sp->getItem());
			auto it = TISC::g_scriptitems.find(item);
			if (TISC::g_scriptitems.end() != it)
			{
				TISC::g_scriptitems.erase(it);
			}		
		}
		// AND we delete our item, since we're not a part of a tree that will do it for us.
		delete item;
		delete sp;
	}
}

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

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

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

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

/*int*/ scriptVar TreeItemScriptController::treeitem_getNumChildren(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	int a = 0;
	if (sp != NULL)
	{
		a = sp->getNumChildren();
	}
	return MAKE_SCRIPT_INT(a);
}

/*void*/ scriptVar TreeItemScriptController::treeitem_setLabel(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*String*/ scriptVar label)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	StringW _label = GET_SCRIPT_STRING(label);
	if (sp != NULL)
	{
		sp->setLabel(_label);
	}
	RETURN_SCRIPT_VOID;
}

/*String*/ scriptVar TreeItemScriptController::treeitem_getLabel(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	if (sp != NULL)
	{
		staticStr = sp->getLabel();
	}
	return MAKE_SCRIPT_STRING(staticStr);
}

/*void*/ scriptVar TreeItemScriptController::treeitem_ensureVisible(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	if (sp != NULL)
	{
		sp->ensureVisible();
	}
	RETURN_SCRIPT_VOID;
}

/*TreeItem*/ scriptVar TreeItemScriptController::treeitem_getNthChild(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*int*/ scriptVar nth)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	int _nth = GET_SCRIPT_INT(nth);
	TreeItem *a = NULL;
	if (sp != NULL)
	{
		a = sp->getNthChild(_nth);
	}
	ScriptTree *tree = sp->getScriptTree();
	ScriptTreeItem *retval = NULL;
	if (tree && a)
	{
		retval = tree->bindScriptTreeItem(a);
	}
	if (retval)
	{
		return MAKE_SCRIPT_OBJECT(retval->getScriptObject());
	}
	return MAKE_SCRIPT_OBJECT(NULL); // Return NULL
}

/*TreeItem*/ scriptVar TreeItemScriptController::treeitem_getChild(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	TreeItem *a = NULL;
	if (sp != NULL)
	{
		a = sp->getChild();
	}
	ScriptTree *tree = sp->getScriptTree();
	ScriptTreeItem *retval = NULL;
	if (tree && a)
	{
		retval = tree->bindScriptTreeItem(a);
	}
	if (retval)
	{
		return MAKE_SCRIPT_OBJECT(retval->getScriptObject());
	}
	return MAKE_SCRIPT_OBJECT(NULL); // Return NULL
}

/*TreeItem*/ scriptVar TreeItemScriptController::treeitem_getChildSibling(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*TreeItem*/ scriptVar _item)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	TreeItem *__item = NULL;
	ScriptObject *io = GET_SCRIPT_OBJECT(_item);
	if (io)
	{
		ScriptTreeItem *sio = static_cast<ScriptTreeItem *>(io->vcpu_getInterface(treeitemGuid));
		if (sio)
		{
			__item = sio->getItem();
		}
	}
	TreeItem *a = NULL;
	if (sp != NULL)
	{
		a = sp->getChildSibling(__item);
	}
	ScriptTree *tree = sp->getScriptTree();
	ScriptTreeItem *retval = NULL;
	if (tree && a)
	{
		retval = tree->bindScriptTreeItem(a);
	}
	if (retval)
	{
		return MAKE_SCRIPT_OBJECT(retval->getScriptObject());
	}
	return MAKE_SCRIPT_OBJECT(NULL); // Return NULL
}

/*TreeItem*/ scriptVar TreeItemScriptController::treeitem_getSibling(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	TreeItem *a = NULL;
	if (sp != NULL)
	{
		a = sp->getSibling();
	}
	ScriptTree *tree = sp->getScriptTree();
	ScriptTreeItem *retval = NULL;
	if (tree && a)
	{
		retval = tree->bindScriptTreeItem(a);
	}
	if (retval)
	{
		return MAKE_SCRIPT_OBJECT(retval->getScriptObject());
	}
	return MAKE_SCRIPT_OBJECT(NULL); // Return NULL
}

/*TreeItem*/ scriptVar TreeItemScriptController::treeitem_getParent(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	TreeItem *a = NULL;
	if (sp != NULL)
	{
		a = sp->getParent();
	}
	ScriptTree *tree = sp->getScriptTree();
	ScriptTreeItem *retval = NULL;
	if (tree && a)
	{
		retval = tree->bindScriptTreeItem(a);
	}
	if (retval)
	{
		return MAKE_SCRIPT_OBJECT(retval->getScriptObject());
	}
	return MAKE_SCRIPT_OBJECT(NULL); // Return NULL
}

/*void*/ scriptVar TreeItemScriptController::treeitem_editLabel(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	if (sp != NULL)
	{
		sp->editLabel();
	}
	RETURN_SCRIPT_VOID;
}

/*int*/ scriptVar TreeItemScriptController::treeitem_hasSubItems(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	int a = 0;
	if (sp != NULL)
	{
		a = sp->hasSubItems();
	}
	return MAKE_SCRIPT_INT(a);
}

/*void*/ scriptVar TreeItemScriptController::treeitem_setSorted(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*int*/ scriptVar issorted)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	int _issorted = GET_SCRIPT_INT(issorted);
	if (sp != NULL)
	{
		sp->setSorted(_issorted);
	}
	RETURN_SCRIPT_VOID;
}

/*void*/ scriptVar TreeItemScriptController::treeitem_setChildTab(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*int*/ scriptVar haschildtab)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	int _haschildtab = GET_SCRIPT_INT(haschildtab);
	if (sp != NULL)
	{
		sp->setChildTab(_haschildtab);
	}
	RETURN_SCRIPT_VOID;
}

/*int*/ scriptVar TreeItemScriptController::treeitem_isSorted(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	int a = 0;
	if (sp != NULL)
	{
		a = sp->isSorted();
	}
	return MAKE_SCRIPT_INT(a);
}

/*int*/ scriptVar TreeItemScriptController::treeitem_isCollapsed(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	int a = 0;
	if (sp != NULL)
	{
		a = sp->isCollapsed();
	}
	return MAKE_SCRIPT_INT(a);
}

/*int*/ scriptVar TreeItemScriptController::treeitem_isExpanded(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	int a = 0;
	if (sp != NULL)
	{
		a = sp->isExpanded();
	}
	return MAKE_SCRIPT_INT(a);
}

/*void*/ scriptVar TreeItemScriptController::treeitem_invalidate(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	if (sp != NULL)
	{
		sp->invalidate();
	}
	RETURN_SCRIPT_VOID;
}

/*int*/ scriptVar TreeItemScriptController::treeitem_isSelected(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	int a = 0;
	if (sp != NULL)
	{
		a = sp->isSelected();
	}
	return MAKE_SCRIPT_INT(a);
}

/*int*/ scriptVar TreeItemScriptController::treeitem_isHilited(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	int a = 0;
	if (sp != NULL)
	{
		a = sp->isHilited();
	}
	return MAKE_SCRIPT_INT(a);
}

/*void*/ scriptVar TreeItemScriptController::treeitem_setHilited(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*int*/ scriptVar ishilited)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	int _ishilited = GET_SCRIPT_INT(ishilited);
	if (sp != NULL)
	{
		sp->setHilited(!!_ishilited);
	}
	RETURN_SCRIPT_VOID;
}

/*int*/ scriptVar TreeItemScriptController::treeitem_collapse(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	int a = 0;
	if (sp != NULL)
	{
		a = sp->collapse();
	}
	return MAKE_SCRIPT_INT(a);
}

/*int*/ scriptVar TreeItemScriptController::treeitem_expand(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	int a = 0;
	if (sp != NULL)
	{
		a = sp->expand();
	}
	return MAKE_SCRIPT_INT(a);
}

#if 0 
//    This was never implemented!
/*void*/ scriptVar TreeItemScriptController::treeitem_setCurrent(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*int*/ scriptVar tf)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	int _tf = GET_SCRIPT_INT(tf);
	if (sp != NULL)
	{
		sp->setCurrent(_tf);
	}
	RETURN_SCRIPT_VOID;
}
#endif

/*GuiTree*/ scriptVar TreeItemScriptController::treeitem_getTree(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	ScriptTreeItem *sp = static_cast<ScriptTreeItem *>(o->vcpu_getInterface(treeitemGuid));
	ScriptTree *a = NULL;
	ScriptObject *retval = NULL;
	if (sp != NULL)
	{
		a = sp->getScriptTree();
	}
	if (a)
	{
		retval = a->getScriptObject();
	}
	return MAKE_SCRIPT_OBJECT(retval);
}

/*void*/ scriptVar TreeItemScriptController::treeitem_onTreeAdd(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS0(o, guiTreeController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

/*void*/ scriptVar TreeItemScriptController::treeitem_onTreeRemove(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS0(o, guiTreeController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

/*void*/ scriptVar TreeItemScriptController::treeitem_onSelect(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS0(o, guiTreeController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

/*void*/ scriptVar TreeItemScriptController::treeitem_onDeselect(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS0(o, guiTreeController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

/*int*/ scriptVar TreeItemScriptController::treeitem_onLeftDoubleClick(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS0(o, guiTreeController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

/*int*/ scriptVar TreeItemScriptController::treeitem_onRightDoubleClick(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS0(o, guiTreeController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

/*int*/ scriptVar TreeItemScriptController::treeitem_onChar(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*int*/ scriptVar _key)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS1(o, guiTreeController, _key);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT1(o, _key);
}

/*void*/ scriptVar TreeItemScriptController::treeitem_onExpand(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS0(o, guiTreeController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

/*void*/ scriptVar TreeItemScriptController::treeitem_onCollapse(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS0(o, guiTreeController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

/*int*/ scriptVar TreeItemScriptController::treeitem_onBeginLabelEdit(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS0(o, guiTreeController);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT0(o);
}

/*int*/ scriptVar TreeItemScriptController::treeitem_onEndLabelEdit(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*String*/ scriptVar _newlabel)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS1(o, guiTreeController, _newlabel);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT1(o, _newlabel);
}

/*int*/ scriptVar TreeItemScriptController::treeitem_onContextMenu(SCRIPT_FUNCTION_PARAMS,  ScriptObject *o,  /*int*/ scriptVar _x,  /*int*/ scriptVar _y)
{
	SCRIPT_FUNCTION_INIT
	PROCESS_HOOKS2(o, guiTreeController, _x, _y);
	SCRIPT_FUNCTION_CHECKABORTEVENT;
	SCRIPT_EXEC_EVENT2(o, _x, _y);
}