Gradient Panel With Shadow Support and Lots of Other Stuff

Properties:

Source Code:


Variables

PointF pf;
SizeF sf = new SizeF();

public enum ImageAlign
{
Custom,
TopLeft,
TopCenter,
TopRight,
MiddleLeft,
MiddleCenter,
MiddleRight,
BottomLeft,
BottomCenter,
BottomRight
}

public enum TextAlign
{
Custom,
TopLeft,
TopCenter,
TopRight,
MiddleLeft,
MiddleCenter,
MiddleRight,
BottomLeft,
BottomCenter,
BottomRight
}

Properties

TextAlign  _TextAlign = TextAlign.TopLeft;
[Browsable(true), Category("GradientPanel")]
public TextAlign TxtAlign
{
get { return _TextAlign; }
set { _TextAlign = value; Invalidate(); }
}

String _Text;
[Browsable(true), Category("GradientPanel")]
public override string Text
{
get { return _Text; }
set { _Text = value; Invalidate(); }
}

private float _TextMargin = 1.0f;
[Browsable(true), Category("GradientPanel")]
[DefaultValue("1.0f")]
public float TextMargin
{
get { return _TextMargin; }
set { _TextMargin = value; Invalidate(); }
}

ImageAlign _ImageAlign= ImageAlign.TopLeft;
[Browsable(true), Category("GradientPanel")]
public ImageAlign ImgAlign
{
get { return _ImageAlign; }
set { _ImageAlign = value; Invalidate(); }
}

Image _Image;
[Browsable(true), Category("GradientPanel")]
public Image Image
{
get { return _Image; }
set { _Image = value; Invalidate(); }
}

Point _ImageLocation = new Point(4, 4);
[Browsable(true), Category("GradientPanel")]
[DefaultValue("4,4")]
public Point ImageLocation
{
get { return _ImageLocation; }
set { _ImageLocation = value; Invalidate(); }
}

private float _ImageMargin = 1.0f;
[Browsable(true), Category("GradientPanel")]
[DefaultValue("1.0f")]
public float ImageMargin
{
get { return _ImageMargin; }
set { _ImageMargin = value; Invalidate(); }
}


int _BorderWidth = 1;
[Browsable(true), Category("GradientPanel")]
[DefaultValue(1)]
public int BorderWidth
{
get { return _BorderWidth; }
set { _BorderWidth = value; Invalidate(); }
}

int _ShadowOffSet = 5;
[Browsable(true), Category("GradientPanel")]
[DefaultValue(5)]
public int Shadow
{
get
{
return _ShadowOffSet;
}
set { _ShadowOffSet = Math.Abs(value); Invalidate(); }
}

int _RoundCornerRadius = 4;
[Browsable(true), Category("GradientPanel")]
[DefaultValue(4)]
public int CornerRadius
{
get { return _RoundCornerRadius; }
set { _RoundCornerRadius = Math.Abs(value); Invalidate(); }
}

Color _BorderColor = Color.Gray;
[Browsable(true), Category("GradientPanel")]
[DefaultValue("Color.Gray")]
public Color BorderColor
{
get { return _BorderColor; }
set { _BorderColor = value; Invalidate(); }
}

Color _GradientStartColor = Color.White;
[Browsable(true), Category("GradientPanel")]
[DefaultValue("Color.White")]
public Color GradientStartColor
{
get { return _GradientStartColor; }
set { _GradientStartColor = value; Invalidate(); }
}

Color _GradientEndColor = Color.Gray;
[Browsable(true), Category("GradientPanel")]
[DefaultValue("Color.Gray")]
public Color GradientEndColor
{
get { return _GradientEndColor; }
set { _GradientEndColor = value; Invalidate(); }
}

LinearGradientMode _LinearGradientMode = LinearGradientMode.Vertical;
[Browsable(true), Category("GradientPanel")]
public LinearGradientMode GradientMode
{
get { return _LinearGradientMode; }
set { _LinearGradientMode = value; Invalidate(); }
}

Boolean _DrawLine = false;
[Browsable(true), Category("GradientPanel")]
public Boolean DrawLine
{
get { return _DrawLine; }
set { _DrawLine = value; Invalidate(); }
}

