Allow Specifying the interactive SortOrder Sequence on Data Grids (#2366)

Author: rklfss

Radzen.Blazor/RadzenDataGrid.razor.cs

@@ -1016,7 +1016,7 @@ internal async Task OnSort(EventArgs args, RadzenDataGridColumn<TItem> column)
 
                 var property = column.GetSortProperty();
 
-                SetColumnSortOrder(column);
+                SetNextColumnSortOrder(column);
                 await Sort.InvokeAsync(new DataGridColumnSortEventArgs<TItem>() { Column = column, SortOrder = column.GetSortOrder() });
                 SaveSettings();
 
@@ -3153,7 +3153,20 @@ internal bool IsOData()
 
         internal List<SortDescriptor> sorts = new List<SortDescriptor>();
 
-        internal void SetColumnSortOrder(RadzenDataGridColumn<TItem> column)
+        internal void SetNextColumnSortOrder(RadzenDataGridColumn<TItem> column)
+        {
+            var sequence = column.SortOrderSequence;
+
+            var pos = Array.IndexOf(sequence, column.GetSortOrder());
+
+            var nextSortOrder = pos == -1 || pos + 1 >= sequence.Length
+                ? sequence.FirstOrDefault()
+                : sequence[pos + 1];
+
+            SetColumnSortOrder(column, nextSortOrder);
+        }
+
+        private void SetColumnSortOrder(RadzenDataGridColumn<TItem> column, SortOrder? sortOrder)
         {
             if (!AllowMultiColumnSorting)
             {
@@ -3165,35 +3178,33 @@ internal void SetColumnSortOrder(RadzenDataGridColumn<TItem> column)
             }
 
             var descriptor = sorts.Where(d => d.Property == column?.GetSortProperty()).FirstOrDefault();
-            if (descriptor == null)
-            {
-                descriptor = new SortDescriptor() { Property = column.GetSortProperty() };
-            }
 
-            if (column.GetSortOrder() == null)
-            {
-                column.SetSortOrderInternal(SortOrder.Ascending);
-                descriptor.SortOrder = SortOrder.Ascending;
-            }
-            else if (column.GetSortOrder() == SortOrder.Ascending)
-            {
-                column.SetSortOrderInternal(SortOrder.Descending);
-                descriptor.SortOrder = SortOrder.Descending;
-            }
-            else if (column.GetSortOrder() == SortOrder.Descending)
+            column.SetSortOrderInternal(sortOrder);
+
+            if (!sortOrder.HasValue)
             {
-                column.SetSortOrderInternal(null);
-                if (sorts.Where(d => d.Property == column?.GetSortProperty()).Any())
+                if (descriptor != null)
                 {
                     sorts.Remove(descriptor);
                 }
-                descriptor = null;
+
+                return;
             }
 
-            if (descriptor != null && !sorts.Where(d => d.Property == column?.GetSortProperty()).Any())
+            if (descriptor == null)
             {
+                descriptor = new SortDescriptor()
+                {
+                    Property = column.GetSortProperty(),
+                    SortOrder = sortOrder,
+                };
+
                 sorts.Add(descriptor);
+
+                return;
             }
+
+            descriptor.SortOrder = sortOrder;
         }
 
         void GroupsCollectionChanged(object sender, NotifyCollectionChangedEventArgs args)
@@ -3377,7 +3388,7 @@ public void OrderBy(string property)
 
             if (column != null)
             {
-                SetColumnSortOrder(column);
+                SetColumnSortOrder(column, SortOrder.Ascending);
                 Sort.InvokeAsync(new DataGridColumnSortEventArgs<TItem>() { Column = column, SortOrder = column.GetSortOrder() });
                 SaveSettings();
             }
@@ -3403,9 +3414,7 @@ public void OrderByDescending(string property)
 
             if (column != null)
             {
-                column.SetSortOrderInternal(SortOrder.Ascending);
-                SetColumnSortOrder(column);
-
+                SetColumnSortOrder(column, SortOrder.Descending);
                 Sort.InvokeAsync(new DataGridColumnSortEventArgs<TItem>() { Column = column, SortOrder = column.GetSortOrder() });
                 SaveSettings();
             }

Radzen.Blazor/RadzenDataGridColumn.razor.cs

@@ -278,6 +278,12 @@ internal void SetOrderIndex(int? value)
         [Parameter]
         public SortOrder? SortOrder { get; set; }
 
+        /// <summary>
+        /// Gets or sets the sequence of the <see cref="Radzen.SortOrder"/>s to use when sorting the column interactively.
+        /// </summary>
+        [Parameter]
+        public SortOrder?[] SortOrderSequence { get; set; } = [Radzen.SortOrder.Ascending, Radzen.SortOrder.Descending, null];
+
         bool visible = true;
         /// <summary>
         /// Gets or sets a value indicating whether this <see cref="RadzenDataGridColumn{TItem}"/> is visible.

Radzen.Blazor/RadzenPivotDataGrid.razor

@@ -198,7 +198,7 @@
                                 <tr class="rz-pivot-header-row">
                                 <th class="rz-pivot-column-header @(isSortable ? "rz-sortable-column" : "")" style="width:100%;margin-top:5px;">
                                     <div class="rz-pivot-header-content-wrapper">
-                                        <div @onclick="@(args => OnColumnSort(args, column))"
+                                        <div @onclick="@(args => OnAggregateSort(args, column))"
                                                 @onkeydown="@(isSortable ? OnSortKeyPressed : (Func<KeyboardEventArgs, Task>)null)"
                                                 class="rz-pivot-header-content @(isSortable ? "rz-sortable" : "")"
                                                 tabindex="@(isSortable ? "0" : null)"

Radzen.Blazor/RadzenPivotDataGrid.razor.cs

@@ -1537,68 +1537,51 @@ private void PadRowHeaderCells(List<PivotBodyRow> rows)
         }
 
         /// <summary>
