private void DrawShadow(Graphics g, Rectangle clipRect)
{
if (this.occludingControl != null)
{
// Draw the outline rectangle
Rectangle outlineRect = new Rectangle(new Point(0, 0), this.occludingControl.Size);
outlineRect = occludingControl.RectangleToScreen(outlineRect);
outlineRect = RectangleToClient(outlineRect);
outlineRect.X -= 1;
outlineRect.Y -= 1;
outlineRect.Width += 2;
outlineRect.Height += 2;
g.DrawLines(
Pens.Black,
new Point[]
{
new Point(outlineRect.Left, outlineRect.Top),
new Point(outlineRect.Right, outlineRect.Top),
new Point(outlineRect.Right, outlineRect.Bottom),
new Point(outlineRect.Left, outlineRect.Bottom),
new Point(outlineRect.Left, outlineRect.Top)
});
using (PdnRegion backRegion = new PdnRegion(clipRect))
{
Rectangle occludingRect = new Rectangle(0, 0, this.occludingControl.Width, this.occludingControl.Height);
occludingRect = this.occludingControl.RectangleToScreen(occludingRect);
occludingRect = RectangleToClient(occludingRect);
backRegion.Exclude(occludingRect);
backRegion.Exclude(outlineRect);
using (Brush backBrush = new SolidBrush(this.BackColor))
{
g.FillRegion(backBrush, backRegion.GetRegionReadOnly());
}
}
Rectangle edgeRect = new Rectangle(0, 0, this.roundedEdgeUL.Width, this.roundedEdgeUR.Height);
Rectangle ulEdgeRect = new Rectangle(outlineRect.Left - 3, outlineRect.Top - 3, this.roundedEdgeUL.Width, this.roundedEdgeUL.Height);
Rectangle urEdgeRect = new Rectangle(outlineRect.Right - 3, outlineRect.Top - 3, this.roundedEdgeUR.Width, this.roundedEdgeUR.Height);
Rectangle llEdgeRect = new Rectangle(outlineRect.Left - 3, outlineRect.Bottom - 3, this.roundedEdgeLL.Width, this.roundedEdgeLL.Height);
Rectangle lrEdgeRect = new Rectangle(outlineRect.Right - 3, outlineRect.Bottom - 3, this.roundedEdgeLR.Width, this.roundedEdgeLR.Height);
g.DrawImage(this.roundedEdgeUL, ulEdgeRect, edgeRect, GraphicsUnit.Pixel);
g.DrawImage(this.roundedEdgeUR, urEdgeRect, edgeRect, GraphicsUnit.Pixel);
g.DrawImage(this.roundedEdgeLL, llEdgeRect, edgeRect, GraphicsUnit.Pixel);
g.DrawImage(this.roundedEdgeLR, lrEdgeRect, edgeRect, GraphicsUnit.Pixel);
Color c1 = Color.FromArgb(95, Color.Black);
Color c2 = Color.FromArgb(47, Color.Black);
Color c3 = Color.FromArgb(15, Color.Black);
Pen p1 = new Pen(c1);
Pen p2 = new Pen(c2);
Pen p3 = new Pen(c3);
// Draw top soft edge
g.DrawLine(p1, ulEdgeRect.Right, outlineRect.Top - 1, urEdgeRect.Left - 1, outlineRect.Top - 1);
g.DrawLine(p2, ulEdgeRect.Right, outlineRect.Top - 2, urEdgeRect.Left - 1, outlineRect.Top - 2);
g.DrawLine(p3, ulEdgeRect.Right, outlineRect.Top - 3, urEdgeRect.Left - 1, outlineRect.Top - 3);
// Draw bottom soft edge
g.DrawLine(p1, llEdgeRect.Right, outlineRect.Bottom + 0, lrEdgeRect.Left - 1, outlineRect.Bottom + 0);
g.DrawLine(p2, llEdgeRect.Right, outlineRect.Bottom + 1, lrEdgeRect.Left - 1, outlineRect.Bottom + 1);
g.DrawLine(p3, llEdgeRect.Right, outlineRect.Bottom + 2, lrEdgeRect.Left - 1, outlineRect.Bottom + 2);
// Draw left soft edge
g.DrawLine(p1, outlineRect.Left - 1, ulEdgeRect.Bottom, outlineRect.Left - 1, llEdgeRect.Top - 1);
g.DrawLine(p2, outlineRect.Left - 2, ulEdgeRect.Bottom, outlineRect.Left - 2, llEdgeRect.Top - 1);
g.DrawLine(p3, outlineRect.Left - 3, ulEdgeRect.Bottom, outlineRect.Left - 3, llEdgeRect.Top - 1);
// Draw right soft edge
g.DrawLine(p1, outlineRect.Right + 0, urEdgeRect.Bottom, outlineRect.Right + 0, lrEdgeRect.Top - 1);
g.DrawLine(p2, outlineRect.Right + 1, urEdgeRect.Bottom, outlineRect.Right + 1, lrEdgeRect.Top - 1);
g.DrawLine(p3, outlineRect.Right + 2, urEdgeRect.Bottom, outlineRect.Right + 2, lrEdgeRect.Top - 1);
p1.Dispose();
p1 = null;
p2.Dispose();
p2 = null;
p3.Dispose();
p3 = null;
}
}
private void DrawGradient(Graphics g)
{
g.PixelOffsetMode = PixelOffsetMode.Half;
Rectangle gradientRect;
float gradientAngle;
switch (this.orientation)
{
case Orientation.Horizontal:
gradientAngle = 180.0f;
break;
case Orientation.Vertical:
gradientAngle = 90.0f;
break;
default:
throw new InvalidEnumArgumentException();
}
// draw gradient
gradientRect = ClientRectangle;
switch (this.orientation)
{
case Orientation.Horizontal:
gradientRect.Inflate(-triangleHalfLength, -triangleSize + 3);
break;
case Orientation.Vertical:
gradientRect.Inflate(-triangleSize + 3, -triangleHalfLength);
break;
default:
throw new InvalidEnumArgumentException();
}
if (this.customGradient != null && gradientRect.Width > 1 && gradientRect.Height > 1)
{
Surface gradientSurface = new Surface(gradientRect.Size);
using (RenderArgs ra = new RenderArgs(gradientSurface))
{
Utility.DrawColorRectangle(ra.Graphics, ra.Bounds, Color.Transparent, false);
if (Orientation == Orientation.Horizontal)
{
for (int x = 0; x < gradientSurface.Width; ++x)
{
// TODO: refactor, double buffer, save this computation in a bitmap somewhere
double index = (double)(x * (this.customGradient.Length - 1)) / (double)(gradientSurface.Width - 1);
int indexL = (int)Math.Floor(index);
double t = 1.0 - (index - indexL);
int indexR = (int)Math.Min(this.customGradient.Length - 1, Math.Ceiling(index));
Color colorL = this.customGradient[indexL];
Color colorR = this.customGradient[indexR];
double a1 = colorL.A / 255.0;
double r1 = colorL.R / 255.0;
double g1 = colorL.G / 255.0;
double b1 = colorL.B / 255.0;
double a2 = colorR.A / 255.0;
double r2 = colorR.R / 255.0;
double g2 = colorR.G / 255.0;
double b2 = colorR.B / 255.0;
double at = (t * a1) + ((1.0 - t) * a2);
double rt;
double gt;
double bt;
if (at == 0)
{
rt = 0;
gt = 0;
bt = 0;
}
else
{
rt = ((t * a1 * r1) + ((1.0 - t) * a2 * r2)) / at;
gt = ((t * a1 * g1) + ((1.0 - t) * a2 * g2)) / at;
bt = ((t * a1 * b1) + ((1.0 - t) * a2 * b2)) / at;
}
int ap = Utility.Clamp((int)Math.Round(at * 255.0), 0, 255);
int rp = Utility.Clamp((int)Math.Round(rt * 255.0), 0, 255);
int gp = Utility.Clamp((int)Math.Round(gt * 255.0), 0, 255);
int bp = Utility.Clamp((int)Math.Round(bt * 255.0), 0, 255);
for (int y = 0; y < gradientSurface.Height; ++y)
{
ColorBgra src = gradientSurface[x, y];
// we are assuming that src.A = 255
int rd = ((rp * ap) + (src.R * (255 - ap))) / 255;
int gd = ((gp * ap) + (src.G * (255 - ap))) / 255;
int bd = ((bp * ap) + (src.B * (255 - ap))) / 255;
// TODO: proper alpha blending!
gradientSurface[x, y] = ColorBgra.FromBgra((byte)bd, (byte)gd, (byte)rd, 255);
}
}
g.DrawImage(ra.Bitmap, gradientRect, ra.Bounds, GraphicsUnit.Pixel);
}
else if (Orientation == Orientation.Vertical)
{
// TODO
}
else
{
throw new InvalidEnumArgumentException();
}
}
gradientSurface.Dispose();
}
else
{
using (LinearGradientBrush lgb = new LinearGradientBrush(this.ClientRectangle,
maxColor, minColor, gradientAngle, false))
{
g.FillRectangle(lgb, gradientRect);
}
}
// fill background
using (PdnRegion nonGradientRegion = new PdnRegion())
{
nonGradientRegion.MakeInfinite();
nonGradientRegion.Exclude(gradientRect);
using (SolidBrush sb = new SolidBrush(this.BackColor))
{
g.FillRegion(sb, nonGradientRegion.GetRegionReadOnly());
}
}
// draw value triangles
for (int i = 0; i < this.vals.Length; i++)
{
int pos = ValueToPosition(vals[i]);
Brush brush;
Pen pen;
if (i == highlight)
{
brush = Brushes.Blue;
pen = (Pen)Pens.White.Clone();
}
else
{
brush = Brushes.Black;
pen = (Pen)Pens.Gray.Clone();
}
g.SmoothingMode = SmoothingMode.AntiAlias;
Point a1;
Point b1;
Point c1;
Point a2;
Point b2;
Point c2;
switch (this.orientation)
{
case Orientation.Horizontal:
a1 = new Point(pos - triangleHalfLength, 0);
b1 = new Point(pos, triangleSize - 1);
c1 = new Point(pos + triangleHalfLength, 0);
a2 = new Point(a1.X, Height - 1 - a1.Y);
b2 = new Point(b1.X, Height - 1 - b1.Y);
c2 = new Point(c1.X, Height - 1 - c1.Y);
break;
case Orientation.Vertical:
a1 = new Point(0, pos - triangleHalfLength);
b1 = new Point(triangleSize - 1, pos);
c1 = new Point(0, pos + triangleHalfLength);
a2 = new Point(Width - 1 - a1.X, a1.Y);
b2 = new Point(Width - 1 - b1.X, b1.Y);
c2 = new Point(Width - 1 - c1.X, c1.Y);
break;
default:
throw new InvalidEnumArgumentException();
}
if (this.drawNearNub)
{
g.FillPolygon(brush, new Point[] { a1, b1, c1, a1 });
}
if (this.drawFarNub)
{
g.FillPolygon(brush, new Point[] { a2, b2, c2, a2 });
}
if (pen != null)
{
if (this.drawNearNub)
{
g.DrawPolygon(pen, new Point[] { a1, b1, c1, a1 });
}
if (this.drawFarNub)
{
g.DrawPolygon(pen, new Point[] { a2, b2, c2, a2 });
}
pen.Dispose();
}
}
}