public void Start(Point pos)
{
_startPos = pos;
switch (DrawStepType)
{
case DrawStep.DrawStepType.DrawRect:
_nowDrawing = StartDrawRect();
break;
case DrawStep.DrawStepType.DrawEllipse:
_nowDrawing = StartDrawEllipse();
break;
case DrawStep.DrawStepType.DrawLine:
_nowDrawing = StartDrawLine();
break;
case DrawStep.DrawStepType.DrawText:
_nowDrawing = StartDrawText();
break;
}
StepManager.InsertNext(_nowDrawing);
if (_nowDrawing.Iterations != -1)
{
StepManager.RefreshToCurrentStep();
}
}
private void ScaleText(TextFigure tf, Point pos)
{
if (_nowScaling == null)
{
_originalX = tf.X.CachedValue.AsDouble;
_originalY = tf.Y.CachedValue.AsDouble;
_originalW = tf.Width.CachedValue.AsDouble;
_originalH = tf.Height.CachedValue.AsDouble;
var snappedTo = StepManager.SnapTo(pos, tf.GetMagnets(), tf.Center);
var bLenSquared = _originalW * _originalW + _originalH * _originalH;
if ((snappedTo == tf.Start) && (Math.Abs(bLenSquared) > Utils.Tolerance))
{
var ax = _originalX + _originalW - pos.X;
var ay = _originalY + _originalH - pos.Y;
_nowScaling = new ScaleTextStep(tf, ScaleTextStep.Side.End,
(ax * _originalW + ay * _originalH) / bLenSquared);
}
else if ((snappedTo == tf.End) && (Math.Abs(bLenSquared) > Utils.Tolerance))
{
var ax = pos.X - _originalX;
var ay = pos.Y - _originalY;
_nowScaling = new ScaleTextStep(tf, ScaleTextStep.Side.Start,
(ax * _originalW + ay * _originalH) / bLenSquared);
}
if (_nowScaling == null)
{
return;
}
StepManager.InsertNext(_nowScaling);
}
else
{
var sts = (ScaleTextStep)_nowScaling;
if (sts.ScaleAround == ScaleTextStep.Side.Start)
{
var bLenSquared = _originalW * _originalW + _originalH * _originalH;
var ax = pos.X - _originalX;
var ay = pos.Y - _originalY;
sts.Scale((ax * _originalW + ay * _originalH) / bLenSquared);
}
else if (sts.ScaleAround == ScaleTextStep.Side.End)
{
var bLenSquared = _originalW * _originalW + _originalH * _originalH;
var ax = _originalX + _originalW - pos.X;
var ay = _originalY + _originalH - pos.Y;
sts.Scale((ax * _originalW + ay * _originalH) / bLenSquared);
}
}
}
private void ScaleEllipse(EllipseFigure ef, Point pos)
{
if (_nowScaling == null)
{
_originalW = ef.Radius1.CachedValue.AsDouble;
_originalH = ef.Radius2.CachedValue.AsDouble;
var snappedTo = StepManager.SnapTo(pos, ef.GetMagnets(), ef.Center);
if ((snappedTo == ef.Left) && (Math.Abs(_originalW) > Utils.Tolerance))
{
_nowScaling = new ScaleEllipseStep(ef, ScaleEllipseStep.Side.Right,
1 - (pos.X - _downPos.X) / _originalW);
}
else if ((snappedTo == ef.Right) && (Math.Abs(_originalW) > Utils.Tolerance))
{
_nowScaling = new ScaleEllipseStep(ef, ScaleEllipseStep.Side.Left,
1 + (pos.X - _downPos.X) / _originalW);
}
else if ((snappedTo == ef.Top) && (Math.Abs(_originalH) > Utils.Tolerance))
{
_nowScaling = new ScaleEllipseStep(ef, ScaleEllipseStep.Side.Bottom,
1 - (pos.Y - _downPos.Y) / _originalH);
}
else if ((snappedTo == ef.Bottom) && (Math.Abs(_originalH) > Utils.Tolerance))
{
_nowScaling = new ScaleEllipseStep(ef, ScaleEllipseStep.Side.Top,
1 + (pos.Y - _downPos.Y) / _originalH);
}
if (_nowScaling == null)
{
return;
}
StepManager.InsertNext(_nowScaling);
}
else
{
var srs = (ScaleEllipseStep)_nowScaling;
if (srs.ScaleAround == ScaleEllipseStep.Side.Right)
{
srs.Scale(1 - (pos.X - _downPos.X) / _originalW);
}
else if (srs.ScaleAround == ScaleEllipseStep.Side.Left)
{
srs.Scale(1 + (pos.X - _downPos.X) / _originalW);
}
else if (srs.ScaleAround == ScaleEllipseStep.Side.Top)
{
srs.Scale(1 + (pos.Y - _downPos.Y) / _originalH);
}
else if (srs.ScaleAround == ScaleEllipseStep.Side.Bottom)
{
srs.Scale(1 - (pos.Y - _downPos.Y) / _originalH);
}
}
}
private void RotateText(TextFigure tf, Point pos)
{
if (_nowRotating == null)
{
var snappedTo = StepManager.SnapTo(pos, tf.GetMagnets(), tf.Center);
if (snappedTo == tf.Start)
{
var angle = Utils.AngleBetween(tf.X.CachedValue.AsDouble + tf.Width.CachedValue.AsDouble - pos.X,
tf.Y.CachedValue.AsDouble + tf.Height.CachedValue.AsDouble - pos.Y,
tf.Width.CachedValue.AsDouble,
tf.Height.CachedValue.AsDouble);
_nowRotating = new RotateTextStep(tf, RotateTextStep.Side.End,
angle / (2 * Math.PI));
}
else if (snappedTo == tf.End)
{
var angle = Utils.AngleBetween(pos.X - tf.X.CachedValue.AsDouble, pos.Y - tf.Y.CachedValue.AsDouble,
tf.Width.CachedValue.AsDouble, tf.Height.CachedValue.AsDouble);
_nowRotating = new RotateTextStep(tf, RotateTextStep.Side.Start,
angle / (2 * Math.PI));
}
if (_nowRotating == null)
{
return;
}
_originalX = tf.X.CachedValue.AsDouble;
_originalY = tf.Y.CachedValue.AsDouble;
_originalW = tf.Width.CachedValue.AsDouble;
_originalH = tf.Height.CachedValue.AsDouble;
StepManager.InsertNext(_nowRotating);
}
else
{
var rls = (RotateTextStep)_nowRotating;
if (rls.RotateAround == RotateTextStep.Side.Start)
{
var angle = Utils.AngleBetween(pos.X - _originalX, pos.Y - _originalY,
_originalW, _originalH);
rls.Rotate(angle / (2 * Math.PI));
}
else if (rls.RotateAround == RotateTextStep.Side.End)
{
var angle = Utils.AngleBetween(_originalX + _originalW - pos.X,
_originalY + _originalH - pos.Y,
_originalW, _originalH);
rls.Rotate(angle / (2 * Math.PI));
}
}
}
private void ResizeText(TextFigure tf, Point pos)
{
if (_nowResizing == null)
{
var snappedTo = StepManager.SnapTo(pos, tf.GetMagnets(), tf.Center);
if (snappedTo == tf.Start)
{
_nowResizing = new ResizeTextStep(tf, ResizeTextStep.Side.End, pos.X - _downPos.X,
pos.Y - _downPos.Y);
}
else if (snappedTo == tf.End)
{
_nowResizing = new ResizeTextStep(tf, ResizeTextStep.Side.Start, pos.X - _downPos.X,
pos.Y - _downPos.Y);
}
if (_nowResizing == null)
{
return;
}
StepManager.InsertNext(_nowResizing);
}
else
{
var rts = (ResizeTextStep)_nowResizing;
var snapped = StepManager.Snap(pos, _nowResizing.Figure);
if (snapped != null)
{
if (rts.ResizeAround == ResizeTextStep.Side.End)
{
rts.Resize("(" + snapped.X.ExprString + ") - " + rts.Figure.Name + ".x",
"(" + snapped.Y.ExprString + ") - " + rts.Figure.Name + ".y", snapped.Def);
}
else if (rts.ResizeAround == ResizeTextStep.Side.Start)
{
rts.Resize("(" + snapped.X.ExprString + ") - (" + rts.Figure.Name + ".x + (" +
rts.Figure.Name + ".width))",
"(" + snapped.Y.ExprString + ") - (" + rts.Figure.Name + ".y + (" +
rts.Figure.Name + ".height))", snapped.Def);
}
}
else
{
if (rts.ResizeAround == ResizeTextStep.Side.End)
{
rts.Resize(pos.X - _downPos.X, pos.Y - _downPos.Y);
}
else if (rts.ResizeAround == ResizeTextStep.Side.Start)
{
rts.Resize(pos.X - _downPos.X, pos.Y - _downPos.Y);
}
}
}
}
private void MoveText(TextFigure tf, Point pos)
{
if (_nowMoving == null)
{
_nowMoving = new MoveTextStep(tf, pos.X - _downPos.X, pos.Y - _downPos.Y);
StepManager.InsertNext(_nowMoving);
}
else
{
var snapped = StepManager.Snap(pos, _nowMoving.Figure);
Magnet snappedBy;
if ((snapped != null) &&
((snappedBy = StepManager.SnapTo(pos, _nowMoving.Figure.GetMagnets())) != null))
{
if (snappedBy.EqualExprStrings(tf.Start))
{
((MoveTextStep)_nowMoving).Move(
"(" + snapped.X.ExprString + ") - (" + _nowMoving.Figure.Name + ".x)",
"(" + snapped.Y.ExprString + ") - (" + _nowMoving.Figure.Name + ".y)", snappedBy.Def,
snapped.Def);
}
else if (snappedBy.EqualExprStrings(tf.Center))
{
((MoveTextStep)_nowMoving).Move(
"((" + snapped.X.ExprString + ") - (" + tf.Name + ".width/2)) - (" +
_nowMoving.Figure.Name +
".x)",
"((" + snapped.Y.ExprString + ") - (" + tf.Name + ".height/2)) - (" +
_nowMoving.Figure.Name +
".y)", snappedBy.Def, snapped.Def);
}
else if (snappedBy.EqualExprStrings(tf.End))
{
((MoveTextStep)_nowMoving).Move(
"((" + snapped.X.ExprString + ") - (" + tf.Name + ".width)) - (" + _nowMoving.Figure.Name +
".x)",
"((" + snapped.Y.ExprString + ") - (" + tf.Name + ".height)) - (" + _nowMoving.Figure.Name +
".y)", snappedBy.Def, snapped.Def);
}
}
else
{
((MoveTextStep)_nowMoving).Move(pos.X - _downPos.X, pos.Y - _downPos.Y);
}
}
}
private void addStepBeforeLabel_Click(object sender, EventArgs e)
{
StepManager.InsertNext(new EmptyStep(), true);
}
private void addStepAfterLabel_Click(object sender, EventArgs e)
{
StepManager.InsertNext(new EmptyStep());
}
private void MoveEllipse(EllipseFigure ef, Point pos)
{
if (_nowMoving == null)
{
_nowMoving = new MoveEllipseStep(ef, pos.X - _downPos.X, pos.Y - _downPos.Y);
StepManager.InsertNext(_nowMoving);
}
else
{
var snapped = StepManager.Snap(pos, _nowMoving.Figure);
Magnet snappedBy;
if ((snapped != null) &&
((snappedBy = StepManager.SnapTo(pos, _nowMoving.Figure.GetMagnets())) != null))
{
if (snappedBy.EqualExprStrings(ef.Left))
{
((MoveEllipseStep)_nowMoving).Move(
"((" + snapped.X.ExprString + ") + (" + ef.Name + ".radius1)) - (" +
_nowMoving.Figure.Name +
".x)",
"(" + snapped.Y.ExprString + ") - (" + _nowMoving.Figure.Name + ".y)",
snappedBy.Def, snapped.Def);
}
else if (snappedBy.EqualExprStrings(ef.Right))
{
((MoveEllipseStep)_nowMoving).Move(
"((" + snapped.X.ExprString + ") - (" + ef.Name + ".radius1)) - (" +
_nowMoving.Figure.Name +
".x)",
"(" + snapped.Y.ExprString + ") - (" + _nowMoving.Figure.Name + ".y)",
snappedBy.Def, snapped.Def);
}
else if (snappedBy.EqualExprStrings(ef.Top))
{
((MoveEllipseStep)_nowMoving).Move(
"(" + snapped.X.ExprString + ") - (" + _nowMoving.Figure.Name + ".x)",
"((" + snapped.Y.ExprString + ") + (" + ef.Name + ".radius2)) - (" +
_nowMoving.Figure.Name +
".y)", snappedBy.Def, snapped.Def);
}
else if (snappedBy.EqualExprStrings(ef.Bottom))
{
((MoveEllipseStep)_nowMoving).Move(
"(" + snapped.X.ExprString + ") - (" + _nowMoving.Figure.Name + ".x)",
"((" + snapped.Y.ExprString + ") - (" + ef.Name + ".radius2)) - (" +
_nowMoving.Figure.Name +
".y)", snappedBy.Def, snapped.Def);
}
else if (snappedBy.EqualExprStrings(ef.Center))
{
((MoveEllipseStep)_nowMoving).Move(
"(" + snapped.X.ExprString + ") - (" + _nowMoving.Figure.Name + ".x)",
"(" + snapped.Y.ExprString + ") - (" + _nowMoving.Figure.Name + ".y)", snappedBy.Def,
snapped.Def);
}
}
else
{
((MoveEllipseStep)_nowMoving).Move(pos.X - _downPos.X, pos.Y - _downPos.Y);
}
}
}
private void ResizeRect(RectFigure rf, Point pos)
{
if (_nowResizing == null)
{
var snappedTo = StepManager.SnapTo(pos, rf.GetMagnets(), rf.Center);
if (snappedTo == rf.Left)
{
_nowResizing = new ResizeRectStep(rf, ResizeRectStep.Side.Right, pos.X - _downPos.X);
}
else if (snappedTo == rf.Right)
{
_nowResizing = new ResizeRectStep(rf, ResizeRectStep.Side.Left, pos.X - _downPos.X);
}
else if (snappedTo == rf.Top)
{
_nowResizing = new ResizeRectStep(rf, ResizeRectStep.Side.Bottom, pos.Y - _downPos.Y);
}
else if (snappedTo == rf.Bottom)
{
_nowResizing = new ResizeRectStep(rf, ResizeRectStep.Side.Top, pos.Y - _downPos.Y);
}
if (_nowResizing == null)
{
return;
}
StepManager.InsertNext(_nowResizing);
}
else
{
var rrs = (ResizeRectStep)_nowResizing;
var snapped = StepManager.Snap(pos, _nowResizing.Figure);
if (snapped != null)
{
if (rrs.ResizeAround == ResizeRectStep.Side.Right)
{
rrs.Resize("(" + snapped.X.ExprString + ") - " + rrs.Figure.Name + ".x", snapped.Def);
}
else if (rrs.ResizeAround == ResizeRectStep.Side.Left)
{
rrs.Resize("(" + snapped.X.ExprString + ") - (" + rrs.Figure.Name + ".x + (" +
rrs.Figure.Name + ".width))", snapped.Def);
}
else if (rrs.ResizeAround == ResizeRectStep.Side.Top)
{
rrs.Resize("(" + snapped.Y.ExprString + ") - (" + rrs.Figure.Name + ".y + (" +
rrs.Figure.Name + ".height))", snapped.Def);
}
else if (rrs.ResizeAround == ResizeRectStep.Side.Bottom)
{
rrs.Resize("(" + snapped.Y.ExprString + ") - " + rrs.Figure.Name + ".y", snapped.Def);
}
}
else
{
if (rrs.ResizeAround == ResizeRectStep.Side.Right)
{
rrs.Resize(pos.X - _downPos.X);
}
else if (rrs.ResizeAround == ResizeRectStep.Side.Left)
{
rrs.Resize(pos.X - _downPos.X);
}
else if (rrs.ResizeAround == ResizeRectStep.Side.Top)
{
rrs.Resize(pos.Y - _downPos.Y);
}
else if (rrs.ResizeAround == ResizeRectStep.Side.Bottom)
{
rrs.Resize(pos.Y - _downPos.Y);
}
}
}
}
private void ResizeEllipse(EllipseFigure ef, Point pos)
{
if (_nowResizing == null)
{
var snappedTo = StepManager.SnapTo(pos, ef.GetMagnets(), ef.Center);
if (snappedTo == ef.Left)
{
_nowResizing = new ResizeEllipseStep(ef, ResizeEllipseStep.Side.Right, pos.X - _downPos.X);
}
else if (snappedTo == ef.Right)
{
_nowResizing = new ResizeEllipseStep(ef, ResizeEllipseStep.Side.Left, pos.X - _downPos.X);
}
else if (snappedTo == ef.Top)
{
_nowResizing = new ResizeEllipseStep(ef, ResizeEllipseStep.Side.Bottom, pos.Y - _downPos.Y);
}
else if (snappedTo == ef.Bottom)
{
_nowResizing = new ResizeEllipseStep(ef, ResizeEllipseStep.Side.Top, pos.Y - _downPos.Y);
}
if (_nowResizing == null)
{
return;
}
StepManager.InsertNext(_nowResizing);
}
else
{
var res = (ResizeEllipseStep)_nowResizing;
var snapped = StepManager.Snap(pos, _nowResizing.Figure);
if (snapped != null)
{
if (res.ResizeAround == ResizeEllipseStep.Side.Right)
{
res.Resize("(" + res.Figure.Name + ".x - " + res.Figure.Name + ".radius1 ) - (" +
snapped.X.ExprString + ")", snapped.Def);
}
else if (res.ResizeAround == ResizeEllipseStep.Side.Left)
{
res.Resize("(" + snapped.X.ExprString + ") - (" + res.Figure.Name + ".x + (" +
res.Figure.Name + ".radius1))", snapped.Def);
}
else if (res.ResizeAround == ResizeEllipseStep.Side.Top)
{
res.Resize("(" + res.Figure.Name + ".y + " + res.Figure.Name + ".radius2 ) - (" +
snapped.Y.ExprString + ")", snapped.Def);
}
else if (res.ResizeAround == ResizeEllipseStep.Side.Bottom)
{
res.Resize("(" + snapped.Y.ExprString + ") - (" + res.Figure.Name + ".y - (" +
res.Figure.Name + ".radius2))", snapped.Def);
}
}
else
{
if (res.ResizeAround == ResizeEllipseStep.Side.Right)
{
res.Resize(_downPos.X - pos.X);
}
else if (res.ResizeAround == ResizeEllipseStep.Side.Left)
{
res.Resize(pos.X - _downPos.X);
}
else if (res.ResizeAround == ResizeEllipseStep.Side.Top)
{
res.Resize(_downPos.Y - pos.Y);
}
else if (res.ResizeAround == ResizeEllipseStep.Side.Bottom)
{
res.Resize(pos.Y - _downPos.Y);
}
}
}
}
