Changeset 9183

Timestamp:

01/23/13 14:05:09 (11 years ago)

Author:

ascheibe

Message:

#2005 reverted changes of r9174 as the trunk now contains the correct memory leak fixes (#2006)

Location:

branches/UnloadJobs

Files:

• HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPane.cs (modified) (1 diff)
• HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.cs (modified) (3 diffs)
• HeuristicLab.MainForm.WindowsForms/3.3/Controls/ViewHost.Designer.cs (modified) (1 diff)
• HeuristicLab.MainForm.WindowsForms/3.3/Controls/ViewHost.cs (modified) (1 diff)
• HeuristicLab.MainForm.WindowsForms/3.3/MainForms/DockForm.cs (modified) (1 diff)
• HeuristicLab.MainForm.WindowsForms/3.3/MainForms/MainForm.cs (modified) (1 diff)
• HeuristicLab.Operators.Views.GraphVisualization.Views/3.3/GraphVisualizationInfoView.Designer.cs (modified) (1 diff)
• HeuristicLab.Operators.Views.GraphVisualization.Views/3.3/GraphVisualizationInfoView.cs (modified) (1 diff)
• HeuristicLab.Operators.Views.GraphVisualization.Views/3.3/OperatorGraphView.Designer.cs (modified) (1 diff)
• HeuristicLab.Operators.Views.GraphVisualization.Views/3.3/OperatorGraphView.cs (modified) (1 diff)

branches/UnloadJobs/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPane.cs

@@ -1 +1 @@
 using System;
 using System.ComponentModel;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+using System.Security.Permissions;
 using System.Diagnostics.CodeAnalysis;
