public class Employee : IComparable<Employee>
{
    //Ключевое поле
    public Guid IdEmployee { get; set; } = Guid.NewGuid();
    //Фамилия
    public string Surname { get; set; }
    //Имя
    public string FirstName { get; set; }
    //Отчество
    public string LastName { get; set; }
    //Должность
    public Guid IdAppointment { get; set; }
 
    public int CompareTo(Employee other)
    {
        return string.Compare(this.ToString(), other.ToString());
    }
 
    public override string ToString()
    {
        return $"{Surname} {FirstName} {LastName}";
    }
}

btnAdd.Click += (o, e) =>
{
   // создаём пустой объект требуемого типа
   var item = Activator.CreateInstance(userClass.GetType());
   // вызываем диалог для заполнения свойств объекта
   var frm = PropertyPanelBuilder.ShowPropertyFormDialog(userModel, item);
   // если не была нажата клавиша "Ввод", выходим
   if (frm.DialogResult != DialogResult.OK) return;
   ...
}

/// <summary>
/// Показ формы с полями для класса параметра
/// </summary>
/// <param name="userClass">Класс для формирования полей редактирования</param>
/// <returns>Объект формы диалога</returns>
public static Form ShowPropertyFormDialog(object userModel, object userClass, string fontName = "Microsoft Sans Serif", float fontSize = 8.25f)
{
    // заготовка для формы диалога
    var frm = new Form()
    {
        Text = GetClassCaption(userClass),
        AutoSize = true,                                // размер подстраивается под содержимое
        AutoSizeMode = AutoSizeMode.GrowAndShrink,      // автоматически увеличивает или уменьшает размер
        StartPosition = FormStartPosition.CenterParent, // показывает форму по центру родительского окна
        FormBorderStyle = FormBorderStyle.FixedDialog,  // формат рамки формы
        MaximizeBox = false,                            // не показывать кнопку "Развернуть"
        MinimizeBox = false,                            // не показывать кнопку "Свернуть"
        ShowInTaskbar = false                           // не показывать в панели задач
    };
    frm.Font = new Font(fontName, fontSize);
    // создаём заготовку панели свойств 
    var ppb = new PropertyPanelBuilder(frm);
    // размещаем панель на форме
    frm.Controls.Add(ppb.BuildPropertyPanel(userModel, userClass));
    // показываем форму диалога
    frm.ShowDialog();
    // возвращаем ссылку на объект формы
    return frm;
}

[Serializable]
[Description("Сотрудник")]
public class Employee : IComparable<Employee>
{
    public Guid IdEmployee { get; set; } = Guid.NewGuid();
 
    [Description("Фамилия"), DataNotEmpty]
    public string Surname { get; set; }
 
    [Description("Имя"), DataNotEmpty]
    public string FirstName { get; set; }
 
    [Description("Отчество"), DataNotEmpty]
    public string LastName { get; set; }
 
    [Description("Должность"), DataLookup("IdAppointment", "Appointments")]
    public Guid IdAppointment { get; set; }
 
    public int CompareTo(Employee other)
    {
        return string.Compare(this.ToString(), other.ToString());
    }
 
    public override string ToString()
    {
        return $"{Surname} {FirstName} {LastName}";
    }
}

if (kind == DrawingKind.Polygon)
    graphics.DrawPolygon(pen, points); // рисование контура
else
    graphics.DrawLines(pen, points);

public partial class FormMain : Form
{
    private readonly PictureEditor _editor;
    private const string Title = @"Простой векторный графический редактор (демо)";
 
    public FormMain()
    {
        InitializeComponent();
        // создаём хранилище созданных фигур, которое также и рисует их
        _editor = new PictureEditor(pbCanvas)
        {
            BackgoundContextMenu = cmsBkgPopup,
            FigureContextMenu = cmsFigPopup
        };
        _editor.FigureSelected += EditorFigureSelected;
        _editor.EditorFarConnerUpdated += EditorFarConnerUpdated;
        cbWidth.Items.Clear();
        for (var i = 1; i < 61; i++) cbWidth.Items.Add(i.ToString("0"));
    }
....

private void tsbSelectMode_Click(object sender, EventArgs e)
{
    foreach (ToolStripButton btn in tsFigures.Items) btn.Checked = false;
    ((ToolStripButton)sender).Checked = true;
    if (tsbPolyline.Checked)
        _editor.EditorMode = EditorMode.AddLine;
    else if (tsbPolygon.Checked)
        _editor.EditorMode = EditorMode.AddPolygon;
    else
        _editor.EditorMode = EditorMode.Selection;
}

[Serializable]
public class StackMemory
{
    readonly int _stackDepth; // глубина стека
 
