开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > C#编程 > 查看源码
DockPanel.cs
资源名称：WeifenLuo.WinFormsUI.Docking.rar　[点击查看]
上传用户：szlfmled
上传日期：2020-11-22
资源大小：978k
文件大小：30k
源码类别：

C#编程

开发平台：

C#

DockPanel.cs：源码内容
  1. using System;
  2. using System.Drawing;
  3. using System.Drawing.Drawing2D;
  4. using System.Windows.Forms;
  5. using System.ComponentModel;
  6. using System.Runtime.InteropServices;
  7. using System.IO;
  8. using System.Text;
  9. using System.Diagnostics.CodeAnalysis;
  10. using System.Collections.Generic;
  11. using System.Windows.Forms.Design;
  13. // To simplify the process of finding the toolbox bitmap resource:
  14. // #1 Create an internal class called "resfinder" outside of the root namespace.
  15. // #2 Use "resfinder" in the toolbox bitmap attribute instead of the control name.
  16. // #3 use the "<default namespace>.<resourcename>" string to locate the resource.
  17. // See: http://www.bobpowell.net/toolboxbitmap.htm
  18. internal class resfinder
  19. {
  20. }
  22. namespace WeifenLuo.WinFormsUI.Docking
  23. {
  24.     [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters", MessageId = "0#")]
  25. public delegate IDockContent DeserializeDockContent(string persistString);
  27.     [LocalizedDescription("DockPanel_Description")]
  28.     [Designer(typeof(System.Windows.Forms.Design.ControlDesigner))]
  29.     [ToolboxBitmap(typeof(resfinder), "WeifenLuo.WinFormsUI.Docking.DockPanel.bmp")]
  30.     [DefaultProperty("DocumentStyle")]
  31.     [DefaultEvent("ActiveContentChanged")]
  32. public partial class DockPanel : Panel
  33. {
  34.         private FocusManagerImpl m_focusManager;
  35.         private DockPanelExtender m_extender;
  36.         private DockPaneCollection m_panes;
  37.         private FloatWindowCollection m_floatWindows;
  38.         private AutoHideWindowControl m_autoHideWindow;
  39.         private DockWindowCollection m_dockWindows;
  40.         private DockContent m_dummyContent; 
  41.         private Control m_dummyControl;
  42.         
  43. public DockPanel()
  44. {
  45.             m_focusManager = new FocusManagerImpl(this);
  46. m_extender = new DockPanelExtender(this);
  47. m_panes = new DockPaneCollection();
  48. m_floatWindows = new FloatWindowCollection();
  50.             SuspendLayout();
  52. m_autoHideWindow = new AutoHideWindowControl(this);
  53. m_autoHideWindow.Visible = false;
  54.             SetAutoHideWindowParent();
  56. m_dummyControl = new DummyControl();
  57. m_dummyControl.Bounds = new Rectangle(0, 0, 1, 1);
  58. Controls.Add(m_dummyControl);
  60. m_dockWindows = new DockWindowCollection(this);
  61. Controls.AddRange(new Control[] {
  62. DockWindows[DockState.Document],
  63. DockWindows[DockState.DockLeft],
  64. DockWindows[DockState.DockRight],
  65. DockWindows[DockState.DockTop],
  66. DockWindows[DockState.DockBottom]
  67. });
  69. m_dummyContent = new DockContent();
  70.             ResumeLayout();
  71.         }
  72.         
  73.         private Color m_BackColor;
  74.         /// <summary>
  75.         /// Determines the color with which the client rectangle will be drawn.
  76.         /// If you take this property instead of the BackColor it will not have any influence on the borders to the surrounding controls (DockPane).
  77.         /// If you use BackColor the borders to the surrounding controls (DockPane) will also change there colors.
  78.         /// Alternatively you can use both of them (BackColor to draw the define the color of the borders and DockBackColor to define the color of the client rectangle). 
  79.         /// For Backgroundimages: Set your prefered Image, then set the DockBackColor and the BackColor to the same Color (Control)
  80.         /// </summary>
  81.         public Color DockBackColor
  82.         {
  83.             get
  84.             {
  85.                 return !m_BackColor.IsEmpty ? m_BackColor : base.BackColor;
  86.             }
  87.             set
  88.             {
  89.                 m_BackColor = value;
  90.             }
  91.         }
  93. private AutoHideStripBase m_autoHideStripControl = null;
  94. internal AutoHideStripBase AutoHideStripControl
  95. {
  96. get
  97. {
  98. if (m_autoHideStripControl == null)
  99. {
  100. m_autoHideStripControl = AutoHideStripFactory.CreateAutoHideStrip(this);
  101. Controls.Add(m_autoHideStripControl);
  102. }
  103. return m_autoHideStripControl;
  104. }
  105. }
  106.         internal void ResetAutoHideStripControl()
  107.         {
  108.             if (m_autoHideStripControl != null)
  109.                 m_autoHideStripControl.Dispose();
  111.             m_autoHideStripControl = null;
  112.         }
  114. private void MdiClientHandleAssigned(object sender, EventArgs e)
  115. {
  116. SetMdiClient();
  117. PerformLayout();
  118. }
  120. private void MdiClient_Layout(object sender, LayoutEventArgs e)
  121. {
  122. if (DocumentStyle != DocumentStyle.DockingMdi)
  123. return;
  125. foreach (DockPane pane in Panes)
  126. if (pane.DockState == DockState.Document)
  127. pane.SetContentBounds();
  129. InvalidateWindowRegion();
  130. }
  132. private bool m_disposed = false;
  133. protected override void Dispose(bool disposing)
  134. {
  135. lock (this)
  136. {
  137. if (!m_disposed && disposing)
  138. {
  139.                     m_focusManager.Dispose();
  140. if (m_mdiClientController != null)
  141. {
  142. m_mdiClientController.HandleAssigned -= new EventHandler(MdiClientHandleAssigned);
  143. m_mdiClientController.MdiChildActivate -= new EventHandler(ParentFormMdiChildActivate);
  144. m_mdiClientController.Layout -= new LayoutEventHandler(MdiClient_Layout);
  145. m_mdiClientController.Dispose();
  146. }
  147. FloatWindows.Dispose();
  148. Panes.Dispose();
  149. DummyContent.Dispose();
  151. m_disposed = true;
  152. }
  154. base.Dispose(disposing);
  155. }
  156. }
  158. [Browsable(false)]
  159. public IDockContent ActiveAutoHideContent
  160. {
  161. get { return AutoHideWindow.ActiveContent; }
  162. set { AutoHideWindow.ActiveContent = value; }
  163. }
  165.         private bool m_allowEndUserDocking = true;
  166. [LocalizedCategory("Category_Docking")]
  167. [LocalizedDescription("DockPanel_AllowEndUserDocking_Description")]
  168. [DefaultValue(true)]
  169. public bool AllowEndUserDocking
  170. {
  171. get { return m_allowEndUserDocking; }
  172. set { m_allowEndUserDocking = value; }
  173. }
  175.         private bool m_allowEndUserNestedDocking = true;
  176.         [LocalizedCategory("Category_Docking")]
  177.         [LocalizedDescription("DockPanel_AllowEndUserNestedDocking_Description")]
  178.         [DefaultValue(true)]
  179.         public bool AllowEndUserNestedDocking
  180.         {
  181.             get { return m_allowEndUserNestedDocking; }
  182.             set { m_allowEndUserNestedDocking = value; }
  183.         }
  185.         private DockContentCollection m_contents = new DockContentCollection();
  186. [Browsable(false)]
  187. public DockContentCollection Contents
  188. {
  189. get { return m_contents; }
  190. }
  192. internal DockContent DummyContent
  193. {
  194. get { return m_dummyContent; }
  195. }
  197.         private bool m_rightToLeftLayout = false;
  198.         [DefaultValue(false)]
  199.         [LocalizedCategory("Appearance")]
  200.         [LocalizedDescription("DockPanel_RightToLeftLayout_Description")]
  201.         public bool RightToLeftLayout
  202.         {
  203.             get { return m_rightToLeftLayout; }
  204.             set
  205.             {
  206.                 if (m_rightToLeftLayout == value)
  207.                     return;
  209.                 m_rightToLeftLayout = value;
  210.                 foreach (FloatWindow floatWindow in FloatWindows)
  211.                     floatWindow.RightToLeftLayout = value;
  212.             }
  213.         }
  215.         protected override void OnRightToLeftChanged(EventArgs e)
  216.         {
  217.             base.OnRightToLeftChanged(e);
  218.             foreach (FloatWindow floatWindow in FloatWindows)
  219.             {
  220.                 if (floatWindow.RightToLeft != RightToLeft)
  221.                     floatWindow.RightToLeft = RightToLeft;
  222.             }
  223.         }
  225. private bool m_showDocumentIcon = false;
  226. [DefaultValue(false)]
  227. [LocalizedCategory("Category_Docking")]
  228. [LocalizedDescription("DockPanel_ShowDocumentIcon_Description")]
  229. public bool ShowDocumentIcon
  230. {
  231. get { return m_showDocumentIcon; }
  232. set
  233. {
  234. if (m_showDocumentIcon == value)
  235. return;
  237. m_showDocumentIcon = value;
  238. Refresh();
  239. }
  240. }
  242.         private DockPanelSkin m_dockPanelSkin = new DockPanelSkin();
  243.         [LocalizedCategory("Category_Docking")]
  244.         [LocalizedDescription("DockPanel_DockPanelSkin")]
  245.         public DockPanelSkin Skin
  246.         {
  247.             get { return m_dockPanelSkin; }
  248.             set { m_dockPanelSkin = value; }
  249.         }
  251.         private DocumentTabStripLocation m_documentTabStripLocation = DocumentTabStripLocation.Top;
  252.         [DefaultValue(DocumentTabStripLocation.Top)]
  253.         [LocalizedCategory("Category_Docking")]
  254.         [LocalizedDescription("DockPanel_DocumentTabStripLocation")]
  255.         public DocumentTabStripLocation DocumentTabStripLocation
  256.         {
  257.             get { return m_documentTabStripLocation; }
  258.             set { m_documentTabStripLocation = value; }
  259.         }
  261. [Browsable(false)]
  262. public DockPanelExtender Extender
  263. {
  264. get { return m_extender; }
  265. }
  267. public DockPanelExtender.IDockPaneFactory DockPaneFactory
  268. {
  269. get { return Extender.DockPaneFactory; }
  270. }
  272. public DockPanelExtender.IFloatWindowFactory FloatWindowFactory
  273. {
  274. get { return Extender.FloatWindowFactory; }
  275. }
  277. internal DockPanelExtender.IDockPaneCaptionFactory DockPaneCaptionFactory
  278. {
  279. get { return Extender.DockPaneCaptionFactory; }
  280. }
  282. internal DockPanelExtender.IDockPaneStripFactory DockPaneStripFactory
  283. {
  284. get { return Extender.DockPaneStripFactory; }
  285. }
  287. internal DockPanelExtender.IAutoHideStripFactory AutoHideStripFactory
  288. {
  289. get { return Extender.AutoHideStripFactory; }
  290. }
  292. [Browsable(false)]
  293. public DockPaneCollection Panes
  294. {
  295. get { return m_panes; }
  296. }
  298. internal Rectangle DockArea
  299. {
  300. get
  301. {
  302. return new Rectangle(DockPadding.Left, DockPadding.Top,
  303. ClientRectangle.Width - DockPadding.Left - DockPadding.Right,
  304. ClientRectangle.Height - DockPadding.Top - DockPadding.Bottom);
  305. }
  306. }
  308. private double m_dockBottomPortion = 0.25;
  309. [LocalizedCategory("Category_Docking")]
  310. [LocalizedDescription("DockPanel_DockBottomPortion_Description")]
  311. [DefaultValue(0.25)]
  312. public double DockBottomPortion
  313. {
  314. get { return m_dockBottomPortion; }
  315. set
  316. {
  317. if (value <= 0)
  318. throw new ArgumentOutOfRangeException("value");
  320. if (value == m_dockBottomPortion)
  321. return;
  323. m_dockBottomPortion = value;
  325.                 if (m_dockBottomPortion < 1 && m_dockTopPortion < 1)
  326.                 {
  327.                     if (m_dockTopPortion + m_dockBottomPortion > 1)
  328.                         m_dockTopPortion = 1 - m_dockBottomPortion;
  329.                 }
  331. PerformLayout();
  332. }
  333. }
  335. private double m_dockLeftPortion = 0.25;
  336. [LocalizedCategory("Category_Docking")]
  337. [LocalizedDescription("DockPanel_DockLeftPortion_Description")]
  338. [DefaultValue(0.25)]
  339. public double DockLeftPortion
  340. {
  341. get { return m_dockLeftPortion; }
  342. set
  343. {
  344. if (value <= 0)
  345. throw new ArgumentOutOfRangeException("value");
  347. if (value == m_dockLeftPortion)
  348. return;
  350. m_dockLeftPortion = value;
  352.                 if (m_dockLeftPortion < 1 && m_dockRightPortion < 1)
  353.                 {
  354.                     if (m_dockLeftPortion + m_dockRightPortion > 1)
  355.                         m_dockRightPortion = 1 - m_dockLeftPortion;
  356.                 }
  357. PerformLayout();
  358. }
  359. }
  361. private double m_dockRightPortion = 0.25;
  362. [LocalizedCategory("Category_Docking")]
  363. [LocalizedDescription("DockPanel_DockRightPortion_Description")]
  364. [DefaultValue(0.25)]
  365. public double DockRightPortion
  366. {
  367. get { return m_dockRightPortion; }
  368. set
  369. {
  370. if (value <= 0)
  371. throw new ArgumentOutOfRangeException("value");
  373. if (value == m_dockRightPortion)
  374. return;
  376. m_dockRightPortion = value;
  378.                 if (m_dockLeftPortion < 1 && m_dockRightPortion < 1)
  379.                 {
  380.                     if (m_dockLeftPortion + m_dockRightPortion > 1)
  381.                         m_dockLeftPortion = 1 - m_dockRightPortion;
  382.                 }
  383. PerformLayout();
  384. }
  385. }
  387. private double m_dockTopPortion = 0.25;
  388. [LocalizedCategory("Category_Docking")]
  389. [LocalizedDescription("DockPanel_DockTopPortion_Description")]
  390. [DefaultValue(0.25)]
  391. public double DockTopPortion
  392. {
  393. get { return m_dockTopPortion; }
  394. set
  395. {
  396. if (value <= 0)
  397. throw new ArgumentOutOfRangeException("value");
  399. if (value == m_dockTopPortion)
  400. return;
  402. m_dockTopPortion = value;
  404.                 if (m_dockTopPortion < 1 && m_dockBottomPortion < 1)
  405.                 {
  406.                     if (m_dockTopPortion + m_dockBottomPortion > 1)
  407.                         m_dockBottomPortion = 1 - m_dockTopPortion;
  408.                 }
  409. PerformLayout();
  410. }
  411. }
  413. [Browsable(false)]
  414. public DockWindowCollection DockWindows
  415. {
  416. get { return m_dockWindows; }
  417. }
  419.         public void UpdateDockWindowZOrder(DockStyle dockStyle, bool fullPanelEdge)
  420.         {
  421.             if (dockStyle == DockStyle.Left)
  422.             {
  423.                 if (fullPanelEdge)
  424.                     DockWindows[DockState.DockLeft].SendToBack();
  425.                 else
  426.                     DockWindows[DockState.DockLeft].BringToFront();
  427.             }
  428.             else if (dockStyle == DockStyle.Right)
  429.             {
  430.                 if (fullPanelEdge)
  431.                     DockWindows[DockState.DockRight].SendToBack();
  432.                 else
  433.                     DockWindows[DockState.DockRight].BringToFront();
  434.             }
  435.             else if (dockStyle == DockStyle.Top)
  436.             {
  437.                 if (fullPanelEdge)
  438.                     DockWindows[DockState.DockTop].SendToBack();
  439.                 else
  440.                     DockWindows[DockState.DockTop].BringToFront();
  441.             }
  442.             else if (dockStyle == DockStyle.Bottom)
  443.             {
  444.                 if (fullPanelEdge)
  445.                     DockWindows[DockState.DockBottom].SendToBack();
  446.                 else
  447.                     DockWindows[DockState.DockBottom].BringToFront();
  448.             }
  449.         }
  451.         public int DocumentsCount
  452.         {
  453.             get
  454.             {
  455.                 int count = 0;
  456.                 foreach (IDockContent content in Documents)
  457.                     count++;
  459.                 return count;
  460.             }
  461.         }
  463.         public IDockContent[] DocumentsToArray()
  464.         {
  465.             int count = DocumentsCount;
  466.             IDockContent[] documents = new IDockContent[count];
  467.             int i = 0;
  468.             foreach (IDockContent content in Documents)
  469.             {
  470.                 documents[i] = content;
  471.                 i++;
  472.             }
  474.             return documents;
  475.         }
  477. public IEnumerable<IDockContent> Documents
  478. {
  479.             get
  480.             {
  481.                 foreach (IDockContent content in Contents)
  482.                 {
  483.                     if (content.DockHandler.DockState == DockState.Document)
  484.                         yield return content;
  485.                 }
  486.             }
  487. }
  489. private Rectangle DocumentRectangle
  490. {
  491. get
  492. {
  493. Rectangle rect = DockArea;
  494. if (DockWindows[DockState.DockLeft].VisibleNestedPanes.Count != 0)
  495. {
  496. rect.X += (int)(DockArea.Width * DockLeftPortion);
  497. rect.Width -= (int)(DockArea.Width * DockLeftPortion);
  498. }
  499. if (DockWindows[DockState.DockRight].VisibleNestedPanes.Count != 0)
  500. rect.Width -= (int)(DockArea.Width * DockRightPortion);
  501. if (DockWindows[DockState.DockTop].VisibleNestedPanes.Count != 0)
  502. {
  503. rect.Y += (int)(DockArea.Height * DockTopPortion);
  504. rect.Height -= (int)(DockArea.Height * DockTopPortion);
  505. }
  506. if (DockWindows[DockState.DockBottom].VisibleNestedPanes.Count != 0)
  507. rect.Height -= (int)(DockArea.Height * DockBottomPortion);
  509. return rect;
  510. }
  511. }
  513. private Control DummyControl
  514. {
  515. get { return m_dummyControl; }
  516. }
  518. [Browsable(false)]
  519. public FloatWindowCollection FloatWindows
  520. {
  521. get { return m_floatWindows; }
  522. }
  524.         private Size m_defaultFloatWindowSize = new Size(300, 300);
  525.         [Category("Layout")]
  526.         [LocalizedDescription("DockPanel_DefaultFloatWindowSize_Description")]
  527.         public Size DefaultFloatWindowSize
  528.         {
  529.             get { return m_defaultFloatWindowSize; }
  530.             set { m_defaultFloatWindowSize = value; }
  531.         }
  532.         private bool ShouldSerializeDefaultFloatWindowSize()
  533.         {
  534.             return DefaultFloatWindowSize != new Size(300, 300);
  535.         }
  537. private DocumentStyle m_documentStyle = DocumentStyle.DockingMdi;
  538. [LocalizedCategory("Category_Docking")]
  539. [LocalizedDescription("DockPanel_DocumentStyle_Description")]
  540. [DefaultValue(DocumentStyle.DockingMdi)]
  541. public DocumentStyle DocumentStyle
  542. {
  543. get { return m_documentStyle; }
  544. set
  545. {
  546. if (value == m_documentStyle)
  547. return;
  549. if (!Enum.IsDefined(typeof(DocumentStyle), value))
  550. throw new InvalidEnumArgumentException();
  552. if (value == DocumentStyle.SystemMdi && DockWindows[DockState.Document].VisibleNestedPanes.Count > 0)
  553. throw new InvalidEnumArgumentException();
  555. m_documentStyle = value;
  557. SuspendLayout(true);
  559.                 SetAutoHideWindowParent();
  560. SetMdiClient();
  561. InvalidateWindowRegion();
  563. foreach (IDockContent content in Contents)
  564. {
  565. if (content.DockHandler.DockState == DockState.Document)
  566. content.DockHandler.SetPaneAndVisible(content.DockHandler.Pane);
  567. }
  569.                 PerformMdiClientLayout();
  571. ResumeLayout(true, true);
  572. }
  573. }
  575.         private int GetDockWindowSize(DockState dockState)
  576.         {
  577.             if (dockState == DockState.DockLeft || dockState == DockState.DockRight)
  578.             {
  579.                 int width = ClientRectangle.Width - DockPadding.Left - DockPadding.Right;
  580.                 int dockLeftSize = m_dockLeftPortion >= 1 ? (int)m_dockLeftPortion : (int)(width * m_dockLeftPortion);
  581.                 int dockRightSize = m_dockRightPortion >= 1 ? (int)m_dockRightPortion : (int)(width * m_dockRightPortion);
  583.                 if (dockLeftSize < MeasurePane.MinSize)
  584.                     dockLeftSize = MeasurePane.MinSize;
  585.                 if (dockRightSize < MeasurePane.MinSize)
  586.                     dockRightSize = MeasurePane.MinSize;
  588.                 if (dockLeftSize + dockRightSize > width - MeasurePane.MinSize)
  589.                 {
  590.                     int adjust = (dockLeftSize + dockRightSize) - (width - MeasurePane.MinSize);
  591.                     dockLeftSize -= adjust / 2;
  592.                     dockRightSize -= adjust / 2;
  593.                 }
  595.                 return dockState == DockState.DockLeft ? dockLeftSize : dockRightSize;
  596.             }
  597.             else if (dockState == DockState.DockTop || dockState == DockState.DockBottom)
  598.             {
  599.                 int height = ClientRectangle.Height - DockPadding.Top - DockPadding.Bottom;
  600.                 int dockTopSize = m_dockTopPortion >= 1 ? (int)m_dockTopPortion : (int)(height * m_dockTopPortion);
  601.                 int dockBottomSize = m_dockBottomPortion >= 1 ? (int)m_dockBottomPortion : (int)(height * m_dockBottomPortion);
  603.                 if (dockTopSize < MeasurePane.MinSize)
  604.                     dockTopSize = MeasurePane.MinSize;
  605.                 if (dockBottomSize < MeasurePane.MinSize)
  606.                     dockBottomSize = MeasurePane.MinSize;
  608.                 if (dockTopSize + dockBottomSize > height - MeasurePane.MinSize)
  609.                 {
  610.                     int adjust = (dockTopSize + dockBottomSize) - (height - MeasurePane.MinSize);
  611.                     dockTopSize -= adjust / 2;
  612.                     dockBottomSize -= adjust / 2;
  613.                 }
  615.                 return dockState == DockState.DockTop ? dockTopSize : dockBottomSize;
  616.             }
  617.             else
  618.                 return 0;
  619.         }
  621.         protected override void OnLayout(LayoutEventArgs levent)
  622. {
  623. SuspendLayout(true);
  625. AutoHideStripControl.Bounds = ClientRectangle;
  627. CalculateDockPadding();
  629.             DockWindows[DockState.DockLeft].Width = GetDockWindowSize(DockState.DockLeft);
  630. DockWindows[DockState.DockRight].Width = GetDockWindowSize(DockState.DockRight);
  631. DockWindows[DockState.DockTop].Height = GetDockWindowSize(DockState.DockTop);
  632. DockWindows[DockState.DockBottom].Height = GetDockWindowSize(DockState.DockBottom);
  634. AutoHideWindow.Bounds = GetAutoHideWindowBounds(AutoHideWindowRectangle);
  636. DockWindows[DockState.Document].BringToFront();
  637. AutoHideWindow.BringToFront();
  639. base.OnLayout(levent);
  641.             if (DocumentStyle == DocumentStyle.SystemMdi && MdiClientExists)
  642.             {
  643.                 SetMdiClientBounds(SystemMdiClientBounds);
  644.                 InvalidateWindowRegion();
  645.             }
  646.             else if (DocumentStyle == DocumentStyle.DockingMdi)
  647.                 InvalidateWindowRegion();
  649. ResumeLayout(true, true);
  650. }
  652. internal Rectangle GetTabStripRectangle(DockState dockState)
  653. {
  654. return AutoHideStripControl.GetTabStripRectangle(dockState);
  655. }
  657. protected override void OnPaint(PaintEventArgs e)
  658. {
  659. base.OnPaint(e);
  661.     if (DockBackColor == BackColor) return;
  663.     Graphics g = e.Graphics;
  664.     SolidBrush bgBrush = new SolidBrush(DockBackColor);
  665.     g.FillRectangle(bgBrush, ClientRectangle);
  666. }
  668. internal void AddContent(IDockContent content)
  669. {
  670. if (content == null)
  671. throw(new ArgumentNullException());
  673. if (!Contents.Contains(content))
  674. {
  675. Contents.Add(content);
  676. OnContentAdded(new DockContentEventArgs(content));
  677. }
  678. }
  680. internal void AddPane(DockPane pane)
  681. {
  682. if (Panes.Contains(pane))
  683. return;
  685. Panes.Add(pane);
  686. }
  688. internal void AddFloatWindow(FloatWindow floatWindow)
  689. {
  690. if (FloatWindows.Contains(floatWindow))
  691. return;
  693. FloatWindows.Add(floatWindow);
  694. }
  696. private void CalculateDockPadding()
  697. {
  698. DockPadding.All = 0;
  700. int height = AutoHideStripControl.MeasureHeight();
  702. if (AutoHideStripControl.GetNumberOfPanes(DockState.DockLeftAutoHide) > 0)
  703. DockPadding.Left = height;
  704. if (AutoHideStripControl.GetNumberOfPanes(DockState.DockRightAutoHide) > 0)
  705. DockPadding.Right = height;
  706. if (AutoHideStripControl.GetNumberOfPanes(DockState.DockTopAutoHide) > 0)
  707. DockPadding.Top = height;
  708. if (AutoHideStripControl.GetNumberOfPanes(DockState.DockBottomAutoHide) > 0)
  709. DockPadding.Bottom = height;
  710. }
  712. internal void RemoveContent(IDockContent content)
  713. {
  714. if (content == null)
  715. throw(new ArgumentNullException());
  717. if (Contents.Contains(content))
  718. {
  719. Contents.Remove(content);
  720. OnContentRemoved(new DockContentEventArgs(content));
  721. }
  722. }
  724. internal void RemovePane(DockPane pane)
  725. {
  726. if (!Panes.Contains(pane))
  727. return;
  729. Panes.Remove(pane);
  730. }
  732. internal void RemoveFloatWindow(FloatWindow floatWindow)
  733. {
  734. if (!FloatWindows.Contains(floatWindow))
  735. return;
  737. FloatWindows.Remove(floatWindow);
  738. }
  740. public void SetPaneIndex(DockPane pane, int index)
  741. {
  742. int oldIndex = Panes.IndexOf(pane);
  743. if (oldIndex == -1)
  744. throw(new ArgumentException(Strings.DockPanel_SetPaneIndex_InvalidPane));
  746. if (index < 0 || index > Panes.Count - 1)
  747. if (index != -1)
  748. throw(new ArgumentOutOfRangeException(Strings.DockPanel_SetPaneIndex_InvalidIndex));
  750. if (oldIndex == index)
  751. return;
  752. if (oldIndex == Panes.Count - 1 && index == -1)
  753. return;
  755. Panes.Remove(pane);
  756. if (index == -1)
  757. Panes.Add(pane);
  758. else if (oldIndex < index)
  759. Panes.AddAt(pane, index - 1);
  760. else
  761. Panes.AddAt(pane, index);
  762. }
  764. public void SuspendLayout(bool allWindows)
  765. {
  766.             FocusManager.SuspendFocusTracking();
  767. SuspendLayout();
  768. if (allWindows)
  769. SuspendMdiClientLayout();
  770. }
  772. public void ResumeLayout(bool performLayout, bool allWindows)
  773. {
  774.             FocusManager.ResumeFocusTracking();
  775.             ResumeLayout(performLayout);
  776.             if (allWindows)
  777.                 ResumeMdiClientLayout(performLayout);
  778. }
  780.     internal Form ParentForm
  781. {
  782. get
  783. {
  784. if (!IsParentFormValid())
  785. throw new InvalidOperationException(Strings.DockPanel_ParentForm_Invalid);
  787. return GetMdiClientController().ParentForm;
  788. }
  789. }
  791. private bool IsParentFormValid()
  792. {
  793. if (DocumentStyle == DocumentStyle.DockingSdi || DocumentStyle == DocumentStyle.DockingWindow)
  794. return true;
  796.             if (!MdiClientExists)
  797.                 GetMdiClientController().RenewMdiClient();
  799.             return (MdiClientExists);
  800. }
  802. protected override void OnParentChanged(EventArgs e)
  803. {
  804.             SetAutoHideWindowParent();
  805.             GetMdiClientController().ParentForm = (this.Parent as Form);
  806. base.OnParentChanged (e);
  807. }
  809.         private void SetAutoHideWindowParent()
  810.         {
  811.             Control parent;
  812.             if (DocumentStyle == DocumentStyle.DockingMdi ||
  813.                 DocumentStyle == DocumentStyle.SystemMdi)
  814.                 parent = this.Parent;
  815.             else
  816.                 parent = this;
  817.             if (AutoHideWindow.Parent != parent)
  818.             {
  819.                 AutoHideWindow.Parent = parent;
  820.                 AutoHideWindow.BringToFront();
  821.             }
  822.         }
  824. protected override void OnVisibleChanged(EventArgs e)
  825. {
  826. base.OnVisibleChanged (e);
  828. if (Visible)
  829. SetMdiClient();
  830. }
  832. private Rectangle SystemMdiClientBounds
  833. {
  834. get
  835. {
  836. if (!IsParentFormValid() || !Visible)
  837. return Rectangle.Empty;
  839. Rectangle rect = ParentForm.RectangleToClient(RectangleToScreen(DocumentWindowBounds));
  840. return rect;
  841. }
  842. }
  844. internal Rectangle DocumentWindowBounds
  845. {
  846. get
  847. {
  848. Rectangle rectDocumentBounds = DisplayRectangle;
  849. if (DockWindows[DockState.DockLeft].Visible)
  850. {
  851. rectDocumentBounds.X += DockWindows[DockState.DockLeft].Width;
  852. rectDocumentBounds.Width -= DockWindows[DockState.DockLeft].Width;
  853. }
  854. if (DockWindows[DockState.DockRight].Visible)
  855. rectDocumentBounds.Width -= DockWindows[DockState.DockRight].Width;
  856. if (DockWindows[DockState.DockTop].Visible)
  857. {
  858. rectDocumentBounds.Y += DockWindows[DockState.DockTop].Height;
  859. rectDocumentBounds.Height -= DockWindows[DockState.DockTop].Height;
  860. }
  861. if (DockWindows[DockState.DockBottom].Visible)
  862. rectDocumentBounds.Height -= DockWindows[DockState.DockBottom].Height;
  864. return rectDocumentBounds;
  866. }
  867. }
  869.         private PaintEventHandler m_dummyControlPaintEventHandler = null;
  870.         private void InvalidateWindowRegion()
  871.         {
  872.             if (DesignMode)
  873.                 return;
  875.             if (m_dummyControlPaintEventHandler == null)
  876.                 m_dummyControlPaintEventHandler = new PaintEventHandler(DummyControl_Paint);
  878.             DummyControl.Paint += m_dummyControlPaintEventHandler;
  879.             DummyControl.Invalidate();
  880.         }
  882.         void DummyControl_Paint(object sender, PaintEventArgs e)
  883.         {
  884.             DummyControl.Paint -= m_dummyControlPaintEventHandler;
  885.             UpdateWindowRegion();
  886.         }
  888. private void UpdateWindowRegion()
  889. {
  890. if (this.DocumentStyle == DocumentStyle.DockingMdi)
  891. UpdateWindowRegion_ClipContent();
  892. else if (this.DocumentStyle == DocumentStyle.DockingSdi ||
  893. this.DocumentStyle == DocumentStyle.DockingWindow)
  894. UpdateWindowRegion_FullDocumentArea();
  895. else if (this.DocumentStyle == DocumentStyle.SystemMdi)
  896. UpdateWindowRegion_EmptyDocumentArea();
  897. }
  899. private void UpdateWindowRegion_FullDocumentArea()
  900. {
  901. SetRegion(null);
  902. }
  904. private void UpdateWindowRegion_EmptyDocumentArea()
  905. {
  906. Rectangle rect = DocumentWindowBounds;
  907. SetRegion(new Rectangle[] { rect });
  908. }
  910. private void UpdateWindowRegion_ClipContent()
  911. {
  912. int count = 0;
  913. foreach (DockPane pane in this.Panes)
  914. {
  915. if (!pane.Visible || pane.DockState != DockState.Document)
  916. continue;
  918. count ++;
  919. }
  921.             if (count == 0)
  922.             {
  923.                 SetRegion(null);
  924.                 return;
  925.             }
  927. Rectangle[] rects = new Rectangle[count];
  928. int i = 0;
  929. foreach (DockPane pane in this.Panes)
  930. {
  931. if (!pane.Visible || pane.DockState != DockState.Document)
  932. continue;
  934.                 rects[i] = RectangleToClient(pane.RectangleToScreen(pane.ContentRectangle));
  935. i++;
  936. }
  938. SetRegion(rects);
  939. }
  941. private Rectangle[] m_clipRects = null;
  942. private void SetRegion(Rectangle[] clipRects)
  943. {
  944. if (!IsClipRectsChanged(clipRects))
  945. return;
  947. m_clipRects = clipRects;
  949. if (m_clipRects == null || m_clipRects.GetLength(0) == 0)
  950. Region = null;
  951. else
  952. {
  953. Region region = new Region(new Rectangle(0, 0, this.Width, this.Height));
  954. foreach (Rectangle rect in m_clipRects)
  955. region.Exclude(rect);
  956. Region = region;
  957. }
  958. }
  960. private bool IsClipRectsChanged(Rectangle[] clipRects)
  961. {
  962. if (clipRects == null && m_clipRects == null)
  963. return false;
  964. else if ((clipRects == null) != (m_clipRects == null))
  965. return true;
  967. foreach (Rectangle rect in clipRects)
  968. {
  969. bool matched = false;
  970. foreach (Rectangle rect2 in m_clipRects)
  971. {
  972. if (rect == rect2)
  973. {
  974. matched = true;
  975. break;
  976. }
  977. }
  978. if (!matched)
  979. return true;
  980. }
  982. foreach (Rectangle rect2 in m_clipRects)
  983. {
  984. bool matched = false;
  985. foreach (Rectangle rect in clipRects)
  986. {
  987. if (rect == rect2)
  988. {
  989. matched = true;
  990. break;
  991. }
  992. }
  993. if (!matched)
  994. return true;
  995. }
  996. return false;
  997. }
  999. private static readonly object ContentAddedEvent = new object();
  1000. [LocalizedCategory("Category_DockingNotification")]
  1001. [LocalizedDescription("DockPanel_ContentAdded_Description")]
  1002. public event EventHandler<DockContentEventArgs> ContentAdded
  1003. {
  1004. add { Events.AddHandler(ContentAddedEvent, value); }
  1005. remove { Events.RemoveHandler(ContentAddedEvent, value); }
  1006. }
  1007. protected virtual void OnContentAdded(DockContentEventArgs e)
  1008. {
  1009. EventHandler<DockContentEventArgs> handler = (EventHandler<DockContentEventArgs>)Events[ContentAddedEvent];
  1010. if (handler != null)
  1011. handler(this, e);
  1012. }
  1014. private static readonly object ContentRemovedEvent = new object();
  1015. [LocalizedCategory("Category_DockingNotification")]
  1016. [LocalizedDescription("DockPanel_ContentRemoved_Description")]
  1017. public event EventHandler<DockContentEventArgs> ContentRemoved
  1018. {
  1019. add { Events.AddHandler(ContentRemovedEvent, value); }
  1020. remove { Events.RemoveHandler(ContentRemovedEvent, value); }
  1021. }
  1022. protected virtual void OnContentRemoved(DockContentEventArgs e)
  1023. {
  1024. EventHandler<DockContentEventArgs> handler = (EventHandler<DockContentEventArgs>)Events[ContentRemovedEvent];
  1025. if (handler != null)
  1026. handler(this, e);
  1027. }
  1028.     }
  1029. }