848 lines
22 KiB
C#
848 lines
22 KiB
C#
using System;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Drawing.Design;
|
|
using System.Text;
|
|
using DevComponents.Instrumentation.Primitives;
|
|
|
|
namespace DevComponents.Instrumentation
|
|
{
|
|
public class GaugeIndicator : GaugeItem
|
|
{
|
|
#region Private variables
|
|
|
|
private bool _AutoSize;
|
|
private bool _UnderScale;
|
|
private int _RefreshRate;
|
|
|
|
private double _MinValue;
|
|
private double _MaxValue;
|
|
private double _Value;
|
|
|
|
private GradientFillColor _BackColor;
|
|
|
|
private SizeF _Size;
|
|
private PointF _Location;
|
|
private Rectangle _Bounds;
|
|
private Point _Center;
|
|
|
|
private Font _Font;
|
|
private string _Text;
|
|
private string _EmptyString;
|
|
private string _OverRangeString;
|
|
private string _UnderRangeString;
|
|
|
|
private bool _Dampening;
|
|
private double _DampeningSweepTime;
|
|
|
|
private double _DValue;
|
|
private double _DeltaValue;
|
|
private double _DStartValue;
|
|
private double _DEndValue;
|
|
|
|
private long _DStartTicks;
|
|
private long _DRefreshTicks;
|
|
|
|
private GaugeControl _GaugeControl;
|
|
|
|
#endregion
|
|
|
|
public GaugeIndicator()
|
|
{
|
|
_AutoSize = true;
|
|
|
|
BackColor.BorderColor = Color.Black;
|
|
|
|
_Size = new SizeF(.07f, .07f);
|
|
_Location = new PointF(.5f, .7f);
|
|
|
|
_UnderScale = true;
|
|
_RefreshRate = 10;
|
|
|
|
_EmptyString = "-";
|
|
_OverRangeString = "Error";
|
|
_UnderRangeString = "Error";
|
|
|
|
_MinValue = 0;
|
|
_MaxValue = 100;
|
|
_Value = double.NaN;
|
|
}
|
|
|
|
#region Public properties
|
|
|
|
#region AutoSize
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether the indicator contents are auto sized
|
|
/// </summary>
|
|
[Browsable(true)]
|
|
[Category("Behavior"), DefaultValue(true)]
|
|
[Editor("DevComponents.Instrumentation.Design.AngleRangeValueEditor, DevComponents.Instrumentation.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=76cb4c6eb576bca5", typeof(UITypeEditor))]
|
|
[Description("Indicates whether the indicator contents are auto sized.")]
|
|
public bool AutoSize
|
|
{
|
|
get { return (_AutoSize); }
|
|
|
|
set
|
|
{
|
|
if (_AutoSize != value)
|
|
{
|
|
_AutoSize = value;
|
|
|
|
OnGaugeItemChanged(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region BackColor
|
|
|
|
/// <summary>
|
|
/// Gets or sets the BackColor
|
|
/// </summary>
|
|
[Browsable(true), Category("Appearance")]
|
|
[Description("Indicates the BackColor.")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public GradientFillColor BackColor
|
|
{
|
|
get
|
|
{
|
|
if (_BackColor == null)
|
|
{
|
|
_BackColor = new GradientFillColor();
|
|
_BackColor.ColorTableChanged += BackColorColorTableChanged;
|
|
}
|
|
|
|
return (_BackColor);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_BackColor != null)
|
|
_BackColor.ColorTableChanged -= BackColorColorTableChanged;
|
|
|
|
_BackColor = value;
|
|
|
|
if (_BackColor != null)
|
|
_BackColor.ColorTableChanged += BackColorColorTableChanged;
|
|
|
|
OnGaugeItemChanged();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Bounds
|
|
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public Rectangle Bounds
|
|
{
|
|
get { return (_Bounds); }
|
|
internal set { _Bounds = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DampeningSweepTime
|
|
|
|
/// <summary>
|
|
/// Gets or sets the time it takes for the indicator to
|
|
/// change from its minimum to maximum value, measured in seconds
|
|
/// </summary>
|
|
[Browsable(true)]
|
|
[Category("Behavior"), DefaultValue(0d)]
|
|
[Description("Indicates the time it takes for the indicator to change from its minimum to maximum value, measured in seconds.")]
|
|
public double DampeningSweepTime
|
|
{
|
|
get { return (_DampeningSweepTime); }
|
|
|
|
set
|
|
{
|
|
if (_DampeningSweepTime != value)
|
|
{
|
|
_DampeningSweepTime = value;
|
|
|
|
OnGaugeItemChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region EmptyString
|
|
|
|
/// <summary>
|
|
/// Gets or sets the text string to display when the Indicator Value is empty (double.NaN)
|
|
/// </summary>
|
|
[Browsable(true), Category("Behavior"), DefaultValue("-")]
|
|
[Description("Indicates the text string to display when the Indicator Value is empty (double.NaN).")]
|
|
public string EmptyString
|
|
{
|
|
get { return (_EmptyString); }
|
|
|
|
set
|
|
{
|
|
if (_EmptyString != value)
|
|
{
|
|
_EmptyString = value;
|
|
|
|
OnGaugeItemChanged(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Font
|
|
|
|
/// <summary>
|
|
/// Gets or sets the text Font
|
|
/// </summary>
|
|
[Browsable(true), Category("Appearance")]
|
|
[Description("Indicates the text Font.")]
|
|
public Font Font
|
|
{
|
|
get
|
|
{
|
|
if (_Font == null)
|
|
_Font = new Font("Microsoft SanSerif", 12);
|
|
|
|
return (_Font);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_Font != null)
|
|
_Font.Dispose();
|
|
|
|
_Font = value;
|
|
|
|
AbsFont = null;
|
|
|
|
OnGaugeItemChanged(true);
|
|
}
|
|
}
|
|
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
internal virtual bool ShouldSerializeFont()
|
|
{
|
|
if (_Font == null)
|
|
return (false);
|
|
|
|
using (Font font = new Font("Microsoft SanSerif", 12))
|
|
return (_Font.Equals(font) == false);
|
|
}
|
|
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
internal virtual void ResetFont()
|
|
{
|
|
Font = new Font("Microsoft SanSerif", 12);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GaugeControl
|
|
|
|
/// <summary>
|
|
/// Gets or sets the owning GaugeControl
|
|
/// </summary>
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public GaugeControl GaugeControl
|
|
{
|
|
get { return (_GaugeControl); }
|
|
internal set { _GaugeControl = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Location
|
|
|
|
/// <summary>
|
|
/// Gets or sets the location of the image area, specified as a percentage
|
|
/// </summary>
|
|
[Browsable(true), Category("Layout")]
|
|
[Editor("DevComponents.Instrumentation.Design.LocationEditor, DevComponents.Instrumentation.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=76cb4c6eb576bca5", typeof(UITypeEditor))]
|
|
[Description("Indicates the location of the image area, specified as a percentage.")]
|
|
[TypeConverter(typeof(PointFConverter))]
|
|
public PointF Location
|
|
{
|
|
get { return (_Location); }
|
|
|
|
set
|
|
{
|
|
if (_Location != value)
|
|
{
|
|
_Location = value;
|
|
|
|
OnGaugeItemChanged(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeLocation()
|
|
{
|
|
return (_Location.X != .5f || _Location.Y != .7f);
|
|
}
|
|
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetLocation()
|
|
{
|
|
_Location = new PointF(.5f, .7f);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region MaxValue
|
|
|
|
/// <summary>
|
|
/// Gets or sets the Maximum value for the Indicator
|
|
/// </summary>
|
|
[Browsable(true), Category("Behavior"), DefaultValue(100d)]
|
|
[Description("Indicates the Maximum value for the Indicator.")]
|
|
public double MaxValue
|
|
{
|
|
get { return (_MaxValue); }
|
|
|
|
set
|
|
{
|
|
if (_MaxValue != value)
|
|
{
|
|
_MaxValue = value;
|
|
|
|
DValue = _Value;
|
|
|
|
OnGaugeItemChanged(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region MinValue
|
|
|
|
/// <summary>
|
|
/// Gets or sets the Minimum value for the Indicator
|
|
/// </summary>
|
|
[Browsable(true), Category("Behavior"), DefaultValue(0d)]
|
|
[Description("Indicates the Minimum value for the Indicator.")]
|
|
public double MinValue
|
|
{
|
|
get { return (_MinValue); }
|
|
|
|
set
|
|
{
|
|
if (_MinValue != value)
|
|
{
|
|
_MinValue = value;
|
|
|
|
DValue = _Value;
|
|
|
|
OnGaugeItemChanged(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OverRangeString
|
|
|
|
/// <summary>
|
|
/// Gets or sets the text string to display when the Indicator Value is over the set MaxValue range
|
|
/// </summary>
|
|
[Browsable(true), Category("Behavior"), DefaultValue("Error")]
|
|
[Description("Indicates the text string to display when the Indicator Value is over the set MaxValue range.")]
|
|
public string OverRangeString
|
|
{
|
|
get { return (_OverRangeString); }
|
|
|
|
set
|
|
{
|
|
if (_OverRangeString != value)
|
|
{
|
|
_OverRangeString = value;
|
|
|
|
OnGaugeItemChanged(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RefreshRate
|
|
|
|
/// <summary>
|
|
/// Gets or sets how often the indicator is refreshed per second
|
|
/// </summary>
|
|
[Browsable(true)]
|
|
[Category("Behavior"), DefaultValue(10)]
|
|
[Editor("DevComponents.Instrumentation.Design.AngleRangeValueEditor, DevComponents.Instrumentation.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=76cb4c6eb576bca5", typeof(UITypeEditor))]
|
|
[Description("Indicates how often the indicator is refreshed per second.")]
|
|
public int RefreshRate
|
|
{
|
|
get { return (_RefreshRate); }
|
|
|
|
set
|
|
{
|
|
if (_RefreshRate != value)
|
|
{
|
|
if (value <= 0 || value > 1000)
|
|
throw new ArgumentException("Value must be between 1 and 100");
|
|
|
|
_RefreshRate = value;
|
|
|
|
OnGaugeItemChanged(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Size
|
|
|
|
/// <summary>
|
|
/// Gets or sets the size of the indicator, specified as a percentage
|
|
/// </summary>
|
|
[Browsable(true), Category("Layout")]
|
|
[Editor("DevComponents.Instrumentation.Design.SizeEditor, DevComponents.Instrumentation.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=76cb4c6eb576bca5", typeof(UITypeEditor))]
|
|
[Description("Determines the size of the indicator, specified as a percentage.")]
|
|
public SizeF Size
|
|
{
|
|
get { return (_Size); }
|
|
|
|
set
|
|
{
|
|
if (_Size != value)
|
|
{
|
|
_Size = value;
|
|
|
|
OnGaugeItemChanged(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeSize()
|
|
{
|
|
return (_Size.Width != .07f || _Size.Height != .07f);
|
|
}
|
|
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetSize()
|
|
{
|
|
_Size = new SizeF(.07f, .07f);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Text
|
|
|
|
/// <summary>
|
|
/// Gets or sets the text to be displayed
|
|
/// </summary>
|
|
[Browsable(true), Category("Behavior"), DefaultValue(null)]
|
|
[Description("Indicates the text to be displayed.")]
|
|
public string Text
|
|
{
|
|
get { return (_Text); }
|
|
|
|
set
|
|
{
|
|
if (_Text != value)
|
|
{
|
|
_Text = value;
|
|
|
|
OnGaugeItemChanged(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region UnderRangeString
|
|
|
|
/// <summary>
|
|
/// Gets or sets the text string to display when the Indicator Value is under the set MinValue range
|
|
/// </summary>
|
|
[Browsable(true), Category("Behavior"), DefaultValue("Error")]
|
|
[Description("Indicates the text string to display when the Indicator Value is under the set MinValue range.")]
|
|
public string UnderRangeString
|
|
{
|
|
get { return (_UnderRangeString); }
|
|
|
|
set
|
|
{
|
|
if (_UnderRangeString != value)
|
|
{
|
|
_UnderRangeString = value;
|
|
|
|
OnGaugeItemChanged(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region UnderScale
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether the indicator is displayed under the scale
|
|
/// </summary>
|
|
[Browsable(true)]
|
|
[Category("Layout"), DefaultValue(true)]
|
|
[Editor("DevComponents.Instrumentation.Design.AngleRangeValueEditor, DevComponents.Instrumentation.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=76cb4c6eb576bca5", typeof(UITypeEditor))]
|
|
[Description("Indicates whether the indicator is displayed under the scale.")]
|
|
public bool UnderScale
|
|
{
|
|
get { return (_UnderScale); }
|
|
|
|
set
|
|
{
|
|
if (_UnderScale != value)
|
|
{
|
|
_UnderScale = value;
|
|
|
|
OnGaugeItemChanged(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Value
|
|
|
|
/// <summary>
|
|
/// Gets or sets the indicator value
|
|
/// </summary>
|
|
[Browsable(true)]
|
|
[Category("Behavior"), DefaultValue(double.NaN)]
|
|
[Description("Indicates the indicator value.")]
|
|
public double Value
|
|
{
|
|
get { return (_Value); }
|
|
|
|
set
|
|
{
|
|
if (_Value != value)
|
|
{
|
|
_Value = value;
|
|
|
|
OnValueChanged(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ValueEx
|
|
|
|
/// <summary>
|
|
/// Gets or sets the value of the indicator - but with no dampening
|
|
/// </summary>
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public double ValueEx
|
|
{
|
|
get { return (_Value); }
|
|
|
|
set
|
|
{
|
|
if (_Value != value)
|
|
{
|
|
_Value = value;
|
|
|
|
OnValueChanged(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Internal properties
|
|
|
|
#region AbsFont
|
|
|
|
// ReSharper disable ValueParameterNotUsed
|
|
internal virtual Font AbsFont
|
|
{
|
|
get { return (Font); }
|
|
set { }
|
|
}
|
|
// ReSharper restore ValueParameterNotUsed
|
|
|
|
#endregion
|
|
|
|
#region Center
|
|
|
|
internal Point Center
|
|
{
|
|
get { return (_Center); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DValue
|
|
|
|
internal double DValue
|
|
{
|
|
get { return (_DValue); }
|
|
|
|
set
|
|
{
|
|
_DValue = value;
|
|
|
|
if (GaugeControl != null)
|
|
GaugeControl.DValueChange = true;
|
|
|
|
OnGaugeItemChanged(true);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Event processing
|
|
|
|
#region BackColor processing
|
|
|
|
void BackColorColorTableChanged(object sender, EventArgs e)
|
|
{
|
|
OnGaugeItemChanged(true);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region OnValueChanged
|
|
|
|
internal virtual void OnValueChanged(bool dampen)
|
|
{
|
|
if (GaugeControl != null && Visible == true)
|
|
{
|
|
if (GaugeControl.InDesignMode == false)
|
|
{
|
|
if (_DValue < _Value)
|
|
{
|
|
double start = Math.Max(_MinValue, _DValue);
|
|
|
|
if (start < _MaxValue)
|
|
{
|
|
if (StartDampening(dampen, start, Math.Min(_MaxValue, _Value)))
|
|
return;
|
|
}
|
|
}
|
|
else if (_DValue > _Value)
|
|
{
|
|
double start = Math.Min(_MaxValue, _DValue);
|
|
|
|
if (start > _MinValue)
|
|
{
|
|
if (StartDampening(dampen, start, Math.Max(_MinValue, _Value)))
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
DValue = _Value;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Dampening support
|
|
|
|
#region StartDampening
|
|
|
|
private bool StartDampening(bool dampen, double start, double end)
|
|
{
|
|
double dampenTime = _DampeningSweepTime;
|
|
|
|
if (GaugeControl.IsHandleCreated &&
|
|
dampen == true && dampenTime > 0)
|
|
{
|
|
_DStartValue = start;
|
|
_DEndValue = end;
|
|
_DeltaValue = (_MaxValue - _MinValue) / (dampenTime * 1000);
|
|
|
|
_DStartTicks = DateTime.Now.Ticks;
|
|
|
|
if (_Dampening == false)
|
|
{
|
|
_Dampening = true;
|
|
_DRefreshTicks = _DStartTicks;
|
|
|
|
_GaugeControl.DampeningUpdate += DampeningUpdate;
|
|
_GaugeControl.StartDampening();
|
|
}
|
|
|
|
return (true);
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DampeningUpdate
|
|
|
|
void DampeningUpdate(object sender, EventArgs e)
|
|
{
|
|
SetIndicatorValue();
|
|
|
|
if (_DValue == _DEndValue)
|
|
{
|
|
if (_Dampening == true)
|
|
{
|
|
_GaugeControl.DampeningUpdate -= DampeningUpdate;
|
|
_GaugeControl.StopDampening();
|
|
|
|
_Dampening = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SetIndicatorValue
|
|
|
|
private void SetIndicatorValue()
|
|
{
|
|
long now = DateTime.Now.Ticks;
|
|
|
|
double ms = new TimeSpan(now - _DStartTicks).TotalMilliseconds;
|
|
double delta = _DeltaValue * ms;
|
|
|
|
if (delta > 0)
|
|
{
|
|
double n = (_DValue <= _Value)
|
|
? Math.Min(_DStartValue + delta, _DEndValue)
|
|
: Math.Max(_DStartValue - delta, _DEndValue);
|
|
|
|
if (n == _DEndValue ||
|
|
new TimeSpan(now - _DRefreshTicks).TotalMilliseconds > 1000 / _RefreshRate)
|
|
{
|
|
_DRefreshTicks = now;
|
|
|
|
DValue = n;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region RecalcLayout
|
|
|
|
public override void RecalcLayout()
|
|
{
|
|
base.RecalcLayout();
|
|
|
|
bool autoCenter = _GaugeControl.Frame.AutoCenter;
|
|
_Center = _GaugeControl.GetAbsPoint(_Location, autoCenter);
|
|
|
|
Size size = _GaugeControl.GetAbsSize(_Size, autoCenter);
|
|
|
|
_Bounds = new Rectangle(
|
|
_Center.X - size.Width / 2, _Center.Y - size.Height / 2,
|
|
size.Width, size.Height);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Contains
|
|
|
|
internal virtual bool Contains(Point pt)
|
|
{
|
|
return (Bounds.Contains(pt));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetOverrideString
|
|
|
|
protected string GetOverrideString()
|
|
{
|
|
string s = null;
|
|
|
|
if (String.IsNullOrEmpty(Text) == false)
|
|
s = Text;
|
|
|
|
else if (Value.Equals(double.NaN) == true)
|
|
s = _EmptyString ?? "";
|
|
|
|
else if (Value < MinValue)
|
|
s = _UnderRangeString;
|
|
|
|
else if (Value > MaxValue)
|
|
s = _OverRangeString ?? "";
|
|
|
|
return (s);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ProcessTemplateText
|
|
|
|
protected override void ProcessTemplateText(
|
|
GaugeControl gauge, StringBuilder sb, string key, string data)
|
|
{
|
|
if (key.Equals("Value") == true)
|
|
{
|
|
sb.Append(string.IsNullOrEmpty(data)
|
|
? _Value.ToString()
|
|
: String.Format("{0:" + data + "}", _Value));
|
|
}
|
|
else
|
|
{
|
|
base.ProcessTemplateText(gauge, sb, key, data);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CopyToItem
|
|
|
|
public override void CopyToItem(GaugeItem copy)
|
|
{
|
|
GaugeIndicator c = copy as GaugeIndicator;
|
|
|
|
if (c != null)
|
|
{
|
|
base.CopyToItem(c);
|
|
|
|
c.AutoSize = _AutoSize;
|
|
|
|
if (_BackColor != null)
|
|
c.BackColor = (GradientFillColor)_BackColor.Clone();
|
|
|
|
c.DampeningSweepTime = _DampeningSweepTime;
|
|
c.EmptyString = _EmptyString;
|
|
|
|
if (_Font != null)
|
|
c.Font = (Font)_Font.Clone();
|
|
|
|
c.Location = _Location;
|
|
c.MaxValue = _MaxValue;
|
|
c.MinValue = _MinValue;
|
|
c.OverRangeString = _OverRangeString;
|
|
c.RefreshRate = _RefreshRate;
|
|
c.Size = _Size;
|
|
c.Text = _Text;
|
|
c.UnderRangeString = _UnderRangeString;
|
|
c.UnderScale = _UnderScale;
|
|
c.Value = _Value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|