    readonly List<byte[]> _list = new List<byte[]>();
        
    /// <summary>
    /// Конструктор
    /// </summary>
    /// <param name="depth"></param>
    public StackMemory(int depth)
    {
        _stackDepth = depth;
        if (depth < 1) _stackDepth = 1;
        _list.Clear();
    }
 
    /// <summary>
    /// Помещаем данные в стек
    /// </summary>
    /// <param name="stream"></param>
    public void Push(MemoryStream stream)
    {
        if (_list.Count > _stackDepth) _list.RemoveAt(0);
        _list.Add(stream.ToArray());
    }
 
    /// <summary>
    /// Очищаем стек
    /// </summary>
    public void Clear()
    {
        _list.Clear();
    }
 
    /// <summary>
    /// Количество сохранённых версий в стеке
    /// </summary>
    public int Count
    {
        get { return (_list.Count); }
    }
 
    /// <summary>
    /// Извлечение данных из стека
    /// </summary>
    /// <param name="stream"></param>
    public void Pop(MemoryStream stream)
    {
        if (_list.Count <= 0) return;
        var buff = _list[_list.Count - 1];
        stream.Write(buff, 0, buff.Length);
        _list.RemoveAt(_list.Count - 1);
    }
}

readonly StackMemory _undoStack = new StackMemory(100);
readonly StackMemory _redoStack = new StackMemory(100);

/// <summary>
/// Признак изменения данных.
/// ВНИМАНИЕ! Для правильной работы логики Undo|Redo
/// изменение этого свойства производить ДО изменения данных!
/// </summary>
public bool FileChanged
{
    get
    {
        return (_fileChanged);
    }
    set
    {
        _fileChanged = value;
        PrepareToUndo(_fileChanged);
        PrepareToRedo(false);
    }
}

/// <summary>
/// Подготовка к отмене (сохранения состояния)
/// </summary>
/// <param name="changed">True - cохранить состояние</param>
private void PrepareToUndo(bool changed)
{
    if (changed)
    {
        using (var stream = new MemoryStream())
        {
            SaveToStream(stream);
            _undoStack.Push(stream);
        }
    }
    else
        _undoStack.Clear();
}

/// <summary>
/// Сохранить все фигуры в поток
/// </summary>
/// <param name="stream">поток в памяти</param>
/// <param name="listToSave">список для сохранения</param>
private void SaveToStream(Stream stream, List<Figure> listToSave = null)
{
    var formatter = new BinaryFormatter();
    var list = (listToSave ?? _figures).ToList();
    formatter.Serialize(stream, list);
    stream.Position = 0;
}

/// <summary>
/// Отмена действий, изменений
/// </summary>
public void UndoChanges()
{
    if (!CanUndoChanges) return;
    PrepareToRedo(true);
    _selected.Clear();
    _figures.Clear();
    GC.Collect();
    using (var stream = new MemoryStream())
    {
        _undoStack.Pop(stream);
        var list = LoadFromStream(stream);
        foreach (var fig in list) _figures.Add(fig);
    }
    _container.Invalidate();
}

/// <summary>
/// Режим выбора и перетаскивания узловых точек (изменения узлов)
/// </summary>
public bool NodeChanging
{
    get { return _nodeChanging; }
    set
    {
        _nodeChanging = value;
        _container.Invalidate();
    }
}

private static void DrawFocusFigure(Figure figure, Graphics graphics, PointF offset,
                                    int markerIndex, bool nodeChanging)
{
    ....
    else
        if (nodeChanging && (markerIndex < 0))
    {
        // тянут мышкой за маркер, изменяющий положение узла
        using (var gp = new GraphicsPath())
        {
            if (figure.Kind == DrawingKind.Polygon)
                gp.AddPolygon(figure.GetPoints());
            else
                gp.AddLines(figure.GetPoints());
            var ps = gp.PathPoints;
            var i = Math.Abs(markerIndex) - 1;
            if ((i >= 0) && (i < ps.Length))
            {
                ps[i].X += offset.X;
                ps[i].Y += offset.Y;
                DrawCustomFigure(graphics, ps, figure.Kind);
            }
        }
    }
    ....
}

private void ContainerMouseUp(object sender, MouseEventArgs e)
{
       ....
                else if (NodeChanging && (MarkerIndex < 0) && _selected.Count == 1) // тянут за маркер узла
                {
                    var fig = _selected[0];
                    UpdateSize(fig, _mouseOffset, MarkerIndex);
                    _container.Invalidate();
                }
                break;
        }
        ....
}

