Ejemplo n.º 1
0
        public Altimeter()
            : base("Altimeter", new Size(364, 376))
        {
            Components.Add(new GaugeImage("{Helios}/Gauges/F-16/Altimeter/altimeter_backplate.xaml", new Rect(32d, 38d, 300d, 300d)));

            _tensDrum = new GaugeDrumCounter("{Helios}/Gauges/F-16/Altimeter/alt_drum_tape.xaml", new Point(71d, 164d), "#", new Size(10d, 15d), new Size(30d, 45d));
            _tensDrum.Clip = new RectangleGeometry(new Rect(71d, 144d, 150d, 81d));
            Components.Add(_tensDrum);

            _drum = new GaugeDrumCounter("{Helios}/Gauges/F-16/Common/drum_tape.xaml", new Point(101d, 164d), "#%00", new Size(10d, 15d), new Size(30d, 45d));
            _drum.Clip = new RectangleGeometry(new Rect(101d, 144d, 150d, 81d));
            Components.Add(_drum);

            _airPressureDrum = new GaugeDrumCounter("{Helios}/Gauges/F-16/Common/drum_tape.xaml", new Point(214d, 233d), "###%", new Size(10d, 15d), new Size(15d, 20d));
            _airPressureDrum.Value = 2992d;
            _airPressureDrum.Clip = new RectangleGeometry(new Rect(214d, 233d, 60d, 20d));
            Components.Add(_airPressureDrum);

            Components.Add(new GaugeImage("{Helios}/Gauges/F-16/Altimeter/altimeter_faceplate.xaml", new Rect(32d, 38d, 300d, 300d)));

            _needleCalibration = new CalibrationPointCollectionDouble(0d, 0d, 1000d, 360d);
            _needle = new GaugeNeedle("{Helios}/Gauges/F-16/Altimeter/altimeter_needle.xaml", new Point(182d, 188d), new Size(16d, 257d), new Point(8d, 138.5d));
            Components.Add(_needle);

            Components.Add(new GaugeImage("{Helios}/Gauges/F-16/Common/f16_gauge_bezel.png", new Rect(0d, 0d, 364d, 376d)));

            _airPressure = new HeliosValue(this, new BindingValue(0d), "", "air pressure", "Current air pressure calibaration setting for the altimeter.", "", BindingValueUnits.InchesOfMercury);
            _airPressure.SetValue(new BindingValue(29.92), true);
            _airPressure.Execute += new HeliosActionHandler(AirPressure_Execute);
            Actions.Add(_airPressure);

            _altitdue = new HeliosValue(this, new BindingValue(0d), "", "altitude", "Current altitude of the aricraft.", "", BindingValueUnits.Feet);
            _altitdue.Execute += new HeliosActionHandler(Altitude_Execute);
            Actions.Add(_altitdue);
        }
Ejemplo n.º 2
0
        public TACANChannel()
            : base("TACAN Channel", new Size(275, 100))
        {
            Components.Add(new GaugeImage("{Helios}/Gauges/A-10/TACANChannel/tacan_channel_faceplate.xaml", new Rect(0d, 0d, 275d, 100d)));

            _hundredsDrum = new GaugeDrumCounter("{Helios}/Gauges/A-10/TACANChannel/tacan_channel_hundreds_tape.xaml", new Point(15.5d, 11.5d), "#", new Size(10d, 15d), new Size(50d, 75d));
            _hundredsDrum.Clip = new RectangleGeometry(new Rect(15.5d, 11.5d, 50d, 75d));
            Components.Add(_hundredsDrum);

            _tensDrum = new GaugeDrumCounter("{Helios}/Gauges/A-10/Common/drum_tape.xaml", new Point(79.5d, 11.5d), "#", new Size(10d, 15d), new Size(50d, 75d));
            _tensDrum.Clip = new RectangleGeometry(new Rect(79.5d, 11.5d, 50d, 75d));
            Components.Add(_tensDrum);

            _onesDrum = new GaugeDrumCounter("{Helios}/Gauges/A-10/Common/drum_tape.xaml", new Point(145.5d, 11.5d), "#", new Size(10d, 15d), new Size(50d, 75d));
            _onesDrum.Clip = new RectangleGeometry(new Rect(145.5d, 11.5d, 50d, 75d));
            Components.Add(_onesDrum);

            _xModeImage = new GaugeImage("{Helios}/Gauges/A-10/TACANChannel/tacan_channel_x_mode.xaml", new Rect(0d, 0d, 275d, 100d));
            Components.Add(_xModeImage);

            _yModeImage = new GaugeImage("{Helios}/Gauges/A-10/TACANChannel/tacan_channel_y_mode.xaml", new Rect(0d, 0d, 275d, 100d));
            _yModeImage.IsHidden = true;
            Components.Add(_yModeImage);

            _channel = new HeliosValue(this, new BindingValue(0d), "", "channel", "TACAN channel", "Does not include X/Y mode", BindingValueUnits.Numeric);
            _channel.Execute += new HeliosActionHandler(Channel_Execute);
            Actions.Add(_channel);

            _xyMode = new HeliosValue(this, new BindingValue(0d), "", "mode", "TACAN X/Y Mode", "1=X, 2=Y", BindingValueUnits.Numeric);
            _xyMode.Execute += new HeliosActionHandler(Mode_Execute);
            Actions.Add(_xyMode);
        }