-using System.Drawing;
-using System.Security.Permissions;
-using System.Windows.Forms;
-
-namespace WeifenLuo.WinFormsUI.Docking {
-  [ToolboxItem(false)]
-  public partial class DockPane : UserControl, IDockDragSource {
-    public enum AppearanceStyle {
-      ToolWindow,
-      Document
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    [ToolboxItem(false)]
+    public partial class DockPane : UserControl, IDockDragSource
+    {
+        public enum AppearanceStyle
+        {
+            ToolWindow,
+            Document
+        }
+
+        private enum HitTestArea
+        {
+            Caption,
+            TabStrip,
+            Content,
+            None
+        }
+
+        private struct HitTestResult
+        {
+            public HitTestArea HitArea;
+            public int Index;
+
+            public HitTestResult(HitTestArea hitTestArea, int index)
+            {
+                HitArea = hitTestArea;
+                Index = index;
+            }
+        }
+
+        private DockPaneCaptionBase m_captionControl;
+        private DockPaneCaptionBase CaptionControl
+        {
+            get { return m_captionControl; }
+        }
+
+        private DockPaneStripBase m_tabStripControl;
+        internal DockPaneStripBase TabStripControl
+        {
+            get { return m_tabStripControl; }
+        }
+
+        internal protected DockPane(IDockContent content, DockState visibleState, bool show)
+        {
+            InternalConstruct(content, visibleState, false, Rectangle.Empty, null, DockAlignment.Right, 0.5, show);
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters", MessageId = "1#")]
+        internal protected DockPane(IDockContent content, FloatWindow floatWindow, bool show)
+        {
+            if (floatWindow == null)
+                throw new ArgumentNullException("floatWindow");
+
+            InternalConstruct(content, DockState.Float, false, Rectangle.Empty, floatWindow.NestedPanes.GetDefaultPreviousPane(this), DockAlignment.Right, 0.5, show);
+        }
+
+        internal protected DockPane(IDockContent content, DockPane previousPane, DockAlignment alignment, double proportion, bool show)
+        {
+            if (previousPane == null)
+                throw (new ArgumentNullException("previousPane"));
+            InternalConstruct(content, previousPane.DockState, false, Rectangle.Empty, previousPane, alignment, proportion, show);
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters", MessageId = "1#")]
+        internal protected DockPane(IDockContent content, Rectangle floatWindowBounds, bool show)
+        {
+            InternalConstruct(content, DockState.Float, true, floatWindowBounds, null, DockAlignment.Right, 0.5, show);
+        }
+
+        private void InternalConstruct(IDockContent content, DockState dockState, bool flagBounds, Rectangle floatWindowBounds, DockPane prevPane, DockAlignment alignment, double proportion, bool show)
+        {
+            if (dockState == DockState.Hidden || dockState == DockState.Unknown)
+                throw new ArgumentException(Strings.DockPane_SetDockState_InvalidState);
+
+            if (content == null)
+                throw new ArgumentNullException(Strings.DockPane_Constructor_NullContent);
+
+            if (content.DockHandler.DockPanel == null)
+                throw new ArgumentException(Strings.DockPane_Constructor_NullDockPanel);
+
+
+            SuspendLayout();
+            SetStyle(ControlStyles.Selectable, false);
+
+            m_isFloat = (dockState == DockState.Float);
+
+            m_contents = new DockContentCollection();
+            m_displayingContents = new DockContentCollection(this);
+            m_dockPanel = content.DockHandler.DockPanel;
+            m_dockPanel.AddPane(this);
+
+            m_splitter = new SplitterControl(this);
+
+            m_nestedDockingStatus = new NestedDockingStatus(this);
+
+            m_captionControl = DockPanel.DockPaneCaptionFactory.CreateDockPaneCaption(this);
+            m_tabStripControl = DockPanel.DockPaneStripFactory.CreateDockPaneStrip(this);
+            Controls.AddRange(new Control[] { m_captionControl, m_tabStripControl });
+
+            DockPanel.SuspendLayout(true);
+            if (flagBounds)
+                FloatWindow = DockPanel.FloatWindowFactory.CreateFloatWindow(DockPanel, this, floatWindowBounds);
+            else if (prevPane != null)
+                DockTo(prevPane.NestedPanesContainer, prevPane, alignment, proportion);
+
+            SetDockState(dockState);
+            if (show)
+                content.DockHandler.Pane = this;
+            else if (this.IsFloat)
+                content.DockHandler.FloatPane = this;
+            else
+                content.DockHandler.PanelPane = this;
+
+            ResumeLayout();
+            DockPanel.ResumeLayout(true, true);
+        }
+
+        private bool m_isDisposing;
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                // IMPORTANT: avoid nested call into this method on Mono. 
+                // https://github.com/dockpanelsuite/dockpanelsuite/issues/16
+                if (Win32Helper.IsRunningOnMono)
+                {
+                    if (m_isDisposing)
+                        return;
+
+                    m_isDisposing = true;
+                }
+
+                m_dockState = DockState.Unknown;
+
+                if (NestedPanesContainer != null)
+                    NestedPanesContainer.NestedPanes.Remove(this);
+
+                if (DockPanel != null)
+                {
+                    DockPanel.RemovePane(this);
+                    m_dockPanel = null;
+                }
+
+                Splitter.Dispose();
+                if (m_autoHidePane != null)
+                    m_autoHidePane.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        private IDockContent m_activeContent = null;
+        public virtual IDockContent ActiveContent
+        {
+            get { return m_activeContent; }
+            set
+            {
+                if (ActiveContent == value)
+                    return;
+
+                if (value != null)
+                {
+                    if (!DisplayingContents.Contains(value))
+                        throw (new InvalidOperationException(Strings.DockPane_ActiveContent_InvalidValue));
+                }
+                else
+                {
+                    if (DisplayingContents.Count != 0)
+                        throw (new InvalidOperationException(Strings.DockPane_ActiveContent_InvalidValue));
+                }
+
+                IDockContent oldValue = m_activeContent;
+
+                if (DockPanel.ActiveAutoHideContent == oldValue)
+                    DockPanel.ActiveAutoHideContent = null;
+
+                m_activeContent = value;
+
+                if (DockPanel.DocumentStyle == DocumentStyle.DockingMdi && DockState == DockState.Document)
+                {
+                    if (m_activeContent != null)
+                        m_activeContent.DockHandler.Form.BringToFront();
+                }
+                else
+                {
+                    if (m_activeContent != null)
+                        m_activeContent.DockHandler.SetVisible();
+                    if (oldValue != null && DisplayingContents.Contains(oldValue))
+                        oldValue.DockHandler.SetVisible();
+                    if (IsActivated && m_activeContent != null)
+                        m_activeContent.DockHandler.Activate();
+                }
+
+                if (FloatWindow != null)
+                    FloatWindow.SetText();
+
+                if (DockPanel.DocumentStyle == DocumentStyle.DockingMdi &&
+                    DockState == DockState.Document)
+                    RefreshChanges(false);  // delayed layout to reduce screen flicker
+                else
+                    RefreshChanges();
+
+                if (m_activeContent != null)
+                    TabStripControl.EnsureTabVisible(m_activeContent);
+            }
+        }
+
+        private bool m_allowDockDragAndDrop = true;
+        public virtual bool AllowDockDragAndDrop
+        {
+            get { return m_allowDockDragAndDrop; }
+            set { m_allowDockDragAndDrop = value; }
+        }
+
+        private IDisposable m_autoHidePane = null;
+        internal IDisposable AutoHidePane
+        {
+            get { return m_autoHidePane; }
+            set { m_autoHidePane = value; }
+        }
+
+        private object m_autoHideTabs = null;
+        internal object AutoHideTabs
+        {
+            get { return m_autoHideTabs; }
+            set { m_autoHideTabs = value; }
+        }
+
+        private object TabPageContextMenu
+        {
+            get
+            {
+                IDockContent content = ActiveContent;
+
+                if (content == null)
+                    return null;
+
+                if (content.DockHandler.TabPageContextMenuStrip != null)
+                    return content.DockHandler.TabPageContextMenuStrip;
+                else if (content.DockHandler.TabPageContextMenu != null)
+                    return content.DockHandler.TabPageContextMenu;
+                else
+                    return null;
+            }
+        }
+
+        internal bool HasTabPageContextMenu
+        {
+            get { return TabPageContextMenu != null; }
+        }
+
+        internal void ShowTabPageContextMenu(Control control, Point position)
+        {
+            object menu = TabPageContextMenu;
+
+            if (menu == null)
+                return;
+
+            ContextMenuStrip contextMenuStrip = menu as ContextMenuStrip;
+            if (contextMenuStrip != null)
+            {
+                contextMenuStrip.Show(control, position);
+                return;
+            }
+
+            ContextMenu contextMenu = menu as ContextMenu;
+            if (contextMenu != null)
+                contextMenu.Show(this, position);
+        }
+
+        private Rectangle CaptionRectangle
+        {
+            get
+            {
+                if (!HasCaption)
+                    return Rectangle.Empty;
+
+                Rectangle rectWindow = DisplayingRectangle;
+                int x, y, width;
+                x = rectWindow.X;
+                y = rectWindow.Y;
+                width = rectWindow.Width;
+                int height = CaptionControl.MeasureHeight();
+
+                return new Rectangle(x, y, width, height);
+            }
+        }
+
+        internal Rectangle ContentRectangle
+        {
+            get
+            {
+                Rectangle rectWindow = DisplayingRectangle;
+                Rectangle rectCaption = CaptionRectangle;
+                Rectangle rectTabStrip = TabStripRectangle;
+
+                int x = rectWindow.X;
+
+                int y = rectWindow.Y + (rectCaption.IsEmpty ? 0 : rectCaption.Height);
+                if (DockState == DockState.Document && DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Top)
+                    y += rectTabStrip.Height;
+
+                int width = rectWindow.Width;
+                int height = rectWindow.Height - rectCaption.Height - rectTabStrip.Height;
+
+                return new Rectangle(x, y, width, height);
+            }
+        }
+
+        internal Rectangle TabStripRectangle
+        {
+            get
+            {
+                if (Appearance == AppearanceStyle.ToolWindow)
+                    return TabStripRectangle_ToolWindow;
+                else
+                    return TabStripRectangle_Document;
+            }
+        }
+
+        private Rectangle TabStripRectangle_ToolWindow
+        {
+            get
+            {
+                if (DisplayingContents.Count <= 1 || IsAutoHide)
+                    return Rectangle.Empty;
+
+                Rectangle rectWindow = DisplayingRectangle;
+
+                int width = rectWindow.Width;
+                int height = TabStripControl.MeasureHeight();
+                int x = rectWindow.X;
+                int y = rectWindow.Bottom - height;
+                Rectangle rectCaption = CaptionRectangle;
+                if (rectCaption.Contains(x, y))
+                    y = rectCaption.Y + rectCaption.Height;
+
+                return new Rectangle(x, y, width, height);
+            }
+        }
+
+        private Rectangle TabStripRectangle_Document
+        {
+            get
+            {
+                if (DisplayingContents.Count == 0)
+                    return Rectangle.Empty;
+
+                if (DisplayingContents.Count == 1 && DockPanel.DocumentStyle == DocumentStyle.DockingSdi)
+                    return Rectangle.Empty;
+
+                Rectangle rectWindow = DisplayingRectangle;
+                int x = rectWindow.X;
+                int width = rectWindow.Width;
+                int height = TabStripControl.MeasureHeight();
+
+                int y = 0;
+                if (DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+                    y = rectWindow.Height - height;
+                else
+                    y = rectWindow.Y;
+
+                return new Rectangle(x, y, width, height);
+            }
+        }
+
+        public virtual string CaptionText
+        {
+            get { return ActiveContent == null ? string.Empty : ActiveContent.DockHandler.TabText; }
+        }
+
+        private DockContentCollection m_contents;
+        public DockContentCollection Contents
+        {
+            get { return m_contents; }
+        }
+
+        private DockContentCollection m_displayingContents;
+        public DockContentCollection DisplayingContents
+        {
+            get { return m_displayingContents; }
+        }
+
+        private DockPanel m_dockPanel;
+        public DockPanel DockPanel
+        {
+            get { return m_dockPanel; }
+        }
+
+        private bool HasCaption
+        {
+            get
+            {
+                if (DockState == DockState.Document ||
+                    DockState == DockState.Hidden ||
+                    DockState == DockState.Unknown ||
+                    (DockState == DockState.Float && FloatWindow.VisibleNestedPanes.Count <= 1))
+                    return false;
+                else
+                    return true;
+            }
+        }
+
+        private bool m_isActivated = false;
+        public bool IsActivated
+        {
+            get { return m_isActivated; }
+        }
+        internal void SetIsActivated(bool value)
+        {
+            if (m_isActivated == value)
+                return;
+
+            m_isActivated = value;
+            if (DockState != DockState.Document)
+                RefreshChanges(false);
+            OnIsActivatedChanged(EventArgs.Empty);
+        }
+
+        private bool m_isActiveDocumentPane = false;
+        public bool IsActiveDocumentPane
+        {
+            get { return m_isActiveDocumentPane; }
+        }
+        internal void SetIsActiveDocumentPane(bool value)
+        {
+            if (m_isActiveDocumentPane == value)
+                return;
+
+            m_isActiveDocumentPane = value;
+            if (DockState == DockState.Document)
+                RefreshChanges();
+            OnIsActiveDocumentPaneChanged(EventArgs.Empty);
+        }
+
+        public bool IsDockStateValid(DockState dockState)
+        {
+            foreach (IDockContent content in Contents)
+                if (!content.DockHandler.IsDockStateValid(dockState))
+                    return false;
+
+            return true;
+        }
+
+        public bool IsAutoHide
+        {
+            get { return DockHelper.IsDockStateAutoHide(DockState); }
+        }
+
+        public AppearanceStyle Appearance
+        {
+            get { return (DockState == DockState.Document) ? AppearanceStyle.Document : AppearanceStyle.ToolWindow; }
+        }
+
+        internal Rectangle DisplayingRectangle
+        {
+            get { return ClientRectangle; }
+        }
+
+        public void Activate()
+        {
+            if (DockHelper.IsDockStateAutoHide(DockState) && DockPanel.ActiveAutoHideContent != ActiveContent)
+                DockPanel.ActiveAutoHideContent = ActiveContent;
+            else if (!IsActivated && ActiveContent != null)
+                ActiveContent.DockHandler.Activate();
+        }
+
+        internal void AddContent(IDockContent content)
+        {
+            if (Contents.Contains(content))
+                return;
+
+            Contents.Add(content);
+        }
+
+        internal void Close()
+        {
+            Dispose();
+        }
+
+        public void CloseActiveContent()
+        {
+            CloseContent(ActiveContent);
+        }
+
+        internal void CloseContent(IDockContent content)
+        {
+            if (content == null)
+                return;
+
+            if (!content.DockHandler.CloseButton)
+                return;
+
+            DockPanel dockPanel = DockPanel;
+
+            dockPanel.SuspendLayout(true);
+
+            try
+            {
+                if (content.DockHandler.HideOnClose)
+                {
+                    content.DockHandler.Hide();
+                    NestedDockingStatus.NestedPanes.SwitchPaneWithFirstChild(this);
+                }
+                else
+                    content.DockHandler.Close();
+            }
+            finally
+            {
+                dockPanel.ResumeLayout(true, true);
+            }
+        }
+
+        private HitTestResult GetHitTest(Point ptMouse)
+        {
+            Point ptMouseClient = PointToClient(ptMouse);
+
+            Rectangle rectCaption = CaptionRectangle;
+            if (rectCaption.Contains(ptMouseClient))
+                return new HitTestResult(HitTestArea.Caption, -1);
+
+            Rectangle rectContent = ContentRectangle;
+            if (rectContent.Contains(ptMouseClient))
+                return new HitTestResult(HitTestArea.Content, -1);
+
+            Rectangle rectTabStrip = TabStripRectangle;
+            if (rectTabStrip.Contains(ptMouseClient))
+                return new HitTestResult(HitTestArea.TabStrip, TabStripControl.HitTest(TabStripControl.PointToClient(ptMouse)));
+
+            return new HitTestResult(HitTestArea.None, -1);
+        }
+
+        private bool m_isHidden = true;
+        public bool IsHidden
+        {
+            get { return m_isHidden; }
+        }
+        private void SetIsHidden(bool value)
+        {
+            if (m_isHidden == value)
+                return;
+
+            m_isHidden = value;
+            if (DockHelper.IsDockStateAutoHide(DockState))
+            {
+                DockPanel.RefreshAutoHideStrip();
+                DockPanel.PerformLayout();
+            }
+            else if (NestedPanesContainer != null)
+                ((Control)NestedPanesContainer).PerformLayout();
+        }
+
+        protected override void OnLayout(LayoutEventArgs levent)
+        {
+            SetIsHidden(DisplayingContents.Count == 0);
+            if (!IsHidden)
+            {
+                CaptionControl.Bounds = CaptionRectangle;
+                TabStripControl.Bounds = TabStripRectangle;
+
+                SetContentBounds();
+
+                foreach (IDockContent content in Contents)
+                {
+                    if (DisplayingContents.Contains(content))
+                        if (content.DockHandler.FlagClipWindow && content.DockHandler.Form.Visible)
+                            content.DockHandler.FlagClipWindow = false;
+                }
+            }
+
+            base.OnLayout(levent);
+        }
+
+        internal void SetContentBounds()
+        {
+            Rectangle rectContent = ContentRectangle;
+            if (DockState == DockState.Document && DockPanel.DocumentStyle == DocumentStyle.DockingMdi)
+                rectContent = DockPanel.RectangleToMdiClient(RectangleToScreen(rectContent));
+
+            Rectangle rectInactive = new Rectangle(-rectContent.Width, rectContent.Y, rectContent.Width, rectContent.Height);
+            foreach (IDockContent content in Contents)
+                if (content.DockHandler.Pane == this)
+                {
+                    if (content == ActiveContent)
+                        content.DockHandler.Form.Bounds = rectContent;
+                    else
+                        content.DockHandler.Form.Bounds = rectInactive;
+                }
+        }
+
+        internal void RefreshChanges()
+        {
+            RefreshChanges(true);
+        }
+
+        private void RefreshChanges(bool performLayout)
+        {
+            if (IsDisposed)
+                return;
+
+            CaptionControl.RefreshChanges();
+            TabStripControl.RefreshChanges();
+            if (DockState == DockState.Float && FloatWindow != null)
+                FloatWindow.RefreshChanges();
+            if (DockHelper.IsDockStateAutoHide(DockState) && DockPanel != null)
+            {
+                DockPanel.RefreshAutoHideStrip();
+                DockPanel.PerformLayout();
+            }
+
+            if (performLayout)
+                PerformLayout();
+        }
+
+        internal void RemoveContent(IDockContent content)
+        {
+            if (!Contents.Contains(content))
+                return;
+
+            Contents.Remove(content);
+        }
+
+        public void SetContentIndex(IDockContent content, int index)
+        {
+            int oldIndex = Contents.IndexOf(content);
+            if (oldIndex == -1)
+                throw (new ArgumentException(Strings.DockPane_SetContentIndex_InvalidContent));
+
+            if (index < 0 || index > Contents.Count - 1)
+                if (index != -1)
+                    throw (new ArgumentOutOfRangeException(Strings.DockPane_SetContentIndex_InvalidIndex));
+
+            if (oldIndex == index)
+                return;
+            if (oldIndex == Contents.Count - 1 && index == -1)
+                return;
+
+            Contents.Remove(content);
+            if (index == -1)
+                Contents.Add(content);
+            else if (oldIndex < index)
+                Contents.AddAt(content, index - 1);
+            else
+                Contents.AddAt(content, index);
+
+            RefreshChanges();
+        }
+
+        private void SetParent()
+        {
+            if (DockState == DockState.Unknown || DockState == DockState.Hidden)
+            {
+                SetParent(null);
+                Splitter.Parent = null;
+            }
+            else if (DockState == DockState.Float)
+            {
+                SetParent(FloatWindow);
+                Splitter.Parent = FloatWindow;
+            }
+            else if (DockHelper.IsDockStateAutoHide(DockState))
+            {
+                SetParent(DockPanel.AutoHideControl);
+                Splitter.Parent = null;
+            }
+            else
+            {
+                SetParent(DockPanel.DockWindows[DockState]);
+                Splitter.Parent = Parent;
+            }
+        }
+
+        private void SetParent(Control value)
+        {
+            if (Parent == value)
+                return;
+
+            //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+            // Workaround of .Net Framework bug:
+            // Change the parent of a control with focus may result in the first
+            // MDI child form get activated. 
+            //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+            IDockContent contentFocused = GetFocusedContent();
+            if (contentFocused != null)
+                DockPanel.SaveFocus();
+
+            //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+            Parent = value;
+
+            //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+            // Workaround of .Net Framework bug:
+            // Change the parent of a control with focus may result in the first
+            // MDI child form get activated. 
+            //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+            if (contentFocused != null)
+                contentFocused.DockHandler.Activate();
+            //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        }
+
+        public new void Show()
+        {
+            Activate();
+        }
+
+        internal void TestDrop(IDockDragSource dragSource, DockOutlineBase dockOutline)
+        {
+            if (!dragSource.CanDockTo(this))
+                return;
+
+            Point ptMouse = Control.MousePosition;
+
+            HitTestResult hitTestResult = GetHitTest(ptMouse);
+            if (hitTestResult.HitArea == HitTestArea.Caption)
+                dockOutline.Show(this, -1);
+            else if (hitTestResult.HitArea == HitTestArea.TabStrip && hitTestResult.Index != -1)
+                dockOutline.Show(this, hitTestResult.Index);
+        }
+
+        internal void ValidateActiveContent()
+        {
+            if (ActiveContent == null)
+            {
+                if (DisplayingContents.Count != 0)
+                    ActiveContent = DisplayingContents[0];
+                return;
+            }
+
+            if (DisplayingContents.IndexOf(ActiveContent) >= 0)
+                return;
+
+            IDockContent prevVisible = null;
+            for (int i = Contents.IndexOf(ActiveContent) - 1; i >= 0; i--)
+                if (Contents[i].DockHandler.DockState == DockState)
+                {
+                    prevVisible = Contents[i];
+                    break;
+                }
+
+            IDockContent nextVisible = null;
+            for (int i = Contents.IndexOf(ActiveContent) + 1; i < Contents.Count; i++)
+                if (Contents[i].DockHandler.DockState == DockState)
+                {
+                    nextVisible = Contents[i];
+                    break;
+                }
+
+            if (prevVisible != null)
+                ActiveContent = prevVisible;
+            else if (nextVisible != null)
+                ActiveContent = nextVisible;
+            else
+                ActiveContent = null;
+        }
+
+        private static readonly object DockStateChangedEvent = new object();
+        public event EventHandler DockStateChanged
+        {
+            add { Events.AddHandler(DockStateChangedEvent, value); }
+            remove { Events.RemoveHandler(DockStateChangedEvent, value); }
+        }
+        protected virtual void OnDockStateChanged(EventArgs e)
+        {
+            EventHandler handler = (EventHandler)Events[DockStateChangedEvent];
+            if (handler != null)
+                handler(this, e);
+        }
+
+        private static readonly object IsActivatedChangedEvent = new object();
+        public event EventHandler IsActivatedChanged
+        {
+            add { Events.AddHandler(IsActivatedChangedEvent, value); }
+            remove { Events.RemoveHandler(IsActivatedChangedEvent, value); }
+        }
+        protected virtual void OnIsActivatedChanged(EventArgs e)
+        {
+            EventHandler handler = (EventHandler)Events[IsActivatedChangedEvent];
+            if (handler != null)
+                handler(this, e);
+        }
+
+        private static readonly object IsActiveDocumentPaneChangedEvent = new object();
+        public event EventHandler IsActiveDocumentPaneChanged
+        {
+            add { Events.AddHandler(IsActiveDocumentPaneChangedEvent, value); }
+            remove { Events.RemoveHandler(IsActiveDocumentPaneChangedEvent, value); }
+        }
+        protected virtual void OnIsActiveDocumentPaneChanged(EventArgs e)
+        {
+            EventHandler handler = (EventHandler)Events[IsActiveDocumentPaneChangedEvent];
+            if (handler != null)
+                handler(this, e);
+        }
+
+        public DockWindow DockWindow
+        {
+            get { return (m_nestedDockingStatus.NestedPanes == null) ? null : m_nestedDockingStatus.NestedPanes.Container as DockWindow; }
+            set
+            {
+                DockWindow oldValue = DockWindow;
+                if (oldValue == value)
+                    return;
+
+                DockTo(value);
+            }
+        }
+
+        public FloatWindow FloatWindow
+        {
+            get { return (m_nestedDockingStatus.NestedPanes == null) ? null : m_nestedDockingStatus.NestedPanes.Container as FloatWindow; }
+            set
+            {
+                FloatWindow oldValue = FloatWindow;
+                if (oldValue == value)
+                    return;
+
+                DockTo(value);
+            }
+        }
+
+        private NestedDockingStatus m_nestedDockingStatus;
+        public NestedDockingStatus NestedDockingStatus
+        {
+            get { return m_nestedDockingStatus; }
+        }
+
+        private bool m_isFloat;
+        public bool IsFloat
+        {
+            get { return m_isFloat; }
+        }
+
+        public INestedPanesContainer NestedPanesContainer
+        {
+            get
+            {
+                if (NestedDockingStatus.NestedPanes == null)
+                    return null;
+                else
+                    return NestedDockingStatus.NestedPanes.Container;
+            }
+        }
+
+        private DockState m_dockState = DockState.Unknown;
+        public DockState DockState
+        {
+            get { return m_dockState; }
+            set
+            {
+                SetDockState(value);
+            }
+        }
+
+        public DockPane SetDockState(DockState value)
+        {
+            if (value == DockState.Unknown || value == DockState.Hidden)
+                throw new InvalidOperationException(Strings.DockPane_SetDockState_InvalidState);
+
+            if ((value == DockState.Float) == this.IsFloat)
+            {
+                InternalSetDockState(value);
+                return this;
+            }
+
+            if (DisplayingContents.Count == 0)
+                return null;
+
+            IDockContent firstContent = null;
+            for (int i = 0; i < DisplayingContents.Count; i++)
+            {
+                IDockContent content = DisplayingContents[i];
+                if (content.DockHandler.IsDockStateValid(value))
+                {
+                    firstContent = content;
+                    break;
+                }
+            }
+            if (firstContent == null)
+                return null;
+
+            firstContent.DockHandler.DockState = value;
+            DockPane pane = firstContent.DockHandler.Pane;
+            DockPanel.SuspendLayout(true);
+            for (int i = 0; i < DisplayingContents.Count; i++)
+            {
+                IDockContent content = DisplayingContents[i];
+                if (content.DockHandler.IsDockStateValid(value))
+                    content.DockHandler.Pane = pane;
+            }
+            DockPanel.ResumeLayout(true, true);
+            return pane;
+        }
+
+        private void InternalSetDockState(DockState value)
+        {
+            if (m_dockState == value)
+                return;
+
+            DockState oldDockState = m_dockState;
+            INestedPanesContainer oldContainer = NestedPanesContainer;
+
+            m_dockState = value;
+
+            SuspendRefreshStateChange();
+
+            IDockContent contentFocused = GetFocusedContent();
+            if (contentFocused != null)
+                DockPanel.SaveFocus();
+
+            if (!IsFloat)
+                DockWindow = DockPanel.DockWindows[DockState];
+            else if (FloatWindow == null)
+                FloatWindow = DockPanel.FloatWindowFactory.CreateFloatWindow(DockPanel, this);
+
+            if (contentFocused != null)
+                if (!Win32Helper.IsRunningOnMono)
+                DockPanel.ContentFocusManager.Activate(contentFocused);
+
+            ResumeRefreshStateChange(oldContainer, oldDockState);
+        }
+
+        private int m_countRefreshStateChange = 0;
+        private void SuspendRefreshStateChange()
+        {
+            m_countRefreshStateChange++;
+            DockPanel.SuspendLayout(true);
+        }
+
+        private void ResumeRefreshStateChange()
+        {
+            m_countRefreshStateChange--;
+            System.Diagnostics.Debug.Assert(m_countRefreshStateChange >= 0);
+            DockPanel.ResumeLayout(true, true);
+        }
+
+        private bool IsRefreshStateChangeSuspended
+        {
+            get { return m_countRefreshStateChange != 0; }
+        }
+
+        private void ResumeRefreshStateChange(INestedPanesContainer oldContainer, DockState oldDockState)
+        {
+            ResumeRefreshStateChange();
+            RefreshStateChange(oldContainer, oldDockState);
+        }
+
+        private void RefreshStateChange(INestedPanesContainer oldContainer, DockState oldDockState)
+        {
+            lock (this)
+            {
+                if (IsRefreshStateChangeSuspended)
+                    return;
+
+                SuspendRefreshStateChange();
+            }
+
+            DockPanel.SuspendLayout(true);
+
+            IDockContent contentFocused = GetFocusedContent();
+            if (contentFocused != null)
+                DockPanel.SaveFocus();
+            SetParent();
+
+            if (ActiveContent != null)
+                ActiveContent.DockHandler.SetDockState(ActiveContent.DockHandler.IsHidden, DockState, ActiveContent.DockHandler.Pane);
+            foreach (IDockContent content in Contents)
+            {
+                if (content.DockHandler.Pane == this)
+                    content.DockHandler.SetDockState(content.DockHandler.IsHidden, DockState, content.DockHandler.Pane);
+            }
+
+            if (oldContainer != null)
+            {
+                Control oldContainerControl = (Control)oldContainer;
+                if (oldContainer.DockState == oldDockState && !oldContainerControl.IsDisposed)
+                    oldContainerControl.PerformLayout();
+            }
+            if (DockHelper.IsDockStateAutoHide(oldDockState))
+                DockPanel.RefreshActiveAutoHideContent();
+
+            if (NestedPanesContainer.DockState == DockState)
+                ((Control)NestedPanesContainer).PerformLayout();
+            if (DockHelper.IsDockStateAutoHide(DockState))
+                DockPanel.RefreshActiveAutoHideContent();
+
+            if (DockHelper.IsDockStateAutoHide(oldDockState) ||
+                DockHelper.IsDockStateAutoHide(DockState))
+            {
+                DockPanel.RefreshAutoHideStrip();
+                DockPanel.PerformLayout();
+            }
+
+            ResumeRefreshStateChange();
+
+            if (contentFocused != null)
+                contentFocused.DockHandler.Activate();
+
+            DockPanel.ResumeLayout(true, true);
+
+            if (oldDockState != DockState)
+                OnDockStateChanged(EventArgs.Empty);
+        }
+
+        private IDockContent GetFocusedContent()
+        {
+            IDockContent contentFocused = null;
+            foreach (IDockContent content in Contents)
+            {
+                if (content.DockHandler.Form.ContainsFocus)
+                {
+                    contentFocused = content;
+                    break;
+                }
+            }
+
+            return contentFocused;
+        }
+
+        public DockPane DockTo(INestedPanesContainer container)
+        {
+            if (container == null)
+                throw new InvalidOperationException(Strings.DockPane_DockTo_NullContainer);
+
+            DockAlignment alignment;
+            if (container.DockState == DockState.DockLeft || container.DockState == DockState.DockRight)
+                alignment = DockAlignment.Bottom;
+            else
+                alignment = DockAlignment.Right;
+
+            return DockTo(container, container.NestedPanes.GetDefaultPreviousPane(this), alignment, 0.5);
+        }
+
+        public DockPane DockTo(INestedPanesContainer container, DockPane previousPane, DockAlignment alignment, double proportion)
+        {
+            if (container == null)
+                throw new InvalidOperationException(Strings.DockPane_DockTo_NullContainer);
+
+            if (container.IsFloat == this.IsFloat)
+            {
+                InternalAddToDockList(container, previousPane, alignment, proportion);
+                return this;
+            }
+
+            IDockContent firstContent = GetFirstContent(container.DockState);
+            if (firstContent == null)
+                return null;
+
+            DockPane pane;
+            DockPanel.DummyContent.DockPanel = DockPanel;
+            if (container.IsFloat)
+                pane = DockPanel.DockPaneFactory.CreateDockPane(DockPanel.DummyContent, (FloatWindow)container, true);
+            else
+                pane = DockPanel.DockPaneFactory.CreateDockPane(DockPanel.DummyContent, container.DockState, true);
+
+            pane.DockTo(container, previousPane, alignment, proportion);
+            SetVisibleContentsToPane(pane);
+            DockPanel.DummyContent.DockPanel = null;
+
+            return pane;
+        }
+
+        private void SetVisibleContentsToPane(DockPane pane)
+        {
+            SetVisibleContentsToPane(pane, ActiveContent);
+        }
+
+        private void SetVisibleContentsToPane(DockPane pane, IDockContent activeContent)
+        {
+            for (int i = 0; i < DisplayingContents.Count; i++)
+            {
+                IDockContent content = DisplayingContents[i];
+                if (content.DockHandler.IsDockStateValid(pane.DockState))
+                {
+                    content.DockHandler.Pane = pane;
+                    i--;
+                }
+            }
+
+            if (activeContent.DockHandler.Pane == pane)
+                pane.ActiveContent = activeContent;
+        }
+
+        private void InternalAddToDockList(INestedPanesContainer container, DockPane prevPane, DockAlignment alignment, double proportion)
+        {
+            if ((container.DockState == DockState.Float) != IsFloat)
+                throw new InvalidOperationException(Strings.DockPane_DockTo_InvalidContainer);
+
+            int count = container.NestedPanes.Count;
+            if (container.NestedPanes.Contains(this))
+                count--;
+            if (prevPane == null && count > 0)
+                throw new InvalidOperationException(Strings.DockPane_DockTo_NullPrevPane);
+
+            if (prevPane != null && !container.NestedPanes.Contains(prevPane))
+                throw new InvalidOperationException(Strings.DockPane_DockTo_NoPrevPane);
+
+            if (prevPane == this)
+                throw new InvalidOperationException(Strings.DockPane_DockTo_SelfPrevPane);
+
+            INestedPanesContainer oldContainer = NestedPanesContainer;
+            DockState oldDockState = DockState;
+            container.NestedPanes.Add(this);
+            NestedDockingStatus.SetStatus(container.NestedPanes, prevPane, alignment, proportion);
+
+            if (DockHelper.IsDockWindowState(DockState))
+                m_dockState = container.DockState;
+
+            RefreshStateChange(oldContainer, oldDockState);
+        }
+
+        public void SetNestedDockingProportion(double proportion)
+        {
+            NestedDockingStatus.SetStatus(NestedDockingStatus.NestedPanes, NestedDockingStatus.PreviousPane, NestedDockingStatus.Alignment, proportion);
+            if (NestedPanesContainer != null)
+                ((Control)NestedPanesContainer).PerformLayout();
+        }
+
+        public DockPane Float()
+        {
+            DockPanel.SuspendLayout(true);
+
+            IDockContent activeContent = ActiveContent;
+
+            DockPane floatPane = GetFloatPaneFromContents();
+            if (floatPane == null)
+            {
+                IDockContent firstContent = GetFirstContent(DockState.Float);
+                if (firstContent == null)
+                {
+                    DockPanel.ResumeLayout(true, true);
+                    return null;
+                }
+                floatPane = DockPanel.DockPaneFactory.CreateDockPane(firstContent, DockState.Float, true);
+            }
+            SetVisibleContentsToPane(floatPane, activeContent);
+
+            DockPanel.ResumeLayout(true, true);
+            return floatPane;
+        }
+
+        private DockPane GetFloatPaneFromContents()
+        {
+            DockPane floatPane = null;
+            for (int i = 0; i < DisplayingContents.Count; i++)
+            {
+                IDockContent content = DisplayingContents[i];
+                if (!content.DockHandler.IsDockStateValid(DockState.Float))
+                    continue;
+
+                if (floatPane != null && content.DockHandler.FloatPane != floatPane)
+                    return null;
+                else
+                    floatPane = content.DockHandler.FloatPane;
+            }
+
+            return floatPane;
+        }
+
+        private IDockContent GetFirstContent(DockState dockState)
+        {
+            for (int i = 0; i < DisplayingContents.Count; i++)
+            {
+                IDockContent content = DisplayingContents[i];
+                if (content.DockHandler.IsDockStateValid(dockState))
+                    return content;
+            }
+            return null;
+        }
+
+        public void RestoreToPanel()
+        {
+            DockPanel.SuspendLayout(true);
+
+            IDockContent activeContent = DockPanel.ActiveContent;
+
+            for (int i = DisplayingContents.Count - 1; i >= 0; i--)
+            {
+                IDockContent content = DisplayingContents[i];
+                if (content.DockHandler.CheckDockState(false) != DockState.Unknown)
+                    content.DockHandler.IsFloat = false;
+            }
+
+            DockPanel.ResumeLayout(true, true);
+        }
+
+        [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
+        protected override void WndProc(ref Message m)
+        {
+            if (m.Msg == (int)Win32.Msgs.WM_MOUSEACTIVATE)
+                Activate();
+
+            base.WndProc(ref m);
+        }
+
+        #region IDockDragSource Members
+
+        #region IDragSource Members
+
+        Control IDragSource.DragControl
+        {
+            get { return this; }
+        }
+
+        #endregion
+
+        bool IDockDragSource.IsDockStateValid(DockState dockState)
+        {
+            return IsDockStateValid(dockState);
+        }
+
+        bool IDockDragSource.CanDockTo(DockPane pane)
+        {
+            if (!IsDockStateValid(pane.DockState))
+                return false;
+
+            if (pane == this)
+                return false;
+
+            return true;
+        }
+
+        Rectangle IDockDragSource.BeginDrag(Point ptMouse)
+        {
+            Point location = PointToScreen(new Point(0, 0));
+            Size size;
+
+            DockPane floatPane = ActiveContent.DockHandler.FloatPane;
+            if (DockState == DockState.Float || floatPane == null || floatPane.FloatWindow.NestedPanes.Count != 1)
+                size = DockPanel.DefaultFloatWindowSize;
+            else
+                size = floatPane.FloatWindow.Size;
+
+            if (ptMouse.X > location.X + size.Width)
+                location.X += ptMouse.X - (location.X + size.Width) + Measures.SplitterSize;
+
+            return new Rectangle(location, size);
+        }
+
+        void IDockDragSource.EndDrag()
+        {
+        }
+
+        public void FloatAt(Rectangle floatWindowBounds)
+        {
+            if (FloatWindow == null || FloatWindow.NestedPanes.Count != 1)
+                FloatWindow = DockPanel.FloatWindowFactory.CreateFloatWindow(DockPanel, this, floatWindowBounds);
+            else
+                FloatWindow.Bounds = floatWindowBounds;
+
+            DockState = DockState.Float;
+
+            NestedDockingStatus.NestedPanes.SwitchPaneWithFirstChild(this);
+        }
+
+        public void DockTo(DockPane pane, DockStyle dockStyle, int contentIndex)
+        {
+            if (dockStyle == DockStyle.Fill)
+            {
+                IDockContent activeContent = ActiveContent;
+                for (int i = Contents.Count - 1; i >= 0; i--)
+                {
+                    IDockContent c = Contents[i];
+                    if (c.DockHandler.DockState == DockState)
+                    {
+                        c.DockHandler.Pane = pane;
+                        if (contentIndex != -1)
+                            pane.SetContentIndex(c, contentIndex);
+                    }
+                }
+                pane.ActiveContent = activeContent;
+            }
+            else
+            {
+                if (dockStyle == DockStyle.Left)
+                    DockTo(pane.NestedPanesContainer, pane, DockAlignment.Left, 0.5);
+                else if (dockStyle == DockStyle.Right)
+                    DockTo(pane.NestedPanesContainer, pane, DockAlignment.Right, 0.5);
+                else if (dockStyle == DockStyle.Top)
+                    DockTo(pane.NestedPanesContainer, pane, DockAlignment.Top, 0.5);
+                else if (dockStyle == DockStyle.Bottom)
+                    DockTo(pane.NestedPanesContainer, pane, DockAlignment.Bottom, 0.5);
+
+                DockState = pane.DockState;
+            }
+        }
+
+        public void DockTo(DockPanel panel, DockStyle dockStyle)
+        {
+            if (panel != DockPanel)
+                throw new ArgumentException(Strings.IDockDragSource_DockTo_InvalidPanel, "panel");
+
+            if (dockStyle == DockStyle.Top)
+                DockState = DockState.DockTop;
+            else if (dockStyle == DockStyle.Bottom)
+                DockState = DockState.DockBottom;
+            else if (dockStyle == DockStyle.Left)
+                DockState = DockState.DockLeft;
+            else if (dockStyle == DockStyle.Right)
+                DockState = DockState.DockRight;
+            else if (dockStyle == DockStyle.Fill)
+                DockState = DockState.Document;
+        }
+
+        #endregion
     }
-
-    private enum HitTestArea {
-      Caption,
-      TabStrip,
-      Content,
-      None
-    }
-
-    private struct HitTestResult {
-      public HitTestArea HitArea;
-      public int Index;
-
-      public HitTestResult(HitTestArea hitTestArea, int index) {
-        HitArea = hitTestArea;
-        Index = index;
-      }
-    }
-
-    private DockPaneCaptionBase m_captionControl;
-    private DockPaneCaptionBase CaptionControl {
-      get { return m_captionControl; }
-    }
-
-    private DockPaneStripBase m_tabStripControl;
-    internal DockPaneStripBase TabStripControl {
-      get { return m_tabStripControl; }
-    }
-
-    internal protected DockPane(IDockContent content, DockState visibleState, bool show) {
-      InternalConstruct(content, visibleState, false, Rectangle.Empty, null, DockAlignment.Right, 0.5, show);
-    }
-
-    [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters", MessageId = "1#")]
-    internal protected DockPane(IDockContent content, FloatWindow floatWindow, bool show) {
-      if (floatWindow == null)
-        throw new ArgumentNullException("floatWindow");
-
-      InternalConstruct(content, DockState.Float, false, Rectangle.Empty, floatWindow.NestedPanes.GetDefaultPreviousPane(this), DockAlignment.Right, 0.5, show);
-    }
-
-    internal protected DockPane(IDockContent content, DockPane previousPane, DockAlignment alignment, double proportion, bool show) {
-      if (previousPane == null)
-        throw (new ArgumentNullException("previousPane"));
-      InternalConstruct(content, previousPane.DockState, false, Rectangle.Empty, previousPane, alignment, proportion, show);
-    }
-
-    [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters", MessageId = "1#")]
-    internal protected DockPane(IDockContent content, Rectangle floatWindowBounds, bool show) {
-      InternalConstruct(content, DockState.Float, true, floatWindowBounds, null, DockAlignment.Right, 0.5, show);
-    }
-
-    private void InternalConstruct(IDockContent content, DockState dockState, bool flagBounds, Rectangle floatWindowBounds, DockPane prevPane, DockAlignment alignment, double proportion, bool show) {
-      if (dockState == DockState.Hidden || dockState == DockState.Unknown)
-        throw new ArgumentException(Strings.DockPane_SetDockState_InvalidState);
-
-      if (content == null)
-        throw new ArgumentNullException(Strings.DockPane_Constructor_NullContent);
-
-      if (content.DockHandler.DockPanel == null)
-        throw new ArgumentException(Strings.DockPane_Constructor_NullDockPanel);
-
-
-      SuspendLayout();
-      SetStyle(ControlStyles.Selectable, false);
-
-      m_isFloat = (dockState == DockState.Float);
-
-      m_contents = new DockContentCollection();
-      m_displayingContents = new DockContentCollection(this);
-      m_dockPanel = content.DockHandler.DockPanel;
-      m_dockPanel.AddPane(this);
-
-      m_splitter = new SplitterControl(this);
-
-      m_nestedDockingStatus = new NestedDockingStatus(this);
-
-      m_captionControl = DockPanel.DockPaneCaptionFactory.CreateDockPaneCaption(this);
-      m_tabStripControl = DockPanel.DockPaneStripFactory.CreateDockPaneStrip(this);
-      Controls.AddRange(new Control[] { m_captionControl, m_tabStripControl });
-
-      DockPanel.SuspendLayout(true);
-      if (flagBounds)
-        FloatWindow = DockPanel.FloatWindowFactory.CreateFloatWindow(DockPanel, this, floatWindowBounds);
-      else if (prevPane != null)
-        DockTo(prevPane.NestedPanesContainer, prevPane, alignment, proportion);
-
-      SetDockState(dockState);
-      if (show)
-        content.DockHandler.Pane = this;
-      else if (this.IsFloat)
-        content.DockHandler.FloatPane = this;
-      else
-        content.DockHandler.PanelPane = this;
-
-      ResumeLayout();
-      DockPanel.ResumeLayout(true, true);
-    }
-
-    private bool m_isDisposing;
-
-    protected override void Dispose(bool disposing) {
-      if (disposing) {
-        // IMPORTANT: avoid nested call into this method on Mono. 
-        // https://github.com/dockpanelsuite/dockpanelsuite/issues/16
-        if (Win32Helper.IsRunningOnMono) {
-          if (m_isDisposing)
-            return;
-
-          m_isDisposing = true;
-        }
-
-        if (m_captionControl != null) {
-          m_captionControl.Dispose();
-          m_captionControl = null;
-        }
-
-        m_dockState = DockState.Unknown;
-
-        if (NestedPanesContainer != null)
-          NestedPanesContainer.NestedPanes.Remove(this);
-
-        if (DockPanel != null) {
-          DockPanel.RemovePane(this);
-          m_dockPanel = null;
-        }
-
-        Splitter.Dispose();
-        if (m_autoHidePane != null)
-          m_autoHidePane.Dispose();
-      }
-      base.Dispose(disposing);
-    }
-
-    private IDockContent m_activeContent = null;
-    public virtual IDockContent ActiveContent {
-      get { return m_activeContent; }
-      set {
-        if (ActiveContent == value)
-          return;
-
-        if (value != null) {
-          if (!DisplayingContents.Contains(value))
-            throw (new InvalidOperationException(Strings.DockPane_ActiveContent_InvalidValue));
-        } else {
-          if (DisplayingContents.Count != 0)
-            throw (new InvalidOperationException(Strings.DockPane_ActiveContent_InvalidValue));
-        }
-
-        IDockContent oldValue = m_activeContent;
-
-        if (DockPanel.ActiveAutoHideContent == oldValue)
-          DockPanel.ActiveAutoHideContent = null;
-
-        m_activeContent = value;
-
-        if (DockPanel.DocumentStyle == DocumentStyle.DockingMdi && DockState == DockState.Document) {
-          if (m_activeContent != null)
-            m_activeContent.DockHandler.Form.BringToFront();
-        } else {
-          if (m_activeContent != null)
-            m_activeContent.DockHandler.SetVisible();
-          if (oldValue != null && DisplayingContents.Contains(oldValue))
-            oldValue.DockHandler.SetVisible();
-          if (IsActivated && m_activeContent != null)
-            m_activeContent.DockHandler.Activate();
-        }
-
-        if (FloatWindow != null)
-          FloatWindow.SetText();
-
-        if (DockPanel.DocumentStyle == DocumentStyle.DockingMdi &&
-            DockState == DockState.Document)
-          RefreshChanges(false);  // delayed layout to reduce screen flicker
-        else
-          RefreshChanges();
-
-        if (m_activeContent != null)
-          TabStripControl.EnsureTabVisible(m_activeContent);
-      }
-    }
-
-    private bool m_allowDockDragAndDrop = true;
-    public virtual bool AllowDockDragAndDrop {
-      get { return m_allowDockDragAndDrop; }
-      set { m_allowDockDragAndDrop = value; }
-    }
-
-    private IDisposable m_autoHidePane = null;
-    internal IDisposable AutoHidePane {
-      get { return m_autoHidePane; }
-      set { m_autoHidePane = value; }
-    }
-
-    private object m_autoHideTabs = null;
-    internal object AutoHideTabs {
-      get { return m_autoHideTabs; }
-      set { m_autoHideTabs = value; }
-    }
-
-    private object TabPageContextMenu {
-      get {
-        IDockContent content = ActiveContent;
-
-        if (content == null)
-          return null;
-
-        if (content.DockHandler.TabPageContextMenuStrip != null)
-          return content.DockHandler.TabPageContextMenuStrip;
-        else if (content.DockHandler.TabPageContextMenu != null)
-          return content.DockHandler.TabPageContextMenu;
-        else
-          return null;
-      }
-    }
-
-    internal bool HasTabPageContextMenu {
-      get { return TabPageContextMenu != null; }
-    }
-
-    internal void ShowTabPageContextMenu(Control control, Point position) {
-      object menu = TabPageContextMenu;
-
-      if (menu == null)
-        return;
-
-      ContextMenuStrip contextMenuStrip = menu as ContextMenuStrip;
-      if (contextMenuStrip != null) {
-        contextMenuStrip.Show(control, position);
-        return;
-      }
-
-      ContextMenu contextMenu = menu as ContextMenu;
-      if (contextMenu != null)
-        contextMenu.Show(this, position);
-    }
-
-    private Rectangle CaptionRectangle {
-      get {
-        if (!HasCaption)
-          return Rectangle.Empty;
-
-        Rectangle rectWindow = DisplayingRectangle;
-        int x, y, width;
-        x = rectWindow.X;
-        y = rectWindow.Y;
-        width = rectWindow.Width;
-        int height = CaptionControl.MeasureHeight();
-
-        return new Rectangle(x, y, width, height);
-      }
-    }
-
-    internal Rectangle ContentRectangle {
-      get {
-        Rectangle rectWindow = DisplayingRectangle;
-        Rectangle rectCaption = CaptionRectangle;
-        Rectangle rectTabStrip = TabStripRectangle;
-
-        int x = rectWindow.X;
-
-        int y = rectWindow.Y + (rectCaption.IsEmpty ? 0 : rectCaption.Height);
-        if (DockState == DockState.Document && DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Top)
-          y += rectTabStrip.Height;
-
-        int width = rectWindow.Width;
-        int height = rectWindow.Height - rectCaption.Height - rectTabStrip.Height;
-
-        return new Rectangle(x, y, width, height);
-      }
-    }
-
-    internal Rectangle TabStripRectangle {
-      get {
-        if (Appearance == AppearanceStyle.ToolWindow)
-          return TabStripRectangle_ToolWindow;
-        else
-          return TabStripRectangle_Document;
-      }
-    }
-
-    private Rectangle TabStripRectangle_ToolWindow {
-      get {
-        if (DisplayingContents.Count <= 1 || IsAutoHide)
-          return Rectangle.Empty;
-
-        Rectangle rectWindow = DisplayingRectangle;
-
-        int width = rectWindow.Width;
-        int height = TabStripControl.MeasureHeight();
-        int x = rectWindow.X;
-        int y = rectWindow.Bottom - height;
-        Rectangle rectCaption = CaptionRectangle;
-        if (rectCaption.Contains(x, y))
-          y = rectCaption.Y + rectCaption.Height;
-
-        return new Rectangle(x, y, width, height);
-      }
-    }
-
-    private Rectangle TabStripRectangle_Document {
-      get {
-        if (DisplayingContents.Count == 0)
-          return Rectangle.Empty;
-
-        if (DisplayingContents.Count == 1 && DockPanel.DocumentStyle == DocumentStyle.DockingSdi)
-          return Rectangle.Empty;
-
-        Rectangle rectWindow = DisplayingRectangle;
-        int x = rectWindow.X;
-        int width = rectWindow.Width;
-        int height = TabStripControl.MeasureHeight();
-
-        int y = 0;
-        if (DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
-          y = rectWindow.Height - height;
-        else
-          y = rectWindow.Y;
-
-        return new Rectangle(x, y, width, height);
-      }
-    }
-
-    public virtual string CaptionText {
-      get { return ActiveContent == null ? string.Empty : ActiveContent.DockHandler.TabText; }
-    }
-
-    private DockContentCollection m_contents;
-    public DockContentCollection Contents {
-      get { return m_contents; }
-    }
-
-    private DockContentCollection m_displayingContents;
-    public DockContentCollection DisplayingContents {
-      get { return m_displayingContents; }
-    }
-
-    private DockPanel m_dockPanel;
-    public DockPanel DockPanel {
-      get { return m_dockPanel; }
-    }
-
-    private bool HasCaption {
-      get {
-        if (DockState == DockState.Document ||
-            DockState == DockState.Hidden ||
-            DockState == DockState.Unknown ||
-            (DockState == DockState.Float && FloatWindow.VisibleNestedPanes.Count <= 1))
-          return false;
-        else
-          return true;
-      }
-    }
-
-    private bool m_isActivated = false;
-    public bool IsActivated {
-      get { return m_isActivated; }
-    }
-    internal void SetIsActivated(bool value) {
-      if (m_isActivated == value)
-        return;
-
-      m_isActivated = value;
-      if (DockState != DockState.Document)
-        RefreshChanges(false);
-      OnIsActivatedChanged(EventArgs.Empty);
-    }
-
-    private bool m_isActiveDocumentPane = false;
-    public bool IsActiveDocumentPane {
-      get { return m_isActiveDocumentPane; }
-    }
-    internal void SetIsActiveDocumentPane(bool value) {
-      if (m_isActiveDocumentPane == value)
-        return;
-
-      m_isActiveDocumentPane = value;
-      if (DockState == DockState.Document)
-        RefreshChanges();
-      OnIsActiveDocumentPaneChanged(EventArgs.Empty);
-    }
-
-    public bool IsDockStateValid(DockState dockState) {
-      foreach (IDockContent content in Contents)
-        if (!content.DockHandler.IsDockStateValid(dockState))
-          return false;
-
-      return true;
-    }
-
-    public bool IsAutoHide {
-      get { return DockHelper.IsDockStateAutoHide(DockState); }
-    }
-
-    public AppearanceStyle Appearance {
-      get { return (DockState == DockState.Document) ? AppearanceStyle.Document : AppearanceStyle.ToolWindow; }
-    }
-
-    internal Rectangle DisplayingRectangle {
-      get { return ClientRectangle; }
-    }
-
-    public void Activate() {
-      if (DockHelper.IsDockStateAutoHide(DockState) && DockPanel.ActiveAutoHideContent != ActiveContent)
-        DockPanel.ActiveAutoHideContent = ActiveContent;
-      else if (!IsActivated && ActiveContent != null)
-        ActiveContent.DockHandler.Activate();
-    }
-
-    internal void AddContent(IDockContent content) {
-      if (Contents.Contains(content))
-        return;
-
-      Contents.Add(content);
-    }
-
-    internal void Close() {
-      Dispose();
-    }
-
-    public void CloseActiveContent() {
-      CloseContent(ActiveContent);
-    }
-
-    internal void CloseContent(IDockContent content) {
-      if (content == null)
-        return;
-
-      if (!content.DockHandler.CloseButton)
-        return;
-
-      DockPanel dockPanel = DockPanel;
-
-      dockPanel.SuspendLayout(true);
-
-      try {
-        if (content.DockHandler.HideOnClose) {
-          content.DockHandler.Hide();
-          NestedDockingStatus.NestedPanes.SwitchPaneWithFirstChild(this);
-        } else
-          content.DockHandler.Close();
-      }
-      finally {
-        dockPanel.ResumeLayout(true, true);
-      }
-    }
-
-    private HitTestResult GetHitTest(Point ptMouse) {
-      Point ptMouseClient = PointToClient(ptMouse);
-
-      Rectangle rectCaption = CaptionRectangle;
-      if (rectCaption.Contains(ptMouseClient))
-        return new HitTestResult(HitTestArea.Caption, -1);
-
-      Rectangle rectContent = ContentRectangle;
-      if (rectContent.Contains(ptMouseClient))
-        return new HitTestResult(HitTestArea.Content, -1);
-
-      Rectangle rectTabStrip = TabStripRectangle;
-      if (rectTabStrip.Contains(ptMouseClient))
-        return new HitTestResult(HitTestArea.TabStrip, TabStripControl.HitTest(TabStripControl.PointToClient(ptMouse)));
-
-      return new HitTestResult(HitTestArea.None, -1);
-    }
-
-    private bool m_isHidden = true;
-    public bool IsHidden {
-      get { return m_isHidden; }
-    }
-    private void SetIsHidden(bool value) {
-      if (m_isHidden == value)
-        return;
-
-      m_isHidden = value;
-      if (DockHelper.IsDockStateAutoHide(DockState)) {
-        DockPanel.RefreshAutoHideStrip();
-        DockPanel.PerformLayout();
-      } else if (NestedPanesContainer != null)
-        ((Control)NestedPanesContainer).PerformLayout();
-    }
-
-    protected override void OnLayout(LayoutEventArgs levent) {
-      SetIsHidden(DisplayingContents.Count == 0);
-      if (!IsHidden) {
-        CaptionControl.Bounds = CaptionRectangle;
-        TabStripControl.Bounds = TabStripRectangle;
-
-        SetContentBounds();
-
-        foreach (IDockContent content in Contents) {
-          if (DisplayingContents.Contains(content))
-            if (content.DockHandler.FlagClipWindow && content.DockHandler.Form.Visible)
-              content.DockHandler.FlagClipWindow = false;
-        }
-      }
-
-      base.OnLayout(levent);
-    }
-
-    internal void SetContentBounds() {
-      Rectangle rectContent = ContentRectangle;
-      if (DockState == DockState.Document && DockPanel.DocumentStyle == DocumentStyle.DockingMdi)
-        rectContent = DockPanel.RectangleToMdiClient(RectangleToScreen(rectContent));
-
-      Rectangle rectInactive = new Rectangle(-rectContent.Width, rectContent.Y, rectContent.Width, rectContent.Height);
-      foreach (IDockContent content in Contents)
-        if (content.DockHandler.Pane == this) {
-          if (content == ActiveContent)
-            content.DockHandler.Form.Bounds = rectContent;
-          else
-            content.DockHandler.Form.Bounds = rectInactive;
-        }
-    }
-
-    internal void RefreshChanges() {
-      RefreshChanges(true);
-    }
-
-    private void RefreshChanges(bool performLayout) {
-      if (IsDisposed)
-        return;
-
-      CaptionControl.RefreshChanges();
-      TabStripControl.RefreshChanges();
-      if (DockState == DockState.Float && FloatWindow != null)
-        FloatWindow.RefreshChanges();
-      if (DockHelper.IsDockStateAutoHide(DockState) && DockPanel != null) {
-        DockPanel.RefreshAutoHideStrip();
-        DockPanel.PerformLayout();
-      }
-
-      if (performLayout)
-        PerformLayout();
-    }
-
-    internal void RemoveContent(IDockContent content) {
-      if (!Contents.Contains(content))
-        return;
-
-      Contents.Remove(content);
-    }
-
-    public void SetContentIndex(IDockContent content, int index) {
-      int oldIndex = Contents.IndexOf(content);
-      if (oldIndex == -1)
-        throw (new ArgumentException(Strings.DockPane_SetContentIndex_InvalidContent));
-
-      if (index < 0 || index > Contents.Count - 1)
-        if (index != -1)
-          throw (new ArgumentOutOfRangeException(Strings.DockPane_SetContentIndex_InvalidIndex));
-
-      if (oldIndex == index)
-        return;
-      if (oldIndex == Contents.Count - 1 && index == -1)
-        return;
-
-      Contents.Remove(content);
-      if (index == -1)
-        Contents.Add(content);
-      else if (oldIndex < index)
-        Contents.AddAt(content, index - 1);
-      else
-        Contents.AddAt(content, index);
-
-      RefreshChanges();
-    }
-
-    private void SetParent() {
-      if (DockState == DockState.Unknown || DockState == DockState.Hidden) {
-        SetParent(null);
-        Splitter.Parent = null;
-      } else if (DockState == DockState.Float) {
-        SetParent(FloatWindow);
-        Splitter.Parent = FloatWindow;
-      } else if (DockHelper.IsDockStateAutoHide(DockState)) {
-        SetParent(DockPanel.AutoHideControl);
-        Splitter.Parent = null;
-      } else {
-        SetParent(DockPanel.DockWindows[DockState]);
-        Splitter.Parent = Parent;
-      }
-    }
-
-    private void SetParent(Control value) {
-      if (Parent == value)
-        return;
-
-      //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-      // Workaround of .Net Framework bug:
-      // Change the parent of a control with focus may result in the first
-      // MDI child form get activated. 
-      //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-      IDockContent contentFocused = GetFocusedContent();
-      if (contentFocused != null)
-        DockPanel.SaveFocus();
-
-      //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-      Parent = value;
-
-      //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-      // Workaround of .Net Framework bug:
-      // Change the parent of a control with focus may result in the first
-      // MDI child form get activated. 
-      //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-      if (contentFocused != null)
-        contentFocused.DockHandler.Activate();
-      //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-    }
-
-    public new void Show() {
-      Activate();
-    }
-
-    internal void TestDrop(IDockDragSource dragSource, DockOutlineBase dockOutline) {
-      if (!dragSource.CanDockTo(this))
-        return;
-
-      Point ptMouse = Control.MousePosition;
-
-      HitTestResult hitTestResult = GetHitTest(ptMouse);
-      if (hitTestResult.HitArea == HitTestArea.Caption)
-        dockOutline.Show(this, -1);
-      else if (hitTestResult.HitArea == HitTestArea.TabStrip && hitTestResult.Index != -1)
-        dockOutline.Show(this, hitTestResult.Index);
-    }
-
-    internal void ValidateActiveContent() {
-      if (ActiveContent == null) {
-        if (DisplayingContents.Count != 0)
-          ActiveContent = DisplayingContents[0];
-        return;
-      }
-
-      if (DisplayingContents.IndexOf(ActiveContent) >= 0)
-        return;
-
-      IDockContent prevVisible = null;
-      for (int i = Contents.IndexOf(ActiveContent) - 1; i >= 0; i--)
-        if (Contents[i].DockHandler.DockState == DockState) {
-          prevVisible = Contents[i];
-          break;
-        }
-
-      IDockContent nextVisible = null;
-      for (int i = Contents.IndexOf(ActiveContent) + 1; i < Contents.Count; i++)
-        if (Contents[i].DockHandler.DockState == DockState) {
-          nextVisible = Contents[i];
-          break;
-        }
-
-      if (prevVisible != null)
-        ActiveContent = prevVisible;
-      else if (nextVisible != null)
-        ActiveContent = nextVisible;
-      else
-        ActiveContent = null;
-    }
-
-    private static readonly object DockStateChangedEvent = new object();
-    public event EventHandler DockStateChanged {
-      add { Events.AddHandler(DockStateChangedEvent, value); }
-      remove { Events.RemoveHandler(DockStateChangedEvent, value); }
-    }
-    protected virtual void OnDockStateChanged(EventArgs e) {
-      EventHandler handler = (EventHandler)Events[DockStateChangedEvent];
-      if (handler != null)
-        handler(this, e);
-    }
-
-    private static readonly object IsActivatedChangedEvent = new object();
-    public event EventHandler IsActivatedChanged {
-      add { Events.AddHandler(IsActivatedChangedEvent, value); }
-      remove { Events.RemoveHandler(IsActivatedChangedEvent, value); }
-    }
-    protected virtual void OnIsActivatedChanged(EventArgs e) {
-      EventHandler handler = (EventHandler)Events[IsActivatedChangedEvent];
-      if (handler != null)
-        handler(this, e);
-    }
-
-    private static readonly object IsActiveDocumentPaneChangedEvent = new object();
-    public event EventHandler IsActiveDocumentPaneChanged {
-      add { Events.AddHandler(IsActiveDocumentPaneChangedEvent, value); }
-      remove { Events.RemoveHandler(IsActiveDocumentPaneChangedEvent, value); }
-    }
-    protected virtual void OnIsActiveDocumentPaneChanged(EventArgs e) {
-      EventHandler handler = (EventHandler)Events[IsActiveDocumentPaneChangedEvent];
-      if (handler != null)
-        handler(this, e);
-    }
-
-    public DockWindow DockWindow {
-      get { return (m_nestedDockingStatus.NestedPanes == null) ? null : m_nestedDockingStatus.NestedPanes.Container as DockWindow; }
-      set {
-        DockWindow oldValue = DockWindow;
-        if (oldValue == value)
-          return;
-
-        DockTo(value);
-      }
-    }
-
-    public FloatWindow FloatWindow {
-      get { return (m_nestedDockingStatus.NestedPanes == null) ? null : m_nestedDockingStatus.NestedPanes.Container as FloatWindow; }
-      set {
-        FloatWindow oldValue = FloatWindow;
-        if (oldValue == value)
-          return;
-
-        DockTo(value);
-      }
-    }
-
-    private NestedDockingStatus m_nestedDockingStatus;
-    public NestedDockingStatus NestedDockingStatus {
-      get { return m_nestedDockingStatus; }
-    }
-
-    private bool m_isFloat;
-    public bool IsFloat {
-      get { return m_isFloat; }
-    }
-
-    public INestedPanesContainer NestedPanesContainer {
-      get {
-        if (NestedDockingStatus.NestedPanes == null)
-          return null;
-        else
-          return NestedDockingStatus.NestedPanes.Container;
-      }
-    }
-
-    private DockState m_dockState = DockState.Unknown;
-    public DockState DockState {
-      get { return m_dockState; }
-      set {
-        SetDockState(value);
-      }
-    }
-
-    public DockPane SetDockState(DockState value) {
-      if (value == DockState.Unknown || value == DockState.Hidden)
-        throw new InvalidOperationException(Strings.DockPane_SetDockState_InvalidState);
-
-      if ((value == DockState.Float) == this.IsFloat) {
-        InternalSetDockState(value);
-        return this;
-      }
-
-      if (DisplayingContents.Count == 0)
-        return null;
-
-      IDockContent firstContent = null;
-      for (int i = 0; i < DisplayingContents.Count; i++) {
-        IDockContent content = DisplayingContents[i];
-        if (content.DockHandler.IsDockStateValid(value)) {
-          firstContent = content;
-          break;
-        }
-      }
-      if (firstContent == null)
-        return null;
-
-      firstContent.DockHandler.DockState = value;
-      DockPane pane = firstContent.DockHandler.Pane;
-      DockPanel.SuspendLayout(true);
-      for (int i = 0; i < DisplayingContents.Count; i++) {
-        IDockContent content = DisplayingContents[i];
-        if (content.DockHandler.IsDockStateValid(value))
-          content.DockHandler.Pane = pane;
-      }
-      DockPanel.ResumeLayout(true, true);
-      return pane;
-    }
-
-    private void InternalSetDockState(DockState value) {
-      if (m_dockState == value)
-        return;
-
-      DockState oldDockState = m_dockState;
-      INestedPanesContainer oldContainer = NestedPanesContainer;
-
-      m_dockState = value;
-
-      SuspendRefreshStateChange();
-
-      IDockContent contentFocused = GetFocusedContent();
-      if (contentFocused != null)
-        DockPanel.SaveFocus();
-
-      if (!IsFloat)
-        DockWindow = DockPanel.DockWindows[DockState];
-      else if (FloatWindow == null)
-        FloatWindow = DockPanel.FloatWindowFactory.CreateFloatWindow(DockPanel, this);
-
-      if (contentFocused != null)
-        if (!Win32Helper.IsRunningOnMono)
-          DockPanel.ContentFocusManager.Activate(contentFocused);
-
-      ResumeRefreshStateChange(oldContainer, oldDockState);
-    }
-
-    private int m_countRefreshStateChange = 0;
-    private void SuspendRefreshStateChange() {
-      m_countRefreshStateChange++;
-      DockPanel.SuspendLayout(true);
-    }
-
-    private void ResumeRefreshStateChange() {
-      m_countRefreshStateChange--;
-      System.Diagnostics.Debug.Assert(m_countRefreshStateChange >= 0);
-      DockPanel.ResumeLayout(true, true);
-    }
-
-    private bool IsRefreshStateChangeSuspended {
-      get { return m_countRefreshStateChange != 0; }
-    }
-
-    private void ResumeRefreshStateChange(INestedPanesContainer oldContainer, DockState oldDockState) {
-      ResumeRefreshStateChange();
-      RefreshStateChange(oldContainer, oldDockState);
-    }
-
-    private void RefreshStateChange(INestedPanesContainer oldContainer, DockState oldDockState) {
-      lock (this) {
-        if (IsRefreshStateChangeSuspended)
-          return;
-
-        SuspendRefreshStateChange();
-      }
-
-      DockPanel.SuspendLayout(true);
-
-      IDockContent contentFocused = GetFocusedContent();
-      if (contentFocused != null)
-        DockPanel.SaveFocus();
-      SetParent();
-
-      if (ActiveContent != null)
-        ActiveContent.DockHandler.SetDockState(ActiveContent.DockHandler.IsHidden, DockState, ActiveContent.DockHandler.Pane);
-      foreach (IDockContent content in Contents) {
-        if (content.DockHandler.Pane == this)
-          content.DockHandler.SetDockState(content.DockHandler.IsHidden, DockState, content.DockHandler.Pane);
-      }
-
-      if (oldContainer != null) {
-        Control oldContainerControl = (Control)oldContainer;
-        if (oldContainer.DockState == oldDockState && !oldContainerControl.IsDisposed)
-          oldContainerControl.PerformLayout();
-      }
-      if (DockHelper.IsDockStateAutoHide(oldDockState))
-        DockPanel.RefreshActiveAutoHideContent();
-
-      if (NestedPanesContainer.DockState == DockState)
-        ((Control)NestedPanesContainer).PerformLayout();
-      if (DockHelper.IsDockStateAutoHide(DockState))
-        DockPanel.RefreshActiveAutoHideContent();
-
-      if (DockHelper.IsDockStateAutoHide(oldDockState) ||
-          DockHelper.IsDockStateAutoHide(DockState)) {
-        DockPanel.RefreshAutoHideStrip();
-        DockPanel.PerformLayout();
-      }
-
-      ResumeRefreshStateChange();
-
-      if (contentFocused != null)
-        contentFocused.DockHandler.Activate();
-
-      DockPanel.ResumeLayout(true, true);
-
-      if (oldDockState != DockState)
-        OnDockStateChanged(EventArgs.Empty);
-    }
-
-    private IDockContent GetFocusedContent() {
-      IDockContent contentFocused = null;
-      foreach (IDockContent content in Contents) {
-        if (content.DockHandler.Form.ContainsFocus) {
-          contentFocused = content;
-          break;
-        }
-      }
-
-      return contentFocused;
-    }
-
-    public DockPane DockTo(INestedPanesContainer container) {
-      if (container == null)
-        throw new InvalidOperationException(Strings.DockPane_DockTo_NullContainer);
-
-      DockAlignment alignment;
-      if (container.DockState == DockState.DockLeft || container.DockState == DockState.DockRight)
-        alignment = DockAlignment.Bottom;
-      else
-        alignment = DockAlignment.Right;
-
-      return DockTo(container, container.NestedPanes.GetDefaultPreviousPane(this), alignment, 0.5);
-    }
-
-    public DockPane DockTo(INestedPanesContainer container, DockPane previousPane, DockAlignment alignment, double proportion) {
-      if (container == null)
-        throw new InvalidOperationException(Strings.DockPane_DockTo_NullContainer);
-
-      if (container.IsFloat == this.IsFloat) {
-        InternalAddToDockList(container, previousPane, alignment, proportion);
-        return this;
-      }
-
-      IDockContent firstContent = GetFirstContent(container.DockState);
-      if (firstContent == null)
-        return null;
-
-      DockPane pane;
-      DockPanel.DummyContent.DockPanel = DockPanel;
-      if (container.IsFloat)
-        pane = DockPanel.DockPaneFactory.CreateDockPane(DockPanel.DummyContent, (FloatWindow)container, true);
-      else
-        pane = DockPanel.DockPaneFactory.CreateDockPane(DockPanel.DummyContent, container.DockState, true);
-
-      pane.DockTo(container, previousPane, alignment, proportion);
-      SetVisibleContentsToPane(pane);
-      DockPanel.DummyContent.DockPanel = null;
-
-      return pane;
-    }
-
-    private void SetVisibleContentsToPane(DockPane pane) {
-      SetVisibleContentsToPane(pane, ActiveContent);
-    }
-
-    private void SetVisibleContentsToPane(DockPane pane, IDockContent activeContent) {
-      for (int i = 0; i < DisplayingContents.Count; i++) {
-        IDockContent content = DisplayingContents[i];
-        if (content.DockHandler.IsDockStateValid(pane.DockState)) {
-          content.DockHandler.Pane = pane;
-          i--;
-        }
-      }
-
-      if (activeContent.DockHandler.Pane == pane)
-        pane.ActiveContent = activeContent;
-    }
-
-    private void InternalAddToDockList(INestedPanesContainer container, DockPane prevPane, DockAlignment alignment, double proportion) {
-      if ((container.DockState == DockState.Float) != IsFloat)
-        throw new InvalidOperationException(Strings.DockPane_DockTo_InvalidContainer);
-
-      int count = container.NestedPanes.Count;
-      if (container.NestedPanes.Contains(this))
-        count--;
-      if (prevPane == null && count > 0)
-        throw new InvalidOperationException(Strings.DockPane_DockTo_NullPrevPane);
-
-      if (prevPane != null && !container.NestedPanes.Contains(prevPane))
-        throw new InvalidOperationException(Strings.DockPane_DockTo_NoPrevPane);
-
-      if (prevPane == this)
-        throw new InvalidOperationException(Strings.DockPane_DockTo_SelfPrevPane);
-
-      INestedPanesContainer oldContainer = NestedPanesContainer;
-      DockState oldDockState = DockState;
-      container.NestedPanes.Add(this);
-      NestedDockingStatus.SetStatus(container.NestedPanes, prevPane, alignment, proportion);
-
-      if (DockHelper.IsDockWindowState(DockState))
-        m_dockState = container.DockState;
-
-      RefreshStateChange(oldContainer, oldDockState);
-    }
-
-    public void SetNestedDockingProportion(double proportion) {
-      NestedDockingStatus.SetStatus(NestedDockingStatus.NestedPanes, NestedDockingStatus.PreviousPane, NestedDockingStatus.Alignment, proportion);
-      if (NestedPanesContainer != null)
-        ((Control)NestedPanesContainer).PerformLayout();
-    }
-
-    public DockPane Float() {
-      DockPanel.SuspendLayout(true);
-
-      IDockContent activeContent = ActiveContent;
-
-      DockPane floatPane = GetFloatPaneFromContents();
-      if (floatPane == null) {
-        IDockContent firstContent = GetFirstContent(DockState.Float);
-        if (firstContent == null) {
-          DockPanel.ResumeLayout(true, true);
-          return null;
-        }
-        floatPane = DockPanel.DockPaneFactory.CreateDockPane(firstContent, DockState.Float, true);
-      }
-      SetVisibleContentsToPane(floatPane, activeContent);
-
-      DockPanel.ResumeLayout(true, true);
-      return floatPane;
-    }
-
-    private DockPane GetFloatPaneFromContents() {
-      DockPane floatPane = null;
-      for (int i = 0; i < DisplayingContents.Count; i++) {
-        IDockContent content = DisplayingContents[i];
-        if (!content.DockHandler.IsDockStateValid(DockState.Float))
-          continue;
-
-        if (floatPane != null && content.DockHandler.FloatPane != floatPane)
-          return null;
-        else
-          floatPane = content.DockHandler.FloatPane;
-      }
-
-      return floatPane;
-    }
-
-    private IDockContent GetFirstContent(DockState dockState) {
-      for (int i = 0; i < DisplayingContents.Count; i++) {
-        IDockContent content = DisplayingContents[i];
-        if (content.DockHandler.IsDockStateValid(dockState))
-          return content;
-      }
-      return null;
-    }
-
-    public void RestoreToPanel() {
-      DockPanel.SuspendLayout(true);
-
-      IDockContent activeContent = DockPanel.ActiveContent;
-
-      for (int i = DisplayingContents.Count - 1; i >= 0; i--) {
-        IDockContent content = DisplayingContents[i];
-        if (content.DockHandler.CheckDockState(false) != DockState.Unknown)
-          content.DockHandler.IsFloat = false;
-      }
-
-      DockPanel.ResumeLayout(true, true);
-    }
-
-    [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
-    protected override void WndProc(ref Message m) {
-      if (m.Msg == (int)Win32.Msgs.WM_MOUSEACTIVATE)
-        Activate();
-
-      base.WndProc(ref m);
-    }
-
-    #region IDockDragSource Members
-
-    #region IDragSource Members
-
-    Control IDragSource.DragControl {
-      get { return this; }
-    }
-
-    #endregion
-
-    bool IDockDragSource.IsDockStateValid(DockState dockState) {
-      return IsDockStateValid(dockState);
-    }
-
-    bool IDockDragSource.CanDockTo(DockPane pane) {
-      if (!IsDockStateValid(pane.DockState))
-        return false;
-
-      if (pane == this)
-        return false;
-
-      return true;
-    }
-
-    Rectangle IDockDragSource.BeginDrag(Point ptMouse) {
-      Point location = PointToScreen(new Point(0, 0));
-      Size size;
-
-      DockPane floatPane = ActiveContent.DockHandler.FloatPane;
-      if (DockState == DockState.Float || floatPane == null || floatPane.FloatWindow.NestedPanes.Count != 1)
-        size = DockPanel.DefaultFloatWindowSize;
-      else
-        size = floatPane.FloatWindow.Size;
-
-      if (ptMouse.X > location.X + size.Width)
-        location.X += ptMouse.X - (location.X + size.Width) + Measures.SplitterSize;
-
-      return new Rectangle(location, size);
-    }
-
-    void IDockDragSource.EndDrag() {
-    }
-
-    public void FloatAt(Rectangle floatWindowBounds) {
-      if (FloatWindow == null || FloatWindow.NestedPanes.Count != 1)
-        FloatWindow = DockPanel.FloatWindowFactory.CreateFloatWindow(DockPanel, this, floatWindowBounds);
-      else
-        FloatWindow.Bounds = floatWindowBounds;
-
-      DockState = DockState.Float;
-
-      NestedDockingStatus.NestedPanes.SwitchPaneWithFirstChild(this);
-    }
-
-    public void DockTo(DockPane pane, DockStyle dockStyle, int contentIndex) {
-      if (dockStyle == DockStyle.Fill) {
-        IDockContent activeContent = ActiveContent;
-        for (int i = Contents.Count - 1; i >= 0; i--) {
-          IDockContent c = Contents[i];
-          if (c.DockHandler.DockState == DockState) {
-            c.DockHandler.Pane = pane;
-            if (contentIndex != -1)
-              pane.SetContentIndex(c, contentIndex);
-          }
-        }
-        pane.ActiveContent = activeContent;
-      } else {
-        if (dockStyle == DockStyle.Left)
-          DockTo(pane.NestedPanesContainer, pane, DockAlignment.Left, 0.5);
-        else if (dockStyle == DockStyle.Right)
-          DockTo(pane.NestedPanesContainer, pane, DockAlignment.Right, 0.5);
-        else if (dockStyle == DockStyle.Top)
-          DockTo(pane.NestedPanesContainer, pane, DockAlignment.Top, 0.5);
-        else if (dockStyle == DockStyle.Bottom)
-          DockTo(pane.NestedPanesContainer, pane, DockAlignment.Bottom, 0.5);
-
-        DockState = pane.DockState;
-      }
-    }
-
-    public void DockTo(DockPanel panel, DockStyle dockStyle) {
-      if (panel != DockPanel)
-        throw new ArgumentException(Strings.IDockDragSource_DockTo_InvalidPanel, "panel");
-
-      if (dockStyle == DockStyle.Top)
-        DockState = DockState.DockTop;
-      else if (dockStyle == DockStyle.Bottom)
-        DockState = DockState.DockBottom;
-      else if (dockStyle == DockStyle.Left)
-        DockState = DockState.DockLeft;
-      else if (dockStyle == DockStyle.Right)
-        DockState = DockState.DockRight;
-      else if (dockStyle == DockStyle.Fill)
-        DockState = DockState.Document;
-    }
-
-    #endregion
-  }
 }

branches/UnloadJobs/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.cs

@@ -1 +1 @@
 using System;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Windows.Forms;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.IO;
+using System.Text;
+using System.Diagnostics.CodeAnalysis;
 using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics.CodeAnalysis;
-using System.Drawing;
-using System.Windows.Forms;
 
 // To simplify the process of finding the toolbox bitmap resource:
@@ -11 +15 @@
 // #3 use the "<default namespace>.<resourcename>" string to locate the resource.
 // See: http://www.bobpowell.net/toolboxbitmap.htm
-internal class resfinder {
+internal class resfinder
+{
 }
 
-namespace WeifenLuo.WinFormsUI.Docking {
-  [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters", MessageId = "0#")]
-  public delegate IDockContent DeserializeDockContent(string persistString);
-
-  [LocalizedDescription("DockPanel_Description")]
-  [Designer("System.Windows.Forms.Design.ControlDesigner, System.Design")]
-  [ToolboxBitmap(typeof(resfinder), "WeifenLuo.WinFormsUI.Docking.DockPanel.bmp")]
-  [DefaultProperty("DocumentStyle")]
-  [DefaultEvent("ActiveContentChanged")]
-  public partial class DockPanel : Panel {
-    private FocusManagerImpl m_focusManager;
-    private DockPanelExtender m_extender;
-    private DockPaneCollection m_panes;
-    private FloatWindowCollection m_floatWindows;
-    private AutoHideWindowControl m_autoHideWindow;
-    private DockWindowCollection m_dockWindows;
-    private DockContent m_dummyContent;
-    private Control m_dummyControl;
-
-    public DockPanel() {
-      m_focusManager = new FocusManagerImpl(this);
-      m_extender = new DockPanelExtender(this);
-      m_panes = new DockPaneCollection();
-      m_floatWindows = new FloatWindowCollection();
-
-      SuspendLayout();
-
-      m_autoHideWindow = new AutoHideWindowControl(this);
-      m_autoHideWindow.Visible = false;
-      SetAutoHideWindowParent();
-
-      m_dummyControl = new DummyControl();
-      m_dummyControl.Bounds = new Rectangle(0, 0, 1, 1);
-      Controls.Add(m_dummyControl);
-
-      m_dockWindows = new DockWindowCollection(this);
-      Controls.AddRange(new Control[] {
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters", MessageId = "0#")]
+  public delegate IDockContent DeserializeDockContent(string persistString);
+
+    [LocalizedDescription("DockPanel_Description")]
+    [Designer("System.Windows.Forms.Design.ControlDesigner, System.Design")]
+    [ToolboxBitmap(typeof(resfinder), "WeifenLuo.WinFormsUI.Docking.DockPanel.bmp")]
+    [DefaultProperty("DocumentStyle")]
+    [DefaultEvent("ActiveContentChanged")]
+  public partial class DockPanel : Panel
+  {
+        private FocusManagerImpl m_focusManager;
+        private DockPanelExtender m_extender;
+        private DockPaneCollection m_panes;
+        private FloatWindowCollection m_floatWindows;
+        private AutoHideWindowControl m_autoHideWindow;
+        private DockWindowCollection m_dockWindows;
+        private DockContent m_dummyContent; 
+        private Control m_dummyControl;
+        
+    public DockPanel()
+    {
+            m_focusManager = new FocusManagerImpl(this);
+      m_extender = new DockPanelExtender(this);
+      m_panes = new DockPaneCollection();
+      m_floatWindows = new FloatWindowCollection();
+
+            SuspendLayout();
+
+      m_autoHideWindow = new AutoHideWindowControl(this);
+      m_autoHideWindow.Visible = false;
+            SetAutoHideWindowParent();
+
+      m_dummyControl = new DummyControl();
+      m_dummyControl.Bounds = new Rectangle(0, 0, 1, 1);
+      Controls.Add(m_dummyControl);
+
+      m_dockWindows = new DockWindowCollection(this);
+      Controls.AddRange(new Control[] {
         DockWindows[DockState.Document],
         DockWindows[DockState.DockLeft],
@@ -58 +66 @@
         });
 
-      m_dummyContent = new DockContent();
-      ResumeLayout();
+      m_dummyContent = new DockContent();
+            ResumeLayout();
+        }
+        
+        private Color m_BackColor;
+        /// <summary>
+        /// Determines the color with which the client rectangle will be drawn.
+        /// If this property is used instead of the BackColor it will not have any influence on the borders to the surrounding controls (DockPane).
+        /// The BackColor property changes the borders of surrounding controls (DockPane).
+        /// Alternatively both properties may be used (BackColor to draw and define the color of the borders and DockBackColor to define the color of the client rectangle). 
+        /// For Backgroundimages: Set your prefered Image, then set the DockBackColor and the BackColor to the same Color (Control)
+        /// </summary>
+        [Description("Determines the color with which the client rectangle will be drawn.\r\n" +
+            "If this property is used instead of the BackColor it will not have any influence on the borders to the surrounding controls (DockPane).\r\n" +
+            "The BackColor property changes the borders of surrounding controls (DockPane).\r\n" +
+            "Alternatively both properties may be used (BackColor to draw and define the color of the borders and DockBackColor to define the color of the client rectangle).\r\n" +
+            "For Backgroundimages: Set your prefered Image, then set the DockBackColor and the BackColor to the same Color (Control).")]
+        public Color DockBackColor
+        {
+            get
+            {
+                return !m_BackColor.IsEmpty ? m_BackColor : base.BackColor;
+            }
+            set
+            {
+                if (m_BackColor != value)
+                {
+                    m_BackColor = value;
+                    this.Refresh();
+                }
+            }
+        }
+
+        private bool ShouldSerializeDockBackColor()
+        {
+            return !m_BackColor.IsEmpty;
+        }
+
+        private void ResetDockBackColor()
+        {
+            DockBackColor = Color.Empty;
+        }
+
+    private AutoHideStripBase m_autoHideStripControl = null;
+    internal AutoHideStripBase AutoHideStripControl
+    {
+      get
+      { 
+        if (m_autoHideStripControl == null)
+        {
+          m_autoHideStripControl = AutoHideStripFactory.CreateAutoHideStrip(this);
+          Controls.Add(m_autoHideStripControl);
+        }
+        return m_autoHideStripControl;
+      }
+    }
+        internal void ResetAutoHideStripControl()
+        {
+            if (m_autoHideStripControl != null)
+                m_autoHideStripControl.Dispose();
+
+            m_autoHideStripControl = null;
+        }
+
+    private void MdiClientHandleAssigned(object sender, EventArgs e)
+    {
+      SetMdiClient();
+      PerformLayout();
+    }
+
+    private void MdiClient_Layout(object sender, LayoutEventArgs e)
+    {
+      if (DocumentStyle != DocumentStyle.DockingMdi)
+        return;
+
+      foreach (DockPane pane in Panes)
+        if (pane.DockState == DockState.Document)
+          pane.SetContentBounds();
+
+      InvalidateWindowRegion();
+    }
+
+    private bool m_disposed = false;
+    protected override void Dispose(bool disposing)
+    {
+      lock (this)
+      {
+        if (!m_disposed && disposing)
+        {
+                    m_focusManager.Dispose();
+          if (m_mdiClientController != null)
+          {
+            m_mdiClientController.HandleAssigned -= new EventHandler(MdiClientHandleAssigned);
+            m_mdiClientController.MdiChildActivate -= new EventHandler(ParentFormMdiChildActivate);
+            m_mdiClientController.Layout -= new LayoutEventHandler(MdiClient_Layout);
+            m_mdiClientController.Dispose();
+          }
+          FloatWindows.Dispose();
+          Panes.Dispose();
+          DummyContent.Dispose();
+
+          m_disposed = true;
+        }
+        
+        base.Dispose(disposing);
+      }
+    }
+
+    [Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+    public IDockContent ActiveAutoHideContent
+    {
+      get { return AutoHideWindow.ActiveContent;  }
+      set { AutoHideWindow.ActiveContent = value; }
+    }
+
+        private bool m_allowEndUserDocking = !Win32Helper.IsRunningOnMono;
+    [LocalizedCategory("Category_Docking")]
+    [LocalizedDescription("DockPanel_AllowEndUserDocking_Description")]
+    [DefaultValue(true)]
+    public bool AllowEndUserDocking
+    {
+      get
+      {
+                if (Win32Helper.IsRunningOnMono && m_allowEndUserDocking)
+                    m_allowEndUserDocking = false;
+
+          return m_allowEndUserDocking;
+      }
+      set
+      {
+          if (Win32Helper.IsRunningOnMono && value)
+              throw new InvalidOperationException("AllowEndUserDocking can only be false if running on Mono");
+                    
+                m_allowEndUserDocking = value;
+      }
+    }
+
+        private bool m_allowEndUserNestedDocking = !Win32Helper.IsRunningOnMono;
+        [LocalizedCategory("Category_Docking")]
+        [LocalizedDescription("DockPanel_AllowEndUserNestedDocking_Description")]
+        [DefaultValue(true)]
+        public bool AllowEndUserNestedDocking
+        {
+            get
+            {
+                if (Win32Helper.IsRunningOnMono && m_allowEndUserDocking)
+                    m_allowEndUserDocking = false;
+                return m_allowEndUserNestedDocking;
+            }
+            set
+            {
+                if (Win32Helper.IsRunningOnMono && value)
+                    throw new InvalidOperationException("AllowEndUserNestedDocking can only be false if running on Mono");
+
+                m_allowEndUserNestedDocking = value;
+            }
+        }
+
+        private DockContentCollection m_contents = new DockContentCollection();
+    [Browsable(false)]
+    public DockContentCollection Contents
+    {
+      get { return m_contents;  }
+    }
+
+    internal DockContent DummyContent
+    {
+      get { return m_dummyContent;  }
+    }
+
+        private bool m_rightToLeftLayout = false;
+        [DefaultValue(false)]
+        [LocalizedCategory("Appearance")]
+        [LocalizedDescription("DockPanel_RightToLeftLayout_Description")]
+        public bool RightToLeftLayout
+        {
+            get { return m_rightToLeftLayout; }
+            set
+            {
+                if (m_rightToLeftLayout == value)
+                    return;
+
+                m_rightToLeftLayout = value;
+                foreach (FloatWindow floatWindow in FloatWindows)
+                    floatWindow.RightToLeftLayout = value;
+            }
+        }
+
+        protected override void OnRightToLeftChanged(EventArgs e)
+        {
+            base.OnRightToLeftChanged(e);
+            foreach (FloatWindow floatWindow in FloatWindows)
+            {
+                if (floatWindow.RightToLeft != RightToLeft)
+                    floatWindow.RightToLeft = RightToLeft;
+            }
+        }
+
+    private bool m_showDocumentIcon = false;
+    [DefaultValue(false)]
+    [LocalizedCategory("Category_Docking")]
+    [LocalizedDescription("DockPanel_ShowDocumentIcon_Description")]
+    public bool ShowDocumentIcon
+    {
+      get { return m_showDocumentIcon;  }
+      set
+      {
+        if (m_showDocumentIcon == value)
+          return;
+
+        m_showDocumentIcon = value;
+        Refresh();
+      }
+    }
+
+        private DocumentTabStripLocation m_documentTabStripLocation = DocumentTabStripLocation.Top;
+        [DefaultValue(DocumentTabStripLocation.Top)]
+        [LocalizedCategory("Category_Docking")]
+        [LocalizedDescription("DockPanel_DocumentTabStripLocation")]
+        public DocumentTabStripLocation DocumentTabStripLocation
+        {
+            get { return m_documentTabStripLocation; }
+            set { m_documentTabStripLocation = value; }
+        }
+
+    [Browsable(false)]
+    public DockPanelExtender Extender
+    {
+      get { return m_extender;  }
+    }
+
+        [Browsable(false)]
+    public DockPanelExtender.IDockPaneFactory DockPaneFactory
+    {
+      get { return Extender.DockPaneFactory;  }
+    }
+
+        [Browsable(false)]
+    public DockPanelExtender.IFloatWindowFactory FloatWindowFactory
+    {
+      get { return Extender.FloatWindowFactory; }
+    }
+
+    internal DockPanelExtender.IDockPaneCaptionFactory DockPaneCaptionFactory
+    {
+      get { return Extender.DockPaneCaptionFactory; }
+    }
+
+    internal DockPanelExtender.IDockPaneStripFactory DockPaneStripFactory
+    {
+      get { return Extender.DockPaneStripFactory; }
+    }
+
+    internal DockPanelExtender.IAutoHideStripFactory AutoHideStripFactory
+    {
+      get { return Extender.AutoHideStripFactory; }
+    }
+
+    [Browsable(false)]
+    public DockPaneCollection Panes
+    {
+      get { return m_panes; }
+    }
+
+    internal Rectangle DockArea
+    {
+      get
+      {
+        return new Rectangle(DockPadding.Left, DockPadding.Top,
+          ClientRectangle.Width - DockPadding.Left - DockPadding.Right,
+          ClientRectangle.Height - DockPadding.Top - DockPadding.Bottom);
+      }
+    }
+
+    private double m_dockBottomPortion = 0.25;
+    [LocalizedCategory("Category_Docking")]
+    [LocalizedDescription("DockPanel_DockBottomPortion_Description")]
+    [DefaultValue(0.25)]
+    public double DockBottomPortion
+    {
+      get { return m_dockBottomPortion; }
+      set
+      {
+        if (value <= 0)
+          throw new ArgumentOutOfRangeException("value");
+
+        if (value == m_dockBottomPortion)
+          return;
+
+        m_dockBottomPortion = value;
+
+                if (m_dockBottomPortion < 1 && m_dockTopPortion < 1)
+                {
+                    if (m_dockTopPortion + m_dockBottomPortion > 1)
+                        m_dockTopPortion = 1 - m_dockBottomPortion;
+                }
+
+        PerformLayout();
+      }
+    }
+
+    private double m_dockLeftPortion = 0.25;
+    [LocalizedCategory("Category_Docking")]
+    [LocalizedDescription("DockPanel_DockLeftPortion_Description")]
+    [DefaultValue(0.25)]
+    public double DockLeftPortion
+    {
+      get { return m_dockLeftPortion; }
+      set
+      {
+        if (value <= 0)
+          throw new ArgumentOutOfRangeException("value");
+
+        if (value == m_dockLeftPortion)
+          return;
+
+        m_dockLeftPortion = value;
+
+                if (m_dockLeftPortion < 1 && m_dockRightPortion < 1)
+                {
+                    if (m_dockLeftPortion + m_dockRightPortion > 1)
+                        m_dockRightPortion = 1 - m_dockLeftPortion;
+                }
+        PerformLayout();
+      }
+    }
+
+    private double m_dockRightPortion = 0.25;
+    [LocalizedCategory("Category_Docking")]
+    [LocalizedDescription("DockPanel_DockRightPortion_Description")]
+    [DefaultValue(0.25)]
+    public double DockRightPortion
+    {
+      get { return m_dockRightPortion;  }
+      set
+      {
+        if (value <= 0)
+          throw new ArgumentOutOfRangeException("value");
+
+        if (value == m_dockRightPortion)
+          return;
+
+        m_dockRightPortion = value;
+
+                if (m_dockLeftPortion < 1 && m_dockRightPortion < 1)
+                {
+                    if (m_dockLeftPortion + m_dockRightPortion > 1)
+                        m_dockLeftPortion = 1 - m_dockRightPortion;
+                }
+        PerformLayout();
+      }
+    }
+
+    private double m_dockTopPortion = 0.25;
+    [LocalizedCategory("Category_Docking")]
+    [LocalizedDescription("DockPanel_DockTopPortion_Description")]
+    [DefaultValue(0.25)]
+    public double DockTopPortion
+    {
+      get { return m_dockTopPortion;  }
+      set
+      {
+        if (value <= 0)
+          throw new ArgumentOutOfRangeException("value");
+
+        if (value == m_dockTopPortion)
+          return;
+
+        m_dockTopPortion = value;
+
+                if (m_dockTopPortion < 1 && m_dockBottomPortion < 1)
+                {
+                    if (m_dockTopPortion + m_dockBottomPortion > 1)
+                        m_dockBottomPortion = 1 - m_dockTopPortion;
+                }
+        PerformLayout();
+      }
+    }
+
+    [Browsable(false)]
+    public DockWindowCollection DockWindows
+    {
+      get { return m_dockWindows; }
+    }
+
+        public void UpdateDockWindowZOrder(DockStyle dockStyle, bool fullPanelEdge)
+        {
+            if (dockStyle == DockStyle.Left)
+            {
+                if (fullPanelEdge)
+                    DockWindows[DockState.DockLeft].SendToBack();
+                else
+                    DockWindows[DockState.DockLeft].BringToFront();
+            }
+            else if (dockStyle == DockStyle.Right)
+            {
+                if (fullPanelEdge)
+                    DockWindows[DockState.DockRight].SendToBack();
+                else
+                    DockWindows[DockState.DockRight].BringToFront();
+            }
+            else if (dockStyle == DockStyle.Top)
+            {
+                if (fullPanelEdge)
+                    DockWindows[DockState.DockTop].SendToBack();
+                else
+                    DockWindows[DockState.DockTop].BringToFront();
+            }
+            else if (dockStyle == DockStyle.Bottom)
+            {
+                if (fullPanelEdge)
+                    DockWindows[DockState.DockBottom].SendToBack();
+                else
+                    DockWindows[DockState.DockBottom].BringToFront();
+            }
+        }
+
+        [Browsable(false)]
+        public int DocumentsCount
+        {
+            get
+            {
+                int count = 0;
+                foreach (IDockContent content in Documents)
+                    count++;
+
+                return count;
+            }
+        }
+
+        public IDockContent[] DocumentsToArray()
+        {
+            int count = DocumentsCount;
+            IDockContent[] documents = new IDockContent[count];
+            int i = 0;
+            foreach (IDockContent content in Documents)
+            {
+                documents[i] = content;
+                i++;
+            }
+
+            return documents;
+        }
+
+        [Browsable(false)]
+    public IEnumerable<IDockContent> Documents
+    {
+            get
+            {
+                foreach (IDockContent content in Contents)
+                {
+                    if (content.DockHandler.DockState == DockState.Document)
+                        yield return content;
+                }
+            }
+    }
+
+    private Rectangle DocumentRectangle
+    {
+      get
+      {
+        Rectangle rect = DockArea;
+        if (DockWindows[DockState.DockLeft].VisibleNestedPanes.Count != 0)
+        {
+          rect.X += (int)(DockArea.Width * DockLeftPortion);
+          rect.Width -= (int)(DockArea.Width * DockLeftPortion);
+        }
+        if (DockWindows[DockState.DockRight].VisibleNestedPanes.Count != 0)
+          rect.Width -= (int)(DockArea.Width * DockRightPortion);
+        if (DockWindows[DockState.DockTop].VisibleNestedPanes.Count != 0)
+        {
+          rect.Y += (int)(DockArea.Height * DockTopPortion);
+          rect.Height -= (int)(DockArea.Height * DockTopPortion);
+        }
+        if (DockWindows[DockState.DockBottom].VisibleNestedPanes.Count != 0)
+          rect.Height -= (int)(DockArea.Height * DockBottomPortion);
+
+        return rect;
+      }
+    }
+
+    private Control DummyControl
+    {
+      get { return m_dummyControl;  }
+    }
+
+    [Browsable(false)]
+    public FloatWindowCollection FloatWindows
+    {
+      get { return m_floatWindows;  }
+    }
+
+        private Size m_defaultFloatWindowSize = new Size(300, 300);
+        [Category("Layout")]
+        [LocalizedDescription("DockPanel_DefaultFloatWindowSize_Description")]
+        public Size DefaultFloatWindowSize
+        {
+            get { return m_defaultFloatWindowSize; }
+            set { m_defaultFloatWindowSize = value; }
+        }
+        private bool ShouldSerializeDefaultFloatWindowSize()
+        {
+            return DefaultFloatWindowSize != new Size(300, 300);
+        }
+        private void ResetDefaultFloatWindowSize()
+        {
+            DefaultFloatWindowSize = new Size(300, 300);
+        }
+
+    private DocumentStyle m_documentStyle = DocumentStyle.DockingMdi;
+    [LocalizedCategory("Category_Docking")]
+    [LocalizedDescription("DockPanel_DocumentStyle_Description")]
+    [DefaultValue(DocumentStyle.DockingMdi)]
+    public DocumentStyle DocumentStyle
+    {
+      get { return m_documentStyle; }
+      set
+      {
+        if (value == m_documentStyle)
+          return;
+
+        if (!Enum.IsDefined(typeof(DocumentStyle), value))
+          throw new InvalidEnumArgumentException();
+
+        if (value == DocumentStyle.SystemMdi && DockWindows[DockState.Document].VisibleNestedPanes.Count > 0)
+          throw new InvalidEnumArgumentException();
+
+        m_documentStyle = value;
+
+        SuspendLayout(true);
+
+                SetAutoHideWindowParent();
+        SetMdiClient();
+        InvalidateWindowRegion();
+
+        foreach (IDockContent content in Contents)
+        {
+          if (content.DockHandler.DockState == DockState.Document)
+            content.DockHandler.SetPaneAndVisible(content.DockHandler.Pane);
+        }
+
+                PerformMdiClientLayout();
+
+        ResumeLayout(true, true);
+      }
+    }
+
+        private bool _supprtDeeplyNestedContent = false;
+        [LocalizedCategory("Category_Performance")]
+        [LocalizedDescription("DockPanel_SupportDeeplyNestedContent_Description")]
+        [DefaultValue(false)]
+        public bool SupportDeeplyNestedContent
+        {
+            get { return _supprtDeeplyNestedContent; }
+            set { _supprtDeeplyNestedContent = value; }
+        }
+
+        private int GetDockWindowSize(DockState dockState)
+        {
+            if (dockState == DockState.DockLeft || dockState == DockState.DockRight)
+            {
+                int width = ClientRectangle.Width - DockPadding.Left - DockPadding.Right;
+                int dockLeftSize = m_dockLeftPortion >= 1 ? (int)m_dockLeftPortion : (int)(width * m_dockLeftPortion);
+                int dockRightSize = m_dockRightPortion >= 1 ? (int)m_dockRightPortion : (int)(width * m_dockRightPortion);
+
+                if (dockLeftSize < MeasurePane.MinSize)
+                    dockLeftSize = MeasurePane.MinSize;
+                if (dockRightSize < MeasurePane.MinSize)
+                    dockRightSize = MeasurePane.MinSize;
+
+                if (dockLeftSize + dockRightSize > width - MeasurePane.MinSize)
+                {
+                    int adjust = (dockLeftSize + dockRightSize) - (width - MeasurePane.MinSize);
+                    dockLeftSize -= adjust / 2;
+                    dockRightSize -= adjust / 2;
+                }
+
+                return dockState == DockState.DockLeft ? dockLeftSize : dockRightSize;
+            }
+            else if (dockState == DockState.DockTop || dockState == DockState.DockBottom)
+            {
+                int height = ClientRectangle.Height - DockPadding.Top - DockPadding.Bottom;
+                int dockTopSize = m_dockTopPortion >= 1 ? (int)m_dockTopPortion : (int)(height * m_dockTopPortion);
+                int dockBottomSize = m_dockBottomPortion >= 1 ? (int)m_dockBottomPortion : (int)(height * m_dockBottomPortion);
+
+                if (dockTopSize < MeasurePane.MinSize)
+                    dockTopSize = MeasurePane.MinSize;
+                if (dockBottomSize < MeasurePane.MinSize)
+                    dockBottomSize = MeasurePane.MinSize;
+
+                if (dockTopSize + dockBottomSize > height - MeasurePane.MinSize)
+                {
+                    int adjust = (dockTopSize + dockBottomSize) - (height - MeasurePane.MinSize);
+                    dockTopSize -= adjust / 2;
+                    dockBottomSize -= adjust / 2;
+                }
+
+                return dockState == DockState.DockTop ? dockTopSize : dockBottomSize;
+            }
+            else
+                return 0;
+        }
+
+        protected override void OnLayout(LayoutEventArgs levent)
+    {
+      SuspendLayout(true);
+
+      AutoHideStripControl.Bounds = ClientRectangle;
+
+      CalculateDockPadding();
+
+            DockWindows[DockState.DockLeft].Width = GetDockWindowSize(DockState.DockLeft);
+      DockWindows[DockState.DockRight].Width = GetDockWindowSize(DockState.DockRight);
+      DockWindows[DockState.DockTop].Height = GetDockWindowSize(DockState.DockTop);
+      DockWindows[DockState.DockBottom].Height = GetDockWindowSize(DockState.DockBottom);
+
+      AutoHideWindow.Bounds = GetAutoHideWindowBounds(AutoHideWindowRectangle);
+
+      DockWindows[DockState.Document].BringToFront();
+      AutoHideWindow.BringToFront();
+
+      base.OnLayout(levent);
+
+            if (DocumentStyle == DocumentStyle.SystemMdi && MdiClientExists)
+            {
+                SetMdiClientBounds(SystemMdiClientBounds);
+                InvalidateWindowRegion();
+            }
+            else if (DocumentStyle == DocumentStyle.DockingMdi)
+                InvalidateWindowRegion();
+
+      ResumeLayout(true, true);
+    }
+
+    internal Rectangle GetTabStripRectangle(DockState dockState)
+    {
+      return AutoHideStripControl.GetTabStripRectangle(dockState);
+    }
+
+    protected override void OnPaint(PaintEventArgs e)
+    {
+      base.OnPaint(e);
+
+        if (DockBackColor == BackColor) return;
+
+        Graphics g = e.Graphics;
+        SolidBrush bgBrush = new SolidBrush(DockBackColor);
+        g.FillRectangle(bgBrush, ClientRectangle);
+    }
+
+    internal void AddContent(IDockContent content)
+    {
+      if (content == null)
+        throw(new ArgumentNullException());
+
+      if (!Contents.Contains(content))
+      {
+        Contents.Add(content);
+        OnContentAdded(new DockContentEventArgs(content));
+      }
+    }
+
+    internal void AddPane(DockPane pane)
+    {
+      if (Panes.Contains(pane))
+        return;
+
+      Panes.Add(pane);
+    }
+
+    internal void AddFloatWindow(FloatWindow floatWindow)
+    {
+      if (FloatWindows.Contains(floatWindow))
+        return;
+
+      FloatWindows.Add(floatWindow);
+    }
+
+    private void CalculateDockPadding()
+    {
+      DockPadding.All = 0;
+
+      int height = AutoHideStripControl.MeasureHeight();
+
+      if (AutoHideStripControl.GetNumberOfPanes(DockState.DockLeftAutoHide) > 0)
+        DockPadding.Left = height;
+      if (AutoHideStripControl.GetNumberOfPanes(DockState.DockRightAutoHide) > 0)
+        DockPadding.Right = height;
+      if (AutoHideStripControl.GetNumberOfPanes(DockState.DockTopAutoHide) > 0)
+        DockPadding.Top = height;
+      if (AutoHideStripControl.GetNumberOfPanes(DockState.DockBottomAutoHide) > 0)
+        DockPadding.Bottom = height;
+    }
+
+    internal void RemoveContent(IDockContent content)
+    {
+      if (content == null)
+        throw(new ArgumentNullException());
+      
+      if (Contents.Contains(content))
+      {
+        Contents.Remove(content);
+        OnContentRemoved(new DockContentEventArgs(content));
+      }
+    }
+
+    internal void RemovePane(DockPane pane)
+    {
+      if (!Panes.Contains(pane))
+        return;
+
+      Panes.Remove(pane);
+    }
+
+    internal void RemoveFloatWindow(FloatWindow floatWindow)
+    {
+      if (!FloatWindows.Contains(floatWindow))
+        return;
+
+      FloatWindows.Remove(floatWindow);
+    }
+
+    public void SetPaneIndex(DockPane pane, int index)
+    {
+      int oldIndex = Panes.IndexOf(pane);
+      if (oldIndex == -1)
+        throw(new ArgumentException(Strings.DockPanel_SetPaneIndex_InvalidPane));
+
+      if (index < 0 || index > Panes.Count - 1)
+        if (index != -1)
+          throw(new ArgumentOutOfRangeException(Strings.DockPanel_SetPaneIndex_InvalidIndex));
+        
+      if (oldIndex == index)
+        return;
+      if (oldIndex == Panes.Count - 1 && index == -1)
+        return;
+
+      Panes.Remove(pane);
+      if (index == -1)
+        Panes.Add(pane);
+      else if (oldIndex < index)
+        Panes.AddAt(pane, index - 1);
+      else
+        Panes.AddAt(pane, index);
+    }
+
+    public void SuspendLayout(bool allWindows)
+    {
+            FocusManager.SuspendFocusTracking();
+      SuspendLayout();
+      if (allWindows)
+        SuspendMdiClientLayout();
+    }
+
+    public void ResumeLayout(bool performLayout, bool allWindows)
+    {
+            FocusManager.ResumeFocusTracking();
+            ResumeLayout(performLayout);
+            if (allWindows)
+                ResumeMdiClientLayout(performLayout);
+    }
+
+      internal Form ParentForm
+    {
+      get
+      { 
+        if (!IsParentFormValid())
+          throw new InvalidOperationException(Strings.DockPanel_ParentForm_Invalid);
+
+        return GetMdiClientController().ParentForm;
+      }
+    }
+
+    private bool IsParentFormValid()
+    {
+      if (DocumentStyle == DocumentStyle.DockingSdi || DocumentStyle == DocumentStyle.DockingWindow)
+        return true;
+
+            if (!MdiClientExists)
+                GetMdiClientController().RenewMdiClient();
+
+            return (MdiClientExists);
+    }
+
+    protected override void OnParentChanged(EventArgs e)
+    {
+            SetAutoHideWindowParent();
+            GetMdiClientController().ParentForm = (this.Parent as Form);
+      base.OnParentChanged (e);
+    }
+
+        private void SetAutoHideWindowParent()
+        {
+            Control parent;
+            if (DocumentStyle == DocumentStyle.DockingMdi ||
+                DocumentStyle == DocumentStyle.SystemMdi)
+                parent = this.Parent;
+            else
+                parent = this;
+            if (AutoHideWindow.Parent != parent)
+            {
+                AutoHideWindow.Parent = parent;
+                AutoHideWindow.BringToFront();
+            }
+        }
+
+    protected override void OnVisibleChanged(EventArgs e)
+    {
+      base.OnVisibleChanged (e);
+
+      if (Visible)
+        SetMdiClient();
+    }
+
+    private Rectangle SystemMdiClientBounds
+    {
+      get
+      {
+        if (!IsParentFormValid() || !Visible)
+          return Rectangle.Empty;
+
+        Rectangle rect = ParentForm.RectangleToClient(RectangleToScreen(DocumentWindowBounds));
+        return rect;
+      }
+    }
+
+    internal Rectangle DocumentWindowBounds
+    {
+      get
+      {
+        Rectangle rectDocumentBounds = DisplayRectangle;
+        if (DockWindows[DockState.DockLeft].Visible)
+        {
+          rectDocumentBounds.X += DockWindows[DockState.DockLeft].Width;
+          rectDocumentBounds.Width -= DockWindows[DockState.DockLeft].Width;
+        }
+        if (DockWindows[DockState.DockRight].Visible)
+          rectDocumentBounds.Width -= DockWindows[DockState.DockRight].Width;
+        if (DockWindows[DockState.DockTop].Visible)
+        {
+          rectDocumentBounds.Y += DockWindows[DockState.DockTop].Height;
+          rectDocumentBounds.Height -= DockWindows[DockState.DockTop].Height;
+        }
+        if (DockWindows[DockState.DockBottom].Visible)
+          rectDocumentBounds.Height -= DockWindows[DockState.DockBottom].Height;
+
+        return rectDocumentBounds;
+
+      }
+    }
+
+        private PaintEventHandler m_dummyControlPaintEventHandler = null;
+        private void InvalidateWindowRegion()
+        {
+            if (DesignMode)
+                return;
+
+            if (m_dummyControlPaintEventHandler == null)
+                m_dummyControlPaintEventHandler = new PaintEventHandler(DummyControl_Paint);
+
+            DummyControl.Paint += m_dummyControlPaintEventHandler;
+            DummyControl.Invalidate();
+        }
+
+        void DummyControl_Paint(object sender, PaintEventArgs e)
+        {
+            DummyControl.Paint -= m_dummyControlPaintEventHandler;
+            UpdateWindowRegion();
+        }
+
+    private void UpdateWindowRegion()
+    {
+      if (this.DocumentStyle == DocumentStyle.DockingMdi)
+        UpdateWindowRegion_ClipContent();
+      else if (this.DocumentStyle == DocumentStyle.DockingSdi ||
+        this.DocumentStyle == DocumentStyle.DockingWindow)
+        UpdateWindowRegion_FullDocumentArea();
+      else if (this.DocumentStyle == DocumentStyle.SystemMdi)
+        UpdateWindowRegion_EmptyDocumentArea();
+    }
+
+    private void UpdateWindowRegion_FullDocumentArea()
+    {
+      SetRegion(null);
+    }
+
+    private void UpdateWindowRegion_EmptyDocumentArea()
+    {
+      Rectangle rect = DocumentWindowBounds;
+      SetRegion(new Rectangle[] { rect });
+    }
+
+    private void UpdateWindowRegion_ClipContent()
+    {
+      int count = 0;
+      foreach (DockPane pane in this.Panes)
+      {
+        if (!pane.Visible || pane.DockState != DockState.Document)
+          continue;
+
+        count ++;
+      }
+
+            if (count == 0)
+            {
+                SetRegion(null);
+                return;
+            }
+
+      Rectangle[] rects = new Rectangle[count];
+      int i = 0;
+      foreach (DockPane pane in this.Panes)
+      {
+        if (!pane.Visible || pane.DockState != DockState.Document)
+          continue;
+
+                rects[i] = RectangleToClient(pane.RectangleToScreen(pane.ContentRectangle));
+        i++;
+      }
+
+      SetRegion(rects);
+    }
+
+    private Rectangle[] m_clipRects = null;
+    private void SetRegion(Rectangle[] clipRects)
+    {
+      if (!IsClipRectsChanged(clipRects))
+        return;
+
+      m_clipRects = clipRects;
+
+      if (m_clipRects == null || m_clipRects.GetLength(0) == 0)
+        Region = null;
+      else
+      {
+        Region region = new Region(new Rectangle(0, 0, this.Width, this.Height));
+        foreach (Rectangle rect in m_clipRects)
+          region.Exclude(rect);
+        Region = region;
+      }
+    }
+
+    private bool IsClipRectsChanged(Rectangle[] clipRects)
+    {
+      if (clipRects == null && m_clipRects == null)
+        return false;
+      else if ((clipRects == null) != (m_clipRects == null))
+        return true;
+
+      foreach (Rectangle rect in clipRects)
+      {
+        bool matched = false;
+        foreach (Rectangle rect2 in m_clipRects)
+        {
+          if (rect == rect2)
+          {
+            matched = true;
+            break;
+          }
+        }
+        if (!matched)
+          return true;
+      }
+
+      foreach (Rectangle rect2 in m_clipRects)
+      {
+        bool matched = false;
+        foreach (Rectangle rect in clipRects)
+        {
+          if (rect == rect2)
+          {
+            matched = true;
+            break;
+          }
+        }
+        if (!matched)
+          return true;
+      }
+      return false;
+    }
+
+    private static readonly object ContentAddedEvent = new object();
+    [LocalizedCategory("Category_DockingNotification")]
+    [LocalizedDescription("DockPanel_ContentAdded_Description")]
+    public event EventHandler<DockContentEventArgs> ContentAdded
+    {
+      add { Events.AddHandler(ContentAddedEvent, value);  }
+      remove  { Events.RemoveHandler(ContentAddedEvent, value); }
+    }
+    protected virtual void OnContentAdded(DockContentEventArgs e)
+    {
+      EventHandler<DockContentEventArgs> handler = (EventHandler<DockContentEventArgs>)Events[ContentAddedEvent];
+      if (handler != null)
+        handler(this, e);
+    }
+
+    private static readonly object ContentRemovedEvent = new object();
+    [LocalizedCategory("Category_DockingNotification")]
+    [LocalizedDescription("DockPanel_ContentRemoved_Description")]
+    public event EventHandler<DockContentEventArgs> ContentRemoved
+    {
+      add { Events.AddHandler(ContentRemovedEvent, value);  }
+      remove  { Events.RemoveHandler(ContentRemovedEvent, value); }
+    }
+    protected virtual void OnContentRemoved(DockContentEventArgs e)
+    {
+      EventHandler<DockContentEventArgs> handler = (EventHandler<DockContentEventArgs>)Events[ContentRemovedEvent];
+      if (handler != null)
+        handler(this, e);
+    }
     }
-
-    private Color m_BackColor;
-    /// <summary>
-    /// Determines the color with which the client rectangle will be drawn.
-    /// If this property is used instead of the BackColor it will not have any influence on the borders to the surrounding controls (DockPane).
-    /// The BackColor property changes the borders of surrounding controls (DockPane).
-    /// Alternatively both properties may be used (BackColor to draw and define the color of the borders and DockBackColor to define the color of the client rectangle). 
-    /// For Backgroundimages: Set your prefered Image, then set the DockBackColor and the BackColor to the same Color (Control)
-    /// </summary>
-    [Description("Determines the color with which the client rectangle will be drawn.\r\n" +
-        "If this property is used instead of the BackColor it will not have any influence on the borders to the surrounding controls (DockPane).\r\n" +
-        "The BackColor property changes the borders of surrounding controls (DockPane).\r\n" +
-        "Alternatively both properties may be used (BackColor to draw and define the color of the borders and DockBackColor to define the color of the client rectangle).\r\n" +
-        "For Backgroundimages: Set your prefered Image, then set the DockBackColor and the BackColor to the same Color (Control).")]
-    public Color DockBackColor {
-      get {
-        return !m_BackColor.IsEmpty ? m_BackColor : base.BackColor;
-      }
-      set {
-        if (m_BackColor != value) {
-          m_BackColor = value;
-          this.Refresh();
-        }
-      }
-    }
-
-    private bool ShouldSerializeDockBackColor() {
-      return !m_BackColor.IsEmpty;
-    }
-
-    private void ResetDockBackColor() {
-      DockBackColor = Color.Empty;
-    }
-
-    private AutoHideStripBase m_autoHideStripControl = null;
-    internal AutoHideStripBase AutoHideStripControl {
-      get {
-        if (m_autoHideStripControl == null) {
-          m_autoHideStripControl = AutoHideStripFactory.CreateAutoHideStrip(this);
-          Controls.Add(m_autoHideStripControl);
-        }
-        return m_autoHideStripControl;
-      }
-    }
-    internal void ResetAutoHideStripControl() {
-      if (m_autoHideStripControl != null)
-        m_autoHideStripControl.Dispose();
-
-      m_autoHideStripControl = null;
-    }
-
-    private void MdiClientHandleAssigned(object sender, EventArgs e) {
-      SetMdiClient();
-      PerformLayout();
-    }
-
-    private void MdiClient_Layout(object sender, LayoutEventArgs e) {
-      if (DocumentStyle != DocumentStyle.DockingMdi)
-        return;
-
-      foreach (DockPane pane in Panes)
-        if (pane.DockState == DockState.Document)
-          pane.SetContentBounds();
-
-      InvalidateWindowRegion();
-    }
-
-    private bool m_disposed = false;
-    protected override void Dispose(bool disposing) {
-      lock (this) {
-        if (!m_disposed && disposing) {
-          m_focusManager.Dispose();
-          if (m_mdiClientController != null) {
-            m_mdiClientController.HandleAssigned -= new EventHandler(MdiClientHandleAssigned);
-            m_mdiClientController.MdiChildActivate -= new EventHandler(ParentFormMdiChildActivate);
-            m_mdiClientController.Layout -= new LayoutEventHandler(MdiClient_Layout);
-            m_mdiClientController.Dispose();
-          }
-          FloatWindows.Dispose();
-          Panes.Dispose();
-          DummyContent.Dispose();
-
-          foreach (var dw in m_dockWindows) {
-            dw.Dispose();
-          }
-          m_dockWindows = null;
-
-          m_disposed = true;
-        }
-
-        base.Dispose(disposing);
-      }
-    }
-
-    [Browsable(false)]
-    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
-    public IDockContent ActiveAutoHideContent {
-      get { return AutoHideWindow.ActiveContent; }
-      set { AutoHideWindow.ActiveContent = value; }
-    }
-
-    private bool m_allowEndUserDocking = !Win32Helper.IsRunningOnMono;
-    [LocalizedCategory("Category_Docking")]
-    [LocalizedDescription("DockPanel_AllowEndUserDocking_Description")]
-    [DefaultValue(true)]
-    public bool AllowEndUserDocking {
-      get {
-        if (Win32Helper.IsRunningOnMono && m_allowEndUserDocking)
-          m_allowEndUserDocking = false;
-
-        return m_allowEndUserDocking;
-      }
-      set {
-        if (Win32Helper.IsRunningOnMono && value)
-          throw new InvalidOperationException("AllowEndUserDocking can only be false if running on Mono");
-
-        m_allowEndUserDocking = value;
-      }
-    }
-
-    private bool m_allowEndUserNestedDocking = !Win32Helper.IsRunningOnMono;
-    [LocalizedCategory("Category_Docking")]
-    [LocalizedDescription("DockPanel_AllowEndUserNestedDocking_Description")]
-    [DefaultValue(true)]
-    public bool AllowEndUserNestedDocking {
-      get {
-        if (Win32Helper.IsRunningOnMono && m_allowEndUserDocking)
-          m_allowEndUserDocking = false;
-        return m_allowEndUserNestedDocking;
-      }
-      set {
-        if (Win32Helper.IsRunningOnMono && value)
-          throw new InvalidOperationException("AllowEndUserNestedDocking can only be false if running on Mono");
-
-        m_allowEndUserNestedDocking = value;
-      }
-    }
-
-    private DockContentCollection m_contents = new DockContentCollection();
-    [Browsable(false)]
-    public DockContentCollection Contents {
-      get { return m_contents; }
-    }
-
-    internal DockContent DummyContent {
-      get { return m_dummyContent; }
-    }
-
-    private bool m_rightToLeftLayout = false;
-    [DefaultValue(false)]
-    [LocalizedCategory("Appearance")]
-    [LocalizedDescription("DockPanel_RightToLeftLayout_Description")]
-    public bool RightToLeftLayout {
-      get { return m_rightToLeftLayout; }
-      set {
-        if (m_rightToLeftLayout == value)
-          return;
-
-        m_rightToLeftLayout = value;
-        foreach (FloatWindow floatWindow in FloatWindows)
-          floatWindow.RightToLeftLayout = value;
-      }
-    }
-
-    protected override void OnRightToLeftChanged(EventArgs e) {
-      base.OnRightToLeftChanged(e);
-      foreach (FloatWindow floatWindow in FloatWindows) {
-        if (floatWindow.RightToLeft != RightToLeft)
-          floatWindow.RightToLeft = RightToLeft;
-      }
-    }
-
-    private bool m_showDocumentIcon = false;
-    [DefaultValue(false)]
-    [LocalizedCategory("Category_Docking")]
-    [LocalizedDescription("DockPanel_ShowDocumentIcon_Description")]
-    public bool ShowDocumentIcon {
-      get { return m_showDocumentIcon; }
-      set {
-        if (m_showDocumentIcon == value)
-          return;
-
-        m_showDocumentIcon = value;
-        Refresh();
-      }
-    }
-
-    private DocumentTabStripLocation m_documentTabStripLocation = DocumentTabStripLocation.Top;
-    [DefaultValue(DocumentTabStripLocation.Top)]
-    [LocalizedCategory("Category_Docking")]
-    [LocalizedDescription("DockPanel_DocumentTabStripLocation")]
-    public DocumentTabStripLocation DocumentTabStripLocation {
-      get { return m_documentTabStripLocation; }
-      set { m_documentTabStripLocation = value; }
-    }
-
-    [Browsable(false)]
-    public DockPanelExtender Extender {
-      get { return m_extender; }
-    }
-
-    [Browsable(false)]
-    public DockPanelExtender.IDockPaneFactory DockPaneFactory {
-      get { return Extender.DockPaneFactory; }
-    }
-
-    [Browsable(false)]
-    public DockPanelExtender.IFloatWindowFactory FloatWindowFactory {
-      get { return Extender.FloatWindowFactory; }
-    }
-
-    internal DockPanelExtender.IDockPaneCaptionFactory DockPaneCaptionFactory {
-      get { return Extender.DockPaneCaptionFactory; }
-    }
-
-    internal DockPanelExtender.IDockPaneStripFactory DockPaneStripFactory {
-      get { return Extender.DockPaneStripFactory; }
-    }
-
-    internal DockPanelExtender.IAutoHideStripFactory AutoHideStripFactory {
-      get { return Extender.AutoHideStripFactory; }
-    }
-
-    [Browsable(false)]
-    public DockPaneCollection Panes {
-      get { return m_panes; }
-    }
-
-    internal Rectangle DockArea {
-      get {
-        return new Rectangle(DockPadding.Left, DockPadding.Top,
-          ClientRectangle.Width - DockPadding.Left - DockPadding.Right,
-          ClientRectangle.Height - DockPadding.Top - DockPadding.Bottom);
-      }
-    }
-
-    private double m_dockBottomPortion = 0.25;
-    [LocalizedCategory("Category_Docking")]
-    [LocalizedDescription("DockPanel_DockBottomPortion_Description")]
-    [DefaultValue(0.25)]
-    public double DockBottomPortion {
-      get { return m_dockBottomPortion; }
-      set {
-        if (value <= 0)
-          throw new ArgumentOutOfRangeException("value");
-
-        if (value == m_dockBottomPortion)
-          return;
-
-        m_dockBottomPortion = value;
-
-        if (m_dockBottomPortion < 1 && m_dockTopPortion < 1) {
-          if (m_dockTopPortion + m_dockBottomPortion > 1)
-            m_dockTopPortion = 1 - m_dockBottomPortion;
-        }
-
-        PerformLayout();
-      }
-    }
-
-    private double m_dockLeftPortion = 0.25;
-    [LocalizedCategory("Category_Docking")]
-    [LocalizedDescription("DockPanel_DockLeftPortion_Description")]
-    [DefaultValue(0.25)]
-    public double DockLeftPortion {
-      get { return m_dockLeftPortion; }
-      set {
-        if (value <= 0)
-          throw new ArgumentOutOfRangeException("value");
-
-        if (value == m_dockLeftPortion)
-          return;
-
-        m_dockLeftPortion = value;
-
-        if (m_dockLeftPortion < 1 && m_dockRightPortion < 1) {
-          if (m_dockLeftPortion + m_dockRightPortion > 1)
-            m_dockRightPortion = 1 - m_dockLeftPortion;
-        }
-        PerformLayout();
-      }
-    }
-
-    private double m_dockRightPortion = 0.25;
-    [LocalizedCategory("Category_Docking")]
-    [LocalizedDescription("DockPanel_DockRightPortion_Description")]
-    [DefaultValue(0.25)]
-    public double DockRightPortion {
-      get { return m_dockRightPortion; }
-      set {
-        if (value <= 0)
-          throw new ArgumentOutOfRangeException("value");
-
-        if (value == m_dockRightPortion)
-          return;
-
-        m_dockRightPortion = value;
-
-        if (m_dockLeftPortion < 1 && m_dockRightPortion < 1) {
-          if (m_dockLeftPortion + m_dockRightPortion > 1)
-            m_dockLeftPortion = 1 - m_dockRightPortion;
-        }
-        PerformLayout();
-      }
-    }
-
-    private double m_dockTopPortion = 0.25;
-    [LocalizedCategory("Category_Docking")]
-    [LocalizedDescription("DockPanel_DockTopPortion_Description")]
-    [DefaultValue(0.25)]
-    public double DockTopPortion {
-      get { return m_dockTopPortion; }
-      set {
-        if (value <= 0)
-          throw new ArgumentOutOfRangeException("value");
-
-        if (value == m_dockTopPortion)
-          return;
-
-        m_dockTopPortion = value;
-
-        if (m_dockTopPortion < 1 && m_dockBottomPortion < 1) {
-          if (m_dockTopPortion + m_dockBottomPortion > 1)
-            m_dockBottomPortion = 1 - m_dockTopPortion;
-        }
-        PerformLayout();
-      }
-    }
-
-    [Browsable(false)]
-    public DockWindowCollection DockWindows {
-      get { return m_dockWindows; }
-    }
-
-    public void UpdateDockWindowZOrder(DockStyle dockStyle, bool fullPanelEdge) {
-      if (dockStyle == DockStyle.Left) {
-        if (fullPanelEdge)
-          DockWindows[DockState.DockLeft].SendToBack();
-        else
-          DockWindows[DockState.DockLeft].BringToFront();
-      } else if (dockStyle == DockStyle.Right) {
-        if (fullPanelEdge)
-          DockWindows[DockState.DockRight].SendToBack();
-        else
-          DockWindows[DockState.DockRight].BringToFront();
-      } else if (dockStyle == DockStyle.Top) {
-        if (fullPanelEdge)
-          DockWindows[DockState.DockTop].SendToBack();
-        else
-          DockWindows[DockState.DockTop].BringToFront();
-      } else if (dockStyle == DockStyle.Bottom) {
-        if (fullPanelEdge)
-          DockWindows[DockState.DockBottom].SendToBack();
-        else
-          DockWindows[DockState.DockBottom].BringToFront();
-      }
-    }
-
-    [Browsable(false)]
-    public int DocumentsCount {
-      get {
-        int count = 0;
-        foreach (IDockContent content in Documents)
-          count++;
-
-        return count;
-      }
-    }
-
-    public IDockContent[] DocumentsToArray() {
-      int count = DocumentsCount;
-      IDockContent[] documents = new IDockContent[count];
-      int i = 0;
-      foreach (IDockContent content in Documents) {
-        documents[i] = content;
-        i++;
-      }
-
-      return documents;
-    }
-
-    [Browsable(false)]
-    public IEnumerable<IDockContent> Documents {
-      get {
-        foreach (IDockContent content in Contents) {
-          if (content.DockHandler.DockState == DockState.Document)
-            yield return content;
-        }
-      }
-    }
-
-    private Rectangle DocumentRectangle {
-      get {
-        Rectangle rect = DockArea;
-        if (DockWindows[DockState.DockLeft].VisibleNestedPanes.Count != 0) {
-          rect.X += (int)(DockArea.Width * DockLeftPortion);
-          rect.Width -= (int)(DockArea.Width * DockLeftPortion);
-        }
-        if (DockWindows[DockState.DockRight].VisibleNestedPanes.Count != 0)
-          rect.Width -= (int)(DockArea.Width * DockRightPortion);
-        if (DockWindows[DockState.DockTop].VisibleNestedPanes.Count != 0) {
-          rect.Y += (int)(DockArea.Height * DockTopPortion);
-          rect.Height -= (int)(DockArea.Height * DockTopPortion);
-        }
-        if (DockWindows[DockState.DockBottom].VisibleNestedPanes.Count != 0)
-          rect.Height -= (int)(DockArea.Height * DockBottomPortion);
-
-        return rect;
-      }
-    }
-
-    private Control DummyControl {
-      get { return m_dummyControl; }
-    }
-
-    [Browsable(false)]
-    public FloatWindowCollection FloatWindows {
-      get { return m_floatWindows; }
-    }
-
-    private Size m_defaultFloatWindowSize = new Size(300, 300);
-    [Category("Layout")]
-    [LocalizedDescription("DockPanel_DefaultFloatWindowSize_Description")]
-    public Size DefaultFloatWindowSize {
-      get { return m_defaultFloatWindowSize; }
-      set { m_defaultFloatWindowSize = value; }
-    }
-    private bool ShouldSerializeDefaultFloatWindowSize() {
-      return DefaultFloatWindowSize != new Size(300, 300);
-    }
-    private void ResetDefaultFloatWindowSize() {
-      DefaultFloatWindowSize = new Size(300, 300);
-    }
-
-    private DocumentStyle m_documentStyle = DocumentStyle.DockingMdi;
-    [LocalizedCategory("Category_Docking")]
-    [LocalizedDescription("DockPanel_DocumentStyle_Description")]
-    [DefaultValue(DocumentStyle.DockingMdi)]
-    public DocumentStyle DocumentStyle {
-      get { return m_documentStyle; }
-      set {
-        if (value == m_documentStyle)
-          return;
-
-        if (!Enum.IsDefined(typeof(DocumentStyle), value))
-          throw new InvalidEnumArgumentException();
-
-        if (value == DocumentStyle.SystemMdi && DockWindows[DockState.Document].VisibleNestedPanes.Count > 0)
-          throw new InvalidEnumArgumentException();
-
-        m_documentStyle = value;
-
-        SuspendLayout(true);
-
-        SetAutoHideWindowParent();
-        SetMdiClient();
-        InvalidateWindowRegion();
-
-        foreach (IDockContent content in Contents) {
-          if (content.DockHandler.DockState == DockState.Document)
-            content.DockHandler.SetPaneAndVisible(content.DockHandler.Pane);
-        }
-
-        PerformMdiClientLayout();
-
-        ResumeLayout(true, true);
-      }
-    }
-
-    private bool _supprtDeeplyNestedContent = false;
-    [LocalizedCategory("Category_Performance")]
-    [LocalizedDescription("DockPanel_SupportDeeplyNestedContent_Description")]
-    [DefaultValue(false)]
-    public bool SupportDeeplyNestedContent {
-      get { return _supprtDeeplyNestedContent; }
-      set { _supprtDeeplyNestedContent = value; }
-    }
-
-    private int GetDockWindowSize(DockState dockState) {
-      if (dockState == DockState.DockLeft || dockState == DockState.DockRight) {
-        int width = ClientRectangle.Width - DockPadding.Left - DockPadding.Right;
-        int dockLeftSize = m_dockLeftPortion >= 1 ? (int)m_dockLeftPortion : (int)(width * m_dockLeftPortion);
-        int dockRightSize = m_dockRightPortion >= 1 ? (int)m_dockRightPortion : (int)(width * m_dockRightPortion);
-
-        if (dockLeftSize < MeasurePane.MinSize)
-          dockLeftSize = MeasurePane.MinSize;
-        if (dockRightSize < MeasurePane.MinSize)
-          dockRightSize = MeasurePane.MinSize;
-
-        if (dockLeftSize + dockRightSize > width - MeasurePane.MinSize) {
-          int adjust = (dockLeftSize + dockRightSize) - (width - MeasurePane.MinSize);
-          dockLeftSize -= adjust / 2;
-          dockRightSize -= adjust / 2;
-        }
-
-        return dockState == DockState.DockLeft ? dockLeftSize : dockRightSize;
-      } else if (dockState == DockState.DockTop || dockState == DockState.DockBottom) {
-        int height = ClientRectangle.Height - DockPadding.Top - DockPadding.Bottom;
-        int dockTopSize = m_dockTopPortion >= 1 ? (int)m_dockTopPortion : (int)(height * m_dockTopPortion);
-        int dockBottomSize = m_dockBottomPortion >= 1 ? (int)m_dockBottomPortion : (int)(height * m_dockBottomPortion);
-
-        if (dockTopSize < MeasurePane.MinSize)
-          dockTopSize = MeasurePane.MinSize;
-        if (dockBottomSize < MeasurePane.MinSize)
-          dockBottomSize = MeasurePane.MinSize;
-
-        if (dockTopSize + dockBottomSize > height - MeasurePane.MinSize) {
-          int adjust = (dockTopSize + dockBottomSize) - (height - MeasurePane.MinSize);
-          dockTopSize -= adjust / 2;
-          dockBottomSize -= adjust / 2;
-        }
-
-        return dockState == DockState.DockTop ? dockTopSize : dockBottomSize;
-      } else
-        return 0;
-    }
-
-    protected override void OnLayout(LayoutEventArgs levent) {
-      SuspendLayout(true);
-
-      AutoHideStripControl.Bounds = ClientRectangle;
-
-      CalculateDockPadding();
-
-      DockWindows[DockState.DockLeft].Width = GetDockWindowSize(DockState.DockLeft);
-      DockWindows[DockState.DockRight].Width = GetDockWindowSize(DockState.DockRight);
-      DockWindows[DockState.DockTop].Height = GetDockWindowSize(DockState.DockTop);
-      DockWindows[DockState.DockBottom].Height = GetDockWindowSize(DockState.DockBottom);
-
-      AutoHideWindow.Bounds = GetAutoHideWindowBounds(AutoHideWindowRectangle);
-
-      DockWindows[DockState.Document].BringToFront();
-      AutoHideWindow.BringToFront();
-
-      base.OnLayout(levent);
-
-      if (DocumentStyle == DocumentStyle.SystemMdi && MdiClientExists) {
-        SetMdiClientBounds(SystemMdiClientBounds);
-        InvalidateWindowRegion();
-      } else if (DocumentStyle == DocumentStyle.DockingMdi)
-        InvalidateWindowRegion();
-
-      ResumeLayout(true, true);
-    }
-
-    internal Rectangle GetTabStripRectangle(DockState dockState) {
-      return AutoHideStripControl.GetTabStripRectangle(dockState);
-    }
-
-    protected override void OnPaint(PaintEventArgs e) {
-      base.OnPaint(e);
-
-      if (DockBackColor == BackColor) return;
-
-      Graphics g = e.Graphics;
-      SolidBrush bgBrush = new SolidBrush(DockBackColor);
-      g.FillRectangle(bgBrush, ClientRectangle);
-    }
-
-    internal void AddContent(IDockContent content) {
-      if (content == null)
-        throw (new ArgumentNullException());
-
-      if (!Contents.Contains(content)) {
-        Contents.Add(content);
-        OnContentAdded(new DockContentEventArgs(content));
-      }
-    }
-
-    internal void AddPane(DockPane pane) {
-      if (Panes.Contains(pane))
-        return;
-
-      Panes.Add(pane);
-    }
-
-    internal void AddFloatWindow(FloatWindow floatWindow) {
-      if (FloatWindows.Contains(floatWindow))
-        return;
-
-      FloatWindows.Add(floatWindow);
-    }
-
-    private void CalculateDockPadding() {
-      DockPadding.All = 0;
-
-      int height = AutoHideStripControl.MeasureHeight();
-
-      if (AutoHideStripControl.GetNumberOfPanes(DockState.DockLeftAutoHide) > 0)
-        DockPadding.Left = height;
-      if (AutoHideStripControl.GetNumberOfPanes(DockState.DockRightAutoHide) > 0)
-        DockPadding.Right = height;
-      if (AutoHideStripControl.GetNumberOfPanes(DockState.DockTopAutoHide) > 0)
-        DockPadding.Top = height;
-      if (AutoHideStripControl.GetNumberOfPanes(DockState.DockBottomAutoHide) > 0)
-        DockPadding.Bottom = height;
-    }
-
-    internal void RemoveContent(IDockContent content) {
-      if (content == null)
-        throw (new ArgumentNullException());
-
-      if (Contents.Contains(content)) {
-        Contents.Remove(content);
-        OnContentRemoved(new DockContentEventArgs(content));
-      }
-    }
-
-    internal void RemovePane(DockPane pane) {
-      if (!Panes.Contains(pane))
-        return;
-
-      Panes.Remove(pane);
-    }
-
-    internal void RemoveFloatWindow(FloatWindow floatWindow) {
-      if (!FloatWindows.Contains(floatWindow))
-        return;
-
-      FloatWindows.Remove(floatWindow);
-    }
-
-    public void SetPaneIndex(DockPane pane, int index) {
-      int oldIndex = Panes.IndexOf(pane);
-      if (oldIndex == -1)
-        throw (new ArgumentException(Strings.DockPanel_SetPaneIndex_InvalidPane));
-
-      if (index < 0 || index > Panes.Count - 1)
-        if (index != -1)
-          throw (new ArgumentOutOfRangeException(Strings.DockPanel_SetPaneIndex_InvalidIndex));
-
-      if (oldIndex == index)
-        return;
-      if (oldIndex == Panes.Count - 1 && index == -1)
-        return;
-
-      Panes.Remove(pane);
-      if (index == -1)
-        Panes.Add(pane);
-      else if (oldIndex < index)
-        Panes.AddAt(pane, index - 1);
-      else
-        Panes.AddAt(pane, index);
-    }
-
-    public void SuspendLayout(bool allWindows) {
-      FocusManager.SuspendFocusTracking();
-      SuspendLayout();
-      if (allWindows)
-        SuspendMdiClientLayout();
-    }
-
-    public void ResumeLayout(bool performLayout, bool allWindows) {
-      FocusManager.ResumeFocusTracking();
-      ResumeLayout(performLayout);
-      if (allWindows)
-        ResumeMdiClientLayout(performLayout);
-    }
-
-    internal Form ParentForm {
-      get {
-        if (!IsParentFormValid())
-          throw new InvalidOperationException(Strings.DockPanel_ParentForm_Invalid);
-
-        return GetMdiClientController().ParentForm;
-      }
-    }
-
-    private bool IsParentFormValid() {
-      if (DocumentStyle == DocumentStyle.DockingSdi || DocumentStyle == DocumentStyle.DockingWindow)
-        return true;
-
-      if (!MdiClientExists)
-        GetMdiClientController().RenewMdiClient();
-
-      return (MdiClientExists);
-    }
-
-    protected override void OnParentChanged(EventArgs e) {
-      SetAutoHideWindowParent();
-      GetMdiClientController().ParentForm = (this.Parent as Form);
-      base.OnParentChanged(e);
-    }
-
-    private void SetAutoHideWindowParent() {
-      Control parent;
-      if (DocumentStyle == DocumentStyle.DockingMdi ||
-          DocumentStyle == DocumentStyle.SystemMdi)
-        parent = this.Parent;
-      else
-        parent = this;
-      if (AutoHideWindow.Parent != parent) {
-        AutoHideWindow.Parent = parent;
-        AutoHideWindow.BringToFront();
-      }
-    }
-
-    protected override void OnVisibleChanged(EventArgs e) {
-      base.OnVisibleChanged(e);
-
-      if (Visible)
-        SetMdiClient();
-    }
-
-    private Rectangle SystemMdiClientBounds {
-      get {
-        if (!IsParentFormValid() || !Visible)
-          return Rectangle.Empty;
-
-        Rectangle rect = ParentForm.RectangleToClient(RectangleToScreen(DocumentWindowBounds));
-        return rect;
-      }
-    }
-
-    internal Rectangle DocumentWindowBounds {
-      get {
-        Rectangle rectDocumentBounds = DisplayRectangle;
-        if (DockWindows[DockState.DockLeft].Visible) {
-          rectDocumentBounds.X += DockWindows[DockState.DockLeft].Width;
-          rectDocumentBounds.Width -= DockWindows[DockState.DockLeft].Width;
-        }
-        if (DockWindows[DockState.DockRight].Visible)
-          rectDocumentBounds.Width -= DockWindows[DockState.DockRight].Width;
-        if (DockWindows[DockState.DockTop].Visible) {
-          rectDocumentBounds.Y += DockWindows[DockState.DockTop].Height;
-          rectDocumentBounds.Height -= DockWindows[DockState.DockTop].Height;
-        }
-        if (DockWindows[DockState.DockBottom].Visible)
-          rectDocumentBounds.Height -= DockWindows[DockState.DockBottom].Height;
-
-        return rectDocumentBounds;
-
-      }
-    }
-
-    private PaintEventHandler m_dummyControlPaintEventHandler = null;
-    private void InvalidateWindowRegion() {
-      if (DesignMode)
-        return;
-
-      if (m_dummyControlPaintEventHandler == null)
-        m_dummyControlPaintEventHandler = new PaintEventHandler(DummyControl_Paint);
-
-      DummyControl.Paint += m_dummyControlPaintEventHandler;
-      DummyControl.Invalidate();
-    }
-
-    void DummyControl_Paint(object sender, PaintEventArgs e) {
-      DummyControl.Paint -= m_dummyControlPaintEventHandler;
-      UpdateWindowRegion();
-    }
-
-    private void UpdateWindowRegion() {
-      if (this.DocumentStyle == DocumentStyle.DockingMdi)
-        UpdateWindowRegion_ClipContent();
-      else if (this.DocumentStyle == DocumentStyle.DockingSdi ||
-        this.DocumentStyle == DocumentStyle.DockingWindow)
-        UpdateWindowRegion_FullDocumentArea();
-      else if (this.DocumentStyle == DocumentStyle.SystemMdi)
-        UpdateWindowRegion_EmptyDocumentArea();
-    }
-
-    private void UpdateWindowRegion_FullDocumentArea() {
-      SetRegion(null);
-    }
-
-    private void UpdateWindowRegion_EmptyDocumentArea() {
-      Rectangle rect = DocumentWindowBounds;
-      SetRegion(new Rectangle[] { rect });
-    }
-
-    private void UpdateWindowRegion_ClipContent() {
-      int count = 0;
-      foreach (DockPane pane in this.Panes) {
-        if (!pane.Visible || pane.DockState != DockState.Document)
-          continue;
-
-        count++;
-      }
-
-      if (count == 0) {
-        SetRegion(null);
-        return;
-      }
-
-      Rectangle[] rects = new Rectangle[count];
-      int i = 0;
-      foreach (DockPane pane in this.Panes) {
-        if (!pane.Visible || pane.DockState != DockState.Document)
-          continue;
-
-        rects[i] = RectangleToClient(pane.RectangleToScreen(pane.ContentRectangle));
-        i++;
-      }
-
-      SetRegion(rects);
-    }
-
-    private Rectangle[] m_clipRects = null;
-    private void SetRegion(Rectangle[] clipRects) {
-      if (!IsClipRectsChanged(clipRects))
-        return;
-
-      m_clipRects = clipRects;
-
-      if (m_clipRects == null || m_clipRects.GetLength(0) == 0)
-        Region = null;
-      else {
-        Region region = new Region(new Rectangle(0, 0, this.Width, this.Height));
-        foreach (Rectangle rect in m_clipRects)
-          region.Exclude(rect);
-        Region = region;
-      }
-    }
-
-    private bool IsClipRectsChanged(Rectangle[] clipRects) {
-      if (clipRects == null && m_clipRects == null)
-        return false;
-      else if ((clipRects == null) != (m_clipRects == null))
-        return true;
-
-      foreach (Rectangle rect in clipRects) {
-        bool matched = false;
-        foreach (Rectangle rect2 in m_clipRects) {
-          if (rect == rect2) {
-            matched = true;
-            break;
-          }
-        }
-        if (!matched)
-          return true;
-      }
-
-      foreach (Rectangle rect2 in m_clipRects) {
-        bool matched = false;
-        foreach (Rectangle rect in clipRects) {
-          if (rect == rect2) {
-            matched = true;
-            break;
-          }
-        }
-        if (!matched)
-          return true;
-      }
-      return false;
-    }
-
-    private static readonly object ContentAddedEvent = new object();
-    [LocalizedCategory("Category_DockingNotification")]
-    [LocalizedDescription("DockPanel_ContentAdded_Description")]
-    public event EventHandler<DockContentEventArgs> ContentAdded {
-      add { Events.AddHandler(ContentAddedEvent, value); }
-      remove { Events.RemoveHandler(ContentAddedEvent, value); }
-    }
-    protected virtual void OnContentAdded(DockContentEventArgs e) {
-      EventHandler<DockContentEventArgs> handler = (EventHandler<DockContentEventArgs>)Events[ContentAddedEvent];
-      if (handler != null)
-        handler(this, e);
-    }
-
-    private static readonly object ContentRemovedEvent = new object();
-    [LocalizedCategory("Category_DockingNotification")]
-    [LocalizedDescription("DockPanel_ContentRemoved_Description")]
-    public event EventHandler<DockContentEventArgs> ContentRemoved {
-      add { Events.AddHandler(ContentRemovedEvent, value); }
-      remove { Events.RemoveHandler(ContentRemovedEvent, value); }
-    }
-    protected virtual void OnContentRemoved(DockContentEventArgs e) {
-      EventHandler<DockContentEventArgs> handler = (EventHandler<DockContentEventArgs>)Events[ContentRemovedEvent];
-      if (handler != null)
-        handler(this, e);
-    }
-  }
 }

branches/UnloadJobs/HeuristicLab.MainForm.WindowsForms/3.3/Controls/ViewHost.Designer.cs

@@ -27 +27 @@
     private System.ComponentModel.IContainer components = null;
 
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing) {
+        if (components != null) components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
 
     #region Component Designer generated code

branches/UnloadJobs/HeuristicLab.MainForm.WindowsForms/3.3/Controls/ViewHost.cs

@@ -298 +298 @@
     }
     #endregion
-
-    /// <summary> 
-    /// Clean up any resources being used. (copied from Designer.cs file)
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing) {
-      if (disposing) {
-        if (components != null) components.Dispose();
-        ActiveView = null;
-        cachedView = null;
-        viewContextMenuStrip.ItemClicked -= new System.Windows.Forms.ToolStripItemClickedEventHandler(this.viewContextMenuStrip_ItemClicked);
-        viewContextMenuStrip.Dispose();
-      }
-      base.Dispose(disposing);
-    }
   }
 }

branches/UnloadJobs/HeuristicLab.MainForm.WindowsForms/3.3/MainForms/DockForm.cs

@@ -75 +75 @@
 
     protected override void Dispose(bool disposing) {
-      if (View != null) {
+      if (View != null)
         View.CaptionChanged -= new System.EventHandler(View_CaptionChanged);
-        view = null;
-      }
       if (disposing && (components != null)) {
         components.Dispose();

branches/UnloadJobs/HeuristicLab.MainForm.WindowsForms/3.3/MainForms/MainForm.cs

@@ -316 +316 @@
       if (ActiveView == view)
         ActiveView = null;
-
-      if (showContentInViewHost) {
-        ViewHost vh = view as ViewHost;
-        vh.Content = null;
-        vh.Dispose();
-      }
     }
 

branches/UnloadJobs/HeuristicLab.Operators.Views.GraphVisualization.Views/3.3/GraphVisualizationInfoView.Designer.cs

@@ -26 +26 @@
     /// </summary>
     private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
 
     #region Component Designer generated code

branches/UnloadJobs/HeuristicLab.Operators.Views.GraphVisualization.Views/3.3/GraphVisualizationInfoView.cs

@@ -349 +349 @@
       }
     }
-
-    /// <summary> 
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing) {
-      if (disposing && (components != null)) {
-        if (Content != null) {
-          DeregisterContentEvents();
-        }
-        foreach (IConnectionInfo connectionInfo in this.connectionInfoConnectionMapping.FirstValues.ToList()) {
-          DeregisterConnectionInfoEvents(connectionInfo);
-        }
-        foreach (IShapeInfo shapeInfo in this.shapeInfoShapeMapping.FirstValues.ToList()) {
-          DeregisterShapeInfoEvents(shapeInfo);
-        }
-        foreach (var shape in this.shapeInfoShapeMapping.SecondValues.ToList()) {
-          DeregisterShapeEvents(shape);
-        }
-        if (Content != null) {
-          foreach (IShapeInfo shapeInfo in this.Content.ShapeInfos)
-            DeregisterShapeInfoEvents(shapeInfo);
-          foreach (IConnectionInfo connectionInfo in this.Content.ConnectionInfos)
-            DeregisterConnectionInfoEvents(connectionInfo);
-        }
-        this.graphVisualization.OnEntityRemoved -= new System.EventHandler<global::Netron.Diagramming.Core.EntityEventArgs>(this.graphVisualization_OnEntityRemoved);
-        this.graphVisualization.OnEntityAdded -= new System.EventHandler<global::Netron.Diagramming.Core.EntityEventArgs>(this.graphVisualization_OnEntityAdded);
-
-        components.Dispose();
-      }
-      base.Dispose(disposing);
-    }
   }
 }

branches/UnloadJobs/HeuristicLab.Operators.Views.GraphVisualization.Views/3.3/OperatorGraphView.Designer.cs

@@ -26 +26 @@
     /// </summary>
     private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
 
     #region Component Designer generated code

branches/UnloadJobs/HeuristicLab.Operators.Views.GraphVisualization.Views/3.3/OperatorGraphView.cs

@@ -319 +319 @@
       }
     }
-
-    /// <summary> 
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing) {
-      if (disposing && (components != null)) {
-        this.graphVisualizationInfoView.Controller.OnShowContextMenu -= new EventHandler<EntityMenuEventArgs>(Controller_OnShowContextMenu);
-        this.graphVisualizationInfoView.Controller.Model.Selection.OnNewSelection -= new EventHandler(Controller_SelectionChanged);
-        this.graphVisualizationInfoView.Controller.OnMouseDown -= new EventHandler<MouseEventArgs>(Controller_OnMouseDown);
-        this.graphVisualizationInfoView.Controller.ParentControl.MouseDown -= new MouseEventHandler(ParentControl_MouseDown);
-        this.graphVisualizationInfoView.Controller.ParentControl.MouseUp -= new MouseEventHandler(ParentControl_MouseUp);
-        foreach (ITool tool in this.graphVisualizationInfoView.Controller.Tools) {
-          tool.OnToolActivate -= new EventHandler<ToolEventArgs>(tool_OnToolActivate);
-          tool.OnToolDeactivate -= new EventHandler<ToolEventArgs>(tool_OnToolDeactivate);
-        }
-        detailsViewHost.Content = null;
-        components.Dispose();
-      }
-      base.Dispose(disposing);
-    }
   }
 }