Editing multiple cells at once

[Sean 2212]

I have created an attached behavior that allows you to select multiple rows in a grid, edit a cell and upon the edit completing, the changed value is applied to the cells in the same column of the selected rows. This works just fine.

However, setting the grid with SelectionMode="Extended" allows multiple rows to be selected but doesn't allow you to use the mouse to click on the selected row and drag to select more rows. I asked about this and Milan advised to use DragElementAction="ExtendedSelect" which is exactly what I wanted but setting it interferes with the selected rows.

Once multiple rows are selected, clicking on the outlined cell on the current row puts the cell into edit mode (as expected) but all the other selected rows disappear. If I remove the DragElementAction property the selected rows do not change when going into edit mode.

The attached behavior I did does not change the selected rows. I would like to be able to retain the multi-edit behavior and the extended selection drag action. SelectionUnit needs to be FullRow. Any help would be appreciated. Thanks.

[Milan]

Hi Sean 2212,

I am afraid that this is the expected behavior at the moment. you could try using F2 to begin editing.

Greetings,
Milan
the Telerik team

[dpl]

Hi Sean 2212,

sorry for pushing this old thread, but can you tell me how you have done it? I have no idea how to attach the behavior.

Many thanks.

[Sean Craig]

Hi, dpl.

We created a behaviour that hooked into the BeginningEdit and CellEditEnded events of the RadGridView. When the cell edit fired, we remembered which rows were selected. Then when the edit ended, we populated the cell in the other selected rows with the new value.

I've included some old code I found using version 2011.10419.40 of the Telerik WPF controls. It's not the best but it's what we had to do to get it to work. Please let me know if you have any questions.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Windows.Interactivity;
using Telerik.Windows.Controls;
using Telerik.Windows.Controls.GridView;

namespace Als.Angel.UI.Wpf.Framework.Views.Behaviors
{
    public class GridMultiEditBehaviour : Behavior<RadGridView>
    {
        public RadGridView Grid { get { return AssociatedObject; } }

        private static readonly IList<GridViewCellInfo> selectedCells = new List<GridViewCellInfo>();
        private static readonly IList<object> selectedItems = new List<object>();

        protected override void OnAttached()
        {
            base.OnAttached();
            Grid.CellEditEnded += RadGridViewCellEditEnded;
            Grid.BeginningEdit += GridBeginningEdit;
        }

        static void GridBeginningEdit(object sender, GridViewBeginningEditRoutedEventArgs e)
        {
            var grid = (RadGridView)sender;

            switch (grid.SelectionUnit)
            {
                case GridViewSelectionUnit.FullRow:
                    selectedItems.Clear();
                    foreach (var item in grid.SelectedItems)
                    {
                        selectedItems.Add(item);
                    }
                    break;

                case GridViewSelectionUnit.Cell:
                    selectedCells.Clear();
                    foreach (var cell in grid.SelectedCells)
                    {
                        selectedCells.Add(cell);
                    }
                    break;
            }
        }

        private static void RadGridViewCellEditEnded(object sender, GridViewCellEditEndedEventArgs e)
        {
            var grid = (RadGridView)sender;

            if (e.EditAction != GridViewEditAction.Commit)
            {
                return;
            }

            switch (grid.SelectionUnit)
            {
                case GridViewSelectionUnit.FullRow:
                    FullRowMultiEdit(e);
                    break;

                case GridViewSelectionUnit.Cell:
                    CellMultiEdit(e);
                    break;
            }
        }

        private static void CellMultiEdit(GridViewCellEditEndedEventArgs e)
        {
            if (selectedCells.Count < 2)
            {
                return;
            }

            var newValue = e.NewData;

            foreach (var selected in selectedCells)
            {
                if (e.Cell.Equals(selected) || selected.Column.IsReadOnly)
                {
                    continue;
                }

                var item = selected.Item;
                var bindingPath = ((GridViewBoundColumnBase)(selected.Column)).DataMemberBinding.Path;
                if (bindingPath.PathParameters.Any())
                {
                    continue;
                }

                var pathProperties = GetPathProperties(item.GetType(), bindingPath.Path);

                var canAssignValue = true;
                if (selected is IEditable)
                {
                    if (!(selected as IEditable).IsEditable)
                    {
                        canAssignValue = false;
                    }
                }

                if (item is ICanMultiEditProperty)
                {
                    var model = item as ICanMultiEditProperty;
                    var descriptors = model.PropertyAccessDescriptors();
                    var key = pathProperties.Info[0].Name;

                    Func<bool> func;
                    if (descriptors.TryGetValue(key, out func))
                    {
                        if (!func())
                        {
                            canAssignValue = false;
                            // If this func return false, it means we can't copy the value to it
                        }
                    }
                }

                if (canAssignValue)
                {
                    SetCellPathValue(item, pathProperties, newValue);
                }
            }
        }

