扩展SplitContainer控件

效果图:

自定义控件实现代码:

 using System;
 using System.ComponentModel;
 using System.Drawing;
 using System.Windows.Forms;
 
 namespace WindowsFormsApplication1
 {
     [ToolboxBitmap(typeof(SplitContainer))]
     public partial class SplitContainerEx : SplitContainer
     {
         #region Field
 
         /// <summary>
         /// 控制器绘制区域
         /// </summary>
         private Rectangle ControlRect
         {
             get
             {
                 var rect = new Rectangle();
 
                 if (Orientation == Orientation.Horizontal)
                 {
                     rect.X = Width <=  ?  : Width /  - ;
                     rect.Y = SplitterDistance;
                     rect.Width = ;
                     rect.Height = ;
                 }
                 else
                 {
                     rect.X = SplitterDistance;
                     rect.Y = Height <=  ?  : Height /  - ;
                     rect.Width = ;
                     rect.Height = ;
                 }
                 return rect;
             }
         }
 
         /// <summary>
         /// 鼠标状态(进入或离开)
         /// </summary>
         private MouseState _mouseState = MouseState.Normal;
 
         /// <summary>
         /// 定义折叠或展开的是哪一个面板
         /// </summary>
         private SplitterPanelEnum _collpaseOrExpandPanel;
 
         /// <summary>
         /// Splitter是否固定
         /// </summary>
         private bool _isSplitterFixed = true;
 
         /// <summary>
         /// 当前是否为折叠状态
         /// </summary>
         private bool _collpased;
 
         #endregion
 
         #region Property
 
         /// <summary>
         /// 进行折叠或展开的SplitterPanel,设置为属性，所以可以在页面进行重新设置
         /// </summary>
         [DefaultValue(SplitterPanelEnum.Panel1)]
         public SplitterPanelEnum CollpaseOrExpandPanel
         {
             get
             {
                 return _collpaseOrExpandPanel;
             }
             set
             {
                 if (value != _collpaseOrExpandPanel)
                 {
                     _collpaseOrExpandPanel = value;
                     Invalidate(ControlRect);
                 }
             }
         }
 
         /// <summary>
         /// 设定Panel1是否为默认折叠
         /// </summary>
         private bool _panel1Collapsed;
         [DefaultValue(false)]
         public new bool Panel1Collapsed
         {
             get
             {
                 return _panel1Collapsed;
             }
             set
             {
                 //只有当CollpaseOrExpandPanel = Panel时，Panel1Collapsed的设置才会有效
                 if (CollpaseOrExpandPanel == SplitterPanelEnum.Panel1 && value != _panel1Collapsed)
                 {
                     _panel1Collapsed = value;
                     //设置_collpased值为value的相反值，再调用CollpaseOrExpand()进行折叠或展开.
                     _collpased = !value;
 
                     CollpaseOrExpand();
                 }
             }
         }
 
         /// <summary>
         /// 设置Panel2是否为默认折叠
         /// </summary>
         private bool _panel2Colapsed;
         [DefaultValue(false)]
         public new bool Panel2Collapsed
         {
             get
             {
                 return _panel2Colapsed;
             }
             set
             {
                 //只有当CollpaseOrExpandPanel = Pane2时，Panel1Collapsed的设置才会有效
                 if (CollpaseOrExpandPanel == SplitterPanelEnum.Panel2 && value != _panel2Colapsed)
                 {
                     _panel2Colapsed = value;
                     //设置_collpased值为value的相反值，再调用CollpaseOrExpand()进行折叠或展开
                     _collpased = !value;
 
                     CollpaseOrExpand();
                 }
             }
         }
 
         /// <summary>
         /// 用于固定保存显式设定的SplitterDistance,因为基类的SplitterDistance属性会变动
         /// </summary>
         public int DefaultSplitterDistance
         {
             get;
             set;
         }
 
         #endregion
 
         #region Ctor
 
         public SplitContainerEx()
         {
             SetStyle(
                 ControlStyles.UserPaint |
                 ControlStyles.AllPaintingInWmPaint |
                 ControlStyles.OptimizedDoubleBuffer, true);
 
             Panel1MinSize = ;
             Panel2MinSize = ;
         }
 
         #endregion
 
         #region Override
 
         protected override void OnPaint(PaintEventArgs e)
         {
             base.OnPaint(e);
 
             Color color = _mouseState == MouseState.Normal ? SystemColors.ButtonShadow : SystemColors.ControlDarkDark;
 
             //需要绘制的图片
             Bitmap bmp = CreateControlImage(color);
 
             //对图片进行旋转
             RotateFlip(bmp);
 
             //清除绘制区域
             e.Graphics.SetClip(SplitterRectangle);
             e.Graphics.Clear(BackColor);
             //绘制
             e.Graphics.DrawImage(bmp, ControlRect);
         }
 
         protected override void OnMouseMove(MouseEventArgs e)
         {
             //鼠标在控制按钮区域
             if (SplitterRectangle.Contains(e.Location))
             {
                 if (ControlRect.Contains(e.Location))
                 {
                     //如果拆分器可移动，则鼠标在控制按钮范围内时临时关闭拆分器
                     if (!IsSplitterFixed)
                     {
                         IsSplitterFixed = true;
 
                         _isSplitterFixed = false;
                     }
 
                     Cursor = Cursors.Hand;
                     _mouseState = MouseState.Hover;
                     Invalidate(ControlRect);
                 }
                 else
                 {
                     //如果拆分器为临时关闭，则开启拆分器
                     if (!_isSplitterFixed)
                     {
                         IsSplitterFixed = false;
                         Cursor = Orientation == Orientation.Horizontal ? Cursors.HSplit : Cursors.VSplit;
                     }
                     else
                     {
                         Cursor = Cursors.Default;
                     }
                     _mouseState = MouseState.Normal;
                     Invalidate(ControlRect);
                 }
             }
             base.OnMouseMove(e);
         }
 
         protected override void OnMouseLeave(EventArgs e)
         {
             Cursor = Cursors.Default;
 
             _mouseState = MouseState.Normal;
 
             Invalidate(ControlRect);
 
             base.OnMouseLeave(e);
         }
 
         protected override void OnMouseClick(MouseEventArgs e)
         {
             if (ControlRect.Contains(e.Location))
             {
                 CollpaseOrExpand();
             }
 
             base.OnMouseClick(e);
         }
 
         #endregion
 
         #region Method
 
         /// <summary>
         /// 折叠或展开
         /// 1.当当前状态为折叠状态时，则进行展开操作
         /// 2.当当前状态为展开状态时，则进行折叠操作
         /// </summary>
         private void CollpaseOrExpand()
         {
             //当前为缩小状态，进行Expand操作
             if (_collpased)
             {
                 //展开
                 SplitterDistance = DefaultSplitterDistance;
             }
             //当前为伸展状态，进行Collpase操作
             else
             {
                 //折叠
                 if (_collpaseOrExpandPanel == SplitterPanelEnum.Panel1)
                 {
                     SplitterDistance = ;
                 }
                 else
                 {
                     if (Orientation == Orientation.Horizontal)
                     {
                         SplitterDistance = Height - ;
                     }
                     else
                     {
                         SplitterDistance = Width - ;
                     }
                 }
             }
 
             _collpased = !_collpased;
 
             Invalidate(ControlRect); //局部刷新绘制
         }
 
         /// <summary>
         /// 需要绘制的用于折叠窗口的按钮样式
         /// </summary>
         /// <param name="color"></param>
         /// <returns></returns>
         private Bitmap CreateControlImage(Color color)
         {
             var bmp = new Bitmap(, );
             for (int x = ; x <= ; x += )
             {
                 for (int y = ; y <= ; y += )
                 {
                     bmp.SetPixel(x, y, color);
                 }
             }
             for (int x = ; x <= ; x += )
             {
                 for (int y = ; y <= ; y += )
                 {
                     bmp.SetPixel(x, y, color);
                 }
             }
 
             int k = ;
             for (int y = ; y >= ; y--)
             {
                 for (int x =  + k; x <=  - k; x++)
                 {
                     bmp.SetPixel(x, y, color);
                 }
                 k++;
             }
 
             return bmp;
         }
 
         private void RotateFlip(Bitmap bmp)
         {
             if (Orientation == Orientation.Horizontal)
             {
                 if (_collpaseOrExpandPanel == SplitterPanelEnum.Panel1 && !_collpased ||
                     _collpaseOrExpandPanel == SplitterPanelEnum.Panel2 && _collpased)
                 {
                     bmp.RotateFlip(RotateFlipType.RotateNoneFlipX);
                 }
                 else
                 {
                     bmp.RotateFlip(RotateFlipType.Rotate180FlipX);
                 }
             }
             else
             {
                 if (_collpaseOrExpandPanel == SplitterPanelEnum.Panel1 && !_collpased ||
                     _collpaseOrExpandPanel == SplitterPanelEnum.Panel2 && _collpased)
                 {
                     bmp.RotateFlip(RotateFlipType.Rotate90FlipX);
                 }
                 else
                 {
                     bmp.RotateFlip(RotateFlipType.Rotate270FlipX);
                 }
             }
         }
 
         #endregion
 
         #region Enums
 
         enum MouseState
         {
             /// <summary>
             /// 正常
             /// </summary>
             Normal,
             /// <summary>
             /// 鼠标移入
             /// </summary>
             Hover
         }
 
         public enum SplitterPanelEnum
         {
             Panel1,
             Panel2
         }
 
         #endregion
     }
 }