public async Task <bool> Execute(IWorkspace workspace, object arg)
{
var input = await workspace.InputService.GetPoint(new UserDirective("From"));
if (input.Cancel)
{
return(false);
}
if (!input.HasValue)
{
return(true);
}
var first = input.Value;
Point last = first;
while (true)
{
var current = await workspace.InputService.GetPoint(new UserDirective("Next or [c]lose", "c"), (p) =>
{
return(new[] { new PrimitiveLine(last, p) });
});
if (current.Cancel)
{
break;
}
if (current.HasValue)
{
workspace.AddToCurrentLayer(new Line(last, current.Value));
last = current.Value;
if (last == first)
{
break; // closed
}
}
else if (current.Directive == "c")
{
if (last != first)
{
workspace.AddToCurrentLayer(new Line(last, first));
}
break;
}
else
{
return(true);
}
}
return(true);
}
public async Task <bool> Execute(IWorkspace workspace, object arg)
{
var first = await workspace.InputService.GetPoint(new UserDirective("First point"));
if (!first.Cancel && first.HasValue)
{
var second = await workspace.InputService.GetPoint(new UserDirective("Second point"), (p) =>
{
return(new[]
{
new PrimitiveLine(first.Value, p)
});
});
if (!second.Cancel && second.HasValue)
{
var third = await workspace.InputService.GetPoint(new UserDirective("Third point"), (p) =>
{
var a = PrimitiveEllipse.ThreePointArc(first.Value, second.Value, p, workspace.DrawingPlane.Normal);
if (a == null)
{
return(new IPrimitive[0]);
}
else
{
return(new IPrimitive[]
{
a,
new PrimitivePoint(first.Value),
new PrimitivePoint(second.Value)
});
}
});
if (!third.Cancel && third.HasValue)
{
var primitiveArc = PrimitiveEllipse.ThreePointArc(first.Value, second.Value, third.Value, workspace.DrawingPlane.Normal);
if (primitiveArc != null)
{
var arc = new Arc(
primitiveArc.Center,
primitiveArc.MajorAxis.Length,
primitiveArc.StartAngle,
primitiveArc.EndAngle,
primitiveArc.Normal);
workspace.AddToCurrentLayer(arc);
return(true);
}
}
}
}
return(false);
}
public async Task <bool> Execute(IWorkspace workspace, object arg)
{
var drawingPlane = workspace.DrawingPlane;
var center = await workspace.InputService.GetPoint(new UserDirective("Center"));
if (!center.Cancel && center.HasValue)
{
var majorEnd = await workspace.InputService.GetPoint(new UserDirective("Major axis endpoint"), p =>
{
return(new[]
{
new PrimitiveLine(center.Value, p)
});
});
var majorPrimitive = new PrimitiveLine(center.Value, majorEnd.Value);
var majorAxis = majorEnd.Value - center.Value;
var majorAxisLength = majorAxis.Length;
if (!majorEnd.Cancel && majorEnd.HasValue)
{
var minorEnd = await workspace.InputService.GetPoint(new UserDirective("Minor axis endpoint"), lastPoint : center.Value, onCursorMove : p =>
{
var tempMinorAxis = p - center.Value;
var tempMinorAxisRatio = tempMinorAxis.Length / majorAxisLength;
var el = new PrimitiveEllipse(center.Value, majorAxis, drawingPlane.Normal, tempMinorAxisRatio, 0.0, 360.0);
return(new IPrimitive[]
{
majorPrimitive, // major axis line
new PrimitiveLine(center.Value, p), // minor axis line
el // the ellipse
});
});
if (!minorEnd.Cancel && minorEnd.HasValue)
{
var minorAxis = minorEnd.Value - center.Value;
var minorAxisRatio = minorAxis.Length / majorAxisLength;
if (!minorEnd.Cancel && minorEnd.HasValue)
{
var el = new Ellipse(center.Value, majorAxis, minorAxisRatio, 0.0, 360.0, drawingPlane.Normal);
workspace.AddToCurrentLayer(el);
return(true);
}
}
}
}
return(false);
}
public async Task <bool> Execute(IWorkspace workspace, object arg)
{
var location = await workspace.InputService.GetPoint(new UserDirective("Location"));
if (location.Cancel)
{
return(false);
}
if (!location.HasValue)
{
return(true);
}
workspace.AddToCurrentLayer(new Location(location.Value));
return(true);
}
public async Task <bool> Execute(IWorkspace workspace, object arg)
{
// get location
var input = await workspace.InputService.GetPoint(new UserDirective("Location"));
if (input.Cancel || !input.HasValue)
{
return(false);
}
var location = input.Value;
// get height
var heightInput = await workspace.InputService.GetDistance(new UserDirective("Text height or first point"), defaultDistance : lastHeight);
if (heightInput.Cancel || !heightInput.HasValue)
{
return(false);
}
var height = heightInput.Value;
lastHeight = height;
// get text
var textInput = await workspace.InputService.GetText();
if (textInput.Cancel || !textInput.HasValue)
{
return(false);
}
var text = textInput.Value;
// add it
workspace.AddToCurrentLayer(new Text(text, location, workspace.DrawingPlane.Normal, height, 0.0));
return(true);
}
public async Task <bool> Execute(IWorkspace workspace, object arg)
{
Entity circle = null;
var drawingPlane = workspace.DrawingPlane;
var cen = await workspace.InputService.GetPoint(new UserDirective("Select center, [ttr], or [th]ree-point", "ttr", "th"));
if (cen.Cancel)
{
return(false);
}
if (cen.HasValue)
{
var mode = CircleMode.Radius;
while (circle == null)
{
switch (mode)
{
case CircleMode.Radius:
{
var rad = await workspace.InputService.GetPoint(new UserDirective("Enter radius or [d]iameter/[i]sometric", "d", "i"), (p) =>
{
return(new IPrimitive[]
{
new PrimitiveLine(cen.Value, p),
new PrimitiveEllipse(cen.Value, (p - cen.Value).Length, drawingPlane.Normal)
});
});
if (rad.Cancel)
{
return(false);
}
if (rad.HasValue)
{
circle = new Circle(cen.Value, (rad.Value - cen.Value).Length, drawingPlane.Normal);
}
else // switch modes
{
if (rad.Directive == null)
{
return(false);
}
switch (rad.Directive)
{
case "d":
mode = CircleMode.Diameter;
break;
case "i":
mode = CircleMode.Isometric;
break;
}
}
break;
}
case CircleMode.Diameter:
{
var dia = await workspace.InputService.GetPoint(new UserDirective("Enter diameter or [r]adius/[i]sometric", "r", "i"), (p) =>
{
return(new IPrimitive[]
{
new PrimitiveLine(cen.Value, p),
new PrimitiveEllipse(cen.Value, (p - cen.Value).Length, drawingPlane.Normal)
});
});
if (dia.Cancel)
{
return(false);
}
if (dia.HasValue)
{
circle = new Circle(cen.Value, (dia.Value - cen.Value).Length * 0.5, drawingPlane.Normal);
}
else // switch modes
{
if (dia.Directive == null)
{
return(false);
}
switch (dia.Directive)
{
case "r":
mode = CircleMode.Radius;
break;
case "i":
mode = CircleMode.Isometric;
break;
}
}
break;
}
case CircleMode.Isometric:
{
var isoRad = await workspace.InputService.GetPoint(new UserDirective("Enter isometric-radius or [r]adius/[d]iameter", "r", "d"), (p) =>
{
return(new IPrimitive[]
{
new PrimitiveLine(cen.Value, p),
new PrimitiveEllipse(cen.Value,
Vector.SixtyDegrees * (p - cen.Value).Length *MathHelper.SqrtThreeHalves,
drawingPlane.Normal,
IsoMinorRatio,
0.0,
360.0)
});
});
if (isoRad.Cancel)
{
return(false);
}
if (isoRad.HasValue)
{
circle = new Ellipse(cen.Value,
Vector.SixtyDegrees * (isoRad.Value - cen.Value).Length * MathHelper.SqrtThreeHalves,
IsoMinorRatio,
0.0,
360.0,
drawingPlane.Normal);
}
else // switch modes
{
if (isoRad.Directive == null)
{
return(false);
}
switch (isoRad.Directive)
{
case "r":
mode = CircleMode.Radius;
break;
case "d":
mode = CircleMode.Diameter;
break;
}
}
break;
}
}
}
}
else
{
switch (cen.Directive)
{
case "ttr":
var firstEntity = await workspace.InputService.GetEntity(new UserDirective("First entity"));
if (firstEntity.Cancel || !firstEntity.HasValue)
{
break;
}
var secondEntity = await workspace.InputService.GetEntity(new UserDirective("Second entity"));
if (secondEntity.Cancel || !secondEntity.HasValue)
{
break;
}
var radius = await workspace.InputService.GetDistance();
var ellipse = EditUtilities.Ttr(drawingPlane, firstEntity.Value, secondEntity.Value, radius.Value);
if (ellipse != null)
{
circle = ellipse.ToEntity();
}
break;
case "2":
break;
case "th":
var first = await workspace.InputService.GetPoint(new UserDirective("First point"));
if (first.Cancel || !first.HasValue)
{
break;
}
var second = await workspace.InputService.GetPoint(new UserDirective("Second point"), p =>
new[]
{
new PrimitiveLine(first.Value, p)
});
if (second.Cancel || !second.HasValue)
{
break;
}
var third = await workspace.InputService.GetPoint(new UserDirective("Third point"), p =>
{
var c = PrimitiveEllipse.ThreePointCircle(first.Value, second.Value, p);
if (c == null)
{
return new IPrimitive[]
{
new PrimitiveLine(first.Value, second.Value),
new PrimitiveLine(second.Value, p),
new PrimitiveLine(p, first.Value)
}
}
;
else
{
return new IPrimitive[]
{
new PrimitiveLine(first.Value, second.Value),
new PrimitiveLine(second.Value, p),
new PrimitiveLine(p, first.Value),
c
}
};
});
if (third.Cancel || !third.HasValue)
{
break;
}
var circ = PrimitiveEllipse.ThreePointCircle(first.Value, second.Value, third.Value);
if (circ != null)
{
circle = new Circle(circ.Center, circ.MajorAxis.Length, circ.Normal);
}
break;
}
}
if (circle != null)
{
workspace.AddToCurrentLayer(circle);
}
return(true);
}
public async Task <bool> Execute(IWorkspace workspace, object arg = null)
{
var locationInput = await workspace.InputService.GetPoint(new UserDirective("Location"));
if (locationInput.Cancel)
{
return(false);
}
if (!locationInput.HasValue)
{
return(false);
}
var location = locationInput.Value;
var imagePath = await workspace.FileSystemService.GetFileNameFromUserForOpen(new[] { new FileSpecification("JPEG Image", new[] { ".jpg", ".jpeg" }) });
if (imagePath == null)
{
return(false);
}
var imageData = await workspace.FileSystemService.GetContentResolverRelativeToPath(workspace.Drawing.Settings.FileName)(imagePath);
var(rawImageWidth, rawImageHeight) = ImageHelpers.GetImageDimensions(imagePath, imageData);
var imageWidthInput = await workspace.InputService.GetDistance(new UserDirective($"Width [{rawImageWidth}]"), defaultDistance : rawImageWidth);
if (imageWidthInput.Cancel)
{
return(false);
}
if (!imageWidthInput.HasValue)
{
return(false);
}
var imageWidth = imageWidthInput.Value;
var scaledRawHeight = (double)rawImageHeight / rawImageWidth * imageWidth;
var imageHeightInput = await workspace.InputService.GetDistance(new UserDirective($"Height [{scaledRawHeight}]"), defaultDistance : scaledRawHeight);
if (imageHeightInput.Cancel)
{
return(false);
}
if (!imageHeightInput.HasValue)
{
return(false);
}
var imageHeight = imageHeightInput.Value;
var defaultRotation = 0;
var imageRotationInput = await workspace.InputService.GetText($"Rotation [{defaultRotation}]");
if (imageRotationInput.Cancel)
{
return(false);
}
var rawRotationInput = imageRotationInput.HasValue ? imageRotationInput.Value : defaultRotation.ToString();
if (string.IsNullOrWhiteSpace(rawRotationInput))
{
return(false);
}
if (!double.TryParse(rawRotationInput, out var imageRotation))
{
return(false);
}
var image = new Image(location, imagePath, imageData, imageWidth, imageHeight, imageRotation);
workspace.AddToCurrentLayer(image);
return(true);
}
public async Task <bool> Execute(IWorkspace workspace, object arg)
{
var points = new List <Vertex>();
var segments = new List <PrimitiveLine>();
var input = await workspace.InputService.GetPoint(new UserDirective("Start"));
if (input.Cancel)
{
return(false);
}
if (!input.HasValue)
{
return(true);
}
var first = input.Value;
points.Add(new Vertex(first));
Point last = first;
while (true)
{
// TODO: allow adding arcs, too
var current = await workspace.InputService.GetPoint(new UserDirective("Next or [c]lose", "c"), (p) =>
{
var toDraw = segments.Concat(new[] { new PrimitiveLine(last, p) });
if (ClosePolyline)
{
toDraw = toDraw.Concat(new[] { new PrimitiveLine(p, first) });
}
return(toDraw);
});
if (current.Cancel)
{
break;
}
if (current.HasValue)
{
segments.Add(new PrimitiveLine(last, current.Value));
points.Add(new Vertex(current.Value));
last = current.Value;
if (last == first)
{
break; // closed
}
}
else if (current.Directive == "c")
{
if (last != first)
{
points.Add(new Vertex(first));
}
break;
}
else
{
break;
}
}
if (ClosePolyline)
{
points.Add(points.First());
}
var polyline = new Polyline(points);
workspace.AddToCurrentLayer(polyline);
return(true);
}