public void UpdateSize(Figure fig, PointF offset, int marker)
{
    PointF[] pts;
     ....
    if (NodeChanging && (marker < 0))
    {
        // перемещение узлов
        pts = fig.GetPoints();
        var index = Math.Abs(marker) - 1;
        if ((index >= 0) && (index < pts.Length))
        {
            pts[index].X += offset.X;
            pts[index].Y += offset.Y;
            fig.SetPoints(pts);
        }
    }
}

/// <summary>
/// Метод добавления нового узла на выбранный сегмент линии
/// </summary>
public void AddNode()
{
    if (_selected.Count != 1) return;
    var figure = _selected[0];
    var ps = figure.GetPoints();
    var pts = new PointF[ps.Length + 1];
    ps.CopyTo(pts, 0);
    // замыкание контура фигуры
    pts[pts.Length - 1].X = pts[0].X;
    pts[pts.Length - 1].Y = pts[0].Y;
    for (var i = 1; i < pts.Length; i++)
    {
        // поиск сегмента линии, куда бы можно добавить новый узел
        if (!PointInRange(figure, MouseDownLocation, pts[i - 1], pts[i])) continue;
        var points = new List<PointF>(figure.GetPoints());
        points.Insert(i, MouseDownLocation);
        figure.SetPoints(points.ToArray());
        break;
    }
    _container.Invalidate();
}

/// <summary>
/// Метод удаления выбранного маркера
/// </summary>
/// <param name="markerIndex">индекс маркера для удаления</param>
public void RemoveNode(int markerIndex = 0)
{
    if (_selected.Count != 1) return;
    if (markerIndex == 0)
        markerIndex = MarkerIndex;
    var figure = _selected[0];
    var ps = figure.GetPoints();
    if ((ps.Length <= (figure.Kind == DrawingKind.Polygon ? 3 : 2)) ||
        (markerIndex >= ps.Length - 1)) return;
    var points = new List<PointF>(figure.GetPoints());
    points.RemoveAt(Math.Abs(markerIndex) - 1);
    figure.SetPoints(points.ToArray());
    _container.Invalidate();
}

/// <summary>
/// Метод строит восемь маркеров на углах и серединах сторон
/// </summary>
/// <param name="rect">размерный прямоугольник</param>
/// <returns>Возвращает перечисление из маркеров для изменения размера</returns>
private static IEnumerable<RectangleF> GetBoundMarkers(RectangleF rect)
{
    if (rect.Width <= 10) rect.Inflate(5, 0);
    if (rect.Height <= 10) rect.Inflate(0, 5);
    var pts = new PointF[8];
    pts[0].X = rect.Left; pts[0].Y = rect.Top;
    pts[1].X = rect.Left + rect.Width * 0.5f; pts[1].Y = rect.Top;
    pts[2].X = rect.Right; pts[2].Y = rect.Top;
    pts[3].X = rect.Right; pts[3].Y = rect.Top + rect.Height * 0.5f;
    pts[4].X = rect.Right; pts[4].Y = rect.Bottom;
    pts[5].X = rect.Left + rect.Width * 0.5f; pts[5].Y = rect.Bottom;
    pts[6].X = rect.Left; pts[6].Y = rect.Bottom;
    pts[7].X = rect.Left; pts[7].Y = rect.Top + rect.Height * 0.5F;
    rect.Inflate(-5, -5);
    var rects = new RectangleF[pts.Length];
    for (var i = 0; i < pts.Length; i++)
    {
        float k;
        if ((rect.Width <= 5) && ((i == 1) || (i == 5)))
            k = 1;
        else if ((rect.Height <= 5) && ((i == 3) || (i == 7)))
            k = 1;
        else
            k = 3;
        rects[i] = RectangleF.FromLTRB(pts[i].X - k, pts[i].Y - k,
                                        pts[i].X + k, pts[i].Y + k);
    }
    return rects;
}

/// <summary>
/// Поиск номера маркера в разных режимах редактора
/// </summary>
/// <param name="pt">точка "нажатия" мышки</param>
/// <param name="figure">проверяемая фигура</param>
/// <returns>индекс маркера</returns>
public int? MarkerSelected(PointF pt, Figure figure)
{
    if (NodeChanging)
    {
        // в режиме изменения узлов
        var rects = GetNodeMarkers(figure);
        for (var i = 0; i < rects.Length; i++)
        {
            if (rects[i].Contains(pt))
                return -(i + 1);
        }
    }
    else
    {
        // в режиме изменения размеров или перемещения
        var bounds = figure.GetBounds;
        var rects = GetBoundMarkers(bounds).ToArray();
        for (var i = 0; i < rects.Length; i++)
        {
            if (rects[i].Contains(pt))
                return i + 1;
        }
    }
    return null;
}

