path: root/Software/Visual_Studio/PPC/Tango.PPC.UI/Controls/RunningJobViewerEureka.xaml.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
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.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using Tango.BL.Entities;
using Tango.Integration.Operation;
using Tango.Logging;

namespace Tango.PPC.UI.Controls
{
    /// <summary>
    /// Interaction logic for RunningJobViewerEureka.xaml
    /// </summary>
    public partial class RunningJobViewerEureka : UserControl
    {
        List<Segment> _segments;
        List<Segment> _lastsegments;


        private double _prevOffset;
        private double _addOffset;
        private int _prevUnit;

        private double _controlWidth;

        public double ControlWidth
        {
            get { return _controlWidth; }
            set {
                _controlWidth = value;//for debug
            }
        }

        /// <summary>
        /// Maybe not necessary!
        /// </summary>
        public bool IsActive
        {
            get { return (bool)GetValue(IsActiveProperty); }
            set { SetValue(IsActiveProperty, value); }
        }
        public static readonly DependencyProperty IsActiveProperty =
            DependencyProperty.Register("IsActive", typeof(bool), typeof(RunningJobViewerEureka), new PropertyMetadata(false));

        /// <summary>
        /// Gets or sets a value indicating whether summary markers.
        /// </summary>
        public bool DisplayMarkers
        {
            get { return (bool)GetValue(DisplayMarkersProperty); }
            set { SetValue(DisplayMarkersProperty, value); }
        }
        public static readonly DependencyProperty DisplayMarkersProperty =
            DependencyProperty.Register("DisplayMarkers", typeof(bool), typeof(RunningJobViewerEureka), new PropertyMetadata(true));
        
        /// <summary>
        /// Gets or sets the job.
        /// </summary>
        public Job Job
        {
            get { return (Job)GetValue(JobProperty); }
            set { SetValue(JobProperty, value); }
        }
        public static readonly DependencyProperty JobProperty =
            DependencyProperty.Register("Job", typeof(Job), typeof(RunningJobViewerEureka), new PropertyMetadata(null, (d, e) => (d as RunningJobViewerEureka).OnUpdateJob()));
        
        private void OnUpdateJob()
        {
            if(Job != null)
            {
                JobUnitLength = Job.Length;
                _segments = Job.EffectiveSegments.ToList();
               
                if (Job.NumberOfUnits > 1 && _segments.Count > 0 
                    && (_segments.Count > 1 || _segments[0].BrushStops.Count > 1))
                {
                    if (Job.EnableInterSegment && Job.InterSegmentLength > 0)
                    {
                        _segments.Add(Job.CreateInterSegment(Job.InterSegmentLength));
                    }
                    _segments.AddRange(Job.EffectiveSegments.ToList());
                    if(Job.NumberOfUnits > 2 && Job.EnableInterSegment && Job.InterSegmentLength > 0)
                    {
                        _segments.Add(Job.CreateInterSegment(Job.InterSegmentLength));
                        JobUnitLength += Job.InterSegmentLength;
                        //_segments.AddRange(Job.EffectiveSegments.ToList());//third set to use in end printing without intersegment
                    }
                    _lastsegments = Job.EffectiveSegments.ToList();;

                    IsHasMultipleColorsSegments = true;
                }
                else
                { 
                    IsHasMultipleColorsSegments = false;
                }
               
                SegmentsItemsControl.ItemsSource = _segments;
                SegmentsItemsControl.InvalidateVisual();
                LastSegmentsItemsControl.ItemsSource = _lastsegments;
                LastSegmentsItemsControl.InvalidateVisual();

                _prevOffset = _addOffset = 0.0;
                _prevUnit = 0;
                ItemsBorder.SetValue(Canvas.LeftProperty, 0.0);
                ItemsBorder.InvalidateVisual();
            }
        }

        /// <summary>
        /// Gets or sets the running job status.
        /// </summary>
        public RunningJobStatus RunningJobStatus
        {
            get { return (RunningJobStatus)GetValue(RunningJobStatusProperty); }
            set { SetValue(RunningJobStatusProperty, value); }
        }
        public static readonly DependencyProperty RunningJobStatusProperty =
            DependencyProperty.Register("RunningJobStatus", typeof(RunningJobStatus), typeof(RunningJobViewerEureka), new PropertyMetadata(null));

        public double MinimumValue
        {
            get { return (double)GetValue(MinimumValueProperty); }
            set { SetValue(MinimumValueProperty, value); }
        }
        /// <summary>
        /// The minimum value property
        /// </summary>
        public static readonly DependencyProperty MinimumValueProperty =
            DependencyProperty.RegisterAttached("MinimumValue", typeof(double), typeof(RunningJobViewerEureka),
                                                new FrameworkPropertyMetadata(0.0));
        public double MaximumValue
        {
            get { return (double)GetValue(MaximumValueProperty); }
            set
            {
                SetValue(MaximumValueProperty, value);
            }
        }
        /// <summary>
        /// The maximum value property
        /// </summary>
        public static readonly DependencyProperty MaximumValueProperty =
            DependencyProperty.RegisterAttached("MaximumValue", typeof(double), typeof(RunningJobViewerEureka),
                                                new FrameworkPropertyMetadata(100.0, 0));

