diff options
Diffstat (limited to 'Src/Wasabi/api/skin/widgets/layer.cpp')
| -rw-r--r-- | Src/Wasabi/api/skin/widgets/layer.cpp | 1727 |
1 files changed, 1727 insertions, 0 deletions
diff --git a/Src/Wasabi/api/skin/widgets/layer.cpp b/Src/Wasabi/api/skin/widgets/layer.cpp new file mode 100644 index 00000000..1a119563 --- /dev/null +++ b/Src/Wasabi/api/skin/widgets/layer.cpp @@ -0,0 +1,1727 @@ +#include <precomp.h> +#include "layer.h" +#include <api/wndmgr/resize.h> +#include <api/wnd/cwndtrack.h> +#ifdef WASABI_COMPILE_WNDMGR +#include <api/wndmgr/layout.h> +#include <api/wac/compon.h> +#endif +#ifdef WASABI_COMPILE_COMPONENTS +#include <api/script/objects/compoobj.h> +#endif +#include <api/skin/skinparse.h> +#if defined(WA3COMPATIBILITY) || defined(GEN_FF) +#include <api/skin/widgets/fx_dmove.h> +#endif +#include <api/script/objects/sregion.h> + +#include <api/script/script.h> +#include <api/script/scriptmgr.h> +#include <api/service/svcs/svc_action.h> +#include <api/script/vcpu.h> +#include <api/wnd/notifmsg.h> +#include <tataki/canvas/bltcanvas.h> +#include <api/wnd/PaintCanvas.h> + +#define SNAP_X 1 +#define SNAP_Y 1 +#define FX_TIMER 0x0A1C + +const wchar_t layerXuiObjectStr[] = L"Layer"; // This is the xml tag +char layerXuiSvcName[] = "Layer xui object"; // this is the name of the xuiservice + +XMLParamPair Layer::params[] = + { + {LAYER_SETMYCURSOR, L"CURSOR"}, + {LAYER_SETDBLCLICKACTION, L"DBLCLICKACTION"}, + {LAYER_DBLCLICKPARAM, L"DBLCLICKPARAM"}, + {LAYER_SETIMAGE, L"IMAGE"}, + {LAYER_SETINACTIVEIMAGE, L"INACTIVEIMAGE"}, + {LAYER_SETQUALITY, L"QUALITY"}, + {LAYER_SETREGION, L"REGION"}, + {LAYER_SETRESIZE, L"RESIZE"}, + {LAYER_SETSCALE, L"SCALE"}, + {LAYER_SETTILE, L"TILE"}, + + }; + +Layer::Layer() + : resizer(0), resizeway(0), scaler(0), scalerway(0), scaling(0), + rgn(NULL), secrgn(NULL), rgnclone(NULL), fx_wrap(0), fx_rect(0), + fx_dmove(NULL) +{ + getScriptObject()->vcpu_setInterface(layerGuid, (void *)static_cast<Layer *>(this)); + getScriptObject()->vcpu_setClassName(L"Layer"); + getScriptObject()->vcpu_setController(layerController); + resizerect = 1; + tiling = 0; + l_customcursor = false; + hasInactiveImage = 0; + fx_on = 0; + fx_bgfx = 0; + fx_grid_x = 16; + fx_grid_y = 16; + fx_bilinear = 1; + fx_alphamode = 0; + fx_delay = 35; + fx_timeron = 0; + fx_clear = 1; + fx_local = 1; + fx_realtime = 0; + last_w = last_h = -1; + getGuiObject()->guiobject_setMover(1); + setRectRgn(1); + xuihandle = newXuiHandle(); +CreateXMLParameters(xuihandle); + +} + +void Layer::CreateXMLParameters(int master_handle) +{ + //LAYER_PARENT::CreateXMLParameters(master_handle); + int numParams = sizeof(params) / sizeof(params[0]); + hintNumberOfParams(xuihandle, numParams); + for (int i = 0;i < numParams;i++) + addParam(xuihandle, params[i], XUI_ATTRIBUTE_IMPLIED); +} + +Layer::~Layer() +{ + WASABI_API_SYSCB->syscb_deregisterCallback(static_cast<SkinCallbackI*>(this)); + delete rgnclone; + delete rgn; + delete secrgn; + delete fx_dmove; +} + +int Layer::onInit() +{ + LAYER_PARENT::onInit(); + WASABI_API_SYSCB->syscb_registerCallback(static_cast<SkinCallbackI*>(this)); + return 1; +} + + +int Layer::onPaint(Canvas *canvas) +{ + PaintCanvas paintcanvas; + if (canvas == NULL) + { + if (!paintcanvas.beginPaint(this)) return 0; + canvas = &paintcanvas; + } + LAYER_PARENT::onPaint(canvas); + + if (!getBitmap()) return 0; + + int talpha = getPaintingAlpha(); + + RegionI *orig = NULL; + + if (secrgn) + { + orig = new RegionI(canvas); + api_region *clone = orig->clone(); + api_region *secclone = secrgn->clone(); + RECT dr; + getClientRect(&dr); + secclone->offset(dr.left, dr.top); + clone->andRegion(secclone); + canvas->selectClipRgn(clone); + orig->disposeClone(clone); + secrgn->disposeClone(secclone); + } + + RECT r, srcR, cb, cr; + getClientRect(&srcR); + r = cr = srcR; + + if (canvas->getClipBox(&cb)) + { + r.left = MAX(r.left, cb.left); + r.top = MAX(r.top, cb.top); + r.right = MIN(r.right, cb.right); + r.bottom = MIN(r.bottom, cb.bottom); + srcR = r; + } + + layer_adjustDest(&cr); + layer_adjustDest(&r); + + +#if defined(WA3COMPATIBILITY) || defined(GEN_FF) + int bmw = getBitmap()->getWidth(); + int bmh = getBitmap()->getHeight(); + int bmpitch = getBitmap()->getFullWidth(); + int *bmbits = (int*)getBitmap()->getBits(); + + if (bmbits) bmbits += getBitmap()->getX() + getBitmap()->getY() * bmpitch; +#endif + + if (getWidth() == (cr.right - cr.left) && getHeight() == (cr.bottom - cr.top)) + { + int w = r.right - r.left, h = r.bottom - r.top; + srcR.top = r.top - cr.top; + srcR.left = r.left - cr.left; + srcR.top += getSourceOffsetY(); + srcR.left += getSourceOffsetX(); + srcR.bottom = srcR.top + h; + srcR.right = srcR.left + w; + // FG> NOT READY FOR OPTIMIZATION YET +#if defined(WA3COMPATIBILITY) || defined(GEN_FF) + if (fx_on && fx_dmove && bmbits) + { + + if (fx_bgfx) + { + if (!fx_dmove->getBltCanvas() || !fx_dmove->getBltCanvas()->getBits()) + fx_dmove->render(this, getWidth(), getHeight(), bmbits, bmw, bmh, bmpitch); + + int w, h, p, *bits = (int*)canvas->getBits(); + if (bits && !canvas->getDim(&w, &h, &p) && + cr.left + getWidth() < w && cr.top + getHeight() < h && cr.left >= 0 && cr.top >= 0) + { + fx_dmove->render(this, getWidth(), getHeight(), bits + cr.left + cr.top*w, getWidth(), getHeight(), w); + } + else + { + BltCanvas c(getWidth(), getHeight()); + canvas->blit(cr.left, cr.top, &c, 0, 0, getWidth(), getHeight()); + fx_dmove->render(this, getWidth(), getHeight(), (int *)c.getBits(), + getWidth(), getHeight(), getWidth()); + } + if (fx_dmove->getBltCanvas()) + fx_dmove->getBltCanvas()->blit(0, 0, canvas, cr.left, cr.top, getWidth(), getHeight()); + + } + else + { // no bgfx + if (fx_getClear() && fx_dmove->getBltCanvas() && fx_dmove->getBltCanvas()->getBits()) + fx_dmove->getBltCanvas()->fillBits(0); + fx_dmove->render(this, getWidth(), getHeight(), bmbits, bmw, bmh, bmpitch); + //SkinBitmap *b = NULL; + if (fx_dmove->getBltCanvas()) + { + fx_dmove->getBltCanvas()->stretchToRectAlpha(canvas, &srcR, &r, talpha); +// b = fx_dmove->getBltCanvas()->getSkinBitmap(); +// if (b) +// b->stretchToRectAlpha(canvas, &srcR, &r, talpha); + } + } + } + else +#endif + getBitmap()->stretchToRectAlpha(canvas, &srcR, &r, talpha); + } + else + { + if (r.right == r.left || r.bottom == r.top) + { + if (orig) + { + canvas->selectClipRgn(orig); + delete orig; orig = 0; + } + return 0; + } + + srcR.top = getSourceOffsetY(); + srcR.left = getSourceOffsetX(); + srcR.bottom = srcR.top + getHeight(); + srcR.right = srcR.left + getWidth(); + + if (!tiling) + { + +#if defined(WA3COMPATIBILITY) || defined(GEN_FF) + if (fx_on && fx_dmove && bmbits) + { + if (fx_bgfx) + { + if (!fx_dmove->getBltCanvas() || !fx_dmove->getBltCanvas()->getBits()) + fx_dmove->render(this, cr.right - cr.left, cr.bottom - cr.top, bmbits, bmw, bmh, bmpitch); + + int w, h, p; + if (canvas->getBits() && !canvas->getDim(&w, &h, &p) && + cr.right < w && cr.bottom < h && cr.left >= 0 && cr.top >= 0) + { + fx_dmove->render(this, cr.right - cr.left, cr.bottom - cr.top, (int *)canvas->getBits() + cr.left + cr.top*w, + cr.right - cr.left, cr.bottom - cr.top, w); + } + else + { + BltCanvas c(cr.right - cr.left, cr.bottom - cr.top); + canvas->blit(cr.left, cr.top, &c, 0, 0, cr.right - cr.left, cr.bottom - cr.top); + fx_dmove->render(this, cr.right - cr.left, cr.bottom - cr.top, (int *)c.getBits(), + cr.right - cr.left, cr.bottom - cr.top, cr.right - cr.left); + + } + + if (fx_dmove->getBltCanvas()) + fx_dmove->getBltCanvas()->blit(0, 0, canvas, cr.left, cr.top, cr.right - cr.left, cr.bottom - cr.top); + } + else + { + if (fx_getClear() && fx_dmove->getBltCanvas() && fx_dmove->getBltCanvas()->getBits()) + fx_dmove->getBltCanvas()->fillBits(0); + fx_dmove->render(this, getWidth(), getHeight(), bmbits, bmw, bmh, bmpitch); + //SkinBitmap *b = NULL; + if (fx_dmove->getBltCanvas()) + { + fx_dmove->getBltCanvas()->stretchToRectAlpha(canvas, &srcR, &cr, talpha); +// b = fx_dmove->getBltCanvas()->getSkinBitmap(); +// if (b) +// b->stretchToRectAlpha(canvas, &srcR, &cr, talpha); + + } + } + } + else +#endif + { + getBitmap()->stretchToRectAlpha(canvas, &srcR, &cr, talpha); + } + + } + else + { + getBitmap()->blitRectToTile(canvas, &cr, &srcR, 0, 0, talpha); + } + } + + if (orig) + { + canvas->selectClipRgn(orig); + delete orig; orig = 0; + } + return 1; +} + +int Layer::onResize() +{ + LAYER_PARENT::onResize(); + RECT r; + getClientRect(&r); + int w = r.right - r.left; + int h = r.bottom - r.top; + if (w != last_w || h != last_h) + invalidateRegionCache(); + return 1; +} + +#pragma warning (disable : 4065) +void Layer::timerCallback(int id) +{ + switch (id) + { +#if defined(WA3COMPATIBILITY) || defined(GEN_FF) + case FX_TIMER: + fx_onFrame(); + invalidate(); + break; +#endif + + default: + LAYER_PARENT::timerCallback(id); + break; + } +} +#pragma warning (default: 4065) + +void Layer::invalidateRegionCache() +{ + delete rgnclone; + rgnclone = NULL; + invalidateWindowRegion(); +} + +int Layer::setXuiParam(int _xuihandle, int attribid, const wchar_t *paramname, const wchar_t *strvalue) +{ + if (xuihandle != _xuihandle) return LAYER_PARENT::setXuiParam(_xuihandle, attribid, paramname, strvalue); + switch (attribid) + { + case LAYER_SETIMAGE: + setBitmap(strvalue); + break; + case LAYER_SETRESIZE: + setResize(SkinParser::parseResize(strvalue)); + if (resizer) getGuiObject()->guiobject_setMover(0); + break; + case LAYER_SETSCALE: + setScaler(SkinParser::parseResize(strvalue)); + if (scaler) getGuiObject()->guiobject_setMover(0); + break; + case LAYER_SETREGION: + setRegionFromBitmap(strvalue); + break; + case LAYER_SETTILE: + setTiling(WTOI(strvalue)); + break; + case LAYER_SETDBLCLICKACTION: + dblClickAction = strvalue; + break; + case LAYER_DBLCLICKPARAM: + setDblClickParam(strvalue); + break; + case LAYER_SETINACTIVEIMAGE: + setInactiveBitmap(strvalue); + break; + case LAYER_SETMYCURSOR: + l_customcursor = true; + getGuiObject()->guiobject_setCursor(strvalue); + break; + case LAYER_SETQUALITY: + bitmap.setResamplingMode(WTOI(strvalue)); + break; + default: + return 0; + + } + return 1; +} + +int Layer::getPreferences(int what) +{ + if (what == SUGGESTED_W) + return getWidth(); + if (what == SUGGESTED_H) + return getHeight(); + return LAYER_PARENT::getPreferences(what); +} + +int Layer::getSourceOffsetX() +{ + return 0; +} + +int Layer::getSourceOffsetY() +{ + return 0; +} + +void Layer::setBitmap(const wchar_t *name) +{ + bitmapname = name; + bitmap = name; + deleteRegion(); + makeRegion(); + notifyParent(ChildNotify::AUTOWHCHANGED); + if (isInited()) invalidate(); +} + +void Layer::setInactiveBitmap(const wchar_t *name) +{ + inactiveImageName = name; + inactiveBitmap = name; + hasInactiveImage = 1; +} + +void Layer::setDblClickParam(const wchar_t *p) +{ + dblclickparam=p; +} + +const wchar_t *Layer::getDblClickParam() +{ + return dblclickparam; +} + +int Layer::getWidth() +{ + if (getBitmap()) return getBitmap()->getWidth(); + return 0; +} + +int Layer::getHeight() +{ + if (getBitmap()) return getBitmap()->getHeight(); + return 0; +} + +int Layer::onLeftButtonDown(int x, int y) +{ + LAYER_PARENT::onLeftButtonDown(x, y); + ifc_window *d = getDesktopParent(); + +#ifdef WASABI_COMPILE_WNDMGR + Layout *_l = NULL; + if (d != NULL) + { + _l = static_cast<Layout *>(d->getInterface(layoutGuid)); + if (_l && _l->isLocked()) return 1; + } + + int need_resize = 0, need_scale = 0, need_move = 0; + + int dock = APPBAR_NOTDOCKED; + int rw = applyResizeRestrictions(resizeway, &dock); + int sw = (dock == APPBAR_NOTDOCKED) ? scalerway : RESIZE_NONE; + + if (resizer && rw != RESIZE_NONE && (!_l || _l->getResizable())) + { + if (scaler && sw != RESIZE_NONE && Std::keyModifier(STDKEY_ALT) && (!_l || _l->getScalable())) + need_scale = 1; + else + need_resize = 1; + } + else if (scaler && sw != RESIZE_NONE && (!_l || _l->getScalable())) + { + need_scale = 1; + } + else if (getGuiObject()->guiobject_getMover()) + { + need_move = 1; + } + + Group *l = static_cast<Group *>(_l); + + if (need_move) + { + // do nothin' + } + else if (need_scale) + { + if (l) + { + l->beginScale(); + scaling = 1; + } + return 1; + } + else if (need_resize) + { + resizerect = 1; + if (l) + { + clientToScreen(&x, &y); + l->mouseResize(x, y, resizeway); + } + } +#endif + return 1; +} + +int Layer::onLeftButtonUp(int x, int y) +{ + LAYER_PARENT::onLeftButtonUp(x, y); +#ifdef WASABI_COMPILE_WNDMGR + if (scaling) + { + getGuiObject()->guiobject_getParentGroup()->endScale(); + scaling = 0; + } +#endif + return 1; +} + +void Layer::onCancelCapture() +{ + LAYER_PARENT::onCancelCapture(); + scaling = 0; +} + +int Layer::onMouseMove(int x, int y) +{ + LAYER_PARENT::onMouseMove(x, y); + POINT pos = {x, y}; + clientToScreen(&pos); + +#ifdef WASABI_COMPILE_WNDMGR + if (scaling && getCapture()) + { // todo: resizing w/no rect + if (!Std::keyDown(MK_LBUTTON)) + scaling = 0; + else + { + RECT oldRect; + RECT newRect; + ifc_window *b = getRootParent(); + b->getWindowRect(&oldRect); + newRect = oldRect; + clientToScreen(&x, &y); + int mask = 0; + if (scalerway & RESIZE_BOTTOM) + { + newRect.bottom = y - y % SNAP_Y; + mask |= BOTTOM; + } + if (scalerway & RESIZE_RIGHT) + { + newRect.right = x - x % SNAP_X; + mask |= RIGHT; + } + if (scalerway & RESIZE_TOP) + { + newRect.top = y - y % SNAP_Y; + mask |= TOP; + } + if (scalerway & RESIZE_LEFT) + { + newRect.left = x - x % SNAP_X; + mask |= LEFT; + } + + RECT dr = newRect; + WASABI_API_WNDMGR->wndTrackDock(b, &dr, &newRect, mask | NOINTERSECT); + if (dr.right - dr.left < 32) dr.right = dr.left + 32; + if (dr.bottom - dr.top < 32) dr.bottom = dr.top + 32; + if (MEMCMP(&dr, &oldRect, sizeof(RECT))) + { + RECT origRect; + b->getClientRect(&origRect); + double rx = (double)(dr.right - dr.left) / (double)(origRect.right - origRect.left); + double ry = (double)(dr.bottom - dr.top) / (double)(origRect.bottom - origRect.top); + double r = MAX(rx, ry); + if (r != 0) b->setRenderRatio(r); + } + } + } +#endif + + return 1; +} + +SkinBitmap *Layer::getBitmap() +{ + return layer_getBitmap(); +} + +SkinBitmap *Layer::layer_getBitmap() +{ + if (hasInactiveImage) + if (!isActive()) + return inactiveBitmap.getBitmap(); + return bitmap.getBitmap(); +} + +const wchar_t *Layer::layer_getBitmapName() +{ + return bitmapname; +} + +int Layer::applyResizeRestrictions(int way, int *side) +{ + ifc_window *rw = getDesktopParent(); + int dock = APPBAR_NOTDOCKED; + if (side) *side = dock; + if (rw) + { + Layout *l = (Layout *)rw->getInterface(layoutGuid); + if (l) dock = l->appbar_getSide(); + } + if (dock == APPBAR_NOTDOCKED) return way; + /* + switch (way) { + case RESIZE_TOPLEFT: + if (dock == APPBAR_TOP || dock == APPBAR_LEFT) return RESIZE_NONE; + break; + case RESIZE_BOTTOMRIGHT: + if (dock == APPBAR_RIGHT || dock == APPBAR_BOTTOM) return RESIZE_NONE; + break; + case RESIZE_TOPRIGHT: + if (dock == APPBAR_TOP || dock == APPBAR_RIGHT) return RESIZE_NONE; + break; + case RESIZE_BOTTOMLEFT: + if (dock == APPBAR_BOTTOM || dock == APPBAR_LEFT) return RESIZE_NONE; + break; + case RESIZE_TOP: + if (dock == APPBAR_TOP) return RESIZE_NONE; + break; + case RESIZE_BOTTOM: + if (dock == APPBAR_BOTTOM) return RESIZE_NONE; + break; + case RESIZE_LEFT: + if (dock == APPBAR_LEFT) return RESIZE_NONE; + break; + case RESIZE_RIGHT: + if (dock == APPBAR_RIGHT) return RESIZE_NONE; + break; + } + return way;*/ + if (dock != APPBAR_NOTDOCKED) return RESIZE_NONE; + return way; +} + +int Layer::getCursorType(int x, int y) +{ + // Return our user cursor if we have one (even when we are resizable!) + if (l_customcursor) + { + return BASEWND_CURSOR_USERSET; + } + // Then check if our layer is used to resize or scale the wnd + ifc_window *d = getDesktopParent(); + int scalable = 1; + int resizable = 1; + Layout *_l = NULL; + if (d != NULL) + { + _l = static_cast<Layout *>(d->getInterface(layoutGuid)); + if (_l) + { + scalable = _l->getScalable(); + resizable = _l->getResizable(); + } + } + + if (!_l || (!_l->isLocked() && (resizer || scaler))) + { + int dock = APPBAR_NOTDOCKED; + + int r = 0; + if (resizer && resizable) + { + if (scaler && scalable) + { + if (Std::keyModifier(STDKEY_ALT)) + { + r = applyResizeRestrictions(scalerway, &dock); + if (dock != APPBAR_NOTDOCKED) r = RESIZE_NONE; + } + else + { + r = applyResizeRestrictions(resizeway); + } + } + else + { + r = applyResizeRestrictions(resizeway); + } + } + if (scaler && scalable) + { + r = applyResizeRestrictions(scalerway, &dock); + if (dock != APPBAR_NOTDOCKED) r = RESIZE_NONE; + } + + switch (r) + { + case RESIZE_TOPLEFT: + case RESIZE_BOTTOMRIGHT: + return BASEWND_CURSOR_NORTHWEST_SOUTHEAST; + case RESIZE_TOPRIGHT: + case RESIZE_BOTTOMLEFT: + return BASEWND_CURSOR_NORTHEAST_SOUTHWEST; + break; + case RESIZE_TOP: + case RESIZE_BOTTOM: + return BASEWND_CURSOR_NORTHSOUTH; + break; + case RESIZE_LEFT: + case RESIZE_RIGHT: + return BASEWND_CURSOR_EASTWEST; + break; + } + } + // At leat we want to have a cursor so spit our the normal pointer + return BASEWND_CURSOR_POINTER; +} + +void Layer::setScaler(int r) +{ + if (r != 0) + { + scaler = 1; + scalerway = r; + } + else + { + resizer = 0; + scalerway = 0; + } +} + +void Layer::setResize(int r) +{ + if (r != 0) + { + resizer = 1; + resizeway = r; + } + else + { + resizer = 0; + resizeway = 0; + } +} + +api_region *Layer::getBitmapRegion() +{ + return rgn; +} + +api_region *Layer::getRegion() +{ + api_region *_rgn = getBitmapRegion(); + if (!_rgn) return NULL; + if (!rgnclone) + { + rgnclone = new RegionI(); + rgnclone->addRegion(_rgn); + } + else + return rgnclone; + float w, h; + RECT r; + getClientRect(&r); + if (r.right - r.left == 0 || r.bottom - r.top == 0) return NULL; + last_w = r.right - r.left; + last_h = r.bottom - r.top; + if (getWidth() == 0 || getHeight() == 0) return NULL; + w = (float)(last_w) / (float)getWidth(); + h = (float)(last_h) / (float)getHeight(); + if (!w || !h) return NULL; + if (!tiling) + { + if (w != 1.0 || h != 1.0) + { + rgnclone->scale(w, h, TRUE); + } + } + else + { + for (int j = 0;j < h;j++) + { + for (int i = 0;i < w;i++) + { + api_region *t = _rgn->clone(); + t->offset(i*getWidth(), j*getHeight()); + rgnclone->addRegion(t); + _rgn->disposeClone(t); + } + } + } + RegionI _r(&r); + _r.offset(-r.left, -r.top); + rgnclone->andRegion(&_r); + + return rgnclone; +} + +void Layer::setRegionOp(int i) +{ + int old = getRegionOp(); + LAYER_PARENT::setRegionOp(i); + if (!old && i) setRectRgn(0); +} + +void Layer::makeRegion() +{ + if (!bitmap.getBitmap()) + return; + delete rgn; + rgn = new RegionI(bitmap); + invalidateRegionCache(); +} + +void Layer::deleteRegion() +{ + if (!rgn) return; + invalidateRegionCache(); + delete rgn; + rgn = NULL; +} + +int Layer::onLeftButtonDblClk(int x, int y) +{ + // Martin> copied and adopted from textbase.cpp + //if (!dblClickAction.isempty() && !VCPU::getComplete()) + if (dblClickAction) + { +#ifdef WASABI_COMPILE_WNDMGR + const wchar_t *toCheck = L"SWITCH;"; + if (!_wcsnicmp(dblClickAction, toCheck, 7)) + { + onLeftButtonUp(x, y); + getGuiObject()->guiobject_getParentGroup()->getParentContainer()->switchToLayout(dblClickAction.getValue() + 7); + return 0; + } + else + { +#endif + svc_action *act = ActionEnum(dblClickAction).getNext(); + if (act) + { + int _x = x; + int _y = y; + clientToScreen(&_x, &_y); + act->onAction(dblClickAction, getDblClickParam(), _x, _y, NULL, 0, this); + //WASABI_API_WNDMGR->messageBox(L"on action; passed", L"debug", 0, NULL, NULL); + SvcEnum::release(act); + } +#ifdef WASABI_COMPILE_WNDMGR + + } +#endif + + } + int r = LAYER_PARENT::onLeftButtonDblClk(x, y); + return r; +} + + +void Layer::setRegionFromMap(SMap *map, int byte, int inversed) +{ + if (secrgn) + { + invalidate(); + delete secrgn; + secrgn = NULL; + } + //RECT r = {map->getBitmap()->getX(), map->getBitmap()->getY(), map->getBitmap()->getWidth(), map->getBitmap()->getHeight()}; + secrgn = new RegionI(map->getBitmap(), NULL, 0, 0, FALSE, 1, (unsigned char)byte, inversed); + if (secrgn) + invalidate(); +} + +void Layer::setRegion(SRegion *reg) +{ + invalidate(); + delete secrgn; + if (!reg) + { + secrgn = NULL; invalidate(); return; + } + secrgn = new RegionI(); + secrgn->addRegion(reg->getRegion()); + invalidate(); +} + +int Layer::wantSiblingInvalidations() +{ + return fx_on; +} + +int Layer::onSiblingInvalidateRgn(api_region *r, ifc_window *who, int who_idx, int my_idx) +{ + if (!fx_on || !fx_bgfx || who_idx >= my_idx) return 0; + RECT rr; + getClientRect(&rr); + if (rgn) + { + api_region *_r = rgn->clone(); + _r->offset(rr.left, rr.top); + if (fx_local && !_r->doesIntersectRgn(r)) + { + rgn->disposeClone(_r); + return 0; + } + if (secrgn) + { + api_region *_rs = secrgn->clone(); + _rs->offset(rr.left, rr.top); + _r->andRegion(_rs); + secrgn->disposeClone(_rs); + } + r->addRegion(_r); + rgn->disposeClone(_r); + } + else + { + RegionI _r(&rr); + if (secrgn) + { + api_region *_rs = secrgn->clone(); + _rs->offset(rr.left, rr.top); + _r.andRegion(_rs); + secrgn->disposeClone(_rs); + } + if (fx_local && !_r.doesIntersectRgn(r)) + { + return 0; + } + r->addRegion(&_r); + } + return 1; +} + +void Layer::onSetVisible(int show) +{ + LAYER_PARENT::onSetVisible(show); + getGuiObject()->guiobject_onSetVisible(show); +} + +int Layer::onActivate() +{ + invalidate(); + return 0; +} + +int Layer::onDeactivate() +{ + invalidate(); + return 0; +} + +void Layer::setTiling(int t) +{ + if (tiling == t) return; + tiling = t; + invalidate(); +} + +int Layer::getTiling() +{ + return tiling; +} + + +void Layer::onBeginResize(RECT r) +{ + scriptVar l = SOM::makeVar(SCRIPT_INT); + SOM::assign(&l, r.left); + scriptVar t = SOM::makeVar(SCRIPT_INT); + SOM::assign(&t, r.top); + scriptVar w = SOM::makeVar(SCRIPT_INT); + SOM::assign(&w, r.right - r.left); + scriptVar h = SOM::makeVar(SCRIPT_INT); + SOM::assign(&h, r.bottom - r.top); + script_vcpu_onBeginResize(SCRIPT_CALL, getScriptObject(), l, t, w, h); +} + +void Layer::onEndResize(RECT r) +{ + scriptVar l = SOM::makeVar(SCRIPT_INT); + SOM::assign(&l, r.left); + scriptVar t = SOM::makeVar(SCRIPT_INT); + SOM::assign(&t, r.top); + scriptVar w = SOM::makeVar(SCRIPT_INT); + SOM::assign(&w, r.right - r.left); + scriptVar h = SOM::makeVar(SCRIPT_INT); + SOM::assign(&h, r.bottom - r.top); + script_vcpu_onEndResize(SCRIPT_CALL, getScriptObject(), l, t, w, h); +} + +#if defined(WA3COMPATIBILITY) || defined(GEN_FF) +void Layer::fx_setEnabled(int i) +{ + static int inited = 0; + if (fx_getEnabled() == !!i) return; + fx_on = !!i; + if (fx_on) + { + if (!inited) + fx_onInit(); + fx_dmove = new FxDynamicMove; + fx_dmove->setBilinear(fx_getBilinear()); + if (fx_getAlphaMode()) + fx_dmove->setAlphaMode(1 | (fx_getBgFx() ? 2 : 0)); + else fx_setAlphaMode(0); + fx_dmove->setAlphaOnce(fx_alphaonce); + fx_dmove->setRect(fx_getRect()); + fx_dmove->setWrap(fx_getWrap()); + fx_dmove->setGridSize(fx_grid_x, fx_grid_y); + if (fx_realtime) + { + setTimer(FX_TIMER, fx_delay); + fx_timeron = 1; + } + } + else + { + if (fx_timeron) + { + killTimer(FX_TIMER); + fx_timeron = 0; + } + delete fx_dmove; + fx_dmove = NULL; + } + invalidate(); +} + +int Layer::fx_getEnabled(void) +{ + return fx_on; +} + +void Layer::fx_setWrap(int i) +{ + if (fx_getWrap() == !!i) return; + fx_wrap = !!i; + if (fx_dmove) fx_dmove->setWrap(fx_wrap); + invalidate(); +} + +int Layer::fx_getWrap(void) +{ + return fx_wrap; +} + +void Layer::fx_setRect(int i) +{ + if (fx_getRect() == !!i) return; + fx_rect = !!i; + if (fx_dmove) fx_dmove->setRect(fx_rect); + invalidate(); +} + +int Layer::fx_getRect(void) +{ + return fx_rect; +} + +int Layer::fx_getAlphaMode() +{ + if (!fx_alphamode) return 0; + if (fx_alphaonce) return 2; + return 1; +} + +void Layer::fx_setAlphaMode(int i) +{ + + if (i == 2) + { + i = 1; + fx_alphaonce = 1; + if (fx_dmove) fx_dmove->setAlphaOnce(1); + } + else + { + fx_alphaonce = 0; + if (fx_dmove) fx_dmove->setAlphaOnce(0); + } + + if (fx_getAlphaMode() == !!i) return; + fx_alphamode = !!i; + if (fx_dmove) + { + if (fx_getAlphaMode()) + fx_dmove->setAlphaMode(1 | (fx_getBgFx() ? 2 : 0)); + else + fx_dmove->setAlphaMode(0); + } + invalidate(); +} + + +int Layer::fx_getBilinear() +{ + return fx_bilinear; +} + +void Layer::fx_setBilinear(int i) +{ + if (fx_getBilinear() == !!i) return; + fx_bilinear = !!i; + if (fx_dmove) fx_dmove->setBilinear(fx_bilinear); + invalidate(); +} + +int Layer::fx_getBgFx() +{ + return fx_bgfx; +} + +void Layer::fx_setBgFx(int i) +{ + if (fx_getBgFx() == !!i) return; + fx_bgfx = !!i; + if (fx_dmove) fx_dmove->setCanCache(!i); + if (fx_dmove && fx_getAlphaMode()) + { + fx_dmove->setAlphaMode(1 | (fx_getBgFx() ? 2 : 0)); + } + invalidate(); +} + +int Layer::fx_getSpeed() +{ + return fx_delay; +} + +void Layer::fx_setSpeed(int s) +{ + if (fx_getSpeed() == s) return; + fx_delay = s; + if (fx_timeron) + { + killTimer(FX_TIMER); + fx_timeron = 0; + } + if (fx_on && fx_realtime) + { + setTimer(FX_TIMER, fx_delay); + fx_timeron = 1; + } +} + +int Layer::fx_getClear() +{ + return fx_clear; +} + +void Layer::fx_setClear(int i) +{ + if (fx_getClear() == !!i) return; + fx_clear = !!i; +} + +int Layer::fx_getRealtime() +{ + return fx_realtime; +} + +void Layer::fx_setRealtime(int i) +{ + if (fx_getRealtime() == !!i) return; + fx_realtime = !!i; +} + +int Layer::fx_getLocalized() +{ + return fx_local; +} + +void Layer::fx_setLocalized(int i) +{ + if (fx_getLocalized() == !!i) return; + fx_local = !!i; +} + +void Layer::fx_setGridSize(int x, int y) +{ + fx_grid_x = x; + fx_grid_y = y; + if (!fx_dmove) return; + fx_dmove->setGridSize(x, y); +} + +void Layer::fx_update(void) +{ + RECT r; + getClientRect(&r); + if (fx_realtime && !isMinimized()) + cascadeRepaintRect(&r); + else + invalidateRect(&r); +} + +void Layer::fx_restart(void) +{ + fx_onInit(); + if (fx_dmove && fx_dmove->getBltCanvas() && fx_dmove->getBltCanvas()->getBits()) + fx_dmove->getBltCanvas()->fillBits(0); + // todo: reset need_alpha in fx_dmove +} + +void Layer::fx_onInit(void) +{ + script_vcpu_fx_onInit(SCRIPT_CALL, getScriptObject()); +} + +void Layer::fx_onFrame(void) +{ + script_vcpu_fx_onFrame(SCRIPT_CALL, getScriptObject()); +} + +double Layer::fx_onGetPixelA(double r, double d, double x, double y) +{ + scriptVar _x = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _y = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _r = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _d = SOM::makeVar(SCRIPT_DOUBLE); + SOM::assign(&_x, x); + SOM::assign(&_y, y); + SOM::assign(&_r, r); + SOM::assign(&_d, d); + scriptVar v = script_vcpu_fx_onGetPixelA(SCRIPT_CALL, getScriptObject(), _r, _d, _x, _y); + return (v.type == 0) ? 0.5 : v.data.ddata; +} + + +double Layer::fx_onGetPixelX(double r, double d, double x, double y) +{ + scriptVar _x = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _y = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _r = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _d = SOM::makeVar(SCRIPT_DOUBLE); + SOM::assign(&_x, x); + SOM::assign(&_y, y); + SOM::assign(&_r, r); + SOM::assign(&_d, d); + scriptVar v = script_vcpu_fx_onGetPixelX(SCRIPT_CALL, getScriptObject(), _r, _d, _x, _y); + return (v.type == 0) ? x : v.data.ddata; +} + +double Layer::fx_onGetPixelY(double r, double d, double x, double y) +{ + scriptVar _x = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _y = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _r = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _d = SOM::makeVar(SCRIPT_DOUBLE); + SOM::assign(&_x, x); + SOM::assign(&_y, y); + SOM::assign(&_r, r); + SOM::assign(&_d, d); + scriptVar v = script_vcpu_fx_onGetPixelY(SCRIPT_CALL, getScriptObject(), _r, _d, _x, _y); + return (v.type == 0) ? y : v.data.ddata; +} + +double Layer::fx_onGetPixelR(double r, double d, double x, double y) +{ + scriptVar _x = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _y = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _r = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _d = SOM::makeVar(SCRIPT_DOUBLE); + SOM::assign(&_x, x); + SOM::assign(&_y, y); + SOM::assign(&_r, r); + SOM::assign(&_d, d); + scriptVar v = script_vcpu_fx_onGetPixelR(SCRIPT_CALL, getScriptObject(), _r, _d, _x, _y); + return (v.type == 0) ? r : v.data.ddata; +} + +double Layer::fx_onGetPixelD(double r, double d, double x, double y) +{ + scriptVar _x = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _y = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _r = SOM::makeVar(SCRIPT_DOUBLE); + scriptVar _d = SOM::makeVar(SCRIPT_DOUBLE); + SOM::assign(&_x, x); + SOM::assign(&_y, y); + SOM::assign(&_r, r); + SOM::assign(&_d, d); + scriptVar v = script_vcpu_fx_onGetPixelD(SCRIPT_CALL, getScriptObject(), _r, _d, _x, _y); + return (v.type == 0) ? d : v.data.ddata; +} +#endif + +int Layer::skincb_onColorThemeChanged(const wchar_t *newcolortheme) +{ + #if defined(WA3COMPATIBILITY) || defined(GEN_FF) + if (fx_getEnabled()) + { + fx_dmove->flushCache(); + fx_update(); + } +#endif + return 0; +} + +void Layer::setRegionFromBitmap(const wchar_t *bmpid) +{ + delete secrgn; + secrgn = NULL; + if (bmpid == NULL || *bmpid == '\0') + return; + bool invert = (*bmpid == '!'); + if (invert) bmpid++; + SkinBitmap b(bmpid); + secrgn = new RegionI(&b, NULL, 0, 0, invert); +} + +LayerScriptController _layerController; +LayerScriptController *layerController = &_layerController; + +// -- Functions table ------------------------------------- +function_descriptor_struct LayerScriptController::exportedFunction[] = { + {L"setRegionFromMap", 3, (void*)Layer::script_vcpu_setRegionFromMap }, + {L"setRegion", 1, (void*)Layer::script_vcpu_setRegion }, + {L"isInvalid", 0, (void*)Layer::script_vcpu_isInvalid }, +#ifdef WASABI_COMPILE_WNDMGR + {L"onBeginResize", 4, (void*)Layer::script_vcpu_onBeginResize }, + {L"onEndResize", 4, (void*)Layer::script_vcpu_onEndResize }, +#endif +#if defined(WA3COMPATIBILITY) || defined(GEN_FF) + { + L"fx_setEnabled", 1, (void*)Layer::script_vcpu_fx_setEnabled + }, + {L"fx_getEnabled", 0, (void*)Layer::script_vcpu_fx_getEnabled }, + {L"fx_onInit", 0, (void*)Layer::script_vcpu_fx_onInit }, + {L"fx_onFrame", 0, (void*)Layer::script_vcpu_fx_onFrame }, + {L"fx_onGetPixelR", 4, (void*)Layer::script_vcpu_fx_onGetPixelR }, + {L"fx_onGetPixelD", 4, (void*)Layer::script_vcpu_fx_onGetPixelD }, + {L"fx_onGetPixelX", 4, (void*)Layer::script_vcpu_fx_onGetPixelX }, + {L"fx_onGetPixelY", 4, (void*)Layer::script_vcpu_fx_onGetPixelY }, + {L"fx_onGetPixelA", 4, (void*)Layer::script_vcpu_fx_onGetPixelA }, + {L"fx_setWrap", 1, (void*)Layer::script_vcpu_fx_setWrap }, + {L"fx_getWrap", 0, (void*)Layer::script_vcpu_fx_getWrap }, + {L"fx_setRect", 1, (void*)Layer::script_vcpu_fx_setRect }, + {L"fx_getRect", 0, (void*)Layer::script_vcpu_fx_getRect }, + {L"fx_setBgFx", 1, (void*)Layer::script_vcpu_fx_setBgFx }, + {L"fx_getBgFx", 0, (void*)Layer::script_vcpu_fx_getBgFx }, + {L"fx_setClear", 1, (void*)Layer::script_vcpu_fx_setClear }, + {L"fx_getClear", 0, (void*)Layer::script_vcpu_fx_getClear }, + {L"fx_setSpeed", 1, (void*)Layer::script_vcpu_fx_setSpeed }, + {L"fx_getSpeed", 0, (void*)Layer::script_vcpu_fx_getSpeed }, + {L"fx_setRealtime", 1, (void*)Layer::script_vcpu_fx_setRealtime }, + {L"fx_getRealtime", 0, (void*)Layer::script_vcpu_fx_getRealtime }, + {L"fx_setLocalized", 1, (void*)Layer::script_vcpu_fx_setLocalized }, + {L"fx_getLocalized", 0, (void*)Layer::script_vcpu_fx_getLocalized }, + {L"fx_setBilinear", 1, (void*)Layer::script_vcpu_fx_setBilinear }, + {L"fx_getBilinear", 0, (void*)Layer::script_vcpu_fx_getBilinear }, + {L"fx_setAlphaMode", 1, (void*)Layer::script_vcpu_fx_setAlphaMode }, + {L"fx_getAlphaMode", 0, (void*)Layer::script_vcpu_fx_getAlphaMode }, + {L"fx_setGridSize", 2, (void*)Layer::script_vcpu_fx_setGridSize }, + {L"fx_update", 0, (void*)Layer::script_vcpu_fx_update }, + {L"fx_restart", 0, (void*)Layer::script_vcpu_fx_restart }, +#endif + }; +// -------------------------------------------------------- + +const wchar_t *LayerScriptController::getClassName() +{ + return L"Layer"; +} + +const wchar_t *LayerScriptController::getAncestorClassName() +{ + return L"GuiObject"; +} + +ScriptObject *LayerScriptController::instantiate() +{ + Layer *l = new Layer; + ASSERT(l != NULL); + return l->getScriptObject(); +} + +void LayerScriptController::destroy(ScriptObject *o) +{ + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + ASSERT(l != NULL); + delete l; +} + +void *LayerScriptController::encapsulate(ScriptObject *o) +{ + return NULL; // no encapsulation for layer yet +} + +void LayerScriptController::deencapsulate(void *o) +{} + +int LayerScriptController::getNumFunctions() +{ + return sizeof(exportedFunction) / sizeof(function_descriptor_struct); +} + +const function_descriptor_struct *LayerScriptController::getExportedFunctions() +{ + return exportedFunction; +} + +GUID LayerScriptController::getClassGuid() +{ + return layerGuid; +} + + +//------------------------------------------------------------------------ + +scriptVar Layer::script_vcpu_onBeginResize(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar left, scriptVar top, scriptVar width, scriptVar height) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS4(o, layerController, left, top, width, height); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT4(o, left, top, width, height); +} + +scriptVar Layer::script_vcpu_onEndResize(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar left, scriptVar top, scriptVar width, scriptVar height) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS4(o, layerController, left, top, width, height); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT4(o, left, top, width, height); +} + +scriptVar Layer::script_vcpu_setRegionFromMap(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar map, scriptVar byte, scriptVar inv) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&byte)); + ASSERT(SOM::isNumeric(&inv)); + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + SMap *m = static_cast<SMap *>(GET_SCRIPT_OBJECT_AS(map, mapGuid)); + if (l) l->setRegionFromMap(m, GET_SCRIPT_INT(byte), GET_SCRIPT_INT(inv)); + RETURN_SCRIPT_VOID; +} + +scriptVar Layer::script_vcpu_setRegion(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar reg) +{ + SCRIPT_FUNCTION_INIT + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + SRegion *r = static_cast<SRegion *>(GET_SCRIPT_OBJECT_AS(reg, regionGuid)); + if (l) l->setRegion(r); + RETURN_SCRIPT_VOID; +} + +bool Layer::layer_isInvalid() +{ + SkinBitmap *b = layer_getBitmap(); + if (b) + return !!b->isInvalid(); + else + return true; +} + +scriptVar Layer::script_vcpu_isInvalid(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) + { + return MAKE_SCRIPT_INT(l->layer_isInvalid()?1:0); + } + return MAKE_SCRIPT_INT(1); +} + + +#if defined(WA3COMPATIBILITY) || defined(GEN_FF) +scriptVar Layer::script_vcpu_fx_setEnabled(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar a) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&a)); + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) l->fx_setEnabled(GET_SCRIPT_INT(a)); + RETURN_SCRIPT_VOID; +} + +scriptVar Layer::script_vcpu_fx_getEnabled(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) return MAKE_SCRIPT_INT(l->fx_getEnabled()); + RETURN_SCRIPT_ZERO; +} + +scriptVar Layer::script_vcpu_fx_setWrap(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar a) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&a)); + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) l->fx_setWrap(SOM::makeInt(&a)); + RETURN_SCRIPT_VOID; +} + +scriptVar Layer::script_vcpu_fx_getWrap(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) return MAKE_SCRIPT_INT(l->fx_getWrap()); + RETURN_SCRIPT_ZERO; +} + +scriptVar Layer::script_vcpu_fx_setRect(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar a) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&a)); + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) l->fx_setRect(SOM::makeInt(&a)); + RETURN_SCRIPT_VOID; +} + +scriptVar Layer::script_vcpu_fx_getRect(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) return MAKE_SCRIPT_INT(l->fx_getRect()); + RETURN_SCRIPT_ZERO; +} + +scriptVar Layer::script_vcpu_fx_setAlphaMode(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar a) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&a)); + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) l->fx_setAlphaMode(SOM::makeInt(&a)); + RETURN_SCRIPT_VOID; +} + +scriptVar Layer::script_vcpu_fx_getAlphaMode(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) return MAKE_SCRIPT_INT(l->fx_getAlphaMode()); + RETURN_SCRIPT_ZERO; +} + +scriptVar Layer::script_vcpu_fx_setBilinear(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar a) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&a)); + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) l->fx_setBilinear(SOM::makeInt(&a)); + RETURN_SCRIPT_VOID; +} + +scriptVar Layer::script_vcpu_fx_getBilinear(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) return MAKE_SCRIPT_INT(l->fx_getBilinear()); + RETURN_SCRIPT_ZERO; +} + +scriptVar Layer::script_vcpu_fx_setBgFx(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar a) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&a)); + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) l->fx_setBgFx(SOM::makeInt(&a)); + RETURN_SCRIPT_VOID; +} + +scriptVar Layer::script_vcpu_fx_getBgFx(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) return MAKE_SCRIPT_INT(((Layer *)o)->fx_getBgFx()); + RETURN_SCRIPT_ZERO; +} + +scriptVar Layer::script_vcpu_fx_setSpeed(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar s) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&s)); + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) l->fx_setSpeed(SOM::makeInt(&s)); + RETURN_SCRIPT_VOID; +} + +scriptVar Layer::script_vcpu_fx_getSpeed(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) return MAKE_SCRIPT_INT(((Layer *)o)->fx_getSpeed()); + RETURN_SCRIPT_ZERO; +} + +scriptVar Layer::script_vcpu_fx_setRealtime(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar s) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&s)); + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) l->fx_setRealtime(SOM::makeInt(&s)); + RETURN_SCRIPT_VOID; +} + +scriptVar Layer::script_vcpu_fx_getRealtime(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) return MAKE_SCRIPT_INT(((Layer *)o)->fx_getRealtime()); + RETURN_SCRIPT_ZERO; +} + +scriptVar Layer::script_vcpu_fx_setClear(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar s) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&s)); + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) l->fx_setClear(SOM::makeInt(&s)); + RETURN_SCRIPT_VOID; +} + +scriptVar Layer::script_vcpu_fx_getClear(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) return MAKE_SCRIPT_INT(l->fx_getClear()); + RETURN_SCRIPT_ZERO; +} + +scriptVar Layer::script_vcpu_fx_setLocalized(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar s) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&s)); + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) l->fx_setLocalized(SOM::makeInt(&s)); + RETURN_SCRIPT_VOID; +} + +scriptVar Layer::script_vcpu_fx_getLocalized(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) return MAKE_SCRIPT_INT(l->fx_getLocalized()); + RETURN_SCRIPT_ZERO; +} + +scriptVar Layer::script_vcpu_fx_setGridSize(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar x, scriptVar y) +{ + SCRIPT_FUNCTION_INIT + ASSERT(SOM::isNumeric(&x)); + ASSERT(SOM::isNumeric(&y)); + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) l->fx_setGridSize(SOM::makeInt(&x), SOM::makeInt(&y)); + RETURN_SCRIPT_VOID; +} + +scriptVar Layer::script_vcpu_fx_update(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) l->fx_update(); + RETURN_SCRIPT_VOID; +} + +scriptVar Layer::script_vcpu_fx_restart(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT + Layer *l = static_cast<Layer *>(o->vcpu_getInterface(layerGuid)); + if (l) l->fx_restart(); + RETURN_SCRIPT_VOID; +} + +scriptVar Layer::script_vcpu_fx_onInit(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS0(o, layerController); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT0(o); +} + +scriptVar Layer::script_vcpu_fx_onFrame(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS0(o, layerController); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT0(o); +} + +scriptVar Layer::script_vcpu_fx_onGetPixelA(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar r, scriptVar d, scriptVar x, scriptVar y) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS4(o, layerController, r, d, x, y); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT4(o, r, d, x, y); +} + + +scriptVar Layer::script_vcpu_fx_onGetPixelX(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar r, scriptVar d, scriptVar x, scriptVar y) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS4(o, layerController, r, d, x, y); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT4(o, r, d, x, y); +} + +scriptVar Layer::script_vcpu_fx_onGetPixelY(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar r, scriptVar d, scriptVar x, scriptVar y) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS4(o, layerController, r, d, x, y); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT4(o, r, d, x, y); +} + +scriptVar Layer::script_vcpu_fx_onGetPixelR(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar r, scriptVar d, scriptVar x, scriptVar y) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS4(o, layerController, r, d, x, y); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT4(o, r, d, x, y); +} + +scriptVar Layer::script_vcpu_fx_onGetPixelD(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar r, scriptVar d, scriptVar x, scriptVar y) +{ + SCRIPT_FUNCTION_INIT; + PROCESS_HOOKS4(o, layerController, r, d, x, y); + SCRIPT_FUNCTION_CHECKABORTEVENT; + SCRIPT_EXEC_EVENT4(o, r, d, x, y); +} + +#endif //WA3COMPATIBILITY || GEN_FF + + |