/// <summary>
/// Проверка нажатия на маркер в фигуре
/// положительные индексы - это маркеры размеров,
/// отрицательные - маркеры узлов,
/// ноль - тело фигуры
/// </summary>
/// <param name="location">точка выбора</param>
/// <param name="figure">указатель на фигуру</param>
/// <returns>индекс маркера</returns>
private int PointInMarker(PointF location, out Figure figure)
{
    figure = null;
    // проверка нажатия на маркерах
    for (var i = _selected.Count - 1; i >= 0; i--)
    {
        // смотрим на выбранные фигуры, начиная с хвоста списка
        var fig = _selected[i];
        var found = MarkerSelected(location, fig);
        if (found == null) continue;
        figure = fig;
        return (int)found;
    }
    return 0;
}

private static void DrawFocusFigure(Figure figure, Graphics graphics, PointF offset,
                                    int markerIndex, bool nodeChanging)
{
    ....
    else if (!nodeChanging && (markerIndex > 0))
    {
        // тянут за размерный маркер
        var ps = figure.GetPoints();
        var oldrect = CalcFocusRect(new PointF(), figure, markerIndex);
        var newrect = CalcFocusRect(offset, figure, markerIndex);
        for (var i = 0; i < ps.Length; i++)
        {
            ps[i].X = newrect.Left + (ps[i].X - oldrect.Left) / oldrect.Width * newrect.Width;
            ps[i].Y = newrect.Top + (ps[i].Y - oldrect.Top) / oldrect.Height * newrect.Height;
        }
        DrawCustomFigure(graphics, ps, figure.Kind);
    }
}

private void ContainerMouseUp(object sender, MouseEventArgs e)
{
    // если мышь была захвачена
    if (_container.Capture)
    {
        // освобождаем захват мышки
        _container.Capture = false;
        // если нажата левая кнопка
        if (e.Button == MouseButtons.Left)
        {
            switch (EditorMode)
            {
                // перетаскивание выбранных фигур "мышкой"
                case EditorMode.Dragging:
                     ....
                    else if (!NodeChanging && (MarkerIndex > 0)) // тянут за размерный маркер
                    {
                        // перебираем все выделенные фигуры и меняем размер
                        foreach (var fig in _selected)
                            UpdateSize(fig, _mouseOffset, MarkerIndex);
                    }
                     ....
                    break;
            }
        }
        ....
    }
}

/// <summary>
/// Изменение внутреннего массива точек фигуры при работе с маркерами
/// </summary>
/// <param name="fig">объект фигуры</param>
/// <param name="offset">смещение</param>
/// <param name="marker">индекс маркера</param>
public void UpdateSize(Figure fig, PointF offset, int marker)
{
    PointF[] pts;
    if (!NodeChanging && (marker > 0))
    {
        // перемещение границ
        pts = fig.GetPoints();
        var oldrect = CalcFocusRect(PointF.Empty, fig, marker);
        var newrect = CalcFocusRect(offset, fig, marker);
        for (var i = 0; i < pts.Length; i++)
        {
            pts[i].X = newrect.Left + (pts[i].X - oldrect.Left) / oldrect.Width * newrect.Width;
            pts[i].Y = newrect.Top + (pts[i].Y - oldrect.Top) / oldrect.Height * newrect.Height;
        }
        fig.SetPoints(pts);
    }
    else
        if (NodeChanging && (marker < 0))
    {
        // перемещение узлов
        pts = fig.GetPoints();
        var index = Math.Abs(marker) - 1;
        if ((index >= 0) && (index < pts.Length))
        {
            pts[index].X += offset.X;
            pts[index].Y += offset.Y;
            fig.SetPoints(pts);
        }
    }
}