Ejemplo n.º 3
0
        public RSBNDistance()
            : base("RSBN Distance", new Size(262, 152))
        {
            Components.Add(new GaugeImage("{Helios}/Gauges/Mig-21/RSBNDistance/RSBNDistance.png", new Rect(0d, 0d, 262d, 152d)));
  
            //======================================================================
            //need to create a new overload for GaugeDrumCounter to go the other way
            //but dont want to touch Gadrocs code until at least mine is ok and he's 
            //happy with it. Can live with the wrong rotation, still correct display.
            //=======================================================================

            _onesDrum = new GaugeDrumCounter("{Helios}/Gauges/Mig-21/Common/drum_tape.xaml", new Point(180d, 21.5d), "%", new Size(10d, 15d), new Size(35d, 55d));
            _onesDrum.Clip = new RectangleGeometry(new Rect(180d, 21.5d, 35d, 55d));
            Components.Add(_onesDrum);

            _tensDrum = new GaugeDrumCounter("{Helios}/Gauges/Mig-21/Common/drum_tape.xaml", new Point(111.5d, 21.5d), "#", new Size(10d, 15d), new Size(35d, 55d));
            _tensDrum.Clip = new RectangleGeometry(new Rect(111.5d, 21.5d, 35d, 55d));
            Components.Add(_tensDrum);

            _hundredsDrum = new GaugeDrumCounter("{Helios}/Gauges/Mig-21/Common/drum_tape.xaml", new Point(45.5d, 21.5d), "#", new Size(10d, 15d), new Size(35d, 55d));
            _hundredsDrum.Clip = new RectangleGeometry(new Rect(45.5d, 21.5d, 35d, 55d));
            Components.Add(_hundredsDrum);

            _ones = new HeliosValue(this, new BindingValue(0d), "", "Single Meters", "RSBN Distance", "Distance singles", BindingValueUnits.Numeric);
            _ones.Execute += new HeliosActionHandler(Drum_One_Execute);
            Actions.Add(_ones);

            _tens = new HeliosValue(this, new BindingValue(0d), "", "Tens Meters", "RSBN Distance", "Distance Tens", BindingValueUnits.Numeric);
            _tens.Execute += new HeliosActionHandler(Drum_Tens_Execute);
            Actions.Add(_tens);

            _hundreds = new HeliosValue(this, new BindingValue(0d), "", "Hundreds Meters", "RSBN Distance", "Distance Hundreds", BindingValueUnits.Numeric);
            _hundreds.Execute += new HeliosActionHandler(Drum_Hundreds_Execute);
            Actions.Add(_hundreds);
        }
