big transformation , using DockPanels now

it feels good to me!
-Thoys

git-svn-id: https://lsleditor.svn.sourceforge.net/svnroot/lsleditor@26 3f4676ac-adda-40fd-8265-58d1435b1672

trunk/Browser.cs

@@ -46,10 +46,11 @@ using System.ComponentModel;
 using System.Drawing;
 using System.Drawing.Imaging;
 using System.Windows.Forms;
+using LSLEditor.Docking;
 
 namespace LSLEditor
 {
-	public partial class Browser : Form
+	public partial class Browser : DockContent
 	{
 		private LSLEditorForm lslEditorForm;
 

trunk/Docking/AutoHideStripBase.cs

@@ -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 LSLEditor.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);
+	}
+}

trunk/Docking/DockAreasEditor.cs

@@ -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 LSLEditor.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;
+		}
+	}
+}

trunk/Docking/DockContent.cs

@@ -0,0 +1,304 @@
+using System;
+using System.ComponentModel;
+using System.Drawing;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+using System.Diagnostics.CodeAnalysis;
+
+namespace LSLEditor.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;	}
+		}
+
+		[Localizable(true)]
+		[LocalizedCategory("Category_Docking")]
+		[LocalizedDescription("DockContent_TabText_Description")]
+		[DefaultValue(null)]
+        private string m_tabText = 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)]
+		public DockPanel DockPanel
+		{
+			get {	return DockHandler.DockPanel; }
+			set	{	DockHandler.DockPanel = value;	}
+		}
+
+		[Browsable(false)]
+		public DockState DockState
+		{
+			get	{	return DockHandler.DockState;	}
+			set	{	DockHandler.DockState = value;	}
+		}
+
+		[Browsable(false)]
+		public DockPane Pane
+		{
+			get {	return DockHandler.Pane; }
+			set	{	DockHandler.Pane = value;		}
+		}
+
+		[Browsable(false)]
+		public bool IsHidden
+		{
+			get	{	return DockHandler.IsHidden;	}
+			set	{	DockHandler.IsHidden = value;	}
+		}
+
+		[Browsable(false)]
+		public DockState VisibleState
+		{
+			get	{	return DockHandler.VisibleState;	}
+			set	{	DockHandler.VisibleState = value;	}
+		}
+
+		[Browsable(false)]
+		public bool IsFloat
+		{
+			get	{	return DockHandler.IsFloat;	}
+			set	{	DockHandler.IsFloat = value;	}
+		}
+
+		[Browsable(false)]
+		public DockPane PanelPane
+		{
+			get	{	return DockHandler.PanelPane;	}
+			set	{	DockHandler.PanelPane = value;	}
+		}
+
+		[Browsable(false)]
+		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
+	}
+}

trunk/Docking/DockContentCollection.cs

@@ -0,0 +1,175 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace LSLEditor.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;
+        }
+    }
+}

trunk/Docking/DockContentEventArgs.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace LSLEditor.Docking
+{
+	public class DockContentEventArgs : EventArgs
+	{
+		private IDockContent m_content;
+
+		public DockContentEventArgs(IDockContent content)
+		{
+			m_content = content;
+		}
+
+		public IDockContent Content
+		{
+			get	{	return m_content;	}
+		}
+	}
+}

trunk/Docking/DockOutlineBase.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace LSLEditor.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();
+        }
+    }
+}

trunk/Docking/DockPane.SplitterControl.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace LSLEditor.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; }
+        }
+    }
+}

trunk/Docking/DockPaneCaptionBase.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.Security.Permissions;
+
+namespace LSLEditor.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();
+	}
+}

trunk/Docking/DockPaneCollection.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.ObjectModel;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace LSLEditor.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);
+		}
+	}
+}

trunk/Docking/DockPaneStripBase.cs

@@ -0,0 +1,252 @@
+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 LSLEditor.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();
+            if (index != -1)
+            {
+                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;
+            }
+        }
+	}
+}

trunk/Docking/DockPanel.AutoHideWindow.cs

@@ -0,0 +1,612 @@
+using System;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Runtime.InteropServices;
+
+namespace LSLEditor.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)
+                            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();
+        }
+
+    }
+}

trunk/Docking/DockPanel.DockDragHandler.cs

@@ -0,0 +1,814 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.ComponentModel;
+
+namespace LSLEditor.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 = 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);
+        }
+    }
+}

trunk/Docking/DockPanel.DragHandler.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.ComponentModel;
+
+namespace LSLEditor.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 (!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);
+            }
+        }
+    }
+}

trunk/Docking/DockPanel.FocusManager.cs

@@ -0,0 +1,568 @@
+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 LSLEditor.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 LocalWindowsHook m_localWindowsHook;
+            private LocalWindowsHook.HookEventHandler m_hookEventHandler;
+
+            public FocusManagerImpl(DockPanel dockPanel)
+            {
+                m_dockPanel = dockPanel;
+                m_localWindowsHook = new LocalWindowsHook(Win32.HookType.WH_CALLWNDPROCRET);
+                m_hookEventHandler = new LocalWindowsHook.HookEventHandler(HookEventHandler);
+                m_localWindowsHook.HookInvoked += m_hookEventHandler;
+                m_localWindowsHook.Install();
+            }
+
+            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)
+                    {
+                        m_localWindowsHook.Dispose();
+                        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))
+                    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
+                        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++;
+                m_localWindowsHook.HookInvoked -= m_hookEventHandler;
+            }
+
+            public void ResumeFocusTracking()
+            {
+                if (m_countSuspendFocusTracking > 0)
+                    m_countSuspendFocusTracking--;
+
+                if (m_countSuspendFocusTracking == 0)
+                {
+                    if (ContentActivating != null)
+                    {
+                        Activate(ContentActivating);
+                        ContentActivating = null;
+                    }
+                    m_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 = 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);
+        }
+    }
+}

trunk/Docking/DockPanel.MdiClientController.cs

@@ -0,0 +1,430 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.Runtime.InteropServices;
+
+namespace LSLEditor.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
+
+                    // 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)]
+            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)
+                            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.
+                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;
+        }
+    }
+}

trunk/Docking/DockPanel.Persistor.cs

@@ -0,0 +1,781 @@
+using System;
+using System.ComponentModel;
+using System.Windows.Forms;
+using System.Drawing;
+using LSLEditor.Docking;
+using System.IO;
+using System.Text;
+using System.Xml;
+using System.Globalization;
+
+namespace LSLEditor.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));
+                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);
+        }
+    }
+}

trunk/Docking/DockPanel.SplitterDragHandler.cs

@@ -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 LSLEditor.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);
+        }
+    }
+}

trunk/Docking/DockPanelExtender.cs

@@ -0,0 +1,225 @@
+using System;
+using System.Drawing;
+using System.Diagnostics.CodeAnalysis;
+
+namespace LSLEditor.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();
+			}
+		}
+	}
+}

trunk/Docking/DockPanelSkin.cs

@@ -0,0 +1,421 @@
+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 LSLEditor.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;
+        private DockPaneStripSkin m_dockPaneStripSkin;
+
+        public DockPanelSkin()
+        {
+            m_autoHideStripSkin = new AutoHideStripSkin();
+            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;
+        private TabGradient m_TabGradient;
+
+        public AutoHideStripSkin()
+        {
+            m_dockStripGradient = new DockPanelGradient();
+            m_dockStripGradient.StartColor = SystemColors.ControlLight;
+            m_dockStripGradient.EndColor = SystemColors.ControlLight;
+
+            m_TabGradient = new TabGradient();
+            m_TabGradient.TextColor = SystemColors.ControlDarkDark;
+        }
+
+        /// <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>
+    /// The skin used to display the document and tool strips and tabs.
+    /// </summary>
+    [TypeConverter(typeof(DockPaneStripConverter))]
+    public class DockPaneStripSkin
+    {
+        private DockPaneStripGradient m_DocumentGradient;
+        private DockPaneStripToolWindowGradient m_ToolWindowGradient;
+
+        public DockPaneStripSkin()
+        {
+            m_DocumentGradient = new DockPaneStripGradient();
+            m_DocumentGradient.DockStripGradient.StartColor = SystemColors.Control;
+            m_DocumentGradient.DockStripGradient.EndColor = SystemColors.Control;
+            m_DocumentGradient.ActiveTabGradient.StartColor = SystemColors.ControlLightLight;
+            m_DocumentGradient.ActiveTabGradient.EndColor = SystemColors.ControlLightLight;
+            m_DocumentGradient.InactiveTabGradient.StartColor = SystemColors.ControlLight;
+            m_DocumentGradient.InactiveTabGradient.EndColor = SystemColors.ControlLight;
+
+            m_ToolWindowGradient = new DockPaneStripToolWindowGradient();
+            m_ToolWindowGradient.DockStripGradient.StartColor = SystemColors.ControlLight;
+            m_ToolWindowGradient.DockStripGradient.EndColor = SystemColors.ControlLight;
+            
+            m_ToolWindowGradient.ActiveTabGradient.StartColor = SystemColors.Control;
+            m_ToolWindowGradient.ActiveTabGradient.EndColor = SystemColors.Control;
+            
+            m_ToolWindowGradient.InactiveTabGradient.StartColor = Color.Transparent;
+            m_ToolWindowGradient.InactiveTabGradient.EndColor = Color.Transparent;
+            m_ToolWindowGradient.InactiveTabGradient.TextColor = SystemColors.ControlDarkDark;
+            
+            m_ToolWindowGradient.ActiveCaptionGradient.StartColor = SystemColors.GradientActiveCaption;
+            m_ToolWindowGradient.ActiveCaptionGradient.EndColor = SystemColors.ActiveCaption;
+            m_ToolWindowGradient.ActiveCaptionGradient.LinearGradientMode = LinearGradientMode.Vertical;
+            m_ToolWindowGradient.ActiveCaptionGradient.TextColor = SystemColors.ActiveCaptionText;
+
+            m_ToolWindowGradient.InactiveCaptionGradient.StartColor = SystemColors.GradientInactiveCaption;
+            m_ToolWindowGradient.InactiveCaptionGradient.EndColor = SystemColors.GradientInactiveCaption;
+            m_ToolWindowGradient.InactiveCaptionGradient.LinearGradientMode = LinearGradientMode.Vertical;
+            m_ToolWindowGradient.InactiveCaptionGradient.TextColor = SystemColors.ControlText;
+        }
+
+        /// <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>
+    /// The skin used to display the DockPane ToolWindow strip and tab.
+    /// </summary>
+    [TypeConverter(typeof(DockPaneStripGradientConverter))]
+    public class DockPaneStripToolWindowGradient : DockPaneStripGradient
+    {
+        private TabGradient m_activeCaptionGradient;
+        private TabGradient m_inactiveCaptionGradient;
+
+        public DockPaneStripToolWindowGradient()
+        {
+            m_activeCaptionGradient = new 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;
+        private TabGradient m_activeTabGradient;
+        private TabGradient m_inactiveTabGradient;
+
+        public DockPaneStripGradient()
+        {
+            m_dockStripGradient = new DockPanelGradient();
+            m_activeTabGradient = new 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;
+
+        public TabGradient()
+        {
+            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;
+        private Color m_endColor;
+        private LinearGradientMode m_linearGradientMode;
+
+        public DockPanelGradient()
+        {
+            m_startColor = SystemColors.Control;
+            m_endColor = SystemColors.Control;
+            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)
+        {
+            if (destinationType == typeof(String) && value is TabGradient)
+            {
+                return "DockPaneTabGradient";
+            }
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+    }
+    #endregion
+}

trunk/Docking/DockWindow.SplitterControl.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace LSLEditor.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));
+            }
+        }
+    }
+}

trunk/Docking/DockWindow.cs

@@ -0,0 +1,243 @@
+using System;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.ComponentModel;
+
+namespace LSLEditor.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
+    }
+}

trunk/Docking/DockWindowCollection.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace LSLEditor.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());
+			}
+		}
+	}
+}

trunk/Docking/DragForm.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Windows.Forms;
+
+namespace LSLEditor.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_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);
+		}
+
+		public virtual void Show(bool bActivate)
+		{
+			if (bActivate)
+				Show();
+			else
+				NativeMethods.ShowWindow(Handle, (int)Win32.ShowWindowStyles.SW_SHOWNOACTIVATE);
+		}
+	}
+}

