Korero – Rev 1
?pathlinks?
using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
namespace AquaControls
{
/// <summary>
/// Aqua Gauge Control - A Windows User Control.
/// Author : Ambalavanar Thirugnanam
/// Date : 24th August 2007
/// email : ambalavanar.thiru@gmail.com
/// This is control is for free. You can use for any commercial or non-commercial purposes.
/// [Please do no remove this header when using this control in your application.]
/// </summary>
public partial class AquaGauge : UserControl
{
#region Constructors, Destructors and Finalizers
public AquaGauge()
{
InitializeComponent();
x = 5;
y = 5;
width = Width - 10;
height = Height - 10;
noOfDivisions = 10;
noOfSubDivisions = 3;
SetStyle(ControlStyles.SupportsTransparentBackColor, true);
SetStyle(ControlStyles.ResizeRedraw, true);
SetStyle(ControlStyles.AllPaintingInWmPaint, true);
SetStyle(ControlStyles.UserPaint, true);
SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
BackColor = Color.Transparent;
Resize += AquaGauge_Resize;
requiresRedraw = true;
}
#endregion
#region Private Attributes
private float minValue;
private float maxValue;
private float threshold;
private float currentValue;
private float recommendedValue;
private int noOfDivisions;
private int noOfSubDivisions;
private string dialText;
private Color dialColor = Color.Lavender;
private float glossinessAlpha = 25;
private int oldWidth, oldHeight;
private readonly int x;
private readonly int y;
private int width, height;
private readonly float fromAngle = 135F;
private readonly float toAngle = 405F;
private bool enableTransparentBackground;
private bool requiresRedraw;
private Image backgroundImg;
private Rectangle rectImg;
#endregion
#region Public Properties
/// <summary>
/// Mininum value on the scale
/// </summary>
[DefaultValue(0)]
[Description("Mininum value on the scale")]
public float MinValue
{
get => minValue;
set
{
if (value < maxValue)
{
minValue = value;
if (currentValue < minValue)
{
currentValue = minValue;
}
if (recommendedValue < minValue)
{
recommendedValue = minValue;
}
requiresRedraw = true;
Invalidate();
}
}
}
/// <summary>
/// Maximum value on the scale
/// </summary>
[DefaultValue(100)]
[Description("Maximum value on the scale")]
public float MaxValue
{
get => maxValue;
set
{
if (value > minValue)
{
maxValue = value;
if (currentValue > maxValue)
{
currentValue = maxValue;
}
if (recommendedValue > maxValue)
{
recommendedValue = maxValue;
}
requiresRedraw = true;
Invalidate();
}
}
}
/// <summary>
/// Gets or Sets the Threshold area from the Recommended Value. (1-99%)
/// </summary>
[DefaultValue(25)]
[Description("Gets or Sets the Threshold area from the Recommended Value. (1-99%)")]
public float ThresholdPercent
{
get => threshold;
set
{
if (value > 0 && value < 100)
{
threshold = value;
requiresRedraw = true;
Invalidate();
}
}
}
/// <summary>
/// Threshold value from which green area will be marked.
/// </summary>
[DefaultValue(25)]
[Description("Threshold value from which green area will be marked.")]
public float RecommendedValue
{
get => recommendedValue;
set
{
if (value > minValue && value < maxValue)
{
recommendedValue = value;
requiresRedraw = true;
Invalidate();
}
}
}
/// <summary>
/// Value where the pointer will point to.
/// </summary>
[DefaultValue(0)]
[Description("Value where the pointer will point to.")]
public float Value
{
get => currentValue;
set
{
if (value >= minValue && value <= maxValue)
{
currentValue = value;
Refresh();
}
}
}
/// <summary>
/// Background color of the dial
/// </summary>
[Description("Background color of the dial")]
public Color DialColor
{
get => dialColor;
set
{
dialColor = value;
requiresRedraw = true;
Invalidate();
}
}
/// <summary>
/// Glossiness strength. Range: 0-100
/// </summary>
[DefaultValue(72)]
[Description("Glossiness strength. Range: 0-100")]
public float Glossiness
{
get => glossinessAlpha * 100 / 220;
set
{
var val = value;
if (val > 100)
{
value = 100;
}
if (val < 0)
{
value = 0;
}
glossinessAlpha = value * 220 / 100;
Refresh();
}
}
/// <summary>
/// Get or Sets the number of Divisions in the dial scale.
/// </summary>
[DefaultValue(10)]
[Description("Get or Sets the number of Divisions in the dial scale.")]
public int NoOfDivisions
{
get => noOfDivisions;
set
{
if (value > 1 && value < 25)
{
noOfDivisions = value;
requiresRedraw = true;
Invalidate();
}
}
}
/// <summary>
/// Gets or Sets the number of Sub Divisions in the scale per Division.
/// </summary>
[DefaultValue(3)]
[Description("Gets or Sets the number of Sub Divisions in the scale per Division.")]
public int NoOfSubDivisions
{
get => noOfSubDivisions;
set
{
if (value > 0 && value <= 10)
{
noOfSubDivisions = value;
requiresRedraw = true;
Invalidate();
}
}
}
/// <summary>
/// Gets or Sets the Text to be displayed in the dial
/// </summary>
[Description("Gets or Sets the Text to be displayed in the dial")]
public string DialText
{
get => dialText;
set
{
dialText = value;
requiresRedraw = true;
Invalidate();
}
}
/// <summary>
/// Enables or Disables Transparent Background color.
/// Note: Enabling this will reduce the performance and may make the control flicker.
/// </summary>
[DefaultValue(false)]
[Description(
"Enables or Disables Transparent Background color. Note: Enabling this will reduce the performance and may make the control flicker.")]
public bool EnableTransparentBackground
{
get => enableTransparentBackground;
set
{
enableTransparentBackground = value;
SetStyle(ControlStyles.OptimizedDoubleBuffer, !enableTransparentBackground);
requiresRedraw = true;
Refresh();
}
}
#endregion
#region Overriden Control methods
/// <summary>
/// Draws the pointer.
/// </summary>
/// <param name="e"></param>
protected override void OnPaint(PaintEventArgs e)
{
e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
width = Width - x * 2;
height = Height - y * 2;
DrawPointer(e.Graphics, width / 2 + x, height / 2 + y);
}
/// <summary>
/// Draws the dial background.
/// </summary>
/// <param name="e"></param>
protected override void OnPaintBackground(PaintEventArgs e)
{
if (!enableTransparentBackground)
{
base.OnPaintBackground(e);
}
e.Graphics.SmoothingMode = SmoothingMode.HighQuality;
e.Graphics.FillRectangle(new SolidBrush(Color.Transparent), new Rectangle(0, 0, Width, Height));
if (backgroundImg == null || requiresRedraw)
{
backgroundImg = new Bitmap(Width, Height);
var g = Graphics.FromImage(backgroundImg);
g.SmoothingMode = SmoothingMode.HighQuality;
width = Width - x * 2;
height = Height - y * 2;
rectImg = new Rectangle(x, y, width, height);
//Draw background color
Brush backGroundBrush = new SolidBrush(Color.FromArgb(120, dialColor));
if (enableTransparentBackground && Parent != null)
{
float gg = width / 60;
//g.FillEllipse(new SolidBrush(this.Parent.BackColor), -gg, -gg, this.Width+gg*2, this.Height+gg*2);
}
g.FillEllipse(backGroundBrush, x, y, width, height);
//Draw Rim
var outlineBrush = new SolidBrush(Color.FromArgb(100, Color.SlateGray));
var outline = new Pen(outlineBrush, (float) (width * .03));
g.DrawEllipse(outline, rectImg);
var darkRim = new Pen(Color.SlateGray);
g.DrawEllipse(darkRim, x, y, width, height);
//Draw Callibration
DrawCalibration(g, rectImg, width / 2 + x, height / 2 + y);
//Draw Colored Rim
var colorPen = new Pen(Color.FromArgb(190, Color.Gainsboro), Width / 40);
var blackPen = new Pen(Color.FromArgb(250, Color.Black), Width / 200);
var gap = (int) (Width * 0.03F);
var rectg = new Rectangle(rectImg.X + gap, rectImg.Y + gap, rectImg.Width - gap * 2,
rectImg.Height - gap * 2);
g.DrawArc(colorPen, rectg, 135, 270);
//Draw Threshold
colorPen = new Pen(Color.FromArgb(200, Color.LawnGreen), Width / 50);
rectg = new Rectangle(rectImg.X + gap, rectImg.Y + gap, rectImg.Width - gap * 2,
rectImg.Height - gap * 2);
var val = MaxValue - MinValue;
val = 100 * (recommendedValue - MinValue) / val;
val = (toAngle - fromAngle) * val / 100;
val += fromAngle;
var stAngle = val - 270 * threshold / 200;
if (stAngle <= 135)
{
stAngle = 135;
}
var sweepAngle = 270 * threshold / 100;
if (stAngle + sweepAngle > 405)
{
sweepAngle = 405 - stAngle;
}
g.DrawArc(colorPen, rectg, stAngle, sweepAngle);
//Draw Digital Value
/* RectangleF digiRect = new RectangleF((float)this.Width / 2F - (float)this.width / 5F, (float)this.height / 1.2F, (float)this.width / 2.5F, (float)this.Height / 9F);
RectangleF digiFRect = new RectangleF(this.Width / 2 - this.width / 7, (int)(this.height / 1.18), this.width / 4, this.Height / 12);
g.FillRectangle(new SolidBrush(Color.FromArgb(30, Color.Gray)), digiRect);
DisplayNumber(g, this.currentValue, digiFRect); */
var textSize = g.MeasureString(dialText, Font);
var digiFRectText = new RectangleF(Width / 2 - textSize.Width / 2, (int) (height / 1.5), textSize.Width,
textSize.Height);
g.DrawString(dialText, Font, new SolidBrush(ForeColor), digiFRectText);
requiresRedraw = false;
}
e.Graphics.DrawImage(backgroundImg, rectImg);
}
protected override CreateParams CreateParams
{
get
{
var cp = base.CreateParams;
cp.ExStyle |= 0x20;
return cp;
}
}
#endregion
#region Private methods
/// <summary>
/// Draws the Pointer.
/// </summary>
/// <param name="gr"></param>
/// <param name="cx"></param>
/// <param name="cy"></param>
private void DrawPointer(Graphics gr, int cx, int cy)
{
var radius = Width / 2 - Width * .12F;
var val = MaxValue - MinValue;
Image img = new Bitmap(Width, Height);
var g = Graphics.FromImage(img);
g.SmoothingMode = SmoothingMode.AntiAlias;
val = 100 * (currentValue - MinValue) / val;
val = (toAngle - fromAngle) * val / 100;
val += fromAngle;
var angle = GetRadian(val);
var gradientAngle = angle;
var pts = new PointF[5];
pts[0].X = (float) (cx + radius * Math.Cos(angle));
pts[0].Y = (float) (cy + radius * Math.Sin(angle));
pts[4].X = (float) (cx + radius * Math.Cos(angle - 0.02));
pts[4].Y = (float) (cy + radius * Math.Sin(angle - 0.02));
angle = GetRadian(val + 20);
pts[1].X = (float) (cx + Width * .09F * Math.Cos(angle));
pts[1].Y = (float) (cy + Width * .09F * Math.Sin(angle));
pts[2].X = cx;
pts[2].Y = cy;
angle = GetRadian(val - 20);
pts[3].X = (float) (cx + Width * .09F * Math.Cos(angle));
pts[3].Y = (float) (cy + Width * .09F * Math.Sin(angle));
Brush pointer = new SolidBrush(Color.Black);
g.FillPolygon(pointer, pts);
var shinePts = new PointF[3];
angle = GetRadian(val);
shinePts[0].X = (float) (cx + radius * Math.Cos(angle));
shinePts[0].Y = (float) (cy + radius * Math.Sin(angle));
angle = GetRadian(val + 20);
shinePts[1].X = (float) (cx + Width * .09F * Math.Cos(angle));
shinePts[1].Y = (float) (cy + Width * .09F * Math.Sin(angle));
shinePts[2].X = cx;
shinePts[2].Y = cy;
var gpointer = new LinearGradientBrush(shinePts[0], shinePts[2], Color.SlateGray, Color.Black);
g.FillPolygon(gpointer, shinePts);
var rect = new Rectangle(x, y, width, height);
DrawCenterPoint(g, rect, width / 2 + x, height / 2 + y);
DrawGloss(g);
gr.DrawImage(img, 0, 0);
}
/// <summary>
/// Draws the glossiness.
/// </summary>
/// <param name="g"></param>
private void DrawGloss(Graphics g)
{
var glossRect = new RectangleF(
x + (float) (width * 0.10),
y + (float) (height * 0.07),
(float) (width * 0.80),
(float) (height * 0.7));
var gradientBrush =
new LinearGradientBrush(glossRect,
Color.FromArgb((int) glossinessAlpha, Color.White),
Color.Transparent,
LinearGradientMode.Vertical);
g.FillEllipse(gradientBrush, glossRect);
//TODO: Gradient from bottom
glossRect = new RectangleF(
x + (float) (width * 0.25),
y + (float) (height * 0.77),
(float) (width * 0.50),
(float) (height * 0.2));
var gloss = (int) (glossinessAlpha / 3);
gradientBrush =
new LinearGradientBrush(glossRect,
Color.Transparent, Color.FromArgb(gloss, BackColor),
LinearGradientMode.Vertical);
g.FillEllipse(gradientBrush, glossRect);
}
/// <summary>
/// Draws the center point.
/// </summary>
/// <param name="g"></param>
/// <param name="rect"></param>
/// <param name="cX"></param>
/// <param name="cY"></param>
private void DrawCenterPoint(Graphics g, Rectangle rect, int cX, int cY)
{
float shift = Width / 5;
var rectangle = new RectangleF(cX - shift / 2, cY - shift / 2, shift, shift);
var brush = new LinearGradientBrush(rect, Color.Black, Color.FromArgb(100, dialColor),
LinearGradientMode.Vertical);
g.FillEllipse(brush, rectangle);
shift = Width / 7;
rectangle = new RectangleF(cX - shift / 2, cY - shift / 2, shift, shift);
brush = new LinearGradientBrush(rect, Color.SlateGray, Color.Black, LinearGradientMode.ForwardDiagonal);
g.FillEllipse(brush, rectangle);
}
/// <summary>
/// Draws the Ruler
/// </summary>
/// <param name="g"></param>
/// <param name="rect"></param>
/// <param name="cX"></param>
/// <param name="cY"></param>
private void DrawCalibration(Graphics g, Rectangle rect, int cX, int cY)
{
var noOfParts = noOfDivisions + 1;
var noOfIntermediates = noOfSubDivisions;
var currentAngle = GetRadian(fromAngle);
var gap = (int) (Width * 0.01F);
float shift = Width / 25;
var rectangle = new Rectangle(rect.Left + gap, rect.Top + gap, rect.Width - gap, rect.Height - gap);
float x, y, x1, y1, tx, ty, radius;
radius = rectangle.Width / 2 - gap * 5;
var totalAngle = toAngle - fromAngle;
var incr = GetRadian(totalAngle / ((noOfParts - 1) * (noOfIntermediates + 1)));
var thickPen = new Pen(Color.Black, Width / 50);
var thinPen = new Pen(Color.Black, Width / 100);
var rulerValue = MinValue;
for (var i = 0; i <= noOfParts; i++)
{
//Draw Thick Line
x = (float) (cX + radius * Math.Cos(currentAngle));
y = (float) (cY + radius * Math.Sin(currentAngle));
x1 = (float) (cX + (radius - Width / 20) * Math.Cos(currentAngle));
y1 = (float) (cY + (radius - Width / 20) * Math.Sin(currentAngle));
g.DrawLine(thickPen, x, y, x1, y1);
//Draw Strings
var format = new StringFormat();
tx = (float) (cX + (radius - Width / 10) * Math.Cos(currentAngle));
ty = (float) (cY - shift + (radius - Width / 10) * Math.Sin(currentAngle));
Brush stringPen = new SolidBrush(ForeColor);
var strFormat = new StringFormat(StringFormatFlags.NoClip);
strFormat.Alignment = StringAlignment.Center;
var f = new Font(Font.FontFamily, Width / 23, Font.Style);
g.DrawString(rulerValue + "", f, stringPen, new PointF(tx, ty), strFormat);
rulerValue += (MaxValue - MinValue) / (noOfParts - 1);
rulerValue = (float) Math.Round(rulerValue, 2);
//currentAngle += incr;
if (i == noOfParts - 1)
{
break;
}
for (var j = 0; j <= noOfIntermediates; j++)
{
//Draw thin lines
currentAngle += incr;
x = (float) (cX + radius * Math.Cos(currentAngle));
y = (float) (cY + radius * Math.Sin(currentAngle));
x1 = (float) (cX + (radius - Width / 50) * Math.Cos(currentAngle));
y1 = (float) (cY + (radius - Width / 50) * Math.Sin(currentAngle));
g.DrawLine(thinPen, x, y, x1, y1);
}
}
}
/// <summary>
/// Converts the given degree to radian.
/// </summary>
/// <param name="theta"></param>
/// <returns></returns>
public float GetRadian(float theta)
{
return theta * (float) Math.PI / 180F;
}
/// <summary>
/// Displays the given number in the 7-Segement format.
/// </summary>
/// <param name="g"></param>
/// <param name="number"></param>
/// <param name="drect"></param>
private void DisplayNumber(Graphics g, float number, RectangleF drect)
{
try
{
var num = number.ToString("000.00");
num.PadLeft(3, '0');
float shift = 0;
if (number < 0)
{
shift -= width / 17;
}
var drawDPS = false;
var chars = num.ToCharArray();
for (var i = 0; i < chars.Length; i++)
{
var c = chars[i];
if (i < chars.Length - 1 && chars[i + 1] == '.')
{
drawDPS = true;
}
else
{
drawDPS = false;
}
if (c != '.')
{
if (c == '-')
{
DrawDigit(g, -1, new PointF(drect.X + shift, drect.Y), drawDPS, drect.Height);
}
else
{
DrawDigit(g, int.Parse(c.ToString()), new PointF(drect.X + shift, drect.Y), drawDPS,
drect.Height);
}
shift += 15 * width / 250f;
}
else
{
shift += 2 * width / 250f;
}
}
}
catch (Exception)
{
}
}
/// <summary>
/// Draws a digit in 7-Segement format.
/// </summary>
/// <param name="g"></param>
/// <param name="number"></param>
/// <param name="position"></param>
/// <param name="dp"></param>
/// <param name="height"></param>
private void DrawDigit(Graphics g, int number, PointF position, bool dp, float height)
{
float width;
width = 10F * height / 13;
var outline = new Pen(Color.FromArgb(40, dialColor));
var fillPen = new Pen(Color.Black);
#region Form Polygon Points
//Segment A
var segmentA = new PointF[5];
segmentA[0] = segmentA[4] = new PointF(position.X + GetX(2.8F, width), position.Y + GetY(1F, height));
segmentA[1] = new PointF(position.X + GetX(10, width), position.Y + GetY(1F, height));
segmentA[2] = new PointF(position.X + GetX(8.8F, width), position.Y + GetY(2F, height));
segmentA[3] = new PointF(position.X + GetX(3.8F, width), position.Y + GetY(2F, height));
//Segment B
var segmentB = new PointF[5];
segmentB[0] = segmentB[4] = new PointF(position.X + GetX(10, width), position.Y + GetY(1.4F, height));
segmentB[1] = new PointF(position.X + GetX(9.3F, width), position.Y + GetY(6.8F, height));
segmentB[2] = new PointF(position.X + GetX(8.4F, width), position.Y + GetY(6.4F, height));
segmentB[3] = new PointF(position.X + GetX(9F, width), position.Y + GetY(2.2F, height));
//Segment C
var segmentC = new PointF[5];
segmentC[0] = segmentC[4] = new PointF(position.X + GetX(9.2F, width), position.Y + GetY(7.2F, height));
segmentC[1] = new PointF(position.X + GetX(8.7F, width), position.Y + GetY(12.7F, height));
segmentC[2] = new PointF(position.X + GetX(7.6F, width), position.Y + GetY(11.9F, height));
segmentC[3] = new PointF(position.X + GetX(8.2F, width), position.Y + GetY(7.7F, height));
//Segment D
var segmentD = new PointF[5];
segmentD[0] = segmentD[4] = new PointF(position.X + GetX(7.4F, width), position.Y + GetY(12.1F, height));
segmentD[1] = new PointF(position.X + GetX(8.4F, width), position.Y + GetY(13F, height));
segmentD[2] = new PointF(position.X + GetX(1.3F, width), position.Y + GetY(13F, height));
segmentD[3] = new PointF(position.X + GetX(2.2F, width), position.Y + GetY(12.1F, height));
//Segment E
var segmentE = new PointF[5];
segmentE[0] = segmentE[4] = new PointF(position.X + GetX(2.2F, width), position.Y + GetY(11.8F, height));
segmentE[1] = new PointF(position.X + GetX(1F, width), position.Y + GetY(12.7F, height));
segmentE[2] = new PointF(position.X + GetX(1.7F, width), position.Y + GetY(7.2F, height));
segmentE[3] = new PointF(position.X + GetX(2.8F, width), position.Y + GetY(7.7F, height));
//Segment F
var segmentF = new PointF[5];
segmentF[0] = segmentF[4] = new PointF(position.X + GetX(3F, width), position.Y + GetY(6.4F, height));
segmentF[1] = new PointF(position.X + GetX(1.8F, width), position.Y + GetY(6.8F, height));
segmentF[2] = new PointF(position.X + GetX(2.6F, width), position.Y + GetY(1.3F, height));
segmentF[3] = new PointF(position.X + GetX(3.6F, width), position.Y + GetY(2.2F, height));
//Segment G
var segmentG = new PointF[7];
segmentG[0] = segmentG[6] = new PointF(position.X + GetX(2F, width), position.Y + GetY(7F, height));
segmentG[1] = new PointF(position.X + GetX(3.1F, width), position.Y + GetY(6.5F, height));
segmentG[2] = new PointF(position.X + GetX(8.3F, width), position.Y + GetY(6.5F, height));
segmentG[3] = new PointF(position.X + GetX(9F, width), position.Y + GetY(7F, height));
segmentG[4] = new PointF(position.X + GetX(8.2F, width), position.Y + GetY(7.5F, height));
segmentG[5] = new PointF(position.X + GetX(2.9F, width), position.Y + GetY(7.5F, height));
//Segment DP
#endregion
#region Draw Segments Outline
g.FillPolygon(outline.Brush, segmentA);
g.FillPolygon(outline.Brush, segmentB);
g.FillPolygon(outline.Brush, segmentC);
g.FillPolygon(outline.Brush, segmentD);
g.FillPolygon(outline.Brush, segmentE);
g.FillPolygon(outline.Brush, segmentF);
g.FillPolygon(outline.Brush, segmentG);
#endregion
#region Fill Segments
//Fill SegmentA
if (IsNumberAvailable(number, 0, 2, 3, 5, 6, 7, 8, 9))
{
g.FillPolygon(fillPen.Brush, segmentA);
}
//Fill SegmentB
if (IsNumberAvailable(number, 0, 1, 2, 3, 4, 7, 8, 9))
{
g.FillPolygon(fillPen.Brush, segmentB);
}
//Fill SegmentC
if (IsNumberAvailable(number, 0, 1, 3, 4, 5, 6, 7, 8, 9))
{
g.FillPolygon(fillPen.Brush, segmentC);
}
//Fill SegmentD
if (IsNumberAvailable(number, 0, 2, 3, 5, 6, 8, 9))
{
g.FillPolygon(fillPen.Brush, segmentD);
}
//Fill SegmentE
if (IsNumberAvailable(number, 0, 2, 6, 8))
{
g.FillPolygon(fillPen.Brush, segmentE);
}
//Fill SegmentF
if (IsNumberAvailable(number, 0, 4, 5, 6, 7, 8, 9))
{
g.FillPolygon(fillPen.Brush, segmentF);
}
//Fill SegmentG
if (IsNumberAvailable(number, 2, 3, 4, 5, 6, 8, 9, -1))
{
g.FillPolygon(fillPen.Brush, segmentG);
}
#endregion
//Draw decimal point
if (dp)
{
g.FillEllipse(fillPen.Brush, new RectangleF(
position.X + GetX(10F, width),
position.Y + GetY(12F, height),
width / 7,
width / 7));
}
}
/// <summary>
/// Gets Relative X for the given width to draw digit
/// </summary>
/// <param name="x"></param>
/// <param name="width"></param>
/// <returns></returns>
private float GetX(float x, float width)
{
return x * width / 12;
}
/// <summary>
/// Gets relative Y for the given height to draw digit
/// </summary>
/// <param name="y"></param>
/// <param name="height"></param>
/// <returns></returns>
private float GetY(float y, float height)
{
return y * height / 15;
}
/// <summary>
/// Returns true if a given number is available in the given list.
/// </summary>
/// <param name="number"></param>
/// <param name="listOfNumbers"></param>
/// <returns></returns>
private bool IsNumberAvailable(int number, params int[] listOfNumbers)
{
if (listOfNumbers.Length > 0)
{
foreach (var i in listOfNumbers)
{
if (i == number)
{
return true;
}
}
}
return false;
}
/// <summary>
/// Restricts the size to make sure the height and width are always same.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void AquaGauge_Resize(object sender, EventArgs e)
{
if (Width < 136)
{
Width = 136;
}
if (oldWidth != Width)
{
Height = Width;
oldHeight = Width;
}
if (oldHeight != Height)
{
Width = Height;
oldWidth = Width;
}
}
#endregion
}
}
Generated by GNU Enscript 1.6.5.90.