public Picture(Control container)
{
    _container = container;
    // подключаемся к необходимым событиям на контейнере
    _container.MouseDown += ContainerMouseDown;
    _container.MouseMove += ContainerMouseMove;
    _container.MouseUp += ContainerMouseUp;
    _container.Paint += ContainerPaint;
    // подключаем объект выбора рамкой
    _ribbonSelector = new RectangleRibbonSelector(_container);
    _ribbonSelector.OnSelected += RibbonSelectorOnSelected;
    // а здесь пробуем найти ссылку на форму, на которой расположен PaintBox
    var parent = _container.Parent;
    // пока не найдём форму или пустой Parent
    while (!(parent is Form))
    {
        if (parent == null) break;
        parent = parent.Parent;
    }
    _form = parent as Form;
    // если найдена форма
    if (_form != null)
    {
        // то подключим к ней обработчик нажатия клавиш
        _form.KeyDown += FormKeyDown;
        _form.KeyUp += FormKeyUp;
        // включим признак предварительного просмотра нажатия клавиш
        _form.KeyPreview = true;
    }
    // при изменении выбора выключаем режим изменения узлов
    _selected.CollectionChanged += (sender, args) =>
        {
            NodeChanging = false;
        };
}

/// <summary>
/// Нажатие кнопки "мышки" на PaintBox
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ContainerMouseDown(object sender, MouseEventArgs e)
{
    // запоминаем точку первую точку для прямоугольника выбора
    _mouseDownLocation = e.Location;
    _mouseOffset = Point.Empty;
    // если установлен другой режим, кроме выбора прямоугольником
    if (EditorMode != EditorMode.Selection)
        _selected.Clear();   // очищаем список выбранных
 
    Figure fig;
    _markerIndex = PointInMarker(e.Location, out fig);
 
    // ищем фигуру в точке нажатия
    if (fig == null) fig = PointInFigure(e.Location);
 
    if (e.Button == MouseButtons.Left)
        _container.Capture = true;
 
    ...
}

/// <summary>
/// Перемещение мышки над PaintBox
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ContainerMouseMove(object sender, MouseEventArgs e)
{
    if (_mouseDownLocation == e.Location) return;
    // если удерживается левая кнопка и мышка захвачена
    if (e.Button == MouseButtons.Left && _container.Capture)
    {
        // пересчитываем смещение мышки
        _mouseOffset.X = e.X - _mouseDownLocation.X;
        _mouseOffset.Y = e.Y - _mouseDownLocation.Y;
        // просим перерисовать
        _container.Invalidate();
    }
    if (e.Button != MouseButtons.None) return;
 
    ...
}

private void ContainerPaint(object sender, PaintEventArgs e)
{
    ...
    // при перетаскивании
    if (EditorMode != EditorMode.Dragging) return;
    foreach (var fig in _selected)
        DrawFocusFigure(fig, e.Graphics, _mouseOffset, _markerIndex, NodeChanging);
}

....
using (var gp = new GraphicsPath())
{
    if (figure.Kind == DrawingKind.Polygon)
        // добавляем в полигон все точки фигуры
        gp.AddPolygon(figure.GetPoints());
    else
        gp.AddLines(figure.GetPoints());
    // получаем графический путь
    var ps = gp.PathPoints;
    // для всех точек пути
    for (var i = 0; i < ps.Length; i++)
    {
        // делаем смещение
        ps[i].X += offset.X;
        ps[i].Y += offset.Y;
    }
    DrawCustomFigure(graphics, ps, figure.Kind);
}
....

/// <summary>
/// Перемещение фигуры
/// </summary>
/// <param name="fig">объект фигуры</param>
/// <param name="offset">смещение</param>
public void UpdateLocation(Figure fig, PointF offset)
{
    // перемещение фигуры
    var pts = fig.GetPoints();
    var oldrect = CalcFocusRect(PointF.Empty, fig, 0);
    var newrect = CalcFocusRect(offset, fig, 0);
    for (var i = 0; i < pts.Length; i++)
    {
        pts[i].X = newrect.Left + (pts[i].X - oldrect.Left);
        pts[i].Y = newrect.Top + (pts[i].Y - oldrect.Top);
    }
    fig.SetPoints(pts);
}

/// <summary>
/// Метод проверяет принадлежность точки фигуре
/// </summary>
/// <param name="point">проверяемая точка</param>
/// <returns>True - точка принадлежит фигуре</returns>
public virtual Boolean PointInFigure(PointF point)
{
    switch (Kind)
    {
        case DrawingKind.Polygon:
            using (var gp = new GraphicsPath())
            {
                gp.AddPolygon(GetPoints());
                return (gp.IsVisible(point));
            }
        case DrawingKind.Polyline:
            using (var gp = new GraphicsPath())
            {
                var ps = GetPoints();
                for (var i = 1; i < ps.Length; i++)
                {
                    gp.StartFigure();
                    gp.AddLine(ps[i - 1], ps[i]);
                    gp.CloseFigure();
                }
                using (var pen = new Pen(Color.Black, Stroke.Width * 5f))
                    return gp.IsOutlineVisible(point, pen);
            }
    }
    return false;
}