Ejemplo n.º 4
0
        public FuelGauge()
            : base("Fuel Gauge", new Size(360, 360))
        {
            Components.Add(new GaugeImage("{Helios}/Gauges/A-10/FuelGauge/fuel_gauge_faceplate.xaml", new Rect(30d, 30d, 300d, 300d)));

            _needleCalibration = new CalibrationPointCollectionDouble(0d, 0d, 6000d, 168d);

            _totalDrum = new GaugeDrumCounter("{Helios}/Gauges/A-10/Common/drum_tape.xaml", new Point(135d, 95d), "##%00", new Size(10d, 15d), new Size(18d, 28d));
            _totalDrum.Clip = new RectangleGeometry(new Rect(135d, 95d, 90d, 28d));
            _totalDrum.Value = 0d;
            Components.Add(_totalDrum);

            _leftNeedle = new GaugeNeedle("{Helios}/Gauges/A-10/FuelGauge/fuel_gauge_needle.xaml", new Point(180d, 180d), new Size(90d, 177d), new Point(45d, 132d), 186d);
            Components.Add(_leftNeedle);

            _rightNeedle = new GaugeNeedle("{Helios}/Gauges/A-10/FuelGauge/fuel_gauge_needle.xaml", new Point(180d, 180d), new Size(90d, 177d), new Point(45d, 132d), 174d);
            Components.Add(_rightNeedle);

            Components.Add(new GaugeImage("{Helios}/Gauges/A-10/Common/engine_bezel.png", new Rect(0d, 0d, 360d, 360d)));

            _leftQuantity = new HeliosValue(this, new BindingValue(0d), "", "left quantity", "Quantity of fuel to display on left needle.", "(0 - 6000)", BindingValueUnits.Pounds);
            _leftQuantity.Execute += new HeliosActionHandler(LeftQuantity_Execute);
            Actions.Add(_leftQuantity);

            _rightQuantity = new HeliosValue(this, new BindingValue(0d), "", "right quantity", "Quantity of fuel to display on right needle.", "(0 - 6000)", BindingValueUnits.Pounds);
            _rightQuantity.Execute += new HeliosActionHandler(RightQuantity_Execute);
            Actions.Add(_rightQuantity);

            _totalQuantity = new HeliosValue(this, new BindingValue(0d), "", "total quantity", "Quantity of fuel to display on the totalizer.", "(0 - 99,999)", BindingValueUnits.Pounds);
            _totalQuantity.Execute += new HeliosActionHandler(TotalQuantity_Execute);
            Actions.Add(_totalQuantity);
        }
Ejemplo n.º 5
0
        public ChannelDisplay()
            : base("Channel Display", new Size(100, 75))
        {
            _drum = new GaugeDrumCounter("{Helios}/Gauges/A-10/Common/drum_tape.xaml", new Point(0d, 0d), "##", new Size(10d, 15d), new Size(50d, 75d));
            _drum.Clip = new RectangleGeometry(new Rect(0d, 0d, 100d, 75d));
            Components.Add(_drum);

            _val = new HeliosValue(this, new BindingValue(0d), "", "Channel Display for Radio, RSBN Nav or RSBN Land", "Use Correct Channel Display as input", "Current Channel", BindingValueUnits.Numeric);
            _val.Execute += new HeliosActionHandler(Drum_Execute);
            Actions.Add(_val);
        }
Ejemplo n.º 6
0
        public TISLCodeWheel()
            : base("TISL Code Wheel Window", new Size(16, 21))
        {
            Components.Add(new GaugeRectangle(Colors.Black, new Rect(0, 0, 16, 21)));

            _drum = new GaugeDrumCounter("{Helios}/Gauges/A-10/Common/drum_tape.xaml", new Point(3, 3), "%", new Size(10d, 15d));
            _drum.Clip = new RectangleGeometry(new Rect(1, 1, 14, 19));
            Components.Add(_drum);

            _wheelValue = new HeliosValue(this, new BindingValue(0d), "", "wheel value", "Current value displayed on the wheel.", "0-9.9", BindingValueUnits.Numeric);
            _wheelValue.Execute += new HeliosActionHandler(WheelValue_Execute);
            Actions.Add(_wheelValue);
        }
