void RectView::GetCorners (Coord* x, Coord* y) {
SF_Rect* rect = (SF_Rect*) GetGraphic();
Coord tx[4], ty[4];
Transformer t;
rect->GetOriginal(tx[0], ty[0], tx[2], ty[2]);
rect->GetOriginal(tx[3], ty[1], tx[1], ty[3]);
rect->TotalTransformation(t);
t.TransformList((Coord*) tx, (Coord*) ty, 4, x, y);
}
void RectView::Interpret (Command* cmd) {
if (cmd->IsA(ALIGNTOGRID_CMD)) {
SF_Rect* rect = (SF_Rect*) GetGraphic();
Transformer total;
rect->TotalTransformation(total);
Coord x0, y0, x1, y1;
float tx0, ty0;
rect->GetOriginal(x0, y0, x1, y1);
total.Transform(float(x0), float(y0), tx0, ty0);
((AlignToGridCmd*) cmd)->Align(this, tx0, ty0);
} else {
GraphicView::Interpret(cmd);
}
}
void RectComp::Write (ostream& out) {
GraphicComp::Write(out);
SF_Rect* rect = GetRect();
Coord x0, y0, x1, y1;
rect->GetOriginal(x0, y0, x1, y1);
out << x0 << " " << y0 << " " << x1 << " " << y1 << " ";
WriteBgFilled(rect->BgFilled(), out);
WriteColor(rect->GetFgColor(), out);
WriteColor(rect->GetBgColor(), out);
WriteBrush(rect->GetBrush(), out);
WritePattern(rect->GetPattern(), out);
WriteTransformer(rect->GetTransformer(), out);
}
void CreateRectFunc::execute() {
const int x0 = 0;
const int y0 = 1;
const int x1 = 2;
const int y1 = 3;
const int n = 4;
int coords[n];
ComValue& vect = stack_arg(0);
if (!vect.is_type(ComValue::ArrayType) || vect.array_len() != n) {
reset_stack();
push_stack(ComValue::nullval());
return;
}
ALIterator i;
AttributeValueList* avl = vect.array_val();
avl->First(i);
for (int j=0; j<n && !avl->Done(i); j++) {
coords[j] = avl->GetAttrVal(i)->int_val();
avl->Next(i);
}
AttributeList* al = stack_keys();
Resource::ref(al);
reset_stack();
PasteCmd* cmd = nil;
if (coords[x0] != coords[x1] || coords[y0] != coords[y1]) {
BrushVar* brVar = (BrushVar*) _ed->GetState("BrushVar");
PatternVar* patVar = (PatternVar*) _ed->GetState("PatternVar");
ColorVar* colVar = (ColorVar*) _ed->GetState("ColorVar");
Transformer* rel = get_transformer(al);
SF_Rect* rect = new SF_Rect(coords[x0], coords[y0], coords[x1], coords[y1], stdgraphic);
if (brVar != nil) rect->SetBrush(brVar->GetBrush());
if (patVar != nil) rect->SetPattern(patVar->GetPattern());
if (colVar != nil) {
rect->FillBg(!colVar->GetBgColor()->None());
rect->SetColors(colVar->GetFgColor(), colVar->GetBgColor());
}
rect->SetTransformer(rel);
Unref(rel);
RectOvComp* comp = new RectOvComp(rect);
comp->SetAttributeList(al);
if (PasteModeFunc::paste_mode()==0)
cmd = new PasteCmd(_ed, new Clipboard(comp));
ComValue compval(new OverlayViewRef(comp), symbol_add("RectComp"));
push_stack(compval);
execute_log(cmd);
} else
push_stack(ComValue::nullval());
Unref(al);
}
void RectComp::Read (istream& in) {
GraphicComp::Read(in);
Coord x0, y0, x1, y1;
in >> x0 >> y0 >> x1 >> y1;
SF_Rect* rect = new SF_Rect(x0, y0, x1, y1);
rect->FillBg(ReadBgFilled(in));
PSColor* fg = ReadColor(in);
PSColor* bg = ReadColor(in);
rect->SetColors(fg, bg);
rect->SetBrush(ReadBrush(in));
rect->SetPattern(ReadPattern(in));
Transformer* t = ReadTransformer(in);
rect->SetTransformer(t);
Unref(t);
SetGraphic(rect);
}
Command* RectView::InterpretManipulator (Manipulator* m) {
DragManip* dm = (DragManip*) m;
Editor* ed = dm->GetViewer()->GetEditor();
Tool* tool = dm->GetTool();
Transformer* rel = dm->GetTransformer();
Command* cmd = nil;
if (tool->IsA(GRAPHIC_COMP_TOOL)) {
RubberRect* rr = (RubberRect*) dm->GetRubberband();
Coord x0, y0, x1, y1;
rr->GetCurrent(x0, y0, x1, y1);
if (x0 != x1 || y0 != y1) {
BrushVar* brVar = (BrushVar*) ed->GetState("BrushVar");
PatternVar* patVar = (PatternVar*) ed->GetState("PatternVar");
ColorVar* colVar = (ColorVar*) ed->GetState("ColorVar");
if (rel != nil) {
rel = new Transformer(rel);
rel->Invert();
}
Graphic* pg = GetGraphicComp()->GetGraphic();
SF_Rect* rect = new SF_Rect(x0, y0, x1, y1, pg);
if (brVar != nil) rect->SetBrush(brVar->GetBrush());
if (patVar != nil) rect->SetPattern(patVar->GetPattern());
if (colVar != nil) {
rect->SetColors(colVar->GetFgColor(), colVar->GetBgColor());
}
rect->SetTransformer(rel);
Unref(rel);
cmd = new PasteCmd(ed, new Clipboard(new RectComp(rect)));
}
} else if (tool->IsA(RESHAPE_TOOL)) {
RubberGroup* rubberGroup = (RubberGroup*) dm->GetRubberband();
RubberLine* rubberLine = (RubberLine*) rubberGroup->First();
SF_Polygon* polygon;
Coord x[4], y[4];
Coord x0, y0;
GetCorners(x, y);
rubberLine->GetCurrent(x0, y0, x[_reshapeCorner], y[_reshapeCorner]);
if (rel != nil) {
rel = new Transformer(rel);
rel->Invert();
}
polygon = new SF_Polygon(x, y, 4, GetGraphic());
polygon->SetTransformer(rel);
Unref(rel);
cmd = new ReplaceCmd(ed, new PolygonComp(polygon));
} else if (tool->IsA(MOVE_TOOL)) {
SlidingLineList* sll;
Transformer* rel = dm->GetTransformer();
Coord* ox, *oy, *cx, *cy;
float fx0, fy0, fx1, fy1;
int n;
sll = (SlidingLineList*) dm->GetRubberband();
sll->GetOriginal(ox, oy, n);
sll->GetCurrent(cx, cy, n);
if (rel != nil) {
rel->InvTransform(float(ox[0]), float(oy[0]), fx0, fy0);
rel->InvTransform(float(cx[0]), float(cy[0]), fx1, fy1);
}
delete ox; delete oy; delete cx; delete cy;
cmd = new MoveCmd(ed, fx1 - fx0, fy1 - fy0);
} else if (tool->IsA(SCALE_TOOL)) {
ScalingLineList* sll = (ScalingLineList*) dm->GetRubberband();
float sxy = sll->CurrentScaling();
cmd = new ScaleCmd(ed, sxy, sxy);
} else if (tool->IsA(ROTATE_TOOL)) {
RotatingLineList* rll = (RotatingLineList*) dm->GetRubberband();
float angle = rll->CurrentAngle() - rll->OriginalAngle();
cmd = new RotateCmd(ed, angle);
} else {
cmd = GraphicView::InterpretManipulator(m);
}
return cmd;
}