Color _LineColor = Color.Black;
[Browsable(true), Category("GradientPanel")]
public Color LineColor
{
get { return _LineColor; }
set { _LineColor = value; Invalidate(); }
}

Constructor

public GradientPanelR()
{
this.SetStyle(ControlStyles.DoubleBuffer, true);
this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
this.SetStyle(ControlStyles.ResizeRedraw, true);
this.SetStyle(ControlStyles.UserPaint, true);
this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
InitializeComponent();
}

Overriding OnPaintBackground method

protected override void OnPaintBackground(PaintEventArgs e)
{
base.OnPaintBackground(e);

int tmpShadowOffSet = Math.Min(Math.Min(_ShadowOffSet, this.Width - 2), this.Height - 2);
int tmpSoundCornerRadius = Math.Min(Math.Min(_RoundCornerRadius, this.Width - 2), this.Height - 2);
if (this.Width > 1 && this.Height > 1)
{
e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;

Rectangle rect = new Rectangle(0, 0, this.Width - tmpShadowOffSet - 1, this.Height - tmpShadowOffSet - 1);
Rectangle rectShadow = new Rectangle(tmpShadowOffSet, tmpShadowOffSet, this.Width - tmpShadowOffSet - 1, this.Height - tmpShadowOffSet - 1);

GraphicsPa th graphPathShadow = GetRoundPath(rectShadow, tmpSoundCornerRadius);
GraphicsPath graphPath = GetRoundPath(rect, tmpSoundCornerRadius);

if (tmpSoundCornerRadius > 0)
{
using (PathGradientBrush gBrush = new PathGradientBrush(graphPathShadow))
{
gBrush.WrapMode = WrapMode.Clamp;
ColorBlend colorBlend = new ColorBlend(3);
colorBlend.Colors = new Color[]{Color.Transparent,
Color.FromArgb(180, Color.DimGray),
Color.FromArgb(180, Color.DimGray)};

colorBlend.Positions = new float[] { 0f, .1f, 1f };

gBrush.InterpolationColors = colorBlend;
e.Graphics.FillPath(gBrush, graphPathShadow);
}
}

// Draw backgroud
LinearGradientBrush brush = new LinearGradientBrush(rect,
this._GradientStartColor,
this._GradientEndColor,
GradientMode);
e.Graphics.FillPath(brush, graphPath);
e.Graphics.DrawPath(new Pen(Color.FromArgb(180, this._BorderColor), _BorderWidth), graphPath);

// Draw Image
if (_Image != null)
{
//e.Graphics.DrawImageUnscaled(_Image, _ImageLocation);
DrawImage(e.Graphics);
}


}
DrawText(e.Graphics);
}

Drawing Image

#region DrawImage
public void DrawImage(Graphics g)
{


if (this.Image != null && _ImageAlign != ImageAlign.Custom)
{
pf = new PointF(0, 0);

if (_ImageAlign == ImageAlign.TopLeft)
{
pf.X = 1; pf.Y = 1;
pf.X += _ImageMargin;
pf.Y += _ImageMargin;

if (_DrawLine)
{
// HatchBrush hbr = new HatchBrush(HatchStyle.ZigZag , _LineColor );
Pen P = new Pen(_LineColor, 3);
g.DrawLine(P, new PointF(Image.Width + pf.X + 2 + 10, Image.Height + pf.Y + 2), new PointF(Width - 10, Image.Height + pf.Y + 2));
}

}
if (_ImageAlign == ImageAlign.TopCenter)
{

pf.X = ((float)Width - (float)Image.Width) / 2;
pf.Y += _ImageMargin;
}
if (_ImageAlign == ImageAlign.TopRight)
{

pf.X = (float)Width - (float)Image.Width;
pf.Y = 1;
pf.X -= _ImageMargin;
pf.Y += _ImageMargin;
}

if (_ImageAlign == ImageAlign.MiddleLeft)
{

pf.X = 1;
pf.Y = ((float)Height - (float)Image.Height) / 2;
pf.X += _ImageMargin;

}

if (_ImageAlign == ImageAlign.MiddleCenter)
{
pf.X = ((float)Width - (float)Image.Width) / 2;
pf.Y = ((float)Height - (float)Image.Height) / 2;

}
if (_ImageAlign == ImageAlign.MiddleRight)
{
pf.X = (float)Width - (float)Image.Width;
pf.Y = ((float)Height - (float)Image.Height) / 2;
pf.X -= _ImageMargin;

}

if (_ImageAlign == ImageAlign.BottomLeft)
{
pf.X = 1;
pf.Y = ((float)Height - (float)Image.Height);
pf.X += _ImageMargin;
pf.Y -= _ImageMargin;
}
if (_ImageAlign == ImageAlign.BottomCenter)
{
pf.X = ((float)Width - (float)Image.Width) / 2;
pf.Y = ((float)Height - (float)Image.Height);

pf.Y -= _ImageMargin;
}
if (_ImageAlign == ImageAlign.BottomRight)
{
pf.X = (float)Width - (float)Image.Width;
pf.Y = ((float)Height - (float)Image.Height);

pf.X -= _ImageMargin;
pf.Y -= _ImageMargin;

}

g.DrawImage(this.Image, pf);
}
if (this.Image != null && _ImageAlign == ImageAlign.Custom)
{
pf = new PointF(0, 0);
pf.X = _ImageLocation.X ;
pf.Y = _ImageLocation.Y;

g.DrawImage(this.Image, pf);
}
}
#endregion