Ejemplo n.º 7
0
        public ILSFrequency()
            : base("ILS Frequency", new Size(300, 100))
        {
            Components.Add(new GaugeImage("{Helios}/Gauges/A-10/ILSFrequency/ils_frequency_faceplate.xaml", new Rect(0d, 0d, 300d, 100d)));

            _megaHzDrum = new GaugeDrumCounter("{Helios}/Gauges/A-10/Common/drum_tape.xaml", new Point(13.5d, 11.5d), "###", new Size(10d, 15d), new Size(50d, 75d));
            _megaHzDrum.Clip = new RectangleGeometry(new Rect(13.5d, 11.5d, 150d, 75d));
            Components.Add(_megaHzDrum);

            _kiloHzDrum = new GaugeDrumCounter("{Helios}/Gauges/A-10/Common/drum_tape.xaml", new Point(183.5, 11.5d), "#%", new Size(10d, 15d), new Size(50d, 75d));
            _kiloHzDrum.Clip = new RectangleGeometry(new Rect(183.5d, 11.5d, 100d, 75d));
            Components.Add(_kiloHzDrum);

            _frequency = new HeliosValue(this, new BindingValue(0d), "", "frequency", "Frequency to display.", "", BindingValueUnits.Numeric);
            _frequency.Execute += new HeliosActionHandler(Frequency_Execute);
            Actions.Add(_frequency);
        }
Ejemplo n.º 8
0
        public FuelFlow()
            : base("Fuel Flow", new Size(220, 204))
        {
            Rect drumRect = new Rect(29d, 60d, 162d, 80d);

            Components.Add(new GaugeRectangle(Colors.Black, drumRect));

            _drum = new GaugeDrumCounter("{Helios}/Gauges/F-16/Common/drum_tape.xaml", new Point(30d, 79d), "##%00", new Size(10d, 15d), new Size(32d, 48d));
            _drum.Clip = new RectangleGeometry(drumRect);
            Components.Add(_drum);

            Components.Add(new GaugeImage("{Helios}/Gauges/F-16/FuelFlow/fuelflow_bezel.png", new Rect(0d, 0d, 220d, 204d)));
            Components.Add(new GaugeImage("{Helios}/Gauges/F-16/FuelFlow/fuelflow_labels.xaml", new Rect(0d, 0d, 220d, 204d)));

            _fuelFlow = new HeliosValue(this, new BindingValue(0d), "", "fuel flow", "Current rate of consumption of fuel.", "", BindingValueUnits.PoundsPerHour);
            _fuelFlow.Execute += new HeliosActionHandler(FuelFlow_Execute);
            Actions.Add(_fuelFlow);
        }
