Положение большого пальца динамической сетки данных WPF изменилось, когда определение строки и столбца добавляется в выбранную динамическую сетку

Требование: Наше требование — нарисовать пустую сетку (таблицу со строками и столбцами) поверх таблиц, представленных на изображении, и для одного изображения может быть несколько сеток. Все сетки должны быть настраиваемыми, и мы можем добавить разделитель строк и разделитель столбцов по щелчку кнопки мыши в сетке. Определения сеток, миниатюр и строк и столбцов создаются на основе кода.

Проблема: Если создано определение столбца или строки, положение ползунка сетки изменяется и он перемещается в первый столбец первой строки, а не остается статическим во внешней сетке. Изменяется положение верхнего, левого, правого и нижнего большого пальца. Можете ли вы помочь нам в этом вопросе?

КСАМЛ:

<Grid Name = "MainGrid" Background = "Gray" MouseDown = "MainGrid_MouseDown" MouseMove = "MainGrid_MouseMove" MouseUp = "MainGrid_MouseUp">
<Image x:Name = "imgDisplay" Source = "{Binding ImagePath, RelativeSource = {RelativeSource AncestorType=UserControl}}" Stretch = "None"/>
<StackPanel Orientation = "Horizontal"  HorizontalAlignment = "Right" VerticalAlignment = "Top" Margin = "10" Cursor = "Hand">
    <StackPanel.Background>
        <LinearGradientBrush EndPoint = "0.5,1" StartPoint = "0.5,0">
            <GradientStop Color = "Black"/>
            <GradientStop Color = "#FF086B69" Offset = "1"/>
        </LinearGradientBrush>
    </StackPanel.Background>
    <Button Name = "btnAddGrid" Content = "Grid" Width = "30" Margin = "5" Click = "AddAdjustableBox_Click"/>
    <Button Name = "btnRowSeperator" Content = "Row" Width = "30" Margin = "5" Click = "btnRowSeperator_Click"/>
    <Button Name = "btnColumnSeperator" Content = "Col" Width = "30" Margin = "5" Click = "btnColumnSeperator_Click"/>

