Software/Visual_Studio/Tango.Touch/Controls/TouchSideMenu.cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

using System;
using System.Collections.Generic;
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.Markup;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace Tango.Touch.Controls
{
    [ContentProperty(nameof(Content))]
    public class TouchSideMenu : Control
    {
        public FrameworkElement Content
        {
            get { return (FrameworkElement)GetValue(ContentProperty); }
            set { SetValue(ContentProperty, value); }
        }
        public static readonly DependencyProperty ContentProperty =
            DependencyProperty.Register("Content", typeof(FrameworkElement), typeof(TouchSideMenu), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender,(d,e) => (d as TouchSideMenu).OnContentChanged()));

        public FrameworkElement MenuContent
        {
            get { return (FrameworkElement)GetValue(MenuContentProperty); }
            set { SetValue(MenuContentProperty, value); }
        }
        public static readonly DependencyProperty MenuContentProperty =
            DependencyProperty.Register("MenuContent", typeof(FrameworkElement), typeof(TouchSideMenu), new PropertyMetadata(null,(d,e) => (d as TouchSideMenu).OnMenuContentChanged()));

        public bool IsOpened
        {
            get { return (bool)GetValue(IsOpenedProperty); }
            set { SetValue(IsOpenedProperty, value); }
        }
        public static readonly DependencyProperty IsOpenedProperty =
            DependencyProperty.Register("IsOpened", typeof(bool), typeof(TouchSideMenu), new PropertyMetadata(false,OnIsOpenedChanged));

        private static void OnIsOpenedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            
        }

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

        private void OnContentChanged()
        {
            RemoveLogicalChild(Content);
            AddLogicalChild(Content);
        }

        private void OnMenuContentChanged()
        {
            RemoveLogicalChild(MenuContent);
            AddLogicalChild(MenuContent);
        }
    }
}

        /// Gets or sets the update interval.
        /// </summary>
        public int UpdateInterval
        {
            get { return _updateInterval; }
            set { _updateInterval = value; RaisePropertyChangedAuto(); }
        }

        /// <summary>
        /// Gets or sets the last update time.
        /// </summary>
        [XmlIgnore]
        public DateTime LastUpdateTime { get; set; }

        private double _effectiveValue;
        /// <summary>
        /// Gets or sets the effective value received from the embedded device.
        /// </summary>
        [XmlIgnore]
        public double EffectiveValue
        {
            get { return _effectiveValue; }
            set
            {
                LastUpdateTime = DateTime.Now;

                if (_effectiveValue != value)
                {
                    _effectiveValue = value;
                    RaisePropertyChangedAuto();
                }
            }
        }

        private double _optimalRangeMinimum;
        /// <summary>
        /// Gets or sets the optimal range.
        /// </summary>
        public double OptimalRangeMinimum
        {
            get { return _optimalRangeMinimum; }
            set
            {
                _optimalRangeMinimum = value;
                RaisePropertyChangedAuto();
            }
        }

        private double _optimalRangeMaximum;
        public double OptimalRangeMaximum
        {
            get { return _optimalRangeMaximum; }
            set { _optimalRangeMaximum = value; RaisePropertyChangedAuto(); }
        }

        public bool IsSetToDefault { get; set; }

        /// <summary>
        /// Gets or sets the set command.
        /// </summary>
        [XmlIgnore]
        public RelayCommand SetCommand { get; set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="ControllerItem"/> class.
        /// </summary>
        public ControllerItem() : base()
        {
            Name = "Value Controller";
            Description = "Single component value controller";
            Image = ResourceHelper.GetImageFromResources("Images/controller.png");
            Color = Colors.DodgerBlue;
            LastUpdateTime = DateTime.Now;
            UpdateInterval = 10;

            SetCommand = new RelayCommand(() => { SetCommandClicked?.Invoke(this, new EventArgs()); });
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ControllerItem"/> class.
        /// </summary>
        /// <param name="techController">The db tech controller.</param>
        public ControllerItem(TechController techController) : this()
        {
            TechController = techController;
        }

        /// <summary>
        /// Clones this instance.
        /// </summary>
        /// <returns></returns>
        public override TechItem Clone()
        {
            ControllerItem cloned = base.Clone() as ControllerItem;
            cloned.TechController = TechController;
            cloned.OptimalRangeMinimum = OptimalRangeMinimum;
            cloned.OptimalRangeMaximum = OptimalRangeMaximum;
            cloned.IsSetToDefault = IsSetToDefault;
            
            return cloned;
        }
    }
}