Ejemplo n.º 9
0
        public HSI()
            : base("HSI", new Size(400, 400))
        {
            Point center = new Point(200, 200);

            Components.Add(new GaugeImage("{Helios}/Gauges/KA-50/HSI/deviation_card.xaml", new Rect(145, 145, 110, 110)));

            _longDeviationNeedle = new GaugeNeedle("{Helios}/Gauges/KA-50/HSI/long_deviation_needle.xaml", center, new Size(120, 5), new Point(60, 2.5));
            Components.Add(_longDeviationNeedle);

            _longDeviation = new HeliosValue(this, BindingValue.Empty, "", "Longitudinal Deviaiton", "Offset of the longitundinal deviation needle from center.", "-1 to 1 where -1 is full left.", BindingValueUnits.Numeric);
            _longDeviation.Execute += new HeliosActionHandler(LongDeviation_Execute);
            Actions.Add(_longDeviation);

            _latDeviationNeedle = new GaugeNeedle("{Helios}/Gauges/KA-50/HSI/lat_deviation_needle.xaml", center, new Size(5, 120), new Point(3, 60));
            Components.Add(_latDeviationNeedle);

            _latDeviation = new HeliosValue(this, BindingValue.Empty, "", "Lateral Deviaiton", "Offset of the Lateral deviation needle from center.", "-1 to 1 where -1 is full up.", BindingValueUnits.Numeric);
            _latDeviation.Execute += new HeliosActionHandler(LatDeviation_Execute);
            Actions.Add(_latDeviation);

            Components.Add(new GaugeImage("{Helios}/Gauges/KA-50/HSI/compass_card_bezel.xaml", new Rect(73, 73, 254, 254)));

            _compassCard = new GaugeNeedle("{Helios}/Gauges/KA-50/HSI/compass_card.xaml", center, new Size(251, 251), new Point(125.5, 125.5));
            Components.Add(_compassCard);

            _heading = new HeliosValue(this, BindingValue.Empty, "", "Heading", "Current heading of the aircraft", "", BindingValueUnits.Degrees);
            _heading.Execute += Heading_Execute;
            Actions.Add(_heading);

            _bearingNeedle = new GaugeNeedle("{Helios}/Gauges/KA-50/HSI/bearing_needle.xaml", center, new Size(15, 235), new Point(7.5, 120.5));
            Components.Add(_bearingNeedle);

            _bearing = new HeliosValue(this, BindingValue.Empty, "", "Bearing", "Current direction the bearing needle is pointing.", "", BindingValueUnits.Degrees);
            _bearing.Execute += Bearing_Execute;
            Actions.Add(_bearing);

            _dtaNeedle = new GaugeNeedle("{Helios}/Gauges/KA-50/HSI/dta_needle.xaml", center, new Size(42, 238), new Point(21, 128));
            Components.Add(_dtaNeedle);

            _course = new HeliosValue(this, BindingValue.Empty, "", "Commanded Course", "Current commanded course.", "", BindingValueUnits.Degrees);
            _course.Execute += Course_Execute;
            Actions.Add(_course);

            Components.Add(new GaugeImage("{Helios}/Gauges/KA-50/HSI/inner_bezel.xaml", new Rect(0, 0, 400, 400)));

            _headingBug = new GaugeNeedle("{Helios}/Gauges/KA-50/HSI/heading_bug.xaml", center, new Size(40, 15), new Point(20, 142));
            Components.Add(_headingBug);

            _commandedHeading = new HeliosValue(this, BindingValue.Empty, "", "Commanded Heading", "Current commanded course.", "", BindingValueUnits.Degrees);
            _commandedHeading.Execute += ComandedHeading_Execute;
            Actions.Add(_commandedHeading);

            _distanceDrum = new GaugeDrumCounter("{Helios}/Gauges/KA-50/Common/drum_tape.xaml", new Point(40, 38), "##%", new Size(10, 15), new Size(18, 27));
            _distanceDrum.Clip = new RectangleGeometry(new Rect(40, 35, 59, 32));
            Components.Add(_distanceDrum);

            _range = new HeliosValue(this, BindingValue.Empty, "", "Range", "Distance to current beacon.", "", BindingValueUnits.Kilometers);
            _range.Execute += Range_Execute;
            Actions.Add(_range);

            _dtaDrum = new GaugeDrumCounter("{Helios}/Gauges/KA-50/Common/drum_tape.xaml", new Point(309, 38), "##%", new Size(10, 15), new Size(18, 27));
            _dtaDrum.Clip = new RectangleGeometry(new Rect(309, 35, 59, 32));
            Components.Add(_dtaDrum);

            _kFlagImage = new GaugeImage("{Helios}/Gauges/KA-50/HSI/k_flag.xaml", new Rect(6, 160, 28, 90));
            Components.Add(_kFlagImage);

            _kFlag = new HeliosValue(this, new BindingValue(false), "", "Glide (K) flag", "Indicates navigation computer failure.", "True if displayed.", BindingValueUnits.Boolean);
            _kFlag.Execute += KFlag_Execute;
            Actions.Add(_kFlag);

            _lFlagImage = new GaugeImage("{Helios}/Gauges/KA-50/HSI/l_flag.xaml", new Rect(366, 160, 28, 90));
            Components.Add(_lFlagImage);

            _lFlag = new HeliosValue(this, new BindingValue(false), "", "Course (L) flag", "Indicates navigation computer failure.", "True if displayed.", BindingValueUnits.Boolean);
            _lFlag.Execute += LFlag_Execute;
            Actions.Add(_lFlag);

            _kcFlagImage = new GaugeImage("{Helios}/Gauges/KA-50/HSI/kc_flag.xaml", new Rect(146, 24, 108, 26));
            Components.Add(_kcFlagImage);

            _kcFlag = new HeliosValue(this, new BindingValue(false), "", "Heading (KC) flag", "Indicates INU failure or lack of power.", "True if displayed.", BindingValueUnits.Boolean);
            _kcFlag.Execute += KCFlag_Execute;
            Actions.Add(_kcFlag);

            Components.Add(new GaugeImage("{Helios}/Gauges/KA-50/HSI/outer_bezel.xaml", new Rect(0, 0, 400, 400)));
        }
