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

using grapher.Models.Calculations;
using grapher.Models.Calculations.Data;
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,
            AccelCalculator calculator)
        {
            SensitivityChart = sensitivityChart;
            VelocityChart = velocityChart;
            GainChart = gainChart;
            Calculator = calculator;
            TwoDotsPerGraph = false;
        }

        public ChartXY SensitivityChart { get; }

        public ChartXY VelocityChart { get; }

        public ChartXY GainChart { get; }

        public IAccelData Data { get; protected set; }

        public AccelCalculator Calculator { get; }

        public virtual Profile Settings { get; set; }

        internal bool TwoDotsPerGraph { get; set; }

        public virtual void MakeDots(double x, double y, double timeInMs)
        {
            Data.CalculateDots(x, y, timeInMs);
        }

        public abstract void Bind();

        public abstract void Activate();

        public virtual void Calculate(ManagedAccel accel, Profile settings)
        {
            Data.CreateGraphData(accel, settings);
        }

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

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

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

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

        public void ShowVelocityAndGain()
        {
            SensitivityChart.SetHeight(Constants.SensitivityChartTogetherHeight);
            VelocityChart.Show();
            GainChart.Show();
        }

        public void HideVelocityAndGain()
        {
            SensitivityChart.SetHeight(Constants.SensitivityChartAloneHeight);
            VelocityChart.Hide();
            GainChart.Hide();
        }

        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);
            }
        }

        public void SetStreaming(bool streaming)
        {
            SensitivityChart.SetStreaming(streaming);
            GainChart.SetStreaming(streaming);
            VelocityChart.SetStreaming(streaming);
        }
    }
}