Разработка системы моделирования электрических цепей

    /// <summary>
    /// Сериализуемая обертка над GraphicsPath
    /// </summary>
    [Serializable]
    public sealed class SerializableGraphicsPath : ISerializable, IDisposable
    {
        public GraphicsPath Path = new GraphicsPath();
 
        public SerializableGraphicsPath() { }
 
        private SerializableGraphicsPath(SerializationInfo info, StreamingContext context)
        {
            if (info.MemberCount > 0)
            {
                var points = (PointF[])info.GetValue("p", typeof(PointF[]));
                var types = (byte[])info.GetValue("t", typeof(byte[]));
                Path = new GraphicsPath(points, types);
            }
            else
                Path = new GraphicsPath();
        }
 
        public void Dispose()
        {
            Path?.Dispose();
        }
 
        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            if (Path.PointCount <= 0) return;
            info.AddValue("p", Path.PathPoints);
            info.AddValue("t", Path.PathTypes);
        }
 
        public static implicit operator GraphicsPath(SerializableGraphicsPath path)
        {
            return path.Path;
        }
 
        public static implicit operator SerializableGraphicsPath(GraphicsPath path)
        {
            return new SerializableGraphicsPath { Path = path };
        }
    }

    /// <summary>
    /// Элемент модели. 
    /// Может быть связан с другими элементами.
    /// </summary>
    [Serializable]
    public class Node : IDrawable, IDragable, ISelectable
    {
        const float GRID_STEP = 20;
 
        [NonSerialized]
        private bool IsSelected = false;
        private SerializableGraphicsPath path;
 
        public GraphicsPath Path
        {
            get { return path; }
            set { path = value; }
        }
 
        public Point Location;
        public virtual Color BorderColor => Color.White;
        public virtual Color FillColor => Color.FromArgb(50, Color.White);
        public object Tag { get; set; }
        public Model Model { get;set;}
        public virtual bool AcceptPin => true;
 
        public List<Pin> Pins { get; } = new List<Pin>();
        public List<Link> Links { get; set; } = new List<Link>();
 
        public Node(Model model)
        {
            this.Model = model;
            Path = Helper.GetRoundedRectangle(new Rectangle(-50, -30, 100, 60), 20);
 
            Pins.Add(new Pin(this) { RelativeLocation = new Point(50, 0)} );
            Pins.Add(new Pin(this) { RelativeLocation = new Point(-50, 0)} );
        }
 
        public virtual void Paint(Graphics gr)
        {
            //отрисовка связей
            foreach (var link in Links)
                link.Paint(gr);
 
            //отрисовка
            var state = gr.Save();
            gr.TranslateTransform(Location.X, Location.Y);
 
            //если выделены - рисуем гало
            if (IsSelected)
                Helper.DrawHalo(Path, gr, Color.Red, Color.Red.Pen(), 4);
 
            //отрисовка себя
            gr.FillPath(FillColor.Brush(), Path);
            gr.DrawPath(BorderColor.Pen(2), Path);
 
            //отрисовка Tag
            var rect = Path.GetBounds();
            rect.Inflate(5, 5);
            if(Tag != null)
                gr.DrawString(Tag.ToString(), Helper.Font, Brushes.White, rect, new StringFormat {Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center});
            gr.Restore(state);
 
            //отрисовка пинов
            foreach (var pin in Pins)
                pin.Paint(gr);
        }
 
        /// <summary>
        /// Точка попадает в фигуру?
        /// </summary>
        public bool Hit(Point p)
        {
            if (Pins.Any(pin => pin.Hit(p)))
                return true;
 
            return Path.GetBounds().Contains(p.Sub(Location));
        }
 
        /// <summary>
        /// Тащим
        /// </summary>
        public void Drag(Point offset)
        {
            Location = Location.Add(offset);
        }
 
        /// <summary>
        /// Начало перетаскивания
        /// </summary>
        public IDragable StartDrag(Point p)
        {
            //если кликнут пин - тащим пин
            var clickedPin = Pins.FirstOrDefault(pin => pin.Hit(p));
            if (clickedPin != null)
                return clickedPin;
 
            //тащим себя
            return this;
        }
 
        /// <summary>
        /// Конец перетаскивания
        /// </summary>
        public void EndDrag()
        {
            //align by grid
            Location = new Point((int)(GRID_STEP * Math.Round(Location.X/GRID_STEP)), (int)(GRID_STEP*Math.Round(Location.Y/GRID_STEP)));
        }
 
        /// <summary>
        /// Поиск ближайшего пина
        /// </summary>
        public Pin FindNearestPin(Point point)
        {
            return Pins.OrderBy(pin => pin.Location.Sub(point).LengthSqr()).FirstOrDefault();
        }
 
        ISelectable ISelectable.Hit(Point p)
        {
            //если кликнули линк, то выделяем линк
            var clickedLink = Links.Select(link => link.Hit(p)).FirstOrDefault(s => s != null);
            if (clickedLink != null)
                return clickedLink;
 
            if(Path.GetBounds().Contains(p.Sub(Location)))
                return this;
 
            return null;
        }
 
        public void Remove()
        {
            //remove me from model
            Model.Remove(this);
 
            //remove me from all links
            foreach (var node in Model.OfType<Node>())
                node.Links.RemoveAll(link => link.Pin1.Parent == this || link.Pin2.Parent == this);
        }
 
        public void Select()
        {
            IsSelected = true;
        }
 
        public void Unselect()
        {
            IsSelected = false;
        }
    }

    /// <summary>
    /// Связь между двумя пинами.
    /// </summary>
    [Serializable]
    public class Link : IDrawable, ISelectable
    {
        [NonSerialized]
        private bool IsSelected;
 
        public Pin Pin1 { get; set; }
        public Pin Pin2 { get; set; }
 
        private GraphicsPath Path
        {
            get
            {
                var path = new GraphicsPath();
                var p0 = Pin1.Location;
                var p1 = Pin1.RelativeLocation.X < 0 ? Pin1.Location.Add(new Point(-50, 0)) : Pin1.Location.Add(new Point(50, 0));
                var p2 = Pin2.RelativeLocation.X < 0 ? Pin2.Location.Add(new Point(-50, 0)) : Pin2.Location.Add(new Point(50, 0));
                var p3 = Pin2.Location;
                path.AddBezier(p0, p1, p2, p3);
                return path;
            }
        }
 
        public void Paint(Graphics gr)
        {
            var path = Path;
            if (IsSelected)
                Helper.DrawHalo(path, gr, Color.Red, Color.Red.Pen(2), 4);
 
            gr.DrawPath(Color.Lime.Pen(2), Path);
        }
 
        public ISelectable Hit(Point p)
        {
            if(Path.IsOutlineVisible(p, Color.Lime.Pen(8)))
                return this;
 
            return null;
        }
 
        public void Remove()
        {
            Pin1.Parent.Links.Remove(this);
            Pin2.Parent.Links.Remove(this);
        }
 
        public void Select()
        {
            IsSelected = true;
        }
 
        public void Unselect()
        {
            IsSelected = false;
        }
    }