/// <summary>
/// Create validation attribute
/// </summary>
/// <returns>Return the validation attribute</returns>
public override ValidationAttribute CreateValidationAttribute(ValidationAttributeParameter parameter)
{
return(new RangeAttribute(DataType, Minimum?.ToString(), Maximum?.ToString())
{
ErrorMessage = FormatMessage(parameter.ErrorMessage)
});
}
/// <summary>
/// Generate our gauge image
/// </summary>
public void GenerateGaugeImage(PaintEventArgs pe)
{
Graphics g = pe.Graphics;
g.Clear(Color.Black);
Rectangle Bounds = new Rectangle(0, 0, ClientRectangle.Width - 1, ClientRectangle.Height - 1);
float Radius = Bounds.Width / 2f;
PointF Center = new PointF(Bounds.Width / 2f, Bounds.Height / 2f);
using (SolidBrush BackBrush = new SolidBrush(Color.FromArgb(16, 16, 16)))
g.FillEllipse(BackBrush, Bounds);
//Draw our bands as requested
if (ErrorRangeMinimum.HasValue && ErrorRangeMaximum.HasValue)
{
DrawBand(g, ErrorRangeMinimum.Value, ErrorRangeMaximum.Value, Brushes.Red);
}
if (WarningRangeMinimum.HasValue && WarningRangeMaximum.HasValue)
{
DrawBand(g, WarningRangeMinimum.Value, WarningRangeMaximum.Value, Brushes.Yellow);
}
if (GoodRangeMinimum.HasValue && GoodRangeMaximum.HasValue)
{
DrawBand(g, GoodRangeMinimum.Value, GoodRangeMaximum.Value, Brushes.Green);
}
for (int Angle = MinimumAngle; Angle <= MaximumAngle; Angle += 5)
{
g.DrawLine(Pens.Gray, Offset(Radius - 3, Angle), Offset(Radius - (Angle % 15 == 0 ? 15 : 10), Angle));
}
using (Pen DrawPen = new Pen(Color.Gray, 3))
g.DrawEllipse(DrawPen, Bounds);
using (Pen DrawPen = new Pen(Color.White, 3))
g.DrawEllipse(DrawPen, 2, 2, Bounds.Width - 4, Bounds.Height - 4);
WriteText(g, Radius - 30, MinimumAngle, Minimum.ToString(NumberFormat), Brushes.DarkGray, this.Font);
WriteText(g, Radius - 30, MaximumAngle, Maximum.ToString(NumberFormat), Brushes.DarkGray, this.Font);
}
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
_upButton = Template.FindName("UpButton", this) as RepeatButton;
_downButton = Template.FindName("DownButton", this) as RepeatButton;
_textBox = Template.FindName("InternalBox", this) as TextBox;
_textBox.Text = Minimum.ToString();
_upButton.Click += _UpButton_Click;
_downButton.Click += _DownButton_Click;
_textBox.TextChanged += _textBox_TextChanged;
_textBox.PreviewTextInput += _textBox_PreviewTextInput;
_textBox.MouseWheel += _textBox_MouseWheel;
_textBox.LostFocus += _textBox_LostFocus;
Value = Value == 1 ? Minimum : Value;
AddHandler(DataObject.PastingEvent, new DataObjectPastingEventHandler(PastingEvent));
InternalValueChanged += (sender, args) => { _textBox.Text = Value.ToString(); };
}
private void TextBox_LostFocus(object sender, RoutedEventArgs e)
{
TextBox target = sender as TextBox;
if (int.TryParse(target.Text, out int inputNumber))
{
if (inputNumber < Minimum)
{
Text = Minimum.ToString();
}
else if (inputNumber > Maximum)
{
Text = Maximum.ToString();
}
}
else
{
Text = DefaultValue.ToString();
}
OnValueChanged(new TextChangedEventArgs(e.RoutedEvent, UndoAction.None));
}
public override string ToString()
{
if (Minimum == Maximum)
{
return(Minimum.ToString());
}
if (Maximum == int.MaxValue)
{
if (Multiplicity > 1)
{
return(string.Format(@"{0}-{1}n", Minimum, Multiplicity));
}
else
{
return(string.Format(@"{0}-n", Minimum));
}
}
return(string.Format(@"{0}-{1}", Minimum, Maximum));
}
protected override void OnPreRender(EventArgs e)
{
Attributes["Minimum"] = Minimum.ToString();
Attributes["Maximum"] = Maximum.ToString();
Attributes["StepSize"] = StepSize.ToString();
var plusImage = new Image {
ImageUrl = PlusImageUrl
};
var minusImage = new Image {
ImageUrl = MinusImageUrl
};
PlusLink.Controls.Add(plusImage);
MinusLink.Controls.Add(minusImage);
PlusLink.NavigateUrl = "javascript:numericUpDown_AddValue('{0}', {1});".FormatWith(ClientID, StepSize);
MinusLink.NavigateUrl = "javascript:numericUpDown_AddValue('{0}', -{1});".FormatWith(ClientID, StepSize);
Page.ClientScript.RegisterClientScriptBlock(GetType(), "Script for NumericUpDown", ScriptFormat, addScriptTags: true);
base.OnPreRender(e);
}
public override string FormatErrorMessage(string name)
{
if (Minimum is int)
{
if ((int)Minimum == int.MinValue)
{
return($"{name}不大于{Maximum}");
}
else
{
return($"{name}不小于{Minimum}，不大于{Maximum}");
}
}
if (Minimum is double)
{
if ((int)Minimum == double.MinValue)
{
return($"{name}不大于{Maximum}");
}
else
{
return($"{name}不小于{Minimum}，不大于{Maximum}");
}
}
if (decimal.TryParse(Minimum.ToString(), out decimal min))
{
if (min == decimal.MinValue)
{
return($"{name}不大于{Maximum}");
}
else
{
return($"{name}不小于{Minimum}，不大于{Maximum}");
}
}
return(base.FormatErrorMessage(name));
}
protected override void BuildRenderTree(Microsoft.AspNetCore.Components.Rendering.RenderTreeBuilder builder)
{
base.BuildRenderTree(builder);
var n = OpenElementWithCommonAttributes(builder, "div");
builder.AddAttribute(n++, "role", "slider");
if (Disabled)
{
builder.AddAttribute(n++, "aria-disabled", "true");
}
builder.AddAttribute(n++, "aria-valuemin", Minimum.ToString());
builder.AddAttribute(n++, "aria-valuemax", Maximum.ToString());
builder.AddAttribute(n++, "aria-valuenow", Value.ToString());
if (Step != null)
{
builder.AddAttribute(n++, "data-step", Step.Value.ToString());
}
builder.AddContent(n++, ChildContent);
builder.CloseElement();
}
/*public override void GeneralSvg(XmlElement g, Point translate, Font font)
* {
* //base.GeneralSvg(g);
* Shape shaper = Shape.GetShaper(TopicShape.Rectangle, 2);
* if (shaper != null)
* {
* Rectangle rect = Bounds;
* rect.Offset(translate);
* rect.Inflate(0, -2);
* XmlElement node = shaper.GenerateSvg(rect, g, Color.Empty, BackColor);
* g.AppendChild(node);
*
* if (Value > 0 && Maximum > Minimum)
* {
* rect.Inflate(-1, -1);
* rect.Width = (int)Math.Ceiling(rect.Width * (Math.Min(Maximum, Value) - Minimum) / (Maximum - Minimum));
* if (rect.Width > 0 && rect.Height > 0)
* {
* node = shaper.GenerateSvg(rect, g, Color.Empty, Color);
* g.AppendChild(node);
* }
* }
* }
*
* // text
* if (ShowText)
* {
* string text = string.Format("{0}%", Value);
* Rectangle rect = Bounds;
* rect.Offset(translate);
* Blumind.Core.Exports.SvgEngine.ExportText(text, ForeColor, font, g, rect);
* }
* }*/
public override void Serialize(XmlDocument dom, XmlElement node)
{
base.Serialize(dom, node);
node.SetAttribute("max", Maximum.ToString());
node.SetAttribute("min", Minimum.ToString());
node.SetAttribute("value", Value.ToString());
node.SetAttribute("show_text", ShowText.ToString());
node.SetAttribute("auto_calculation", AutoCalculation.ToString());
//node.SetAttribute("visible", Visible.ToString());
if (!Color.IsEmpty)
{
node.SetAttribute("color", ST.ToString(Color));
}
if (!BackColor.IsEmpty)
{
node.SetAttribute("back_color", ST.ToString(BackColor));
}
if (!ForeColor.IsEmpty)
{
node.SetAttribute("fore_color", ST.ToString(ForeColor));
}
}
public override string ToString()
{
if (Minimum != null && Maximum != null)
{
return(String.Format("{0} - {1}", Minimum, Maximum));
}
else if (Minimum != null)
{
return(Minimum.ToString());
}
else if (Maximum != null)
{
return(Maximum.ToString());
}
else if (Name != null)
{
return(Name.ToString());
}
else
{
return(String.Empty);
}
}
/// <summary>
/// Returns a string representation of this Range
/// </summary>
/// <returns></returns>
public override string ToString()
{
if (IsPoint)
{
return(Minimum.ToString());
}
if (this == INFINITY)
{
return("..");
}
if (!HasEnd)
{
return(Minimum + "..");
}
else if (!HasStart)
{
return(".." + Maximum);
}
return(Minimum + ".." + Maximum);
}
private void CheckMinimumMaximumCap(string str)
{
try
{
var tmp = Convert.ToDecimal(str, CultureInfo.InvariantCulture);
if (tmp > Maximum)
{
txtBox.Text = Maximum.ToString();
txtBox.SelectionStart = str.Length + 1;
txtBox.SelectionLength = 0;
Value = Maximum;
}
else if (tmp < Minimum)
{
txtBox.Text = Minimum.ToString();
txtBox.SelectionStart = str.Length + 1;
txtBox.SelectionLength = 0;
Value = Minimum;
}
else
{
Value = tmp;
}
}
catch (FormatException)
{
this.Value = this.DefaultValue;
}
catch (OverflowException)
{
this.Value = this.DefaultValue;
}
catch (Exception)
{
this.Value = this.DefaultValue;
}
}
public string WriteConstructor()
{
List <string> parameters = new List <string>
{
Required.ToBoolString(),
Units.WrapInQuotes(),
Minimum.ToString(),
Maximum.ToString(),
Default.WrapInQuotes(),
AutoCalculatable.ToBoolString(),
AutoSizeable.ToBoolString(),
$"IdfFieldAlphaNumeric.{AlphaNumeric}",
WriteKeys(),
Name.WrapInQuotes(),
$"IdfFieldMinMaxType.{MinType}",
$"IdfFieldMinMaxType.{MaxType}",
WriteStringList(ReferenceList),
WriteStringList(ReferenceClassList),
WriteStringList(ObjectList),
};
return
($"new IdfField({string.Join(",", parameters)})");
}
/// <include file='doc\ScrollBar.uex' path='docs/doc[@for="ScrollBar.ToString"]/*' />
/// <internalonly/>
/// <devdoc>
/// </devdoc>
public override string ToString()
{
string s = base.ToString();
return(s + ", Minimum: " + Minimum.ToString() + ", Maximum: " + Maximum.ToString() + ", Value: " + Value.ToString());
}
private void TextBox_TextChanged(object sender, TextChangedEventArgs e)
{
TextBox text = (TextBox)sender;
string value = text.Text;
if (text.IsFocused)
{
IsAction = true;
}
try
{
if (Value.ToString(_numberFormatInfo) != value)
{
int intvalue;
//Убираем всё лишнее
if (this.DecimalPlaces == 0)
{
value = value.Replace(".", "").Replace(",", "");
}
else
{
value = value.TrimEnd(new char[] { '.', ',' });
}
if (Int32.TryParse(value, NumberStyles.Integer, null, out intvalue))
{
decimal dvalue = Convert.ToDecimal(value);
if (dvalue > Maximum)
{
Value = Maximum;
text.Text = Maximum.ToString(_numberFormatInfo);
}
else if (dvalue < Minimum)
{
Value = Minimum;
text.Text = Minimum.ToString(_numberFormatInfo);
}
else
{
Value = dvalue;
if (this.DecimalPlaces == 0)
{
text.Text = Value.ToString(_numberFormatInfo);
}
}
}
else
{
double double_value;
string sep = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;
value = value.Replace(".", sep).Replace(",", sep);
if (value.Contains(sep))
{
//Отрезаем лишнюю десятичную часть; Decimal.Round() - округляет последний символ, не годится
value = value.Substring(0, Math.Min(value.Length, value.IndexOf(sep) + this.DecimalPlaces + 1));
}
if (Double.TryParse(value, out double_value))
{
decimal dvalue = Convert.ToDecimal(double_value);
if (dvalue > Maximum)
{
Value = Maximum;
}
else if (dvalue < Minimum)
{
Value = Minimum;
}
else
{
Value = dvalue;
}
text.Text = Value.ToString(_numberFormatInfo);
}
else
{
text.Text = Value.ToString(_numberFormatInfo);
}
}
text.CaretIndex = text.ToString().Length;
}
}
catch
{
text.Text = Value.ToString(_numberFormatInfo);
text.CaretIndex = text.ToString().Length;
}
IsAction = false;
}
public virtual string ToString(string format)
{
return($"[{Minimum.ToString(format, System.Globalization.CultureInfo.InvariantCulture)};{Maximum.ToString(format, System.Globalization.CultureInfo.InvariantCulture)}]");
}
public string Get(string propertyName)
{
switch (propertyName)
{
//ELEMENT
case nameof(ClassId):
return(ClassId.ToString());
case nameof(AutomationId):
return(AutomationId.ToString());
case nameof(Id):
return(Id.ToString());
case nameof(StyleId):
return(StyleId.ToString());
//VISUAL ELEMENT
case nameof(AnchorX):
return(AnchorX.ToString());
case nameof(AnchorY):
return(AnchorY.ToString());
case nameof(BackgroundColor):
return(BackgroundColor.ToHex());
case nameof(Width):
return(this.Width.ToString());
case nameof(Height):
return(this.Height.ToString());
case nameof(IsEnabled):
return(IsEnabled.ToString());
case nameof(WidthRequest):
return(this.WidthRequest.ToString());
case nameof(HeightRequest):
return(this.HeightRequest.ToString());
case nameof(IsFocused):
return(IsFocused.ToString());
case nameof(IsVisible):
return(IsVisible.ToString());
case nameof(InputTransparent):
return(InputTransparent.ToString());
case nameof(X):
return(this.X.ToString());
case nameof(Y):
return(this.Y.ToString());
case nameof(Opacity):
return(this.Opacity.ToString());
case nameof(TranslationX):
return(this.TranslationX.ToString());
case nameof(TranslationY):
return(this.TranslationY.ToString());
case nameof(Rotation):
return(this.Rotation.ToString());
case nameof(RotationX):
return(this.RotationX.ToString());
case nameof(RotationY):
return(this.RotationY.ToString());
case nameof(Scale):
return(this.Scale.ToString());
//VIEW
case nameof(Margin):
return(this.Margin.ToString());
case nameof(VerticalOptions):
return(this.VerticalOptions.ToString());
case nameof(HorizontalOptions):
return(this.HorizontalOptions.ToString());
//STEPPER
case nameof(Maximum):
return(Maximum.ToString());
case nameof(Minimum):
return(Minimum.ToString());
case nameof(Value):
return(Value.ToString());
case nameof(Increment):
return(Increment.ToString());
default:
return(string.Empty);
}
}
protected override void OnTextChanged(EventArgs e)
{
if (ignoreNextCheck)
{
ignoreNextCheck = false;
return;
}
// After we validated or the key press the text will be changed,
// so we need to recheck it in case their is some misbehavior
keyCapture = new KeyEventArgs(Keys.None);
string checkedString = string.Empty;
for (int i = 0; i < Text.Length; i++)
{
if (IsValidCharacter(Text[i], i, checkedString))
{
checkedString += Text[i];
}
else
{
IgnoreChanges();
return;
}
}
// Text is good but let's check if it is clamped
if (!IgnoreClamping)
{
if (UsedFilter == Filter.Digits)
{
if (Text == string.Empty)
{
return;
}
float f = ParseFloatValue(Text);
if (f < Minimum)
{
IgnoreChanges(Minimum.ToString());
}
if (f > Maximum)
{
IgnoreChanges(Maximum.ToString());
}
}
else if (UsedFilter == Filter.DigitList)
{
string[] fl = Text.Split(' ');
bool badInput = false;
for (int i = 0; i < fl.Length; i++)
{
if (fl[i] == string.Empty)
{
// Return and ignore everything if a string is empty since it will value 0
// and it will be corrected by minimum if it's bigger than 0 Sooo...
return;
}
float f = ParseFloatValue(fl[i]);
if (f < Minimum)
{
fl[i] = Minimum.ToString();
badInput = true;
}
if (f > Maximum)
{
fl[i] = Maximum.ToString();
badInput = true;
}
}
if (badInput)
{
IgnoreChanges(string.Join(" ", fl));
}
}
}
// If text is good remember it :D
lastGoodText = Text;
OnSafeTextChange?.Invoke(this, lastGoodText);
base.OnTextChanged(e);
}
/// <summary>
/// Presents the Range in readable format
/// </summary>
/// <returns>String representation of the Range</returns>
public override string ToString()
{
return(Minimum.CompareTo(Maximum) == 0 ? Minimum.ToString() : $"{Minimum} - {Maximum}");
}
public string ToString(string format, IFormatProvider formatProvider)
{
return(String.Format(_cachedStringFormat,
Minimum.ToString(format, formatProvider),
Maximum.ToString(format, formatProvider)));
}
public string ToStringInvariant(string format)
{
return(String.Format(_cachedStringFormat,
Minimum.ToString(format, CultureInfo.InvariantCulture),
Maximum.ToString(format, CultureInfo.InvariantCulture)));
}
public void Serialize(StringBuilder sb)
{
sb.Append(((int)Type).ToString("X2")).Append('#');
sb.Append(Minimum.ToString("X2")).Append('#');
sb.Append(Maximum.ToString("X2"));
}
public override string ToString(string format)
{
return(string.Format("{0} - {1} Da", Minimum.ToString(format), Maximum.ToString(format)));
}
protected override void OnRender(DrawingContext dc)
{
if (Children.Count < 3 || Ticks < 0)
{
return;
}
var steps = Children.Count;
var deltaAngle = 360D / steps;
var center = new Point(RenderSize.Width / 2, RenderSize.Height / 2);
var radius = Math.Min(RenderSize.Width, RenderSize.Height) / 2;
//dc.DrawEllipse(null, pen, center, radius, radius);
// Draw the background ticks between minRadius and maxRadius
var minRadius = radius / 10;
var maxRadius = radius * .8;
var deltaRadius = (maxRadius - minRadius);
var deltaTickRadius = deltaRadius / (Ticks - 1);
var spokeLength = maxRadius + 10;
for (var i = 0; i < Ticks; i++)
{
var curRadius = minRadius + i * deltaTickRadius;
var angle = 0D;
var p1 = GetPoint(center, curRadius, angle);
for (var j = 0; j < steps; j++)
{
angle = (j + 1) * deltaAngle;
var p2 = GetPoint(center, curRadius, angle);
dc.DrawLine(DashedPen, p1, p2);
p1 = p2;
}
// Draw the labels
p1 = new Point(p1.X + 5, p1.Y - 15);
if (i == 0)
{
dc.DrawText(new FormattedText(Minimum.ToString(CultureInfo.InvariantCulture), CultureInfo.GetCultureInfo("en-us"), FlowDirection.LeftToRight, LabelFont, 14, Brushes.Black), p1);
}
else if (i == Ticks - 1)
{
dc.DrawText(new FormattedText(Maximum.ToString(CultureInfo.InvariantCulture), CultureInfo.GetCultureInfo("en-us"), FlowDirection.LeftToRight, LabelFont, 14, Brushes.Black), p1);
}
}
// Draw the spokes
for (var i = 0; i < steps; i++)
{
var angle = i * deltaAngle;
var p1 = GetPoint(center, spokeLength, angle);
dc.DrawLine(Pen, center, p1);
}
// Draw the chart lines
if (Lines == null)
{
return;
}
var scale = Maximum - Minimum;
if (scale <= 0)
{
return;
}
foreach (var line in Lines)
{
var angle = 0D;
var curRadius = minRadius + (line.PointDataSource[0] - Minimum) * deltaRadius / scale;
var p1 = GetPoint(center, curRadius, angle);
var myPathFigure = new PathFigure
{
StartPoint = p1,
Segments = new PathSegmentCollection()
};
var pts = new PointCollection(steps)
{
p1
};
for (var j = 1; j < steps; j++)
{
angle = (j) * deltaAngle;
curRadius = minRadius + (line.PointDataSource[j] - Minimum) * deltaRadius / scale;
var p2 = GetPoint(center, curRadius, angle);
myPathFigure.Segments.Add(new LineSegment {
Point = p2
});
pts.Add(p2);
}
myPathFigure.Segments.Add(new LineSegment {
Point = p1
});
var myPathGeometry = new PathGeometry {
Figures = new PathFigureCollection {
myPathFigure
}
};
var pen = new Pen(new SolidColorBrush(line.LineColor), line.LineThickness);
dc.DrawGeometry(line.FillColor == Colors.Transparent ? null : new SolidColorBrush(line.FillColor), pen, myPathGeometry);
var brush = new SolidColorBrush(line.LineColor);
// Draw fat circles on each data point
foreach (var pt in pts)
{
dc.DrawEllipse(brush, pen, pt, line.LineThickness + 2, line.LineThickness + 2);
}
}
}
private void DefineArithmeticProgressionDialog_Load(object sender, System.EventArgs e)
{
minimumTextBox.Text = Minimum.ToString();
maximumTextBox.Text = Maximum.ToString();
stepSizeTextBox.Text = Step.ToString();
}
private void ResetText(TextBox tb)
{
tb.Text = 0 < Minimum?Minimum.ToString() : "0";
tb.SelectAll();
}
/// <summary>
/// Returns a string representation of this range at the given numerical format
/// </summary>
/// <param name="format">The format to display the double values</param>
/// <returns></returns>
public virtual string ToString(string format)
{
return(string.Format("[{0} - {1}]", Minimum.ToString(format), Maximum.ToString(format)));
}
public override string ToString()
{
return("{Minimum=" + Minimum.ToString() + ",Maximum=" + Maximum.ToString() + "}");
}
/// <include file='doc\ProgressBar.uex' path='docs/doc[@for="ProgressBar.ToString"]/*' />
/// <devdoc>
/// Returns a string representation for this control.
/// </devdoc>
/// <internalonly/>
public override string ToString()
{
string s = base.ToString();
return(s + ", Minimum: " + Minimum.ToString(CultureInfo.CurrentCulture) + ", Maximum: " + Maximum.ToString(CultureInfo.CurrentCulture) + ", Value: " + Value.ToString(CultureInfo.CurrentCulture));
}
/// <summary>
/// Draws the text for Minimum and Maximum
/// </summary>
/// <param name="g"></param>
/// <param name="clipRectangle"></param>
protected virtual void OnDrawText(Graphics g, Rectangle clipRectangle)
{
_textRectangle = TextBounds(g);
SizeF labelSize = LabelSize(g);
SizeF minSize = g.MeasureString(Minimum.ToString(), Font);
SizeF maxSize = g.MeasureString(Maximum.ToString(), Font);
Brush fontBrush = new SolidBrush(ForeColor);
PointF centerTl = new PointF((Width - labelSize.Width) / 2, (Height - labelSize.Height) / 2);
if (_orientation == Orientation.Vertical)
{
//if (Height < labelSize.Height) return;
if (_showValue)
{
g.DrawString(Value.ToString(_numberFormat), Font, fontBrush, new PointF(_textRectangle.X, centerTl.Y));
}
//if (Height < labelSize.Height * 3) return;
if (_flipRamp)
{
if (_showMinimum)
{
g.DrawString(Minimum.ToString(_numberFormat), Font, fontBrush, new PointF(_textRectangle.X, _textRectangle.Top));
}
if (_showMaximum)
{
g.DrawString(Maximum.ToString(_numberFormat), Font, fontBrush, new PointF(_textRectangle.X, _textRectangle.Bottom - labelSize.Height));
}
}
else
{
if (_showMaximum)
{
g.DrawString(Maximum.ToString(_numberFormat), Font, fontBrush, new PointF(_textRectangle.X, _textRectangle.Top));
}
if (_showMinimum)
{
g.DrawString(Minimum.ToString(_numberFormat), Font, fontBrush, new PointF(_textRectangle.X, _textRectangle.Bottom - labelSize.Height));
}
}
}
else
{
//if (Width < labelSize.Width) return;
if (_showValue)
{
g.DrawString(Value.ToString(_numberFormat), Font, fontBrush, new PointF(centerTl.X, _textRectangle.Top));
}
//if (Width < labelSize.Width * 3) return;
if (_flipRamp)
{
if (_showMaximum)
{
g.DrawString(Maximum.ToString(_numberFormat), Font, fontBrush, new PointF(_textRectangle.X, _textRectangle.Top));
}
if (_showMinimum)
{
g.DrawString(Minimum.ToString(_numberFormat), Font, fontBrush, new PointF(_textRectangle.Width - minSize.Width, _textRectangle.Top));
}
}
else
{
if (_showMinimum)
{
g.DrawString(Minimum.ToString(_numberFormat), Font, fontBrush, new PointF(_textRectangle.X, _textRectangle.Top));
}
if (_showMaximum)
{
g.DrawString(Maximum.ToString(_numberFormat), Font, fontBrush, new PointF(_textRectangle.Width - maxSize.Width, _textRectangle.Top));
}
}
}
}