trunk/Docking/DummyControl.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Windows.Forms;
+
+namespace LSLEditor.Docking
+{
+	internal class DummyControl : Control
+	{
+		public DummyControl()
+		{
+			SetStyle(ControlStyles.Selectable, false);
+		}
+	}
+}

trunk/Docking/Enums.cs

@@ -0,0 +1,60 @@
+using System;
+using System.ComponentModel;
+using System.Windows.Forms;
+
+namespace LSLEditor.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
+    }
+}

trunk/Docking/FloatWindow.cs

@@ -0,0 +1,453 @@
+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 LSLEditor.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)
+				Text = " ";	// use " " instead of string.Empty because the whole title bar will disappear when ControlBox is set to false.
+			else if (theOnlyPane.ActiveContent == null)
+				Text = " ";
+			else
+				Text = theOnlyPane.ActiveContent.DockHandler.TabText;
+		}
+
+		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 = 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 = 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 = 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 (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;
+        }
+
+        Rectangle IDockDragSource.BeginDrag(Point ptMouse)
+        {
+            return Bounds;
+        }
+
+        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
+    }
+}

trunk/Docking/FloatWindowCollection.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace LSLEditor.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);
+		}
+	}
+}

trunk/Docking/Helpers/DockHelper.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace LSLEditor.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)
+		{
+			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)
+		{
+			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;
+		}
+	}
+}

trunk/Docking/Helpers/DrawHelper.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Drawing.Imaging;
+using System.Windows.Forms;
+
+namespace LSLEditor.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; 
+		} 
+	}
+}

trunk/Docking/Helpers/ResourceHelper.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Drawing;
+using System.Reflection;
+using System.Resources;
+using System.Windows.Forms;
+
+namespace LSLEditor.Docking
+{
+	internal static class ResourceHelper
+	{
+        private static ResourceManager _resourceManager = null;
+
+        private static ResourceManager ResourceManager
+        {
+            get
+            {
+                if (_resourceManager == null)
+                    _resourceManager = new ResourceManager("LSLEditor.Docking.Strings", typeof(ResourceHelper).Assembly);
+                return _resourceManager;
+            }
+
+        }
+
+		public static string GetString(string name)
+		{
+			return ResourceManager.GetString(name);
+		}
+	}
+}

trunk/Docking/Helpers/Win32Helper.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace LSLEditor.Docking
+{
+	internal static class Win32Helper
+	{
+		public static Control ControlAtPoint(Point pt)
+		{
+			return Control.FromChildHandle(NativeMethods.WindowFromPoint(pt));
+		}
+
+		public static uint MakeLong(int low, int high)
+		{
+			return (uint)((high << 16) + low);
+		}
+	}
+}

trunk/Docking/InertButtonBase.cs

@@ -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 LSLEditor.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()
+        {
+        }
+    }
+}

trunk/Docking/Interfaces.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace LSLEditor.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);
+        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);
+    }
+}

trunk/Docking/Localization.cs

@@ -0,0 +1,46 @@
+using System;
+using System.ComponentModel;
+
+namespace LSLEditor.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);
+		}
+	}
+}

trunk/Docking/Measures.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace LSLEditor.Docking
+{
+	internal static class Measures
+	{
+		public const int SplitterSize = 4;
+	}
+
+	internal static class MeasurePane
+	{
+		public const int MinSize = 24;
+	}
+}

trunk/Docking/NestedDockingStatus.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Drawing;
+
+namespace LSLEditor.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;
+		}
+	}
+}

trunk/Docking/NestedPaneCollection.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Drawing;
+
+namespace LSLEditor.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)
+					NativeMethods.PostMessage(((FloatWindow)Container).Handle, FloatWindow.WM_CHECKDISPOSE, 0, 0);
+			}
+		}
+
+		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;
+		}
+	}
+}

trunk/Docking/Resources.Designer.cs

@@ -0,0 +1,225 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:2.0.50727.3603
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace LSLEditor.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("LSLEditor.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));
+            }
+        }
+    }
+}

trunk/Docking/Resources.resx

@@ -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>

trunk/Docking/SplitterBase.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace LSLEditor.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);
+		}
+	}
+}

trunk/Docking/Strings.Designer.cs

@@ -0,0 +1,774 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:2.0.50727.3603
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace LSLEditor.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("LSLEditor.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 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 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 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);
+            }
+        }
+    }
+}

trunk/Docking/Strings.resx

@@ -0,0 +1,357 @@
+<?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_DocumentTabStripLocation" xml:space="preserve">
+    <value>Determines where the tab strip for Document style content is drawn.</value>
+  </data>
+</root>

trunk/Docking/VS2005AutoHideStrip.cs

@@ -0,0 +1,505 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+using System.Drawing.Drawing2D;
+using System.ComponentModel;
+
+namespace LSLEditor.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
+        private static Font TextFont
+        {
+            get { return SystemInformation.MenuFont; }
+        }
+
+		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);
+			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))
+				{
+                    DockState dockState = pane.DockPane.DockState;
+					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);
+        }
+	}
+}

trunk/Docking/VS2005DockPaneCaption.cs

@@ -0,0 +1,478 @@
+using System;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Windows.Forms;
+using System.ComponentModel;
+using System.Windows.Forms.VisualStyles;
+
+namespace LSLEditor.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;	}
+		}
+
+        private static Font TextFont
+        {
+            get { return SystemInformation.MenuFont; }
+        }
+
+		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;
+
+		}
+
+        private void Options_Click(object sender, EventArgs e)
+        {
+            ShowTabPageContextMenu(PointToClient(Control.MousePosition));
+        }
+
+        protected override void OnRightToLeftChanged(EventArgs e)
+        {
+            base.OnRightToLeftChanged(e);
+            PerformLayout();
+        }
+	}
+}

trunk/Docking/VisibleNestedPaneCollection.cs

@@ -0,0 +1,168 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace LSLEditor.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);
+			}
+		}
+	}
+}

trunk/Docking/Win32/Enums.cs

@@ -0,0 +1,369 @@
+using System;
+
+namespace LSLEditor.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
+	}
+
+	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
+    }
+}

trunk/Docking/Win32/NativeMethods.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.Diagnostics.CodeAnalysis;
+using LSLEditor.Docking.Win32;
+
+namespace LSLEditor.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);
+	}
+}

trunk/EditForm.cs

@@ -46,12 +46,12 @@ using System.IO;
 using System.Xml;
 using System.Drawing;
 using System.Windows.Forms;
-
+using LSLEditor.Docking;
 using LSLEditor.Helpers;
 
 namespace LSLEditor
 {
-	public partial class EditForm : Form
+	public partial class EditForm : DockContent
 	{
 		public RuntimeConsole runtime;
 
@@ -182,7 +182,7 @@ namespace LSLEditor
 
 		void EditForm_Position(object sender, EventArgs e)
 		{
-			this.numberedTextBoxUC1.TextBox.SetPosition(this.MdiParent.RectangleToScreen(this.MdiParent.ClientRectangle));
+			//this.numberedTextBoxUC1.TextBox.SetPosition(this.MdiParent.RectangleToScreen(this.MdiParent.ClientRectangle));
 		}
 
 		void TextBox_OnDirtyChanged(object sender, EventArgs e)
@@ -195,8 +195,9 @@ namespace LSLEditor
 			TabPage tabPage = this.Tag as TabPage;
 			if (tabPage != null)
 				tabPage.Text = this.Text;
+
 			this.parent.OnDirtyChanged(this.numberedTextBoxUC1.TextBox.Dirty);
-		}
+        }
 
 		private void exitToolStripMenuItem_Click(object sender, EventArgs e)
 		{

trunk/LSLEditorForm.cs

@@ -54,6 +54,7 @@ using System.Globalization;
 using System.Windows.Forms;
 using System.Drawing.Printing;
 
+using LSLEditor.Docking;
 // aximp is oude informatie, maar ik laat het er even instaan
 // aximp %WINDIR%\System32\shdocvw.dll /out:"d:\temp\AxInterop.SHDocVw.dll" /keyfile:"D:\Documents and Settings\Administrator\Mijn documenten\Mijn keys\Test.snk"
 // copieer de TWEE files AxInterop.SHDocVw.dll en SHDocVw.dll in de bin/Debug directory
@@ -87,8 +88,11 @@ namespace LSLEditor
 		private Browser browser;
 		private SimulatorConsole SimulatorConsole;
         
+
 		public bool CancelClosing = false;
 
+        public Solution.SolutionExplorer m_SolutionExplorer;
+
 		public GListBoxWindow GListBoxWindow;
 		public TooltipWindow TooltipMouse;
 		public TooltipWindow TooltipKeyboard;
@@ -126,7 +130,7 @@ namespace LSLEditor
 		{
 			get
 			{
-				return this.solutionExplorer1;
+                return this.m_SolutionExplorer;
 			}
 		}
 
@@ -170,6 +174,9 @@ namespace LSLEditor
 
 			InitializeComponent();
 
+            m_SolutionExplorer = new LSLEditor.Solution.SolutionExplorer();
+            m_SolutionExplorer.parent = this;
+
 			InitRecentFileList();
 			InitRecentProjectList();
 			InitPluginsList();
@@ -194,8 +201,9 @@ namespace LSLEditor
 					return this.MdiChildren;
 
 				List<Form> children = new List<Form>();
-				foreach (TabPage tabPage in this.tabControlExtended1.TabPages)
-					children.Add(tabPage.Tag as Form);
+			//TODO: Find Child forms
+                //foreach (TabPage tabPage in this.tabControlExtended1.TabPages)
+				//	children.Add(tabPage.Tag as Form);
 				return children.ToArray();
 			}
 		}
@@ -208,9 +216,12 @@ namespace LSLEditor
 					return this.ActiveMdiChild;
 				else
 				{
-					if (this.tabControlExtended1.SelectedTab == null)
-						return null;
-					return this.tabControlExtended1.SelectedTab.Tag as Form;
+                    //TODO: Get Active Mdi Form
+                    return null;
+                    //dockPanel.ActiveContent
+				//	if (this.tabControlExtended1.SelectedTab == null)
+				//		return null;
+				//	return this.tabControlExtended1.SelectedTab.Tag as Form;
 				}
 			}		
 		}
@@ -223,7 +234,8 @@ namespace LSLEditor
 			}
 			else
 			{
-				for (int intI = 0; intI < this.tabControlExtended1.TabCount; intI++)
+                //TODO: Activate the right Mdi Form
+				/*for (int intI = 0; intI < this.tabControlExtended1.TabCount; intI++)
 				{
 					TabPage tabPage = this.tabControlExtended1.TabPages[intI];
 					EditForm f = tabPage.Tag as EditForm;
@@ -233,32 +245,40 @@ namespace LSLEditor
 						tabPage.Focus();
 						break;
 					}
-				}
+				}*/
 			}
 		}
 
-		public void AddForm(Form form)
+		public void AddForm(DockContent form)
 		{
 			if (this.IsMdiContainer)
 			{
-				form.MdiParent = this;
-				form.Tag = null;
-				form.Show();
-				ActivateMdiChild(form);
+				//form.MdiParent = this;
+				//form.Tag = null;
+				//form.Show();
+				//ActivateMdiChild(form);
+
+                //TODO: add form in the right way
+                form.Show(dockPanel);
 			}
 			else
 			{
-				form.Visible = false;
-				form.MdiParent = null;
-				TabPage tabPage = new TabPage(form.Text+"   ");
-				tabPage.BackColor = Color.White;
-				for(int intI=form.Controls.Count-1;intI>=0;intI--)
-					tabPage.Controls.Add(form.Controls[intI]);
-				tabPage.Tag = form;
-				form.Tag = tabPage;
-				//tabPage.Controls.Add(form.Controls[0]);
-				this.tabControlExtended1.TabPages.Add(tabPage);
-				this.tabControlExtended1.SelectedTab = tabPage;
+                
+                
+
+				//form.Visible = false;
+				//form.MdiParent = null;
+				//TabPage tabPage = new TabPage(form.Text+"   ");
+				//tabPage.BackColor = Color.White;
+				//for(int intI=form.Controls.Count-1;intI>=0;intI--)
+				//	tabPage.Controls.Add(form.Controls[intI]);
+				//tabPage.Tag = form;
+				//form.Tag = tabPage;
+				// Was already commented out //tabPage.Controls.Add(form.Controls[0]);
+				
+                
+                //this.tabControlExtended1.TabPages.Add(tabPage);
+				//this.tabControlExtended1.SelectedTab = tabPage;
 			}
 		}
 
