void Viewer::Update () {
Selection* s = GetSelection();
GraphicView* view = GetGraphicView();
Component* viewComp = view->GetGraphicComp();
Component* edComp = _editor->GetComponent();
if (viewComp != edComp) {
ComponentView* newView = edComp->Create(ViewCategory());
if (newView->IsA(GRAPHIC_VIEW)) {
edComp->Attach(newView);
newView->Update();
SetGraphicView((GraphicView*) newView);
} else {
delete newView;
}
} else {
s->Hide(this);
_viewerView->Update();
GraphicBlock::UpdatePerspective();
_damage->Repair();
s->Show(this);
}
}
void AttributeValue::dup_as_needed() {
if (_type == AttributeValue::ArrayType) {
AttributeValueList* avl = _v.arrayval.ptr;
_v.arrayval.ptr = new AttributeValueList(avl);
Resource::ref(_v.arrayval.ptr);
Resource::unref(avl);
} else if (_type == AttributeValue::StreamType) {
AttributeValueList* avl = _v.streamval.listptr;
_v.streamval.listptr = new AttributeValueList(avl);
Resource::ref(_v.streamval.listptr);
Resource::unref(avl);
}
#ifdef RESOURCE_COMPVIEW
else if (_type == AttributeValue::ObjectType && object_compview()) {
ComponentView* oldview = (ComponentView*)_v.objval.ptr;
Component* subject = oldview->GetSubject();
ComponentView* newview = oldview->Duplicate();
newview->SetSubject(subject);
subject->Attach(newview);
_v.objval.ptr = newview;
Resource::ref(newview);
Resource::unref(oldview);
}
#endif
}
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 DeleteFunc::execute() {
Viewer* viewer = _ed->GetViewer();
int nf=nargsfixed();
if (nf==0) {
reset_stack();
return;
}
Clipboard* delcb = new Clipboard();
for (int i=0; i<nf; i++) {
ComValue& obj = stack_arg(i);
if (obj.object_compview()) {
ComponentView* comview = (ComponentView*)obj.obj_val();
OverlayComp* comp = (OverlayComp*)comview->GetSubject();
if (comp) delcb->Append(comp);
}
}
DeleteCmd* delcmd = new DeleteCmd(GetEditor(), delcb);
delcmd->Execute();
unidraw->Update();
delete delcmd;
reset_stack();
}
OverlayView* OverlayComp::FindView (Viewer* viewer) {
if (!_views) return nil;
for (UList* u = _views->First(); u != _views->End(); u = u->Next()) {
ComponentView* compview = View(u);
if (compview->IsA(OVERLAY_VIEW) &&
((OverlayView*)compview)->GetViewer() == viewer)
return (OverlayView*)compview;
}
return nil;
}
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 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);
}
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 OverlayComp::Interpret(Command* cmd) {
Editor* ed = cmd->GetEditor();
if (cmd->IsA(UNHIDE_VIEWS_CMD) || cmd->IsA(SENSITIZE_VIEWS_CMD)) {
for (UList* u = _views->First(); u != _views->End(); u = u->Next()) {
ComponentView* compview = View(u);
if (compview->IsA(OVERLAY_VIEW)) {
((OverlayView*)compview)->Sensitize();
if (cmd->IsA(UNHIDE_VIEWS_CMD))
((OverlayView*)compview)->Show();
}
}
Notify();
} else {
GraphicComp::Interpret(cmd);
}
}
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();
}
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);
}