void TransformerFunc::execute() {
ComValue objv(stack_arg(0));
ComValue transv(stack_arg(0));
reset_stack();
if (objv.object_compview()) {
ComponentView* compview = (ComponentView*)objv.obj_val();
if (compview && compview->GetSubject()) {
OverlayComp* comp = (OverlayComp*)compview->GetSubject();
Graphic* gr = comp->GetGraphic();
if (gr) {
Transformer* trans = gr->GetTransformer();
if (transv.is_unknown() || !transv.is_array() || transv.array_val()->Number()!=6) {
AttributeValueList* avl = new AttributeValueList();
float a00, a01, a10, a11, a20, a21;
trans->matrix(a00, a01, a10, a11, a20, a21);
avl->Append(new AttributeValue(a00));
avl->Append(new AttributeValue(a01));
avl->Append(new AttributeValue(a10));
avl->Append(new AttributeValue(a11));
avl->Append(new AttributeValue(a20));
avl->Append(new AttributeValue(a21));
ComValue retval(avl);
push_stack(retval);
} else {
float a00, a01, a10, a11, a20, a21;
AttributeValueList* avl = transv.array_val();
Iterator it;
AttributeValue* av;
avl->First(it);
av = avl->GetAttrVal(it);
a00 = av->float_val();
avl->Next(it);
av = avl->GetAttrVal(it);
a01 = av->float_val();
avl->Next(it);
av = avl->GetAttrVal(it);
a10 = av->float_val();
avl->Next(it);
av = avl->GetAttrVal(it);
a11 = av->float_val();
avl->Next(it);
av = avl->GetAttrVal(it);
a20 = av->float_val();
avl->Next(it);
av = avl->GetAttrVal(it);
a21 = av->float_val();
Transformer t(a00, a01, a10, a11, a20, a21);
*gr->GetTransformer()=t;
ComValue compval(new OverlayViewRef(comp), comp->class_symid());
push_stack(compval);
}
}
}
}
}
void SymIdFunc::execute() {
// return id of each symbol in the arguments
boolean noargs = !nargs() && !nkeys();
int numargs = nargs();
if (!numargs) return;
int symbol_ids[numargs];
for (int i=0; i<numargs; i++) {
ComValue& val = stack_arg(i, true);
if (val.is_type(AttributeValue::CommandType))
symbol_ids[i] = val.command_symid();
else if (val.is_type(AttributeValue::StringType))
symbol_ids[i] = val.string_val();
else if (val.is_type(AttributeValue::SymbolType))
symbol_ids[i] = val.symbol_val();
else
symbol_ids[i] = -1;
}
reset_stack();
if (numargs>1) {
AttributeValueList* avl = new AttributeValueList();
ComValue retval(avl);
for (int i=0; i<numargs; i++)
avl->Append(new AttributeValue(symbol_ids[i], AttributeValue::IntType));
push_stack(retval);
} else {
ComValue retval (symbol_ids[0], AttributeValue::IntType);
push_stack(retval);
}
}
void SymValFunc::execute() {
// return value for each symbol variable
boolean noargs = !nargs() && !nkeys();
int numargs = nargs();
if (!numargs) return;
ComValue* varvalues[numargs];
for (int i=0; i<numargs; i++) {
// return fully-evaluated value: expression --> symbol --> value
varvalues[i] = &stack_arg(i, false);
// lookup_symval(*varvalues[i]);
}
if (numargs>1) {
AttributeValueList* avl = new AttributeValueList();
ComValue retval(avl);
for (int i=0; i<numargs; i++)
avl->Append(new ComValue(*varvalues[i]));
reset_stack();
push_stack(retval);
} else {
ComValue retval (*varvalues[0]);
reset_stack();
push_stack(retval);
}
}
void SymbolFunc::execute() {
// return symbol for each id argument
boolean noargs = !nargs() && !nkeys();
int numargs = nargs();
if (!numargs) return;
int symbol_ids[numargs];
for (int i=0; i<numargs; i++) {
ComValue& val = stack_arg(i, true);
if (val.is_char() || val.is_short() || val.is_int())
symbol_ids[i] = val.int_val();
else
symbol_ids[i] = -1;
}
reset_stack();
if (numargs>1) {
AttributeValueList* avl = new AttributeValueList();
ComValue retval(avl);
for (int i=0; i<numargs; i++) {
ComValue* av = new ComValue(symbol_ids[i], AttributeValue::SymbolType);
av->bquote(1);
avl->Append(av);
}
push_stack(retval);
} else {
ComValue retval (symbol_ids[0], AttributeValue::SymbolType);
retval.bquote(1);
push_stack(retval);
}
}
void EvalFunc::execute() {
static int symret_sym = symbol_add("symret");
ComValue symretv(stack_key(symret_sym));
if (!comterp()->is_serv()) {
cerr << "need server mode comterp (or remote mode) for eval command\n";
reset_stack();
push_stack(ComValue::nullval());
return;
}
// evaluate every string fixed argument on the stack and return in array
int numargs = nargsfixed();
if (numargs>1) {
AttributeValueList* avl = nil;
for (int i=0; i<numargs; i++) {
ComValue argstrv (stack_arg(i));
if (argstrv.is_nil()) break;
if (argstrv.is_string()) {
ComValue* val = new ComValue(comterpserv()->run(argstrv.symbol_ptr(), true /* nested */));
if (val->is_nil() && symretv.is_true()) {
delete val;
val = new ComValue(argstrv.symbol_val(), AttributeValue::SymbolType);
}
if (!avl) avl = new AttributeValueList();
avl->Append(val);
}
}
reset_stack();
if (avl) {
ComValue retval(avl);
push_stack(retval);
}
}
/* unless only single argument */
else if (numargs==1) {
ComValue argstrv (stack_arg(0));
reset_stack();
if (argstrv.is_nil()) {
push_stack(ComValue::nullval());
} else if (argstrv.is_string()) {
ComValue val(comterpserv()->run(argstrv.symbol_ptr(), true /* nested */));
if (val.is_nil() && symretv.is_true()) {
val.assignval(ComValue(argstrv.symbol_val(), AttributeValue::SymbolType));
}
push_stack(val);
}
} else
reset_stack();
}
void SplitStrFunc::execute() {
ComValue symvalv(stack_arg(0));
reset_stack();
if (symvalv.is_string()) {
AttributeValueList* avl = new AttributeValueList();
ComValue retval(avl);
const char* str = symvalv.symbol_ptr();
int len = strlen(str);
for (int i=0; i<len; i++)
avl->Append(new AttributeValue(str[i]));
push_stack(retval);
} else
push_stack(ComValue::nullval());
}
void GrStreamFunc::execute() {
ComValue convertv(stack_arg_post_eval(0));
if (convertv.object_compview()) {
reset_stack();
static StreamNextFunc* snfunc = nil;
if (!snfunc) {
snfunc = new StreamNextFunc(comterp());
snfunc->funcid(symbol_add("stream"));
}
AttributeValueList* avl = new AttributeValueList();
Component* comp = ((ComponentView*)convertv.obj_val())->GetSubject();
if (!comp->IsA(OVERLAYS_COMP)) {
push_stack(ComValue::nullval());
return;
}
OverlaysComp* ovcomps = (OverlaysComp*)comp;
Iterator it;
for(ovcomps->First(it); !ovcomps->Done(it); ovcomps->Next(it)) {
OverlayComp* subcomp = (OverlayComp*) ovcomps->GetComp(it);
AttributeValue* av =
new AttributeValue(new OverlayViewRef(subcomp), subcomp->classid());
avl->Append(av);
}
ComValue stream(snfunc, avl);
stream.stream_mode(-1); // for internal use (use by this func)
push_stack(stream);
} else {
StreamFunc strmfunc(comterp());
strmfunc.exec(funcstate()->nargs(), funcstate()->nkeys(), pedepth());
return;
}
}
void PostEvalFunc::execute() {
// evaluate every fixed argument on the stack and return in array
int numargs = nargstotal();
if (numargs) {
AttributeValueList* avl = nil;
for (int i=0; i<numargs; i++) {
ComValue* val = new ComValue(stack_arg_post_eval(i));
if (val->is_nil()) {
delete val;
break;
}
if (!avl) avl = new AttributeValueList();
avl->Append(val);
}
reset_stack();
if (avl) {
ComValue retval(avl);
push_stack(retval);
}
} else
reset_stack();
}
void GlobalSymbolFunc::execute() {
// return symbol(s) with global flag set
boolean noargs = !nargs() && !nkeys();
int numargs = nargs();
if (!numargs) {
reset_stack();
return;
}
int symbol_ids[numargs];
for (int i=0; i<numargs; i++) {
ComValue& val = stack_arg(i, true);
if (val.is_symbol())
symbol_ids[i] = val.symbol_val();
else
symbol_ids[i] = -1;
}
reset_stack();
if (numargs>1) {
AttributeValueList* avl = new AttributeValueList();
ComValue retval(avl);
for (int i=0; i<numargs; i++) {
ComValue* av =
new ComValue(symbol_ids[i], AttributeValue::SymbolType);
av->global_flag(true);
av->bquote(1);
avl->Append(av);
}
push_stack(retval);
} else {
ComValue retval (symbol_ids[0], AttributeValue::SymbolType);
retval.global_flag(true);
retval.bquote(1);
push_stack(retval);
}
}
void SymAddFunc::execute() {
// return each symbol in the arguments as is
boolean noargs = !nargs() && !nkeys();
int numargs = nargs();
if (!numargs) return;
int symbol_ids[numargs];
for (int i=0; i<numargs; i++) {
ComValue& val = stack_arg(i);
if (val.is_type(AttributeValue::CommandType))
symbol_ids[i] = val.command_symid();
else if (val.is_type(AttributeValue::StringType))
symbol_ids[i] = val.string_val();
else if (val.is_type(AttributeValue::SymbolType))
symbol_ids[i] = val.symbol_val();
else
symbol_ids[i] = -1;
}
reset_stack();
if (numargs>1) {
AttributeValueList* avl = new AttributeValueList();
ComValue retval(avl);
for (int i=0; i<numargs; i++) {
ComValue* av = new ComValue(symbol_ids[i], AttributeValue::SymbolType);
av->bquote(1);
if (symbol_ids[i]<0) av->type(ComValue::UnknownType);
avl->Append(av);
}
push_stack(retval);
} else {
ComValue retval (symbol_ids[0], AttributeValue::SymbolType);
if (symbol_ids[0]<0) retval.type(ComValue::UnknownType);
retval.bquote(1);
push_stack(retval);
}
}
void SelectFunc::execute() {
static int all_symid = symbol_add("all");
ComValue all_flagv(stack_key(all_symid));
boolean all_flag = all_flagv.is_true();
static int clear_symid = symbol_add("clear");
ComValue clear_flagv(stack_key(clear_symid));
boolean clear_flag = clear_flagv.is_true();
Selection* sel = _ed->GetViewer()->GetSelection();
if (clear_flag) {
sel->Clear();
unidraw->Update();
reset_stack();
return;
}
OverlaySelection* newSel = ((OverlayEditor*)_ed)->overlay_kit()->MakeSelection();
Viewer* viewer = _ed->GetViewer();
AttributeValueList* avl = new AttributeValueList();
if (all_flag) {
GraphicView* gv = ((OverlayEditor*)_ed)->GetFrame();
Iterator i;
int count=0;
for (gv->First(i); !gv->Done(i); gv->Next(i)) {
GraphicView* subgv = gv->GetView(i);
newSel->Append(subgv);
OverlayComp* comp = (OverlayComp*)subgv->GetGraphicComp();
ComValue* compval = new ComValue(new OverlayViewRef(comp), comp->classid());
avl->Append(compval);
}
} else if (nargs()==0) {
Iterator i;
int count=0;
for (sel->First(i); !sel->Done(i); sel->Next(i)) {
GraphicView* grview = sel->GetView(i);
OverlayComp* comp = grview ? (OverlayComp*)grview->GetSubject() : nil;
ComValue* compval = comp ? new ComValue(new OverlayViewRef(comp), comp->classid()) : nil;
if (compval) {
avl->Append(compval);
}
delete newSel;
newSel = nil;
}
} else {
for (int i=0; i<nargsfixed(); i++) {
ComValue& obj = stack_arg(i);
if (obj.object_compview()) {
ComponentView* comview = (ComponentView*)obj.obj_val();
OverlayComp* comp = (OverlayComp*)comview->GetSubject();
if (comp) {
GraphicView* view = comp->FindView(viewer);
if (view) {
newSel->Append(view);
ComValue* compval = new ComValue(new OverlayViewRef(comp), comp->classid());
avl->Append(compval);
}
}
} else if (obj.is_array()) {
Iterator it;
AttributeValueList* al = obj.array_val();
al->First(it);
while (!al->Done(it)) {
if (al->GetAttrVal(it)->object_compview()) {
ComponentView* comview = (ComponentView*)al->GetAttrVal(it)->obj_val();
OverlayComp* comp = (OverlayComp*)comview->GetSubject();
if (comp) {
GraphicView* view = comp->FindView(viewer);
if (view) {
newSel->Append(view);
ComValue* compval = new ComValue(new OverlayViewRef(comp), comp->classid());
avl->Append(compval);
}
}
}
al->Next(it);
}
}
}
}
if (newSel){
sel->Clear();
delete sel;
_ed->SetSelection(newSel);
newSel->Update(viewer);
unidraw->Update();
}
reset_stack();
ComValue retval(avl);
push_stack(retval);
}