Support resizing result grid columns

Author: 长安员外

SqlAnalyzer.App/Models/ResultColumnViewItem.cs

@@ -26,6 +26,8 @@ public sealed class ResultColumnViewItem
 
     public bool HasExplicitAlias { get; set; }
 
+    public double? ManualWidth { get; set; }
+
     public string EffectiveSourceColumn =>
         string.IsNullOrWhiteSpace(SourceColumn) ? RawName : SourceColumn!;
 }

SqlAnalyzer.App/Services/ResultWorkspaceController.cs

@@ -14,20 +14,31 @@ namespace SqlAnalyzer.App.Services;
 
 public sealed class ResultWorkspaceController
 {
+    private const double ColumnResizeHandleWidth = 7.0;
+    private const double ColumnResizeHandleOverflow = 2.0;
+    private const double MinDataColumnWidth = 48.0;
+    private const double MaxDataColumnWidth = 720.0;
+
     private readonly Dictionary<int, Border> _headerBorders = [];
     private readonly HashSet<int> _pinnedHeaderColumns = [];
     private readonly Dictionary<ResultRowViewItem, Border> _rowBorders = [];
     private readonly Dictionary<ResultRowViewItem, Border> _actionBorders = [];
     private readonly Dictionary<(ResultRowViewItem Row, int ColumnIndex), Border> _cellBorders = [];
+    private readonly Dictionary<int, int> _columnVisualIndexes = [];
+    private readonly List<Grid> _scrollableGrids = [];
     private readonly HashSet<ResultRowViewItem> _selectedRows = [];
     private readonly HashSet<(ResultRowViewItem Row, int ColumnIndex)> _selectedCells = [];
     private ResultRowViewItem? _selectedRow;
     private ResultRowViewItem? _selectionAnchorRow;
     private ResultCellContext? _cellSelectionAnchor;
     private ResultCellContext? _selectedCell;
+    private int _resizingColumnIndex = -1;
+    private double _resizeStartX;
+    private double _resizeStartWidth;
     private bool _isDraggingSelection;
     private bool _isDraggingCellSelection;
     private bool _isDraggingHeaderSelection;
+    private bool _isResizingColumn;
 
     public ResultRowViewItem? SelectedRow => _selectedRow;
 
@@ -41,6 +52,8 @@ public sealed class ResultWorkspaceController
 
     public bool IsDraggingHeaderSelection => _isDraggingHeaderSelection;
 
+    public bool IsResizingColumn => _isResizingColumn;
+
     public ResultCellContext? SelectedCell => _selectedCell;
 
     public int SelectedCellSelectionCount => _selectedCells.Count;
@@ -93,10 +106,12 @@ public Border BuildScrollableHeaderRow(
         {
             ColumnDefinitions = new ColumnDefinitions(string.Join(",", columnWidths.Select(width => $"{width}")))
         };
+        _scrollableGrids.Add(headerGrid);
 
         for (int visualIndex = 0; visualIndex < orderedColumns.Count; visualIndex++)
         {
             int columnIndex = orderedColumns[visualIndex];
+            _columnVisualIndexes[columnIndex] = visualIndex;
             ResultColumnViewItem column = resultSet.Columns[columnIndex];
             string subtitle = headerSubtitleFormatter(column);
             Border headerCell = new()
@@ -188,6 +203,7 @@ public Border BuildScrollableDataRow(
         {
             ColumnDefinitions = new ColumnDefinitions(string.Join(",", columnWidths.Select(width => $"{width}")))
         };
+        _scrollableGrids.Add(rowGrid);
 
         for (int visualIndex = 0; visualIndex < orderedColumns.Count; visualIndex++)
         {
@@ -407,15 +423,91 @@ public void Reset()
         _rowBorders.Clear();
         _actionBorders.Clear();
         _cellBorders.Clear();
+        _columnVisualIndexes.Clear();
+        _scrollableGrids.Clear();
         _selectedRows.Clear();
         _selectedCells.Clear();
         _selectedRow = null;
         _selectionAnchorRow = null;
         _cellSelectionAnchor = null;
         _selectedCell = null;
+        _resizingColumnIndex = -1;
+        _resizeStartX = 0;
+        _resizeStartWidth = 0;
         _isDraggingSelection = false;
         _isDraggingCellSelection = false;
         _isDraggingHeaderSelection = false;
+        _isResizingColumn = false;
+    }
+    public bool TryGetHeaderResizeColumnAtPoint(Visual relativeTo, Point point, out int columnIndex)
+    {
+        double bestDistance = double.MaxValue;
+        int bestColumnIndex = -1;
+        foreach ((int key, Border border) in _headerBorders)
+        {
+            if (!TryBuildHitRect(border, relativeTo, out Rect rect) ||
+                point.Y < rect.Top ||
+                point.Y > rect.Bottom ||
+                point.X < rect.Right - ColumnResizeHandleWidth ||
+                point.X > rect.Right + ColumnResizeHandleOverflow)
+            {
+                continue;
+            }
+
+            double distance = Math.Abs(point.X - rect.Right);
+            if (distance < bestDistance)
+            {
+                bestDistance = distance;
+                bestColumnIndex = key;
+            }
+        }
+
+        columnIndex = bestColumnIndex;
+        return bestColumnIndex >= 0;
+    }
+    public void BeginColumnResize(ResultSetViewItem resultSet, Visual relativeTo, Point point, int columnIndex)
+    {
+        if (columnIndex < 0 ||
+            columnIndex >= resultSet.Columns.Count ||
+            !_headerBorders.TryGetValue(columnIndex, out Border? border) ||
+            !TryBuildHitRect(border, relativeTo, out Rect rect))
+        {
+            return;
+        }
+
+        _isResizingColumn = true;
+        _isDraggingSelection = false;
+        _isDraggingCellSelection = false;
+        _isDraggingHeaderSelection = false;
+        _resizingColumnIndex = columnIndex;
+        _resizeStartX = point.X;
+        _resizeStartWidth = Math.Clamp(rect.Width, MinDataColumnWidth, MaxDataColumnWidth);
+        resultSet.Columns[columnIndex].ManualWidth = _resizeStartWidth;
+    }
+    public bool UpdateColumnResize(ResultSetViewItem resultSet, double pointerX, bool isLeftButtonPressed)
+    {
+        if (!_isResizingColumn || !isLeftButtonPressed)
+        {
+            return false;
+        }
+
+        if (_resizingColumnIndex < 0 || _resizingColumnIndex >= resultSet.Columns.Count)
+        {
+            EndColumnResize();
+            return false;
+        }
+
+        double width = Math.Clamp(_resizeStartWidth + pointerX - _resizeStartX, MinDataColumnWidth, MaxDataColumnWidth);
+        resultSet.Columns[_resizingColumnIndex].ManualWidth = width;
+        ApplyColumnWidth(_resizingColumnIndex, width);
+        return true;
+    }
+    public void EndColumnResize()
+    {
+        _isResizingColumn = false;
+        _resizingColumnIndex = -1;
+        _resizeStartX = 0;
+        _resizeStartWidth = 0;
     }
     public bool TryGetHeaderColumnAtPoint(Visual relativeTo, Point point, out int columnIndex, bool ignoreVerticalBounds = false)
     {
@@ -550,11 +642,29 @@ public double[] BuildColumnWidths(
 
             widths[visualIndex] = columnIndex < 0
                 ? 14
-                : Math.Clamp((maxLength * 7) + 16, 76, 210);
+                : resultSet.Columns[columnIndex].ManualWidth is { } manualWidth
+                    ? Math.Clamp(manualWidth, MinDataColumnWidth, MaxDataColumnWidth)
+                    : Math.Clamp((maxLength * 7) + 16, 76, 210);
         }
 
         return widths;
     }
+    private void ApplyColumnWidth(int columnIndex, double width)
+    {
+        if (!_columnVisualIndexes.TryGetValue(columnIndex, out int visualIndex))
+        {
+            return;
+        }
+
+        GridLength gridLength = new(width);
+        foreach (Grid grid in _scrollableGrids)
+        {
+            if (visualIndex >= 0 && visualIndex < grid.ColumnDefinitions.Count)
+            {
+                grid.ColumnDefinitions[visualIndex].Width = gridLength;
+            }
+        }
+    }
     private static int GetHeaderMeasurementLength(ResultColumnViewItem column, Func<ResultColumnViewItem, string> headerFormatter)
     {
         string rawName = string.IsNullOrWhiteSpace(column.RawName) ? column.HeaderText : column.RawName;

SqlAnalyzer.App/Views/MainWindow.axaml.cs

@@ -43,6 +43,8 @@ public partial class MainWindow : Window
 
 	private static readonly bool DiagnosticLoggingEnabled = string.Equals(Environment.GetEnvironmentVariable("SQLANALYZER_DIAGNOSTIC_LOGS"), "1", StringComparison.OrdinalIgnoreCase);
 
+	private static readonly Cursor ResultColumnResizeCursor = new(StandardCursorType.SizeWestEast);
+
 	private readonly RegistryOptions _registryOptions = new RegistryOptions(ThemeName.LightPlus);
 
 	private object? _textMateInstallation;
@@ -2845,6 +2847,11 @@ private void Window_PointerPressed(object? sender, PointerPressedEventArgs e)
 		if (selectedDocumentSelectedResultSet != null)
 		{
 			PointerPointProperties properties = e.GetCurrentPoint(this).Properties;
+			if (TryBeginResultColumnResize(e, relativeTo, position, control, selectedDocumentSelectedResultSet))
+			{
+				return;
+			}
+
 			if (properties.IsLeftButtonPressed && _resultWorkspaceController.TryGetHeaderColumnAtPoint(relativeTo, position, out var columnIndex) && columnIndex >= 0)
 			{
 				EndInlineCellEdit();
@@ -2890,17 +2897,42 @@ private void Window_PointerPressed(object? sender, PointerPressedEventArgs e)
 
 	private void Window_PointerMoved(object? sender, PointerEventArgs e)
 	{
-		if (e.KeyModifiers.HasFlag(KeyModifiers.Alt) || (!_resultWorkspaceController.IsDraggingSelection && !_resultWorkspaceController.IsDraggingCellSelection && !_resultWorkspaceController.IsDraggingHeaderSelection))
+		if (e.KeyModifiers.HasFlag(KeyModifiers.Alt))
 		{
+			ResetResultColumnResizeCursor();
 			return;
 		}
+
 		ResultSetViewItem? selectedDocumentSelectedResultSet = ViewModel.SelectedDocumentSelectedResultSet;
-		if (selectedDocumentSelectedResultSet == null || !e.GetCurrentPoint(this).Properties.IsLeftButtonPressed)
+		PointerPointProperties properties = e.GetCurrentPoint(this).Properties;
+		Visual relativeTo = ResultInteractionHost;
+		Point position = e.GetPosition(relativeTo);
+		if (_resultWorkspaceController.IsResizingColumn)
 		{
+			if (selectedDocumentSelectedResultSet == null || !properties.IsLeftButtonPressed)
+			{
+				_resultWorkspaceController.EndColumnResize();
+				ResetResultColumnResizeCursor();
+				return;
+			}
+
+			_resultWorkspaceController.UpdateColumnResize(selectedDocumentSelectedResultSet, position.X, properties.IsLeftButtonPressed);
+			ResultInteractionHost.Cursor = ResultColumnResizeCursor;
+			e.Handled = true;
 			return;
 		}
-		Visual relativeTo = ResultInteractionHost;
-		Point position = e.GetPosition(relativeTo);
+
+		if (!_resultWorkspaceController.IsDraggingSelection && !_resultWorkspaceController.IsDraggingCellSelection && !_resultWorkspaceController.IsDraggingHeaderSelection)
+		{
+			UpdateResultColumnResizeCursor(e);
+			return;
+		}
+
+		if (selectedDocumentSelectedResultSet == null || !properties.IsLeftButtonPressed)
+		{
+			return;
+		}
+
 		if (_resultWorkspaceController.IsDraggingHeaderSelection)
 		{
 			if (_resultWorkspaceController.TryGetHeaderColumnAtPoint(relativeTo, position, out var columnIndex, ignoreVerticalBounds: true) && columnIndex >= 0)
@@ -2926,13 +2958,69 @@ private void Window_PointerMoved(object? sender, PointerEventArgs e)
 
 	private void Window_PointerReleased(object? sender, PointerReleasedEventArgs e)
 	{
+		if (_resultWorkspaceController.IsResizingColumn)
+		{
+			e.Pointer.Capture(null);
+			_resultWorkspaceController.EndColumnResize();
+			ResetResultColumnResizeCursor();
+			e.Handled = true;
+			return;
+		}
+
 		if (!e.KeyModifiers.HasFlag(KeyModifiers.Alt) && (_resultWorkspaceController.IsDraggingSelection || _resultWorkspaceController.IsDraggingCellSelection || _resultWorkspaceController.IsDraggingHeaderSelection))
 		{
 			e.Pointer.Capture(null);
 			_resultWorkspaceController.EndSelection();
 		}
 	}
 
+	private bool TryBeginResultColumnResize(
+		PointerPressedEventArgs e,
+		Visual relativeTo,
+		Point position,
+		IInputElement captureTarget,
+		ResultSetViewItem resultSet)
+	{
+		PointerPointProperties properties = e.GetCurrentPoint(this).Properties;
+		if (!properties.IsLeftButtonPressed ||
+		    !_resultWorkspaceController.TryGetHeaderResizeColumnAtPoint(relativeTo, position, out int columnIndex))
+		{
+			return false;
+		}
+
+		EndInlineCellEdit();
+		e.Pointer.Capture(captureTarget);
+		_resultWorkspaceController.BeginColumnResize(resultSet, relativeTo, position, columnIndex);
+		ResultInteractionHost.Cursor = ResultColumnResizeCursor;
+		ViewModel.ClearSelectedDocumentValueDetail();
+		e.Handled = true;
+		return true;
+	}
+
+	private void UpdateResultColumnResizeCursor(PointerEventArgs e)
+	{
+		ResultSetViewItem? resultSet = ViewModel.SelectedDocumentSelectedResultSet;
+		if (resultSet == null)
+		{
+			ResetResultColumnResizeCursor();
+			return;
+		}
+
+		Visual relativeTo = ResultInteractionHost;
+		Point position = e.GetPosition(relativeTo);
+		ResultInteractionHost.Cursor = _resultWorkspaceController.TryGetHeaderResizeColumnAtPoint(relativeTo, position, out _)
+			? ResultColumnResizeCursor
+			: null;
+	}
+
+	private void ResetResultColumnResizeCursor()
+	{
+		if (!_resultWorkspaceController.IsResizingColumn && ResultInteractionHost != null)
+		{
+			ResultInteractionHost.Cursor = null;
+		}
+	}
+
 	private void CompletionListBox_KeyDown(object? sender, KeyEventArgs e)
 	{
 		if (_completionController.GetPopupKeyAction(e.Key) == CompletionController.PopupKeyAction.Commit)
@@ -4190,10 +4278,17 @@ private void ResultHeaderCell_PointerPressed(object? sender, PointerPressedEvent
 			if (selectedDocumentSelectedResultSet != null)
 			{
 				EndInlineCellEdit();
+				IInputElement captureTarget = (IInputElement?)ResultInteractionHost ?? this;
+				Visual relativeTo = ResultInteractionHost!;
+				Point position = e.GetPosition(relativeTo);
+				if (TryBeginResultColumnResize(e, relativeTo, position, captureTarget, selectedDocumentSelectedResultSet))
+				{
+					return;
+				}
+
 				PointerPointProperties properties = e.GetCurrentPoint(this).Properties;
 				if (properties.IsLeftButtonPressed)
 				{
-					IInputElement captureTarget = (IInputElement?)ResultInteractionHost ?? this;
 					e.Pointer.Capture(captureTarget);
 					_resultWorkspaceController.BeginHeaderSelection(selectedDocumentSelectedResultSet, columnIndex);
 				}