Selection Rectangle not moving along with datagrid content during scroll.

Question

I am attempting to replicate the selection behavior of Windows File Explorer within a WPF DataGrid. Specifically, I aim to implement a selection rectangle that mimics the functionality of File Explorer's selection mechanism. Currently, I have created an adorner rectangle to facilitate the selection of items. However, I encounter an issue when attempting to select rows while scrolling. As the DataGrid's content scrolls within its own ScrollViewer, the rows that are not intersecting with the selection rectangle are being deselected as the Selection rectangle is static and not moving along with the datagrid content during scroll. To provide a clearer understanding of the issue, I have included images below for reference. file

This is my xaml code

```xml Code Behind private void DataGrid_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e) { haskell isleftbuttonpressed = true; isSelecting = true; selectionStartPoint = e.GetPosition(FileDataGrid); adorner = new SelectionAdorner(FileDataGrid, selectionStartPoint); var adornerLayer = AdornerLayer.GetAdornerLayer(FileDataGrid); adornerLayer.Add(adorner); adorner.SetStartPoint(selectionStartPoint); } private void DataGrid_PreviewMouseMove(object sender, MouseEventArgs e) { typescript if (e.LeftButton == MouseButtonState.Pressed) { isleftbuttonpressed = true; } if (isSelecting && adorner != null) { adorner.SetEndPoint(e.GetPosition(FileDataGrid)); var selectionRect = adorner.GetSelectionRect(); SelectItemsInRectangle(selectionRect, FileDataGrid, sender, e); } private void SelectItemsInRectangle(Rect selectionRect, DataGrid dataGrid, object sender, MouseEventArgs e) { powershell foreach (var item in dataGrid.Items) { var row = (DataGridRow)dataGrid.ItemContainerGenerator.ContainerFromItem(item); if (row != null) { var rowBounds = GetRowBoundsRelativeToDataGrid(row, dataGrid); // Check if the row intersects with the selection rectangle if (selectionRect.IntersectsWith(rowBounds)) { // Select the item and add it to the collection of selected items row.IsSelected = true; } else { row.IsSelected = false; } } } }

private Rect GetRowBoundsRelativeToDataGrid(DataGridRow row, DataGrid dataGrid)

{

 var rowTransform = row.TransformToAncestor(dataGrid);

 var rowPosition = rowTransform.Transform(new Point(0, 0));

 // Calculate the bounds relative to the DataGrid

 return new Rect(rowPosition.X, rowPosition.Y, row.ActualWidth, row.ActualHeight);

}

Accepted Answer

namespace Gekka.WPF.DataGrid.Sample
{
    using System;
    using System.Windows;
    using System.Windows.Data;
    using System.Windows.Input;
    using System.Windows.Markup;
    using System.Windows.Controls;
    using System.Linq;
    using System.Windows.Media;
    using System.Collections.Generic;
    using System.Collections;
    using System.ComponentModel;

    using System.Windows.Media.Animation;

    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            Grid grid = new Grid();
            this.Content = grid;

            DataGrid dataGrid = new DataGrid() { Margin = new Thickness(20), RowHeaderWidth = 50 };
            for (int i = 1; i <= 10; i++)
            {
                var column = new DataGridTextColumn() { Header = "Column" + i.ToString(), Width = 100, IsReadOnly = true };
                if (i == 1)
                {
                    column.Binding = new Binding(".");
                }
                dataGrid.Columns.Add(column);
            }
            grid.Children.Add(dataGrid);
            dataGrid.ItemsSource = Enumerable.Range(1, 1000).ToArray();

            // 
            SelectionAdorner.SetEnableSelectionRectangle(dataGrid, true);
        }
    }

    class SelectionAdorner : System.Windows.Documents.Adorner
    {
        #region Attached Proeprty

        public static bool GetEnableSelectionRectangle(DataGrid obj) { return (bool)obj.GetValue(EnableSelectionRectangleProperty); }
        public static void SetEnableSelectionRectangle(DataGrid obj, bool value) { obj.SetValue(EnableSelectionRectangleProperty, value); }

        public static readonly DependencyProperty EnableSelectionRectangleProperty =
            DependencyProperty.RegisterAttached
            ("EnableSelectionRectangle"
            , typeof(bool)
            , typeof(SelectionAdorner)
            , new UIPropertyMetadata
                (default(bool)
                    , new PropertyChangedCallback(OnEnableSelectionRectanglePropertyChanged)));

        private static void OnEnableSelectionRectanglePropertyChanged(DependencyObject dpo, DependencyPropertyChangedEventArgs e)
        {
            DataGrid target = dpo as DataGrid;
            if (target != null)
            {
                if ((bool)e.OldValue)
                {
                    target.PreviewMouseLeftButtonDown -= Target_PreviewMouseLeftButtonDown;
                }
                if ((bool)e.NewValue)
                {
                    target.PreviewMouseLeftButtonDown += Target_PreviewMouseLeftButtonDown;
                }
            }
        }

        private static void Target_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            DataGrid target = sender as DataGrid;
            SelectionAdorner adorner = new SelectionAdorner(target);
            adorner = new SelectionAdorner(target);

            adorner.DG_PreviewMouseLeftButtonDown(sender, e);
        }

        #endregion

        private bool isSelecting;
        private DataGrid dataGrid;
        private ScrollViewer scrollViewer;
        private int hitRowIndex = -1;
        private Point pHitRow;
        private double offsetX;
        private double offsetY;
        private Point pStart;
        private Point pNow;

        public Brush BackgroundBrush { get; set; } = new SolidColorBrush(Color.FromArgb(0x3F, 0, 0x7F, 0xFF));
        public Brush BorderBrush { get; set; } = new SolidColorBrush(Colors.Red);

        public SelectionAdorner(DataGrid dg) : base(dg)
        {
            this.dataGrid = dg;
            this.IsHitTestVisible = false;
        }

        public void DG_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            if (this.scrollViewer == null)
            {
                this.scrollViewer = this.dataGrid.Template.FindName("DG_ScrollViewer", this.dataGrid) as ScrollViewer;
                this.scrollViewer.ScrollChanged += scrollViewer_ScrollChanged;

                //this.scrollViewer.CanContentScroll = false;
            }

            if (isSelecting || this.scrollViewer == null)
            {
                return;
            }

            this.offsetX = this.scrollViewer.HorizontalOffset;
            this.offsetY = this.scrollViewer.VerticalOffset;

            this.pStart = e.GetPosition(this.dataGrid);
            this.pNow = this.pStart;

            var hit = VisualTreeHelper.HitTest(this.dataGrid, this.pStart);
            if (hit == null)
            {
                return;
            }

            var rowcells = FindParent(hit.VisualHit);
            if (rowcells == null)
            {
                return;
            }

            var hitRow = FindParent(rowcells);
            pHitRow = e.GetPosition(hitRow);

            this.hitRowIndex = this.dataGrid.ItemContainerGenerator.IndexFromContainer(hitRow);

            var layer = System.Windows.Documents.AdornerLayer.GetAdornerLayer(this.dataGrid);
            layer.Add(this);

            isSelecting = true;
            this.dataGrid.PreviewMouseLeftButtonUp += DG_PreviewMouseLeftButtonUp;
            this.dataGrid.PreviewMouseMove += DG_PreviewMouseMove;
        }

        private T FindParent(DependencyObject d) where T : DependencyObject
        {
            while (d != null)
            {
                if (d is T t)
                {
                    return t;
                }
                d = VisualTreeHelper.GetParent(d);
            }
            return null;
        }

        private void DG_PreviewMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            isSelecting = false;
            this.dataGrid.PreviewMouseLeftButtonUp -= DG_PreviewMouseLeftButtonUp;
            this.dataGrid.PreviewMouseMove -= DG_PreviewMouseMove;

            var layer = System.Windows.Documents.AdornerLayer.GetAdornerLayer(this.dataGrid);
            layer.Remove(this);
            hitRowIndex = -1;

            base.OnPreviewMouseLeftButtonUp(e);
        }

        private void DG_PreviewMouseMove(object sender, MouseEventArgs e)
        {
            base.OnPreviewMouseMove(e);

            this.pNow = e.GetPosition(this.dataGrid);

            var hit = VisualTreeHelper.HitTest(this.dataGrid, this.pNow);
            if (hit == null)
            {
                double x = Math.Min(Math.Max(0, pNow.X), this.dataGrid.ActualWidth);
                double y = Math.Min(Math.Max(0, pNow.Y), this.dataGrid.ActualHeight);

                pNow = new Point(x, y);
            }
            this.InvalidateVisual();
        }

        private void scrollViewer_ScrollChanged(object sender, ScrollChangedEventArgs e)
        {
            if (!isSelecting)
            {
                return;
            }

            var h = e.VerticalChange;

            this.InvalidateVisual();
        }

        protected override void OnRender(DrawingContext drawingContext)
        {
            if (this.isSelecting)
            {
                double startX = pStart.X - (this.scrollViewer.HorizontalOffset - this.offsetX);
                double startY = pStart.Y;
                if (this.scrollViewer.CanContentScroll)
                {
                    if (offsetY == this.scrollViewer.VerticalOffset)
                    {
                        startY = pStart.Y;
                    }
                    else if (hitRowIndex < this.scrollViewer.VerticalOffset)
                    {
                        startY = 0;
                    }
                    else
                    {
                        var row = this.dataGrid.ItemContainerGenerator.ContainerFromIndex(hitRowIndex) as DataGridRow;
                        if (row == null)
                        {
                            startY = this.dataGrid.ActualHeight;
                        }
                        else
                        {
                            var p = row.TranslatePoint(pHitRow, this.dataGrid);
                            startY = p.Y;
                        }
                    }
                }
                else
                {
                    startY = pStart.Y - (this.scrollViewer.VerticalOffset - this.offsetY);
                }

                startX = Math.Min(Math.Max(0, startX), this.dataGrid.ActualWidth);
                startY = Math.Min(Math.Max(0, startY), this.dataGrid.ActualHeight);

                var pStartFix = new Point(startX, startY);
                Rect rect = new Rect(pStartFix, pNow);

                //drawingContext.PushClip(new RectangleGeometry(new Rect(0,0,this.dataGrid.ActualWidth, this.dataGrid.ActualHeight)));
                drawingContext.DrawRectangle(this.BackgroundBrush, new Pen(this.BorderBrush, 1), rect);
            }
            base.OnRender(drawingContext);
        }
    }
}

Selection Rectangle not moving along with datagrid content during scroll.

0 additional answers