diff options
Diffstat (limited to 'Src/Wasabi/api/skin/widgets/group.cpp')
| -rw-r--r-- | Src/Wasabi/api/skin/widgets/group.cpp | 1753 |
1 files changed, 1753 insertions, 0 deletions
diff --git a/Src/Wasabi/api/skin/widgets/group.cpp b/Src/Wasabi/api/skin/widgets/group.cpp new file mode 100644 index 00000000..d0827ef5 --- /dev/null +++ b/Src/Wasabi/api/skin/widgets/group.cpp @@ -0,0 +1,1753 @@ +#include <precomp.h> +#include <tataki/bitmap/bitmap.h> +#include <api/wnd/popup.h> +#include <api/wndmgr/layout.h> +#include <api/skin/skinparse.h> +//#include <api/skin/widgets/button.h> +//#include <api/core/buttons.h> +#include <api/wnd/wndtrack.h> +#include <api/wac/compon.h> +#include <api/skin/skin.h> +#include <api/wnd/notifmsg.h> +#include <api/config/items/intarray.h> +#include <api/config/items/cfgitem.h> +#include <api/config/items/attribute.h> +#include <api/wndmgr/layout.h> +#include <api/script/script.h> +#include <api/script/scriptmgr.h> +#include <bfc/util/profiler.h> +#include <api/wndmgr/resize.h> +#include <bfc/wasabi_std_wnd.h> +#include <api/wnd/PaintCanvas.h> + +#ifndef WM_MOUSEWHEEL +#define WM_MOUSEWHEEL 0x20A +#endif + +const wchar_t groupXuiObjectStr[] = L"Group"; // This is the xml tag +char groupXuiSvcName[] = "Group xui object"; // this is the name of the xuiservice + +#ifdef WASABI_COMPILE_CONFIG +const wchar_t cfgGroupXuiObjectStr[] = L"CfgGroup"; // This is the xml tag +char cfgGroupXuiSvcName[] = "CfgGroup xui object"; // this is the name of the xuiservice +#endif + +XMLParamPair Group::groupParams[] = + { + {XUIGROUP_AUTOHEIGHTSOURCE, L"AUTOHEIGHTSOURCE"}, + {XUIGROUP_AUTOWIDTHSOURCE, L"AUTOWIDTHSOURCE"}, + {XUIGROUP_BACKGROUND, L"BACKGROUND"}, + {XUIGROUP_DRAWBACKGROUND, L"DRAWBACKGROUND"}, + {XUIGROUP_DEFAULT_W, L"DEFAULT_W"}, + {XUIGROUP_DEFAULT_H, L"DEFAULT_H"}, + {XUIGROUP_DESIGN_H, L"DESIGN_H"}, + {XUIGROUP_DESIGN_W, L"DESIGN_W"}, + {XUIGROUP_EMBED_XUI, L"EMBED_XUI"}, + {XUIGROUP_INHERIT_CONTENT, L"INHERIT_CONTENT"}, + {XUIGROUP_INHERIT_GROUP, L"INHERIT_GROUP"}, + {XUIGROUP_INSTANCEID, L"INSTANCEID"}, + {XUIGROUP_LOCKMINMAX, L"LOCKMINMAX"}, + {XUIGROUP_MAXIMUM_H, L"MAXIMUM_H"}, + {XUIGROUP_MAXIMUM_W, L"MAXIMUM_W"}, + {XUIGROUP_MINIMUM_H, L"MINIMUM_H"}, + {XUIGROUP_MINIMUM_W, L"MINIMUM_W"}, + {XUIGROUP_NAME, L"NAME"}, + {XUIGROUP_PROPAGATESIZE, L"PROPAGATESIZE"}, + {XUIGROUP_XUITAG, L"XUITAG"}, + }; + +Group::Group() +{ + scripts_enabled = 1; + getScriptObject()->vcpu_setInterface(groupGuid, (void *)static_cast<Group *>(this)); + getScriptObject()->vcpu_setClassName(L"Group"); + getScriptObject()->vcpu_setController(groupController); + background = NULL; + skinpart = 0; + captured = 0; resizing = 0; + x = 0; y = 0; + size_w = 0; size_h = 0; + lockminmax = 0; + propagatesize = 0; + reg = NULL; + default_h = AUTOWH; + default_w = AUTOWH; + // allreg = NULL; + // subregionlayers = new PtrList<api_window>; + // subregiongroups = new PtrList<api_window>; + deleting = 0; + moving = 0; + drawbackground = 0; + groupmaxheight = AUTOWH; + groupmaxwidth = AUTOWH; + groupminheight = AUTOWH; + groupminwidth = AUTOWH; + // regionop = 0; + // allsubreg = NULL; + groups.addItem(this); + scaledreg = NULL; + scaledregionvalid = 0; + autoregionop = 1; + setRectRgn(0); + disable_update_pos = 0; + no_init_on_addchild = 0; + lastheightsource = lastwidthsource = NULL; + lastgetwidthbasedon = lastgetheightbasedon = AUTOWH; + content_item = NULL; + + xuihandle = newXuiHandle(); + CreateXMLParameters(xuihandle); + + design_w = AUTOWH; + design_h = AUTOWH; +} + +void Group::CreateXMLParameters(int master_handle) +{ + //GROUP_PARENT::CreateXMLParameters(master_handle); + int numParams = sizeof(groupParams) / sizeof(groupParams[0]); + hintNumberOfParams(xuihandle, numParams); + for (int i = 0;i < numParams;i++) + { + addParam(xuihandle, groupParams[i], XUI_ATTRIBUTE_IMPLIED); + } +} + +Group::~Group() +{ + deleteScripts(); + deleting = 1; + WASABI_API_WND->skin_unregisterBaseTextureWindow(this); + while (gui_objects.getNumItems() > 0) + { + SkinParser::destroyGuiObject(gui_objects.enumItem(0)); + gui_objects.removeByPos(0); + } + delete background; + delete reg; + delete scaledreg; + xuiparams.deleteAll(); + /* subregionlayers->removeAll(); + delete subregionlayers; + subregiongroups->removeAll(); + delete subregiongroups;*/ + groups.removeItem(this); + WASABI_API_SYSCB->syscb_deregisterCallback(static_cast<WndCallbackI*>(this)); +} + +int Group::isGroup(Group *o) +{ + return groups.haveItem(o); +} + +int Group::setXmlParam(const wchar_t *paramname, const wchar_t *strvalue) +{ + if (!WCSICMP(paramname, L"id") && !instanceid.isempty()) + return GROUP_PARENT::setXmlParam(paramname, instanceid); + return GROUP_PARENT::setXmlParam(paramname, strvalue); +} + +int Group::setXuiParam(int _xuihandle, int xuiid, const wchar_t *paramname, const wchar_t *strvalue) +{ + if (xuihandle == _xuihandle) + { + switch (xuiid) + { + case XUIGROUP_INSTANCEID: + instanceid = strvalue; + getGuiObject()->guiobject_setId(instanceid); + return 1; + case XUIGROUP_BACKGROUND: + setBaseTexture(strvalue); + setDrawBackground(1); + return 1; + case XUIGROUP_DRAWBACKGROUND: + setDrawBackground(WTOI(strvalue)); + return 1; + case XUIGROUP_DEFAULT_W: + { + int w = WTOI(strvalue); + //getGuiObject()->guiobject_setGuiPosition(NULL, NULL, &w, NULL, NULL, NULL, NULL, NULL); + default_w = w; + return 1; + } + case XUIGROUP_DEFAULT_H: + { + int h = WTOI(strvalue); + //getGuiObject()->guiobject_setGuiPosition(NULL, NULL, NULL, &h, NULL, NULL, NULL, NULL); + default_h = h; + return 1; + } + + case XUIGROUP_MAXIMUM_H: + groupmaxheight = WTOI(strvalue); + return 1; + case XUIGROUP_MAXIMUM_W: + groupmaxwidth = WTOI(strvalue); + return 1; + case XUIGROUP_MINIMUM_H: + groupminheight = WTOI(strvalue); + return 1; + case XUIGROUP_MINIMUM_W: + groupminwidth = WTOI(strvalue); + return 1; + case XUIGROUP_PROPAGATESIZE: + propagatesize = WTOI(strvalue); + return 1; + case XUIGROUP_LOCKMINMAX: + lockminmax = WTOI(strvalue); + return 1; + case XUIGROUP_NAME: + setName(strvalue); + return 1; + case XUIGROUP_AUTOWIDTHSOURCE: + setAutoWidthSource(strvalue); + return 1; + case XUIGROUP_AUTOHEIGHTSOURCE: + setAutoHeightSource(strvalue); + return 1; + case XUIGROUP_EMBED_XUI: + xui_embedded_id = strvalue; + return 1; + case XUIGROUP_XUITAG: + return 1; + case XUIGROUP_INHERIT_GROUP: + return 1; + case XUIGROUP_INHERIT_CONTENT: + return 1; + case XUIGROUP_DESIGN_W: + setDesignWidth(WTOI(strvalue)); + return 1; + case XUIGROUP_DESIGN_H: + setDesignHeight(WTOI(strvalue)); + return 1; + } + } + return GROUP_PARENT::setXuiParam(_xuihandle, xuiid, paramname, strvalue); +} + +void Group::setDesignWidth(int w) +{ + design_w = w; + if (isPostOnInit()) + onResize(); +} + +void Group::setDesignHeight(int h) +{ + design_h = h; + if (isPostOnInit()) + onResize(); +} + +int Group::getDesignWidth() +{ + return design_w; +} + +int Group::getDesignHeight() +{ + return design_h; +} + +int Group::onPostedMove() +{ + return GROUP_PARENT::onPostedMove(); +} + +#ifdef WASABI_COMPILE_WNDMGR +void Group::beginMove() +{ + if (getGuiObject()->guiobject_getParentGroup()) + getGuiObject()->guiobject_getParentGroup()->beginMove(); +} + +void Group::beginScale() +{ + if (getGuiObject()->guiobject_getParentGroup()) + getGuiObject()->guiobject_getParentGroup()->beginScale(); +} + +void Group::beginResize() +{ + if (getGuiObject()->guiobject_getParentGroup()) + getGuiObject()->guiobject_getParentGroup()->beginResize(); +} + +void Group::endMove() +{ + if (getGuiObject()->guiobject_getParentGroup()) + getGuiObject()->guiobject_getParentGroup()->endMove(); +} + +void Group::endScale() +{ + if (getGuiObject()->guiobject_getParentGroup()) + getGuiObject()->guiobject_getParentGroup()->endScale(); +} + +void Group::endResize() +{ + if (getGuiObject()->guiobject_getParentGroup()) + getGuiObject()->guiobject_getParentGroup()->endResize(); +} +#endif + +void Group::onMinMaxEnforcerChanged() +{ + if (!isPostOnInit()) return ; + int min_x = getPreferences(MINIMUM_W); + int min_y = getPreferences(MINIMUM_H); + int max_x = getPreferences(MAXIMUM_W); + int max_y = getPreferences(MAXIMUM_H); + int sug_x = getPreferences(SUGGESTED_W); + int sug_y = getPreferences(SUGGESTED_H); + min_x = MAX(RESIZE_MINW, min_x); + min_y = MAX(RESIZE_MINH, min_y); + + RECT r; + POINT pt; + getClientRect(&r); + int w = r.right - r.left; + int h = r.bottom - r.top; + getPosition(&pt); + if ((w < min_x || h < min_y || w > max_x || h > max_y) && (w != sug_x || h != sug_y)) + { + //DebugString("reapplying minmax constraints\n"); + resize(pt.x, pt.y, sug_x, sug_y); + } +} + +#ifdef WASABI_COMPILE_WNDMGR +void Group::mouseResize(int x, int y, int resizeway) +{ // screen coords! + + int min_x = getPreferences(MINIMUM_W); + int min_y = getPreferences(MINIMUM_H); + int max_x = getPreferences(MAXIMUM_W); + int max_y = getPreferences(MAXIMUM_H); + int sug_x = getPreferences(SUGGESTED_W); + int sug_y = getPreferences(SUGGESTED_H); + + if (max_x != AUTOWH && min_x != AUTOWH && max_x < min_x) max_x = min_x; + if (max_y != AUTOWH && min_y != AUTOWH && max_y < min_y) max_y = min_y; + if (min_x != AUTOWH && max_x != AUTOWH && min_x > max_x) min_x = max_x; + if (min_y != AUTOWH && max_y != AUTOWH && min_y > max_y) min_y = max_y; + if (sug_x != AUTOWH && min_x != AUTOWH && sug_x < min_x) sug_x = min_x; + if (sug_y != AUTOWH && min_y != AUTOWH && sug_y < min_y) sug_y = min_y; + if (sug_x != AUTOWH && max_x != AUTOWH && sug_x > max_x) sug_x = max_x; + if (sug_y != AUTOWH && max_y != AUTOWH && sug_y > max_y) sug_y = max_y; + + beginResize(); + + int mask = 0; + if (resizeway & RESIZE_BOTTOM) + { + mask |= BOTTOM; + } + if (resizeway & RESIZE_RIGHT) + { + mask |= RIGHT; + } + if (resizeway & RESIZE_TOP) + { + mask |= TOP; + } + if (resizeway & RESIZE_LEFT) + { + mask |= LEFT; + } + + min_x = MAX(RESIZE_MINW, min_x); + min_y = MAX(RESIZE_MINH, min_y); + + if (renderRatioActive()) + { + if (min_x != AUTOWH) multRatio(&min_x); + if (min_y != AUTOWH) multRatio(NULL, &min_y); + if (max_x != AUTOWH) multRatio(&max_x); + if (max_y != AUTOWH) multRatio(NULL, &max_y); + if (sug_x != AUTOWH) multRatio(&sug_x); + if (sug_y != AUTOWH) multRatio(NULL, &sug_y); + } + + if (min_x == AUTOWH) min_x = -1; + if (max_x == AUTOWH) max_x = -1; + if (min_y == AUTOWH) min_y = -1; + if (max_y == AUTOWH) max_y = -1; + if (sug_x == AUTOWH) sug_x = -1; + if (sug_y == AUTOWH) sug_y = -1; + + resizeClass rsize(this, min_x, min_y, max_x, max_y, sug_x, sug_y); + if (rsize.resizeWindow(this, mask | NOINTERSECT)) + { + RECT r = rsize.getRect(); + + if (renderRatioActive()) + { + r.right = (int)(((double)(r.right - r.left) / getRenderRatio()) + r.left + 0.5f); + r.bottom = (int)(((double)(r.bottom - r.top) / getRenderRatio()) + r.top + 0.5f); + } + + int _min_x = getPreferences(MINIMUM_W); + int _min_y = getPreferences(MINIMUM_H); + int _max_x = getPreferences(MAXIMUM_W); + int _max_y = getPreferences(MAXIMUM_H); + + if (_max_x != AUTOWH && _min_x != AUTOWH && _max_x < _min_x) _max_x = _min_x; + if (_max_y != AUTOWH && _min_y != AUTOWH && _max_y < _min_y) _max_y = _min_y; + if (_min_x != AUTOWH && _max_x != AUTOWH && _min_x > _max_x) _min_x = _max_x; + if (_min_y != AUTOWH && _max_y != AUTOWH && _min_y > _max_y) _min_y = _max_y; + + if (r.right - r.left < _min_x) r.right = r.left + _min_x; + if (r.bottom - r.top < _min_y) r.bottom = r.top + _min_y; + if (r.right - r.left > _max_x) r.right = r.left + _max_x; + if (r.bottom - r.top > _max_y) r.bottom = r.top + _max_y; + + resizeToRect(&r); + invalidate(); + endResize(); + } +} +#endif + +void Group::setAutoWidthSource(const wchar_t *obj) +{ + autowidthsource = obj; +} + +void Group::setAutoHeightSource(const wchar_t *obj) +{ + autoheightsource = obj; +} + +int Group::getAutoWidth() +{ + return default_w == AUTOWH ? GROUP_PARENT::getPreferences(SUGGESTED_W) : default_w; +} + +int Group::getAutoHeight() +{ + return default_h == AUTOWH ? GROUP_PARENT::getPreferences(SUGGESTED_H) : default_h; +} + +int Group::getWidthBasedOn(GuiObject *o) +{ + if (o == NULL) + { + if (lastwidthsource == NULL) + { + if (!autowidthsource.isempty()) + { + lastwidthsource = getObject(autowidthsource); + } + } + o = lastwidthsource; + } + if (o == NULL) return AUTOWH; + if (lastgetwidthbasedon != AUTOWH) return lastgetwidthbasedon; + int x, rx, w, rw; + o->guiobject_getGuiPosition(&x, NULL, &w, NULL, &rx, NULL, &rw, NULL); + int p = o->guiobject_getAutoWidth(); +if (w == AUTOWH) { w = p; rw = 0; } + if (rx == 0 && rw == 1) + lastgetwidthbasedon = p - w; + else if (rx == 0 && rw == 0) + lastgetwidthbasedon = p + x; + else + lastgetwidthbasedon = AUTOWH; + + return lastgetwidthbasedon; +} + +int Group::getHeightBasedOn(GuiObject *o) +{ + if (o == NULL) + { + if (lastheightsource == NULL) + { + if (!autoheightsource.isempty()) + { + lastheightsource = getObject(autoheightsource); + } + } + o = lastheightsource; + } + if (o == NULL) return AUTOWH; + if (lastgetheightbasedon != AUTOWH) return lastgetheightbasedon; + int y, ry, h, rh; + o->guiobject_getGuiPosition(NULL, &y, NULL, &h, NULL, &ry, NULL, &rh); + int p = o->guiobject_getAutoHeight(); +if (h == AUTOWH) { h = p; rh = 0; } + if (ry == 0 && rh == 1) + lastgetheightbasedon = p - h; + else if (ry == 0 && rh == 0) + lastgetheightbasedon = h + y; + else + lastgetheightbasedon = AUTOWH; + + return lastgetheightbasedon; +} + +int Group::getPreferences(int what) +{ + int _what = what; + if (lockminmax) + { + if (_what == MAXIMUM_W || _what == MINIMUM_W) + _what = SUGGESTED_W; + if (_what == MAXIMUM_H || _what == MINIMUM_H) + _what = SUGGESTED_H; + } + switch (_what) + { + case SUGGESTED_W: + { + int w, rw; + getGuiObject()->guiobject_getGuiPosition(NULL, NULL, &w, NULL, NULL, NULL, &rw, NULL); + + if (w == AUTOWH) + w = getWidthBasedOn(); + + if (w == AUTOWH || rw == 1) + w = getAutoWidth(); + + if (w == AUTOWH && getBaseTexture()) + w = getBaseTexture()->getWidth(); + + if (groupmaxwidth != AUTOWH) + { + if (groupminwidth != AUTOWH) + { + return MIN(groupmaxwidth, MAX(groupminwidth, w)); + } + else + { + return MIN(groupmaxwidth, w); + } + } + else if (groupminwidth != AUTOWH) + { + return MAX(groupminwidth, w); + } + return w; + } + case SUGGESTED_H: + { + int h, rh; + getGuiObject()->guiobject_getGuiPosition(NULL, NULL, NULL, &h, NULL, NULL, NULL, &rh); + + if (h == AUTOWH) + h = getHeightBasedOn(); + + if (h == AUTOWH || rh == 1) + h = getAutoHeight(); + + if (h == AUTOWH && getBaseTexture()) + h = getBaseTexture()->getHeight(); + + if (groupmaxheight != AUTOWH) + { + if (groupminheight != AUTOWH) + { + return MIN(groupmaxheight, MAX(groupminheight, h)); + } + else + { + return MIN(groupmaxheight, h); + } + } + else if (groupminheight != AUTOWH) + { + return MAX(groupminheight, h); + } + return h; + } + case MAXIMUM_H: + { + int h = GROUP_PARENT::getPreferences(what); + + if (h != AUTOWH) + return MIN(h, groupmaxheight); + + return groupmaxheight; + } + case MAXIMUM_W: + { + int w = GROUP_PARENT::getPreferences(what); + + if (w != AUTOWH) + return MIN(w, groupmaxwidth); + + return groupmaxwidth; + } + case MINIMUM_H: + { + int h = GROUP_PARENT::getPreferences(what); + + if (h != AUTOWH) + return MAX(h, groupminheight); + + return groupminheight; + } + case MINIMUM_W: + { + int w = GROUP_PARENT::getPreferences(what); + + if (w != AUTOWH) + return MAX(w, groupminwidth); + + return groupminwidth; + } + } + return GROUP_PARENT::getPreferences(what); +} + +void Group::updatePos(GuiObject *o, RECT *r2) +{ + + if (disable_update_pos) return ; + + RECT r; + if (r2 == NULL) + { + getClientRect(&r); + r2 = &r; + } + + + double d = getRenderRatio(); + int w, h; + int ox, oy, ow, oh, orx, ory, orw, orh; + int ox1, ox2, oy1, oy2, oanchor; + + if (o->guiobject_getAnchoragePosition(&ox1, &oy1, &ox2, &oy2, &oanchor)) + { + // anchorage values have not been translated into native values yet, do it now + int x, y, w, h, rx, ry, rw, rh; + x = y = w = h = rx = ry = rw = rh = AUTOWH; + int lw = ox2 - ox1; + int lh = oy2 - oy1; + int iw = getDesignWidth(); + int ih = getDesignHeight(); + if (iw == AUTOWH || ih == AUTOWH) + { + Wasabi::Std::messageBox(L"anchor coordinate system used without design size for the parent group.\nYour parent group needs the design_w/design_h parameters if you are using x1/y1/x2/y2/anchor parameters on one of its children\nDefaulting to 320x200", L"XML Error", 0); + iw = 320; + ih = 200; + } + int right_m = iw - ox2; + int bottom_m = ih - oy2; + + if ((oanchor & ANCHOR_LEFT) == 0 && (oanchor & ANCHOR_RIGHT) == 0) oanchor |= ANCHOR_LEFT; + if ((oanchor & ANCHOR_TOP) == 0 && (oanchor & ANCHOR_BOTTOM) == 0) oanchor |= ANCHOR_TOP; + + if (oanchor & ANCHOR_LEFT) + { + x = ox1; + rx = 0; + if (oanchor & ANCHOR_RIGHT) + { + w = -((iw - ox2) + ox1); + rw = 1; + } + else + { + w = lw; + rw = 0; + } + } + else + { + if (oanchor & ANCHOR_RIGHT) + { + x = -(right_m + lw); + rx = 1; + w = lw; + rw = 0; + } + } + if (oanchor & ANCHOR_TOP) + { + y = oy1; + ry = 0; + if (oanchor & ANCHOR_BOTTOM) + { + h = -((ih - oy2) + oy1); + rh = 1; + } + else + { + h = lh; + rh = 0; + } + } + else + { + if (oanchor & ANCHOR_BOTTOM) + { + y = -(bottom_m + lh); + ry = 1; + h = lh; + rh = 0; + } + } + disable_update_pos = 1; + o->guiobject_setGuiPosition(&x, &y, &w, &h, &rx, &ry, &rw, &rh); + o->guiobject_validateAnchorage(); + disable_update_pos = 0; + } + + o->guiobject_getGuiPosition(&ox, &oy, &ow, &oh, &orx, &ory, &orw, &orh); + if (ow == AUTOWH) { ow = o->guiobject_getAutoWidth(); orw = 0; } + if (oh == AUTOWH) { oh = o->guiobject_getAutoHeight(); orh = 0; } + + TextInfoCanvas fontInfoCanvas(this); + double fontScale = fontInfoCanvas.getSystemFontScale(); + if (o->guiobject_getAutoSysMetricsX()) + ox = (int)((float)ox * fontScale); + + if (o->guiobject_getAutoSysMetricsY()) + oy = (int)((float)oy * fontScale); + + if (o->guiobject_getAutoSysMetricsW()) + ow = (int)((float)ow * fontScale); + + if (o->guiobject_getAutoSysMetricsH()) + oh = (int)((float)oh * fontScale); + + if (!o->guiobject_getRootWnd()->handleRatio()) + { + if (orw == 1) + w = (int)((float)(r2->right - r2->left + ow) * d); + else if (orw == 2) + w = (int)(((float)(r2->right - r2->left) * ((float)ow / 100.0f)) * d); + else + w = (int)((float)(ow) * d); + if (orh == 1) + h = (int)((float)(r2->bottom - r2->top + oh) * d); + else if (orh == 2) + h = (int)(((float)(r2->bottom - r2->top) * ((float)oh / 100.0f)) * d); + else + h = (int)((float)(oh) * d); + if (orx == 1) + x = (int)((float)(r2->right - r2->left + ox) * d); + else if (orx == 2) + x = (int)(((float)(r2->right - r2->left) * ((float)ox / 100.0f)) * d); + else + x = (int)((float)(ox) * d); + if (ory == 1) + y = (int)((float)(r2->bottom - r2->top + oy) * d); + else if (ory == 2) + y = (int)(((float)(r2->bottom - r2->top) * ((float)oy / 100.0f)) * d); + else + y = (int)((float)(oy) * d); + x += (int)((float)(r2->left) * d); + y += (int)((float)(r2->top) * d); + } + else + { + if (orw == 1) + w = r2->right - r2->left + ow; + else if (orw == 2) + w = (int)((float)(r2->right - r2->left) * ((float)ow / 100.0f)); + else + w = ow; + if (orh == 1) + h = r2->bottom - r2->top + oh; + else if (orh == 2) + h = (int)((float)(r2->bottom - r2->top) * ((float)oh / 100.0f)); + else + h = oh; + if (orx == 1) + x = r2->right - r2->left + ox; + else if (orx == 2) + x = (int)((float)(r2->right - r2->left) * ((float)ox / 100.0f)); + else + x = ox; + if (ory == 1) + y = r2->bottom - r2->top + oy; + else if (ory == 2) + y = (int)((float)(r2->bottom - r2->top) * ((float)oy / 100.0f)); + else + y = oy; + x += r2->left; + y += r2->top; + } + + o->guiobject_getRootWnd()->resize(x, y, w, h); +} + + +int Group::onResize() +{ + GROUP_PARENT::onResize(); + if (!isInited()) return 1; + + RECT wr; + getWindowRect(&wr); + RECT r2; + getClientRect(&r2); + size_w = r2.right - r2.left; size_h = r2.bottom - r2.top; + for (int i = 0;i < gui_objects.getNumItems();i++) + { + GuiObject *o = gui_objects.enumItem(i); + updatePos(o, &r2); + } + invalidateScaledReg(); + return 1; +} + +void Group::invalidateScaledReg() +{ + scaledregionvalid = 0; + invalidateWindowRegion(); +} + +int Group::onInit() +{ + GROUP_PARENT::onInit(); + + WASABI_API_SYSCB->syscb_registerCallback(static_cast<WndCallbackI*>(this)); + + disable_update_pos = 1; + no_init_on_addchild = 1; + + const wchar_t *id = getGroupContentId(); + SkinItem *item = getGroupContentSkinItem(); + if ((id && *id) || item != NULL) + { + SkinParser::fillGroup(this, id, item, 0, 1, scripts_enabled); + } + + disable_update_pos = 0; + no_init_on_addchild = 0; + + onFillGroup(); + + return 1; +} + +void Group::onFillGroup() +{ + reloadDefaults(); + if (xui_embedded_id.len() > 0) + embeddedxui_onNewEmbeddedContent(); +} + +int Group::onGroupChange(const wchar_t *id) +{ + GROUP_PARENT::onGroupChange(id); + + if (!isInited()) return 1; + const wchar_t *cid = getGroupContentId(); + SkinItem *item = getGroupContentSkinItem(); + if (!(cid && *cid) || item != NULL) return 1; + + if (!WCSICMP(id, cid)) return 1; + + deleteScripts(); + + WASABI_API_WND->skin_unregisterBaseTextureWindow(this); + while (gui_objects.getNumItems() > 0) + { + SkinParser::destroyGuiObject(gui_objects.enumItem(0)); + } + + delete background; background = NULL; + delete reg; reg = NULL; + delete scaledreg; scaledreg = NULL; + + disable_update_pos = 1; + no_init_on_addchild = 1; + + SkinParser::fillGroup(this, cid, item, 0, 1, scripts_enabled); + + disable_update_pos = 0; + no_init_on_addchild = 0; + + onFillGroup(); + if (isInited()) + onResize(); + + getGuiObject()->guiobject_onStartup(); + + return 1; +} + +void Group::reloadDefaults() +{ + getGuiObject()->guiobject_getGuiPosition(NULL, NULL, &size_w, &size_h, NULL, NULL, NULL, NULL); + if (size_w == AUTOWH && size_h == AUTOWH) + { + /* if (!background) { + size_w = 250; + size_h = 100; + } else { + size_w = background->getWidth(); + size_h = background->getHeight(); + }*/ + if (background) + { + setPreferences(SUGGESTED_W, background->getWidth()); + setPreferences(SUGGESTED_H, background->getHeight()); + } + size_w = GROUP_PARENT::getPreferences(SUGGESTED_W); + size_h = GROUP_PARENT::getPreferences(SUGGESTED_H); + } + //setName(getGuiObject()->guiobject_getId()); + + if (propagatesize) + { + Layout *l = getGuiObject()->guiobject_getParentLayout(); + if (l) l->addMinMaxEnforcer(this); + } + + int i; + for (i = 0;i < gui_objects.getNumItems();i++) + { + + GuiObject *o = gui_objects.enumItem(i); + + if (o->guiobject_getParentGroup()) + { + o->guiobject_getRootWnd()->setParent(o->guiobject_getParentGroup()); + if (!o->guiobject_getRootWnd()->isInited()) + { + o->guiobject_getRootWnd()->init(o->guiobject_getParentGroup()); + o->guiobject_getParentGroup()->onCreateObject(getGuiObject()); + } + } + } + + /* if (getGuiObject()->guiobject_getParentGroup() && regionop) + getGuiObject()->guiobject_getParentGroup()->addSubRegionGroup(this);*/ + + invalidateWindowRegion(); + + startScripts(); + + for (i = 0;i < gui_objects.getNumItems();i++) + { + GuiObject *o = gui_objects.enumItem(i); + o->guiobject_onStartup(); + } + + autoResize(); + + const wchar_t *name = getName(); + if (name != NULL) + onSetName(); +} + +void Group::startScripts() +{ + for (int i = 0;i < getNumScripts();i++) + { + int vcpuid = enumScript(i); + SystemObject *o = SOM::getSystemObjectByScriptId(vcpuid); + if (o != NULL) + { + o->onLoad(); + foreach(xuiparams) + XuiParam *p = xuiparams.getfor(); + o->onSetXuiParam(p->param, p->value); + endfor; + } + } +} + +int Group::onPaint(Canvas *canvas) +{ + PaintCanvas paintcanvas; + if (canvas == NULL) + { + if (!paintcanvas.beginPaint(this)) return 0; + canvas = &paintcanvas; + } + GROUP_PARENT::onPaint(canvas); + RECT r; + if (!canvas->getClipBox(&r)) + getClientRect(&r); + + + if (getDrawBackground()) RenderBaseTexture(canvas, r); + return 1; +} + +ifc_window *Group::getBaseTextureWindow() +{ + if (reg && !reg->isEmpty()) return this; + if (getParent()) return getParent()->getBaseTextureWindow(); + return this; +} + +void Group::autoResize() +{ + int w = getWidthBasedOn(); + int h = getHeightBasedOn(); + if (h == AUTOWH && w == AUTOWH) return ; + resize(NOCHANGE, NOCHANGE, w == AUTOWH ? NOCHANGE : w, h == AUTOWH ? NOCHANGE : h); +} + +int Group::childNotify(ifc_window *child, int msg, intptr_t p1, intptr_t p2) +{ + if (msg == ChildNotify::AUTOWHCHANGED) + { + if (lastwidthsource && child == lastwidthsource->guiobject_getRootWnd() || + lastheightsource && child == lastheightsource->guiobject_getRootWnd()) + { + lastgetwidthbasedon = AUTOWH; + lastgetheightbasedon = AUTOWH; + autoResize(); + } + } + if (!getParent()) + return 0; + return getParent()->childNotify(child, msg, p1, p2); +} + + +void Group::sendNotifyToAllChildren(int notifymsg, intptr_t param1, intptr_t param2) +{ + for (int i = 0;i < gui_objects.getNumItems();i++) + gui_objects.enumItem(i)->guiobject_getRootWnd()->childNotify(this, notifymsg, param1, param2); +} + +void Group::addScript(int scriptid) +{ + scripts.addItem(scriptid); +} + +int Group::getNumScripts() +{ + return scripts.getNumItems(); +} + +int Group::enumScript(int n) +{ + return scripts.enumItem(n); +} + +void Group::deleteScripts() +{ + for (int i = 0;i < scripts.getNumItems();i++) + Script::unloadScript(scripts.enumItem(i)); + scripts.removeAll(); +} + +SkinBitmap *Group::getBaseTexture() +{ + if (!background) return NULL; + return background->getBitmap(); +} + +void Group::setBaseTexture(const wchar_t *b, int regis) +{ + backgroundstr = b; + if (regis) WASABI_API_WND->skin_unregisterBaseTextureWindow(this); + delete background; + background = NULL; + if (b != NULL && *b) + { + background = new AutoSkinBitmap(); + background->setBitmap(b); +#ifdef _WIN32 + RegionI r(background->getBitmap()); + setRegion(&r); +#else +#warning port me! +#endif + + if (regis) WASABI_API_WND->skin_registerBaseTextureWindow(this, b); + } + else + { + delete reg; + reg = NULL; + delete scaledreg; + scaledreg = NULL; + invalidateWindowRegion(); + } + +} + +const wchar_t *Group::getBackgroundStr() +{ + return backgroundstr; +} + +int Group::onUnknownXuiParam(const wchar_t *xmlattributename, const wchar_t *value) +{ + int r = GROUP_PARENT::onUnknownXuiParam(xmlattributename, value); + if (r == 0) + { + if (!isInited()) + { + xuiparams.addItem(new XuiParam(xmlattributename, value)); + } + else + { + for (int i = 0;i < getNumScripts();i++) + { + int vcpuid = enumScript(i); + SystemObject *o = SOM::getSystemObjectByScriptId(vcpuid); + if (o != NULL) o->onSetXuiParam(xmlattributename, value); + } + } + } + return r; +} + +api_region *Group::getRegion() +{ + ensureScaledRegValid(); + return scaledreg; +} + +void Group::ensureScaledRegValid() +{ + if (!scaledregionvalid) + { + scaledregionvalid = 1; + if (!reg) return ; + if (!scaledreg) scaledreg = new RegionI; + scaledreg->empty(); + scaledreg->addRegion(reg); + RECT rr; + getNonClientRect(&rr); + if (background) + { + float w = (float)(rr.right - rr.left) / (float)background->getWidth(); + float h = (float)(rr.bottom - rr.top) / (float)background->getHeight(); + if (w && h && (ABS(w - 1.0f) > 0.01f || ABS(h - 1.0f) > 0.01f)) + scaledreg->scale(w, h, 1); + else if (w == 0 || h == 0) + { + RECT r = {0, 0, 0, 0}; + scaledreg->setRect(&r); + } + } + } +} + +void Group::setRegion(api_region *r) +{ + ASSERT(r != NULL); + if (!reg) reg = new RegionI; + + reg->empty(); + reg->addRegion(r); // background + + invalidateWindowRegion(); + invalidateScaledReg(); +} + +Container *Group::getParentContainer() +{ + if (!getGuiObject()->guiobject_getParentGroup()) + { + ifc_window *r = getDesktopParent(); + if (r != NULL) + { + //ASSERT(r != NULL); + Layout *l = static_cast<Layout *>(r->getInterface(layoutGuid)); + if (!l) return NULL; + return l->getParentContainer(); + } + } + Group *g = getGuiObject()->guiobject_getParentGroup(); + if (g) return g->getParentContainer(); + return NULL; +} + +ifc_window *Group::enumObjects(int i) +{ + if (i >= gui_objects.getNumItems()) return NULL; + return gui_objects.enumItem(i)->guiobject_getRootWnd(); +} + +int Group::getNumObjects() +{ + return gui_objects.getNumItems(); +} + +void Group::addChild(GuiObject *g) +{ + gui_objects.addItem(g); + script_objects.addItem((ScriptObject *)g); + g->guiobject_setParentGroup(this); + g->guiobject_getRootWnd()->setParent(this); + if (!no_init_on_addchild && isInited() + && !g->guiobject_getRootWnd()->isInited()) + g->guiobject_getRootWnd()->init(this); +} + +void Group::removeChild(GuiObject *g) +{ + if (!deleting) + gui_objects.removeItem(g); + script_objects.removeItem((ScriptObject *)g); +} + +void Group::onCreateObject(GuiObject *o) +{ + script_vcpu_onCreateObject(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_OBJECT(o->guiobject_getScriptObject())); +} + +int Group::getDrawBackground() +{ + return drawbackground; +} + +void Group::setDrawBackground(int t) +{ + drawbackground = t; +} + +int Group::isLayout() +{ + return 0; +} + +int Group::isDesktopAlphaSafe() +{ + if (!Wasabi::Std::Wnd::isDesktopAlphaAvailable()) return 0; + for (int i = 0;i < getNumObjects();i++) + { + ifc_window *w = enumObjects(i); + Group *cg = static_cast<Group *>(w); + if (Group::isGroup(cg)) + if (!cg->isDesktopAlphaSafe()) return 0; + if (!w->handleDesktopAlpha()) return 0; + } + return 1; +} + +int Group::isTransparencySafe(int excludeme) +{ + if (!Wasabi::Std::Wnd::isTransparencyAvailable()) return 0; + if (!excludeme && isTransparencyForcedOff()) return 0; + for (int i = 0;i < getNumObjects();i++) + { + ifc_window *w = enumObjects(i); + Group *cg = static_cast<Group *>(w); + if (Group::isGroup(cg)) + if (!cg->isTransparencySafe()) return 0; + if (!w->handleTransparency()) return 0; + } + return 1; +} + +GuiObject *Group::getObject(const wchar_t *id) +{ + for (int i = 0;i < script_objects.getNumItems();i++) + { + if (!WCSICMP(id, gui_objects.enumItem(i)->guiobject_getId())) + { + return gui_objects.enumItem(i); + } + } + return NULL; +} + +void Group::setGroupContent(const wchar_t *id, SkinItem *item, int allowscripts) +{ + content_id = id; + content_item = item; + scripts_enabled = allowscripts; +} + +const wchar_t *Group::getGroupContentId() +{ + return content_id; +} + +SkinItem *Group::getGroupContentSkinItem() +{ + return content_item; +} + +ScriptObject *Group::script_cast(GUID g) +{ + GuiObject *o = embeddedxui_getEmbeddedObject(); + if (o != NULL) + { + void *r = o->guiobject_getScriptObject()->vcpu_getInterface(g); + if (r != NULL) + { + return o->guiobject_getScriptObject(); + } + } + return NULL; +} + +// ----------------------------------------------------------------------- + +GroupScriptController _groupController; +GroupScriptController *groupController = &_groupController; + +// -- Functions table ------------------------------------- +function_descriptor_struct GroupScriptController::exportedFunction[] = { + {L"getObject", 1, (void*)Group::script_vcpu_getObject }, + {L"enumObject", 1, (void*)Group::script_vcpu_enumObject }, + {L"getNumObjects", 0, (void*)Group::script_vcpu_getNumObjects }, + {L"onCreateObject", 1, (void*)Group::script_vcpu_onCreateObject }, + {L"getMousePosX", 0, (void*)Group::script_vcpu_getMousePosX }, + {L"getMousePosY", 0, (void*)Group::script_vcpu_getMousePosY }, + {L"isLayout", 0, (void*)Group::script_vcpu_isLayout }, + {L"autoResize", 0, (void*)Group::script_vcpu_autoResize}, + }; +// -------------------------------------------------------- + +ScriptObject *GroupScriptController::cast(ScriptObject *o, GUID g) +{ + Group *grp = static_cast<Group *>(o->vcpu_getInterface(groupGuid)); + if (grp != NULL) + return grp->script_cast(g); + return NULL; +} + +const wchar_t *GroupScriptController::getClassName() +{ + return L"Group"; +} + +const wchar_t *GroupScriptController::getAncestorClassName() +{ + return L"GuiObject"; +} + +int GroupScriptController::getInstantiable() +{ + return 1; +} + +ScriptObject *GroupScriptController::instantiate() +{ + return NULL; +} + +void GroupScriptController::destroy(ScriptObject *o) +{} + +void *GroupScriptController::encapsulate(ScriptObject *o) +{ + return NULL; +} + +void GroupScriptController::deencapsulate(void *o) +{} + +int GroupScriptController::getNumFunctions() +{ + return sizeof(exportedFunction) / sizeof(function_descriptor_struct); +} + +const function_descriptor_struct *GroupScriptController::getExportedFunctions() +{ + return exportedFunction; +} + +GUID GroupScriptController::getClassGuid() +{ + return groupGuid; +} + + +const wchar_t *Group::vcpu_getClassName() +{ + return L"Group"; +} + + +void Group::addObject(GuiObject *o) +{ + addChild(o); +} + +void Group::removeObject(GuiObject *o) +{ + removeChild(o); +} + +void Group::setRegionOp(int o) +{ + GROUP_PARENT::setRegionOp(o); + autoregionop = 0; +} + +void Group::invalidateWindowRegion() +{ + GROUP_PARENT::invalidateWindowRegion(); + if (!isInited() || isLayout()) return ; + if (autoregionop) + { + int yes = 0; + for (int i = 0;i < gui_objects.getNumItems();i++) + { + if (gui_objects.enumItem(i)->guiobject_getRegionOp() != REGIONOP_NONE) + { + yes = 1; + break; + } + } + if (yes) + GROUP_PARENT::setRegionOp(REGIONOP_OR); + else + GROUP_PARENT::setRegionOp(REGIONOP_NONE); + } +} + +// VCPU + +scriptVar Group::script_vcpu_onCreateObject(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar ob) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS1(o, groupController, ob); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT1(o, ob); +} + +// Get an object from its ID +scriptVar Group::script_vcpu_getObject(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar obj) +{ + SCRIPT_FUNCTION_INIT + ASSERT(obj.type == SCRIPT_STRING); // compiler discarded + Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid)); + GuiObject *ob = NULL; + if (g) + ob = g->getObject(GET_SCRIPT_STRING(obj)); + return MAKE_SCRIPT_OBJECT(ob ? ob->guiobject_getScriptObject() : NULL); +} + +scriptVar Group::script_vcpu_getMousePosX(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid)); + if (g) + { + POINT pt; + Wasabi::Std::getMousePos(&pt); + g->screenToClient(&pt); + return MAKE_SCRIPT_INT(pt.x); + } + RETURN_SCRIPT_ZERO; +} + +scriptVar Group::script_vcpu_getMousePosY(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid)); + if (g) + { + POINT pt; + Wasabi::Std::getMousePos(&pt); + g->screenToClient(&pt); + return MAKE_SCRIPT_INT(pt.y); + } + RETURN_SCRIPT_ZERO; +} + +scriptVar Group::script_vcpu_getNumObjects(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid)); + if (g) return MAKE_SCRIPT_INT(g->getNumObjects()); + RETURN_SCRIPT_ZERO; +} + +scriptVar Group::script_vcpu_enumObject(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar i) +{ + SCRIPT_FUNCTION_INIT + Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid)); + GuiObject *obj = NULL; + if (g) + obj = g->gui_objects.enumItem(GET_SCRIPT_INT(i)); + return MAKE_SCRIPT_OBJECT(obj ? obj->guiobject_getScriptObject() : NULL); +} + +scriptVar Group::script_vcpu_isLayout(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid)); + return MAKE_SCRIPT_BOOLEAN(g ? g->isLayout() : NULL); +} + +scriptVar Group::script_vcpu_autoResize(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid)); + if (g != NULL) g->autoResize(); + RETURN_SCRIPT_VOID +} + +#ifdef WASABI_COMPILE_CONFIG + +int Group::isCfgGroup(Group *ptr) +{ + CfgGroup *g = static_cast<CfgGroup *>(ptr); + return cfggrouplist.haveItem(g); +} + +#endif + +PtrList<CfgGroup> Group::cfggrouplist; +PtrList<Group> Group::groups; + +// --------------------------------------------------------------- +// Config Groups + + +#ifdef WASABI_COMPILE_CONFIG + +CfgGroup::CfgGroup() +{ + getScriptObject()->vcpu_setInterface(cfgGroupGuid, (void *)static_cast<CfgGroup *>(this)); + getScriptObject()->vcpu_setClassName(L"CfgGroup"); + getScriptObject()->vcpu_setController(cfgGroupController); + cfgitem = NULL; + cfggrouplist.addItem(this); +} + +CfgGroup::~CfgGroup() +{ + if (cfgitem) viewer_delViewItem(cfgitem); + cfggrouplist.removeItem(this); +} + +const wchar_t *CfgGroup::vcpu_getClassName() +{ + return L"CfgGroup"; +} + +void CfgGroup::setAttr(CfgItem *item, const wchar_t *name) +{ + if (cfgitem) viewer_delViewItem(cfgitem); + cfgitem = item; + attrname = name; + if (cfgitem != NULL) + { + wchar_t t[256] = L""; + nsGUID::toCharW(cfgitem->getGuid(), t); + cfgguid = t; + } + if (cfgitem) viewer_addViewItem(cfgitem); + dataChanged(); +} + +int CfgGroup::viewer_onEvent(CfgItem *item, int event, intptr_t param, void *ptr, size_t ptrlen) +{ + dataChanged(); + return 1; +} + +int CfgGroup::onInit() +{ + int r = Group::onInit(); + dataChanged(); + return r; +} + +void CfgGroup::dataChanged() +{ + script_vcpu_onCfgChanged(SCRIPT_CALL, getScriptObject()); +} + +CfgItem *CfgGroup::getCfgItem() +{ + return cfgitem; +} + +const wchar_t *CfgGroup::getAttributeName() +{ + return attrname; +} + +scriptVar CfgGroup::script_vcpu_cfgGetInt(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid)); + if (cg) + { + CfgItem *i = cg->getCfgItem(); + const wchar_t *attrname = cg->getAttributeName(); + if (o != NULL && attrname != NULL) + return MAKE_SCRIPT_INT(i->getDataAsInt(attrname, 0)); + } + return MAKE_SCRIPT_INT(0); +} + +scriptVar CfgGroup::script_vcpu_cfgSetInt(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar v) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&v)); + CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid)); + if (cg) + { + CfgItem *i = cg->getCfgItem(); + const wchar_t *attrname = cg->getAttributeName(); + if (o != NULL && attrname != NULL) + { + i->setDataAsInt(attrname, GET_SCRIPT_INT(v)); + } + } + RETURN_SCRIPT_VOID; +} + +scriptVar CfgGroup::script_vcpu_cfgGetString(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid)); + if (cg) + { + CfgItem *i = cg->getCfgItem(); + const wchar_t *a = cg->getAttributeName(); + *txt = 0; + if (!i || !a) + return MAKE_SCRIPT_STRING(txt); + if (o != NULL && a != NULL) + { + i->getData(a, txt, 512); + } + return MAKE_SCRIPT_STRING(txt); + } + return MAKE_SCRIPT_STRING(L""); +} + +scriptVar CfgGroup::script_vcpu_cfgSetString(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar v) +{ + SCRIPT_FUNCTION_INIT + ASSERT(!SOM::isNumeric(&v)); + CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid)); + if (cg) + { + CfgItem *i = cg->getCfgItem(); + const wchar_t *a = cg->getAttributeName(); + if (!i || !a) RETURN_SCRIPT_VOID; + if (o != NULL && a != NULL) + { + i->setData(a, GET_SCRIPT_STRING(v)); + } + } + RETURN_SCRIPT_VOID; +} + +scriptVar CfgGroup::script_vcpu_cfgGetFloat(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid)); + if (cg) + { + CfgItem *i = cg->getCfgItem(); + const wchar_t *attrname = cg->getAttributeName(); + if (o != NULL && attrname != NULL) + return MAKE_SCRIPT_FLOAT((float)i->getDataAsFloat(attrname, 0)); + } + return MAKE_SCRIPT_FLOAT(0); +} + +scriptVar CfgGroup::script_vcpu_cfgSetFloat(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar v) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&v)); + CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid)); + if (cg) + { + CfgItem *i = cg->getCfgItem(); + const wchar_t *attrname = cg->getAttributeName(); + if (o != NULL && attrname != NULL) + { + i->setDataAsFloat(attrname, GET_SCRIPT_FLOAT(v)); + } + } + RETURN_SCRIPT_VOID; +} + +scriptVar CfgGroup::script_vcpu_cfgGetName(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid)); + + if (cg) + { + return MAKE_SCRIPT_STRING(cg->getAttributeName()); + } + return MAKE_SCRIPT_STRING(L""); +} + +scriptVar CfgGroup::script_vcpu_cfgGetGuid(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + CfgGroup *cg = static_cast<CfgGroup *>(o->vcpu_getInterface(cfgGroupGuid)); + if (cg) + return MAKE_SCRIPT_STRING(cg->getCfgGuid()); + return MAKE_SCRIPT_STRING(L""); +} + + +scriptVar CfgGroup::script_vcpu_onCfgChanged(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS0(o, cfgGroupController); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT0(o); +} + +CfgGroupScriptController _cfgGroupController; +CfgGroupScriptController *cfgGroupController = &_cfgGroupController; + +// -- Functions table ------------------------------------- +function_descriptor_struct CfgGroupScriptController::exportedFunction[] = { + {L"cfgGetInt", 0, (void*)CfgGroup::script_vcpu_cfgGetInt }, + {L"cfgSetInt", 1, (void*)CfgGroup::script_vcpu_cfgSetInt }, + {L"cfgGetFloat", 0, (void*)CfgGroup::script_vcpu_cfgGetFloat }, + {L"cfgSetFloat", 1, (void*)CfgGroup::script_vcpu_cfgSetFloat }, + {L"cfgGetString", 0, (void*)CfgGroup::script_vcpu_cfgGetString }, + {L"cfgSetString", 1, (void*)CfgGroup::script_vcpu_cfgSetString }, + {L"onCfgChanged", 0, (void*)CfgGroup::script_vcpu_onCfgChanged }, + {L"cfgGetName", 0, (void*)CfgGroup::script_vcpu_cfgGetName }, + {L"cfgGetGuid", 0, (void*)CfgGroup::script_vcpu_cfgGetGuid}, + }; + +/*SET_HIERARCHY(Group, SCRIPT_LAYOUT); +SET_HIERARCHY2(Group, SCRIPT_LAYOUT, LAYOUT_SCRIPTPARENT);*/ + +const wchar_t *CfgGroupScriptController::getClassName() +{ + return L"CfgGroup"; +} + +const wchar_t *CfgGroupScriptController::getAncestorClassName() +{ + return L"Group"; +} + +int CfgGroupScriptController::getInstantiable() +{ + return 1; +} + +ScriptObject *CfgGroupScriptController::instantiate() +{ + return NULL; +} + +int CfgGroupScriptController::getNumFunctions() +{ + return sizeof(exportedFunction) / sizeof(function_descriptor_struct); +} + +const function_descriptor_struct *CfgGroupScriptController::getExportedFunctions() +{ + return exportedFunction; +} + +GUID CfgGroupScriptController::getClassGuid() +{ + return cfgGroupGuid; +} + +wchar_t CfgGroup::txt[512] = L""; + +#endif // config |