public void CreateFrame(ISheet sheet, XBlock block, double size, double thickness, ArgbColor stroke)
{
double padding = 6.0;
double width = 1260.0;
double height = 891.0;
double startX = padding;
double startY = padding;
double rowsStart = 60;
double rowsEnd = 780.0;
double tableStartX = startX;
double tableStartY = rowsEnd + 25.0;
bool frameShowBorder = true;
bool frameShowRows = true;
bool frameShowTable = true;
double row0 = 0.0;
double row1 = 20.0;
double row2 = 40.0;
double row3 = 60.0;
double row4 = 80.0;
bool tableShowRevisions = true;
bool tableShowLogos = true;
bool tableShowInfo = true;
if (frameShowRows)
{
// frame headers
CreateText(sheet, block.Texts, "I N P U T S", padding, padding, 330.0 - padding, 30.0 - padding, (int)HAlignment.Center, (int)VAlignment.Center, 16.0, stroke);
CreateText(sheet, block.Texts, "F U N C T I O N", 330.0, padding, 600.0, 30.0 - padding, (int)HAlignment.Center, (int)VAlignment.Center, 16.0, stroke);
CreateText(sheet, block.Texts, "O U T P U T S", 930.0, padding, 330.0 - padding, 30.0 - padding, (int)HAlignment.Center, (int)VAlignment.Center, 16.0, stroke);
// frame left rows
int leftRowNumber = 1;
for (double y = rowsStart; y < rowsEnd; y += size)
{
CreateLine(sheet, block.Lines, thickness, startX, y, 330.0, y, stroke);
CreateText(sheet, block.Texts, leftRowNumber.ToString("00"), startX, y, 30.0 - padding, size, (int)HAlignment.Center, (int)VAlignment.Center, 14.0, stroke);
leftRowNumber++;
}
// frame right rows
int rightRowNumber = 1;
for (double y = rowsStart; y < rowsEnd; y += size)
{
CreateLine(sheet, block.Lines, thickness, 930.0, y, width - padding, y, stroke);
CreateText(sheet, block.Texts, rightRowNumber.ToString("00"), width - 30.0, y, 30.0 - padding, size, (int)HAlignment.Center, (int)VAlignment.Center, 14.0, stroke);
rightRowNumber++;
}
// frame columns
double[] columnWidth = { 30.0, 210.0, 90.0, 600.0, 210.0, 90.0 };
double[] columnX = { 30.0, 30.0, startY, startY, 30.0, 30.0 };
double[] columnY = { rowsEnd, rowsEnd, rowsEnd, rowsEnd, rowsEnd, rowsEnd };
double start = 0.0;
for (int i = 0; i < columnWidth.Length; i++)
{
start += columnWidth[i];
CreateLine(sheet, block.Lines, thickness, start, columnX[i], start, columnY[i], stroke);
}
// frame header
CreateLine(sheet, block.Lines, thickness, startX, 30.0, width - padding, 30.0, stroke);
// frame footer
CreateLine(sheet, block.Lines, thickness, startX, rowsEnd, width - padding, rowsEnd, stroke);
}
if (frameShowTable)
{
// table header
CreateLine(sheet, block.Lines, thickness, tableStartX + 0, tableStartY + row0, tableStartX + 1248, tableStartY + row0, stroke);
// table revisions
if (tableShowRevisions)
{
CreateLine(sheet, block.Lines, thickness, tableStartX + 24, tableStartY + row0, tableStartX + 24, tableStartY + row4, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 75, tableStartY + row0, tableStartX + 75, tableStartY + row4, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 0, tableStartY + row1, tableStartX + 175, tableStartY + row1, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 0, tableStartY + row2, tableStartX + 175, tableStartY + row2, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 0, tableStartY + row3, tableStartX + 175, tableStartY + row3, stroke);
}
// table logos
if (tableShowLogos)
{
CreateLine(sheet, block.Lines, thickness, tableStartX + 175, tableStartY + row0, tableStartX + 175, tableStartY + row4, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 290, tableStartY + row0, tableStartX + 290, tableStartY + row4, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 405, tableStartY + row0, tableStartX + 405, tableStartY + row4, stroke);
}
// table info
if (tableShowInfo)
{
CreateLine(sheet, block.Lines, thickness, tableStartX + 405, tableStartY + row1, tableStartX + 1248, tableStartY + row1, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 405, tableStartY + row2, tableStartX + 695, tableStartY + row2, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 965, tableStartY + row2, tableStartX + 1248, tableStartY + row2, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 405, tableStartY + row3, tableStartX + 695, tableStartY + row3, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 965, tableStartY + row3, tableStartX + 1248, tableStartY + row3, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 465, tableStartY + row0, tableStartX + 465, tableStartY + row4, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 595, tableStartY + row0, tableStartX + 595, tableStartY + row4, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 640, tableStartY + row0, tableStartX + 640, tableStartY + row4, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 695, tableStartY + row0, tableStartX + 695, tableStartY + row4, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 965, tableStartY + row0, tableStartX + 965, tableStartY + row4, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 1005, tableStartY + row0, tableStartX + 1005, tableStartY + row4, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 1045, tableStartY + row0, tableStartX + 1045, tableStartY + row4, stroke);
CreateLine(sheet, block.Lines, thickness, tableStartX + 1100, tableStartY + row0, tableStartX + 1100, tableStartY + row4, stroke);
}
}
if (frameShowBorder)
{
// frame border
CreateLine(sheet, block.Lines, thickness, startX, startY, width - padding, startY, stroke);
CreateLine(sheet, block.Lines, thickness, startX, height - padding, width - padding, height - padding, stroke);
CreateLine(sheet, block.Lines, thickness, startX, startY, startX, height - padding, stroke);
CreateLine(sheet, block.Lines, thickness, width - padding, startY, width - padding, height - padding, stroke);
}
}
public bool HitTest(IEnumerable <XBlock> blocks, ImmutableRect rect, object relativeTo, XBlock selected, bool findOnlyOne, bool findInsideBlock)
{
foreach (var block in blocks)
{
if (HitTest(block, rect, relativeTo, findInsideBlock ? selected : null, true, false))
{
if (selected != null)
{
selected.Blocks.Add(block);
}
if (findOnlyOne)
{
return(true);
}
}
}
return(false);
}
public IList <XEllipse> Add(ISheet sheet, IEnumerable <ItemEllipse> ellipseItems, XBlock parent, XBlock selected, bool select, double thickness)
{
var ellipses = new List <XEllipse>();
foreach (var ellipseItem in ellipseItems)
{
var ellipse = _blockSerializer.Deserialize(sheet, parent, ellipseItem, thickness);
ellipses.Add(ellipse);
if (select)
{
Select(ellipse);
selected.Ellipses.Add(ellipse);
}
}
return(ellipses);
}
public ItemBlock SerializerAndSetId(XBlock parent, int id, double x, double y, double width, double height, int dataId, string name)
{
SetId(parent, id + 1);
return(Serialize(parent, id, x, y, width, height, dataId, name, parent.Backgroud));
}
public bool HitTest(IEnumerable <XImage> images, ImmutableRect rect, object relativeTo, XBlock selected, bool findOnlyOne)
{
foreach (var image in images)
{
if (_blockHelper.HitTest(image, rect, relativeTo))
{
if (selected != null)
{
selected.Images.Add(image);
}
if (findOnlyOne)
{
return(true);
}
}
}
return(false);
}
private IBlock ReadBlock()
{
var block = new XBlock()
{
Id = _reader.ReadInt32()
};
var children = block.Children;
while (_reader.BaseStream.Position != _reader.BaseStream.Length)
{
var type = ReadNativeType();
switch (type)
{
case NativeType.Pin:
children.Add(ReadPin());
break;
case NativeType.Line:
children.Add(ReadLine());
break;
case NativeType.Bezier:
children.Add(ReadBezier());
break;
case NativeType.QuadraticBezier:
children.Add(ReadQuadraticBezier());
break;
case NativeType.Arc:
children.Add(ReadArc());
break;
case NativeType.Rectangle:
children.Add(ReadRectangle());
break;
case NativeType.Ellipse:
children.Add(ReadEllipse());
break;
case NativeType.Text:
children.Add(ReadText());
break;
case NativeType.Block:
children.Add(ReadBlock());
break;
case NativeType.End:
_natives.Add(block.Id, block);
return block;
default:
throw new InvalidDataException();
}
}
throw new InvalidDataException();
}
private void OnXMouseEnterEvent(object sender, MouseEventArgs e)
{
XBlock.SetCurrentValue(ForegroundProperty, Brushes.White);
}
public IList <XLine> Add(ISheet sheet, IEnumerable <ItemLine> lineItems, XBlock parent, XBlock selected, bool select, double thickness)
{
var lines = new List <XLine>();
foreach (var lineItem in lineItems)
{
var line = _blockSerializer.Deserialize(sheet, parent, lineItem, thickness);
lines.Add(line);
if (select)
{
Select(line);
selected.Lines.Add(line);
}
}
return(lines);
}
public IList <XRectangle> Add(ISheet sheet, IEnumerable <ItemRectangle> rectangleItems, XBlock parent, XBlock selected, bool select, double thickness)
{
var rectangles = new List <XRectangle>();
foreach (var rectangleItem in rectangleItems)
{
var rectangle = _blockSerializer.Deserialize(sheet, parent, rectangleItem, thickness);
rectangles.Add(rectangle);
if (select)
{
Select(rectangle);
selected.Rectangles.Add(rectangle);
}
}
return(rectangles);
}
public IList <XBlock> Add(ISheet sheet, IEnumerable <ItemBlock> blockItems, XBlock parent, XBlock selected, bool select, double thickness)
{
var blocks = new List <XBlock>();
foreach (var blockItem in blockItems)
{
var block = _blockSerializer.Deserialize(sheet, parent, blockItem, thickness);
blocks.Add(block);
if (select)
{
Select(block);
selected.Blocks.Add(block);
}
}
return(blocks);
}
public IList <XPoint> Add(ISheet sheet, IEnumerable <ItemPoint> pointItems, XBlock parent, XBlock selected, bool select, double thickness)
{
var points = new List <XPoint>();
foreach (var pointItem in pointItems)
{
var point = _blockSerializer.Deserialize(sheet, parent, pointItem, thickness);
points.Add(point);
if (select)
{
Select(point);
selected.Points.Add(point);
}
}
return(points);
}
public IList <XImage> Add(ISheet sheet, IEnumerable <ItemImage> imageItems, XBlock parent, XBlock selected, bool select, double thickness)
{
var images = new List <XImage>();
foreach (var imageItem in imageItems)
{
var image = _blockSerializer.Deserialize(sheet, parent, imageItem);
images.Add(image);
if (select)
{
Select(image);
selected.Images.Add(image);
}
}
return(images);
}
public IList <XText> Add(ISheet sheet, IEnumerable <ItemText> textItems, XBlock parent, XBlock selected, bool select, double thickness)
{
var texts = new List <XText>();
foreach (var textItem in textItems)
{
var text = _blockSerializer.Deserialize(sheet, parent, textItem);
texts.Add(text);
if (select)
{
Select(text);
selected.Texts.Add(text);
}
}
return(texts);
}
public bool HitTest(ISheet sheet, XBlock block, ImmutablePoint p, double size, XBlock selected, bool findOnlyOne, bool findInsideBlock)
{
return(HitTest(sheet, block, new ImmutableRect(p.X - size, p.Y - size, 2 * size, 2 * size), selected, findOnlyOne, findInsideBlock));
}
private static void FindPinTypes(
IDictionary <XPin, ICollection <Tuple <XPin, bool> > > dependencies,
Dictionary <XPin, PinType> pinTypes,
List <XPin> pins)
{
var pinsWithoutType = new List <XPin>();
// pins with onnections but do not have Input or Output type set
foreach (var pin in pins)
{
XBlock owner = pin.Owner;
int noneCount = owner.Pins.Count(p => pinTypes[p] == PinType.None && dependencies[p].Count > 0);
int inputCount = owner.Pins.Count(p => pinTypes[p] == PinType.Input);
int outputCount = owner.Pins.Count(p => pinTypes[p] == PinType.Output);
var pinDependencies = dependencies[pin];
int noneDepCount = pinDependencies.Count(
p => pinTypes.ContainsKey(p.Item1) && pinTypes[p.Item1] == PinType.None);
int inputDepCount = pinDependencies.Count(
p => pinTypes.ContainsKey(p.Item1) && pinTypes[p.Item1] == PinType.Input);
int outputDepCount = pinDependencies.Count(
p => pinTypes.ContainsKey(p.Item1) && pinTypes[p.Item1] == PinType.Output);
if (inputDepCount == 0 && outputDepCount > 0 && noneDepCount == 0)
{
// set as Input
pinTypes[pin] = PinType.Input;
}
else if (inputDepCount > 0 && outputDepCount == 0 && noneDepCount == 0)
{
// set as Output
pinTypes[pin] = PinType.Output;
foreach (var p in pin.Owner.Pins.Where(p => p != pin && dependencies[p].Count > 0))
{
if (pinTypes.ContainsKey(p))
{
if (pinTypes[p] == PinType.None)
{
// set as Input
pinTypes[p] = PinType.Input;
}
}
else
{
// set as Input
pinTypes.Add(p, PinType.Input);
}
}
}
else
{
if (pinTypes[pin] == PinType.None)
{
if (noneCount == 1 && inputCount == 1 && outputCount == 0)
{
// set as Output
pinTypes[pin] = PinType.Output;
}
else
{
pinsWithoutType.Add(pin);
}
}
}
}
if (pinsWithoutType.Count > 0 && pins.Count == pinsWithoutType.Count)
{
throw new Exception("Can not find pin types.");
}
if (pinsWithoutType.Count > 0)
{
FindPinTypes(dependencies, pinTypes, pinsWithoutType);
}
}
public bool HitTest(IEnumerable <XRectangle> rectangles, ImmutableRect rect, object relativeTo, XBlock selected, bool findOnlyOne)
{
foreach (var rectangle in rectangles)
{
if (_blockHelper.HitTest(rectangle, rect, relativeTo))
{
if (selected != null)
{
selected.Rectangles.Add(rectangle);
}
if (findOnlyOne)
{
return(true);
}
}
}
return(false);
}
public void Initialize(MainViewModel model, Main main)
{
// status
this.status.DataContext = model.Log;
// zoom
this.page.EnableAutoFit = main.Options.EnableAutoFit;
this.zoom.InvalidateChild = (zoom) =>
{
model.Renderer.Zoom = zoom;
model.InvalidateTemplate();
model.InvalidateLayers();
};
this.zoom.AutoFitChild = (width, height) =>
{
if (this.zoom != null &&
model != null &&
model.Page != null &&
model.Page.Template != null)
{
this.zoom.AutoFit(
width,
height,
model.Page.Template.Width,
model.Page.Template.Height);
}
};
// drag & drop
this.pageView.AllowDrop = true;
this.pageView.DragEnter += (s, e) =>
{
if (main.IsSimulationMode())
{
return;
}
if (!e.Data.GetDataPresent("Block") || s == e.Source)
{
e.Effects = DragDropEffects.None;
}
};
this.pageView.Drop += (s, e) =>
{
if (main.IsSimulationMode())
{
return;
}
// block
if (e.Data.GetDataPresent("Block"))
{
try
{
XBlock block = e.Data.GetData("Block") as XBlock;
if (block != null)
{
Point point = e.GetPosition(this.pageView);
main.BlockInsert(block, point.X, point.Y);
e.Handled = true;
}
}
catch (Exception ex)
{
if (model.Log != null)
{
model.Log.LogError("{0}{1}{2}",
ex.Message,
Environment.NewLine,
ex.StackTrace);
}
}
}
// files
else if (e.Data.GetDataPresent(DataFormats.FileDrop))
{
try
{
string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
if (files != null && files.Length == 1)
{
string path = files[0];
if (!string.IsNullOrEmpty(path))
{
main.FileOpen(path);
e.Handled = true;
}
}
}
catch (Exception ex)
{
if (model.Log != null)
{
model.Log.LogError("{0}{1}{2}",
ex.Message,
Environment.NewLine,
ex.StackTrace);
}
}
}
};
// context menu
this.pageView.ContextMenuOpening += (s, e) =>
{
if (model.EditorLayer.CurrentMode != LayerViewModel.Mode.None)
{
e.Handled = true;
}
else if (model.EditorLayer.SkipContextMenu == true)
{
model.EditorLayer.SkipContextMenu = false;
e.Handled = true;
}
else
{
if (model.Renderer.Selected == null &&
!main.IsSimulationMode())
{
Point2 point = new Point2(
model.EditorLayer.RightX,
model.EditorLayer.RightY);
IShape shape = model.HitTest(point);
if (shape != null && shape is XBlock)
{
model.Selected = shape;
model.HaveSelected = true;
}
else
{
model.Selected = null;
model.HaveSelected = false;
}
}
else
{
model.Selected = null;
model.HaveSelected = false;
}
main.IsContextMenuOpen = true;
}
};
this.pageView.ContextMenuClosing += (s, e) =>
{
if (model.Selected != null)
{
model.InvalidateLayers();
}
main.IsContextMenuOpen = false;
};
// blocks
this.blocks.PreviewMouseLeftButtonDown += (s, e) =>
{
if (main.IsSimulationMode())
{
return;
}
_dragStartPoint = e.GetPosition(null);
};
this.blocks.PreviewMouseMove += (s, e) =>
{
if (main.IsSimulationMode())
{
return;
}
Point point = e.GetPosition(null);
Vector diff = _dragStartPoint - point;
if (e.LeftButton == MouseButtonState.Pressed &&
(Math.Abs(diff.X) > SystemParameters.MinimumHorizontalDragDistance ||
Math.Abs(diff.Y) > SystemParameters.MinimumVerticalDragDistance))
{
var listBox = s as ListBox;
var listBoxItem = ((DependencyObject)e.OriginalSource).FindVisualParent <ListBoxItem>();
if (listBoxItem != null)
{
var block = (XBlock)listBox
.ItemContainerGenerator
.ItemFromContainer(listBoxItem);
DataObject dragData = new DataObject("Block", block);
DragDrop.DoDragDrop(
listBoxItem,
dragData,
DragDropEffects.Move);
}
}
};
// show
this.DataContext = model;
}
public bool HitTest(IEnumerable <XEllipse> ellipses, ImmutableRect rect, object relativeTo, XBlock selected, bool findOnlyOne)
{
foreach (var ellipse in ellipses)
{
if (_blockHelper.HitTest(ellipse, rect, relativeTo))
{
if (selected != null)
{
selected.Ellipses.Add(ellipse);
}
if (findOnlyOne)
{
return(true);
}
}
}
return(false);
}
public string Generate(XBlock block, string namespaceName, string className, string blockName)
{
var sb = new StringBuilder();
sb.AppendLine("using Logic.Core;");
sb.AppendLine("using System;");
sb.AppendLine("using System.Collections.Generic;");
sb.AppendLine("using System.Linq;");
sb.AppendLine("using System.Text;");
sb.AppendLine("");
sb.AppendLine("namespace " + namespaceName);
sb.AppendLine("{");
sb.AppendLine(" public class " + className + " : XBlock");
sb.AppendLine(" {");
sb.AppendLine(" public " + className + "()");
sb.AppendLine(" {");
sb.AppendLine(" base.Database = new List<KeyValuePair<string, IProperty>>();");
sb.AppendLine(" base.Shapes = new List<IShape>();");
sb.AppendLine(" base.Pins = new List<XPin>();");
sb.AppendLine("");
sb.AppendLine(" base.Name = \"" + blockName + "\";");
sb.AppendLine("");
string indent = " ";
foreach (var shape in block.Shapes)
{
if (shape is XLine)
{
var line = shape as XLine;
var value = string.Format(
"{0}base.Shapes.Add(new XLine() {{ X1 = {1}, Y1 = {2}, X2 = {3}, Y2 = {4} }});",
indent,
line.X1,
line.Y1,
line.X2,
line.Y2);
sb.AppendLine(value);
}
else if (shape is XEllipse)
{
var ellipse = shape as XEllipse;
var value = string.Format(
"{0}base.Shapes.Add(new XEllipse() {{ X = {1}, Y = {2}, RadiusX = {3}, RadiusY = {4}, IsFilled = {5} }});",
indent,
ellipse.X,
ellipse.Y,
ellipse.RadiusX,
ellipse.RadiusY,
ellipse.IsFilled.ToString().ToLower());
sb.AppendLine(value);
}
else if (shape is XRectangle)
{
var rectangle = shape as XRectangle;
var value = string.Format(
"{0}base.Shapes.Add(new XRectangle() {{ X = {1}, Y = {2}, Width = {3}, Height = {4}, IsFilled = {5} }});",
indent,
rectangle.X,
rectangle.Y,
rectangle.Width,
rectangle.Height,
rectangle.IsFilled.ToString().ToLower());
sb.AppendLine(value);
}
else if (shape is XText)
{
var text = shape as XText;
sb.AppendLine(indent + "base.Shapes.Add(");
sb.AppendLine(indent + " new XText()");
sb.AppendLine(indent + " {");
sb.AppendLine(indent + " X = " + text.X + ",");
sb.AppendLine(indent + " Y = " + text.Y + ",");
sb.AppendLine(indent + " Width = " + text.Width + ",");
sb.AppendLine(indent + " Height = " + text.Height + ",");
sb.AppendLine(indent + " HAlignment = HAlignment." + text.HAlignment + ",");
sb.AppendLine(indent + " VAlignment = VAlignment." + text.VAlignment + ",");
sb.AppendLine(indent + " FontName = \"" + text.FontName + "\",");
sb.AppendLine(indent + " FontSize = " + text.FontSize + ",");
sb.AppendLine(indent + " Text = \"" + text.Text + "\"");
sb.AppendLine(indent + " });");
}
else if (shape is XImage)
{
var image = shape as XImage;
var value = string.Format(
"{0}base.Shapes.Add(new XImage() {{ X = {1}, Y = {2}, Width = {3}, Height = {4}, Path = {5} }});",
indent,
image.X,
image.Y,
image.Width,
image.Height,
image.Path);
sb.AppendLine(value);
}
else if (shape is XWire)
{
// Not supported.
}
else if (shape is XPin)
{
// Not supported.
}
else if (shape is XBlock)
{
// Not supported.
}
}
foreach (var pin in block.Pins)
{
var value = string.Format(
"{0}base.Pins.Add(new XPin() {{ Name = \"{1}\", X = {2}, Y = {3}, PinType = PinType.{4}, Owner = null }});",
indent,
pin.Name,
pin.X,
pin.Y,
pin.PinType);
sb.AppendLine(value);
}
sb.AppendLine(" }");
sb.AppendLine(" }");
sb.AppendLine("}");
return(sb.ToString());
}
public bool HitTest(IEnumerable <XText> texts, ImmutableRect rect, object relativeTo, XBlock selected, bool findOnlyOne)
{
foreach (var text in texts)
{
if (_blockHelper.HitTest(text, rect, relativeTo))
{
if (selected != null)
{
selected.Texts.Add(text);
}
if (findOnlyOne)
{
return(true);
}
}
}
return(false);
}
private void OnXMouseEnterLeave(object sender, MouseEventArgs e)
{
XBlock.SetCurrentValue(ForegroundProperty, Brushes.IndianRed);
}
public ItemBlock Serialize(XBlock parent)
{
return(Serialize(parent, parent.Id, parent.X, parent.Y, parent.Width, parent.Height, parent.DataId, parent.Name, parent.Backgroud));
}
