diff options
Diffstat (limited to 'Src/Wasabi/api/wndmgr/container.cpp')
| -rw-r--r-- | Src/Wasabi/api/wndmgr/container.cpp | 919 |
1 files changed, 919 insertions, 0 deletions
diff --git a/Src/Wasabi/api/wndmgr/container.cpp b/Src/Wasabi/api/wndmgr/container.cpp new file mode 100644 index 00000000..cfa7485e --- /dev/null +++ b/Src/Wasabi/api/wndmgr/container.cpp @@ -0,0 +1,919 @@ +#include <precomp.h> +#include "wasabicfg.h" +#include <api/wndmgr/container.h> +#include <api/script/script.h> +#include <api/script/scriptmgr.h> +#include <api/config/items/attrbool.h> +#include <api/config/items/cfgitem.h> +#include <api/skin/skinparse.h> +#include <api/wac/compon.h> +#include <api/wnd/wndtrack.h> +#include <api/skin/skin.h> +#include <api/wndmgr/skinembed.h> +#include <api/syscb/callbacks/wndcb.h> +#include <bfc/string/stringdict.h> +#include <api/skin/widgets/xuiwndholder.h> // TODO: cut, but we need XuiWindowHolder::parseGUID for now +#include <bfc/platform/guid.h> + +#ifdef WIN32 +#include "resource.h" +#include "../Agave/Language/api_language.h" +#endif + +BEGIN_STRINGDICTIONARY(_containerparams) +SDI(L"name", CONTAINERPARAM_NAME); +SDI(L"id", CONTAINERPARAM_ID); +SDI(L"dynamic", CONTAINERPARAM_DYNAMIC); +SDI(L"default_x", CONTAINERPARAM_DEFAULTX); +SDI(L"default_y", CONTAINERPARAM_DEFAULTY); +SDI(L"default_visible", CONTAINERPARAM_DEFAULTVISIBLE); +SDI(L"canclose", CONTAINERPARAM_CANCLOSE); +SDI(L"nomenu", CONTAINERPARAM_NOMENU); +SDI(L"nofocusapponclose", CONTAINERPARAM_NOFOCUSAPPONCLOSE); +SDI(L"primarycomponent", CONTAINERPARAM_CONTENT); +END_STRINGDICTIONARY(_containerparams, containerparams); + +Container::Container(int script_id) +{ + getScriptObject()->vcpu_setInterface(containerGuid, (void *)static_cast<Container *>(this)); + getScriptObject()->vcpu_setClassName(L"Container"); + getScriptObject()->vcpu_setController(containerController); + scriptid = script_id; + currentLayout = -1; + default_visible = TRUE; + loaded_default_visible = TRUE; + dynamic = 0; + MEMCPY(&myGUID, &INVALID_GUID, sizeof(GUID)); + lastLayout = -1; + refocusapponclose = 1; + canclose = 1; + inited = 0; + deleting = 0; + transcient = 0; + switching_layout = 0; + nomenu = 0; + prevent_save_visibility = 0; + contentGuid = INVALID_GUID; + hasContentGuid=false; +} + + +void Container::setName(const wchar_t *name) +{ +#ifdef ON_TWEAK_CONTAINER_NAMEW + ON_TWEAK_CONTAINER_NAMEW(name); +#endif + containerName = name ? name : CONTAINER_UNDEFINED_NAME; + foreach(layouts) + Layout *l = layouts.getfor(); + if (l->getRootWndName() == NULL) + { + l->setOSWndName(name); + } + endfor; + updateDefaultVisible(); + + dependent_sendEvent(Container::depend_getClassGuid(), Event_NAMECHANGE, 0, this); +} + +void Container::resetLayouts() +{ + updateDefaultVisible(); + + foreach(layouts) + layouts.getfor()->loadSavedState(); + endfor; +} + +void Container::setId(const wchar_t *id) +{ + containerId = id ? id : L"undefined"; + ismain = !WCSICMP(id, L"main"); +} + +int Container::setXmlParam(const wchar_t *paramname, const wchar_t *strvalue) +{ + switch (containerparams.getId(paramname)) + { + case CONTAINERPARAM_NAME: + setName(strvalue); + return 1; + case CONTAINERPARAM_ID: + setId(strvalue); + return 1; + case CONTAINERPARAM_DYNAMIC: + setDynamic(WTOI(strvalue)); + return 1; + case CONTAINERPARAM_DEFAULTX: + default_x = WTOI(strvalue); + return 1; + case CONTAINERPARAM_DEFAULTY: + default_y = WTOI(strvalue); + return 1; + case CONTAINERPARAM_DEFAULTVISIBLE: + default_visible = WTOI(strvalue); + updateDefaultVisible(); + return 1; + case CONTAINERPARAM_CANCLOSE: + canclose = WTOI(strvalue); + return 1; + case CONTAINERPARAM_NOMENU: + nomenu = WTOI(strvalue); + return 1; + case CONTAINERPARAM_NOFOCUSAPPONCLOSE: + refocusapponclose = !WTOI(strvalue); + break; + case CONTAINERPARAM_CONTENT: + { + // TODO: move this out of XuiWindowHolder + GUID *g = XuiWindowHolder::parseGUID(strvalue); + contentGuid = *g; + hasContentGuid=true; + + break; + } + + } + return 0; +} + +Container::~Container() +{ + containerCallback(CONT_CB_HIDDEN); + layouts.deleteAll(); + contents.deleteAll(); + SkinParser::containers.removeItem(this); +} + +void Container::getWindowRect(RECT *r) +{ + Layout *l = getCurrentLayout(); + if (l) + l->getWindowRect(r); +} + +void Container::addLayout(Layout *layout) +{ + layouts.addItem(layout); +} + +const wchar_t *Container::getName() +{ + return containerName; +} + +const wchar_t *Container::getId() +{ + return containerId; +} + +int Container::getDefaultPositionX(void) +{ + return default_x; +} + +int Container::getDefaultPositionY(void) +{ + return default_y; +} + +void Container::onInit(int noshow) +{ + if (inited) return ; + inited++; + loadFromDefaults(noshow); +} + +void Container::loadFromDefaults(int noshow) +{ +#ifdef WASABI_COMPILE_CONFIG + if (last_layout.isempty()) + { + StringPrintfW tmp(L"container_%s|active", getName()); + wchar_t c[512] = {0}; + WASABI_API_CONFIG->getStringPrivate(tmp, c, 511, L""); + c[510] = 0; + last_layout = c; + } +#endif + + if (loaded_default_visible) + { + showDefaultLayout(noshow); + } +} + +void Container::setDefaultLayout(const wchar_t *name) +{ + last_layout = name; +} + +void Container::showDefaultLayout(int noshow) +{ + Layout *l = getLayout(last_layout); + + if (!l) + l = layouts.enumItem(0); + + if (l) + { + currentLayout = layouts.searchItem(l); + + if (!noshow) + l->setVisible(1); + + containerCallback(CONT_CB_VISIBLE); // since we set currentLayout prior to showing the layout, the callback will not be processed in onChildSetLayoutVisible + } +} + +void Container::setVisible(int sh) +{ + if (!sh && !canclose) + return ; + + int is = isVisible(); + + if (!!sh == !!is) + return ; + + Layout *l = getCurrentLayout(); + + if (!l && lastLayout != -1) + l = layouts[lastLayout]; + + if (sh) + { + if (!l) + showDefaultLayout(); + else + { + l->setVisible(1); + } + } + else + { + if (l) + l->setVisible(0); + } +} + +int Container::isVisible() +{ + if (switching_layout) return 1; + Layout *l = getCurrentLayout(); + if (!l) return 0; + return l->isVisible(); +} + +void Container::onChildSetLayoutVisible(Layout *l, int v) +{ + for (int i = 0;i < layouts.getNumItems();i++) + { + if (layouts[i] == l) + { + if (v) + { + if (currentLayout != i) + { + Layout *l = NULL; + if (currentLayout >= 0) + l = layouts[currentLayout]; + if (l) l->setVisible(0); + containerCallback(CONT_CB_VISIBLE); + currentLayout = i; + l = layouts[currentLayout]; +#ifdef WASABI_COMPILE_CONFIG + if (!isTranscient() && !prevent_save_visibility) + WASABI_API_CONFIG->setStringPrivate(StringPrintfW(L"container_%s|active", getName()), l->getGuiObject()->guiobject_getId()); +#endif +#ifdef WA3COMPATIBILITY + l->setForwardMsgWnd(WASABI_API_WND->main_getRootWnd()->gethWnd()); +#endif + if (l->wantActivation()) + { + l->bringToFront(); + l->setFocus(); + } + l->invalidate(); + } +#ifdef WASABI_COMPILE_CONFIG + if (!isTranscient() && !isDynamic() && !prevent_save_visibility) + WASABI_API_CONFIG->setIntPrivate(StringPrintfW(L"activated/%s", getName()), v); + WASABI_API_CONFIG->setIntPrivate(StringPrintfW(L"everloaded/%s", getName()), 1); +#endif + + } + else + { + if (i == currentLayout) + { + if (!isDeleting() && !isTranscient() && !isDynamic()) + { +#ifdef WASABI_COMPILE_CONFIG + WASABI_API_CONFIG->setIntPrivate(StringPrintfW(L"activated/%s", getName()), v); +#endif + lastLayout = currentLayout; + currentLayout = -1; + } + containerCallback(CONT_CB_HIDDEN); + } + } + return ; + } + } +} + +void Container::containerCallback(int msg) +{ + switch (msg) + { + case CONT_CB_VISIBLE: + { + foreach(contents) + ContentEntry *e = contents.getfor(); + WndInfo i; + i.groupid = e->groupid; + i.guid = e->guid; + i.c = this; + WASABI_API_SYSCB->syscb_issueCallback(SysCallback::WINDOW, WndCallback::SHOWWINDOW, reinterpret_cast<intptr_t>(&i)); + endfor + WndInfo i; + i.groupid = getId(); + i.guid = INVALID_GUID; + i.c = this; + WASABI_API_SYSCB->syscb_issueCallback(SysCallback::WINDOW, WndCallback::SHOWWINDOW, reinterpret_cast<intptr_t>(&i)); + } + break; + case CONT_CB_HIDDEN: + { + foreach(contents) + ContentEntry *e = contents.getfor(); + WndInfo i; + i.groupid = e->groupid; + i.guid = e->guid; + i.c = this; + WASABI_API_SYSCB->syscb_issueCallback(SysCallback::WINDOW, WndCallback::HIDEWINDOW, reinterpret_cast<intptr_t>(&i)); + endfor + WndInfo i; + i.groupid = getId(); + i.guid = INVALID_GUID; + i.c = this; + WASABI_API_SYSCB->syscb_issueCallback(SysCallback::WINDOW, WndCallback::HIDEWINDOW, reinterpret_cast<intptr_t>(&i)); + } + break; + } +} + +void Container::close() +{ + int norefocs = !wantRefocusApp(); + if (norefocs) WASABI_API_WND->appdeactivation_push_disallow(NULL); + if (!canclose) return ; + if (isDynamic()) + { + setVisible(0); + skinEmbedder->destroyContainer(this); // deferred + } + else + setVisible(0); + if (norefocs) WASABI_API_WND->appdeactivation_pop_disallow(NULL); +} + +void Container::toggle() +{ + if (isVisible()) close(); else setVisible(1); // close has special function hide/destroy depending on dynamic status +} + +void Container::switchToLayout(const wchar_t *name, int moveit) +{ + int l = -1; + getLayout(name, &l); + + if (l == -1) + { + // Layout not found, reverting to first in the list + if (layouts.getNumItems() > 0) l = 0; + else + return ; // none found, abort + } + + switching_layout = 1; + if (l != currentLayout) + { + int old = currentLayout; + RECT r = {0}; + Layout *oldlayout = old >= 0 ? layouts[old] : NULL; + Layout *newlayout = layouts[l]; + onBeforeSwitchToLayout(oldlayout, newlayout); + if (oldlayout) + { + oldlayout->getWindowRect(&r); + oldlayout->endCapture(); + } + int unlinked = layouts[l]->isUnlinked(); + unlinked |= oldlayout ? oldlayout->isUnlinked() : 0; + if (moveit && !unlinked && oldlayout) + layouts[l]->move(r.left, r.top); +#ifdef WASABI_COMPILE_CONFIG + // {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"Link layouts scale")) + { +#else + if (WASABI_WNDMGR_LINKLAYOUTSCALES) + { +#endif + if (oldlayout) + { + double _r = oldlayout->getRenderRatio(); + newlayout->setRenderRatio(_r); + } + } +#ifdef WASABI_COMPILE_CONFIG + if (_intVal(WASABI_API_CONFIG->config_getCfgItemByGuid(uioptions_guid), L"Link layouts alpha")) + { +#else + if (WASABI_WNDMGR_LINKLAYOUTSALPHA) + { +#endif + if (oldlayout) + { + int a = layouts[old]->getAlpha(); + newlayout->setAlpha(a); + int autoopacify = layouts[old]->getAutoOpacify(); + newlayout->setAutoOpacify(autoopacify); + } + } + + WindowTracker::layoutChanged(oldlayout, newlayout); +#ifdef ON_LAYOUT_CHANGED + ON_LAYOUT_CHANGED; +#endif + layouts[l]->setVisible(1); + foreach(SkinParser::containers) + SkinParser::containers.getfor()->savePositions(); + endfor + onSwitchToLayout(newlayout); + } + switching_layout = 0; +} + +void Container::savePositions() +{ + foreach (layouts) + layouts.getfor()->savePosition(); + endfor +} + +Layout *Container::getLayout(const wchar_t *name, int *pos) +{ + for ( int i = 0; i < getNumLayouts(); i++ ) + { + if ( WCSCASEEQLSAFE( enumLayout( i )->getGuiObject()->guiobject_getId(), name ) ) + { + if (pos) + { + *pos = i; + } + + return enumLayout( i ); + + } + } + + return NULL; +} + +Layout *Container::getCurrentLayout() +{ + if (currentLayout < 0) + return NULL; + + return layouts.enumItem(currentLayout); +} + +void Container::otherContainerToggled(const wchar_t *id, int visible) +{ + for (int i = 0;i < layouts.getNumItems();i++) + layouts[i]->containerToggled(id, visible); +} + +void Container::componentToggled(GUID *g, int visible) +{ + for (int i = 0;i < layouts.getNumItems();i++) + layouts[i]->componentToggled(g, visible); +} + +void Container::sendNotifyToAllLayouts(int notifymsg, int param1, int param2) +{ + for (int i = 0;i < layouts.getNumItems();i++) + layouts[i]->sendNotifyToAllChildren(notifymsg, param1, param2); +} + +int Container::isMainContainer() +{ + return ismain; +} + +void Container::sysMenu() +{ + POINT p; + Wasabi::Std::getMousePos(&p); + layouts.enumItem(currentLayout)->onRightButtonDown(p.x, p.y); +} + +void Container::setDynamic(int i) +{ + dynamic = i; + if (!containerId.isempty()) + setId(containerId); +} + +int Container::isDynamic() +{ + return dynamic; +} + +void Container::onSwitchToLayout(Layout *l) +{ + ScriptObject *ls = l ? l->getGuiObject()->guiobject_getScriptObject() : NULL; + script_onSwitchToLayout(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_OBJECT(ls)); +} + +void Container::onBeforeSwitchToLayout(Layout *oldl, Layout *newl) +{ + ScriptObject *olds = oldl ? oldl->getGuiObject()->guiobject_getScriptObject() : NULL; + ScriptObject *news = newl ? newl->getGuiObject()->guiobject_getScriptObject() : NULL; + script_onBeforeSwitchToLayout(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_OBJECT(olds), MAKE_SCRIPT_OBJECT(news)); +} + + +void Container::onHideLayout(Layout *l) +{ + script_onHideLayout(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_OBJECT(l->getGuiObject()->guiobject_getScriptObject())); +} + +void Container::onShowLayout(Layout *l) +{ + script_onShowLayout(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_OBJECT(l->getGuiObject()->guiobject_getScriptObject())); +} + +int Container::getNumLayouts() +{ + return layouts.getNumItems(); +} + +Layout *Container::enumLayout(int n) +{ + return layouts.enumItem(n); +} + +const wchar_t *Container::getDescriptor() +{ + static wchar_t d[256]; + // if we've tweaked the container names then when saving out we can see and attempt to 'untweak' + // so that things like Winamp Modern's ML will be correctly positioned irrespective of language + int untweak = 0; + wchar_t tweaked[96] = {0}; + // Martin> We need to check the containerName against null - dunno why some skins cause this string to be null + if(containerName.v() != NULL && !_wcsicmp(containerName.v(), WASABI_API_LNGSTRINGW_BUF(IDS_MEDIA_LIBRARY,tweaked,96))){ + untweak = 1; + } + WCSNPRINTF(d, 256,L"%s/%s", getId(), (!untweak ? containerName.v() : L"Media Library")); + return d; +} + +void Container::updateDefaultVisible() +{ + if (!canclose) + { + loaded_default_visible = 1; + return ; + } +#ifdef WASABI_COMPILE_CONFIG + loaded_default_visible = WASABI_API_CONFIG->getIntPrivate(StringPrintfW(L"activated/%s", getName()), default_visible); +#else + loaded_default_visible = default_visible; +#endif +} + +int Container::getScriptId() +{ + return scriptid; +} + +void Container::notifyAddContent(ifc_window *w, const wchar_t *id, GUID g) +{ + contents.addItem(new ContentEntry(id, g, w)); + ScriptObject *_w = w ? w->getGuiObject()->guiobject_getScriptObject() : NULL; + wchar_t guidstr[256] = {0}; + nsGUID::toCharW(g, guidstr); + script_onAddContent(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_OBJECT(_w), MAKE_SCRIPT_STRING(id), MAKE_SCRIPT_STRING(guidstr)); +} + +void Container::notifyRemoveContent(ifc_window *w) +{ + foreach(contents) + ContentEntry *e = contents.getfor(); + if (e->wnd == w) + { + contents.removeItem(e); + delete e; + return ; + } + endfor; +} + +int Container::hasContent(GUID g) +{ + foreach(contents) + ContentEntry *e = contents.getfor(); + if (e->guid == g) + { + return 1; + } + endfor; + return 0; +} + +GUID Container::getDefaultContent() +{ + if (hasContentGuid) + return contentGuid; + if (contents.getNumItems() > 0) return contents.enumItem(0)->guid; + return INVALID_GUID; +} + +ContainerScriptController _containerController; +ContainerScriptController *containerController = &_containerController; + + +// -- Functions table ------------------------------------- +function_descriptor_struct ContainerScriptController::exportedFunction[] = { + {L"onSwitchToLayout", 1, (void*)Container::script_onSwitchToLayout }, + {L"onBeforeSwitchToLayout", 2, (void*)Container::script_onBeforeSwitchToLayout }, + {L"onHideLayout", 1, (void*)Container::script_onHideLayout }, + {L"onShowLayout", 1, (void*)Container::script_onShowLayout }, + {L"getLayout", 1, (void*)Container::script_getLayout }, + {L"getNumLayouts", 0, (void*)Container::script_getNumLayouts }, + {L"enumLayout", 1, (void*)Container::script_enumLayout }, + {L"getCurLayout", 0, (void*)Container::script_getCurrentLayout}, + {L"switchToLayout", 1, (void*)Container::script_switchToLayout }, + {L"isDynamic", 0, (void*)Container::script_isDynamic }, + {L"show", 0, (void*)Container::script_show }, + {L"hide", 0, (void*)Container::script_hide }, + {L"close", 0, (void*)Container::script_close}, + {L"toggle", 0, (void*)Container::script_toggle }, + {L"setName", 1, (void*)Container::script_setName }, + {L"getName", 0, (void*)Container::script_getName }, + {L"getGuid", 0, (void*)Container::script_getGuid }, + {L"setXmlParam", 2, (void*)Container::script_setXmlParam}, + {L"onAddContent", 3, (void*)Container::script_onAddContent}, + }; +// -------------------------------------------------------- + +/*SET_HIERARCHY(Container, SCRIPT_CONTAINER); +SET_HIERARCHY2(Container, SCRIPT_CONTAINER, CONTAINER_SCRIPTPARENT);*/ + +const wchar_t *ContainerScriptController::getClassName() +{ + return L"Container"; +} + +const wchar_t *ContainerScriptController::getAncestorClassName() +{ + return L"Object"; +} + +ScriptObjectController *ContainerScriptController::getAncestorController() +{ + return rootScriptObjectController; +} + +int ContainerScriptController::getInstantiable() +{ + return 1; +} + +ScriptObject *ContainerScriptController::instantiate() +{ + Container *c = new Container; + return c->getScriptObject(); +} + +void ContainerScriptController::destroy(ScriptObject *o) +{ + //ASSERTALWAYS("be nice, don't do that"); + Container *c = (Container *)o->vcpu_getInterface(containerGuid); + delete c; +} + +void *ContainerScriptController::encapsulate(ScriptObject *o) +{ + return NULL; +} + +void ContainerScriptController::deencapsulate(void *o) +{} + + +int ContainerScriptController::getNumFunctions() +{ + return sizeof(exportedFunction) / sizeof(function_descriptor_struct); +} + +const function_descriptor_struct *ContainerScriptController::getExportedFunctions() +{ + return exportedFunction; +} + +GUID ContainerScriptController::getClassGuid() +{ + return containerGuid; +} + +//----------------------------------------------------------------------- + +scriptVar Container::script_onSwitchToLayout(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar l) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS1(o, containerController, l); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT1(o, l); +} + +scriptVar Container::script_onBeforeSwitchToLayout(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar oldl, scriptVar newl) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS2(o, containerController, oldl, newl); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT2(o, oldl, newl); +} + +scriptVar Container::script_onHideLayout(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar l) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS1(o, containerController, l); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT1(o, l); +} + +scriptVar Container::script_onShowLayout(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar l) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS1(o, containerController, l); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT1(o, l); +} + +// Get an layout from its ID +scriptVar Container::script_getLayout(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar obj) +{ + SCRIPT_FUNCTION_INIT + ASSERT(obj.type == SCRIPT_STRING); // compiler discarded + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + if (c) + { + for (int i = 0;i < c->layouts.getNumItems();i++) + if (!WCSICMP(obj.data.sdata, c->layouts.enumItem(i)->getGuiObject()->guiobject_getId())) + { + return MAKE_SCRIPT_OBJECT(c->layouts.enumItem(i)->getGuiObject()->guiobject_getScriptObject()); + } + } + RETURN_SCRIPT_ZERO; +} + +scriptVar Container::script_show(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + if (c) c->setVisible(1); + RETURN_SCRIPT_VOID; +} +scriptVar Container::script_hide(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + if (c) c->setVisible(0); + RETURN_SCRIPT_VOID; +} + +scriptVar Container::script_close(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + if (c) c->close(); + RETURN_SCRIPT_VOID; +} + +scriptVar Container::script_toggle(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + if (c) c->toggle(); + RETURN_SCRIPT_VOID; +} + +// Switch to another layout +scriptVar Container::script_switchToLayout(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar l) +{ + SCRIPT_FUNCTION_INIT + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + if (c) + c->switchToLayout(GET_SCRIPT_STRING(l)); + RETURN_SCRIPT_VOID; +} + +scriptVar Container::script_getNumLayouts(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + if (c) return MAKE_SCRIPT_INT(c->getNumLayouts()); + RETURN_SCRIPT_ZERO; +} + +scriptVar Container::script_enumLayout(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar n) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&n)); // compiler discarded + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + Layout *l = NULL; + if (c) l = c->enumLayout(SOM::makeInt(&n)); + return MAKE_SCRIPT_OBJECT(l ? l->getScriptObject() : NULL); +} + +scriptVar Container::script_getCurrentLayout(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + Layout *l = c->getCurrentLayout(); + return MAKE_SCRIPT_OBJECT(l ? l->getScriptObject() : NULL); +} + +// Switch to another layout +scriptVar Container::script_vcpu_getId(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + + if (c) + return MAKE_SCRIPT_STRING(c->getId()); + + return MAKE_SCRIPT_STRING(L""); +} + +scriptVar Container::script_isDynamic(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + if (c) return MAKE_SCRIPT_INT(c->isDynamic()); + RETURN_SCRIPT_ZERO; +} + +scriptVar Container::script_setName(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar name) +{ + SCRIPT_FUNCTION_INIT + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + if (c) c->setName(GET_SCRIPT_STRING(name)); + RETURN_SCRIPT_VOID; +} + +scriptVar Container::script_getName(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + if (c) return MAKE_SCRIPT_STRING(c->getName()); + return MAKE_SCRIPT_STRING(L""); +} + +scriptVar Container::script_getGuid(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + if (c) + { + static wchar_t guidstr[256]; + nsGUID::toCharW(c->getGUID(), guidstr); + return MAKE_SCRIPT_STRING(guidstr); + } + return MAKE_SCRIPT_STRING(L""); +} + +scriptVar Container::script_setXmlParam(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar p, scriptVar v) +{ + SCRIPT_FUNCTION_INIT + Container *c = static_cast<Container *>(o->vcpu_getInterface(containerGuid)); + if (c) c->setXmlParam(GET_SCRIPT_STRING(p), GET_SCRIPT_STRING(v)); + RETURN_SCRIPT_VOID; +} + +//void Container::notifyAddContent(ifc_window *w, const wchar_t *id, GUID g) +scriptVar Container::script_onAddContent(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar window, scriptVar id, scriptVar g) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS3(o, containerController, window, id, g); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT3(o, window, id, g); +} + |