XPGroupBox.cs

using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
 
namespace be.gaudry.view.controls
{
	/// <summary>
    /// XP styled GroupBox (expandable)
    /// More info :
    /// http://www.codeproject.com/cs/media/ExtendedGraphics.asp
	/// </summary>
	public class XPGroupBox : GroupBox
	{
        #region declarations
        private System.ComponentModel.IContainer components;
 
        public event EventHandler StateChanged;
        /// <summary>
        /// Collapsed (1) or expanded (0)
        /// </summary>
        public enum GroupBoxState : int
        {
            /// <summary>
            /// Full view
            /// </summary>
            Expanded = 0,
            /// <summary>
            /// Only the title is displayed
            /// </summary>
            Collapsed = 1
        }
        private int headerHeight;
        private Rectangle headerRect;
        private int origHeight;
        private GroupBoxState state = GroupBoxState.Expanded;
        private System.Windows.Forms.ImageList imageList1;
        private Color backColor = System.Drawing.SystemColors.ControlLightLight;
        private Color headerForeColor = System.Drawing.SystemColors.ControlText;
        private Font headerFont;
        private Color borderColor = System.Drawing.SystemColors.ControlDarkDark;
        private Color headerBackColor = System.Drawing.SystemColors.Control;
        private Icon icon = null;
        private Cursor cursor;
        private bool canCollapse = true;
        private bool displayCollapseBtn = true; 
        #endregion
 
		#region properties
		/// <summary>
        /// Get or define if the XPGroupBox can be collapsed or not
		/// </summary>
		[
        Description("Get or define if the XPGroupBox can be collapsed or not"),
		Category("Behavior")
        ]
		public bool CanCollapse {
			get {return canCollapse;}
			set {canCollapse = value;
				this.Invalidate(this.headerRect, false);
			}
        }/// <summary>
        /// Display a button to collapse or expand the XPGroupBox
        /// </summary>
        [
        Description("Display a button to collapse or expand the XPGroupBox"),
        Category("Behavior"), 
        DefaultValue(typeof(bool), "true")
        ]
        public bool DisplayCollapseButton
        {
            get { return displayCollapseBtn; }
            set
            {
                displayCollapseBtn = value;
                this.Invalidate(this.headerRect, false);
            }
        }
        /// <summary>
        /// Get or define the XPGroupBoxState (Expanded or not)
        /// </summary>
        [
        Description("Get or define the XPGroupBoxState (Expanded or not)"),
        Category("Appearance"), 
        DefaultValue(typeof(bool), "false")
        ]
        public bool Expanded
        {
            get { return state.Equals(XPGroupBox.GroupBoxState.Expanded); }
            set
            {
                state = (value) ? GroupBoxState.Expanded : GroupBoxState.Collapsed;
            }
        }
        /*
		/// <summary>
		/// Obtient ou défini la couleur de fond du groupe
		/// </summary>
		[Description("Obtient ou défini la couleur du fond du groupe"),
		Category("Appearance"), DefaultValue(typeof(Color),"239, 243, 255")]
		public Color BackgroundColor {
			get {return backColor;}
			set {backColor = value;
				this.Invalidate(true);
			}
		}
		/// <summary>
		/// Obtient ou défini la couleur du texte de l'entête
		/// </summary>
		[Description("Obtient ou défini la couleur du texte de l'entête"),
		Category("Appearance"), DefaultValue(typeof(Color),"48, 72, 110")]
		public Color HeaderForeColor {
			get {return headerForeColor;}
			set {headerForeColor = value;
				this.Invalidate(this.headerRect, false);
			}
		}
 
		/// <summary>
		/// Otient ou défini la police de l'entête
		/// </summary>
		[Description("Obtient ou défini la police du texte de l'entête"),
		Category("Appearance"), DefaultValue(typeof(Font),"Trebuchet MS; 9,75pt; style=Bold")]
		public Font HeaderFont {
			get {return headerFont;}
			set {
				if (value != null) {
					headerFont = value;
				} else {
					headerFont = base.Font;
				}
				this.ComputeHeaderHeight();
				this.Invalidate();
			}
		}
        */
		[Browsable(false),EditorBrowsable(EditorBrowsableState.Never)]
		public new FlatStyle FlatStyle {
			get {return FlatStyle.Standard;}
		}
 