        private static void SetCellPathValue(object o, PathProperties pathProperties, object value)
        {
            var target = o;
            for (var i = 0; i < pathProperties.Info.Count - 1; i++)
            {
                var pval = pathProperties.Info[i].GetValue(target, null);
                if (pval == null)
                {
                    return;
                }

                target = pval;
            }

            if (target != null)
            {
                if (pathProperties.PropertyIndex != null)
                {
                    var index = pathProperties.PropertyIndex.ToArray();
                    var obj = pathProperties.Info[pathProperties.Info.Count - 1].GetValue(target, null);
                    obj.GetType().GetProperty("Item").SetValue(obj, value, index);
                }
                else
                {
                    pathProperties.Info[pathProperties.Info.Count - 1].SetValue(target, value, null);
                }
            }
        }

        private static void FullRowMultiEdit(GridViewCellEditEndedEventArgs e)
        {
            if (selectedItems.Count < 2)
            {
                return;
            }

            var newValue = e.NewData;
            var underlyingRow = e.Cell.DataContext;
            var bindingPath = e.Cell.DataColumn.DataMemberBinding.Path;
            if (bindingPath.PathParameters.Any())
            {
                return;
            }

            var pathProperties = GetPathProperties(underlyingRow.GetType(), bindingPath.Path);

            foreach (var selected in selectedItems)
            {
                if (underlyingRow.Equals(selected))
                {
                    continue;
                }

                var canAssignValue = true;
                if (selected is IEditable)
                {
                    if (!(selected as IEditable).IsEditable)
                    {
                        canAssignValue = false;
                    }
                }

                if (selected is ICanMultiEditProperty)
                {
                    var model = selected as ICanMultiEditProperty;
                    var descriptors = model.PropertyAccessDescriptors();
                    var key = bindingPath.Path;

                    Func<bool> func;
                    if (descriptors.TryGetValue(key, out func))
                    {
                        if (!func())
                        {
                            canAssignValue = false;
                            // If this func return false, it means we can't copy the value to it
                        }
                    }
                }

                if (canAssignValue)
                {
                    SetMultiPathValue(selected, pathProperties, newValue);
                }
            }
        }

        private static void SetMultiPathValue(object o, PathProperties pathProperties, object value)
        {
            var target = o;
            for (var i = 0; i < pathProperties.Info.Count - 1; i++)
            {
                var pval = pathProperties.Info[i].GetValue(target, null);
                if (pval == null)
                {
                    return;
                }

                target = pval;
            }

            if (target != null)
            {
                pathProperties.Info[pathProperties.Info.Count - 1].SetValue(target, value, null);
            }
        }

        private static PathProperties GetPathProperties(Type type, string propertyPath)
        {
            var result = new PathProperties();

            var currentType = type;
            var pathElements = propertyPath.Split('.');

            foreach (var t in pathElements)
            {
                var name = t;
                if (t.EndsWith("]"))
                {
                    var bracketBegin = t.IndexOf('[');
                    var bracketEnd = t.IndexOf(']');

                    name = t.Substring(0, bracketBegin);

                    var index = Convert.ToInt32(t.Substring(bracketBegin + 1, bracketEnd - bracketBegin - 1));
                    result.PropertyIndex.Add(index);
                }

                var pi = currentType.GetProperty(name);
                result.Info.Add(pi);

                currentType = pi.PropertyType;
            }

            return result;
        }
    }

    public class PathProperties
    {
        public IList<PropertyInfo> Info { get; set; }
        public IList<object> PropertyIndex { get; set; }

        public PathProperties()
        {
            Info = new List<PropertyInfo>();
            PropertyIndex = new List<object>();
        }
    }

    public interface ICanMultiEditProperty
    {
        Dictionary<string, Func<bool>> PropertyAccessDescriptors();
    }
}

[dpl]

Hi Sean,

many thanks. I will try it as soon as possible.