612 lines
16 KiB
C++
612 lines
16 KiB
C++
#include "precomp.h"
|
|
#include <bfc/std_math.h>
|
|
#include "compbuck2.h"
|
|
#include <api/wac/wac.h>
|
|
#include <tataki/bitmap/bitmap.h>
|
|
#include <api/wndmgr/layout.h>
|
|
#include <api/wnd/notifmsg.h>
|
|
#include <api/service/service.h>
|
|
#include <api/service/services.h>
|
|
#include <api/wnd/wndclass/svcwndhold.h>
|
|
|
|
#define TIMER_SCROLL (0x400+8879)
|
|
#define TIMER_SCROLLPAGE (0x400+8880)
|
|
|
|
#define TIMER_SPEED 10
|
|
#define SCROLL_STEPS 10
|
|
#define SCROLL_SPEED 20
|
|
|
|
#define SCROLL_LEFT -2
|
|
#define SCROLL_RIGHT +2
|
|
|
|
#ifndef PI
|
|
#define PI 3.1415926536
|
|
#endif
|
|
|
|
const wchar_t componentBucketXuiObjectStr[] = L"ComponentBucket"; // This is the xml tag
|
|
char componentBucketXuiSvcName[] = "ComponentBucket xui object"; // this is the name of the xuiservice
|
|
|
|
XMLParamPair ComponentBucket2::params[] =
|
|
{
|
|
{COMPBUCK_LEFTMARGIN, L"LEFTMARGIN"},
|
|
{COMPBUCK_RIGHTMARGIN, L"RIGHTMARGIN"},
|
|
{COMPBUCK_SPACING, L"SPACING"},
|
|
{COMPBUCK_VERTICAL, L"VERTICAL"},
|
|
{COMPBUCK_WNDTYPE, L"WNDTYPE"},
|
|
};
|
|
|
|
ComponentBucket2::ComponentBucket2() {
|
|
getScriptObject()->vcpu_setInterface(cbucketGuid, (void *)static_cast<ComponentBucket2 *>(this));
|
|
getScriptObject()->vcpu_setClassName(L"ComponentBucket");
|
|
getScriptObject()->vcpu_setController(cbucketController);
|
|
lastticcount=0;
|
|
wndtype = BUCKETITEM;
|
|
timeron = 0;
|
|
lmargin = 2;
|
|
rmargin = 2;
|
|
spacing = 2;
|
|
direction = 0;
|
|
xscroll = 0;
|
|
timerset = 0;
|
|
cblist.addItem(this);
|
|
vertical = 0;
|
|
scrollpage_timerset = 0;
|
|
scrollpage_starttime = 0;
|
|
scrollpage_start = 0;
|
|
scrollpage_target = 0;
|
|
scrollpage_speed = 250;
|
|
xuihandle = newXuiHandle();
|
|
CreateXMLParameters(xuihandle);
|
|
}
|
|
|
|
void ComponentBucket2::CreateXMLParameters(int master_handle)
|
|
{
|
|
//COMPONENTBUCKET2_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);
|
|
}
|
|
|
|
ComponentBucket2::~ComponentBucket2() {
|
|
if (scrollpage_timerset) killTimer(TIMER_SCROLLPAGE);
|
|
myclients.deleteAll();
|
|
cblist.removeItem(this);
|
|
if (cblist.getNumItems() == 0) cblist.removeAll();
|
|
}
|
|
|
|
int ComponentBucket2::onInit() {
|
|
COMPONENTBUCKET2_PARENT::onInit();
|
|
load();
|
|
return 1;
|
|
}
|
|
|
|
int ComponentBucket2::setXuiParam(int _xuihandle, int id, const wchar_t *name, const wchar_t *strval) {
|
|
if (xuihandle == _xuihandle) {
|
|
switch (id) {
|
|
case COMPBUCK_LEFTMARGIN: setLMargin(WTOI(strval)); return 1;
|
|
case COMPBUCK_RIGHTMARGIN: setRMargin(WTOI(strval)); return 1;
|
|
case COMPBUCK_SPACING: setSpacing(WTOI(strval)); return 1;
|
|
case COMPBUCK_VERTICAL: setVertical(WTOI(strval)); return 1;
|
|
case COMPBUCK_WNDTYPE: wndtype = strval; return 1;
|
|
}
|
|
}
|
|
return COMPONENTBUCKET2_PARENT::setXuiParam(_xuihandle, id, name, strval);
|
|
}
|
|
|
|
void ComponentBucket2::setScroll(int v) {
|
|
xscroll = v;
|
|
if (isInited())
|
|
onResize();
|
|
invalidate();
|
|
}
|
|
|
|
int ComponentBucket2::getScroll() {
|
|
return xscroll;
|
|
}
|
|
|
|
void ComponentBucket2::timerCallback(int id) {
|
|
switch (id) {
|
|
case TIMER_SCROLL: {
|
|
RECT r;
|
|
getClientRect(&r);
|
|
do {
|
|
xscroll += direction;
|
|
lastticcount += TIMER_SPEED;
|
|
} while (lastticcount < Wasabi::Std::getTickCount() - TIMER_SPEED);
|
|
if (!vertical)
|
|
xscroll = MIN((int)(getMaxWidth()-(r.right-r.left)), xscroll);
|
|
else
|
|
xscroll = MIN((int)(getMaxHeight()-(r.bottom-r.top)), xscroll);
|
|
xscroll = MAX(0, xscroll);
|
|
if (isInited())
|
|
onResize();
|
|
invalidate();
|
|
return;
|
|
}
|
|
case TIMER_SCROLLPAGE: {
|
|
int n = MulDiv(Wasabi::Std::getTickCount()-scrollpage_starttime,256,scrollpage_speed);
|
|
if (n > 255) n = 255; if (n < 0) n = 0;
|
|
float sintrans = (float)(sin(((float)n/255)*PI-PI/2)/2+0.5);
|
|
xscroll = (int)(((float)(scrollpage_target - scrollpage_start) * sintrans) + scrollpage_start);
|
|
if (n == 255) {
|
|
killTimer(TIMER_SCROLLPAGE);
|
|
scrollpage_timerset = 0;
|
|
}
|
|
if (isInited())
|
|
onResize();
|
|
invalidate();
|
|
return;
|
|
}
|
|
default:
|
|
COMPONENTBUCKET2_PARENT::timerCallback(id);
|
|
return;
|
|
}
|
|
}
|
|
|
|
int ComponentBucket2::childNotify(ifc_window *child, int msg, intptr_t p1, intptr_t p2) {
|
|
switch (msg) {
|
|
case ChildNotify::COMPONENTBUCKET_SETTEXT:
|
|
setText((const wchar_t *)p1);
|
|
return 1;
|
|
}
|
|
return COMPONENTBUCKET2_PARENT::childNotify(child, msg, p1, p2);
|
|
}
|
|
|
|
void ComponentBucket2::prev_down(Group *l) {
|
|
if (!l) return;
|
|
for (int i=0;i<cblist.getNumItems();i++) {
|
|
if (cblist[i]->getGuiObject()->guiobject_getParentGroup()->getParentContainer() == l->getParentContainer())
|
|
cblist[i]->prev_down();
|
|
}
|
|
}
|
|
|
|
void ComponentBucket2::next_down(Group *l) {
|
|
if (!l) return;
|
|
for (int i=0;i<cblist.getNumItems();i++) {
|
|
if (cblist[i]->getGuiObject()->guiobject_getParentGroup()->getParentContainer() == l->getParentContainer())
|
|
cblist[i]->next_down();
|
|
}
|
|
}
|
|
|
|
void ComponentBucket2::prev_up(Group *l) {
|
|
if (!l) return;
|
|
for (int i=0;i<cblist.getNumItems();i++) {
|
|
if (cblist[i]->getGuiObject()->guiobject_getParentGroup()->getParentContainer() == l->getParentContainer())
|
|
cblist[i]->prev_up();
|
|
}
|
|
}
|
|
|
|
void ComponentBucket2::next_up(Group *l) {
|
|
if (!l) return;
|
|
for (int i=0;i<cblist.getNumItems();i++) {
|
|
if (cblist[i]->getGuiObject()->guiobject_getParentGroup()->getParentContainer() == l->getParentContainer())
|
|
cblist[i]->next_up();
|
|
}
|
|
}
|
|
|
|
void ComponentBucket2::prev_page(Group *l) {
|
|
if (!l) return;
|
|
for (int i=0;i<cblist.getNumItems();i++) {
|
|
if (cblist[i]->getGuiObject()->guiobject_getParentGroup()->getParentContainer() == l->getParentContainer())
|
|
cblist[i]->prev_page();
|
|
}
|
|
}
|
|
|
|
void ComponentBucket2::next_page(Group *l) {
|
|
if (!l) return;
|
|
for (int i=0;i<cblist.getNumItems();i++) {
|
|
if (cblist[i]->getGuiObject()->guiobject_getParentGroup()->getParentContainer() == l->getParentContainer())
|
|
cblist[i]->next_page();
|
|
}
|
|
}
|
|
|
|
void ComponentBucket2::prev_down() {
|
|
direction = SCROLL_LEFT;
|
|
startScrollTimer();
|
|
}
|
|
|
|
void ComponentBucket2::prev_up() {
|
|
stopScrollTimer();
|
|
}
|
|
|
|
void ComponentBucket2::next_down() {
|
|
direction = SCROLL_RIGHT;
|
|
startScrollTimer();
|
|
}
|
|
|
|
void ComponentBucket2::next_up() {
|
|
stopScrollTimer();
|
|
}
|
|
|
|
void ComponentBucket2::prev_page() {
|
|
scrollpage_starttime = Wasabi::Std::getTickCount();
|
|
scrollpage_start = xscroll;
|
|
RECT r;
|
|
getClientRect(&r);
|
|
int nx = 0;
|
|
if (vertical)
|
|
nx = r.bottom - r.top;
|
|
else
|
|
nx = r.right - r.left;
|
|
nx = xscroll - nx;
|
|
if (nx < 0) nx = 0;
|
|
scrollpage_target = nx;
|
|
if (!scrollpage_timerset) {
|
|
setTimer(TIMER_SCROLLPAGE, 20);
|
|
scrollpage_timerset = 1;
|
|
}
|
|
}
|
|
|
|
void ComponentBucket2::next_page() {
|
|
scrollpage_starttime = Wasabi::Std::getTickCount();
|
|
scrollpage_start = xscroll;
|
|
RECT r;
|
|
getClientRect(&r);
|
|
int nx = 0;
|
|
if (vertical)
|
|
nx = r.bottom - r.top;
|
|
else
|
|
nx = r.right - r.left;
|
|
nx += xscroll;
|
|
if (!vertical)
|
|
nx = MIN((int)(getMaxWidth()-(r.right-r.left)), nx);
|
|
else
|
|
nx = MIN((int)(getMaxHeight()-(r.bottom-r.top)), nx);
|
|
scrollpage_target = nx;
|
|
if (!scrollpage_timerset) {
|
|
setTimer(TIMER_SCROLLPAGE, 20);
|
|
scrollpage_timerset = 1;
|
|
}
|
|
}
|
|
|
|
void ComponentBucket2::startScrollTimer() {
|
|
if (timerset) return;
|
|
timerset=1;
|
|
lastticcount = Wasabi::Std::getTickCount();
|
|
setTimer(TIMER_SCROLL, TIMER_SPEED);
|
|
}
|
|
|
|
void ComponentBucket2::stopScrollTimer() {
|
|
if (!timerset) return;
|
|
killTimer(TIMER_SCROLL);
|
|
timerset=0;
|
|
}
|
|
|
|
void ComponentBucket2::setText(const wchar_t *t)
|
|
{
|
|
for (int i=0;i<txtlist.getNumItems();i++) {
|
|
if (txtlist.enumItem(i)->getRootParent() == getRootParent()) {
|
|
txtlist.enumItem(i)->setName(t);
|
|
txtlist.enumItem(i)->invalidate();
|
|
}
|
|
}
|
|
}
|
|
|
|
void ComponentBucket2::setText(ifc_window *cb , const wchar_t *txt) {
|
|
for (int i=0;i<cblist.getNumItems();i++) {
|
|
if (static_cast<ifc_window *>(cblist.enumItem(i)) == cb)
|
|
cblist.enumItem(i)->setText(txt);
|
|
}
|
|
}
|
|
|
|
void ComponentBucket2::registerText(Text *t, const wchar_t *id)
|
|
{
|
|
ComponentBucket2 *cb = getComponentBucket(id);
|
|
if (cb) {
|
|
cb->doRegisterText(t);
|
|
return;
|
|
}
|
|
ifc_window *p = t->getDesktopParent();
|
|
for (int i=0;i<cblist.getNumItems();i++) {
|
|
if (cblist.enumItem(i)->getDesktopParent() == p)
|
|
cblist.enumItem(i)->doRegisterText(t);
|
|
}
|
|
}
|
|
|
|
void ComponentBucket2::unRegisterText(Text *t, const wchar_t *id) {
|
|
ComponentBucket2 *cb = getComponentBucket(id);
|
|
if (cb) {
|
|
cb->doUnregisterText(t);
|
|
return;
|
|
}
|
|
ifc_window *p = t->getDesktopParent();
|
|
for (int i=0;i<cblist.getNumItems();i++) {
|
|
if (cblist.enumItem(i)->getDesktopParent() == p)
|
|
cblist.enumItem(i)->doUnregisterText(t);
|
|
}
|
|
}
|
|
|
|
ComponentBucket2 *ComponentBucket2::getComponentBucket(const wchar_t *cb) {
|
|
if (!cb) return NULL;
|
|
for (int i=0;i<cblist.getNumItems();i++) {
|
|
if (cblist.enumItem(i)->getGuiObject()->guiobject_getId()
|
|
&& !WCSICMP(cblist.enumItem(i)->getGuiObject()->guiobject_getId(), cb))
|
|
return cblist.enumItem(i);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void ComponentBucket2::setLMargin(int i) {
|
|
lmargin = i;
|
|
invalidate();
|
|
}
|
|
|
|
void ComponentBucket2::setRMargin(int i) {
|
|
rmargin = i;
|
|
invalidate();
|
|
}
|
|
|
|
void ComponentBucket2::setSpacing(int i) {
|
|
spacing = i;
|
|
invalidate();
|
|
}
|
|
|
|
int ComponentBucket2::getLMargin(void) {
|
|
return lmargin;
|
|
}
|
|
|
|
int ComponentBucket2::getRMargin(void) {
|
|
return rmargin;
|
|
}
|
|
|
|
int ComponentBucket2::getSpacing(void) {
|
|
return spacing;
|
|
}
|
|
|
|
void ComponentBucket2::load() {
|
|
WindowCreateByTypeEnum wce(wndtype);
|
|
svc_windowCreate *obj;
|
|
while ((obj = wce.getNext()) != NULL) {
|
|
addItems(obj);
|
|
}
|
|
if (isPostOnInit())
|
|
onResize();
|
|
}
|
|
|
|
void ComponentBucket2::doRegisterText(Text *t) {
|
|
txtlist.addItem(t);
|
|
}
|
|
|
|
void ComponentBucket2::doUnregisterText(Text *t) {
|
|
txtlist.delItem(t);
|
|
}
|
|
|
|
|
|
void ComponentBucket2::addItems(svc_windowCreate *svc) {
|
|
|
|
for (int i = 0; ; i++) {
|
|
ASSERTPR(i < 1336, "someone is lame-o");
|
|
ServiceWndHolder *svcwnd = new ServiceWndHolder;
|
|
ifc_window *wnd = svc->createWindowOfType(wndtype, svcwnd, i);
|
|
if (wnd == NULL) {
|
|
delete svcwnd;
|
|
if (i==0) SvcEnum::release(svc);
|
|
break;
|
|
}
|
|
svcwnd->setChild(wnd, svc);
|
|
myclients.addItem(svcwnd);
|
|
svcwnd->setStartHidden(1);
|
|
svcwnd->init(this);
|
|
}
|
|
}
|
|
|
|
int ComponentBucket2::getMaxWidth() {
|
|
if (!vertical) {
|
|
int p = getLMargin();
|
|
|
|
for (int j=0;j<myclients.getNumItems();j++) {
|
|
//CUT for (int i=0;i<myclients.enumItem(j)->wnds.getNumItems();i++) {
|
|
RECT r;
|
|
myclients[j]->getClientRect(&r);
|
|
p+=(r.right-r.left)+getSpacing();
|
|
//CUT }
|
|
}
|
|
|
|
return p+getRMargin();
|
|
}
|
|
RECT r;
|
|
getClientRect(&r);
|
|
return r.right-r.left;
|
|
}
|
|
|
|
int ComponentBucket2::getMaxHeight() {
|
|
if (vertical) {
|
|
int p = getLMargin();
|
|
|
|
for (int j=0;j<myclients.getNumItems();j++) {
|
|
//CUT for (int i=0;i<myclients.enumItem(j)->wnds.getNumItems();i++) {
|
|
RECT r;
|
|
myclients[j]->getClientRect(&r);
|
|
p+=(r.bottom-r.top)+getSpacing();
|
|
//CUT }
|
|
}
|
|
|
|
return p+getLMargin();
|
|
}
|
|
RECT r;
|
|
getClientRect(&r);
|
|
return r.right-r.left;
|
|
}
|
|
|
|
int ComponentBucket2::onResize() {
|
|
COMPONENTBUCKET2_PARENT::onResize();
|
|
|
|
RECT r;
|
|
getClientRect(&r);
|
|
|
|
int sh;
|
|
int myh;
|
|
if (!vertical) {
|
|
sh = r.bottom - r.top;
|
|
} else {
|
|
sh = r.right - r.left;
|
|
}
|
|
myh = sh;
|
|
|
|
|
|
int p = getLMargin() - xscroll;
|
|
|
|
for (int j=0;j<myclients.getNumItems();j++) {
|
|
//CUT for (int i=0;i<myclients.enumItem(j)->wnds.getNumItems();i++) {
|
|
//CUT api_window *c = myclients.enumItem(j)->wnds.enumItem(i);
|
|
ifc_window *c = myclients[j];
|
|
int w = c->getPreferences(SUGGESTED_W);
|
|
int h = c->getPreferences(SUGGESTED_H);
|
|
|
|
if (!vertical) {
|
|
float rt = (float)myh / (float)h;
|
|
if (ABS(rt-1.0f) > 0.1) {
|
|
w = (int)((float)w*rt);
|
|
h = (int)((float)h*rt);
|
|
}
|
|
} else {
|
|
float rt = (float)myh / (float)w;
|
|
if (ABS(rt-1.0f) > 0.1) {
|
|
w = (int)((float)w*rt);
|
|
h = (int)((float)h*rt);
|
|
}
|
|
}
|
|
|
|
if (!vertical)
|
|
c->resize(p+r.left, r.top+(sh - h) / 2, w, h);
|
|
else
|
|
c->resize(r.left+(sh - w) / 2, p+r.top, w, h);
|
|
|
|
if (!vertical)
|
|
p+=w+getSpacing();
|
|
else
|
|
p+=h+getSpacing();
|
|
|
|
if (!c->isVisible()) c->setVisible(1);
|
|
//CUT }
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
void ComponentBucket2::setVertical(int v) {
|
|
if (v == vertical) return;
|
|
vertical = v;
|
|
if (isInited()) invalidate();
|
|
}
|
|
|
|
int ComponentBucket2::getNumChildren() {
|
|
return myclients.getNumItems();
|
|
}
|
|
|
|
GuiObject *ComponentBucket2::enumChildren(int i) {
|
|
ServiceWndHolder *w = myclients.enumItem(i);
|
|
if (!w) return NULL;
|
|
ifc_window *_w = w->rootwndholder_getRootWnd();
|
|
if (!_w) return NULL;
|
|
return _w->getGuiObject();
|
|
}
|
|
|
|
PtrList<ComponentBucket2> ComponentBucket2::cblist;
|
|
|
|
CompBucketScriptController _cbucketController;
|
|
CompBucketScriptController *cbucketController = &_cbucketController;
|
|
|
|
|
|
// -- Functions table -------------------------------------
|
|
function_descriptor_struct CompBucketScriptController ::exportedFunction[] = {
|
|
{L"getMaxWidth", 0, (void*)ComponentBucket2::script_vcpu_getMaxWidth},
|
|
{L"getMaxHeight", 0, (void*)ComponentBucket2::script_vcpu_getMaxHeight},
|
|
{L"getScroll", 0, (void*)ComponentBucket2::script_vcpu_getScroll},
|
|
{L"setScroll", 1, (void*)ComponentBucket2::script_vcpu_setScroll},
|
|
{L"getNumChildren", 0, (void*)ComponentBucket2::script_vcpu_getNumChildren},
|
|
{L"enumChildren", 1, (void*)ComponentBucket2::script_vcpu_enumChildren},
|
|
{L"fake", 0, (void*)ComponentBucket2::script_vcpu_fake },
|
|
};
|
|
|
|
const wchar_t *CompBucketScriptController ::getClassName() {
|
|
return L"ComponentBucket";
|
|
}
|
|
|
|
const wchar_t *CompBucketScriptController ::getAncestorClassName() {
|
|
return L"GuiObject";
|
|
}
|
|
|
|
ScriptObject *CompBucketScriptController::instantiate() {
|
|
ComponentBucket2 *cb = new ComponentBucket2;
|
|
ASSERT(cb != NULL);
|
|
return cb->getScriptObject();
|
|
}
|
|
|
|
void CompBucketScriptController::destroy(ScriptObject *o) {
|
|
ComponentBucket2 *cb = static_cast<ComponentBucket2 *>(o->vcpu_getInterface(cbucketGuid));
|
|
ASSERT(cb != NULL);
|
|
delete cb;
|
|
}
|
|
|
|
void *CompBucketScriptController::encapsulate(ScriptObject *o) {
|
|
return NULL; // no encapsulation for componentbucket yet
|
|
}
|
|
|
|
void CompBucketScriptController::deencapsulate(void *o) {
|
|
}
|
|
|
|
int CompBucketScriptController ::getNumFunctions() {
|
|
return sizeof(exportedFunction) / sizeof(function_descriptor_struct);
|
|
}
|
|
|
|
const function_descriptor_struct *CompBucketScriptController ::getExportedFunctions() {
|
|
return exportedFunction;
|
|
}
|
|
|
|
GUID CompBucketScriptController ::getClassGuid() {
|
|
return cbucketGuid;
|
|
}
|
|
|
|
scriptVar ComponentBucket2::script_vcpu_fake(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) {
|
|
SCRIPT_FUNCTION_INIT
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|
|
scriptVar ComponentBucket2::script_vcpu_getMaxWidth(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) {
|
|
SCRIPT_FUNCTION_INIT
|
|
ComponentBucket2 *cb = static_cast<ComponentBucket2*>(o->vcpu_getInterface(cbucketGuid));
|
|
if (cb) return MAKE_SCRIPT_INT(cb->getMaxWidth());
|
|
RETURN_SCRIPT_ZERO;
|
|
}
|
|
|
|
scriptVar ComponentBucket2::script_vcpu_getMaxHeight(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) {
|
|
SCRIPT_FUNCTION_INIT
|
|
ComponentBucket2 *cb = static_cast<ComponentBucket2*>(o->vcpu_getInterface(cbucketGuid));
|
|
if (cb) return MAKE_SCRIPT_INT(cb->getMaxHeight());
|
|
RETURN_SCRIPT_ZERO;
|
|
}
|
|
|
|
scriptVar ComponentBucket2::script_vcpu_getScroll(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) {
|
|
SCRIPT_FUNCTION_INIT
|
|
ComponentBucket2 *cb = static_cast<ComponentBucket2*>(o->vcpu_getInterface(cbucketGuid));
|
|
if (cb) return MAKE_SCRIPT_INT(cb->getScroll());
|
|
RETURN_SCRIPT_ZERO;
|
|
}
|
|
|
|
scriptVar ComponentBucket2::script_vcpu_setScroll(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar v) {
|
|
SCRIPT_FUNCTION_INIT
|
|
ComponentBucket2 *cb = static_cast<ComponentBucket2*>(o->vcpu_getInterface(cbucketGuid));
|
|
if (cb) cb->setScroll(GET_SCRIPT_INT(v));
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|
|
scriptVar ComponentBucket2::script_vcpu_getNumChildren(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) {
|
|
SCRIPT_FUNCTION_INIT
|
|
ComponentBucket2 *cb = static_cast<ComponentBucket2*>(o->vcpu_getInterface(cbucketGuid));
|
|
if (cb) return MAKE_SCRIPT_INT(cb->getNumChildren());
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|
|
scriptVar ComponentBucket2::script_vcpu_enumChildren(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar v) {
|
|
SCRIPT_FUNCTION_INIT
|
|
ComponentBucket2 *cb = static_cast<ComponentBucket2*>(o->vcpu_getInterface(cbucketGuid));
|
|
if (cb) {
|
|
GuiObject *o = cb->enumChildren(GET_SCRIPT_INT(v));
|
|
if (o) return MAKE_SCRIPT_OBJECT(o->guiobject_getScriptObject());
|
|
}
|
|
RETURN_SCRIPT_ZERO;
|
|
}
|
|
|