void AlignToGridCmd::Align (GraphicView* gv, float refx, float refy) {
MoveData* md = (MoveData*) Recall(gv->GetGraphicComp());
if (md == nil) {
Viewer* v = gv->GetViewer();
Grid* grid = (v == nil) ? nil : v->GetGrid();
if (grid == nil) {
return;
}
Graphic* g = gv->GetGraphic();
Transformer t;
g->Parent()->TotalTransformation(t);
t.Invert();
Coord cx = iv26_round(refx);
Coord cy = iv26_round(refy);
grid->Constrain(cx, cy);
float dx, dy, trefx, trefy;
t.Transform(float(cx), float(cy), dx, dy);
t.Transform(refx, refy, trefx, trefy);
dx -= trefx;
dy -= trefy;
Store(gv->GetGraphicComp(), new MoveData(dx, dy));
}
Move(gv->GetGraphicComp());
}
Command* PinView::InterpGraphicCompManip (Manipulator* m) {
DragManip* dm = (DragManip*) m;
Editor* ed = dm->GetViewer()->GetEditor();
BrushVar* brVar = (BrushVar*) ed->GetState("Brush");
SlidingPin* sp = (SlidingPin*) dm->GetRubberband();
Transformer* rel = dm->GetTransformer();
Coord px, py, dum;
float dx, dy;
PinGraphic* pinGraphic;
sp->GetCurrent(px, py, dum, dum);
if (rel != nil) {
GetOffset(rel, px, py, dx, dy);
rel = new Transformer;
rel->Translate(dx, dy);
}
Graphic* pg = GetGraphicComp()->GetGraphic();
pinGraphic = new PinGraphic(px, py, pg);
if (brVar != nil) pinGraphic->SetBrush(brVar->GetBrush());
pinGraphic->SetTransformer(rel);
Unref(rel);
return new PasteCmd(ed, new Clipboard(NewSubject(pinGraphic)));
}
bool RasterRect::intersects (BoxObj& userb, Graphic* gs) {
Transformer* t = gs->GetTransformer();
Coord xmax = _raster->Width();
Coord ymax = _raster->Height();
Coord tx0, ty0, tx1, ty1;
if (t != nil && t->Rotated()) {
Coord x[4], tx[5];
Coord y[4], ty[5];
x[0] = x[3] = y[0] = y[1] = 0;
x[2] = x[1] = xmax;
y[2] = y[3] = ymax;
transformList(x, y, 4, tx, ty, gs);
tx[4] = tx[0];
ty[4] = ty[0];
FillPolygonObj fp (tx, ty, 5);
return fp.Intersects(userb);
} else if (t != nil) {
t->Transform(0, 0, tx0, ty0);
t->Transform(xmax, ymax, tx1, ty1);
BoxObj b1 (tx0, ty0, tx1, ty1);
return b1.Intersects(userb);
} else {
BoxObj b2 (0, 0, xmax, ymax);
return b2.Intersects(userb);
}
}
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);
}
}
}
}
}
static Transformer* ComputeRel (Viewer* v, Transformer* t) {
Transformer* rel = new Transformer;
GraphicComp* comp = v->GetGraphicView()->GetGraphicComp();
comp->GetGraphic()->TotalTransformation(*rel);
rel->Postmultiply(t);
return rel;
}
Transformer* CreateGraphicFunc::get_transformer(AttributeList* al) {
static int transform_symid = symbol_add("transform");
AttributeValue* transformv = nil;
Transformer* rel = nil;
AttributeValueList* avl = nil;
if (al &&
(transformv=al->find(transform_symid)) &&
transformv->is_array() &&
(avl=transformv->array_val()) &&
avl->Number()==6) {
float a00, a01, a10, a11, a20, a21;
Iterator it;
avl->First(it); a00=avl->GetAttrVal(it)->float_val();
avl->Next(it); a01=avl->GetAttrVal(it)->float_val();
avl->Next(it); a10=avl->GetAttrVal(it)->float_val();
avl->Next(it); a11=avl->GetAttrVal(it)->float_val();
avl->Next(it); a20=avl->GetAttrVal(it)->float_val();
avl->Next(it); a21=avl->GetAttrVal(it)->float_val();
rel = new Transformer(a00, a01, a10, a11, a20, a21);
} else {
rel = ((OverlayViewer*)_ed->GetViewer())->GetRel();
if (rel != nil) {
rel = new Transformer(rel);
rel->Invert();
}
}
return rel;
}
LinkComp::LinkComp (Line* line) {
if (line != nil) {
Coord x0, y0, x1, y1;
float fx0, fy0, fx1, fy1;
line->GetOriginal(x0, y0, x1, y1);
Transformer* t = line->GetTransformer();
Graphic* parent = new Picture(line);
parent->SetTransformer(nil);
if (t == nil) {
fx0 = x0; fy0 = y0; fx1 = x1; fy1 = y1;
} else {
t->Transform(float(x0), float(y0), fx0, fy0);
t->Transform(float(x1), float(y1), fx1, fy1);
}
delete line;
line = new Line(0, 0, 1, 1);
InitLine(line, fx0, fy0, fx1, fy1);
PinGraphic* pg1 = new PinGraphic;
PinGraphic* pg2 = new PinGraphic;
pg1->SetBrush(psnonebr);
pg2->SetBrush(psnonebr);
pg1->Translate(fx0, fy0);
pg2->Translate(fx1, fy1);
_conn1 = new PinComp(pg1);
_conn2 = new PinComp(pg2);
parent->Append(line, pg1, pg2);
SetGraphic(parent);
}
}
void View::transform(
Transformer& t, const Allocation& a, const Allocation&
) const {
scene2view(a);
const Allotment& ax = a.x_allotment();
const Allotment& ay = a.y_allotment();
csize(ax.begin(), ax.span(), ay.begin(), ay.span());
float sx = ax.span()/XYView::width();
float sy = ay.span()/XYView::height();
// if (sx > sy) sx = sy;
t.translate( -x(), -y());
t.scale(sx, sx);
View* v = (View*)this;
v->x_pick_epsilon_ = pick_epsilon/sx;
v->y_pick_epsilon_ = pick_epsilon/sx;
t.translate((ax.begin() + ax.end())/2,(ay.begin() + ay.end())/2);
//printf("\nx origin=%g span=%g alignment=%g begin=%g end=%g\n", ax.origin(), ax.span(), ax.alignment(), ax.begin(), ax.end());
//printf("\ny origin=%g span=%g alignment=%g begin=%g end=%g\n", ay.origin(), ay.span(), ay.alignment(), ay.begin(), ay.end());
Coord x1,y1;
t.transform(x() - x_span_/2, y() - y_span_/2, x1, y1);
if (!Math::equal(ax.begin(), x1, 1) || !Math::equal(ay.begin(), y1, 1)) {
t.inverse_transform(ax.begin(), ay.begin(), x1, y1);
v->x_span_ = 2*(x() - x1);
v->y_span_ = 2*(y() - y1);
v->size(x1,y1,x1+v->x_span_, y1+v->y_span_);
}
}
void Graphic::invTransform (Coord& tx, Coord& ty, Graphic* g) {
Transformer* t = (g == nil) ? GetTransformer() : g->GetTransformer();
if (t != nil) {
t->InvTransform(tx, ty);
}
}
Command* PadView::InterpGraphicCompManip (Manipulator* m) {
Command* cmd = nil;
DragManip* dm = (DragManip*) m;
SlidingRect* sr = (SlidingRect*) dm->GetRubberband();
Coord l, b, r, t;
sr->GetCurrent(l, b, r, t);
if (l != r || b != t) {
DragManip* dm = (DragManip*) m;
Editor* ed = dm->GetViewer()->GetEditor();
BrushVar* brVar = (BrushVar*) ed->GetState("Brush");
Transformer* rel = dm->GetTransformer();
if (rel != nil) {
rel = new Transformer(rel);
rel->Invert();
}
Graphic* pg = GetGraphicComp()->GetGraphic();
PadGraphic* padGraphic = new PadGraphic(l, b, r, t, pg);
if (brVar != nil) padGraphic->SetBrush(brVar->GetBrush());
padGraphic->SetTransformer(rel);
Unref(rel);
cmd = new PasteCmd(ed, new Clipboard(NewSubject(padGraphic)));
}
return cmd;
}
void Graphic::transform (Coord& x, Coord& y, Graphic* g) {
Transformer* t = (g == nil) ? GetTransformer() : g->GetTransformer();
if (t != nil) {
t->Transform(x, y);
}
}
void LineView::GetEndpoints (Coord& x0, Coord& y0, Coord& x1, Coord& y1) {
Line* line = (Line*) GetGraphic();
Transformer t;
line->GetOriginal(x0, y0, x1, y1);
line->TotalTransformation(t);
t.Transform(x0, y0);
t.Transform(x1, y1);
}
Command* TextOvView::InterpretManipulator (Manipulator* m) {
Viewer* v = m->GetViewer();
Editor* ed = v->GetEditor();
Tool* tool = m->GetTool();
Command* cmd = nil;
if (tool->IsA(GRAPHIC_COMP_TOOL) || tool->IsA(RESHAPE_TOOL)) {
TextManip* tm = (TextManip*) m;
int size;
const char* text = tm->GetText(size);
if (size == 0) {
if (tool->IsA(RESHAPE_TOOL)) {
cmd = new OvDeleteCmd(ed);
} else {
v->Update(); // to repair text display-incurred damage
}
} else {
Coord xpos, ypos;
tm->GetPosition(xpos, ypos);
Painter* p = tm->GetPainter();
Transformer* rel = tm->GetPainter()->GetTransformer();
int lineHt = tm->GetLineHeight();
Graphic* pg = GetGraphicComp()->GetGraphic();
TextGraphic* textgr = new TextGraphic(text, lineHt, pg);
if (tool->IsA(GRAPHIC_COMP_TOOL)) {
textgr->SetTransformer(nil);
}
if (rel != nil) {
if (v->GetOrientation()==Rotated && !tool->IsA(RESHAPE_TOOL))
rel->Rotate(-90);
rel->InvTransform(xpos, ypos);
}
if (v->GetOrientation()==Rotated && !tool->IsA(RESHAPE_TOOL))
textgr->Rotate(90.0);
textgr->Translate(xpos, ypos);
textgr->FillBg(false);
textgr->SetFont((PSFont*) p->GetFont());
textgr->SetColors((PSColor*) p->GetFgColor(), nil);
if (tool->IsA(GRAPHIC_COMP_TOOL)) {
cmd = new PasteCmd(ed, new Clipboard(new TextOvComp(textgr)));
} else {
cmd = new ReplaceCmd(ed, new TextOvComp(textgr));
}
}
} else {
cmd = OverlayView::InterpretManipulator(m);
}
return cmd;
}
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 Graphic::transform (Coord x, Coord y, Coord& tx, Coord& ty, Graphic* g) {
Transformer* t = (g == nil) ? GetTransformer() : g->GetTransformer();
if (t != nil) {
t->Transform(x, y, tx, ty);
} else {
tx = x;
ty = y;
}
}
boolean Vertices::GetPoint (int index, Coord& px, Coord& py) {
if (index<0 || index>=count()) return false;
Coord tx, ty;
Transformer t;
tx = x()[index];
ty = y()[index];
TotalTransformation(t);
t.Transform(tx, ty, px, py);
return true;
}
void Graphic::transform (float x, float y, float& tx, float& ty, Graphic* g) {
Transformer* t = (g == nil) ? GetTransformer() : g->GetTransformer();
if (t != nil) {
t->Transform(x, y, tx, ty);
} else {
tx = x;
ty = y;
}
}
// constructor
Shape::Shape(const Shape& other)
#ifdef ICON_O_MATIC
: IconObject(other),
Transformable(other),
Observer(),
PathContainerListener(),
#else
: Transformable(other),
#endif
fPaths(new (nothrow) PathContainer(false)),
fStyle(NULL),
fPathSource(fPaths),
fTransformers(4),
fNeedsUpdate(true),
fLastBounds(0, 0, -1, -1),
fHinting(other.fHinting),
fMinVisibilityScale(other.fMinVisibilityScale),
fMaxVisibilityScale(other.fMaxVisibilityScale)
#ifdef ICON_O_MATIC
, fListeners(8)
#endif
{
SetStyle(other.fStyle);
if (fPaths) {
#ifdef ICON_O_MATIC
fPaths->AddListener(this);
#endif
// copy the path references from
// the other shape
if (other.fPaths) {
int32 count = other.fPaths->CountPaths();
for (int32 i = 0; i < count; i++) {
if (!fPaths->AddPath(other.fPaths->PathAtFast(i)))
break;
}
}
}
// clone vertex transformers
int32 count = other.CountTransformers();
for (int32 i = 0; i < count; i++) {
Transformer* original = other.TransformerAtFast(i);
Transformer* cloned = original->Clone(fPathSource);
if (!AddTransformer(cloned)) {
delete cloned;
break;
}
}
}
void Viewer::IncurTextDisplayDamage (TextDisplay* td, Painter* p) {
Coord l, b, r, t;
td->Bounds(l, b, r, t);
--l; --b; ++r; ++t;
Transformer* rel = p->GetTransformer();
if (rel != nil) rel->TransformRect(l, b, r, t);
_damage->Incur(l, b, r, t);
}
void Graphic::invTransformRect (
float x0, float y0, float x1, float y1,
float& nx0, float& ny0, float& nx1, float& ny1, Graphic* g
) {
Transformer* t = (g == nil) ? GetTransformer() : g->GetTransformer();
nx0 = x0; ny0 = y0; nx1 = x1; ny1 = y1;
if (t != nil) {
t->InvTransformRect(nx0, ny0, nx1, ny1);
}
}
void Graphic::invTransformList(
Coord tx[], Coord ty[], int n, Coord x[], Coord y[], Graphic* g
) {
Transformer* t = (g == nil) ? GetTransformer() : g->GetTransformer();
if (t != nil) {
t->InvTransformList(tx, ty, n, x, y);
} else {
ArrayCopy(tx, ty, n, x, y);
}
}
void Graphic::invTransform (
Coord tx, Coord ty, Coord& x, Coord& y, Graphic* g
) {
Transformer* t = (g == nil) ? GetTransformer() : g->GetTransformer();
if (t != nil) {
t->InvTransform(tx, ty, x, y);
} else {
x = tx;
y = ty;
}
}
void do_draw (
Painter* painter, Canvas* canvas, float rotate, float scalex, float scaley
) {
Transformer* oldt = painter->GetTransformer();
Transformer t;
t.Rotate(rotate);
t.Scale(scalex, scaley);
painter->SetTransformer(&t);
painter->FillPolygon(canvas, poly1_x, poly1_y, poly1_count);
painter->FillPolygon(canvas, poly2_x, poly2_y, poly2_count);
painter->SetTransformer(oldt);
}
void Graphic::invTransform (
float tx, float ty, float& x, float& y, Graphic* g
) {
Transformer* t = (g == nil) ? GetTransformer() : g->GetTransformer();
if (t != nil) {
t->InvTransform(tx, ty, x, y);
} else {
x = tx;
y = ty;
}
}
void TextManip::PlaceTextDisplay (Coord xpos, Coord ypos) {
GetViewer()->InitTextDisplay(_display, _painter);
Transformer* rel = _painter->GetTransformer();
if (rel != nil) rel->InvTransform(xpos, ypos);
int l = xpos;
int r = l + _display->Width();
int t = ypos + _lineHt-1;
int b = t - _display->Height();
_display->Resize(l, b, r, t);
}
void TextView::Interpret (Command* cmd) {
if (cmd->IsA(ALIGNTOGRID_CMD)) {
Transformer total;
GetGraphic()->TotalTransformation(total);
float tx0, ty0;
total.Transform(0., 0., tx0, ty0);
((AlignToGridCmd*) cmd)->Align(this, tx0, ty0);
} else {
GraphicView::Interpret(cmd);
}
}
static void corners(
Coord& left, Coord& bottom, Coord& right, Coord& top, const Transformer& t
) {
Coord x1, y1, x2, y2, x3, y3, x4, y4;
t.transform(left, bottom, x1, y1);
t.transform(left, top, x2, y2);
t.transform(right, top, x3, y3);
t.transform(right, bottom, x4, y4);
left = Math::min(x1, x2, x3, x4);
bottom = Math::min(y1, y2, y3, y4);
right = Math::max(x1, x2, x3, x4);
top = Math::max(y1, y2, y3, y4);
}
void Logo::DrawBitmap () {
Transformer* oldt = output->GetTransformer();
Transformer t;
t.Scale(float(xmax+1)/bitmap->Width(), float(ymax+1)/bitmap->Height());
output->SetTransformer(&t);
output->Stencil(
canvas, -bitmap->Left(), -bitmap->Bottom(), bitmap, bitmap
);
output->SetTransformer(oldt);
output->SetOrigin(0, 0);
}
void XYView::transform(
Transformer& t, const Allocation& a, const Allocation& n
) const {
#if 0
Allotment ax, ay;
if (view_margin()) {
const Allotment& alx = a.x_allotment();
ax.span(alx.span() - 2*view_margin());
ax.origin(alx.begin() + view_margin());
ax.alignment(0);
const Allotment& aly = a.y_allotment();
ay.span(aly.span() - 2*view_margin());
ay.origin(aly.begin() + view_margin());
ay.alignment(0);
} else {
ax = a.x_allotment();
ay = a.y_allotment();
}
Allocation al;
al.allot_x(ax);
al.allot_y(ay);
scene2view(al);
#else
scene2view(a);
const Allotment& ax = a.x_allotment();
const Allotment& ay = a.y_allotment();
#endif
const Allotment& nx = n.x_allotment();
const Allotment& ny = n.y_allotment();
XYView* v = (XYView*)this;
csize(ax.begin(), ax.span(), ay.begin(), ay.span());
float sx = xsize_/width();
float sy = ysize_/height();
XYView* xv = (XYView*)this;
xv->x_pick_epsilon_ = pick_epsilon/sx;
xv->y_pick_epsilon_ = pick_epsilon/sy;
t.translate( -left(), -bottom());
t.scale(sx, sy);
t.translate(ax.begin(), ay.begin());
#if 0
printf("XYView::transform ax origin=%g span=%g alignment=%g begin=%g\n",
ax.origin(), ax.span(), ax.alignment(), ax.begin());
printf("XYView::transform ay origin=%g span=%g alignment=%g begin=%g %g\n",
ay.origin(), ay.span(), ay.alignment(), ay.begin(), ay.end());
printf("XYView::transform natx origin=%g span=%g alignment=%g begin=%g\n",
nx.origin(), nx.span(), nx.alignment(), nx.begin());
printf("XYView::transform naty origin=%g span=%g alignment=%g begin=%g %g\n",
ny.origin(), ny.span(), ny.alignment(), ny.begin(), ny.end());
#endif
}
boolean TextManip::Contains (Coord x, Coord y) {
Transformer* rel = _painter->GetTransformer();
if (rel != nil) rel->InvTransform(x, y);
int line = _display->LineNumber(y);
int index = _display->LineIndex(line, x);
return
x >= _display->Left(line, _text->BeginningOfLine(index)) &&
x <= _display->Right(line, _text->EndOfLine(index)) &&
y >= _display->Base(line) &&
y <= _display->Top(line);
}