private AngularMeter GetRange(AngularMeter m, int alert, double value)
{
m.addText(7, 35, value.ToString("0.##"), "Verdana", 8, 0xffffff, Chart.TopLeft).setBackground(0, 0, -1);
int total = ControllerManager.AlertTotal.GetTotalForAlert(alert);
if (alert == 1 || alert == 4)
{
total = 45;
}
m.setScale(0, total, total / 3, Convert.ToDouble(total) / 6);
m.addZone((total / 3) * 2, total, 0xffcccc, 0x808080);
m.addZone(total / 3, (total / 3) * 2, 0xffff66, 0x808080);
m.addZone(0, total / 3, 0x99ff99, 0x808080);
if ((alert == 1 || alert == 4) && value > total)
{
m.addPointer(total, unchecked ((int)0x80000000));
}
else if ((alert == 1 || alert == 4) && value < 0)
{
m.addPointer(0, unchecked ((int)0x80000000));
}
else
{
m.addPointer(value, unchecked ((int)0x80000000));
}
return(m);
}
//Main code for creating chart.
//Note: the argument img is unused because this demo only has 1 chart.
public void createChart(WinChartViewer viewer, string img)
{
// Create an AugularMeter object of size 200 x 200 pixels
AngularMeter m = new AngularMeter(200, 200);
// Use white on black color palette for default text and line colors
m.setColors(Chart.whiteOnBlackPalette);
// Set the meter center at (100, 100), with radius 85 pixels, and span
// from 0 to 360 degress
m.setMeter(100, 100, 85, 0, 360);
// Meter scale is 0 - 100, with major tick every 10 units, minor tick
// every 5 units, and micro tick every 1 units
m.setScale(0, 100, 10, 5, 1);
// Set angular arc, major tick and minor tick line widths to 2 pixels.
m.setLineWidth(2, 2, 2);
// Add a blue (9999ff) ring between radii 88 - 90 as decoration
m.addRing(88, 90, 0x9999ff);
// Set 0 - 60 as green (00AA00) zone, 60 - 80 as yellow (CCCC00) zone,
// and 80 - 100 as red (AA0000) zone
m.addZone(0, 60, 0x00aa00);
m.addZone(60, 80, 0xcccc00);
m.addZone(80, 100, 0xaa0000);
// Add a text label centered at (100, 70) with 12 pts Arial Bold font
m.addText(100, 70, "PSI", "Arial Bold", 12, Chart.TextColor, Chart.Center
);
// Add a semi-transparent blue (806666FF) pointer using the default
// shape
m.addPointer(25, unchecked ((int)0x806666ff), 0x6666ff);
// Add a semi-transparent red (80FF6666) pointer using the arrow shape
m.addPointer(9, unchecked ((int)0x80ff6666), 0xff6666).setShape(
Chart.ArrowPointer2);
// Add a semi-transparent yellow (80FFFF66) pointer using another arrow
// shape
m.addPointer(51, unchecked ((int)0x80ffff66), 0xffff66).setShape(
Chart.ArrowPointer);
// Add a semi-transparent green (8066FF66) pointer using the line shape
m.addPointer(72, unchecked ((int)0x8066ff66), 0x66ff66).setShape(
Chart.LinePointer);
// Add a semi-transparent grey (80CCCCCC) pointer using the pencil shape
m.addPointer(85, unchecked ((int)0x80cccccc), 0xcccccc).setShape(
Chart.PencilPointer);
// Output the chart
viewer.Image = m.makeImage();
}
//Main code for creating chart.
//Note: the argument chartIndex is unused because this demo only has 1 chart.
public void createChart(WPFChartViewer viewer, int chartIndex)
{
// Create an AngularMeter object of size 300 x 300 pixels with transparent background
AngularMeter m = new AngularMeter(300, 300, Chart.Transparent);
// Set the default text and line colors to white (0xffffff)
m.setColor(Chart.TextColor, 0xffffff);
m.setColor(Chart.LineColor, 0xffffff);
// Center at (150, 150), scale radius = 125 pixels, scale angle 0 to 360 degrees
m.setMeter(150, 150, 125, 0, 360);
// Add a black (0x000000) circle with radius 148 pixels as background
m.addRing(0, 148, 0x000000);
// Add a ring between radii 139 and 147 pixels using the silver color with a light grey
// (0xcccccc) edge as border
m.addRing(139, 147, Chart.silverColor(), 0xcccccc);
// Meter scale is 0 - 100, with major/minor/micro ticks every 10/5/1 units
m.setScale(0, 100, 10, 5, 1);
// Set the scale label style to 16pt Arial Italic. Set the major/minor/micro tick
// lengths to 13/10/7 pixels pointing inwards, and their widths to 2/1/1 pixels.
m.setLabelStyle("Arial Italic", 16);
m.setTickLength(-13, -10, -7);
m.setLineWidth(0, 2, 1, 1);
// Add a default red (0xff0000) pointer
m.addPointer2(25, 0xff0000);
// Add a semi-transparent green (0x3f00ff00) line style pointer
m.addPointer2(9, 0x3f00ff00, -1, Chart.LinePointer2);
// Add a semi-transparent blue (0x7f66aaff) triangular pointer floating between 60% and
// 85% of the scale radius with the pointer width 5 times the default
m.addPointer2(52, 0x7f66aaff, 0x66aaff, Chart.TriangularPointer2, 0.6, 0.85, 5);
// Add a semi-transparent yellow (0x7fffff66) triangular pointer floating between 80%
// and 90% of the scale radius with the pointer width 5 times the default
m.addPointer2(65, 0x7fffff66, 0xffff66, Chart.TriangularPointer2, 0.8, 0.9, 5);
// Add two red (0xff0000) triangular pointer at 72 and 94. The pointers float between
// 110% and 100% of the scale radius with widths 3 times the default
m.addPointer2(72, 0xff0000, -1, Chart.TriangularPointer2, 1.1, 1.0, 3);
m.addPointer2(94, 0xff0000, -1, Chart.TriangularPointer2, 1.1, 1.0, 3);
// Add a red (0xcc0000) zone spanning from 72 to 94, and between the radii 112 and 125
m.addZone(72, 94, 125, 112, 0xcc0000);
// Output the chart
viewer.Chart = m;
}
//Main code for creating chart.
//Note: the argument img is unused because this demo only has 1 chart.
public void createChart(WinChartViewer viewer, string img)
{
// The value to display on the meter
double value = 45.17;
// Create an AugularMeter object of size 200 x 200 pixels, with silver
// background, black border, 2 pixel 3D depressed border and rounded
// corners.
AngularMeter m = new AngularMeter(200, 200, Chart.silverColor(),
0x000000, -2);
m.setRoundedFrame();
// Set the meter center at (100, 100), with radius 85 pixels, and span
// from -135 to +135 degress
m.setMeter(100, 100, 85, -135, 135);
// Meter scale is 0 - 100, with major tick every 10 units, minor tick
// every 5 units, and micro tick every 1 units
m.setScale(0, 100, 10, 5, 1);
// Disable default angular arc by setting its width to 0. Set 2 pixels
// line width for major tick, and 1 pixel line width for minor ticks.
m.setLineWidth(0, 2, 1);
// Set the circular meter surface as metallic blue (9999DD)
m.addRing(0, 90, Chart.metalColor(0x9999dd));
// Add a blue (6666FF) ring between radii 88 - 90 as decoration
m.addRing(88, 90, 0x6666ff);
// Set 0 - 60 as green (99FF99) zone, 60 - 80 as yellow (FFFF00) zone,
// and 80 - 100 as red (FF3333) zone
m.addZone(0, 60, 0x99ff99);
m.addZone(60, 80, 0xffff00);
m.addZone(80, 100, 0xff3333);
// Add a text label centered at (100, 135) with 15 pts Arial Bold font
m.addText(100, 135, "CPU", "Arial Bold", 15, Chart.TextColor,
Chart.Center);
// Add a text box centered at (100, 165) showing the value formatted to 2
// decimal places, using white text on a black background, and with 1
// pixel 3D depressed border
m.addText(100, 165, m.formatValue(value, "2"), "Arial", 8, 0xffffff,
Chart.Center).setBackground(0x000000, 0x000000, -1);
// Add a semi-transparent blue (40333399) pointer at the specified value
m.addPointer(value, 0x40333399);
// Output the chart
viewer.Image = m.makeImage();
}
//Main code for creating chart.
//Note: the argument img is unused because this demo only has 1 chart.
public void createChart(WinChartViewer viewer, string img)
{
// The value to display on the meter
double value = 27.48;
// Create an AngularMeter object of size 200 x 115 pixels, with silver
// background color, black border, 2 pixel 3D border border and rounded
// corners
AngularMeter m = new AngularMeter(200, 115, Chart.silverColor(),
0x000000, 2);
m.setRoundedFrame();
// Set the meter center at (100, 100), with radius 85 pixels, and span
// from -90 to +90 degress (semi-circle)
m.setMeter(100, 100, 85, -90, 90);
// Meter scale is 0 - 100, with major tick every 20 units, minor tick
// every 10 units, and micro tick every 5 units
m.setScale(0, 100, 20, 10, 5);
// Set 0 - 60 as green (66FF66) zone
m.addZone(0, 60, 0, 85, 0x66ff66);
// Set 60 - 80 as yellow (FFFF33) zone
m.addZone(60, 80, 0, 85, 0xffff33);
// Set 80 - 100 as red (FF6666) zone
m.addZone(80, 100, 0, 85, 0xff6666);
// Add a text label centered at (100, 60) with 12 pts Arial Bold font
m.addText(100, 60, "PSI", "Arial Bold", 12, Chart.TextColor, Chart.Center
);
// Add a text box at the top right corner of the meter showing the value
// formatted to 2 decimal places, using white text on a black background,
// and with 1 pixel 3D depressed border
m.addText(156, 8, m.formatValue(value, "2"), "Arial", 8, 0xffffff
).setBackground(0x000000, 0, -1);
// Add a semi-transparent blue (40666699) pointer with black border at
// the specified value
m.addPointer(value, 0x40666699, 0x000000);
// Output the chart
viewer.Image = m.makeImage();
}
//Main code for creating chart.
//Note: the argument chartIndex is unused because this demo only has 1 chart.
public void createChart(WinChartViewer viewer, int chartIndex)
{
// Create an AngularMeter object of size 300 x 300 pixels with transparent background
AngularMeter m = new AngularMeter(300, 300, Chart.Transparent);
// Set the default text and line colors to white (0xffffff)
m.setColor(Chart.TextColor, 0xffffff);
m.setColor(Chart.LineColor, 0xffffff);
// Center at (150, 150), scale radius = 128 pixels, scale angle 0 to 360 degrees
m.setMeter(150, 150, 128, 0, 360);
// Add a black (0x000000) circle with radius 148 pixels as background
m.addRing(0, 148, 0x000000);
// Add a ring between radii 139 and 147 pixels using the silver color with a light grey
// (0xcccccc) edge as border
m.addRing(139, 147, Chart.silverColor(), 0xcccccc);
// Meter scale is 0 - 100, with major/minor/micro ticks every 10/5/1 units
m.setScale(0, 100, 10, 5, 1);
// Set the scale label style to 16pt Arial Italic. Set the major/minor/micro tick
// lengths to 13/10/7 pixels pointing inwards, and their widths to 2/1/1 pixels.
m.setLabelStyle("Arial Italic", 16);
m.setTickLength(-13, -10, -7);
m.setLineWidth(0, 2, 1, 1);
// Add a semi-transparent blue (0x7f6666ff) pointer using the default shape
m.addPointer(25, 0x7f6666ff, 0x6666ff);
// Add a semi-transparent red (0x7fff6666) pointer using the arrow shape
m.addPointer(9, 0x7fff6666, 0xff6666).setShape(Chart.ArrowPointer2);
// Add a semi-transparent yellow (0x7fffff66) pointer using another arrow shape
m.addPointer(51, 0x7fffff66, 0xffff66).setShape(Chart.ArrowPointer);
// Add a semi-transparent green (0x7f66ff66) pointer using the line shape
m.addPointer(72, 0x7f66ff66, 0x66ff66).setShape(Chart.LinePointer);
// Add a semi-transparent grey (0x7fcccccc) pointer using the pencil shape
m.addPointer(85, 0x7fcccccc, 0xcccccc).setShape(Chart.PencilPointer);
// Output the chart
viewer.Chart = m;
}
//Main code for creating chart.
//Note: the argument chartIndex is unused because this demo only has 1 chart.
public void createChart(WinChartViewer viewer, int chartIndex)
{
// The value to display on the meter
double value = 72.55;
// Create an AngularMeter object of size 300 x 180 pixels with transparent background
AngularMeter m = new AngularMeter(300, 180, Chart.Transparent);
// Center at (150, 150), scale radius = 128 pixels, scale angle -90 to +90 degrees
m.setMeter(150, 150, 128, -90, 90);
// Add a pale grey (0xeeeeee) scale background of 148 pixels radius, with a 10 pixel
// thick light grey (0xcccccc) border
m.addScaleBackground(148, 0xeeeeee, 10, 0xcccccc);
// Meter scale is 0 - 100, with major tick every 20 units, minor tick every 10 units,
// and micro tick every 5 units
m.setScale(0, 100, 20, 10, 5);
// Set the scale label style to 15pt Arial Italic. Set the major/minor/micro tick
// lengths to 16/16/10 pixels pointing inwards, and their widths to 2/1/1 pixels.
m.setLabelStyle("Arial Italic", 16);
m.setTickLength(-16, -16, -10);
m.setLineWidth(0, 2, 1, 1);
// Add a smooth color scale to the meter
double[] smoothColorScale = { 0, 0x3333ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
m.addColorScale(smoothColorScale);
// Add a text label centered at (150, 125) with 15pt Arial Italic font
m.addText(150, 125, "CPU", "Arial Italic", 15, Chart.TextColor, Chart.BottomCenter);
// Add a red (0xff0000) pointer at the specified value
m.addPointer2(value, 0xff0000);
// Output the chart
viewer.Chart = m;
}
//
// Create chart
//
private void createChart(RazorChartViewer viewer)
{
// The value to display on the meter
double value = 72.3;
// Create an AngularMeter object of size 250 x 250 pixels with transparent background
AngularMeter m = new AngularMeter(250, 250, Chart.Transparent);
// Center at (125, 125), scale radius = 111 pixels, scale angle -145 to +145 degrees
m.setMeter(125, 125, 111, -145, 145);
// Add a very light grey (0xeeeeee) circle with radius 123 pixels as background
m.addRing(0, 123, 0xeeeeee);
// Add a grey (0xcccccc) ring between radii 116 and 123 pixels as border
m.addRing(116, 123, 0xcccccc);
// Meter scale is 0 - 100, with major/minor/micro ticks every 10/5/1 units
m.setScale(0, 100, 10, 5, 1);
// Set the scale label style to 15pt Arial Italic. Set the major/minor/micro tick lengths to
// 12/9/6 pixels pointing inwards, and their widths to 2/1/1 pixels.
m.setLabelStyle("Arial Italic", 15);
m.setTickLength(-12, -9, -6);
m.setLineWidth(0, 2, 1, 1);
// Add a smooth color scale to the meter
double[] smoothColorScale = { 0, 0x3333ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
m.addColorScale(smoothColorScale);
// Add a text label centered at (125, 175) with 15pt Arial Italic font
m.addText(125, 175, "CPU", "Arial Italic", 15, Chart.TextColor, Chart.Center);
// Add a red (0xff0000) pointer at the specified value
m.addPointer2(value, 0xff0000);
// Output the chart
viewer.Image = m.makeWebImage(Chart.PNG);
}
//Main code for creating charts
public void createChart(WPFChartViewer viewer, int chartIndex)
{
// The value to display on the meter
double value = 72.55;
// Create an AngularMeter object of size 240 x 170 pixels with very light grey
// (0xeeeeee) background, and a rounded 4-pixel thick light grey (0xcccccc) border
AngularMeter m = new AngularMeter(240, 170, 0xeeeeee, 0xcccccc);
m.setRoundedFrame(Chart.Transparent);
m.setThickFrame(4);
// Set the default text and line colors to dark grey (0x222222)
m.setColor(Chart.TextColor, 0x222222);
m.setColor(Chart.LineColor, 0x222222);
// Center at (120, 145), scale radius = 128 pixels, scale angle -60 to +60 degrees
m.setMeter(120, 145, 128, -60, 60);
// Meter scale is 0 - 100, with major/minor/micro ticks every 20/10/5 units
m.setScale(0, 100, 20, 10, 5);
// Set the scale label style to 14pt Arial Italic. Set the major/minor/micro tick
// lengths to 16/16/10 pixels pointing inwards, and their widths to 2/1/1 pixels.
m.setLabelStyle("Arial Italic", 14);
m.setTickLength(-16, -16, -10);
m.setLineWidth(0, 2, 1, 1);
// Demostrate different types of color scales and putting them at different positions
double[] smoothColorScale = { 0, 0x3333ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
double[] stepColorScale = { 0, 0x00cc00, 60, 0xffdd00, 80, 0xee0000, 100 };
double[] highLowColorScale = { 0, 0x00ff00, 70, Chart.Transparent, 100, 0xff0000 };
if (chartIndex == 0)
{
// Add the smooth color scale at the default position
m.addColorScale(smoothColorScale);
}
else if (chartIndex == 1)
{
// Add the smooth color scale starting at radius 128 with zero width and ending at
// radius 128 with 16 pixels inner width
m.addColorScale(smoothColorScale, 128, 0, 128, -16);
}
else if (chartIndex == 2)
{
// Add the smooth color scale starting at radius 70 with zero width and ending at
// radius 60 with 20 pixels outer width
m.addColorScale(smoothColorScale, 70, 0, 60, 20);
}
else if (chartIndex == 3)
{
// Add the high/low color scale at the default position
m.addColorScale(highLowColorScale);
}
else if (chartIndex == 4)
{
// Add the step color scale at the default position
m.addColorScale(stepColorScale);
}
else
{
// Add the smooth color scale at radius 60 with 15 pixels outer width
m.addColorScale(smoothColorScale, 60, 15);
}
// Add a text label centered at (120, 120) with 15pt Arial Italic font
m.addText(120, 120, "CPU", "Arial Italic", 15, Chart.TextColor, Chart.BottomCenter);
// Add a red (0xff0000) pointer at the specified value
m.addPointer2(value, 0xff0000);
// Add a semi-transparent light grey (0x3fcccccc) rectangle at (0, 120) and of size 240
// x 60 pixels to cover the bottom part of the meter for decoration
ChartDirector.TextBox cover = m.addText(0, 120, "");
cover.setSize(240, 60);
cover.setBackground(0x3fcccccc);
// Output the chart
viewer.Chart = m;
}
//Main code for creating charts
public void createChart(WPFChartViewer viewer, int chartIndex)
{
// The value to display on the meter
double value = 72.3;
// The background and border colors of the meters
int[] bgColor = { 0x88ccff, 0xffdddd, 0xffddaa, 0xffccff, 0xdddddd, 0xccffcc };
int[] borderColor = { 0x000077, 0x880000, 0xee6600, 0x440088, 0x000000, 0x006000 };
// Create an AngularMeter object of size 250 x 250 pixels with transparent background
AngularMeter m = new AngularMeter(250, 250, Chart.Transparent);
// Demonstration two different meter scale angles
if (chartIndex % 2 == 0)
{
// Center at (125, 125), scale radius = 111 pixels, scale angle -140 to +140 degrees
m.setMeter(125, 125, 111, -140, 140);
}
else
{
// Center at (125, 125), scale radius = 111 pixels, scale angle -180 to +90 degrees
m.setMeter(125, 125, 111, -180, 90);
}
// Background gradient color with brighter color at the center
double[] bgGradient = { 0, m.adjustBrightness(bgColor[chartIndex], 3), 0.75, bgColor[
chartIndex] };
// Add circle with radius 123 pixels as background using the background gradient
m.addRing(0, 123, m.relativeRadialGradient(bgGradient));
// Add a ring between radii 116 and 123 pixels as border
m.addRing(116, 123, borderColor[chartIndex]);
// Meter scale is 0 - 100, with major/minor/micro ticks every 10/5/1 units
m.setScale(0, 100, 10, 5, 1);
// Set the scale label style to 15pt Arial Italic. Set the major/minor/micro tick
// lengths to 12/9/6 pixels pointing inwards, and their widths to 2/1/1 pixels.
m.setLabelStyle("Arial Italic", 15);
m.setTickLength(-12, -9, -6);
m.setLineWidth(0, 2, 1, 1);
// Demostrate different types of color scales and putting them at different positions
double[] smoothColorScale = { 0, 0x3333ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
double[] stepColorScale = { 0, 0x00cc00, 60, 0xffdd00, 80, 0xee0000, 100 };
double[] highLowColorScale = { 0, 0x00ff00, 70, Chart.Transparent, 100, 0xff0000 };
if (chartIndex == 0)
{
// Add the smooth color scale at the default position
m.addColorScale(smoothColorScale);
}
else if (chartIndex == 1)
{
// Add the smooth color scale starting at radius 62 with zero width and ending at
// radius 40 with 22 pixels outer width
m.addColorScale(smoothColorScale, 62, 0, 40, 22);
}
else if (chartIndex == 2)
{
// Add green, yellow and red zones between radii 44 and 60
m.addZone(0, 60, 44, 60, 0x00dd00);
m.addZone(60, 80, 44, 60, 0xffff00);
m.addZone(80, 100, 44, 60, 0xff0000);
}
else if (chartIndex == 3)
{
// Add the high/low color scale at the default position
m.addColorScale(highLowColorScale);
}
else if (chartIndex == 4)
{
// Add the smooth color scale at radius 44 with 16 pixels outer width
m.addColorScale(smoothColorScale, 44, 16);
}
else
{
// Add the step color scale at the default position
m.addColorScale(stepColorScale);
}
// Add a text label centered at (125, 175) with 15pt Arial Italic font
m.addText(125, 175, "CPU", "Arial Italic", 15, Chart.TextColor, Chart.Center);
// Add a readout to some of the charts as demonstration
if (chartIndex == 0 || chartIndex == 2)
{
// Put the value label center aligned at (125, 232), using white (0xffffff) 14pt
// Arial font on a black (0x000000) background. Set box width to 50 pixels with 5
// pixels rounded corners.
ChartDirector.TextBox t = m.addText(125, 232, m.formatValue(value,
"<*block,width=50,halign=center*>{value|1}"), "Arial", 14, 0xffffff,
Chart.BottomCenter);
t.setBackground(0x000000);
t.setRoundedCorners(5);
}
// Add a red (0xff0000) pointer at the specified value
m.addPointer2(value, 0xff0000);
// Output the chart
viewer.Chart = m;
}
//Main code for creating charts
public void createChart(WPFChartViewer viewer, int chartIndex)
{
// The value to display on the meter
double value = 72.55;
// Create an AngularMeter object of size 300 x 180 pixels with transparent background
AngularMeter m = new AngularMeter(300, 180, Chart.Transparent);
// Set the default text and line colors to very dark grey (0x222222)
m.setColor(Chart.TextColor, 0x222222);
m.setColor(Chart.LineColor, 0x222222);
// Center at (150, 150), scale radius = 128 pixels, scale angle -90 to +90 degrees
m.setMeter(150, 150, 128, -90, 90);
// Gradient color for the border to make it silver-like
double[] ringGradient = { 1, 0x999999, 0.5, 0xdddddd, 0, 0xf8f8f8, -0.5, 0xdddddd, -1,
0x999999 };
// Background gradient color from white (0xffffff) at the center to light grey
// (0xdddddd) at the border
double[] bgGradient = { 0, 0xffffff, 0.75, 0xeeeeee, 1, 0xdddddd };
// Add a scale background of 148 pixels radius using the gradient background, with a 10
// pixel thick silver border
m.addScaleBackground(148, m.relativeRadialGradient(bgGradient, 148), 10,
m.relativeLinearGradient(ringGradient, 45, 148));
// Add a 1 pixel light grey (0xbbbbbb) line at the inner edge of the thick silver border
// (radius = 138) to enhance its contrast with the background gradient
m.addScaleBackground(138, Chart.Transparent, 1, 0xbbbbbb);
// Meter scale is 0 - 100, with major tick every 20 units, minor tick every 10 units,
// and micro tick every 5 units
m.setScale(0, 100, 20, 10, 5);
// Set the scale label style to 15pt Arial Italic. Set the major/minor/micro tick
// lengths to 16/16/10 pixels pointing inwards, and their widths to 2/1/1 pixels.
m.setLabelStyle("Arial Italic", 16);
m.setTickLength(-16, -16, -10);
m.setLineWidth(0, 2, 1, 1);
// Demostrate different types of color scales and putting them at different positions
double[] smoothColorScale = { 0, 0x3333ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
double[] stepColorScale = { 0, 0x00cc00, 60, 0xffdd00, 80, 0xee0000, 100 };
double[] highLowColorScale = { 0, 0x00ff00, 70, Chart.Transparent, 100, 0xff0000 };
if (chartIndex == 0)
{
// Add the smooth color scale at the default position
m.addColorScale(smoothColorScale);
}
else if (chartIndex == 1)
{
// Add the smooth color scale starting at radius 128 with zero width and ending at
// radius 128 with 16 pixels inner width
m.addColorScale(smoothColorScale, 128, 0, 128, -16);
}
else if (chartIndex == 2)
{
// Add the smooth color scale starting at radius 70 with zero width and ending at
// radius 60 with 20 pixels outer width
m.addColorScale(smoothColorScale, 70, 0, 60, 20);
}
else if (chartIndex == 3)
{
// Add the high/low color scale at the default position
m.addColorScale(highLowColorScale);
}
else if (chartIndex == 4)
{
// Add the step color scale at the default position
m.addColorScale(stepColorScale);
}
else
{
// Add the smooth color scale at radius 60 with 15 pixels outer width
m.addColorScale(smoothColorScale, 60, 15);
}
// Add a text label centered at (150, 125) with 15pt Arial Italic font
m.addText(150, 125, "CPU", "Arial Italic", 15, Chart.TextColor, Chart.BottomCenter);
// Add a red (0xff0000) pointer at the specified value
m.addPointer2(value, 0xff0000);
// Output the chart
viewer.Chart = m;
}
//Main code for creating charts
public void createChart(WPFChartViewer viewer, int chartIndex)
{
// The value to display on the meter
double value = 50;
// The main color of the four meters in this example. The other colors and gradients are
// derived from the main color.
int[] colorList = { 0x007700, 0x770077, 0x0033dd, 0x880000 };
int mainColor = colorList[chartIndex];
//
// In this example, we demonstrate how to parameterized by size, so that the chart size
// can be changed by changing just one variable.
//
int size = 300;
// The radius of the entire meter, which is size / 2, minus 2 pixels for margin
int outerRadius = size / 2 - 2;
// The radius of the meter scale
int scaleRadius = outerRadius * 92 / 100;
// The radius of the inner decorative circle
int innerRadius = scaleRadius * 40 / 100;
// The width of the color scale
int colorScaleWidth = scaleRadius * 10 / 100;
// Major tick length
int tickLength = scaleRadius * 10 / 100;
// Major tick width
int tickWidth = scaleRadius * 1 / 100 + 1;
// Label font size
int fontSize = scaleRadius * 13 / 100;
//
// Create an angular meter based on the above parameters
//
// Create an AngularMeter object of the specified size. In this demo, we use black
// (0x000000) as the background color. You can also use transparent or other colors.
AngularMeter m = new AngularMeter(size, size, 0x000000);
// Set the default text and line colors to white (0xffffff)
m.setColor(Chart.TextColor, 0xffffff);
m.setColor(Chart.LineColor, 0xffffff);
// Set meter center and scale radius, and set the scale angle from -180 to +90 degrees
m.setMeter(size / 2, size / 2, scaleRadius, -180, 90);
// Background gradient with the mainColor at the center and become darker near the
// border
double[] bgGradient = { 0, mainColor, 0.5, m.adjustBrightness(mainColor, 0.75), 1,
m.adjustBrightness(mainColor, 0.15) };
// Fill the meter background with the background gradient
m.addRing(0, outerRadius, m.relativeRadialGradient(bgGradient, outerRadius * 0.66));
// Fill the inner circle with the same background gradient for decoration
m.addRing(0, innerRadius, m.relativeRadialGradient(bgGradient, innerRadius * 0.8));
// Gradient for the neon backlight, with the main color at the scale radius fading to
// transparent
double[] neonGradient = { 0.89, Chart.Transparent, 1, mainColor, 1.07, Chart.Transparent }
;
m.addRing(scaleRadius * 85 / 100, outerRadius, m.relativeRadialGradient(neonGradient));
// The neon ring at the scale radius with width equal to 1/80 of the scale radius,
// creating using a brighter version of the main color
m.addRing(scaleRadius, scaleRadius + scaleRadius / 80, m.adjustBrightness(mainColor, 2))
;
// Meter scale is 0 - 100, with major/minor/micro ticks every 10/5/1 units
m.setScale(0, 100, 10, 5, 1);
// Set the scale label style, tick length and tick width. The minor and micro tick
// lengths are 80% and 60% of the major tick length, and their widths are around half of
// the major tick width.
m.setLabelStyle("Arial Italic", fontSize);
m.setTickLength(-tickLength, -tickLength * 80 / 100, -tickLength * 60 / 100);
m.setLineWidth(0, tickWidth, (tickWidth + 1) / 2, (tickWidth + 1) / 2);
// Demostrate different types of color scales and glare effects and putting them at
// different positions.
double[] smoothColorScale = { 0, 0x0000ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
double[] stepColorScale = { 0, 0x00dd00, 60, 0xddaa00, 80, 0xdd0000, 100 };
double[] highColorScale = { 70, Chart.Transparent, 100, 0xff0000 };
if (chartIndex == 1)
{
// Add the smooth color scale just outside the inner circle
m.addColorScale(smoothColorScale, innerRadius + 1, colorScaleWidth);
// Add glare up to the scale radius, concave and spanning 190 degrees
m.addGlare(scaleRadius, -190);
}
else if (chartIndex == 2)
{
// Add the high color scale at the default position
m.addColorScale(highColorScale);
// Add glare up to the scale radius
m.addGlare(scaleRadius);
}
else
{
// Add the step color scale just outside the inner circle
m.addColorScale(stepColorScale, innerRadius + 1, colorScaleWidth);
// Add glare up to the scale radius, concave and spanning 190 degrees and rotated by
// -45 degrees
m.addGlare(scaleRadius, -190, -45);
}
// Add a red (0xff0000) pointer at the specified value
m.addPointer2(value, 0xff0000);
// Set the cap background to a brighter version of the mainColor, and using black
// (0x000000) for the cap and grey (0x999999) for the cap border
m.setCap2(m.adjustBrightness(mainColor, 1.1), 0x000000, 0x999999);
// Output the chart
viewer.Chart = m;
}
//Main code for creating charts
public void createChart(WinChartViewer viewer, int chartIndex)
{
// The value to display on the meter
double value = 54;
// The main color of the four meters in this example. The other colors and gradients are
// derived from the main color.
int[] colorList = { 0x0033dd, 0xaaaa00 };
int mainColor = colorList[chartIndex];
//
// In this example, we demonstrate how to parameterized by size, so that the chart size
// can be changed by changing just one variable.
//
int size = 300;
// The radius of the entire meter, which is size / 2, minus 2 pixels for margin
int outerRadius = size / 2 - 2;
// The radius of the meter scale
int scaleRadius = outerRadius * 92 / 100;
// The radius of the color scale
int colorScaleRadius = scaleRadius * 43 / 100;
// The width of the color scale
int colorScaleWidth = scaleRadius * 10 / 100;
// Major tick length
int tickLength = scaleRadius * 10 / 100;
// Major tick width
int tickWidth = scaleRadius * 1 / 100 + 1;
// Label font size
int fontSize = scaleRadius * 13 / 100;
// Radius of readout circle as a ratio to the scale radius
double readOutRadiusRatio = 0.333333333333;
// Readout font size
int readOutFontSize = scaleRadius * 24 / 100;
//
// Create an angular meter based on the above parameters
//
// Create an AngularMeter object of the specified size. In this demo, we use black
// (0x000000) as the background color. You can also use transparent or other colors.
AngularMeter m = new AngularMeter(size, size, 0x000000);
// Set the default text and line colors to white (0xffffff)
m.setColor(Chart.TextColor, 0xffffff);
m.setColor(Chart.LineColor, 0xffffff);
// Set meter center and scale radius, and set the scale angle from -180 to +90 degrees
m.setMeter(size / 2, size / 2, scaleRadius, -180, 90);
// Background gradient with the mainColor at the center and become darker near the
// border
double[] bgGradient = { 0, mainColor, 0.5, m.adjustBrightness(mainColor, 0.75), 1,
m.adjustBrightness(mainColor, 0.15) };
// Fill the meter background with the background gradient
m.addRing(0, outerRadius, m.relativeRadialGradient(bgGradient, outerRadius * 0.66));
// Gradient for the neon backlight, with the main color at the scale radius fading to
// transparent
double[] neonGradient = { 0.89, Chart.Transparent, 1, mainColor, 1.07, Chart.Transparent }
;
m.addRing(scaleRadius * 85 / 100, outerRadius, m.relativeRadialGradient(neonGradient));
// The neon ring at the scale radius with width equal to 1/80 of the scale radius,
// creating using a brighter version of the main color
m.addRing(scaleRadius, scaleRadius + scaleRadius / 80, m.adjustBrightness(mainColor, 2))
;
// Meter scale is 0 - 100, with major/minor/micro ticks every 10/5/1 units
m.setScale(0, 100, 10, 5, 1);
// Set the scale label style, tick length and tick width. The minor and micro tick
// lengths are 80% and 60% of the major tick length, and their widths are around half of
// the major tick width.
m.setLabelStyle("Arial Italic", fontSize);
m.setTickLength(-tickLength, -tickLength * 80 / 100, -tickLength * 60 / 100);
m.setLineWidth(0, tickWidth, tickWidth + 1 / 2, tickWidth + 1 / 2);
// Demostrate different types of color scales and putting them at different positions.
double[] smoothColorScale = { 0, 0x0000ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
double[] highColorScale = { 70, Chart.Transparent, 100, 0xff0000 };
if (chartIndex == 0)
{
// Add the smooth color scale
m.addColorScale(smoothColorScale, colorScaleRadius, colorScaleWidth);
// Add a red (0xff0000) pointer
m.addPointer2(value, 0xff0000);
}
else
{
// Add the high color scale at the default position
m.addColorScale(highColorScale);
// Add a red (0xff0000) triangular pointer starting from 40% and ending at 60% of
// scale radius, with a width 6 times the default
m.addPointer2(value, 0xff0000, -1, Chart.TriangularPointer2, 0.4, 0.6, 6);
}
// Configure a large "pointer cap" to be used as the readout circle at the center. The
// cap border width is set to 1.5% of the scale radius. The cap color is darker version
// of the main color. The border color is a brighter version of the main color with 75%
// brightness gradient effect.
m.setCap2(Chart.Transparent, m.adjustBrightness(mainColor, 0.3), m.adjustBrightness(
mainColor, 1.5), 0.75, 0, readOutRadiusRatio, 0.015);
// Add value label at the center using a brighter version of the main color and Arial
// Italic font
m.addText(size / 2, size / 2, m.formatValue(value, "{value|0}"), "Arial Italic",
readOutFontSize, m.adjustBrightness(mainColor, 2.5), Chart.Center).setMargin(0);
// Add glare up to the scale radius
m.addGlare(scaleRadius);
// Output the chart
viewer.Chart = m;
}
//Main code for creating charts
public void createChart(WinChartViewer viewer, int chartIndex)
{
// The value to display on the meter
double value = 72.3;
// Create an AngularMeter object of size 250 x 250 pixels with transparent background
AngularMeter m = new AngularMeter(250, 250, Chart.Transparent);
// Set the default text and line colors to white (0xffffff)
m.setColor(Chart.TextColor, 0xffffff);
m.setColor(Chart.LineColor, 0xffffff);
// Demonstration two different meter scale angles
if (chartIndex % 2 == 0)
{
// Center at (125, 125), scale radius = 111 pixels, scale angle -140 to +140 degrees
m.setMeter(125, 125, 111, -140, 140);
}
else
{
// Center at (125, 125), scale radius = 111 pixels, scale angle -180 to +90 degrees
m.setMeter(125, 125, 111, -180, 90);
}
// Add a black (0x000000) circle with radius 123 pixels as background
m.addRing(0, 123, 0x000000);
// Gradient color for the border to make it silver-like
double[] ringGradient = { 1, 0x7f7f7f, 0.5, 0xd6d6d6, 0, 0xffffff, -0.5, 0xd6d6d6, -1,
0x7f7f7f };
// Add a ring between radii 116 and 122 pixels using the silver gradient as border
m.addRing(116, 122, m.relativeLinearGradient(ringGradient, 45, 122));
// Meter scale is 0 - 100, with major/minor/micro ticks every 10/5/1 units
m.setScale(0, 100, 10, 5, 1);
// Set the scale label style to 15pt Arial Italic. Set the major/minor/micro tick
// lengths to 12/9/6 pixels pointing inwards, and their widths to 2/1/1 pixels.
m.setLabelStyle("Arial Italic", 15);
m.setTickLength(-12, -9, -6);
m.setLineWidth(0, 2, 1, 1);
// Demostrate different types of color scales and glare effects and putting them at
// different positions.
double[] smoothColorScale = { 0, 0x0000ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
double[] stepColorScale = { 0, 0x00aa00, 60, 0xddaa00, 80, 0xcc0000, 100 };
double[] highLowColorScale = { 0, 0x00ff00, 70, Chart.Transparent, 100, 0xff0000 };
if (chartIndex == 0)
{
// Add the smooth color scale at the default position
m.addColorScale(smoothColorScale);
// Add glare up to radius 116 (= region inside border)
m.addGlare(116);
}
else if (chartIndex == 1)
{
// Add the smooth color scale starting at radius 62 with zero width and ending at
// radius 40 with 22 pixels outer width
m.addColorScale(smoothColorScale, 62, 0, 40, 22);
// Add glare up to radius 116 (= region inside border), concave and spanning 190
// degrees
m.addGlare(116, -190);
}
else if (chartIndex == 2)
{
// Add the smooth color scale starting at radius 111 with zero width and ending at
// radius 111 with 12 pixels inner width
m.addColorScale(smoothColorScale, 111, 0, 111, -12);
// Add glare up to radius 116 (= region inside border), concave and spanning 190
// degrees and rotated by 45 degrees
m.addGlare(116, -190, 45);
}
else if (chartIndex == 3)
{
// Add the high/low color scale at the default position
m.addColorScale(highLowColorScale);
}
else if (chartIndex == 4)
{
// Add the smooth color scale at radius 44 with 16 pixels outer width
m.addColorScale(smoothColorScale, 44, 16);
// Add glare up to radius 116 (= region inside border), concave and spanning 190
// degrees and rotated by -45 degrees
m.addGlare(116, -190, -45);
}
else
{
// Add the step color scale at the default position
m.addColorScale(stepColorScale);
}
// Add a text label centered at (125, 175) with 15pt Arial Italic font
m.addText(125, 175, "CPU", "Arial Italic", 15, Chart.TextColor, Chart.Center);
// Add a readout to some of the charts as demonstration
if (chartIndex == 0 || chartIndex == 2)
{
// Put the value label center aligned at (125, 232), using black (0x000000) 14pt
// Arial font on a light blue (0x99ccff) background. Set box width to 50 pixels with
// 5 pixels rounded corners.
ChartDirector.TextBox t = m.addText(125, 232, m.formatValue(value,
"<*block,width=50,halign=center*>{value|1}"), "Arial", 14, 0x000000,
Chart.BottomCenter);
t.setBackground(0x99ccff);
t.setRoundedCorners(5);
}
// Add a red (0xff0000) pointer at the specified value
m.addPointer2(value, 0xff0000);
// Output the chart
viewer.Chart = m;
}
//Main code for creating charts
public void createChart(WinChartViewer viewer, string img)
{
// The value to display on the meter
double value = 6.5;
// Create an AugularMeter object of size 200 x 100 pixels with rounded
// corners
AngularMeter m = new AngularMeter(200, 100);
m.setRoundedFrame();
// Set meter background according to a parameter
if (img == "0")
{
// Use gold background color
m.setBackground(Chart.goldColor(), 0x000000, -2);
}
else if (img == "1")
{
// Use silver background color
m.setBackground(Chart.silverColor(), 0x000000, -2);
}
else if (img == "2")
{
// Use metallic blue (9898E0) background color
m.setBackground(Chart.metalColor(0x9898e0), 0x000000, -2);
}
else if (img == "3")
{
// Use a wood pattern as background color
m.setBackground(m.patternColor2("wood.png"), 0x000000, -2);
}
else if (img == "4")
{
// Use a marble pattern as background color
m.setBackground(m.patternColor2("marble.png"), 0x000000, -2);
}
else
{
// Use a solid light purple (EEBBEE) background color
m.setBackground(0xeebbee, 0x000000, -2);
}
// Set the meter center at (100, 235), with radius 210 pixels, and span
// from -24 to +24 degress
m.setMeter(100, 235, 210, -24, 24);
// Meter scale is 0 - 100, with a tick every 1 unit
m.setScale(0, 10, 1);
// Set 0 - 6 as green (99ff99) zone, 6 - 8 as yellow (ffff00) zone, and 8
// - 10 as red (ff3333) zone
m.addZone(0, 6, 0x99ff99, 0x808080);
m.addZone(6, 8, 0xffff00, 0x808080);
m.addZone(8, 10, 0xff3333, 0x808080);
// Add a title at the bottom of the meter using 10 pts Arial Bold font
m.addTitle2(Chart.Bottom, "OUTPUT POWER LEVEL\n", "Arial Bold", 10);
// Add a semi-transparent black (80000000) pointer at the specified value
m.addPointer(value, unchecked ((int)0x80000000));
// Output the chart
viewer.Image = m.makeImage();
}
//Main code for creating charts
public void createChart(WinChartViewer viewer, string img)
{
// The value to display on the meter
double value = 4.75;
// Create an AugularMeter object of size 110 x 110 pixels, using silver
// background color with a black 2 pixel 3D depressed border.
AngularMeter m = new AngularMeter(110, 110, Chart.silverColor(),
0x000000, -2);
// Set meter appearance according to a parameter
if (img == "0")
{
// Set the meter center at bottom left corner (15, 95), with radius
// 85 pixels. Meter spans from 90 - 0 degrees.
m.setMeter(15, 95, 85, 90, 0);
// Add a label to the meter centered at (35, 75)
m.addText(35, 75, "VDC", "Arial Bold", 12, Chart.TextColor,
Chart.Center);
// Add a text box to show the value at top right corner (103, 7)
m.addText(103, 7, m.formatValue(value, "2"), "Arial", 8, 0xffffff,
Chart.TopRight).setBackground(0, 0, -1);
}
else if (img == "1")
{
// Set the meter center at top left corner (15, 15), with radius 85
// pixels. Meter spans from 90 - 180 degrees.
m.setMeter(15, 15, 85, 90, 180);
// Add a label to the meter centered at (35, 35)
m.addText(35, 35, "AMP", "Arial Bold", 12, Chart.TextColor,
Chart.Center);
// Add a text box to show the value at bottom right corner (103, 103)
m.addText(103, 103, m.formatValue(value, "2"), "Arial", 8, 0xffffff,
Chart.BottomRight).setBackground(0, 0, -1);
}
else if (img == "2")
{
// Set the meter center at top right corner (15, 95), with radius 85
// pixels. Meter spans from 270 - 180 degrees.
m.setMeter(95, 15, 85, 270, 180);
// Add a label to the meter centered at (75, 35)
m.addText(75, 35, "KW", "Arial Bold", 12, Chart.TextColor,
Chart.Center);
// Add a text box to show the value at bottom left corner (7, 103)
m.addText(7, 103, m.formatValue(value, "2"), "Arial", 8, 0xffffff,
Chart.BottomLeft).setBackground(0, 0, -1);
}
else
{
// Set the meter center at bottom right corner (95, 95), with radius
// 85 pixels. Meter spans from 270 - 360 degrees.
m.setMeter(95, 95, 85, 270, 360);
// Add a label to the meter centered at (75, 75)
m.addText(75, 75, "RPM", "Arial Bold", 12, Chart.TextColor,
Chart.Center);
// Add a text box to show the value at top left corner (7, 7)
m.addText(7, 7, m.formatValue(value, "2"), "Arial", 8, 0xffffff,
Chart.TopLeft).setBackground(0, 0, -1);
}
// Meter scale is 0 - 10, with a major tick every 2 units, and minor tick
// every 1 unit
m.setScale(0, 10, 2, 1);
// Set 0 - 6 as green (99ff99) zone, 6 - 8 as yellow (ffff00) zone, and 8
// - 10 as red (ff3333) zone
m.addZone(0, 6, 0x99ff99, 0x808080);
m.addZone(6, 8, 0xffff00, 0x808080);
m.addZone(8, 10, 0xff3333, 0x808080);
// Add a semi-transparent black (80000000) pointer at the specified value
m.addPointer(value, unchecked ((int)0x80000000));
// Output the chart
viewer.Image = m.makeImage();
}
//
// Create chart
//
private void createChart(RazorChartViewer viewer, int chartIndex)
{
// The value to display on the meter
double value = 72.55;
// Create an AngularMeter object of size 300 x 180 pixels with transparent background
AngularMeter m = new AngularMeter(300, 180, Chart.Transparent);
// Set the default text and line colors to white (0xffffff)
m.setColor(Chart.TextColor, 0xffffff);
m.setColor(Chart.LineColor, 0xffffff);
// Center at (150, 150), scale radius = 128 pixels, scale angle -90 to +90 degrees
m.setMeter(150, 150, 128, -90, 90);
// Gradient color for the border to make it silver-like
double[] ringGradient = { 1, 0x909090, 0.5, 0xd6d6d6, 0, 0xeeeeee, -0.5, 0xd6d6d6, -1,
0x909090 };
// Add a black (0x000000) scale background of 148 pixels radius with a 10 pixel thick silver
// border
m.addScaleBackground(148, 0, 10, m.relativeLinearGradient(ringGradient, 45, 148));
// Meter scale is 0 - 100, with major tick every 20 units, minor tick every 10 units, and
// micro tick every 5 units
m.setScale(0, 100, 20, 10, 5);
// Set the scale label style to 15pt Arial Italic. Set the major/minor/micro tick lengths to
// 16/16/10 pixels pointing inwards, and their widths to 2/1/1 pixels.
m.setLabelStyle("Arial Italic", 16);
m.setTickLength(-16, -16, -10);
m.setLineWidth(0, 2, 1, 1);
// Demostrate different types of color scales and putting them at different positions
double[] smoothColorScale = { 0, 0x0000ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
double[] stepColorScale = { 0, 0x00aa00, 60, 0xddaa00, 80, 0xcc0000, 100 };
double[] highLowColorScale = { 0, 0x00ff00, 70, Chart.Transparent, 100, 0xff0000 };
if (chartIndex == 0)
{
// Add the smooth color scale at the default position
m.addColorScale(smoothColorScale);
}
else if (chartIndex == 1)
{
// Add the smooth color scale starting at radius 128 with zero width and ending at radius
// 128 with 16 pixels inner width
m.addColorScale(smoothColorScale, 128, 0, 128, -16);
}
else if (chartIndex == 2)
{
// Add the smooth color scale starting at radius 70 with zero width and ending at radius
// 60 with 20 pixels outer width
m.addColorScale(smoothColorScale, 70, 0, 60, 20);
}
else if (chartIndex == 3)
{
// Add the high/low color scale at the default position
m.addColorScale(highLowColorScale);
}
else if (chartIndex == 4)
{
// Add the step color scale at the default position
m.addColorScale(stepColorScale);
}
else
{
// Add the smooth color scale at radius 60 with 15 pixels outer width
m.addColorScale(smoothColorScale, 60, 15);
}
// Add a text label centered at (150, 125) with 15pt Arial Italic font
m.addText(150, 125, "CPU", "Arial Italic", 15, Chart.TextColor, Chart.BottomCenter);
// Add a red (0xff0000) pointer at the specified value
m.addPointer2(value, 0xff0000);
// Add glare up to radius 138 (= region inside border)
if (chartIndex % 2 == 0)
{
m.addGlare(138);
}
// Output the chart
viewer.Image = m.makeWebImage(Chart.PNG);
}
//
// Create chart
//
private void createChart(RazorChartViewer viewer, int chartIndex)
{
// The value to display on the meter
double value = 66;
// The background and border colors of the meters
int[] bgColor = { 0x88ccff, 0xffdddd };
int[] borderColor = { 0x000077, 0x880000 };
// Create an AngularMeter object of size 300 x 200 pixels with transparent background
AngularMeter m = new AngularMeter(300, 200, Chart.Transparent);
// Center at (150, 150), scale radius = 124 pixels, scale angle -90 to +90 degrees
m.setMeter(150, 150, 124, -90, 90);
// Background gradient color with brighter color at the center
double[] bgGradient = { 0, m.adjustBrightness(bgColor[chartIndex], 3), 0.75, bgColor[
chartIndex] };
// Add a scale background of 148 pixels radius using the background gradient, with a 13 pixel
// thick border
m.addScaleBackground(148, m.relativeRadialGradient(bgGradient), 13, borderColor[chartIndex]);
// Meter scale is 0 - 100, with major tick every 20 units, minor tick every 10 units, and
// micro tick every 5 units
m.setScale(0, 100, 20, 10, 5);
// Set the scale label style to 15pt Arial Italic. Set the major/minor/micro tick lengths to
// 16/16/10 pixels pointing inwards, and their widths to 2/1/1 pixels.
m.setLabelStyle("Arial Italic", 16);
m.setTickLength(-16, -16, -10);
m.setLineWidth(0, 2, 1, 1);
// Demostrate different types of color scales and putting them at different positions
double[] smoothColorScale = { 0, 0x3333ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
if (chartIndex == 0)
{
// Add the smooth color scale at the default position
m.addColorScale(smoothColorScale);
// Add a red (0xff0000) triangular pointer starting from 38% and ending at 60% of scale
// radius, with a width 6 times the default
m.addPointer2(value, 0xff0000, -1, Chart.TriangularPointer2, 0.38, 0.6, 6);
}
else
{
// Add the smooth color scale starting at radius 124 with zero width and ending at radius
// 124 with 16 pixels inner width
m.addColorScale(smoothColorScale, 124, 0, 124, -16);
// Add a red (0xff0000) pointer
m.addPointer2(value, 0xff0000);
}
// Configure a large "pointer cap" to be used as the readout circle at the center. The cap
// radius and border width is set to 33% and 4% of the meter scale radius. The cap color is
// dark blue (0x000044). The border color is light blue (0x66bbff) with a 60% brightness
// gradient effect.
m.setCap2(Chart.Transparent, 0x000044, 0x66bbff, 0.6, 0, 0.33, 0.04);
// Add value label at the center with light blue (0x66ddff) 28pt Arial Italic font
m.addText(150, 150, m.formatValue(value, "{value|0}"), "Arial Italic", 28, 0x66ddff,
Chart.Center).setMargin(0);
// Output the chart
viewer.Image = m.makeWebImage(Chart.PNG);
}
//Main code for creating charts
public void createChart(WPFChartViewer viewer, int chartIndex)
{
// The value to display on the meter
double value = 72.55;
// The background and border colors of the meters
int[] bgColor = { 0x88ccff, 0xffdddd, 0xffddaa, 0xffccff, 0xdddddd, 0xccffcc };
int[] borderColor = { 0x000077, 0x880000, 0xee6600, 0x440088, 0x000000, 0x006000 };
// Create an AngularMeter object of size 300 x 180 pixels with transparent background
AngularMeter m = new AngularMeter(300, 180, Chart.Transparent);
// Center at (150, 150), scale radius = 124 pixels, scale angle -90 to +90 degrees
m.setMeter(150, 150, 124, -90, 90);
// Background gradient color with brighter color at the center
double[] bgGradient = { 0, m.adjustBrightness(bgColor[chartIndex], 3), 0.75, bgColor[
chartIndex] };
// Add a scale background of 148 pixels radius using the background gradient, with a 13
// pixel thick border
m.addScaleBackground(148, m.relativeRadialGradient(bgGradient), 13, borderColor[
chartIndex]);
// Meter scale is 0 - 100, with major tick every 20 units, minor tick every 10 units,
// and micro tick every 5 units
m.setScale(0, 100, 20, 10, 5);
// Set the scale label style to 15pt Arial Italic. Set the major/minor/micro tick
// lengths to 16/16/10 pixels pointing inwards, and their widths to 2/1/1 pixels.
m.setLabelStyle("Arial Italic", 16);
m.setTickLength(-16, -16, -10);
m.setLineWidth(0, 2, 1, 1);
// Demostrate different types of color scales and putting them at different positions
double[] smoothColorScale = { 0, 0x3333ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
double[] stepColorScale = { 0, 0x00cc00, 60, 0xffdd00, 80, 0xee0000, 100 };
double[] highLowColorScale = { 0, 0x00ff00, 70, Chart.Transparent, 100, 0xff0000 };
if (chartIndex == 0)
{
// Add the smooth color scale at the default position
m.addColorScale(smoothColorScale);
}
else if (chartIndex == 1)
{
// Add the smooth color scale starting at radius 124 with zero width and ending at
// radius 124 with 16 pixels inner width
m.addColorScale(smoothColorScale, 124, 0, 124, -16);
}
else if (chartIndex == 2)
{
// Add the smooth color scale starting at radius 65 with zero width and ending at
// radius 55 with 20 pixels outer width
m.addColorScale(smoothColorScale, 65, 0, 55, 20);
}
else if (chartIndex == 3)
{
// Add the high/low color scale at the default position
m.addColorScale(highLowColorScale);
}
else if (chartIndex == 4)
{
// Add the step color scale at the default position
m.addColorScale(stepColorScale);
}
else
{
// Add the smooth color scale at radius 55 with 20 pixels outer width
m.addColorScale(smoothColorScale, 55, 20);
}
// Add a text label centered at (150, 125) with 15pt Arial Italic font
m.addText(150, 125, "CPU", "Arial Italic", 15, Chart.TextColor, Chart.BottomCenter);
// Demonstrate two different types of pointers - thin triangular pointer (the default)
// and line pointer
if (chartIndex % 2 == 0)
{
m.addPointer2(value, 0xff0000);
}
else
{
m.addPointer2(value, 0xff0000, -1, Chart.LinePointer2);
}
// Output the chart
viewer.Chart = m;
}
//
// Create chart
//
private void createChart(RazorChartViewer viewer, int chartIndex)
{
// The value to display on the meter
double value = 72.3;
// Create an AngularMeter object of size 250 x 250 pixels with transparent background
AngularMeter m = new AngularMeter(250, 250, Chart.Transparent);
// Set the default text and line colors to dark grey (0x333333)
m.setColor(Chart.TextColor, 0x333333);
m.setColor(Chart.LineColor, 0x333333);
// Demonstration two different meter scale angles
if (chartIndex % 2 == 0)
{
// Center at (125, 125), scale radius = 111 pixels, scale angle -140 to +140 degrees
m.setMeter(125, 125, 109, -140, 140);
}
else
{
// Center at (125, 125), scale radius = 111 pixels, scale angle -180 to +90 degrees
m.setMeter(125, 125, 109, -180, 90);
}
// Add a black (0x000000) circle with radius 123 pixels as background
m.addRing(0, 123, 0x000000);
// Background gradient color from white (0xffffff) at the center to light grey (0xdddddd) at
// the border
double[] bgGradient = { 0, 0xffffff, 0.75, 0xeeeeee, 1, 0xdddddd };
// Add circle with radius 123 pixels as background using the background gradient
m.addRing(0, 123, m.relativeRadialGradient(bgGradient, 123));
// Gradient color for the border to make it silver-like
double[] ringGradient = { 1, 0x999999, 0.5, 0xdddddd, 0, 0xffffff, -0.5, 0xdddddd, -1,
0x999999 };
// Add a ring between radii 114 and 123 pixels using the silver gradient with a light grey
// (0xbbbbbb) edge as the meter border
m.addRing(114, 123, m.relativeLinearGradient(ringGradient, 45, 123), 0xbbbbbb);
// Meter scale is 0 - 100, with major/minor/micro ticks every 10/5/1 units
m.setScale(0, 100, 10, 5, 1);
// Set the scale label style to 15pt Arial Italic. Set the major/minor/micro tick lengths to
// 12/9/6 pixels pointing inwards, and their widths to 2/1/1 pixels.
m.setLabelStyle("Arial Italic", 15);
m.setTickLength(-12, -9, -6);
m.setLineWidth(0, 2, 1, 1);
// Demostrate different types of color scales and putting them at different positions
double[] smoothColorScale = { 0, 0x3333ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
double[] stepColorScale = { 0, 0x00cc00, 60, 0xffdd00, 80, 0xee0000, 100 };
double[] highLowColorScale = { 0, 0x00ff00, 70, Chart.Transparent, 100, 0xff0000 };
if (chartIndex == 0)
{
// Add the smooth color scale at the default position
m.addColorScale(smoothColorScale);
}
else if (chartIndex == 1)
{
// Add the smooth color scale starting at radius 62 with zero width and ending at radius
// 40 with 22 pixels outer width
m.addColorScale(smoothColorScale, 62, 0, 40, 22);
}
else if (chartIndex == 2)
{
// Add the smooth color scale starting at radius 109 with zero width and ending at radius
// 109 with 12 pixels inner width
m.addColorScale(smoothColorScale, 109, 0, 109, -12);
}
else if (chartIndex == 3)
{
// Add the high/low color scale at the default position
m.addColorScale(highLowColorScale);
}
else if (chartIndex == 4)
{
// Add the smooth color scale at radius 44 with 16 pixels outer width
m.addColorScale(smoothColorScale, 44, 16);
}
else
{
// Add the step color scale at the default position
m.addColorScale(stepColorScale);
}
// Add a text label centered at (125, 175) with 15pt Arial Italic font
m.addText(125, 175, "CPU", "Arial Italic", 15, Chart.TextColor, Chart.Center);
// Add a readout to some of the charts as demonstration
if (chartIndex == 0 || chartIndex == 2)
{
// Put the value label center aligned at (125, 232), using white (0xffffff) 14pt Arial
// font on a dark grey (0x222222) background. Set box width to 50 pixels with 5 pixels
// rounded corners.
ChartDirector.TextBox t = m.addText(125, 232, m.formatValue(value,
"<*block,width=50,halign=center*>{value|1}"), "Arial", 14, 0xffffff,
Chart.BottomCenter);
t.setBackground(0x222222);
t.setRoundedCorners(5);
}
// Add a red (0xff0000) pointer at the specified value
m.addPointer2(value, 0xff0000);
// Output the chart
viewer.Image = m.makeWebImage(Chart.PNG);
}