Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.3.1/HeuristicLab.WinFormsUI-2.3.1/Plugin.cs.frame
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.3.1/HeuristicLab.WinFormsUI-2.3.1/Plugin.cs.frame	(revision 8615)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.3.1/HeuristicLab.WinFormsUI-2.3.1/Plugin.cs.frame	(revision 8616)
@@ -1,3 +1,23 @@
-﻿using System;
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+ #endregion
+using System;
 using System.Collections.Generic;
 using System.Linq;
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/HeuristicLab.WinFormsUI-2.7.0/HeuristicLab.WinFormsUI-2.7.0.csproj
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/HeuristicLab.WinFormsUI-2.7.0/HeuristicLab.WinFormsUI-2.7.0.csproj	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/HeuristicLab.WinFormsUI-2.7.0/HeuristicLab.WinFormsUI-2.7.0.csproj	(revision 8616)
@@ -0,0 +1,174 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{3A32A015-9BF9-4EEB-AE80-C5E2B654B860}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.WinFormsUI</RootNamespace>
+    <AssemblyName>HeuristicLab.WinFormsUI-2.7.0</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
+    <FileAlignment>512</FileAlignment>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <UpgradeBackupLocation />
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Xml.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data.DataSetExtensions">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Plugin.cs.frame" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+    <None Include="WeifenLuo.WinFormsUI.Docking License.txt">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
+      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
+      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\2.3.1\WinFormsUI-2.3.1\WinFormsUI-2.3.1.csproj">
+      <Project>{1849A92E-DCFC-4E05-BB0A-D7B7A3DAFCFB}</Project>
+      <Name>WinFormsUI-2.3.1</Name>
+      <Private>False</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 3.1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <PropertyGroup>
+    <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+</PreBuildEvent>
+    <PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
+export ProjectDir=$(ProjectDir)
+export SolutionDir=$(SolutionDir)
+
+$SolutionDir/PreBuildEvent.sh
+</PreBuildEvent>
+  </PropertyGroup>
+</Project>
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/HeuristicLab.WinFormsUI-2.7.0/Plugin.cs.frame
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/HeuristicLab.WinFormsUI-2.7.0/Plugin.cs.frame	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/HeuristicLab.WinFormsUI-2.7.0/Plugin.cs.frame	(revision 8616)
@@ -0,0 +1,35 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+ #endregion
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.WinFormsUI {
+  [Plugin("HeuristicLab.WinFormsUI", "2.7.0.$WCREV$")]
+  [PluginFile("HeuristicLab.WinFormsUI-2.7.0.dll", PluginFileType.Assembly)]
+  [PluginFile("WeifenLuo.WinFormsUI.Docking-2.7.0.dll", PluginFileType.Assembly)]
+  [PluginFile("WeifenLuo.WinFormsUI.Docking License.txt",PluginFileType.License)]
+  public class HeuristicLabWinFormsUIPlugin : PluginBase {
+  }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/HeuristicLab.WinFormsUI-2.7.0/Properties/AssemblyInfo.cs.frame
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/HeuristicLab.WinFormsUI-2.7.0/Properties/AssemblyInfo.cs.frame	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/HeuristicLab.WinFormsUI-2.7.0/Properties/AssemblyInfo.cs.frame	(revision 8616)
@@ -0,0 +1,36 @@
+﻿using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.WinFormsUI")]
+[assembly: AssemblyDescription("Provides docking abilities for WinForms applications")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2012 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("3f5083f8-2738-4573-b230-e9928ef61e6b")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("2.7.0.0")]
+[assembly: AssemblyFileVersion("2.7.0.$WCREV$")]
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/HeuristicLab.WinFormsUI-2.7.0/WeifenLuo.WinFormsUI.Docking License.txt
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/HeuristicLab.WinFormsUI-2.7.0/WeifenLuo.WinFormsUI.Docking License.txt	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/HeuristicLab.WinFormsUI-2.7.0/WeifenLuo.WinFormsUI.Docking License.txt	(revision 8616)
@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright (c) 2007-2012 Weifen Luo (email: weifenluo@yahoo.com) and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/AutoHideStripBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/AutoHideStripBase.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/AutoHideStripBase.cs	(revision 8616)
@@ -0,0 +1,530 @@
+using System;
+using System.Collections;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public abstract partial class AutoHideStripBase : Control
+	{
+        [SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
+        protected class Tab : IDisposable
+        {
+            private IDockContent m_content;
+
+            protected internal Tab(IDockContent content)
+            {
+                m_content = content;
+            }
+
+            ~Tab()
+            {
+                Dispose(false);
+            }
+
+            public IDockContent Content
+            {
+                get { return m_content; }
+            }
+
+            public void Dispose()
+            {
+                Dispose(true);
+                GC.SuppressFinalize(this);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+            }
+        }
+
+        [SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
+        protected sealed class TabCollection : IEnumerable<Tab>
+        {
+            #region IEnumerable Members
+            IEnumerator<Tab> IEnumerable<Tab>.GetEnumerator()
+            {
+                for (int i = 0; i < Count; i++)
+                    yield return this[i];
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                for (int i = 0; i < Count; i++)
+                    yield return this[i];
+            }
+            #endregion
+
+            internal TabCollection(DockPane pane)
+            {
+                m_dockPane = pane;
+            }
+
+            private DockPane m_dockPane = null;
+            public DockPane DockPane
+            {
+                get { return m_dockPane; }
+            }
+
+            public DockPanel DockPanel
+            {
+                get { return DockPane.DockPanel; }
+            }
+
+            public int Count
+            {
+                get { return DockPane.DisplayingContents.Count; }
+            }
+
+            public Tab this[int index]
+            {
+                get
+                {
+                    IDockContent content = DockPane.DisplayingContents[index];
+                    if (content == null)
+                        throw (new ArgumentOutOfRangeException("index"));
+                    if (content.DockHandler.AutoHideTab == null)
+                        content.DockHandler.AutoHideTab = (DockPanel.AutoHideStripControl.CreateTab(content));
+                    return content.DockHandler.AutoHideTab as Tab;
+                }
+            }
+
+            public bool Contains(Tab tab)
+            {
+                return (IndexOf(tab) != -1);
+            }
+
+            public bool Contains(IDockContent content)
+            {
+                return (IndexOf(content) != -1);
+            }
+
+            public int IndexOf(Tab tab)
+            {
+                if (tab == null)
+                    return -1;
+
+                return IndexOf(tab.Content);
+            }
+
+            public int IndexOf(IDockContent content)
+            {
+                return DockPane.DisplayingContents.IndexOf(content);
+            }
+        }
+
+        [SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
+        protected class Pane : IDisposable
+        {
+            private DockPane m_dockPane;
+
+            protected internal Pane(DockPane dockPane)
+            {
+                m_dockPane = dockPane;
+            }
+
+            ~Pane()
+            {
+                Dispose(false);
+            }
+
+            public DockPane DockPane
+            {
+                get { return m_dockPane; }
+            }
+
+            public TabCollection AutoHideTabs
+            {
+                get
+                {
+                    if (DockPane.AutoHideTabs == null)
+                        DockPane.AutoHideTabs = new TabCollection(DockPane);
+                    return DockPane.AutoHideTabs as TabCollection;
+                }
+            }
+
+            public void Dispose()
+            {
+                Dispose(true);
+                GC.SuppressFinalize(this);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+            }
+        }
+
+        [SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
+        protected sealed class PaneCollection : IEnumerable<Pane>
+        {
+            private class AutoHideState
+            {
+                public DockState m_dockState;
+                public bool m_selected = false;
+
+                public AutoHideState(DockState dockState)
+                {
+                    m_dockState = dockState;
+                }
+
+                public DockState DockState
+                {
+                    get { return m_dockState; }
+                }
+
+                public bool Selected
+                {
+                    get { return m_selected; }
+                    set { m_selected = value; }
+                }
+            }
+
+            private class AutoHideStateCollection
+            {
+                private AutoHideState[] m_states;
+
+                public AutoHideStateCollection()
+                {
+                    m_states = new AutoHideState[]	{	
+												new AutoHideState(DockState.DockTopAutoHide),
+												new AutoHideState(DockState.DockBottomAutoHide),
+												new AutoHideState(DockState.DockLeftAutoHide),
+												new AutoHideState(DockState.DockRightAutoHide)
+											};
+                }
+
+                public AutoHideState this[DockState dockState]
+                {
+                    get
+                    {
+                        for (int i = 0; i < m_states.Length; i++)
+                        {
+                            if (m_states[i].DockState == dockState)
+                                return m_states[i];
+                        }
+                        throw new ArgumentOutOfRangeException("dockState");
+                    }
+                }
+
+                public bool ContainsPane(DockPane pane)
+                {
+                    if (pane.IsHidden)
+                        return false;
+
+                    for (int i = 0; i < m_states.Length; i++)
+                    {
+                        if (m_states[i].DockState == pane.DockState && m_states[i].Selected)
+                            return true;
+                    }
+                    return false;
+                }
+            }
+
+            internal PaneCollection(DockPanel panel, DockState dockState)
+            {
+                m_dockPanel = panel;
+                m_states = new AutoHideStateCollection();
+                States[DockState.DockTopAutoHide].Selected = (dockState == DockState.DockTopAutoHide);
+                States[DockState.DockBottomAutoHide].Selected = (dockState == DockState.DockBottomAutoHide);
+                States[DockState.DockLeftAutoHide].Selected = (dockState == DockState.DockLeftAutoHide);
+                States[DockState.DockRightAutoHide].Selected = (dockState == DockState.DockRightAutoHide);
+            }
+
+            private DockPanel m_dockPanel;
+            public DockPanel DockPanel
+            {
+                get { return m_dockPanel; }
+            }
+
+            private AutoHideStateCollection m_states;
+            private AutoHideStateCollection States
+            {
+                get { return m_states; }
+            }
+
+            public int Count
+            {
+                get
+                {
+                    int count = 0;
+                    foreach (DockPane pane in DockPanel.Panes)
+                    {
+                        if (States.ContainsPane(pane))
+                            count++;
+                    }
+
+                    return count;
+                }
+            }
+
+            public Pane this[int index]
+            {
+                get
+                {
+                    int count = 0;
+                    foreach (DockPane pane in DockPanel.Panes)
+                    {
+                        if (!States.ContainsPane(pane))
+                            continue;
+
+                        if (count == index)
+                        {
+                            if (pane.AutoHidePane == null)
+                                pane.AutoHidePane = DockPanel.AutoHideStripControl.CreatePane(pane);
+                            return pane.AutoHidePane as Pane;
+                        }
+
+                        count++;
+                    }
+                    throw new ArgumentOutOfRangeException("index");
+                }
+            }
+
+            public bool Contains(Pane pane)
+            {
+                return (IndexOf(pane) != -1);
+            }
+
+            public int IndexOf(Pane pane)
+            {
+                if (pane == null)
+                    return -1;
+
+                int index = 0;
+                foreach (DockPane dockPane in DockPanel.Panes)
+                {
+                    if (!States.ContainsPane(pane.DockPane))
+                        continue;
+
+                    if (pane == dockPane.AutoHidePane)
+                        return index;
+
+                    index++;
+                }
+                return -1;
+            }
+
+            #region IEnumerable Members
+
+            IEnumerator<Pane> IEnumerable<Pane>.GetEnumerator()
+            {
+                for (int i = 0; i < Count; i++)
+                    yield return this[i];
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                for (int i = 0; i < Count; i++)
+                    yield return this[i];
+            }
+
+            #endregion
+        }
+
+		protected AutoHideStripBase(DockPanel panel)
+		{
+			m_dockPanel = panel;
+			m_panesTop = new PaneCollection(panel, DockState.DockTopAutoHide);
+			m_panesBottom = new PaneCollection(panel, DockState.DockBottomAutoHide);
+			m_panesLeft = new PaneCollection(panel, DockState.DockLeftAutoHide);
+			m_panesRight = new PaneCollection(panel, DockState.DockRightAutoHide);
+
+			SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
+			SetStyle(ControlStyles.Selectable, false);
+		}
+
+		private DockPanel m_dockPanel;
+		protected DockPanel DockPanel
+		{
+			get	{	return m_dockPanel;	}
+		}
+
+		private PaneCollection m_panesTop;
+		protected PaneCollection PanesTop
+		{
+			get	{	return m_panesTop;	}
+		}
+
+		private PaneCollection m_panesBottom;
+		protected PaneCollection PanesBottom
+		{
+			get	{	return m_panesBottom;	}
+		}
+
+		private PaneCollection m_panesLeft;
+		protected PaneCollection PanesLeft
+		{
+			get	{	return m_panesLeft;	}
+		}
+
+		private PaneCollection m_panesRight;
+		protected PaneCollection PanesRight
+		{
+			get	{	return m_panesRight;	}
+		}
+
+		protected PaneCollection GetPanes(DockState dockState)
+		{
+			if (dockState == DockState.DockTopAutoHide)
+				return PanesTop;
+			else if (dockState == DockState.DockBottomAutoHide)
+				return PanesBottom;
+			else if (dockState == DockState.DockLeftAutoHide)
+				return PanesLeft;
+			else if (dockState == DockState.DockRightAutoHide)
+				return PanesRight;
+			else
+				throw new ArgumentOutOfRangeException("dockState");
+		}
+
+        internal int GetNumberOfPanes(DockState dockState)
+        {
+            return GetPanes(dockState).Count;
+        }
+
+		protected Rectangle RectangleTopLeft
+		{
+			get
+			{	
+				int height = MeasureHeight();
+				return PanesTop.Count > 0 && PanesLeft.Count > 0 ? new Rectangle(0, 0, height, height) : Rectangle.Empty;
+			}
+		}
+
+		protected Rectangle RectangleTopRight
+		{
+			get
+			{
+				int height = MeasureHeight();
+				return PanesTop.Count > 0 && PanesRight.Count > 0 ? new Rectangle(Width - height, 0, height, height) : Rectangle.Empty;
+			}
+		}
+
+		protected Rectangle RectangleBottomLeft
+		{
+			get
+			{
+				int height = MeasureHeight();
+				return PanesBottom.Count > 0 && PanesLeft.Count > 0 ? new Rectangle(0, Height - height, height, height) : Rectangle.Empty;
+			}
+		}
+
+		protected Rectangle RectangleBottomRight
+		{
+			get
+			{
+				int height = MeasureHeight();
+				return PanesBottom.Count > 0 && PanesRight.Count > 0 ? new Rectangle(Width - height, Height - height, height, height) : Rectangle.Empty;
+			}
+		}
+
+		protected internal Rectangle GetTabStripRectangle(DockState dockState)
+		{
+			int height = MeasureHeight();
+			if (dockState == DockState.DockTopAutoHide && PanesTop.Count > 0)
+				return new Rectangle(RectangleTopLeft.Width, 0, Width - RectangleTopLeft.Width - RectangleTopRight.Width, height);
+			else if (dockState == DockState.DockBottomAutoHide && PanesBottom.Count > 0)
+				return new Rectangle(RectangleBottomLeft.Width, Height - height, Width - RectangleBottomLeft.Width - RectangleBottomRight.Width, height);
+			else if (dockState == DockState.DockLeftAutoHide && PanesLeft.Count > 0)
+				return new Rectangle(0, RectangleTopLeft.Width, height, Height - RectangleTopLeft.Height - RectangleBottomLeft.Height);
+			else if (dockState == DockState.DockRightAutoHide && PanesRight.Count > 0)
+				return new Rectangle(Width - height, RectangleTopRight.Width, height, Height - RectangleTopRight.Height - RectangleBottomRight.Height);
+			else
+				return Rectangle.Empty;
+		}
+
+		private GraphicsPath m_displayingArea = null;
+		private GraphicsPath DisplayingArea
+		{
+			get
+			{
+				if (m_displayingArea == null)
+					m_displayingArea = new GraphicsPath();
+
+				return m_displayingArea;
+			}
+		}
+
+		private void SetRegion()
+		{
+			DisplayingArea.Reset();
+			DisplayingArea.AddRectangle(RectangleTopLeft);
+			DisplayingArea.AddRectangle(RectangleTopRight);
+			DisplayingArea.AddRectangle(RectangleBottomLeft);
+			DisplayingArea.AddRectangle(RectangleBottomRight);
+			DisplayingArea.AddRectangle(GetTabStripRectangle(DockState.DockTopAutoHide));
+			DisplayingArea.AddRectangle(GetTabStripRectangle(DockState.DockBottomAutoHide));
+			DisplayingArea.AddRectangle(GetTabStripRectangle(DockState.DockLeftAutoHide));
+			DisplayingArea.AddRectangle(GetTabStripRectangle(DockState.DockRightAutoHide));
+			Region = new Region(DisplayingArea);
+		}
+
+		protected override void OnMouseDown(MouseEventArgs e)
+		{
+			base.OnMouseDown(e);
+
+			if (e.Button != MouseButtons.Left)
+				return;
+
+			IDockContent content = HitTest();
+			if (content == null)
+				return;
+
+			content.DockHandler.Activate();
+		}
+
+		protected override void OnMouseHover(EventArgs e)
+		{
+			base.OnMouseHover(e);
+
+			IDockContent content = HitTest();
+			if (content != null && DockPanel.ActiveAutoHideContent != content)
+				DockPanel.ActiveAutoHideContent = content;
+
+			// requires further tracking of mouse hover behavior,
+            ResetMouseEventArgs();
+		}
+
+		protected override void OnLayout(LayoutEventArgs levent)
+		{
+			RefreshChanges();
+			base.OnLayout (levent);
+		}
+
+		internal void RefreshChanges()
+		{
+            if (IsDisposed)
+                return;
+
+			SetRegion();
+			OnRefreshChanges();
+		}
+
+		protected virtual void OnRefreshChanges()
+		{
+		}
+
+		protected internal abstract int MeasureHeight();
+
+		private IDockContent HitTest()
+		{
+			Point ptMouse = PointToClient(Control.MousePosition);
+			return HitTest(ptMouse);
+		}
+
+        protected virtual Tab CreateTab(IDockContent content)
+        {
+            return new Tab(content);
+        }
+
+        protected virtual Pane CreatePane(DockPane dockPane)
+        {
+            return new Pane(dockPane);
+        }
+
+		protected abstract IDockContent HitTest(Point point);
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockAreasEditor.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockAreasEditor.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockAreasEditor.cs	(revision 8616)
@@ -0,0 +1,142 @@
+using System;
+using System.ComponentModel;
+using System.Drawing;
+using System.Drawing.Design;
+using System.Windows.Forms;
+using System.Windows.Forms.Design;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{	
+	internal class DockAreasEditor : UITypeEditor
+	{
+		private class DockAreasEditorControl : System.Windows.Forms.UserControl
+		{
+			private CheckBox checkBoxFloat;
+			private CheckBox checkBoxDockLeft;
+			private CheckBox checkBoxDockRight;
+			private CheckBox checkBoxDockTop;
+			private CheckBox checkBoxDockBottom;
+			private CheckBox checkBoxDockFill;
+			private DockAreas m_oldDockAreas;
+
+			public DockAreas DockAreas
+			{
+				get
+				{
+					DockAreas dockAreas = 0;
+					if (checkBoxFloat.Checked)
+						dockAreas |= DockAreas.Float;
+					if (checkBoxDockLeft.Checked)
+						dockAreas |= DockAreas.DockLeft;
+					if (checkBoxDockRight.Checked)
+						dockAreas |= DockAreas.DockRight;
+					if (checkBoxDockTop.Checked)
+						dockAreas |= DockAreas.DockTop;
+					if (checkBoxDockBottom.Checked)
+						dockAreas |= DockAreas.DockBottom;
+					if (checkBoxDockFill.Checked)
+						dockAreas |= DockAreas.Document;
+
+					if (dockAreas == 0)
+						return m_oldDockAreas;
+					else
+						return dockAreas;
+				}
+			}
+
+			public DockAreasEditorControl()
+			{
+				checkBoxFloat = new CheckBox();
+				checkBoxDockLeft = new CheckBox();
+				checkBoxDockRight = new CheckBox();
+				checkBoxDockTop = new CheckBox();
+				checkBoxDockBottom = new CheckBox();
+				checkBoxDockFill = new CheckBox();
+
+				SuspendLayout();
+
+				checkBoxFloat.Appearance = Appearance.Button;
+				checkBoxFloat.Dock = DockStyle.Top;
+				checkBoxFloat.Height = 24;
+				checkBoxFloat.Text = Strings.DockAreaEditor_FloatCheckBoxText;
+				checkBoxFloat.TextAlign = ContentAlignment.MiddleCenter;
+				checkBoxFloat.FlatStyle = FlatStyle.System;
+			
+				checkBoxDockLeft.Appearance = System.Windows.Forms.Appearance.Button;
+				checkBoxDockLeft.Dock = System.Windows.Forms.DockStyle.Left;
+				checkBoxDockLeft.Width = 24;
+				checkBoxDockLeft.FlatStyle = FlatStyle.System;
+
+				checkBoxDockRight.Appearance = System.Windows.Forms.Appearance.Button;
+				checkBoxDockRight.Dock = System.Windows.Forms.DockStyle.Right;
+				checkBoxDockRight.Width = 24;
+				checkBoxDockRight.FlatStyle = FlatStyle.System;
+
+				checkBoxDockTop.Appearance = System.Windows.Forms.Appearance.Button;
+				checkBoxDockTop.Dock = System.Windows.Forms.DockStyle.Top;
+				checkBoxDockTop.Height = 24;
+				checkBoxDockTop.FlatStyle = FlatStyle.System;
+
+				checkBoxDockBottom.Appearance = System.Windows.Forms.Appearance.Button;
+				checkBoxDockBottom.Dock = System.Windows.Forms.DockStyle.Bottom;
+				checkBoxDockBottom.Height = 24;
+				checkBoxDockBottom.FlatStyle = FlatStyle.System;
+			
+				checkBoxDockFill.Appearance = System.Windows.Forms.Appearance.Button;
+				checkBoxDockFill.Dock = System.Windows.Forms.DockStyle.Fill;
+				checkBoxDockFill.FlatStyle = FlatStyle.System;
+
+				this.Controls.AddRange(new Control[] {
+														 checkBoxDockFill,
+														 checkBoxDockBottom,
+														 checkBoxDockTop,
+														 checkBoxDockRight,
+														 checkBoxDockLeft,
+														 checkBoxFloat});
+
+				Size = new System.Drawing.Size(160, 144);
+				BackColor = SystemColors.Control;
+				ResumeLayout();
+			}
+
+			public void SetStates(DockAreas dockAreas)
+			{
+				m_oldDockAreas = dockAreas;
+				if ((dockAreas & DockAreas.DockLeft) != 0)
+					checkBoxDockLeft.Checked = true;
+				if ((dockAreas & DockAreas.DockRight) != 0)
+					checkBoxDockRight.Checked = true;
+				if ((dockAreas & DockAreas.DockTop) != 0)
+					checkBoxDockTop.Checked = true;
+				if ((dockAreas & DockAreas.DockTop) != 0)
+					checkBoxDockTop.Checked = true;
+				if ((dockAreas & DockAreas.DockBottom) != 0)
+					checkBoxDockBottom.Checked = true;
+				if ((dockAreas & DockAreas.Document) != 0)
+					checkBoxDockFill.Checked = true;
+				if ((dockAreas & DockAreas.Float) != 0)
+					checkBoxFloat.Checked = true;
+			}
+		}
+
+		private DockAreasEditor.DockAreasEditorControl m_ui = null;
+
+		public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
+		{
+			return UITypeEditorEditStyle.DropDown;
+		}
+
+		public override object EditValue(ITypeDescriptorContext context, IServiceProvider sp, object value)
+		{
+			if (m_ui == null)
+				m_ui = new DockAreasEditor.DockAreasEditorControl();
+
+			m_ui.SetStates((DockAreas)value);
+
+            IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)sp.GetService(typeof(IWindowsFormsEditorService));
+			edSvc.DropDownControl(m_ui);
+
+			return m_ui.DockAreas;
+		}
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockContent.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockContent.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockContent.cs	(revision 8616)
@@ -0,0 +1,335 @@
+using System;
+using System.ComponentModel;
+using System.Drawing;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+using System.Diagnostics.CodeAnalysis;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public class DockContent : Form, IDockContent
+	{
+		public DockContent()
+		{
+			m_dockHandler = new DockContentHandler(this, new GetPersistStringCallback(GetPersistString));
+			m_dockHandler.DockStateChanged += new EventHandler(DockHandler_DockStateChanged);
+			//Suggested as a fix by bensty regarding form resize
+            this.ParentChanged += new EventHandler(DockContent_ParentChanged);
+		}
+
+		//Suggested as a fix by bensty regarding form resize
+        private void DockContent_ParentChanged(object Sender, EventArgs e)
+        {
+            if (this.Parent != null)
+                this.Font = this.Parent.Font;
+		}
+
+		private DockContentHandler m_dockHandler = null;
+		[Browsable(false)]
+		public DockContentHandler DockHandler
+		{
+			get	{	return m_dockHandler;	}
+		}
+
+		[LocalizedCategory("Category_Docking")]
+		[LocalizedDescription("DockContent_AllowEndUserDocking_Description")]
+		[DefaultValue(true)]
+		public bool AllowEndUserDocking
+		{
+			get	{	return DockHandler.AllowEndUserDocking;	}
+			set	{	DockHandler.AllowEndUserDocking = value;	}
+		}
+
+		[LocalizedCategory("Category_Docking")]
+		[LocalizedDescription("DockContent_DockAreas_Description")]
+		[DefaultValue(DockAreas.DockLeft|DockAreas.DockRight|DockAreas.DockTop|DockAreas.DockBottom|DockAreas.Document|DockAreas.Float)]
+		public DockAreas DockAreas
+		{
+			get	{	return DockHandler.DockAreas;	}
+			set	{	DockHandler.DockAreas = value;	}
+		}
+
+		[LocalizedCategory("Category_Docking")]
+		[LocalizedDescription("DockContent_AutoHidePortion_Description")]
+		[DefaultValue(0.25)]
+		public double AutoHidePortion
+		{
+			get	{	return DockHandler.AutoHidePortion;	}
+			set	{	DockHandler.AutoHidePortion = value;	}
+		}
+
+        private string m_tabText = null;
+		[Localizable(true)]
+		[LocalizedCategory("Category_Docking")]
+		[LocalizedDescription("DockContent_TabText_Description")]
+		[DefaultValue(null)]
+		public string TabText
+		{
+            get { return m_tabText; }
+            set { DockHandler.TabText = m_tabText = value; }
+		}
+
+        private bool ShouldSerializeTabText()
+		{
+			return (m_tabText != null);
+		}
+
+		[LocalizedCategory("Category_Docking")]
+		[LocalizedDescription("DockContent_CloseButton_Description")]
+		[DefaultValue(true)]
+		public bool CloseButton
+		{
+			get	{	return DockHandler.CloseButton;	}
+			set	{	DockHandler.CloseButton = value;	}
+		}
+
+        [LocalizedCategory("Category_Docking")]
+        [LocalizedDescription("DockContent_CloseButtonVisible_Description")]
+        [DefaultValue(true)]
+        public bool CloseButtonVisible
+        {
+            get { return DockHandler.CloseButtonVisible; }
+            set { DockHandler.CloseButtonVisible = value; }
+        }
+		
+		[Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+		public DockPanel DockPanel
+		{
+			get {	return DockHandler.DockPanel; }
+			set	{	DockHandler.DockPanel = value;	}
+		}
+
+        [Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+		public DockState DockState
+		{
+			get	{	return DockHandler.DockState;	}
+			set	{	DockHandler.DockState = value;	}
+		}
+
+        [Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+		public DockPane Pane
+		{
+			get {	return DockHandler.Pane; }
+			set	{	DockHandler.Pane = value;		}
+		}
+
+		[Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+		public bool IsHidden
+		{
+			get	{	return DockHandler.IsHidden;	}
+			set	{	DockHandler.IsHidden = value;	}
+		}
+
+        [Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+		public DockState VisibleState
+		{
+			get	{	return DockHandler.VisibleState;	}
+			set	{	DockHandler.VisibleState = value;	}
+		}
+
+        [Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+		public bool IsFloat
+		{
+			get	{	return DockHandler.IsFloat;	}
+			set	{	DockHandler.IsFloat = value;	}
+		}
+
+        [Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+		public DockPane PanelPane
+		{
+			get	{	return DockHandler.PanelPane;	}
+			set	{	DockHandler.PanelPane = value;	}
+		}
+
+        [Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+		public DockPane FloatPane
+		{
+			get	{	return DockHandler.FloatPane;	}
+			set	{	DockHandler.FloatPane = value;	}
+		}
+
+        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
+        protected virtual string GetPersistString()
+		{
+            return GetType().ToString();
+		}
+
+		[LocalizedCategory("Category_Docking")]
+		[LocalizedDescription("DockContent_HideOnClose_Description")]
+		[DefaultValue(false)]
+		public bool HideOnClose
+		{
+			get	{	return DockHandler.HideOnClose;	}
+			set	{	DockHandler.HideOnClose = value;	}
+		}
+
+		[LocalizedCategory("Category_Docking")]
+		[LocalizedDescription("DockContent_ShowHint_Description")]
+		[DefaultValue(DockState.Unknown)]
+		public DockState ShowHint
+		{
+			get	{	return DockHandler.ShowHint;	}
+			set	{	DockHandler.ShowHint = value;	}
+		}
+
+		[Browsable(false)]
+		public bool IsActivated
+		{
+			get	{	return DockHandler.IsActivated;	}
+		}
+
+		public bool IsDockStateValid(DockState dockState)
+		{
+			return DockHandler.IsDockStateValid(dockState);
+		}
+
+		[LocalizedCategory("Category_Docking")]
+		[LocalizedDescription("DockContent_TabPageContextMenu_Description")]
+		[DefaultValue(null)]
+		public ContextMenu TabPageContextMenu
+		{
+			get	{	return DockHandler.TabPageContextMenu;	}
+			set	{	DockHandler.TabPageContextMenu = value;	}
+		}
+
+        [LocalizedCategory("Category_Docking")]
+        [LocalizedDescription("DockContent_TabPageContextMenuStrip_Description")]
+        [DefaultValue(null)]
+        public ContextMenuStrip TabPageContextMenuStrip
+        {
+            get { return DockHandler.TabPageContextMenuStrip; }
+            set { DockHandler.TabPageContextMenuStrip = value; }
+        }
+
+		[Localizable(true)]
+		[Category("Appearance")]
+		[LocalizedDescription("DockContent_ToolTipText_Description")]
+		[DefaultValue(null)]
+		public string ToolTipText
+		{
+			get	{	return DockHandler.ToolTipText;	}
+			set {	DockHandler.ToolTipText = value;	}
+		}
+
+		public new void Activate()
+		{
+			DockHandler.Activate();
+		}
+
+		public new void Hide()
+		{
+			DockHandler.Hide();
+		}
+
+		public new void Show()
+		{
+			DockHandler.Show();
+		}
+
+		public void Show(DockPanel dockPanel)
+		{
+			DockHandler.Show(dockPanel);
+		}
+
+		public void Show(DockPanel dockPanel, DockState dockState)
+		{
+			DockHandler.Show(dockPanel, dockState);
+		}
+
+        [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters")]
+		public void Show(DockPanel dockPanel, Rectangle floatWindowBounds)
+		{
+			DockHandler.Show(dockPanel, floatWindowBounds);
+		}
+
+		public void Show(DockPane pane, IDockContent beforeContent)
+		{
+			DockHandler.Show(pane, beforeContent);
+		}
+
+		public void Show(DockPane previousPane, DockAlignment alignment, double proportion)
+		{
+			DockHandler.Show(previousPane, alignment, proportion);
+		}
+
+        [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters")]
+        public void FloatAt(Rectangle floatWindowBounds)
+        {
+            DockHandler.FloatAt(floatWindowBounds);
+        }
+
+        public void DockTo(DockPane paneTo, DockStyle dockStyle, int contentIndex)
+        {
+            DockHandler.DockTo(paneTo, dockStyle, contentIndex);
+        }
+
+        public void DockTo(DockPanel panel, DockStyle dockStyle)
+        {
+            DockHandler.DockTo(panel, dockStyle);
+        }
+
+		#region IDockContent Members
+		void IDockContent.OnActivated(EventArgs e)
+		{
+			this.OnActivated(e);
+		}
+
+		void IDockContent.OnDeactivate(EventArgs e)
+		{
+			this.OnDeactivate(e);
+		}
+		#endregion
+
+		#region Events
+		private void DockHandler_DockStateChanged(object sender, EventArgs e)
+		{
+			OnDockStateChanged(e);
+		}
+
+		private static readonly object DockStateChangedEvent = new object();
+		[LocalizedCategory("Category_PropertyChanged")]
+		[LocalizedDescription("Pane_DockStateChanged_Description")]
+		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);
+		}
+		#endregion
+
+        /// <summary>
+        /// Overridden to avoid resize issues with nested controls
+        /// </summary>
+        /// <remarks>
+        /// http://blogs.msdn.com/b/alejacma/archive/2008/11/20/controls-won-t-get-resized-once-the-nesting-hierarchy-of-windows-exceeds-a-certain-depth-x64.aspx
+        /// http://support.microsoft.com/kb/953934
+        /// </remarks>
+        protected override void OnSizeChanged(EventArgs e)
+        {
+            if (DockPanel != null && DockPanel.SupportDeeplyNestedContent && IsHandleCreated)
+            {
+                BeginInvoke((MethodInvoker)delegate
+                {
+                    base.OnSizeChanged(e);
+                });
+            }
+            else
+            {
+                base.OnSizeChanged(e);
+            }
+        }
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockContentCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockContentCollection.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockContentCollection.cs	(revision 8616)
@@ -0,0 +1,175 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    public class DockContentCollection : ReadOnlyCollection<IDockContent>
+    {
+        private static List<IDockContent> _emptyList = new List<IDockContent>(0);
+
+        internal DockContentCollection()
+            : base(new List<IDockContent>())
+        {
+        }
+
+        internal DockContentCollection(DockPane pane)
+            : base(_emptyList)
+        {
+            m_dockPane = pane;
+        }
+
+        private DockPane m_dockPane = null;
+        private DockPane DockPane
+        {
+            get { return m_dockPane; }
+        }
+
+        public new IDockContent this[int index]
+        {
+            get
+            {
+                if (DockPane == null)
+                    return Items[index] as IDockContent;
+                else
+                    return GetVisibleContent(index);
+            }
+        }
+
+        internal int Add(IDockContent content)
+        {
+#if DEBUG
+			if (DockPane != null)
+				throw new InvalidOperationException();
+#endif
+
+            if (Contains(content))
+                return IndexOf(content);
+
+            Items.Add(content);
+            return Count - 1;
+        }
+
+        internal void AddAt(IDockContent content, int index)
+        {
+#if DEBUG
+			if (DockPane != null)
+				throw new InvalidOperationException();
+#endif
+
+            if (index < 0 || index > Items.Count - 1)
+                return;
+
+            if (Contains(content))
+                return;
+
+            Items.Insert(index, content);
+        }
+
+        public new bool Contains(IDockContent content)
+        {
+            if (DockPane == null)
+                return Items.Contains(content);
+            else
+                return (GetIndexOfVisibleContents(content) != -1);
+        }
+
+        public new int Count
+        {
+            get
+            {
+                if (DockPane == null)
+                    return base.Count;
+                else
+                    return CountOfVisibleContents;
+            }
+        }
+
+        public new int IndexOf(IDockContent content)
+        {
+            if (DockPane == null)
+            {
+                if (!Contains(content))
+                    return -1;
+                else
+                    return Items.IndexOf(content);
+            }
+            else
+                return GetIndexOfVisibleContents(content);
+        }
+
+        internal void Remove(IDockContent content)
+        {
+            if (DockPane != null)
+                throw new InvalidOperationException();
+
+            if (!Contains(content))
+                return;
+
+            Items.Remove(content);
+        }
+
+        private int CountOfVisibleContents
+        {
+            get
+            {
+#if DEBUG
+				if (DockPane == null)
+					throw new InvalidOperationException();
+#endif
+
+                int count = 0;
+                foreach (IDockContent content in DockPane.Contents)
+                {
+                    if (content.DockHandler.DockState == DockPane.DockState)
+                        count++;
+                }
+                return count;
+            }
+        }
+
+        private IDockContent GetVisibleContent(int index)
+        {
+#if DEBUG
+			if (DockPane == null)
+				throw new InvalidOperationException();
+#endif
+
+            int currentIndex = -1;
+            foreach (IDockContent content in DockPane.Contents)
+            {
+                if (content.DockHandler.DockState == DockPane.DockState)
+                    currentIndex++;
+
+                if (currentIndex == index)
+                    return content;
+            }
+            throw (new ArgumentOutOfRangeException());
+        }
+
+        private int GetIndexOfVisibleContents(IDockContent content)
+        {
+#if DEBUG
+			if (DockPane == null)
+				throw new InvalidOperationException();
+#endif
+
+            if (content == null)
+                return -1;
+
+            int index = -1;
+            foreach (IDockContent c in DockPane.Contents)
+            {
+                if (c.DockHandler.DockState == DockPane.DockState)
+                {
+                    index++;
+
+                    if (c == content)
+                        return index;
+                }
+            }
+            return -1;
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockContentEventArgs.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockContentEventArgs.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockContentEventArgs.cs	(revision 8616)
@@ -0,0 +1,19 @@
+using System;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public class DockContentEventArgs : EventArgs
+	{
+		private IDockContent m_content;
+
+		public DockContentEventArgs(IDockContent content)
+		{
+			m_content = content;
+		}
+
+		public IDockContent Content
+		{
+			get	{	return m_content;	}
+		}
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockContentHandler.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockContentHandler.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockContentHandler.cs	(revision 8616)
@@ -0,0 +1,1080 @@
+using System;
+using System.Windows.Forms;
+using System.Drawing;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public delegate string GetPersistStringCallback();
+
+	public class DockContentHandler : IDisposable, IDockDragSource
+	{
+		public DockContentHandler(Form form) : this(form, null)
+		{
+		}
+
+		public DockContentHandler(Form form, GetPersistStringCallback getPersistStringCallback)
+		{
+			if (!(form is IDockContent))
+				throw new ArgumentException(Strings.DockContent_Constructor_InvalidForm, "form");
+
+			m_form = form;
+			m_getPersistStringCallback = getPersistStringCallback;
+
+			m_events = new EventHandlerList();
+			Form.Disposed +=new EventHandler(Form_Disposed);
+			Form.TextChanged += new EventHandler(Form_TextChanged);
+		}
+
+		public void Dispose()
+		{
+			Dispose(true);
+			GC.SuppressFinalize(this);
+		}
+
+		protected virtual void Dispose(bool disposing)
+		{
+			if(disposing)
+			{
+				lock(this)
+				{
+					DockPanel = null;
+					if (m_autoHideTab != null)
+						m_autoHideTab.Dispose();
+					if (m_tab != null)
+						m_tab.Dispose();
+
+					Form.Disposed -= new EventHandler(Form_Disposed);
+					Form.TextChanged -= new EventHandler(Form_TextChanged);
+					m_events.Dispose();
+				}
+			}
+		}
+
+		private Form m_form;
+		public Form Form
+		{
+			get	{	return m_form;	}
+		}
+
+		public IDockContent Content
+		{
+			get	{	return Form as IDockContent;	}
+		}
+
+        private IDockContent m_previousActive = null;
+        public IDockContent PreviousActive
+        {
+            get { return m_previousActive; }
+            internal set { m_previousActive = value; }
+        }
+
+        private IDockContent m_nextActive = null;
+        public IDockContent NextActive
+        {
+            get { return m_nextActive; }
+            internal set { m_nextActive = value; }
+        }
+
+		private EventHandlerList m_events;
+		private EventHandlerList Events
+		{
+			get	{	return m_events;	}
+		}
+
+		private bool m_allowEndUserDocking = true;
+		public bool AllowEndUserDocking
+		{
+			get	{	return m_allowEndUserDocking;	}
+			set	{	m_allowEndUserDocking = value;	}
+		}
+
+		private double m_autoHidePortion = 0.25;
+		public double AutoHidePortion
+		{
+			get	{	return m_autoHidePortion;	}
+			set
+			{
+				if (value <= 0)
+					throw(new ArgumentOutOfRangeException(Strings.DockContentHandler_AutoHidePortion_OutOfRange));
+
+				if (m_autoHidePortion == value)
+					return;
+
+				m_autoHidePortion = value;
+
+				if (DockPanel == null)
+					return;
+
+				if (DockPanel.ActiveAutoHideContent == Content)
+					DockPanel.PerformLayout();
+			}
+		}
+
+		private bool m_closeButton = true;
+		public bool CloseButton
+		{
+			get	{	return m_closeButton;	}
+			set
+			{
+				if (m_closeButton == value)
+					return;
+
+				m_closeButton = value;
+				if (Pane != null)
+					if (Pane.ActiveContent.DockHandler == this)
+						Pane.RefreshChanges();
+			}
+		}
+
+        private bool m_closeButtonVisible = true;
+        /// <summary>
+        /// Determines whether the close button is visible on the content
+        /// </summary>
+        public bool CloseButtonVisible
+        {
+            get { return m_closeButtonVisible; }
+            set { m_closeButtonVisible = value; }
+        }
+		
+		private DockState DefaultDockState
+		{
+			get
+			{
+				if (ShowHint != DockState.Unknown && ShowHint != DockState.Hidden)
+					return ShowHint;
+
+				if ((DockAreas & DockAreas.Document) != 0)
+					return DockState.Document;
+				if ((DockAreas & DockAreas.DockRight) != 0)
+					return DockState.DockRight;
+				if ((DockAreas & DockAreas.DockLeft) != 0)
+					return DockState.DockLeft;
+				if ((DockAreas & DockAreas.DockBottom) != 0)
+					return DockState.DockBottom;
+				if ((DockAreas & DockAreas.DockTop) != 0)
+					return DockState.DockTop;
+
+				return DockState.Unknown;
+			}
+		}
+
+		private DockState DefaultShowState
+		{
+			get
+			{
+				if (ShowHint != DockState.Unknown)
+					return ShowHint;
+
+				if ((DockAreas & DockAreas.Document) != 0)
+					return DockState.Document;
+				if ((DockAreas & DockAreas.DockRight) != 0)
+					return DockState.DockRight;
+				if ((DockAreas & DockAreas.DockLeft) != 0)
+					return DockState.DockLeft;
+				if ((DockAreas & DockAreas.DockBottom) != 0)
+					return DockState.DockBottom;
+				if ((DockAreas & DockAreas.DockTop) != 0)
+					return DockState.DockTop;
+				if ((DockAreas & DockAreas.Float) != 0)
+					return DockState.Float;
+
+				return DockState.Unknown;
+			}
+		}
+
+		private DockAreas m_allowedAreas = DockAreas.DockLeft | DockAreas.DockRight | DockAreas.DockTop | DockAreas.DockBottom | DockAreas.Document | DockAreas.Float;
+		public DockAreas DockAreas
+		{
+			get	{	return m_allowedAreas;	}
+			set
+			{
+				if (m_allowedAreas == value)
+					return;
+
+				if (!DockHelper.IsDockStateValid(DockState, value))
+					throw(new InvalidOperationException(Strings.DockContentHandler_DockAreas_InvalidValue));
+
+				m_allowedAreas = value;
+
+				if (!DockHelper.IsDockStateValid(ShowHint, m_allowedAreas))
+					ShowHint = DockState.Unknown;
+			}
+		}
+
+		private DockState m_dockState = DockState.Unknown;
+		public DockState DockState
+		{
+			get	{	return m_dockState;	}
+			set
+			{
+				if (m_dockState == value)
+					return;
+
+                DockPanel.SuspendLayout(true);
+
+				if (value == DockState.Hidden)
+					IsHidden = true;
+				else
+					SetDockState(false, value, Pane);
+
+                DockPanel.ResumeLayout(true, true);
+			}
+		}
+
+		private DockPanel m_dockPanel = null;
+		public DockPanel DockPanel
+		{
+			get { return m_dockPanel; }
+			set
+			{
+				if (m_dockPanel == value)
+					return;
+
+				Pane = null;
+
+				if (m_dockPanel != null)
+					m_dockPanel.RemoveContent(Content);
+
+				if (m_tab != null)
+				{
+					m_tab.Dispose();
+					m_tab = null;
+				}
+
+				if (m_autoHideTab != null)
+				{
+					m_autoHideTab.Dispose();
+					m_autoHideTab = null;
+				}
+
+				m_dockPanel = value;
+
+				if (m_dockPanel != null)
+				{
+					m_dockPanel.AddContent(Content);
+					Form.TopLevel = false;
+					Form.FormBorderStyle = FormBorderStyle.None;
+					Form.ShowInTaskbar = false;
+                    Form.WindowState = FormWindowState.Normal;
+                    if (!Win32Helper.IsRunningOnMono)		    
+					NativeMethods.SetWindowPos(Form.Handle, IntPtr.Zero, 0, 0, 0, 0,
+						Win32.FlagsSetWindowPos.SWP_NOACTIVATE |
+						Win32.FlagsSetWindowPos.SWP_NOMOVE |
+						Win32.FlagsSetWindowPos.SWP_NOSIZE |
+						Win32.FlagsSetWindowPos.SWP_NOZORDER |
+						Win32.FlagsSetWindowPos.SWP_NOOWNERZORDER |
+						Win32.FlagsSetWindowPos.SWP_FRAMECHANGED);
+				}
+			}
+		}
+
+		public Icon Icon
+		{
+			get	{	return Form.Icon;	}
+		}
+
+		public DockPane Pane
+		{
+			get {	return IsFloat ? FloatPane : PanelPane; }
+			set
+			{
+				if (Pane == value)
+					return;
+
+                DockPanel.SuspendLayout(true);
+
+				DockPane oldPane = Pane;
+
+				SuspendSetDockState();
+				FloatPane = (value == null ? null : (value.IsFloat ? value : FloatPane));
+				PanelPane = (value == null ? null : (value.IsFloat ? PanelPane : value));
+				ResumeSetDockState(IsHidden, value != null ? value.DockState : DockState.Unknown, oldPane);
+
+                DockPanel.ResumeLayout(true, true);
+			}
+		}
+
+		private bool m_isHidden = true;
+		public bool IsHidden
+		{
+			get	{	return m_isHidden;	}
+			set
+			{
+				if (m_isHidden == value)
+					return;
+
+				SetDockState(value, VisibleState, Pane);
+			}
+		}
+
+		private string m_tabText = null;
+		public string TabText
+		{
+            get { return m_tabText == null || m_tabText == "" ? Form.Text : m_tabText; }
+			set
+			{
+				if (m_tabText == value)
+					return;
+
+				m_tabText = value;
+				if (Pane != null)
+					Pane.RefreshChanges();
+			}
+		}
+
+		private DockState m_visibleState = DockState.Unknown;
+		public DockState VisibleState
+		{
+			get	{	return m_visibleState;	}
+			set
+			{
+				if (m_visibleState == value)
+					return;
+
+				SetDockState(IsHidden, value, Pane);
+			}
+		}
+
+		private bool m_isFloat = false;
+		public bool IsFloat
+		{
+			get	{	return m_isFloat;	}
+			set
+			{
+				if (m_isFloat == value)
+					return;
+
+                DockState visibleState = CheckDockState(value);
+
+				if (visibleState == DockState.Unknown)
+					throw new InvalidOperationException(Strings.DockContentHandler_IsFloat_InvalidValue);
+
+				SetDockState(IsHidden, visibleState, Pane);
+			}
+		}
+
+        [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters")]
+        public DockState CheckDockState(bool isFloat)
+        {
+            DockState dockState;
+
+            if (isFloat)
+            {
+                if (!IsDockStateValid(DockState.Float))
+                    dockState = DockState.Unknown;
+                else
+                    dockState = DockState.Float;
+            }
+            else
+            {
+                dockState = (PanelPane != null) ? PanelPane.DockState : DefaultDockState;
+                if (dockState != DockState.Unknown && !IsDockStateValid(dockState))
+                    dockState = DockState.Unknown;
+            }
+
+            return dockState;
+        }
+
+		private DockPane m_panelPane = null;
+		public DockPane PanelPane
+		{
+			get	{	return m_panelPane;	}
+			set
+			{
+				if (m_panelPane == value)
+					return;
+
+				if (value != null)
+				{
+					if (value.IsFloat || value.DockPanel != DockPanel)
+						throw new InvalidOperationException(Strings.DockContentHandler_DockPane_InvalidValue);
+				}
+
+				DockPane oldPane = Pane;
+
+                if (m_panelPane != null)
+                    RemoveFromPane(m_panelPane);
+				m_panelPane = value;
+				if (m_panelPane != null)
+				{
+					m_panelPane.AddContent(Content);
+					SetDockState(IsHidden, IsFloat ? DockState.Float : m_panelPane.DockState, oldPane);
+				}
+				else
+					SetDockState(IsHidden, DockState.Unknown, oldPane);
+			}
+		}
+
+        private void RemoveFromPane(DockPane pane)
+        {
+            pane.RemoveContent(Content);
+            SetPane(null);
+            if (pane.Contents.Count == 0)
+                pane.Dispose();
+        }
+
+		private DockPane m_floatPane = null;
+		public DockPane FloatPane
+		{
+			get	{	return m_floatPane;	}
+			set
+			{
+				if (m_floatPane == value)
+					return;
+
+				if (value != null)
+				{
+					if (!value.IsFloat || value.DockPanel != DockPanel)
+						throw new InvalidOperationException(Strings.DockContentHandler_FloatPane_InvalidValue);
+				}
+
+				DockPane oldPane = Pane;
+
+                if (m_floatPane != null)
+                    RemoveFromPane(m_floatPane);
+				m_floatPane = value;
+				if (m_floatPane != null)
+				{
+					m_floatPane.AddContent(Content);
+					SetDockState(IsHidden, IsFloat ? DockState.Float : VisibleState, oldPane);
+				}
+				else
+					SetDockState(IsHidden, DockState.Unknown, oldPane);
+			}
+		}
+
+		private int m_countSetDockState = 0;
+		private void SuspendSetDockState()
+		{
+			m_countSetDockState ++;
+		}
+
+		private void ResumeSetDockState()
+		{
+			m_countSetDockState --;
+			if (m_countSetDockState < 0)
+				m_countSetDockState = 0;
+		}
+
+		internal bool IsSuspendSetDockState
+		{
+			get	{	return m_countSetDockState != 0;	}
+		}
+
+		private void ResumeSetDockState(bool isHidden, DockState visibleState, DockPane oldPane)
+		{
+			ResumeSetDockState();
+			SetDockState(isHidden, visibleState, oldPane);
+		}
+
+		internal void SetDockState(bool isHidden, DockState visibleState, DockPane oldPane)
+		{
+			if (IsSuspendSetDockState)
+				return;
+
+			if (DockPanel == null && visibleState != DockState.Unknown)
+				throw new InvalidOperationException(Strings.DockContentHandler_SetDockState_NullPanel);
+
+			if (visibleState == DockState.Hidden || (visibleState != DockState.Unknown && !IsDockStateValid(visibleState)))
+				throw new InvalidOperationException(Strings.DockContentHandler_SetDockState_InvalidState);
+
+            DockPanel dockPanel = DockPanel;
+            if (dockPanel != null)
+                dockPanel.SuspendLayout(true);
+
+			SuspendSetDockState();
+
+			DockState oldDockState = DockState;
+
+			if (m_isHidden != isHidden || oldDockState == DockState.Unknown)
+			{
+				m_isHidden = isHidden;
+			}
+			m_visibleState = visibleState;
+			m_dockState = isHidden ? DockState.Hidden : visibleState;
+
+            if (visibleState == DockState.Unknown)
+                Pane = null;
+            else
+            {
+                m_isFloat = (m_visibleState == DockState.Float);
+
+                if (Pane == null)
+                    Pane = DockPanel.DockPaneFactory.CreateDockPane(Content, visibleState, true);
+                else if (Pane.DockState != visibleState)
+                {
+                    if (Pane.Contents.Count == 1)
+                        Pane.SetDockState(visibleState);
+                    else
+                        Pane = DockPanel.DockPaneFactory.CreateDockPane(Content, visibleState, true);
+                }
+            }
+
+            if (Form.ContainsFocus)
+                if (DockState == DockState.Hidden || DockState == DockState.Unknown)
+                    if (!Win32Helper.IsRunningOnMono)                    
+                        DockPanel.ContentFocusManager.GiveUpFocus(Content);
+
+            SetPaneAndVisible(Pane);
+
+			if (oldPane != null && !oldPane.IsDisposed && oldDockState == oldPane.DockState)
+				RefreshDockPane(oldPane);
+
+			if (Pane != null && DockState == Pane.DockState)
+			{
+				if ((Pane != oldPane) ||
+					(Pane == oldPane && oldDockState != oldPane.DockState))
+					// Avoid early refresh of hidden AutoHide panes
+					if ((Pane.DockWindow == null || Pane.DockWindow.Visible || Pane.IsHidden) && !Pane.IsAutoHide)
+						RefreshDockPane(Pane);			
+			}
+
+            if (oldDockState != DockState)
+            {
+                if (DockState == DockState.Hidden || DockState == DockState.Unknown ||
+                    DockHelper.IsDockStateAutoHide(DockState))
+                    if (!Win32Helper.IsRunningOnMono)
+                        DockPanel.ContentFocusManager.RemoveFromList(Content);
+                else
+                    if (!Win32Helper.IsRunningOnMono)
+                        DockPanel.ContentFocusManager.AddToList(Content);
+
+                OnDockStateChanged(EventArgs.Empty);
+            }
+			ResumeSetDockState();
+
+            if (dockPanel != null)
+                dockPanel.ResumeLayout(true, true);
+		}
+
+		private static void RefreshDockPane(DockPane pane)
+		{
+			pane.RefreshChanges();
+			pane.ValidateActiveContent();
+		}
+
+		internal string PersistString
+		{
+			get	{	return GetPersistStringCallback == null ? Form.GetType().ToString() : GetPersistStringCallback();	}
+		}
+
+		private GetPersistStringCallback m_getPersistStringCallback = null;
+		public GetPersistStringCallback GetPersistStringCallback
+		{
+			get	{	return m_getPersistStringCallback;	}
+			set	{	m_getPersistStringCallback = value;	}
+		}
+
+
+		private bool m_hideOnClose = false;
+		public bool HideOnClose
+		{
+			get	{	return m_hideOnClose;	}
+			set	{	m_hideOnClose = value;	}
+		}
+
+		private DockState m_showHint = DockState.Unknown;
+		public DockState ShowHint
+		{
+			get	{	return m_showHint;	}
+			set
+			{	
+				if (!DockHelper.IsDockStateValid(value, DockAreas))
+					throw (new InvalidOperationException(Strings.DockContentHandler_ShowHint_InvalidValue));
+
+				if (m_showHint == value)
+					return;
+
+				m_showHint = value;
+			}
+		}
+
+		private bool m_isActivated = false;
+		public bool IsActivated
+		{
+			get	{	return m_isActivated;	}
+		    internal set
+		    {
+	            if (m_isActivated == value)
+		            return;
+
+	            m_isActivated = value;
+		    }
+		}
+
+		public bool IsDockStateValid(DockState dockState)
+		{
+			if (DockPanel != null && dockState == DockState.Document && DockPanel.DocumentStyle == DocumentStyle.SystemMdi)
+				return false;
+			else
+				return DockHelper.IsDockStateValid(dockState, DockAreas);
+		}
+
+		private ContextMenu m_tabPageContextMenu = null;
+		public ContextMenu TabPageContextMenu
+		{
+			get	{	return m_tabPageContextMenu;	}
+			set	{	m_tabPageContextMenu = value;	}
+		}
+
+		private string m_toolTipText = null;
+		public string ToolTipText
+		{
+			get	{	return m_toolTipText;	}
+			set {	m_toolTipText = value;	}
+		}
+
+		public void Activate()
+		{
+			if (DockPanel == null)
+				Form.Activate();
+			else if (Pane == null)
+				Show(DockPanel);
+			else
+			{
+				IsHidden = false;
+				Pane.ActiveContent = Content;
+                if (DockState == DockState.Document && DockPanel.DocumentStyle == DocumentStyle.SystemMdi)
+                {
+                    Form.Activate();
+                    return;
+                }
+                else if (DockHelper.IsDockStateAutoHide(DockState))
+                {
+                    if (DockPanel.ActiveAutoHideContent != Content)
+                    {
+                        DockPanel.ActiveAutoHideContent = null;
+                        return;
+                    }
+                }
+
+                if (!Form.ContainsFocus)
+                    if (!Win32Helper.IsRunningOnMono)
+                        DockPanel.ContentFocusManager.Activate(Content);
+			}
+		}
+
+        public void GiveUpFocus()
+        {
+            if (!Win32Helper.IsRunningOnMono)
+                DockPanel.ContentFocusManager.GiveUpFocus(Content);
+        }
+
+		private IntPtr m_activeWindowHandle = IntPtr.Zero;
+		internal IntPtr ActiveWindowHandle
+		{
+			get	{	return m_activeWindowHandle;	}
+			set	{	m_activeWindowHandle = value;	}
+		}
+
+		public void Hide()
+		{
+			IsHidden = true;
+		}
+
+        internal void SetPaneAndVisible(DockPane pane)
+        {
+            SetPane(pane);
+            SetVisible();
+        }
+
+		private void SetPane(DockPane pane)
+		{
+			if (pane != null && pane.DockState == DockState.Document && DockPanel.DocumentStyle == DocumentStyle.DockingMdi)
+			{
+				if (Form.Parent is DockPane)
+					SetParent(null);
+				if (Form.MdiParent != DockPanel.ParentForm)
+				{
+					FlagClipWindow = true;
+					Form.MdiParent = DockPanel.ParentForm;
+				}
+			}
+			else
+			{
+				FlagClipWindow = true;
+				if (Form.MdiParent != null)
+					Form.MdiParent = null;
+				if (Form.TopLevel)
+					Form.TopLevel = false;
+				SetParent(pane);
+			}
+		}
+
+		internal void SetVisible()
+		{
+			bool visible;
+
+			if (IsHidden)
+				visible = false;
+			else if (Pane != null && Pane.DockState == DockState.Document && DockPanel.DocumentStyle == DocumentStyle.DockingMdi)
+				visible = true;
+			else if (Pane != null && Pane.ActiveContent == Content)
+				visible = true;
+			else if (Pane != null && Pane.ActiveContent != Content)
+				visible = false;
+			else
+				visible = Form.Visible;
+
+            if (Form.Visible != visible)
+                Form.Visible = visible;
+		}
+
+		private void SetParent(Control value)
+		{
+			if (Form.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. 
+            //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+            bool bRestoreFocus = false;
+            if (Form.ContainsFocus)
+            {
+				//Suggested as a fix for a memory leak by bugreports
+                if (value == null && !IsFloat)
+                    if (!Win32Helper.IsRunningOnMono)
+                        DockPanel.ContentFocusManager.GiveUpFocus(this.Content);
+                else
+                {
+                    DockPanel.SaveFocus();
+                    bRestoreFocus = true;
+                }
+            }
+            //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+            Form.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 (bRestoreFocus)
+                Activate();
+            //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        }
+
+		public void Show()
+		{
+			if (DockPanel == null)
+				Form.Show();
+			else
+				Show(DockPanel);
+		}
+
+		public void Show(DockPanel dockPanel)
+		{
+			if (dockPanel == null)
+				throw(new ArgumentNullException(Strings.DockContentHandler_Show_NullDockPanel));
+
+			if (DockState == DockState.Unknown)
+				Show(dockPanel, DefaultShowState);
+			else			
+				Activate();
+		}
+
+		public void Show(DockPanel dockPanel, DockState dockState)
+		{
+			if (dockPanel == null)
+				throw(new ArgumentNullException(Strings.DockContentHandler_Show_NullDockPanel));
+
+			if (dockState == DockState.Unknown || dockState == DockState.Hidden)
+				throw(new ArgumentException(Strings.DockContentHandler_Show_InvalidDockState));
+
+            dockPanel.SuspendLayout(true);
+
+			DockPanel = dockPanel;
+
+			if (dockState == DockState.Float && FloatPane == null)
+				Pane = DockPanel.DockPaneFactory.CreateDockPane(Content, DockState.Float, true);
+			else if (PanelPane == null)
+			{
+				DockPane paneExisting = null;
+				foreach (DockPane pane in DockPanel.Panes)
+					if (pane.DockState == dockState)
+					{
+						paneExisting = pane;
+						break;
+					}
+
+				if (paneExisting == null)
+					Pane = DockPanel.DockPaneFactory.CreateDockPane(Content, dockState, true);
+				else
+					Pane = paneExisting;
+			}
+
+			DockState = dockState;
+            dockPanel.ResumeLayout(true, true); //we'll resume the layout before activating to ensure that the position
+            Activate();                         //and size of the form are finally processed before the form is shown
+		}
+
+        [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters")]
+		public void Show(DockPanel dockPanel, Rectangle floatWindowBounds)
+		{
+			if (dockPanel == null)
+				throw(new ArgumentNullException(Strings.DockContentHandler_Show_NullDockPanel));
+
+            dockPanel.SuspendLayout(true);
+
+			DockPanel = dockPanel;
+			if (FloatPane == null)
+			{
+				IsHidden = true;	// to reduce the screen flicker
+				FloatPane = DockPanel.DockPaneFactory.CreateDockPane(Content, DockState.Float, false);
+				FloatPane.FloatWindow.StartPosition = FormStartPosition.Manual;
+			}
+
+			FloatPane.FloatWindow.Bounds = floatWindowBounds;
+			
+			Show(dockPanel, DockState.Float);
+			Activate();
+
+            dockPanel.ResumeLayout(true, true);
+		}
+
+		public void Show(DockPane pane, IDockContent beforeContent)
+		{
+			if (pane == null)
+				throw(new ArgumentNullException(Strings.DockContentHandler_Show_NullPane));
+
+			if (beforeContent != null && pane.Contents.IndexOf(beforeContent) == -1)
+				throw(new ArgumentException(Strings.DockContentHandler_Show_InvalidBeforeContent));
+
+            pane.DockPanel.SuspendLayout(true);
+
+			DockPanel = pane.DockPanel;
+			Pane = pane;
+			pane.SetContentIndex(Content, pane.Contents.IndexOf(beforeContent));
+			Show();
+
+            pane.DockPanel.ResumeLayout(true, true);
+		}
+
+		public void Show(DockPane previousPane, DockAlignment alignment, double proportion)
+		{
+			if (previousPane == null)
+				throw(new ArgumentException(Strings.DockContentHandler_Show_InvalidPrevPane));
+
+			if (DockHelper.IsDockStateAutoHide(previousPane.DockState))
+				throw(new ArgumentException(Strings.DockContentHandler_Show_InvalidPrevPane));
+
+            previousPane.DockPanel.SuspendLayout(true);
+
+			DockPanel = previousPane.DockPanel;
+			DockPanel.DockPaneFactory.CreateDockPane(Content, previousPane, alignment, proportion, true);
+			Show();
+
+            previousPane.DockPanel.ResumeLayout(true, true);
+		}
+
+		public void Close()
+		{
+			DockPanel dockPanel = DockPanel;
+            if (dockPanel != null)
+                dockPanel.SuspendLayout(true);
+			Form.Close();
+			if (dockPanel != null)
+				dockPanel.ResumeLayout(true, true);
+
+		}
+
+		private DockPaneStripBase.Tab m_tab = null;
+		internal DockPaneStripBase.Tab GetTab(DockPaneStripBase dockPaneStrip)
+		{
+            if (m_tab == null)
+                m_tab = dockPaneStrip.CreateTab(Content);
+
+            return m_tab;
+		}
+
+		private IDisposable m_autoHideTab = null;
+		internal IDisposable AutoHideTab
+		{
+            get { return m_autoHideTab; }
+            set { m_autoHideTab = value; }
+		}
+
+		#region Events
+		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);
+		}
+		#endregion
+
+		private void Form_Disposed(object sender, EventArgs e)
+		{
+			Dispose();
+		}
+
+		private void Form_TextChanged(object sender, EventArgs e)
+		{
+			if (DockHelper.IsDockStateAutoHide(DockState))
+				DockPanel.RefreshAutoHideStrip();
+			else if (Pane != null)
+			{
+				if (Pane.FloatWindow != null)
+					Pane.FloatWindow.SetText();
+				Pane.RefreshChanges();
+			}
+		}
+
+		private bool m_flagClipWindow = false;
+		internal bool FlagClipWindow
+		{
+			get	{	return m_flagClipWindow;	}
+			set
+			{
+				if (m_flagClipWindow == value)
+					return;
+
+				m_flagClipWindow = value;
+				if (m_flagClipWindow)
+					Form.Region = new Region(Rectangle.Empty);
+				else
+					Form.Region = null;
+			}
+		}
+
+        private ContextMenuStrip m_tabPageContextMenuStrip = null;
+        public ContextMenuStrip TabPageContextMenuStrip
+        {
+            get { return m_tabPageContextMenuStrip; }
+            set { m_tabPageContextMenuStrip = value; }
+        }
+
+        #region IDockDragSource Members
+
+        Control IDragSource.DragControl
+        {
+            get { return Form; }
+        }
+
+        bool IDockDragSource.CanDockTo(DockPane pane)
+        {
+            if (!IsDockStateValid(pane.DockState))
+                return false;
+
+            if (Pane == pane && pane.DisplayingContents.Count == 1)
+                return false;
+
+            return true;
+        }
+
+        Rectangle IDockDragSource.BeginDrag(Point ptMouse)
+        {
+            Size size;
+            DockPane floatPane = this.FloatPane;
+            if (DockState == DockState.Float || floatPane == null || floatPane.FloatWindow.NestedPanes.Count != 1)
+                size = DockPanel.DefaultFloatWindowSize;
+            else
+                size = floatPane.FloatWindow.Size;
+
+            Point location;
+			Rectangle rectPane = Pane.ClientRectangle;
+            if (DockState == DockState.Document)
+            {
+                if (Pane.DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+                    location = new Point(rectPane.Left, rectPane.Bottom - size.Height);
+                else
+                    location = new Point(rectPane.Left, rectPane.Top);
+            }
+            else
+            {
+                location = new Point(rectPane.Left, rectPane.Bottom);
+                location.Y -= size.Height;
+            }
+            location = Pane.PointToScreen(location);
+
+            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)
+        {
+            DockPane pane = DockPanel.DockPaneFactory.CreateDockPane(Content, floatWindowBounds, true);
+        }
+
+        public void DockTo(DockPane pane, DockStyle dockStyle, int contentIndex)
+        {
+			if (dockStyle == DockStyle.Fill)
+			{
+				bool samePane = (Pane == pane);
+				if (!samePane)
+					Pane = pane;
+
+				if (contentIndex == -1 || !samePane)
+					pane.SetContentIndex(Content, contentIndex);
+				else
+				{
+					DockContentCollection contents = pane.Contents;
+					int oldIndex = contents.IndexOf(Content);
+					int newIndex = contentIndex;
+					if (oldIndex < newIndex)
+					{
+						newIndex += 1;
+						if (newIndex > contents.Count -1)
+							newIndex = -1;
+					}
+					pane.SetContentIndex(Content, newIndex);
+				}
+			}
+			else
+			{
+				DockPane paneFrom = DockPanel.DockPaneFactory.CreateDockPane(Content, pane.DockState, true);
+				INestedPanesContainer container = pane.NestedPanesContainer;
+				if (dockStyle == DockStyle.Left)
+					paneFrom.DockTo(container, pane, DockAlignment.Left, 0.5);
+				else if (dockStyle == DockStyle.Right) 
+					paneFrom.DockTo(container, pane, DockAlignment.Right, 0.5);
+				else if (dockStyle == DockStyle.Top)
+					paneFrom.DockTo(container, pane, DockAlignment.Top, 0.5);
+				else if (dockStyle == DockStyle.Bottom) 
+					paneFrom.DockTo(container, pane, DockAlignment.Bottom, 0.5);
+
+				paneFrom.DockState = pane.DockState;
+			}
+        }
+
+        public void DockTo(DockPanel panel, DockStyle dockStyle)
+        {
+            if (panel != DockPanel)
+                throw new ArgumentException(Strings.IDockDragSource_DockTo_InvalidPanel, "panel");
+
+            DockPane pane;
+
+            if (dockStyle == DockStyle.Top)
+                pane = DockPanel.DockPaneFactory.CreateDockPane(Content, DockState.DockTop, true);
+            else if (dockStyle == DockStyle.Bottom)
+                pane = DockPanel.DockPaneFactory.CreateDockPane(Content, DockState.DockBottom, true);
+            else if (dockStyle == DockStyle.Left)
+                pane = DockPanel.DockPaneFactory.CreateDockPane(Content, DockState.DockLeft, true);
+            else if (dockStyle == DockStyle.Right)
+                pane = DockPanel.DockPaneFactory.CreateDockPane(Content, DockState.DockRight, true);
+            else if (dockStyle == DockStyle.Fill)
+                pane = DockPanel.DockPaneFactory.CreateDockPane(Content, DockState.Document, true);
+            else
+                return;
+        }
+
+        #endregion
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockOutlineBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockOutlineBase.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockOutlineBase.cs	(revision 8616)
@@ -0,0 +1,161 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    internal abstract class DockOutlineBase
+    {
+        public DockOutlineBase()
+        {
+            Init();
+        }
+
+        private void Init()
+        {
+            SetValues(Rectangle.Empty, null, DockStyle.None, -1);
+            SaveOldValues();
+        }
+
+        private Rectangle m_oldFloatWindowBounds;
+        protected Rectangle OldFloatWindowBounds
+        {
+            get { return m_oldFloatWindowBounds; }
+        }
+
+        private Control m_oldDockTo;
+        protected Control OldDockTo
+        {
+            get { return m_oldDockTo; }
+        }
+
+        private DockStyle m_oldDock;
+        protected DockStyle OldDock
+        {
+            get { return m_oldDock; }
+        }
+
+        private int m_oldContentIndex;
+        protected int OldContentIndex
+        {
+            get { return m_oldContentIndex; }
+        }
+
+        protected bool SameAsOldValue
+        {
+            get
+            {
+                return FloatWindowBounds == OldFloatWindowBounds &&
+                    DockTo == OldDockTo &&
+                    Dock == OldDock &&
+                    ContentIndex == OldContentIndex;
+            }
+        }
+
+        private Rectangle m_floatWindowBounds;
+        public Rectangle FloatWindowBounds
+        {
+            get { return m_floatWindowBounds; }
+        }
+
+        private Control m_dockTo;
+        public Control DockTo
+        {
+            get { return m_dockTo; }
+        }
+
+        private DockStyle m_dock;
+        public DockStyle Dock
+        {
+            get { return m_dock; }
+        }
+
+        private int m_contentIndex;
+        public int ContentIndex
+        {
+            get { return m_contentIndex; }
+        }
+
+        public bool FlagFullEdge
+        {
+            get { return m_contentIndex != 0; }
+        }
+
+        private bool m_flagTestDrop = false;
+        public bool FlagTestDrop
+        {
+            get { return m_flagTestDrop; }
+            set { m_flagTestDrop = value; }
+        }
+
+        private void SaveOldValues()
+        {
+            m_oldDockTo = m_dockTo;
+            m_oldDock = m_dock;
+            m_oldContentIndex = m_contentIndex;
+            m_oldFloatWindowBounds = m_floatWindowBounds;
+        }
+
+        protected abstract void OnShow();
+
+        protected abstract void OnClose();
+
+        private void SetValues(Rectangle floatWindowBounds, Control dockTo, DockStyle dock, int contentIndex)
+        {
+            m_floatWindowBounds = floatWindowBounds;
+            m_dockTo = dockTo;
+            m_dock = dock;
+            m_contentIndex = contentIndex;
+            FlagTestDrop = true;
+        }
+
+        private void TestChange()
+        {
+            if (m_floatWindowBounds != m_oldFloatWindowBounds ||
+                m_dockTo != m_oldDockTo ||
+                m_dock != m_oldDock ||
+                m_contentIndex != m_oldContentIndex)
+                OnShow();
+        }
+
+        public void Show()
+        {
+            SaveOldValues();
+            SetValues(Rectangle.Empty, null, DockStyle.None, -1);
+            TestChange();
+        }
+
+        public void Show(DockPane pane, DockStyle dock)
+        {
+            SaveOldValues();
+            SetValues(Rectangle.Empty, pane, dock, -1);
+            TestChange();
+        }
+
+        public void Show(DockPane pane, int contentIndex)
+        {
+            SaveOldValues();
+            SetValues(Rectangle.Empty, pane, DockStyle.Fill, contentIndex);
+            TestChange();
+        }
+
+        public void Show(DockPanel dockPanel, DockStyle dock, bool fullPanelEdge)
+        {
+            SaveOldValues();
+            SetValues(Rectangle.Empty, dockPanel, dock, fullPanelEdge ? -1 : 0);
+            TestChange();
+        }
+
+        public void Show(Rectangle floatWindowBounds)
+        {
+            SaveOldValues();
+            SetValues(floatWindowBounds, null, DockStyle.None, -1);
+            TestChange();
+        }
+
+        public void Close()
+        {
+            OnClose();
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPane.SplitterControl.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPane.SplitterControl.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPane.SplitterControl.cs	(revision 8616)
@@ -0,0 +1,157 @@
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    partial class DockPane
+    {
+        private class SplitterControl : Control, ISplitterDragSource
+        {
+            DockPane m_pane;
+
+            public SplitterControl(DockPane pane)
+            {
+                SetStyle(ControlStyles.Selectable, false);
+                m_pane = pane;
+            }
+
+            public DockPane DockPane
+            {
+                get { return m_pane; }
+            }
+
+            private DockAlignment m_alignment;
+            public DockAlignment Alignment
+            {
+                get { return m_alignment; }
+                set
+                {
+                    m_alignment = value;
+                    if (m_alignment == DockAlignment.Left || m_alignment == DockAlignment.Right)
+                        Cursor = Cursors.VSplit;
+                    else if (m_alignment == DockAlignment.Top || m_alignment == DockAlignment.Bottom)
+                        Cursor = Cursors.HSplit;
+                    else
+                        Cursor = Cursors.Default;
+
+                    if (DockPane.DockState == DockState.Document)
+                        Invalidate();
+                }
+            }
+
+            protected override void OnPaint(PaintEventArgs e)
+            {
+                base.OnPaint(e);
+
+                if (DockPane.DockState != DockState.Document)
+                    return;
+
+                Graphics g = e.Graphics;
+                Rectangle rect = ClientRectangle;
+                if (Alignment == DockAlignment.Top || Alignment == DockAlignment.Bottom)
+                    g.DrawLine(SystemPens.ControlDark, rect.Left, rect.Bottom - 1, rect.Right, rect.Bottom - 1);
+                else if (Alignment == DockAlignment.Left || Alignment == DockAlignment.Right)
+                    g.DrawLine(SystemPens.ControlDarkDark, rect.Right - 1, rect.Top, rect.Right - 1, rect.Bottom);
+            }
+
+            protected override void OnMouseDown(MouseEventArgs e)
+            {
+                base.OnMouseDown(e);
+
+                if (e.Button != MouseButtons.Left)
+                    return;
+
+                DockPane.DockPanel.BeginDrag(this, Parent.RectangleToScreen(Bounds));
+            }
+
+            #region ISplitterDragSource Members
+
+            void ISplitterDragSource.BeginDrag(Rectangle rectSplitter)
+            {
+            }
+
+            void ISplitterDragSource.EndDrag()
+            {
+            }
+
+            bool ISplitterDragSource.IsVertical
+            {
+                get
+                {
+                    NestedDockingStatus status = DockPane.NestedDockingStatus;
+                    return (status.DisplayingAlignment == DockAlignment.Left ||
+                        status.DisplayingAlignment == DockAlignment.Right);
+                }
+            }
+
+            Rectangle ISplitterDragSource.DragLimitBounds
+            {
+                get
+                {
+                    NestedDockingStatus status = DockPane.NestedDockingStatus;
+                    Rectangle rectLimit = Parent.RectangleToScreen(status.LogicalBounds);
+                    if (((ISplitterDragSource)this).IsVertical)
+                    {
+                        rectLimit.X += MeasurePane.MinSize;
+                        rectLimit.Width -= 2 * MeasurePane.MinSize;
+                    }
+                    else
+                    {
+                        rectLimit.Y += MeasurePane.MinSize;
+                        rectLimit.Height -= 2 * MeasurePane.MinSize;
+                    }
+
+                    return rectLimit;
+                }
+            }
+
+            void ISplitterDragSource.MoveSplitter(int offset)
+            {
+                NestedDockingStatus status = DockPane.NestedDockingStatus;
+                double proportion = status.Proportion;
+                if (status.LogicalBounds.Width <= 0 || status.LogicalBounds.Height <= 0)
+                    return;
+                else if (status.DisplayingAlignment == DockAlignment.Left)
+                    proportion += ((double)offset) / (double)status.LogicalBounds.Width;
+                else if (status.DisplayingAlignment == DockAlignment.Right)
+                    proportion -= ((double)offset) / (double)status.LogicalBounds.Width;
+                else if (status.DisplayingAlignment == DockAlignment.Top)
+                    proportion += ((double)offset) / (double)status.LogicalBounds.Height;
+                else
+                    proportion -= ((double)offset) / (double)status.LogicalBounds.Height;
+
+                DockPane.SetNestedDockingProportion(proportion);
+            }
+
+            #region IDragSource Members
+
+            Control IDragSource.DragControl
+            {
+                get { return this; }
+            }
+
+            #endregion
+
+            #endregion
+        }
+
+        private SplitterControl m_splitter;
+        private SplitterControl Splitter
+        {
+            get { return m_splitter; }
+        }
+
+        internal Rectangle SplitterBounds
+        {
+            set { Splitter.Bounds = value; }
+        }
+
+        internal DockAlignment SplitterAlignment
+        {
+            set { Splitter.Alignment = value; }
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPane.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPane.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPane.cs	(revision 8616)
@@ -0,0 +1,1316 @@
+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;
+
+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
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPaneCaptionBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPaneCaptionBase.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPaneCaptionBase.cs	(revision 8616)
@@ -0,0 +1,100 @@
+using System;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.Security.Permissions;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public abstract class DockPaneCaptionBase : Control
+	{
+		protected internal DockPaneCaptionBase(DockPane pane)
+		{
+			m_dockPane = pane;
+
+			SetStyle(ControlStyles.OptimizedDoubleBuffer |
+                ControlStyles.ResizeRedraw |
+                ControlStyles.UserPaint |
+                ControlStyles.AllPaintingInWmPaint, true);
+			SetStyle(ControlStyles.Selectable, false);
+		}
+
+		private DockPane m_dockPane;
+		protected DockPane DockPane
+		{
+			get	{	return m_dockPane;	}
+		}
+
+		protected DockPane.AppearanceStyle Appearance
+		{
+			get	{	return DockPane.Appearance;	}
+		}
+
+        protected bool HasTabPageContextMenu
+        {
+            get { return DockPane.HasTabPageContextMenu; }
+        }
+
+        protected void ShowTabPageContextMenu(Point position)
+        {
+            DockPane.ShowTabPageContextMenu(this, position);
+        }
+
+        protected override void OnMouseUp(MouseEventArgs e)
+        {
+            base.OnMouseUp(e);
+
+            if (e.Button == MouseButtons.Right)
+                ShowTabPageContextMenu(new Point(e.X, e.Y));
+        }
+
+        protected override void OnMouseDown(MouseEventArgs e)
+        {
+            base.OnMouseDown(e);
+
+            if (e.Button == MouseButtons.Left &&
+			    DockPane.DockPanel.AllowEndUserDocking &&
+                DockPane.AllowDockDragAndDrop &&
+				!DockHelper.IsDockStateAutoHide(DockPane.DockState) &&
+                DockPane.ActiveContent != null)
+				DockPane.DockPanel.BeginDrag(DockPane);
+        }
+
+        [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]         
+        protected override void WndProc(ref Message m)
+        {
+            if (m.Msg == (int)Win32.Msgs.WM_LBUTTONDBLCLK)
+            {
+                if (DockHelper.IsDockStateAutoHide(DockPane.DockState))
+                {
+                    DockPane.DockPanel.ActiveAutoHideContent = null;
+                    return;
+                }
+
+                if (DockPane.IsFloat)
+                    DockPane.RestoreToPanel();
+                else
+                    DockPane.Float();
+            }
+            base.WndProc(ref m);
+        }
+
+		internal void RefreshChanges()
+		{
+            if (IsDisposed)
+                return;
+
+			OnRefreshChanges();
+		}
+
+        protected virtual void OnRightToLeftLayoutChanged()
+        {
+        }
+
+		protected virtual void OnRefreshChanges()
+		{
+		}
+
+		protected internal abstract int MeasureHeight();
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPaneCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPaneCollection.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPaneCollection.cs	(revision 8616)
@@ -0,0 +1,47 @@
+using System;
+using System.Collections.ObjectModel;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public class DockPaneCollection : ReadOnlyCollection<DockPane>
+	{
+        internal DockPaneCollection()
+            : base(new List<DockPane>())
+        {
+        }
+
+		internal int Add(DockPane pane)
+		{
+			if (Items.Contains(pane))
+				return Items.IndexOf(pane);
+
+			Items.Add(pane);
+            return Count - 1;
+		}
+
+		internal void AddAt(DockPane pane, int index)
+		{
+			if (index < 0 || index > Items.Count - 1)
+				return;
+			
+			if (Contains(pane))
+				return;
+
+			Items.Insert(index, pane);
+		}
+
+		internal void Dispose()
+		{
+			for (int i=Count - 1; i>=0; i--)
+				this[i].Close();
+		}
+
+		internal void Remove(DockPane pane)
+		{
+			Items.Remove(pane);
+		}
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPaneStripBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPaneStripBase.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPaneStripBase.cs	(revision 8616)
@@ -0,0 +1,262 @@
+using System;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Collections;
+using System.Collections.Generic;
+using System.Security.Permissions;
+using System.Diagnostics.CodeAnalysis;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public abstract class DockPaneStripBase : Control
+	{
+        [SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]        
+        protected internal class Tab : IDisposable
+        {
+            private IDockContent m_content;
+
+            public Tab(IDockContent content)
+            {
+                m_content = content;
+            }
+
+            ~Tab()
+            {
+                Dispose(false);
+            }
+
+            public IDockContent Content
+            {
+                get { return m_content; }
+            }
+
+            public Form ContentForm
+            {
+                get { return m_content as Form; }
+            }
+
+            public void Dispose()
+            {
+                Dispose(true);
+                GC.SuppressFinalize(this);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+            }
+        }
+
+        [SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]        
+        protected sealed class TabCollection : IEnumerable<Tab>
+        {
+            #region IEnumerable Members
+            IEnumerator<Tab> IEnumerable<Tab>.GetEnumerator()
+            {
+                for (int i = 0; i < Count; i++)
+                    yield return this[i];
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                for (int i = 0; i < Count; i++)
+                    yield return this[i];
+            }
+            #endregion
+
+            internal TabCollection(DockPane pane)
+            {
+                m_dockPane = pane;
+            }
+
+            private DockPane m_dockPane;
+            public DockPane DockPane
+            {
+                get { return m_dockPane; }
+            }
+
+            public int Count
+            {
+                get { return DockPane.DisplayingContents.Count; }
+            }
+
+            public Tab this[int index]
+            {
+                get
+                {
+                    IDockContent content = DockPane.DisplayingContents[index];
+                    if (content == null)
+                        throw (new ArgumentOutOfRangeException("index"));
+                    return content.DockHandler.GetTab(DockPane.TabStripControl);
+                }
+            }
+
+            public bool Contains(Tab tab)
+            {
+                return (IndexOf(tab) != -1);
+            }
+
+            public bool Contains(IDockContent content)
+            {
+                return (IndexOf(content) != -1);
+            }
+
+            public int IndexOf(Tab tab)
+            {
+                if (tab == null)
+                    return -1;
+
+                return DockPane.DisplayingContents.IndexOf(tab.Content);
+            }
+
+            public int IndexOf(IDockContent content)
+            {
+                return DockPane.DisplayingContents.IndexOf(content);
+            }
+        }
+
+		protected DockPaneStripBase(DockPane pane)
+		{
+			m_dockPane = pane;
+
+			SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
+			SetStyle(ControlStyles.Selectable, false);
+            AllowDrop = true;
+		}
+
+		private DockPane m_dockPane;
+		protected DockPane DockPane
+		{
+			get	{	return m_dockPane;	}
+		}
+
+		protected DockPane.AppearanceStyle Appearance
+		{
+			get	{	return DockPane.Appearance;	}
+		}
+
+        private TabCollection m_tabs = null;
+		protected TabCollection Tabs
+		{
+			get
+            {
+                if (m_tabs == null)
+                    m_tabs = new TabCollection(DockPane);
+
+                return m_tabs;
+            }
+		}
+
+		internal void RefreshChanges()
+		{
+            if (IsDisposed)
+                return;
+
+			OnRefreshChanges();
+		}
+
+		protected virtual void OnRefreshChanges()
+		{
+		}
+
+		protected internal abstract int MeasureHeight();
+
+		protected internal abstract void EnsureTabVisible(IDockContent content);
+
+		protected int HitTest()
+		{
+			return HitTest(PointToClient(Control.MousePosition));
+		}
+
+		protected internal abstract int HitTest(Point point);
+
+		protected internal abstract GraphicsPath GetOutline(int index);
+
+        protected internal virtual Tab CreateTab(IDockContent content)
+        {
+            return new Tab(content);
+        }
+
+        protected override void OnMouseDown(MouseEventArgs e)
+        {
+            base.OnMouseDown(e);
+
+            int index = HitTest(e.Location);
+
+            if (index != -1)
+            {
+                if (e.Button == MouseButtons.Middle)
+                {
+                    // Close the specified content.
+                    IDockContent content = Tabs[index].Content;
+                    DockPane.CloseContent(content);
+                }
+                else
+                {
+                    IDockContent content = Tabs[index].Content;
+                    if (DockPane.ActiveContent != content)
+                        DockPane.ActiveContent = content;
+                }
+            }
+
+            if (e.Button == MouseButtons.Left)
+            {
+                if (DockPane.DockPanel.AllowEndUserDocking && DockPane.AllowDockDragAndDrop && DockPane.ActiveContent.DockHandler.AllowEndUserDocking)
+                    DockPane.DockPanel.BeginDrag(DockPane.ActiveContent.DockHandler);
+            }
+        }
+
+        protected bool HasTabPageContextMenu
+        {
+            get { return DockPane.HasTabPageContextMenu; }
+        }
+
+        protected void ShowTabPageContextMenu(Point position)
+        {
+            DockPane.ShowTabPageContextMenu(this, position);
+        }
+
+        protected override void OnMouseUp(MouseEventArgs e)
+        {
+            base.OnMouseUp(e);
+
+            if (e.Button == MouseButtons.Right)
+                ShowTabPageContextMenu(new Point(e.X, e.Y));
+        }
+
+        [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
+		protected override void WndProc(ref Message m)
+		{
+			if (m.Msg == (int)Win32.Msgs.WM_LBUTTONDBLCLK)
+			{
+				base.WndProc(ref m);
+
+				int index = HitTest();
+				if (DockPane.DockPanel.AllowEndUserDocking && index != -1)
+				{
+					IDockContent content = Tabs[index].Content;
+                    if (content.DockHandler.CheckDockState(!content.DockHandler.IsFloat) != DockState.Unknown)
+					    content.DockHandler.IsFloat = !content.DockHandler.IsFloat;	
+				}
+
+				return;
+			}
+
+			base.WndProc(ref m);
+			return;
+		}
+
+        protected override void OnDragOver(DragEventArgs drgevent)
+        {
+            base.OnDragOver(drgevent);
+
+            int index = HitTest();
+            if (index != -1)
+            {
+                IDockContent content = Tabs[index].Content;
+                if (DockPane.ActiveContent != content)
+                    DockPane.ActiveContent = content;
+            }
+        }
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.Appearance.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.Appearance.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.Appearance.cs	(revision 8616)
@@ -0,0 +1,35 @@
+﻿using WeifenLuo.WinFormsUI.Docking.Skins;
+using System.ComponentModel;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public partial class DockPanel
+	{
+        private DockPanelSkin m_dockPanelSkin = DockPanelSkinBuilder.Create(Style.VisualStudio2005);
+        [LocalizedCategory("Category_Docking")]
+        [LocalizedDescription("DockPanel_DockPanelSkin")]
+        public DockPanelSkin Skin
+        {
+            get { return m_dockPanelSkin;  }
+            set { m_dockPanelSkin = value; }
+        }
+        
+        private Style m_dockPanelSkinStyle = Style.VisualStudio2005;
+        [LocalizedCategory("Category_Docking")]
+        [LocalizedDescription("DockPanel_DockPanelSkinStyle")]
+        [DefaultValue(Style.VisualStudio2005)]
+        public Style SkinStyle
+        {
+            get { return m_dockPanelSkinStyle; }
+            set
+            {
+                if (m_dockPanelSkinStyle == value)
+                    return;
+
+                m_dockPanelSkinStyle = value;
+
+                Skin = DockPanelSkinBuilder.Create(m_dockPanelSkinStyle);
+            }
+        }
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.AutoHideWindow.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.AutoHideWindow.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.AutoHideWindow.cs	(revision 8616)
@@ -0,0 +1,613 @@
+using System;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Runtime.InteropServices;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    partial class DockPanel
+    {
+        private class AutoHideWindowControl : Panel, ISplitterDragSource
+        {
+            private class SplitterControl : SplitterBase
+            {
+                public SplitterControl(AutoHideWindowControl autoHideWindow)
+                {
+                    m_autoHideWindow = autoHideWindow;
+                }
+
+                private AutoHideWindowControl m_autoHideWindow;
+                private AutoHideWindowControl AutoHideWindow
+                {
+                    get { return m_autoHideWindow; }
+                }
+
+                protected override int SplitterSize
+                {
+                    get { return Measures.SplitterSize; }
+                }
+
+                protected override void StartDrag()
+                {
+        			AutoHideWindow.DockPanel.BeginDrag(AutoHideWindow, AutoHideWindow.RectangleToScreen(Bounds));
+                }
+            }
+
+            #region consts
+            private const int ANIMATE_TIME = 100;	// in mini-seconds
+            #endregion
+
+            private Timer m_timerMouseTrack;
+            private SplitterControl m_splitter;
+
+            public AutoHideWindowControl(DockPanel dockPanel)
+            {
+                m_dockPanel = dockPanel;
+
+                m_timerMouseTrack = new Timer();
+                m_timerMouseTrack.Tick += new EventHandler(TimerMouseTrack_Tick);
+
+                Visible = false;
+                m_splitter = new SplitterControl(this);
+                Controls.Add(m_splitter);
+            }
+
+            protected override void Dispose(bool disposing)
+            {
+                if (disposing)
+                {
+                    m_timerMouseTrack.Dispose();
+                }
+                base.Dispose(disposing);
+            }
+
+            private DockPanel m_dockPanel = null;
+            public DockPanel DockPanel
+            {
+                get { return m_dockPanel; }
+            }
+
+            private DockPane m_activePane = null;
+            public DockPane ActivePane
+            {
+                get { return m_activePane; }
+            }
+            private void SetActivePane()
+            {
+                DockPane value = (ActiveContent == null ? null : ActiveContent.DockHandler.Pane);
+
+                if (value == m_activePane)
+                    return;
+
+                m_activePane = value;
+            }
+
+            private IDockContent m_activeContent = null;
+            public IDockContent ActiveContent
+            {
+                get { return m_activeContent; }
+                set
+                {
+                    if (value == m_activeContent)
+                        return;
+
+                    if (value != null)
+                    {
+                        if (!DockHelper.IsDockStateAutoHide(value.DockHandler.DockState) || value.DockHandler.DockPanel != DockPanel)
+                            throw (new InvalidOperationException(Strings.DockPanel_ActiveAutoHideContent_InvalidValue));
+                    }
+
+                    DockPanel.SuspendLayout();
+
+                    if (m_activeContent != null)
+                    {
+                        if (m_activeContent.DockHandler.Form.ContainsFocus)
+                            if (!Win32Helper.IsRunningOnMono)
+                                DockPanel.ContentFocusManager.GiveUpFocus(m_activeContent);
+                        AnimateWindow(false);
+                    }
+
+                    m_activeContent = value;
+                    SetActivePane();
+                    if (ActivePane != null)
+                        ActivePane.ActiveContent = m_activeContent;
+
+                    if (m_activeContent != null)
+                        AnimateWindow(true);
+
+                    DockPanel.ResumeLayout();
+                    DockPanel.RefreshAutoHideStrip();
+
+                    SetTimerMouseTrack();
+                }
+            }
+
+            public DockState DockState
+            {
+                get { return ActiveContent == null ? DockState.Unknown : ActiveContent.DockHandler.DockState; }
+            }
+
+            private bool m_flagAnimate = true;
+            private bool FlagAnimate
+            {
+                get { return m_flagAnimate; }
+                set { m_flagAnimate = value; }
+            }
+
+            private bool m_flagDragging = false;
+            internal bool FlagDragging
+            {
+                get { return m_flagDragging; }
+                set
+                {
+                    if (m_flagDragging == value)
+                        return;
+
+                    m_flagDragging = value;
+                    SetTimerMouseTrack();
+                }
+            }
+
+            private void AnimateWindow(bool show)
+            {
+                if (!FlagAnimate && Visible != show)
+                {
+                    Visible = show;
+                    return;
+                }
+
+                Parent.SuspendLayout();
+
+                Rectangle rectSource = GetRectangle(!show);
+                Rectangle rectTarget = GetRectangle(show);
+                int dxLoc, dyLoc;
+                int dWidth, dHeight;
+                dxLoc = dyLoc = dWidth = dHeight = 0;
+                if (DockState == DockState.DockTopAutoHide)
+                    dHeight = show ? 1 : -1;
+                else if (DockState == DockState.DockLeftAutoHide)
+                    dWidth = show ? 1 : -1;
+                else if (DockState == DockState.DockRightAutoHide)
+                {
+                    dxLoc = show ? -1 : 1;
+                    dWidth = show ? 1 : -1;
+                }
+                else if (DockState == DockState.DockBottomAutoHide)
+                {
+                    dyLoc = (show ? -1 : 1);
+                    dHeight = (show ? 1 : -1);
+                }
+
+                if (show)
+                {
+                    Bounds = DockPanel.GetAutoHideWindowBounds(new Rectangle(-rectTarget.Width, -rectTarget.Height, rectTarget.Width, rectTarget.Height));
+                    if (Visible == false)
+                        Visible = true;
+                    PerformLayout();
+                }
+
+                SuspendLayout();
+
+                LayoutAnimateWindow(rectSource);
+                if (Visible == false)
+                    Visible = true;
+
+                int speedFactor = 1;
+                int totalPixels = (rectSource.Width != rectTarget.Width) ?
+                    Math.Abs(rectSource.Width - rectTarget.Width) :
+                    Math.Abs(rectSource.Height - rectTarget.Height);
+                int remainPixels = totalPixels;
+                DateTime startingTime = DateTime.Now;
+                while (rectSource != rectTarget)
+                {
+                    DateTime startPerMove = DateTime.Now;
+
+                    rectSource.X += dxLoc * speedFactor;
+                    rectSource.Y += dyLoc * speedFactor;
+                    rectSource.Width += dWidth * speedFactor;
+                    rectSource.Height += dHeight * speedFactor;
+                    if (Math.Sign(rectTarget.X - rectSource.X) != Math.Sign(dxLoc))
+                        rectSource.X = rectTarget.X;
+                    if (Math.Sign(rectTarget.Y - rectSource.Y) != Math.Sign(dyLoc))
+                        rectSource.Y = rectTarget.Y;
+                    if (Math.Sign(rectTarget.Width - rectSource.Width) != Math.Sign(dWidth))
+                        rectSource.Width = rectTarget.Width;
+                    if (Math.Sign(rectTarget.Height - rectSource.Height) != Math.Sign(dHeight))
+                        rectSource.Height = rectTarget.Height;
+
+                    LayoutAnimateWindow(rectSource);
+                    if (Parent != null)
+                        Parent.Update();
+
+                    remainPixels -= speedFactor;
+
+                    while (true)
+                    {
+                        TimeSpan time = new TimeSpan(0, 0, 0, 0, ANIMATE_TIME);
+                        TimeSpan elapsedPerMove = DateTime.Now - startPerMove;
+                        TimeSpan elapsedTime = DateTime.Now - startingTime;
+                        if (((int)((time - elapsedTime).TotalMilliseconds)) <= 0)
+                        {
+                            speedFactor = remainPixels;
+                            break;
+                        }
+                        else
+                            speedFactor = remainPixels * (int)elapsedPerMove.TotalMilliseconds / (int)((time - elapsedTime).TotalMilliseconds);
+                        if (speedFactor >= 1)
+                            break;
+                    }
+                }
+                ResumeLayout();
+                Parent.ResumeLayout();
+            }
+
+            private void LayoutAnimateWindow(Rectangle rect)
+            {
+                Bounds = DockPanel.GetAutoHideWindowBounds(rect);
+
+                Rectangle rectClient = ClientRectangle;
+
+                if (DockState == DockState.DockLeftAutoHide)
+                    ActivePane.Location = new Point(rectClient.Right - 2 - Measures.SplitterSize - ActivePane.Width, ActivePane.Location.Y);
+                else if (DockState == DockState.DockTopAutoHide)
+                    ActivePane.Location = new Point(ActivePane.Location.X, rectClient.Bottom - 2 - Measures.SplitterSize - ActivePane.Height);
+            }
+
+            private Rectangle GetRectangle(bool show)
+            {
+                if (DockState == DockState.Unknown)
+                    return Rectangle.Empty;
+
+                Rectangle rect = DockPanel.AutoHideWindowRectangle;
+
+                if (show)
+                    return rect;
+
+                if (DockState == DockState.DockLeftAutoHide)
+                    rect.Width = 0;
+                else if (DockState == DockState.DockRightAutoHide)
+                {
+                    rect.X += rect.Width;
+                    rect.Width = 0;
+                }
+                else if (DockState == DockState.DockTopAutoHide)
+                    rect.Height = 0;
+                else
+                {
+                    rect.Y += rect.Height;
+                    rect.Height = 0;
+                }
+
+                return rect;
+            }
+
+            private void SetTimerMouseTrack()
+            {
+                if (ActivePane == null || ActivePane.IsActivated || FlagDragging)
+                {
+                    m_timerMouseTrack.Enabled = false;
+                    return;
+                }
+
+                // start the timer
+                int hovertime = SystemInformation.MouseHoverTime ;
+
+                // assign a default value 400 in case of setting Timer.Interval invalid value exception
+                if (hovertime <= 0)
+                    hovertime = 400;
+
+                m_timerMouseTrack.Interval = 2 * (int)hovertime;
+                m_timerMouseTrack.Enabled = true;
+            }
+
+            protected virtual Rectangle DisplayingRectangle
+            {
+                get
+                {
+                    Rectangle rect = ClientRectangle;
+
+                    // exclude the border and the splitter
+                    if (DockState == DockState.DockBottomAutoHide)
+                    {
+                        rect.Y += 2 + Measures.SplitterSize;
+                        rect.Height -= 2 + Measures.SplitterSize;
+                    }
+                    else if (DockState == DockState.DockRightAutoHide)
+                    {
+                        rect.X += 2 + Measures.SplitterSize;
+                        rect.Width -= 2 + Measures.SplitterSize;
+                    }
+                    else if (DockState == DockState.DockTopAutoHide)
+                        rect.Height -= 2 + Measures.SplitterSize;
+                    else if (DockState == DockState.DockLeftAutoHide)
+                        rect.Width -= 2 + Measures.SplitterSize;
+
+                    return rect;
+                }
+            }
+
+            protected override void OnLayout(LayoutEventArgs levent)
+            {
+                DockPadding.All = 0;
+                if (DockState == DockState.DockLeftAutoHide)
+                {
+                    DockPadding.Right = 2;
+                    m_splitter.Dock = DockStyle.Right;
+                }
+                else if (DockState == DockState.DockRightAutoHide)
+                {
+                    DockPadding.Left = 2;
+                    m_splitter.Dock = DockStyle.Left;
+                }
+                else if (DockState == DockState.DockTopAutoHide)
+                {
+                    DockPadding.Bottom = 2;
+                    m_splitter.Dock = DockStyle.Bottom;
+                }
+                else if (DockState == DockState.DockBottomAutoHide)
+                {
+                    DockPadding.Top = 2;
+                    m_splitter.Dock = DockStyle.Top;
+                }
+
+                Rectangle rectDisplaying = DisplayingRectangle;
+                Rectangle rectHidden = new Rectangle(-rectDisplaying.Width, rectDisplaying.Y, rectDisplaying.Width, rectDisplaying.Height);
+                foreach (Control c in Controls)
+                {
+                    DockPane pane = c as DockPane;
+                    if (pane == null)
+                        continue;
+                    
+                    
+                    if (pane == ActivePane)
+                        pane.Bounds = rectDisplaying;
+                    else
+                        pane.Bounds = rectHidden;
+                }
+
+                base.OnLayout(levent);
+            }
+
+            protected override void OnPaint(PaintEventArgs e)
+            {
+                // Draw the border
+                Graphics g = e.Graphics;
+
+                if (DockState == DockState.DockBottomAutoHide)
+                    g.DrawLine(SystemPens.ControlLightLight, 0, 1, ClientRectangle.Right, 1);
+                else if (DockState == DockState.DockRightAutoHide)
+                    g.DrawLine(SystemPens.ControlLightLight, 1, 0, 1, ClientRectangle.Bottom);
+                else if (DockState == DockState.DockTopAutoHide)
+                {
+                    g.DrawLine(SystemPens.ControlDark, 0, ClientRectangle.Height - 2, ClientRectangle.Right, ClientRectangle.Height - 2);
+                    g.DrawLine(SystemPens.ControlDarkDark, 0, ClientRectangle.Height - 1, ClientRectangle.Right, ClientRectangle.Height - 1);
+                }
+                else if (DockState == DockState.DockLeftAutoHide)
+                {
+                    g.DrawLine(SystemPens.ControlDark, ClientRectangle.Width - 2, 0, ClientRectangle.Width - 2, ClientRectangle.Bottom);
+                    g.DrawLine(SystemPens.ControlDarkDark, ClientRectangle.Width - 1, 0, ClientRectangle.Width - 1, ClientRectangle.Bottom);
+                }
+
+                base.OnPaint(e);
+            }
+
+            public void RefreshActiveContent()
+            {
+                if (ActiveContent == null)
+                    return;
+
+                if (!DockHelper.IsDockStateAutoHide(ActiveContent.DockHandler.DockState))
+                {
+                    FlagAnimate = false;
+                    ActiveContent = null;
+                    FlagAnimate = true;
+                }
+            }
+
+            public void RefreshActivePane()
+            {
+                SetTimerMouseTrack();
+            }
+
+            private void TimerMouseTrack_Tick(object sender, EventArgs e)
+            {
+                if (IsDisposed)
+                    return;
+
+                if (ActivePane == null || ActivePane.IsActivated)
+                {
+                    m_timerMouseTrack.Enabled = false;
+                    return;
+                }
+
+                DockPane pane = ActivePane;
+                Point ptMouseInAutoHideWindow = PointToClient(Control.MousePosition);
+                Point ptMouseInDockPanel = DockPanel.PointToClient(Control.MousePosition);
+
+                Rectangle rectTabStrip = DockPanel.GetTabStripRectangle(pane.DockState);
+
+                if (!ClientRectangle.Contains(ptMouseInAutoHideWindow) && !rectTabStrip.Contains(ptMouseInDockPanel))
+                {
+                    ActiveContent = null;
+                    m_timerMouseTrack.Enabled = false;
+                }
+            }
+
+            #region ISplitterDragSource Members
+
+            void ISplitterDragSource.BeginDrag(Rectangle rectSplitter)
+            {
+                FlagDragging = true;
+            }
+
+            void ISplitterDragSource.EndDrag()
+            {
+                FlagDragging = false;
+            }
+
+            bool ISplitterDragSource.IsVertical
+            {
+                get { return (DockState == DockState.DockLeftAutoHide || DockState == DockState.DockRightAutoHide); }
+            }
+
+            Rectangle ISplitterDragSource.DragLimitBounds
+            {
+                get
+                {
+                    Rectangle rectLimit = DockPanel.DockArea;
+
+                    if ((this as ISplitterDragSource).IsVertical)
+                    {
+                        rectLimit.X += MeasurePane.MinSize;
+                        rectLimit.Width -= 2 * MeasurePane.MinSize;
+                    }
+                    else
+                    {
+                        rectLimit.Y += MeasurePane.MinSize;
+                        rectLimit.Height -= 2 * MeasurePane.MinSize;
+                    }
+
+                    return DockPanel.RectangleToScreen(rectLimit);
+                }
+            }
+
+            void ISplitterDragSource.MoveSplitter(int offset)
+            {
+                Rectangle rectDockArea = DockPanel.DockArea;
+                IDockContent content = ActiveContent;
+                if (DockState == DockState.DockLeftAutoHide && rectDockArea.Width > 0)
+                {
+                    if (content.DockHandler.AutoHidePortion < 1)
+                        content.DockHandler.AutoHidePortion += ((double)offset) / (double)rectDockArea.Width;
+                    else
+                        content.DockHandler.AutoHidePortion = Width + offset;
+                }
+                else if (DockState == DockState.DockRightAutoHide && rectDockArea.Width > 0)
+                {
+                    if (content.DockHandler.AutoHidePortion < 1)
+                        content.DockHandler.AutoHidePortion -= ((double)offset) / (double)rectDockArea.Width;
+                    else
+                        content.DockHandler.AutoHidePortion = Width - offset;
+                }
+                else if (DockState == DockState.DockBottomAutoHide && rectDockArea.Height > 0)
+                {
+                    if (content.DockHandler.AutoHidePortion < 1)
+                        content.DockHandler.AutoHidePortion -= ((double)offset) / (double)rectDockArea.Height;
+                    else
+                        content.DockHandler.AutoHidePortion = Height - offset;
+                }
+                else if (DockState == DockState.DockTopAutoHide && rectDockArea.Height > 0)
+                {
+                    if (content.DockHandler.AutoHidePortion < 1)
+                        content.DockHandler.AutoHidePortion += ((double)offset) / (double)rectDockArea.Height;
+                    else
+                        content.DockHandler.AutoHidePortion = Height + offset;
+                }
+            }
+
+            #region IDragSource Members
+
+            Control IDragSource.DragControl
+            {
+                get { return this; }
+            }
+
+            #endregion
+
+            #endregion
+        }
+
+        private AutoHideWindowControl AutoHideWindow
+        {
+            get { return m_autoHideWindow; }
+        }
+
+        internal Control AutoHideControl
+        {
+            get { return m_autoHideWindow; }
+        }
+
+        internal void RefreshActiveAutoHideContent()
+        {
+            AutoHideWindow.RefreshActiveContent();
+        }
+
+        internal Rectangle AutoHideWindowRectangle
+        {
+            get
+            {
+                DockState state = AutoHideWindow.DockState;
+                Rectangle rectDockArea = DockArea;
+                if (ActiveAutoHideContent == null)
+                    return Rectangle.Empty;
+
+                if (Parent == null)
+                    return Rectangle.Empty;
+
+                Rectangle rect = Rectangle.Empty;
+                double autoHideSize = ActiveAutoHideContent.DockHandler.AutoHidePortion;
+                if (state == DockState.DockLeftAutoHide)
+                {
+                    if (autoHideSize < 1)
+                        autoHideSize = rectDockArea.Width * autoHideSize;
+                    if (autoHideSize > rectDockArea.Width - MeasurePane.MinSize)
+                        autoHideSize = rectDockArea.Width - MeasurePane.MinSize;
+                    rect.X = rectDockArea.X;
+                    rect.Y = rectDockArea.Y;
+                    rect.Width = (int)autoHideSize;
+                    rect.Height = rectDockArea.Height;
+                }
+                else if (state == DockState.DockRightAutoHide)
+                {
+                    if (autoHideSize < 1)
+                        autoHideSize = rectDockArea.Width * autoHideSize;
+                    if (autoHideSize > rectDockArea.Width - MeasurePane.MinSize)
+                        autoHideSize = rectDockArea.Width - MeasurePane.MinSize;
+                    rect.X = rectDockArea.X + rectDockArea.Width - (int)autoHideSize;
+                    rect.Y = rectDockArea.Y;
+                    rect.Width = (int)autoHideSize;
+                    rect.Height = rectDockArea.Height;
+                }
+                else if (state == DockState.DockTopAutoHide)
+                {
+                    if (autoHideSize < 1)
+                        autoHideSize = rectDockArea.Height * autoHideSize;
+                    if (autoHideSize > rectDockArea.Height - MeasurePane.MinSize)
+                        autoHideSize = rectDockArea.Height - MeasurePane.MinSize;
+                    rect.X = rectDockArea.X;
+                    rect.Y = rectDockArea.Y;
+                    rect.Width = rectDockArea.Width;
+                    rect.Height = (int)autoHideSize;
+                }
+                else if (state == DockState.DockBottomAutoHide)
+                {
+                    if (autoHideSize < 1)
+                        autoHideSize = rectDockArea.Height * autoHideSize;
+                    if (autoHideSize > rectDockArea.Height - MeasurePane.MinSize)
+                        autoHideSize = rectDockArea.Height - MeasurePane.MinSize;
+                    rect.X = rectDockArea.X;
+                    rect.Y = rectDockArea.Y + rectDockArea.Height - (int)autoHideSize;
+                    rect.Width = rectDockArea.Width;
+                    rect.Height = (int)autoHideSize;
+                }
+
+                return rect;
+            }
+        }
+
+        internal Rectangle GetAutoHideWindowBounds(Rectangle rectAutoHideWindow)
+        {
+            if (DocumentStyle == DocumentStyle.SystemMdi ||
+                DocumentStyle == DocumentStyle.DockingMdi)
+                return (Parent == null) ? Rectangle.Empty : Parent.RectangleToClient(RectangleToScreen(rectAutoHideWindow));
+            else
+                return rectAutoHideWindow;
+        }
+
+        internal void RefreshAutoHideStrip()
+        {
+            AutoHideStripControl.RefreshChanges();
+        }
+
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.DockDragHandler.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.DockDragHandler.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.DockDragHandler.cs	(revision 8616)
@@ -0,0 +1,816 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.ComponentModel;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    partial class DockPanel
+    {
+        private sealed class DockDragHandler : DragHandler
+        {
+            private class DockIndicator : DragForm
+            {
+                #region IHitTest
+                private interface IHitTest
+                {
+                    DockStyle HitTest(Point pt);
+                    DockStyle Status { get;	set;	}
+                }
+                #endregion
+
+                #region PanelIndicator
+                private class PanelIndicator : PictureBox, IHitTest
+                {
+                    private static Image _imagePanelLeft = Resources.DockIndicator_PanelLeft;
+                    private static Image _imagePanelRight = Resources.DockIndicator_PanelRight;
+                    private static Image _imagePanelTop = Resources.DockIndicator_PanelTop;
+                    private static Image _imagePanelBottom = Resources.DockIndicator_PanelBottom;
+                    private static Image _imagePanelFill = Resources.DockIndicator_PanelFill;
+                    private static Image _imagePanelLeftActive = Resources.DockIndicator_PanelLeft_Active;
+                    private static Image _imagePanelRightActive = Resources.DockIndicator_PanelRight_Active;
+                    private static Image _imagePanelTopActive = Resources.DockIndicator_PanelTop_Active;
+                    private static Image _imagePanelBottomActive = Resources.DockIndicator_PanelBottom_Active;
+                    private static Image _imagePanelFillActive = Resources.DockIndicator_PanelFill_Active;
+
+                    public PanelIndicator(DockStyle dockStyle)
+                    {
+                        m_dockStyle = dockStyle;
+                        SizeMode = PictureBoxSizeMode.AutoSize;
+                        Image = ImageInactive;
+                    }
+
+                    private DockStyle m_dockStyle;
+                    private DockStyle DockStyle
+                    {
+                        get { return m_dockStyle; }
+                    }
+
+                    private DockStyle m_status;
+                    public DockStyle Status
+                    {
+                        get { return m_status; }
+                        set
+                        {
+                            if (value != DockStyle && value != DockStyle.None)
+                                throw new InvalidEnumArgumentException();
+
+                            if (m_status == value)
+                                return;
+
+                            m_status = value;
+                            IsActivated = (m_status != DockStyle.None);
+                        }
+                    }
+
+                    private Image ImageInactive
+                    {
+                        get
+                        {
+                            if (DockStyle == DockStyle.Left)
+                                return _imagePanelLeft;
+                            else if (DockStyle == DockStyle.Right)
+                                return _imagePanelRight;
+                            else if (DockStyle == DockStyle.Top)
+                                return _imagePanelTop;
+                            else if (DockStyle == DockStyle.Bottom)
+                                return _imagePanelBottom;
+                            else if (DockStyle == DockStyle.Fill)
+                                return _imagePanelFill;
+                            else
+                                return null;
+                        }
+                    }
+
+                    private Image ImageActive
+                    {
+                        get
+                        {
+                            if (DockStyle == DockStyle.Left)
+                                return _imagePanelLeftActive;
+                            else if (DockStyle == DockStyle.Right)
+                                return _imagePanelRightActive;
+                            else if (DockStyle == DockStyle.Top)
+                                return _imagePanelTopActive;
+                            else if (DockStyle == DockStyle.Bottom)
+                                return _imagePanelBottomActive;
+                            else if (DockStyle == DockStyle.Fill)
+                                return _imagePanelFillActive;
+                            else
+                                return null;
+                        }
+                    }
+
+                    private bool m_isActivated = false;
+                    private bool IsActivated
+                    {
+                        get { return m_isActivated; }
+                        set
+                        {
+                            m_isActivated = value;
+                            Image = IsActivated ? ImageActive : ImageInactive;
+                        }
+                    }
+
+                    public DockStyle HitTest(Point pt)
+                    {
+                        return this.Visible && ClientRectangle.Contains(PointToClient(pt)) ? DockStyle : DockStyle.None;
+                    }
+                }
+                #endregion PanelIndicator
+
+                #region PaneIndicator
+                private class PaneIndicator : PictureBox, IHitTest
+                {
+                    private struct HotSpotIndex
+                    {
+                        public HotSpotIndex(int x, int y, DockStyle dockStyle)
+                        {
+                            m_x = x;
+                            m_y = y;
+                            m_dockStyle = dockStyle;
+                        }
+
+                        private int m_x;
+                        public int X
+                        {
+                            get { return m_x; }
+                        }
+
+                        private int m_y;
+                        public int Y
+                        {
+                            get { return m_y; }
+                        }
+
+                        private DockStyle m_dockStyle;
+                        public DockStyle DockStyle
+                        {
+                            get { return m_dockStyle; }
+                        }
+                    }
+
+                    private static Bitmap _bitmapPaneDiamond = Resources.DockIndicator_PaneDiamond;
+                    private static Bitmap _bitmapPaneDiamondLeft = Resources.DockIndicator_PaneDiamond_Left;
+                    private static Bitmap _bitmapPaneDiamondRight = Resources.DockIndicator_PaneDiamond_Right;
+                    private static Bitmap _bitmapPaneDiamondTop = Resources.DockIndicator_PaneDiamond_Top;
+                    private static Bitmap _bitmapPaneDiamondBottom = Resources.DockIndicator_PaneDiamond_Bottom;
+                    private static Bitmap _bitmapPaneDiamondFill = Resources.DockIndicator_PaneDiamond_Fill;
+                    private static Bitmap _bitmapPaneDiamondHotSpot = Resources.DockIndicator_PaneDiamond_HotSpot;
+                    private static Bitmap _bitmapPaneDiamondHotSpotIndex = Resources.DockIndicator_PaneDiamond_HotSpotIndex;
+                    private static HotSpotIndex[] _hotSpots = new HotSpotIndex[]
+			{
+				new HotSpotIndex(1, 0, DockStyle.Top),
+				new HotSpotIndex(0, 1, DockStyle.Left),
+				new HotSpotIndex(1, 1, DockStyle.Fill),
+				new HotSpotIndex(2, 1, DockStyle.Right),
+				new HotSpotIndex(1, 2, DockStyle.Bottom)
+			};
+                    private static GraphicsPath _displayingGraphicsPath = DrawHelper.CalculateGraphicsPathFromBitmap(_bitmapPaneDiamond);
+
+                    public PaneIndicator()
+                    {
+                        SizeMode = PictureBoxSizeMode.AutoSize;
+                        Image = _bitmapPaneDiamond;
+                        Region = new Region(DisplayingGraphicsPath);
+                    }
+
+                    public static GraphicsPath DisplayingGraphicsPath
+                    {
+                        get { return _displayingGraphicsPath; }
+                    }
+
+                    public DockStyle HitTest(Point pt)
+                    {
+                        if (!Visible)
+                            return DockStyle.None;
+
+                        pt = PointToClient(pt);
+                        if (!ClientRectangle.Contains(pt))
+                            return DockStyle.None;
+
+                        for (int i = _hotSpots.GetLowerBound(0); i <= _hotSpots.GetUpperBound(0); i++)
+                        {
+                            if (_bitmapPaneDiamondHotSpot.GetPixel(pt.X, pt.Y) == _bitmapPaneDiamondHotSpotIndex.GetPixel(_hotSpots[i].X, _hotSpots[i].Y))
+                                return _hotSpots[i].DockStyle;
+                        }
+
+                        return DockStyle.None;
+                    }
+
+                    private DockStyle m_status = DockStyle.None;
+                    public DockStyle Status
+                    {
+                        get { return m_status; }
+                        set
+                        {
+                            m_status = value;
+                            if (m_status == DockStyle.None)
+                                Image = _bitmapPaneDiamond;
+                            else if (m_status == DockStyle.Left)
+                                Image = _bitmapPaneDiamondLeft;
+                            else if (m_status == DockStyle.Right)
+                                Image = _bitmapPaneDiamondRight;
+                            else if (m_status == DockStyle.Top)
+                                Image = _bitmapPaneDiamondTop;
+                            else if (m_status == DockStyle.Bottom)
+                                Image = _bitmapPaneDiamondBottom;
+                            else if (m_status == DockStyle.Fill)
+                                Image = _bitmapPaneDiamondFill;
+                        }
+                    }
+                }
+                #endregion PaneIndicator
+
+                #region consts
+                private int _PanelIndicatorMargin = 10;
+                #endregion
+
+                private DockDragHandler m_dragHandler;
+
+                public DockIndicator(DockDragHandler dragHandler)
+                {
+                    m_dragHandler = dragHandler;
+                    Controls.AddRange(new Control[] {
+			            PaneDiamond,
+			            PanelLeft,
+			            PanelRight,
+			            PanelTop,
+			            PanelBottom,
+			            PanelFill
+			            });
+                    Region = new Region(Rectangle.Empty);
+                }
+
+                private PaneIndicator m_paneDiamond = null;
+                private PaneIndicator PaneDiamond
+                {
+                    get
+                    {
+                        if (m_paneDiamond == null)
+                            m_paneDiamond = new PaneIndicator();
+
+                        return m_paneDiamond;
+                    }
+                }
+
+                private PanelIndicator m_panelLeft = null;
+                private PanelIndicator PanelLeft
+                {
+                    get
+                    {
+                        if (m_panelLeft == null)
+                            m_panelLeft = new PanelIndicator(DockStyle.Left);
+
+                        return m_panelLeft;
+                    }
+                }
+
+                private PanelIndicator m_panelRight = null;
+                private PanelIndicator PanelRight
+                {
+                    get
+                    {
+                        if (m_panelRight == null)
+                            m_panelRight = new PanelIndicator(DockStyle.Right);
+
+                        return m_panelRight;
+                    }
+                }
+
+                private PanelIndicator m_panelTop = null;
+                private PanelIndicator PanelTop
+                {
+                    get
+                    {
+                        if (m_panelTop == null)
+                            m_panelTop = new PanelIndicator(DockStyle.Top);
+
+                        return m_panelTop;
+                    }
+                }
+
+                private PanelIndicator m_panelBottom = null;
+                private PanelIndicator PanelBottom
+                {
+                    get
+                    {
+                        if (m_panelBottom == null)
+                            m_panelBottom = new PanelIndicator(DockStyle.Bottom);
+
+                        return m_panelBottom;
+                    }
+                }
+
+                private PanelIndicator m_panelFill = null;
+                private PanelIndicator PanelFill
+                {
+                    get
+                    {
+                        if (m_panelFill == null)
+                            m_panelFill = new PanelIndicator(DockStyle.Fill);
+
+                        return m_panelFill;
+                    }
+                }
+
+                private bool m_fullPanelEdge = false;
+                public bool FullPanelEdge
+                {
+                    get { return m_fullPanelEdge; }
+                    set
+                    {
+                        if (m_fullPanelEdge == value)
+                            return;
+
+                        m_fullPanelEdge = value;
+                        RefreshChanges();
+                    }
+                }
+
+                public DockDragHandler DragHandler
+                {
+                    get { return m_dragHandler; }
+                }
+
+                public DockPanel DockPanel
+                {
+                    get { return DragHandler.DockPanel; }
+                }
+
+                private DockPane m_dockPane = null;
+                public DockPane DockPane
+                {
+                    get { return m_dockPane; }
+                    internal set
+                    {
+                        if (m_dockPane == value)
+                            return;
+
+                        DockPane oldDisplayingPane = DisplayingPane;
+                        m_dockPane = value;
+                        if (oldDisplayingPane != DisplayingPane)
+                            RefreshChanges();
+                    }
+                }
+
+                private IHitTest m_hitTest = null;
+                private IHitTest HitTestResult
+                {
+                    get { return m_hitTest; }
+                    set
+                    {
+                        if (m_hitTest == value)
+                            return;
+
+                        if (m_hitTest != null)
+                            m_hitTest.Status = DockStyle.None;
+
+                        m_hitTest = value;
+                    }
+                }
+
+                private DockPane DisplayingPane
+                {
+                    get { return ShouldPaneDiamondVisible() ? DockPane : null; }
+                }
+
+                private void RefreshChanges()
+                {
+                    Region region = new Region(Rectangle.Empty);
+                    Rectangle rectDockArea = FullPanelEdge ? DockPanel.DockArea : DockPanel.DocumentWindowBounds;
+
+                    rectDockArea = RectangleToClient(DockPanel.RectangleToScreen(rectDockArea));
+                    if (ShouldPanelIndicatorVisible(DockState.DockLeft))
+                    {
+                        PanelLeft.Location = new Point(rectDockArea.X + _PanelIndicatorMargin, rectDockArea.Y + (rectDockArea.Height - PanelRight.Height) / 2);
+                        PanelLeft.Visible = true;
+                        region.Union(PanelLeft.Bounds);
+                    }
+                    else
+                        PanelLeft.Visible = false;
+
+                    if (ShouldPanelIndicatorVisible(DockState.DockRight))
+                    {
+                        PanelRight.Location = new Point(rectDockArea.X + rectDockArea.Width - PanelRight.Width - _PanelIndicatorMargin, rectDockArea.Y + (rectDockArea.Height - PanelRight.Height) / 2);
+                        PanelRight.Visible = true;
+                        region.Union(PanelRight.Bounds);
+                    }
+                    else
+                        PanelRight.Visible = false;
+
+                    if (ShouldPanelIndicatorVisible(DockState.DockTop))
+                    {
+                        PanelTop.Location = new Point(rectDockArea.X + (rectDockArea.Width - PanelTop.Width) / 2, rectDockArea.Y + _PanelIndicatorMargin);
+                        PanelTop.Visible = true;
+                        region.Union(PanelTop.Bounds);
+                    }
+                    else
+                        PanelTop.Visible = false;
+
+                    if (ShouldPanelIndicatorVisible(DockState.DockBottom))
+                    {
+                        PanelBottom.Location = new Point(rectDockArea.X + (rectDockArea.Width - PanelBottom.Width) / 2, rectDockArea.Y + rectDockArea.Height - PanelBottom.Height - _PanelIndicatorMargin);
+                        PanelBottom.Visible = true;
+                        region.Union(PanelBottom.Bounds);
+                    }
+                    else
+                        PanelBottom.Visible = false;
+
+                    if (ShouldPanelIndicatorVisible(DockState.Document))
+                    {
+                        Rectangle rectDocumentWindow = RectangleToClient(DockPanel.RectangleToScreen(DockPanel.DocumentWindowBounds));
+                        PanelFill.Location = new Point(rectDocumentWindow.X + (rectDocumentWindow.Width - PanelFill.Width) / 2, rectDocumentWindow.Y + (rectDocumentWindow.Height - PanelFill.Height) / 2);
+                        PanelFill.Visible = true;
+                        region.Union(PanelFill.Bounds);
+                    }
+                    else
+                        PanelFill.Visible = false;
+
+                    if (ShouldPaneDiamondVisible())
+                    {
+                        Rectangle rect = RectangleToClient(DockPane.RectangleToScreen(DockPane.ClientRectangle));
+                        PaneDiamond.Location = new Point(rect.Left + (rect.Width - PaneDiamond.Width) / 2, rect.Top + (rect.Height - PaneDiamond.Height) / 2);
+                        PaneDiamond.Visible = true;
+                        using (GraphicsPath graphicsPath = PaneIndicator.DisplayingGraphicsPath.Clone() as GraphicsPath)
+                        {
+                            Point[] pts = new Point[]
+						{
+							new Point(PaneDiamond.Left, PaneDiamond.Top),
+							new Point(PaneDiamond.Right, PaneDiamond.Top),
+							new Point(PaneDiamond.Left, PaneDiamond.Bottom)
+						};
+                            using (Matrix matrix = new Matrix(PaneDiamond.ClientRectangle, pts))
+                            {
+                                graphicsPath.Transform(matrix);
+                            }
+                            region.Union(graphicsPath);
+                        }
+                    }
+                    else
+                        PaneDiamond.Visible = false;
+
+                    Region = region;
+                }
+
+                private bool ShouldPanelIndicatorVisible(DockState dockState)
+                {
+                    if (!Visible)
+                        return false;
+
+                    if (DockPanel.DockWindows[dockState].Visible)
+                        return false;
+
+                    return DragHandler.DragSource.IsDockStateValid(dockState);
+                }
+
+                private bool ShouldPaneDiamondVisible()
+                {
+                    if (DockPane == null)
+                        return false;
+
+                    if (!DockPanel.AllowEndUserNestedDocking)
+                        return false;
+
+                    return DragHandler.DragSource.CanDockTo(DockPane);
+                }
+
+                public override void Show(bool bActivate)
+                {
+                    base.Show(bActivate);
+                    Bounds = SystemInformation.VirtualScreen;
+                    RefreshChanges();
+                }
+
+                public void TestDrop()
+                {
+                    Point pt = Control.MousePosition;
+                    DockPane = DockHelper.PaneAtPoint(pt, DockPanel);
+
+                    if (TestDrop(PanelLeft, pt) != DockStyle.None)
+                        HitTestResult = PanelLeft;
+                    else if (TestDrop(PanelRight, pt) != DockStyle.None)
+                        HitTestResult = PanelRight;
+                    else if (TestDrop(PanelTop, pt) != DockStyle.None)
+                        HitTestResult = PanelTop;
+                    else if (TestDrop(PanelBottom, pt) != DockStyle.None)
+                        HitTestResult = PanelBottom;
+                    else if (TestDrop(PanelFill, pt) != DockStyle.None)
+                        HitTestResult = PanelFill;
+                    else if (TestDrop(PaneDiamond, pt) != DockStyle.None)
+                        HitTestResult = PaneDiamond;
+                    else
+                        HitTestResult = null;
+
+                    if (HitTestResult != null)
+                    {
+                        if (HitTestResult is PaneIndicator)
+                            DragHandler.Outline.Show(DockPane, HitTestResult.Status);
+                        else
+                            DragHandler.Outline.Show(DockPanel, HitTestResult.Status, FullPanelEdge);
+                    }
+                }
+
+                private static DockStyle TestDrop(IHitTest hitTest, Point pt)
+                {
+                    return hitTest.Status = hitTest.HitTest(pt);
+                }
+            }
+
+            private class DockOutline : DockOutlineBase
+            {
+                public DockOutline()
+                {
+                    m_dragForm = new DragForm();
+                    SetDragForm(Rectangle.Empty);
+                    DragForm.BackColor = SystemColors.ActiveCaption;
+                    DragForm.Opacity = 0.5;
+                    DragForm.Show(false);
+                }
+
+                DragForm m_dragForm;
+                private DragForm DragForm
+                {
+                    get { return m_dragForm; }
+                }
+
+                protected override void OnShow()
+                {
+                    CalculateRegion();
+                }
+
+                protected override void OnClose()
+                {
+                    DragForm.Close();
+                }
+
+                private void CalculateRegion()
+                {
+                    if (SameAsOldValue)
+                        return;
+
+                    if (!FloatWindowBounds.IsEmpty)
+                        SetOutline(FloatWindowBounds);
+                    else if (DockTo is DockPanel)
+                        SetOutline(DockTo as DockPanel, Dock, (ContentIndex != 0));
+                    else if (DockTo is DockPane)
+                        SetOutline(DockTo as DockPane, Dock, ContentIndex);
+                    else
+                        SetOutline();
+                }
+
+                private void SetOutline()
+                {
+                    SetDragForm(Rectangle.Empty);
+                }
+
+                private void SetOutline(Rectangle floatWindowBounds)
+                {
+                    SetDragForm(floatWindowBounds);
+                }
+
+                private void SetOutline(DockPanel dockPanel, DockStyle dock, bool fullPanelEdge)
+                {
+                    Rectangle rect = fullPanelEdge ? dockPanel.DockArea : dockPanel.DocumentWindowBounds;
+                    rect.Location = dockPanel.PointToScreen(rect.Location);
+                    if (dock == DockStyle.Top)
+                    {
+                        int height = dockPanel.GetDockWindowSize(DockState.DockTop);
+                        rect = new Rectangle(rect.X, rect.Y, rect.Width, height);
+                    }
+                    else if (dock == DockStyle.Bottom)
+                    {
+                        int height = dockPanel.GetDockWindowSize(DockState.DockBottom);
+                        rect = new Rectangle(rect.X, rect.Bottom - height, rect.Width, height);
+                    }
+                    else if (dock == DockStyle.Left)
+                    {
+                        int width = dockPanel.GetDockWindowSize(DockState.DockLeft);
+                        rect = new Rectangle(rect.X, rect.Y, width, rect.Height);
+                    }
+                    else if (dock == DockStyle.Right)
+                    {
+                        int width = dockPanel.GetDockWindowSize(DockState.DockRight);
+                        rect = new Rectangle(rect.Right - width, rect.Y, width, rect.Height);
+                    }
+                    else if (dock == DockStyle.Fill)
+                    {
+                        rect = dockPanel.DocumentWindowBounds;
+                        rect.Location = dockPanel.PointToScreen(rect.Location);
+                    }
+
+                    SetDragForm(rect);
+                }
+
+                private void SetOutline(DockPane pane, DockStyle dock, int contentIndex)
+                {
+                    if (dock != DockStyle.Fill)
+                    {
+                        Rectangle rect = pane.DisplayingRectangle;
+                        if (dock == DockStyle.Right)
+                            rect.X += rect.Width / 2;
+                        if (dock == DockStyle.Bottom)
+                            rect.Y += rect.Height / 2;
+                        if (dock == DockStyle.Left || dock == DockStyle.Right)
+                            rect.Width -= rect.Width / 2;
+                        if (dock == DockStyle.Top || dock == DockStyle.Bottom)
+                            rect.Height -= rect.Height / 2;
+                        rect.Location = pane.PointToScreen(rect.Location);
+
+                        SetDragForm(rect);
+                    }
+                    else if (contentIndex == -1)
+                    {
+                        Rectangle rect = pane.DisplayingRectangle;
+                        rect.Location = pane.PointToScreen(rect.Location);
+                        SetDragForm(rect);
+                    }
+                    else
+                    {
+                        using (GraphicsPath path = pane.TabStripControl.GetOutline(contentIndex))
+                        {
+                            RectangleF rectF = path.GetBounds();
+                            Rectangle rect = new Rectangle((int)rectF.X, (int)rectF.Y, (int)rectF.Width, (int)rectF.Height);
+                            using (Matrix matrix = new Matrix(rect, new Point[] { new Point(0, 0), new Point(rect.Width, 0), new Point(0, rect.Height) }))
+                            {
+                                path.Transform(matrix);
+                            }
+                            Region region = new Region(path);
+                            SetDragForm(rect, region);
+                        }
+                    }
+                }
+
+                private void SetDragForm(Rectangle rect)
+                {
+                    DragForm.Bounds = rect;
+                    if (rect == Rectangle.Empty)
+                        DragForm.Region = new Region(Rectangle.Empty);
+                    else if (DragForm.Region != null)
+                        DragForm.Region = null;
+                }
+
+                private void SetDragForm(Rectangle rect, Region region)
+                {
+                    DragForm.Bounds = rect;
+                    DragForm.Region = region;
+                }
+            }
+
+            public DockDragHandler(DockPanel panel)
+                : base(panel)
+            {
+            }
+
+            public new IDockDragSource DragSource
+            {
+                get { return base.DragSource as IDockDragSource; }
+                set { base.DragSource = value; }
+            }
+
+            private DockOutlineBase m_outline;
+            public DockOutlineBase Outline
+            {
+                get { return m_outline; }
+                private set { m_outline = value; }
+            }
+
+            private DockIndicator m_indicator;
+            private DockIndicator Indicator
+            {
+                get { return m_indicator; }
+                set { m_indicator = value; }
+            }
+
+            private Rectangle m_floatOutlineBounds;
+            private Rectangle FloatOutlineBounds
+            {
+                get { return m_floatOutlineBounds; }
+                set { m_floatOutlineBounds = value; }
+            }
+
+            public void BeginDrag(IDockDragSource dragSource)
+            {
+                DragSource = dragSource;
+
+                if (!BeginDrag())
+                {
+                    DragSource = null;
+                    return;
+                }
+
+                Outline = new DockOutline();
+                Indicator = new DockIndicator(this);
+                Indicator.Show(false);
+
+                FloatOutlineBounds = DragSource.BeginDrag(StartMousePosition);
+            }
+
+            protected override void OnDragging()
+            {
+                TestDrop();
+            }
+
+            protected override void OnEndDrag(bool abort)
+            {
+                DockPanel.SuspendLayout(true);
+
+                Outline.Close();
+                Indicator.Close();
+
+                EndDrag(abort);
+
+                // Queue a request to layout all children controls
+                DockPanel.PerformMdiClientLayout();
+
+                DockPanel.ResumeLayout(true, true);
+
+                DragSource.EndDrag();
+
+                DragSource = null;
+            }
+
+            private void TestDrop()
+            {
+                Outline.FlagTestDrop = false;
+
+                Indicator.FullPanelEdge = ((Control.ModifierKeys & Keys.Shift) != 0);
+
+                if ((Control.ModifierKeys & Keys.Control) == 0)
+                {
+                    Indicator.TestDrop();
+
+                    if (!Outline.FlagTestDrop)
+                    {
+                        DockPane pane = DockHelper.PaneAtPoint(Control.MousePosition, DockPanel);
+                        if (pane != null && DragSource.IsDockStateValid(pane.DockState))
+                            pane.TestDrop(DragSource, Outline);
+                    }
+
+                    if (!Outline.FlagTestDrop && DragSource.IsDockStateValid(DockState.Float))
+                    {
+                        FloatWindow floatWindow = DockHelper.FloatWindowAtPoint(Control.MousePosition, DockPanel);
+                        if (floatWindow != null)
+                            floatWindow.TestDrop(DragSource, Outline);
+                    }
+                }
+                else
+                    Indicator.DockPane = DockHelper.PaneAtPoint(Control.MousePosition, DockPanel);
+
+                if (!Outline.FlagTestDrop)
+                {
+                    if (DragSource.IsDockStateValid(DockState.Float))
+                    {
+                        Rectangle rect = FloatOutlineBounds;
+                        rect.Offset(Control.MousePosition.X - StartMousePosition.X, Control.MousePosition.Y - StartMousePosition.Y);
+                        Outline.Show(rect);
+                    }
+                }
+
+                if (!Outline.FlagTestDrop)
+                {
+                    Cursor.Current = Cursors.No;
+                    Outline.Show();
+                }
+                else
+                    Cursor.Current = DragControl.Cursor;
+            }
+
+            private void EndDrag(bool abort)
+            {
+                if (abort)
+                    return;
+
+                if (!Outline.FloatWindowBounds.IsEmpty)
+                    DragSource.FloatAt(Outline.FloatWindowBounds);
+                else if (Outline.DockTo is DockPane)
+                {
+                    DockPane pane = Outline.DockTo as DockPane;
+                    DragSource.DockTo(pane, Outline.Dock, Outline.ContentIndex);
+                }
+                else if (Outline.DockTo is DockPanel)
+                {
+                    DockPanel panel = Outline.DockTo as DockPanel;
+                    panel.UpdateDockWindowZOrder(Outline.Dock, Outline.FlagFullEdge);
+                    DragSource.DockTo(panel, Outline.Dock);
+                }
+            }
+        }
+
+        private DockDragHandler m_dockDragHandler = null;
+        private DockDragHandler GetDockDragHandler()
+        {
+            if (m_dockDragHandler == null)
+                m_dockDragHandler = new DockDragHandler(this);
+            return m_dockDragHandler;
+        }
+
+        internal void BeginDrag(IDockDragSource dragSource)
+        {
+            GetDockDragHandler().BeginDrag(dragSource);
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.DragHandler.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.DragHandler.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.DragHandler.cs	(revision 8616)
@@ -0,0 +1,136 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.ComponentModel;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    partial class DockPanel
+    {
+        /// <summary>
+        /// DragHandlerBase is the base class for drag handlers. The derived class should:
+        ///   1. Define its public method BeginDrag. From within this public BeginDrag method,
+        ///      DragHandlerBase.BeginDrag should be called to initialize the mouse capture
+        ///      and message filtering.
+        ///   2. Override the OnDragging and OnEndDrag methods.
+        /// </summary>
+        private abstract class DragHandlerBase : NativeWindow, IMessageFilter
+        {
+            protected DragHandlerBase()
+            {
+            }
+
+            protected abstract Control DragControl
+            {
+                get;
+            }
+
+            private Point m_startMousePosition = Point.Empty;
+            protected Point StartMousePosition
+            {
+                get { return m_startMousePosition; }
+                private set { m_startMousePosition = value; }
+            }
+
+            protected bool BeginDrag()
+            {
+                // Avoid re-entrance;
+                lock (this)
+                {
+                    if (DragControl == null)
+                        return false;
+
+                    StartMousePosition = Control.MousePosition;
+
+                    if (!Win32Helper.IsRunningOnMono)
+                    if (!NativeMethods.DragDetect(DragControl.Handle, StartMousePosition))
+                        return false;
+
+                    DragControl.FindForm().Capture = true;
+                    AssignHandle(DragControl.FindForm().Handle);
+                    Application.AddMessageFilter(this);
+                    return true;
+                }
+            }
+
+            protected abstract void OnDragging();
+
+            protected abstract void OnEndDrag(bool abort);
+
+            private void EndDrag(bool abort)
+            {
+                ReleaseHandle();
+                Application.RemoveMessageFilter(this);
+                DragControl.FindForm().Capture = false;
+
+                OnEndDrag(abort);
+            }
+
+            bool IMessageFilter.PreFilterMessage(ref Message m)
+            {
+                if (m.Msg == (int)Win32.Msgs.WM_MOUSEMOVE)
+                    OnDragging();
+                else if (m.Msg == (int)Win32.Msgs.WM_LBUTTONUP)
+                    EndDrag(false);
+                else if (m.Msg == (int)Win32.Msgs.WM_CAPTURECHANGED)
+                    EndDrag(true);
+                else if (m.Msg == (int)Win32.Msgs.WM_KEYDOWN && (int)m.WParam == (int)Keys.Escape)
+                    EndDrag(true);
+
+                return OnPreFilterMessage(ref m);
+            }
+
+            protected virtual bool OnPreFilterMessage(ref Message m)
+            {
+                return false;
+            }
+
+            protected sealed override void WndProc(ref Message m)
+            {
+                if (m.Msg == (int)Win32.Msgs.WM_CANCELMODE || m.Msg == (int)Win32.Msgs.WM_CAPTURECHANGED)
+                    EndDrag(true);
+
+                base.WndProc(ref m);
+            }
+        }
+
+        private abstract class DragHandler : DragHandlerBase
+        {
+            private DockPanel m_dockPanel;
+
+            protected DragHandler(DockPanel dockPanel)
+            {
+                m_dockPanel = dockPanel;
+            }
+
+            public DockPanel DockPanel
+            {
+                get { return m_dockPanel; }
+            }
+
+            private IDragSource m_dragSource;
+            protected IDragSource DragSource
+            {
+                get { return m_dragSource; }
+                set { m_dragSource = value; }
+            }
+
+            protected sealed override Control DragControl
+            {
+                get { return DragSource == null ? null : DragSource.DragControl; }
+            }
+
+            protected sealed override bool OnPreFilterMessage(ref Message m)
+            {
+                if ((m.Msg == (int)Win32.Msgs.WM_KEYDOWN || m.Msg == (int)Win32.Msgs.WM_KEYUP) &&
+                    ((int)m.WParam == (int)Keys.ControlKey || (int)m.WParam == (int)Keys.ShiftKey))
+                    OnDragging();
+
+                return base.OnPreFilterMessage(ref m);
+            }
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.FocusManager.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.FocusManager.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.FocusManager.cs	(revision 8616)
@@ -0,0 +1,583 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+using System.Diagnostics.CodeAnalysis;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    internal interface IContentFocusManager
+    {
+        void Activate(IDockContent content);
+        void GiveUpFocus(IDockContent content);
+        void AddToList(IDockContent content);
+        void RemoveFromList(IDockContent content);
+    }
+
+    partial class DockPanel
+    {
+        private interface IFocusManager
+        {
+            void SuspendFocusTracking();
+            void ResumeFocusTracking();
+            bool IsFocusTrackingSuspended { get; }
+            IDockContent ActiveContent { get; }
+            DockPane ActivePane { get; }
+            IDockContent ActiveDocument { get; }
+            DockPane ActiveDocumentPane { get; }
+        }
+
+        private class FocusManagerImpl : Component, IContentFocusManager, IFocusManager
+        {
+            private class HookEventArgs : EventArgs
+            {
+                [SuppressMessage("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")]
+                public int HookCode;
+                [SuppressMessage("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")]
+                public IntPtr wParam;
+                public IntPtr lParam;
+            }
+
+            private class LocalWindowsHook : IDisposable
+            {
+                // Internal properties
+                private IntPtr m_hHook = IntPtr.Zero;
+                private NativeMethods.HookProc m_filterFunc = null;
+                private Win32.HookType m_hookType;
+
+                // Event delegate
+                public delegate void HookEventHandler(object sender, HookEventArgs e);
+
+                // Event: HookInvoked 
+                public event HookEventHandler HookInvoked;
+                protected void OnHookInvoked(HookEventArgs e)
+                {
+                    if (HookInvoked != null)
+                        HookInvoked(this, e);
+                }
+
+                public LocalWindowsHook(Win32.HookType hook)
+                {
+                    m_hookType = hook;
+                    m_filterFunc = new NativeMethods.HookProc(this.CoreHookProc);
+                }
+
+                // Default filter function
+                public IntPtr CoreHookProc(int code, IntPtr wParam, IntPtr lParam)
+                {
+                    if (code < 0)
+                        return NativeMethods.CallNextHookEx(m_hHook, code, wParam, lParam);
+
+                    // Let clients determine what to do
+                    HookEventArgs e = new HookEventArgs();
+                    e.HookCode = code;
+                    e.wParam = wParam;
+                    e.lParam = lParam;
+                    OnHookInvoked(e);
+
+                    // Yield to the next hook in the chain
+                    return NativeMethods.CallNextHookEx(m_hHook, code, wParam, lParam);
+                }
+
+                // Install the hook
+                public void Install()
+                {
+                    if (m_hHook != IntPtr.Zero)
+                        Uninstall();
+
+                    int threadId = NativeMethods.GetCurrentThreadId();
+                    m_hHook = NativeMethods.SetWindowsHookEx(m_hookType, m_filterFunc, IntPtr.Zero, threadId);
+                }
+
+                // Uninstall the hook
+                public void Uninstall()
+                {
+                    if (m_hHook != IntPtr.Zero)
+                    {
+                        NativeMethods.UnhookWindowsHookEx(m_hHook);
+                        m_hHook = IntPtr.Zero;
+                    }
+                }
+
+                ~LocalWindowsHook()
+                {
+                    Dispose(false);
+                }
+
+                public void Dispose()
+                {
+                    Dispose(true);
+                    GC.SuppressFinalize(this);
+                }
+
+                protected virtual void Dispose(bool disposing)
+                {
+                    Uninstall();
+                }
+            }
+
+            private static LocalWindowsHook sm_localWindowsHook;
+            private LocalWindowsHook.HookEventHandler m_hookEventHandler;
+
+            // Use a static instance of the windows hook to prevent stack overflows in the windows kernel.
+            static FocusManagerImpl()
+            {
+                if (Win32Helper.IsRunningOnMono)
+                    return; 
+
+                sm_localWindowsHook = new LocalWindowsHook(Win32.HookType.WH_CALLWNDPROCRET);
+                sm_localWindowsHook.Install();
+            }
+
+            public FocusManagerImpl(DockPanel dockPanel)
+            {
+                m_dockPanel = dockPanel;
+                if (Win32Helper.IsRunningOnMono)
+                    return;                
+                m_hookEventHandler = new LocalWindowsHook.HookEventHandler(HookEventHandler);
+                sm_localWindowsHook.HookInvoked += m_hookEventHandler;
+            }
+
+            private DockPanel m_dockPanel;
+            public DockPanel DockPanel
+            {
+                get { return m_dockPanel; }
+            }
+
+            private bool m_disposed = false;
+            protected override void Dispose(bool disposing)
+            {
+                lock (this)
+                {
+                    if (!m_disposed && disposing)
+                    {
+                        if (!Win32Helper.IsRunningOnMono)
+                        sm_localWindowsHook.HookInvoked -= m_hookEventHandler;
+                        m_disposed = true;
+                    }
+
+                    base.Dispose(disposing);
+                }
+            }
+
+            private IDockContent m_contentActivating = null;
+            private IDockContent ContentActivating
+            {
+                get { return m_contentActivating; }
+                set { m_contentActivating = value; }
+            }
+
+            public void Activate(IDockContent content)
+            {
+                if (IsFocusTrackingSuspended)
+                {
+                    ContentActivating = content;
+                    return;
+                }
+
+                if (content == null)
+                    return;
+                DockContentHandler handler = content.DockHandler;
+                if (handler.Form.IsDisposed)
+                    return; // Should not reach here, but better than throwing an exception
+                if (ContentContains(content, handler.ActiveWindowHandle))
+                    if (!Win32Helper.IsRunningOnMono)
+                        NativeMethods.SetFocus(handler.ActiveWindowHandle);
+                if (!handler.Form.ContainsFocus)
+                {
+                    if (!handler.Form.SelectNextControl(handler.Form.ActiveControl, true, true, true, true))
+                        // Since DockContent Form is not selectalbe, use Win32 SetFocus instead
+                        if (!Win32Helper.IsRunningOnMono)
+                            NativeMethods.SetFocus(handler.Form.Handle);
+                }
+            }
+
+            private List<IDockContent> m_listContent = new List<IDockContent>();
+            private List<IDockContent> ListContent
+            {
+                get { return m_listContent; }
+            }
+            public void AddToList(IDockContent content)
+            {
+                if (ListContent.Contains(content) || IsInActiveList(content))
+                    return;
+
+                ListContent.Add(content);
+            }
+
+            public void RemoveFromList(IDockContent content)
+            {
+                if (IsInActiveList(content))
+                    RemoveFromActiveList(content);
+                if (ListContent.Contains(content))
+                    ListContent.Remove(content);
+            }
+
+            private IDockContent m_lastActiveContent = null;
+            private IDockContent LastActiveContent
+            {
+                get { return m_lastActiveContent; }
+                set { m_lastActiveContent = value; }
+            }
+
+            private bool IsInActiveList(IDockContent content)
+            {
+                return !(content.DockHandler.NextActive == null && LastActiveContent != content);
+            }
+
+            private void AddLastToActiveList(IDockContent content)
+            {
+                IDockContent last = LastActiveContent;
+                if (last == content)
+                    return;
+
+                DockContentHandler handler = content.DockHandler;
+
+                if (IsInActiveList(content))
+                    RemoveFromActiveList(content);
+
+                handler.PreviousActive = last;
+                handler.NextActive = null;
+                LastActiveContent = content;
+                if (last != null)
+                    last.DockHandler.NextActive = LastActiveContent;
+            }
+
+            private void RemoveFromActiveList(IDockContent content)
+            {
+                if (LastActiveContent == content)
+                    LastActiveContent = content.DockHandler.PreviousActive;
+
+                IDockContent prev = content.DockHandler.PreviousActive;
+                IDockContent next = content.DockHandler.NextActive;
+                if (prev != null)
+                    prev.DockHandler.NextActive = next;
+                if (next != null)
+                    next.DockHandler.PreviousActive = prev;
+
+                content.DockHandler.PreviousActive = null;
+                content.DockHandler.NextActive = null;
+            }
+
+            public void GiveUpFocus(IDockContent content)
+            {
+                DockContentHandler handler = content.DockHandler;
+                if (!handler.Form.ContainsFocus)
+                    return;
+
+                if (IsFocusTrackingSuspended)
+                    DockPanel.DummyControl.Focus();
+
+                if (LastActiveContent == content)
+                {
+                    IDockContent prev = handler.PreviousActive;
+                    if (prev != null)
+                        Activate(prev);
+                    else if (ListContent.Count > 0)
+                        Activate(ListContent[ListContent.Count - 1]);
+                }
+                else if (LastActiveContent != null)
+                    Activate(LastActiveContent);
+                else if (ListContent.Count > 0)
+                    Activate(ListContent[ListContent.Count - 1]);
+            }
+
+            private static bool ContentContains(IDockContent content, IntPtr hWnd)
+            {
+                Control control = Control.FromChildHandle(hWnd);
+                for (Control parent = control; parent != null; parent = parent.Parent)
+                    if (parent == content.DockHandler.Form)
+                        return true;
+
+                return false;
+            }
+
+            private int m_countSuspendFocusTracking = 0;
+            public void SuspendFocusTracking()
+            {
+                m_countSuspendFocusTracking++;
+                if (!Win32Helper.IsRunningOnMono)
+                    sm_localWindowsHook.HookInvoked -= m_hookEventHandler;
+            }
+
+            public void ResumeFocusTracking()
+            {
+                if (m_countSuspendFocusTracking > 0)
+                    m_countSuspendFocusTracking--;
+
+                if (m_countSuspendFocusTracking == 0)
+                {
+                    if (ContentActivating != null)
+                    {
+                        Activate(ContentActivating);
+                        ContentActivating = null;
+                    }
+                    if (!Win32Helper.IsRunningOnMono)
+                        sm_localWindowsHook.HookInvoked += m_hookEventHandler;
+                    if (!InRefreshActiveWindow)
+                        RefreshActiveWindow();
+                }
+            }
+
+            public bool IsFocusTrackingSuspended
+            {
+                get { return m_countSuspendFocusTracking != 0; }
+            }
+
+            // Windows hook event handler
+            private void HookEventHandler(object sender, HookEventArgs e)
+            {
+                Win32.Msgs msg = (Win32.Msgs)Marshal.ReadInt32(e.lParam, IntPtr.Size * 3);
+
+                if (msg == Win32.Msgs.WM_KILLFOCUS)
+                {
+                    IntPtr wParam = Marshal.ReadIntPtr(e.lParam, IntPtr.Size * 2);
+                    DockPane pane = GetPaneFromHandle(wParam);
+                    if (pane == null)
+                        RefreshActiveWindow();
+                }
+                else if (msg == Win32.Msgs.WM_SETFOCUS)
+                    RefreshActiveWindow();
+            }
+
+            private DockPane GetPaneFromHandle(IntPtr hWnd)
+            {
+                Control control = Control.FromChildHandle(hWnd);
+
+                IDockContent content = null;
+                DockPane pane = null;
+                for (; control != null; control = control.Parent)
+                {
+                    content = control as IDockContent;
+                    if (content != null)
+                        content.DockHandler.ActiveWindowHandle = hWnd;
+
+                    if (content != null && content.DockHandler.DockPanel == DockPanel)
+                        return content.DockHandler.Pane;
+
+                    pane = control as DockPane;
+                    if (pane != null && pane.DockPanel == DockPanel)
+                        break;
+                }
+
+                return pane;
+            }
+
+            private bool m_inRefreshActiveWindow = false;
+            private bool InRefreshActiveWindow
+            {
+                get { return m_inRefreshActiveWindow; }
+            }
+
+            private void RefreshActiveWindow()
+            {
+                SuspendFocusTracking();
+                m_inRefreshActiveWindow = true;
+
+                DockPane oldActivePane = ActivePane;
+                IDockContent oldActiveContent = ActiveContent;
+                IDockContent oldActiveDocument = ActiveDocument;
+
+                SetActivePane();
+                SetActiveContent();
+                SetActiveDocumentPane();
+                SetActiveDocument();
+                DockPanel.AutoHideWindow.RefreshActivePane();
+
+                ResumeFocusTracking();
+                m_inRefreshActiveWindow = false;
+
+                if (oldActiveContent != ActiveContent)
+                    DockPanel.OnActiveContentChanged(EventArgs.Empty);
+                if (oldActiveDocument != ActiveDocument)
+                    DockPanel.OnActiveDocumentChanged(EventArgs.Empty);
+                if (oldActivePane != ActivePane)
+                    DockPanel.OnActivePaneChanged(EventArgs.Empty);
+            }
+
+            private DockPane m_activePane = null;
+            public DockPane ActivePane
+            {
+                get { return m_activePane; }
+            }
+
+            private void SetActivePane()
+            {
+                DockPane value = Win32Helper.IsRunningOnMono ? null : GetPaneFromHandle(NativeMethods.GetFocus());
+                if (m_activePane == value)
+                    return;
+
+                if (m_activePane != null)
+                    m_activePane.SetIsActivated(false);
+
+                m_activePane = value;
+
+                if (m_activePane != null)
+                    m_activePane.SetIsActivated(true);
+            }
+
+            private IDockContent m_activeContent = null;
+            public IDockContent ActiveContent
+            {
+                get { return m_activeContent; }
+            }
+
+            internal void SetActiveContent()
+            {
+                IDockContent value = ActivePane == null ? null : ActivePane.ActiveContent;
+
+                if (m_activeContent == value)
+                    return;
+
+                if (m_activeContent != null)
+                    m_activeContent.DockHandler.IsActivated = false;
+
+                m_activeContent = value;
+
+                if (m_activeContent != null)
+                {
+                    m_activeContent.DockHandler.IsActivated = true;
+                    if (!DockHelper.IsDockStateAutoHide((m_activeContent.DockHandler.DockState)))
+                        AddLastToActiveList(m_activeContent);
+                }
+            }
+
+            private DockPane m_activeDocumentPane = null;
+            public DockPane ActiveDocumentPane
+            {
+                get { return m_activeDocumentPane; }
+            }
+
+            private void SetActiveDocumentPane()
+            {
+                DockPane value = null;
+
+                if (ActivePane != null && ActivePane.DockState == DockState.Document)
+                    value = ActivePane;
+
+                if (value == null && DockPanel.DockWindows != null)
+                {
+                    if (ActiveDocumentPane == null)
+                        value = DockPanel.DockWindows[DockState.Document].DefaultPane;
+                    else if (ActiveDocumentPane.DockPanel != DockPanel || ActiveDocumentPane.DockState != DockState.Document)
+                        value = DockPanel.DockWindows[DockState.Document].DefaultPane;
+                    else
+                        value = ActiveDocumentPane;
+                }
+
+                if (m_activeDocumentPane == value)
+                    return;
+
+                if (m_activeDocumentPane != null)
+                    m_activeDocumentPane.SetIsActiveDocumentPane(false);
+
+                m_activeDocumentPane = value;
+
+                if (m_activeDocumentPane != null)
+                    m_activeDocumentPane.SetIsActiveDocumentPane(true);
+            }
+
+            private IDockContent m_activeDocument = null;
+            public IDockContent ActiveDocument
+            {
+                get { return m_activeDocument; }
+            }
+
+            private void SetActiveDocument()
+            {
+                IDockContent value = ActiveDocumentPane == null ? null : ActiveDocumentPane.ActiveContent;
+
+                if (m_activeDocument == value)
+                    return;
+
+                m_activeDocument = value;
+            }
+        }
+
+        private IFocusManager FocusManager
+        {
+            get { return m_focusManager; }
+        }
+
+        internal IContentFocusManager ContentFocusManager
+        {
+            get { return m_focusManager; }
+        }
+
+        internal void SaveFocus()
+        {
+            DummyControl.Focus();
+        }
+
+        [Browsable(false)]
+        public IDockContent ActiveContent
+        {
+            get { return FocusManager.ActiveContent; }
+        }
+
+        [Browsable(false)]
+        public DockPane ActivePane
+        {
+            get { return FocusManager.ActivePane; }
+        }
+
+        [Browsable(false)]
+        public IDockContent ActiveDocument
+        {
+            get { return FocusManager.ActiveDocument; }
+        }
+
+        [Browsable(false)]
+        public DockPane ActiveDocumentPane
+        {
+            get { return FocusManager.ActiveDocumentPane; }
+        }
+
+        private static readonly object ActiveDocumentChangedEvent = new object();
+        [LocalizedCategory("Category_PropertyChanged")]
+        [LocalizedDescription("DockPanel_ActiveDocumentChanged_Description")]
+        public event EventHandler ActiveDocumentChanged
+        {
+            add { Events.AddHandler(ActiveDocumentChangedEvent, value); }
+            remove { Events.RemoveHandler(ActiveDocumentChangedEvent, value); }
+        }
+        protected virtual void OnActiveDocumentChanged(EventArgs e)
+        {
+            EventHandler handler = (EventHandler)Events[ActiveDocumentChangedEvent];
+            if (handler != null)
+                handler(this, e);
+        }
+
+        private static readonly object ActiveContentChangedEvent = new object();
+        [LocalizedCategory("Category_PropertyChanged")]
+        [LocalizedDescription("DockPanel_ActiveContentChanged_Description")]
+        public event EventHandler ActiveContentChanged
+        {
+            add { Events.AddHandler(ActiveContentChangedEvent, value); }
+            remove { Events.RemoveHandler(ActiveContentChangedEvent, value); }
+        }
+        protected void OnActiveContentChanged(EventArgs e)
+        {
+            EventHandler handler = (EventHandler)Events[ActiveContentChangedEvent];
+            if (handler != null)
+                handler(this, e);
+        }
+
+        private static readonly object ActivePaneChangedEvent = new object();
+        [LocalizedCategory("Category_PropertyChanged")]
+        [LocalizedDescription("DockPanel_ActivePaneChanged_Description")]
+        public event EventHandler ActivePaneChanged
+        {
+            add { Events.AddHandler(ActivePaneChangedEvent, value); }
+            remove { Events.RemoveHandler(ActivePaneChangedEvent, value); }
+        }
+        protected virtual void OnActivePaneChanged(EventArgs e)
+        {
+            EventHandler handler = (EventHandler)Events[ActivePaneChangedEvent];
+            if (handler != null)
+                handler(this, e);
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.MdiClientController.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.MdiClientController.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.MdiClientController.cs	(revision 8616)
@@ -0,0 +1,435 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.Runtime.InteropServices;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    partial class DockPanel
+    {
+        //  This class comes from Jacob Slusser's MdiClientController class:
+        //  http://www.codeproject.com/cs/miscctrl/mdiclientcontroller.asp
+        private class MdiClientController : NativeWindow, IComponent, IDisposable
+        {
+            private bool m_autoScroll = true;
+            private BorderStyle m_borderStyle = BorderStyle.Fixed3D;
+            private MdiClient m_mdiClient = null;
+            private Form m_parentForm = null;
+            private ISite m_site = null;
+
+            public MdiClientController()
+            {
+            }
+
+            public void Dispose()
+            {
+                Dispose(true);
+                GC.SuppressFinalize(this);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+                if (disposing)
+                {
+                    lock (this)
+                    {
+                        if (Site != null && Site.Container != null)
+                            Site.Container.Remove(this);
+
+                        if (Disposed != null)
+                            Disposed(this, EventArgs.Empty);
+                    }
+                }
+            }
+
+            public bool AutoScroll
+            {
+                get { return m_autoScroll; }
+                set
+                {
+                    // By default the MdiClient control scrolls. It can appear though that
+                    // there are no scrollbars by turning them off when the non-client
+                    // area is calculated. I decided to expose this method following
+                    // the .NET vernacular of an AutoScroll property.
+                    m_autoScroll = value;
+                    if (MdiClient != null)
+                        UpdateStyles();
+                }
+            }
+
+            public BorderStyle BorderStyle
+            {
+                set
+                {
+                    // Error-check the enum.
+                    if (!Enum.IsDefined(typeof(BorderStyle), value))
+                        throw new InvalidEnumArgumentException();
+
+                    m_borderStyle = value;
+
+                    if (MdiClient == null)
+                        return;
+
+                    // This property can actually be visible in design-mode,
+                    // but to keep it consistent with the others,
+                    // prevent this from being show at design-time.
+                    if (Site != null && Site.DesignMode)
+                        return;
+
+                    // There is no BorderStyle property exposed by the MdiClient class,
+                    // but this can be controlled by Win32 functions. A Win32 ExStyle
+                    // of WS_EX_CLIENTEDGE is equivalent to a Fixed3D border and a
+                    // Style of WS_BORDER is equivalent to a FixedSingle border.
+
+                    // This code is inspired Jason Dori's article:
+                    // "Adding designable borders to user controls".
+                    // http://www.codeproject.com/cs/miscctrl/CsAddingBorders.asp
+
+                    if (!Win32Helper.IsRunningOnMono)
+                    {
+                        // Get styles using Win32 calls
+                        int style = NativeMethods.GetWindowLong(MdiClient.Handle, (int)Win32.GetWindowLongIndex.GWL_STYLE);
+                        int exStyle = NativeMethods.GetWindowLong(MdiClient.Handle, (int)Win32.GetWindowLongIndex.GWL_EXSTYLE);
+
+                        // Add or remove style flags as necessary.
+                        switch (m_borderStyle)
+                        {
+                            case BorderStyle.Fixed3D:
+                                exStyle |= (int)Win32.WindowExStyles.WS_EX_CLIENTEDGE;
+                                style &= ~((int)Win32.WindowStyles.WS_BORDER);
+                                break;
+
+                            case BorderStyle.FixedSingle:
+                                exStyle &= ~((int)Win32.WindowExStyles.WS_EX_CLIENTEDGE);
+                                style |= (int)Win32.WindowStyles.WS_BORDER;
+                                break;
+
+                            case BorderStyle.None:
+                                style &= ~((int)Win32.WindowStyles.WS_BORDER);
+                                exStyle &= ~((int)Win32.WindowExStyles.WS_EX_CLIENTEDGE);
+                                break;
+                        }
+
+                        // Set the styles using Win32 calls
+                        NativeMethods.SetWindowLong(MdiClient.Handle, (int)Win32.GetWindowLongIndex.GWL_STYLE, style);
+                        NativeMethods.SetWindowLong(MdiClient.Handle, (int)Win32.GetWindowLongIndex.GWL_EXSTYLE, exStyle);
+                    }
+                    // Cause an update of the non-client area.
+                    UpdateStyles();
+                }
+            }
+
+            public MdiClient MdiClient
+            {
+                get { return m_mdiClient; }
+            }
+
+            [Browsable(false)]
+            [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+            public Form ParentForm
+            {
+                get { return m_parentForm; }
+                set
+                {
+                    // If the ParentForm has previously been set,
+                    // unwire events connected to the old parent.
+                    if (m_parentForm != null)
+                    {
+                        m_parentForm.HandleCreated -= new EventHandler(ParentFormHandleCreated);
+                        m_parentForm.MdiChildActivate -= new EventHandler(ParentFormMdiChildActivate);
+                    }
+
+                    m_parentForm = value;
+
+                    if (m_parentForm == null)
+                        return;
+
+                    // If the parent form has not been created yet,
+                    // wait to initialize the MDI client until it is.
+                    if (m_parentForm.IsHandleCreated)
+                    {
+                        InitializeMdiClient();
+                        RefreshProperties();
+                    }
+                    else
+                        m_parentForm.HandleCreated += new EventHandler(ParentFormHandleCreated);
+
+                    m_parentForm.MdiChildActivate += new EventHandler(ParentFormMdiChildActivate);
+                }
+            }
+
+            public ISite Site
+            {
+                get { return m_site; }
+                set
+                {
+                    m_site = value;
+
+                    if (m_site == null)
+                        return;
+
+                    // If the component is dropped onto a form during design-time,
+                    // set the ParentForm property.
+                    IDesignerHost host = (value.GetService(typeof(IDesignerHost)) as IDesignerHost);
+                    if (host != null)
+                    {
+                        Form parent = host.RootComponent as Form;
+                        if (parent != null)
+                            ParentForm = parent;
+                    }
+                }
+            }
+
+            public void RenewMdiClient()
+            {
+                // Reinitialize the MdiClient and its properties.
+                InitializeMdiClient();
+                RefreshProperties();
+            }
+
+            public event EventHandler Disposed;
+
+            public event EventHandler HandleAssigned;
+
+            public event EventHandler MdiChildActivate;
+
+            public event LayoutEventHandler Layout;
+
+            protected virtual void OnHandleAssigned(EventArgs e)
+            {
+                // Raise the HandleAssigned event.
+                if (HandleAssigned != null)
+                    HandleAssigned(this, e);
+            }
+
+            protected virtual void OnMdiChildActivate(EventArgs e)
+            {
+                // Raise the MdiChildActivate event
+                if (MdiChildActivate != null)
+                    MdiChildActivate(this, e);
+            }
+
+            protected virtual void OnLayout(LayoutEventArgs e)
+            {
+                // Raise the Layout event
+                if (Layout != null)
+                    Layout(this, e);
+            }
+
+            public event PaintEventHandler Paint;
+
+            protected virtual void OnPaint(PaintEventArgs e)
+            {
+                // Raise the Paint event.
+                if (Paint != null)
+                    Paint(this, e);
+            }
+
+            protected override void WndProc(ref Message m)
+            {
+                switch (m.Msg)
+                {
+                    case (int)Win32.Msgs.WM_NCCALCSIZE:
+                        // If AutoScroll is set to false, hide the scrollbars when the control
+                        // calculates its non-client area.
+                        if (!AutoScroll)
+                            if (!Win32Helper.IsRunningOnMono)
+                                NativeMethods.ShowScrollBar(m.HWnd, (int)Win32.ScrollBars.SB_BOTH, 0 /*false*/);
+                        break;
+                }
+
+                base.WndProc(ref m);
+            }
+
+            private void ParentFormHandleCreated(object sender, EventArgs e)
+            {
+                // The form has been created, unwire the event, and initialize the MdiClient.
+                this.m_parentForm.HandleCreated -= new EventHandler(ParentFormHandleCreated);
+                InitializeMdiClient();
+                RefreshProperties();
+            }
+
+            private void ParentFormMdiChildActivate(object sender, EventArgs e)
+            {
+                OnMdiChildActivate(e);
+            }
+
+            private void MdiClientLayout(object sender, LayoutEventArgs e)
+            {
+                OnLayout(e);
+            }
+
+            private void MdiClientHandleDestroyed(object sender, EventArgs e)
+            {
+                // If the MdiClient handle has been released, drop the reference and
+                // release the handle.
+                if (m_mdiClient != null)
+                {
+                    m_mdiClient.HandleDestroyed -= new EventHandler(MdiClientHandleDestroyed);
+                    m_mdiClient = null;
+                }
+
+                ReleaseHandle();
+            }
+
+            private void InitializeMdiClient()
+            {
+                // If the mdiClient has previously been set, unwire events connected
+                // to the old MDI.
+                if (MdiClient != null)
+                {
+                    MdiClient.HandleDestroyed -= new EventHandler(MdiClientHandleDestroyed);
+                    MdiClient.Layout -= new LayoutEventHandler(MdiClientLayout);
+                }
+
+                if (ParentForm == null)
+                    return;
+
+                // Get the MdiClient from the parent form.
+                foreach (Control control in ParentForm.Controls)
+                {
+                    // If the form is an MDI container, it will contain an MdiClient control
+                    // just as it would any other control.
+
+                    m_mdiClient = control as MdiClient;
+                    if (m_mdiClient == null)
+                        continue;
+
+                    // Assign the MdiClient Handle to the NativeWindow.
+                    ReleaseHandle();
+                    AssignHandle(MdiClient.Handle);
+
+                    // Raise the HandleAssigned event.
+                    OnHandleAssigned(EventArgs.Empty);
+
+                    // Monitor the MdiClient for when its handle is destroyed.
+                    MdiClient.HandleDestroyed += new EventHandler(MdiClientHandleDestroyed);
+                    MdiClient.Layout += new LayoutEventHandler(MdiClientLayout);
+
+                    break;
+                }
+            }
+
+            private void RefreshProperties()
+            {
+                // Refresh all the properties
+                BorderStyle = m_borderStyle;
+                AutoScroll = m_autoScroll;
+            }
+
+            private void UpdateStyles()
+            {
+                // To show style changes, the non-client area must be repainted. Using the
+                // control's Invalidate method does not affect the non-client area.
+                // Instead use a Win32 call to signal the style has changed.
+                if (!Win32Helper.IsRunningOnMono)
+                    NativeMethods.SetWindowPos(MdiClient.Handle, IntPtr.Zero, 0, 0, 0, 0,
+                        Win32.FlagsSetWindowPos.SWP_NOACTIVATE |
+                        Win32.FlagsSetWindowPos.SWP_NOMOVE |
+                        Win32.FlagsSetWindowPos.SWP_NOSIZE |
+                        Win32.FlagsSetWindowPos.SWP_NOZORDER |
+                        Win32.FlagsSetWindowPos.SWP_NOOWNERZORDER |
+                        Win32.FlagsSetWindowPos.SWP_FRAMECHANGED);
+            }
+        }
+
+        private MdiClientController m_mdiClientController = null;
+        private MdiClientController GetMdiClientController()
+        {
+            if (m_mdiClientController == null)
+            {
+                m_mdiClientController = new MdiClientController();
+                m_mdiClientController.HandleAssigned += new EventHandler(MdiClientHandleAssigned);
+                m_mdiClientController.MdiChildActivate += new EventHandler(ParentFormMdiChildActivate);
+                m_mdiClientController.Layout += new LayoutEventHandler(MdiClient_Layout);
+            }
+
+            return m_mdiClientController;
+        }
+
+        private void ParentFormMdiChildActivate(object sender, EventArgs e)
+        {
+            if (GetMdiClientController().ParentForm == null)
+                return;
+
+            IDockContent content = GetMdiClientController().ParentForm.ActiveMdiChild as IDockContent;
+            if (content == null)
+                return;
+
+            if (content.DockHandler.DockPanel == this && content.DockHandler.Pane != null)
+                content.DockHandler.Pane.ActiveContent = content;
+        }
+
+        private bool MdiClientExists
+        {
+            get { return GetMdiClientController().MdiClient != null; }
+        }
+
+        private void SetMdiClientBounds(Rectangle bounds)
+        {
+            GetMdiClientController().MdiClient.Bounds = bounds;
+        }
+
+        private void SuspendMdiClientLayout()
+        {
+            if (GetMdiClientController().MdiClient != null)
+                GetMdiClientController().MdiClient.SuspendLayout();
+        }
+
+        private void ResumeMdiClientLayout(bool perform)
+        {
+            if (GetMdiClientController().MdiClient != null)
+                GetMdiClientController().MdiClient.ResumeLayout(perform);
+        }
+
+        private void PerformMdiClientLayout()
+        {
+            if (GetMdiClientController().MdiClient != null)
+                GetMdiClientController().MdiClient.PerformLayout();
+        }
+
+        // Called when:
+        // 1. DockPanel.DocumentStyle changed
+        // 2. DockPanel.Visible changed
+        // 3. MdiClientController.Handle assigned
+        private void SetMdiClient()
+        {
+            MdiClientController controller = GetMdiClientController();
+
+            if (this.DocumentStyle == DocumentStyle.DockingMdi)
+            {
+                controller.AutoScroll = false;
+                controller.BorderStyle = BorderStyle.None;
+                if (MdiClientExists)
+                    controller.MdiClient.Dock = DockStyle.Fill;
+            }
+            else if (DocumentStyle == DocumentStyle.DockingSdi || DocumentStyle == DocumentStyle.DockingWindow)
+            {
+                controller.AutoScroll = true;
+                controller.BorderStyle = BorderStyle.Fixed3D;
+                if (MdiClientExists)
+                    controller.MdiClient.Dock = DockStyle.Fill;
+            }
+            else if (this.DocumentStyle == DocumentStyle.SystemMdi)
+            {
+                controller.AutoScroll = true;
+                controller.BorderStyle = BorderStyle.Fixed3D;
+                if (controller.MdiClient != null)
+                {
+                    controller.MdiClient.Dock = DockStyle.None;
+                    controller.MdiClient.Bounds = SystemMdiClientBounds;
+                }
+            }
+        }
+
+        internal Rectangle RectangleToMdiClient(Rectangle rect)
+        {
+            if (MdiClientExists)
+                return GetMdiClientController().MdiClient.RectangleToClient(rect);
+            else
+                return Rectangle.Empty;
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.Persistor.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.Persistor.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.Persistor.cs	(revision 8616)
@@ -0,0 +1,785 @@
+using System;
+using System.ComponentModel;
+using System.Windows.Forms;
+using System.Drawing;
+using WeifenLuo.WinFormsUI.Docking;
+using System.IO;
+using System.Text;
+using System.Xml;
+using System.Globalization;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    partial class DockPanel
+    {
+        private static class Persistor
+        {
+            private const string ConfigFileVersion = "1.0";
+            private static string[] CompatibleConfigFileVersions = new string[] { };
+
+            private class DummyContent : DockContent
+            {
+            }
+
+            private struct DockPanelStruct
+            {
+                private double m_dockLeftPortion;
+                public double DockLeftPortion
+                {
+                    get { return m_dockLeftPortion; }
+                    set { m_dockLeftPortion = value; }
+                }
+
+                private double m_dockRightPortion;
+                public double DockRightPortion
+                {
+                    get { return m_dockRightPortion; }
+                    set { m_dockRightPortion = value; }
+                }
+
+                private double m_dockTopPortion;
+                public double DockTopPortion
+                {
+                    get { return m_dockTopPortion; }
+                    set { m_dockTopPortion = value; }
+                }
+
+                private double m_dockBottomPortion;
+                public double DockBottomPortion
+                {
+                    get { return m_dockBottomPortion; }
+                    set { m_dockBottomPortion = value; }
+                }
+
+                private int m_indexActiveDocumentPane;
+                public int IndexActiveDocumentPane
+                {
+                    get { return m_indexActiveDocumentPane; }
+                    set { m_indexActiveDocumentPane = value; }
+                }
+
+                private int m_indexActivePane;
+                public int IndexActivePane
+                {
+                    get { return m_indexActivePane; }
+                    set { m_indexActivePane = value; }
+                }
+            }
+
+            private struct ContentStruct
+            {
+                private string m_persistString;
+                public string PersistString
+                {
+                    get { return m_persistString; }
+                    set { m_persistString = value; }
+                }
+
+                private double m_autoHidePortion;
+                public double AutoHidePortion
+                {
+                    get { return m_autoHidePortion; }
+                    set { m_autoHidePortion = value; }
+                }
+
+                private bool m_isHidden;
+                public bool IsHidden
+                {
+                    get { return m_isHidden; }
+                    set { m_isHidden = value; }
+                }
+
+                private bool m_isFloat;
+                public bool IsFloat
+                {
+                    get { return m_isFloat; }
+                    set { m_isFloat = value; }
+                }
+            }
+
+            private struct PaneStruct
+            {
+                private DockState m_dockState;
+                public DockState DockState
+                {
+                    get { return m_dockState; }
+                    set { m_dockState = value; }
+                }
+
+                private int m_indexActiveContent;
+                public int IndexActiveContent
+                {
+                    get { return m_indexActiveContent; }
+                    set { m_indexActiveContent = value; }
+                }
+
+                private int[] m_indexContents;
+                public int[] IndexContents
+                {
+                    get { return m_indexContents; }
+                    set { m_indexContents = value; }
+                }
+
+                private int m_zOrderIndex;
+                public int ZOrderIndex
+                {
+                    get { return m_zOrderIndex; }
+                    set { m_zOrderIndex = value; }
+                }
+            }
+
+            private struct NestedPane
+            {
+                private int m_indexPane;
+                public int IndexPane
+                {
+                    get { return m_indexPane; }
+                    set { m_indexPane = value; }
+                }
+
+                private int m_indexPrevPane;
+                public int IndexPrevPane
+                {
+                    get { return m_indexPrevPane; }
+                    set { m_indexPrevPane = value; }
+                }
+
+                private DockAlignment m_alignment;
+                public DockAlignment Alignment
+                {
+                    get { return m_alignment; }
+                    set { m_alignment = value; }
+                }
+
+                private double m_proportion;
+                public double Proportion
+                {
+                    get { return m_proportion; }
+                    set { m_proportion = value; }
+                }
+            }
+
+            private struct DockWindowStruct
+            {
+                private DockState m_dockState;
+                public DockState DockState
+                {
+                    get { return m_dockState; }
+                    set { m_dockState = value; }
+                }
+
+                private int m_zOrderIndex;
+                public int ZOrderIndex
+                {
+                    get { return m_zOrderIndex; }
+                    set { m_zOrderIndex = value; }
+                }
+
+                private NestedPane[] m_nestedPanes;
+                public NestedPane[] NestedPanes
+                {
+                    get { return m_nestedPanes; }
+                    set { m_nestedPanes = value; }
+                }
+            }
+
+            private struct FloatWindowStruct
+            {
+                private Rectangle m_bounds;
+                public Rectangle Bounds
+                {
+                    get { return m_bounds; }
+                    set { m_bounds = value; }
+                }
+
+                private int m_zOrderIndex;
+                public int ZOrderIndex
+                {
+                    get { return m_zOrderIndex; }
+                    set { m_zOrderIndex = value; }
+                }
+
+                private NestedPane[] m_nestedPanes;
+                public NestedPane[] NestedPanes
+                {
+                    get { return m_nestedPanes; }
+                    set { m_nestedPanes = value; }
+                }
+            }
+
+            public static void SaveAsXml(DockPanel dockPanel, string fileName)
+            {
+                SaveAsXml(dockPanel, fileName, Encoding.Unicode);
+            }
+
+            public static void SaveAsXml(DockPanel dockPanel, string fileName, Encoding encoding)
+            {
+                FileStream fs = new FileStream(fileName, FileMode.Create);
+                try
+                {
+                    SaveAsXml(dockPanel, fs, encoding);
+                }
+                finally
+                {
+                    fs.Close();
+                }
+            }
+
+            public static void SaveAsXml(DockPanel dockPanel, Stream stream, Encoding encoding)
+            {
+                SaveAsXml(dockPanel, stream, encoding, false);
+            }
+
+            public static void SaveAsXml(DockPanel dockPanel, Stream stream, Encoding encoding, bool upstream)
+            {
+                XmlTextWriter xmlOut = new XmlTextWriter(stream, encoding);
+
+                // Use indenting for readability
+                xmlOut.Formatting = Formatting.Indented;
+
+                if (!upstream)
+                    xmlOut.WriteStartDocument();
+
+                // Always begin file with identification and warning
+                xmlOut.WriteComment(Strings.DockPanel_Persistor_XmlFileComment1);
+                xmlOut.WriteComment(Strings.DockPanel_Persistor_XmlFileComment2);
+
+                // Associate a version number with the root element so that future version of the code
+                // will be able to be backwards compatible or at least recognise out of date versions
+                xmlOut.WriteStartElement("DockPanel");
+                xmlOut.WriteAttributeString("FormatVersion", ConfigFileVersion);
+                xmlOut.WriteAttributeString("DockLeftPortion", dockPanel.DockLeftPortion.ToString(CultureInfo.InvariantCulture));
+                xmlOut.WriteAttributeString("DockRightPortion", dockPanel.DockRightPortion.ToString(CultureInfo.InvariantCulture));
+                xmlOut.WriteAttributeString("DockTopPortion", dockPanel.DockTopPortion.ToString(CultureInfo.InvariantCulture));
+                xmlOut.WriteAttributeString("DockBottomPortion", dockPanel.DockBottomPortion.ToString(CultureInfo.InvariantCulture));
+
+                if (!Win32Helper.IsRunningOnMono)
+                {
+                    xmlOut.WriteAttributeString("ActiveDocumentPane", dockPanel.Panes.IndexOf(dockPanel.ActiveDocumentPane).ToString(CultureInfo.InvariantCulture));
+                    xmlOut.WriteAttributeString("ActivePane", dockPanel.Panes.IndexOf(dockPanel.ActivePane).ToString(CultureInfo.InvariantCulture));
+                }                
+
+                // Contents
+                xmlOut.WriteStartElement("Contents");
+                xmlOut.WriteAttributeString("Count", dockPanel.Contents.Count.ToString(CultureInfo.InvariantCulture));
+                foreach (IDockContent content in dockPanel.Contents)
+                {
+                    xmlOut.WriteStartElement("Content");
+                    xmlOut.WriteAttributeString("ID", dockPanel.Contents.IndexOf(content).ToString(CultureInfo.InvariantCulture));
+                    xmlOut.WriteAttributeString("PersistString", content.DockHandler.PersistString);
+                    xmlOut.WriteAttributeString("AutoHidePortion", content.DockHandler.AutoHidePortion.ToString(CultureInfo.InvariantCulture));
+                    xmlOut.WriteAttributeString("IsHidden", content.DockHandler.IsHidden.ToString(CultureInfo.InvariantCulture));
+                    xmlOut.WriteAttributeString("IsFloat", content.DockHandler.IsFloat.ToString(CultureInfo.InvariantCulture));
+                    xmlOut.WriteEndElement();
+                }
+                xmlOut.WriteEndElement();
+
+                // Panes
+                xmlOut.WriteStartElement("Panes");
+                xmlOut.WriteAttributeString("Count", dockPanel.Panes.Count.ToString(CultureInfo.InvariantCulture));
+                foreach (DockPane pane in dockPanel.Panes)
+                {
+                    xmlOut.WriteStartElement("Pane");
+                    xmlOut.WriteAttributeString("ID", dockPanel.Panes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
+                    xmlOut.WriteAttributeString("DockState", pane.DockState.ToString());
+                    xmlOut.WriteAttributeString("ActiveContent", dockPanel.Contents.IndexOf(pane.ActiveContent).ToString(CultureInfo.InvariantCulture));
+                    xmlOut.WriteStartElement("Contents");
+                    xmlOut.WriteAttributeString("Count", pane.Contents.Count.ToString(CultureInfo.InvariantCulture));
+                    foreach (IDockContent content in pane.Contents)
+                    {
+                        xmlOut.WriteStartElement("Content");
+                        xmlOut.WriteAttributeString("ID", pane.Contents.IndexOf(content).ToString(CultureInfo.InvariantCulture));
+                        xmlOut.WriteAttributeString("RefID", dockPanel.Contents.IndexOf(content).ToString(CultureInfo.InvariantCulture));
+                        xmlOut.WriteEndElement();
+                    }
+                    xmlOut.WriteEndElement();
+                    xmlOut.WriteEndElement();
+                }
+                xmlOut.WriteEndElement();
+
+                // DockWindows
+                xmlOut.WriteStartElement("DockWindows");
+                int dockWindowId = 0;
+                foreach (DockWindow dw in dockPanel.DockWindows)
+                {
+                    xmlOut.WriteStartElement("DockWindow");
+                    xmlOut.WriteAttributeString("ID", dockWindowId.ToString(CultureInfo.InvariantCulture));
+                    dockWindowId++;
+                    xmlOut.WriteAttributeString("DockState", dw.DockState.ToString());
+                    xmlOut.WriteAttributeString("ZOrderIndex", dockPanel.Controls.IndexOf(dw).ToString(CultureInfo.InvariantCulture));
+                    xmlOut.WriteStartElement("NestedPanes");
+                    xmlOut.WriteAttributeString("Count", dw.NestedPanes.Count.ToString(CultureInfo.InvariantCulture));
+                    foreach (DockPane pane in dw.NestedPanes)
+                    {
+                        xmlOut.WriteStartElement("Pane");
+                        xmlOut.WriteAttributeString("ID", dw.NestedPanes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
+                        xmlOut.WriteAttributeString("RefID", dockPanel.Panes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
+                        NestedDockingStatus status = pane.NestedDockingStatus;
+                        xmlOut.WriteAttributeString("PrevPane", dockPanel.Panes.IndexOf(status.PreviousPane).ToString(CultureInfo.InvariantCulture));
+                        xmlOut.WriteAttributeString("Alignment", status.Alignment.ToString());
+                        xmlOut.WriteAttributeString("Proportion", status.Proportion.ToString(CultureInfo.InvariantCulture));
+                        xmlOut.WriteEndElement();
+                    }
+                    xmlOut.WriteEndElement();
+                    xmlOut.WriteEndElement();
+                }
+                xmlOut.WriteEndElement();
+
+                // FloatWindows
+                RectangleConverter rectConverter = new RectangleConverter();
+                xmlOut.WriteStartElement("FloatWindows");
+                xmlOut.WriteAttributeString("Count", dockPanel.FloatWindows.Count.ToString(CultureInfo.InvariantCulture));
+                foreach (FloatWindow fw in dockPanel.FloatWindows)
+                {
+                    xmlOut.WriteStartElement("FloatWindow");
+                    xmlOut.WriteAttributeString("ID", dockPanel.FloatWindows.IndexOf(fw).ToString(CultureInfo.InvariantCulture));
+                    xmlOut.WriteAttributeString("Bounds", rectConverter.ConvertToInvariantString(fw.Bounds));
+                    xmlOut.WriteAttributeString("ZOrderIndex", fw.DockPanel.FloatWindows.IndexOf(fw).ToString(CultureInfo.InvariantCulture));
+                    xmlOut.WriteStartElement("NestedPanes");
+                    xmlOut.WriteAttributeString("Count", fw.NestedPanes.Count.ToString(CultureInfo.InvariantCulture));
+                    foreach (DockPane pane in fw.NestedPanes)
+                    {
+                        xmlOut.WriteStartElement("Pane");
+                        xmlOut.WriteAttributeString("ID", fw.NestedPanes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
+                        xmlOut.WriteAttributeString("RefID", dockPanel.Panes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
+                        NestedDockingStatus status = pane.NestedDockingStatus;
+                        xmlOut.WriteAttributeString("PrevPane", dockPanel.Panes.IndexOf(status.PreviousPane).ToString(CultureInfo.InvariantCulture));
+                        xmlOut.WriteAttributeString("Alignment", status.Alignment.ToString());
+                        xmlOut.WriteAttributeString("Proportion", status.Proportion.ToString(CultureInfo.InvariantCulture));
+                        xmlOut.WriteEndElement();
+                    }
+                    xmlOut.WriteEndElement();
+                    xmlOut.WriteEndElement();
+                }
+                xmlOut.WriteEndElement();	//	</FloatWindows>
+
+                xmlOut.WriteEndElement();
+
+                if (!upstream)
+                {
+                    xmlOut.WriteEndDocument();
+                    xmlOut.Close();
+                }
+                else
+                    xmlOut.Flush();
+            }
+
+            public static void LoadFromXml(DockPanel dockPanel, string fileName, DeserializeDockContent deserializeContent)
+            {
+                FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
+                try
+                {
+                    LoadFromXml(dockPanel, fs, deserializeContent);
+                }
+                finally
+                {
+                    fs.Close();
+                }
+            }
+
+            public static void LoadFromXml(DockPanel dockPanel, Stream stream, DeserializeDockContent deserializeContent)
+            {
+                LoadFromXml(dockPanel, stream, deserializeContent, true);
+            }
+
+            private static ContentStruct[] LoadContents(XmlTextReader xmlIn)
+            {
+                int countOfContents = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
+                ContentStruct[] contents = new ContentStruct[countOfContents];
+                MoveToNextElement(xmlIn);
+                for (int i = 0; i < countOfContents; i++)
+                {
+                    int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
+                    if (xmlIn.Name != "Content" || id != i)
+                        throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+
+                    contents[i].PersistString = xmlIn.GetAttribute("PersistString");
+                    contents[i].AutoHidePortion = Convert.ToDouble(xmlIn.GetAttribute("AutoHidePortion"), CultureInfo.InvariantCulture);
+                    contents[i].IsHidden = Convert.ToBoolean(xmlIn.GetAttribute("IsHidden"), CultureInfo.InvariantCulture);
+                    contents[i].IsFloat = Convert.ToBoolean(xmlIn.GetAttribute("IsFloat"), CultureInfo.InvariantCulture);
+                    MoveToNextElement(xmlIn);
+                }
+
+                return contents;
+            }
+
+            private static PaneStruct[] LoadPanes(XmlTextReader xmlIn)
+            {
+                EnumConverter dockStateConverter = new EnumConverter(typeof(DockState));
+                int countOfPanes = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
+                PaneStruct[] panes = new PaneStruct[countOfPanes];
+                MoveToNextElement(xmlIn);
+                for (int i = 0; i < countOfPanes; i++)
+                {
+                    int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
+                    if (xmlIn.Name != "Pane" || id != i)
+                        throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+
+                    panes[i].DockState = (DockState)dockStateConverter.ConvertFrom(xmlIn.GetAttribute("DockState"));
+                    panes[i].IndexActiveContent = Convert.ToInt32(xmlIn.GetAttribute("ActiveContent"), CultureInfo.InvariantCulture);
+                    panes[i].ZOrderIndex = -1;
+
+                    MoveToNextElement(xmlIn);
+                    if (xmlIn.Name != "Contents")
+                        throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+                    int countOfPaneContents = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
+                    panes[i].IndexContents = new int[countOfPaneContents];
+                    MoveToNextElement(xmlIn);
+                    for (int j = 0; j < countOfPaneContents; j++)
+                    {
+                        int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
+                        if (xmlIn.Name != "Content" || id2 != j)
+                            throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+
+                        panes[i].IndexContents[j] = Convert.ToInt32(xmlIn.GetAttribute("RefID"), CultureInfo.InvariantCulture);
+                        MoveToNextElement(xmlIn);
+                    }
+                }
+
+                return panes;
+            }
+
+            private static DockWindowStruct[] LoadDockWindows(XmlTextReader xmlIn, DockPanel dockPanel)
+            {
+                EnumConverter dockStateConverter = new EnumConverter(typeof(DockState));
+                EnumConverter dockAlignmentConverter = new EnumConverter(typeof(DockAlignment));
+                int countOfDockWindows = dockPanel.DockWindows.Count;
+                DockWindowStruct[] dockWindows = new DockWindowStruct[countOfDockWindows];
+                MoveToNextElement(xmlIn);
+                for (int i = 0; i < countOfDockWindows; i++)
+                {
+                    int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
+                    if (xmlIn.Name != "DockWindow" || id != i)
+                        throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+
+                    dockWindows[i].DockState = (DockState)dockStateConverter.ConvertFrom(xmlIn.GetAttribute("DockState"));
+                    dockWindows[i].ZOrderIndex = Convert.ToInt32(xmlIn.GetAttribute("ZOrderIndex"), CultureInfo.InvariantCulture);
+                    MoveToNextElement(xmlIn);
+                    if (xmlIn.Name != "DockList" && xmlIn.Name != "NestedPanes")
+                        throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+                    int countOfNestedPanes = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
+                    dockWindows[i].NestedPanes = new NestedPane[countOfNestedPanes];
+                    MoveToNextElement(xmlIn);
+                    for (int j = 0; j < countOfNestedPanes; j++)
+                    {
+                        int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
+                        if (xmlIn.Name != "Pane" || id2 != j)
+                            throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+                        dockWindows[i].NestedPanes[j].IndexPane = Convert.ToInt32(xmlIn.GetAttribute("RefID"), CultureInfo.InvariantCulture);
+                        dockWindows[i].NestedPanes[j].IndexPrevPane = Convert.ToInt32(xmlIn.GetAttribute("PrevPane"), CultureInfo.InvariantCulture);
+                        dockWindows[i].NestedPanes[j].Alignment = (DockAlignment)dockAlignmentConverter.ConvertFrom(xmlIn.GetAttribute("Alignment"));
+                        dockWindows[i].NestedPanes[j].Proportion = Convert.ToDouble(xmlIn.GetAttribute("Proportion"), CultureInfo.InvariantCulture);
+                        MoveToNextElement(xmlIn);
+                    }
+                }
+
+                return dockWindows;
+            }
+
+            private static FloatWindowStruct[] LoadFloatWindows(XmlTextReader xmlIn)
+            {
+                EnumConverter dockAlignmentConverter = new EnumConverter(typeof(DockAlignment));
+                RectangleConverter rectConverter = new RectangleConverter();
+                int countOfFloatWindows = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
+                FloatWindowStruct[] floatWindows = new FloatWindowStruct[countOfFloatWindows];
+                MoveToNextElement(xmlIn);
+                for (int i = 0; i < countOfFloatWindows; i++)
+                {
+                    int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
+                    if (xmlIn.Name != "FloatWindow" || id != i)
+                        throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+
+                    floatWindows[i].Bounds = (Rectangle)rectConverter.ConvertFromInvariantString(xmlIn.GetAttribute("Bounds"));
+                    floatWindows[i].ZOrderIndex = Convert.ToInt32(xmlIn.GetAttribute("ZOrderIndex"), CultureInfo.InvariantCulture);
+                    MoveToNextElement(xmlIn);
+                    if (xmlIn.Name != "DockList" && xmlIn.Name != "NestedPanes")
+                        throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+                    int countOfNestedPanes = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
+                    floatWindows[i].NestedPanes = new NestedPane[countOfNestedPanes];
+                    MoveToNextElement(xmlIn);
+                    for (int j = 0; j < countOfNestedPanes; j++)
+                    {
+                        int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
+                        if (xmlIn.Name != "Pane" || id2 != j)
+                            throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+                        floatWindows[i].NestedPanes[j].IndexPane = Convert.ToInt32(xmlIn.GetAttribute("RefID"), CultureInfo.InvariantCulture);
+                        floatWindows[i].NestedPanes[j].IndexPrevPane = Convert.ToInt32(xmlIn.GetAttribute("PrevPane"), CultureInfo.InvariantCulture);
+                        floatWindows[i].NestedPanes[j].Alignment = (DockAlignment)dockAlignmentConverter.ConvertFrom(xmlIn.GetAttribute("Alignment"));
+                        floatWindows[i].NestedPanes[j].Proportion = Convert.ToDouble(xmlIn.GetAttribute("Proportion"), CultureInfo.InvariantCulture);
+                        MoveToNextElement(xmlIn);
+                    }
+                }
+
+                return floatWindows;
+            }
+
+            public static void LoadFromXml(DockPanel dockPanel, Stream stream, DeserializeDockContent deserializeContent, bool closeStream)
+            {
+
+                if (dockPanel.Contents.Count != 0)
+                    throw new InvalidOperationException(Strings.DockPanel_LoadFromXml_AlreadyInitialized);
+
+                XmlTextReader xmlIn = new XmlTextReader(stream);
+                xmlIn.WhitespaceHandling = WhitespaceHandling.None;
+                xmlIn.MoveToContent();
+
+                while (!xmlIn.Name.Equals("DockPanel"))
+                {
+                    if (!MoveToNextElement(xmlIn))
+                        throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+                }
+
+                string formatVersion = xmlIn.GetAttribute("FormatVersion");
+                if (!IsFormatVersionValid(formatVersion))
+                    throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidFormatVersion);
+
+                DockPanelStruct dockPanelStruct = new DockPanelStruct();
+                dockPanelStruct.DockLeftPortion = Convert.ToDouble(xmlIn.GetAttribute("DockLeftPortion"), CultureInfo.InvariantCulture);
+                dockPanelStruct.DockRightPortion = Convert.ToDouble(xmlIn.GetAttribute("DockRightPortion"), CultureInfo.InvariantCulture);
+                dockPanelStruct.DockTopPortion = Convert.ToDouble(xmlIn.GetAttribute("DockTopPortion"), CultureInfo.InvariantCulture);
+                dockPanelStruct.DockBottomPortion = Convert.ToDouble(xmlIn.GetAttribute("DockBottomPortion"), CultureInfo.InvariantCulture);
+                dockPanelStruct.IndexActiveDocumentPane = Convert.ToInt32(xmlIn.GetAttribute("ActiveDocumentPane"), CultureInfo.InvariantCulture);
+                dockPanelStruct.IndexActivePane = Convert.ToInt32(xmlIn.GetAttribute("ActivePane"), CultureInfo.InvariantCulture);
+
+                // Load Contents
+                MoveToNextElement(xmlIn);
+                if (xmlIn.Name != "Contents")
+                    throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+                ContentStruct[] contents = LoadContents(xmlIn);
+
+                // Load Panes
+                if (xmlIn.Name != "Panes")
+                    throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+                PaneStruct[] panes = LoadPanes(xmlIn);
+
+                // Load DockWindows
+                if (xmlIn.Name != "DockWindows")
+                    throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+                DockWindowStruct[] dockWindows = LoadDockWindows(xmlIn, dockPanel);
+
+                // Load FloatWindows
+                if (xmlIn.Name != "FloatWindows")
+                    throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
+                FloatWindowStruct[] floatWindows = LoadFloatWindows(xmlIn);
+
+                if (closeStream)
+                    xmlIn.Close();
+
+                dockPanel.SuspendLayout(true);
+
+                dockPanel.DockLeftPortion = dockPanelStruct.DockLeftPortion;
+                dockPanel.DockRightPortion = dockPanelStruct.DockRightPortion;
+                dockPanel.DockTopPortion = dockPanelStruct.DockTopPortion;
+                dockPanel.DockBottomPortion = dockPanelStruct.DockBottomPortion;
+
+                // Set DockWindow ZOrders
+                int prevMaxDockWindowZOrder = int.MaxValue;
+                for (int i = 0; i < dockWindows.Length; i++)
+                {
+                    int maxDockWindowZOrder = -1;
+                    int index = -1;
+                    for (int j = 0; j < dockWindows.Length; j++)
+                    {
+                        if (dockWindows[j].ZOrderIndex > maxDockWindowZOrder && dockWindows[j].ZOrderIndex < prevMaxDockWindowZOrder)
+                        {
+                            maxDockWindowZOrder = dockWindows[j].ZOrderIndex;
+                            index = j;
+                        }
+                    }
+
+                    dockPanel.DockWindows[dockWindows[index].DockState].BringToFront();
+                    prevMaxDockWindowZOrder = maxDockWindowZOrder;
+                }
+
+                // Create Contents
+                for (int i = 0; i < contents.Length; i++)
+                {
+                    IDockContent content = deserializeContent(contents[i].PersistString);
+                    if (content == null)
+                        content = new DummyContent();
+                    content.DockHandler.DockPanel = dockPanel;
+                    content.DockHandler.AutoHidePortion = contents[i].AutoHidePortion;
+                    content.DockHandler.IsHidden = true;
+                    content.DockHandler.IsFloat = contents[i].IsFloat;
+                }
+
+                // Create panes
+                for (int i = 0; i < panes.Length; i++)
+                {
+                    DockPane pane = null;
+                    for (int j = 0; j < panes[i].IndexContents.Length; j++)
+                    {
+                        IDockContent content = dockPanel.Contents[panes[i].IndexContents[j]];
+                        if (j == 0)
+                            pane = dockPanel.DockPaneFactory.CreateDockPane(content, panes[i].DockState, false);
+                        else if (panes[i].DockState == DockState.Float)
+                            content.DockHandler.FloatPane = pane;
+                        else
+                            content.DockHandler.PanelPane = pane;
+                    }
+                }
+
+                // Assign Panes to DockWindows
+                for (int i = 0; i < dockWindows.Length; i++)
+                {
+                    for (int j = 0; j < dockWindows[i].NestedPanes.Length; j++)
+                    {
+                        DockWindow dw = dockPanel.DockWindows[dockWindows[i].DockState];
+                        int indexPane = dockWindows[i].NestedPanes[j].IndexPane;
+                        DockPane pane = dockPanel.Panes[indexPane];
+                        int indexPrevPane = dockWindows[i].NestedPanes[j].IndexPrevPane;
+                        DockPane prevPane = (indexPrevPane == -1) ? dw.NestedPanes.GetDefaultPreviousPane(pane) : dockPanel.Panes[indexPrevPane];
+                        DockAlignment alignment = dockWindows[i].NestedPanes[j].Alignment;
+                        double proportion = dockWindows[i].NestedPanes[j].Proportion;
+                        pane.DockTo(dw, prevPane, alignment, proportion);
+                        if (panes[indexPane].DockState == dw.DockState)
+                            panes[indexPane].ZOrderIndex = dockWindows[i].ZOrderIndex;
+                    }
+                }
+
+                // Create float windows
+                for (int i = 0; i < floatWindows.Length; i++)
+                {
+                    FloatWindow fw = null;
+                    for (int j = 0; j < floatWindows[i].NestedPanes.Length; j++)
+                    {
+                        int indexPane = floatWindows[i].NestedPanes[j].IndexPane;
+                        DockPane pane = dockPanel.Panes[indexPane];
+                        if (j == 0)
+                            fw = dockPanel.FloatWindowFactory.CreateFloatWindow(dockPanel, pane, floatWindows[i].Bounds);
+                        else
+                        {
+                            int indexPrevPane = floatWindows[i].NestedPanes[j].IndexPrevPane;
+                            DockPane prevPane = indexPrevPane == -1 ? null : dockPanel.Panes[indexPrevPane];
+                            DockAlignment alignment = floatWindows[i].NestedPanes[j].Alignment;
+                            double proportion = floatWindows[i].NestedPanes[j].Proportion;
+                            pane.DockTo(fw, prevPane, alignment, proportion);
+                        }
+
+                        if (panes[indexPane].DockState == fw.DockState)
+                            panes[indexPane].ZOrderIndex = floatWindows[i].ZOrderIndex;
+                    }
+                }
+
+                // sort IDockContent by its Pane's ZOrder
+                int[] sortedContents = null;
+                if (contents.Length > 0)
+                {
+                    sortedContents = new int[contents.Length];
+                    for (int i = 0; i < contents.Length; i++)
+                        sortedContents[i] = i;
+
+                    int lastDocument = contents.Length;
+                    for (int i = 0; i < contents.Length - 1; i++)
+                    {
+                        for (int j = i + 1; j < contents.Length; j++)
+                        {
+                            DockPane pane1 = dockPanel.Contents[sortedContents[i]].DockHandler.Pane;
+                            int ZOrderIndex1 = pane1 == null ? 0 : panes[dockPanel.Panes.IndexOf(pane1)].ZOrderIndex;
+                            DockPane pane2 = dockPanel.Contents[sortedContents[j]].DockHandler.Pane;
+                            int ZOrderIndex2 = pane2 == null ? 0 : panes[dockPanel.Panes.IndexOf(pane2)].ZOrderIndex;
+                            if (ZOrderIndex1 > ZOrderIndex2)
+                            {
+                                int temp = sortedContents[i];
+                                sortedContents[i] = sortedContents[j];
+                                sortedContents[j] = temp;
+                            }
+                        }
+                    }
+                }
+
+                // show non-document IDockContent first to avoid screen flickers
+                for (int i = 0; i < contents.Length; i++)
+                {
+                    IDockContent content = dockPanel.Contents[sortedContents[i]];
+                    if (content.DockHandler.Pane != null && content.DockHandler.Pane.DockState != DockState.Document)
+                        content.DockHandler.IsHidden = contents[sortedContents[i]].IsHidden;
+                }
+
+                // after all non-document IDockContent, show document IDockContent
+                for (int i = 0; i < contents.Length; i++)
+                {
+                    IDockContent content = dockPanel.Contents[sortedContents[i]];
+                    if (content.DockHandler.Pane != null && content.DockHandler.Pane.DockState == DockState.Document)
+                        content.DockHandler.IsHidden = contents[sortedContents[i]].IsHidden;
+                }
+
+                for (int i = 0; i < panes.Length; i++)
+                    dockPanel.Panes[i].ActiveContent = panes[i].IndexActiveContent == -1 ? null : dockPanel.Contents[panes[i].IndexActiveContent];
+
+                if (dockPanelStruct.IndexActiveDocumentPane != -1)
+                    dockPanel.Panes[dockPanelStruct.IndexActiveDocumentPane].Activate();
+
+                if (dockPanelStruct.IndexActivePane != -1)
+                    dockPanel.Panes[dockPanelStruct.IndexActivePane].Activate();
+
+                for (int i = dockPanel.Contents.Count - 1; i >= 0; i--)
+                    if (dockPanel.Contents[i] is DummyContent)
+                        dockPanel.Contents[i].DockHandler.Form.Close();
+
+                dockPanel.ResumeLayout(true, true);
+            }
+
+            private static bool MoveToNextElement(XmlTextReader xmlIn)
+            {
+                if (!xmlIn.Read())
+                    return false;
+
+                while (xmlIn.NodeType == XmlNodeType.EndElement)
+                {
+                    if (!xmlIn.Read())
+                        return false;
+                }
+
+                return true;
+            }
+
+            private static bool IsFormatVersionValid(string formatVersion)
+            {
+                if (formatVersion == ConfigFileVersion)
+                    return true;
+
+                foreach (string s in CompatibleConfigFileVersions)
+                    if (s == formatVersion)
+                        return true;
+
+                return false;
+            }
+        }
+
+        public void SaveAsXml(string fileName)
+        {
+            Persistor.SaveAsXml(this, fileName);
+        }
+
+        public void SaveAsXml(string fileName, Encoding encoding)
+        {
+            Persistor.SaveAsXml(this, fileName, encoding);
+        }
+
+        public void SaveAsXml(Stream stream, Encoding encoding)
+        {
+            Persistor.SaveAsXml(this, stream, encoding);
+        }
+
+        public void SaveAsXml(Stream stream, Encoding encoding, bool upstream)
+        {
+            Persistor.SaveAsXml(this, stream, encoding, upstream);
+        }
+
+        public void LoadFromXml(string fileName, DeserializeDockContent deserializeContent)
+        {
+            Persistor.LoadFromXml(this, fileName, deserializeContent);
+        }
+
+        public void LoadFromXml(Stream stream, DeserializeDockContent deserializeContent)
+        {
+            Persistor.LoadFromXml(this, stream, deserializeContent);
+        }
+
+        public void LoadFromXml(Stream stream, DeserializeDockContent deserializeContent, bool closeStream)
+        {
+            Persistor.LoadFromXml(this, stream, deserializeContent, closeStream);
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.SplitterDragHandler.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.SplitterDragHandler.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.SplitterDragHandler.cs	(revision 8616)
@@ -0,0 +1,165 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.ComponentModel;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    partial class DockPanel
+    {
+        private sealed class SplitterDragHandler : DragHandler
+        {
+            private class SplitterOutline
+            {
+                public SplitterOutline()
+                {
+                    m_dragForm = new DragForm();
+                    SetDragForm(Rectangle.Empty);
+                    DragForm.BackColor = Color.Black;
+                    DragForm.Opacity = 0.7;
+                    DragForm.Show(false);
+                }
+
+                DragForm m_dragForm;
+                private DragForm DragForm
+                {
+                    get { return m_dragForm; }
+                }
+
+                public void Show(Rectangle rect)
+                {
+                    SetDragForm(rect);
+                }
+
+                public void Close()
+                {
+                    DragForm.Close();
+                }
+
+                private void SetDragForm(Rectangle rect)
+                {
+                    DragForm.Bounds = rect;
+                    if (rect == Rectangle.Empty)
+                        DragForm.Region = new Region(Rectangle.Empty);
+                    else if (DragForm.Region != null)
+                        DragForm.Region = null;
+                }
+            }
+
+            public SplitterDragHandler(DockPanel dockPanel)
+                : base(dockPanel)
+            {
+            }
+
+            public new ISplitterDragSource DragSource
+            {
+                get { return base.DragSource as ISplitterDragSource; }
+                private set { base.DragSource = value; }
+            }
+
+            private SplitterOutline m_outline;
+            private SplitterOutline Outline
+            {
+                get { return m_outline; }
+                set { m_outline = value; }
+            }
+
+            private Rectangle m_rectSplitter;
+            private Rectangle RectSplitter
+            {
+                get { return m_rectSplitter; }
+                set { m_rectSplitter = value; }
+            }
+
+            public void BeginDrag(ISplitterDragSource dragSource, Rectangle rectSplitter)
+            {
+                DragSource = dragSource;
+                RectSplitter = rectSplitter;
+
+                if (!BeginDrag())
+                {
+                    DragSource = null;
+                    return;
+                }
+
+                Outline = new SplitterOutline();
+                Outline.Show(rectSplitter);
+                DragSource.BeginDrag(rectSplitter);
+            }
+
+            protected override void OnDragging()
+            {
+                Outline.Show(GetSplitterOutlineBounds(Control.MousePosition));
+            }
+
+            protected override void OnEndDrag(bool abort)
+            {
+                DockPanel.SuspendLayout(true);
+
+                Outline.Close();
+
+                if (!abort)
+                    DragSource.MoveSplitter(GetMovingOffset(Control.MousePosition));
+
+                DragSource.EndDrag();
+                DockPanel.ResumeLayout(true, true);
+            }
+
+            private int GetMovingOffset(Point ptMouse)
+            {
+                Rectangle rect = GetSplitterOutlineBounds(ptMouse);
+                if (DragSource.IsVertical)
+                    return rect.X - RectSplitter.X;
+                else
+                    return rect.Y - RectSplitter.Y;
+            }
+
+            private Rectangle GetSplitterOutlineBounds(Point ptMouse)
+            {
+                Rectangle rectLimit = DragSource.DragLimitBounds;
+
+                Rectangle rect = RectSplitter;
+                if (rectLimit.Width <= 0 || rectLimit.Height <= 0)
+                    return rect;
+
+                if (DragSource.IsVertical)
+                {
+                    rect.X += ptMouse.X - StartMousePosition.X;
+                    rect.Height = rectLimit.Height;
+                }
+                else
+                {
+                    rect.Y += ptMouse.Y - StartMousePosition.Y;
+                    rect.Width = rectLimit.Width;
+                }
+
+                if (rect.Left < rectLimit.Left)
+                    rect.X = rectLimit.X;
+                if (rect.Top < rectLimit.Top)
+                    rect.Y = rectLimit.Y;
+                if (rect.Right > rectLimit.Right)
+                    rect.X -= rect.Right - rectLimit.Right;
+                if (rect.Bottom > rectLimit.Bottom)
+                    rect.Y -= rect.Bottom - rectLimit.Bottom;
+
+                return rect;
+            }
+        }
+
+        private SplitterDragHandler m_splitterDragHandler = null;
+        private SplitterDragHandler GetSplitterDragHandler()
+        {
+            if (m_splitterDragHandler == null)
+                m_splitterDragHandler = new SplitterDragHandler(this);
+            return m_splitterDragHandler;
+        }
+
+        internal void BeginDrag(ISplitterDragSource dragSource, Rectangle rectSplitter)
+        {
+            GetSplitterDragHandler().BeginDrag(dragSource, rectSplitter);
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.cs	(revision 8616)
@@ -0,0 +1,1080 @@
+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;
+
+// To simplify the process of finding the toolbox bitmap resource:
+// #1 Create an internal class called "resfinder" outside of the root namespace.
+// #2 Use "resfinder" in the toolbox bitmap attribute instead of the control name.
+// #3 use the "<default namespace>.<resourcename>" string to locate the resource.
+// See: http://www.bobpowell.net/toolboxbitmap.htm
+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[]	{
+				DockWindows[DockState.Document],
+				DockWindows[DockState.DockLeft],
+				DockWindows[DockState.DockRight],
+				DockWindows[DockState.DockTop],
+				DockWindows[DockState.DockBottom]
+				});
+
+			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);
+		}
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanelExtender.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanelExtender.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanelExtender.cs	(revision 8616)
@@ -0,0 +1,225 @@
+using System;
+using System.Drawing;
+using System.Diagnostics.CodeAnalysis;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public sealed class DockPanelExtender
+	{
+        [SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
+        public interface IDockPaneFactory
+		{
+			DockPane CreateDockPane(IDockContent content, DockState visibleState, bool show);
+            [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters", MessageId = "1#")]            
+			DockPane CreateDockPane(IDockContent content, FloatWindow floatWindow, bool show);
+			DockPane CreateDockPane(IDockContent content, DockPane previousPane, DockAlignment alignment, double proportion, bool show);
+            [SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters", MessageId = "1#")]            
+			DockPane CreateDockPane(IDockContent content, Rectangle floatWindowBounds, bool show);
+		}
+
+        [SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
+        public interface IFloatWindowFactory
+		{
+			FloatWindow CreateFloatWindow(DockPanel dockPanel, DockPane pane);
+			FloatWindow CreateFloatWindow(DockPanel dockPanel, DockPane pane, Rectangle bounds);
+		}
+
+        [SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
+        public interface IDockPaneCaptionFactory
+		{
+			DockPaneCaptionBase CreateDockPaneCaption(DockPane pane);
+		}
+
+        [SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
+        public interface IDockPaneStripFactory
+		{
+			DockPaneStripBase CreateDockPaneStrip(DockPane pane);
+		}
+
+        [SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
+        public interface IAutoHideStripFactory
+		{
+			AutoHideStripBase CreateAutoHideStrip(DockPanel panel);
+		}
+
+		#region DefaultDockPaneFactory
+		private class DefaultDockPaneFactory : IDockPaneFactory
+		{
+			public DockPane CreateDockPane(IDockContent content, DockState visibleState, bool show)
+			{
+				return new DockPane(content, visibleState, show);
+			}
+
+			public DockPane CreateDockPane(IDockContent content, FloatWindow floatWindow, bool show)
+			{
+				return new DockPane(content, floatWindow, show);
+			}
+
+			public DockPane CreateDockPane(IDockContent content, DockPane prevPane, DockAlignment alignment, double proportion, bool show)
+			{
+				return new DockPane(content, prevPane, alignment, proportion, show);
+			}
+
+			public DockPane CreateDockPane(IDockContent content, Rectangle floatWindowBounds, bool show)
+			{
+				return new DockPane(content, floatWindowBounds, show);
+			}
+		}
+		#endregion
+
+		#region DefaultFloatWindowFactory
+		private class DefaultFloatWindowFactory : IFloatWindowFactory
+		{
+			public FloatWindow CreateFloatWindow(DockPanel dockPanel, DockPane pane)
+			{
+				return new FloatWindow(dockPanel, pane);
+			}
+
+			public FloatWindow CreateFloatWindow(DockPanel dockPanel, DockPane pane, Rectangle bounds)
+			{
+				return new FloatWindow(dockPanel, pane, bounds);
+			}
+		}
+		#endregion
+
+		#region DefaultDockPaneCaptionFactory
+		private class DefaultDockPaneCaptionFactory : IDockPaneCaptionFactory
+		{
+			public DockPaneCaptionBase CreateDockPaneCaption(DockPane pane)
+			{
+				return new VS2005DockPaneCaption(pane);
+			}
+		}
+		#endregion
+
+		#region DefaultDockPaneTabStripFactory
+		private class DefaultDockPaneStripFactory : IDockPaneStripFactory
+		{
+			public DockPaneStripBase CreateDockPaneStrip(DockPane pane)
+			{
+				return new VS2005DockPaneStrip(pane);
+			}
+		}
+		#endregion
+
+		#region DefaultAutoHideStripFactory
+		private class DefaultAutoHideStripFactory : IAutoHideStripFactory
+		{
+			public AutoHideStripBase CreateAutoHideStrip(DockPanel panel)
+			{
+				return new VS2005AutoHideStrip(panel);
+			}
+		}
+		#endregion
+
+		internal DockPanelExtender(DockPanel dockPanel)
+		{
+			m_dockPanel = dockPanel;
+		}
+
+		private DockPanel m_dockPanel;
+		private DockPanel DockPanel
+		{
+			get	{	return m_dockPanel;	}
+		}
+
+		private IDockPaneFactory m_dockPaneFactory = null;
+		public IDockPaneFactory DockPaneFactory
+		{
+			get
+			{
+				if (m_dockPaneFactory == null)
+					m_dockPaneFactory = new DefaultDockPaneFactory();
+
+				return m_dockPaneFactory;
+			}
+			set
+			{
+				if (DockPanel.Panes.Count > 0)
+					throw new InvalidOperationException();
+
+				m_dockPaneFactory = value;
+			}
+		}
+
+		private IFloatWindowFactory m_floatWindowFactory = null;
+		public IFloatWindowFactory FloatWindowFactory
+		{
+			get
+			{
+				if (m_floatWindowFactory == null)
+					m_floatWindowFactory = new DefaultFloatWindowFactory();
+
+				return m_floatWindowFactory;
+			}
+			set
+			{
+				if (DockPanel.FloatWindows.Count > 0)
+					throw new InvalidOperationException();
+
+				m_floatWindowFactory = value;
+			}
+		}
+
+		private IDockPaneCaptionFactory m_dockPaneCaptionFactory = null;
+		public IDockPaneCaptionFactory DockPaneCaptionFactory
+		{	
+			get
+			{
+				if (m_dockPaneCaptionFactory == null)
+					m_dockPaneCaptionFactory = new DefaultDockPaneCaptionFactory();
+
+				return m_dockPaneCaptionFactory;
+			}
+			set
+			{
+				if (DockPanel.Panes.Count > 0)
+					throw new InvalidOperationException();
+
+				m_dockPaneCaptionFactory = value;
+			}
+		}
+
+		private IDockPaneStripFactory m_dockPaneStripFactory = null;
+		public IDockPaneStripFactory DockPaneStripFactory
+		{
+			get
+			{
+				if (m_dockPaneStripFactory == null)
+					m_dockPaneStripFactory = new DefaultDockPaneStripFactory();
+
+				return m_dockPaneStripFactory;
+			}
+			set
+			{
+				if (DockPanel.Contents.Count > 0)
+					throw new InvalidOperationException();
+
+				m_dockPaneStripFactory = value;
+			}
+		}
+
+		private IAutoHideStripFactory m_autoHideStripFactory = null;
+		public IAutoHideStripFactory AutoHideStripFactory
+		{	
+			get
+			{
+				if (m_autoHideStripFactory == null)
+					m_autoHideStripFactory = new DefaultAutoHideStripFactory();
+
+				return m_autoHideStripFactory;
+			}
+			set
+			{
+				if (DockPanel.Contents.Count > 0)
+					throw new InvalidOperationException();
+
+				if (m_autoHideStripFactory == value)
+					return;
+
+				m_autoHideStripFactory = value;
+                DockPanel.ResetAutoHideStripControl();
+			}
+		}
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanelSkin.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanelSkin.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanelSkin.cs	(revision 8616)
@@ -0,0 +1,371 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Drawing.Design;
+using System.Windows.Forms.Design;
+using System.ComponentModel;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    #region DockPanelSkin classes
+    /// <summary>
+    /// The skin to use when displaying the DockPanel.
+    /// The skin allows custom gradient color schemes to be used when drawing the
+    /// DockStrips and Tabs.
+    /// </summary>
+    [TypeConverter(typeof(DockPanelSkinConverter))]
+    public class DockPanelSkin
+    {
+        private AutoHideStripSkin m_autoHideStripSkin = new AutoHideStripSkin();
+        private DockPaneStripSkin m_dockPaneStripSkin = new DockPaneStripSkin();
+
+        /// <summary>
+        /// The skin used to display the auto hide strips and tabs.
+        /// </summary>
+        public AutoHideStripSkin AutoHideStripSkin
+        {
+            get { return m_autoHideStripSkin; }
+            set { m_autoHideStripSkin = value; }
+        }
+
+        /// <summary>
+        /// The skin used to display the Document and ToolWindow style DockStrips and Tabs.
+        /// </summary>
+        public DockPaneStripSkin DockPaneStripSkin
+        {
+            get { return m_dockPaneStripSkin; }
+            set { m_dockPaneStripSkin = value; }
+        }
+    }
+
+    /// <summary>
+    /// The skin used to display the auto hide strip and tabs.
+    /// </summary>
+    [TypeConverter(typeof(AutoHideStripConverter))]
+    public class AutoHideStripSkin
+    {
+        private DockPanelGradient m_dockStripGradient = new DockPanelGradient();
+        private TabGradient m_TabGradient = new TabGradient();
+        private Font m_textFont = SystemFonts.MenuFont;
+
+        /// <summary>
+        /// The gradient color skin for the DockStrips.
+        /// </summary>
+        public DockPanelGradient DockStripGradient
+        {
+            get { return m_dockStripGradient; }
+            set { m_dockStripGradient = value; }
+        }
+
+        /// <summary>
+        /// The gradient color skin for the Tabs.
+        /// </summary>
+        public TabGradient TabGradient
+        {
+            get { return m_TabGradient; }
+            set { m_TabGradient = value; }
+        }
+
+        /// <summary>
+        /// Font used in AutoHideStrip elements.
+        /// </summary>
+        [DefaultValue(typeof(SystemFonts), "MenuFont")]
+        public Font TextFont
+        {
+            get { return m_textFont; }
+            set { m_textFont = value; }
+        }
+    }
+
+    /// <summary>
+    /// The skin used to display the document and tool strips and tabs.
+    /// </summary>
+    [TypeConverter(typeof(DockPaneStripConverter))]
+    public class DockPaneStripSkin
+    {
+        private DockPaneStripGradient m_DocumentGradient = new DockPaneStripGradient();
+        private DockPaneStripToolWindowGradient m_ToolWindowGradient = new DockPaneStripToolWindowGradient();
+        private Font m_textFont = SystemFonts.MenuFont;
+
+        /// <summary>
+        /// The skin used to display the Document style DockPane strip and tab.
+        /// </summary>
+        public DockPaneStripGradient DocumentGradient
+        {
+            get { return m_DocumentGradient; }
+            set { m_DocumentGradient = value; }
+        }
+
+        /// <summary>
+        /// The skin used to display the ToolWindow style DockPane strip and tab.
+        /// </summary>
+        public DockPaneStripToolWindowGradient ToolWindowGradient
+        {
+            get { return m_ToolWindowGradient; }
+            set { m_ToolWindowGradient = value; }
+        }
+
+        /// <summary>
+        /// Font used in DockPaneStrip elements.
+        /// </summary>
+        [DefaultValue(typeof(SystemFonts), "MenuFont")]
+        public Font TextFont
+        {
+            get { return m_textFont; }
+            set { m_textFont = value; }
+        }
+    }
+
+    /// <summary>
+    /// The skin used to display the DockPane ToolWindow strip and tab.
+    /// </summary>
+    [TypeConverter(typeof(DockPaneStripGradientConverter))]
+    public class DockPaneStripToolWindowGradient : DockPaneStripGradient
+    {
+        private TabGradient m_activeCaptionGradient = new TabGradient();
+        private TabGradient m_inactiveCaptionGradient = new TabGradient();
+
+        /// <summary>
+        /// The skin used to display the active ToolWindow caption.
+        /// </summary>
+        public TabGradient ActiveCaptionGradient
+        {
+            get { return m_activeCaptionGradient; }
+            set { m_activeCaptionGradient = value; }
+        }
+
+        /// <summary>
+        /// The skin used to display the inactive ToolWindow caption.
+        /// </summary>
+        public TabGradient InactiveCaptionGradient
+        {
+            get { return m_inactiveCaptionGradient; }
+            set { m_inactiveCaptionGradient = value; }
+        }
+    }
+
+    /// <summary>
+    /// The skin used to display the DockPane strip and tab.
+    /// </summary>
+    [TypeConverter(typeof(DockPaneStripGradientConverter))]
+    public class DockPaneStripGradient
+    {
+        private DockPanelGradient m_dockStripGradient = new DockPanelGradient();
+        private TabGradient m_activeTabGradient = new TabGradient();
+        private TabGradient m_inactiveTabGradient = new TabGradient();
+
+        /// <summary>
+        /// The gradient color skin for the DockStrip.
+        /// </summary>
+        public DockPanelGradient DockStripGradient
+        {
+            get { return m_dockStripGradient; }
+            set { m_dockStripGradient = value; }
+        }
+
+        /// <summary>
+        /// The skin used to display the active DockPane tabs.
+        /// </summary>
+        public TabGradient ActiveTabGradient
+        {
+            get { return m_activeTabGradient; }
+            set { m_activeTabGradient = value; }
+        }
+
+        /// <summary>
+        /// The skin used to display the inactive DockPane tabs.
+        /// </summary>
+        public TabGradient InactiveTabGradient
+        {
+            get { return m_inactiveTabGradient; }
+            set { m_inactiveTabGradient = value; }
+        }
+    }
+
+    /// <summary>
+    /// The skin used to display the dock pane tab
+    /// </summary>
+    [TypeConverter(typeof(DockPaneTabGradientConverter))]
+    public class TabGradient : DockPanelGradient
+    {
+        private Color m_textColor = SystemColors.ControlText;
+
+        /// <summary>
+        /// The text color.
+        /// </summary>
+        [DefaultValue(typeof(SystemColors), "ControlText")]
+        public Color TextColor
+        {
+            get { return m_textColor; }
+            set { m_textColor = value; }
+        }
+    }
+
+    /// <summary>
+    /// The gradient color skin.
+    /// </summary>
+    [TypeConverter(typeof(DockPanelGradientConverter))]
+    public class DockPanelGradient
+    {
+        private Color m_startColor = SystemColors.Control;
+        private Color m_endColor = SystemColors.Control;
+        private LinearGradientMode m_linearGradientMode = LinearGradientMode.Horizontal;
+
+        /// <summary>
+        /// The beginning gradient color.
+        /// </summary>
+        [DefaultValue(typeof(SystemColors), "Control")]
+        public Color StartColor
+        {
+            get { return m_startColor; }
+            set { m_startColor = value; }
+        }
+
+        /// <summary>
+        /// The ending gradient color.
+        /// </summary>
+        [DefaultValue(typeof(SystemColors), "Control")]
+        public Color EndColor
+        {
+            get { return m_endColor; }
+            set { m_endColor = value; }
+        }
+
+        /// <summary>
+        /// The gradient mode to display the colors.
+        /// </summary>
+        [DefaultValue(LinearGradientMode.Horizontal)]
+        public LinearGradientMode LinearGradientMode
+        {
+            get { return m_linearGradientMode; }
+            set { m_linearGradientMode = value; }
+        }
+    }
+
+    #endregion
+
+    #region Converters
+    public class DockPanelSkinConverter : ExpandableObjectConverter
+    {
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            if (destinationType == typeof(DockPanelSkin))
+                return true;
+
+            return base.CanConvertTo(context, destinationType);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
+        {
+            if (destinationType == typeof(String) && value is DockPanelSkin)
+            {
+                return "DockPanelSkin";
+            }
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+    }
+
+    public class DockPanelGradientConverter : ExpandableObjectConverter
+    {
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            if (destinationType == typeof(DockPanelGradient))
+                return true;
+
+            return base.CanConvertTo(context, destinationType);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
+        {
+            if (destinationType == typeof(String) && value is DockPanelGradient)
+            {
+                return "DockPanelGradient";
+            }
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+    }
+
+    public class AutoHideStripConverter : ExpandableObjectConverter
+    {
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            if (destinationType == typeof(AutoHideStripSkin))
+                return true;
+
+            return base.CanConvertTo(context, destinationType);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
+        {
+            if (destinationType == typeof(String) && value is AutoHideStripSkin)
+            {
+                return "AutoHideStripSkin";
+            }
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+    }
+
+    public class DockPaneStripConverter : ExpandableObjectConverter
+    {
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            if (destinationType == typeof(DockPaneStripSkin))
+                return true;
+
+            return base.CanConvertTo(context, destinationType);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
+        {
+            if (destinationType == typeof(String) && value is DockPaneStripSkin)
+            {
+                return "DockPaneStripSkin";
+            }
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+    }
+
+    public class DockPaneStripGradientConverter : ExpandableObjectConverter
+    {
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            if (destinationType == typeof(DockPaneStripGradient))
+                return true;
+
+            return base.CanConvertTo(context, destinationType);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
+        {
+            if (destinationType == typeof(String) && value is DockPaneStripGradient)
+            {
+                return "DockPaneStripGradient";
+            }
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+    }
+
+    public class DockPaneTabGradientConverter : ExpandableObjectConverter
+    {
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            if (destinationType == typeof(TabGradient))
+                return true;
+
+            return base.CanConvertTo(context, destinationType);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
+        {
+            TabGradient val = value as TabGradient;
+            if (destinationType == typeof(String) && val != null)
+            {
+                return "DockPaneTabGradient";
+            }
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+    }
+    #endregion
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockWindow.SplitterControl.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockWindow.SplitterControl.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockWindow.SplitterControl.cs	(revision 8616)
@@ -0,0 +1,28 @@
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    public partial class DockWindow
+    {
+        private class SplitterControl : SplitterBase
+        {
+            protected override int SplitterSize
+            {
+                get { return Measures.SplitterSize; }
+            }
+
+            protected override void StartDrag()
+            {
+                DockWindow window = Parent as DockWindow;
+                if (window == null)
+                    return;
+
+                window.DockPanel.BeginDrag(window, window.RectangleToScreen(Bounds));
+            }
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockWindow.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockWindow.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockWindow.cs	(revision 8616)
@@ -0,0 +1,243 @@
+using System;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.ComponentModel;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	[ToolboxItem(false)]
+	public partial class DockWindow : Panel, INestedPanesContainer, ISplitterDragSource
+	{
+		private DockPanel m_dockPanel;
+		private DockState m_dockState;
+		private SplitterControl m_splitter;
+		private NestedPaneCollection m_nestedPanes;
+
+		internal DockWindow(DockPanel dockPanel, DockState dockState)
+		{
+			m_nestedPanes = new NestedPaneCollection(this);
+			m_dockPanel = dockPanel;
+			m_dockState = dockState;
+			Visible = false;
+
+			SuspendLayout();
+
+			if (DockState == DockState.DockLeft || DockState == DockState.DockRight ||
+				DockState == DockState.DockTop || DockState == DockState.DockBottom)
+			{
+				m_splitter = new SplitterControl();
+				Controls.Add(m_splitter);
+			}
+
+			if (DockState == DockState.DockLeft)
+			{
+				Dock = DockStyle.Left;
+				m_splitter.Dock = DockStyle.Right;
+			}
+			else if (DockState == DockState.DockRight)
+			{
+				Dock = DockStyle.Right;
+				m_splitter.Dock = DockStyle.Left;
+			}
+			else if (DockState == DockState.DockTop)
+			{
+				Dock = DockStyle.Top;
+				m_splitter.Dock = DockStyle.Bottom;
+			}
+			else if (DockState == DockState.DockBottom)
+			{
+				Dock = DockStyle.Bottom;
+				m_splitter.Dock = DockStyle.Top;
+			}
+			else if (DockState == DockState.Document)
+			{
+				Dock = DockStyle.Fill;
+			}
+
+			ResumeLayout();
+		}
+
+		public VisibleNestedPaneCollection VisibleNestedPanes
+		{
+			get	{	return NestedPanes.VisibleNestedPanes;	}
+		}
+
+		public NestedPaneCollection NestedPanes
+		{
+			get	{	return m_nestedPanes;	}
+		}
+
+		public DockPanel DockPanel
+		{
+			get	{	return m_dockPanel;	}
+		}
+
+		public DockState DockState
+		{
+			get	{	return m_dockState;	}
+		}
+
+		public bool IsFloat
+		{
+			get	{	return DockState == DockState.Float;	}
+		}
+
+		internal DockPane DefaultPane
+		{
+			get	{	return VisibleNestedPanes.Count == 0 ? null : VisibleNestedPanes[0];	}
+		}
+
+		public virtual Rectangle DisplayingRectangle
+		{
+			get
+			{
+				Rectangle rect = ClientRectangle;
+				// if DockWindow is document, exclude the border
+				if (DockState == DockState.Document)
+				{
+					rect.X += 1;
+					rect.Y += 1;
+					rect.Width -= 2;
+					rect.Height -= 2;
+				}
+				// exclude the splitter
+				else if (DockState == DockState.DockLeft)
+					rect.Width -= Measures.SplitterSize;
+				else if (DockState == DockState.DockRight)
+				{
+					rect.X += Measures.SplitterSize;
+					rect.Width -= Measures.SplitterSize;
+				}
+				else if (DockState == DockState.DockTop)
+					rect.Height -= Measures.SplitterSize;
+				else if (DockState == DockState.DockBottom)
+				{
+					rect.Y += Measures.SplitterSize;
+					rect.Height -= Measures.SplitterSize;
+				}
+
+				return rect;
+			}
+		}
+
+		protected override void OnPaint(PaintEventArgs e)
+		{
+			// if DockWindow is document, draw the border
+            if (DockState == DockState.Document)
+                e.Graphics.DrawRectangle(SystemPens.ControlDark, ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width - 1, ClientRectangle.Height - 1);
+
+			base.OnPaint(e);
+		}
+
+		protected override void OnLayout(LayoutEventArgs levent)
+		{
+			VisibleNestedPanes.Refresh();
+			if (VisibleNestedPanes.Count == 0)
+			{
+                if (Visible)
+                    Visible = false;
+			}
+			else if (!Visible)
+			{
+				Visible = true;
+				VisibleNestedPanes.Refresh();
+			}
+
+			base.OnLayout (levent);
+		}
+
+        #region ISplitterDragSource Members
+
+        void ISplitterDragSource.BeginDrag(Rectangle rectSplitter)
+        {
+        }
+
+        void ISplitterDragSource.EndDrag()
+        {
+        }
+
+        bool ISplitterDragSource.IsVertical
+        {
+            get { return (DockState == DockState.DockLeft || DockState == DockState.DockRight); }
+        }
+
+        Rectangle ISplitterDragSource.DragLimitBounds
+        {
+            get
+            {
+                Rectangle rectLimit = DockPanel.DockArea;
+                Point location;
+                if ((Control.ModifierKeys & Keys.Shift) == 0)
+                    location = Location;
+                else
+                    location = DockPanel.DockArea.Location;
+
+                if (((ISplitterDragSource)this).IsVertical)
+                {
+                    rectLimit.X += MeasurePane.MinSize;
+                    rectLimit.Width -= 2 * MeasurePane.MinSize;
+                    rectLimit.Y = location.Y;
+                    if ((Control.ModifierKeys & Keys.Shift) == 0)
+                        rectLimit.Height = Height;
+                }
+                else
+                {
+                    rectLimit.Y += MeasurePane.MinSize;
+                    rectLimit.Height -= 2 * MeasurePane.MinSize;
+                    rectLimit.X = location.X;
+                    if ((Control.ModifierKeys & Keys.Shift) == 0)
+                        rectLimit.Width = Width;
+                }
+
+                return DockPanel.RectangleToScreen(rectLimit);
+            }
+        }
+
+        void ISplitterDragSource.MoveSplitter(int offset)
+        {
+            if ((Control.ModifierKeys & Keys.Shift) != 0)
+                SendToBack();
+
+            Rectangle rectDockArea = DockPanel.DockArea;
+            if (DockState == DockState.DockLeft && rectDockArea.Width > 0)
+            {
+                if (DockPanel.DockLeftPortion > 1)
+                    DockPanel.DockLeftPortion = Width + offset;
+                else
+                    DockPanel.DockLeftPortion += ((double)offset) / (double)rectDockArea.Width;
+            }
+            else if (DockState == DockState.DockRight && rectDockArea.Width > 0)
+            {
+                if (DockPanel.DockRightPortion > 1)
+                    DockPanel.DockRightPortion = Width - offset;
+                else
+                    DockPanel.DockRightPortion -= ((double)offset) / (double)rectDockArea.Width;
+            }
+            else if (DockState == DockState.DockBottom && rectDockArea.Height > 0)
+            {
+                if (DockPanel.DockBottomPortion > 1)
+                    DockPanel.DockBottomPortion = Height - offset;
+                else
+                    DockPanel.DockBottomPortion -= ((double)offset) / (double)rectDockArea.Height;
+            }
+            else if (DockState == DockState.DockTop && rectDockArea.Height > 0)
+            {
+                if (DockPanel.DockTopPortion > 1)
+                    DockPanel.DockTopPortion = Height + offset;
+                else
+                    DockPanel.DockTopPortion += ((double)offset) / (double)rectDockArea.Height;
+            }
+        }
+
+        #region IDragSource Members
+
+        Control IDragSource.DragControl
+        {
+            get { return this; }
+        }
+
+        #endregion
+        #endregion
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockWindowCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockWindowCollection.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockWindowCollection.cs	(revision 8616)
@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public class DockWindowCollection : ReadOnlyCollection<DockWindow>
+	{
+		internal DockWindowCollection(DockPanel dockPanel)
+            : base(new List<DockWindow>())
+		{
+			Items.Add(new DockWindow(dockPanel, DockState.Document));
+			Items.Add(new DockWindow(dockPanel, DockState.DockLeft));
+			Items.Add(new DockWindow(dockPanel, DockState.DockRight));
+			Items.Add(new DockWindow(dockPanel, DockState.DockTop));
+			Items.Add(new DockWindow(dockPanel, DockState.DockBottom));
+		}
+
+		public DockWindow this [DockState dockState]
+		{
+			get
+			{
+				if (dockState == DockState.Document)
+					return Items[0];
+				else if (dockState == DockState.DockLeft || dockState == DockState.DockLeftAutoHide)
+					return Items[1];
+				else if (dockState == DockState.DockRight || dockState == DockState.DockRightAutoHide)
+					return Items[2];
+				else if (dockState == DockState.DockTop || dockState == DockState.DockTopAutoHide)
+					return Items[3];
+				else if (dockState == DockState.DockBottom || dockState == DockState.DockBottomAutoHide)
+					return Items[4];
+
+				throw (new ArgumentOutOfRangeException());
+			}
+		}
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DragForm.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DragForm.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DragForm.cs	(revision 8616)
@@ -0,0 +1,68 @@
+using System;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    // Inspired by Chris Sano's article:
+    // http://msdn.microsoft.com/smartclient/default.aspx?pull=/library/en-us/dnwinforms/html/colorpicker.asp
+    // In Sano's article, the DragForm needs to meet the following criteria:
+    // (1) it was not to show up in the task bar;
+    //     ShowInTaskBar = false
+    // (2) it needed to be the top-most window;
+    //     TopMost = true (not necessary here)
+    // (3) its icon could not show up in the ALT+TAB window if the user pressed ALT+TAB during a drag-and-drop;
+    //     FormBorderStyle = FormBorderStyle.None;
+    //     Create with WS_EX_TOOLWINDOW window style.
+    //     Compares with the solution in the artile by setting FormBorderStyle as FixedToolWindow,
+    //     and then clip the window caption and border, this way is much simplier.
+    // (4) it was not to steal focus from the application when displayed.
+    //     User Win32 ShowWindow API with SW_SHOWNOACTIVATE
+    // In addition, this form should only for display and therefore should act as transparent, otherwise
+    // WindowFromPoint will return this form, instead of the control beneath. Need BOTH of the following to
+    // achieve this (don't know why, spent hours to try it out :( ):
+    //  1. Enabled = false;
+    //  2. WM_NCHITTEST returns HTTRANSPARENT
+    internal class DragForm : Form
+    {
+        public DragForm()
+        {
+            FormBorderStyle = FormBorderStyle.None;
+            ShowInTaskbar = false;
+            SetStyle(ControlStyles.Selectable, false);
+            Enabled = false;
+        }
+
+        protected override CreateParams CreateParams
+        {
+            get
+            {
+                CreateParams createParams = base.CreateParams;
+                createParams.ExStyle |= (int)(Win32.WindowExStyles.WS_EX_NOACTIVATE | Win32.WindowExStyles.WS_EX_TOOLWINDOW);
+                return createParams;
+            }
+        }
+
+        protected override void WndProc(ref Message m)
+        {
+            if (m.Msg == (int)Win32.Msgs.WM_NCHITTEST)
+            {
+                m.Result = (IntPtr)Win32.HitTest.HTTRANSPARENT;
+                return;
+            }
+
+            base.WndProc(ref m);
+        }
+        //The form can be still activated by explicity calling Activate
+        protected override bool ShowWithoutActivation
+        {
+            get { return true; }
+        }
+        public virtual void Show(bool bActivate)
+        {
+                Show();
+
+                if (bActivate)
+                    Activate();
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DummyControl.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DummyControl.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DummyControl.cs	(revision 8616)
@@ -0,0 +1,13 @@
+using System;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	internal class DummyControl : Control
+	{
+		public DummyControl()
+		{
+			SetStyle(ControlStyles.Selectable, false);
+		}
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Enums.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Enums.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Enums.cs	(revision 8616)
@@ -0,0 +1,60 @@
+using System;
+using System.ComponentModel;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	[Flags]
+	[Serializable]
+	[Editor(typeof(DockAreasEditor), typeof(System.Drawing.Design.UITypeEditor))]
+	public enum DockAreas
+	{
+		Float = 1,
+		DockLeft = 2,
+		DockRight = 4,
+		DockTop = 8,
+		DockBottom = 16,
+		Document = 32
+	}
+
+	public enum DockState
+	{
+		Unknown = 0,
+		Float = 1,
+		DockTopAutoHide = 2,
+		DockLeftAutoHide = 3,
+		DockBottomAutoHide = 4,
+		DockRightAutoHide = 5,
+		Document = 6,
+		DockTop = 7,
+		DockLeft = 8,
+		DockBottom = 9,
+		DockRight = 10,
+		Hidden = 11
+	}
+
+	public enum DockAlignment
+	{
+		Left,
+		Right,
+		Top,
+		Bottom
+	}
+
+	public enum DocumentStyle
+	{
+		DockingMdi,
+		DockingWindow,
+		DockingSdi,
+		SystemMdi,
+	}
+
+    /// <summary>
+    /// The location to draw the DockPaneStrip for Document style windows.
+    /// </summary>
+    public enum DocumentTabStripLocation
+    {
+        Top,
+        Bottom
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/FloatWindow.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/FloatWindow.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/FloatWindow.cs	(revision 8616)
@@ -0,0 +1,472 @@
+using System;
+using System.Collections;
+using System.Drawing;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+using System.Security.Permissions;
+using System.Diagnostics.CodeAnalysis;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    public class FloatWindow : Form, INestedPanesContainer, IDockDragSource
+	{
+		private NestedPaneCollection m_nestedPanes;
+		internal const int WM_CHECKDISPOSE = (int)(Win32.Msgs.WM_USER + 1);
+
+		internal protected FloatWindow(DockPanel dockPanel, DockPane pane)
+		{
+			InternalConstruct(dockPanel, pane, false, Rectangle.Empty);
+		}
+
+		internal protected FloatWindow(DockPanel dockPanel, DockPane pane, Rectangle bounds)
+		{
+			InternalConstruct(dockPanel, pane, true, bounds);
+		}
+
+		private void InternalConstruct(DockPanel dockPanel, DockPane pane, bool boundsSpecified, Rectangle bounds)
+		{
+			if (dockPanel == null)
+				throw(new ArgumentNullException(Strings.FloatWindow_Constructor_NullDockPanel));
+
+			m_nestedPanes = new NestedPaneCollection(this);
+
+			FormBorderStyle = FormBorderStyle.SizableToolWindow;
+			ShowInTaskbar = false;
+            if (dockPanel.RightToLeft != RightToLeft)
+                RightToLeft = dockPanel.RightToLeft;
+            if (RightToLeftLayout != dockPanel.RightToLeftLayout)
+                RightToLeftLayout = dockPanel.RightToLeftLayout;
+			
+			SuspendLayout();
+            if (boundsSpecified)
+            {
+                Bounds = bounds;
+                StartPosition = FormStartPosition.Manual;
+            }
+            else
+            {
+                StartPosition = FormStartPosition.WindowsDefaultLocation;
+                Size = dockPanel.DefaultFloatWindowSize;
+            }
+
+			m_dockPanel = dockPanel;
+			Owner = DockPanel.FindForm();
+			DockPanel.AddFloatWindow(this);
+			if (pane != null)
+				pane.FloatWindow = this;
+
+			ResumeLayout();
+		}
+
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing)
+			{
+				if (DockPanel != null)
+					DockPanel.RemoveFloatWindow(this);
+				m_dockPanel = null;
+			}
+			base.Dispose(disposing);
+		}
+
+		private bool m_allowEndUserDocking = true;
+		public bool AllowEndUserDocking
+		{
+			get	{	return m_allowEndUserDocking;	}
+			set	{	m_allowEndUserDocking = value;	}
+		}
+
+		public NestedPaneCollection NestedPanes
+		{
+			get	{	return m_nestedPanes;	}
+		}
+
+		public VisibleNestedPaneCollection VisibleNestedPanes
+		{
+			get	{	return NestedPanes.VisibleNestedPanes;	}
+		}
+
+		private DockPanel m_dockPanel;
+		public DockPanel DockPanel
+		{
+			get	{	return m_dockPanel;	}
+		}
+
+		public DockState DockState
+		{
+			get	{	return DockState.Float;	}
+		}
+	
+		public bool IsFloat
+		{
+			get	{	return DockState == DockState.Float;	}
+		}
+
+		internal bool IsDockStateValid(DockState dockState)
+		{
+			foreach (DockPane pane in NestedPanes)
+				foreach (IDockContent content in pane.Contents)
+					if (!DockHelper.IsDockStateValid(dockState, content.DockHandler.DockAreas))
+						return false;
+
+			return true;
+		}
+
+		protected override void OnActivated(EventArgs e)
+		{
+			DockPanel.FloatWindows.BringWindowToFront(this);
+			base.OnActivated (e);
+			// Propagate the Activated event to the visible panes content objects
+			foreach (DockPane pane in VisibleNestedPanes)
+				foreach (IDockContent content in pane.Contents)
+					content.OnActivated(e);
+		}
+
+		protected override void OnDeactivate(EventArgs e)
+		{
+			base.OnDeactivate(e);
+			// Propagate the Deactivate event to the visible panes content objects
+			foreach (DockPane pane in VisibleNestedPanes)
+				foreach (IDockContent content in pane.Contents)
+					content.OnDeactivate(e);
+		}
+
+		protected override void OnLayout(LayoutEventArgs levent)
+		{
+			VisibleNestedPanes.Refresh();
+			RefreshChanges();
+            Visible = (VisibleNestedPanes.Count > 0);
+            SetText();
+
+			base.OnLayout(levent);
+		}
+
+
+        [SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.Windows.Forms.Control.set_Text(System.String)")]
+        internal void SetText()
+		{
+			DockPane theOnlyPane = (VisibleNestedPanes.Count == 1) ? VisibleNestedPanes[0] : null;
+
+			if (theOnlyPane == null || theOnlyPane.ActiveContent == null)
+            {
+				Text = " ";	// use " " instead of string.Empty because the whole title bar will disappear when ControlBox is set to false.
+                Icon = null;
+            }
+			else
+			{
+			    Text = theOnlyPane.ActiveContent.DockHandler.TabText;
+                Icon = theOnlyPane.ActiveContent.DockHandler.Icon;
+			}
+		}
+
+		protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified)
+		{
+			Rectangle rectWorkArea = SystemInformation.VirtualScreen;
+
+			if (y + height > rectWorkArea.Bottom)
+				y -= (y + height) - rectWorkArea.Bottom;
+
+			if (y < rectWorkArea.Top)
+				y += rectWorkArea.Top - y;
+
+			base.SetBoundsCore (x, y, width, height, specified);
+		}
+
+        [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
+		protected override void WndProc(ref Message m)
+		{
+			if (m.Msg == (int)Win32.Msgs.WM_NCLBUTTONDOWN)
+			{
+				if (IsDisposed)
+					return;
+
+				uint result = Win32Helper.IsRunningOnMono ? 0 : NativeMethods.SendMessage(this.Handle, (int)Win32.Msgs.WM_NCHITTEST, 0, (uint)m.LParam);
+				if (result == 2 && DockPanel.AllowEndUserDocking && this.AllowEndUserDocking)	// HITTEST_CAPTION
+				{
+					Activate();
+					m_dockPanel.BeginDrag(this);
+				}
+				else
+					base.WndProc(ref m);
+
+				return;
+			}
+            else if (m.Msg == (int)Win32.Msgs.WM_NCRBUTTONDOWN)
+            {
+                uint result = Win32Helper.IsRunningOnMono ? 0 : NativeMethods.SendMessage(this.Handle, (int)Win32.Msgs.WM_NCHITTEST, 0, (uint)m.LParam);
+                if (result == 2)	// HITTEST_CAPTION
+                {
+                    DockPane theOnlyPane = (VisibleNestedPanes.Count == 1) ? VisibleNestedPanes[0] : null;
+                    if (theOnlyPane != null && theOnlyPane.ActiveContent != null)
+                    {
+                        theOnlyPane.ShowTabPageContextMenu(this, PointToClient(Control.MousePosition));
+                        return;
+                    }
+                }
+
+                base.WndProc(ref m);
+                return;
+            }
+            else if (m.Msg == (int)Win32.Msgs.WM_CLOSE)
+            {
+                if (NestedPanes.Count == 0)
+                {
+                    base.WndProc(ref m);
+                    return;
+                }
+
+                for (int i = NestedPanes.Count - 1; i >= 0; i--)
+                {
+                    DockContentCollection contents = NestedPanes[i].Contents;
+                    for (int j = contents.Count - 1; j >= 0; j--)
+                    {
+                        IDockContent content = contents[j];
+                        if (content.DockHandler.DockState != DockState.Float)
+                            continue;
+
+                        if (!content.DockHandler.CloseButton)
+                            continue;
+
+                        if (content.DockHandler.HideOnClose)
+                            content.DockHandler.Hide();
+                        else
+                            content.DockHandler.Close();
+                    }
+                }
+
+                return;
+            }
+            else if (m.Msg == (int)Win32.Msgs.WM_NCLBUTTONDBLCLK)
+            {
+                uint result = Win32Helper.IsRunningOnMono ? 0: NativeMethods.SendMessage(this.Handle, (int)Win32.Msgs.WM_NCHITTEST, 0, (uint)m.LParam);
+                if (result != 2)	// HITTEST_CAPTION
+                {
+                    base.WndProc(ref m);
+                    return;
+                }
+
+                DockPanel.SuspendLayout(true);
+
+                // Restore to panel
+                foreach (DockPane pane in NestedPanes)
+                {
+                    if (pane.DockState != DockState.Float)
+                        continue;
+                    pane.RestoreToPanel();
+                }
+
+
+                DockPanel.ResumeLayout(true, true);
+                return;
+            }
+            else if (m.Msg == WM_CHECKDISPOSE)
+            {
+                if (NestedPanes.Count == 0)
+                    Dispose();
+
+                return;
+            }
+            
+			base.WndProc(ref m);
+		}
+
+		internal void RefreshChanges()
+		{
+            if (IsDisposed)
+                return;
+
+			if (VisibleNestedPanes.Count == 0)
+			{
+				ControlBox = true;
+				return;
+			}
+
+			for (int i=VisibleNestedPanes.Count - 1; i>=0; i--)
+			{
+				DockContentCollection contents = VisibleNestedPanes[i].Contents;
+				for (int j=contents.Count - 1; j>=0; j--)
+				{
+					IDockContent content = contents[j];
+					if (content.DockHandler.DockState != DockState.Float)
+						continue;
+
+					if (content.DockHandler.CloseButton && content.DockHandler.CloseButtonVisible)
+					{
+						ControlBox = true;
+						return;
+					}
+				}
+			}
+			//Only if there is a ControlBox do we turn it off
+			//old code caused a flash of the window.
+            if (ControlBox)
+				ControlBox = false;
+		}
+
+		public virtual Rectangle DisplayingRectangle
+		{
+			get	{	return ClientRectangle;	}
+		}
+
+		internal void TestDrop(IDockDragSource dragSource, DockOutlineBase dockOutline)
+		{
+            if (VisibleNestedPanes.Count == 1)
+            {
+                DockPane pane = VisibleNestedPanes[0];
+                if (!dragSource.CanDockTo(pane))
+                    return;
+
+                Point ptMouse = Control.MousePosition;
+                uint lParam = Win32Helper.MakeLong(ptMouse.X, ptMouse.Y);
+                if (!Win32Helper.IsRunningOnMono)
+                    if (NativeMethods.SendMessage(Handle, (int)Win32.Msgs.WM_NCHITTEST, 0, lParam) == (uint)Win32.HitTest.HTCAPTION)
+                        dockOutline.Show(VisibleNestedPanes[0], -1);
+            }
+		}
+
+        #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.FloatWindow == this)
+                return false;
+
+            return true;
+        }
+
+        private int m_preDragExStyle;
+
+        Rectangle IDockDragSource.BeginDrag(Point ptMouse)
+        {
+            m_preDragExStyle = NativeMethods.GetWindowLong(this.Handle, (int)Win32.GetWindowLongIndex.GWL_EXSTYLE);
+            NativeMethods.SetWindowLong(this.Handle, 
+                                        (int)Win32.GetWindowLongIndex.GWL_EXSTYLE,
+                                        m_preDragExStyle | (int)(Win32.WindowExStyles.WS_EX_TRANSPARENT | Win32.WindowExStyles.WS_EX_LAYERED) );
+            return Bounds;
+        }
+
+        void IDockDragSource.EndDrag()
+        {
+            NativeMethods.SetWindowLong(this.Handle, (int)Win32.GetWindowLongIndex.GWL_EXSTYLE, m_preDragExStyle);
+            
+            Invalidate(true);
+            NativeMethods.SendMessage(this.Handle, (int)Win32.Msgs.WM_NCPAINT, 1, 0);
+        }
+
+        public  void FloatAt(Rectangle floatWindowBounds)
+        {
+            Bounds = floatWindowBounds;
+        }
+
+        public void DockTo(DockPane pane, DockStyle dockStyle, int contentIndex)
+        {
+            if (dockStyle == DockStyle.Fill)
+            {
+                for (int i = NestedPanes.Count - 1; i >= 0; i--)
+                {
+                    DockPane paneFrom = NestedPanes[i];
+                    for (int j = paneFrom.Contents.Count - 1; j >= 0; j--)
+                    {
+                        IDockContent c = paneFrom.Contents[j];
+                        c.DockHandler.Pane = pane;
+                        if (contentIndex != -1)
+                            pane.SetContentIndex(c, contentIndex);
+                        c.DockHandler.Activate();
+                    }
+                }
+            }
+            else
+            {
+                DockAlignment alignment = DockAlignment.Left;
+                if (dockStyle == DockStyle.Left)
+                    alignment = DockAlignment.Left;
+                else if (dockStyle == DockStyle.Right)
+                    alignment = DockAlignment.Right;
+                else if (dockStyle == DockStyle.Top)
+                    alignment = DockAlignment.Top;
+                else if (dockStyle == DockStyle.Bottom)
+                    alignment = DockAlignment.Bottom;
+
+                MergeNestedPanes(VisibleNestedPanes, pane.NestedPanesContainer.NestedPanes, pane, alignment, 0.5);
+            }
+        }
+
+        public void DockTo(DockPanel panel, DockStyle dockStyle)
+        {
+            if (panel != DockPanel)
+                throw new ArgumentException(Strings.IDockDragSource_DockTo_InvalidPanel, "panel");
+
+            NestedPaneCollection nestedPanesTo = null;
+
+            if (dockStyle == DockStyle.Top)
+                nestedPanesTo = DockPanel.DockWindows[DockState.DockTop].NestedPanes;
+            else if (dockStyle == DockStyle.Bottom)
+                nestedPanesTo = DockPanel.DockWindows[DockState.DockBottom].NestedPanes;
+            else if (dockStyle == DockStyle.Left)
+                nestedPanesTo = DockPanel.DockWindows[DockState.DockLeft].NestedPanes;
+            else if (dockStyle == DockStyle.Right)
+                nestedPanesTo = DockPanel.DockWindows[DockState.DockRight].NestedPanes;
+            else if (dockStyle == DockStyle.Fill)
+                nestedPanesTo = DockPanel.DockWindows[DockState.Document].NestedPanes;
+
+            DockPane prevPane = null;
+            for (int i = nestedPanesTo.Count - 1; i >= 0; i--)
+                if (nestedPanesTo[i] != VisibleNestedPanes[0])
+                    prevPane = nestedPanesTo[i];
+            MergeNestedPanes(VisibleNestedPanes, nestedPanesTo, prevPane, DockAlignment.Left, 0.5);
+        }
+
+        private static void MergeNestedPanes(VisibleNestedPaneCollection nestedPanesFrom, NestedPaneCollection nestedPanesTo, DockPane prevPane, DockAlignment alignment, double proportion)
+        {
+            if (nestedPanesFrom.Count == 0)
+                return;
+
+            int count = nestedPanesFrom.Count;
+            DockPane[] panes = new DockPane[count];
+            DockPane[] prevPanes = new DockPane[count];
+            DockAlignment[] alignments = new DockAlignment[count];
+            double[] proportions = new double[count];
+
+            for (int i = 0; i < count; i++)
+            {
+                panes[i] = nestedPanesFrom[i];
+                prevPanes[i] = nestedPanesFrom[i].NestedDockingStatus.PreviousPane;
+                alignments[i] = nestedPanesFrom[i].NestedDockingStatus.Alignment;
+                proportions[i] = nestedPanesFrom[i].NestedDockingStatus.Proportion;
+            }
+
+            DockPane pane = panes[0].DockTo(nestedPanesTo.Container, prevPane, alignment, proportion);
+            panes[0].DockState = nestedPanesTo.DockState;
+
+            for (int i = 1; i < count; i++)
+            {
+                for (int j = i; j < count; j++)
+                {
+                    if (prevPanes[j] == panes[i - 1])
+                        prevPanes[j] = pane;
+                }
+                pane = panes[i].DockTo(nestedPanesTo.Container, prevPanes[i], alignments[i], proportions[i]);
+                panes[i].DockState = nestedPanesTo.DockState;
+            }
+        }
+
+        #endregion
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/FloatWindowCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/FloatWindowCollection.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/FloatWindowCollection.cs	(revision 8616)
@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public class FloatWindowCollection : ReadOnlyCollection<FloatWindow>
+	{
+		internal FloatWindowCollection()
+            : base(new List<FloatWindow>())
+		{
+		}
+
+		internal int Add(FloatWindow fw)
+		{
+			if (Items.Contains(fw))
+				return Items.IndexOf(fw);
+
+			Items.Add(fw);
+            return Count - 1;
+		}
+
+		internal void Dispose()
+		{
+			for (int i=Count - 1; i>=0; i--)
+				this[i].Close();
+		}
+
+		internal void Remove(FloatWindow fw)
+		{
+			Items.Remove(fw);
+		}
+
+		internal void BringWindowToFront(FloatWindow fw)
+		{
+			Items.Remove(fw);
+			Items.Add(fw);
+		}
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Helpers/DockHelper.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Helpers/DockHelper.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Helpers/DockHelper.cs	(revision 8616)
@@ -0,0 +1,105 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	internal static class DockHelper
+	{
+		public static bool IsDockStateAutoHide(DockState dockState)
+		{
+			if (dockState == DockState.DockLeftAutoHide ||
+				dockState == DockState.DockRightAutoHide ||
+				dockState == DockState.DockTopAutoHide ||
+				dockState == DockState.DockBottomAutoHide)
+				return true;
+			else
+				return false;
+		}
+
+		public static bool IsDockStateValid(DockState dockState, DockAreas dockableAreas)
+		{
+			if (((dockableAreas & DockAreas.Float) == 0) &&
+				(dockState == DockState.Float))
+				return false;
+			else if (((dockableAreas & DockAreas.Document) == 0) &&
+				(dockState == DockState.Document))
+				return false;
+			else if (((dockableAreas & DockAreas.DockLeft) == 0) &&
+				(dockState == DockState.DockLeft || dockState == DockState.DockLeftAutoHide))
+				return false;
+			else if (((dockableAreas & DockAreas.DockRight) == 0) &&
+				(dockState == DockState.DockRight || dockState == DockState.DockRightAutoHide))
+				return false;
+			else if (((dockableAreas & DockAreas.DockTop) == 0) &&
+				(dockState == DockState.DockTop || dockState == DockState.DockTopAutoHide))
+				return false;
+			else if (((dockableAreas & DockAreas.DockBottom) == 0) &&
+				(dockState == DockState.DockBottom || dockState == DockState.DockBottomAutoHide))
+				return false;
+			else
+				return true;
+		}
+
+		public static bool IsDockWindowState(DockState state)
+		{
+			if (state == DockState.DockTop || state == DockState.DockBottom || state == DockState.DockLeft ||
+				state == DockState.DockRight || state == DockState.Document)
+				return true;
+			else
+				return false;
+		}
+
+		public static DockState ToggleAutoHideState(DockState state)
+		{
+			if (state == DockState.DockLeft)
+				return DockState.DockLeftAutoHide;
+			else if (state == DockState.DockRight)
+				return DockState.DockRightAutoHide;
+			else if (state == DockState.DockTop)
+				return DockState.DockTopAutoHide;
+			else if (state == DockState.DockBottom)
+				return DockState.DockBottomAutoHide;
+			else if (state == DockState.DockLeftAutoHide)
+				return DockState.DockLeft;
+			else if (state == DockState.DockRightAutoHide)
+				return DockState.DockRight;
+			else if (state == DockState.DockTopAutoHide)
+				return DockState.DockTop;
+			else if (state == DockState.DockBottomAutoHide)
+				return DockState.DockBottom;
+			else
+				return state;
+		}
+
+		public static DockPane PaneAtPoint(Point pt, DockPanel dockPanel)
+		{
+            if (!Win32Helper.IsRunningOnMono)
+			    for (Control control = Win32Helper.ControlAtPoint(pt); control != null; control = control.Parent)
+			    {
+				    IDockContent content = control as IDockContent;
+				    if (content != null && content.DockHandler.DockPanel == dockPanel)
+					    return content.DockHandler.Pane;
+
+				    DockPane pane = control as DockPane;
+				    if (pane != null && pane.DockPanel == dockPanel)
+					    return pane;
+			    }
+
+			return null;
+		}
+
+		public static FloatWindow FloatWindowAtPoint(Point pt, DockPanel dockPanel)
+		{
+            if (!Win32Helper.IsRunningOnMono)
+			    for (Control control = Win32Helper.ControlAtPoint(pt); control != null; control = control.Parent)
+			    {
+				    FloatWindow floatWindow = control as FloatWindow;
+				    if (floatWindow != null && floatWindow.DockPanel == dockPanel)
+					    return floatWindow;
+			    }
+
+			return null;
+		}
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Helpers/DrawHelper.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Helpers/DrawHelper.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Helpers/DrawHelper.cs	(revision 8616)
@@ -0,0 +1,88 @@
+using System;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Drawing.Imaging;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	internal static class DrawHelper
+	{
+        public static Point RtlTransform(Control control, Point point)
+        {
+            if (control.RightToLeft != RightToLeft.Yes)
+                return point;
+            else
+                return new Point(control.Right - point.X, point.Y);
+        }
+
+        public static Rectangle RtlTransform(Control control, Rectangle rectangle)
+        {
+            if (control.RightToLeft != RightToLeft.Yes)
+                return rectangle;
+            else
+                return new Rectangle(control.ClientRectangle.Right - rectangle.Right, rectangle.Y, rectangle.Width, rectangle.Height);
+        }
+
+        public static GraphicsPath GetRoundedCornerTab(GraphicsPath graphicsPath, Rectangle rect, bool upCorner)
+        {
+            if (graphicsPath == null)
+                graphicsPath = new GraphicsPath();
+            else
+                graphicsPath.Reset();
+            
+            int curveSize = 6;
+            if (upCorner)
+            {
+                graphicsPath.AddLine(rect.Left, rect.Bottom, rect.Left, rect.Top + curveSize / 2);
+                graphicsPath.AddArc(new Rectangle(rect.Left, rect.Top, curveSize, curveSize), 180, 90);
+                graphicsPath.AddLine(rect.Left + curveSize / 2, rect.Top, rect.Right - curveSize / 2, rect.Top);
+                graphicsPath.AddArc(new Rectangle(rect.Right - curveSize, rect.Top, curveSize, curveSize), -90, 90);
+                graphicsPath.AddLine(rect.Right, rect.Top + curveSize / 2, rect.Right, rect.Bottom);
+            }
+            else
+            {
+                graphicsPath.AddLine(rect.Right, rect.Top, rect.Right, rect.Bottom - curveSize / 2);
+                graphicsPath.AddArc(new Rectangle(rect.Right - curveSize, rect.Bottom - curveSize, curveSize, curveSize), 0, 90);
+                graphicsPath.AddLine(rect.Right - curveSize / 2, rect.Bottom, rect.Left + curveSize / 2, rect.Bottom);
+                graphicsPath.AddArc(new Rectangle(rect.Left, rect.Bottom - curveSize, curveSize, curveSize), 90, 90);
+                graphicsPath.AddLine(rect.Left, rect.Bottom - curveSize / 2, rect.Left, rect.Top);
+            }
+
+            return graphicsPath;
+        }
+
+		public static GraphicsPath CalculateGraphicsPathFromBitmap(Bitmap bitmap)
+		{
+			return CalculateGraphicsPathFromBitmap(bitmap, Color.Empty);
+		}
+
+		// From http://edu.cnzz.cn/show_3281.html
+		public static GraphicsPath CalculateGraphicsPathFromBitmap(Bitmap bitmap, Color colorTransparent) 
+		{ 
+			GraphicsPath graphicsPath = new GraphicsPath(); 
+			if (colorTransparent == Color.Empty)
+				colorTransparent = bitmap.GetPixel(0, 0); 
+
+			for(int row = 0; row < bitmap.Height; row ++) 
+			{ 
+				int colOpaquePixel = 0;
+				for(int col = 0; col < bitmap.Width; col ++) 
+				{ 
+					if(bitmap.GetPixel(col, row) != colorTransparent) 
+					{ 
+						colOpaquePixel = col; 
+						int colNext = col; 
+						for(colNext = colOpaquePixel; colNext < bitmap.Width; colNext ++) 
+							if(bitmap.GetPixel(colNext, row) == colorTransparent) 
+								break;
+ 
+						graphicsPath.AddRectangle(new Rectangle(colOpaquePixel, row, colNext - colOpaquePixel, 1)); 
+						col = colNext; 
+					} 
+				} 
+			} 
+			return graphicsPath; 
+		} 
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Helpers/ResourceHelper.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Helpers/ResourceHelper.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Helpers/ResourceHelper.cs	(revision 8616)
@@ -0,0 +1,29 @@
+using System;
+using System.Drawing;
+using System.Reflection;
+using System.Resources;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	internal static class ResourceHelper
+	{
+        private static ResourceManager _resourceManager = null;
+
+        private static ResourceManager ResourceManager
+        {
+            get
+            {
+                if (_resourceManager == null)
+                    _resourceManager = new ResourceManager("WeifenLuo.WinFormsUI.Docking.Strings", typeof(ResourceHelper).Assembly);
+                return _resourceManager;
+            }
+
+        }
+
+		public static string GetString(string name)
+		{
+			return ResourceManager.GetString(name);
+		}
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Helpers/Win32Helper.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Helpers/Win32Helper.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Helpers/Win32Helper.cs	(revision 8616)
@@ -0,0 +1,23 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    public static class Win32Helper
+    {
+        private static readonly bool _isRunningOnMono = Type.GetType("Mono.Runtime") != null;
+
+        public static bool IsRunningOnMono { get { return _isRunningOnMono; } }
+
+        internal static Control ControlAtPoint(Point pt)
+        {
+            return Control.FromChildHandle(NativeMethods.WindowFromPoint(pt));
+        }
+
+        internal static uint MakeLong(int low, int high)
+        {
+            return (uint)((high << 16) + low);
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/InertButtonBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/InertButtonBase.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/InertButtonBase.cs	(revision 8616)
@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Drawing.Imaging;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    internal abstract class InertButtonBase : Control
+    {
+        protected InertButtonBase()
+        {
+            SetStyle(ControlStyles.SupportsTransparentBackColor, true);
+            BackColor = Color.Transparent;
+        }
+
+        public abstract Bitmap Image
+        {
+            get;
+        }
+
+        private bool m_isMouseOver = false;
+        protected bool IsMouseOver
+        {
+            get { return m_isMouseOver; }
+            private set
+            {
+                if (m_isMouseOver == value)
+                    return;
+
+                m_isMouseOver = value;
+                Invalidate();
+            }
+        }
+
+        protected override Size DefaultSize
+        {
+            get { return Resources.DockPane_Close.Size; }
+        }
+
+        protected override void OnMouseMove(MouseEventArgs e)
+        {
+            base.OnMouseMove(e);
+            bool over = ClientRectangle.Contains(e.X, e.Y);
+            if (IsMouseOver != over)
+                IsMouseOver = over;
+        }
+
+        protected override void OnMouseEnter(EventArgs e)
+        {
+            base.OnMouseEnter(e);
+            if (!IsMouseOver)
+                IsMouseOver = true;
+        }
+
+        protected override void OnMouseLeave(EventArgs e)
+        {
+            base.OnMouseLeave(e);
+            if (IsMouseOver)
+                IsMouseOver = false;
+        }
+
+        protected override void OnPaint(PaintEventArgs e)
+        {
+            if (IsMouseOver && Enabled)
+            {
+                using (Pen pen = new Pen(ForeColor))
+                {
+                    e.Graphics.DrawRectangle(pen, Rectangle.Inflate(ClientRectangle, -1, -1));
+                }
+            }
+
+            using (ImageAttributes imageAttributes = new ImageAttributes())
+            {
+                ColorMap[] colorMap = new ColorMap[2];
+                colorMap[0] = new ColorMap();
+                colorMap[0].OldColor = Color.FromArgb(0, 0, 0);
+                colorMap[0].NewColor = ForeColor;
+                colorMap[1] = new ColorMap();
+                colorMap[1].OldColor = Image.GetPixel(0, 0);
+                colorMap[1].NewColor = Color.Transparent;
+
+                imageAttributes.SetRemapTable(colorMap);
+
+                e.Graphics.DrawImage(
+                   Image,
+                   new Rectangle(0, 0, Image.Width, Image.Height),
+                   0, 0,
+                   Image.Width,
+                   Image.Height,
+                   GraphicsUnit.Pixel,
+                   imageAttributes);
+            }
+
+            base.OnPaint(e);
+        }
+
+        public void RefreshChanges()
+        {
+            if (IsDisposed)
+                return;
+
+            bool mouseOver = ClientRectangle.Contains(PointToClient(Control.MousePosition));
+            if (mouseOver != IsMouseOver)
+                IsMouseOver = mouseOver;
+
+            OnRefreshChanges();
+        }
+
+        protected virtual void OnRefreshChanges()
+        {
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Interfaces.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Interfaces.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Interfaces.cs	(revision 8616)
@@ -0,0 +1,47 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public interface IDockContent
+	{
+		DockContentHandler DockHandler	{	get;	}
+		void OnActivated(EventArgs e);
+		void OnDeactivate(EventArgs e);
+	}
+
+	public interface INestedPanesContainer
+	{
+		DockState DockState	{	get;	}
+		Rectangle DisplayingRectangle	{	get;	}
+		NestedPaneCollection NestedPanes	{	get;	}
+		VisibleNestedPaneCollection VisibleNestedPanes	{	get;	}
+		bool IsFloat	{	get;	}
+	}
+
+    internal interface IDragSource
+    {
+        Control DragControl { get; }
+    }
+
+    internal interface IDockDragSource : IDragSource
+    {
+        Rectangle BeginDrag(Point ptMouse);
+        void EndDrag();
+        bool IsDockStateValid(DockState dockState);
+        bool CanDockTo(DockPane pane);
+        void FloatAt(Rectangle floatWindowBounds);
+        void DockTo(DockPane pane, DockStyle dockStyle, int contentIndex);
+        void DockTo(DockPanel panel, DockStyle dockStyle);
+    }
+
+    internal interface ISplitterDragSource : IDragSource
+    {
+        void BeginDrag(Rectangle rectSplitter);
+        void EndDrag();
+        bool IsVertical { get; }
+        Rectangle DragLimitBounds { get; }
+        void MoveSplitter(int offset);
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Localization.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Localization.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Localization.cs	(revision 8616)
@@ -0,0 +1,46 @@
+using System;
+using System.ComponentModel;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	[AttributeUsage(AttributeTargets.All)]
+	internal sealed class LocalizedDescriptionAttribute : DescriptionAttribute
+	{
+		private bool m_initialized = false;
+
+		public LocalizedDescriptionAttribute(string key) : base(key)
+		{
+		}
+
+		public override string Description
+		{
+			get
+			{	
+				if (!m_initialized)
+				{
+					string key = base.Description;
+					DescriptionValue = ResourceHelper.GetString(key);
+					if (DescriptionValue == null)
+						DescriptionValue = String.Empty;
+
+					m_initialized = true;
+				}
+
+				return DescriptionValue;
+			}
+		}
+	}
+
+	[AttributeUsage(AttributeTargets.All)]
+	internal sealed class LocalizedCategoryAttribute : CategoryAttribute
+	{
+		public LocalizedCategoryAttribute(string key) : base(key)
+		{
+		}
+
+		protected override string GetLocalizedString(string key)
+		{
+			return ResourceHelper.GetString(key);
+		}
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Measures.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Measures.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Measures.cs	(revision 8616)
@@ -0,0 +1,14 @@
+using System;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	internal static class Measures
+	{
+		public const int SplitterSize = 4;
+	}
+
+	internal static class MeasurePane
+	{
+		public const int MinSize = 24;
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/NestedDockingStatus.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/NestedDockingStatus.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/NestedDockingStatus.cs	(revision 8616)
@@ -0,0 +1,108 @@
+using System;
+using System.Drawing;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public sealed class NestedDockingStatus
+	{
+		internal NestedDockingStatus(DockPane pane)
+		{
+			m_dockPane = pane;
+		}
+
+		private DockPane m_dockPane = null;
+		public DockPane DockPane
+		{
+			get	{	return m_dockPane;	}
+		}
+		
+		private NestedPaneCollection m_nestedPanes = null;
+		public NestedPaneCollection NestedPanes
+		{
+			get	{	return m_nestedPanes;	}
+		}
+		
+		private DockPane m_previousPane = null;
+		public DockPane PreviousPane
+		{
+			get	{	return m_previousPane;	}
+		}
+
+		private DockAlignment m_alignment = DockAlignment.Left;
+		public DockAlignment Alignment
+		{
+			get	{	return m_alignment;	}
+		}
+
+		private double m_proportion = 0.5;
+		public double Proportion
+		{
+			get	{	return m_proportion;	}
+		}
+
+		private bool m_isDisplaying = false;
+		public bool IsDisplaying
+		{
+			get	{	return m_isDisplaying;	}
+		}
+
+		private DockPane m_displayingPreviousPane = null;
+		public DockPane DisplayingPreviousPane
+		{
+			get	{	return m_displayingPreviousPane;	}
+		}
+
+		private DockAlignment m_displayingAlignment = DockAlignment.Left;
+		public DockAlignment DisplayingAlignment
+		{
+			get	{	return m_displayingAlignment;	}
+		}
+
+		private double m_displayingProportion = 0.5;
+		public double DisplayingProportion
+		{
+			get	{	return m_displayingProportion;	}
+		}
+
+		private Rectangle m_logicalBounds = Rectangle.Empty; 
+		public Rectangle LogicalBounds
+		{
+			get	{	return m_logicalBounds;	}
+		}
+
+		private Rectangle m_paneBounds = Rectangle.Empty;
+		public Rectangle PaneBounds
+		{
+			get	{	return m_paneBounds;	}
+		}
+
+		private Rectangle m_splitterBounds = Rectangle.Empty;
+		public Rectangle SplitterBounds
+		{
+			get	{	return m_splitterBounds;	}
+		}
+
+		internal void SetStatus(NestedPaneCollection nestedPanes, DockPane previousPane, DockAlignment alignment, double proportion)
+		{
+			m_nestedPanes = nestedPanes;
+			m_previousPane = previousPane;
+			m_alignment = alignment;
+			m_proportion = proportion;
+		}
+
+		internal void SetDisplayingStatus(bool isDisplaying, DockPane displayingPreviousPane, DockAlignment displayingAlignment, double displayingProportion)
+		{
+			m_isDisplaying = isDisplaying;
+			m_displayingPreviousPane = displayingPreviousPane;
+			m_displayingAlignment = displayingAlignment;
+			m_displayingProportion = displayingProportion;
+		}
+
+		internal void SetDisplayingBounds(Rectangle logicalBounds, Rectangle paneBounds, Rectangle splitterBounds)
+		{
+			m_logicalBounds = logicalBounds;
+			m_paneBounds = paneBounds;
+			m_splitterBounds = splitterBounds;
+		}
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/NestedPaneCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/NestedPaneCollection.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/NestedPaneCollection.cs	(revision 8616)
@@ -0,0 +1,167 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Drawing;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public sealed class NestedPaneCollection : ReadOnlyCollection<DockPane>
+	{
+		private INestedPanesContainer m_container;
+		private VisibleNestedPaneCollection m_visibleNestedPanes;
+
+		internal NestedPaneCollection(INestedPanesContainer container)
+            : base(new List<DockPane>())
+		{
+			m_container = container;
+			m_visibleNestedPanes = new VisibleNestedPaneCollection(this);
+		}
+
+		public INestedPanesContainer Container
+		{
+			get	{	return m_container;	}
+		}
+		
+		public VisibleNestedPaneCollection VisibleNestedPanes
+		{
+			get	{	return m_visibleNestedPanes;	}
+		}
+
+		public DockState DockState
+		{
+			get	{	return Container.DockState;	}
+		}
+
+		public bool IsFloat
+		{
+			get	{	return DockState == DockState.Float;	}
+		}
+
+		internal void Add(DockPane pane)
+		{
+			if (pane == null)
+				return;
+
+			NestedPaneCollection oldNestedPanes = (pane.NestedPanesContainer == null) ? null : pane.NestedPanesContainer.NestedPanes;
+			if (oldNestedPanes != null)
+				oldNestedPanes.InternalRemove(pane);
+			Items.Add(pane);
+			if (oldNestedPanes != null)
+				oldNestedPanes.CheckFloatWindowDispose();
+		}
+
+		private void CheckFloatWindowDispose()
+		{
+			if (Count == 0 && Container.DockState == DockState.Float)
+			{
+				FloatWindow floatWindow = (FloatWindow)Container;
+				if (!floatWindow.Disposing && !floatWindow.IsDisposed)
+                                        if (!Win32Helper.IsRunningOnMono)
+					NativeMethods.PostMessage(((FloatWindow)Container).Handle, FloatWindow.WM_CHECKDISPOSE, 0, 0);
+			}
+		}
+
+        /// <summary>
+        /// Switches a pane with its first child in the pane hierarchy. (The actual hiding happens elsewhere.)
+        /// </summary>
+        /// <param name="pane">Pane to switch</param>
+        internal void SwitchPaneWithFirstChild(DockPane pane)
+        {
+            if (!Contains(pane))
+                return;
+
+            NestedDockingStatus statusPane = pane.NestedDockingStatus;
+            DockPane lastNestedPane = null;
+            for (int i = Count - 1; i > IndexOf(pane); i--)
+            {
+                if (this[i].NestedDockingStatus.PreviousPane == pane)
+                {
+                    lastNestedPane = this[i];
+                    break;
+                }
+            }
+
+            if (lastNestedPane != null)
+            {
+                int indexLastNestedPane = IndexOf(lastNestedPane);
+                Items[IndexOf(pane)] = lastNestedPane;
+                Items[indexLastNestedPane] = pane;
+                NestedDockingStatus lastNestedDock = lastNestedPane.NestedDockingStatus;
+
+                DockAlignment newAlignment;
+                if (lastNestedDock.Alignment == DockAlignment.Left)
+                    newAlignment = DockAlignment.Right;
+                else if (lastNestedDock.Alignment == DockAlignment.Right)
+                    newAlignment = DockAlignment.Left;
+                else if (lastNestedDock.Alignment == DockAlignment.Top)
+                    newAlignment = DockAlignment.Bottom;
+                else
+                    newAlignment = DockAlignment.Top;
+                double newProportion = 1 - lastNestedDock.Proportion;
+
+                lastNestedDock.SetStatus(this, statusPane.PreviousPane, statusPane.Alignment, statusPane.Proportion);
+                for (int i = indexLastNestedPane - 1; i > IndexOf(lastNestedPane); i--)
+                {
+                    NestedDockingStatus status = this[i].NestedDockingStatus;
+                    if (status.PreviousPane == pane)
+                        status.SetStatus(this, lastNestedPane, status.Alignment, status.Proportion);
+                }
+
+                statusPane.SetStatus(this, lastNestedPane, newAlignment, newProportion);
+            }
+        }
+
+		internal void Remove(DockPane pane)
+		{
+			InternalRemove(pane);
+			CheckFloatWindowDispose();
+		}
+
+		private void InternalRemove(DockPane pane)
+		{
+			if (!Contains(pane))
+				return;
+
+			NestedDockingStatus statusPane = pane.NestedDockingStatus;
+			DockPane lastNestedPane = null;
+			for (int i=Count - 1; i> IndexOf(pane); i--)
+			{
+				if (this[i].NestedDockingStatus.PreviousPane == pane)
+				{
+					lastNestedPane = this[i];
+					break;
+				}
+			}
+
+			if (lastNestedPane != null)
+			{
+				int indexLastNestedPane = IndexOf(lastNestedPane);
+				Items.Remove(lastNestedPane);
+				Items[IndexOf(pane)] = lastNestedPane;
+				NestedDockingStatus lastNestedDock = lastNestedPane.NestedDockingStatus;
+				lastNestedDock.SetStatus(this, statusPane.PreviousPane, statusPane.Alignment, statusPane.Proportion);
+				for (int i=indexLastNestedPane - 1; i>IndexOf(lastNestedPane); i--)
+				{
+					NestedDockingStatus status = this[i].NestedDockingStatus;
+					if (status.PreviousPane == pane)
+						status.SetStatus(this, lastNestedPane, status.Alignment, status.Proportion);
+				}
+			}
+			else
+				Items.Remove(pane);
+
+			statusPane.SetStatus(null, null, DockAlignment.Left, 0.5);
+			statusPane.SetDisplayingStatus(false, null, DockAlignment.Left, 0.5);
+			statusPane.SetDisplayingBounds(Rectangle.Empty, Rectangle.Empty, Rectangle.Empty);
+		}
+
+		public DockPane GetDefaultPreviousPane(DockPane pane)
+		{
+			for (int i=Count-1; i>=0; i--)
+				if (this[i] != pane)
+					return this[i];
+
+			return null;
+		}
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Resources.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Resources.Designer.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Resources.Designer.cs	(revision 8616)
@@ -0,0 +1,224 @@
+﻿//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:2.0.50727.4952
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace WeifenLuo.WinFormsUI.Docking {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "2.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("WeifenLuo.WinFormsUI.Docking.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PaneDiamond {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PaneDiamond_Bottom {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond_Bottom", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PaneDiamond_Fill {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond_Fill", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PaneDiamond_HotSpot {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond_HotSpot", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PaneDiamond_HotSpotIndex {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond_HotSpotIndex", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PaneDiamond_Left {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond_Left", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PaneDiamond_Right {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond_Right", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PaneDiamond_Top {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond_Top", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PanelBottom {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PanelBottom", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PanelBottom_Active {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PanelBottom_Active", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PanelFill {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PanelFill", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PanelFill_Active {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PanelFill_Active", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PanelLeft {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PanelLeft", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PanelLeft_Active {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PanelLeft_Active", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PanelRight {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PanelRight", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PanelRight_Active {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PanelRight_Active", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PanelTop {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PanelTop", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockIndicator_PanelTop_Active {
+            get {
+                object obj = ResourceManager.GetObject("DockIndicator_PanelTop_Active", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockPane_AutoHide {
+            get {
+                object obj = ResourceManager.GetObject("DockPane_AutoHide", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockPane_Close {
+            get {
+                object obj = ResourceManager.GetObject("DockPane_Close", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockPane_Dock {
+            get {
+                object obj = ResourceManager.GetObject("DockPane_Dock", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockPane_Option {
+            get {
+                object obj = ResourceManager.GetObject("DockPane_Option", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        internal static System.Drawing.Bitmap DockPane_OptionOverflow {
+            get {
+                object obj = ResourceManager.GetObject("DockPane_OptionOverflow", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Resources.resx
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Resources.resx	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Resources.resx	(revision 8616)
@@ -0,0 +1,190 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="DockIndicator_PaneDiamond" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PaneDiamond.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PaneDiamond_Bottom" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PaneDiamond_Bottom.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PaneDiamond_Fill" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\Dockindicator_PaneDiamond_Fill.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PaneDiamond_HotSpot" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PaneDiamond_Hotspot.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PaneDiamond_HotSpotIndex" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PaneDiamond_HotspotIndex.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PaneDiamond_Left" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PaneDiamond_Left.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PaneDiamond_Right" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PaneDiamond_Right.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PaneDiamond_Top" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PaneDiamond_Top.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PanelBottom" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PanelBottom.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PanelBottom_Active" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PanelBottom_Active.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PanelFill" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PanelFill.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PanelFill_Active" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PanelFill_Active.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PanelLeft" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PanelLeft.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PanelLeft_Active" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PanelLeft_Active.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PanelRight" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PanelRight.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PanelRight_Active" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PanelRight_Active.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PanelTop" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PanelTop.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockIndicator_PanelTop_Active" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockIndicator_PanelTop_Active.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockPane_AutoHide" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockPane_AutoHide.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockPane_Close" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockPane_Close.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockPane_Dock" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockPane_Dock.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockPane_Option" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockPane_Option.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DockPane_OptionOverflow" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>Resources\DockPane_OptionOverflow.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+</root>
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Skins/DockPanelSkinBuilder.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Skins/DockPanelSkinBuilder.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Skins/DockPanelSkinBuilder.cs	(revision 8616)
@@ -0,0 +1,57 @@
+﻿using System.Drawing;
+using System.Drawing.Drawing2D;
+
+namespace WeifenLuo.WinFormsUI.Docking.Skins
+{
+    internal static class DockPanelSkinBuilder
+    {
+        public static DockPanelSkin Create(Style style)
+        {
+            switch (style)
+            {
+                case Style.VisualStudio2005:
+                default:
+                    return CreateVisualStudio2005();
+            }
+        }
+
+        private static DockPanelSkin CreateVisualStudio2005()
+        {
+            DockPanelSkin skin = new DockPanelSkin();
+
+            skin.AutoHideStripSkin.DockStripGradient.StartColor = SystemColors.ControlLight;
+            skin.AutoHideStripSkin.DockStripGradient.EndColor = SystemColors.ControlLight;
+            skin.AutoHideStripSkin.TabGradient.TextColor = SystemColors.ControlDarkDark;
+
+            skin.DockPaneStripSkin.DocumentGradient.DockStripGradient.StartColor = SystemColors.Control;
+            skin.DockPaneStripSkin.DocumentGradient.DockStripGradient.EndColor = SystemColors.Control;
+            skin.DockPaneStripSkin.DocumentGradient.ActiveTabGradient.StartColor = SystemColors.ControlLightLight;
+            skin.DockPaneStripSkin.DocumentGradient.ActiveTabGradient.EndColor = SystemColors.ControlLightLight;
+            skin.DockPaneStripSkin.DocumentGradient.InactiveTabGradient.StartColor = SystemColors.ControlLight;
+            skin.DockPaneStripSkin.DocumentGradient.InactiveTabGradient.EndColor = SystemColors.ControlLight;
+
+            skin.DockPaneStripSkin.ToolWindowGradient.DockStripGradient.StartColor = SystemColors.ControlLight;
+            skin.DockPaneStripSkin.ToolWindowGradient.DockStripGradient.EndColor = SystemColors.ControlLight;
+
+            skin.DockPaneStripSkin.ToolWindowGradient.ActiveTabGradient.StartColor = SystemColors.Control;
+            skin.DockPaneStripSkin.ToolWindowGradient.ActiveTabGradient.EndColor = SystemColors.Control;
+
+            skin.DockPaneStripSkin.ToolWindowGradient.InactiveTabGradient.StartColor = Color.Transparent;
+            skin.DockPaneStripSkin.ToolWindowGradient.InactiveTabGradient.EndColor = Color.Transparent;
+            skin.DockPaneStripSkin.ToolWindowGradient.InactiveTabGradient.TextColor = SystemColors.ControlDarkDark;
+
+            skin.DockPaneStripSkin.ToolWindowGradient.ActiveCaptionGradient.StartColor = SystemColors.GradientActiveCaption;
+            skin.DockPaneStripSkin.ToolWindowGradient.ActiveCaptionGradient.EndColor = SystemColors.ActiveCaption;
+            skin.DockPaneStripSkin.ToolWindowGradient.ActiveCaptionGradient.LinearGradientMode = LinearGradientMode.Vertical;
+            skin.DockPaneStripSkin.ToolWindowGradient.ActiveCaptionGradient.TextColor = SystemColors.ActiveCaptionText;
+
+            skin.DockPaneStripSkin.ToolWindowGradient.InactiveCaptionGradient.StartColor = SystemColors.GradientInactiveCaption;
+            skin.DockPaneStripSkin.ToolWindowGradient.InactiveCaptionGradient.EndColor = SystemColors.InactiveCaption;
+            skin.DockPaneStripSkin.ToolWindowGradient.InactiveCaptionGradient.LinearGradientMode = LinearGradientMode.Vertical;
+            skin.DockPaneStripSkin.ToolWindowGradient.InactiveCaptionGradient.TextColor = SystemColors.InactiveCaptionText;
+
+            return skin;
+        }
+
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Skins/Style.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Skins/Style.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Skins/Style.cs	(revision 8616)
@@ -0,0 +1,7 @@
+﻿namespace WeifenLuo.WinFormsUI.Docking.Skins
+{
+    public enum Style
+    {
+        VisualStudio2005 = 1
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/SplitterBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/SplitterBase.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/SplitterBase.cs	(revision 8616)
@@ -0,0 +1,70 @@
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	internal class SplitterBase : Control
+	{
+		public SplitterBase()
+		{
+			SetStyle(ControlStyles.Selectable, false);
+		}
+
+		public override DockStyle Dock
+		{
+			get	{	return base.Dock;	}
+			set
+			{
+				SuspendLayout();
+				base.Dock = value;
+
+				if (Dock == DockStyle.Left || Dock == DockStyle.Right)
+					Width = SplitterSize;
+				else if (Dock == DockStyle.Top || Dock == DockStyle.Bottom)
+					Height = SplitterSize;
+				else
+					Bounds = Rectangle.Empty;
+
+				if (Dock == DockStyle.Left || Dock == DockStyle.Right)
+					Cursor = Cursors.VSplit;
+				else if (Dock == DockStyle.Top || Dock == DockStyle.Bottom)
+					Cursor = Cursors.HSplit;
+				else
+					Cursor = Cursors.Default;
+					
+				ResumeLayout();
+			}
+		}
+
+		protected virtual int SplitterSize
+		{
+			get	{	return 0;	}
+		}
+
+		protected override void OnMouseDown(MouseEventArgs e)
+		{
+			base.OnMouseDown(e);
+
+			if (e.Button != MouseButtons.Left)
+				return;
+
+			StartDrag();
+		}
+
+		protected virtual void StartDrag()
+		{
+		}
+
+		protected override void WndProc(ref Message m)
+		{
+            // eat the WM_MOUSEACTIVATE message
+			if (m.Msg == (int)Win32.Msgs.WM_MOUSEACTIVATE)
+				return;
+
+			base.WndProc(ref m);
+		}
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Strings.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Strings.Designer.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Strings.Designer.cs	(revision 8616)
@@ -0,0 +1,801 @@
+﻿//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:2.0.50727.4952
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace WeifenLuo.WinFormsUI.Docking {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "2.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Strings {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Strings() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("WeifenLuo.WinFormsUI.Docking.Strings", typeof(Strings).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Docking.
+        /// </summary>
+        internal static string Category_Docking {
+            get {
+                return ResourceManager.GetString("Category_Docking", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Docking Notification.
+        /// </summary>
+        internal static string Category_DockingNotification {
+            get {
+                return ResourceManager.GetString("Category_DockingNotification", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Performance.
+        /// </summary>
+        internal static string Category_Performance {
+            get {
+                return ResourceManager.GetString("Category_Performance", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Property Changed.
+        /// </summary>
+        internal static string Category_PropertyChanged {
+            get {
+                return ResourceManager.GetString("Category_PropertyChanged", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to (Float).
+        /// </summary>
+        internal static string DockAreaEditor_FloatCheckBoxText {
+            get {
+                return ResourceManager.GetString("DockAreaEditor_FloatCheckBoxText", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Determines if end user drag and drop docking is allowed..
+        /// </summary>
+        internal static string DockContent_AllowEndUserDocking_Description {
+            get {
+                return ResourceManager.GetString("DockContent_AllowEndUserDocking_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The size to display the content in auto hide mode. Value &lt; 1 to specify the size in portion; value &gt;= 1 to specify the size in pixel..
+        /// </summary>
+        internal static string DockContent_AutoHidePortion_Description {
+            get {
+                return ResourceManager.GetString("DockContent_AutoHidePortion_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Enable/Disable the close button of the content..
+        /// </summary>
+        internal static string DockContent_CloseButton_Description {
+            get {
+                return ResourceManager.GetString("DockContent_CloseButton_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Shows or hides the close button of the content. This property does not function with System MDI Document Style..
+        /// </summary>
+        internal static string DockContent_CloseButtonVisible_Description {
+            get {
+                return ResourceManager.GetString("DockContent_CloseButtonVisible_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The form must be of type IDockContent..
+        /// </summary>
+        internal static string DockContent_Constructor_InvalidForm {
+            get {
+                return ResourceManager.GetString("DockContent_Constructor_InvalidForm", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Gets or sets a value indicating in which area of the DockPanel the content allowed to show..
+        /// </summary>
+        internal static string DockContent_DockAreas_Description {
+            get {
+                return ResourceManager.GetString("DockContent_DockAreas_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Occurs when the value of DockState property changed..
+        /// </summary>
+        internal static string DockContent_DockStateChanged_Description {
+            get {
+                return ResourceManager.GetString("DockContent_DockStateChanged_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Indicates the content will be hidden instead of being closed..
+        /// </summary>
+        internal static string DockContent_HideOnClose_Description {
+            get {
+                return ResourceManager.GetString("DockContent_HideOnClose_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The desired docking state when first showing..
+        /// </summary>
+        internal static string DockContent_ShowHint_Description {
+            get {
+                return ResourceManager.GetString("DockContent_ShowHint_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Context menu displayed for the dock pane tab strip..
+        /// </summary>
+        internal static string DockContent_TabPageContextMenu_Description {
+            get {
+                return ResourceManager.GetString("DockContent_TabPageContextMenu_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The tab text displayed in the dock pane. If not set, the Text property will be used..
+        /// </summary>
+        internal static string DockContent_TabText_Description {
+            get {
+                return ResourceManager.GetString("DockContent_TabText_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The text displayed when mouse hovers over the tab..
+        /// </summary>
+        internal static string DockContent_ToolTipText_Description {
+            get {
+                return ResourceManager.GetString("DockContent_ToolTipText_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The provided value is out of range..
+        /// </summary>
+        internal static string DockContentHandler_AutoHidePortion_OutOfRange {
+            get {
+                return ResourceManager.GetString("DockContentHandler_AutoHidePortion_OutOfRange", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid Value: The value of DockAreas conflicts with current DockState..
+        /// </summary>
+        internal static string DockContentHandler_DockAreas_InvalidValue {
+            get {
+                return ResourceManager.GetString("DockContentHandler_DockAreas_InvalidValue", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The pane is invalid. Check the IsFloat and DockPanel properties of this dock pane..
+        /// </summary>
+        internal static string DockContentHandler_DockPane_InvalidValue {
+            get {
+                return ResourceManager.GetString("DockContentHandler_DockPane_InvalidValue", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The pane is invalid. Check the IsFloat and DockPanel properties of this dock pane..
+        /// </summary>
+        internal static string DockContentHandler_FloatPane_InvalidValue {
+            get {
+                return ResourceManager.GetString("DockContentHandler_FloatPane_InvalidValue", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid value, conflicts with DockableAreas  property..
+        /// </summary>
+        internal static string DockContentHandler_IsFloat_InvalidValue {
+            get {
+                return ResourceManager.GetString("DockContentHandler_IsFloat_InvalidValue", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The dock state is invalid..
+        /// </summary>
+        internal static string DockContentHandler_SetDockState_InvalidState {
+            get {
+                return ResourceManager.GetString("DockContentHandler_SetDockState_InvalidState", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The dock panel is null..
+        /// </summary>
+        internal static string DockContentHandler_SetDockState_NullPanel {
+            get {
+                return ResourceManager.GetString("DockContentHandler_SetDockState_NullPanel", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid beforeContent, it must be contained by the pane..
+        /// </summary>
+        internal static string DockContentHandler_Show_InvalidBeforeContent {
+            get {
+                return ResourceManager.GetString("DockContentHandler_Show_InvalidBeforeContent", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid DockState: Content can not be showed as &quot;Unknown&quot; or &quot;Hidden&quot;..
+        /// </summary>
+        internal static string DockContentHandler_Show_InvalidDockState {
+            get {
+                return ResourceManager.GetString("DockContentHandler_Show_InvalidDockState", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The previous pane is invalid. It can not be null, and its docking state must not be auto-hide..
+        /// </summary>
+        internal static string DockContentHandler_Show_InvalidPrevPane {
+            get {
+                return ResourceManager.GetString("DockContentHandler_Show_InvalidPrevPane", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to DockPanel can not be null..
+        /// </summary>
+        internal static string DockContentHandler_Show_NullDockPanel {
+            get {
+                return ResourceManager.GetString("DockContentHandler_Show_NullDockPanel", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The Pane can not be null..
+        /// </summary>
+        internal static string DockContentHandler_Show_NullPane {
+            get {
+                return ResourceManager.GetString("DockContentHandler_Show_NullPane", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid value, check DockableAreas property..
+        /// </summary>
+        internal static string DockContentHandler_ShowHint_InvalidValue {
+            get {
+                return ResourceManager.GetString("DockContentHandler_ShowHint_InvalidValue", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Context menu displayed for the dock pane tab strip..
+        /// </summary>
+        internal static string DockHandler_TabPageContextMenuStrip_Description {
+            get {
+                return ResourceManager.GetString("DockHandler_TabPageContextMenuStrip_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Press SHIFT for docking to full side..
+        /// </summary>
+        internal static string DockIndicator_ToolTipText {
+            get {
+                return ResourceManager.GetString("DockIndicator_ToolTipText", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid Content: ActiveContent must be one of the visible contents, or null if there is no visible content..
+        /// </summary>
+        internal static string DockPane_ActiveContent_InvalidValue {
+            get {
+                return ResourceManager.GetString("DockPane_ActiveContent_InvalidValue", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid argument: Content can not be &quot;null&quot;..
+        /// </summary>
+        internal static string DockPane_Constructor_NullContent {
+            get {
+                return ResourceManager.GetString("DockPane_Constructor_NullContent", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid argument: The content&apos;s DockPanel can not be &quot;null&quot;..
+        /// </summary>
+        internal static string DockPane_Constructor_NullDockPanel {
+            get {
+                return ResourceManager.GetString("DockPane_Constructor_NullDockPanel", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The specified container conflicts with the IsFloat property..
+        /// </summary>
+        internal static string DockPane_DockTo_InvalidContainer {
+            get {
+                return ResourceManager.GetString("DockPane_DockTo_InvalidContainer", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The previous pane does not exist in the nested docking pane collection..
+        /// </summary>
+        internal static string DockPane_DockTo_NoPrevPane {
+            get {
+                return ResourceManager.GetString("DockPane_DockTo_NoPrevPane", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The container can not be null..
+        /// </summary>
+        internal static string DockPane_DockTo_NullContainer {
+            get {
+                return ResourceManager.GetString("DockPane_DockTo_NullContainer", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The previous pane can not be null when the nested docking pane collection is not empty..
+        /// </summary>
+        internal static string DockPane_DockTo_NullPrevPane {
+            get {
+                return ResourceManager.GetString("DockPane_DockTo_NullPrevPane", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The previous pane can not be itself..
+        /// </summary>
+        internal static string DockPane_DockTo_SelfPrevPane {
+            get {
+                return ResourceManager.GetString("DockPane_DockTo_SelfPrevPane", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to FloatWindow property can not be set to &quot;null&quot; when DockState is DockState.Float..
+        /// </summary>
+        internal static string DockPane_FloatWindow_InvalidValue {
+            get {
+                return ResourceManager.GetString("DockPane_FloatWindow_InvalidValue", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid Content: Content not within the collection..
+        /// </summary>
+        internal static string DockPane_SetContentIndex_InvalidContent {
+            get {
+                return ResourceManager.GetString("DockPane_SetContentIndex_InvalidContent", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid Index: The index is out of range..
+        /// </summary>
+        internal static string DockPane_SetContentIndex_InvalidIndex {
+            get {
+                return ResourceManager.GetString("DockPane_SetContentIndex_InvalidIndex", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The state for the dock pane is invalid..
+        /// </summary>
+        internal static string DockPane_SetDockState_InvalidState {
+            get {
+                return ResourceManager.GetString("DockPane_SetDockState_InvalidState", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Auto Hide.
+        /// </summary>
+        internal static string DockPaneCaption_ToolTipAutoHide {
+            get {
+                return ResourceManager.GetString("DockPaneCaption_ToolTipAutoHide", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Close.
+        /// </summary>
+        internal static string DockPaneCaption_ToolTipClose {
+            get {
+                return ResourceManager.GetString("DockPaneCaption_ToolTipClose", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Options.
+        /// </summary>
+        internal static string DockPaneCaption_ToolTipOptions {
+            get {
+                return ResourceManager.GetString("DockPaneCaption_ToolTipOptions", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid Content: The content must be auto-hide state and associates with this DockPanel..
+        /// </summary>
+        internal static string DockPanel_ActiveAutoHideContent_InvalidValue {
+            get {
+                return ResourceManager.GetString("DockPanel_ActiveAutoHideContent_InvalidValue", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Occurs when the value of ActiveContentProperty changed..
+        /// </summary>
+        internal static string DockPanel_ActiveContentChanged_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_ActiveContentChanged_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Occurs when the value of ActiveDocument property changed..
+        /// </summary>
+        internal static string DockPanel_ActiveDocumentChanged_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_ActiveDocumentChanged_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Occurs when the value of ActivePane property changed..
+        /// </summary>
+        internal static string DockPanel_ActivePaneChanged_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_ActivePaneChanged_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Determines if the drag and drop docking is allowed..
+        /// </summary>
+        internal static string DockPanel_AllowEndUserDocking_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_AllowEndUserDocking_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Determines if the drag and drop nested docking is allowed..
+        /// </summary>
+        internal static string DockPanel_AllowEndUserNestedDocking_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_AllowEndUserNestedDocking_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Occurs when a content added to the DockPanel..
+        /// </summary>
+        internal static string DockPanel_ContentAdded_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_ContentAdded_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Occurs when a content removed from the DockPanel..
+        /// </summary>
+        internal static string DockPanel_ContentRemoved_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_ContentRemoved_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The default size of float window..
+        /// </summary>
+        internal static string DockPanel_DefaultFloatWindowSize_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_DefaultFloatWindowSize_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Provides Visual Studio .Net style docking..
+        /// </summary>
+        internal static string DockPanel_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Size of the bottom docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels..
+        /// </summary>
+        internal static string DockPanel_DockBottomPortion_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_DockBottomPortion_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Size of the left docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels..
+        /// </summary>
+        internal static string DockPanel_DockLeftPortion_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_DockLeftPortion_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The visual skin to use when displaying the docked windows..
+        /// </summary>
+        internal static string DockPanel_DockPanelSkin {
+            get {
+                return ResourceManager.GetString("DockPanel_DockPanelSkin", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The predefined style used as the base for the skin..
+        /// </summary>
+        internal static string DockPanel_DockPanelSkinStyle {
+            get {
+                return ResourceManager.GetString("DockPanel_DockPanelSkinStyle", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Size of the right docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels..
+        /// </summary>
+        internal static string DockPanel_DockRightPortion_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_DockRightPortion_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Size of the top docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels..
+        /// </summary>
+        internal static string DockPanel_DockTopPortion_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_DockTopPortion_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The style of the document window..
+        /// </summary>
+        internal static string DockPanel_DocumentStyle_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_DocumentStyle_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Determines where the tab strip for Document style content is drawn..
+        /// </summary>
+        internal static string DockPanel_DocumentTabStripLocation {
+            get {
+                return ResourceManager.GetString("DockPanel_DocumentTabStripLocation", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The DockPanel has already been initialized..
+        /// </summary>
+        internal static string DockPanel_LoadFromXml_AlreadyInitialized {
+            get {
+                return ResourceManager.GetString("DockPanel_LoadFromXml_AlreadyInitialized", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The configuration file&apos;s version is invalid..
+        /// </summary>
+        internal static string DockPanel_LoadFromXml_InvalidFormatVersion {
+            get {
+                return ResourceManager.GetString("DockPanel_LoadFromXml_InvalidFormatVersion", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The XML file format is invalid..
+        /// </summary>
+        internal static string DockPanel_LoadFromXml_InvalidXmlFormat {
+            get {
+                return ResourceManager.GetString("DockPanel_LoadFromXml_InvalidXmlFormat", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid parent form. When using DockingMdi or SystemMdi document style, the DockPanel control must be the child control of the main MDI container form..
+        /// </summary>
+        internal static string DockPanel_ParentForm_Invalid {
+            get {
+                return ResourceManager.GetString("DockPanel_ParentForm_Invalid", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to DockPanel configuration file. Author: Weifen Luo, all rights reserved..
+        /// </summary>
+        internal static string DockPanel_Persistor_XmlFileComment1 {
+            get {
+                return ResourceManager.GetString("DockPanel_Persistor_XmlFileComment1", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to !!! AUTOMATICALLY GENERATED FILE. DO NOT MODIFY !!!.
+        /// </summary>
+        internal static string DockPanel_Persistor_XmlFileComment2 {
+            get {
+                return ResourceManager.GetString("DockPanel_Persistor_XmlFileComment2", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Indicates whether the control layout is right-to-left when the RightToLeft property is set to Yes..
+        /// </summary>
+        internal static string DockPanel_RightToLeftLayout_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_RightToLeftLayout_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid Index: The index is out of range..
+        /// </summary>
+        internal static string DockPanel_SetPaneIndex_InvalidIndex {
+            get {
+                return ResourceManager.GetString("DockPanel_SetPaneIndex_InvalidIndex", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid Pane: DockPane not within the collection..
+        /// </summary>
+        internal static string DockPanel_SetPaneIndex_InvalidPane {
+            get {
+                return ResourceManager.GetString("DockPanel_SetPaneIndex_InvalidPane", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Determines if the document icon will be displayed in the tab strip..
+        /// </summary>
+        internal static string DockPanel_ShowDocumentIcon_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_ShowDocumentIcon_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Support deeply nested controls.  Disabling this setting may improve resize performance but may cause heavily nested content not to resize..
+        /// </summary>
+        internal static string DockPanel_SupportDeeplyNestedContent_Description {
+            get {
+                return ResourceManager.GetString("DockPanel_SupportDeeplyNestedContent_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Close.
+        /// </summary>
+        internal static string DockPaneStrip_ToolTipClose {
+            get {
+                return ResourceManager.GetString("DockPaneStrip_ToolTipClose", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Window List.
+        /// </summary>
+        internal static string DockPaneStrip_ToolTipWindowList {
+            get {
+                return ResourceManager.GetString("DockPaneStrip_ToolTipWindowList", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid argument: DockPanel can not be &quot;null&quot;..
+        /// </summary>
+        internal static string FloatWindow_Constructor_NullDockPanel {
+            get {
+                return ResourceManager.GetString("FloatWindow_Constructor_NullDockPanel", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid Index: The index is out of range..
+        /// </summary>
+        internal static string FloatWindow_SetPaneIndex_InvalidIndex {
+            get {
+                return ResourceManager.GetString("FloatWindow_SetPaneIndex_InvalidIndex", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid Pane: DockPane not within the collection..
+        /// </summary>
+        internal static string FloatWindow_SetPaneIndex_InvalidPane {
+            get {
+                return ResourceManager.GetString("FloatWindow_SetPaneIndex_InvalidPane", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid DockPanel..
+        /// </summary>
+        internal static string IDockDragSource_DockTo_InvalidPanel {
+            get {
+                return ResourceManager.GetString("IDockDragSource_DockTo_InvalidPanel", resourceCulture);
+            }
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Strings.resx
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Strings.resx	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Strings.resx	(revision 8616)
@@ -0,0 +1,366 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="Category_Docking" xml:space="preserve">
+    <value>Docking</value>
+  </data>
+  <data name="Category_DockingNotification" xml:space="preserve">
+    <value>Docking Notification</value>
+  </data>
+  <data name="Category_PropertyChanged" xml:space="preserve">
+    <value>Property Changed</value>
+  </data>
+  <data name="DockAreaEditor_FloatCheckBoxText" xml:space="preserve">
+    <value>(Float)</value>
+  </data>
+  <data name="DockContent_AllowEndUserDocking_Description" xml:space="preserve">
+    <value>Determines if end user drag and drop docking is allowed.</value>
+  </data>
+  <data name="DockContent_AutoHidePortion_Description" xml:space="preserve">
+    <value>The size to display the content in auto hide mode. Value &lt; 1 to specify the size in portion; value &gt;= 1 to specify the size in pixel.</value>
+  </data>
+  <data name="DockContent_CloseButton_Description" xml:space="preserve">
+    <value>Enable/Disable the close button of the content.</value>
+  </data>
+  <data name="DockContent_Constructor_InvalidForm" xml:space="preserve">
+    <value>The form must be of type IDockContent.</value>
+  </data>
+  <data name="DockContent_DockAreas_Description" xml:space="preserve">
+    <value>Gets or sets a value indicating in which area of the DockPanel the content allowed to show.</value>
+  </data>
+  <data name="DockContent_DockStateChanged_Description" xml:space="preserve">
+    <value>Occurs when the value of DockState property changed.</value>
+  </data>
+  <data name="DockContent_HideOnClose_Description" xml:space="preserve">
+    <value>Indicates the content will be hidden instead of being closed.</value>
+  </data>
+  <data name="DockContent_ShowHint_Description" xml:space="preserve">
+    <value>The desired docking state when first showing.</value>
+  </data>
+  <data name="DockContent_TabPageContextMenu_Description" xml:space="preserve">
+    <value>Context menu displayed for the dock pane tab strip.</value>
+  </data>
+  <data name="DockContent_TabText_Description" xml:space="preserve">
+    <value>The tab text displayed in the dock pane. If not set, the Text property will be used.</value>
+  </data>
+  <data name="DockContent_ToolTipText_Description" xml:space="preserve">
+    <value>The text displayed when mouse hovers over the tab.</value>
+  </data>
+  <data name="DockContentHandler_AutoHidePortion_OutOfRange" xml:space="preserve">
+    <value>The provided value is out of range.</value>
+  </data>
+  <data name="DockContentHandler_DockAreas_InvalidValue" xml:space="preserve">
+    <value>Invalid Value: The value of DockAreas conflicts with current DockState.</value>
+  </data>
+  <data name="DockContentHandler_DockPane_InvalidValue" xml:space="preserve">
+    <value>The pane is invalid. Check the IsFloat and DockPanel properties of this dock pane.</value>
+  </data>
+  <data name="DockContentHandler_FloatPane_InvalidValue" xml:space="preserve">
+    <value>The pane is invalid. Check the IsFloat and DockPanel properties of this dock pane.</value>
+  </data>
+  <data name="DockContentHandler_IsFloat_InvalidValue" xml:space="preserve">
+    <value>Invalid value, conflicts with DockableAreas  property.</value>
+  </data>
+  <data name="DockContentHandler_SetDockState_InvalidState" xml:space="preserve">
+    <value>The dock state is invalid.</value>
+  </data>
+  <data name="DockContentHandler_SetDockState_NullPanel" xml:space="preserve">
+    <value>The dock panel is null.</value>
+  </data>
+  <data name="DockContentHandler_Show_InvalidBeforeContent" xml:space="preserve">
+    <value>Invalid beforeContent, it must be contained by the pane.</value>
+  </data>
+  <data name="DockContentHandler_Show_InvalidDockState" xml:space="preserve">
+    <value>Invalid DockState: Content can not be showed as "Unknown" or "Hidden".</value>
+  </data>
+  <data name="DockContentHandler_Show_InvalidPrevPane" xml:space="preserve">
+    <value>The previous pane is invalid. It can not be null, and its docking state must not be auto-hide.</value>
+  </data>
+  <data name="DockContentHandler_Show_NullDockPanel" xml:space="preserve">
+    <value>DockPanel can not be null.</value>
+  </data>
+  <data name="DockContentHandler_Show_NullPane" xml:space="preserve">
+    <value>The Pane can not be null.</value>
+  </data>
+  <data name="DockContentHandler_ShowHint_InvalidValue" xml:space="preserve">
+    <value>Invalid value, check DockableAreas property.</value>
+  </data>
+  <data name="DockHandler_TabPageContextMenuStrip_Description" xml:space="preserve">
+    <value>Context menu displayed for the dock pane tab strip.</value>
+  </data>
+  <data name="DockIndicator_ToolTipText" xml:space="preserve">
+    <value>Press SHIFT for docking to full side.</value>
+  </data>
+  <data name="DockPane_ActiveContent_InvalidValue" xml:space="preserve">
+    <value>Invalid Content: ActiveContent must be one of the visible contents, or null if there is no visible content.</value>
+  </data>
+  <data name="DockPane_Constructor_NullContent" xml:space="preserve">
+    <value>Invalid argument: Content can not be "null".</value>
+  </data>
+  <data name="DockPane_Constructor_NullDockPanel" xml:space="preserve">
+    <value>Invalid argument: The content's DockPanel can not be "null".</value>
+  </data>
+  <data name="DockPane_DockTo_InvalidContainer" xml:space="preserve">
+    <value>The specified container conflicts with the IsFloat property.</value>
+  </data>
+  <data name="DockPane_DockTo_NoPrevPane" xml:space="preserve">
+    <value>The previous pane does not exist in the nested docking pane collection.</value>
+  </data>
+  <data name="DockPane_DockTo_NullContainer" xml:space="preserve">
+    <value>The container can not be null.</value>
+  </data>
+  <data name="DockPane_DockTo_NullPrevPane" xml:space="preserve">
+    <value>The previous pane can not be null when the nested docking pane collection is not empty.</value>
+  </data>
+  <data name="DockPane_DockTo_SelfPrevPane" xml:space="preserve">
+    <value>The previous pane can not be itself.</value>
+  </data>
+  <data name="DockPane_FloatWindow_InvalidValue" xml:space="preserve">
+    <value>FloatWindow property can not be set to "null" when DockState is DockState.Float.</value>
+  </data>
+  <data name="DockPane_SetContentIndex_InvalidContent" xml:space="preserve">
+    <value>Invalid Content: Content not within the collection.</value>
+  </data>
+  <data name="DockPane_SetContentIndex_InvalidIndex" xml:space="preserve">
+    <value>Invalid Index: The index is out of range.</value>
+  </data>
+  <data name="DockPane_SetDockState_InvalidState" xml:space="preserve">
+    <value>The state for the dock pane is invalid.</value>
+  </data>
+  <data name="DockPaneCaption_ToolTipAutoHide" xml:space="preserve">
+    <value>Auto Hide</value>
+  </data>
+  <data name="DockPaneCaption_ToolTipClose" xml:space="preserve">
+    <value>Close</value>
+  </data>
+  <data name="DockPaneCaption_ToolTipOptions" xml:space="preserve">
+    <value>Options</value>
+  </data>
+  <data name="DockPanel_ActiveAutoHideContent_InvalidValue" xml:space="preserve">
+    <value>Invalid Content: The content must be auto-hide state and associates with this DockPanel.</value>
+  </data>
+  <data name="DockPanel_ActiveContentChanged_Description" xml:space="preserve">
+    <value>Occurs when the value of ActiveContentProperty changed.</value>
+  </data>
+  <data name="DockPanel_ActiveDocumentChanged_Description" xml:space="preserve">
+    <value>Occurs when the value of ActiveDocument property changed.</value>
+  </data>
+  <data name="DockPanel_ActivePaneChanged_Description" xml:space="preserve">
+    <value>Occurs when the value of ActivePane property changed.</value>
+  </data>
+  <data name="DockPanel_AllowEndUserDocking_Description" xml:space="preserve">
+    <value>Determines if the drag and drop docking is allowed.</value>
+  </data>
+  <data name="DockPanel_AllowEndUserNestedDocking_Description" xml:space="preserve">
+    <value>Determines if the drag and drop nested docking is allowed.</value>
+  </data>
+  <data name="DockPanel_ContentAdded_Description" xml:space="preserve">
+    <value>Occurs when a content added to the DockPanel.</value>
+  </data>
+  <data name="DockPanel_ContentRemoved_Description" xml:space="preserve">
+    <value>Occurs when a content removed from the DockPanel.</value>
+  </data>
+  <data name="DockPanel_DefaultFloatWindowSize_Description" xml:space="preserve">
+    <value>The default size of float window.</value>
+  </data>
+  <data name="DockPanel_Description" xml:space="preserve">
+    <value>Provides Visual Studio .Net style docking.</value>
+  </data>
+  <data name="DockPanel_DockBottomPortion_Description" xml:space="preserve">
+    <value>Size of the bottom docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels.</value>
+  </data>
+  <data name="DockPanel_DockLeftPortion_Description" xml:space="preserve">
+    <value>Size of the left docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels.</value>
+  </data>
+  <data name="DockPanel_DockRightPortion_Description" xml:space="preserve">
+    <value>Size of the right docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels.</value>
+  </data>
+  <data name="DockPanel_DockTopPortion_Description" xml:space="preserve">
+    <value>Size of the top docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels.</value>
+  </data>
+  <data name="DockPanel_DocumentStyle_Description" xml:space="preserve">
+    <value>The style of the document window.</value>
+  </data>
+  <data name="DockPanel_LoadFromXml_AlreadyInitialized" xml:space="preserve">
+    <value>The DockPanel has already been initialized.</value>
+  </data>
+  <data name="DockPanel_LoadFromXml_InvalidFormatVersion" xml:space="preserve">
+    <value>The configuration file's version is invalid.</value>
+  </data>
+  <data name="DockPanel_LoadFromXml_InvalidXmlFormat" xml:space="preserve">
+    <value>The XML file format is invalid.</value>
+  </data>
+  <data name="DockPanel_ParentForm_Invalid" xml:space="preserve">
+    <value>Invalid parent form. When using DockingMdi or SystemMdi document style, the DockPanel control must be the child control of the main MDI container form.</value>
+  </data>
+  <data name="DockPanel_Persistor_XmlFileComment1" xml:space="preserve">
+    <value>DockPanel configuration file. Author: Weifen Luo, all rights reserved.</value>
+  </data>
+  <data name="DockPanel_Persistor_XmlFileComment2" xml:space="preserve">
+    <value>!!! AUTOMATICALLY GENERATED FILE. DO NOT MODIFY !!!</value>
+  </data>
+  <data name="DockPanel_RightToLeftLayout_Description" xml:space="preserve">
+    <value>Indicates whether the control layout is right-to-left when the RightToLeft property is set to Yes.</value>
+  </data>
+  <data name="DockPanel_SetPaneIndex_InvalidIndex" xml:space="preserve">
+    <value>Invalid Index: The index is out of range.</value>
+  </data>
+  <data name="DockPanel_SetPaneIndex_InvalidPane" xml:space="preserve">
+    <value>Invalid Pane: DockPane not within the collection.</value>
+  </data>
+  <data name="DockPanel_ShowDocumentIcon_Description" xml:space="preserve">
+    <value>Determines if the document icon will be displayed in the tab strip.</value>
+  </data>
+  <data name="DockPaneStrip_ToolTipClose" xml:space="preserve">
+    <value>Close</value>
+  </data>
+  <data name="DockPaneStrip_ToolTipWindowList" xml:space="preserve">
+    <value>Window List</value>
+  </data>
+  <data name="FloatWindow_Constructor_NullDockPanel" xml:space="preserve">
+    <value>Invalid argument: DockPanel can not be "null".</value>
+  </data>
+  <data name="FloatWindow_SetPaneIndex_InvalidIndex" xml:space="preserve">
+    <value>Invalid Index: The index is out of range.</value>
+  </data>
+  <data name="FloatWindow_SetPaneIndex_InvalidPane" xml:space="preserve">
+    <value>Invalid Pane: DockPane not within the collection.</value>
+  </data>
+  <data name="IDockDragSource_DockTo_InvalidPanel" xml:space="preserve">
+    <value>Invalid DockPanel.</value>
+  </data>
+  <data name="DockContent_CloseButtonVisible_Description" xml:space="preserve">
+    <value>Shows or hides the close button of the content. This property does not function with System MDI Document Style.</value>
+  </data>
+  <data name="DockPanel_DockPanelSkin" xml:space="preserve">
+    <value>The visual skin to use when displaying the docked windows.</value>
+  </data>
+  <data name="DockPanel_DockPanelSkinStyle" xml:space="preserve">
+    <value>The predefined style used as the base for the skin.</value>
+  </data>
+  <data name="DockPanel_DocumentTabStripLocation" xml:space="preserve">
+    <value>Determines where the tab strip for Document style content is drawn.</value>
+  </data>
+  <data name="Category_Performance" xml:space="preserve">
+    <value>Performance</value>
+  </data>
+  <data name="DockPanel_SupportDeeplyNestedContent_Description" xml:space="preserve">
+    <value>Support deeply nested controls.  Disabling this setting may improve resize performance but may cause heavily nested content not to resize.</value>
+  </data>
+</root>
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/VS2005AutoHideStrip.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/VS2005AutoHideStrip.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/VS2005AutoHideStrip.cs	(revision 8616)
@@ -0,0 +1,526 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+using System.Drawing.Drawing2D;
+using System.ComponentModel;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    internal class VS2005AutoHideStrip : AutoHideStripBase
+    {
+        private class TabVS2005 : Tab
+        {
+            internal TabVS2005(IDockContent content)
+                : base(content)
+            {
+            }
+
+            private int m_tabX = 0;
+            public int TabX
+            {
+                get { return m_tabX; }
+                set { m_tabX = value; }
+            }
+
+            private int m_tabWidth = 0;
+            public int TabWidth
+            {
+                get { return m_tabWidth; }
+                set { m_tabWidth = value; }
+            }
+
+        }
+
+        private const int _ImageHeight = 16;
+        private const int _ImageWidth = 16;
+        private const int _ImageGapTop = 2;
+        private const int _ImageGapLeft = 4;
+        private const int _ImageGapRight = 2;
+        private const int _ImageGapBottom = 2;
+        private const int _TextGapLeft = 0;
+        private const int _TextGapRight = 0;
+        private const int _TabGapTop = 3;
+        private const int _TabGapLeft = 4;
+        private const int _TabGapBetween = 10;
+
+        #region Customizable Properties
+        public Font TextFont
+        {
+            get { return DockPanel.Skin.AutoHideStripSkin.TextFont; }
+        }
+
+        private static StringFormat _stringFormatTabHorizontal;
+        private StringFormat StringFormatTabHorizontal
+        {
+            get
+            {
+                if (_stringFormatTabHorizontal == null)
+                {
+                    _stringFormatTabHorizontal = new StringFormat();
+                    _stringFormatTabHorizontal.Alignment = StringAlignment.Near;
+                    _stringFormatTabHorizontal.LineAlignment = StringAlignment.Center;
+                    _stringFormatTabHorizontal.FormatFlags = StringFormatFlags.NoWrap;
+                    _stringFormatTabHorizontal.Trimming = StringTrimming.None;
+                }
+
+                if (RightToLeft == RightToLeft.Yes)
+                    _stringFormatTabHorizontal.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
+                else
+                    _stringFormatTabHorizontal.FormatFlags &= ~StringFormatFlags.DirectionRightToLeft;
+
+                return _stringFormatTabHorizontal;
+            }
+        }
+
+        private static StringFormat _stringFormatTabVertical;
+        private StringFormat StringFormatTabVertical
+        {
+            get
+            {
+                if (_stringFormatTabVertical == null)
+                {
+                    _stringFormatTabVertical = new StringFormat();
+                    _stringFormatTabVertical.Alignment = StringAlignment.Near;
+                    _stringFormatTabVertical.LineAlignment = StringAlignment.Center;
+                    _stringFormatTabVertical.FormatFlags = StringFormatFlags.NoWrap | StringFormatFlags.DirectionVertical;
+                    _stringFormatTabVertical.Trimming = StringTrimming.None;
+                }
+                if (RightToLeft == RightToLeft.Yes)
+                    _stringFormatTabVertical.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
+                else
+                    _stringFormatTabVertical.FormatFlags &= ~StringFormatFlags.DirectionRightToLeft;
+
+                return _stringFormatTabVertical;
+            }
+        }
+
+        private static int ImageHeight
+        {
+            get { return _ImageHeight; }
+        }
+
+        private static int ImageWidth
+        {
+            get { return _ImageWidth; }
+        }
+
+        private static int ImageGapTop
+        {
+            get { return _ImageGapTop; }
+        }
+
+        private static int ImageGapLeft
+        {
+            get { return _ImageGapLeft; }
+        }
+
+        private static int ImageGapRight
+        {
+            get { return _ImageGapRight; }
+        }
+
+        private static int ImageGapBottom
+        {
+            get { return _ImageGapBottom; }
+        }
+
+        private static int TextGapLeft
+        {
+            get { return _TextGapLeft; }
+        }
+
+        private static int TextGapRight
+        {
+            get { return _TextGapRight; }
+        }
+
+        private static int TabGapTop
+        {
+            get { return _TabGapTop; }
+        }
+
+        private static int TabGapLeft
+        {
+            get { return _TabGapLeft; }
+        }
+
+        private static int TabGapBetween
+        {
+            get { return _TabGapBetween; }
+        }
+
+        private static Pen PenTabBorder
+        {
+            get { return SystemPens.GrayText; }
+        }
+        #endregion
+
+        private static Matrix _matrixIdentity = new Matrix();
+        private static Matrix MatrixIdentity
+        {
+            get { return _matrixIdentity; }
+        }
+
+        private static DockState[] _dockStates;
+        private static DockState[] DockStates
+        {
+            get
+            {
+                if (_dockStates == null)
+                {
+                    _dockStates = new DockState[4];
+                    _dockStates[0] = DockState.DockLeftAutoHide;
+                    _dockStates[1] = DockState.DockRightAutoHide;
+                    _dockStates[2] = DockState.DockTopAutoHide;
+                    _dockStates[3] = DockState.DockBottomAutoHide;
+                }
+                return _dockStates;
+            }
+        }
+
+        private static GraphicsPath _graphicsPath;
+        internal static GraphicsPath GraphicsPath
+        {
+            get
+            {
+                if (_graphicsPath == null)
+                    _graphicsPath = new GraphicsPath();
+
+                return _graphicsPath;
+            }
+        }
+
+        public VS2005AutoHideStrip(DockPanel panel)
+            : base(panel)
+        {
+            SetStyle(ControlStyles.ResizeRedraw |
+                ControlStyles.UserPaint |
+                ControlStyles.AllPaintingInWmPaint |
+                ControlStyles.OptimizedDoubleBuffer, true);
+            BackColor = SystemColors.ControlLight;
+        }
+
+        protected override void OnPaint(PaintEventArgs e)
+        {
+            Graphics g = e.Graphics;
+
+            Color startColor = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.StartColor;
+            Color endColor = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.EndColor;
+            LinearGradientMode gradientMode = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.LinearGradientMode;
+            using (LinearGradientBrush brush = new LinearGradientBrush(ClientRectangle, startColor, endColor, gradientMode))
+            {
+                g.FillRectangle(brush, ClientRectangle);
+            }
+
+            DrawTabStrip(g);
+        }
+
+        protected override void OnLayout(LayoutEventArgs levent)
+        {
+            CalculateTabs();
+            base.OnLayout(levent);
+        }
+
+        private void DrawTabStrip(Graphics g)
+        {
+            DrawTabStrip(g, DockState.DockTopAutoHide);
+            DrawTabStrip(g, DockState.DockBottomAutoHide);
+            DrawTabStrip(g, DockState.DockLeftAutoHide);
+            DrawTabStrip(g, DockState.DockRightAutoHide);
+        }
+
+        private void DrawTabStrip(Graphics g, DockState dockState)
+        {
+            Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
+
+            if (rectTabStrip.IsEmpty)
+                return;
+
+            Matrix matrixIdentity = g.Transform;
+            if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
+            {
+                Matrix matrixRotated = new Matrix();
+                matrixRotated.RotateAt(90, new PointF((float)rectTabStrip.X + (float)rectTabStrip.Height / 2,
+                    (float)rectTabStrip.Y + (float)rectTabStrip.Height / 2));
+                g.Transform = matrixRotated;
+            }
+
+            foreach (Pane pane in GetPanes(dockState))
+            {
+                foreach (TabVS2005 tab in pane.AutoHideTabs)
+                    DrawTab(g, tab);
+            }
+            g.Transform = matrixIdentity;
+        }
+
+        private void CalculateTabs()
+        {
+            CalculateTabs(DockState.DockTopAutoHide);
+            CalculateTabs(DockState.DockBottomAutoHide);
+            CalculateTabs(DockState.DockLeftAutoHide);
+            CalculateTabs(DockState.DockRightAutoHide);
+        }
+
+        private void CalculateTabs(DockState dockState)
+        {
+            Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
+
+            int imageHeight = rectTabStrip.Height - ImageGapTop - ImageGapBottom;
+            int imageWidth = ImageWidth;
+            if (imageHeight > ImageHeight)
+                imageWidth = ImageWidth * (imageHeight / ImageHeight);
+
+            int x = TabGapLeft + rectTabStrip.X;
+            foreach (Pane pane in GetPanes(dockState))
+            {
+                foreach (TabVS2005 tab in pane.AutoHideTabs)
+                {
+                    int width = imageWidth + ImageGapLeft + ImageGapRight +
+                        TextRenderer.MeasureText(tab.Content.DockHandler.TabText, TextFont).Width +
+                        TextGapLeft + TextGapRight;
+                    tab.TabX = x;
+                    tab.TabWidth = width;
+                    x += width;
+                }
+
+                x += TabGapBetween;
+            }
+        }
+
+        private Rectangle RtlTransform(Rectangle rect, DockState dockState)
+        {
+            Rectangle rectTransformed;
+            if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
+                rectTransformed = rect;
+            else
+                rectTransformed = DrawHelper.RtlTransform(this, rect);
+
+            return rectTransformed;
+        }
+
+        private GraphicsPath GetTabOutline(TabVS2005 tab, bool transformed, bool rtlTransform)
+        {
+            DockState dockState = tab.Content.DockHandler.DockState;
+            Rectangle rectTab = GetTabRectangle(tab, transformed);
+            if (rtlTransform)
+                rectTab = RtlTransform(rectTab, dockState);
+            bool upTab = (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockBottomAutoHide);
+            DrawHelper.GetRoundedCornerTab(GraphicsPath, rectTab, upTab);
+
+            return GraphicsPath;
+        }
+
+        private void DrawTab(Graphics g, TabVS2005 tab)
+        {
+            Rectangle rectTabOrigin = GetTabRectangle(tab);
+            if (rectTabOrigin.IsEmpty)
+                return;
+
+            DockState dockState = tab.Content.DockHandler.DockState;
+            IDockContent content = tab.Content;
+
+            GraphicsPath path = GetTabOutline(tab, false, true);
+
+            Color startColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.StartColor;
+            Color endColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.EndColor;
+            LinearGradientMode gradientMode = DockPanel.Skin.AutoHideStripSkin.TabGradient.LinearGradientMode;
+            g.FillPath(new LinearGradientBrush(rectTabOrigin, startColor, endColor, gradientMode), path);
+            g.DrawPath(PenTabBorder, path);
+
+            // Set no rotate for drawing icon and text
+            Matrix matrixRotate = g.Transform;
+            g.Transform = MatrixIdentity;
+
+            // Draw the icon
+            Rectangle rectImage = rectTabOrigin;
+            rectImage.X += ImageGapLeft;
+            rectImage.Y += ImageGapTop;
+            int imageHeight = rectTabOrigin.Height - ImageGapTop - ImageGapBottom;
+            int imageWidth = ImageWidth;
+            if (imageHeight > ImageHeight)
+                imageWidth = ImageWidth * (imageHeight / ImageHeight);
+            rectImage.Height = imageHeight;
+            rectImage.Width = imageWidth;
+            rectImage = GetTransformedRectangle(dockState, rectImage);
+
+            if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
+            {
+                // The DockState is DockLeftAutoHide or DockRightAutoHide, so rotate the image 90 degrees to the right. 
+                Rectangle rectTransform = RtlTransform(rectImage, dockState);
+                Point[] rotationPoints =
+                { 
+                    new Point(rectTransform.X + rectTransform.Width, rectTransform.Y), 
+                    new Point(rectTransform.X + rectTransform.Width, rectTransform.Y + rectTransform.Height), 
+                    new Point(rectTransform.X, rectTransform.Y)
+                };
+
+                using (Icon rotatedIcon = new Icon(((Form)content).Icon, 16, 16))
+                {
+                    g.DrawImage(rotatedIcon.ToBitmap(), rotationPoints);
+                }
+            }
+            else
+            {
+                // Draw the icon normally without any rotation.
+                g.DrawIcon(((Form)content).Icon, RtlTransform(rectImage, dockState));
+            }
+
+            // Draw the text
+            Rectangle rectText = rectTabOrigin;
+            rectText.X += ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
+            rectText.Width -= ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
+            rectText = RtlTransform(GetTransformedRectangle(dockState, rectText), dockState);
+
+            Color textColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.TextColor;
+
+            if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
+                g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabVertical);
+            else
+                g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabHorizontal);
+
+            // Set rotate back
+            g.Transform = matrixRotate;
+        }
+
+        private Rectangle GetLogicalTabStripRectangle(DockState dockState)
+        {
+            return GetLogicalTabStripRectangle(dockState, false);
+        }
+
+        private Rectangle GetLogicalTabStripRectangle(DockState dockState, bool transformed)
+        {
+            if (!DockHelper.IsDockStateAutoHide(dockState))
+                return Rectangle.Empty;
+
+            int leftPanes = GetPanes(DockState.DockLeftAutoHide).Count;
+            int rightPanes = GetPanes(DockState.DockRightAutoHide).Count;
+            int topPanes = GetPanes(DockState.DockTopAutoHide).Count;
+            int bottomPanes = GetPanes(DockState.DockBottomAutoHide).Count;
+
+            int x, y, width, height;
+
+            height = MeasureHeight();
+            if (dockState == DockState.DockLeftAutoHide && leftPanes > 0)
+            {
+                x = 0;
+                y = (topPanes == 0) ? 0 : height;
+                width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 : height);
+            }
+            else if (dockState == DockState.DockRightAutoHide && rightPanes > 0)
+            {
+                x = Width - height;
+                if (leftPanes != 0 && x < height)
+                    x = height;
+                y = (topPanes == 0) ? 0 : height;
+                width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 : height);
+            }
+            else if (dockState == DockState.DockTopAutoHide && topPanes > 0)
+            {
+                x = leftPanes == 0 ? 0 : height;
+                y = 0;
+                width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
+            }
+            else if (dockState == DockState.DockBottomAutoHide && bottomPanes > 0)
+            {
+                x = leftPanes == 0 ? 0 : height;
+                y = Height - height;
+                if (topPanes != 0 && y < height)
+                    y = height;
+                width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
+            }
+            else
+                return Rectangle.Empty;
+
+            if (!transformed)
+                return new Rectangle(x, y, width, height);
+            else
+                return GetTransformedRectangle(dockState, new Rectangle(x, y, width, height));
+        }
+
+        private Rectangle GetTabRectangle(TabVS2005 tab)
+        {
+            return GetTabRectangle(tab, false);
+        }
+
+        private Rectangle GetTabRectangle(TabVS2005 tab, bool transformed)
+        {
+            DockState dockState = tab.Content.DockHandler.DockState;
+            Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
+
+            if (rectTabStrip.IsEmpty)
+                return Rectangle.Empty;
+
+            int x = tab.TabX;
+            int y = rectTabStrip.Y +
+                (dockState == DockState.DockTopAutoHide || dockState == DockState.DockRightAutoHide ?
+                0 : TabGapTop);
+            int width = tab.TabWidth;
+            int height = rectTabStrip.Height - TabGapTop;
+
+            if (!transformed)
+                return new Rectangle(x, y, width, height);
+            else
+                return GetTransformedRectangle(dockState, new Rectangle(x, y, width, height));
+        }
+
+        private Rectangle GetTransformedRectangle(DockState dockState, Rectangle rect)
+        {
+            if (dockState != DockState.DockLeftAutoHide && dockState != DockState.DockRightAutoHide)
+                return rect;
+
+            PointF[] pts = new PointF[1];
+            // the center of the rectangle
+            pts[0].X = (float)rect.X + (float)rect.Width / 2;
+            pts[0].Y = (float)rect.Y + (float)rect.Height / 2;
+            Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
+            Matrix matrix = new Matrix();
+            matrix.RotateAt(90, new PointF((float)rectTabStrip.X + (float)rectTabStrip.Height / 2,
+                (float)rectTabStrip.Y + (float)rectTabStrip.Height / 2));
+            matrix.TransformPoints(pts);
+
+            return new Rectangle((int)(pts[0].X - (float)rect.Height / 2 + .5F),
+                (int)(pts[0].Y - (float)rect.Width / 2 + .5F),
+                rect.Height, rect.Width);
+        }
+
+        protected override IDockContent HitTest(Point ptMouse)
+        {
+            foreach (DockState state in DockStates)
+            {
+                Rectangle rectTabStrip = GetLogicalTabStripRectangle(state, true);
+                if (!rectTabStrip.Contains(ptMouse))
+                    continue;
+
+                foreach (Pane pane in GetPanes(state))
+                {
+                    foreach (TabVS2005 tab in pane.AutoHideTabs)
+                    {
+                        GraphicsPath path = GetTabOutline(tab, true, true);
+                        if (path.IsVisible(ptMouse))
+                            return tab.Content;
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        protected internal override int MeasureHeight()
+        {
+            return Math.Max(ImageGapBottom +
+                ImageGapTop + ImageHeight,
+                TextFont.Height) + TabGapTop;
+        }
+
+        protected override void OnRefreshChanges()
+        {
+            CalculateTabs();
+            Invalidate();
+        }
+
+        protected override AutoHideStripBase.Tab CreateTab(IDockContent content)
+        {
+            return new TabVS2005(content);
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/VS2005DockPaneCaption.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/VS2005DockPaneCaption.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/VS2005DockPaneCaption.cs	(revision 8616)
@@ -0,0 +1,480 @@
+using System;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Windows.Forms;
+using System.ComponentModel;
+using System.Windows.Forms.VisualStyles;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	internal class VS2005DockPaneCaption : DockPaneCaptionBase
+	{
+        private sealed class InertButton : InertButtonBase
+        {
+            private Bitmap m_image, m_imageAutoHide;
+
+            public InertButton(VS2005DockPaneCaption dockPaneCaption, Bitmap image, Bitmap imageAutoHide)
+                : base()
+            {
+                m_dockPaneCaption = dockPaneCaption;
+                m_image = image;
+                m_imageAutoHide = imageAutoHide;
+                RefreshChanges();
+            }
+
+            private VS2005DockPaneCaption m_dockPaneCaption;
+            private VS2005DockPaneCaption DockPaneCaption
+            {
+                get { return m_dockPaneCaption; }
+            }
+
+            public bool IsAutoHide
+            {
+                get { return DockPaneCaption.DockPane.IsAutoHide; }
+            }
+
+            public override Bitmap Image
+            {
+                get { return IsAutoHide ? m_imageAutoHide : m_image; }
+            }
+
+            protected override void OnRefreshChanges()
+            {
+                if (DockPaneCaption.DockPane.DockPanel != null)
+                {
+                    if (DockPaneCaption.TextColor != ForeColor)
+                    {
+                        ForeColor = DockPaneCaption.TextColor;
+                        Invalidate();
+                    }
+                }
+            }
+        }
+
+		#region consts
+		private const int _TextGapTop = 2;
+		private const int _TextGapBottom = 0;
+		private const int _TextGapLeft = 3;
+		private const int _TextGapRight = 3;
+		private const int _ButtonGapTop = 2;
+		private const int _ButtonGapBottom = 1;
+		private const int _ButtonGapBetween = 1;
+		private const int _ButtonGapLeft = 1;
+		private const int _ButtonGapRight = 2;
+		#endregion
+
+        private static Bitmap _imageButtonClose;
+        private static Bitmap ImageButtonClose
+        {
+            get
+            {
+                if (_imageButtonClose == null)
+                    _imageButtonClose = Resources.DockPane_Close;
+
+                return _imageButtonClose;
+            }
+        }
+
+		private InertButton m_buttonClose;
+        private InertButton ButtonClose
+        {
+            get
+            {
+                if (m_buttonClose == null)
+                {
+                    m_buttonClose = new InertButton(this, ImageButtonClose, ImageButtonClose);
+                    m_toolTip.SetToolTip(m_buttonClose, ToolTipClose);
+                    m_buttonClose.Click += new EventHandler(Close_Click);
+                    Controls.Add(m_buttonClose);
+                }
+
+                return m_buttonClose;
+            }
+        }
+
+        private static Bitmap _imageButtonAutoHide;
+        private static Bitmap ImageButtonAutoHide
+        {
+            get
+            {
+                if (_imageButtonAutoHide == null)
+                    _imageButtonAutoHide = Resources.DockPane_AutoHide;
+
+                return _imageButtonAutoHide;
+            }
+        }
+
+        private static Bitmap _imageButtonDock;
+        private static Bitmap ImageButtonDock
+        {
+            get
+            {
+                if (_imageButtonDock == null)
+                    _imageButtonDock = Resources.DockPane_Dock;
+
+                return _imageButtonDock;
+            }
+        }
+
+        private InertButton m_buttonAutoHide;
+        private InertButton ButtonAutoHide
+        {
+            get
+            {
+                if (m_buttonAutoHide == null)
+                {
+                    m_buttonAutoHide = new InertButton(this, ImageButtonDock, ImageButtonAutoHide);
+                    m_toolTip.SetToolTip(m_buttonAutoHide, ToolTipAutoHide);
+                    m_buttonAutoHide.Click += new EventHandler(AutoHide_Click);
+                    Controls.Add(m_buttonAutoHide);
+                }
+
+                return m_buttonAutoHide;
+            }
+        }
+
+        private static Bitmap _imageButtonOptions;
+        private static Bitmap ImageButtonOptions
+        {
+            get
+            {
+                if (_imageButtonOptions == null)
+                    _imageButtonOptions = Resources.DockPane_Option;
+
+                return _imageButtonOptions;
+            }
+        }
+
+        private InertButton m_buttonOptions;
+        private InertButton ButtonOptions
+        {
+            get
+            {
+                if (m_buttonOptions == null)
+                {
+                    m_buttonOptions = new InertButton(this, ImageButtonOptions, ImageButtonOptions);
+                    m_toolTip.SetToolTip(m_buttonOptions, ToolTipOptions);
+                    m_buttonOptions.Click += new EventHandler(Options_Click);
+                    Controls.Add(m_buttonOptions);
+                }
+                return m_buttonOptions;
+            }
+        }
+
+        private IContainer m_components;
+        private IContainer Components
+        {
+            get { return m_components; }
+        }
+
+		private ToolTip m_toolTip;
+
+		public VS2005DockPaneCaption(DockPane pane) : base(pane)
+		{
+			SuspendLayout();
+
+            m_components = new Container();
+            m_toolTip = new ToolTip(Components);
+
+			ResumeLayout();
+		}
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+                Components.Dispose();
+            base.Dispose(disposing);
+        }
+
+		private static int TextGapTop
+		{
+			get	{	return _TextGapTop;	}
+		}
+
+        public Font TextFont
+        {
+            get { return DockPane.DockPanel.Skin.DockPaneStripSkin.TextFont; }
+        }
+
+		private static int TextGapBottom
+		{
+			get	{	return _TextGapBottom;	}
+		}
+
+		private static int TextGapLeft
+		{
+			get	{	return _TextGapLeft;	}
+		}
+
+		private static int TextGapRight
+		{
+			get	{	return _TextGapRight;	}
+		}
+
+		private static int ButtonGapTop
+		{
+			get	{	return _ButtonGapTop;	}
+		}
+
+		private static int ButtonGapBottom
+		{
+			get	{	return _ButtonGapBottom;	}
+		}
+
+		private static int ButtonGapLeft
+		{
+			get	{	return _ButtonGapLeft;	}
+		}
+
+		private static int ButtonGapRight
+		{
+			get	{	return _ButtonGapRight;	}
+		}
+
+		private static int ButtonGapBetween
+		{
+			get	{	return _ButtonGapBetween;	}
+		}
+
+		private static string _toolTipClose;
+		private static string ToolTipClose
+		{
+			get
+			{	
+				if (_toolTipClose == null)
+					_toolTipClose = Strings.DockPaneCaption_ToolTipClose;
+				return _toolTipClose;
+			}
+		}
+
+        private static string _toolTipOptions;
+        private static string ToolTipOptions
+        {
+            get
+            {
+                if (_toolTipOptions == null)
+                    _toolTipOptions = Strings.DockPaneCaption_ToolTipOptions;
+
+                return _toolTipOptions;
+            }
+        }
+
+		private static string _toolTipAutoHide;
+		private static string ToolTipAutoHide
+		{
+			get
+			{	
+				if (_toolTipAutoHide == null)
+					_toolTipAutoHide = Strings.DockPaneCaption_ToolTipAutoHide;
+				return _toolTipAutoHide;
+			}
+		}
+
+        private static Blend _activeBackColorGradientBlend;
+        private static Blend ActiveBackColorGradientBlend
+        {
+            get
+            {
+                if (_activeBackColorGradientBlend == null)
+                {
+                    Blend blend = new Blend(2);
+
+                    blend.Factors = new float[]{0.5F, 1.0F};
+                    blend.Positions = new float[]{0.0F, 1.0F};
+                    _activeBackColorGradientBlend = blend;
+                }
+
+                return _activeBackColorGradientBlend;
+            }
+        }
+
+        private Color TextColor
+        {
+            get
+            {
+                if (DockPane.IsActivated)
+                    return DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveCaptionGradient.TextColor;
+                else
+                    return DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveCaptionGradient.TextColor;
+            }
+        }
+
+		private static TextFormatFlags _textFormat =
+            TextFormatFlags.SingleLine |
+            TextFormatFlags.EndEllipsis |
+            TextFormatFlags.VerticalCenter;
+		private TextFormatFlags TextFormat
+		{
+            get
+            {
+                if (RightToLeft == RightToLeft.No)
+                    return _textFormat;
+                else
+                    return _textFormat | TextFormatFlags.RightToLeft | TextFormatFlags.Right;
+            }
+		}
+
+		protected internal override int MeasureHeight()
+		{
+			int height = TextFont.Height + TextGapTop + TextGapBottom;
+
+			if (height < ButtonClose.Image.Height + ButtonGapTop + ButtonGapBottom)
+				height = ButtonClose.Image.Height + ButtonGapTop + ButtonGapBottom;
+
+			return height;
+		}
+
+		protected override void OnPaint(PaintEventArgs e)
+		{
+			base.OnPaint (e);
+			DrawCaption(e.Graphics);
+		}
+
+		private void DrawCaption(Graphics g)
+		{
+            if (ClientRectangle.Width == 0 || ClientRectangle.Height == 0)
+                return;
+
+            if (DockPane.IsActivated)
+            {
+                Color startColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveCaptionGradient.StartColor;
+                Color endColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveCaptionGradient.EndColor;
+                LinearGradientMode gradientMode = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveCaptionGradient.LinearGradientMode;
+                using (LinearGradientBrush brush = new LinearGradientBrush(ClientRectangle, startColor, endColor, gradientMode))
+                {
+                    brush.Blend = ActiveBackColorGradientBlend;
+                    g.FillRectangle(brush, ClientRectangle);
+                }
+            }
+            else
+            {
+                Color startColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveCaptionGradient.StartColor;
+                Color endColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveCaptionGradient.EndColor;
+                LinearGradientMode gradientMode = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveCaptionGradient.LinearGradientMode;
+                using (LinearGradientBrush brush = new LinearGradientBrush(ClientRectangle, startColor, endColor, gradientMode))
+                {
+                    g.FillRectangle(brush, ClientRectangle);
+                }
+            }
+
+			Rectangle rectCaption = ClientRectangle;
+
+			Rectangle rectCaptionText = rectCaption;
+            rectCaptionText.X += TextGapLeft;
+            rectCaptionText.Width -= TextGapLeft + TextGapRight;
+            rectCaptionText.Width -= ButtonGapLeft + ButtonClose.Width + ButtonGapRight;
+            if (ShouldShowAutoHideButton)
+                rectCaptionText.Width -= ButtonAutoHide.Width + ButtonGapBetween;
+            if (HasTabPageContextMenu)
+                rectCaptionText.Width -= ButtonOptions.Width + ButtonGapBetween;
+			rectCaptionText.Y += TextGapTop;
+			rectCaptionText.Height -= TextGapTop + TextGapBottom;
+
+            Color colorText;
+            if (DockPane.IsActivated)
+                colorText = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveCaptionGradient.TextColor;
+            else
+                colorText = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveCaptionGradient.TextColor;
+
+            TextRenderer.DrawText(g, DockPane.CaptionText, TextFont, DrawHelper.RtlTransform(this, rectCaptionText), colorText, TextFormat);
+		}
+
+		protected override void OnLayout(LayoutEventArgs levent)
+		{
+			SetButtonsPosition();
+			base.OnLayout (levent);
+		}
+
+		protected override void OnRefreshChanges()
+		{
+			SetButtons();
+			Invalidate();
+		}
+
+		private bool CloseButtonEnabled
+		{
+			get	{	return (DockPane.ActiveContent != null)? DockPane.ActiveContent.DockHandler.CloseButton : false;	}
+		}
+
+        /// <summary>
+        /// Determines whether the close button is visible on the content
+        /// </summary>
+        private bool CloseButtonVisible
+        {
+            get { return (DockPane.ActiveContent != null) ? DockPane.ActiveContent.DockHandler.CloseButtonVisible : false; }
+        }
+
+		private bool ShouldShowAutoHideButton
+		{
+			get	{	return !DockPane.IsFloat;	}
+		}
+
+		private void SetButtons()
+		{
+			ButtonClose.Enabled = CloseButtonEnabled;
+            ButtonClose.Visible = CloseButtonVisible;
+			ButtonAutoHide.Visible = ShouldShowAutoHideButton;
+            ButtonOptions.Visible = HasTabPageContextMenu;
+            ButtonClose.RefreshChanges();
+            ButtonAutoHide.RefreshChanges();
+            ButtonOptions.RefreshChanges();
+			
+			SetButtonsPosition();
+		}
+
+		private void SetButtonsPosition()
+		{
+			// set the size and location for close and auto-hide buttons
+			Rectangle rectCaption = ClientRectangle;
+			int buttonWidth = ButtonClose.Image.Width;
+			int buttonHeight = ButtonClose.Image.Height;
+			int height = rectCaption.Height - ButtonGapTop - ButtonGapBottom;
+			if (buttonHeight < height)
+			{
+				buttonWidth = buttonWidth * (height / buttonHeight);
+				buttonHeight = height;
+			}
+			Size buttonSize = new Size(buttonWidth, buttonHeight);
+			int x = rectCaption.X + rectCaption.Width - 1 - ButtonGapRight - m_buttonClose.Width;
+			int y = rectCaption.Y + ButtonGapTop;
+			Point point = new Point(x, y);
+            ButtonClose.Bounds = DrawHelper.RtlTransform(this, new Rectangle(point, buttonSize));
+
+            // If the close button is not visible draw the auto hide button overtop.
+            // Otherwise it is drawn to the left of the close button.
+            if (CloseButtonVisible)
+			    point.Offset(-(buttonWidth + ButtonGapBetween), 0);
+            
+            ButtonAutoHide.Bounds = DrawHelper.RtlTransform(this, new Rectangle(point, buttonSize));
+            if (ShouldShowAutoHideButton)
+                point.Offset(-(buttonWidth + ButtonGapBetween), 0);
+            ButtonOptions.Bounds = DrawHelper.RtlTransform(this, new Rectangle(point, buttonSize));
+		}
+
+		private void Close_Click(object sender, EventArgs e)
+		{
+			DockPane.CloseActiveContent();
+		}
+
+		private void AutoHide_Click(object sender, EventArgs e)
+		{
+			DockPane.DockState = DockHelper.ToggleAutoHideState(DockPane.DockState);
+            if (DockHelper.IsDockStateAutoHide(DockPane.DockState))
+            {
+                DockPane.DockPanel.ActiveAutoHideContent = null;
+                DockPane.NestedDockingStatus.NestedPanes.SwitchPaneWithFirstChild(DockPane);
+            }
+		}
+
+        private void Options_Click(object sender, EventArgs e)
+        {
+            ShowTabPageContextMenu(PointToClient(Control.MousePosition));
+        }
+
+        protected override void OnRightToLeftChanged(EventArgs e)
+        {
+            base.OnRightToLeftChanged(e);
+            PerformLayout();
+        }
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/VS2005DockPaneStrip.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/VS2005DockPaneStrip.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/VS2005DockPaneStrip.cs	(revision 8616)
@@ -0,0 +1,1492 @@
+using System;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Windows.Forms;
+using System.ComponentModel;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    internal class VS2005DockPaneStrip : DockPaneStripBase
+    {
+        private class TabVS2005 : Tab
+        {
+            public TabVS2005(IDockContent content)
+                : base(content)
+            {
+            }
+
+            private int m_tabX;
+            public int TabX
+            {
+                get { return m_tabX; }
+                set { m_tabX = value; }
+            }
+
+            private int m_tabWidth;
+            public int TabWidth
+            {
+                get { return m_tabWidth; }
+                set { m_tabWidth = value; }
+            }
+
+            private int m_maxWidth;
+            public int MaxWidth
+            {
+                get { return m_maxWidth; }
+                set { m_maxWidth = value; }
+            }
+
+            private bool m_flag;
+            protected internal bool Flag
+            {
+                get { return m_flag; }
+                set { m_flag = value; }
+            }
+        }
+
+        protected internal override DockPaneStripBase.Tab CreateTab(IDockContent content)
+        {
+            return new TabVS2005(content);
+        }
+
+        private sealed class InertButton : InertButtonBase
+        {
+            private Bitmap m_image0, m_image1;
+
+            public InertButton(Bitmap image0, Bitmap image1)
+                : base()
+            {
+                m_image0 = image0;
+                m_image1 = image1;
+            }
+
+            private int m_imageCategory = 0;
+            public int ImageCategory
+            {
+                get { return m_imageCategory; }
+                set
+                {
+                    if (m_imageCategory == value)
+                        return;
+
+                    m_imageCategory = value;
+                    Invalidate();
+                }
+            }
+
+            public override Bitmap Image
+            {
+                get { return ImageCategory == 0 ? m_image0 : m_image1; }
+            }
+        }
+
+        #region Constants
+
+        private const int _ToolWindowStripGapTop = 0;
+        private const int _ToolWindowStripGapBottom = 1;
+        private const int _ToolWindowStripGapLeft = 0;
+        private const int _ToolWindowStripGapRight = 0;
+        private const int _ToolWindowImageHeight = 16;
+        private const int _ToolWindowImageWidth = 16;
+        private const int _ToolWindowImageGapTop = 3;
+        private const int _ToolWindowImageGapBottom = 1;
+        private const int _ToolWindowImageGapLeft = 2;
+        private const int _ToolWindowImageGapRight = 0;
+        private const int _ToolWindowTextGapRight = 3;
+        private const int _ToolWindowTabSeperatorGapTop = 3;
+        private const int _ToolWindowTabSeperatorGapBottom = 3;
+
+        private const int _DocumentStripGapTop = 0;
+        private const int _DocumentStripGapBottom = 1;
+        private const int _DocumentTabMaxWidth = 200;
+        private const int _DocumentButtonGapTop = 4;
+        private const int _DocumentButtonGapBottom = 4;
+        private const int _DocumentButtonGapBetween = 0;
+        private const int _DocumentButtonGapRight = 3;
+        private const int _DocumentTabGapTop = 3;
+        private const int _DocumentTabGapLeft = 3;
+        private const int _DocumentTabGapRight = 3;
+        private const int _DocumentIconGapBottom = 2;
+        private const int _DocumentIconGapLeft = 8;
+        private const int _DocumentIconGapRight = 0;
+        private const int _DocumentIconHeight = 16;
+        private const int _DocumentIconWidth = 16;
+        private const int _DocumentTextGapRight = 3;
+
+        #endregion
+
+        #region Members
+
+        private ContextMenuStrip m_selectMenu;
+        private static Bitmap m_imageButtonClose;
+        private InertButton m_buttonClose;
+        private static Bitmap m_imageButtonWindowList;
+        private static Bitmap m_imageButtonWindowListOverflow;
+        private InertButton m_buttonWindowList;
+        private IContainer m_components;
+        private ToolTip m_toolTip;
+        private Font m_font;
+        private Font m_boldFont;
+        private int m_startDisplayingTab = 0;
+        private int m_endDisplayingTab = 0;
+        private int m_firstDisplayingTab = 0;
+        private bool m_documentTabsOverflow = false;
+        private static string m_toolTipSelect;
+        private static string m_toolTipClose;
+        private bool m_closeButtonVisible = false;
+
+        #endregion
+
+        #region Properties
+
+        private Rectangle TabStripRectangle
+        {
+            get
+            {
+                if (Appearance == DockPane.AppearanceStyle.Document)
+                    return TabStripRectangle_Document;
+                else
+                    return TabStripRectangle_ToolWindow;
+            }
+        }
+
+        private Rectangle TabStripRectangle_ToolWindow
+        {
+            get
+            {
+                Rectangle rect = ClientRectangle;
+                return new Rectangle(rect.X, rect.Top + ToolWindowStripGapTop, rect.Width, rect.Height - ToolWindowStripGapTop - ToolWindowStripGapBottom);
+            }
+        }
+
+        private Rectangle TabStripRectangle_Document
+        {
+            get
+            {
+                Rectangle rect = ClientRectangle;
+                return new Rectangle(rect.X, rect.Top + DocumentStripGapTop, rect.Width, rect.Height - DocumentStripGapTop - ToolWindowStripGapBottom);
+            }
+        }
+
+        private Rectangle TabsRectangle
+        {
+            get
+            {
+                if (Appearance == DockPane.AppearanceStyle.ToolWindow)
+                    return TabStripRectangle;
+
+                Rectangle rectWindow = TabStripRectangle;
+                int x = rectWindow.X;
+                int y = rectWindow.Y;
+                int width = rectWindow.Width;
+                int height = rectWindow.Height;
+
+                x += DocumentTabGapLeft;
+                width -= DocumentTabGapLeft +
+                    DocumentTabGapRight +
+                    DocumentButtonGapRight +
+                    ButtonClose.Width +
+                    ButtonWindowList.Width +
+                    2 * DocumentButtonGapBetween;
+
+                return new Rectangle(x, y, width, height);
+            }
+        }
+
+        private ContextMenuStrip SelectMenu
+        {
+            get { return m_selectMenu; }
+        }
+
+        private static Bitmap ImageButtonClose
+        {
+            get
+            {
+                if (m_imageButtonClose == null)
+                    m_imageButtonClose = Resources.DockPane_Close;
+
+                return m_imageButtonClose;
+            }
+        }
+
+        private InertButton ButtonClose
+        {
+            get
+            {
+                if (m_buttonClose == null)
+                {
+                    m_buttonClose = new InertButton(ImageButtonClose, ImageButtonClose);
+                    m_toolTip.SetToolTip(m_buttonClose, ToolTipClose);
+                    m_buttonClose.Click += new EventHandler(Close_Click);
+                    Controls.Add(m_buttonClose);
+                }
+
+                return m_buttonClose;
+            }
+        }
+
+        private static Bitmap ImageButtonWindowList
+        {
+            get
+            {
+                if (m_imageButtonWindowList == null)
+                    m_imageButtonWindowList = Resources.DockPane_Option;
+
+                return m_imageButtonWindowList;
+            }
+        }
+
+        private static Bitmap ImageButtonWindowListOverflow
+        {
+            get
+            {
+                if (m_imageButtonWindowListOverflow == null)
+                    m_imageButtonWindowListOverflow = Resources.DockPane_OptionOverflow;
+
+                return m_imageButtonWindowListOverflow;
+            }
+        }
+
+        private InertButton ButtonWindowList
+        {
+            get
+            {
+                if (m_buttonWindowList == null)
+                {
+                    m_buttonWindowList = new InertButton(ImageButtonWindowList, ImageButtonWindowListOverflow);
+                    m_toolTip.SetToolTip(m_buttonWindowList, ToolTipSelect);
+                    m_buttonWindowList.Click += new EventHandler(WindowList_Click);
+                    Controls.Add(m_buttonWindowList);
+                }
+
+                return m_buttonWindowList;
+            }
+        }
+
+        private static GraphicsPath GraphicsPath
+        {
+            get { return VS2005AutoHideStrip.GraphicsPath; }
+        }
+
+        private IContainer Components
+        {
+            get { return m_components; }
+        }
+
+        public Font TextFont
+        {
+            get { return DockPane.DockPanel.Skin.DockPaneStripSkin.TextFont; }
+        }
+
+        private Font BoldFont
+        {
+            get
+            {
+                if (IsDisposed)
+                    return null;
+
+                if (m_boldFont == null)
+                {
+                    m_font = TextFont;
+                    m_boldFont = new Font(TextFont, FontStyle.Bold);
+                }
+                else if (m_font != TextFont)
+                {
+                    m_boldFont.Dispose();
+                    m_font = TextFont;
+                    m_boldFont = new Font(TextFont, FontStyle.Bold);
+                }
+
+                return m_boldFont;
+            }
+        }
+
+        private int StartDisplayingTab
+        {
+            get { return m_startDisplayingTab; }
+            set
+            {
+                m_startDisplayingTab = value;
+                Invalidate();
+            }
+        }
+
+        private int EndDisplayingTab
+        {
+            get { return m_endDisplayingTab; }
+            set { m_endDisplayingTab = value; }
+        }
+
+        private int FirstDisplayingTab
+        {
+            get { return m_firstDisplayingTab; }
+            set { m_firstDisplayingTab = value; }
+        }
+
+        private bool DocumentTabsOverflow
+        {
+            set
+            {
+                if (m_documentTabsOverflow == value)
+                    return;
+
+                m_documentTabsOverflow = value;
+                if (value)
+                    ButtonWindowList.ImageCategory = 1;
+                else
+                    ButtonWindowList.ImageCategory = 0;
+            }
+        }
+
+        #region Customizable Properties
+
+        private static int ToolWindowStripGapTop
+        {
+            get { return _ToolWindowStripGapTop; }
+        }
+
+        private static int ToolWindowStripGapBottom
+        {
+            get { return _ToolWindowStripGapBottom; }
+        }
+
+        private static int ToolWindowStripGapLeft
+        {
+            get { return _ToolWindowStripGapLeft; }
+        }
+
+        private static int ToolWindowStripGapRight
+        {
+            get { return _ToolWindowStripGapRight; }
+        }
+
+        private static int ToolWindowImageHeight
+        {
+            get { return _ToolWindowImageHeight; }
+        }
+
+        private static int ToolWindowImageWidth
+        {
+            get { return _ToolWindowImageWidth; }
+        }
+
+        private static int ToolWindowImageGapTop
+        {
+            get { return _ToolWindowImageGapTop; }
+        }
+
+        private static int ToolWindowImageGapBottom
+        {
+            get { return _ToolWindowImageGapBottom; }
+        }
+
+        private static int ToolWindowImageGapLeft
+        {
+            get { return _ToolWindowImageGapLeft; }
+        }
+
+        private static int ToolWindowImageGapRight
+        {
+            get { return _ToolWindowImageGapRight; }
+        }
+
+        private static int ToolWindowTextGapRight
+        {
+            get { return _ToolWindowTextGapRight; }
+        }
+
+        private static int ToolWindowTabSeperatorGapTop
+        {
+            get { return _ToolWindowTabSeperatorGapTop; }
+        }
+
+        private static int ToolWindowTabSeperatorGapBottom
+        {
+            get { return _ToolWindowTabSeperatorGapBottom; }
+        }
+
+        private static string ToolTipClose
+        {
+            get
+            {
+                if (m_toolTipClose == null)
+                    m_toolTipClose = Strings.DockPaneStrip_ToolTipClose;
+                return m_toolTipClose;
+            }
+        }
+
+        private static string ToolTipSelect
+        {
+            get
+            {
+                if (m_toolTipSelect == null)
+                    m_toolTipSelect = Strings.DockPaneStrip_ToolTipWindowList;
+                return m_toolTipSelect;
+            }
+        }
+
+        private TextFormatFlags ToolWindowTextFormat
+        {
+            get
+            {
+                TextFormatFlags textFormat = TextFormatFlags.EndEllipsis |
+                    TextFormatFlags.HorizontalCenter |
+                    TextFormatFlags.SingleLine |
+                    TextFormatFlags.VerticalCenter;
+                if (RightToLeft == RightToLeft.Yes)
+                    return textFormat | TextFormatFlags.RightToLeft | TextFormatFlags.Right;
+                else
+                    return textFormat;
+            }
+        }
+
+        private static int DocumentStripGapTop
+        {
+            get { return _DocumentStripGapTop; }
+        }
+
+        private static int DocumentStripGapBottom
+        {
+            get { return _DocumentStripGapBottom; }
+        }
+
+        private TextFormatFlags DocumentTextFormat
+        {
+            get
+            {
+                TextFormatFlags textFormat = TextFormatFlags.EndEllipsis |
+                    TextFormatFlags.SingleLine |
+                    TextFormatFlags.VerticalCenter |
+                    TextFormatFlags.HorizontalCenter;
+                if (RightToLeft == RightToLeft.Yes)
+                    return textFormat | TextFormatFlags.RightToLeft;
+                else
+                    return textFormat;
+            }
+        }
+
+        private static int DocumentTabMaxWidth
+        {
+            get { return _DocumentTabMaxWidth; }
+        }
+
+        private static int DocumentButtonGapTop
+        {
+            get { return _DocumentButtonGapTop; }
+        }
+
+        private static int DocumentButtonGapBottom
+        {
+            get { return _DocumentButtonGapBottom; }
+        }
+
+        private static int DocumentButtonGapBetween
+        {
+            get { return _DocumentButtonGapBetween; }
+        }
+
+        private static int DocumentButtonGapRight
+        {
+            get { return _DocumentButtonGapRight; }
+        }
+
+        private static int DocumentTabGapTop
+        {
+            get { return _DocumentTabGapTop; }
+        }
+
+        private static int DocumentTabGapLeft
+        {
+            get { return _DocumentTabGapLeft; }
+        }
+
+        private static int DocumentTabGapRight
+        {
+            get { return _DocumentTabGapRight; }
+        }
+
+        private static int DocumentIconGapBottom
+        {
+            get { return _DocumentIconGapBottom; }
+        }
+
+        private static int DocumentIconGapLeft
+        {
+            get { return _DocumentIconGapLeft; }
+        }
+
+        private static int DocumentIconGapRight
+        {
+            get { return _DocumentIconGapRight; }
+        }
+
+        private static int DocumentIconWidth
+        {
+            get { return _DocumentIconWidth; }
+        }
+
+        private static int DocumentIconHeight
+        {
+            get { return _DocumentIconHeight; }
+        }
+
+        private static int DocumentTextGapRight
+        {
+            get { return _DocumentTextGapRight; }
+        }
+
+        private static Pen PenToolWindowTabBorder
+        {
+            get { return SystemPens.GrayText; }
+        }
+
+        private static Pen PenDocumentTabActiveBorder
+        {
+            get { return SystemPens.ControlDarkDark; }
+        }
+
+        private static Pen PenDocumentTabInactiveBorder
+        {
+            get { return SystemPens.GrayText; }
+        }
+
+        #endregion
+
+        #endregion
+
+        public VS2005DockPaneStrip(DockPane pane)
+            : base(pane)
+        {
+            SetStyle(ControlStyles.ResizeRedraw |
+                ControlStyles.UserPaint |
+                ControlStyles.AllPaintingInWmPaint |
+                ControlStyles.OptimizedDoubleBuffer, true);
+
+            SuspendLayout();
+
+            m_components = new Container();
+            m_toolTip = new ToolTip(Components);
+            m_selectMenu = new ContextMenuStrip(Components);
+
+            ResumeLayout();
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                Components.Dispose();
+                if (m_boldFont != null)
+                {
+                    m_boldFont.Dispose();
+                    m_boldFont = null;
+                }
+            }
+            base.Dispose(disposing);
+        }
+
+        protected internal override int MeasureHeight()
+        {
+            if (Appearance == DockPane.AppearanceStyle.ToolWindow)
+                return MeasureHeight_ToolWindow();
+            else
+                return MeasureHeight_Document();
+        }
+
+        private int MeasureHeight_ToolWindow()
+        {
+            if (DockPane.IsAutoHide || Tabs.Count <= 1)
+                return 0;
+
+            int height = Math.Max(TextFont.Height, ToolWindowImageHeight + ToolWindowImageGapTop + ToolWindowImageGapBottom)
+                + ToolWindowStripGapTop + ToolWindowStripGapBottom;
+
+            return height;
+        }
+
+        private int MeasureHeight_Document()
+        {
+            int height = Math.Max(TextFont.Height + DocumentTabGapTop,
+                ButtonClose.Height + DocumentButtonGapTop + DocumentButtonGapBottom)
+                + DocumentStripGapBottom + DocumentStripGapTop;
+
+            return height;
+        }
+
+        protected override void OnPaint(PaintEventArgs e)
+        {
+            Rectangle rect = TabsRectangle;
+
+            if (Appearance == DockPane.AppearanceStyle.Document)
+            {
+                rect.X -= DocumentTabGapLeft;
+
+                // Add these values back in so that the DockStrip color is drawn
+                // beneath the close button and window list button.
+                rect.Width += DocumentTabGapLeft +
+                    DocumentTabGapRight +
+                    DocumentButtonGapRight +
+                    ButtonClose.Width +
+                    ButtonWindowList.Width;
+
+                // It is possible depending on the DockPanel DocumentStyle to have
+                // a Document without a DockStrip.
+                if (rect.Width > 0 && rect.Height > 0)
+                {
+                    Color startColor = DockPane.DockPanel.Skin.DockPaneStripSkin.DocumentGradient.DockStripGradient.StartColor;
+                    Color endColor = DockPane.DockPanel.Skin.DockPaneStripSkin.DocumentGradient.DockStripGradient.EndColor;
+                    LinearGradientMode gradientMode = DockPane.DockPanel.Skin.DockPaneStripSkin.DocumentGradient.DockStripGradient.LinearGradientMode;
+                    using (LinearGradientBrush brush = new LinearGradientBrush(rect, startColor, endColor, gradientMode))
+                    {
+                        e.Graphics.FillRectangle(brush, rect);
+                    }
+                }
+            }
+            else
+            {
+                Color startColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.DockStripGradient.StartColor;
+                Color endColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.DockStripGradient.EndColor;
+                LinearGradientMode gradientMode = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.DockStripGradient.LinearGradientMode;
+                using (LinearGradientBrush brush = new LinearGradientBrush(rect, startColor, endColor, gradientMode))
+                {
+                    e.Graphics.FillRectangle(brush, rect);
+                }
+            }
+            base.OnPaint(e);
+            CalculateTabs();
+            if (Appearance == DockPane.AppearanceStyle.Document && DockPane.ActiveContent != null)
+            {
+                if (EnsureDocumentTabVisible(DockPane.ActiveContent, false))
+                    CalculateTabs();
+            }
+
+            DrawTabStrip(e.Graphics);
+        }
+
+        protected override void OnRefreshChanges()
+        {
+            SetInertButtons();
+            Invalidate();
+        }
+
+        protected internal override GraphicsPath GetOutline(int index)
+        {
+
+            if (Appearance == DockPane.AppearanceStyle.Document)
+                return GetOutline_Document(index);
+            else
+                return GetOutline_ToolWindow(index);
+
+        }
+
+        private GraphicsPath GetOutline_Document(int index)
+        {
+            Rectangle rectTab = GetTabRectangle(index);
+            rectTab.X -= rectTab.Height / 2;
+            rectTab.Intersect(TabsRectangle);
+            rectTab = RectangleToScreen(DrawHelper.RtlTransform(this, rectTab));
+            Rectangle rectPaneClient = DockPane.RectangleToScreen(DockPane.ClientRectangle);
+
+            GraphicsPath path = new GraphicsPath();
+            GraphicsPath pathTab = GetTabOutline_Document(Tabs[index], true, true, true);
+            path.AddPath(pathTab, true);
+
+            if (DockPane.DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+            {
+                path.AddLine(rectTab.Right, rectTab.Top, rectPaneClient.Right, rectTab.Top);
+                path.AddLine(rectPaneClient.Right, rectTab.Top, rectPaneClient.Right, rectPaneClient.Top);
+                path.AddLine(rectPaneClient.Right, rectPaneClient.Top, rectPaneClient.Left, rectPaneClient.Top);
+                path.AddLine(rectPaneClient.Left, rectPaneClient.Top, rectPaneClient.Left, rectTab.Top);
+                path.AddLine(rectPaneClient.Left, rectTab.Top, rectTab.Right, rectTab.Top);
+            }
+            else
+            {
+                path.AddLine(rectTab.Right, rectTab.Bottom, rectPaneClient.Right, rectTab.Bottom);
+                path.AddLine(rectPaneClient.Right, rectTab.Bottom, rectPaneClient.Right, rectPaneClient.Bottom);
+                path.AddLine(rectPaneClient.Right, rectPaneClient.Bottom, rectPaneClient.Left, rectPaneClient.Bottom);
+                path.AddLine(rectPaneClient.Left, rectPaneClient.Bottom, rectPaneClient.Left, rectTab.Bottom);
+                path.AddLine(rectPaneClient.Left, rectTab.Bottom, rectTab.Right, rectTab.Bottom);
+            }
+            return path;
+        }
+
+        private GraphicsPath GetOutline_ToolWindow(int index)
+        {
+            Rectangle rectTab = GetTabRectangle(index);
+            rectTab.Intersect(TabsRectangle);
+            rectTab = RectangleToScreen(DrawHelper.RtlTransform(this, rectTab));
+            Rectangle rectPaneClient = DockPane.RectangleToScreen(DockPane.ClientRectangle);
+
+            GraphicsPath path = new GraphicsPath();
+            GraphicsPath pathTab = GetTabOutline(Tabs[index], true, true);
+            path.AddPath(pathTab, true);
+            path.AddLine(rectTab.Left, rectTab.Top, rectPaneClient.Left, rectTab.Top);
+            path.AddLine(rectPaneClient.Left, rectTab.Top, rectPaneClient.Left, rectPaneClient.Top);
+            path.AddLine(rectPaneClient.Left, rectPaneClient.Top, rectPaneClient.Right, rectPaneClient.Top);
+            path.AddLine(rectPaneClient.Right, rectPaneClient.Top, rectPaneClient.Right, rectTab.Top);
+            path.AddLine(rectPaneClient.Right, rectTab.Top, rectTab.Right, rectTab.Top);
+            return path;
+        }
+
+        private void CalculateTabs()
+        {
+            if (Appearance == DockPane.AppearanceStyle.ToolWindow)
+                CalculateTabs_ToolWindow();
+            else
+                CalculateTabs_Document();
+        }
+
+        private void CalculateTabs_ToolWindow()
+        {
+            if (Tabs.Count <= 1 || DockPane.IsAutoHide)
+                return;
+
+            Rectangle rectTabStrip = TabStripRectangle;
+
+            // Calculate tab widths
+            int countTabs = Tabs.Count;
+            foreach (TabVS2005 tab in Tabs)
+            {
+                tab.MaxWidth = GetMaxTabWidth(Tabs.IndexOf(tab));
+                tab.Flag = false;
+            }
+
+            // Set tab whose max width less than average width
+            bool anyWidthWithinAverage = true;
+            int totalWidth = rectTabStrip.Width - ToolWindowStripGapLeft - ToolWindowStripGapRight;
+            int totalAllocatedWidth = 0;
+            int averageWidth = totalWidth / countTabs;
+            int remainedTabs = countTabs;
+            for (anyWidthWithinAverage = true; anyWidthWithinAverage && remainedTabs > 0; )
+            {
+                anyWidthWithinAverage = false;
+                foreach (TabVS2005 tab in Tabs)
+                {
+                    if (tab.Flag)
+                        continue;
+
+                    if (tab.MaxWidth <= averageWidth)
+                    {
+                        tab.Flag = true;
+                        tab.TabWidth = tab.MaxWidth;
+                        totalAllocatedWidth += tab.TabWidth;
+                        anyWidthWithinAverage = true;
+                        remainedTabs--;
+                    }
+                }
+                if (remainedTabs != 0)
+                    averageWidth = (totalWidth - totalAllocatedWidth) / remainedTabs;
+            }
+
+            // If any tab width not set yet, set it to the average width
+            if (remainedTabs > 0)
+            {
+                int roundUpWidth = (totalWidth - totalAllocatedWidth) - (averageWidth * remainedTabs);
+                foreach (TabVS2005 tab in Tabs)
+                {
+                    if (tab.Flag)
+                        continue;
+
+                    tab.Flag = true;
+                    if (roundUpWidth > 0)
+                    {
+                        tab.TabWidth = averageWidth + 1;
+                        roundUpWidth--;
+                    }
+                    else
+                        tab.TabWidth = averageWidth;
+                }
+            }
+
+            // Set the X position of the tabs
+            int x = rectTabStrip.X + ToolWindowStripGapLeft;
+            foreach (TabVS2005 tab in Tabs)
+            {
+                tab.TabX = x;
+                x += tab.TabWidth;
+            }
+        }
+
+        private bool CalculateDocumentTab(Rectangle rectTabStrip, ref int x, int index)
+        {
+            bool overflow = false;
+
+            TabVS2005 tab = Tabs[index] as TabVS2005;
+            tab.MaxWidth = GetMaxTabWidth(index);
+            int width = Math.Min(tab.MaxWidth, DocumentTabMaxWidth);
+            if (x + width < rectTabStrip.Right || index == StartDisplayingTab)
+            {
+                tab.TabX = x;
+                tab.TabWidth = width;
+                EndDisplayingTab = index;
+            }
+            else
+            {
+                tab.TabX = 0;
+                tab.TabWidth = 0;
+                overflow = true;
+            }
+            x += width;
+
+            return overflow;
+        }
+
+        /// <summary>
+        /// Calculate which tabs are displayed and in what order.
+        /// </summary>
+        private void CalculateTabs_Document()
+        {
+            if (m_startDisplayingTab >= Tabs.Count)
+                m_startDisplayingTab = 0;
+
+            Rectangle rectTabStrip = TabsRectangle;
+
+            int x = rectTabStrip.X + rectTabStrip.Height / 2;
+            bool overflow = false;
+
+            // Originally all new documents that were considered overflow
+            // (not enough pane strip space to show all tabs) were added to
+            // the far left (assuming not right to left) and the tabs on the
+            // right were dropped from view. If StartDisplayingTab is not 0
+            // then we are dealing with making sure a specific tab is kept in focus.
+            if (m_startDisplayingTab > 0)
+            {
+                int tempX = x;
+                TabVS2005 tab = Tabs[m_startDisplayingTab] as TabVS2005;
+                tab.MaxWidth = GetMaxTabWidth(m_startDisplayingTab);
+
+                // Add the active tab and tabs to the left
+                for (int i = StartDisplayingTab; i >= 0; i--)
+                    CalculateDocumentTab(rectTabStrip, ref tempX, i);
+
+                // Store which tab is the first one displayed so that it
+                // will be drawn correctly (without part of the tab cut off)
+                FirstDisplayingTab = EndDisplayingTab;
+
+                tempX = x; // Reset X location because we are starting over
+
+                // Start with the first tab displayed - name is a little misleading.
+                // Loop through each tab and set its location. If there is not enough
+                // room for all of them overflow will be returned.
+                for (int i = EndDisplayingTab; i < Tabs.Count; i++)
+                    overflow = CalculateDocumentTab(rectTabStrip, ref tempX, i);
+
+                // If not all tabs are shown then we have an overflow.
+                if (FirstDisplayingTab != 0)
+                    overflow = true;
+            }
+            else
+            {
+                for (int i = StartDisplayingTab; i < Tabs.Count; i++)
+                    overflow = CalculateDocumentTab(rectTabStrip, ref x, i);
+                for (int i = 0; i < StartDisplayingTab; i++)
+                    overflow = CalculateDocumentTab(rectTabStrip, ref x, i);
+
+                FirstDisplayingTab = StartDisplayingTab;
+            }
+
+            if (!overflow)
+            {
+                m_startDisplayingTab = 0;
+                FirstDisplayingTab = 0;
+                x = rectTabStrip.X + rectTabStrip.Height / 2;
+                foreach (TabVS2005 tab in Tabs)
+                {
+                    tab.TabX = x;
+                    x += tab.TabWidth;
+                }
+            }
+            DocumentTabsOverflow = overflow;
+        }
+
+        protected internal override void EnsureTabVisible(IDockContent content)
+        {
+            if (Appearance != DockPane.AppearanceStyle.Document || !Tabs.Contains(content))
+                return;
+
+            CalculateTabs();
+            EnsureDocumentTabVisible(content, true);
+        }
+
+        private bool EnsureDocumentTabVisible(IDockContent content, bool repaint)
+        {
+            int index = Tabs.IndexOf(content);
+            TabVS2005 tab = Tabs[index] as TabVS2005;
+            if (tab.TabWidth != 0)
+                return false;
+
+            StartDisplayingTab = index;
+            if (repaint)
+                Invalidate();
+
+            return true;
+        }
+
+        private int GetMaxTabWidth(int index)
+        {
+            if (Appearance == DockPane.AppearanceStyle.ToolWindow)
+                return GetMaxTabWidth_ToolWindow(index);
+            else
+                return GetMaxTabWidth_Document(index);
+        }
+
+        private int GetMaxTabWidth_ToolWindow(int index)
+        {
+            IDockContent content = Tabs[index].Content;
+            Size sizeString = TextRenderer.MeasureText(content.DockHandler.TabText, TextFont);
+            return ToolWindowImageWidth + sizeString.Width + ToolWindowImageGapLeft
+                + ToolWindowImageGapRight + ToolWindowTextGapRight;
+        }
+
+        private int GetMaxTabWidth_Document(int index)
+        {
+            IDockContent content = Tabs[index].Content;
+
+            int height = GetTabRectangle_Document(index).Height;
+
+            Size sizeText = TextRenderer.MeasureText(content.DockHandler.TabText, BoldFont, new Size(DocumentTabMaxWidth, height), DocumentTextFormat);
+
+            if (DockPane.DockPanel.ShowDocumentIcon)
+                return sizeText.Width + DocumentIconWidth + DocumentIconGapLeft + DocumentIconGapRight + DocumentTextGapRight;
+            else
+                return sizeText.Width + DocumentIconGapLeft + DocumentTextGapRight;
+        }
+
+        private void DrawTabStrip(Graphics g)
+        {
+            if (Appearance == DockPane.AppearanceStyle.Document)
+                DrawTabStrip_Document(g);
+            else
+                DrawTabStrip_ToolWindow(g);
+        }
+
+        private void DrawTabStrip_Document(Graphics g)
+        {
+            int count = Tabs.Count;
+            if (count == 0)
+                return;
+
+            Rectangle rectTabStrip = TabStripRectangle;
+
+            // Draw the tabs
+            Rectangle rectTabOnly = TabsRectangle;
+            Rectangle rectTab = Rectangle.Empty;
+            TabVS2005 tabActive = null;
+            g.SetClip(DrawHelper.RtlTransform(this, rectTabOnly));
+            for (int i = 0; i < count; i++)
+            {
+                rectTab = GetTabRectangle(i);
+                if (Tabs[i].Content == DockPane.ActiveContent)
+                {
+                    tabActive = Tabs[i] as TabVS2005;
+                    continue;
+                }
+                if (rectTab.IntersectsWith(rectTabOnly))
+                    DrawTab(g, Tabs[i] as TabVS2005, rectTab);
+            }
+
+            g.SetClip(rectTabStrip);
+
+            if (DockPane.DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+                g.DrawLine(PenDocumentTabActiveBorder, rectTabStrip.Left, rectTabStrip.Top + 1,
+                    rectTabStrip.Right, rectTabStrip.Top + 1);
+            else
+                g.DrawLine(PenDocumentTabActiveBorder, rectTabStrip.Left, rectTabStrip.Bottom - 1,
+                    rectTabStrip.Right, rectTabStrip.Bottom - 1);
+
+            g.SetClip(DrawHelper.RtlTransform(this, rectTabOnly));
+            if (tabActive != null)
+            {
+                rectTab = GetTabRectangle(Tabs.IndexOf(tabActive));
+                if (rectTab.IntersectsWith(rectTabOnly))
+                    DrawTab(g, tabActive, rectTab);
+            }
+        }
+
+        private void DrawTabStrip_ToolWindow(Graphics g)
+        {
+            Rectangle rectTabStrip = TabStripRectangle;
+
+            g.DrawLine(PenToolWindowTabBorder, rectTabStrip.Left, rectTabStrip.Top,
+                rectTabStrip.Right, rectTabStrip.Top);
+
+            for (int i = 0; i < Tabs.Count; i++)
+                DrawTab(g, Tabs[i] as TabVS2005, GetTabRectangle(i));
+        }
+
+        private Rectangle GetTabRectangle(int index)
+        {
+            if (Appearance == DockPane.AppearanceStyle.ToolWindow)
+                return GetTabRectangle_ToolWindow(index);
+            else
+                return GetTabRectangle_Document(index);
+        }
+
+        private Rectangle GetTabRectangle_ToolWindow(int index)
+        {
+            Rectangle rectTabStrip = TabStripRectangle;
+
+            TabVS2005 tab = (TabVS2005)(Tabs[index]);
+            return new Rectangle(tab.TabX, rectTabStrip.Y, tab.TabWidth, rectTabStrip.Height);
+        }
+
+        private Rectangle GetTabRectangle_Document(int index)
+        {
+            Rectangle rectTabStrip = TabStripRectangle;
+            TabVS2005 tab = (TabVS2005)Tabs[index];
+
+            Rectangle rect = new Rectangle();
+            rect.X = tab.TabX;
+            rect.Width = tab.TabWidth;
+            rect.Height = rectTabStrip.Height - DocumentTabGapTop;
+
+            if (DockPane.DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+                rect.Y = rectTabStrip.Y + DocumentStripGapBottom;
+            else
+                rect.Y = rectTabStrip.Y + DocumentTabGapTop;
+
+            return rect;
+        }
+
+        private void DrawTab(Graphics g, TabVS2005 tab, Rectangle rect)
+        {
+            if (Appearance == DockPane.AppearanceStyle.ToolWindow)
+                DrawTab_ToolWindow(g, tab, rect);
+            else
+                DrawTab_Document(g, tab, rect);
+        }
+
+        private GraphicsPath GetTabOutline(Tab tab, bool rtlTransform, bool toScreen)
+        {
+            if (Appearance == DockPane.AppearanceStyle.ToolWindow)
+                return GetTabOutline_ToolWindow(tab, rtlTransform, toScreen);
+            else
+                return GetTabOutline_Document(tab, rtlTransform, toScreen, false);
+        }
+
+        private GraphicsPath GetTabOutline_ToolWindow(Tab tab, bool rtlTransform, bool toScreen)
+        {
+            Rectangle rect = GetTabRectangle(Tabs.IndexOf(tab));
+            if (rtlTransform)
+                rect = DrawHelper.RtlTransform(this, rect);
+            if (toScreen)
+                rect = RectangleToScreen(rect);
+
+            DrawHelper.GetRoundedCornerTab(GraphicsPath, rect, false);
+            return GraphicsPath;
+        }
+
+        private GraphicsPath GetTabOutline_Document(Tab tab, bool rtlTransform, bool toScreen, bool full)
+        {
+            int curveSize = 6;
+
+            GraphicsPath.Reset();
+            Rectangle rect = GetTabRectangle(Tabs.IndexOf(tab));
+            if (rtlTransform)
+                rect = DrawHelper.RtlTransform(this, rect);
+            if (toScreen)
+                rect = RectangleToScreen(rect);
+
+            // Draws the full angle piece for active content (or first tab)
+            if (tab.Content == DockPane.ActiveContent || full || Tabs.IndexOf(tab) == FirstDisplayingTab)
+            {
+                if (RightToLeft == RightToLeft.Yes)
+                {
+                    if (DockPane.DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+                    {
+                        // For some reason the next line draws a line that is not hidden like it is when drawing the tab strip on top.
+                        // It is not needed so it has been commented out.
+                        //GraphicsPath.AddLine(rect.Right, rect.Bottom, rect.Right + rect.Height / 2, rect.Bottom);
+                        GraphicsPath.AddLine(rect.Right + rect.Height / 2, rect.Top, rect.Right - rect.Height / 2 + curveSize / 2, rect.Bottom - curveSize / 2);
+                    }
+                    else
+                    {
+                        GraphicsPath.AddLine(rect.Right, rect.Bottom, rect.Right + rect.Height / 2, rect.Bottom);
+                        GraphicsPath.AddLine(rect.Right + rect.Height / 2, rect.Bottom, rect.Right - rect.Height / 2 + curveSize / 2, rect.Top + curveSize / 2);
+                    }
+                }
+                else
+                {
+                    if (DockPane.DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+                    {
+                        // For some reason the next line draws a line that is not hidden like it is when drawing the tab strip on top.
+                        // It is not needed so it has been commented out.
+                        //GraphicsPath.AddLine(rect.Left, rect.Top, rect.Left - rect.Height / 2, rect.Top);
+                        GraphicsPath.AddLine(rect.Left - rect.Height / 2, rect.Top, rect.Left + rect.Height / 2 - curveSize / 2, rect.Bottom - curveSize / 2);
+                    }
+                    else
+                    {
+                        GraphicsPath.AddLine(rect.Left, rect.Bottom, rect.Left - rect.Height / 2, rect.Bottom);
+                        GraphicsPath.AddLine(rect.Left - rect.Height / 2, rect.Bottom, rect.Left + rect.Height / 2 - curveSize / 2, rect.Top + curveSize / 2);
+                    }
+                }
+            }
+            // Draws the partial angle for non-active content
+            else
+            {
+                if (RightToLeft == RightToLeft.Yes)
+                {
+                    if (DockPane.DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+                    {
+                        GraphicsPath.AddLine(rect.Right, rect.Top, rect.Right, rect.Top + rect.Height / 2);
+                        GraphicsPath.AddLine(rect.Right, rect.Top + rect.Height / 2, rect.Right - rect.Height / 2 + curveSize / 2, rect.Bottom - curveSize / 2);
+                    }
+                    else
+                    {
+                        GraphicsPath.AddLine(rect.Right, rect.Bottom, rect.Right, rect.Bottom - rect.Height / 2);
+                        GraphicsPath.AddLine(rect.Right, rect.Bottom - rect.Height / 2, rect.Right - rect.Height / 2 + curveSize / 2, rect.Top + curveSize / 2);
+                    }
+                }
+                else
+                {
+                    if (DockPane.DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+                    {
+                        GraphicsPath.AddLine(rect.Left, rect.Top, rect.Left, rect.Top + rect.Height / 2);
+                        GraphicsPath.AddLine(rect.Left, rect.Top + rect.Height / 2, rect.Left + rect.Height / 2 - curveSize / 2, rect.Bottom - curveSize / 2);
+                    }
+                    else
+                    {
+                        GraphicsPath.AddLine(rect.Left, rect.Bottom, rect.Left, rect.Bottom - rect.Height / 2);
+                        GraphicsPath.AddLine(rect.Left, rect.Bottom - rect.Height / 2, rect.Left + rect.Height / 2 - curveSize / 2, rect.Top + curveSize / 2);
+                    }
+                }
+            }
+
+            if (RightToLeft == RightToLeft.Yes)
+            {
+                if (DockPane.DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+                {
+                    // Draws the bottom horizontal line (short side)
+                    GraphicsPath.AddLine(rect.Right - rect.Height / 2 - curveSize / 2, rect.Bottom, rect.Left + curveSize / 2, rect.Bottom);
+
+                    // Drawing the rounded corner is not necessary. The path is automatically connected
+                    //GraphicsPath.AddArc(new Rectangle(rect.Left, rect.Top, curveSize, curveSize), 180, 90);
+                }
+                else
+                {
+                    // Draws the bottom horizontal line (short side)
+                    GraphicsPath.AddLine(rect.Right - rect.Height / 2 - curveSize / 2, rect.Top, rect.Left + curveSize / 2, rect.Top);
+                    GraphicsPath.AddArc(new Rectangle(rect.Left, rect.Top, curveSize, curveSize), 180, 90);
+                }
+            }
+            else
+            {
+                if (DockPane.DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+                {
+                    // Draws the bottom horizontal line (short side)
+                    GraphicsPath.AddLine(rect.Left + rect.Height / 2 + curveSize / 2, rect.Bottom, rect.Right - curveSize / 2, rect.Bottom);
+
+                    // Drawing the rounded corner is not necessary. The path is automatically connected
+                    //GraphicsPath.AddArc(new Rectangle(rect.Right - curveSize, rect.Bottom, curveSize, curveSize), 90, -90);
+                }
+                else
+                {
+                    // Draws the top horizontal line (short side)
+                    GraphicsPath.AddLine(rect.Left + rect.Height / 2 + curveSize / 2, rect.Top, rect.Right - curveSize / 2, rect.Top);
+
+                    // Draws the rounded corner oppposite the angled side
+                    GraphicsPath.AddArc(new Rectangle(rect.Right - curveSize, rect.Top, curveSize, curveSize), -90, 90);
+                }
+            }
+
+            if (Tabs.IndexOf(tab) != EndDisplayingTab &&
+                (Tabs.IndexOf(tab) != Tabs.Count - 1 && Tabs[Tabs.IndexOf(tab) + 1].Content == DockPane.ActiveContent)
+                && !full)
+            {
+                if (RightToLeft == RightToLeft.Yes)
+                {
+                    if (DockPane.DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+                    {
+                        GraphicsPath.AddLine(rect.Left, rect.Bottom - curveSize / 2, rect.Left, rect.Bottom - rect.Height / 2);
+                        GraphicsPath.AddLine(rect.Left, rect.Bottom - rect.Height / 2, rect.Left + rect.Height / 2, rect.Top);
+                    }
+                    else
+                    {
+                        GraphicsPath.AddLine(rect.Left, rect.Top + curveSize / 2, rect.Left, rect.Top + rect.Height / 2);
+                        GraphicsPath.AddLine(rect.Left, rect.Top + rect.Height / 2, rect.Left + rect.Height / 2, rect.Bottom);
+                    }
+                }
+                else
+                {
+                    if (DockPane.DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+                    {
+                        GraphicsPath.AddLine(rect.Right, rect.Bottom - curveSize / 2, rect.Right, rect.Bottom - rect.Height / 2);
+                        GraphicsPath.AddLine(rect.Right, rect.Bottom - rect.Height / 2, rect.Right - rect.Height / 2, rect.Top);
+                    }
+                    else
+                    {
+                        GraphicsPath.AddLine(rect.Right, rect.Top + curveSize / 2, rect.Right, rect.Top + rect.Height / 2);
+                        GraphicsPath.AddLine(rect.Right, rect.Top + rect.Height / 2, rect.Right - rect.Height / 2, rect.Bottom);
+                    }
+                }
+            }
+            else
+            {
+                // Draw the vertical line opposite the angled side
+                if (RightToLeft == RightToLeft.Yes)
+                {
+                    if (DockPane.DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+                        GraphicsPath.AddLine(rect.Left, rect.Bottom - curveSize / 2, rect.Left, rect.Top);
+                    else
+                        GraphicsPath.AddLine(rect.Left, rect.Top + curveSize / 2, rect.Left, rect.Bottom);
+                }
+                else
+                {
+                    if (DockPane.DockPanel.DocumentTabStripLocation == DocumentTabStripLocation.Bottom)
+                        GraphicsPath.AddLine(rect.Right, rect.Bottom - curveSize / 2, rect.Right, rect.Top);
+                    else
+                        GraphicsPath.AddLine(rect.Right, rect.Top + curveSize / 2, rect.Right, rect.Bottom);
+                }
+            }
+
+            return GraphicsPath;
+        }
+
+        private void DrawTab_ToolWindow(Graphics g, TabVS2005 tab, Rectangle rect)
+        {
+            Rectangle rectIcon = new Rectangle(
+                rect.X + ToolWindowImageGapLeft,
+                rect.Y + rect.Height - 1 - ToolWindowImageGapBottom - ToolWindowImageHeight,
+                ToolWindowImageWidth, ToolWindowImageHeight);
+            Rectangle rectText = rectIcon;
+            rectText.X += rectIcon.Width + ToolWindowImageGapRight;
+            rectText.Width = rect.Width - rectIcon.Width - ToolWindowImageGapLeft -
+                ToolWindowImageGapRight - ToolWindowTextGapRight;
+
+            Rectangle rectTab = DrawHelper.RtlTransform(this, rect);
+            rectText = DrawHelper.RtlTransform(this, rectText);
+            rectIcon = DrawHelper.RtlTransform(this, rectIcon);
+            GraphicsPath path = GetTabOutline(tab, true, false);
+            if (DockPane.ActiveContent == tab.Content)
+            {
+                Color startColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveTabGradient.StartColor;
+                Color endColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveTabGradient.EndColor;
+                LinearGradientMode gradientMode = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveTabGradient.LinearGradientMode;
+                g.FillPath(new LinearGradientBrush(rectTab, startColor, endColor, gradientMode), path);
+                g.DrawPath(PenToolWindowTabBorder, path);
+
+                Color textColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveTabGradient.TextColor;
+                TextRenderer.DrawText(g, tab.Content.DockHandler.TabText, TextFont, rectText, textColor, ToolWindowTextFormat);
+            }
+            else
+            {
+                Color startColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveTabGradient.StartColor;
+                Color endColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveTabGradient.EndColor;
+                LinearGradientMode gradientMode = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveTabGradient.LinearGradientMode;
+                g.FillPath(new LinearGradientBrush(rectTab, startColor, endColor, gradientMode), path);
+
+                if (Tabs.IndexOf(DockPane.ActiveContent) != Tabs.IndexOf(tab) + 1)
+                {
+                    Point pt1 = new Point(rect.Right, rect.Top + ToolWindowTabSeperatorGapTop);
+                    Point pt2 = new Point(rect.Right, rect.Bottom - ToolWindowTabSeperatorGapBottom);
+                    g.DrawLine(PenToolWindowTabBorder, DrawHelper.RtlTransform(this, pt1), DrawHelper.RtlTransform(this, pt2));
+                }
+
+                Color textColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveTabGradient.TextColor;
+                TextRenderer.DrawText(g, tab.Content.DockHandler.TabText, TextFont, rectText, textColor, ToolWindowTextFormat);
+            }
+
+            if (rectTab.Contains(rectIcon))
+                g.DrawIcon(tab.Content.DockHandler.Icon, rectIcon);
+        }
+
+        private void DrawTab_Document(Graphics g, TabVS2005 tab, Rectangle rect)
+        {
+            if (tab.TabWidth == 0)
+                return;
+
+            Rectangle rectIcon = new Rectangle(
+                rect.X + DocumentIconGapLeft,
+                rect.Y + rect.Height - 1 - DocumentIconGapBottom - DocumentIconHeight,
+                DocumentIconWidth, DocumentIconHeight);
+            Rectangle rectText = rectIcon;
+            if (DockPane.DockPanel.ShowDocumentIcon)
+            {
+                rectText.X += rectIcon.Width + DocumentIconGapRight;
+                rectText.Y = rect.Y;
+                rectText.Width = rect.Width - rectIcon.Width - DocumentIconGapLeft -
+                    DocumentIconGapRight - DocumentTextGapRight;
+                rectText.Height = rect.Height;
+            }
+            else
+                rectText.Width = rect.Width - DocumentIconGapLeft - DocumentTextGapRight;
+
+            Rectangle rectTab = DrawHelper.RtlTransform(this, rect);
+            Rectangle rectBack = DrawHelper.RtlTransform(this, rect);
+            rectBack.Width += rect.X;
+            rectBack.X = 0;
+
+            rectText = DrawHelper.RtlTransform(this, rectText);
+            rectIcon = DrawHelper.RtlTransform(this, rectIcon);
+            GraphicsPath path = GetTabOutline(tab, true, false);
+            if (DockPane.ActiveContent == tab.Content)
+            {
+                Color startColor = DockPane.DockPanel.Skin.DockPaneStripSkin.DocumentGradient.ActiveTabGradient.StartColor;
+                Color endColor = DockPane.DockPanel.Skin.DockPaneStripSkin.DocumentGradient.ActiveTabGradient.EndColor;
+                LinearGradientMode gradientMode = DockPane.DockPanel.Skin.DockPaneStripSkin.DocumentGradient.ActiveTabGradient.LinearGradientMode;
+                g.FillPath(new LinearGradientBrush(rectBack, startColor, endColor, gradientMode), path);
+                g.DrawPath(PenDocumentTabActiveBorder, path);
+
+                Color textColor = DockPane.DockPanel.Skin.DockPaneStripSkin.DocumentGradient.ActiveTabGradient.TextColor;
+                if (DockPane.IsActiveDocumentPane)
+                    TextRenderer.DrawText(g, tab.Content.DockHandler.TabText, BoldFont, rectText, textColor, DocumentTextFormat);
+                else
+                    TextRenderer.DrawText(g, tab.Content.DockHandler.TabText, TextFont, rectText, textColor, DocumentTextFormat);
+            }
+            else
+            {
+                Color startColor = DockPane.DockPanel.Skin.DockPaneStripSkin.DocumentGradient.InactiveTabGradient.StartColor;
+                Color endColor = DockPane.DockPanel.Skin.DockPaneStripSkin.DocumentGradient.InactiveTabGradient.EndColor;
+                LinearGradientMode gradientMode = DockPane.DockPanel.Skin.DockPaneStripSkin.DocumentGradient.InactiveTabGradient.LinearGradientMode;
+                g.FillPath(new LinearGradientBrush(rectBack, startColor, endColor, gradientMode), path);
+                g.DrawPath(PenDocumentTabInactiveBorder, path);
+
+                Color textColor = DockPane.DockPanel.Skin.DockPaneStripSkin.DocumentGradient.InactiveTabGradient.TextColor;
+                TextRenderer.DrawText(g, tab.Content.DockHandler.TabText, TextFont, rectText, textColor, DocumentTextFormat);
+            }
+
+            if (rectTab.Contains(rectIcon) && DockPane.DockPanel.ShowDocumentIcon)
+                g.DrawIcon(tab.Content.DockHandler.Icon, rectIcon);
+        }
+
+        private void WindowList_Click(object sender, EventArgs e)
+        {
+            int x = 0;
+            int y = ButtonWindowList.Location.Y + ButtonWindowList.Height;
+
+            SelectMenu.Items.Clear();
+            foreach (TabVS2005 tab in Tabs)
+            {
+                IDockContent content = tab.Content;
+                ToolStripItem item = SelectMenu.Items.Add(content.DockHandler.TabText, content.DockHandler.Icon.ToBitmap());
+                item.Tag = tab.Content;
+                item.Click += new EventHandler(ContextMenuItem_Click);
+            }
+            SelectMenu.Show(ButtonWindowList, x, y);
+        }
+
+        private void ContextMenuItem_Click(object sender, EventArgs e)
+        {
+            ToolStripMenuItem item = sender as ToolStripMenuItem;
+            if (item != null)
+            {
+                IDockContent content = (IDockContent)item.Tag;
+                DockPane.ActiveContent = content;
+            }
+        }
+
+        private void SetInertButtons()
+        {
+            if (Appearance == DockPane.AppearanceStyle.ToolWindow)
+            {
+                if (m_buttonClose != null)
+                    m_buttonClose.Left = -m_buttonClose.Width;
+
+                if (m_buttonWindowList != null)
+                    m_buttonWindowList.Left = -m_buttonWindowList.Width;
+            }
+            else
+            {
+                ButtonClose.Enabled = DockPane.ActiveContent == null ? true : DockPane.ActiveContent.DockHandler.CloseButton;
+                m_closeButtonVisible = DockPane.ActiveContent == null ? true : DockPane.ActiveContent.DockHandler.CloseButtonVisible;
+                ButtonClose.Visible = m_closeButtonVisible;
+                ButtonClose.RefreshChanges();
+                ButtonWindowList.RefreshChanges();
+            }
+        }
+
+        protected override void OnLayout(LayoutEventArgs levent)
+        {
+            if (Appearance == DockPane.AppearanceStyle.Document)
+            {
+                LayoutButtons();
+                OnRefreshChanges();
+            }
+
+            base.OnLayout(levent);
+        }
+
+        private void LayoutButtons()
+        {
+            Rectangle rectTabStrip = TabStripRectangle;
+
+            // Set position and size of the buttons
+            int buttonWidth = ButtonClose.Image.Width;
+            int buttonHeight = ButtonClose.Image.Height;
+            int height = rectTabStrip.Height - DocumentButtonGapTop - DocumentButtonGapBottom;
+            if (buttonHeight < height)
+            {
+                buttonWidth = buttonWidth * (height / buttonHeight);
+                buttonHeight = height;
+            }
+            Size buttonSize = new Size(buttonWidth, buttonHeight);
+
+            int x = rectTabStrip.X + rectTabStrip.Width - DocumentTabGapLeft
+                - DocumentButtonGapRight - buttonWidth;
+            int y = rectTabStrip.Y + DocumentButtonGapTop;
+            Point point = new Point(x, y);
+            ButtonClose.Bounds = DrawHelper.RtlTransform(this, new Rectangle(point, buttonSize));
+
+            // If the close button is not visible draw the window list button overtop.
+            // Otherwise it is drawn to the left of the close button.
+            if (m_closeButtonVisible)
+                point.Offset(-(DocumentButtonGapBetween + buttonWidth), 0);
+
+            ButtonWindowList.Bounds = DrawHelper.RtlTransform(this, new Rectangle(point, buttonSize));
+        }
+
+        private void Close_Click(object sender, EventArgs e)
+        {
+            DockPane.CloseActiveContent();
+        }
+
+        protected internal override int HitTest(Point ptMouse)
+        {
+            if (!TabsRectangle.Contains(ptMouse))
+                return -1;
+
+            foreach (Tab tab in Tabs)
+            {
+                GraphicsPath path = GetTabOutline(tab, true, false);
+                if (path.IsVisible(ptMouse))
+                    return Tabs.IndexOf(tab);
+            }
+            return -1;
+        }
+
+        protected override void OnMouseHover(EventArgs e)
+        {
+            int index = HitTest(PointToClient(Control.MousePosition));
+            string toolTip = string.Empty;
+
+            base.OnMouseHover(e);
+
+            if (index != -1)
+            {
+                TabVS2005 tab = Tabs[index] as TabVS2005;
+                if (!String.IsNullOrEmpty(tab.Content.DockHandler.ToolTipText))
+                    toolTip = tab.Content.DockHandler.ToolTipText;
+                else if (tab.MaxWidth > tab.TabWidth)
+                    toolTip = tab.Content.DockHandler.TabText;
+            }
+
+            if (m_toolTip.GetToolTip(this) != toolTip)
+            {
+                m_toolTip.Active = false;
+                m_toolTip.SetToolTip(this, toolTip);
+                m_toolTip.Active = true;
+            }
+
+            // requires further tracking of mouse hover behavior,
+            ResetMouseEventArgs();
+        }
+
+        protected override void OnRightToLeftChanged(EventArgs e)
+        {
+            base.OnRightToLeftChanged(e);
+            PerformLayout();
+        }
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/VisibleNestedPaneCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/VisibleNestedPaneCollection.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/VisibleNestedPaneCollection.cs	(revision 8616)
@@ -0,0 +1,168 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+	public sealed class VisibleNestedPaneCollection : ReadOnlyCollection<DockPane>
+	{
+		private NestedPaneCollection m_nestedPanes;
+
+        internal VisibleNestedPaneCollection(NestedPaneCollection nestedPanes)
+            : base(new List<DockPane>())
+        {
+            m_nestedPanes = nestedPanes;
+        }
+
+		public NestedPaneCollection NestedPanes
+		{
+			get	{	return m_nestedPanes;	}
+		}
+
+		public INestedPanesContainer Container
+		{
+			get	{	return NestedPanes.Container;	}
+		}
+
+		public DockState DockState
+		{
+			get	{	return NestedPanes.DockState;	}
+		}
+
+		public bool IsFloat
+		{
+			get	{	return NestedPanes.IsFloat;	}
+		}
+
+		internal void Refresh()
+		{
+			Items.Clear();
+			for (int i=0; i<NestedPanes.Count; i++)
+			{
+				DockPane pane = NestedPanes[i];
+				NestedDockingStatus status = pane.NestedDockingStatus;
+				status.SetDisplayingStatus(true, status.PreviousPane, status.Alignment, status.Proportion);
+				Items.Add(pane);
+			}
+
+			foreach (DockPane pane in NestedPanes)
+				if (pane.DockState != DockState || pane.IsHidden)
+				{
+					pane.Bounds = Rectangle.Empty;
+					pane.SplitterBounds = Rectangle.Empty;
+					Remove(pane);
+				}
+
+			CalculateBounds();
+
+			foreach (DockPane pane in this)
+			{
+				NestedDockingStatus status = pane.NestedDockingStatus;
+				pane.Bounds = status.PaneBounds;
+				pane.SplitterBounds = status.SplitterBounds;
+				pane.SplitterAlignment = status.Alignment;
+			}
+		}
+
+		private void Remove(DockPane pane)
+		{
+			if (!Contains(pane))
+				return;
+
+			NestedDockingStatus statusPane = pane.NestedDockingStatus;
+			DockPane lastNestedPane = null;
+			for (int i=Count - 1; i> IndexOf(pane); i--)
+			{
+				if (this[i].NestedDockingStatus.PreviousPane == pane)
+				{
+					lastNestedPane = this[i];
+					break;
+				}
+			}
+
+			if (lastNestedPane != null)
+			{
+				int indexLastNestedPane = IndexOf(lastNestedPane);
+				Items.Remove(lastNestedPane);
+				Items[IndexOf(pane)] = lastNestedPane;
+				NestedDockingStatus lastNestedDock = lastNestedPane.NestedDockingStatus;
+				lastNestedDock.SetDisplayingStatus(true, statusPane.DisplayingPreviousPane, statusPane.DisplayingAlignment, statusPane.DisplayingProportion);
+				for (int i=indexLastNestedPane - 1; i>IndexOf(lastNestedPane); i--)
+				{
+					NestedDockingStatus status = this[i].NestedDockingStatus;
+					if (status.PreviousPane == pane)
+						status.SetDisplayingStatus(true, lastNestedPane, status.DisplayingAlignment, status.DisplayingProportion);
+				}
+			}
+			else
+				Items.Remove(pane);
+
+			statusPane.SetDisplayingStatus(false, null, DockAlignment.Left, 0.5);
+		}
+
+		private void CalculateBounds()
+		{
+			if (Count == 0)
+				return;
+
+			this[0].NestedDockingStatus.SetDisplayingBounds(Container.DisplayingRectangle, Container.DisplayingRectangle, Rectangle.Empty);
+
+			for (int i=1; i<Count; i++)
+			{
+				DockPane pane = this[i];
+				NestedDockingStatus status = pane.NestedDockingStatus;
+				DockPane prevPane = status.DisplayingPreviousPane;
+				NestedDockingStatus statusPrev = prevPane.NestedDockingStatus;
+
+				Rectangle rect = statusPrev.PaneBounds;
+				bool bVerticalSplitter = (status.DisplayingAlignment == DockAlignment.Left || status.DisplayingAlignment == DockAlignment.Right);
+
+				Rectangle rectThis = rect;
+				Rectangle rectPrev = rect;
+				Rectangle rectSplitter = rect;
+				if (status.DisplayingAlignment == DockAlignment.Left)
+				{
+					rectThis.Width = (int)((double)rect.Width * status.DisplayingProportion) - (Measures.SplitterSize / 2);
+					rectSplitter.X = rectThis.X + rectThis.Width;
+					rectSplitter.Width = Measures.SplitterSize;
+					rectPrev.X = rectSplitter.X + rectSplitter.Width;
+					rectPrev.Width = rect.Width - rectThis.Width - rectSplitter.Width;
+				}
+				else if (status.DisplayingAlignment == DockAlignment.Right)
+				{
+					rectPrev.Width = (rect.Width - (int)((double)rect.Width * status.DisplayingProportion)) - (Measures.SplitterSize / 2);
+					rectSplitter.X = rectPrev.X + rectPrev.Width;
+					rectSplitter.Width = Measures.SplitterSize;
+					rectThis.X = rectSplitter.X + rectSplitter.Width;
+					rectThis.Width = rect.Width - rectPrev.Width - rectSplitter.Width;
+				}
+				else if (status.DisplayingAlignment == DockAlignment.Top)
+				{
+					rectThis.Height = (int)((double)rect.Height * status.DisplayingProportion) - (Measures.SplitterSize / 2);
+					rectSplitter.Y = rectThis.Y + rectThis.Height;
+					rectSplitter.Height = Measures.SplitterSize;
+					rectPrev.Y = rectSplitter.Y + rectSplitter.Height;
+					rectPrev.Height = rect.Height - rectThis.Height - rectSplitter.Height;
+				}
+				else if (status.DisplayingAlignment == DockAlignment.Bottom)
+				{
+					rectPrev.Height = (rect.Height - (int)((double)rect.Height * status.DisplayingProportion)) - (Measures.SplitterSize / 2);
+					rectSplitter.Y = rectPrev.Y + rectPrev.Height;
+					rectSplitter.Height = Measures.SplitterSize;
+					rectThis.Y = rectSplitter.Y + rectSplitter.Height;
+					rectThis.Height = rect.Height - rectPrev.Height - rectSplitter.Height;
+				}
+				else
+					rectThis = Rectangle.Empty;
+
+				rectSplitter.Intersect(rect);
+				rectThis.Intersect(rect);
+				rectPrev.Intersect(rect);
+				status.SetDisplayingBounds(rect, rectThis, rectSplitter);
+				statusPrev.SetDisplayingBounds(statusPrev.LogicalBounds, rectPrev, statusPrev.SplitterBounds);
+			}
+		}
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Win32/Enums.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Win32/Enums.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Win32/Enums.cs	(revision 8616)
@@ -0,0 +1,370 @@
+using System;
+
+namespace WeifenLuo.WinFormsUI.Docking.Win32
+{
+	[Flags]
+	internal enum FlagsSetWindowPos : uint
+	{
+		SWP_NOSIZE          = 0x0001,
+		SWP_NOMOVE          = 0x0002,
+		SWP_NOZORDER        = 0x0004,
+		SWP_NOREDRAW        = 0x0008,
+		SWP_NOACTIVATE      = 0x0010,
+		SWP_FRAMECHANGED    = 0x0020,
+		SWP_SHOWWINDOW      = 0x0040,
+		SWP_HIDEWINDOW      = 0x0080,
+		SWP_NOCOPYBITS      = 0x0100,
+		SWP_NOOWNERZORDER   = 0x0200, 
+		SWP_NOSENDCHANGING  = 0x0400,
+		SWP_DRAWFRAME       = 0x0020,
+		SWP_NOREPOSITION    = 0x0200,
+		SWP_DEFERERASE      = 0x2000,
+		SWP_ASYNCWINDOWPOS  = 0x4000
+	}
+
+	internal enum ShowWindowStyles : short
+	{
+		SW_HIDE             = 0,
+		SW_SHOWNORMAL       = 1,
+		SW_NORMAL           = 1,
+		SW_SHOWMINIMIZED    = 2,
+		SW_SHOWMAXIMIZED    = 3,
+		SW_MAXIMIZE         = 3,
+		SW_SHOWNOACTIVATE   = 4,
+		SW_SHOW             = 5,
+		SW_MINIMIZE         = 6,
+		SW_SHOWMINNOACTIVE  = 7,
+		SW_SHOWNA           = 8,
+		SW_RESTORE          = 9,
+		SW_SHOWDEFAULT      = 10,
+		SW_FORCEMINIMIZE    = 11,
+		SW_MAX              = 11
+	}
+
+	internal enum WindowStyles : uint
+	{
+		WS_OVERLAPPED       = 0x00000000,
+		WS_POPUP            = 0x80000000,
+		WS_CHILD            = 0x40000000,
+		WS_MINIMIZE         = 0x20000000,
+		WS_VISIBLE          = 0x10000000,
+		WS_DISABLED         = 0x08000000,
+		WS_CLIPSIBLINGS     = 0x04000000,
+		WS_CLIPCHILDREN     = 0x02000000,
+		WS_MAXIMIZE         = 0x01000000,
+		WS_CAPTION          = 0x00C00000,
+		WS_BORDER           = 0x00800000,
+		WS_DLGFRAME         = 0x00400000,
+		WS_VSCROLL          = 0x00200000,
+		WS_HSCROLL          = 0x00100000,
+		WS_SYSMENU          = 0x00080000,
+		WS_THICKFRAME       = 0x00040000,
+		WS_GROUP            = 0x00020000,
+		WS_TABSTOP          = 0x00010000,
+		WS_MINIMIZEBOX      = 0x00020000,
+		WS_MAXIMIZEBOX      = 0x00010000,
+		WS_TILED            = 0x00000000,
+		WS_ICONIC           = 0x20000000,
+		WS_SIZEBOX          = 0x00040000,
+		WS_POPUPWINDOW      = 0x80880000,
+		WS_OVERLAPPEDWINDOW = 0x00CF0000,
+		WS_TILEDWINDOW      = 0x00CF0000,
+		WS_CHILDWINDOW      = 0x40000000
+	}
+
+	internal enum WindowExStyles
+	{
+		WS_EX_DLGMODALFRAME     = 0x00000001,
+		WS_EX_NOPARENTNOTIFY    = 0x00000004,
+		WS_EX_TOPMOST           = 0x00000008,
+		WS_EX_ACCEPTFILES       = 0x00000010,
+		WS_EX_TRANSPARENT       = 0x00000020,
+		WS_EX_MDICHILD          = 0x00000040,
+		WS_EX_TOOLWINDOW        = 0x00000080,
+		WS_EX_WINDOWEDGE        = 0x00000100,
+		WS_EX_CLIENTEDGE        = 0x00000200,
+		WS_EX_CONTEXTHELP       = 0x00000400,
+		WS_EX_RIGHT             = 0x00001000,
+		WS_EX_LEFT              = 0x00000000,
+		WS_EX_RTLREADING        = 0x00002000,
+		WS_EX_LTRREADING        = 0x00000000,
+		WS_EX_LEFTSCROLLBAR     = 0x00004000,
+		WS_EX_RIGHTSCROLLBAR    = 0x00000000,
+		WS_EX_CONTROLPARENT     = 0x00010000,
+		WS_EX_STATICEDGE        = 0x00020000,
+		WS_EX_APPWINDOW         = 0x00040000,
+		WS_EX_OVERLAPPEDWINDOW  = 0x00000300,
+		WS_EX_PALETTEWINDOW     = 0x00000188,
+		WS_EX_LAYERED			= 0x00080000,
+        WS_EX_NOACTIVATE        = 0x08000000
+	}
+
+	internal enum Msgs
+	{
+		WM_NULL                   = 0x0000,
+		WM_CREATE                 = 0x0001,
+		WM_DESTROY                = 0x0002,
+		WM_MOVE                   = 0x0003,
+		WM_SIZE                   = 0x0005,
+		WM_ACTIVATE               = 0x0006,
+		WM_SETFOCUS               = 0x0007,
+		WM_KILLFOCUS              = 0x0008,
+		WM_ENABLE                 = 0x000A,
+		WM_SETREDRAW              = 0x000B,
+		WM_SETTEXT                = 0x000C,
+		WM_GETTEXT                = 0x000D,
+		WM_GETTEXTLENGTH          = 0x000E,
+		WM_PAINT                  = 0x000F,
+		WM_CLOSE                  = 0x0010,
+		WM_QUERYENDSESSION        = 0x0011,
+		WM_QUIT                   = 0x0012,
+		WM_QUERYOPEN              = 0x0013,
+		WM_ERASEBKGND             = 0x0014,
+		WM_SYSCOLORCHANGE         = 0x0015,
+		WM_ENDSESSION             = 0x0016,
+		WM_SHOWWINDOW             = 0x0018,
+		WM_WININICHANGE           = 0x001A,
+		WM_SETTINGCHANGE          = 0x001A,
+		WM_DEVMODECHANGE          = 0x001B,
+		WM_ACTIVATEAPP            = 0x001C,
+		WM_FONTCHANGE             = 0x001D,
+		WM_TIMECHANGE             = 0x001E,
+		WM_CANCELMODE             = 0x001F,
+		WM_SETCURSOR              = 0x0020,
+		WM_MOUSEACTIVATE          = 0x0021,
+		WM_CHILDACTIVATE          = 0x0022,
+		WM_QUEUESYNC              = 0x0023,
+		WM_GETMINMAXINFO          = 0x0024,
+		WM_PAINTICON              = 0x0026,
+		WM_ICONERASEBKGND         = 0x0027,
+		WM_NEXTDLGCTL             = 0x0028,
+		WM_SPOOLERSTATUS          = 0x002A,
+		WM_DRAWITEM               = 0x002B,
+		WM_MEASUREITEM            = 0x002C,
+		WM_DELETEITEM             = 0x002D,
+		WM_VKEYTOITEM             = 0x002E,
+		WM_CHARTOITEM             = 0x002F,
+		WM_SETFONT                = 0x0030,
+		WM_GETFONT                = 0x0031,
+		WM_SETHOTKEY              = 0x0032,
+		WM_GETHOTKEY              = 0x0033,
+		WM_QUERYDRAGICON          = 0x0037,
+		WM_COMPAREITEM            = 0x0039,
+		WM_GETOBJECT              = 0x003D,
+		WM_COMPACTING             = 0x0041,
+		WM_COMMNOTIFY             = 0x0044 ,
+		WM_WINDOWPOSCHANGING      = 0x0046,
+		WM_WINDOWPOSCHANGED       = 0x0047,
+		WM_POWER                  = 0x0048,
+		WM_COPYDATA               = 0x004A,
+		WM_CANCELJOURNAL          = 0x004B,
+		WM_NOTIFY                 = 0x004E,
+		WM_INPUTLANGCHANGEREQUEST = 0x0050,
+		WM_INPUTLANGCHANGE        = 0x0051,
+		WM_TCARD                  = 0x0052,
+		WM_HELP                   = 0x0053,
+		WM_USERCHANGED            = 0x0054,
+		WM_NOTIFYFORMAT           = 0x0055,
+		WM_CONTEXTMENU            = 0x007B,
+		WM_STYLECHANGING          = 0x007C,
+		WM_STYLECHANGED           = 0x007D,
+		WM_DISPLAYCHANGE          = 0x007E,
+		WM_GETICON                = 0x007F,
+		WM_SETICON                = 0x0080,
+		WM_NCCREATE               = 0x0081,
+		WM_NCDESTROY              = 0x0082,
+		WM_NCCALCSIZE             = 0x0083,
+		WM_NCHITTEST              = 0x0084,
+		WM_NCPAINT                = 0x0085,
+		WM_NCACTIVATE             = 0x0086,
+		WM_GETDLGCODE             = 0x0087,
+		WM_SYNCPAINT              = 0x0088,
+		WM_NCMOUSEMOVE            = 0x00A0,
+		WM_NCLBUTTONDOWN          = 0x00A1,
+		WM_NCLBUTTONUP            = 0x00A2,
+		WM_NCLBUTTONDBLCLK        = 0x00A3,
+		WM_NCRBUTTONDOWN          = 0x00A4,
+		WM_NCRBUTTONUP            = 0x00A5,
+		WM_NCRBUTTONDBLCLK        = 0x00A6,
+		WM_NCMBUTTONDOWN          = 0x00A7,
+		WM_NCMBUTTONUP            = 0x00A8,
+		WM_NCMBUTTONDBLCLK        = 0x00A9,
+		WM_KEYDOWN                = 0x0100,
+		WM_KEYUP                  = 0x0101,
+		WM_CHAR                   = 0x0102,
+		WM_DEADCHAR               = 0x0103,
+		WM_SYSKEYDOWN             = 0x0104,
+		WM_SYSKEYUP               = 0x0105,
+		WM_SYSCHAR                = 0x0106,
+		WM_SYSDEADCHAR            = 0x0107,
+		WM_KEYLAST                = 0x0108,
+		WM_IME_STARTCOMPOSITION   = 0x010D,
+		WM_IME_ENDCOMPOSITION     = 0x010E,
+		WM_IME_COMPOSITION        = 0x010F,
+		WM_IME_KEYLAST            = 0x010F,
+		WM_INITDIALOG             = 0x0110,
+		WM_COMMAND                = 0x0111,
+		WM_SYSCOMMAND             = 0x0112,
+		WM_TIMER                  = 0x0113,
+		WM_HSCROLL                = 0x0114,
+		WM_VSCROLL                = 0x0115,
+		WM_INITMENU               = 0x0116,
+		WM_INITMENUPOPUP          = 0x0117,
+		WM_MENUSELECT             = 0x011F,
+		WM_MENUCHAR               = 0x0120,
+		WM_ENTERIDLE              = 0x0121,
+		WM_MENURBUTTONUP          = 0x0122,
+		WM_MENUDRAG               = 0x0123,
+		WM_MENUGETOBJECT          = 0x0124,
+		WM_UNINITMENUPOPUP        = 0x0125,
+		WM_MENUCOMMAND            = 0x0126,
+		WM_CTLCOLORMSGBOX         = 0x0132,
+		WM_CTLCOLOREDIT           = 0x0133,
+		WM_CTLCOLORLISTBOX        = 0x0134,
+		WM_CTLCOLORBTN            = 0x0135,
+		WM_CTLCOLORDLG            = 0x0136,
+		WM_CTLCOLORSCROLLBAR      = 0x0137,
+		WM_CTLCOLORSTATIC         = 0x0138,
+		WM_MOUSEMOVE              = 0x0200,
+		WM_LBUTTONDOWN            = 0x0201,
+		WM_LBUTTONUP              = 0x0202,
+		WM_LBUTTONDBLCLK          = 0x0203,
+		WM_RBUTTONDOWN            = 0x0204,
+		WM_RBUTTONUP              = 0x0205,
+		WM_RBUTTONDBLCLK          = 0x0206,
+		WM_MBUTTONDOWN            = 0x0207,
+		WM_MBUTTONUP              = 0x0208,
+		WM_MBUTTONDBLCLK          = 0x0209,
+		WM_MOUSEWHEEL             = 0x020A,
+		WM_PARENTNOTIFY           = 0x0210,
+		WM_ENTERMENULOOP          = 0x0211,
+		WM_EXITMENULOOP           = 0x0212,
+		WM_NEXTMENU               = 0x0213,
+		WM_SIZING                 = 0x0214,
+		WM_CAPTURECHANGED         = 0x0215,
+		WM_MOVING                 = 0x0216,
+		WM_DEVICECHANGE           = 0x0219,
+		WM_MDICREATE              = 0x0220,
+		WM_MDIDESTROY             = 0x0221,
+		WM_MDIACTIVATE            = 0x0222,
+		WM_MDIRESTORE             = 0x0223,
+		WM_MDINEXT                = 0x0224,
+		WM_MDIMAXIMIZE            = 0x0225,
+		WM_MDITILE                = 0x0226,
+		WM_MDICASCADE             = 0x0227,
+		WM_MDIICONARRANGE         = 0x0228,
+		WM_MDIGETACTIVE           = 0x0229,
+		WM_MDISETMENU             = 0x0230,
+		WM_ENTERSIZEMOVE          = 0x0231,
+		WM_EXITSIZEMOVE           = 0x0232,
+		WM_DROPFILES              = 0x0233,
+		WM_MDIREFRESHMENU         = 0x0234,
+		WM_IME_SETCONTEXT         = 0x0281,
+		WM_IME_NOTIFY             = 0x0282,
+		WM_IME_CONTROL            = 0x0283,
+		WM_IME_COMPOSITIONFULL    = 0x0284,
+		WM_IME_SELECT             = 0x0285,
+		WM_IME_CHAR               = 0x0286,
+		WM_IME_REQUEST            = 0x0288,
+		WM_IME_KEYDOWN            = 0x0290,
+		WM_IME_KEYUP              = 0x0291,
+		WM_MOUSEHOVER             = 0x02A1,
+		WM_MOUSELEAVE             = 0x02A3,
+		WM_CUT                    = 0x0300,
+		WM_COPY                   = 0x0301,
+		WM_PASTE                  = 0x0302,
+		WM_CLEAR                  = 0x0303,
+		WM_UNDO                   = 0x0304,
+		WM_RENDERFORMAT           = 0x0305,
+		WM_RENDERALLFORMATS       = 0x0306,
+		WM_DESTROYCLIPBOARD       = 0x0307,
+		WM_DRAWCLIPBOARD          = 0x0308,
+		WM_PAINTCLIPBOARD         = 0x0309,
+		WM_VSCROLLCLIPBOARD       = 0x030A,
+		WM_SIZECLIPBOARD          = 0x030B,
+		WM_ASKCBFORMATNAME        = 0x030C,
+		WM_CHANGECBCHAIN          = 0x030D,
+		WM_HSCROLLCLIPBOARD       = 0x030E,
+		WM_QUERYNEWPALETTE        = 0x030F,
+		WM_PALETTEISCHANGING      = 0x0310,
+		WM_PALETTECHANGED         = 0x0311,
+		WM_HOTKEY                 = 0x0312,
+		WM_PRINT                  = 0x0317,
+		WM_PRINTCLIENT            = 0x0318,
+		WM_HANDHELDFIRST          = 0x0358,
+		WM_HANDHELDLAST           = 0x035F,
+		WM_AFXFIRST               = 0x0360,
+		WM_AFXLAST                = 0x037F,
+		WM_PENWINFIRST            = 0x0380,
+		WM_PENWINLAST             = 0x038F,
+		WM_APP                    = 0x8000,
+		WM_USER                   = 0x0400
+	}
+
+	internal enum HitTest
+	{
+		HTERROR			= -2,
+		HTTRANSPARENT   = -1,
+		HTNOWHERE		= 0,
+		HTCLIENT		= 1,
+		HTCAPTION		= 2,
+		HTSYSMENU		= 3,
+		HTGROWBOX		= 4,
+		HTSIZE			= 4,
+		HTMENU			= 5,
+		HTHSCROLL		= 6,
+		HTVSCROLL		= 7,
+		HTMINBUTTON		= 8,
+		HTMAXBUTTON		= 9,
+		HTLEFT			= 10,
+		HTRIGHT			= 11,
+		HTTOP			= 12,
+		HTTOPLEFT		= 13,
+		HTTOPRIGHT		= 14,
+		HTBOTTOM		= 15,
+		HTBOTTOMLEFT	= 16,
+		HTBOTTOMRIGHT	= 17,
+		HTBORDER		= 18,
+		HTREDUCE		= 8,
+		HTZOOM			= 9 ,
+		HTSIZEFIRST		= 10,
+		HTSIZELAST		= 17,
+		HTOBJECT		= 19,
+		HTCLOSE			= 20,
+		HTHELP			= 21
+	}
+
+	internal enum ScrollBars : uint
+	{
+		SB_HORZ = 0,
+		SB_VERT = 1,
+		SB_CTL = 2,
+		SB_BOTH = 3
+	}
+
+	internal enum GetWindowLongIndex : int
+	{
+		GWL_STYLE = -16,
+		GWL_EXSTYLE = -20
+	}
+
+    // Hook Types  
+    internal enum HookType : int
+    {
+        WH_JOURNALRECORD = 0,
+        WH_JOURNALPLAYBACK = 1,
+        WH_KEYBOARD = 2,
+        WH_GETMESSAGE = 3,
+        WH_CALLWNDPROC = 4,
+        WH_CBT = 5,
+        WH_SYSMSGFILTER = 6,
+        WH_MOUSE = 7,
+        WH_HARDWARE = 8,
+        WH_DEBUG = 9,
+        WH_SHELL = 10,
+        WH_FOREGROUNDIDLE = 11,
+        WH_CALLWNDPROCRET = 12,
+        WH_KEYBOARD_LL = 13,
+        WH_MOUSE_LL = 14
+    }
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Win32/NativeMethods.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Win32/NativeMethods.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/Win32/NativeMethods.cs	(revision 8616)
@@ -0,0 +1,64 @@
+using System;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.Diagnostics.CodeAnalysis;
+using WeifenLuo.WinFormsUI.Docking.Win32;
+
+namespace WeifenLuo.WinFormsUI.Docking
+{
+    internal static class NativeMethods
+    {
+		[DllImport("User32.dll", CharSet=CharSet.Auto)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+		public static extern bool DragDetect(IntPtr hWnd, Point pt);
+
+        [DllImport("User32.dll", CharSet=CharSet.Auto)]
+        public static extern IntPtr GetFocus();
+
+        [DllImport("User32.dll", CharSet=CharSet.Auto)]
+        public static extern IntPtr SetFocus(IntPtr hWnd);
+
+        [DllImport("User32.dll", CharSet=CharSet.Auto)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool PostMessage(IntPtr hWnd, int Msg, uint wParam, uint lParam);
+
+        [DllImport("User32.dll", CharSet=CharSet.Auto)]
+        public static extern uint SendMessage(IntPtr hWnd, int Msg, uint wParam, uint lParam);
+
+        [DllImport("User32.dll", CharSet=CharSet.Auto)]
+        public static extern int ShowWindow(IntPtr hWnd, short cmdShow);
+
+        [DllImport("User32.dll", CharSet=CharSet.Auto)]
+        public static extern int SetWindowPos(IntPtr hWnd, IntPtr hWndAfter, int X, int Y, int Width, int Height, FlagsSetWindowPos flags);
+
+		[DllImport("user32.dll", CharSet = CharSet.Auto)]
+		public static extern int GetWindowLong(IntPtr hWnd, int Index);
+
+		[DllImport("user32.dll", CharSet = CharSet.Auto)]
+		public static extern int SetWindowLong(IntPtr hWnd, int Index, int Value);
+
+		[DllImport("user32.dll", CharSet=CharSet.Auto)]
+		public static extern int ShowScrollBar(IntPtr hWnd, int wBar, int bShow);
+
+		[DllImport("user32.dll", CharSet=CharSet.Auto)]
+        //*********************************
+        // FxCop bug, suppress the message
+        //*********************************
+        [SuppressMessage("Microsoft.Portability", "CA1901:PInvokeDeclarationsShouldBePortable", MessageId = "0")]
+		public static extern IntPtr WindowFromPoint(Point point);
+
+        [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
+        public static extern int GetCurrentThreadId();
+
+        public delegate IntPtr HookProc(int code, IntPtr wParam, IntPtr lParam);
+
+        [DllImport("user32.dll")]
+        public static extern IntPtr SetWindowsHookEx(Win32.HookType code, HookProc func, IntPtr hInstance, int threadID);
+
+        [DllImport("user32.dll")]
+        public static extern int UnhookWindowsHookEx(IntPtr hhook);
+
+        [DllImport("user32.dll")]
+        public static extern IntPtr CallNextHookEx(IntPtr hhook, int code, IntPtr wParam, IntPtr lParam);
+	}
+}
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Properties/AssemblyInfo.cs
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Properties/AssemblyInfo.cs	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Properties/AssemblyInfo.cs	(revision 8616)
@@ -0,0 +1,27 @@
+﻿using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyTitle("DockPanel Suite for .Net")]
+[assembly: AssemblyDescription(".Net Docking Library for Windows Forms")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Weifen Luo")]
+[assembly: AssemblyProduct("DockPanel Suite")]
+[assembly: AssemblyCopyright("Copyright © Weifen Luo and other contributors 2007-2012")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: CLSCompliant(true)]
+
+[assembly: ComVisible(false)]
+
+[assembly: Guid("9d690ef9-ce19-4c69-874c-e24d8eb36aff")]
+
+[assembly: AssemblyVersion("2.7.0.0")]
+[assembly: AssemblyFileVersion("2.7.0.0")]
+
+[module: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", Scope = "namespace", Target = "WeifenLuo.WinFormsUI.Docking", MessageId = "Weifen")]
+[module: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", Scope = "namespace", Target = "WeifenLuo.WinFormsUI.Docking", MessageId = "Luo")]
+[module: SuppressMessage("Microsoft.Naming", "CA1703:ResourceStringsShouldBeSpelledCorrectly", Scope = "resource", Target = "WeifenLuo.WinFormsUI.Docking.Strings.resources", MessageId = "Weifen")]
+[module: SuppressMessage("Microsoft.Naming", "CA1703:ResourceStringsShouldBeSpelledCorrectly", Scope = "resource", Target = "WeifenLuo.WinFormsUI.Docking.Strings.resources", MessageId = "Luo")]
+[module: SuppressMessage("Microsoft.Naming", "CA1703:ResourceStringsShouldBeSpelledCorrectly", Scope = "resource", Target = "WeifenLuo.WinFormsUI.Docking.Strings.resources", MessageId = "Dockable")]
Index: /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/WinFormsUI-2.7.0.csproj
===================================================================
--- /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/WinFormsUI-2.7.0.csproj	(revision 8616)
+++ /trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/WinFormsUI-2.7.0.csproj	(revision 8616)
@@ -0,0 +1,267 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{EAF5F178-406C-4844-B1DC-D3AAF3992FDF}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>WeifenLuo.WinFormsUI</RootNamespace>
+    <AssemblyName>WeifenLuo.WinFormsUI.Docking-2.7.0</AssemblyName>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE;DEBUG</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE;DEBUG</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE;DEBUG</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Design" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Docking\AutoHideStripBase.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\DockAreasEditor.cs" />
+    <Compile Include="Docking\DockContent.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Docking\DockContentCollection.cs" />
+    <Compile Include="Docking\DockContentEventArgs.cs" />
+    <Compile Include="Docking\DockContentHandler.cs" />
+    <Compile Include="Docking\DockOutlineBase.cs" />
+    <Compile Include="Docking\DockPane.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="Docking\DockPane.SplitterControl.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="Docking\DockPaneCaptionBase.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\DockPaneCollection.cs" />
+    <Compile Include="Docking\DockPanel.Appearance.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\DockPanel.AutoHideWindow.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\DockPanel.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\DockPanel.DockDragHandler.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\DockPanel.DragHandler.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\DockPanel.FocusManager.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\DockPanel.MdiClientController.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\DockPanel.Persistor.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\DockPanel.SplitterDragHandler.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\DockPanelExtender.cs" />
+    <Compile Include="Docking\DockPanelSkin.cs" />
+    <Compile Include="Docking\DockPaneStripBase.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\DockWindow.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\DockWindow.SplitterControl.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\DockWindowCollection.cs" />
+    <Compile Include="Docking\DragForm.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Docking\DummyControl.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\Enums.cs" />
+    <Compile Include="Docking\FloatWindow.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Docking\FloatWindowCollection.cs" />
+    <Compile Include="Docking\Helpers\DockHelper.cs" />
+    <Compile Include="Docking\Helpers\DrawHelper.cs" />
+    <Compile Include="Docking\Helpers\ResourceHelper.cs" />
+    <Compile Include="Docking\Helpers\Win32Helper.cs" />
+    <Compile Include="Docking\InertButtonBase.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\Interfaces.cs" />
+    <Compile Include="Docking\Localization.cs" />
+    <Compile Include="Docking\Measures.cs" />
+    <Compile Include="Docking\NestedDockingStatus.cs" />
+    <Compile Include="Docking\NestedPaneCollection.cs" />
+    <Compile Include="Docking\Resources.Designer.cs" />
+    <Compile Include="Docking\Skins\DockPanelSkinBuilder.cs" />
+    <Compile Include="Docking\Skins\Style.cs" />
+    <Compile Include="Docking\SplitterBase.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\Strings.Designer.cs" />
+    <Compile Include="Docking\VisibleNestedPaneCollection.cs" />
+    <Compile Include="Docking\VS2005AutoHideStrip.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\VS2005DockPaneCaption.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\VS2005DockPaneStrip.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Docking\Win32\Enums.cs" />
+    <Compile Include="Docking\Win32\NativeMethods.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Docking\Resources\Thumbs.db" />
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 3.1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <ItemGroup />
+  <ItemGroup>
+    <Content Include="Docking\DockPanel.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PaneDiamond.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PaneDiamond_Bottom.bmp" />
+    <Content Include="Docking\Resources\Dockindicator_PaneDiamond_Fill.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PaneDiamond_Hotspot.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PaneDiamond_HotspotIndex.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PaneDiamond_Left.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PaneDiamond_Right.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PaneDiamond_Top.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PanelBottom.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PanelBottom_Active.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PanelFill.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PanelFill_Active.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PanelLeft.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PanelLeft_Active.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PanelRight.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PanelRight_Active.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PanelTop.bmp" />
+    <Content Include="Docking\Resources\DockIndicator_PanelTop_Active.bmp" />
+    <Content Include="Docking\Resources\DockPane_AutoHide.bmp" />
+    <Content Include="Docking\Resources\DockPane_Close.bmp" />
+    <Content Include="Docking\Resources\DockPane_Dock.bmp" />
+    <Content Include="Docking\Resources\DockPane_Option.bmp" />
+    <Content Include="Docking\Resources\DockPane_OptionOverflow.bmp" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Docking\Resources.resx" />
+    <EmbeddedResource Include="Docking\Strings.resx" />
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