// список созданных фигур
private readonly List<Figure> _figures = new List<Figure>();

// список выбранных фигур
private readonly ObservableCollection<Figure> _selected = new ObservableCollection<Figure>();

/// <summary>
/// Режим выбора и перетаскивания узловых точек (изменения узлов)
/// </summary>
public bool NodeChanging { get; set; }

/// <summary>
/// Режим работы редактора
/// </summary>
public EditorMode EditorMode
{
    get { return _editorMode; }
    set
    {
        _editorMode = value;
        // выбор рамкой запрещён во всех режимах, кроме EditorMode.Selection
        _ribbonSelector.Disabled = _editorMode != EditorMode.Selection;
    }
}

/// <summary>
/// Режимы редактора
/// </summary>
public enum EditorMode
{
    Selection,
    Dragging
}

/// <summary>
/// Нажатие кнопки "мышки" на PaintBox
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ContainerMouseDown(object sender, MouseEventArgs e)
{
    ...
   
    // если нажата правая кнопка мышки
    if (e.Button != MouseButtons.Right) return;
    // переключаем режим на выбор рамкой
    EditorMode = EditorMode.Selection;
    ShowContextMenu(e.Location);
 
    ... 
}

/// <summary>
/// Вызов контекстного меню
/// </summary>
/// <param name="location">точка вызова контекстного меню</param>
private void ShowContextMenu(Point location)
{
    _contextMenuStrip.Items.Clear();
    Figure fig;
    PointInMarker(location, out fig);
    // ищем фигуру в точке нажатия
    if (fig == null)
        fig = PointInFigure(location);
    // есть ли фигура под курсором мышки?
    if (fig == null) // это не фигура, показываем общее меню
    {
        // создаём пункт меню
        var miRectangle = new ToolStripMenuItem("Добавить фигуру");
        // подключаем обработчик
        miRectangle.Click += (o, args) =>
            {
                var rect = RectangleF.FromLTRB(location.X, location.Y,location.X + 50, location.Y + 50);
                var points = new List<PointF>
                    {
                        new PointF(rect.Left, rect.Top),
                        new PointF(rect.Left + rect.Width, rect.Top),
                        new PointF(rect.Left + rect.Width, rect.Top + rect.Height),
                        new PointF(rect.Left, rect.Top + rect.Height)
                    };
                fig = new Figure(DrawingKind.Polygon, points);
                _figures.Add(fig);
                _selected.Add(fig);
                _container.Invalidate();
            };
        // и добавляем его к меню
        _contextMenuStrip.Items.Add(miRectangle);
        // создаём пункт меню
        var miLine = new ToolStripMenuItem("Добавить линию");
        // подключаем обработчик
        miLine.Click += (o, args) =>
        {
            var rect = RectangleF.FromLTRB(location.X, location.Y, location.X + 50, location.Y + 50);
            var points = new List<PointF>
                    {
                        new PointF(rect.Left, rect.Top),
                        new PointF(rect.Left + rect.Width, rect.Top + rect.Height)
                    };
            fig = new Figure(DrawingKind.Polyline, points);
            _figures.Add(fig);
            _selected.Add(fig);
            _container.Invalidate();
        };
        // и добавляем его к меню
        _contextMenuStrip.Items.Add(miLine);
    }
 
    ...
 
    // показываем контекстное меню
    _contextMenuStrip.Show(_container, location);
}

/// <summary>
/// Обработчик события рисования на поверхности контейнера
/// </summary>
/// <param name="sender">визуальный компонент с поверхностью для рисования</param>
/// <param name="e">объект параметров события со свойством Graphics</param>
private void ContainerPaint(object sender, PaintEventArgs e)
{
    // рисуем все созданные фигуры
    foreach (var fig in _figures) fig.DrawFigure(e.Graphics);
    if (EditorMode != EditorMode.Dragging)
    {
        if (NodeChanging)
        {
            // маркеры узлов рисуем круглыми
            foreach (var fig in _selected)
            {
                using (var gp = new GraphicsPath())
                {
                    var rects = GetNodeMarkers(fig);
                    foreach (var t in rects)
                        gp.AddEllipse(t);
                    e.Graphics.FillPath(Brushes.White, gp);
                    using (var pen = new Pen(Color.Black))
                    {
                        pen.Width = 0;
                        e.Graphics.DrawPath(pen, gp);
                    }
                }
            }
        }
        else
        {
            // рисуем маркеры размеров у выбранных фигур
            foreach (var fig in _selected)
            {
                using (var gp = new GraphicsPath())
                {
                    var sizeMarkers = GetBoundMarkers(fig.GetBounds);
                    foreach (var t in sizeMarkers.Where(t => t.Width > 2))
                        gp.AddRectangle(t);
                    e.Graphics.FillPath(Brushes.White, gp);
                    using (var pen = new Pen(Color.Black))
                    {
                        pen.Width = 0;
                        e.Graphics.DrawPath(pen, gp);
                    }
                }
            }
        }
    }
    // при перетаскивании
    if (EditorMode != EditorMode.Dragging) return;
    foreach (var fig in _selected)
        DrawFocusFigure(fig, e.Graphics, _mouseOffset, _markerIndex, NodeChanging);
}