-        /// Handles column header click for sorting.
+        /// Handles aggregate click for sorting.
         /// </summary>
-        internal async Task OnColumnSort(EventArgs args, RadzenPivotField<TItem> column)
+        internal async Task OnAggregateSort(EventArgs args, RadzenPivotAggregate<TItem> aggregate)
         {
-            if (AllowSorting && column.Sortable)
-            {
-                // Toggle sort order: None -> Ascending -> Descending -> None
-                if (column.GetSortOrder() == null)
-                {
-                    column.SetSortOrderInternal(SortOrder.Ascending);
-                }
-                else if (column.GetSortOrder() == SortOrder.Ascending)
-                {
-                    column.SetSortOrderInternal(SortOrder.Descending);
-                }
-                else
-                {
-                    column.SetSortOrderInternal(null);
-                }
-
-                // Clear other column sorts if single column sorting
-                if (column.GetSortOrder() != null)
-                {
-                    foreach (var col in pivotColumns.Where(c => c != column))
-                    {
-                        col.SetSortOrderInternal(null);
-                    }
-                }
-
-                await Reload();
-            }
+            await HandleFieldSort(pivotAggregates, aggregate);
+        }
 
-            await Task.CompletedTask;
+        /// <summary>
+        /// Handles column header click for sorting.
+        /// </summary>
+        internal async Task OnColumnSort(EventArgs args, RadzenPivotColumn<TItem> column)
+        {
+            await HandleFieldSort(pivotColumns, column);
         }
 
         /// <summary>
         /// Handles row header click for sorting.
         /// </summary>
         internal async Task OnRowSort(EventArgs args, RadzenPivotRow<TItem> row)
         {
-            if (AllowSorting && row.Sortable)
+            await HandleFieldSort(pivotRows, row);
+        }
+
+        private async Task HandleFieldSort<T>(List<T> allFields, T sortedField)
+            where T : RadzenPivotField<TItem>
+        {
+            if (AllowSorting && sortedField.Sortable)
             {
-                // Toggle sort order: None -> Ascending -> Descending -> None
-                if (row.GetSortOrder() == null)
-                {
-                    row.SetSortOrderInternal(SortOrder.Ascending);
-                }
-                else if (row.GetSortOrder() == SortOrder.Ascending)
-                {
-                    row.SetSortOrderInternal(SortOrder.Descending);
-                }
-                else
-                {
-                    row.SetSortOrderInternal(null);
-                }
+                // Toggle sort order
+                var sequence = sortedField.SortOrderSequence;
 
-                // Clear other row sorts if single row sorting
-                if (row.GetSortOrder() != null)
+                var pos = Array.IndexOf(sequence, sortedField.GetSortOrder());
+
+                var nextSortOrder = pos == -1 || pos + 1 >= sequence.Length
+                    ? sequence.FirstOrDefault()
+                    : sequence[pos + 1];
+
+                sortedField.SetSortOrderInternal(nextSortOrder);
+
+                // Clear other column sorts if single column sorting
+                if (sortedField.GetSortOrder() != null)
                 {
-                    foreach (var r in pivotRows.Where(r => r != row))
+                    foreach (var col in allFields.Where(c => c != sortedField))
                     {
-                        r.SetSortOrderInternal(null);
+                        col.SetSortOrderInternal(null);
                     }
                 }
 

Radzen.Blazor/RadzenPivotField.razor.cs

@@ -30,6 +30,12 @@ public partial class RadzenPivotField<TItem> : ComponentBase, IDisposable
         [Parameter]
         public SortOrder? SortOrder { get; set; }
 
+        /// <summary>
+        /// Gets or sets the sequence of the <see cref="Radzen.SortOrder"/>s to use when sorting the column interactively.
+        /// </summary>
+        [Parameter]
+        public SortOrder?[] SortOrderSequence { get; set; } = [Radzen.SortOrder.Ascending, Radzen.SortOrder.Descending, null];
+
         /// <summary>
         /// Gets or sets a value indicating whether this column is sortable.
         /// </summary>