diff --git a/src/client/spark/Modules/Market/MarketView/MarketViewView.xaml.cs b/src/client/spark/Modules/Market/MarketView/MarketViewView.xaml.cs index b65b363ce..418c01ce9 100644 --- a/src/client/spark/Modules/Market/MarketView/MarketViewView.xaml.cs +++ b/src/client/spark/Modules/Market/MarketView/MarketViewView.xaml.cs @@ -138,8 +138,11 @@ namespace mbts.ui.spark { } } - void _show_popup(object content, object header) => - _show_popup(content, header, new AuxiliaryDataResources()); + void _show_popup(object content, object header) { + var resources = new AuxiliaryDataResources(); + resources.MergedDictionaries.Add(new AutoHideScrollbarResources()); + _show_popup(content, header, resources); + } void _show_popup(object content, object header, ResourceDictionary resources) { var view = new HeaderedContentControl { diff --git a/src/client/spark/view/Controls/Adorners/DIYGridCellHoverAdorner.cs b/src/client/spark/view/Controls/Adorners/DIYGridCellHoverAdorner.cs index 480fb9f26..e39a2d9f5 100644 --- a/src/client/spark/view/Controls/Adorners/DIYGridCellHoverAdorner.cs +++ b/src/client/spark/view/Controls/Adorners/DIYGridCellHoverAdorner.cs @@ -1,126 +1,136 @@ -using mbts.ui.dpi; -using mbts.ui.extensions; -using System; -using System.Linq; -using System.Windows; -using System.Windows.Controls; -using System.Windows.Media; - -namespace mbts.ui.controls.adorners { - class DIYGridCellHoverAdorner : Adorner, IDisposable { - Brush _row_fill, _cell_fill; - Pen _row_stroke, _cell_stroke; - - DIYGridRowsPresenter _rows_presenter; - ScrollViewer _scroll_viewer; - ScrollContentPresenter _scroll_content_backing; - DIYGrid _grid; - IDisposable _dispose; - DIYGrid.CellGeometry? _hover_cell; - AdornerHost _menu_host = null; - ActionMenu _menu => _menu_host.Child as ActionMenu; - - #region RowFill - public static readonly DependencyProperty RowFillProperty = - WPFHelper.create_dp( - nameof(RowFill), - FrameworkPropertyMetadataOptions.AffectsRender, - (o, v) => o._row_fill = v, - FrozenBrushCache.get_brush(DIYGrid.DefaultSelectionHighlight)); - - public SolidColorBrush RowFill { - get => GetValue(RowFillProperty) as SolidColorBrush; - set => SetValue(RowFillProperty, value); - } - #endregion - - #region RowStroke - public static readonly DependencyProperty RowStrokeProperty = - WPFHelper.create_dp( - nameof(RowStroke), - FrameworkPropertyMetadataOptions.AffectsRender, - (o, v) => o._row_stroke = v); - - public Pen RowStroke { - get => GetValue(RowStrokeProperty) as Pen; - set => SetValue(RowStrokeProperty, value); - } - #endregion - - #region CellFill - public static readonly DependencyProperty CellFillProperty = - WPFHelper.create_dp( - nameof(CellFill), - FrameworkPropertyMetadataOptions.AffectsRender, - (o, v) => o._cell_fill = v); - - public SolidColorBrush CellFill { - get => GetValue(CellFillProperty) as SolidColorBrush; - set => SetValue(CellFillProperty, value); - } - #endregion - - #region CellStroke - public static readonly DependencyProperty CellStrokeProperty = - WPFHelper.create_dp( - nameof(CellStroke), - FrameworkPropertyMetadataOptions.AffectsRender, - (o, v) => o._cell_stroke = v); - - public Pen CellStroke { - get => GetValue(CellStrokeProperty) as Pen; - set => SetValue(CellStrokeProperty, value); - } - #endregion - - public DIYGridCellHoverAdorner(DIYGridRowsPresenter adorned_element, ScrollViewer scroll_viewer) - : base(adorned_element) { - _row_fill = RowFill; - _row_stroke = RowStroke; - _cell_fill = CellFill; - _cell_stroke = CellStroke; - _scroll_viewer = scroll_viewer; - IsHitTestVisible = false; - _rows_presenter = adorned_element; - - _grid = _rows_presenter.find_ancestor_of_type(); - _dispose = Disposable.Create( - _grid.SubscribeMouseHoverCell().Subscribe(cell => { - _hover_cell = cell; - if (_hover_cell.HasValue) { - var (row, col) = _hover_cell.Value; - var row_tl = row.TranslatePoint(default, this); - } - InvalidateVisual(); - })); - } - - ScrollContentPresenter _scroll_content => - _scroll_content_backing ?? (_scroll_content_backing = _scroll_viewer.descendants_of_type().FirstOrDefault()); - - protected override void OnRender(DrawingContext drawingContext) { - base.OnRender(drawingContext); - if (_hover_cell.HasValue) { - (var row, var cell) = _hover_cell.Value; - if (row != null) { - var row_tl = new Lazy(() => row.TranslatePoint(default, this)); - if (_row_fill != null || _row_stroke != null) { - var row_rect = new Rect(row_tl.Value, row.RenderSize); - if (_scroll_content != null) { - var content_bounds = this.GetChildBounds(_scroll_content); - row_rect.Intersect(content_bounds); - } - drawingContext.DrawRectangle(_row_fill, _row_stroke, row_rect, true); - } - if (_cell_fill != null || _cell_stroke != null) { - var cell_rect = cell.to_visible_rect(row.ActualHeight, row_tl.Value.Y); - drawingContext.DrawRectangle(_cell_fill, _cell_stroke, cell_rect, true); - } - } - } - } - - public void Dispose() => - Disposable.dispose(ref _dispose); - } -} +using mbts.ui.dpi; +using mbts.ui.extensions; +using System; +using System.Linq; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Documents; +using System.Windows.Media; + +namespace mbts.ui.controls.adorners { + class DIYGridCellHoverAdorner : Adorner, IDisposable { + Brush _row_fill, _cell_fill; + Pen _row_stroke, _cell_stroke; + + ScrollViewer _scroll_viewer; + ScrollContentPresenter _scroll_content; + DIYGrid _grid; + IDisposable _dispose; + DIYGrid.CellGeometry? _hover_cell; + AdornerHost _menu_host = null; + ActionMenu _menu => _menu_host.Child as ActionMenu; + + #region RowFill + public static readonly DependencyProperty RowFillProperty = + WPFHelper.create_dp( + nameof(RowFill), + FrameworkPropertyMetadataOptions.AffectsRender, + (o, v) => o._row_fill = v, + FrozenBrushCache.get_brush(DIYGrid.DefaultSelectionHighlight)); + + public SolidColorBrush RowFill { + get => GetValue(RowFillProperty) as SolidColorBrush; + set => SetValue(RowFillProperty, value); + } + #endregion + + #region RowStroke + public static readonly DependencyProperty RowStrokeProperty = + WPFHelper.create_dp( + nameof(RowStroke), + FrameworkPropertyMetadataOptions.AffectsRender, + (o, v) => o._row_stroke = v); + + public Pen RowStroke { + get => GetValue(RowStrokeProperty) as Pen; + set => SetValue(RowStrokeProperty, value); + } + #endregion + + #region CellFill + public static readonly DependencyProperty CellFillProperty = + WPFHelper.create_dp( + nameof(CellFill), + FrameworkPropertyMetadataOptions.AffectsRender, + (o, v) => o._cell_fill = v); + + public SolidColorBrush CellFill { + get => GetValue(CellFillProperty) as SolidColorBrush; + set => SetValue(CellFillProperty, value); + } + #endregion + + #region CellStroke + public static readonly DependencyProperty CellStrokeProperty = + WPFHelper.create_dp( + nameof(CellStroke), + FrameworkPropertyMetadataOptions.AffectsRender, + (o, v) => o._cell_stroke = v); + + public Pen CellStroke { + get => GetValue(CellStrokeProperty) as Pen; + set => SetValue(CellStrokeProperty, value); + } + #endregion + + public DIYGridCellHoverAdorner(ListBox list_box, ScrollViewer scroll_viewer) + : this(list_box, scroll_viewer, list_box.descendants_of_type().FirstOrDefault()) { } + + /// + /// Create an instance of the class. + /// + /// + /// + /// + /// The actual AdornedElement (the ScrollViewer may clip the ScrollContentPresenter, and the most prudent way to reflect such a clip is to use it as the actual AdornedElement). + /// + public DIYGridCellHoverAdorner(ListBox list_box, ScrollViewer scroll_viewer, ScrollContentPresenter scroll_content) + : base(scroll_content) { + _row_fill = RowFill; + _row_stroke = RowStroke; + _cell_fill = CellFill; + _cell_stroke = CellStroke; + _scroll_viewer = scroll_viewer; + _scroll_content = scroll_content; + IsHitTestVisible = false; + // reflect AdornedElement's clip + IsClipEnabled = true; + + _grid = list_box.find_ancestor_of_type(); + _dispose = Disposable.Create( + _grid.SubscribeMouseHoverCell().Subscribe(cell => { + _hover_cell = cell; + if (_hover_cell.HasValue) { + var (row, col) = _hover_cell.Value; + var row_tl = row.TranslatePoint(default, this); + } + InvalidateVisual(); + })); + } + + protected override void OnRender(DrawingContext drawingContext) { + base.OnRender(drawingContext); + if (_hover_cell.HasValue) { + (var row, var cell) = _hover_cell.Value; + if (row != null) { + var row_tl = new Lazy(() => row.TranslatePoint(default, this)); + if (_row_fill != null || _row_stroke != null) { + var row_rect = new Rect(row_tl.Value, row.RenderSize); + if (_scroll_content != null) { + var content_bounds = this.GetChildBounds(_scroll_content); + row_rect.Intersect(content_bounds); + } + drawingContext.DrawRectangle(_row_fill, _row_stroke, row_rect, true); + } + if (_cell_fill != null || _cell_stroke != null) { + var cell_rect = cell.to_visible_rect(row.ActualHeight, row_tl.Value.Y); + drawingContext.DrawRectangle(_cell_fill, _cell_stroke, cell_rect, true); + } + } + } + } + + public void Dispose() => + Disposable.dispose(ref _dispose); + } +} diff --git a/src/client/spark/view/Controls/Adorners/RowSelectionAdorner.cs b/src/client/spark/view/Controls/Adorners/RowSelectionAdorner.cs index 7275bb02e..92f9fb516 100644 --- a/src/client/spark/view/Controls/Adorners/RowSelectionAdorner.cs +++ b/src/client/spark/view/Controls/Adorners/RowSelectionAdorner.cs @@ -8,13 +8,11 @@ using System.Windows.Documents; using System.Windows.Media; namespace mbts.ui.controls.adorners { - class RowSelectionAdorner : Adorner, IDisposable { + class RowSelectionAdorner : Adorner, IDisposable { Brush _fill; Pen _stroke; - - DIYGridRowsPresenter _diy_rp; + ListBox _diy_rp; ScrollViewer _diy_scroll; - ScrollContentPresenter _diy_scp; List _disposables = new List(); #region Fill @@ -45,15 +43,28 @@ namespace mbts.ui.controls.adorners { } #endregion - public RowSelectionAdorner(DIYGridRowsPresenter adorned_element, ScrollViewer scroll_viewer) : base(adorned_element) { + public RowSelectionAdorner(ListBox list_box, ScrollViewer scroll_viewer) + : this(list_box, scroll_viewer, list_box.descendants_of_type().FirstOrDefault()) { } + + /// + /// Create an instance of the class. + /// + /// + /// + /// + /// The actual AdornedElement (the ScrollViewer may clip the ScrollContentPresenter, and the most prudent way to reflect such a clip is to use it as the actual AdornedElement). + /// + public RowSelectionAdorner(ListBox list_box, ScrollViewer scroll_viewer, ScrollContentPresenter scroll_presenter) + : base(scroll_presenter) { _fill = Fill; _stroke = Stroke; // we want our clicks to go through to the underlying grid IsHitTestVisible = false; + // reflect the AdornedElement's clip + IsClipEnabled = true; - _diy_rp = adorned_element; + _diy_rp = list_box; _diy_scroll = scroll_viewer; - _diy_scp = _diy_rp.descendants_of_type().empty_if_null().FirstOrDefault(); // We actually don't need mouse up/down or key up/down when we can just respond to selection changes _disposables.Add(((System.Windows.Controls.Primitives.Selector)_diy_rp).SubscribeSelectionChanged((s, e) => InvalidateVisual())); @@ -63,22 +74,22 @@ namespace mbts.ui.controls.adorners { protected override void OnRender(DrawingContext drawingContext) { base.OnRender(drawingContext); - if (AdornedElement is ListBox lb && lb.SelectedItems != null && lb.SelectedItems.Count > 0) { - foreach(var lbi in lb.SelectedItems) { + if (_diy_rp.SelectedItems != null && _diy_rp.SelectedItems.Count > 0) { + foreach(var lbi in _diy_rp.SelectedItems) { if (_diy_rp.ItemContainerGenerator.ContainerFromItem(lbi) is FrameworkElement row && row.IsVisible) { - var top_left = lb.GetChildTopLeft(row); + var top_left = _diy_rp.GetChildTopLeft(row); var top_is_within_bounds = top_left.Y >= 0; // Note that the top of the row can still technically be visible but we wont show // the adorner rectangle b/c the bottom of the row will be obscured by the scrollbar - var bottom_is_within_bounds = lb.GetChildBounds(row).BottomRight.Y <= _diy_scroll.ActualHeight; + var bottom_is_within_bounds = _diy_rp.GetChildBounds(row).BottomRight.Y <= _diy_scroll.ActualHeight; if (top_is_within_bounds && bottom_is_within_bounds) { // we use the scroll content presenter in the X point calculation instead of the row // because of the OB which has a right side panel that takes up some space over // row width drawingContext.DrawRectangle(_fill, _stroke, - new Rect(top_left, new Point(top_left.X + _diy_scp.ActualWidth, top_left.Y + row.ActualHeight))); + new Rect(top_left, new Point(top_left.X + AdornedElement.RenderSize.Width, top_left.Y + row.ActualHeight))); } } } diff --git a/src/client/spark/view/Controls/AutoHideScrollBar/AutoHideScrollBar.xaml b/src/client/spark/view/Controls/AutoHideScrollBar/AutoHideScrollBar.xaml new file mode 100644 index 000000000..91d68c1e5 --- /dev/null +++ b/src/client/spark/view/Controls/AutoHideScrollBar/AutoHideScrollBar.xaml @@ -0,0 +1,493 @@ + + 5 + 5 + + #FFCDCDCD + #FFA6A6A6 + #FF606060 + + #FFF0F0F0 + #FFDADADA + #FF606060 + #FF606060 + #FF000000 + #FFFFFFFF + #FFBFBFBF + + #FFF0F0F0 + + + M0,4C0,4 0,6 0,6 0,6 3.5,2.5 3.5,2.5 3.5,2.5 7,6 7,6 7,6 7,4 7,4 7,4 3.5,0.5 3.5,0.5 3.5,0.5 0,4 0,4z + + + + M0,2.5C0,2.5 0,0.5 0,0.5 0,0.5 3.5,4 3.5,4 3.5,4 7,0.5 7,0.5 7,0.5 7,2.5 7,2.5 7,2.5 3.5,6 3.5,6 3.5,6 0,2.5 0,2.5z + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/client/spark/view/Controls/AutoHideScrollBar/AutoHideScrollBar.xaml.cs b/src/client/spark/view/Controls/AutoHideScrollBar/AutoHideScrollBar.xaml.cs new file mode 100644 index 000000000..91e063520 --- /dev/null +++ b/src/client/spark/view/Controls/AutoHideScrollBar/AutoHideScrollBar.xaml.cs @@ -0,0 +1,80 @@ +using mbts.ui.converters; +using mbts.ui.extensions; +using System; +using System.Windows; +using System.Windows.Controls.Primitives; +using System.Windows.Data; +using System.Windows.Media; + +namespace mbts.ui.controls { + partial class AutoHideScrollbarResources : ResourceDictionary { + public AutoHideScrollbarResources() => + InitializeComponent(); + } + + class AutoHideScrollBar : ScrollBar { + IDisposable _hooks; + + public static IMultiValueConverter ScrollContentClipConverter = + ValueConverter.create( + (scroll_bar_width, scroll_bar_height, content_width, content_height) => + new RectangleGeometry( + new Rect(new Size( + Math.Max(0, content_width - DoubleHelper.CoerceNaN(scroll_bar_width, 0)), + Math.Max(0, content_height - DoubleHelper.CoerceNaN(scroll_bar_height, 0)))))); + + #region VisibleWidth + static readonly DependencyPropertyKey VisibleWidthPropertyKey = + DependencyProperty.RegisterAttachedReadOnly( + nameof(VisibleWidth), + typeof(double), + typeof(AutoHideScrollBar), + new PropertyMetadata(double.NaN, null, CoerceVisibleWidth)); + + static object CoerceVisibleWidth(DependencyObject d, object baseValue) => + (d as AutoHideScrollBar)?.Track?.ActualWidth ?? baseValue; + + public static readonly DependencyProperty VisibleWidthProperty = + VisibleWidthPropertyKey.DependencyProperty; + + public double VisibleWidth { + get => (double)GetValue(VisibleWidthProperty); + private set => SetValue(VisibleWidthPropertyKey, value); + } + #endregion + + #region VisibleHeight + static readonly DependencyPropertyKey VisibleHeightPropertyKey = + DependencyProperty.RegisterAttachedReadOnly( + nameof(VisibleHeight), + typeof(double), + typeof(AutoHideScrollBar), + new PropertyMetadata(double.NaN, null, CoerceVisibleHeight)); + + static object CoerceVisibleHeight(DependencyObject d, object baseValue) => + (d as AutoHideScrollBar)?.Track?.ActualHeight ?? baseValue; + + public static readonly DependencyProperty VisibleHeightProperty = + VisibleHeightPropertyKey.DependencyProperty; + + public double VisibleHeight { + get => (double)GetValue(VisibleHeightProperty); + private set => SetValue(VisibleHeightPropertyKey, value); + } + #endregion + + public override void OnApplyTemplate() { + Disposable.dispose(ref _hooks); + /// call base method first to ensure is initialized. + base.OnApplyTemplate(); + _hooks = Track.SubscribeSizeChanged((s, e) => { + if (e.WidthChanged) + CoerceValue(VisibleWidthProperty); + if (e.HeightChanged) + CoerceValue(VisibleHeightProperty); + }); + CoerceValue(VisibleWidthProperty); + CoerceValue(VisibleHeightProperty); + } + } +} diff --git a/src/client/spark/view/Controls/DIYGrid/DIYGrid.cs b/src/client/spark/view/Controls/DIYGrid/DIYGrid.cs index 7e2f0079c..a3a86052c 100644 --- a/src/client/spark/view/Controls/DIYGrid/DIYGrid.cs +++ b/src/client/spark/view/Controls/DIYGrid/DIYGrid.cs @@ -363,7 +363,8 @@ namespace mbts.ui.controls { HorizontalAlignment = HorizontalAlignment.Left, VerticalAlignment = VerticalAlignment.Top, StrokeThickness = HighDpiExtensions.pixel_unit - } + }, + IsClipEnabled = true }; _drag_rect_adorner.Child.bind(Shape.FillProperty, _highlight_path, DIYGrid.SelectionHighlightBrushConverter, _grid); _drag_rect_adorner.Child.bind(Shape.StrokeProperty, _highlight_path, DIYGrid.SelectionHighlightOpaqueBrushConverter, _grid);