@@ -305,9 +325,10 @@ namespace LSLEditor
 					this.Text += " (BETA)";
 			}
             
+            //TODO: Fix close buttons on tabs
 			// enables close buttons on tab
-			this.tabControlExtended1.SetDrawMode();
-			this.tabControlExtended1.OnTabClose += new EventHandler(tabControl1_OnTabClose);
+			//this.tabControlExtended1.SetDrawMode();
+			//this.tabControlExtended1.OnTabClose += new EventHandler(tabControl1_OnTabClose);
 
 			if (args.Length == 0)
 			{
@@ -646,7 +667,8 @@ namespace LSLEditor
 			}
 			else
 			{
-				for (int intI = 0; intI < this.tabControlExtended1.TabCount; intI++)
+                //TODO: find browser in childs
+				/*for (int intI = 0; intI < this.tabControlExtended1.TabCount; intI++)
 				{
 					TabPage tabPage = this.tabControlExtended1.TabPages[intI];
 					Browser b = tabPage.Tag as Browser;
@@ -656,7 +678,7 @@ namespace LSLEditor
 						tabPage.Focus();
 						break;
 					}
-				}
+				}*/
 			}
 
 			return this.browser;
@@ -887,8 +909,9 @@ namespace LSLEditor
 
 			SetFontsOnWindows();
 
-			this.solutionExplorer1.parent = this;
-			this.solutionExplorer1.CreateNewFileDrowDownMenu(this.addNewFileToolStripMenuItem);
+            //TODO: Fix new file drop down
+			//this.solutionExplorer1.parent = this;
+			//this.solutionExplorer1.CreateNewFileDrowDownMenu(this.addNewFileToolStripMenuItem);
 			this.solutionExplorerToolStripMenuItem.Checked = Properties.Settings.Default.ShowSolutionExplorer;
 			ShowSolutionExplorer(this.solutionExplorerToolStripMenuItem.Checked);
 
@@ -958,7 +981,8 @@ namespace LSLEditor
 		{
 			try
 			{
-				this.tabControlExtended1.Visible = false;
+                //TODO: hmmm?
+				//this.tabControlExtended1.Visible = false;
 
 				// this.panel1.Visible = false; // Simulator
 				// this.panel2.Visible = false; // right pane
@@ -980,12 +1004,6 @@ namespace LSLEditor
 				this.browserInWindowToolStripMenuItem.Checked = 
 					Properties.Settings.Default.BrowserInWindow;
 
-				this.tabbedViewToolStripMenuItem.Checked =
-					Properties.Settings.Default.TabbedDocument;
-
-				if (this.tabbedViewToolStripMenuItem.Checked)
-					SwitchDocumentView();
-
 				this.WikiSepBrowserstoolStripMenuItem.Checked =
 					Properties.Settings.Default.WikiSeperateBrowser;
 
@@ -1116,26 +1134,6 @@ namespace LSLEditor
 			browser.ShowWebBrowser("Check for Updates", Properties.Settings.Default.Update + strVersion);
 		}
 
-		private void horizontalToolStripMenuItem_Click(object sender, EventArgs e)
-		{
-			this.LayoutMdi(MdiLayout.TileHorizontal);
-		}
-
-		private void verticalToolStripMenuItem_Click(object sender, EventArgs e)
-		{
-			this.LayoutMdi(MdiLayout.TileVertical);
-		}
-
-		private void cascadeToolStripMenuItem_Click(object sender, EventArgs e)
-		{
-			this.LayoutMdi(MdiLayout.Cascade);
-		}
-
-		private void normalToolStripMenuItem_Click(object sender, EventArgs e)
-		{
-			this.LayoutMdi(MdiLayout.ArrangeIcons);
-		}
-
 		private void browserInWindowToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			this.browserInWindowToolStripMenuItem.Checked = !this.browserInWindowToolStripMenuItem.Checked;
@@ -1181,15 +1179,19 @@ namespace LSLEditor
 				return;
 
 			this.SimulatorConsole = new SimulatorConsole(this.SolutionExplorer, this.Children);
-			this.panel1.Controls.Clear();
-			this.panel1.Controls.Add(this.SimulatorConsole);
-			this.panel1.Visible = true;
-			this.splitter1.SplitPosition = Properties.Settings.Default.SimulatorSize.Height;
+
+            this.SimulatorConsole.Show(dockPanel);
+            //TODO: Show Simulator Console somewhere
+            //this.panel1.Controls.Clear();
+			//this.panel1.Controls.Add(this.SimulatorConsole);
+			//this.panel1.Visible = true;
+			//this.splitter1.SplitPosition = Properties.Settings.Default.SimulatorSize.Height;
 		}
 
 		public void StopSimulator()
 		{
-			this.panel1.Visible = false;
+            //TODO: Hide simulator? Or we could keep it like the debug output in VS
+			//this.panel1.Visible = false;
 			if (this.SimulatorConsole != null)
 			{
 				this.SimulatorConsole.Stop();
@@ -1201,7 +1203,8 @@ namespace LSLEditor
 
 		private bool SyntaxCheck(bool Silent)
 		{
-			this.panel1.Visible = false;
+            //TODO: What do we hide on SyntaxCheck?
+			//this.panel1.Visible = false;
 			InitSyntaxError();
 
 			foreach (Form form in this.Children)
@@ -1219,10 +1222,12 @@ namespace LSLEditor
 
 			if (this.SyntaxErrors.HasErrors)
 			{
-				this.panel1.Controls.Clear();
-				this.panel1.Controls.Add(this.SyntaxErrors);
-				this.panel1.Visible = true;
-				this.splitter1.SplitPosition = Properties.Settings.Default.SimulatorSize.Height;
+                this.SyntaxErrors.Show(dockPanel);
+                //TODO: Show errors somewhere in an output
+				//this.panel1.Controls.Clear();
+				//this.panel1.Controls.Add(this.SyntaxErrors);
+				//this.panel1.Visible = true;
+				//this.splitter1.SplitPosition = Properties.Settings.Default.SimulatorSize.Height;
 				return false;
 			}
 			else
@@ -1253,8 +1258,9 @@ namespace LSLEditor
 
 		private void splitter1_SplitterMoved(object sender, SplitterEventArgs e)
 		{
-			if( this.splitter1.SplitPosition>50)
-				Properties.Settings.Default.SimulatorSize = new Size(this.splitter1.Width, this.splitter1.SplitPosition);
+            //TODO: Splitter moved? I Think this is depricated
+			//if( this.splitter1.SplitPosition>50)
+			//	Properties.Settings.Default.SimulatorSize = new Size(this.splitter1.Width, this.splitter1.SplitPosition);
 		}
 
 		void tabControl1_SelectedIndexChanged(object sender, EventArgs e)
@@ -1265,68 +1271,6 @@ namespace LSLEditor
 			this.TooltipListBox.Visible = false;
 		}
 
-		private void SwitchDocumentView()
-		{
-			bool blnTabbed = this.tabbedViewToolStripMenuItem.Checked;
-
-			this.horizontalToolStripMenuItem.Enabled = !blnTabbed;
-			this.verticalToolStripMenuItem.Enabled = !blnTabbed;
-			this.cascadeToolStripMenuItem.Enabled = !blnTabbed;
-			this.ArangeIconsToolStripMenuItem.Enabled = !blnTabbed;
-
-			if (blnTabbed)
-			{
-				if (!this.IsMdiContainer)
-					return;// no change
-				this.tabControlExtended1.TabPages.Clear();
-				foreach (Form form in this.Children)
-				{
-					//AddForm(editForm);
-					form.Visible = false;
-					form.MdiParent = null;
-					TabPage tabPage = new TabPage(form.Text+"   ");
-					tabPage.BackColor = Color.White;
-					tabPage.Tag = form;
-					form.Tag = tabPage;
-					tabPage.Controls.Add(form.Controls[0]);
-					this.tabControlExtended1.TabPages.Add(tabPage);
-				}
-				this.IsMdiContainer = false;
-				this.tabControlExtended1.Dock = DockStyle.Fill;
-				this.tabControlExtended1.SelectedIndexChanged += new EventHandler(tabControl1_SelectedIndexChanged);
-				this.tabControlExtended1.Visible = true;
-			}
-			else
-			{
-				if (this.IsMdiContainer)
-					return;// no change
-
-				this.tabControlExtended1.Visible = false;
-				//this.tabControl1.Dock = DockStyle.Bottom;
-				this.IsMdiContainer = true;
-				foreach (TabPage tabPage in this.tabControlExtended1.TabPages)
-				{
-					Form form = tabPage.Tag as Form;
-					if (form != null)
-					{
-						form.Tag = null;
-						form.Controls.Add(tabPage.Controls[0]);
-						form.MdiParent = this;
-						form.Visible = true;
-					}
-				}
-				this.tabControlExtended1.TabPages.Clear();
-			}
-			Properties.Settings.Default.TabbedDocument = blnTabbed;
-		}
-
-		private void tabbedViewToolStripMenuItem_Click(object sender, EventArgs e)
-		{
-			this.tabbedViewToolStripMenuItem.Checked = !this.tabbedViewToolStripMenuItem.Checked;
-			Properties.Settings.Default.TabbedDocument = this.tabbedViewToolStripMenuItem.Checked;
-			SwitchDocumentView();
-		}
-
 		private void tabControlExtended1_MouseDown(object sender, MouseEventArgs e)
 		{
 			TabControl tabControl = sender as TabControl;
@@ -1359,14 +1303,19 @@ namespace LSLEditor
 
 		private void CloseTab(int intTabToDelete)
 		{
+            //TODO: Find a new way for closing tabs
+            /*
 			// reset toolstrip information
 			this.toolStripStatusLabel1.Text = "";
 
 			//int intTabToDelete = (int)this.contextMenuStrip1.Tag;
-			if (intTabToDelete >= this.tabControlExtended1.TabCount)
+			
+            if (intTabToDelete >= this.tabControlExtended1.TabCount)
 				return;
-			TabPage tabPage = this.tabControlExtended1.TabPages[intTabToDelete];
-			if (tabPage.Text.Contains("Browser"))
+			
+            TabPage tabPage = this.tabControlExtended1.TabPages[intTabToDelete];
+			
+            if (tabPage.Text.Contains("Browser"))
 			{
 				this.browser.Dispose();
 				this.browser = null;
@@ -1400,6 +1349,7 @@ namespace LSLEditor
 				editForm = null;
 			}
 			this.tabControlExtended1.TabPages[intTabToDelete].Dispose();
+            */
 			GC.Collect();
 		}
 
@@ -1443,10 +1393,14 @@ namespace LSLEditor
 			}
 			else
 			{
-				int intTabToClose = this.tabControlExtended1.SelectedIndex;
+                //TODO: Find a new way
+				/*
+                int intTabToClose = this.tabControlExtended1.SelectedIndex;
 				if (intTabToClose >= 0)
 					CloseTab(intTabToClose);
-			}
+			
+                 */
+            }
 		}
 
 		private void closeActiveWindowToolStripMenuItem_Click(object sender, EventArgs e)
@@ -1537,9 +1491,18 @@ namespace LSLEditor
 
 		public void ShowSolutionExplorer(bool blnVisible)
 		{
-			this.panel2.Visible = blnVisible;
+            //TODO: We need another way to activate the Solution Explorer
+			//this.panel2.Visible = blnVisible;
+            if (blnVisible)
+            {
+                m_SolutionExplorer.Show(dockPanel);
+            }
+            else
+            {
+                m_SolutionExplorer.Hide();
+            }
 			this.solutionExplorerToolStripMenuItem.Checked = blnVisible;
-			this.tabControlExtended1.Refresh();
+			//this.tabControlExtended1.Refresh();
 		}
 
 		private void solutionExplorerToolStripMenuItem_Click(object sender, EventArgs e)
@@ -1660,7 +1623,7 @@ namespace LSLEditor
 			if (CloseAllOpenWindows())
 			{
 				string strPath = tsmi.Tag.ToString();
-				this.solutionExplorer1.OpenSolution(strPath);
+				this.SolutionExplorer.OpenSolution(strPath);
 			}
 		}
 
