Gradient Panel With Shadow Support and Lots of Other Stuff

11:25 PM
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);

                GraphicsPath 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 : sandeepparekh9@gmail.com

1 comments:

Post a Comment