/// <summary>
///
/// </summary>
/// <param name="binding"></param>
/// <param name="r"></param>
/// <param name="value"></param>
private static void BindToDouble(ShapeBinding binding, Record r, ref double value)
{
var columns = r.Columns;
for (int i = 0; i < columns.Length; i++)
{
if (columns[i].Name != binding.Path)
{
continue;
}
double result;
bool success = double.TryParse(
r.Values[i].Content,
NumberStyles.Any, CultureInfo.InvariantCulture,
out result);
if (success)
{
value = result;
break;
}
}
}
/// <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, XQBezier qbezier, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var _gfx = gfx as Graphics;
Brush brush = ToSolidBrush(qbezier.Style.Fill);
Pen pen = ToPen(qbezier.Style, _scaleToPage);
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 GraphicsPath();
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));
_gfx.FillPath(brush, path);
}
if (qbezier.IsStroked)
{
_gfx.DrawBezier(
pen,
_scaleToPage(x1 + dx),
_scaleToPage(y1 + dy),
_scaleToPage(x2 + dx),
_scaleToPage(y2 + dy),
_scaleToPage(x3 + dx),
_scaleToPage(y3 + dy),
_scaleToPage(x4 + dx),
_scaleToPage(y4 + dy));
}
brush.Dispose();
pen.Dispose();
}
/// <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, XArc arc, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var a = GdiArc.FromXArc(arc, dx, dy);
if (a.Width <= 0.0 || a.Height <= 0.0)
return;
var _gfx = gfx as Graphics;
Brush brush = ToSolidBrush(arc.Style.Fill);
Pen pen = ToPen(arc.Style, _scaleToPage);
if (arc.IsFilled)
{
var path = new GraphicsPath();
path.AddArc(
_scaleToPage(a.X),
_scaleToPage(a.Y),
_scaleToPage(a.Width),
_scaleToPage(a.Height),
(float)a.StartAngle,
(float)a.SweepAngle);
_gfx.FillPath(brush, path);
}
if (arc.IsStroked)
{
_gfx.DrawArc(
pen,
_scaleToPage(a.X),
_scaleToPage(a.Y),
_scaleToPage(a.Width),
_scaleToPage(a.Height),
(float)a.StartAngle,
(float)a.SweepAngle);
}
brush.Dispose();
pen.Dispose();
}
/// <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, XRectangle rectangle, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var _gfx = gfx as Graphics;
Brush brush = ToSolidBrush(rectangle.Style.Fill);
Pen pen = ToPen(rectangle.Style, _scaleToPage);
var rect = CreateRect(
rectangle.TopLeft,
rectangle.BottomRight,
dx, dy);
if (rectangle.IsFilled)
{
_gfx.FillRectangle(
brush,
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
}
if (rectangle.IsStroked)
{
_gfx.DrawRectangle(
pen,
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
}
if (rectangle.IsGrid)
{
DrawGridInternal(
_gfx,
pen,
ref rect,
rectangle.OffsetX, rectangle.OffsetY,
rectangle.CellWidth, rectangle.CellHeight,
true);
}
brush.Dispose();
pen.Dispose();
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="layer"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Layer layer, ImmutableArray<ShapeProperty> db, Record r)
{
foreach (var shape in layer.Shapes)
{
if (shape.State.HasFlag(_state.DrawShapeState))
{
shape.Draw(gfx, this, 0, 0, db, r);
}
}
}
/// <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, XText text, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var _gfx = gfx as Graphics;
var tbind = text.BindToTextProperty(db, r);
if (string.IsNullOrEmpty(tbind))
return;
var brush = ToSolidBrush(text.Style.Stroke);
var fontStyle = Eto.Drawing.FontStyle.None;
if (text.Style.TextStyle.FontStyle.Flags.HasFlag(Test2d.FontStyleFlags.Bold))
{
fontStyle |= Eto.Drawing.FontStyle.Bold;
}
if (text.Style.TextStyle.FontStyle.Flags.HasFlag(Test2d.FontStyleFlags.Italic))
{
fontStyle |= Eto.Drawing.FontStyle.Italic;
}
var fontDecoration = Eto.Drawing.FontDecoration.None;
if (text.Style.TextStyle.FontStyle.Flags.HasFlag(Test2d.FontStyleFlags.Underline))
{
fontDecoration |= Eto.Drawing.FontDecoration.Underline;
}
if (text.Style.TextStyle.FontStyle.Flags.HasFlag(Test2d.FontStyleFlags.Strikeout))
{
fontDecoration |= Eto.Drawing.FontDecoration.Strikethrough;
}
var font = new Font(
text.Style.TextStyle.FontName,
(float)(text.Style.TextStyle.FontSize * _textScaleFactor),
fontStyle,
fontDecoration);
var rect = CreateRect(
text.TopLeft,
text.BottomRight,
dx, dy);
var srect = new RectangleF(
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
var size = _gfx.MeasureString(font, tbind);
var origin = GetTextOrigin(text.Style, ref srect, ref size);
_gfx.DrawText(
font,
brush,
origin,
tbind);
brush.Dispose();
font.Dispose();
}
/// <summary>
///
/// </summary>
/// <param name="record"></param>
/// <param name="x"></param>
/// <param name="y"></param>
public void DropAsShapeAndBind(Record record, double x, double y)
{
switch (_editor.CurrentTool)
{
case Tool.Point:
{
var point = XPoint.Create(x, y, _editor.Project.Options.PointShape);
point.Record = record;
if (record.Columns.Length >= 2)
{
point.Bindings = point.Bindings.Add(ShapeBinding.Create("X", record.Columns[0].Name));
point.Bindings = point.Bindings.Add(ShapeBinding.Create("Y", record.Columns[1].Name));
}
_editor.AddWithHistory(point);
}
break;
case Tool.Line:
{
var line = XLine.Create(
x, y,
_editor.Project.CurrentStyleLibrary.CurrentStyle,
_editor.Project.Options.PointShape);
line.Record = record;
if (record.Columns.Length >= 2)
{
line.Bindings = line.Bindings.Add(ShapeBinding.Create("Start.X", record.Columns[0].Name));
line.Bindings = line.Bindings.Add(ShapeBinding.Create("Start.Y", record.Columns[1].Name));
}
if (record.Columns.Length >= 4)
{
line.Bindings = line.Bindings.Add(ShapeBinding.Create("End.X", record.Columns[2].Name));
line.Bindings = line.Bindings.Add(ShapeBinding.Create("End.Y", record.Columns[3].Name));
}
_editor.AddWithHistory(line);
}
break;
case Tool.Rectangle:
{
var rectangle = XRectangle.Create(
x, y,
_editor.Project.CurrentStyleLibrary.CurrentStyle,
_editor.Project.Options.PointShape);
rectangle.Record = record;
if (record.Columns.Length >= 2)
{
rectangle.Bindings = rectangle.Bindings.Add(ShapeBinding.Create("TopLeft.X", record.Columns[0].Name));
rectangle.Bindings = rectangle.Bindings.Add(ShapeBinding.Create("TopLeft.Y", record.Columns[1].Name));
}
if (record.Columns.Length >= 4)
{
rectangle.Bindings = rectangle.Bindings.Add(ShapeBinding.Create("BottomRight.X", record.Columns[2].Name));
rectangle.Bindings = rectangle.Bindings.Add(ShapeBinding.Create("BottomRight.Y", record.Columns[3].Name));
}
_editor.AddWithHistory(rectangle);
}
break;
case Tool.Ellipse:
{
var ellipse = XEllipse.Create(
x, y,
_editor.Project.CurrentStyleLibrary.CurrentStyle,
_editor.Project.Options.PointShape);
ellipse.Record = record;
if (record.Columns.Length >= 2)
{
ellipse.Bindings = ellipse.Bindings.Add(ShapeBinding.Create("TopLeft.X", record.Columns[0].Name));
ellipse.Bindings = ellipse.Bindings.Add(ShapeBinding.Create("TopLeft.Y", record.Columns[1].Name));
}
if (record.Columns.Length >= 4)
{
ellipse.Bindings = ellipse.Bindings.Add(ShapeBinding.Create("BottomRight.X", record.Columns[2].Name));
ellipse.Bindings = ellipse.Bindings.Add(ShapeBinding.Create("BottomRight.Y", record.Columns[3].Name));
}
_editor.AddWithHistory(ellipse);
}
break;
case Tool.Arc:
{
var arc = XArc.Create(
x, y,
_editor.Project.CurrentStyleLibrary.CurrentStyle,
_editor.Project.Options.PointShape);
arc.Record = record;
if (record.Columns.Length >= 2)
{
arc.Bindings = arc.Bindings.Add(ShapeBinding.Create("Point1.X", record.Columns[0].Name));
arc.Bindings = arc.Bindings.Add(ShapeBinding.Create("Point1.Y", record.Columns[1].Name));
}
if (record.Columns.Length >= 4)
{
arc.Bindings = arc.Bindings.Add(ShapeBinding.Create("Point2.X", record.Columns[2].Name));
arc.Bindings = arc.Bindings.Add(ShapeBinding.Create("Point2.Y", record.Columns[3].Name));
}
if (record.Columns.Length >= 6)
{
arc.Bindings = arc.Bindings.Add(ShapeBinding.Create("Point3.X", record.Columns[4].Name));
arc.Bindings = arc.Bindings.Add(ShapeBinding.Create("Point3.Y", record.Columns[5].Name));
}
if (record.Columns.Length >= 8)
{
arc.Bindings = arc.Bindings.Add(ShapeBinding.Create("Point4.X", record.Columns[6].Name));
arc.Bindings = arc.Bindings.Add(ShapeBinding.Create("Point4.Y", record.Columns[7].Name));
}
_editor.AddWithHistory(arc);
}
break;
case Tool.Bezier:
{
var bezier = XBezier.Create(
x, y,
_editor.Project.CurrentStyleLibrary.CurrentStyle,
_editor.Project.Options.PointShape);
bezier.Record = record;
if (record.Columns.Length >= 2)
{
bezier.Bindings = bezier.Bindings.Add(ShapeBinding.Create("Point1.X", record.Columns[0].Name));
bezier.Bindings = bezier.Bindings.Add(ShapeBinding.Create("Point1.Y", record.Columns[1].Name));
}
if (record.Columns.Length >= 4)
{
bezier.Bindings = bezier.Bindings.Add(ShapeBinding.Create("Point2.X", record.Columns[2].Name));
bezier.Bindings = bezier.Bindings.Add(ShapeBinding.Create("Point2.Y", record.Columns[3].Name));
}
if (record.Columns.Length >= 6)
{
bezier.Bindings = bezier.Bindings.Add(ShapeBinding.Create("Point3.X", record.Columns[4].Name));
bezier.Bindings = bezier.Bindings.Add(ShapeBinding.Create("Point3.Y", record.Columns[5].Name));
}
if (record.Columns.Length >= 8)
{
bezier.Bindings = bezier.Bindings.Add(ShapeBinding.Create("Point4.X", record.Columns[6].Name));
bezier.Bindings = bezier.Bindings.Add(ShapeBinding.Create("Point4.Y", record.Columns[7].Name));
}
_editor.AddWithHistory(bezier);
}
break;
case Tool.QBezier:
{
var qbezier = XQBezier.Create(
x, y,
_editor.Project.CurrentStyleLibrary.CurrentStyle,
_editor.Project.Options.PointShape);
qbezier.Record = record;
if (record.Columns.Length >= 2)
{
qbezier.Bindings = qbezier.Bindings.Add(ShapeBinding.Create("Point1.X", record.Columns[0].Name));
qbezier.Bindings = qbezier.Bindings.Add(ShapeBinding.Create("Point1.Y", record.Columns[1].Name));
}
if (record.Columns.Length >= 4)
{
qbezier.Bindings = qbezier.Bindings.Add(ShapeBinding.Create("Point2.X", record.Columns[2].Name));
qbezier.Bindings = qbezier.Bindings.Add(ShapeBinding.Create("Point2.Y", record.Columns[3].Name));
}
if (record.Columns.Length >= 6)
{
qbezier.Bindings = qbezier.Bindings.Add(ShapeBinding.Create("Point3.X", record.Columns[4].Name));
qbezier.Bindings = qbezier.Bindings.Add(ShapeBinding.Create("Point3.Y", record.Columns[5].Name));
}
_editor.AddWithHistory(qbezier);
}
break;
case Tool.Text:
{
var text = XText.Create(
x, y,
_editor.Project.CurrentStyleLibrary.CurrentStyle,
_editor.Project.Options.PointShape,
"Text");
text.Record = record;
if (record.Columns.Length >= 2)
{
text.Bindings = text.Bindings.Add(ShapeBinding.Create("TopLeft.X", record.Columns[0].Name));
text.Bindings = text.Bindings.Add(ShapeBinding.Create("TopLeft.Y", record.Columns[1].Name));
}
if (record.Columns.Length >= 4)
{
text.Bindings = text.Bindings.Add(ShapeBinding.Create("BottomRight.X", record.Columns[2].Name));
text.Bindings = text.Bindings.Add(ShapeBinding.Create("BottomRight.Y", record.Columns[3].Name));
}
_editor.AddWithHistory(text);
}
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="dc"></param>
/// <param name="renderer"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public override void Draw(object dc, IRenderer renderer, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var record = r ?? this.Record;
if (State.HasFlag(ShapeState.Visible))
{
renderer.Draw(dc, this, dx, dy, db, record);
}
if (renderer.State.SelectedShape != null)
{
if (this == renderer.State.SelectedShape)
{
var points = this.GetAllPoints();
foreach (var point in points)
{
point.Draw(dc, renderer, dx, dy, db, record);
}
}
else
{
var points = this.GetAllPoints();
foreach (var point in points)
{
if (point == renderer.State.SelectedShape)
{
point.Draw(dc, renderer, dx, dy, db, record);
}
}
}
}
if (renderer.State.SelectedShapes != null)
{
if (renderer.State.SelectedShapes.Contains(this))
{
var points = this.GetAllPoints();
foreach (var point in points)
{
point.Draw(dc, renderer, dx, dy, db, record);
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="dc"></param>
/// <param name="renderer"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public override void Draw(object dc, IRenderer renderer, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var record = r ?? this.Data.Record;
if (_shape != null)
{
if (State.Flags.HasFlag(ShapeStateFlags.Visible))
{
_shape.Draw(dc, renderer, X + dx, Y + dy, db, record);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="r"></param>
public override void Bind(Record r)
{
var record = r ?? this.Record;
_point1.TryToBind("Point1", this.Bindings, record);
_point2.TryToBind("Point2", this.Bindings, record);
_point3.TryToBind("Point3", this.Bindings, record);
_point4.TryToBind("Point4", this.Bindings, record);
}
/// <summary>
///
/// </summary>
/// <param name="dc"></param>
/// <param name="renderer"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public override void Draw(object dc, IRenderer renderer, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var record = r ?? this.Record;
if (State.HasFlag(ShapeState.Visible))
{
renderer.Draw(dc, this, dx, dy, db, record);
base.Draw(dc, renderer, dx, dy, db, record);
}
}
/// <summary>
///
/// </summary>
/// <param name="r"></param>
public override void Bind(Record r)
{
base.Bind(r ?? this.Record);
}
/// <summary>
///
/// </summary>
/// <param name="bindings"></param>
/// <param name="r"></param>
/// <param name="propertyName"></param>
/// <param name="value"></param>
/// <returns></returns>
private static bool TryToBind(
ImmutableArray<ShapeBinding> bindings,
Record r,
string propertyName,
out string value)
{
if (r == null || bindings == null || bindings.Length <= 0)
{
value = null;
return false;
}
if (r.Columns == null || r.Values == null || r.Columns.Length != r.Values.Length)
{
value = null;
return false;
}
var columns = r.Columns;
foreach (var binding in bindings)
{
if (string.IsNullOrEmpty(binding.Property) || string.IsNullOrEmpty(binding.Path))
continue;
if (binding.Property != propertyName)
continue;
for (int i = 0; i < columns.Length; i++)
{
if (columns[i].Name == binding.Path)
{
value = r.Values[i].Content;
return true;
}
}
}
value = null;
return false;
}
/// <summary>
///
/// </summary>
/// <param name="dc"></param>
/// <param name="renderer"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public override void Draw(object dc, IRenderer renderer, double dx, double dy, ImmutableArray <ShapeProperty> db, Record r)
{
var record = r ?? this.Data.Record;
if (_shape != null)
{
if (State.Flags.HasFlag(ShapeStateFlags.Visible))
{
_shape.Draw(dc, renderer, X + dx, Y + dy, db, record);
}
}
}
/// <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, XImage image, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var _gfx = gfx as Graphics;
Brush brush = ToSolidBrush(image.Style.Stroke);
var rect = CreateRect(
image.TopLeft,
image.BottomRight,
dx, dy);
var srect = new RectangleF(
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
if (image.IsFilled)
{
_gfx.FillRectangle(
ToSolidBrush(image.Style.Fill),
srect);
}
if (image.IsStroked)
{
_gfx.DrawRectangle(
ToPen(image.Style, _scaleToPage),
srect.X,
srect.Y,
srect.Width,
srect.Height);
}
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);
var bi = Image.FromStream(ms);
ms.Dispose();
if (_enableImageCache)
_biCache[image.Path] = bi;
_gfx.DrawImage(bi, srect);
if (!_enableImageCache)
bi.Dispose();
}
}
brush.Dispose();
}
/// <summary>
///
/// </summary>
/// <param name="propertyName"></param>
/// <param name="bindings"></param>
/// <param name="record"></param>
public void TryToBind(string propertyName, ImmutableArray<ShapeBinding> bindings, Record record)
{
string propertyNameX = propertyName + ".X";
string propertyNameY = propertyName + ".Y";
TryToBind(bindings, record, propertyNameX, propertyNameY);
}
/// <summary>
///
/// </summary>
/// <param name="propertyName"></param>
/// <param name="bindings"></param>
/// <param name="record"></param>
public void TryToBind(string propertyName, ImmutableArray <ShapeBinding> bindings, Record record)
{
string propertyNameX = propertyName + ".X";
string propertyNameY = propertyName + ".Y";
TryToBind(bindings, record, propertyNameX, propertyNameY);
}
/// <summary>
///
/// </summary>
/// <param name="binding"></param>
/// <param name="r"></param>
/// <param name="value"></param>
private static void BindToDouble(ShapeBinding binding, Record r, ref double value)
{
var columns = r.Columns;
for (int i = 0; i < columns.Length; i++)
{
if (columns[i].Name != binding.Path)
continue;
double result;
bool success = double.TryParse(
r.Values[i].Content,
NumberStyles.Any, CultureInfo.InvariantCulture,
out result);
if (success)
{
value = result;
break;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="record"></param>
/// <param name="x"></param>
/// <param name="y"></param>
public void Drop(Record record, double x, double y)
{
try
{
if (_editor.Renderers[0].State.SelectedShape != null)
{
// TODO: Add history snapshot.
_editor.Renderers[0].State.SelectedShape.Record = record;
}
else if (_editor.Renderers[0].State.SelectedShapes != null && _editor.Renderers[0].State.SelectedShapes.Count > 0)
{
// TODO: Add history snapshot.
foreach (var shape in _editor.Renderers[0].State.SelectedShapes)
{
shape.Record = record;
}
}
else
{
var container = _editor.Project.CurrentContainer;
if (container != null)
{
var result = ShapeBounds.HitTest(container, new Vector2(x, y), _editor.Project.Options.HitTreshold);
if (result != null)
{
var previous = result.Record;
var next = record;
_editor.History.Snapshot(previous, next, (p) => result.Record = p);
result.Record = next;
}
else
{
if (_editor.CurrentTool == Tool.None
|| _editor.CurrentTool == Tool.Selection
|| _editor.CurrentTool == Tool.Image
|| _editor.CurrentTool == Tool.Path)
{
DropAsGroup(record, x, y);
}
else
{
DropAsShapeAndBind(record, x, y);
}
}
}
}
}
catch (Exception ex)
{
if (_editor.Log != null)
{
_editor.Log.LogError("{0}{1}{2}",
ex.Message,
Environment.NewLine,
ex.StackTrace);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="bindings"></param>
/// <param name="r"></param>
/// <param name="propertyNameX"></param>
/// <param name="propertyNameY"></param>
private void TryToBind(
ImmutableArray<ShapeBinding> bindings,
Record r,
string propertyNameX,
string propertyNameY)
{
if (r == null || bindings == null || bindings.Length <= 0)
return;
if (r.Columns == null || r.Values == null || r.Columns.Length != r.Values.Length)
return;
foreach (var binding in bindings)
{
if (string.IsNullOrEmpty(binding.Property) || string.IsNullOrEmpty(binding.Path))
continue;
if (binding.Property == propertyNameX)
{
BindToDouble(binding, r, ref _x);
}
else if (binding.Property == propertyNameY)
{
BindToDouble(binding, r, ref _y);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="record"></param>
/// <param name="x"></param>
/// <param name="y"></param>
public void DropAsGroup(Record record, double x, double y)
{
var g = XGroup.Create("g");
g.Record = record;
double sx = _editor.Project.Options.SnapToGrid ? Editor.Snap(x, _editor.Project.Options.SnapX) : x;
double sy = _editor.Project.Options.SnapToGrid ? Editor.Snap(y, _editor.Project.Options.SnapY) : y;
var length = record.Values.Length;
double px = sx;
double py = sy;
double width = 150;
double height = 15;
for (int i = 0; i < length; i++)
{
var column = record.Columns[i];
if (column.IsVisible)
{
var text = XText.Create(
px, py,
px + width, py + height,
_editor.Project.CurrentStyleLibrary.CurrentStyle,
_editor.Project.Options.PointShape, "");
var binding = ShapeBinding.Create("Text", record.Columns[i].Name);
text.Bindings = text.Bindings.Add(binding);
g.AddShape(text);
py += height;
}
}
var rectangle = XRectangle.Create(
sx, sy,
sx + width, sy + (double)length * height,
_editor.Project.CurrentStyleLibrary.CurrentStyle,
_editor.Project.Options.PointShape);
g.AddShape(rectangle);
double ptx = sx + width / 2;
double pty = sy;
double pbx = sx + width / 2;
double pby = sy + (double)length * height;
double plx = sx;
double ply = sy + ((double)length * height) / 2;
double prx = sx + width;
double pry = sy + ((double)length * height) / 2;
var pt = XPoint.Create(ptx, pty, _editor.Project.Options.PointShape);
var pb = XPoint.Create(pbx, pby, _editor.Project.Options.PointShape);
var pl = XPoint.Create(plx, ply, _editor.Project.Options.PointShape);
var pr = XPoint.Create(prx, pry, _editor.Project.Options.PointShape);
g.AddConnectorAsNone(pt);
g.AddConnectorAsNone(pb);
g.AddConnectorAsNone(pl);
g.AddConnectorAsNone(pr);
_editor.AddWithHistory(g);
}
/// <summary>
///
/// </summary>
/// <param name="r"></param>
public override void Bind(Record r)
{
var record = r ?? this.Data.Record;
var bindings = this.Data.Bindings;
string propertyNameX = "X";
string propertyNameY = "Y";
TryToBind(bindings, record, propertyNameX, propertyNameY);
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="container"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Container container, ImmutableArray<ShapeProperty> db, Record r)
{
foreach (var layer in container.Layers)
{
if (layer.IsVisible)
{
Draw(gfx, layer, db, r);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="r"></param>
public override void Bind(Record r)
{
var record = r ?? this.Record;
_start.TryToBind("Start", this.Bindings, record);
_end.TryToBind("End", this.Bindings, record);
}
/// <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, XLine line, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var _gfx = gfx as Graphics;
Brush fillLine = ToSolidBrush(line.Style.Fill);
Pen strokeLine = ToPen(line.Style, _scaleToPage);
Brush fillStartArrow = ToSolidBrush(line.Style.StartArrowStyle.Fill);
Pen strokeStartArrow = ToPen(line.Style.StartArrowStyle, _scaleToPage);
Brush fillEndArrow = ToSolidBrush(line.Style.EndArrowStyle.Fill);
Pen strokeEndArrow = ToPen(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;
XLine.SetMaxLength(line, ref _x1, ref _y1, ref _x2, ref _y2);
float x1 = _scaleToPage(_x1);
float y1 = _scaleToPage(_y1);
float x2 = _scaleToPage(_x2);
float y2 = _scaleToPage(_y2);
var sas = line.Style.StartArrowStyle;
var eas = line.Style.EndArrowStyle;
float a1 = (float)(Math.Atan2(y1 - y2, x1 - x2) * 180.0 / Math.PI);
float a2 = (float)(Math.Atan2(y2 - y1, x2 - x1) * 180.0 / Math.PI);
var t1 = new Matrix();
var c1 = new PointF(x1, y1);
t1.RotateAt(a1, c1);
var t2 = new Matrix();
var c2 = new PointF(x2, y2);
t2.RotateAt(a2, c2);
PointF pt1;
PointF pt2;
double radiusX1 = sas.RadiusX;
double radiusY1 = sas.RadiusY;
double sizeX1 = 2.0 * radiusX1;
double sizeY1 = 2.0 * radiusY1;
switch (sas.ArrowType)
{
default:
case ArrowType.None:
{
pt1 = new PointF(x1, y1);
}
break;
case ArrowType.Rectangle:
{
var pts = new PointF[] { new PointF(x1 - (float)sizeX1, y1) };
t1.TransformPoints(pts);
pt1 = pts[0];
var rect = new Rect2(x1 - sizeX1, y1 - radiusY1, sizeX1, sizeY1);
var gs = _gfx.Save();
_gfx.MultiplyTransform(t1);
DrawRectangleInternal(_gfx, fillStartArrow, strokeStartArrow, sas.IsStroked, sas.IsFilled, ref rect);
_gfx.Restore(gs);
}
break;
case ArrowType.Ellipse:
{
var pts = new PointF[] { new PointF(x1 - (float)sizeX1, y1) };
t1.TransformPoints(pts);
pt1 = pts[0];
var gs = _gfx.Save();
_gfx.MultiplyTransform(t1);
var rect = new Rect2(x1 - sizeX1, y1 - radiusY1, sizeX1, sizeY1);
DrawEllipseInternal(_gfx, fillStartArrow, strokeStartArrow, sas.IsStroked, sas.IsFilled, ref rect);
_gfx.Restore(gs);
}
break;
case ArrowType.Arrow:
{
var pts = new PointF[]
{
new PointF(x1, y1),
new PointF(x1 - (float)sizeX1, y1 + (float)sizeY1),
new PointF(x1, y1),
new PointF(x1 - (float)sizeX1, y1 - (float)sizeY1),
new PointF(x1, y1)
};
t1.TransformPoints(pts);
pt1 = pts[0];
var p11 = pts[1];
var p21 = pts[2];
var p12 = pts[3];
var p22 = pts[4];
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 ArrowType.None:
{
pt2 = new PointF(x2, y2);
}
break;
case ArrowType.Rectangle:
{
var pts = new PointF[] { new PointF(x2 - (float)sizeX2, y2) };
t2.TransformPoints(pts);
pt2 = pts[0];
var rect = new Rect2(x2 - sizeX2, y2 - radiusY2, sizeX2, sizeY2);
var gs = _gfx.Save();
_gfx.MultiplyTransform(t2);
DrawRectangleInternal(_gfx, fillEndArrow, strokeEndArrow, eas.IsStroked, eas.IsFilled, ref rect);
_gfx.Restore(gs);
}
break;
case ArrowType.Ellipse:
{
var pts = new PointF[] { new PointF(x2 - (float)sizeX2, y2) };
t2.TransformPoints(pts);
pt2 = pts[0];
var gs = _gfx.Save();
_gfx.MultiplyTransform(t2);
var rect = new Rect2(x2 - sizeX2, y2 - radiusY2, sizeX2, sizeY2);
DrawEllipseInternal(_gfx, fillEndArrow, strokeEndArrow, eas.IsStroked, eas.IsFilled, ref rect);
_gfx.Restore(gs);
}
break;
case ArrowType.Arrow:
{
var pts = new PointF[]
{
new PointF(x2, y2),
new PointF(x2 - (float)sizeX2, y2 + (float)sizeY2),
new PointF(x2, y2),
new PointF(x2 - (float)sizeX2, y2 - (float)sizeY2),
new PointF(x2, y2)
};
t2.TransformPoints(pts);
pt2 = pts[0];
var p11 = pts[1];
var p21 = pts[2];
var p12 = pts[3];
var p22 = pts[4];
DrawLineInternal(_gfx, strokeEndArrow, eas.IsStroked, ref p11, ref p21);
DrawLineInternal(_gfx, strokeEndArrow, eas.IsStroked, ref p12, ref p22);
}
break;
}
_gfx.DrawLine(strokeLine, pt1, pt2);
fillLine.Dispose();
strokeLine.Dispose();
fillStartArrow.Dispose();
strokeStartArrow.Dispose();
fillEndArrow.Dispose();
strokeEndArrow.Dispose();
}
/// <summary>
///
/// </summary>
/// <param name="dc"></param>
/// <param name="renderer"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public override void Draw(object dc, IRenderer renderer, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var record = r ?? this.Record;
if (State.HasFlag(ShapeState.Visible))
{
renderer.Draw(dc, this, dx, dy, db, record);
}
if (renderer.State.SelectedShape != null)
{
if (this == renderer.State.SelectedShape)
{
_start.Draw(dc, renderer, dx, dy, db, record);
_end.Draw(dc, renderer, dx, dy, db, record);
}
else if (_start == renderer.State.SelectedShape)
{
_start.Draw(dc, renderer, dx, dy, db, record);
}
else if (_end == renderer.State.SelectedShape)
{
_end.Draw(dc, renderer, dx, dy, db, record);
}
}
if (renderer.State.SelectedShapes != null)
{
if (renderer.State.SelectedShapes.Contains(this))
{
_start.Draw(dc, renderer, dx, dy, db, record);
_end.Draw(dc, renderer, dx, dy, db, record);
}
}
}
/// <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, XEllipse ellipse, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var _gfx = gfx as Graphics;
Brush brush = ToSolidBrush(ellipse.Style.Fill);
Pen pen = ToPen(ellipse.Style, _scaleToPage);
var rect = CreateRect(
ellipse.TopLeft,
ellipse.BottomRight,
dx, dy);
if (ellipse.IsFilled)
{
_gfx.FillEllipse(
brush,
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
}
if (ellipse.IsStroked)
{
_gfx.DrawEllipse(
pen,
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
}
brush.Dispose();
pen.Dispose();
}
/// <summary>
///
/// </summary>
/// <param name="r"></param>
public override void Bind(Record r)
{
var record = r ?? this.Data.Record;
foreach (var shape in Shapes)
{
shape.Bind(record);
}
foreach (var connector in Connectors)
{
connector.Bind(record);
}
}
/// <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, XBezier bezier, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var _gfx = gfx as Graphics;
Brush brush = ToSolidBrush(bezier.Style.Fill);
Pen pen = ToPen(bezier.Style, _scaleToPage);
if (bezier.IsFilled)
{
var path = new GraphicsPath();
path.AddBezier(
_scaleToPage(bezier.Point1.X),
_scaleToPage(bezier.Point1.Y),
_scaleToPage(bezier.Point2.X),
_scaleToPage(bezier.Point2.Y),
_scaleToPage(bezier.Point3.X),
_scaleToPage(bezier.Point3.Y),
_scaleToPage(bezier.Point4.X),
_scaleToPage(bezier.Point4.Y));
_gfx.FillPath(brush, path);
}
if (bezier.IsStroked)
{
_gfx.DrawBezier(
pen,
_scaleToPage(bezier.Point1.X),
_scaleToPage(bezier.Point1.Y),
_scaleToPage(bezier.Point2.X),
_scaleToPage(bezier.Point2.Y),
_scaleToPage(bezier.Point3.X),
_scaleToPage(bezier.Point3.Y),
_scaleToPage(bezier.Point4.X),
_scaleToPage(bezier.Point4.Y));
}
brush.Dispose();
pen.Dispose();
}
/// <summary>
///
/// </summary>
/// <param name="dc"></param>
/// <param name="renderer"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public override void Draw(object dc, IRenderer renderer, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var record = r ?? this.Data.Record;
if (State.Flags.HasFlag(ShapeStateFlags.Visible))
{
foreach (var shape in Shapes)
{
shape.Draw(dc, renderer, dx, dy, db, record);
}
}
if (renderer.State.SelectedShape != null)
{
if (this == renderer.State.SelectedShape)
{
foreach (var connector in Connectors)
{
connector.Draw(dc, renderer, dx, dy, db, record);
}
}
else
{
foreach (var connector in Connectors)
{
if (connector == renderer.State.SelectedShape)
{
connector.Draw(dc, renderer, dx, dy, db, record);
}
}
}
}
if (renderer.State.SelectedShapes != null)
{
if (renderer.State.SelectedShapes.Contains(this))
{
foreach (var connector in Connectors)
{
connector.Draw(dc, renderer, dx, dy, db, record);
}
}
}
}
/// <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, XText text, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var _gfx = gfx as Graphics;
var tbind = text.BindToTextProperty(db, r);
if (string.IsNullOrEmpty(tbind))
return;
Brush brush = ToSolidBrush(text.Style.Stroke);
var fontStyle = System.Drawing.FontStyle.Regular;
if (text.Style.TextStyle.FontStyle.HasFlag(Test2d.FontStyle.Bold))
{
fontStyle |= System.Drawing.FontStyle.Bold;
}
if (text.Style.TextStyle.FontStyle.HasFlag(Test2d.FontStyle.Italic))
{
fontStyle |= System.Drawing.FontStyle.Italic;
}
if (text.Style.TextStyle.FontStyle.HasFlag(Test2d.FontStyle.Underline))
{
fontStyle |= System.Drawing.FontStyle.Underline;
}
if (text.Style.TextStyle.FontStyle.HasFlag(Test2d.FontStyle.Strikeout))
{
fontStyle |= System.Drawing.FontStyle.Strikeout;
}
Font font = new Font(
text.Style.TextStyle.FontName,
(float)(text.Style.TextStyle.FontSize * _textScaleFactor),
fontStyle);
var rect = CreateRect(
text.TopLeft,
text.BottomRight,
dx, dy);
var srect = new RectangleF(
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
var format = new StringFormat();
switch (text.Style.TextStyle.TextHAlignment)
{
case TextHAlignment.Left:
format.Alignment = StringAlignment.Near;
break;
case TextHAlignment.Center:
format.Alignment = StringAlignment.Center;
break;
case TextHAlignment.Right:
format.Alignment = StringAlignment.Far;
break;
}
switch (text.Style.TextStyle.TextVAlignment)
{
case TextVAlignment.Top:
format.LineAlignment = StringAlignment.Near;
break;
case TextVAlignment.Center:
format.LineAlignment = StringAlignment.Center;
break;
case TextVAlignment.Bottom:
format.LineAlignment = StringAlignment.Far;
break;
}
_gfx.DrawString(
tbind,
font,
ToSolidBrush(text.Style.Stroke),
srect,
format);
brush.Dispose();
font.Dispose();
}
/// <summary>
///
/// </summary>
/// <param name="r"></param>
public override void Bind(Record r)
{
// TODO: Implement Bind() method.
}
/// <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, XPath path, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
{
var _gfx = gfx as Graphics;
var gp = path.Geometry.ToGraphicsPath(dx, dy, _scaleToPage);
if (path.IsFilled && path.IsStroked)
{
var brush = ToSolidBrush(path.Style.Fill);
var pen = ToPen(path.Style, _scaleToPage);
_gfx.FillPath(
brush,
gp);
_gfx.DrawPath(
pen,
gp);
brush.Dispose();
pen.Dispose();
}
else if (path.IsFilled && !path.IsStroked)
{
var brush = ToSolidBrush(path.Style.Fill);
_gfx.FillPath(
brush,
gp);
brush.Dispose();
}
else if (!path.IsFilled && path.IsStroked)
{
var pen = ToPen(path.Style, _scaleToPage);
_gfx.DrawPath(
pen,
gp);
pen.Dispose();
}
}
/// <summary>
///
/// </summary>
/// <param name="r"></param>
public override void Bind(Record r)
{
base.Bind(r ?? this.Data.Record);
}
