1 files changed, 290 insertions, 0 deletions
diff --git a/Software/Visual_Studio/Tango.EmbroideryUI/EmbroideryFileEditor.xaml.cs b/Software/Visual_Studio/Tango.EmbroideryUI/EmbroideryFileEditor.xaml.cs
new file mode 100644
index 000000000..6b86c68cb
--- /dev/null
+++ b/Software/Visual_Studio/Tango.EmbroideryUI/EmbroideryFileEditor.xaml.cs
@@ -0,0 +1,290 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+using Tango.Editors;
+using Tango.PMR;
+using Tango.PMR.Embroidery;
+
+namespace Tango.EmbroideryUI
+{
+    /// <summary>
+    /// Interaction logic for EmbroideryFileEditor.xaml
+    /// </summary>
+    public partial class EmbroideryFileEditor : UserControl
+    {
+        [DllImport("Tango.Embroidery.dll", CallingConvention = CallingConvention.Cdecl, EntryPoint = "AnalyzeEmbroideryFile")]
+        public static extern int AnalyzeEmbroideryFile(IntPtr data, int size, ref IntPtr output);
+
+        private Thickness _currentMargins;
+
+        #region Properties
+
+        public ObservableCollection<EmbroideryPath> Paths
+        {
+            get { return (ObservableCollection<EmbroideryPath>)GetValue(PathsProperty); }
+            set { SetValue(PathsProperty, value); }
+        }
+        public static readonly DependencyProperty PathsProperty =
+            DependencyProperty.Register("Paths", typeof(ObservableCollection<EmbroideryPath>), typeof(EmbroideryFileEditor), new PropertyMetadata(null, (d, e) => (d as EmbroideryFileEditor).OnPathsChanged()));
+
+        public EmbroideryFile EmbroideryFile
+        {
+            get { return (EmbroideryFile)GetValue(EmbroideryFileProperty); }
+            set { SetValue(EmbroideryFileProperty, value); }
+        }
+        public static readonly DependencyProperty EmbroideryFileProperty =
+            DependencyProperty.Register("EmbroideryFile", typeof(EmbroideryFile), typeof(EmbroideryFileEditor), new PropertyMetadata(null));
+
+        public String FileName
+        {
+            get { return (String)GetValue(FileNameProperty); }
+            set { SetValue(FileNameProperty, value); }
+        }
+        public static readonly DependencyProperty FileNameProperty =
+            DependencyProperty.Register("FileName", typeof(String), typeof(EmbroideryFileEditor), new PropertyMetadata(null, (d, e) => (d as EmbroideryFileEditor).OnFileNameChanged()));
+
+        public double ScaleFactor
+        {
+            get { return (double)GetValue(ScaleFactorProperty); }
+            set { SetValue(ScaleFactorProperty, value); }
+        }
+        public static readonly DependencyProperty ScaleFactorProperty =
+            DependencyProperty.Register("ScaleFactor", typeof(double), typeof(EmbroideryFileEditor), new PropertyMetadata(1.0, (d, e) => (d as EmbroideryFileEditor).OnScaleFactorChanged()));
+
+        public EmbroideryPath SelectedPath
+        {
+            get { return (EmbroideryPath)GetValue(SelectedPathProperty); }
+            set { SetValue(SelectedPathProperty, value); }
+        }
+        public static readonly DependencyProperty SelectedPathProperty =
+            DependencyProperty.Register("SelectedPath", typeof(EmbroideryPath), typeof(EmbroideryFileEditor), new PropertyMetadata(null));
+
+        #endregion
+
+        #region Constructors
+
+        public EmbroideryFileEditor()
+        {
+            Paths = new ObservableCollection<EmbroideryPath>();
+            InitializeComponent();
+            MouseWheel += EmbroideryFileEditor_MouseWheel;
+        }
+
+        #endregion
+
+        #region Virtual Methods
+
+        protected virtual void OnFileNameChanged()
+        {
+            if (!File.Exists(FileName)) return;
+
+            AnalyzeInput input = new AnalyzeInput();
+            input.FilePath = FileName;
+
+
+            NativePMR<AnalyzeInput, AnalyzeOutput> nativePMR = new NativePMR<AnalyzeInput, AnalyzeOutput>(AnalyzeEmbroideryFile);
+            AnalyzeOutput output = nativePMR.Invoke(input);
+
+            EmbroideryFile = output.EmbroideryFile;
+            DrawFile();
+            ScaleToFit();
+        }
+
+        protected virtual void OnPathsChanged()
+        {
+            if (Paths != null)
+            {
+                Paths.CollectionChanged -= Paths_CollectionChanged;
+                Paths.CollectionChanged += Paths_CollectionChanged;
+
+                RegisterPathsEvents();
+            }
+        }
+
+        protected virtual void OnScaleFactorChanged()
+        {
+            if (EmbroideryFile != null)
+            {
+                DrawFile();
+            }
+        }
+
+        #endregion
+
+        #region Event Handlers
+
+        private void EmbroideryFileEditor_MouseWheel(object sender, MouseWheelEventArgs e)
+        {
+            double factor = e.Delta > 0 ? 0.5 : -0.5;
+            Paths.Clear();
+            ScaleFactor += factor;
+            DrawFile();
+        }
+
+        private void Paths_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
+        {
+            RegisterPathsEvents();
+        }
+
+        private void Path_MouseDown(object sender, MouseButtonEventArgs e)
+        {
+            EmbroideryPath path = sender as EmbroideryPath;
+
+            path.IsSelected = !path.IsSelected;
+            SelectedPath = path;
+            Paths.Where(x => x != path).ToList().ForEach(x => x.IsSelected = false);
+        }
+
+        private void OnThumbDragging(object sender, System.Windows.Controls.Primitives.DragDeltaEventArgs e)
+        {
+            list.Margin = new Thickness(_currentMargins.Left + e.HorizontalChange, _currentMargins.Top + e.VerticalChange, 0, 0);
+            this.Cursor = Cursors.SizeAll;
+        }
+
+        private void OnThumbDragStarted(object sender, System.Windows.Controls.Primitives.DragStartedEventArgs e)
+        {
+            _currentMargins = list.Margin;
+        }
+
+        private void OnDragCompleted(object sender, System.Windows.Controls.Primitives.DragCompletedEventArgs e)
+        {
+            this.Cursor = Cursors.Arrow;
+        }
+
+        #endregion
+
+        #region Private Methods
+
+        private void RegisterPathsEvents()
+        {
+            foreach (var path in Paths)
+            {
+                path.MouseDown -= Path_MouseDown;
+                path.MouseDown += Path_MouseDown;
+            }
+        }
+
+        public void DrawFile()
+        {
+            if (EmbroideryFile == null) return;
+
+            Point _currentPoint = new Point();
+            Point _lastPoint = new Point();
+            Stitch _lastStitch = new Stitch();
+            StitchFlag _mode = StitchFlag.Jump;
+
+            if (Paths == null)
+            {
+                Paths = new ObservableCollection<EmbroideryPath>();
+            }
+
+            Paths.Clear();
+
+            Color color = ConvertStitchColorToColor(EmbroideryFile.Colors[0]);
+            var path = CreatePathFigure(color, _currentPoint);
+
+            foreach (var stitch in EmbroideryFile.Stitches)
+            {
+                _currentPoint = new Point(stitch.XX * ScaleFactor, stitch.YY * -1 * ScaleFactor);
+
+                switch (stitch.Flag)
+                {
+                    case StitchFlag.Jump:
+                        path = CreatePathFigure(color, _currentPoint);
+                        _mode = StitchFlag.Jump;
+                        break;
+                    case StitchFlag.Stop:
+                        color = ConvertStitchColorToColor(EmbroideryFile.Colors[stitch.ColorIndex]);
+                        break;
+                    case StitchFlag.Normal:
+
+                        if (_mode == StitchFlag.Normal)
+                        {
+                            path.PathFigure.Segments.Add(new LineSegment(new Point(_currentPoint.X, _currentPoint.Y), true));
+                            path.Length += Math.Abs(GetDistance(_lastStitch.XX, _lastStitch.YY, stitch.XX, stitch.YY));
+                            path.StitchCount++;
+                        }
+                        _mode = StitchFlag.Normal;
+                        break;
+                }
+
+
+                _lastStitch = stitch;
+                _lastPoint = _currentPoint;
+            }
+        }
+
+        private Color ConvertStitchColorToColor(StitchColor stitchColor)
+        {
+            return Color.FromRgb((byte)stitchColor.Red, (byte)stitchColor.Green, (byte)stitchColor.Blue);
+        }
+
+        private EmbroideryPath CreatePathFigure(Color color, Point startPoint)
+        {
+            PathFigure figure = new PathFigure();
+            figure.StartPoint = startPoint;
+            figure.IsClosed = false;
+
+
+            EmbroideryPath path = new EmbroideryPath(new PathGeometry(new PathFigureCollection() { figure }));
+            path.PathFigure = figure;
+            path.StrokeThickness = 1;
+            path.Brush = new SolidColorBrush(color);
+            Paths.Add(path);
+            return path;
+        }
+
+        private static double GetDistance(double x1, double y1, double x2, double y2)
+        {
+            return Math.Sqrt(Math.Pow((x2 - x1), 2) + Math.Pow((y2 - y1), 2));
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        public void ScaleToFit()
+        {
+            double minX = Paths.Select(x => x.Path.GetFlattenedPathGeometry().Bounds.Left).Min();
+            double minY = Paths.Select(x => x.Path.GetFlattenedPathGeometry().Bounds.Top).Min();
+            double maxX = Paths.Select(x => x.Path.GetFlattenedPathGeometry().Bounds.Right).Max();
+            double maxY = Paths.Select(x => x.Path.GetFlattenedPathGeometry().Bounds.Bottom).Max();
+
+            Rect embRect = new Rect(minX, minY, maxX - minX, maxY - minY);
+            Rect editorRect = new Rect(0, 0, ActualWidth, ActualHeight);
+
+            double embRectArea = embRect.Width * embRect.Height;
+            double editorRectArea = editorRect.Width * editorRect.Height;
+
+            double factor = (editorRect.Width / embRect.Width) / 2d;
+
+            if (embRect.Height > embRect.Width)
+            {
+                factor = (editorRect.Height / embRect.Height) / 2d;
+            }
+
+            ScaleFactor = factor;
+
+            minY = Paths.Select(x => x.Path.GetFlattenedPathGeometry().Bounds.Top).Min();
+            minX = Paths.Select(x => x.Path.GetFlattenedPathGeometry().Bounds.Left).Min();
+
+            list.Margin = new Thickness(minX / 2, -minY / 2, 0, 0);
+        }
+
+        #endregion
+    }
+}