Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

DotNet 4.8.1 build of DotNetBar

Browse Source
This commit is contained in:
John Jenko
2025-02-07 10:35:23 -05:00
parent 33439b63a0
commit 6b0a5d60f4
2609 changed files with 989814 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

386
PROMS/DotNetBar Source Code/InstrumentationControls/Knobs/KnobStyle2.cs Normal file
View File

@@ -0,0 +1,386 @@
using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
namespace DevComponents.Instrumentation.Primitives
{
public class KnobStyle2 : BaseKnob
{
/// <summary>
/// Constructor
/// </summary>
/// <param name="knobControl">Associated knob control</param>
public KnobStyle2(KnobControl knobControl)
: base(knobControl)
{
}
#region Knob Configuration
#region ConfigureKnob
/// <summary>
/// Configures the given knob control
/// by establishing various default object parameters
/// </summary>
/// <param name="e"></param>
public override void ConfigureKnob(PaintEventArgs e)
{
base.ConfigureKnob(e);
// Calculate default sizes and bounding object rectangles
ZoneIndWidth = KnobWidth * 0.047f;
MajorTickSize = new Size((int)(KnobWidth * 0.008), (int)(KnobWidth * 0.017));
MinorTickSize = new Size(1, (int)(KnobWidth * 0.02));
IndTickHeight = (int)ZoneIndWidth / 3;
CalculateBoundingRects();
// Fill in the default knob colors
DefaultColorTable.MajorTickColor = Color.Black;
DefaultColorTable.MinorTickColor = Color.Gray;
DefaultColorTable.ZoneIndicatorColor = Color.SteelBlue;
DefaultColorTable.KnobIndicatorPointerColor = Color.Black;
DefaultColorTable.KnobIndicatorPointerBorderColor = Color.Black;
DefaultColorTable.KnobFaceColor = new LinearGradientColorTable(Color.White, Color.LightGray);
DefaultColorTable.KnobIndicatorColor = new LinearGradientColorTable(0xFFFFFF, 0x1A507B);
DefaultColorTable.MinZoneIndicatorColor = new LinearGradientColorTable(Color.White, Color.Green);
DefaultColorTable.MaxZoneIndicatorColor = new LinearGradientColorTable(Color.Yellow, Color.Red);
}
#endregion
#region CalculateBoundingRects
/// <summary>
/// Calculates several default control
/// // bounding rectangles
/// </summary>
private void CalculateBoundingRects()
{
// Calculate the bounding Zone indicator rectangle and width
int delta = MaxLabelWidth + MajorTickSize.Height + (int)(KnobWidth * 0.05f);
ZoneIndicatorBounds = new Rectangle(delta, delta,
KnobWidth - (delta * 2), KnobWidth - (delta * 2));
// Calculate the KnobFace and inset face rectangles
delta += (int)ZoneIndWidth + 1;
KnobFaceBounds = new Rectangle(delta, delta,
KnobWidth - (delta * 2), KnobWidth - (delta * 2));
// Calculate the KnobIndicator bounding rectangle
delta += (int)(KnobWidth * .068f);
KnobIndicatorBounds = new Rectangle(delta, delta,
KnobWidth - (delta * 2), KnobWidth - (delta * 2));
// Calculate the TickLabel bounding rect
delta = (int)((MaxLabelWidth + IndTickHeight) * .60f + IndTickHeight);
TickLabelBounds = new Rectangle(ZoneIndicatorBounds.Location, ZoneIndicatorBounds.Size);
TickLabelBounds.Inflate(delta, delta);
// Calculate the focus rectangle
FocusRectBounds = new Rectangle(KnobFaceBounds.Location, KnobFaceBounds.Size);
delta = (int)(KnobFaceBounds.Width * .025);
FocusRectBounds.Inflate(-delta, -delta);
}
#endregion
#endregion
#region Part rendering code
#region RenderZoneIndicator
/// <summary>
/// Renders the zone indicator
/// </summary>
/// <param name="e"></param>
public override void RenderZoneIndicator(PaintEventArgs e)
{
if (ZoneIndicatorBounds.Width > 10 && ZoneIndicatorBounds.Height > 10)
{
Graphics g = e.Graphics;
Color c = ControlPaint.Light(ZoneIndicatorColor, .30f);
int passes = (int) (ZoneIndWidth);
int adj = 100 / passes;
Rectangle r = new Rectangle(ZoneIndicatorBounds.X,
ZoneIndicatorBounds.Y, ZoneIndicatorBounds.Width, ZoneIndicatorBounds.Height);
r.Inflate(-passes, -passes);
for (int i = 0; i < passes; i++)
{
using (Pen pen = new Pen(c, 2))
{
g.DrawEllipse(pen, r);
r.Inflate(1, 1);
c = Color.FromArgb(Math.Max(0, c.R - adj),
Math.Max(0, c.G - adj), Math.Max(0, c.B - adj));
}
}
}
}
#endregion
#region RenderTickMinor
/// <summary>
/// Renders the minor tick marks
/// </summary>
/// <param name="e"></param>
public override void RenderTickMinor(PaintEventArgs e)
{
Graphics g = e.Graphics;
using (Pen pen = new Pen(MinorTickColor, MinorTickSize.Width))
{
for (int i = 0; i < MinorTicks; i++)
{
// Don't draw a minor tick if it overlaps
// with a previous major tick
if (Knob.MajorTickAmount > 0)
{
if ((i == 0 || i == MinorTicks - 1) ||
((Knob.MinorTickAmount * i) % Knob.MajorTickAmount == 0))
continue;
}
g.DrawLines(pen, GetMinorTickPoints(i));
}
}
}
/// <summary>
/// Calculates a series of points
/// that defines the tick mark
/// </summary>
/// <param name="tick">Tick to calculate</param>
/// <returns>An array of points that defines the tick</returns>
private Point[] GetMinorTickPoints(int tick)
{
float degree = GetTickDegree((float)Knob.MinorTickAmount, tick);
double rad = GetRadians(degree);
int dx = ZoneIndicatorBounds.X + ZoneIndicatorBounds.Width / 2;
int dy = ZoneIndicatorBounds.Y + ZoneIndicatorBounds.Height / 2;
int h = (int)(ZoneIndicatorBounds.Width / 2 + ZoneIndWidth * .1f);
Point[] pts = new Point[2];
pts[0].X = (int)(Math.Cos(rad) * h + dx);
pts[0].Y = (int)(Math.Sin(rad) * h + dy);
pts[1].X = (int)(Math.Cos(rad) * (h + MinorTickSize.Height) + dx);
pts[1].Y = (int)(Math.Sin(rad) * (h + MinorTickSize.Height) + dy);
return (pts);
}
#endregion
#region RenderKnobFace
/// <summary>
/// Renders the knob face
/// </summary>
/// <param name="e"></param>
public override void RenderKnobFace(PaintEventArgs e)
{
if (KnobFaceBounds.Width > 10 && KnobFaceBounds.Height > 10)
{
Graphics g = e.Graphics;
// Allocate a path to accumulate the knob
// drawing pieces
using (GraphicsPath path = new GraphicsPath())
{
// Draw the 14 arc segments all the way to the
// center of the knob just in case the user wants
// to render a different sized/shaped knob indicator
Rectangle rInset = new Rectangle(KnobFaceBounds.X, KnobFaceBounds.Y,
KnobFaceBounds.Width, KnobFaceBounds.Height);
int w = KnobFaceBounds.Width/2 - 1;
rInset.Inflate(-w, -w);
const float arc = 360f/14;
for (int i = 0; i < 14; i++)
{
if (i%2 == 0)
{
path.AddArc(KnobFaceBounds, i*arc, arc);
path.AddArc(rInset, (i + 1)*arc, -arc);
// Let Windows connect the arcs
path.CloseFigure();
}
}
// Select an appropriate hatch size given
// the overall size of the control
HatchStyle hs = (KnobWidth < 250)
? HatchStyle.LightUpwardDiagonal
: HatchStyle.WideUpwardDiagonal;
// Fill the face and then draw the outlining path
using (HatchBrush hbr = new HatchBrush(hs, KnobFaceColor.Start, KnobFaceColor.End))
g.FillPath(hbr, path);
using (Pen pen = new Pen(KnobFaceColor.End))
g.DrawPath(pen, path);
}
}
}
#endregion
#region RenderKnobIndicator
#region RenderKnobIndicator
/// <summary>
/// Renders the knob face
/// </summary>
/// <param name="e"></param>
public override void RenderKnobIndicator(PaintEventArgs e)
{
if (KnobIndicatorBounds.Width > 10 && KnobIndicatorBounds.Height > 10)
{
Graphics g = e.Graphics;
// Allocate a graphics path and draw the
// arrow lines into it
using (GraphicsPath path = new GraphicsPath())
{
path.AddLines(GetIndicatorPoints());
path.CloseFigure();
// Fill the closed arrow
using (SolidBrush br = new SolidBrush(KnobIndicatorPointerColor))
g.FillPath(br, path);
// Outline the arrow and draw the knob face
if (KnobIndicatorPointerBorderWidth > 0 &&
KnobIndicatorPointerColor.Equals(KnobIndicatorPointerBorderColor) == false)
{
using (Pen pen = new Pen(KnobIndicatorPointerBorderColor, KnobIndicatorPointerBorderWidth))
g.DrawPath(pen, path);
}
// Fill the knob face
using (Brush br = KnobIndicatorColor.GetBrush(KnobIndicatorBounds))
g.FillEllipse(br, KnobIndicatorBounds);
// Reset the path and add a glossy looking
// hilight to the control face
path.Reset();
path.AddEllipse(KnobIndicatorBounds);
using (PathGradientBrush pgb = new PathGradientBrush(path))
{
pgb.CenterColor = KnobIndicatorColor.Start;
pgb.SurroundColors = new Color[] {KnobIndicatorColor.End};
int radius = KnobIndicatorBounds.Width/2;
int dr = Math.Max((int) (radius*.1f), 5);
float dx = (radius - dr)*(float) Math.Sin(GetRadians(60));
float dy = (radius - dr)*(float) Math.Cos(GetRadians(60));
pgb.CenterPoint = new PointF(KnobIndicatorBounds.X + radius - dx,
KnobIndicatorBounds.Y + radius - dy);
g.FillRectangle(pgb, KnobIndicatorBounds);
}
}
}
}
#endregion
#region GetIndicatorPoints
/// <summary>
/// Calculates a series of points that
/// defines the indicator arrow
/// </summary>
/// <returns>An array of defining points</returns>
private Point[] GetIndicatorPoints()
{
float degrees = (float)(Knob.SweepAngle / ValueCount) *
(float)(Knob.Value - Knob.MinValue) + Knob.StartAngle;
int arrowHeight = (int)(KnobWidth * .052f);
double rad0 = GetRadians(degrees - 17);
double rad1 = GetRadians(degrees);
double rad2 = GetRadians(degrees + 17);
int n = (int)(KnobIndicatorBounds.Width * .03f);
if (n < 2)
n = 2;
int dx = KnobIndicatorBounds.X + KnobIndicatorBounds.Width / 2 + 1;
int dy = KnobIndicatorBounds.Y + KnobIndicatorBounds.Height / 2 + 1;
int h = KnobIndicatorBounds.Width / 2 + n;
Point[] pts = new Point[3];
pts[0].X = (int)(Math.Cos(rad0) * h + dx);
pts[0].Y = (int)(Math.Sin(rad0) * h + dy);
pts[1].X = (int)(Math.Cos(rad1) * (h + arrowHeight) + dx);
pts[1].Y = (int)(Math.Sin(rad1) * (h + arrowHeight) + dy);
pts[2].X = (int)(Math.Cos(rad2) * h + dx);
pts[2].Y = (int)(Math.Sin(rad2) * h + dy);
return (pts);
}
#endregion
#endregion
#endregion
}
}