grapher/Models/Charts/ChartState/ChartState.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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

using grapher.Models.Calculations;
using grapher.Models.Serialized;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace grapher.Models.Charts.ChartState
{
    public abstract class ChartState
    {
        public ChartState(
            ChartXY sensitivityChart,
            ChartXY velocityChart,
            ChartXY gainChart,
            AccelData accelData,
            AccelCalculator calculator)
        {
            SensitivityChart = sensitivityChart;
            VelocityChart = velocityChart;
            GainChart = gainChart;
            Data = accelData;
            Calculator = calculator;
            TwoDotsPerGraph = false;
        }

        public ChartXY SensitivityChart { get; }

        public ChartXY VelocityChart { get; }

        public ChartXY GainChart { get; }

        public AccelData Data { get; }

        public AccelCalculator Calculator { get; }

        public virtual DriverSettings Settings { get; set; }

        internal bool TwoDotsPerGraph { get; set; }

        public abstract void MakeDots(int x, int y, double timeInMs);

        public abstract void Bind();

        public abstract void Activate();

        public abstract void Calculate(ManagedAccel accel, DriverSettings settings);

        public void Redraw()
        {
            SensitivityChart.Update();
            VelocityChart.Update();
            GainChart.Update();
        }

        public virtual void SetUpCalculate(DriverSettings settings)
        {
            Data.Clear();
            Calculator.ScaleByMouseSettings();
        }

        public void DrawLastMovement()
        {
            SensitivityChart.DrawLastMovementValue(TwoDotsPerGraph);
            VelocityChart.DrawLastMovementValue(TwoDotsPerGraph);
            GainChart.DrawLastMovementValue(TwoDotsPerGraph);
        }

        public void SetWidened()
        {
            SensitivityChart.SetWidened();
            VelocityChart.SetWidened();
            GainChart.SetWidened();
        }

        public void SetNarrowed()
        {
            SensitivityChart.SetNarrowed();
            VelocityChart.SetNarrowed();
            GainChart.SetNarrowed();
        }

        public void ClearLastValue()
        {
            SensitivityChart.ClearLastValue();
            VelocityChart.ClearLastValue();
            GainChart.ClearLastValue();
        }

        public void ShowVelocityAndGain(Form form, int borderHeight)
        {
            VelocityChart.Show();
            GainChart.Show();
            form.Height = SensitivityChart.Height +
                                    Constants.ChartSeparationVertical +
                                    VelocityChart.Height +
                                    Constants.ChartSeparationVertical +
                                    GainChart.Height +
                                    borderHeight;
        }

        public void HideVelocityAndGain(Form form, int borderHeight)
        {
            VelocityChart.Hide();
            GainChart.Hide();
            form.Height = SensitivityChart.Height + borderHeight;
        }

        public void SetLogarithmic(bool x, bool y)
        {
            if (x)
            {
                ChartXY.SetLogarithmic(SensitivityChart.ChartX);
                ChartXY.SetLogarithmic(GainChart.ChartX);
            }
            else
            {
                ChartXY.SetStandard(SensitivityChart.ChartX);
                ChartXY.SetStandard(GainChart.ChartX);
            }

            if (y)
            {
                ChartXY.SetLogarithmic(SensitivityChart.ChartY);
                ChartXY.SetLogarithmic(GainChart.ChartY);
            }
            {
                ChartXY.SetStandard(SensitivityChart.ChartY);
                ChartXY.SetStandard(GainChart.ChartY);
            }
        }
    }
}