		[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
		public new Image BackgroundImage {
			get {return null;}
		}
        /*
		/// <summary>
		/// Obtient ou défini la couleur de la bordure du contrôle
		/// </summary>
		[Description("Obtient ou défini la couleur de la bordure du contrôle"),
		Category("Appearance"), DefaultValue(typeof(Color),"183, 202, 234")]
		public Color BorderColor {
			get {return borderColor;}
			set {borderColor = value;
				this.Invalidate();
			}
		}
		/// <summary>
		/// Obtient ou défini la couleur de fond de l'entête
		/// </summary>
		[Description("Obtient ou défini la couleur du fond de l'entête"),
		Category("Appearance"), DefaultValue(typeof(Color),"195, 214, 255")]
		public Color HeaderBackColor {
			get {return headerBackColor;}
			set {headerBackColor = value;
				this.Invalidate(this.headerRect, false);
 
			}
		}
        */
		/// <summary>
        /// Get or define the icon witch be displayed in the title
		/// </summary>
		[
        Description("Get or define the icon witch be displayed in the title"),
		Category("Appearance")
        ]
		public Icon Icon {
			get {return icon;}
			set {
				icon = value;
				this.Invalidate(this.headerRect, false);
			}
		}
 
		#endregion
 
        #region constructor
        public XPGroupBox()
        {
            this.SetStyle(ControlStyles.UserPaint |
                ControlStyles.DoubleBuffer |
                ControlStyles.SupportsTransparentBackColor |
                ControlStyles.AllPaintingInWmPaint, true);
            InitializeComponent();
            ComputeHeaderHeight();
 
            this.headerFont = base.Font;
            //			this.backColor = base.BackColor;
            cursor = base.Cursor;
        } 
        #endregion
 
        #region public methods
        /// <summary>
        /// Expand or collapse the XPGroupBox
        /// </summary>
        /// <param name="expand">(bool) true to expand</param>
        public void expand(bool expand)
        {
            this.state = (expand) ? GroupBoxState.Expanded : GroupBoxState.Collapsed;
            ChangeState();
        } 
        #endregion
 
        #region events and private methods
        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);
            if (canCollapse)
            {
                if (headerRect.Contains(this.PointToClient(MousePosition)))
                {
                    cursor = this.Cursor;
                    this.Cursor = Cursors.Hand;
                }
                else
                {
                    this.Cursor = Cursors.Default;
                }
            }
        }
 
        protected override void OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp(e);
 