@@ -1708,9 +1671,7 @@ namespace LSLEditor
 		{
 			this.browserInWindowToolStripMenuItem.Checked = Properties.Settings.Default.BrowserInWindow;
 			this.WikiSepBrowserstoolStripMenuItem.Checked = Properties.Settings.Default.WikiSeperateBrowser;
-			this.tabbedViewToolStripMenuItem.Checked = Properties.Settings.Default.TabbedDocument;
 
-			SwitchDocumentView();
 			SetFontsOnWindows();
 			InitPluginsList();
 		}
@@ -1731,10 +1692,11 @@ namespace LSLEditor
 			{
 				if (lslint.HasErrors)
 				{
-					this.panel1.Controls.Clear();
-					this.panel1.Controls.Add(this.SyntaxErrors);
-					this.panel1.Visible = true;
-					this.splitter1.SplitPosition = Properties.Settings.Default.SimulatorSize.Height;
+                    //TODO: Show errors somewhere else
+					//this.panel1.Controls.Clear();
+					//this.panel1.Controls.Add(this.SyntaxErrors);
+					//this.panel1.Visible = true;
+					//this.splitter1.SplitPosition = Properties.Settings.Default.SimulatorSize.Height;
 				}
 				else
 				{
@@ -1777,7 +1739,8 @@ namespace LSLEditor
 
 		private void PluginsHandler(object sender, EventArgs e)
 		{
-			this.panel1.Visible = false;
+            //TODO: What do we hide here?
+			//this.panel1.Visible = false;
 
 			ToolStripMenuItem tsmi = sender as ToolStripMenuItem;
 			if (tsmi == null)

trunk/Plugins/Generic.cs

@@ -45,6 +45,7 @@ using System;
 using System.IO;
 using System.Windows.Forms;
 using System.Reflection;
+using LSLEditor.Docking;
 
 namespace LSLEditor.Plugins
 {
@@ -83,11 +84,11 @@ namespace LSLEditor.Plugins
 
 			foreach (Type t in assembly.GetTypes())
 			{
-				if (t.BaseType.Name == "Form")
+				if (t.BaseType.Name == "DockContent")
 				{
-					Form form = assembly.CreateInstance(t.FullName, false,
+					DockContent form = assembly.CreateInstance(t.FullName, false,
 						BindingFlags.Public|BindingFlags.Instance|BindingFlags.CreateInstance,
-						null,args,null,null) as Form;
+                        null, args, null, null) as DockContent;
 					if (form != null)
 					{
 						parent.AddForm(form);

trunk/Plugins/Particles.cs

@@ -61,15 +61,15 @@ namespace LSLEditor.Plugins
             Assembly assembly = Assembly.LoadFrom(strProgram);
             Form frmMain = assembly.CreateInstance("Particles.frmMain") as Form;
 
-			if (parent.IsMdiContainer)
+		/*	if (parent.IsMdiContainer)
 			{
 				parent.AddForm(frmMain);
 			}
 			else
-			{
+			{*/
 				//MessageBox.Show("This plugin does not run in tabbed mode", "Particles plugin", MessageBoxButtons.OK, MessageBoxIcon.Error);
                 frmMain.Show();
-			}
+			//}
 		}
 	}
 }

trunk/SimulatorConsole.Designer.cs

@@ -28,139 +28,144 @@ namespace LSLEditor
 		/// </summary>
 		private void InitializeComponent()
 		{
-			this.components = new System.ComponentModel.Container();
-			this.panel1 = new System.Windows.Forms.Panel();
-			this.buttonShout = new System.Windows.Forms.Button();
-			this.buttonSay = new System.Windows.Forms.Button();
-			this.textBox1 = new System.Windows.Forms.TextBox();
-			this.groupBox1 = new System.Windows.Forms.GroupBox();
-			this.textBox2 = new System.Windows.Forms.TextBox();
-			this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components);
-			this.copyToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-			this.selectAllToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-			this.toolStripSeparator1 = new System.Windows.Forms.ToolStripSeparator();
-			this.clearToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-			this.panel1.SuspendLayout();
-			this.groupBox1.SuspendLayout();
-			this.contextMenuStrip1.SuspendLayout();
-			this.SuspendLayout();
-			// 
-			// panel1
-			// 
-			this.panel1.Controls.Add(this.buttonShout);
-			this.panel1.Controls.Add(this.buttonSay);
-			this.panel1.Controls.Add(this.textBox1);
-			this.panel1.Dock = System.Windows.Forms.DockStyle.Bottom;
-			this.panel1.Location = new System.Drawing.Point(4, 180);
-			this.panel1.Name = "panel1";
-			this.panel1.Size = new System.Drawing.Size(507, 35);
-			this.panel1.TabIndex = 0;
-			// 
-			// buttonShout
-			// 
-			this.buttonShout.Location = new System.Drawing.Point(312, 8);
-			this.buttonShout.Name = "buttonShout";
-			this.buttonShout.Size = new System.Drawing.Size(48, 23);
-			this.buttonShout.TabIndex = 2;
-			this.buttonShout.Text = "shout";
-			this.buttonShout.UseVisualStyleBackColor = true;
-			this.buttonShout.Click += new System.EventHandler(this.buttonShout_Click);
-			// 
-			// buttonSay
-			// 
-			this.buttonSay.Location = new System.Drawing.Point(256, 8);
-			this.buttonSay.Name = "buttonSay";
-			this.buttonSay.Size = new System.Drawing.Size(48, 23);
-			this.buttonSay.TabIndex = 1;
-			this.buttonSay.Text = "say";
-			this.buttonSay.UseVisualStyleBackColor = true;
-			this.buttonSay.Click += new System.EventHandler(this.buttonSay_Click);
-			// 
-			// textBox1
-			// 
-			this.textBox1.Location = new System.Drawing.Point(8, 8);
-			this.textBox1.Name = "textBox1";
-			this.textBox1.Size = new System.Drawing.Size(240, 20);
-			this.textBox1.TabIndex = 0;
-			this.textBox1.KeyDown += new System.Windows.Forms.KeyEventHandler(this.textBox1_KeyDown);
-			// 
-			// groupBox1
-			// 
-			this.groupBox1.Controls.Add(this.textBox2);
-			this.groupBox1.Dock = System.Windows.Forms.DockStyle.Fill;
-			this.groupBox1.Location = new System.Drawing.Point(4, 4);
-			this.groupBox1.Name = "groupBox1";
-			this.groupBox1.Size = new System.Drawing.Size(507, 176);
-			this.groupBox1.TabIndex = 1;
-			this.groupBox1.TabStop = false;
-			this.groupBox1.Text = "Console";
-			// 
-			// textBox2
-			// 
-			this.textBox2.AcceptsReturn = true;
-			this.textBox2.AcceptsTab = true;
-			this.textBox2.ContextMenuStrip = this.contextMenuStrip1;
-			this.textBox2.Dock = System.Windows.Forms.DockStyle.Fill;
-			this.textBox2.Location = new System.Drawing.Point(3, 16);
-			this.textBox2.Multiline = true;
-			this.textBox2.Name = "textBox2";
-			this.textBox2.ReadOnly = true;
-			this.textBox2.ScrollBars = System.Windows.Forms.ScrollBars.Both;
-			this.textBox2.Size = new System.Drawing.Size(501, 157);
-			this.textBox2.TabIndex = 0;
-			this.textBox2.KeyDown += new System.Windows.Forms.KeyEventHandler(this.textBox2_KeyDown);
-			// 
-			// contextMenuStrip1
-			// 
-			this.contextMenuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
+            this.components = new System.ComponentModel.Container();
+            this.panel1 = new System.Windows.Forms.Panel();
+            this.buttonShout = new System.Windows.Forms.Button();
+            this.buttonSay = new System.Windows.Forms.Button();
+            this.textBox1 = new System.Windows.Forms.TextBox();
+            this.groupBox1 = new System.Windows.Forms.GroupBox();
+            this.textBox2 = new System.Windows.Forms.TextBox();
+            this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components);
+            this.copyToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
+            this.selectAllToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
+            this.toolStripSeparator1 = new System.Windows.Forms.ToolStripSeparator();
+            this.clearToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
+            this.panel1.SuspendLayout();
+            this.groupBox1.SuspendLayout();
+            this.contextMenuStrip1.SuspendLayout();
+            this.SuspendLayout();
+            // 
+            // panel1
+            // 
+            this.panel1.Controls.Add(this.buttonShout);
+            this.panel1.Controls.Add(this.buttonSay);
+            this.panel1.Controls.Add(this.textBox1);
+            this.panel1.Dock = System.Windows.Forms.DockStyle.Bottom;
+            this.panel1.Location = new System.Drawing.Point(4, 153);
+            this.panel1.Name = "panel1";
+            this.panel1.Size = new System.Drawing.Size(499, 35);
+            this.panel1.TabIndex = 0;
+            // 
+            // buttonShout
+            // 
+            this.buttonShout.Location = new System.Drawing.Point(312, 8);
+            this.buttonShout.Name = "buttonShout";
+            this.buttonShout.Size = new System.Drawing.Size(48, 23);
+            this.buttonShout.TabIndex = 2;
+            this.buttonShout.Text = "shout";
+            this.buttonShout.UseVisualStyleBackColor = true;
+            this.buttonShout.Click += new System.EventHandler(this.buttonShout_Click);
+            // 
+            // buttonSay
+            // 
+            this.buttonSay.Location = new System.Drawing.Point(256, 8);
+            this.buttonSay.Name = "buttonSay";
+            this.buttonSay.Size = new System.Drawing.Size(48, 23);
+            this.buttonSay.TabIndex = 1;
+            this.buttonSay.Text = "say";
+            this.buttonSay.UseVisualStyleBackColor = true;
+            this.buttonSay.Click += new System.EventHandler(this.buttonSay_Click);
+            // 
+            // textBox1
+            // 
+            this.textBox1.Location = new System.Drawing.Point(8, 8);
+            this.textBox1.Name = "textBox1";
+            this.textBox1.Size = new System.Drawing.Size(240, 20);
+            this.textBox1.TabIndex = 0;
+            this.textBox1.KeyDown += new System.Windows.Forms.KeyEventHandler(this.textBox1_KeyDown);
+            // 
+            // groupBox1
+            // 
+            this.groupBox1.Controls.Add(this.textBox2);
+            this.groupBox1.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.groupBox1.Location = new System.Drawing.Point(4, 4);
+            this.groupBox1.Name = "groupBox1";
+            this.groupBox1.Size = new System.Drawing.Size(499, 149);
+            this.groupBox1.TabIndex = 1;
+            this.groupBox1.TabStop = false;
+            this.groupBox1.Text = "Console";
+            // 
+            // textBox2
+            // 
+            this.textBox2.AcceptsReturn = true;
+            this.textBox2.AcceptsTab = true;
+            this.textBox2.ContextMenuStrip = this.contextMenuStrip1;
+            this.textBox2.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.textBox2.Location = new System.Drawing.Point(3, 16);
+            this.textBox2.Multiline = true;
+            this.textBox2.Name = "textBox2";
+            this.textBox2.ReadOnly = true;
+            this.textBox2.ScrollBars = System.Windows.Forms.ScrollBars.Both;
+            this.textBox2.Size = new System.Drawing.Size(493, 130);
+            this.textBox2.TabIndex = 0;
+            this.textBox2.KeyDown += new System.Windows.Forms.KeyEventHandler(this.textBox2_KeyDown);
+            // 
+            // contextMenuStrip1
+            // 
+            this.contextMenuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
             this.copyToolStripMenuItem,
             this.selectAllToolStripMenuItem,
             this.toolStripSeparator1,
             this.clearToolStripMenuItem});
