OverlayComp* OverlayComp::TopComp() {
OverlayComp* comp = this;
OverlayComp* parent = (OverlayComp*)comp->GetParent();
while (parent)
comp = (OverlayComp*) comp->GetParent();
return comp;
}
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);
}
}
}
}
}
int FrameFileScript::ReadPathName (istream& in, void* addr1, void* addr2, void* addr3, void* addr4) {
FrameFileComp* filecomp = (FrameFileComp*)addr1;
char pathname[BUFSIZ];
if (ParamList::parse_pathname(in, pathname, BUFSIZ, filecomp->GetBaseDir()) != 0)
return -1;
/* check pathname for recursion */
OverlayComp* parent = (OverlayComp*) filecomp->GetParent();
while (parent != nil) {
if (parent->GetPathName() && strcmp(parent->GetPathName(), pathname) == 0) {
cerr << "framefile recursion not allowed (" << pathname << ")\n";
return -1;
}
parent = (OverlayComp*) parent->GetParent();
}
filecomp->SetPathName(pathname);
FrameIdrawComp* child = nil;
FrameCatalog* catalog = (FrameCatalog*)unidraw->GetCatalog();
catalog->SetParent(filecomp);
if( catalog->FrameCatalog::Retrieve(pathname, (Component*&)child)) {
catalog->SetParent(nil);
catalog->Forget(child);
filecomp->Append(child);
return 0;
} else {
catalog->SetParent(nil);
return -1;
}
}
void OverlaysComp::Ungroup (OverlayComp* parent, Clipboard* cb, Command* cmd) {
Iterator i, insertPt;
parent->First(i);
if (!parent->Done(i)) {
SetComp(parent, insertPt);
for (parent->First(i); !parent->Done(i); parent->Next(i)) {
OverlayComp* kid = (OverlayComp*) parent->GetComp(i);
cmd->Store(kid, new UngroupData(parent, kid->GetGraphic()));
}
cmd->Store(parent, new GSData(parent->GetGraphic()));
parent->Bequeath();
parent->First(i);
do {
OverlayComp* kid = (OverlayComp*)parent->GetComp(i);
parent->Remove(i);
InsertBefore(insertPt, kid);
cb->Append(kid);
} while (!parent->Done(i));
Remove(parent);
}
}
boolean OverlayComp::operator == (OverlayComp& comp) {
Graphic* gr = GetGraphic();
Graphic* test = comp.GetGraphic();
return
GetClassId() == comp.GetClassId() &&
GraphicEquals(gr, test);
}
/* virtual */ void ComEditor::ExecuteCmd(Command* cmd) {
if(!whiteboard())
/* normal Unidraw command execution */
OverlayEditor::ExecuteCmd(cmd);
else {
/* indirect command execution, all by script */
std::ostrstream sbuf;
boolean oldflag = OverlayScript::ptlist_parens();
OverlayScript::ptlist_parens(false);
switch (cmd->GetClassId()) {
case PASTE_CMD:
{
boolean scripted = false;
Clipboard* cb = cmd->GetClipboard();
if (cb) {
Iterator it;
for (cb->First(it); !cb->Done(it); cb->Next(it)) {
OverlayComp* comp = (OverlayComp*)cb->GetComp(it);
if (comp) {
Creator* creator = unidraw->GetCatalog()->GetCreator();
OverlayScript* scripter = (OverlayScript*)
creator->Create(Combine(comp->GetClassId(), SCRIPT_VIEW));
if (scripter) {
scripter->SetSubject(comp);
if (scripted)
sbuf << ';';
else
scripted = true;
boolean status = scripter->Definition(sbuf);
delete scripter;
}
}
}
}
if (!scripted)
sbuf << "print(\"Failed attempt to generate script for a PASTE_CMD\\n\" :err)";
sbuf.put('\0');
cout << sbuf.str() << "\n";
cout.flush();
GetComTerp()->run(sbuf.str());
delete cmd;
}
break;
default:
sbuf << "print(\"Attempt to convert unknown command (id == %d) to interpretable script\\n\" " << cmd->GetClassId() << " :err)";
cmd->Execute();
if (cmd->Reversible()) {
cmd->Log();
} else {
delete cmd;
}
break;
}
OverlayScript::ptlist_parens(oldflag);
}
}
int OverlayFileScript::ReadPathName (istream& in, void* addr1, void* addr2, void* addr3, void* addr4) {
OverlayFileComp* filecomp = (OverlayFileComp*)addr1;
const char* paramname = ParamList::CurrParamStruct()->name();
filecomp->SetPopenFlag(strcmp(paramname, "popen")==0);
char pathname[BUFSIZ];
if (filecomp->GetPopenFlag()) {
if (ParamList::parse_string(in, pathname, BUFSIZ) != 0)
return -1;
} else {
if (ParamList::parse_pathname(in, pathname, BUFSIZ, filecomp->GetBaseDir()) != 0)
return -1;
}
/* check pathname for recursion */
OverlayComp* parent = (OverlayComp*) filecomp->GetParent();
while (!filecomp->GetPopenFlag() && parent != nil) {
if (parent->GetPathName() && strcmp(parent->GetPathName(), pathname) == 0) {
cerr << "pathname recursion not allowed (" << pathname << ")\n";
return -1;
}
parent = (OverlayComp*) parent->GetParent();
}
filecomp->SetPathName(pathname);
if (!filecomp->GetPopenFlag()) {
OverlayIdrawComp* child = nil;
OverlayCatalog* catalog = (OverlayCatalog*) unidraw->GetCatalog();
catalog->SetParent(filecomp);
if( catalog->OverlayCatalog::Retrieve(pathname, (Component*&)child)) {
catalog->SetParent(nil);
catalog->Forget(child);
filecomp->Append(child);
return 0;
} else {
catalog->SetParent(nil);
return -1;
}
} else {
OvImportCmd impcmd((Editor*)nil);
FILE* fptr = popen(pathname, "r");
if (fptr) {
FILEBUF(fbuf, fptr, ios_base::in);
istream ifs(&fbuf);
OverlayComp* child = (OverlayComp*) impcmd.Import(ifs);
if (child) {
filecomp->Append(child);
return 0;
}
fclose(fptr);
}
return -1;
}
}
void AttributeDialogImpl::accept() {
editor_->add();
// should set modified flag here if something happenns
// ((ModifStatusVar*)<Editor>->GetState("ModifStatusVar"))->SetModifStatus(true);
OverlayComp* comp = (OverlayComp*)compview_->GetSubject();
if (comp) comp->SetAttributeList(copylist_);
Unref(copylist_);
dialog_->dismiss(true);
unidraw->Update();
}
static OverlayComp* Pred (OverlayComp* child) {
Iterator i;
OverlayComp* parent = (OverlayComp*) child->GetParent();
if (parent) {
parent->SetComp(child, i);
parent->Prev(i);
return (OverlayComp*) parent->GetComp(i);
} else
return nil;
}
void OverlaysComp::DeferredNotify() {
if (_notify_deferred) {
GraphicComp::Notify();
_notify_deferred = false;
} else {
Iterator i;
for (First(i); !Done(i); Next(i)) {
OverlayComp* comp = (OverlayComp*)GetComp(i);
if (!comp->GetGraphic()->Hidden())
((OverlayComp*)GetComp(i))->DeferredNotify();
}
}
}
void GrAttrListFunc::execute() {
ComValue compviewv(stack_arg(0));
reset_stack();
if (compviewv.object_compview()) {
ComponentView* compview = (ComponentView*)compviewv.obj_val();
OverlayComp* comp = compview ? (OverlayComp*)compview->GetSubject() : nil;
if (comp) {
ComValue retval(AttributeList::class_symid(), (void*)comp->GetAttributeList());
push_stack(retval);
} else
push_stack(ComValue::nullval());
}
}
void OverlaysComp::RestorePosition (OverlayComp* comp, Command* cmd) {
VoidData* vd = (VoidData*) cmd->Recall(comp);
OverlayComp* pred = (OverlayComp*) vd->_void;
OverlayComp* parent = (OverlayComp*) comp->GetParent();
if (parent != nil) parent->Remove(comp);
if (pred == nil) {
Prepend(comp);
} else {
Iterator insertPt;
SetComp(pred, insertPt);
InsertAfter(insertPt, comp);
}
}
void GrParentFunc::execute() {
ComValue compv(stack_arg(0));
reset_stack();
if(compv.is_object() && compv.object_compview()) {
ComponentView* compview = (ComponentView*)compv.obj_val();
OverlayComp* comp = (OverlayComp*)compview->GetSubject();
if (comp && comp->GetParent()) {
ComValue retval(new OverlayViewRef((OverlayComp*)comp->GetParent()),
((OverlayComp*)comp->GetParent())->classid());
push_stack(retval);
return;
}
}
push_stack(ComValue::nullval());
return;
}
void SensitizeCompFunc::execute() {
ComValue viewval(stack_arg(0));
reset_stack();
if (!viewval.is_object()) {
push_stack(ComValue::nullval());
return;
}
ComponentView* view = (ComponentView*)viewval.obj_val();
OverlayComp* comp = (OverlayComp*)view->GetSubject();
if(comp) {
comp->GetGraphic()->Sensitize();
comp->Notify();
}
push_stack(viewval);
}
boolean TextFileComp::operator == (OverlayComp& comp) {
if (GetClassId() != comp.GetClassId()) return false;
return
strcmp(GetPathname(), ((TextFileComp&)comp).GetPathname()) &&
strcmp(GetBegstr(), ((TextFileComp&)comp).GetBegstr()) &&
strcmp(GetEndstr(), ((TextFileComp&)comp).GetEndstr()) &&
GetLineWidth() == ((TextFileComp&)comp).GetLineWidth() &&
OverlayComp::operator==(comp);
}
boolean TextOvComp::operator == (OverlayComp& comp) {
if (GetClassId() != comp.GetClassId()) return false;
TextGraphic* texta = GetText();
TextGraphic* textb = ((TextOvComp&)comp).GetText();
int lha = texta->GetLineHeight();
int lhb = textb->GetLineHeight();
return
lha == lhb &&
strcmp(texta->GetOriginal(), textb->GetOriginal()) == 0 &&
OverlayComp::operator==(comp);
}
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 GrDotFunc::execute() {
ComValue& before_part(stack_arg(0, true));
ComValue& after_part(stack_arg(1, true));
if (!before_part.is_symbol() &&
!(before_part.is_attribute() && ((Attribute*)before_part.obj_val())->Value()->is_attributelist()) &&
!(before_part.object_compview())) {
cerr << "expression before \".\" needs to evaluate to a symbol or <AttributeList> or <Component>\n";
return;
}
if (!after_part.is_symbol()) {
cerr << "expression after \".\" needs to be a symbol or evaluate to a symbol\n";
reset_stack();
return;
}
/* handle ComponentView case */
if (before_part.is_symbol())
lookup_symval(before_part);
if (before_part.is_object() && before_part.object_compview()) {
ComponentView* compview = (ComponentView*)before_part.obj_val();
OverlayComp* comp = (OverlayComp*)compview->GetSubject();
if (comp) {
ComValue stuffval(AttributeList::class_symid(), (void*)comp->GetAttributeList());
before_part.assignval(stuffval);
} else {
cerr << "nil subject on compview value\n";
reset_stack();
push_stack(ComValue::nullval());
return;
}
}
DotFunc::execute();
}
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);
}
void OverlaysComp::Uninterpret (Command* cmd) {
Editor* ed = cmd->GetEditor();
if (
(cmd->IsA(DELETE_CMD) || cmd->IsA(CUT_CMD)) &&
ed->GetComponent() != this
) {
Iterator i;
for (Last(i); !Done(i); Prev(i)) {
GetComp(i)->Uninterpret(cmd);
}
} else if (cmd->IsA(DELETE_CMD)) {
Clipboard* cb = cmd->GetClipboard();
if (cb != nil) {
Iterator i;
for (cb->Last(i); !cb->Done(i); cb->Prev(i)) {
OverlayComp* comp = (OverlayComp*) cb->GetComp(i);
RestorePosition(comp, cmd);
comp->Uninterpret(cmd);
}
Notify();
SelectClipboard(cb, ed);
unidraw->Update();
}
} else if (cmd->IsA(CUT_CMD)) {
Clipboard* cb = cmd->GetClipboard();
if (cb != nil) {
Iterator i;
for (cb->Last(i); !cb->Done(i); cb->Prev(i)) {
OverlayComp* comp = (OverlayComp*) cb->GetComp(i);
RestorePosition(comp, cmd);
comp->Uninterpret(cmd);
}
Notify();
SelectClipboard(cb, ed);
unidraw->Update();
}
} else if (cmd->IsA(PASTE_CMD)) {
Clipboard* cb = cmd->GetClipboard();
if (cb != nil) {
Selection* s = ed->GetSelection();
Iterator i, pos;
s->Clear();
for (cb->First(i); !cb->Done(i); cb->Next(i)) {
GraphicComp* comp = cb->GetComp(i);
unidraw->CloseDependents(comp);
Remove(comp);
}
Notify();
unidraw->Update();
}
} else if (cmd->IsA(DUP_CMD)) {
Clipboard* cb = cmd->GetClipboard();
if (cb != nil) {
Selection* s = ed->GetSelection();
Iterator i;
s->Clear();
for (cb->First(i); !cb->Done(i); cb->Next(i)) {
GraphicComp* comp = cb->GetComp(i);
unidraw->CloseDependents(comp);
Remove(comp);
}
Notify();
unidraw->Update();
}
} else if (cmd->IsA(OVGROUP_CMD)) {
OvGroupCmd* gcmd = (OvGroupCmd*) cmd;
OverlayComp* group = gcmd->GetGroup();
Component* edComp = gcmd->GetEditor()->GetComponent();
if (group == this) {
edComp->Uninterpret(gcmd);
} else if (edComp == (Component*) this) {
Clipboard* cb = cmd->GetClipboard();
Iterator i;
cb->First(i);
OverlayComp* group = (OverlayComp*) cb->GetComp(i)->GetParent();
GroupCmd* gcmd = (GroupCmd*) cmd;
unidraw->CloseDependents(group);
for (cb->Last(i); !cb->Done(i); cb->Prev(i)) {
RestorePosition((OverlayComp*)cb->GetComp(i), cmd);
}
Remove(group);
Notify();
SelectClipboard(cb, ed);
unidraw->Update();
} else {
OverlayComp::Uninterpret(gcmd);
}
} else if (cmd->IsA(UNGROUP_CMD)) {
UngroupCmd* ucmd = (UngroupCmd*) cmd;
Component* edComp = ucmd->GetEditor()->GetComponent();
if (edComp == (Component*) this) {
Clipboard* cb = ucmd->GetClipboard();
Clipboard* kids = ucmd->GetKids();
Clipboard insertedParents;
Iterator k;
for (kids->First(k); !kids->Done(k); kids->Next(k)) {
OverlayComp* kid = (OverlayComp*) kids->GetComp(k);
UngroupData* ud = (UngroupData*) cmd->Recall(kid);
OverlayComp* parent = (OverlayComp*)ud->_parent;
*kid->GetGraphic() = *ud->_gs;
if (!insertedParents.Includes(parent)) {
GSData* gd = (GSData*) cmd->Recall(parent);
*parent->GetGraphic() = *gd->_gs;
Iterator insertPt;
SetComp(kid, insertPt);
InsertBefore(insertPt, parent);
insertedParents.Append(parent);
}
Remove(kid);
parent->Append(kid);
}
Notify();
SelectClipboard(cb, ed);
unidraw->Update();
delete kids;
ucmd->SetKids(nil);
}
} else if (cmd->IsA(FRONT_CMD)) {
Component* edComp = cmd->GetEditor()->GetComponent();
if (edComp == (Component*) this) {
Clipboard* cb = cmd->GetClipboard();
Iterator i;
for (cb->Last(i); !cb->Done(i); cb->Prev(i)) {
RestorePosition((OverlayComp*)cb->GetComp(i), cmd);
}
Notify();
SelectClipboard(cb, ed);
unidraw->Update();
} else {
OverlayComp::Uninterpret(cmd);
}
} else if (cmd->IsA(BACK_CMD)) {
Component* edComp = cmd->GetEditor()->GetComponent();
if (edComp == (Component*) this) {
Clipboard* cb = cmd->GetClipboard();
Iterator i;
for (cb->First(i); !cb->Done(i); cb->Next(i)) {
RestorePosition((OverlayComp*)cb->GetComp(i), cmd);
}
Notify();
SelectClipboard(cb, ed);
unidraw->Update();
} else {
OverlayComp::Uninterpret(cmd);
}
} else {
OverlayComp::Uninterpret(cmd);
}
}
void OverlaysComp::Interpret (Command* cmd) {
Editor* ed = cmd->GetEditor();
if (
(cmd->IsA(DELETE_CMD) || cmd->IsA(CUT_CMD)) &&
ed->GetComponent() != this
) {
Iterator i;
for (First(i); !Done(i); Next(i)) {
GetComp(i)->Interpret(cmd);
}
} else if (cmd->IsA(DELETE_CMD)) {
Clipboard* cb = cmd->GetClipboard();
Selection* s = ed->GetSelection();
if (cb == nil) {
if (s->IsEmpty()) {
return;
}
cmd->SetClipboard(cb = new Clipboard);
cb->Init(s);
}
s->Clear();
Iterator i;
for (cb->First(i); !cb->Done(i); cb->Next(i)) {
OverlayComp* comp = (OverlayComp*)cb->GetComp(i);
unidraw->CloseDependents(comp);
comp->Interpret(cmd);
StorePosition(comp, cmd);
Remove(comp);
}
Notify();
unidraw->Update();
} else if (cmd->IsA(CUT_CMD)) {
Clipboard* cb = cmd->GetClipboard();
Selection* s = ed->GetSelection();
if (cb == nil) {
if (s->IsEmpty()) {
return;
}
GraphicView* views = ed->GetViewer()->GetGraphicView();
s->Sort(views);
cmd->SetClipboard(cb = new Clipboard);
cb->Init(s);
Clipboard* globalcb = unidraw->GetCatalog()->GetClipboard();
globalcb->DeleteComps();
globalcb->CopyInit(s);
}
s->Clear();
Iterator i;
for (cb->First(i); !cb->Done(i); cb->Next(i)) {
OverlayComp* comp = (OverlayComp*)cb->GetComp(i);
unidraw->CloseDependents(comp);
comp->Interpret(cmd);
StorePosition(comp, cmd);
Remove(comp);
}
Notify();
unidraw->Update();
} else if (cmd->IsA(PASTE_CMD)) {
Clipboard* cb = cmd->GetClipboard();
Iterator i;
if (cb == nil) {
Clipboard* globalcb = unidraw->GetCatalog()->GetClipboard();
if (globalcb->IsEmpty()) {
return;
}
cmd->SetClipboard(cb = globalcb->DeepCopy());
}
for (cb->First(i); !cb->Done(i); cb->Next(i)) {
Append((OverlayComp*)cb->GetComp(i));
}
Notify();
SelectClipboard(cb, ed);
unidraw->Update();
} else if (cmd->IsA(DUP_CMD)) {
GraphicView* views = ed->GetViewer()->GetGraphicView();
OverlayComp* prev, *dup1;
Iterator i, pos;
Clipboard* cb = cmd->GetClipboard();
const float offset = 8;
MoveCmd move(ed, offset, offset);
if (cb == nil) {
OverlaySelection* s = (OverlaySelection*)ed->GetSelection();
if (s->IsEmpty()) {
return;
}
cmd->SetClipboard(cb = new Clipboard);
s->Sort(views);
for (s->First(i); !s->Done(i); s->Next(i)) {
OverlayComp* orig = s->GetView(i)->GetOverlayComp();
dup1 = (OverlayComp*) orig->Copy();
if (!dup1->attrlist() && orig->attrlist()) {
AttributeList* al = new AttributeList(orig->attrlist());
dup1->SetAttributeList(al);
}
dup1->Interpret(&move);
cb->Append(dup1);
}
cb->First(i);
dup1 = (OverlayComp*) cb->GetComp(i);
Last(pos);
prev = (OverlayComp*) GetComp(pos);
cmd->Store(dup1, new VoidData(prev));
} else {
cb->First(i);
dup1 = (OverlayComp*) cb->GetComp(i);
VoidData* vd = (VoidData*) cmd->Recall(dup1);
prev = (OverlayComp*) vd->_void;
SetComp(prev, pos);
}
for (cb->Last(i); !cb->Done(i); cb->Prev(i)) {
InsertAfter(pos, cb->GetComp(i));
}
Notify();
SelectClipboard(cb, ed);
unidraw->Update();
} else if (cmd->IsA(OVGROUP_CMD)) {
OvGroupCmd* gcmd = (OvGroupCmd*) cmd;
OverlayComp* group = gcmd->GetGroup();
Component* edComp = gcmd->GetEditor()->GetComponent();
if (group == this) {
edComp->Interpret(gcmd);
} else if (edComp == (Component*) this) {
Clipboard* cb = cmd->GetClipboard();
NullGS(group->GetGraphic());
Group(cb, group, cmd);
Notify();
SelectViewsOf(group, ed);
unidraw->Update();
} else {
OverlayComp::Interpret(gcmd);
}
} else if (cmd->IsA(UNGROUP_CMD)) {
UngroupCmd* ucmd = (UngroupCmd*) cmd;
Component* edComp = ucmd->GetEditor()->GetComponent();
if (edComp == (Component*) this) {
Clipboard* cb = cmd->GetClipboard();
Clipboard* kids = new Clipboard;
ucmd->SetKids(kids);
Iterator i;
for (cb->First(i); !cb->Done(i); cb->Next(i)) {
OverlayComp* parent = (OverlayComp*)cb->GetComp(i);
unidraw->CloseDependents(parent);
Ungroup(parent, kids, cmd);
}
Notify();
SelectClipboard(kids, ed);
unidraw->Update();
} else {
cmd->GetClipboard()->Append(this);
}
} else if (cmd->IsA(PUSH_CMD) || cmd->IsA(PULL_CMD)) {
Component* edComp = cmd->GetEditor()->GetComponent();
if (edComp == (Component*) this) {
Clipboard* cb = cmd->GetClipboard();
Iterator i;
if (cmd->IsA(PULL_CMD)) {
for (cb->First(i); !cb->Done(i); cb->Next(i)) {
OverlayComp* comp = (OverlayComp*)cb->GetComp(i);
Iterator j;
SetComp(comp, j);
Next(j);
StorePosition(comp, cmd);
if (!Done(j)) {
Remove(comp);
InsertAfter(j, comp);
}
}
} else {
for (cb->Last(i); !cb->Done(i); cb->Prev(i)) {
OverlayComp* comp = (OverlayComp*) cb->GetComp(i);
Iterator j;
SetComp(comp, j);
Prev(j);
StorePosition(comp, cmd);
if (!Done(j)) {
Remove(comp);
InsertBefore(j, comp);
}
}
}
Notify();
unidraw->Update();
} else {
OverlayComp::Interpret(cmd);
}
} else if (cmd->IsA(FRONT_CMD) || cmd->IsA(BACK_CMD)) {
Component* edComp = cmd->GetEditor()->GetComponent();
if (edComp == (Component*) this) {
Clipboard* cb = cmd->GetClipboard();
Iterator i;
if (cmd->IsA(FRONT_CMD)) {
for (cb->First(i); !cb->Done(i); cb->Next(i)) {
OverlayComp* comp = (OverlayComp*)cb->GetComp(i);
StorePosition(comp, cmd);
Remove(comp);
Append(comp);
}
} else {
for (cb->Last(i); !cb->Done(i); cb->Prev(i)) {
OverlayComp* comp = (OverlayComp*) cb->GetComp(i);
StorePosition(comp, cmd);
Remove(comp);
Prepend(comp);
}
}
Notify();
unidraw->Update();
} else {
OverlayComp::Interpret(cmd);
}
} else {
OverlayComp::Interpret(cmd);
}
}
int DrawIdrawScript::ReadFrames (istream& in, void* addr1, void* addr2, void* addr3, void* addr4) {
FrameComp* frame;
FrameFileComp* framefile;
OverlayComp* child;
DrawIdrawComp* comps = (DrawIdrawComp*)addr1;
char buf1[BUFSIZ];
char buf2[BUFSIZ];
char* buf = buf1;
DrawCatalog* catalog = (DrawCatalog*)unidraw->GetCatalog();
int num_edge = (comps)->GetNumEdge();
int num_node = (comps)->GetNumNode();
catalog->graph_init(comps, num_edge, num_node);
FrameComp* bgframe = nil;
while (in.good()) {
frame = nil;
framefile = nil;
child = nil;
if (read_name(in, buf, BUFSIZ)) break;
int status;
if (status = read_gsptspic(buf, in, comps)) {
if (status==-1) break;
}
else if (strcmp(buf, "frame") == 0) {
frame = new FrameComp(in, comps);
if (!bgframe) bgframe = frame;
} else if (strcmp(buf, "framefile") == 0) framefile = new FrameFileComp(in, comps);
else {
if (!bgframe) {
bgframe = new FrameComp(comps);
comps->Append(bgframe);
}
child = read_obj(buf, in, bgframe);
if (!child) return -1;
}
if (frame != nil) {
if (in.good() && frame->valid()) {
comps->Append(frame);
} else {
/* report failure even if one child fails */
delete frame;
return -1;
}
}
if (framefile != nil) {
Iterator j;
framefile->First(j);
FrameIdrawComp* frameidraw = (FrameIdrawComp*)framefile->GetComp(j);
if (in.good() && frameidraw->valid()) {
Iterator i;
frameidraw->First(i);
frameidraw->Next(i);
while (!frameidraw->Done(i)) {
comps->Append((GraphicComp*)frameidraw->GetComp(i));
frameidraw->Next(i);
}
} else {
/* report failure even if one child fails */
delete framefile;
return -1;
}
}
if (child) {
if (in.good() && child->valid()) {
bgframe->Append(child);
} else {
/* report failure even if one child fails */
if (!*buf && (buf==buf1 ? *buf2 : *buf1))
cerr << "Error after reading " << (buf==buf1 ? buf2 : buf1) << "\n";
delete child;
return -1;
}
}
buf = buf==buf1 ? buf2 : buf1;
}
catalog->graph_finish();
return 0;
}
boolean OverlaysComp::operator == (OverlayComp& comp) {
if (GetClassId() != comp.GetClassId()) return false;
return SamePicture(&(OverlaysComp&)comp) &&
OverlayComp::operator==(comp);
}
boolean OverlayFileComp::operator == (OverlayComp& comp) {
if (GetClassId() != comp.GetClassId()) return false;
return
strcmp(GetPathName(), ((OverlayFileComp&)comp).GetPathName()) &&
OverlayComp::operator==(comp);
}
void DrawServ::ExecuteCmd(Command* cmd) {
static int grid_sym = symbol_add("grid");
static int sid_sym = symbol_add("sid");
boolean original = false;
unsigned int from_sid = 0;
if(!_linklist || _linklist->Number()==0)
/* normal Unidraw command execution */
Unidraw::ExecuteCmd(cmd);
else {
/* indirect command execution, all by script */
std::ostrstream sbuf;
boolean oldflag = OverlayScript::ptlist_parens();
OverlayScript::ptlist_parens(false);
switch (cmd->GetClassId()) {
case PASTE_CMD:
{
boolean scripted = false;
Clipboard* cb = cmd->GetClipboard();
if (cb) {
Iterator it;
for (cb->First(it); !cb->Done(it); cb->Next(it)) {
OverlayComp* comp = (OverlayComp*)cb->GetComp(it);
AttributeList* al = comp->GetAttributeList();
AttributeValue* idv = al->find(grid_sym);
AttributeValue* sidv = al->find(sid_sym);
from_sid = sidv ? sidv->uint_val() : 0;
/* unique id already remotely assigned */
if (idv && idv->uint_val() !=0 && sidv && sidv->uint_val() !=0) {
GraphicId* graphicid = new GraphicId();
graphicid->grcomp(comp);
graphicid->id(idv->uint_val());
graphicid->selector(sidv->uint_val());
graphicid->selected(LinkSelection::RemotelySelected);
}
/* generate unique id and add as attribute */
/* also mark with selector id */
else {
GraphicId* graphicid = new GraphicId(sessionid());
graphicid->grcomp(comp);
graphicid->selector(((DrawServ*)unidraw)->sessionid());
AttributeValue* gridv = new AttributeValue(graphicid->id(), AttributeValue::UIntType);
gridv->state(AttributeValue::HexState);
al->add_attr(grid_sym, gridv);
AttributeValue* sidv = new AttributeValue(graphicid->selector(), AttributeValue::UIntType);
sidv->state(AttributeValue::HexState);
al->add_attr(sid_sym, sidv);
original = true;
}
if (comp && (original || linklist()->Number()>1)) {
Creator* creator = unidraw->GetCatalog()->GetCreator();
OverlayScript* scripter = (OverlayScript*)
creator->Create(Combine(comp->GetClassId(), SCRIPT_VIEW));
if (scripter) {
scripter->SetSubject(comp);
if (scripted)
sbuf << ';';
else
scripted = true;
boolean status = scripter->Definition(sbuf);
delete scripter;
}
}
}
}
if (original || linklist()->Number()>1) {
if (!scripted)
sbuf << "print(\"Failed attempt to generate script for a PASTE_CMD\\n\" :err)";
sbuf.put('\0');
cout << sbuf.str() << "\n";
cout.flush();
}
/* first execute here */
#if 0
((ComEditor*)cmd->GetEditor())->GetComTerp()->run(sbuf.str());
((PasteCmd*)cmd)->executed(true);
#else
cmd->Execute();
#endif
/* then send everywhere else */
if (original || linklist()->Number()>1)
DistributeCmdString(sbuf.str(), linkget(from_sid));
}
break;
default:
sbuf << "print(\"Attempt to convert unknown command (id == %d) to interpretable script\\n\" " << cmd->GetClassId() << " :err)";
cmd->Execute();
break;
}
if (cmd->Reversible()) {
cmd->Log();
} else {
delete cmd;
}
OverlayScript::ptlist_parens(oldflag);
}
}