/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XArc arc, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var _gfx = dc as XGraphics;
var a = Core2D.Math.Arc.GdiArc.FromXArc(arc, dx, dy);
if (arc.IsFilled)
{
var path = new XGraphicsPath();
// NOTE: Not implemented in PdfSharp Core version.
path.AddArc(
_scaleToPage(a.X),
_scaleToPage(a.Y),
_scaleToPage(a.Width),
_scaleToPage(a.Height),
a.StartAngle,
a.SweepAngle);
if (arc.IsStroked)
{
_gfx.DrawPath(
ToXPen(arc.Style, _scaleToPage, _sourceDpi, _targetDpi),
ToXSolidBrush(arc.Style.Fill),
path);
}
else
{
_gfx.DrawPath(
ToXSolidBrush(arc.Style.Fill),
path);
}
}
else
{
if (arc.IsStroked)
{
_gfx.DrawArc(
ToXPen(arc.Style, _scaleToPage, _sourceDpi, _targetDpi),
_scaleToPage(a.X),
_scaleToPage(a.Y),
_scaleToPage(a.Width),
_scaleToPage(a.Height),
a.StartAngle,
a.SweepAngle);
}
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XCubicBezier cubicBezier, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var _gfx = dc as XGraphics;
if (cubicBezier.IsFilled)
{
var path = new XGraphicsPath();
path.AddBezier(
_scaleToPage(cubicBezier.Point1.X + dx),
_scaleToPage(cubicBezier.Point1.Y + dy),
_scaleToPage(cubicBezier.Point2.X + dx),
_scaleToPage(cubicBezier.Point2.Y + dy),
_scaleToPage(cubicBezier.Point3.X + dx),
_scaleToPage(cubicBezier.Point3.Y + dy),
_scaleToPage(cubicBezier.Point4.X + dx),
_scaleToPage(cubicBezier.Point4.Y + dy));
if (cubicBezier.IsStroked)
{
_gfx.DrawPath(
ToXPen(cubicBezier.Style, _scaleToPage, _sourceDpi, _targetDpi),
ToXSolidBrush(cubicBezier.Style.Fill),
path);
}
else
{
_gfx.DrawPath(
ToXSolidBrush(cubicBezier.Style.Fill),
path);
}
}
else
{
if (cubicBezier.IsStroked)
{
_gfx.DrawBezier(
ToXPen(cubicBezier.Style, _scaleToPage, _sourceDpi, _targetDpi),
_scaleToPage(cubicBezier.Point1.X + dx),
_scaleToPage(cubicBezier.Point1.Y + dy),
_scaleToPage(cubicBezier.Point2.X + dx),
_scaleToPage(cubicBezier.Point2.Y + dy),
_scaleToPage(cubicBezier.Point3.X + dx),
_scaleToPage(cubicBezier.Point3.Y + dy),
_scaleToPage(cubicBezier.Point4.X + dx),
_scaleToPage(cubicBezier.Point4.Y + dy));
}
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XRectangle rectangle, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var _gfx = dc as XGraphics;
var rect = Core2D.Math.Rect2.Create(
rectangle.TopLeft,
rectangle.BottomRight,
dx, dy);
if (rectangle.IsStroked && rectangle.IsFilled)
{
_gfx.DrawRectangle(
ToXPen(rectangle.Style, _scaleToPage, _sourceDpi, _targetDpi),
ToXSolidBrush(rectangle.Style.Fill),
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
}
else if (rectangle.IsStroked && !rectangle.IsFilled)
{
_gfx.DrawRectangle(
ToXPen(rectangle.Style, _scaleToPage, _sourceDpi, _targetDpi),
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
}
else if (!rectangle.IsStroked && rectangle.IsFilled)
{
_gfx.DrawRectangle(
ToXSolidBrush(rectangle.Style.Fill),
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
}
if (rectangle.IsGrid)
{
DrawGridInternal(
_gfx,
ToXPen(rectangle.Style, _scaleToPage, _sourceDpi, _targetDpi),
ref rect,
rectangle.OffsetX, rectangle.OffsetY,
rectangle.CellWidth, rectangle.CellHeight,
true);
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XEllipse ellipse, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var _gfx = dc as XGraphics;
var rect = Core2D.Math.Rect2.Create(
ellipse.TopLeft,
ellipse.BottomRight,
dx, dy);
if (ellipse.IsStroked && ellipse.IsFilled)
{
_gfx.DrawEllipse(
ToXPen(ellipse.Style, _scaleToPage, _sourceDpi, _targetDpi),
ToXSolidBrush(ellipse.Style.Fill),
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
}
else if (ellipse.IsStroked && !ellipse.IsFilled)
{
_gfx.DrawEllipse(
ToXPen(ellipse.Style, _scaleToPage, _sourceDpi, _targetDpi),
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
}
else if (!ellipse.IsStroked && ellipse.IsFilled)
{
_gfx.DrawEllipse(
ToXSolidBrush(ellipse.Style.Fill),
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Project.XLayer layer, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var dxf = dc as DxfDocument;
foreach (var shape in layer.Shapes)
{
if (shape.State.Flags.HasFlag(State.DrawShapeState.Flags))
{
shape.Draw(dxf, this, 0, 0, db, r);
}
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XLine line, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
if (!line.IsStroked)
{
return;
}
var _gfx = dc as XGraphics;
XPen strokeLine = ToXPen(line.Style, _scaleToPage, _sourceDpi, _targetDpi);
XPoint pt1, pt2;
DrawLineArrowsInternal(_gfx, line, dx, dy, out pt1, out pt2);
if (line.Style.LineStyle.IsCurved)
{
DrawLineCurveInternal(
_gfx,
strokeLine, line.IsStroked,
ref pt1, ref pt2,
line.Style.LineStyle.Curvature,
line.Style.LineStyle.CurveOrientation,
line.Start.Alignment,
line.End.Alignment);
}
else
{
DrawLineInternal(_gfx, strokeLine, line.IsStroked, ref pt1, ref pt2);
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XText text, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var dxf = dc as DxfDocument;
var tbind = text.BindText(db, r);
if (string.IsNullOrEmpty(tbind))
{
return;
}
var style = text.Style;
var stroke = ToColor(style.Stroke);
var strokeTansparency = ToTransparency(style.Stroke);
var attachmentPoint = default(MTextAttachmentPoint);
double x, y;
var rect = Core2D.Math.Rect2.Create(text.TopLeft, text.BottomRight, dx, dy);
switch (text.Style.TextStyle.TextHAlignment)
{
default:
case Core2D.Style.TextHAlignment.Left:
x = rect.X;
break;
case Core2D.Style.TextHAlignment.Center:
x = rect.X + rect.Width / 2.0;
break;
case Core2D.Style.TextHAlignment.Right:
x = rect.X + rect.Width;
break;
}
switch (text.Style.TextStyle.TextVAlignment)
{
default:
case Core2D.Style.TextVAlignment.Top:
y = rect.Y;
break;
case Core2D.Style.TextVAlignment.Center:
y = rect.Y + rect.Height / 2.0;
break;
case Core2D.Style.TextVAlignment.Bottom:
y = rect.Y + rect.Height;
break;
}
switch (text.Style.TextStyle.TextVAlignment)
{
default:
case Core2D.Style.TextVAlignment.Top:
switch (text.Style.TextStyle.TextHAlignment)
{
default:
case Core2D.Style.TextHAlignment.Left:
attachmentPoint = MTextAttachmentPoint.TopLeft;
break;
case Core2D.Style.TextHAlignment.Center:
attachmentPoint = MTextAttachmentPoint.TopCenter;
break;
case Core2D.Style.TextHAlignment.Right:
attachmentPoint = MTextAttachmentPoint.TopRight;
break;
}
break;
case Core2D.Style.TextVAlignment.Center:
switch (text.Style.TextStyle.TextHAlignment)
{
default:
case Core2D.Style.TextHAlignment.Left:
attachmentPoint = MTextAttachmentPoint.MiddleLeft;
break;
case Core2D.Style.TextHAlignment.Center:
attachmentPoint = MTextAttachmentPoint.MiddleCenter;
break;
case Core2D.Style.TextHAlignment.Right:
attachmentPoint = MTextAttachmentPoint.MiddleRight;
break;
}
break;
case Core2D.Style.TextVAlignment.Bottom:
switch (text.Style.TextStyle.TextHAlignment)
{
default:
case Core2D.Style.TextHAlignment.Left:
attachmentPoint = MTextAttachmentPoint.BottomLeft;
break;
case Core2D.Style.TextHAlignment.Center:
attachmentPoint = MTextAttachmentPoint.BottomCenter;
break;
case Core2D.Style.TextHAlignment.Right:
attachmentPoint = MTextAttachmentPoint.BottomRight;
break;
}
break;
}
var ts = new TextStyle(style.TextStyle.FontName, style.TextStyle.FontFile);
var dxfMText = new MText(
new Vector3(ToDxfX(x), ToDxfY(y), 0),
text.Style.TextStyle.FontSize * _targetDpi / _sourceDpi,
rect.Width,
ts);
dxfMText.AttachmentPoint = attachmentPoint;
var options = new MTextFormattingOptions(dxfMText.Style);
var fs = text.Style.TextStyle.FontStyle;
if (fs != null)
{
options.Bold = fs.Flags.HasFlag(Core2D.Style.FontStyleFlags.Bold);
options.Italic = fs.Flags.HasFlag(Core2D.Style.FontStyleFlags.Italic);
options.Underline = fs.Flags.HasFlag(Core2D.Style.FontStyleFlags.Underline);
options.StrikeThrough = fs.Flags.HasFlag(Core2D.Style.FontStyleFlags.Strikeout);
}
options.Aligment = MTextFormattingOptions.TextAligment.Default;
options.Color = null;
dxfMText.Write(tbind, options);
dxfMText.Layer = _currentLayer;
dxfMText.Transparency.Value = strokeTansparency;
dxfMText.Color = stroke;
dxf.AddEntity(dxfMText);
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XImage image, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var _gfx = dc as XGraphics;
var rect = Core2D.Math.Rect2.Create(
image.TopLeft,
image.BottomRight,
dx, dy);
var srect = new XRect(
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
if (image.IsStroked || image.IsFilled)
{
DrawRectangleInternal(
_gfx,
ToXSolidBrush(image.Style.Fill),
ToXPen(image.Style, _scaleToPage, _sourceDpi, _targetDpi),
image.IsStroked,
image.IsFilled,
ref srect);
}
if (_enableImageCache &&
_biCache.ContainsKey(image.Key))
{
_gfx.DrawImage(_biCache[image.Key], srect);
}
else
{
if (State.ImageCache == null || string.IsNullOrEmpty(image.Key))
{
return;
}
var bytes = State.ImageCache.GetImage(image.Key);
if (bytes != null)
{
var ms = new System.IO.MemoryStream(bytes);
#if WPF
var bs = new BitmapImage();
bs.BeginInit();
bs.StreamSource = ms;
bs.EndInit();
bs.Freeze();
var bi = XImage.FromBitmapSource(bs);
#else
var bi = XImage.FromStream(ms);
#endif
if (_enableImageCache)
{
_biCache[image.Key] = bi;
}
_gfx.DrawImage(bi, srect);
if (!_enableImageCache)
{
bi.Dispose();
}
}
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XArc arc, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var dxf = dc as DxfDocument;
var style = arc.Style;
var dxfEllipse = CreateEllipticalArc(arc, dx, dy);
if (arc.IsFilled)
{
var fill = ToColor(style.Fill);
var fillTransparency = ToTransparency(style.Fill);
// TODO: The netDxf does not create hatch for Ellipse with end angle equal to 360.
var bounds =
new List <HatchBoundaryPath>
{
new HatchBoundaryPath(
new List <EntityObject>
{
(Ellipse)dxfEllipse.Clone()
})
};
var hatch = new Hatch(HatchPattern.Solid, bounds, false);
hatch.Layer = _currentLayer;
hatch.Color = fill;
hatch.Transparency.Value = fillTransparency;
dxf.AddEntity(hatch);
}
if (arc.IsStroked)
{
var stroke = ToColor(style.Stroke);
var strokeTansparency = ToTransparency(style.Stroke);
var lineweight = ToLineweight(style.Thickness);
dxfEllipse.Layer = _currentLayer;
dxfEllipse.Color = stroke;
dxfEllipse.Transparency.Value = strokeTansparency;
dxfEllipse.Lineweight = lineweight;
dxf.AddEntity(dxfEllipse);
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XQuadraticBezier quadraticBezier, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
if (!quadraticBezier.IsStroked && !quadraticBezier.IsFilled)
{
return;
}
var dxf = dc as DxfDocument;
var style = quadraticBezier.Style;
var dxfSpline = CreateQuadraticSpline(
quadraticBezier.Point1.X + dx,
quadraticBezier.Point1.Y + dy,
quadraticBezier.Point2.X + dx,
quadraticBezier.Point2.Y + dy,
quadraticBezier.Point3.X + dx,
quadraticBezier.Point3.Y + dy);
if (quadraticBezier.IsFilled)
{
var fill = ToColor(style.Fill);
var fillTransparency = ToTransparency(style.Fill);
var bounds =
new List <HatchBoundaryPath>
{
new HatchBoundaryPath(
new List <EntityObject>
{
(Spline)dxfSpline.Clone()
})
};
var hatch = new Hatch(HatchPattern.Solid, bounds, false);
hatch.Layer = _currentLayer;
hatch.Color = fill;
hatch.Transparency.Value = fillTransparency;
dxf.AddEntity(hatch);
}
if (quadraticBezier.IsStroked)
{
var stroke = ToColor(style.Stroke);
var strokeTansparency = ToTransparency(style.Stroke);
var lineweight = ToLineweight(style.Thickness);
dxfSpline.Layer = _currentLayer;
dxfSpline.Color = stroke;
dxfSpline.Transparency.Value = strokeTansparency;
dxfSpline.Lineweight = lineweight;
dxf.AddEntity(dxfSpline);
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XEllipse ellipse, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
if (!ellipse.IsStroked && !ellipse.IsFilled)
{
return;
}
var dxf = dc as DxfDocument;
var style = ellipse.Style;
var rect = Core2D.Math.Rect2.Create(ellipse.TopLeft, ellipse.BottomRight, dx, dy);
DrawEllipseInternal(dxf, _currentLayer, ellipse.IsFilled, ellipse.IsStroked, style, ref rect);
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XRectangle rectangle, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
if (!rectangle.IsStroked && !rectangle.IsFilled && !rectangle.IsGrid)
{
return;
}
var dxf = dc as DxfDocument;
var style = rectangle.Style;
var rect = Core2D.Math.Rect2.Create(rectangle.TopLeft, rectangle.BottomRight, dx, dy);
DrawRectangleInternal(dxf, _currentLayer, rectangle.IsFilled, rectangle.IsStroked, style, ref rect);
if (rectangle.IsGrid)
{
DrawGridInternal(
dxf,
_currentLayer,
style,
rectangle.OffsetX, rectangle.OffsetY,
rectangle.CellWidth, rectangle.CellHeight,
ref rect);
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XLine line, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
if (!line.IsStroked)
{
return;
}
var dxf = dc as DxfDocument;
double _x1 = line.Start.X + dx;
double _y1 = line.Start.Y + dy;
double _x2 = line.End.X + dx;
double _y2 = line.End.Y + dy;
Core2D.Shapes.XLineExtensions.GetMaxLength(line, ref _x1, ref _y1, ref _x2, ref _y2);
// TODO: Draw line start arrow.
// TODO: Draw line end arrow.
// TODO: Draw line curve.
DrawLineInternal(dxf, _currentLayer, line.Style, line.IsStroked, _x1, _y1, _x2, _y2);
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XQuadraticBezier quadraticBezier, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var _gfx = dc as XGraphics;
double x1 = quadraticBezier.Point1.X;
double y1 = quadraticBezier.Point1.Y;
double x2 = quadraticBezier.Point1.X + (2.0 * (quadraticBezier.Point2.X - quadraticBezier.Point1.X)) / 3.0;
double y2 = quadraticBezier.Point1.Y + (2.0 * (quadraticBezier.Point2.Y - quadraticBezier.Point1.Y)) / 3.0;
double x3 = x2 + (quadraticBezier.Point3.X - quadraticBezier.Point1.X) / 3.0;
double y3 = y2 + (quadraticBezier.Point3.Y - quadraticBezier.Point1.Y) / 3.0;
double x4 = quadraticBezier.Point3.X;
double y4 = quadraticBezier.Point3.Y;
if (quadraticBezier.IsFilled)
{
var path = new XGraphicsPath();
path.AddBezier(
_scaleToPage(x1 + dx),
_scaleToPage(y1 + dy),
_scaleToPage(x2 + dx),
_scaleToPage(y2 + dy),
_scaleToPage(x3 + dx),
_scaleToPage(y3 + dy),
_scaleToPage(x4 + dx),
_scaleToPage(y4 + dy));
if (quadraticBezier.IsStroked)
{
_gfx.DrawPath(
ToXPen(quadraticBezier.Style, _scaleToPage, _sourceDpi, _targetDpi),
ToXSolidBrush(quadraticBezier.Style.Fill),
path);
}
else
{
_gfx.DrawPath(
ToXSolidBrush(quadraticBezier.Style.Fill),
path);
}
}
else
{
if (quadraticBezier.IsStroked)
{
_gfx.DrawBezier(
ToXPen(quadraticBezier.Style, _scaleToPage, _sourceDpi, _targetDpi),
_scaleToPage(x1 + dx),
_scaleToPage(y1 + dy),
_scaleToPage(x2 + dx),
_scaleToPage(y2 + dy),
_scaleToPage(x3 + dx),
_scaleToPage(y3 + dy),
_scaleToPage(x4 + dx),
_scaleToPage(y4 + dy));
}
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XImage image, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var dxf = dc as DxfDocument;
var bytes = State.ImageCache.GetImage(image.Key);
if (bytes != null)
{
var rect = Core2D.Math.Rect2.Create(image.TopLeft, image.BottomRight, dx, dy);
var dxfImageDefinitionCached = _biCache.Get(image.Key);
if (dxfImageDefinitionCached != null)
{
var dxfImage = new Image(
dxfImageDefinitionCached,
new Vector3(ToDxfX(rect.X), ToDxfY(rect.Y + rect.Height), 0),
rect.Width,
rect.Height);
dxf.AddEntity(dxfImage);
}
else
{
if (State.ImageCache == null || string.IsNullOrEmpty(image.Key))
{
return;
}
var path = System.IO.Path.Combine(_outputPath, System.IO.Path.GetFileName(image.Key));
System.IO.File.WriteAllBytes(path, bytes);
var dxfImageDefinition = new ImageDefinition(path);
_biCache.Set(image.Key, dxfImageDefinition);
var dxfImage = new Image(
dxfImageDefinition,
new Vector3(ToDxfX(rect.X), ToDxfY(rect.Y + rect.Height), 0),
rect.Width,
rect.Height);
dxf.AddEntity(dxfImage);
}
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XText text, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var _gfx = dc as XGraphics;
var tbind = text.BindText(db, r);
if (string.IsNullOrEmpty(tbind))
{
return;
}
var options = new XPdfFontOptions(PdfFontEncoding.Unicode);
var fontStyle = XFontStyle.Regular;
if (text.Style.TextStyle.FontStyle != null)
{
if (text.Style.TextStyle.FontStyle.Flags.HasFlag(Core2D.Style.FontStyleFlags.Bold))
{
fontStyle |= XFontStyle.Bold;
}
if (text.Style.TextStyle.FontStyle.Flags.HasFlag(Core2D.Style.FontStyleFlags.Italic))
{
fontStyle |= XFontStyle.Italic;
}
if (text.Style.TextStyle.FontStyle.Flags.HasFlag(Core2D.Style.FontStyleFlags.Underline))
{
fontStyle |= XFontStyle.Underline;
}
if (text.Style.TextStyle.FontStyle.Flags.HasFlag(Core2D.Style.FontStyleFlags.Strikeout))
{
fontStyle |= XFontStyle.Strikeout;
}
}
var font = new XFont(
text.Style.TextStyle.FontName,
_scaleToPage(text.Style.TextStyle.FontSize),
fontStyle,
options);
var rect = Core2D.Math.Rect2.Create(
text.TopLeft,
text.BottomRight,
dx, dy);
var srect = new XRect(
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
var format = new XStringFormat();
switch (text.Style.TextStyle.TextHAlignment)
{
case Core2D.Style.TextHAlignment.Left:
format.Alignment = XStringAlignment.Near;
break;
case Core2D.Style.TextHAlignment.Center:
format.Alignment = XStringAlignment.Center;
break;
case Core2D.Style.TextHAlignment.Right:
format.Alignment = XStringAlignment.Far;
break;
}
switch (text.Style.TextStyle.TextVAlignment)
{
case Core2D.Style.TextVAlignment.Top:
format.LineAlignment = XLineAlignment.Near;
break;
case Core2D.Style.TextVAlignment.Center:
format.LineAlignment = XLineAlignment.Center;
break;
case Core2D.Style.TextVAlignment.Bottom:
format.LineAlignment = XLineAlignment.Far;
break;
}
_gfx.DrawString(
tbind,
font,
ToXSolidBrush(text.Style.Stroke),
srect,
format);
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XPath path, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
if (!path.IsStroked && !path.IsFilled)
{
return;
}
var dxf = dc as DxfDocument;
var style = path.Style;
IList <HatchBoundaryPath> bounds;
ICollection <EntityObject> entities;
CreateHatchBoundsAndEntitiess(path.Geometry, dx, dy, out bounds, out entities);
if (entities == null || bounds == null)
{
return;
}
if (path.IsFilled)
{
var fill = ToColor(style.Fill);
var fillTransparency = ToTransparency(style.Fill);
var hatch = new Hatch(HatchPattern.Solid, bounds, false);
hatch.Layer = _currentLayer;
hatch.Color = fill;
hatch.Transparency.Value = fillTransparency;
dxf.AddEntity(hatch);
}
if (path.IsStroked)
{
// TODO: Add support for Closed paths.
var stroke = ToColor(style.Stroke);
var strokeTansparency = ToTransparency(style.Stroke);
var lineweight = ToLineweight(style.Thickness);
foreach (var entity in entities)
{
entity.Layer = _currentLayer;
entity.Color = stroke;
entity.Transparency.Value = strokeTansparency;
entity.Lineweight = lineweight;
dxf.AddEntity(entity);
}
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XPath path, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var _gfx = dc as XGraphics;
var gp = path.Geometry.ToXGraphicsPath(dx, dy, _scaleToPage);
if (path.IsFilled && path.IsStroked)
{
_gfx.DrawPath(
ToXPen(path.Style, _scaleToPage, _sourceDpi, _targetDpi),
ToXSolidBrush(path.Style.Fill),
gp);
}
else if (path.IsFilled && !path.IsStroked)
{
_gfx.DrawPath(
ToXSolidBrush(path.Style.Fill),
gp);
}
else if (!path.IsFilled && path.IsStroked)
{
_gfx.DrawPath(
ToXPen(path.Style, _scaleToPage, _sourceDpi, _targetDpi),
gp);
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Project.XContainer container, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var dxf = dc as DxfDocument;
foreach (var layer in container.Layers)
{
var dxfLayer = new Layer(layer.Name)
{
IsVisible = layer.IsVisible
};
dxf.Layers.Add(dxfLayer);
_currentLayer = dxfLayer;
Draw(dc, layer, db, r);
}
}