-			this.contextMenuStrip1.Name = "contextMenuStrip1";
-			this.contextMenuStrip1.Size = new System.Drawing.Size(129, 76);
-			// 
-			// copyToolStripMenuItem
-			// 
-			this.copyToolStripMenuItem.Name = "copyToolStripMenuItem";
-			this.copyToolStripMenuItem.Size = new System.Drawing.Size(128, 22);
-			this.copyToolStripMenuItem.Text = "Copy";
-			this.copyToolStripMenuItem.Click += new System.EventHandler(this.copyToolStripMenuItem_Click);
-			// 
-			// selectAllToolStripMenuItem
-			// 
-			this.selectAllToolStripMenuItem.Name = "selectAllToolStripMenuItem";
-			this.selectAllToolStripMenuItem.Size = new System.Drawing.Size(128, 22);
-			this.selectAllToolStripMenuItem.Text = "Select All";
-			this.selectAllToolStripMenuItem.Click += new System.EventHandler(this.selectAllToolStripMenuItem_Click);
-			// 
-			// toolStripSeparator1
-			// 
-			this.toolStripSeparator1.Name = "toolStripSeparator1";
-			this.toolStripSeparator1.Size = new System.Drawing.Size(125, 6);
-			// 
-			// clearToolStripMenuItem
-			// 
-			this.clearToolStripMenuItem.Name = "clearToolStripMenuItem";
-			this.clearToolStripMenuItem.Size = new System.Drawing.Size(128, 22);
-			this.clearToolStripMenuItem.Text = "Clear";
-			this.clearToolStripMenuItem.Click += new System.EventHandler(this.clearToolStripMenuItem_Click);
-			// 
-			// SimulatorConsole
-			// 
-			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-			this.Controls.Add(this.groupBox1);
-			this.Controls.Add(this.panel1);
-			this.Name = "SimulatorConsole";
-			this.Padding = new System.Windows.Forms.Padding(4);
-			this.Size = new System.Drawing.Size(515, 219);
-			this.panel1.ResumeLayout(false);
-			this.panel1.PerformLayout();
-			this.groupBox1.ResumeLayout(false);
-			this.groupBox1.PerformLayout();
-			this.contextMenuStrip1.ResumeLayout(false);
-			this.ResumeLayout(false);
+            this.contextMenuStrip1.Name = "contextMenuStrip1";
+            this.contextMenuStrip1.Size = new System.Drawing.Size(129, 76);
+            // 
+            // copyToolStripMenuItem
+            // 
+            this.copyToolStripMenuItem.Name = "copyToolStripMenuItem";
+            this.copyToolStripMenuItem.Size = new System.Drawing.Size(128, 22);
+            this.copyToolStripMenuItem.Text = "Copy";
+            this.copyToolStripMenuItem.Click += new System.EventHandler(this.copyToolStripMenuItem_Click);
+            // 
+            // selectAllToolStripMenuItem
+            // 
+            this.selectAllToolStripMenuItem.Name = "selectAllToolStripMenuItem";
+            this.selectAllToolStripMenuItem.Size = new System.Drawing.Size(128, 22);
+            this.selectAllToolStripMenuItem.Text = "Select All";
+            this.selectAllToolStripMenuItem.Click += new System.EventHandler(this.selectAllToolStripMenuItem_Click);
+            // 
+            // toolStripSeparator1
+            // 
+            this.toolStripSeparator1.Name = "toolStripSeparator1";
+            this.toolStripSeparator1.Size = new System.Drawing.Size(125, 6);
+            // 
+            // clearToolStripMenuItem
+            // 
+            this.clearToolStripMenuItem.Name = "clearToolStripMenuItem";
+            this.clearToolStripMenuItem.Size = new System.Drawing.Size(128, 22);
+            this.clearToolStripMenuItem.Text = "Clear";
+            this.clearToolStripMenuItem.Click += new System.EventHandler(this.clearToolStripMenuItem_Click);
+            // 
+            // SimulatorConsole
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(507, 192);
+            this.Controls.Add(this.groupBox1);
+            this.Controls.Add(this.panel1);
+            this.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+            this.Name = "SimulatorConsole";
+            this.Padding = new System.Windows.Forms.Padding(4);
+            this.ShowHint = LSLEditor.Docking.DockState.DockBottom;
+            this.ShowIcon = false;
+            this.TabText = "Simulator Console";
+            this.Text = "Simulator Console";
+            this.panel1.ResumeLayout(false);
+            this.panel1.PerformLayout();
+            this.groupBox1.ResumeLayout(false);
+            this.groupBox1.PerformLayout();
+            this.contextMenuStrip1.ResumeLayout(false);
+            this.ResumeLayout(false);
 
 		}
 

trunk/SimulatorConsole.cs

@@ -45,10 +45,11 @@ using System;
 using System.Drawing;
 using System.Collections.Generic;
 using System.Windows.Forms;