Drawing Text

#region DrawText
public void DrawText(Graphics g)
{
SolidBrush b = new SolidBrush(this.ForeColor);

pf = new PointF();
sf = g.MeasureString(this.Text, this.Font);

//calculate textalign
if (_TextAlign == TextAlign.TopLeft)
{
pf.X = 1 + _TextMargin ; pf.Y = 1 + _TextMargin ;
}
if (this._TextAlign == TextAlign.TopCenter)
{

pf.X = ((float)Width - sf.Width) / 2;
pf.Y =1 + _TextMargin ;
}
if (this._TextAlign == TextAlign.TopRight)
{

pf.X = (float)Width - sf.Width - _TextMargin ;
pf.Y = 1 + _TextMargin ;
}

if (this._TextAlign == TextAlign.MiddleLeft)
{

pf.X = 1 + _TextMargin ;
pf.Y =( (float)Height - sf.Height) / 2;
}

if (this._TextAlign == TextAlign.MiddleCenter)
{
pf.X = ((float)Width - sf.Width) / 2;
pf.Y = ((float)Height - sf.Height) / 2;
}
if (this._TextAlign == TextAlign.MiddleRight)
{
pf.X = (float)Width - sf.Width - _TextMargin ;
pf.Y = ((float)Height - sf.Height) / 2;
}

if (this._TextAlign == TextAlign.BottomLeft)
{
pf.X = 1 + _TextMargin ;
pf.Y = ((float)Height - sf.Height) - _TextMargin ;
}
if (this._TextAlign == TextAlign.BottomCenter)
{
pf.X = ((float)Width - sf.Width) / 2;
pf.Y = ((float)Height - sf.Height) - _TextMargin ;
}
if (this._TextAlign == TextAlign.BottomRight)
{
pf.X = (float)Width - sf.Width - _TextMargin;
pf.Y = ((float)Height - sf.Height) - _TextMargin ;
}

//g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias ;
g.DrawString(this.Text, this.Font, b, pf);

}

#endregion

Other Helping Methods

public static GraphicsPath GetRoundPath(Rectangle r, int depth)
{
GraphicsPath graphPath = new GraphicsPath();

graphPath.AddArc(r.X, r.Y, depth, depth, 180, 90);
graphPath.AddArc(r.X + r.Width - depth, r.Y, depth, depth, 270, 90);
graphPath.AddArc(r.X + r.Width - depth, r.Y + r.Height - depth, depth, depth, 0, 90);
graphPath.AddArc(r.X, r.Y + r.Height - depth, depth, depth, 90, 90);
graphPath.AddLine(r.X, r.Y + r.Height - depth, r.X, r.Y + depth / 2);

return graphPath;
}

For Complete source mail me at : [email protected]

 

One thought on “Gradient Panel With Shadow Support and Lots of Other Stuff

Leave a Reply

Your email address will not be published. Required fields are marked *