            if (this.canCollapse && headerRect.Contains(this.PointToClient(MousePosition)))
            {
                this.state = (this.state == GroupBoxState.Collapsed ? GroupBoxState.Expanded : GroupBoxState.Collapsed);
                ChangeState();
            }
        }
 
        protected override void OnPaintBackground(PaintEventArgs pevent)
        {
            //			base.OnPaintBackground (pevent);
            pevent.Graphics.FillRectangle(new SolidBrush(this.BackColor),
                new Rectangle(0, 0, this.Width, this.Height));
        }
 
        protected void ChangeState()
        {
            if (this.state != GroupBoxState.Expanded)
            {
                this.origHeight = this.Height;
                this.Height = this.headerHeight + 1; // + 5;
            }
            else
            {
                this.Height = this.origHeight;
            }
            if (this.StateChanged != null)
            {
                this.StateChanged(this, EventArgs.Empty);
            }
        }
 
 
        //		public GroupBoxState State {
        //			get {return state;}
        //			set {state = value;
        //				ChangeState();
        //			}
        //		}
 
        public override Rectangle DisplayRectangle
        {
            get
            {
                Rectangle rect = new Rectangle(1, headerHeight + 1, this.Width - 2, this.Height - headerHeight - 8);
                return rect;
            }
        }
 
 
        protected override void OnPaint(PaintEventArgs e)
        {
            headerHeight = ComputeHeaderHeight();
 
            //			// We erase the control
            //			e.Graphics.FillRectangle(new SolidBrush(Color.Transparent), 0,0,this.Width,this.Height);
 
            GraphicsPath RREntete = this.GetRoundedRect(this.headerRect, 4F);
            GraphicsPath RRBackground = this.GetRoundedRect(new Rectangle(0, 0, this.Width - 1, this.Height - 5), 4F);
 
            // fill the background if state == Expanded
            if (this.state == GroupBoxState.Expanded)
            {
                e.Graphics.FillPath(new SolidBrush(this.backColor), RRBackground);
                e.Graphics.DrawPath(new Pen(this.borderColor), RRBackground);
            }
 
 
            // paint the header of the control
            Brush b = new LinearGradientBrush(
                this.headerRect, this.headerBackColor, this.backColor, LinearGradientMode.Horizontal);
            e.Graphics.FillPath(b, RREntete);
            e.Graphics.DrawPath(new Pen(this.borderColor), RREntete);
 
            // add icon if exists
            int left = 5;
            if (this.icon != null)
            {
                e.Graphics.DrawIcon(
                    this.icon,
                    new Rectangle(left, 2, this.headerHeight - 2, this.headerHeight - 2));
                left += this.headerHeight + 5;
            }
 
            // add header text
            StringFormat sf = StringFormat.GenericTypographic;
            sf.LineAlignment = StringAlignment.Center;
            e.Graphics.DrawString(this.Text, headerFont, new SolidBrush(this.headerForeColor),
                new Rectangle(left, 0, this.Width - left, this.headerHeight),
                sf);
            sf.Dispose();
 
            if (this.canCollapse)
            {
                // draw image according to the XPGroupBox state (expanded or not)
                e.Graphics.DrawImage(this.imageList1.Images[(int)state], new Point(this.Width - 24, (this.headerHeight - 16) / 2));
                // draw a vertical line to separate text from the header and the state image
                e.Graphics.DrawLine(new Pen(this.borderColor), new Point(this.Width - 32, (this.headerHeight - 16) / 2),
                    new Point(this.Width - 32, 16 + (this.headerHeight - 16) / 2));
                e.Graphics.DrawLine(SystemPens.ControlLight, new Point(this.Width - 31, 1 + (this.headerHeight - 16) / 2),
                    new Point(this.Width - 31, 17 + (this.headerHeight - 16) / 2));
            }
        }
 
        /// <summary>
        /// Calculate the ideal size of the header according to the used font.
        /// </summary>
        /// <returns>ideal size in pixels</returns>
        private int ComputeHeaderHeight()
        {
 
            Font font = this.headerFont;
            if (font == null) font = base.Font;
 
            int height = (int)(this.CreateGraphics().MeasureString("I", font).Height * 1.5F);
            if (height != this.headerHeight)
            {
                this.headerHeight = height;
                this.RecreateHandle();
            }
            headerRect = new Rectangle(0, 0, this.Width - 1, this.headerHeight);
            return this.headerHeight;
        }
 
 
 
        /// <summary> 
        /// Clean non used ressources
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }
            base.Dispose(disposing);
        } 
        #endregion
 
        #region Windows Form Designer generated code
 
        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
		{
			this.components = new System.ComponentModel.Container();
			System.Resources.ResourceManager resources = new System.Resources.ResourceManager(typeof(XPGroupBox));
			this.imageList1 = new System.Windows.Forms.ImageList(this.components);
			// 
			// imageList1
			// 
			this.imageList1.ColorDepth = System.Windows.Forms.ColorDepth.Depth32Bit;
			this.imageList1.ImageSize = new System.Drawing.Size(16, 16);
			this.imageList1.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList1.ImageStream")));
			this.imageList1.TransparentColor = System.Drawing.Color.Magenta;
 
		}
		#endregion
 
		#region Code from CodeProject : http://www.codeproject.com/cs/media/ExtendedGraphics.asp
		private GraphicsPath GetRoundedRect(RectangleF baseRect, 
			float radius) {
			// if corner radius is less than or equal to zero, 
			// return the original rectangle 
			if( radius<=0.0F ) { 
				GraphicsPath mPath = new GraphicsPath(); 
				mPath.AddRectangle(baseRect); 
				mPath.CloseFigure(); 
				return mPath;
			}
 
			// if the corner radius is greater than or equal to 
			// half the width, or height (whichever is shorter) 
			// then return a capsule instead of a lozenge 
			if( radius>=(Math.Min(baseRect.Width, baseRect.Height))/2.0) 
				return GetCapsule( baseRect ); 
 
			// create the arc for the rectangle sides and declare 
			// a graphics path object for the drawing 
			float diameter = radius * 2.0F; 
			SizeF sizeF = new SizeF( diameter, diameter );
			RectangleF arc = new RectangleF( baseRect.Location, sizeF ); 
			GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath(); 
 
			// top left arc 
			path.AddArc( arc, 180, 90 ); 
 
			// top right arc 
			arc.X = baseRect.Right-diameter; 
			path.AddArc( arc, 270, 90 ); 
 
			// bottom right arc 
			arc.Y = baseRect.Bottom-diameter; 
			path.AddArc( arc, 0, 90 ); 
 
			// bottom left arc
			arc.X = baseRect.Left;     
			path.AddArc( arc, 90, 90 );     
 
			path.CloseFigure(); 
			return path; 
		} 
 
		private GraphicsPath GetCapsule( RectangleF baseRect ) { 
			float diameter; 
			RectangleF arc; 
			GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath(); 
			try { 
				if( baseRect.Width>baseRect.Height ) { 
					// return horizontal capsule 
					diameter = baseRect.Height; 
					SizeF sizeF = new SizeF(diameter, diameter);
					arc = new RectangleF( baseRect.Location, sizeF ); 
					path.AddArc( arc, 90, 180); 
					arc.X = baseRect.Right-diameter; 
					path.AddArc( arc, 270, 180); 
				} 
				else if( baseRect.Width < baseRect.Height ) { 
					// return vertical capsule 
					diameter = baseRect.Width;
					SizeF sizeF = new SizeF(diameter, diameter);
					arc = new RectangleF( baseRect.Location, sizeF ); 
					path.AddArc( arc, 180, 180 ); 
					arc.Y = baseRect.Bottom-diameter; 
					path.AddArc( arc, 0, 180 ); 
				} 
				else { 
					// return circle 
					path.AddEllipse( baseRect ); 
				}
			} 
			catch(Exception ex) {
				path.AddEllipse( baseRect ); 
				System.Console.WriteLine(ex.Message);
			} 
			finally { 
				path.CloseFigure(); 
			} 
			return path; 
		} 
		#endregion
	}
}