+using LSLEditor.Docking;
 
 namespace LSLEditor
 {
-	public partial class SimulatorConsole : UserControl
+	public partial class SimulatorConsole : DockContent
 	{
 		public event SecondLifeHost.SecondLifeHostChatHandler OnChat;
 		public event EventHandler OnControl;

trunk/Solution/SolutionExplorer.cs

@@ -51,7 +51,7 @@ using System.Collections.Generic;
 
 namespace LSLEditor.Solution
 {
-	public partial class SolutionExplorer : UserControl
+	public partial class SolutionExplorer : ToolWindow
 	{
 		public enum TypeSL : int
 		{

trunk/Solution/SolutionExplorer.designer.cs

@@ -31,78 +31,82 @@ namespace LSLEditor.Solution
 		/// </summary>
 		private void InitializeComponent()
 		{
-			this.treeView1 = new System.Windows.Forms.TreeView();
-			this.listView1 = new System.Windows.Forms.ListView();
-			this.panel1 = new System.Windows.Forms.Panel();
-			this.splitter1 = new System.Windows.Forms.Splitter();
-			this.panel2 = new System.Windows.Forms.Panel();
-			this.panel1.SuspendLayout();
-			this.panel2.SuspendLayout();
-			this.SuspendLayout();
-			// 
-			// treeView1
-			// 
-			this.treeView1.Dock = System.Windows.Forms.DockStyle.Fill;
-			this.treeView1.Location = new System.Drawing.Point(0, 0);
-			this.treeView1.Name = "treeView1";
-			this.treeView1.Size = new System.Drawing.Size(216, 192);
-			this.treeView1.TabIndex = 0;
-			this.treeView1.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.treeView1_AfterSelect);
-			this.treeView1.KeyDown += new System.Windows.Forms.KeyEventHandler(this.treeView1_KeyDown);
-			// 
-			// listView1
-			// 
-			this.listView1.Dock = System.Windows.Forms.DockStyle.Fill;
-			this.listView1.FullRowSelect = true;
-			this.listView1.GridLines = true;
-			this.listView1.Location = new System.Drawing.Point(0, 0);
-			this.listView1.MultiSelect = false;
-			this.listView1.Name = "listView1";
-			this.listView1.Size = new System.Drawing.Size(216, 75);
-			this.listView1.TabIndex = 0;
-			this.listView1.UseCompatibleStateImageBehavior = false;
-			this.listView1.MouseMove += new System.Windows.Forms.MouseEventHandler(this.listView1_MouseMove);
-			// 
-			// panel1
-			// 
-			this.panel1.AutoScroll = true;
-			this.panel1.Controls.Add(this.listView1);
-			this.panel1.Dock = System.Windows.Forms.DockStyle.Bottom;
-			this.panel1.Location = new System.Drawing.Point(0, 200);
-			this.panel1.Name = "panel1";
-			this.panel1.Size = new System.Drawing.Size(216, 75);
-			this.panel1.TabIndex = 1;
-			// 
-			// splitter1
-			// 
-			this.splitter1.Dock = System.Windows.Forms.DockStyle.Bottom;
-			this.splitter1.Location = new System.Drawing.Point(0, 192);
-			this.splitter1.Name = "splitter1";
-			this.splitter1.Size = new System.Drawing.Size(216, 8);
-			this.splitter1.TabIndex = 2;
-			this.splitter1.TabStop = false;
-			// 
-			// panel2
-			// 
-			this.panel2.Controls.Add(this.treeView1);
-			this.panel2.Dock = System.Windows.Forms.DockStyle.Fill;
-			this.panel2.Location = new System.Drawing.Point(0, 0);
-			this.panel2.Name = "panel2";
-			this.panel2.Size = new System.Drawing.Size(216, 192);
-			this.panel2.TabIndex = 3;
-			// 
-			// SolutionExplorer
-			// 
-			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-			this.Controls.Add(this.panel2);
-			this.Controls.Add(this.splitter1);
-			this.Controls.Add(this.panel1);
-			this.Name = "SolutionExplorer";
-			this.Size = new System.Drawing.Size(216, 275);
-			this.panel1.ResumeLayout(false);
-			this.panel2.ResumeLayout(false);
-			this.ResumeLayout(false);
+            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(SolutionExplorer));
+            this.treeView1 = new System.Windows.Forms.TreeView();
+            this.listView1 = new System.Windows.Forms.ListView();
+            this.panel1 = new System.Windows.Forms.Panel();
+            this.splitter1 = new System.Windows.Forms.Splitter();
+            this.panel2 = new System.Windows.Forms.Panel();
+            this.panel1.SuspendLayout();
+            this.panel2.SuspendLayout();
+            this.SuspendLayout();
+            // 
+            // treeView1
+            // 
+            this.treeView1.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.treeView1.Location = new System.Drawing.Point(0, 0);
+            this.treeView1.Name = "treeView1";
+            this.treeView1.Size = new System.Drawing.Size(208, 165);
+            this.treeView1.TabIndex = 0;
+            this.treeView1.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.treeView1_AfterSelect);
+            this.treeView1.KeyDown += new System.Windows.Forms.KeyEventHandler(this.treeView1_KeyDown);
+            // 
+            // listView1
+            // 
+            this.listView1.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.listView1.FullRowSelect = true;
+            this.listView1.GridLines = true;
+            this.listView1.Location = new System.Drawing.Point(0, 0);
+            this.listView1.MultiSelect = false;
+            this.listView1.Name = "listView1";
+            this.listView1.Size = new System.Drawing.Size(208, 75);
+            this.listView1.TabIndex = 0;
+            this.listView1.UseCompatibleStateImageBehavior = false;
+            this.listView1.MouseMove += new System.Windows.Forms.MouseEventHandler(this.listView1_MouseMove);
+            // 
+            // panel1
+            // 
+            this.panel1.AutoScroll = true;
+            this.panel1.Controls.Add(this.listView1);
+            this.panel1.Dock = System.Windows.Forms.DockStyle.Bottom;
+            this.panel1.Location = new System.Drawing.Point(0, 173);
+            this.panel1.Name = "panel1";
+            this.panel1.Size = new System.Drawing.Size(208, 75);
+            this.panel1.TabIndex = 1;
+            // 
+            // splitter1
+            // 
+            this.splitter1.Dock = System.Windows.Forms.DockStyle.Bottom;
+            this.splitter1.Location = new System.Drawing.Point(0, 165);
+            this.splitter1.Name = "splitter1";
+            this.splitter1.Size = new System.Drawing.Size(208, 8);
+            this.splitter1.TabIndex = 2;
+            this.splitter1.TabStop = false;
+            // 
+            // panel2
+            // 
+            this.panel2.Controls.Add(this.treeView1);
+            this.panel2.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.panel2.Location = new System.Drawing.Point(0, 0);
+            this.panel2.Name = "panel2";
+            this.panel2.Size = new System.Drawing.Size(208, 165);
+            this.panel2.TabIndex = 3;
+            // 
+            // SolutionExplorer
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(208, 248);
+            this.Controls.Add(this.panel2);
+            this.Controls.Add(this.splitter1);
+            this.Controls.Add(this.panel1);
+            this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
+            this.Name = "SolutionExplorer";
+            this.TabText = "Solution Explorer";
+            this.Text = "Solution Explorer";
+            this.panel1.ResumeLayout(false);
+            this.panel2.ResumeLayout(false);
+            this.ResumeLayout(false);
 
 		}
 

trunk/Solution/SolutionExplorer.resx

@@ -117,4 +117,208 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
+  <assembly alias="System.Drawing" name="System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+  <data name="$this.Icon" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        AAABAAcAEBAQAAAAAAAoAQAAdgAAABAQAAAAAAAAaAUAAJ4BAAAYGAAAAAAAAMgGAAAGBwAAICAQAAAA
+        AADoAgAAzg0AACAgAAAAAAAAqAgAALYQAAAwMBAAAAAAAGgGAABeGQAAMDAAAAAAAACoDgAAxh8AACgA
+        AAAQAAAAIAAAAAEABAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAACAgAAAAACAAACA
+        gACAAIAAgICAAMDAwAAA/wAA/wAAAP//AAAAAP8AAP//AAAAAAD///8AERERERERERERERERERERERER
+        ERERERERERERERERERERAAAAAAABEXF//////wEREX+IiIiPgBF3F/f////wEREX+I//+PARdxf/d3d3
+        +AEREX//////AXdxeqqqq7wBEREXd3d3d3ERERERERERERERERERERERERERERERERH//wAA//8AAP//
+        AAD//xERwAd4iEAHiIjAA4iIIAMREeADd/8gAf//8AH//xABERH4ARf//////////////xERKAAAABAA
+        AAAgAAAAAQAIAAAAAABAAQAAAAAAAAAAAAAAAAAAAAAAALJOHQDfjScAeEQoAN+QLgCGUzkAtHU7ANSU
+        SQDnoEkA6KNOALF8WQBmZmYAtIprAICJiQC+oYwAlJSQAIuWlwCPlpcAmZydAKOlpAC2r6UAlKKsALay
+        rAC7tq4AuLaxAM3FugDJzMwAz9DNANDQ0ADO09MAy93hANbh5ADW5OgA1+frAOLp6wDn7O0A2OrvANnq
+        7wDo8vUA6/T3APP29wAAAAAA////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKCgoKCgoKCgoKCgoKCgoKCgoKCgo
+        KCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgKCgoKCgoKCgoKKCgoKCgAAAAAAAAAAAAAAAooKBco
+        CSMjIyMjIyMjIwAKKCgoKAkgHBkZGRkZGSUNAgooFhEoCR0QKSkpKSchJAUKKCgoKAkjFBspKSkpHiYL
+        CigTDigJHyMMDAwMDA8iGgUKKCgoKAkjIyMjIyMjIyMFChgVEigJAwEBAQEBCAcGBQQoKCgoKAAAAAAA
+        AAAAAAAoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgo//94iv//
+        AAD//zMV4AdrbsADAqNAA6OjwAFvkyABAADgAQAAIABnfvAApaQQAKSk+AGYjv//NgD//zEG//9RlCgA
+        AAAYAAAAMAAAAAEACAAAAAAAoAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwb+/APr5+QDQy8oA0szKAKGQ
+        iQCikIgA18jBAHdEKgB3Ri4AjlY5AKp0WQB1UkAAoXFZAHRSQQBxU0QAhmdYAK+MegCykYEAopKKALqy
+        rgDPy8kAe0gtAJFZOwCxeVkAtH5fAJ1uVQCeb1YAdFNBAIZmVQCGZ1YAu5mGALycigC6m4oAwKaXAJOA
+        dQCmlIoA3dLMALyzrgDAubUAp25MALJ6WQDBl30Awpl/ALOPegC7nIoAupuJAMCnmADCqZoAqJeNANzS
+        zADCurUArFITAL9oLgCUhHkArJuPAMrGwwChVxsAwp+DAMG3rwDEu7QA3GkAANaofgDTwK8AwLGkAMa4
+        qwDebwAA3W8AANxtAADGuKoA0snAANDIwADpiiUA95w3AO+YPADgtogA37WIAN61iADftokA37eKANXL
+        wADXzcEA0ci8AOWsWwDotGUA6LVlAOu5aADpuGwA67tvAOq7cQDluHMA3bV2ALa2tQChpaQA2NzbANfb
+        2gDg//8AkpubAJOZmQCgpaUAnaKiAKGvsACvuLkA3u7wANzs7gDd5eYA3vr/AOL7/wCdqqwAtbu8ALDA
+        wwDg6uwA2+XnAO7z9ADd8fYAv9HVAMLT1wC/0NQA2uzwANPk6ADk8PMA5e7wANzk5gDP09QA7fHyAN32
+        /QDP4ucAz+HmANvt8gDa7PEA2OrvAN/q7QDl8PMA3ff/AN73/wDd9v4A3PX9ANrw9wDc8PYAwNHWANvs
+        8QDa6/AA4/P4AODq7QDl7/IA5O7xAN31/QDg9/8A3PL6ANjq8ADb7PIA4fH3AN7m6QDY4OMA2/P9ANry
+        /ADb8/4A2vL9ANfv+gDa8/8A7vL0AO3x8wD4+PkA////AP39/QDp6ekAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4eHh4eHh4eHh4eHh0Q
+        NgAAAAAAAAAAAAsgIS4uLi4uLi4uLi0fCg8AAAAAAEAFEj9gfZKSkpKSkpKSkpJqaRc2AAAAAEcEByuI
+        goCMdoGBgYGBgYGNhTAMAAAAAAAAAClolXCRkI+Pj4+Pj4N5l14WAAAAAEATBRFRiWVte6ChoaGhoXx6
+        eIoaIwAAAEYzFSUqa25dAQKjo6Ojo6Nxb5MiDgAAAAAAAAAZZ35hXKWkpKSkpKSimI5fCDYAAEExBgUR
+        UZRsYmNjY2NjY2NkZoRyGyMAAFA8JwMyKoZ/i3Nzc3Nzc3N1dHeHLxw2AAAAAAAAGJafnJycnJycnJyb
+        nZ6amQk2AEU3JAUFLFNWVVRUVFRUVFVZV1hbWjk2AFI7JhQ4ADU9REJDQ0NDQ0NKSEkNKDQ2AAAAAAAA
+        AAA6Pk9NTU1NTU1MTE5LS0sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAA////Kv///w7///8o////KP///yjwAB8o8AAPToAAB12AAAdD8AAHIIAA
+        Az2AAAM9+AABPYAAAT2AAABV/AAAXYAAAF2CAABd/wABVf///1X///9V////Vf///1X///9dKAAAACAA
+        AABAAAAAAQAEAAAAAACAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAICAAAAAAIAAAICAAIAA
+        gACAgIAAwMDAAAD/AAD/AAAA//8AAAAA/wAA//8AAAAAAP///wARERERERERERERERERERERERERERER
+        ERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERER
+        ERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERAAAAAAAAAAAAAAER
+        EREREXiIiIiIiIiIiIiAERERABF3////////////8BEREX9xF/////////////cBEREXcReP////////
+        ///4AREREREXf/iIiIiIiIiP/wEREQABEX/4f4//////j/9wERF/9xF4+H+I//////j/gBERF3cRd/iH
+        9//////4//ARERERERf/h/f/////+P/3ARFwAAEXj4d3d3d3d3eP+AERf//3F3+IiIiIiIiIiP8wERd3
+        dxF/////////////cBEREREReP///////////4ARcAAAEXi7u7u7u7u7u7uyAX///3EXqqqqqqqqq6us
+        ygEXd3dxF6qqqqqqqqqqqqoBERERERF3d3d3d3d3d3d3ERERERERERERERERERERERERERERERERERER
+        ERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERER
+        EREREREREREREf//////////////////////////////////////////8AAAf/AAAD8wAAA/GAAAH5gA
+        AB/4AAAfHAAADwwAAA+MAAAP/gAABwYAAAcCAAADgwAAA/8AAAMDAAABAYAAAYGAAAH/wAAD////////
+        ////////////////////////KAAAACAAAABAAAAAAQAIAAAAAACABAAAAAAAAAAAAAAAAAAAAAAAAJ44
+        AACmQAAAsUsAANNtAADZcgAAmDcGAH4wCQB/MQoAlDoMAHAvDwCDNg8AcDEQAJ5CEwDBZRMAoEQVANN0
+        FQCWQRYAl0IXAI9CHAChTCEAznQiANF4JgDzoScAXzsoAGpBKwCdUy4AnlMuAJ5VLwCiWDMAplw3AN+N
+        OwCjXjwArG5PALF0VQBeXl4As3tfALCIYwBmZmYAhHNoAG5ycgBwd3cAc3h3AHV5eAB2enkAeXt6AHl8
+        egB6fHoAe317AH1+ewB+f3wAvJiEALmghgCKiooAkJCMAI6RkAD/zJkApaShAKWloQCmpaEAxLKlAKqq
+        qgChsLEAysG5AMC+uwDCwLwAury9AMXFwgDGxsMAvsLEANnQxQDNy8cA087JANbQyQDP0M0A4NfNAOnc
+        0ADs4NEAv9DUANLa2wDO4OQA0uToAOjo6ADg6OoA6urqANnp7QDY6u8A2ervANvr8ADv8/QA6fP2APj4
+        +AD7+/sA/f39AAAAAAA0b/8A////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AABdXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1d
+        XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1d
+        XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1d
+        XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dJSUlJSUlJSUl
+        JSUlJSUlJSUlJSUlXV1dXV1dXV1dXR8SCgcGBgYGBgYGBgYGBgYGBgYGByUmXV1dXV1dXV1dCDtGRkZG
+        RkZGRkZGRkZGRkZGRkY+BSVdXV1dXUI2XV0gM1VVVVVVVVVVVVVVVVVVVVVVVVUTJV1dXV1dQEA/XV0M
+        VVVVVVVVVVVVVVVVVVVVVVVVVTILJV1dXV1dXV1dXQ5JVV9fX19fX19fX19fX19fX19VTgUlXV1dXV1d
+        XV1dICRVVE1NTU1NTU1NTU1NTU1NX1ZVEyVdXV1dNS4qXV1dDFVVPShfPFFfX19fX19fX01YX1UyCyVd
+        XV1FRT8/XV0OSVU9KF84PF9fX19fX19fUk1fVU4FJV1dXV1dXV1dXSAkVU89KFsiU1pfX19fX19cTV9X
+        VRMlXV1dXV1dXV1dXQxVVT0oXzRTU19fX19fX19NX1lVMgslXV05MC0qJ11dDklVPSgoKCgoKCgoKCgo
+        KChNX1VOBSVdXUtLSENEP10gJFVQPT09PT09PT09PT09PT1NVVUTFyVdXV1dXV1dXV0MVVVVVVVVVVVV
+        VVVVVVVVVVVVVTIJJV1dXV1dXV1dXQ5JVVVVVVVVVVVVVVVVVVVVVVVVTgUlXToxLywrKV1dIw0WFhYW
+        FhYWFhYWFhYWFhYWFhYWARglTExKR0NBP11dAAQEBAQEBAQEBAQEBAQ3DzcPXg8DASVdXV1dXV1dXV0d
+        AhQVHh4eHh4eHh4eHh4eHh4eHgMFXV1dXV1dXV1dXV0hHBsaGRkZGRkZGRkZGRkZGRkQEV1dXV1dXV1d
+        XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1d
+        XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1d
+        XV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1d
+        XV1dXV1d//////////////////////////////////////gAAD/wAAAf8AAAHzAAAB8YAAAP+AAAD/gA
+        AA8cAAAHDAAAB/wAAAf+AAADBgAAAwIAAAH/AAAB/wAAAQMAAAABgAAA/4AAAf/AAAP/////////////
+        //////////////////8oAAAAMAAAAGAAAAABAAQAAAAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AACAAAAAgIAAAAAAgAAAgIAAgACAAICAgADAwMAAAP8AAP8AAAD//wAAAAD/AAD//wAAAAAA////ABER
+        ERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERER
+        ERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERER
+        ERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERER
+        ERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERER
+        ERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERAAAAAAAAAAAAAA
+        AAAAAAABERERERERERd3d3d3d3d3d3d3d3d3d3cgERERERERERd///////////////////ggERERERAB
+        ERc///////////////////8wEREREX/wERF4//////////////////9yARERERd3ERF3////////////
+        //////+CARERERERERFz///////////////////zAREREREREREXj//////////////////3IBERERER
+        EREXf/iIiIiIiIiIiIiIj//4IBERERAAAREXP/+If/h/////////j///MBEREX//8BEReP+IeP9/////
+        ////iP//cgERERd3dxERd//4d/94////////+P//ggERERERERERc//4h4+H////////+P//8wERERER
+        ERERF4/4h3/3////////+I//9yARERERERERF3//h3j4f///////+I//+CARERAAAAERFz//iHd3d3d3
+        d3d3d4j//zAREX////AREXj/iIiIiIiIiIiIiIj//3IBERd3d3cREXf//////////////////4IBERER
+        EREREXP///////////////////MBEREREREREReP//////////////////cgERERERERERd/////////
+        //////////ggERAAAAABERd6qqqqqqqqqqqqqqqqqqowEX/////wERF6qqqqqqqqqqqqq7q7rMMyARd3
+        d3d3ERF6qqqqqqqqqqqqqrqrp8cyAREREREREREXu7u7u7u7u7u7u7u7u7uyARERERERERERd3d3d3d3
+        d3d3d3d3d3d3ERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERER
+        ERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERER
+        ERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERER
+        ERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERERER
+        EREREREREREREf///////wAA////////AAD///////8AAP///////wAA////////AAD///////8AAP//
+        /////wAA////////AAD///////8AAP///////wAA////////AAD///////8AAP4AAAAB/wAA/gAAAAD/
+        AAD+AAAAAP8AAJ4AAAAA/wAADwAAAAB/AACPAAAAAH8AAP8AAAAAfwAA/4AAAAA/AAD/gAAAAD8AAIeA
+        AAAAPwAAA8AAAAAfAACDwAAAAB8AAP/AAAAAHwAA/+AAAAAPAAD/4AAAAA8AAIHgAAAADwAAAPAAAAAH
+        AACA8AAAAAcAAP/wAAAABwAA//gAAAADAAD/+AAAAAMAAIB4AAAAAwAAADwAAAABAACAPAAAAAEAAP/+
+        AAAAAQAA//8AAAADAAD///////8AAP///////wAA////////AAD///////8AAP///////wAA////////
+        AAD///////8AAP///////wAA////////AAD///////8AACgAAAAwAAAAYAAAAAEACAAAAAAAgAoAAAAA
+        AAAAAAAAAAAAAAAAAACQMAAAmTMAAKE7AACtRwAAu1UAAMNdAADMZgAA020AAN13AAD2kAAAoz0BAIYv
+        BACbNwQAzGkGAKNEDQBwMRAAnkITAHQ1FAAVFRUAaTIVAKBEFQDTdBUA4oMVAJhDGACgSh4Ao0sfAKFM
+        IQCaSyMAp08jAJ1NJQClUCUAXzsoAFw9LABhQS8AvHYxANB9MQDeijcAODg4AG5LOADaiTkAvHM9AOGQ
+        PwB5U0AA3I5AAKxqSQBNTU0AnWhNALN/YwBmZmYAtYRqAO+sagD1s2oAcXFxAHB3dwC4jncAdXp6APa7
+        fwD6v38Ae4SEALyYhAB7aoYAh5KSAJOcnACXpaUAmaioAJqmqQCqqqoAra2rAJ+srACvr6wAq66uALSy
+        rgC3tbAAvLixAL24sQDBu7MAw720AMrCtwDLwrcApra4ANXJuwDXyrwArLy9ANnLvQDczr4A4NDAAOTT
+        wQDq18QA69jEAPLcxwD13sgAtMXJAM/QzQDGzc4AuszRALvN0gC/0NQAwtPWAMbV2QDJ19sA0trbANvb
+        2wDJ2t4Ay9zgANfc4ADa3eEA3uHjAPjw4wDf4uQA2OLlAPjy5QDk5uYA3uLnAOXm5wDS5OgA3OXoAOzr
+        6ADr6+kA7uzpAPn06QDq6uoA8u/rAPr16wDW6OwA9vLsAOPr7QD59O0A2OrvANnq7wDo7u8A2+vwAOvt
+        8ADt7/AA3ezxAODu8gDv8fIA7vDzAPLz8wD19PMA5fH0APf29AD69/UA6fP2APz69gDt9fcA9/f3APX3
+        +ADy+PkA+fz8AAAAAAA0b/8A////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZUwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMJWVlZWVlZWVlZWVlZWV
+        lQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQERMJWVlZWVlZWVlZWVlZWVlQEvNjY2NjY2NjY2
+        NjY2NjY2NjY2NjY2NjY2NjY2NiwBITCVlZWVlZWVlZWVlZWVlQExf39/f39/f39/f39/f39/f39/f39/
+        f39/f39/f2QBEzCVlZWVlZWVlTAwlZWVlRcQf39/f39/f39/f39/f39/f39/f39/f39/f39/f38aGDCV
+        lZWVlZWVa1RJMJWVlZUBXH9/f39/f39/f39/f39/f39/f39/f39/f39/f387ASAwlZWVlZWVlXZscJWV
+        lZUAMX9/f39/f39/f39/f39/f39/f39/f39/f39/f39kAQ8wlZWVlZWVlZWVlZWVlZUXEH9/f39/f39/
+        f39/f39/f39/f39/f39/f39/f39/GgswlZWVlZWVlZWVlZWVlZWVAVx/f5eXl5eXl5eXl5eXl5eXl5eX
+        l5eXl5eXhX9/OwEfMJWVlZWVlZWVlZWVlZWVADF/f3I/T15eXl5eXl5eXl5eXl5eXl5eXl+XkH9/ZAEP
+        MJWVlZWVlTAwMDCVlZWVFxB/f38/QDVzc3Nzc3Nzc3Nzc3Nzc3NzbV6Bl39/fxoLMJWVlZWVblhRTEcw
+        lZWVlQFcf39hPzVGl5cSl5eXl5eXl5eXl5eXl2Bjl4Z/fzsBHzCVlZWVlXx0b2lwlZWVlQAxf397Pz41
+        eJclZZeXl5eXl5eXl5eXl21el5N/f2QBDzCVlZWVlZWVlZWVlZWVlRcQf39/Uj81RpdCNJeXl5eXl5eX
+        l5eXl5JefZeAf38aGTCVlZWVlZWVlZWVlZWVlZUBXH9/Zj81N5eRLZeXl5eXl5eXl5eXl5dgYpeLf387
+        AR8wlZWVlZWVlZWVlZWVlZUBMX9/fz89NUaXQkKXl5eXl5eXl5eXl5dBXpeUf39kAQ8wlZWVlTAwMDAw
+        MJWVlZUdEH9/f1I/NTU1NTU1NTU1NTU1NTU1NTU6W12Xgn9/GhkwlZWVd1lWU05KRTCVlZWVAVx/f2c/
+        Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/P0SXjn9/OwEfMJWVlX55dXFqaHCVlZWVATF/f39/f39/f39/f39/f39/
+        f39/f39/f39/f39/ZAEPMJWVlZWVlZWVlZWVlZWVHRB/f39/f39/f39/f39/f39/f39/f39/f39/f39/
+        fxoZMJWVlZWVlZWVlZWVlZWVlQFcf39/f39/f39/f39/f39/f39/f39/f39/f39/fzsBHzCVlZWVlZWV
+        lZWVlZWVlQExf39/f39/f39/f39/f39/f39/f39/f39/f39/f2QBDzCVlTAwMDAwMDAwlZWVlR0CCQkJ
+        CQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkDHjCVelpXVVBNS0hDMJWVlZUBBwgICAgICAgICAgICAgI
+        CAgICAg5OQgzORaWliIEASYwlY+NjIqJh4SDiJWVlZUUDg0GBgYGBgYGBgYGBgYGBgYGBgYyOBUpOCku
+        ljwFASowlZWVlZWVlZWVlZWVlZWVAQojKyQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCcoATCVlZWVlZWV
+        lZWVlZWVlZWVlRwBAQwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwBG5WVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV
+        lZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWV////////AAD///////8AAP//
+        /////wAA////////AAD///////8AAP///////wAA////////AAD///////8AAP///////wAA////////
+        AAD///////8AAP8AAAAA/wAA/gAAAAD/AAD+AAAAAH8AAP4AAAAAfwAAngAAAAB/AAAPAAAAAD8AAI8A
+        AAAAPwAA/wAAAAA/AAD/gAAAAB8AAP+AAAAAHwAAh4AAAAAfAAADwAAAAA8AAIPAAAAADwAA/8AAAAAP
+        AAD/4AAAAAcAAP/gAAAABwAAgeAAAAAHAAAA8AAAAAMAAIDwAAAAAwAA//AAAAADAAD/+AAAAAEAAP/4
+        AAAAAQAAgHgAAAABAAAAPAAAAAAAAIA8AAAAAAAA//4AAAABAAD//wAAAAMAAP///////wAA////////
+        AAD///////8AAP///////wAA////////AAD///////8AAP///////wAA////////AAD///////8AAP//
+        /////wAA
+</value>
+  </data>
 </root>

trunk/SyntaxError.Designer.cs

@@ -28,26 +28,26 @@ namespace LSLEditor
 		/// </summary>
 		private void InitializeComponent()
 		{
-			this.components = new System.ComponentModel.Container();
-			System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(SyntaxError));
-			this.listView1 = new System.Windows.Forms.ListView();
-			this.columnHeader1 = new System.Windows.Forms.ColumnHeader();
-			this.columnHeader2 = new System.Windows.Forms.ColumnHeader();
-			this.columnHeader3 = new System.Windows.Forms.ColumnHeader();
-			this.columnHeader4 = new System.Windows.Forms.ColumnHeader();
-			this.columnHeader5 = new System.Windows.Forms.ColumnHeader();
-			this.columnHeader6 = new System.Windows.Forms.ColumnHeader();
-			this.columnHeader7 = new System.Windows.Forms.ColumnHeader();
-			this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components);
-			this.copyLineToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-			this.copyDescriptionOnlyToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-			this.imageList1 = new System.Windows.Forms.ImageList(this.components);
-			this.contextMenuStrip1.SuspendLayout();
-			this.SuspendLayout();
-			// 
-			// listView1
-			// 
-			this.listView1.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
+            this.components = new System.ComponentModel.Container();
+            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(SyntaxError));
+            this.listView1 = new System.Windows.Forms.ListView();
+            this.columnHeader1 = new System.Windows.Forms.ColumnHeader();
+            this.columnHeader2 = new System.Windows.Forms.ColumnHeader();
+            this.columnHeader3 = new System.Windows.Forms.ColumnHeader();
+            this.columnHeader4 = new System.Windows.Forms.ColumnHeader();
+            this.columnHeader5 = new System.Windows.Forms.ColumnHeader();
+            this.columnHeader6 = new System.Windows.Forms.ColumnHeader();
+            this.columnHeader7 = new System.Windows.Forms.ColumnHeader();
+            this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components);
+            this.copyLineToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
+            this.copyDescriptionOnlyToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
+            this.imageList1 = new System.Windows.Forms.ImageList(this.components);
+            this.contextMenuStrip1.SuspendLayout();
+            this.SuspendLayout();
+            // 
+            // listView1
+            // 
+            this.listView1.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
             this.columnHeader1,
             this.columnHeader2,
             this.columnHeader3,
