Persist expanded state of GroupingBrid groups after changes to the grouping.

Author: comintern

Rubberduck.Core/UI/Controls/GroupingGrid.xaml

@@ -3,7 +3,9 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-             xmlns:local="clr-namespace:Rubberduck.UI.Controls" x:Class="Rubberduck.UI.Controls.GroupingGrid"
+             xmlns:local="clr-namespace:Rubberduck.UI.Controls"
+             xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
+             x:Class="Rubberduck.UI.Controls.GroupingGrid"
              mc:Ignorable="d" 
              d:DesignHeight="300" d:DesignWidth="300">
     <DataGrid.Resources>
@@ -76,6 +78,9 @@
                                 </StackPanel>
                             </Expander.Header>
                             <ItemsPresenter Margin="25,0,0,0" />
+                            <i:Interaction.Behaviors>
+                                <local:PersistGroupExpandedStateBehavior GroupName="{Binding Name}" />
+                            </i:Interaction.Behaviors>
                         </Expander>
                     </ControlTemplate>
                 </Setter.Value>

Rubberduck.Core/UI/Controls/PersistGroupExpandedStateBehavior.cs

@@ -0,0 +1,81 @@
+using System.Collections.Generic;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Interactivity;
+using GongSolutions.Wpf.DragDrop.Utilities;
+
+namespace Rubberduck.UI.Controls
+{
+    // Courtesy of @aKzenT - this is a heavily refactored implementation of https://stackoverflow.com/a/15924044/4088852
+    public class PersistGroupExpandedStateBehavior : Behavior<Expander>
+    {
+        public static readonly DependencyProperty GroupNameProperty = DependencyProperty.Register(
+            "GroupName",
+            typeof(object),
+            typeof(PersistGroupExpandedStateBehavior),
+            new PropertyMetadata(default(object)));
+
+        private static readonly DependencyProperty ExpandedStateStoreProperty =
+            DependencyProperty.RegisterAttached(
+                "ExpandedStateStore",
+                typeof(IDictionary<object, bool>),
+                typeof(PersistGroupExpandedStateBehavior),
+                new PropertyMetadata(default(IDictionary<object, bool>)));
+
+        public object GroupName
+        {
+            get => GetValue(GroupNameProperty);
+            set => SetValue(GroupNameProperty, value);
+        }
+
+        protected override void OnAttached()
+        {
+            base.OnAttached();
+
+            var states = GetExpandedStateStore();
+            var expanded = !states.ContainsKey(GroupName ?? string.Empty) ? (bool?)null : states[GroupName ?? string.Empty];
+
+            if (expanded != null)
+            {
+                AssociatedObject.IsExpanded = expanded.Value;
+            }
+
+            AssociatedObject.Expanded += OnExpanded;
+            AssociatedObject.Collapsed += OnCollapsed;
+        }
+
+        protected override void OnDetaching()
+        {
+            AssociatedObject.Expanded -= OnExpanded;
+            AssociatedObject.Collapsed -= OnCollapsed;
+
+            base.OnDetaching();
+        }
+
+        private void OnCollapsed(object sender, RoutedEventArgs e) => SetExpanded(false);
+
+        private void OnExpanded(object sender, RoutedEventArgs e) => SetExpanded(true);
+
+        private void SetExpanded(bool expanded) => GetExpandedStateStore()[GroupName ?? string.Empty] = expanded;
+
+        private IDictionary<object, bool> GetExpandedStateStore()
+        {
+            if (!(AssociatedObject?.GetVisualAncestor<ItemsControl>() is ItemsControl items))
+            {
+                return null;
+            }
+
+            var states = (IDictionary<object, bool>)items.GetValue(ExpandedStateStoreProperty);
+
+            if (states != null)
+            {
+                return states;
+            }
+
+            states = new Dictionary<object, bool>();
+            items.SetValue(ExpandedStateStoreProperty, states);
+
+            return states;
+        }
+    }
+}

Rubberduck.Core/UI/GridViewSort.cs

@@ -1,40 +1,40 @@
-using System.Collections.Generic;
-using System.Linq;
+//using System.Collections.Generic;
+//using System.Linq;
 
-namespace Rubberduck.UI
-{
-    public class GridViewSort<T>
-    {
-        public bool SortedAscending { get; private set; }
-        public string ColumnName { get; private set; }
+//namespace Rubberduck.UI
+//{
+//    public class GridViewSort<T>
+//    {
+//        public bool SortedAscending { get; private set; }
+//        public string ColumnName { get; private set; }
 
-        public GridViewSort(string columnName, bool sortedAscending)
-        {
-            ColumnName = columnName;
-            SortedAscending = sortedAscending;
-        }
+//        public GridViewSort(string columnName, bool sortedAscending)
+//        {
+//            ColumnName = columnName;
+//            SortedAscending = sortedAscending;
+//        }
 
-        public IEnumerable<T> Sort(IEnumerable<T> items, string columnName)
-        {
-            if (columnName == ColumnName && SortedAscending)
-            {
-                SortedAscending = false;
-                return items.OrderByDescending(x => x.GetType().GetProperty(columnName).GetValue(x));
-            }
+//        public IEnumerable<T> Sort(IEnumerable<T> items, string columnName)
+//        {
+//            if (columnName == ColumnName && SortedAscending)
+//            {
+//                SortedAscending = false;
+//                return items.OrderByDescending(x => x.GetType().GetProperty(columnName).GetValue(x));
+//            }
 
-            ColumnName = columnName;
-            SortedAscending = true;
-            return items.OrderBy(x => x.GetType().GetProperty(columnName).GetValue(x));
-        }
+//            ColumnName = columnName;
+//            SortedAscending = true;
+//            return items.OrderBy(x => x.GetType().GetProperty(columnName).GetValue(x));
+//        }
 
-        public IEnumerable<T> Sort(IEnumerable<T> items, string columnName, bool sortAscending)
-        {
-            SortedAscending = sortAscending;
-            ColumnName = columnName;
+//        public IEnumerable<T> Sort(IEnumerable<T> items, string columnName, bool sortAscending)
+//        {
+//            SortedAscending = sortAscending;
+//            ColumnName = columnName;
 
-            return sortAscending
-                ? items.OrderBy(x => x.GetType().GetProperty(columnName).GetValue(x))
-                : items.OrderByDescending(x => x.GetType().GetProperty(columnName).GetValue(x));
-        }
-    }
-}
+//            return sortAscending
+//                ? items.OrderBy(x => x.GetType().GetProperty(columnName).GetValue(x))
+//                : items.OrderByDescending(x => x.GetType().GetProperty(columnName).GetValue(x));
+//        }
+//    }
+//}