1 files changed, 227 insertions, 0 deletions
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Logging/Controls/TimeRuler.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Logging/Controls/TimeRuler.cs
new file mode 100644
index 000000000..552f8f416
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Logging/Controls/TimeRuler.cs
@@ -0,0 +1,227 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+
+namespace Tango.MachineStudio.Logging.Controls
+{
+    public class TimeRuler : Control
+    {
+        private double _smallStep;
+        private double _bigStep;
+
+        #region Private Methods
+
+        private static T FindVisualParent<T>(DependencyObject child) where T : DependencyObject
+        {
+            // get parent item
+            DependencyObject parentObject = VisualTreeHelper.GetParent(child);
+
+            // we’ve reached the end of the tree
+            if (parentObject == null) return null;
+
+            // check if the parent matches the type we’re looking for
+            T parent = parentObject as T;
+            if (parent != null)
+            {
+                return parent;
+            }
+            else
+            {
+                // use recursion to proceed with next level
+                return FindVisualParent<T>(parentObject);
+            }
+        }
+
+        #endregion
+
+        #region Properties
+
+        public double RenderWidth
+        {
+            get { return (double)GetValue(RenderWidthProperty); }
+            set { SetValue(RenderWidthProperty, value); }
+        }
+        public static readonly DependencyProperty RenderWidthProperty =
+            DependencyProperty.Register("RenderWidth", typeof(double), typeof(TimeRuler), new FrameworkPropertyMetadata(400.0, FrameworkPropertyMetadataOptions.AffectsRender));
+
+        public double HorizontalOffset
+        {
+            get { return (double)GetValue(HorizontalOffsetProperty); }
+            set { SetValue(HorizontalOffsetProperty, value); }
+        }
+        public static readonly DependencyProperty HorizontalOffsetProperty =
+            DependencyProperty.Register("HorizontalOffset", typeof(double), typeof(TimeRuler), new PropertyMetadata(0.0, HorizontalOffsetChanged));
+
+        private static void HorizontalOffsetChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var control = d as TimeRuler;
+            control.Margin = new Thickness(-control.HorizontalOffset, 0, 0, 0);
+            control.InvalidateVisual();
+        }
+
+
+
+        #region Zoom
+        /// <summary>
+        /// Gets or sets the zoom factor for the ruler. The default value is 1.0. 
+        /// </summary>
+        public double Zoom
+        {
+            get
+            {
+                return (double)GetValue(ZoomProperty);
+            }
+            set
+            {
+                SetValue(ZoomProperty, value);
+                this.InvalidateVisual();
+            }
+        }
+
+        private void SetSteps(double value)
+        {
+            if (value >= 50)
+            {
+                _smallStep = 0.25;
+                _bigStep = 1;
+            }
+            else if (value >= 40)
+            {
+                _smallStep = 0.25;
+                _bigStep = 2;
+            }
+            else if (value >= 30)
+            {
+                _smallStep = 0.5;
+                _bigStep = 2;
+            }
+            else if (value >= 20)
+            {
+                _smallStep = 1;
+                _bigStep = 5;
+            }
+            else if (value >= 10)
+            {
+                _smallStep = 1;
+                _bigStep = 10;
+            }
+            else if (value >= 5)
+            {
+                _smallStep = 2;
+                _bigStep = 20;
+            }
+            else if (value >= 3)
+            {
+                _smallStep = 5;
+                _bigStep = 30;
+            }
+            else if (value >= 1)
+            {
+                _smallStep = 30;
+                _bigStep = 300;
+            }
+            else if (value >= 0.5)
+            {
+                _smallStep = 60;
+                _bigStep = 600;
+            }
+        }
+
+        /// <summary>
+        /// Identifies the Zoom dependency property.
+        /// </summary>
+        public static readonly DependencyProperty ZoomProperty =
+            DependencyProperty.Register("Zoom", typeof(double), typeof(TimeRuler), new FrameworkPropertyMetadata((double)1.0, FrameworkPropertyMetadataOptions.AffectsRender, new PropertyChangedCallback(ZoomChanged)));
+
+        private static void ZoomChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            (d as TimeRuler).SetSteps((double)e.NewValue);
+        }
+
+
+        #endregion
+
+        #endregion
+
+        #region Constructor
+
+        public TimeRuler()
+        {
+            _smallStep = 1;
+            _bigStep = 10;
+            FontSize = 10;
+            this.Loaded += TimeRuler_Loaded;
+        }
+
+        private void TimeRuler_Loaded(object sender, RoutedEventArgs e)
+        {
+            this.InvalidateVisual();
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Participates in rendering operations.
+        /// </summary>
+        /// <param name="drawingContext">The drawing instructions for a specific element. This context is provided to the layout system.</param>
+        protected override void OnRender(DrawingContext drawingContext)
+        {
+            base.OnRender(drawingContext);
+
+            double xDest = RenderWidth;
+            int start = (int)(HorizontalOffset / Zoom);
+
+            drawingContext.DrawRectangle(Background, new Pen(BorderBrush, 0), new Rect(new Point(start * Zoom, 0.0), new Point(xDest + (start * Zoom) + 100, Height)));
+            drawingContext.DrawLine(new Pen(BorderBrush, 1), new Point(start * Zoom, Height - 1), new Point(xDest + (start * Zoom) + 100, Height));
+
+
+            double l = (start % _smallStep);
+            while (l != 0) //I don't know why, but this is needed in order to prevent ruler from flickering on some lower scale factors :/
+            {
+                start += 1;
+                l = (start % _smallStep);
+            }
+
+            for (double dUnit = start; dUnit < (RenderWidth / Zoom) + (start) + 10; dUnit += _smallStep)
+            {
+                double d = dUnit * (this.Zoom);
+
+                double startHeight;
+                double endHeight;
+
+                startHeight = Height;
+                endHeight = ((dUnit % _bigStep == 0) ? (this.ActualHeight / 5) * 1.5 : this.ActualHeight / 5);
+
+                drawingContext.DrawLine(new Pen(Foreground, 1), new Point(d, startHeight), new Point(d, (startHeight - endHeight)));
+
+                double uu = (dUnit % _bigStep);
+
+                if ((dUnit != 0.0) && (uu == 0) && (dUnit < (RenderWidth / Zoom) + start + 10))
+                {
+                    double u = dUnit;
+                    TimeSpan t = TimeSpan.FromSeconds((u));
+
+                    FormattedText ft = new FormattedText(t.ToString("g"),
+                            CultureInfo.CurrentCulture,
+                            FlowDirection.LeftToRight,
+                            new Typeface(FontFamily.ToString()),
+                            FontSize,
+                            Foreground);
+                    ft.SetFontWeight(FontWeight);
+                    ft.TextAlignment = TextAlignment.Center;
+                    drawingContext.DrawText(ft, new Point(d, (Height / 2) - (ft.Height / 2) - 2));
+                }
+            }
+        }
+
+        #endregion
+    }
+}