@@ -55,96 +55,106 @@ namespace LSLEditor
             this.columnHeader5,
             this.columnHeader6,
             this.columnHeader7});
-			this.listView1.ContextMenuStrip = this.contextMenuStrip1;
-			this.listView1.Dock = System.Windows.Forms.DockStyle.Fill;
-			this.listView1.FullRowSelect = true;
-			this.listView1.GridLines = true;
-			this.listView1.Location = new System.Drawing.Point(0, 0);
-			this.listView1.Name = "listView1";
-			this.listView1.Size = new System.Drawing.Size(515, 131);
-			this.listView1.SmallImageList = this.imageList1;
-			this.listView1.TabIndex = 1;
-			this.listView1.UseCompatibleStateImageBehavior = false;
-			this.listView1.View = System.Windows.Forms.View.Details;
-			this.listView1.DoubleClick += new System.EventHandler(this.listView1_DoubleClick);
-			this.listView1.Resize += new System.EventHandler(this.listView1_Resize);
-			this.listView1.KeyDown += new System.Windows.Forms.KeyEventHandler(this.listView1_KeyDown);
-			// 
-			// columnHeader1
-			// 
-			this.columnHeader1.Text = "";
-			this.columnHeader1.Width = 25;
-			// 
-			// columnHeader2
-			// 
-			this.columnHeader2.Text = "";
-			this.columnHeader2.TextAlign = System.Windows.Forms.HorizontalAlignment.Right;
-			this.columnHeader2.Width = 40;
-			// 
-			// columnHeader3
-			// 
-			this.columnHeader3.Text = "Description";
-			this.columnHeader3.Width = 200;
-			// 
-			// columnHeader4
-			// 
-			this.columnHeader4.Text = "File";
-			this.columnHeader4.Width = 100;
-			// 
-			// columnHeader5
-			// 
-			this.columnHeader5.Text = "Line";
-			this.columnHeader5.TextAlign = System.Windows.Forms.HorizontalAlignment.Right;
-			this.columnHeader5.Width = 40;
-			// 
-			// columnHeader6
-			// 
-			this.columnHeader6.Text = "Chr";
-			this.columnHeader6.TextAlign = System.Windows.Forms.HorizontalAlignment.Right;
-			this.columnHeader6.Width = 40;
-			// 
-			// columnHeader7
-			// 
-			this.columnHeader7.Text = "Project";
-			// 
-			// contextMenuStrip1
-			// 
-			this.contextMenuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
+            this.listView1.ContextMenuStrip = this.contextMenuStrip1;
+            this.listView1.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.listView1.FullRowSelect = true;
+            this.listView1.GridLines = true;
+            this.listView1.Location = new System.Drawing.Point(0, 0);
+            this.listView1.Name = "listView1";
+            this.listView1.Size = new System.Drawing.Size(507, 104);
+            this.listView1.SmallImageList = this.imageList1;
+            this.listView1.TabIndex = 1;
+            this.listView1.UseCompatibleStateImageBehavior = false;
+            this.listView1.View = System.Windows.Forms.View.Details;
+            this.listView1.Resize += new System.EventHandler(this.listView1_Resize);
+            this.listView1.DoubleClick += new System.EventHandler(this.listView1_DoubleClick);
+            this.listView1.KeyDown += new System.Windows.Forms.KeyEventHandler(this.listView1_KeyDown);
+            // 
+            // columnHeader1
+            // 
+            this.columnHeader1.Text = "";
+            this.columnHeader1.Width = 25;
+            // 
+            // columnHeader2
+            // 
+            this.columnHeader2.Text = "";
+            this.columnHeader2.TextAlign = System.Windows.Forms.HorizontalAlignment.Right;
+            this.columnHeader2.Width = 40;
+            // 
+            // columnHeader3
+            // 
+            this.columnHeader3.Text = "Description";
+            this.columnHeader3.Width = 200;
+            // 
+            // columnHeader4
+            // 
+            this.columnHeader4.Text = "File";
+            this.columnHeader4.Width = 100;
+            // 
+            // columnHeader5
+            // 
+            this.columnHeader5.Text = "Line";
+            this.columnHeader5.TextAlign = System.Windows.Forms.HorizontalAlignment.Right;
+            this.columnHeader5.Width = 40;
+            // 
+            // columnHeader6
+            // 
+            this.columnHeader6.Text = "Chr";
+            this.columnHeader6.TextAlign = System.Windows.Forms.HorizontalAlignment.Right;
+            this.columnHeader6.Width = 40;
+            // 
+            // columnHeader7
+            // 
+            this.columnHeader7.Text = "Project";
+            // 
+            // contextMenuStrip1
+            // 
+            this.contextMenuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
             this.copyLineToolStripMenuItem,
             this.copyDescriptionOnlyToolStripMenuItem});