Ejemplo n.º 10
0
        public HSI()
            : base("HSI", new Size(350, 350))
        {
            Point center = new Point(175, 170);

            Components.Add(new GaugeRectangle(Colors.Black, new Rect(10, 10, 330, 330)));

            _milesDrum = new GaugeDrumCounter("{Helios}/Gauges/A-10/Common/drum_tape.xaml", new Point(28, 68), "##%", new Size(10d, 15d), new Size(13d, 18d));
            _milesDrum.Clip = new RectangleGeometry(new Rect(28d, 60d, 39d, 30d));
            Components.Add(_milesDrum);

            _courseDrum = new GaugeDrumCounter("{Helios}/Gauges/A-10/Common/drum_tape.xaml", new Point(282, 68), "##%", new Size(10d, 15d), new Size(13d, 18d));
            _courseDrum.Clip = new RectangleGeometry(new Rect(282d, 68d, 39d, 18d));
            Components.Add(_courseDrum);

            _compassNeedle = new GaugeNeedle("{Helios}/Gauges/A-10/HSI/hsi_compass.xaml", center, new Size(243, 243), new Point(121.5, 121.5));
            Components.Add(_compassNeedle);

            _dmeFlagImage = new GaugeImage("{Helios}/Gauges/A-10/HSI/hsi_range_flag.xaml", new Rect(27, 74, 37, 10));
            _dmeFlagImage.IsHidden = true;
            Components.Add(_dmeFlagImage);

            _courseFlagNeedle = new GaugeNeedle("{Helios}/Gauges/A-10/HSI/hsi_bearing_flag.xaml", center, new Size(350, 350), center);
            _courseFlagNeedle.IsHidden = true;
            Components.Add(_courseFlagNeedle);

            _toFlagNeedle = new GaugeNeedle("{Helios}/Gauges/A-10/HSI/hsi_to_flag.xaml", center, new Size(350, 350), center);
            _toFlagNeedle.IsHidden = true;
            Components.Add(_toFlagNeedle);

            _fromFlagNeedle = new GaugeNeedle("{Helios}/Gauges/A-10/HSI/hsi_from_flag.xaml", center, new Size(350, 350), center);
            _fromFlagNeedle.IsHidden = true;
            Components.Add(_fromFlagNeedle);

            _deviationCard = new GaugeNeedle("{Helios}/Gauges/A-10/HSI/hsi_deviation_card.xaml", center, new Size(183, 183), new Point(91.5, 91.5));
            Components.Add(_deviationCard);

            _deviationNeedle = new GaugeNeedle("{Helios}/Gauges/A-10/HSI/hsi_deviation_needle.xaml", center, new Size(6, 149), new Point(3, 74.5));
            Components.Add(_deviationNeedle);

            _desiredCourseNeedle = new GaugeNeedle("{Helios}/Gauges/A-10/HSI/hsi_course_needle.xaml", center, new Size(16, 217), new Point(8, 108.5));
            Components.Add(_desiredCourseNeedle);

            Components.Add(new GaugeImage("{Helios}/Gauges/A-10/HSI/hsi_faceplate.xaml", new Rect(0, 0, 350, 350)));

            _headingBug = new GaugeNeedle("{Helios}/Gauges/A-10/HSI/hsi_heading_bug.xaml", center, new Size(22, 9), new Point(11, 130.5));
            Components.Add(_headingBug);

            _bearingNeedle = new GaugeNeedle("{Helios}/Gauges/A-10/HSI/hsi_bearing_needle_1.xaml", center, new Size(9, 288), new Point(4.5, 148));
            Components.Add(_bearingNeedle);

            _bearingNeedle2 = new GaugeNeedle("{Helios}/Gauges/A-10/HSI/hsi_bearing_needle_2.xaml", center, new Size(12, 267), new Point(6, 133.5));
            Components.Add(_bearingNeedle2);

            _offFlagImage = new GaugeImage("{Helios}/Gauges/A-10/HSI/hsi_off_flag.xaml", new Rect(266, 116, 77, 131));
            _offFlagImage.IsHidden = true;
            Components.Add(_offFlagImage);

            Components.Add(new GaugeImage("{Helios}/Gauges/A-10/HSI/hsi_bezel.png", new Rect(0, 0, 350, 350)));

            _offFlag = new HeliosValue(this, new BindingValue(false), "", "off flag", "Indicates whether the off flag is displayed.", "True if displayed.", BindingValueUnits.Boolean);
            _offFlag.Execute += new HeliosActionHandler(OffFlag_Execute);
            Actions.Add(_offFlag);

            _courseFlag = new HeliosValue(this, new BindingValue(false), "", "course flag", "Indicates whether the course flag is displayed.", "True if displayed.", BindingValueUnits.Boolean);
            _courseFlag.Execute += new HeliosActionHandler(CourseFlag_Execute);
            Actions.Add(_courseFlag);

            _dmeFlag = new HeliosValue(this, new BindingValue(false), "", "dme flag", "Indicates whether the dme flag is displayed.", "True if displayed.", BindingValueUnits.Boolean);
            _dmeFlag.Execute += new HeliosActionHandler(DMEFlag_Execute);
            Actions.Add(_dmeFlag);

            _toFlag = new HeliosValue(this, new BindingValue(false), "", "to flag", "Indicates whether the to flag is displayed.", "True if displayed.", BindingValueUnits.Boolean);
            _toFlag.Execute += new HeliosActionHandler(ToFlag_Execute);
            Actions.Add(_toFlag);

            _fromFlag = new HeliosValue(this, new BindingValue(false), "", "from flag", "Indicates whether the from flag is displayed.", "True if displayed.", BindingValueUnits.Boolean);
            _fromFlag.Execute += new HeliosActionHandler(FromFlag_Execute);
            Actions.Add(_fromFlag);

            _distance = new HeliosValue(this, new BindingValue(0d), "", "distance to beacon", "Miles to the beacon.", "", BindingValueUnits.NauticalMiles);
            _distance.Execute += new HeliosActionHandler(Distance_Execute);
            Actions.Add(_distance);

            _bearing1 = new HeliosValue(this, new BindingValue(0d), "", "bearing 1", "Bearing to the beacon.", "(0 - 360)", BindingValueUnits.Degrees);
            _bearing1.Execute += new HeliosActionHandler(Bearing1_Execute);
            Actions.Add(_bearing1);

            _bearing2 = new HeliosValue(this, new BindingValue(0d), "", "bearing 2", "Bearing to the beacon.", "(0 - 360)", BindingValueUnits.Degrees);
            _bearing2.Execute += new HeliosActionHandler(Bearing2_Execute);
            Actions.Add(_bearing2);

            _desiredHeading = new HeliosValue(this, new BindingValue(0d), "", "desired heading", "Current desired heading.", "(0 - 360)", BindingValueUnits.Degrees);
            _desiredHeading.Execute += new HeliosActionHandler(DesiredHeading_Execute);
            Actions.Add(_desiredHeading);

            _desiredCourse = new HeliosValue(this, new BindingValue(0d), "", "desired course", "Current desired course.", "(0 - 360)", BindingValueUnits.Degrees);
            _desiredCourse.Execute += new HeliosActionHandler(DesiredCourse_Execute);
            Actions.Add(_desiredCourse);

            _courseDeviation = new HeliosValue(this, new BindingValue(0d), "", "course deviation", "Deviation from course.", "(-1 - 1)", BindingValueUnits.Numeric);
            _courseDeviation.Execute += new HeliosActionHandler(Deviation_Execute);
            Actions.Add(_courseDeviation);

            _currentHeading = new HeliosValue(this, new BindingValue(0d), "", "heading", "Current magnetic heading.", "(0 - 360)", BindingValueUnits.Degrees);
            _currentHeading.Execute += new HeliosActionHandler(CurrentHeading_Execute);
            Actions.Add(_currentHeading);

            _deviationCallibration = new CalibrationPointCollectionDouble(-1d, -70d, 1d, 70d);
        }