private readonly Pen _pen;
 
/// <summary>
/// Конструктор без параметров, со свойствами по умолчанию
/// </summary>
public Stroke()
{
    _pen = new Pen(Color.Black);
}

/// <summary>
/// Деструктор объекта
/// </summary>
~Stroke()
{
    Dispose();
}
 
/// <summary>
/// Реализация интерфейса IDisposable
/// </summary>
public void Dispose()
{
    if (_pen != null) _pen.Dispose();
}

/// <summary>
/// Цвет линии фигуры
/// </summary>
public Color Color
{
    get { return _pen.Color; }
    set { _pen.Color = value; }
}
        
/// <summary>
/// Ширина линии фигуры
/// </summary>
public Single Width
{
    get { return _pen.Width; }
    set { _pen.Width = value; }
}
        
/// <summary>
/// Стиль линии фигуры
/// </summary>
public DashStyle DashStyle
{
    get { return _pen.DashStyle; }
    set { _pen.DashStyle = value; }
}
        
/// <summary>
/// Яркость:
/// 0 - полностью прозрачный,
/// 255 - полноцветный
/// </summary>
public int Alpha
{
    get { return _pen.Color.A; }
    set { _pen.Color = Color.FromArgb(value, _pen.Color); }
}
        
/// <summary>
/// Стиль начала линии
/// </summary>
public LineCap StartCap
{
    get { return _pen.StartCap; }
    set { _pen.StartCap = value; }
}
        
/// <summary>
/// Стиль конца линии
/// </summary>
public LineCap EndCap
{
    get { return _pen.EndCap; }
    set { _pen.EndCap = value; }
}
        
/// <summary>
/// Стиль соединения двух отрезков линии
/// </summary>
public LineJoin LineJoin
{
    get { return _pen.LineJoin; }
    set { _pen.LineJoin = value; }
}

/// <summary>
/// Свойство возвращает "карандаш", настроенный по текущим свойствам stroke
/// </summary>
public Pen GetPen
{
    get { return _pen; }
}

private readonly SolidBrush _brush;
 
/// <summary>
/// Конструктор без параметров, с цветом по умолчанию
/// </summary>
public Fill()
{
    _brush = new SolidBrush(Color.White);
}

/// <summary>
/// Деструктор объекта
/// </summary>
~Fill()
{
    Dispose();
}
 
/// <summary>
/// Реализация интерфейса IDisposable
/// </summary>
public void Dispose()
{
    if (_brush != null) _brush.Dispose();
}

/// <summary>
/// Цвет заливки
/// </summary>
public Color Color
{
    get { return _brush.Color; }
    set { _brush.Color = value; }
}
 
/// <summary>
/// Яркость:
/// 0 - полностью прозрачный,
/// 255 - полноцветный
/// </summary>
public int Alpha
{
    get { return _brush.Color.A; }
    set { _brush.Color = Color.FromArgb(value, _brush.Color); }
}

/// <summary>
/// Свойство возвращает "кисть", настроенный по текущим свойствам fill
/// </summary>
/// <returns>Настроенная кисть для заполнения контура фигуры</returns>
public Brush GetBrush
{
    get { return _brush; }
}

/// <summary>
///  Конструктор без параметра с настройкой по умолчанию
/// </summary>
protected Figure()
{
    Stroke = new Stroke();
    Fill = new Fill();
}

/// <summary>
/// Метод рисования фигуры по точкам базового списка
/// </summary>
/// <param name="graphics">"холст" - объект для рисования</param>
public virtual void DrawFigure(Graphics graphics)
{
    var points = Points.ToArray();
    // заливаем фон кистью
    graphics.FillPolygon(Fill.GetBrush, points);
    // рисуем контур карандашом
    graphics.DrawPolygon(Stroke.GetPen, points);
}