        public double SliderValue
        {
            get { return (double)GetValue(SliderValueProperty); }
            set { SetValue(SliderValueProperty, value); }
        }

        // Using a DependencyProperty as the backing store for SliderValue.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty SliderValueProperty =
            DependencyProperty.Register("SliderValue", typeof(double), typeof(RunningJobViewerEureka), new FrameworkPropertyMetadata((double)0.0, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, (d, e) => (d as RunningJobViewerEureka).OnSliderValueChanged()));
        
        public double HeightSlider
        {
            get { return (double)GetValue(HeightSliderProperty); }
            set { SetValue(HeightSliderProperty, value); }
        }

        // Using a DependencyProperty as the backing store for HeightSlider.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty HeightSliderProperty =
            DependencyProperty.Register("HeightSlider", typeof(double), typeof(RunningJobViewerEureka), new FrameworkPropertyMetadata(0.0));
        
        public double ThumbHeight
        {
            get { return (double)GetValue(ThumbHeightProperty); }
            set { SetValue(ThumbHeightProperty, value); }
        }

        // Using a DependencyProperty as the backing store for ThumbHeight.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ThumbHeightProperty =
            DependencyProperty.Register("ThumbHeight", typeof(double), typeof(RunningJobViewerEureka), new FrameworkPropertyMetadata(0.0));

        
        public bool IsHasMultipleColorsSegments
        {
            get { return (bool)GetValue(IsHasMultipleColorsSegmentsProperty); }
            set { SetValue(IsHasMultipleColorsSegmentsProperty, value); }
        }

        // Using a DependencyProperty as the backing store for IsHasMultipleColorsSegments.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty IsHasMultipleColorsSegmentsProperty =
            DependencyProperty.Register("IsHasMultipleColorsSegments", typeof(bool), typeof(RunningJobViewerEureka), new PropertyMetadata(false));



        public double JobUnitLength
        {
            get { return (double)GetValue(JobUnitLengthProperty); }
            set { SetValue(JobUnitLengthProperty, value); }
        }

        // Using a DependencyProperty as the backing store for JobUnitLength.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty JobUnitLengthProperty =
            DependencyProperty.Register("JobUnitLength", typeof(double), typeof(RunningJobViewerEureka), new FrameworkPropertyMetadata(0.0));




        /// <summary>
        /// Initializes a new instance of the <see cref="RunningJobViewerEureka"/> class.
        /// </summary>
        public RunningJobViewerEureka()
        {
            InitializeComponent();
        }

        private void SliderContentControl_MouseDown(object sender, MouseButtonEventArgs e)
        {
            e.Handled = true;
        }

        private void SliderContentControl_TouchDown(object sender, TouchEventArgs e)
        {
            e.Handled = true;
        }
       

        private void OnSliderValueChanged()
        {
            if(slider_control != null)
            { 
                slider_control.Value = SliderValue;
                if(RunningJobStatus != null && RunningJobStatus.IsSettingUp == false && IsHasMultipleColorsSegments && ColorCanvas != null && ControlWidth > 0 && RunningJobStatus.CurrentUnitProgress > 0.01 && RunningJobStatus.CurrentUnitTotalProgress > 0)
                {
                    double progress = RunningJobStatus.CurrentUnitProgress;
                    double total = RunningJobStatus.CurrentUnitTotalProgress;
                    
                    int currentUnit = RunningJobStatus.CurrentUnit;
                    int totalUnits = RunningJobStatus.RemainingUnits + RunningJobStatus.CurrentUnit;//Job.NumberOfUnits;

                    double simpleoffset = ((progress / total) * ControlWidth) ;
                    
                    double multiplier = (((double)(totalUnits - 1)) / (double)totalUnits);
                    double offset = simpleoffset * multiplier;
                   
                    if(_prevUnit < currentUnit)
                    {
                        if(_prevOffset == 0)//resume
                        {
                            _prevOffset = ControlWidth * (1-multiplier) * currentUnit;
                        }
                        _addOffset = _prevOffset;
                    }
                   // Debug.WriteLine($"OnSliderValueChanged Offset: '{offset}' CurrentUnitProgress = {RunningJobStatus.CurrentUnitProgress} progress= {progress} currentUnit = {currentUnit}, total:{total}");
                    offset += _addOffset;
                   
                    if (offset >= ControlWidth && currentUnit < (Job.NumberOfUnits - 2))
                    {
                        offset -= ControlWidth;//round 
                       // Debug.WriteLine($"OnSliderValueChanged round!!! offset: '{offset}' currentUnit = {currentUnit}, total:{total}");
                    }
                   
                    //if(currentUnit == (Job.NumberOfUnits - 1))
                    //{
                    //    Debug.WriteLine($"OnSliderValueChanged offset: '{offset}' currentUnit = {currentUnit}. ControlWidth = {ControlWidth} total:{total}");
                    //}
                    _prevOffset = offset;
                    _prevUnit = currentUnit;

                    ItemsBorder.SetValue(Canvas.LeftProperty, (-1) * offset);
                    ItemsBorder.InvalidateVisual();
                }
            }
        }

        private void Slider_control_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            ControlWidth = e.NewSize.Width;
        }
    }
}