path: root/Software/Visual_Studio/Tango.Touch/Controls/LightTouchScrollViewer.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using Tango.Core.EventArguments;
using Tango.DragAndDrop;

namespace Tango.Touch.Controls
{
    public class LightTouchScrollViewer : ContentControl
    {
        private Border _border_viewport;
        private Grid _grid_content;
        private Point _mouse_down_location;
        private List<double> _last_manipulation_deltas;
        private const double touch_inertia_coefficiant = 10;
        private const double bounce_offset_max = 100;
        private Thumb _thumb;
        private Border _border_thumb;
        private TouchDevice _moveTouchDevice;

        #region Properties


        /// <summary>
        /// Gets or sets the scroll bar margins.
        /// </summary>
        public Thickness ScrollBarMargin
        {
            get { return (Thickness)GetValue(ScrollBarMarginProperty); }
            set { SetValue(ScrollBarMarginProperty, value); }
        }
        public static readonly DependencyProperty ScrollBarMarginProperty =
            DependencyProperty.Register("ScrollBarMargin", typeof(Thickness), typeof(LightTouchScrollViewer), new PropertyMetadata(new Thickness()));


        /// <summary>
        /// Gets or sets a value indicating whether the data grid is currently scrolling.
        /// </summary>
        public bool IsScrolling
        {
            get { return (bool)GetValue(IsScrollingProperty); }
            set { SetValue(IsScrollingProperty, value); }
        }
        public static readonly DependencyProperty IsScrollingProperty =
            DependencyProperty.Register("IsScrolling", typeof(bool), typeof(LightTouchScrollViewer), new PropertyMetadata(false));


        /// <summary>
        /// Gets or sets a value indicating whether this instance is mouse touch down.
        /// </summary>
        public bool IsMouseTouchDown
        {
            get { return (bool)GetValue(IsMouseTouchDownProperty); }
            set { SetValue(IsMouseTouchDownProperty, value); }
        }
        public static readonly DependencyProperty IsMouseTouchDownProperty =
            DependencyProperty.Register("IsMouseTouchDown", typeof(bool), typeof(LightTouchScrollViewer), new PropertyMetadata(false));

        /// <summary>
        /// Gets or sets the width of the scroll bar.
        /// </summary>
        /// <value>
        /// The width of the scroll bar.
        /// </value>
        public double ScrollBarWidth
        {
            get { return (double)GetValue(ScrollBarWidthProperty); }
            set { SetValue(ScrollBarWidthProperty, value); }
        }
        public static readonly DependencyProperty ScrollBarWidthProperty =
            DependencyProperty.Register("ScrollBarWidth", typeof(double), typeof(LightTouchScrollViewer), new PropertyMetadata(5.0));

        /// <summary>
        /// Gets or sets the scroll bar background.
        /// </summary>
        public Brush ScrollBarBackground
        {
            get { return (Brush)GetValue(ScrollBarBackgroundProperty); }
            set { SetValue(ScrollBarBackgroundProperty, value); }
        }
        public static readonly DependencyProperty ScrollBarBackgroundProperty =
            DependencyProperty.Register("ScrollBarBackground", typeof(Brush), typeof(LightTouchScrollViewer), new PropertyMetadata(null));

        /// <summary>
        /// Gets or sets the scroll bar foreground.
        /// </summary>
        public Brush ScrollBarForeground
        {
            get { return (Brush)GetValue(ScrollBarForegroundProperty); }
            set { SetValue(ScrollBarForegroundProperty, value); }
        }
        public static readonly DependencyProperty ScrollBarForegroundProperty =
            DependencyProperty.Register("ScrollBarForeground", typeof(Brush), typeof(LightTouchScrollViewer), new PropertyMetadata(null));

        /// <summary>
        /// Gets or sets the scroll bar corner radius.
        /// </summary>
        public CornerRadius ScrollBarCornerRadius
        {
            get { return (CornerRadius)GetValue(ScrollBarCornerRadiusProperty); }
            set { SetValue(ScrollBarCornerRadiusProperty, value); }
        }
        public static readonly DependencyProperty ScrollBarCornerRadiusProperty =
            DependencyProperty.Register("ScrollBarCornerRadius", typeof(CornerRadius), typeof(LightTouchScrollViewer), new PropertyMetadata(default(CornerRadius)));