/// <summary>
/// Конструктор без параметров, со свойствами по умолчанию
/// </summary>
public Stroke() : this(Color.Black, 1.0F) { }
        
/// <summary>
/// Конструктор с параметрами
/// </summary>
/// <param name="color">Цвет линии</param>
/// <param name="width">Ширина линии</param>
public Stroke(Color color, Single width)
{
    Color = color;
    Width = width;
    DashStyle = DashStyle.Solid;
    Alpha = 255;
}

/// <summary>
/// Цвет линии фигуры
/// </summary>
public Color Color { get; set; }
        
/// <summary>
/// Ширина линии фигуры
/// </summary>
public Single Width { get; set; }
        
/// <summary>
/// Стиль линии фигуры
/// </summary>
public DashStyle DashStyle { get; set; }
        
/// <summary>
/// Яркость:
/// 0 - полностью прозрачный,
/// 255 - полноцветный
/// </summary>
public int Alpha { get; set; }
        
/// <summary>
/// Стиль начала линии
/// </summary>
public LineCap StartCap { get; set; }
        
/// <summary>
/// Стиль конца линии
/// </summary>
public LineCap EndCap { get; set; }
        
/// <summary>
/// Стиль соединения двух отрезков линии
/// </summary>
public LineJoin LineJoin { get; set; }

/// <summary>
/// Метод присваивания свойств другого stroke
/// </summary>
/// <param name="stroke">Источник значений свойств stroke</param>
public void Assign(Stroke stroke)
{
    if (stroke == null) return;
    Color = stroke.Color;
    Width = stroke.Width;
    DashStyle = stroke.DashStyle;
    Alpha = stroke.Alpha;
    LineJoin = stroke.LineJoin;
    StartCap = stroke.StartCap;
    EndCap = stroke.EndCap;
}

/// <summary>
/// Реализация интерфейса ICloneable
/// </summary>
/// <returns>Возвращаем копию Stroke</returns>
public object Clone()
{
    var stroke = new Stroke();
    stroke.Assign(this);
    return stroke;
}

/// <summary>
/// Метод возвращает "карандаш", настроенный по текущим свойствам stroke
/// </summary>
public Pen Pen()
{
    var pen = new Pen(Color.FromArgb(Alpha, Color))
        {
            Width = Width,
            LineJoin = LineJoin,
            StartCap = StartCap,
            EndCap = EndCap
        };
    if (DashStyle == DashStyle.Custom)
    {
        pen.DashStyle = DashStyle.Solid;
        pen.Color = Color.Transparent;
    }
    else
        pen.DashStyle = DashStyle;
    return (pen);
}

// рисуем контур карандашом
using (var pen = Stroke.Pen())
    graphics.DrawPolygon(pen, points);

/// <summary>
/// Конструктор без параметров, с цветом по умолчанию
/// </summary>
public Fill() : this(Color.White) { }
 
/// <summary>
/// Конструктор с параметром
/// </summary>
/// <param name="color">Цвет заливки фона</param>
public Fill(Color color)
{
    Color = color;
    Alpha = 255;
    PatternColor = Color.Black;
    PatternIndex = 1; // FillMode.Solid;
    Mode = FillMode.Solid;
    HatchMode = HatchStyle.Percent50;
    LinearMode = LinearGradientMode.Horizontal;
}

/// <summary>
/// Цвет заливки
/// </summary>
public Color Color { get; set; }
 
/// <summary>
/// Яркость:
/// 0 - полностью прозрачный,
/// 255 - полноцветный
/// </summary>
public int Alpha { get; set; }
 
/// <summary>
/// Цвет линий при заливке выбранной битовой маской
/// </summary>
public Color PatternColor { get; set; }
 
/// <summary>
/// Стиль заполнения битовой маской
/// </summary>
public HatchStyle HatchMode { get; set; }
 
/// <summary>
/// Стиль заполнения градиентной кистью
/// </summary>
public LinearGradientMode LinearMode { get; set; }

/// <summary>
/// Режим заполнения поверхности фигуры
/// </summary>
public FillMode Mode { get; set; }

/// <summary>
/// Перечисление для типа заполнения
/// </summary>
public enum FillMode
{
    None = 0,           // без заливки
    Solid = 1,          // сплошная заливка
    Hatch = 2,          // битовая маска из набора
    LinearGradient = 3  // линейный градиент
};