-			this.contextMenuStrip1.Name = "contextMenuStrip1";
-			this.contextMenuStrip1.Size = new System.Drawing.Size(190, 70);
-			// 
-			// copyLineToolStripMenuItem
-			// 
-			this.copyLineToolStripMenuItem.Name = "copyLineToolStripMenuItem";
-			this.copyLineToolStripMenuItem.Size = new System.Drawing.Size(189, 22);
-			this.copyLineToolStripMenuItem.Text = "Copy";
-			this.copyLineToolStripMenuItem.Click += new System.EventHandler(this.copyLineToolStripMenuItem_Click);
-			// 
-			// copyDescriptionOnlyToolStripMenuItem
-			// 
-			this.copyDescriptionOnlyToolStripMenuItem.Name = "copyDescriptionOnlyToolStripMenuItem";
-			this.copyDescriptionOnlyToolStripMenuItem.Size = new System.Drawing.Size(189, 22);
-			this.copyDescriptionOnlyToolStripMenuItem.Text = "Copy Description only";
-			this.copyDescriptionOnlyToolStripMenuItem.Click += new System.EventHandler(this.copyDescriptionOnlyToolStripMenuItem_Click);
-			// 
-			// imageList1
-			// 
-			this.imageList1.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList1.ImageStream")));
-			this.imageList1.TransparentColor = System.Drawing.Color.Magenta;
-			this.imageList1.Images.SetKeyName(0, "");
-			this.imageList1.Images.SetKeyName(1, "");
-			// 
-			// SyntaxError
-			// 
-			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-			this.Controls.Add(this.listView1);
-			this.Name = "SyntaxError";
-			this.Size = new System.Drawing.Size(515, 131);
-			this.contextMenuStrip1.ResumeLayout(false);
-			this.ResumeLayout(false);
+            this.contextMenuStrip1.Name = "contextMenuStrip1";
+            this.contextMenuStrip1.Size = new System.Drawing.Size(190, 48);
+            // 
+            // copyLineToolStripMenuItem
+            // 
+            this.copyLineToolStripMenuItem.Name = "copyLineToolStripMenuItem";
+            this.copyLineToolStripMenuItem.Size = new System.Drawing.Size(189, 22);
+            this.copyLineToolStripMenuItem.Text = "Copy";
+            this.copyLineToolStripMenuItem.Click += new System.EventHandler(this.copyLineToolStripMenuItem_Click);
+            // 
+            // copyDescriptionOnlyToolStripMenuItem
+            // 
+            this.copyDescriptionOnlyToolStripMenuItem.Name = "copyDescriptionOnlyToolStripMenuItem";
+            this.copyDescriptionOnlyToolStripMenuItem.Size = new System.Drawing.Size(189, 22);
+            this.copyDescriptionOnlyToolStripMenuItem.Text = "Copy Description only";
+            this.copyDescriptionOnlyToolStripMenuItem.Click += new System.EventHandler(this.copyDescriptionOnlyToolStripMenuItem_Click);
+            // 
+            // imageList1
+            // 
+            this.imageList1.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList1.ImageStream")));
+            this.imageList1.TransparentColor = System.Drawing.Color.Magenta;
+            this.imageList1.Images.SetKeyName(0, "");
+            this.imageList1.Images.SetKeyName(1, "");
+            // 
+            // SyntaxError
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(507, 104);
+            this.Controls.Add(this.listView1);
+            this.DockAreas = ((LSLEditor.Docking.DockAreas)(((((LSLEditor.Docking.DockAreas.Float | LSLEditor.Docking.DockAreas.DockLeft)
+                        | LSLEditor.Docking.DockAreas.DockRight)
+                        | LSLEditor.Docking.DockAreas.DockTop)
+                        | LSLEditor.Docking.DockAreas.DockBottom)));
+            this.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+            this.HideOnClose = true;
+            this.Name = "SyntaxError";
+            this.ShowHint = LSLEditor.Docking.DockState.DockBottom;
+            this.ShowIcon = false;
+            this.TabText = "Error List";
+            this.Text = "Error List";
+            this.contextMenuStrip1.ResumeLayout(false);
+            this.ResumeLayout(false);
 
 		}
 

trunk/SyntaxError.cs

@@ -45,10 +45,11 @@ using System;
 using System.Text;
 using System.Drawing;
 using System.Windows.Forms;
+using LSLEditor.Docking;
 
 namespace LSLEditor
 {
-	public partial class SyntaxError : UserControl
+	public partial class SyntaxError : DockContent
 	{
 		public SyntaxError()
 		{

trunk/ToolWindow.Designer.cs

@@ -0,0 +1,51 @@
+namespace LSLEditor
+{
+    partial class ToolWindow
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.SuspendLayout();
+            // 
+            // ToolWindow
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(292, 273);
+            this.DockAreas = ((LSLEditor.Docking.DockAreas)(((((LSLEditor.Docking.DockAreas.Float | LSLEditor.Docking.DockAreas.DockLeft)
+                        | LSLEditor.Docking.DockAreas.DockRight)
+                        | LSLEditor.Docking.DockAreas.DockTop)
+                        | LSLEditor.Docking.DockAreas.DockBottom)));
+            this.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+            this.Name = "ToolWindow";
+            this.Text = "ToolWindow";
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+    }
+}

trunk/ToolWindow.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+using LSLEditor.Docking;
+
+namespace LSLEditor
+{
+    public partial class ToolWindow : DockContent
+    {
+        public ToolWindow()
+        {
+            InitializeComponent();
+        }
+    }
+}

trunk/ToolWindow.resx

@@ -0,0 +1,120 @@
+<?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>
+</root>

trunk/lsleditor.csproj

@@ -1,7 +1,7 @@
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5">
   <PropertyGroup>
     <ProjectType>Local</ProjectType>
-    <ProductVersion>9.0.30729</ProductVersion>
+    <ProductVersion>9.0.21022</ProductVersion>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{59468D25-6E68-4113-B740-C6EF4695045B}</ProjectGuid>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -95,6 +95,7 @@
       <Name>System</Name>
     </Reference>
     <Reference Include="System.Data" />
+    <Reference Include="System.Design" />
     <Reference Include="System.Drawing">
       <Name>System.Drawing</Name>
     </Reference>
@@ -128,6 +129,103 @@
     <None Include="BZip2Decompress\MD5Verify.cs" />
     <None Include="BZip2Decompress\StrangeCrc.cs" />
     <Compile Include="Decompressor\ZipEntry.cs" />
+    <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.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\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="Editor\KeyWords.cs" />
     <None Include="Editor\RoundCorners.cs" />
     <Compile Include="Decompressor\Decompress.cs" />
@@ -293,13 +391,13 @@
       <DependentUpon>TabControlExtended.cs</DependentUpon>
     </Compile>
     <Compile Include="SimulatorConsole.cs">
-      <SubType>UserControl</SubType>
+      <SubType>Form</SubType>
     </Compile>
     <Compile Include="SimulatorConsole.Designer.cs">
       <DependentUpon>SimulatorConsole.cs</DependentUpon>
     </Compile>
     <Compile Include="Solution\SolutionExplorer.cs">
-      <SubType>UserControl</SubType>
+      <SubType>Form</SubType>
     </Compile>
     <Compile Include="Solution\SolutionExplorer.designer.cs">
       <DependentUpon>SolutionExplorer.cs</DependentUpon>
@@ -312,7 +410,7 @@
     </Compile>
     <Compile Include="Plugins\Svn.cs" />
     <Compile Include="SyntaxError.cs">
-      <SubType>UserControl</SubType>
+      <SubType>Form</SubType>
     </Compile>
     <Compile Include="SyntaxError.Designer.cs">
       <DependentUpon>SyntaxError.cs</DependentUpon>
@@ -401,6 +499,12 @@
     <Compile Include="Tools\VersionControlGeneral.Designer.cs">
       <DependentUpon>VersionControlGeneral.cs</DependentUpon>
     </Compile>
+    <Compile Include="ToolWindow.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="ToolWindow.Designer.cs">
+      <DependentUpon>ToolWindow.cs</DependentUpon>
+    </Compile>
     <Compile Include="UpdateApplicationForm.cs">
       <SubType>Form</SubType>
     </Compile>
@@ -420,6 +524,12 @@
       <SubType>Designer</SubType>
       <DependentUpon>BugReportForm.cs</DependentUpon>
     </EmbeddedResource>
+    <EmbeddedResource Include="Docking\Resources.resx">
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Docking\Strings.resx">
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
     <EmbeddedResource Include="Solution\GuidProperty.resx">
       <SubType>Designer</SubType>
       <DependentUpon>GuidProperty.cs</DependentUpon>
@@ -501,6 +611,30 @@
     <EmbeddedResource Include="Images\Close-Active.gif" />
     <EmbeddedResource Include="Images\Close-Disabled.gif" />
     <EmbeddedResource Include="Images\Close-Inactive.gif" />
+    <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" />
     <Content Include="Icons\ADDITEM.GIF" />
     <Content Include="Icons\COPY.GIF" />
     <Content Include="Icons\CUT.GIF" />
@@ -647,6 +781,10 @@
       <SubType>Designer</SubType>
       <DependentUpon>VersionControlGeneral.cs</DependentUpon>
     </EmbeddedResource>
+    <EmbeddedResource Include="ToolWindow.resx">
+      <DependentUpon>ToolWindow.cs</DependentUpon>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
     <EmbeddedResource Include="UpdateApplicationForm.resx">
       <SubType>Designer</SubType>
       <DependentUpon>UpdateApplicationForm.cs</DependentUpon>