        /// <summary>
        /// Gets or sets the size of the top arc.
        /// </summary>
        public Size TopArcSize
        {
            get { return (Size)GetValue(TopArcSizeProperty); }
            set { SetValue(TopArcSizeProperty, value); }
        }
        public static readonly DependencyProperty TopArcSizeProperty =
            DependencyProperty.Register("TopArcSize", typeof(Size), typeof(LightTouchScrollViewer), new PropertyMetadata(default(Size)));

        /// <summary>
        /// Gets or sets the size of the bottom arc.
        /// </summary>
        public Size BottomArcSize
        {
            get { return (Size)GetValue(BottomArcSizeProperty); }
            set { SetValue(BottomArcSizeProperty, value); }
        }
        public static readonly DependencyProperty BottomArcSizeProperty =
            DependencyProperty.Register("BottomArcSize", typeof(Size), typeof(LightTouchScrollViewer), new PropertyMetadata(default(Size)));

        #endregion

        #region Constructors

        public LightTouchScrollViewer()
        {
            _last_manipulation_deltas = new List<double>();
        }

        static LightTouchScrollViewer()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(LightTouchScrollViewer), new FrameworkPropertyMetadata(typeof(LightTouchScrollViewer)));
        }

        #endregion

        #region Apply Template

        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();

            _border_viewport = GetTemplateChild("PART_Border") as Border;
            _grid_content = GetTemplateChild("PART_Grid_Content") as Grid;
            _thumb = GetTemplateChild("PART_Thumb") as Thumb;
            _border_thumb = GetTemplateChild("PART_Thumb_Border") as Border;

            ContentPresenter presenter = GetTemplateChild("PART_Content_Presenter") as ContentPresenter;

            _border_viewport.RegisterForMouseOrTouchDown(OnMouseTouchDown);
            _border_viewport.RegisterForMouseOrTouchMove(OnMouseTouchMove);
            _border_viewport.RegisterForPreviewMouseOrTouchUp(OnMouseTouchUp);

            _border_viewport.ManipulationDelta += _grid_rows_ManipulationDelta;
            _border_viewport.ManipulationCompleted += _grid_rows_ManipulationCompleted;

            _thumb.DragDelta += _thumb_DragDelta;
            _thumb.DragStarted += _thumb_DragStarted;
            _thumb.DragCompleted += _thumb_DragCompleted;
        }

        private void _thumb_DragCompleted(object sender, DragCompletedEventArgs e)
        {
            IsScrolling = false;
        }

        private void _thumb_DragStarted(object sender, DragStartedEventArgs e)
        {
            IsScrolling = true;
        }

        private void _thumb_DragDelta(object sender, DragDeltaEventArgs e)
        {
            var step = CalculateScrollbarThumbStep();

            double content_margin = _grid_content.Margin.Top + -(step * e.VerticalChange);

            _grid_content.BeginAnimation(Grid.MarginProperty, null);

            Canvas.SetTop(_border_thumb, Canvas.GetTop(_border_thumb) + e.VerticalChange);
            _grid_content.Margin = new Thickness(0, content_margin, 0, 0);

            if (content_margin > 0)
            {
                Canvas.SetTop(_border_thumb, 0);
                _grid_content.Margin = new Thickness(0, 0, 0, 0);
            }
            else if (content_margin - _border_viewport.ActualHeight < -_grid_content.ActualHeight)
            {
                Canvas.SetTop(_border_thumb, _border_viewport.ActualHeight - _border_thumb.ActualHeight);
                _grid_content.Margin = new Thickness(0, -(_grid_content.ActualHeight - _border_viewport.ActualHeight), 0, 0);
            }
        }

        #endregion

        #region Touch Manipulation Handlers

        /// <summary>
        /// Handles the ManipulationCompleted event of the _grid_rows control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="ManipulationCompletedEventArgs"/> instance containing the event data.</param>
        private void _grid_rows_ManipulationCompleted(object sender, ManipulationCompletedEventArgs e)
        {
            _border_viewport.IsManipulationEnabled = false;

            ReleaseMouseTouchCapture();

            e.Cancel();

            if (_last_manipulation_deltas.Count == 0) return;

            var last_manipulation_delta = _last_manipulation_deltas.Last();

            if (last_manipulation_delta == 0 && _last_manipulation_deltas.Count > 1)
            {
                last_manipulation_delta = _last_manipulation_deltas[_last_manipulation_deltas.Count - 2];
            }

            if (last_manipulation_delta != 0)
            {
                var to = (_grid_content.Margin.Top + (last_manipulation_delta * touch_inertia_coefficiant));

                if (to > 0)
                {
                    to = Math.Min(to, bounce_offset_max);
                }
                else
                {
                    to = Math.Max(to, bounce_offset_max + -(_grid_content.ActualHeight - _border_viewport.ActualHeight));
                }

                bool bounced = false;

                ThicknessAnimation ani = new ThicknessAnimation();
                ani.Duration = TimeSpan.FromSeconds(1);
                ani.To = new Thickness(0, to, 0, 0);
                ani.CurrentTimeInvalidated += (_, __) =>
                {
                    if (!bounced)
                    {
                        if (_grid_content.Margin.Top > 0 || (_grid_content.Margin.Top - _border_viewport.ActualHeight < -_grid_content.ActualHeight))
                        {
                            bounced = true;
                            SnapContentToBounds();
                        }
                    }

                    SetThumbPosition();
                };
                ani.DecelerationRatio = 1.0;
                _grid_content.BeginAnimation(Grid.MarginProperty, ani);
                _last_manipulation_deltas.Clear();
            }
        }

        /// <summary>
        /// Handles the ManipulationDelta event of the _grid_rows control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="ManipulationDeltaEventArgs"/> instance containing the event data.</param>
        private void _grid_rows_ManipulationDelta(object sender, ManipulationDeltaEventArgs e)
        {
            _last_manipulation_deltas.Add(e.DeltaManipulation.Translation.Y);
        }

        #endregion

        #region Touch / Mouse Handlers

        /// <summary>
        /// Called when the mouse touch has been down
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="MouseOrTouchEventArgs"/> instance containing the event data.</param>
        protected virtual void OnMouseTouchDown(object sender, MouseOrTouchEventArgs e)
        {
            if (e.OriginalSource.GetType() == typeof(DragThumb))
            {
                return;
            }

            _mouse_down_location = new Point(e.Location.X, e.Location.Y - _grid_content.Margin.Top);
            IsMouseTouchDown = true;
        }

        /// <summary>
        /// Called when the mouse touch has been move
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="MouseOrTouchEventArgs"/> instance containing the event data.</param>
        protected virtual void OnMouseTouchMove(object sender, MouseOrTouchEventArgs e)
        {
            var a = _mouse_down_location.Y + _grid_content.Margin.Top;

            if (IsMouseTouchDown && Math.Abs((e.Location.Y - a)) > 10)
            {
                if (!IsScrolling)
                {
                    _border_viewport.IsManipulationEnabled = true;

                    IsScrolling = true;
                    Mouse.Capture(_border_viewport);

                    if (e.TouchDevice != null)
                    {
                        _moveTouchDevice = e.TouchDevice;
                        e.TouchDevice.Capture(_border_viewport);
                    }
                }

                _grid_content.Margin = new Thickness(0, e.Location.Y - _mouse_down_location.Y, 0, 0);
                _grid_content.BeginAnimation(Grid.MarginProperty, null);

                double bottom_offset = -(_grid_content.ActualHeight - (_border_viewport.ActualHeight + -_grid_content.Margin.Top));

                if (_grid_content.Margin.Top > 0)
                {
                    BeginAnimation(TopArcSizeProperty, null);
                    TopArcSize = new Size(250, Math.Min(_grid_content.Margin.Top / 15, 100));
                }
                else if (bottom_offset > 0)
                {
                    BeginAnimation(BottomArcSizeProperty, null);
                    BottomArcSize = new Size(250, Math.Min(bottom_offset / 15, 100));
                }

                SetThumbPosition();
            }
        }

        /// <summary>
        /// Called when the mouse touch has been up
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="MouseOrTouchEventArgs"/> instance containing the event data.</param>
        protected virtual void OnMouseTouchUp(object sender, MouseOrTouchEventArgs e)
        {
            if (IsMouseTouchDown)
            {
                IsMouseTouchDown = false;

                if (IsScrolling)
                {
                    ReleaseMouseTouchCapture();
                    e.Handled = true;
                    SnapContentToBounds();
                }

                IsScrolling = false;
            }
        }

        #endregion

        #region Private Methods

        /// <summary>
        /// Snaps the content if it's out of bounds.
        /// </summary>
        private void SnapContentToBounds()
        {
            ThicknessAnimation ani = new ThicknessAnimation();
            ani.Duration = TimeSpan.FromSeconds(0.2);
            ani.AccelerationRatio = 1;

            SizeAnimation sizeAni = new SizeAnimation();
            sizeAni.Duration = TimeSpan.FromSeconds(0.2);
            sizeAni.AccelerationRatio = 1;
            sizeAni.To = new Size(250, 0);

            BeginAnimation(TopArcSizeProperty, sizeAni);
            BeginAnimation(BottomArcSizeProperty, sizeAni);

            if (_grid_content.Margin.Top > 0 || _grid_content.ActualHeight < _border_viewport.ActualHeight)
            {
                ani.To = new Thickness(0);
                _grid_content.BeginAnimation(Grid.MarginProperty, ani);
            }
            else if (_grid_content.Margin.Top - _border_viewport.ActualHeight < -_grid_content.ActualHeight)
            {
                ani.To = new Thickness(0, -(_grid_content.ActualHeight - _border_viewport.ActualHeight), 0, 0);
                _grid_content.BeginAnimation(Grid.MarginProperty, ani);
            }
        }

        private double CalculateScrollbarThumbStep()
        {
            var scrollTrackSpace = _grid_content.ActualHeight - _border_viewport.ActualHeight;
            var scrollThumbSpace = _border_viewport.ActualHeight - _thumb.ActualHeight;
            var scrollJump = scrollTrackSpace / scrollThumbSpace;
            return scrollJump;
        }

        private void SetThumbPosition()
        {
            double step = CalculateScrollbarThumbStep();

            if (step != 0)
            {
                double content_margin = _grid_content.Margin.Top;
                double thumb_top = -(content_margin / step);

                Canvas.SetTop(_border_thumb, thumb_top);

                if (thumb_top < 0)
                {
                    Canvas.SetTop(_border_thumb, 0);
                }
                else if (thumb_top + _border_thumb.ActualHeight > _border_viewport.ActualHeight)
                {
                    Canvas.SetTop(_border_thumb, _border_viewport.ActualHeight - _border_thumb.ActualHeight);
                }
            }
        }

        private void ReleaseMouseTouchCapture()
        {
            Mouse.Capture(null);
            _border_viewport.ReleaseMouseCapture();
            _border_viewport.ReleaseAllTouchCaptures();

            if (_moveTouchDevice != null)
            {
                _border_viewport.ReleaseTouchCapture(_moveTouchDevice);
                _moveTouchDevice = null;
            }
        }

        #endregion

        #region Public Methods

        public void ScrollToElement(FrameworkElement element)
        {
            if (element != null)
            {
                var e = this.FindVisualChildren<FrameworkElement>().SingleOrDefault(x => x == element);

                if (e != null)
                {
                    var location = e.TranslatePoint(new Point(0, 0), _grid_content);
                    Rect elementRect = new Rect(location, new Size(e.ActualWidth, e.ActualHeight));
                    Rect viewPortRect = new Rect(0, 0, _border_viewport.ActualWidth, _border_viewport.ActualHeight);
                    ScrollToPosition((location.Y - (viewPortRect.Height / 2)) + (elementRect.Height / 2));
                }
            }
        }

        public void ScrollToTop()
        {
            _grid_content.Margin = new Thickness(0);
        }

        public void ScrollToPosition(double y)
        {
            if (_grid_content.ActualHeight > _border_viewport.ActualHeight)
            {
                if (y < 0)
                {
                    y = 0;
                }
                if (-y - _border_viewport.ActualHeight < -_grid_content.ActualHeight)
                {
                    y = (_grid_content.ActualHeight - _border_viewport.ActualHeight);
                }

                _grid_content.BeginAnimation(Grid.MarginProperty, null);

                _grid_content.Margin = new Thickness(0, -y, 0, 0);
            }

            SnapContentToBounds();
        }

        #endregion
    }
}