/// <summary>
/// Determines whether the NeedleCollection contains a specific Needle.
/// </summary>
/// <param name="value">A Needle</param>
/// <returns>true if the NeedleCollection contains the specified Needle; otherwise, false.</returns>
public bool Contains(Needle value)
{
// If value is not of type Needle, this will return false.
return(List.Contains(value));
}
private void UpdateNormal(double[] ds, Color[] cs)
{
GaugeLayer theLayer = null;
if (MyChart.Layer.Contains("GaugeLayer"))
{
theLayer = _mychart.Layer["GaugeLayer"] as GaugeLayer;
}
else
{
theLayer = new GaugeLayer();
theLayer.Appearance = new GaugeAppearance();
theLayer.Appearance.Radius = 300;
//theLayer.Appearance.Center = new Point(190, 190);
//theLayer.Appearance.DialPE.Stroke = Color.Black;
//theLayer.Appearance.DialPE.StrokeWidth = 5;
theLayer.ChartComponent = MyChart;
_mychart.Layer.Add("GaugeLayer", theLayer);
_mychart.UserLayerIndex = new string[] { "GaugeLayer" };
// Set axes
_mychart.ChartType = ChartType.PieChart;
_mychart.Legend.Visible = false;
_mychart.Axis.Y.Labels.ItemFormatString = "<DATA_VALUE:0>";
_mychart.Axis.Y.MajorGridLines.Thickness = 5;
_mychart.Axis.Y.MinorGridLines.Thickness = 2;
_mychart.Axis.Y.MajorGridLines.DrawStyle = LineDrawStyle.Solid;
_mychart.Axis.Y.MinorGridLines.DrawStyle = LineDrawStyle.Solid;
// Set data source (this is meaningless to the gauge layer)
_mychart.Data.DataSource = Infragistics.UltraChart.Data.DemoTable.Table();
_mychart.Data.DataBind();
//this.ultraChart1.BackgroundImage = System.Drawing.Image.FromFile(Config.ImagePath + @"\chart_gray_bg.jpg");
}
#region sections & needle
theLayer.Appearance.Sections.Clear();
theLayer.Appearance.Needles.Clear();
GaugeSection section = null;
_invalidcode = 0;
double maxtick = _maxtick;
if (!double.IsNaN(ds[0]))
{
if (ds[0] < 0)
{
_invalidcode = 1;
}
maxtick = Math.Max(maxtick, ds[0]);
}
if (!double.IsNaN(ds[1]))
{
if (ds[1] < 0)
{
_invalidcode = 1;
}
maxtick = Math.Max(maxtick, ds[1]);
}
if (!double.IsNaN(ds[2]))
{
if (ds[2] < 0)
{
_invalidcode = 2;
}
maxtick = Math.Max(maxtick, ds[2]);
}
if (!double.Equals(maxtick, 100.0))
{
long mt = Convert.ToInt64(Math.Ceiling(maxtick));
if (mt % 100 == 0)
{
if (mt < 100)
{
maxtick = 100;
}
else
{
maxtick = Convert.ToDouble((mt / 100) * 100);
}
}
else
{
maxtick = Convert.ToDouble((mt / 100 + 1) * 100);
}
}
if (!double.IsNaN(ds[0]))
{
if (!double.IsNaN(ds[1]))
{
section = new GaugeSection(ds[0] - _mintick);
section.StartWidth = _sectionstart;
section.EndWidth = _sectionend;
section.PE.ElementType = PaintElementType.SolidFill; //.Gradient;
section.PE.FillGradientStyle = GradientStyle.Horizontal;
section.PE.Fill = cs[0]; //Color.Green;
//section.PE.FillStopColor = Color.Yellow;
theLayer.Appearance.Sections.Add(section);
section = new GaugeSection(ds[1] - ds[0]);
section.StartWidth = _sectionstart;
section.EndWidth = _sectionend;
section.PE.ElementType = PaintElementType.SolidFill; //.Gradient;
section.PE.FillGradientStyle = GradientStyle.Horizontal;
section.PE.Fill = cs[1]; //Color.Green;
//section.PE.FillStopColor = Color.Yellow;
theLayer.Appearance.Sections.Add(section);
section = new GaugeSection(maxtick - ds[1]);
section.StartWidth = _sectionstart;
section.EndWidth = _sectionend;
section.PE.ElementType = PaintElementType.SolidFill; //.Gradient;
section.PE.FillGradientStyle = GradientStyle.Horizontal;
section.PE.Fill = cs[2]; //Color.Green;
//section.PE.FillStopColor = Color.Yellow;
theLayer.Appearance.Sections.Add(section);
}
else
{
section = new GaugeSection(ds[0] - _mintick);
section.StartWidth = _sectionstart;
section.EndWidth = _sectionend;
section.PE.ElementType = PaintElementType.SolidFill; //.Gradient;
section.PE.FillGradientStyle = GradientStyle.Horizontal;
section.PE.Fill = cs[0]; //Color.Green;
//section.PE.FillStopColor = Color.Yellow;
theLayer.Appearance.Sections.Add(section);
section = new GaugeSection(maxtick - ds[0]);
section.StartWidth = _sectionstart;
section.EndWidth = _sectionend;
section.PE.ElementType = PaintElementType.SolidFill; //.Gradient;
section.PE.FillGradientStyle = GradientStyle.Horizontal;
section.PE.Fill = cs[2]; //Color.Green;
//section.PE.FillStopColor = Color.Yellow;
theLayer.Appearance.Sections.Add(section);
}
}
else
{
section = new GaugeSection(maxtick - _mintick);
section.StartWidth = 1;
section.EndWidth = 2;
section.PE.ElementType = PaintElementType.SolidFill;//.Gradient;
section.PE.FillGradientStyle = GradientStyle.Horizontal;
section.PE.Fill = _gaugecolor;
theLayer.Appearance.Sections.Add(section);
}
if (!double.IsNaN(ds[2]))
{
Needle nv = new Needle(ds[2], new PaintElement(_needlecolor));
nv.PE.StrokeWidth = 12;
nv.Length = _needlelength;
theLayer.Appearance.Needles.Add(nv);
}
#endregion
theLayer.Appearance.StartAngle = _bsemicircle ? 0 : -45;
theLayer.Appearance.EndAngle = _bsemicircle ? 180 : 225;
theLayer.Appearance.TextLoc = _textloc;
theLayer.Appearance.TickStart = _tickstart;
theLayer.Appearance.TickEnd = _tickend;
_mychart.Axis.Y.Visible = true;
_mychart.Axis.Y.Labels.Visible = true;
_mychart.Axis.Y.MajorGridLines.Visible = true;
_mychart.Axis.Y.MinorGridLines.Visible = true;
_mychart.Axis.Y.MajorGridLines.Color = _tickcolor;
_mychart.Axis.Y.MinorGridLines.Color = _tickcolor;
_mychart.Axis.Y.Labels.FontColor = _fontcolor;
_mychart.Axis.Y.LineColor = _linecolor;
if (_gaugetype == GaugeType.Blue3D)
{
theLayer.Appearance.DialPE = new PaintElement(String4Report.GetImage("Template0.gif"));
}
else
{
theLayer.Appearance.DialPE = new PaintElement(_gaugecolor);
}
//theLayer.Appearance.DialPE = new PaintElement(Color.WhiteSmoke, Color.CornflowerBlue, GradientStyle.Elliptical);
//if (_caption != null)
//{
// _mychart.TitleBottom.Text = _caption;
// _mychart.TitleBottom.FontSizeBestFit = true;
// _mychart.TitleBottom.HorizontalAlign = StringAlignment.Center;
//}
_mychart.InvalidateLayers();
}
/// <summary>
/// Removes the first occurrence of a specific Needle from the Needle Collection.
/// </summary>
/// <param name="value">A Needle</param>
public void Remove(Needle value)
{
List.Remove(value);
}
/// <summary>
/// Inserts an element into the Needle Collection at the specified index.
/// </summary>
/// <param name="index">The zero-based index at which value should be inserted.</param>
/// <param name="value">The Needle to insert.</param>
public void Insert(int index, Needle value)
{
List.Insert(index, value);
}
/// <summary>
/// Searches for the specified Needle and returns the zero-based index of the first occurrence within the entire NeedleCollection.
/// </summary>
/// <param name="value">Needle to search</param>
/// <returns>The zero-based index of the first occurrence of given Needle within the entire Needle Collection, if found; otherwise, -1</returns>
public int IndexOf(Needle value)
{
return(List.IndexOf(value));
}
/// <summary>
/// Adds an Needle to the end of the Needle Collection.
/// </summary>
/// <param name="value">A needle</param>
/// <returns>The Needle Collection index at which the value has been added.</returns>
public int Add(Needle value)
{
return(List.Add(value));
}
/// <summary>
/// Layer's main piece of code that does the drawing. This method calculates and
/// populates a scene graph with various primitive that constitue the chart.
/// </summary>
/// <param name="scene">Collection of Scene items (primitives) to hold items that draw chart.</param>
public void FillSceneGraph(SceneGraph scene)
{
//Draw the axes, use the settings from the y axis properties.
AxisAppearance YApp = (AxisAppearance)this.ChartComponent.GetChartAppearance(ChartAppearanceTypes.AxisY);
// Check if appearance and Y-axis appearance are defined.
if (_Appearance != null && YApp != null)
{
#region Initialization
// initilize the variable.
// Minimum value a needle can have.
double min = 0;
// Maximum value a needle can have.
double max = 100;
// Tick increments.
double delta = 10;
// Check to see if the Gauge should assume size and layout automatically
// centering the dial and assuming available width as its size.
if (this._Appearance.Layout == DialLayout.Automatic)
{
this._Appearance.Radius = Math.Min(this.innerBounds.Width / 3, this.innerBounds.Height / 3);
this._Appearance.Center = new Point(this.innerBounds.X + this.innerBounds.Width / 2, this.innerBounds.Y + this.innerBounds.Height / 2);
}
// check for axis settings
// If cutom rage is specified use custom range.
if (YApp.RangeType == AxisRangeType.Custom)
{
min = YApp.RangeMin;
max = YApp.RangeMax;
}
else
{
// Automatic: add up the specified sections.
if (this._Appearance.Sections.Count > 0)
{
min = 0;
max = 0;
foreach (GaugeSection sec in this._Appearance.Sections)
{
max += sec.Value;
}
}
}
// Assume and calculate the default increment.
delta = (max - min) / 10;
// check for y-axis appearance for specified data interval.
if (YApp.TickmarkStyle == AxisTickStyle.DataInterval)
{
// Actual value is specified.
delta = YApp.TickmarkInterval;
}
else
{
// Convert the percentage value in actual value.
delta = (max - min) * YApp.TickmarkPercentage / 100;
}
// set up ruler with value. This will be used for measurement purposes.
_Ruler.Maximum = max;
_Ruler.Minimum = min;
// Check the direction of the dial ticks.
if (this.Appearance.Direction == Direction.RightToLeft)
{
_Ruler.MapMinimum = _Appearance.StartAngle;
_Ruler.MapMaximum = _Appearance.EndAngle;
}
else
{
_Ruler.MapMinimum = _Appearance.EndAngle;
_Ruler.MapMaximum = _Appearance.StartAngle;
}
// copy scoll-scale.
_Ruler.Scale = YApp.ScrollScale.Scale;
_Ruler.Scroll = YApp.ScrollScale.Scroll;
#endregion
#region Draw dial and sections
// start from the minimum
double d_i = (double)_Ruler.WindowMinimum;
// calculate various radii.
int r1 = this._Appearance.TickStart * this._Appearance.Radius / 100;
int r2 = this._Appearance.TickEnd * this._Appearance.Radius / 100;
int r3 = this._Appearance.TextLoc * this._Appearance.Radius / 100;
// draw dial or background.
Ellipse dial = new Ellipse(this._Appearance.Center, this._Appearance.Radius);
dial.PE = this.Appearance.DialPE;
// add dial background.
scene.Add(dial);
// draw the sections
// variable to hold present value.
double presentVal = 0;
// start the section from the window minimum.
double lastVal = (double)_Ruler.WindowMinimum;
// foreach section, draw a section.
foreach (GaugeSection sec in this._Appearance.Sections)
{
presentVal = lastVal + sec.Value;
// section start angle.
int ang0 = -(int)_Ruler.Map(lastVal);
// section end angle.
int ang1 = -(int)_Ruler.Map(presentVal);
// create the wedge
Wedge w = new Wedge(this._Appearance.Center, sec.EndWidth * this._Appearance.Radius / 100, ang0, (ang1 - ang0));
w.PE = sec.PE;
w.RadiusInner = Math.Max(0, Math.Min(w.Radius - 1, sec.StartWidth * this._Appearance.Radius / 100));
scene.Add(w);
lastVal = presentVal;
}
#endregion
#region Draw axis' tick marks on dial
// sanity check for increment. Without this it will go into infinite loop.
if (delta < 2 * double.Epsilon)
{
delta = 5 * double.Epsilon;
}
// loop thru and add the items.
while (d_i < (double)_Ruler.WindowMaximum + 2 * double.Epsilon + delta)
{
// convert the tickmark value to angle
int ang = (int)_Ruler.Map(d_i);
// see if major grid lines are visible.
if (YApp.MajorGridLines.Visible)
{
// Convert polar co-ordinates into cartiesian.
// In simple words: Convert a pair of (radius, angle) in a point (x and y).
Point p1 = Infragistics.UltraChart.Core.Util.Geometry.AngularToCartesian(this._Appearance.Center, r1, -Geometry.DegreeToRadian(ang));
Point p2 = Infragistics.UltraChart.Core.Util.Geometry.AngularToCartesian(this._Appearance.Center, r2, -Geometry.DegreeToRadian(ang));
// Draw the line for tick marks. Use Y-axis's properties to color and style it.
Line l = new Line(p1, p2);
l.PE.Stroke = YApp.MajorGridLines.Color;
l.PE.StrokeOpacity = YApp.MajorGridLines.Color.A;
l.lineStyle.DrawStyle = YApp.MajorGridLines.DrawStyle;
l.PE.StrokeWidth = YApp.MajorGridLines.Thickness;
// add to scene.
scene.Add(l);
}
// see if minor grid lines are visible. If yes draw them half
// a tick far from major grid line. It will use Y-axis's minor
// grid lines appearance for color and style.
if (YApp.MinorGridLines.Visible)
{
if (d_i + delta / 2 < (double)_Ruler.WindowMaximum)
{
// convert the tickmark value to angle
int ang1 = (int)_Ruler.Map(d_i + delta / 2);
int tfp = Math.Abs((r2 - r1) / 4);
// Convert a pair of (radius, angle) in a point (x and y).
Point p1 = Infragistics.UltraChart.Core.Util.Geometry.AngularToCartesian(this._Appearance.Center, r1 + tfp, -Geometry.DegreeToRadian(ang1));
Point p2 = Infragistics.UltraChart.Core.Util.Geometry.AngularToCartesian(this._Appearance.Center, r2 - tfp, -Geometry.DegreeToRadian(ang1));
// draw a minor tick line
Line l = new Line(p1, p2);
l.PE.Stroke = YApp.MinorGridLines.Color;
l.PE.StrokeOpacity = YApp.MinorGridLines.Color.A;
l.lineStyle.DrawStyle = YApp.MinorGridLines.DrawStyle;
l.PE.StrokeWidth = YApp.MinorGridLines.Thickness;
// add to scene.
scene.Add(l);
}
}
// see if labels are visible.
if (YApp.Labels.Visible)
{
// Draw the labels: Convert the angle and radius into point location for the label.
Point p3 = Infragistics.UltraChart.Core.Util.Geometry.AngularToCartesian(this._Appearance.Center, r3, -Geometry.DegreeToRadian(ang));
_Labels["DATA_VALUE"] = d_i;
// Use the label formatter and use Y-axis label format.
Text t = new Text(p3, LabelFormatter.replaceKeywords(_Labels, YApp.Labels.ItemFormatString), YApp.Labels.LabelStyle.Copy());
t.labelStyle.VerticalAlign = StringAlignment.Center;
t.labelStyle.HorizontalAlign = StringAlignment.Center;
// Use custom orienation as we need to rotate them to
// place them on angular axis.
t.labelStyle.Orientation = TextOrientation.Custom;
// rotate with respect to present tick angle.
t.labelStyle.RotationAngle = ang - 90;
// add to scene.
scene.Add(t);
}
// increment current value of tick by the data interval: delta.
d_i += delta;
}
// See if axis line is visible.
if (YApp.Visible)
{
// create new line style
LineStyle ls = new LineStyle();
// use y-axis's draw style.
ls.DrawStyle = YApp.LineDrawStyle;
// draw an arc that looks takes place of axis line.
Arc el = new Arc(this._Appearance.Center, (r1 + r2) / 2, (float)this._Appearance.StartAngle, -(float)Math.Abs(this._Appearance.EndAngle - this._Appearance.StartAngle), ls);
// use the axes line's color and thickness.
el.PE.Stroke = YApp.LineColor;
el.PE.StrokeOpacity = YApp.LineColor.A;
el.PE.StrokeWidth = YApp.LineThickness;
// add to scene.
scene.Add(el);
}
#endregion
#region Draw needles
// sort needles according to needle length. shortest comes on the top.
double[] ar = new Double[this.Appearance.Needles.Count];
for (int i = 0; i < this.Appearance.Needles.Count; i++)
{
// store the length of needle in temporary array.
ar[i] = this.Appearance.Needles[i].Length;
}
// sort the order. This function takes the length of
// needle array and get the sorted order.
int[] order = null;
if (ar.Length > 0)
{
order = MiscFunctions.GetSortedOrderDouble(ar);
}
// draw the needles on the dials
for (int i = 0; i < this.Appearance.Needles.Count; i++)
{
// get n-th needle.
Needle nd = this.Appearance.Needles[order[i]];
// depending upon needle's present value find out the
// angle at which it should be inclined.
int theta_i = (int)_Ruler.Map(nd.Value);
// convert, angle of needle and its length into a point location.
Point p = Infragistics.UltraChart.Core.Util.Geometry.AngularToCartesian(this._Appearance.Center, nd.Length * this._Appearance.Radius / 100, Geometry.DegreeToRadian(-theta_i));
// draw a line from the center of dial to location of needle's head.
Line l = new Line(this._Appearance.Center, p);
l.lineStyle.EndStyle = LineCapStyle.ArrowAnchor;
l.lineStyle.StartStyle = LineCapStyle.RoundAnchor;
// attach the paint element from needle to the line primitive.
l.PE = nd.PE;
// add to scene.
scene.Add(l);
}
#endregion
}
}