Код C Sharp:

    public partial class TableDesignerUserControl : UserControl
    {
        private Point startPoint;
        private Rectangle selectionRectangle;
        private Border resizeBorder;
        private bool isResizing = false;
        private bool isDragging = false;
        private string resizeDirection;
        private bool _columnSeperator;
        private bool _rowSeperator;
        private bool gridGenerator;
        private Grid selectedGrid;
        private Dictionary<Grid, GridData> gridDataMap = new Dictionary<Grid, GridData>();
        private List<Border> selectedCells = new List<Border>();
        private List<Border> gridBorders = new List<Border>();
        private Border activeBorder = null;
        private bool isSelecting = false;
        private bool isDeselecting = false;
        private Border initialCell = null;

        public TableDesignerUserControl()
        {
            InitializeComponent();
        }

        
        private void MainGrid_MouseDown(object sender, MouseButtonEventArgs e)
        {
            if (gridGenerator)
            {
                startPoint = e.GetPosition(MainGrid);

                double imageWidth = imgDisplay.ActualWidth;
                double imageHeight = imgDisplay.ActualHeight;
                Point imagePosition = imgDisplay.TranslatePoint(new Point(0, 0), MainGrid);

                if (startPoint.X < imagePosition.X || startPoint.X > imagePosition.X + imageWidth ||
                    startPoint.Y < imagePosition.Y || startPoint.Y > imagePosition.Y + imageHeight)
                {
                    MessageBox.Show("Cannot draw outside the boundaries of the image.", "Alert", MessageBoxButton.OK, MessageBoxImage.Warning);
                    return;
                }

                selectionRectangle = new Rectangle
                {
                    Stroke = Brushes.Black,
                    StrokeDashArray = new DoubleCollection { 2 },
                    StrokeThickness = 1,
                    Width = 0,
                    Height = 0,
                    HorizontalAlignment = HorizontalAlignment.Left,
                    VerticalAlignment = VerticalAlignment.Top,
                    Margin = new Thickness(startPoint.X, startPoint.Y, 0, 0)
                };

                MainGrid.Children.Add(selectionRectangle);
            }
            else
            {
                if (e.OriginalSource is Border border && gridBorders.Contains(border))
                {
                    activeBorder = border;
                    SelectGrid(activeBorder.Child as Grid);
                    return;
                }
                else if (e.OriginalSource is Grid grid && grid != MainGrid)
                {
                    SelectGrid(grid);
                    return;
                }
            }
        }

        private void MainGrid_MouseMove(object sender, MouseEventArgs e)
        {
            if (selectionRectangle == null || isResizing || isDragging)
                return;

            var currentPoint = e.GetPosition(MainGrid);

            double imageWidth = imgDisplay.ActualWidth;
            double imageHeight = imgDisplay.ActualHeight;
            Point imagePosition = imgDisplay.TranslatePoint(new Point(0, 0), MainGrid);

            currentPoint.X = Math.Max(imagePosition.X, Math.Min(currentPoint.X, imagePosition.X + imageWidth));
            currentPoint.Y = Math.Max(imagePosition.Y, Math.Min(currentPoint.Y, imagePosition.Y + imageHeight));

            var minX = Math.Min(startPoint.X, currentPoint.X);
            var minY = Math.Min(startPoint.Y, currentPoint.Y);

            var width = Math.Abs(currentPoint.X - startPoint.X);
            var height = Math.Abs(currentPoint.Y - startPoint.Y);

            selectionRectangle.Margin = new Thickness(minX, minY, 0, 0);
            selectionRectangle.Width = width;
            selectionRectangle.Height = height;
        }

        private void MainGrid_MouseUp(object sender, MouseButtonEventArgs e)
        {
            if (selectionRectangle != null && !isResizing && !isDragging)
            {
                var currentPoint = e.GetPosition(MainGrid);

                double imageWidth = imgDisplay.ActualWidth;
                double imageHeight = imgDisplay.ActualHeight;
                Point imagePosition = imgDisplay.TranslatePoint(new Point(0, 0), MainGrid);

                currentPoint.X = Math.Max(imagePosition.X, Math.Min(currentPoint.X, imagePosition.X + imageWidth));
                currentPoint.Y = Math.Max(imagePosition.Y, Math.Min(currentPoint.Y, imagePosition.Y + imageHeight));

                var minX = Math.Min(startPoint.X, currentPoint.X);
                var minY = Math.Min(startPoint.Y, currentPoint.Y);

                var width = Math.Abs(currentPoint.X - startPoint.X);
                var height = Math.Abs(currentPoint.Y - startPoint.Y);

                MainGrid.Children.Remove(selectionRectangle);

                var border = new Border
                {
                    Width = width,
                    Height = height,
                    BorderBrush = Brushes.Black,
                    BorderThickness = new Thickness(1),
                    Margin = new Thickness(minX, minY, 0, 0),
                    HorizontalAlignment = HorizontalAlignment.Left,
                    VerticalAlignment = VerticalAlignment.Top
                };

                var grid = new Grid
                {
                    Background = Brushes.LightBlue,
                    Opacity = 0.3,
                    HorizontalAlignment = HorizontalAlignment.Stretch,
                    VerticalAlignment = VerticalAlignment.Stretch
                };

                AddResizeThumbs(grid);

                grid.MouseLeftButtonDown += Grid_MouseLeftButtonDown;
                border.Child = grid;
                MainGrid.Children.Add(border);
                grid.Margin = new Thickness(0);
                SelectGrid(grid);
                selectionRectangle = null;

                gridBorders.Add(border);
                activeBorder = border;
                gridDataMap[grid] = new GridData(); // Initialize GridData for the new grid
            }
        }

        private void SelectGrid(Grid grid)
        {
            if (grid == null)
                return;

            selectedGrid = grid;

            selectedGrid.Background = Brushes.LightBlue;
            selectedGrid.Opacity = 0.5;

            foreach (var border in gridBorders)
            {
                if (border.Child != selectedGrid)
                {
                    (border.Child as Grid).Background = Brushes.Gray;
                    (border.Child as Grid).Opacity = 0.3;
                }
            }
        }

        private void AddResizeThumbs(Grid container)
        {
            AddResizeThumb(container, Cursors.SizeWE, HorizontalAlignment.Right, VerticalAlignment.Stretch, "Right", 0, 0);
            AddResizeThumb(container, Cursors.SizeNS, HorizontalAlignment.Stretch, VerticalAlignment.Bottom, "Bottom", 0, 0);
            AddResizeThumb(container, Cursors.SizeWE, HorizontalAlignment.Left, VerticalAlignment.Stretch, "Left", 0, 0);
            AddResizeThumb(container, Cursors.SizeNS, HorizontalAlignment.Stretch, VerticalAlignment.Top, "Top", 0, 0);
            AddDraggingThumb(container, 0, 0);
        }

        private void AddResizeThumb(Grid container, Cursor cursor, HorizontalAlignment horizontalAlignment, VerticalAlignment verticalAlignment, string direction, double marginLeft, double marginTop)
        {
            var thumb = new Thumb
            {
                Width = 10,
                Height = 10,
                Opacity = 1,
                Background = Brushes.White,
                HorizontalAlignment = horizontalAlignment,
                VerticalAlignment = verticalAlignment,
                Cursor = cursor,
                Tag = direction,
                Margin = new Thickness(marginLeft, marginTop, 0, 0)
            };

            thumb.DragStarted += (s, e) =>
            {
                resizeBorder = (Border)container.Parent;
                activeBorder = resizeBorder;
                isResizing = true;
                resizeDirection = (string)thumb.Tag;
                MainGrid.Children.Remove(activeBorder);
                MainGrid.Children.Add(activeBorder);
            };

            thumb.DragDelta += Thumb_DragDelta;
            thumb.DragCompleted += (s, e) =>
            {
                isResizing = false;
                resizeDirection = null;
            };

            container.Children.Add(thumb);
        }

        private void AddDraggingThumb(Grid container, double marginLeft, double marginTop)
        {
            var thumb = new Thumb
            {
                Width = 10,
                Height = 10,
                Opacity = 1,
                Background = Brushes.Red,
                HorizontalAlignment = HorizontalAlignment.Left,
                VerticalAlignment = VerticalAlignment.Top,
                Cursor = Cursors.SizeAll,
                Margin = new Thickness(marginLeft, marginTop, 0, 0)
            };

            thumb.DragStarted += (s, e) =>
            {
                resizeBorder = (Border)container.Parent;
                activeBorder = resizeBorder;
                isDragging = true;
                MainGrid.Children.Remove(activeBorder);
                MainGrid.Children.Add(activeBorder);
            };

            thumb.DragDelta += Thumb_DragMove;
            thumb.DragCompleted += (s, e) =>
            {
                isDragging = false;
            };

            container.Children.Add(thumb);
        }

        private void Thumb_DragDelta(object sender, DragDeltaEventArgs e)
        {
            if (resizeBorder == null || !isResizing)
                return;

            double newWidth, newHeight, newLeft, newTop;

            double imageWidth = imgDisplay.ActualWidth;
            double imageHeight = imgDisplay.ActualHeight;
            Point imagePosition = imgDisplay.TranslatePoint(new Point(0, 0), MainGrid);

            switch (resizeDirection)
            {
                case "Right":
                    newWidth = resizeBorder.Width + e.HorizontalChange;
                    if (newWidth > 0 && resizeBorder.Margin.Left + newWidth <= imagePosition.X + imageWidth)
                        resizeBorder.Width = newWidth;
                    break;

                case "Bottom":
                    newHeight = resizeBorder.Height + e.VerticalChange;
                    if (newHeight > 0 && resizeBorder.Margin.Top + newHeight <= imagePosition.Y + imageHeight)
                        resizeBorder.Height = newHeight;
                    break;

                case "Left":
                    newWidth = resizeBorder.Width - e.HorizontalChange;
                    newLeft = resizeBorder.Margin.Left + e.HorizontalChange;
                    if (newWidth > 0 && newLeft >= imagePosition.X)
                    {
                        resizeBorder.Width = newWidth;
                        resizeBorder.Margin = new Thickness(newLeft, resizeBorder.Margin.Top, 0, 0);
                    }
                    break;

                case "Top":
                    newHeight = resizeBorder.Height - e.VerticalChange;
                    newTop = resizeBorder.Margin.Top + e.VerticalChange;
                    if (newHeight > 0 && newTop >= imagePosition.Y)
                    {
                        resizeBorder.Height = newHeight;
                        resizeBorder.Margin = new Thickness(resizeBorder.Margin.Left, newTop, 0, 0);
                    }
                    break;
            }

            AdjustGridCells();
        }

        private void Thumb_DragMove(object sender, DragDeltaEventArgs e)
        {
            if (resizeBorder == null || !isDragging)
                return;

            double newLeft = resizeBorder.Margin.Left + e.HorizontalChange;
            double newTop = resizeBorder.Margin.Top + e.VerticalChange;

            double imageWidth = imgDisplay.ActualWidth;
            double imageHeight = imgDisplay.ActualHeight;
            Point imagePosition = imgDisplay.TranslatePoint(new Point(0, 0), MainGrid);

            if (newLeft >= imagePosition.X && newTop >= imagePosition.Y &&
                newLeft + resizeBorder.Width <= imagePosition.X + imageWidth &&
                newTop + resizeBorder.Height <= imagePosition.Y + imageHeight)
            {
                resizeBorder.Margin = new Thickness(newLeft, newTop, 0, 0);
            }
        }

        private void Grid_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            Point clickPosition = e.GetPosition(selectedGrid);

            if (_rowSeperator && !isDragging)
            {
                if (!gridDataMap[selectedGrid].RowSeparators.Contains(clickPosition.Y))
                {
                    gridDataMap[selectedGrid].RowSeparators.Add(clickPosition.Y);
                    gridDataMap[selectedGrid].RowSeparators.Sort();
                }
                UpdateGrid();
            }
            else if (_columnSeperator && !isDragging)
            {
                if (!gridDataMap[selectedGrid].ColumnSeparators.Contains(clickPosition.X))
                {
                    gridDataMap[selectedGrid].ColumnSeparators.Add(clickPosition.X);
                    gridDataMap[selectedGrid].ColumnSeparators.Sort();
                }
                UpdateGrid();
            }
        }

        private void UpdateGrid()
        {
            if (selectedGrid == null)
                return;

            selectedGrid.RowDefinitions.Clear();
            selectedGrid.ColumnDefinitions.Clear();

            double previousY = 0;
            foreach (var separator in gridDataMap[selectedGrid].RowSeparators)
            {
                selectedGrid.RowDefinitions.Add(new RowDefinition { Height = new GridLength(separator - previousY, GridUnitType.Pixel) });
                previousY = separator;
            }
            selectedGrid.RowDefinitions.Add(new RowDefinition { Height = new GridLength(selectedGrid.ActualHeight - previousY, GridUnitType.Pixel) });

            double previousX = 0;
            foreach (var separator in gridDataMap[selectedGrid].ColumnSeparators)
            {
                selectedGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(separator - previousX, GridUnitType.Pixel) });
                previousX = separator;
            }
            selectedGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(selectedGrid.ActualWidth - previousX, GridUnitType.Pixel) });

            for (int row = 0; row < selectedGrid.RowDefinitions.Count; row++)
            {
                for (int column = 0; column < selectedGrid.ColumnDefinitions.Count; column++)
                {
                    AddGridCell(selectedGrid, row, column);
                }
            }
        }

        private void AdjustGridCells()
        {
            if (selectedGrid == null)
                return;

            foreach (var cell in selectedGrid.Children.OfType<Border>())
            {
                var row = Grid.GetRow(cell);
                var column = Grid.GetColumn(cell);

                cell.Width = selectedGrid.ColumnDefinitions[column].Width.Value;
                cell.Height = selectedGrid.RowDefinitions[row].Height.Value;
            }
        }

        private void AddGridCell(Grid grid, int row, int column)
        {
            var cellBorder = new Border
            {
                BorderBrush = Brushes.Blue,
                BorderThickness = new Thickness(0.5),
                Background = Brushes.Transparent
            };

            Grid.SetRow(cellBorder, row);
            Grid.SetColumn(cellBorder, column);
            cellBorder.MouseLeftButtonDown += CellBorder_MouseLeftButtonDown;
            cellBorder.MouseMove += CellBorder_MouseMove;
            cellBorder.MouseLeftButtonUp += CellBorder_MouseLeftButtonUp;

            AddCellResizeThumbs(cellBorder); // Add this line to add thumbs to each cell

            grid.Children.Add(cellBorder);
        }

Выход:

Перед добавлением разделителя: большой палец работает как положено.

После добавления разделителей: большой палец перемещается в другое положение.

После добавления UpdateThumbArrangement — (изменение размера сетки не работает, большой палец перемещается к границам ячеек, а не к границе сетки)

Вывод сейчас: