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

using System;
using System.Collections;
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.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Threading;
using Tango.Core.EventArguments;

namespace Tango.Touch.Controls
{
    public class TouchNotificationBar : ContentControl
    {
        private bool _isMouseDown;
        private Point _mouseDownLocation;
        private bool _isMoving;
        private Point _downLocation;
        private TouchDevice _touchDevice;
        private double _last_manipulation_delta;
        private DateTime _last_delta_measure_time;
        private double _last_mouse_y;


        private Border border_notifications;
        private Grid grid_container;

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

        public String ItemExpandedPropertyPath
        {
            get { return (String)GetValue(ItemExpandedPropertyPathProperty); }
            set { SetValue(ItemExpandedPropertyPathProperty, value); }
        }
        public static readonly DependencyProperty ItemExpandedPropertyPathProperty =
            DependencyProperty.Register("ItemExpandedPropertyPath", typeof(String), typeof(TouchNotificationBar), new PropertyMetadata(null));

        public double MinNotificationHeight
        {
            get { return (double)GetValue(MinNotificationHeightProperty); }
            set { SetValue(MinNotificationHeightProperty, value); }
        }
        public static readonly DependencyProperty MinNotificationHeightProperty =
            DependencyProperty.Register("MinNotificationHeight", typeof(double), typeof(TouchNotificationBar), new PropertyMetadata(60.0));

        public double MaxNotificationHeight
        {
            get { return (double)GetValue(MaxNotificationHeightProperty); }
            set { SetValue(MaxNotificationHeightProperty, value); }
        }
        public static readonly DependencyProperty MaxNotificationHeightProperty =
            DependencyProperty.Register("MaxNotificationHeight", typeof(double), typeof(TouchNotificationBar), new PropertyMetadata(100.0));

        public Thickness NotificationPadding
        {
            get { return (Thickness)GetValue(NotificationPaddingProperty); }
            set { SetValue(NotificationPaddingProperty, value); }
        }
        public static readonly DependencyProperty NotificationPaddingProperty =
            DependencyProperty.Register("NotificationPadding", typeof(Thickness), typeof(TouchNotificationBar), new PropertyMetadata(new Thickness(0)));

        public bool HasNotifications
        {
            get { return (bool)GetValue(HasNotificationsProperty); }
            set { SetValue(HasNotificationsProperty, value); }
        }
        public static readonly DependencyProperty HasNotificationsProperty =
            DependencyProperty.Register("HasNotifications", typeof(bool), typeof(TouchNotificationBar), new PropertyMetadata(false, (d, e) => (d as TouchNotificationBar).OnHasNotificationsChanged()));

        public IList Notifications
        {
            get { return (IList)GetValue(NotificationsProperty); }
            set { SetValue(NotificationsProperty, value); }
        }
        public static readonly DependencyProperty NotificationsProperty =
            DependencyProperty.Register("Notifications", typeof(IList), typeof(TouchNotificationBar), new PropertyMetadata(null));

        public DataTemplate NotificationTemplate
        {
            get { return (DataTemplate)GetValue(NotificationTemplateProperty); }
            set { SetValue(NotificationTemplateProperty, value); }
        }
        public static readonly DependencyProperty NotificationTemplateProperty =
            DependencyProperty.Register("NotificationTemplate", typeof(DataTemplate), typeof(TouchNotificationBar), new PropertyMetadata(null));

        public double NotificationHeight
        {
            get { return (double)GetValue(NotificationHeightProperty); }
            set { SetValue(NotificationHeightProperty, value); }
        }
        public static readonly DependencyProperty NotificationHeightProperty =
            DependencyProperty.Register("NotificationHeight", typeof(double), typeof(TouchNotificationBar), new PropertyMetadata(0.0));


        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();
            border_notifications = GetTemplateChild("PART_BorderNotifications") as Border;
            grid_container = GetTemplateChild("PART_Grid_Container") as Grid;

            //border_notifications.IsManipulationEnabled = true;
            border_notifications.RegisterForPreviewMouseOrTouchDown(GridNotificationMouseDown);
            border_notifications.RegisterForMouseOrTouchMove(GridNotificationMouseMove);
            border_notifications.RegisterForPreviewMouseOrTouchUp(GridNotificationMouseUp);

            border_notifications.SizeChanged += Border_notifications_SizeChanged;
        }

        private void Border_notifications_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            double maxPadding = 150;
            NotificationHeight = (border_notifications.ActualHeight / ActualHeight) * maxPadding;
        }

        private void OnHasNotificationsChanged()
        {
            DoubleAnimation ani = new DoubleAnimation();
            ani.Duration = TimeSpan.FromSeconds(0.2);

            if (HasNotifications)
            {
                ani.To = MinNotificationHeight;
            }
            else
            {
                ani.To = 0;
                CloseNotifications();
            }

            grid_container.BeginAnimation(Grid.MinHeightProperty, ani);
        }

        private void OpenNotifications()
        {
            DoubleAnimation ani = new DoubleAnimation();
            ani.DecelerationRatio = 1;
            ani.Duration = TimeSpan.FromSeconds(0.2);

            if (double.IsNaN(border_notifications.Height))
            {
                border_notifications.Height = border_notifications.ActualHeight;
            }

            border_notifications.MaxHeight = this.ActualHeight;
            ani.To = this.ActualHeight;
            border_notifications.BeginAnimation(Grid.HeightProperty, ani);

            if (ItemExpandedPropertyPath != null)
            {
                foreach (var item in Notifications)
                {
                    item.SetPropertyValueByPath(ItemExpandedPropertyPath, true);
                }
            }
        }

        private void CloseNotifications()
        {
            DoubleAnimation ani = new DoubleAnimation();
            ani.Duration = TimeSpan.FromSeconds(0.2);
            ani.AccelerationRatio = 1;

            ani.From = border_notifications.ActualHeight;
            ani.To = MinNotificationHeight;

            ani.Completed += (_, __) =>
            {
                border_notifications.BorderThickness = new Thickness(0);
                border_notifications.BeginAnimation(Border.HeightProperty, null);
                border_notifications.Height = double.NaN;
            };

            border_notifications.BeginAnimation(Border.MaxHeightProperty, ani);
            border_notifications.BeginAnimation(Border.HeightProperty, ani);

            ThicknessAnimation tAni = new ThicknessAnimation();
            tAni.Duration = TimeSpan.FromSeconds(0.3);
            tAni.To = new Thickness(0);
            border_notifications.BeginAnimation(Border.BorderThicknessProperty, tAni);

            if (ItemExpandedPropertyPath != null)
            {
                foreach (var item in Notifications)
                {
                    item.SetPropertyValueByPath(ItemExpandedPropertyPath, false);
                }
            }
        }

        private void GridNotificationMouseUp(object sender, MouseOrTouchEventArgs e)
        {
            _isMouseDown = false;

            if (_isMoving)
            {
                if (_touchDevice != null)
                {
                    border_notifications.ReleaseTouchCapture(_touchDevice);
                    _touchDevice = null;
                }
                else
                {
                    border_notifications.ReleaseMouseCapture();
                }

                e.Handled = true;
                _isMoving = false;
                DoubleAnimation ani = new DoubleAnimation();
                ani.Duration = TimeSpan.FromSeconds(0.2);

                if ((e.GetPosition(this).Y > ActualHeight / 2 && _last_manipulation_delta > 0) || _last_manipulation_delta > 20)
                {
                    OpenNotifications();
                }
                else if ((e.GetPosition(this).Y < ActualHeight / 2 && _last_manipulation_delta < 0) || _last_manipulation_delta < 20)
                {
                    CloseNotifications();
                }
            }
        }

        private void GridNotificationMouseMove(object sender, MouseOrTouchEventArgs e)
        {
            if (_isMouseDown)
            {
                if (Math.Abs(e.Location.Y - _downLocation.Y) > 5)
                {
                    _isMoving = true;
                }

                if (_isMoving)
                {
                    DateTime curTime = DateTime.Now;

                    if (curTime > _last_delta_measure_time.AddMilliseconds(10))
                    {
                        _last_delta_measure_time = curTime;

                        double delta = e.Location.Y - _last_mouse_y;

                        if (delta != 0)
                        {
                            _last_manipulation_delta = delta;
                        }

                        _last_mouse_y = e.Location.Y;
                    }

                    if (e.TouchDevice != null)
                    {
                        border_notifications.CaptureTouch(e.TouchDevice);
                    }
                    else
                    {
                        Mouse.Capture(border_notifications);
                    }
                    border_notifications.Height = Math.Max(e.Location.Y + _mouseDownLocation.Y, MinNotificationHeight);
                    border_notifications.MaxHeight = Math.Max(e.Location.Y + _mouseDownLocation.Y, MinNotificationHeight);
                    border_notifications.BeginAnimation(Border.HeightProperty, null);
                    border_notifications.BeginAnimation(Border.MaxHeightProperty, null);

                    border_notifications.BeginAnimation(Border.BorderThicknessProperty, null);
                    if (border_notifications.ActualHeight > MinNotificationHeight)
                    {
                        border_notifications.BorderThickness = new Thickness(0, 0, 0, 20);
                    }
                    else
                    {
                        border_notifications.BorderThickness = new Thickness(0);
                    }
                }
            }
        }

        private void GridNotificationMouseDown(object sender, MouseOrTouchEventArgs e)
        {
            _mouseDownLocation = new Point(e.Location.X, border_notifications.MaxHeight - e.Location.Y);
            _downLocation = e.Location;
            _last_mouse_y = _downLocation.Y;
            _last_delta_measure_time = DateTime.Now;
            _last_manipulation_delta = 0;
            _isMouseDown = true;
        }
    }
}