/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="layer"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Core2D.Layer layer, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
foreach (var shape in layer.Shapes)
{
if (shape.State.Flags.HasFlag(_state.DrawShapeState.Flags))
{
shape.Draw(gfx, this, 0, 0, db, r);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="line"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Core2D.XLine line, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
if (!line.IsStroked)
{
return;
}
var _gfx = gfx as XGraphics;
XSolidBrush fillLine = ToXSolidBrush(line.Style.Fill);
XPen strokeLine = ToXPen(line.Style, _scaleToPage);
XSolidBrush fillStartArrow = ToXSolidBrush(line.Style.StartArrowStyle.Fill);
XPen strokeStartArrow = ToXPen(line.Style.StartArrowStyle, _scaleToPage);
XSolidBrush fillEndArrow = ToXSolidBrush(line.Style.EndArrowStyle.Fill);
XPen strokeEndArrow = ToXPen(line.Style.EndArrowStyle, _scaleToPage);
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.XLine.SetMaxLength(line, ref _x1, ref _y1, ref _x2, ref _y2);
double x1 = _scaleToPage(_x1);
double y1 = _scaleToPage(_y1);
double x2 = _scaleToPage(_x2);
double y2 = _scaleToPage(_y2);
var sas = line.Style.StartArrowStyle;
var eas = line.Style.EndArrowStyle;
double a1 = Math.Atan2(y1 - y2, x1 - x2) * 180.0 / Math.PI;
double a2 = Math.Atan2(y2 - y1, x2 - x1) * 180.0 / Math.PI;
var t1 = new XMatrix();
var c1 = new XPoint(x1, y1);
t1.RotateAtPrepend(a1, c1);
var t2 = new XMatrix();
var c2 = new XPoint(x2, y2);
t2.RotateAtPrepend(a2, c2);
XPoint pt1;
XPoint pt2;
double radiusX1 = sas.RadiusX;
double radiusY1 = sas.RadiusY;
double sizeX1 = 2.0 * radiusX1;
double sizeY1 = 2.0 * radiusY1;
switch (sas.ArrowType)
{
default:
case Core2D.ArrowType.None:
{
pt1 = new XPoint(x1, y1);
}
break;
case Core2D.ArrowType.Rectangle:
{
pt1 = t1.Transform(new XPoint(x1 - sizeX1, y1));
var rect = new XRect(x1 - sizeX1, y1 - radiusY1, sizeX1, sizeY1);
_gfx.Save();
_gfx.RotateAtTransform(a1, c1);
DrawRectangleInternal(_gfx, fillStartArrow, strokeStartArrow, sas.IsStroked, sas.IsFilled, ref rect);
_gfx.Restore();
}
break;
case Core2D.ArrowType.Ellipse:
{
pt1 = t1.Transform(new XPoint(x1 - sizeX1, y1));
_gfx.Save();
_gfx.RotateAtTransform(a1, c1);
var rect = new XRect(x1 - sizeX1, y1 - radiusY1, sizeX1, sizeY1);
DrawEllipseInternal(_gfx, fillStartArrow, strokeStartArrow, sas.IsStroked, sas.IsFilled, ref rect);
_gfx.Restore();
}
break;
case Core2D.ArrowType.Arrow:
{
pt1 = t1.Transform(new XPoint(x1, y1));
var p11 = t1.Transform(new XPoint(x1 - sizeX1, y1 + sizeY1));
var p21 = t1.Transform(new XPoint(x1, y1));
var p12 = t1.Transform(new XPoint(x1 - sizeX1, y1 - sizeY1));
var p22 = t1.Transform(new XPoint(x1, y1));
DrawLineInternal(_gfx, strokeStartArrow, sas.IsStroked, ref p11, ref p21);
DrawLineInternal(_gfx, strokeStartArrow, sas.IsStroked, ref p12, ref p22);
}
break;
}
double radiusX2 = eas.RadiusX;
double radiusY2 = eas.RadiusY;
double sizeX2 = 2.0 * radiusX2;
double sizeY2 = 2.0 * radiusY2;
switch (eas.ArrowType)
{
default:
case Core2D.ArrowType.None:
{
pt2 = new XPoint(x2, y2);
}
break;
case Core2D.ArrowType.Rectangle:
{
pt2 = t2.Transform(new XPoint(x2 - sizeX2, y2));
var rect = new XRect(x2 - sizeX2, y2 - radiusY2, sizeX2, sizeY2);
_gfx.Save();
_gfx.RotateAtTransform(a2, c2);
DrawRectangleInternal(_gfx, fillEndArrow, strokeEndArrow, eas.IsStroked, eas.IsFilled, ref rect);
_gfx.Restore();
}
break;
case Core2D.ArrowType.Ellipse:
{
pt2 = t2.Transform(new XPoint(x2 - sizeX2, y2));
_gfx.Save();
_gfx.RotateAtTransform(a2, c2);
var rect = new XRect(x2 - sizeX2, y2 - radiusY2, sizeX2, sizeY2);
DrawEllipseInternal(_gfx, fillEndArrow, strokeEndArrow, eas.IsStroked, eas.IsFilled, ref rect);
_gfx.Restore();
}
break;
case Core2D.ArrowType.Arrow:
{
pt2 = t2.Transform(new XPoint(x2, y2));
var p11 = t2.Transform(new XPoint(x2 - sizeX2, y2 + sizeY2));
var p21 = t2.Transform(new XPoint(x2, y2));
var p12 = t2.Transform(new XPoint(x2 - sizeX2, y2 - sizeY2));
var p22 = t2.Transform(new XPoint(x2, y2));
DrawLineInternal(_gfx, strokeEndArrow, eas.IsStroked, ref p11, ref p21);
DrawLineInternal(_gfx, strokeEndArrow, eas.IsStroked, ref p12, ref p22);
}
break;
}
_gfx.DrawLine(strokeLine, pt1, pt2);
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="path"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Core2D.XPath path, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _gfx = gfx as XGraphics;
var gp = path.Geometry.ToXGraphicsPath(dx, dy, _scaleToPage);
if (path.IsFilled && path.IsStroked)
{
_gfx.DrawPath(
ToXPen(path.Style, _scaleToPage),
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),
gp);
}
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="container"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Core2D.Container container, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
foreach (var layer in container.Layers)
{
if (layer.IsVisible)
{
Draw(gfx, layer, db, r);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="qbezier"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Core2D.XQBezier qbezier, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _gfx = gfx as XGraphics;
double x1 = qbezier.Point1.X;
double y1 = qbezier.Point1.Y;
double x2 = qbezier.Point1.X + (2.0 * (qbezier.Point2.X - qbezier.Point1.X)) / 3.0;
double y2 = qbezier.Point1.Y + (2.0 * (qbezier.Point2.Y - qbezier.Point1.Y)) / 3.0;
double x3 = x2 + (qbezier.Point3.X - qbezier.Point1.X) / 3.0;
double y3 = y2 + (qbezier.Point3.Y - qbezier.Point1.Y) / 3.0;
double x4 = qbezier.Point3.X;
double y4 = qbezier.Point3.Y;
if (qbezier.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 (qbezier.IsStroked)
{
_gfx.DrawPath(
ToXPen(qbezier.Style, _scaleToPage),
ToXSolidBrush(qbezier.Style.Fill),
path);
}
else
{
_gfx.DrawPath(
ToXSolidBrush(qbezier.Style.Fill),
path);
}
}
else
{
if (qbezier.IsStroked)
{
_gfx.DrawBezier(
ToXPen(qbezier.Style, _scaleToPage),
_scaleToPage(x1 + dx),
_scaleToPage(y1 + dy),
_scaleToPage(x2 + dx),
_scaleToPage(y2 + dy),
_scaleToPage(x3 + dx),
_scaleToPage(y3 + dy),
_scaleToPage(x4 + dx),
_scaleToPage(y4 + dy));
}
}
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="path"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Core2D.XPath path, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
if (!path.IsStroked && !path.IsFilled)
{
return;
}
var _doc = doc as DxfDocument;
var style = path.Style;
ICollection <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 = GetColor(style.Fill);
var fillTransparency = GetTransparency(style.Fill);
var hatch = new Hatch(HatchPattern.Solid, bounds, false);
hatch.Layer = _currentLayer;
hatch.Color = fill;
hatch.Transparency.Value = fillTransparency;
_doc.AddEntity(hatch);
}
if (path.IsStroked)
{
// TODO: Add support for Closed paths.
var stroke = GetColor(style.Stroke);
var strokeTansparency = GetTransparency(style.Stroke);
var lineweight = ThicknessToLineweight(style.Thickness);
foreach (var entity in entities)
{
entity.Layer = _currentLayer;
entity.Color = stroke;
entity.Transparency.Value = strokeTansparency;
entity.Lineweight.Value = lineweight;
_doc.AddEntity(entity);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="arc"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Core2D.XArc arc, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _doc = doc as DxfDocument;
var style = arc.Style;
var dxfEllipse = CreateEllipticalArc(arc, dx, dy);
if (arc.IsFilled)
{
var fill = GetColor(style.Fill);
var fillTransparency = GetTransparency(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;
_doc.AddEntity(hatch);
}
if (arc.IsStroked)
{
var stroke = GetColor(style.Stroke);
var strokeTansparency = GetTransparency(style.Stroke);
var lineweight = ThicknessToLineweight(style.Thickness);
dxfEllipse.Layer = _currentLayer;
dxfEllipse.Color = stroke;
dxfEllipse.Transparency.Value = strokeTansparency;
dxfEllipse.Lineweight.Value = lineweight;
_doc.AddEntity(dxfEllipse);
}
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="arc"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Core2D.XArc arc, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _gfx = gfx as XGraphics;
var a = Core2D.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),
ToXSolidBrush(arc.Style.Fill),
path);
}
else
{
_gfx.DrawPath(
ToXSolidBrush(arc.Style.Fill),
path);
}
}
else
{
if (arc.IsStroked)
{
_gfx.DrawArc(
ToXPen(arc.Style, _scaleToPage),
_scaleToPage(a.X),
_scaleToPage(a.Y),
_scaleToPage(a.Width),
_scaleToPage(a.Height),
a.StartAngle,
a.SweepAngle);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="rectangle"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Core2D.XRectangle rectangle, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
if (!rectangle.IsStroked && !rectangle.IsFilled && !rectangle.IsGrid)
{
return;
}
var _doc = doc as DxfDocument;
var style = rectangle.Style;
var rect = Core2D.Rect2.Create(rectangle.TopLeft, rectangle.BottomRight, dx, dy);
DrawRectangleInternal(_doc, _currentLayer, rectangle.IsFilled, rectangle.IsStroked, style, ref rect);
if (rectangle.IsGrid)
{
DrawGridInternal(
_doc,
_currentLayer,
style,
rectangle.OffsetX, rectangle.OffsetY,
rectangle.CellWidth, rectangle.CellHeight,
ref rect);
}
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="ellipse"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Core2D.XEllipse ellipse, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
if (!ellipse.IsStroked && !ellipse.IsFilled)
{
return;
}
var _doc = doc as DxfDocument;
var style = ellipse.Style;
var rect = Core2D.Rect2.Create(ellipse.TopLeft, ellipse.BottomRight, dx, dy);
DrawEllipseInternal(_doc, _currentLayer, ellipse.IsFilled, ellipse.IsStroked, style, ref rect);
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="line"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Core2D.XLine line, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
if (!line.IsStroked)
{
return;
}
var _doc = doc as DxfDocument;
var style = line.Style;
var stroke = GetColor(style.Stroke);
var strokeTansparency = GetTransparency(style.Stroke);
var lineweight = ThicknessToLineweight(style.Thickness);
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.XLine.SetMaxLength(line, ref _x1, ref _y1, ref _x2, ref _y2);
var dxfLine = CreateLine(_x1, _y1, _x2, _y2);
// TODO: Draw line start arrow.
// TODO: Draw line end arrow.
dxfLine.Layer = _currentLayer;
dxfLine.Color = stroke;
dxfLine.Transparency.Value = strokeTansparency;
dxfLine.Lineweight.Value = lineweight;
_doc.AddEntity(dxfLine);
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="layer"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Core2D.Layer layer, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _doc = doc as DxfDocument;
foreach (var shape in layer.Shapes)
{
if (shape.State.Flags.HasFlag(_state.DrawShapeState.Flags))
{
shape.Draw(_doc, this, 0, 0, db, r);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="container"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Core2D.Container container, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _doc = doc as DxfDocument;
foreach (var layer in container.Layers)
{
var dxfLayer = new Layer(layer.Name)
{
IsVisible = layer.IsVisible
};
_doc.Layers.Add(dxfLayer);
_currentLayer = dxfLayer;
Draw(doc, layer, db, r);
}
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="rectangle"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Core2D.XRectangle rectangle, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _gfx = gfx as XGraphics;
var rect = Core2D.Rect2.Create(
rectangle.TopLeft,
rectangle.BottomRight,
dx, dy);
if (rectangle.IsStroked && rectangle.IsFilled)
{
_gfx.DrawRectangle(
ToXPen(rectangle.Style, _scaleToPage),
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),
_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 && rectangle.IsStroked)
{
DrawGridInternal(
_gfx,
ToXPen(rectangle.Style, _scaleToPage),
ref rect,
rectangle.OffsetX, rectangle.OffsetY,
rectangle.CellWidth, rectangle.CellHeight,
true);
}
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="qbezier"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Core2D.XQBezier qbezier, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
if (!qbezier.IsStroked && !qbezier.IsFilled)
{
return;
}
var _doc = doc as DxfDocument;
var style = qbezier.Style;
var dxfSpline = CreateQuadraticSpline(
qbezier.Point1.X + dx,
qbezier.Point1.Y + dy,
qbezier.Point2.X + dx,
qbezier.Point2.Y + dy,
qbezier.Point3.X + dx,
qbezier.Point3.Y + dy);
if (qbezier.IsFilled)
{
var fill = GetColor(style.Fill);
var fillTransparency = GetTransparency(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;
_doc.AddEntity(hatch);
}
if (qbezier.IsStroked)
{
var stroke = GetColor(style.Stroke);
var strokeTansparency = GetTransparency(style.Stroke);
var lineweight = ThicknessToLineweight(style.Thickness);
dxfSpline.Layer = _currentLayer;
dxfSpline.Color = stroke;
dxfSpline.Transparency.Value = strokeTansparency;
dxfSpline.Lineweight.Value = lineweight;
_doc.AddEntity(dxfSpline);
}
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="ellipse"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Core2D.XEllipse ellipse, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _gfx = gfx as XGraphics;
var rect = Core2D.Rect2.Create(
ellipse.TopLeft,
ellipse.BottomRight,
dx, dy);
if (ellipse.IsStroked && ellipse.IsFilled)
{
_gfx.DrawEllipse(
ToXPen(ellipse.Style, _scaleToPage),
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),
_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));
}
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="text"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Core2D.XText text, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _doc = doc as DxfDocument;
var tbind = text.BindToTextProperty(db, r);
if (string.IsNullOrEmpty(tbind))
{
return;
}
var style = text.Style;
var stroke = GetColor(style.Stroke);
var strokeTansparency = GetTransparency(style.Stroke);
var attachmentPoint = default(MTextAttachmentPoint);
double x, y;
var rect = Core2D.Rect2.Create(text.TopLeft, text.BottomRight, dx, dy);
switch (text.Style.TextStyle.TextHAlignment)
{
default:
case Core2D.TextHAlignment.Left:
x = rect.X;
break;
case Core2D.TextHAlignment.Center:
x = rect.X + rect.Width / 2.0;
break;
case Core2D.TextHAlignment.Right:
x = rect.X + rect.Width;
break;
}
switch (text.Style.TextStyle.TextVAlignment)
{
default:
case Core2D.TextVAlignment.Top:
y = rect.Y;
break;
case Core2D.TextVAlignment.Center:
y = rect.Y + rect.Height / 2.0;
break;
case Core2D.TextVAlignment.Bottom:
y = rect.Y + rect.Height;
break;
}
switch (text.Style.TextStyle.TextVAlignment)
{
default:
case Core2D.TextVAlignment.Top:
switch (text.Style.TextStyle.TextHAlignment)
{
default:
case Core2D.TextHAlignment.Left:
attachmentPoint = MTextAttachmentPoint.TopLeft;
break;
case Core2D.TextHAlignment.Center:
attachmentPoint = MTextAttachmentPoint.TopCenter;
break;
case Core2D.TextHAlignment.Right:
attachmentPoint = MTextAttachmentPoint.TopRight;
break;
}
break;
case Core2D.TextVAlignment.Center:
switch (text.Style.TextStyle.TextHAlignment)
{
default:
case Core2D.TextHAlignment.Left:
attachmentPoint = MTextAttachmentPoint.MiddleLeft;
break;
case Core2D.TextHAlignment.Center:
attachmentPoint = MTextAttachmentPoint.MiddleCenter;
break;
case Core2D.TextHAlignment.Right:
attachmentPoint = MTextAttachmentPoint.MiddleRight;
break;
}
break;
case Core2D.TextVAlignment.Bottom:
switch (text.Style.TextStyle.TextHAlignment)
{
default:
case Core2D.TextHAlignment.Left:
attachmentPoint = MTextAttachmentPoint.BottomLeft;
break;
case Core2D.TextHAlignment.Center:
attachmentPoint = MTextAttachmentPoint.BottomCenter;
break;
case Core2D.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 * 72.0 / 96.0,
rect.Width,
ts);
dxfMText.AttachmentPoint = attachmentPoint;
var fs = text.Style.TextStyle.FontStyle;
var options = new MTextFormattingOptions(dxfMText.Style);
options.Bold = fs.Flags.HasFlag(Core2D.FontStyleFlags.Bold);
options.Italic = fs.Flags.HasFlag(Core2D.FontStyleFlags.Italic);
options.Underline = fs.Flags.HasFlag(Core2D.FontStyleFlags.Underline);
options.StrikeThrough = fs.Flags.HasFlag(Core2D.FontStyleFlags.Strikeout);
options.Aligment = MTextFormattingOptions.TextAligment.Default;
options.Color = null;
dxfMText.Write(tbind, options);
dxfMText.Layer = _currentLayer;
dxfMText.Transparency.Value = strokeTansparency;
dxfMText.Color = stroke;
_doc.AddEntity(dxfMText);
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="bezier"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Core2D.XBezier bezier, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _gfx = gfx as XGraphics;
if (bezier.IsFilled)
{
var path = new XGraphicsPath();
path.AddBezier(
_scaleToPage(bezier.Point1.X + dx),
_scaleToPage(bezier.Point1.Y + dy),
_scaleToPage(bezier.Point2.X + dx),
_scaleToPage(bezier.Point2.Y + dy),
_scaleToPage(bezier.Point3.X + dx),
_scaleToPage(bezier.Point3.Y + dy),
_scaleToPage(bezier.Point4.X + dx),
_scaleToPage(bezier.Point4.Y + dy));
if (bezier.IsStroked)
{
_gfx.DrawPath(
ToXPen(bezier.Style, _scaleToPage),
ToXSolidBrush(bezier.Style.Fill),
path);
}
else
{
_gfx.DrawPath(
ToXSolidBrush(bezier.Style.Fill),
path);
}
}
else
{
if (bezier.IsStroked)
{
_gfx.DrawBezier(
ToXPen(bezier.Style, _scaleToPage),
_scaleToPage(bezier.Point1.X + dx),
_scaleToPage(bezier.Point1.Y + dy),
_scaleToPage(bezier.Point2.X + dx),
_scaleToPage(bezier.Point2.Y + dy),
_scaleToPage(bezier.Point3.X + dx),
_scaleToPage(bezier.Point3.Y + dy),
_scaleToPage(bezier.Point4.X + dx),
_scaleToPage(bezier.Point4.Y + dy));
}
}
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="image"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Core2D.XImage image, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _gfx = gfx as XGraphics;
var rect = Core2D.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)
{
_gfx.DrawRectangle(
ToXPen(image.Style, _scaleToPage),
ToXSolidBrush(image.Style.Fill),
srect);
}
else if (image.IsStroked && !image.IsFilled)
{
_gfx.DrawRectangle(
ToXPen(image.Style, _scaleToPage),
srect);
}
else if (!image.IsStroked && image.IsFilled)
{
_gfx.DrawRectangle(
ToXSolidBrush(image.Style.Fill),
srect);
}
if (_enableImageCache &&
_biCache.ContainsKey(image.Path))
{
_gfx.DrawImage(_biCache[image.Path], srect);
}
else
{
if (_state.ImageCache == null || string.IsNullOrEmpty(image.Path))
{
return;
}
var bytes = _state.ImageCache.GetImage(image.Path);
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.Path] = bi;
}
_gfx.DrawImage(bi, srect);
if (!_enableImageCache)
{
bi.Dispose();
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="text"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Core2D.XText text, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _gfx = gfx as XGraphics;
var tbind = text.BindToTextProperty(db, r);
if (string.IsNullOrEmpty(tbind))
{
return;
}
var options = new XPdfFontOptions(PdfFontEncoding.Unicode);
var fontStyle = XFontStyle.Regular;
if (text.Style.TextStyle.FontStyle.Flags.HasFlag(Core2D.FontStyleFlags.Bold))
{
fontStyle |= XFontStyle.Bold;
}
if (text.Style.TextStyle.FontStyle.Flags.HasFlag(Core2D.FontStyleFlags.Italic))
{
fontStyle |= XFontStyle.Italic;
}
if (text.Style.TextStyle.FontStyle.Flags.HasFlag(Core2D.FontStyleFlags.Underline))
{
fontStyle |= XFontStyle.Underline;
}
if (text.Style.TextStyle.FontStyle.Flags.HasFlag(Core2D.FontStyleFlags.Strikeout))
{
fontStyle |= XFontStyle.Strikeout;
}
var font = new XFont(
text.Style.TextStyle.FontName,
_scaleToPage(text.Style.TextStyle.FontSize),
fontStyle,
options);
var rect = Core2D.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.TextHAlignment.Left:
format.Alignment = XStringAlignment.Near;
break;
case Core2D.TextHAlignment.Center:
format.Alignment = XStringAlignment.Center;
break;
case Core2D.TextHAlignment.Right:
format.Alignment = XStringAlignment.Far;
break;
}
switch (text.Style.TextStyle.TextVAlignment)
{
case Core2D.TextVAlignment.Top:
format.LineAlignment = XLineAlignment.Near;
break;
case Core2D.TextVAlignment.Center:
format.LineAlignment = XLineAlignment.Center;
break;
case Core2D.TextVAlignment.Bottom:
format.LineAlignment = XLineAlignment.Far;
break;
}
_gfx.DrawString(
tbind,
font,
ToXSolidBrush(text.Style.Stroke),
srect,
format);
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="image"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Core2D.XImage image, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _doc = doc as DxfDocument;
var bytes = _state.ImageCache.GetImage(image.Path);
if (bytes != null)
{
var rect = Core2D.Rect2.Create(image.TopLeft, image.BottomRight, dx, dy);
if (_enableImageCache &&
_biCache.ContainsKey(image.Path))
{
var dxfImageDefinition = _biCache[image.Path];
var dxfImage = new Image(
dxfImageDefinition,
new Vector3(ToDxfX(rect.X), ToDxfY(rect.Y + rect.Height), 0),
rect.Width,
rect.Height);
_doc.AddEntity(dxfImage);
}
else
{
if (_state.ImageCache == null || string.IsNullOrEmpty(image.Path))
{
return;
}
var path = System.IO.Path.Combine(_outputPath, System.IO.Path.GetFileName(image.Path));
System.IO.File.WriteAllBytes(path, bytes);
var dxfImageDefinition = new ImageDef(path);
if (_enableImageCache)
{
_biCache[image.Path] = dxfImageDefinition;
}
var dxfImage = new Image(
dxfImageDefinition,
new Vector3(ToDxfX(rect.X), ToDxfY(rect.Y + rect.Height), 0),
rect.Width,
rect.Height);
_doc.AddEntity(dxfImage);
}
}
}
