Интерактивность в электрической схеме

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
 
namespace WindowsFormsApplication312
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
 
            var figures = new Figures();
            
            //создаем перем резистор
            var tr = new VariableResistor();
            tr.Move(100, 200);
            figures.Add(tr);
 
            var pn = new FigurePanel {Parent = this, Dock = DockStyle.Fill};
            pn.Figures = figures;
        }
    }
 
    //контрол для отрисовки фигур
    public class FigurePanel : UserControl
    {
        public Figures Figures { get; set; }
 
        private Figure selectedFigure;
        private Marker selectedMarker;
        private Point startMouseDrag;
 
        public FigurePanel()
        {
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint, true);
 
            BackColor = Color.White;
        }
 
        protected override void OnPaint(PaintEventArgs e)
        {
            if(Figures == null) return;
 
            e.Graphics.SmoothingMode = SmoothingMode.HighQuality;
 
            //рисуем фигуры
            foreach (var f in Figures)
                e.Graphics.DrawPath(Pens.Black, f.Path);
 
            //рисуем маркеры для выделенной фигуры
            if (selectedFigure != null)
            {
                foreach (var m in selectedFigure)
                    m.Draw(e.Graphics);
            }
        }
 
        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);
 
            if (Figures == null) return;
 
            if (e.Button == MouseButtons.Left)
            {
                startMouseDrag = e.Location;
 
                //есликликнули на маркер - выделяем маркер
                if (selectedFigure != null)
                {
                    foreach (var m in selectedFigure)
                    if (m.HitTest(e.Location))
                    {
                        selectedMarker = m;
                        return;
                    }
                }
 
                selectedFigure = null;
                selectedMarker = null;
 
                //ищем фигуру под мышкой
                using(var pen = new Pen(Color.Black, 3))
                foreach (var f in Figures)
                if (f.Path.IsOutlineVisible(e.Location, pen))
                {
                    selectedFigure = f;//выделяем фигуру
                    break;
                }
 
                Invalidate();
            }
        }
 
        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);
 
            if (e.Button == MouseButtons.Left)
            {
                var dx = e.Location.X - startMouseDrag.X;
                var dy = e.Location.Y - startMouseDrag.Y;
                startMouseDrag = e.Location;
 
                if(selectedFigure != null)
                {
                    if(selectedMarker != null)
                    {
                        //двигаем маркер
                        selectedMarker.Move(dx, dy);
                        selectedFigure.Build();
                    }else
                    {
                        //двигаем фигуру целиком
                        selectedFigure.Move(dx, dy);
                    }
 
                    Invalidate();
                }
            }
        }
    }
 
    //список фигур
    public class Figures : List<Figure>
    {
    }
 
    //базовая фигура
    public abstract class Figure : List<Marker>
    {
        public GraphicsPath Path { get; private set; }
        public abstract void Build();
 
        public Figure()
        {
            Path = new GraphicsPath();
        }
 
        public void Move(float dx, float dy)
        {
            foreach (var m in this)
                m.Move(dx, dy);
 
            Build();
        }
    }
 
    //маркер
    public class Marker
    {
        public const int Size = 7;
 
        public float X { get; set; }
        public float Y { get; set; }
 
        public Marker(float x, float y)
        {
            X = x;
            Y = y;
        }
 
        public void Draw(Graphics gr)
        {
            gr.DrawRectangle(Pens.Red, X- Size /2, Y - Size / 2, Size, Size);
        }
 
        public bool HitTest(Point p)
        {
            return Math.Abs(p.X - X) <= Size/2 && Math.Abs(p.Y - Y) <= Size/2;
        }
 
        public static implicit operator PointF(Marker m)
        {
            return new PointF(m.X, m.Y);
        }
 
        public void Move(float dx, float dy)
        {
            X += dx;
            Y += dy;
        }
    }
 
 
    /// <summary>
    /// Переменный резистор (реостат)
    /// </summary>
    public class VariableResistor : Figure
    {
        private const int Width = 50;
        private const int Height = 20;
 
        public VariableResistor()
        {
            Add(new Marker(0, 0));
            Add(new Marker(0, -Height * 2));
            Build();
        }
 
        public override void Build()
        {
            Path.Reset();
            var p0 = new PointF(this[0].X - Width / 2, this[0].Y);
            var p1 = new PointF(this[0].X + Width / 2, this[0].Y);
            //
            var p2 = this[1];
            if (p2.X < p0.X) p2.X = p0.X;
            if (p2.X > p1.X) p2.X = p1.X;
            this[1] = p2;
            //
 
            var d0 = p2.Y < p0.Y ? -5 : 5;
            var p3 = p2.Y > p0.Y ? new PointF(p2.X, p0.Y + Height / 2 + d0) : new PointF(p2.X, p0.Y - Height / 2 + d0);
            //resistior
            Path.AddRectangle(new RectangleF(p0.X, this[0].Y - Height / 2, Width, Height));
 
            //pins (temp, in release you need to draw connections with other components)
            Path.StartFigure();
            Path.AddLine(p0.X - 10, p0.Y, p0.X, p0.Y);
 
            Path.StartFigure();
            Path.AddLine(p1.X + 10, p1.Y, p1.X, p1.Y);
 
            //variator
            Path.StartFigure();
            var d1 = Math.Abs(d0);
            Path.AddLine(p2.X, p2.Y, p3.X, p3.Y);
            Path.AddLine(p3.X, p3.Y, p3.X + d1, p3.Y);
            Path.AddLine(p3.X + d1, p3.Y, p3.X, p3.Y - d0);
            Path.AddLine(p3.X, p3.Y - d0, p3.X - d1, p3.Y);
            Path.AddLine(p3.X - d1, p3.Y, p3.X, p3.Y);
        }
    }
}