using System;
using System.Windows.Forms;
using System.Drawing;
using System.Xml;
using System.ComponentModel;

namespace DevComponents.DotNetBar
{
	/// <summary>
	/// Represents class that manages document docking UI interaction.
	/// </summary>
	public class DocumentDockUIManager
	{
		#region Private Variables, Constructor
		private DocumentDockContainer m_DocumentDockContainer=null;
		private Cursor m_ContainerCursor=null;
		private DockSite m_Container=null;
		private Point m_MouseDownPoint=Point.Empty;
		private bool m_ResizePreview=false;
		private Form m_Splitter=null;
		private DocumentDockContainer m_ResizeDockContainer=null;
		private DocumentBaseContainer m_ResizeDocument=null;
		private int m_SplitterWidth=3;
		private bool m_LoadingLayout=false;

		public DocumentDockUIManager(DockSite container)
		{
			m_Container=container;
		}
		#endregion

		#region Properties
		/// <summary>
		/// Gets or sets the root document dock container object.
		/// </summary>
		public DocumentDockContainer RootDocumentDockContainer
		{
			get {return m_DocumentDockContainer;}
			set {m_DocumentDockContainer=value;}
		}

        /// <summary>
        /// Gets or sets the splitter width used for mouse hit-testing.
        /// </summary>
        public int SplitterWidth
        {
            get
            {
                return m_SplitterWidth;
            }
            set
            {
                m_SplitterWidth = value;
            }
        }

		/// <summary>
		/// Gets or sets the container of the document. 
		/// </summary>
		public DockSite Container
		{
			get {return m_Container;}
			set {m_Container=value;}
		}
		#endregion

		#region Methods
		/// <summary>
		/// Estimates the docking position and size of a given bar for outline purposes during drag&drop
		/// </summary>
		/// <param name="bar">Bar to find estimated docking position and size for</param>
		/// <param name="pDockInfo">Docking information</param>
		/// <returns>Preview Rectangle in screen coordinates.</returns>
		internal Rectangle GetDockPreviewRectangle(Bar bar, ref DockSiteInfo dockInfo)
		{
			DocumentBaseContainer referenceDoc=GetDocumentFromBar(dockInfo.MouseOverBar);
			Rectangle r=Rectangle .Empty;

            // Handle edge case docking first
            if (m_Container.Dock!= DockStyle.Fill && (dockInfo.DockLine == 999 || dockInfo.DockLine == -1))
            {
                return GetEdgeDockPreviewRectangle(bar, ref dockInfo);
            }
			else if(referenceDoc!=null)
			{
				if(dockInfo.MouseOverDockSide==eDockSide.Left)
				{
					r=referenceDoc.DisplayBounds;
					r.Width=r.Width/2;
				}
				else if(dockInfo.MouseOverDockSide==eDockSide.Right)
				{
					r=referenceDoc.DisplayBounds;
					r.X+=r.Width/2;
					r.Width=r.Width/2;
				}
				else if(dockInfo.MouseOverDockSide==eDockSide.Top)
				{
					r=referenceDoc.DisplayBounds;
					r.Height=r.Height/2;
				}
				else if(dockInfo.MouseOverDockSide==eDockSide.Bottom)
				{
					r=referenceDoc.DisplayBounds;
					r.Y+=r.Height/2;
					r.Height=r.Height/2;
				}
				else if(dockInfo.MouseOverDockSide==eDockSide.Document)
				{
					r=referenceDoc.DisplayBounds;
				}
				r.Location=m_Container.PointToScreen(r.Location);
			}
			else
			{
                if (m_Container.Dock == DockStyle.Fill)
                {
                    r = m_Container.ClientRectangle;
                    r.Location = m_Container.PointToScreen(r.Location);
                }
                else if (m_Container.Dock == DockStyle.Right)
                {
                    r = m_Container.ClientRectangle;
                    r.Location = m_Container.PointToScreen(r.Location);
                    if (r.Width == 0)
                    {
                        r.Width = bar.GetBarDockedSize(eOrientation.Vertical);
                        r.X -= r.Width;
                    }
                }
                else if (m_Container.Dock == DockStyle.Left)
                {
                    r = m_Container.ClientRectangle;
                    r.Location = m_Container.PointToScreen(r.Location);
                    if (r.Width == 0)
                    {
                        r.Width = bar.GetBarDockedSize(eOrientation.Vertical);
                    }
                }
                else if (m_Container.Dock == DockStyle.Top)
                {
                    r = m_Container.ClientRectangle;
                    r.Location = m_Container.PointToScreen(r.Location);
                    if (r.Height == 0)
                    {
                        r.Height = bar.GetBarDockedSize(eOrientation.Horizontal);
                    }
                }
                else if (m_Container.Dock == DockStyle.Bottom)
                {
                    r = m_Container.ClientRectangle;
                    r.Location = m_Container.PointToScreen(r.Location);
                    if (r.Height == 0)
                    {
                        r.Height = bar.GetBarDockedSize(eOrientation.Horizontal);
                        r.Y -= r.Height;
                    }
                }
			}

			return r;
		}

        private Rectangle GetEdgeDockPreviewRectangle(Bar bar, ref DockSiteInfo dockInfo)
        {
            Rectangle r = Rectangle.Empty;
            int fullSizeIndex = -1;
            int partialSizeIndex = -1;
            if (dockInfo.FullSizeDock)
                fullSizeIndex = m_Container.GetFullSizeIndex();
            else if (dockInfo.PartialSizeDock)
                partialSizeIndex = m_Container.GetPartialSizeIndex();

            // Docks the bar to the edge
            switch (m_Container.Dock)
            {
                case DockStyle.Top:
                    {
                        r.Width = m_Container.ClientRectangle.Width;
                        r.Height = bar.GetBarDockedSize(eOrientation.Horizontal);

                        if (fullSizeIndex >= 0)
                        {
                            r.Width += m_Container.GetSiteZOrderSize(m_Container.Owner.LeftDockSite, true).Width;
                            r.Width += m_Container.GetSiteZOrderSize(m_Container.Owner.RightDockSite, true).Width;
                            dockInfo.DockSiteZOrderIndex = fullSizeIndex;
                        }
                        else if (partialSizeIndex >= 0)
                        {
                            // Reduce by the size of the left and right dock site
                            r.Width -= m_Container.GetSiteZOrderSize(m_Container.Owner.LeftDockSite, false).Width;
                            r.Width -= m_Container.GetSiteZOrderSize(m_Container.Owner.RightDockSite, false).Width;
                            dockInfo.DockSiteZOrderIndex = partialSizeIndex;

                        }

                        Point p = Point.Empty;
                        if (dockInfo.DockLine == -1)
                        {
                            p = m_Container.PointToScreen(m_Container.ClientRectangle.Location);
                        }
                        else
                        {
                            p = m_Container.PointToScreen(new Point(m_Container.ClientRectangle.X, m_Container.ClientRectangle.Bottom));
                            p.Y++;
                        }
                        if (fullSizeIndex >= 0)
                            p.X -= m_Container.GetSiteZOrderSize(m_Container.Owner.LeftDockSite, true).Width;
                        else if (partialSizeIndex >= 0)
                            p.X += m_Container.GetSiteZOrderSize(m_Container.Owner.LeftDockSite, false).Width;
                        r.Location = p;
                        break;
                    }
                case DockStyle.Bottom:
                    {
                        r.Width = m_Container.ClientRectangle.Width;
                        r.Height = bar.GetBarDockedSize(eOrientation.Horizontal);
                        if (fullSizeIndex >= 0)
                        {
                            r.Width += m_Container.GetSiteZOrderSize(m_Container.Owner.LeftDockSite, true).Width;
                            r.Width += m_Container.GetSiteZOrderSize(m_Container.Owner.RightDockSite, true).Width;
                            dockInfo.DockSiteZOrderIndex = fullSizeIndex;
                        }
                        else if (partialSizeIndex >= 0)
                        {
                            // Reduce by the size of the left and right dock site
                            r.Width -= m_Container.GetSiteZOrderSize(m_Container.Owner.LeftDockSite, false).Width;
                            r.Width -= m_Container.GetSiteZOrderSize(m_Container.Owner.RightDockSite, false).Width;
                            dockInfo.DockSiteZOrderIndex = partialSizeIndex;

                        }

                        Point p = Point.Empty;
                        if (dockInfo.DockLine == -1)
                        {
                            p = m_Container.PointToScreen(new Point(m_Container.ClientRectangle.X, m_Container.ClientRectangle.Y - r.Height));
                        }
                        else
                        {
                            p = m_Container.PointToScreen(new Point(m_Container.ClientRectangle.X, m_Container.ClientRectangle.Bottom - r.Height));
                            p.Y++;
                        }
                        if (fullSizeIndex >= 0)
                            p.X -= m_Container.GetSiteZOrderSize(m_Container.Owner.LeftDockSite, true).Width;
                        else if (partialSizeIndex >= 0)
                            p.X += m_Container.GetSiteZOrderSize(m_Container.Owner.LeftDockSite, false).Width;
                        r.Location = p;
                        break;
                    }
                case DockStyle.Right:
                    {
                        r.Height = m_Container.ClientRectangle.Height;

                        if (fullSizeIndex >= 0)
                        {
                            r.Height += m_Container.GetSiteZOrderSize(m_Container.Owner.TopDockSite, true).Height;
                            r.Height += m_Container.GetSiteZOrderSize(m_Container.Owner.BottomDockSite, true).Height;
                            dockInfo.DockSiteZOrderIndex = fullSizeIndex;
                        }
                        else if (partialSizeIndex >= 0)
                        {
                            // Reduce by the size of the top and bottom dock site
                            r.Height -= m_Container.GetSiteZOrderSize(m_Container.Owner.TopDockSite, false).Height;
                            r.Height -= m_Container.GetSiteZOrderSize(m_Container.Owner.BottomDockSite, false).Height;
                            dockInfo.DockSiteZOrderIndex = partialSizeIndex;

                        }

                        r.Width = bar.GetBarDockedSize(eOrientation.Vertical);
                        Point p = Point.Empty;
                        if (dockInfo.DockLine == -1)
                        {
                            p = m_Container.PointToScreen(new Point(m_Container.ClientRectangle.X - r.Width, m_Container.ClientRectangle.Y));
                        }
                        else
                        {
                            p = m_Container.PointToScreen(new Point(m_Container.ClientRectangle.Right - r.Width, m_Container.ClientRectangle.Y));
                            p.X--;
                        }
                        if (fullSizeIndex >= 0)
                            p.Y -= m_Container.GetSiteZOrderSize(m_Container.Owner.TopDockSite, true).Height;
                        else if (partialSizeIndex >= 0)
                            p.Y += m_Container.GetSiteZOrderSize(m_Container.Owner.TopDockSite, false).Height;
                        r.Location = p;
                        break;
                    }
                default:
                    {
                        r.Height = m_Container.ClientRectangle.Height;
                        if (fullSizeIndex >= 0)
                        {
                            r.Height += m_Container.GetSiteZOrderSize(m_Container.Owner.TopDockSite, true).Height;
                            r.Height += m_Container.GetSiteZOrderSize(m_Container.Owner.BottomDockSite, true).Height;
                            dockInfo.DockSiteZOrderIndex = fullSizeIndex;
                        }
                        else if (partialSizeIndex >= 0)
                        {
                            // Reduce by the size of the top and bottom dock site
                            r.Height -= m_Container.GetSiteZOrderSize(m_Container.Owner.TopDockSite, false).Height;
                            r.Height -= m_Container.GetSiteZOrderSize(m_Container.Owner.BottomDockSite, false).Height;
                            dockInfo.DockSiteZOrderIndex = partialSizeIndex;

                        }
                        r.Width = bar.GetBarDockedSize(eOrientation.Vertical);

                        Point p = Point.Empty;
                        if (dockInfo.DockLine == -1)
                        {
                            p = m_Container.PointToScreen(new Point(m_Container.ClientRectangle.X, m_Container.ClientRectangle.Y));
                        }
                        else
                        {
                            p = m_Container.PointToScreen(new Point(m_Container.ClientRectangle.Right, m_Container.ClientRectangle.Y));
                            p.X++;
                        }
                        if (fullSizeIndex >= 0)
                            p.Y -= m_Container.GetSiteZOrderSize(m_Container.Owner.TopDockSite, true).Height;
                        else if (partialSizeIndex >= 0)
                            p.Y += m_Container.GetSiteZOrderSize(m_Container.Owner.TopDockSite, false).Height;
                        r.Location = p;
                        break;
                    }
            }

            return r;
        }

		/// <summary>
		/// Returns DocumentBaseContainer that holds the reference bar.
		/// </summary>
		/// <param name="bar">Bar to return document container for.</param>
		/// <returns>Returns null if document container cannot  be found or reference to the document container.</returns>
		public DocumentBaseContainer GetDocumentFromBar(Bar bar)
		{
			if(bar==null)
				return null;
			return GetDocumentFromBar(bar,m_DocumentDockContainer);
		}

		private DocumentBaseContainer GetDocumentFromBar(Bar bar, DocumentDockContainer dockContainer)
		{
			foreach(DocumentBaseContainer doc in dockContainer.Documents)
			{
				if(doc is DocumentBarContainer && ((DocumentBarContainer)doc).Bar==bar)
					return doc;
				else if(doc is DocumentDockContainer)
				{
					DocumentBaseContainer d=GetDocumentFromBar(bar,doc as DocumentDockContainer);
					if(d!=null)
						return d;
				}
			}
			return null;
		}

        private bool IsAddedInFront(eDockSide dockSide)
        {
            if (m_Container.Dock == DockStyle.Left && dockSide == eDockSide.Left ||
                m_Container.Dock == DockStyle.Right && dockSide == eDockSide.Left ||
                m_Container.Dock == DockStyle.Top && dockSide== eDockSide.Top || 
                m_Container.Dock == DockStyle.Bottom && dockSide == eDockSide.Top)
                return true;

            return false;
        }

		/// <summary>
		/// Docks specified bar by appending it to the container. Bar will be added according to the container's orientation.
		/// </summary>
		/// <param name="barToDock">Bar to dock.</param>
		public void Dock(Bar barToDock)
		{
			Dock(null,barToDock,eDockSide.None);
		}

        /// <summary>
        /// Docks specified bar by appending it to the container. Bar will be added according to the container's orientation.
        /// </summary>
        /// <param name="barToDock">Bar to dock.</param>
        /// <param name="dockSide">Side to dock bar at.</param>
		public void Dock(Bar referenceBar, Bar barToDock, eDockSide dockSide)
		{
			if(dockSide==eDockSide.None && barToDock.Parent==m_Container)
			{
				ApplyBarStyle(barToDock);
				return;
			}

			if(barToDock.Parent is DockSite && ((DockSite)barToDock.Parent).DocumentDockContainer!=null)
				((DockSite)barToDock.Parent).GetDocumentUIManager().UnDock(barToDock);
			else if(barToDock.Parent is DockSite && barToDock.Parent!=m_Container)
				((DockSite)barToDock.Parent).RemoveBar(barToDock);
            else if (barToDock.Parent != null && barToDock.Parent != m_Container)
            {
                if (barToDock.Parent is FloatingContainer)
                {
                    barToDock.RemoveFromFloatingContainer();
                    barToDock.SetBarState(eBarState.Docked);
                }
                else
                    barToDock.Parent.Controls.Remove(barToDock);
            }

			if(!m_LoadingLayout)
			{
				// TODO: Add Docking as Document, i.e. add DockContainerItems from barToDock...
				DocumentBarContainer doc=this.CreateDocumentBarContainer(barToDock);
                DocumentBaseContainer referenceDoc = this.GetDocumentFromBar(referenceBar);

                if (referenceBar == null || dockSide == eDockSide.None || referenceBar == barToDock || referenceDoc == null)
				{
                    if (m_Container.Dock == DockStyle.Fill)
                        m_DocumentDockContainer.Documents.Add(doc);
                    else
                    {
                        eOrientation containerOrientation = eOrientation.Horizontal; // Needed container orientation
                        if (m_Container.Dock == DockStyle.Top || m_Container.Dock == DockStyle.Bottom)
                            containerOrientation = eOrientation.Vertical;

                        // Switch orientation when adding new bar if possible
                        if (m_DocumentDockContainer.Orientation != containerOrientation)
                        {
                            if (m_DocumentDockContainer.Documents.Count <= 1)
                            {
                                m_DocumentDockContainer.Orientation = containerOrientation;
                                if (IsAddedInFront(dockSide))
                                    m_DocumentDockContainer.Documents.Insert(0, doc);
                                else
                                    m_DocumentDockContainer.Documents.Add(doc);
                            }
                            else
                            {
                                DocumentBaseContainer[] docs = new DocumentBaseContainer[m_DocumentDockContainer.Documents.Count];
                                m_DocumentDockContainer.Documents.CopyTo(docs);
                                m_DocumentDockContainer.Documents.Clear();

                                DocumentDockContainer newParent = new DocumentDockContainer(docs, m_DocumentDockContainer.Orientation);
								newParent.SetLayoutBounds(m_DocumentDockContainer.DisplayBounds);
                                m_DocumentDockContainer.Orientation = containerOrientation;
                                m_DocumentDockContainer.Documents.Add(newParent);
                                if (IsAddedInFront(dockSide))
                                    m_DocumentDockContainer.Documents.Insert(0, doc);
                                else
                                    m_DocumentDockContainer.Documents.Add(doc);
                            }
                        }
                        else
                        {
                            if (IsAddedInFront(dockSide))
                                m_DocumentDockContainer.Documents.Insert(0, doc);
                            else
                                m_DocumentDockContainer.Documents.Add(doc);
                        }
                    }
				}
				else
				{
					DocumentDockContainer parent=referenceDoc.Parent as DocumentDockContainer;

					referenceDoc.SetLayoutBounds(Rectangle.Empty);
					doc.SetLayoutBounds(Rectangle.Empty);

					if((parent.Orientation==eOrientation.Horizontal && (dockSide==eDockSide.Left || dockSide==eDockSide.Right)) ||
						(parent.Orientation==eOrientation.Vertical && (dockSide==eDockSide.Top || dockSide==eDockSide.Bottom)))
					{
						if(dockSide==eDockSide.Right || dockSide==eDockSide.Bottom)
							parent.Documents.Insert(parent.Documents.IndexOf(referenceDoc)+1,doc);
						else
							parent.Documents.Insert(parent.Documents.IndexOf(referenceDoc),doc);
					}
					else if(parent.Documents.Count==1)
					{
						// Orientation of the parent dock container can be changed
						if(parent.Orientation==eOrientation.Vertical)
							parent.Orientation=eOrientation.Horizontal;
						else
							parent.Orientation=eOrientation.Vertical;

						if(dockSide==eDockSide.Right || dockSide==eDockSide.Bottom)
							parent.Documents.Insert(parent.Documents.IndexOf(referenceDoc)+1,doc);
						else
							parent.Documents.Insert(parent.Documents.IndexOf(referenceDoc),doc);
					}
					else
					{
						// New DocumentDockContainer needs to be inserted with appropriate orientation and referenceBar needs
						// to be moved into it.
						DocumentDockContainer newParent=new DocumentDockContainer();
						if(parent.Orientation==eOrientation.Horizontal)
							newParent.Orientation=eOrientation.Vertical;
						else
							newParent.Orientation=eOrientation.Horizontal;

						parent.Documents.Insert(parent.Documents.IndexOf(referenceDoc),newParent);
						parent.Documents.Remove(referenceDoc);
	                    
						if(dockSide==eDockSide.Right || dockSide==eDockSide.Bottom)
						{
							newParent.Documents.Add(referenceDoc);
							newParent.Documents.Add(doc);
						}
						else
						{
							newParent.Documents.Add(doc);
							newParent.Documents.Add(referenceDoc);
						}
					}
				}

                AdjustContainerSize(barToDock, false);
			}

			if(m_Container!=null)
			{
				if(barToDock.Parent==null)
					m_Container.Controls.Add(barToDock);
                ApplyBarStyle(barToDock);	
				m_Container.RecalcLayout();
			}
			else
				ApplyBarStyle(barToDock);
		}

        /// <summary>
        /// Adjusts the size of the dock container if needed after a bar has been docked to it.
        /// </summary>
        /// <param name="barToDock">Bar object that has been docked.</param>
        /// <param name="visibleChanged">Indicates that bar was already docked but its Visible property has changed</param>
        internal void AdjustContainerSize(Bar barToDock, bool visibleChanged)
        {
            if (m_Container.Owner != null && m_Container.Owner.IsLoadingLayout) return;

            // Adjust the size of the container since it dictates the size of the bars docked inside
            if (m_Container.Dock != DockStyle.Fill)
            {
                DocumentBaseContainer doc = this.GetDocumentFromBar(barToDock);
                if (doc == null) return;
                if (m_Container.Dock == DockStyle.Left || m_Container.Dock == DockStyle.Right)
                {
                    if (m_Container.Width == 0 || doc.Parent == m_DocumentDockContainer &&
                        (m_DocumentDockContainer.Orientation == eOrientation.Horizontal || visibleChanged && m_DocumentDockContainer.Documents.Count == 1))
                    {
                        int width = barToDock.GetBarDockedSize(eOrientation.Vertical);
                        if (barToDock.Width > 0 && barToDock.Width<m_Container.Width) width = barToDock.Width;
                        int clientWidth = GetClientWidth();

                        if (barToDock.Visible)
                        {
                            if (width > clientWidth)
                                width = barToDock.MinimumDockSize(eOrientation.Vertical).Width * 2;
                            if (width > clientWidth)
                                width = barToDock.MinimumDockSize(eOrientation.Vertical).Width;
                        }
                        
						if(doc.LayoutBounds.Width == 0)
							doc.SetLayoutBounds(new Rectangle(doc.LayoutBounds.X, doc.LayoutBounds.Y, width, doc.LayoutBounds.Height));
                        width += Dpi.Width(m_DocumentDockContainer.SplitterSize);
                        if (visibleChanged)
                        {
                            if(barToDock.Visible)
                                m_Container.Width += width;
                            else if(m_Container.Width>0)
                                m_Container.Width -= Math.Min(width, m_Container.Width);
                        }
                        else
                            m_Container.Width += width;
                        m_Container.Invalidate();
                    }
                }
                else if (m_Container.Dock == DockStyle.Top || m_Container.Dock == DockStyle.Bottom)
                {
                    if (m_Container.Height == 0 || doc.Parent == m_DocumentDockContainer &&
                        (m_DocumentDockContainer.Orientation == eOrientation.Vertical || visibleChanged && m_DocumentDockContainer.Documents.Count == 1))
                    {
                        int height = barToDock.GetBarDockedSize(eOrientation.Horizontal);
                        if (barToDock.Height > 0 && barToDock.Height<m_Container.Height) height = barToDock.Height;
                        int clientHeight = GetClientHeight();

                        if (barToDock.Visible)
                        {
                            if (height > clientHeight)
                                height = barToDock.MinimumDockSize(eOrientation.Horizontal).Height * 2;
                            if (height > clientHeight)
                                height = barToDock.MinimumDockSize(eOrientation.Horizontal).Height;
                        }
                        
						if(doc.LayoutBounds.Height == 0)
							doc.SetLayoutBounds(new Rectangle(doc.LayoutBounds.X, doc.LayoutBounds.Y, doc.LayoutBounds.Width, height));
                        height += Dpi.Width(m_DocumentDockContainer.SplitterSize);
                        if (visibleChanged)
                        {
                            if (barToDock.Visible)
                                m_Container.Height += height;
                            else if (m_Container.Height > 0)
                                m_Container.Height -= Math.Min(height, m_Container.Height);
                        }
                        else
                            m_Container.Height += height;
                        m_Container.Invalidate();
                    }
                }
            }
        }

        private int GetClientWidth()
        {
            if (m_Container == null)
                return 0;

            return m_Container.GetClientWidth();
        }

        private int GetClientHeight()
        {
            if (m_Container == null)
                return 0;
            return m_Container.GetClientHeight();
        }

		public void UnDock(Bar barToUnDock)
		{
			UnDock(barToUnDock,true);
		}

        internal void SaveLastDockInfo(Bar bar, DocumentBarContainer doc, DockSiteInfo info)
        {
            if (bar.m_LastDockSiteInfo == null) return;
            //bar.m_LastDockSiteInfo.LastRelativeDockToBar = null;
            //bar.m_LastDockSiteInfo.LastRelativeDocumentId = -1;
            // Tries to find relative dock-to-bar so un-docked bar can be returned back
            if (!(doc.Parent is DocumentDockContainer)) return;
            DocumentDockContainer dockParent = (DocumentDockContainer)doc.Parent;
            DocumentBaseContainer nextBarDocument = GetNextDocument(dockParent, dockParent.Documents.IndexOf(doc));
            if (nextBarDocument == null)
            {
                DocumentBaseContainer prevBarDocument = GetPreviousDocument(dockParent, dockParent.Documents.IndexOf(doc));
                if (prevBarDocument != null)
                {
                    Bar prevBar = null;
                    if (prevBarDocument is DocumentBarContainer)
                    {
                        prevBar = ((DocumentBarContainer)prevBarDocument).Bar;
                        bar.m_LastDockSiteInfo.LastRelativeDockToBar = prevBar;
                        prevBar.m_LastDockSiteInfo.LastRelativeDockToBar = bar;
                        prevBar.m_LastDockSiteInfo.LastRelativeDocumentId = doc.Id;
                    }
                    bar.m_LastDockSiteInfo.LastRelativeDocumentId = prevBarDocument.Id;
                    if (dockParent.Orientation == eOrientation.Horizontal)
                    {
                        bar.LastDockSide = eDockSide.Right;
                        if (prevBar != null) prevBar.LastDockSide = eDockSide.Left;
                    }
                    else
                    {
                        bar.LastDockSide = eDockSide.Bottom;
                        if (prevBar != null) prevBar.LastDockSide = eDockSide.Top;
                    }
                }
            }
            else
            {
                Bar nextBar = null;
                if (nextBarDocument is DocumentBarContainer)
                {
                    nextBar = ((DocumentBarContainer)nextBarDocument).Bar;
                    bar.m_LastDockSiteInfo.LastRelativeDockToBar = nextBar;
                    nextBar.m_LastDockSiteInfo.LastRelativeDockToBar = bar;
                    nextBar.m_LastDockSiteInfo.LastRelativeDocumentId = doc.Id;
                }
                bar.m_LastDockSiteInfo.LastRelativeDocumentId = nextBarDocument.Id;
                if (dockParent.Orientation == eOrientation.Horizontal)
                {
                    bar.LastDockSide = eDockSide.Left;
                    if (nextBar != null) nextBar.LastDockSide = eDockSide.Right;
                }
                else
                {
                    bar.LastDockSide = eDockSide.Top;
                    if (nextBar != null) nextBar.LastDockSide = eDockSide.Bottom;
                }
            }
            if (GetDockSide(bar) != eDockSide.None)
                bar.m_LastDockSiteInfo.LastDockSiteSide = GetDockSide(bar);
        }

        private eDockSide GetDockSide(Bar bar)
        {
            if (bar.Parent == null)
                return eDockSide.None;
            else if (bar.Parent.Dock == DockStyle.Left)
                return eDockSide.Left;
            else if (bar.Parent.Dock == DockStyle.Right)
                return eDockSide.Right;
            else if (bar.Parent.Dock == DockStyle.Top)
                return eDockSide.Top;
            else if (bar.Parent.Dock == DockStyle.Bottom)
                return eDockSide.Bottom;
            else if (bar.Parent.Dock == DockStyle.Fill)
                return eDockSide.Document;
            return eDockSide.None;
        }

        [EditorBrowsable(EditorBrowsableState.Never)]
		public void UnDock(Bar barToUnDock, bool removeFromContainer)
		{
			DocumentBarContainer doc=m_DocumentDockContainer.GetBarDocumentContainer(barToUnDock);

            if (barToUnDock.DockSide != eDockSide.None) barToUnDock.LastDockSide = barToUnDock.DockSide;
            if (doc != null)
                SaveLastDockInfo(barToUnDock, doc, barToUnDock.m_LastDockSiteInfo);
            
            int containerSizeReduction = 0;
            // Calculate the size reduction of container if needed
            if (doc != null && m_Container != null && m_Container.Dock != DockStyle.Fill)
            {
                if (m_Container.Dock == DockStyle.Left || m_Container.Dock == DockStyle.Right)
                {
                    if (doc.Parent != null && doc.Parent == m_DocumentDockContainer && m_DocumentDockContainer.Orientation == eOrientation.Horizontal)
                        containerSizeReduction = barToUnDock.Width + Dpi.Width(m_DocumentDockContainer.SplitterSize);
                }
                else if (m_Container.Dock == DockStyle.Top || m_Container.Dock == DockStyle.Bottom)
                {
                    if (doc.Parent != null && doc.Parent == m_DocumentDockContainer && m_DocumentDockContainer.Orientation == eOrientation.Vertical)
                        containerSizeReduction = barToUnDock.Height + Dpi.Width(m_DocumentDockContainer.SplitterSize);
                }
            }

            if(doc==null)
            {
                if (removeFromContainer && barToUnDock.Parent == m_Container)
                    m_Container.Controls.Remove(barToUnDock);
				RestoreBarStyle(barToUnDock);
                return;
            }
			
			DocumentDockContainer parent=doc.Parent as DocumentDockContainer;
			if(parent!=null)
			{
				parent.Documents.Remove(doc);
				if(parent!=m_DocumentDockContainer)
					RemoveEmptyContainers(parent);
				else if(parent.Documents.Count==1 && parent.Documents[0] is DocumentDockContainer)
					RemoveEmptyContainers(parent.Documents[0] as DocumentDockContainer);
			}

			if(m_Container!=null)
			{
				if(removeFromContainer)
					m_Container.Controls.Remove(barToUnDock);
				RestoreBarStyle(barToUnDock);
                bool isLoadingLayout = false;
                if (m_Container.Owner != null) isLoadingLayout = m_Container.Owner.IsLoadingLayout;
                if (!isLoadingLayout && !m_Container.IsAnyControlVisible)
                {
                    if (m_Container.Dock == DockStyle.Left || m_Container.Dock == DockStyle.Right)
                        m_Container.Width = 0;
                    else if (m_Container.Dock == DockStyle.Top || m_Container.Dock == DockStyle.Bottom)
                        m_Container.Height = 0;
                }
                else if (!isLoadingLayout && containerSizeReduction != 0)
                {
                    if (m_Container.Dock == DockStyle.Left || m_Container.Dock == DockStyle.Right)
                        m_Container.Width -= containerSizeReduction;
                    else if (m_Container.Dock == DockStyle.Top || m_Container.Dock == DockStyle.Bottom)
                        m_Container.Height -= containerSizeReduction;
                }
                else
                    m_Container.RecalcLayout();
			}
			else
				RestoreBarStyle(barToUnDock);
		}

		private void RemoveEmptyContainers(DocumentDockContainer parent)
		{
			while(parent.Documents.Count==0 && parent.Parent!=null && parent.Parent is DocumentDockContainer ||
				parent.Parent!=null && parent.Parent is DocumentDockContainer && (((DocumentDockContainer)parent.Parent).Documents.Count==1 ||
                   parent.Documents.Count == 1))
			{
				if(parent.Parent!=null && parent.Parent is DocumentDockContainer && ((DocumentDockContainer)parent.Parent).Documents.Count==1)
				{
					// Removes the instances where DocumentDockContainer hosts another one and only one DocumentDockContainer object
					DocumentDockContainer p=parent.Parent as DocumentDockContainer;
                    p.Orientation = parent.Orientation;
                    p.Documents.Remove(parent);
					DocumentBaseContainer[] documents=new DocumentBaseContainer[parent.Documents.Count];
					parent.Documents.CopyTo(documents);
					p.Documents.AddRange(documents);
					parent=p;
				}
                else if (parent.Parent != null && parent.Parent is DocumentDockContainer && parent.Documents.Count == 1)
                {
                    DocumentDockContainer p = parent.Parent as DocumentDockContainer;
                    int index = p.Documents.IndexOf(parent);
                    p.Documents.Remove(parent);
                    DocumentBaseContainer document = parent.Documents[0];
                    p.Documents.Insert(index, document);
                    parent = p;
                }
				else
				{
					DocumentDockContainer p=parent.Parent as DocumentDockContainer;
					p.Documents.Remove(parent);
					parent=p;
				}
			}
		}

		private void ApplyBarStyle(Bar bar)
		{
			if(m_Container!=null && m_Container.Owner!=null && m_Container.Owner.ApplyDocumentBarStyle && m_Container.Dock == DockStyle.Fill)
			{
				BarFunctions.ApplyAutoDocumentBarStyle(bar);
			}
		}

		private void RestoreBarStyle(Bar bar)
		{
            if (m_Container != null && m_Container.Owner != null && m_Container.Owner.ApplyDocumentBarStyle && m_Container.Dock == DockStyle.Fill)
			{
				BarFunctions.RestoreAutoDocumentBarStyle(bar);
			}
		}

		private DocumentBarContainer CreateDocumentBarContainer(Bar bar)
		{
			DocumentBarContainer doc=new DocumentBarContainer(bar);
			return doc;
		}

		private DocumentDockContainer CreateDocumentDockContainer()
		{
			DocumentDockContainer dock=new DocumentDockContainer();
			return dock;
		}

		#endregion

		#region Mouse Resize Handling
        /// <summary>
        /// Gets whether document/bar is being resized.
        /// </summary>
        public bool IsResizingDocument
        {
            get
            {
                return (m_ResizeDocument != null);
            }
        }
		/// <summary>
		/// Processes OnMouseMove events from DockSite. This routine assumes that mouse messages are received only when mouse is actually over
		/// the dock site and not containing bars. This is significant because it will receive messages only if mouse is over the splitter
		/// space between bars.
		/// </summary>
		/// <param name="e">Mouse event arguments.</param>
		public void OnMouseMove(MouseEventArgs e)
		{
			int x=e.X,y=e.Y;
			if(e.Button==MouseButtons.None)
			{
				Cursor c=this.GetCursor(x,y);
				if(c==null)
				{
					if(m_ContainerCursor!=null)
						this.Container.Cursor=m_ContainerCursor;
					m_ContainerCursor=null;
				}
				else
				{
					if(m_ContainerCursor==null)
						m_ContainerCursor=this.Container.Cursor;
					this.Container.Cursor=c;
				}
			}
			else if(e.Button==MouseButtons.Left)
			{
				Point p=GetResizeToPoint(x,y);
				if(p.IsEmpty)
					return;

				if(!m_ResizePreview)
					SplitterMouseMove(p.X,p.Y);
				else
				{
					ResizeTo(p.X,p.Y);
					m_MouseDownPoint=p;
				}
			}
		}
        [EditorBrowsable(EditorBrowsableState.Never)]
		public Cursor GetCursor(int x, int y)
		{
			Cursor c=null;
			DocumentDockContainer context=this.GetContainerFromRoot(x,y);
			if(context!=null)
			{
				if(context.Orientation==eOrientation.Horizontal)
					c=Cursors.VSplit;
				else if(context.Orientation==eOrientation.Vertical)
					c=Cursors.HSplit;
			}
            else if (m_Container != null && m_Container.Dock != DockStyle.Fill)
            {
                if(m_Container.Dock == DockStyle.Top || m_Container.Dock == DockStyle.Bottom)
                    c = Cursors.HSplit;
                else if (m_Container.Dock == DockStyle.Left || m_Container.Dock == DockStyle.Right)
                    c = Cursors.VSplit;
            }

			return c;
		}

		public void OnMouseDown(MouseEventArgs e)
		{
			int x=e.X, y=e.Y;
			if(e.Button==MouseButtons.Left)
			{
				m_MouseDownPoint=new Point(x,y);
				DocumentDockContainer context=this.GetContainerFromRoot(x,y);
                
                if(context!=null)
				{
					m_ResizeDocument=this.GetClosestDocument(context,x,y);
					if(m_ResizeDocument==null)
						return;
					m_ResizeDockContainer=context;
					if(!m_ResizePreview)
					{
						CreateSplitter();
						SplitterMouseMove(x,y);
					}
				}
                else if (m_Container != null && m_Container.Dock != DockStyle.Fill)
                {
                    m_ResizeDockContainer = m_DocumentDockContainer;
                    if (!m_ResizePreview)
                    {
                        CreateSplitter();
                        SplitterMouseMove(x, y);
                    }
                }
			}
		}

		public void OnMouseUp(MouseEventArgs e)
		{
			if(m_ResizeDockContainer!=null && !m_MouseDownPoint.IsEmpty)
			{
				ResizeTo(e.X,e.Y);
			}

			m_MouseDownPoint=Point.Empty;
			m_ResizeDockContainer=null;
			m_ResizeDocument=null;
			DestroySplitter();
		}

		public void OnMouseLeave()
		{
			if(m_ContainerCursor!=null)
				this.Container.Cursor=m_ContainerCursor;
			m_ContainerCursor=null;
		}

		private DocumentBaseContainer GetClosestDocument(DocumentDockContainer parent, int x, int y)
		{
			DocumentBaseContainer ret=null;
			eOrientation orientation=parent.Orientation;
			foreach(DocumentBaseContainer doc in parent.Documents)
			{
				if(orientation==eOrientation.Horizontal && doc.DisplayBounds.X>x && doc.Visible)
                    break;
                else if(orientation==eOrientation.Vertical && doc.DisplayBounds.Y>y && doc.Visible)
					break;
                if(doc.Visible)
				    ret=doc;
			}
			return ret;
		}

		/// <summary>
		/// Returns reference to the DocumentDockContainer that contains specified coordinates. Searches through the Documents collection first.
		/// </summary>
		/// <param name="x">X coordinate</param>
		/// <param name="y">Y coordinate</param>
		/// <returns></returns>
		private DocumentDockContainer GetContainerFromRoot(int x, int y)
		{
			return GetContainer(m_DocumentDockContainer,x,y);
		}

		private DocumentDockContainer GetContainer(DocumentDockContainer parent, int x, int y)
		{
			if(parent==null || !parent.DisplayBounds.Contains(x,y) || !parent.Visible)
				return null;
			DocumentDockContainer ret=null;
			foreach(DocumentBaseContainer doc in parent.Documents)
			{
				if(doc is DocumentDockContainer)
				{
					ret=this.GetContainer((DocumentDockContainer)doc,x,y);
					if(ret!=null)
						break;
				}
			}

            if (ret == null)
                ret = parent;
			return ret;
		}
		
		private void CreateSplitter()
		{
            if (m_ResizeDockContainer == null)
				return;

			if(m_Splitter==null)
				m_Splitter=BarFunctions.CreateOutlineForm();
		}

		private void SplitterMouseMove(int x, int y)
		{
			if(m_Splitter==null || m_ResizeDockContainer==null)
				return;
			
            Rectangle splitterBounds=Rectangle.Empty;

			// Set splitter size
		    int splitterWidth = Dpi.Width(m_SplitterWidth);
		    if (m_ResizeDockContainer.Orientation == eOrientation.Horizontal && m_ResizeDocument != null || 
                m_ResizeDocument == null && (m_Container.Dock == DockStyle.Left || m_Container.Dock == DockStyle.Right))
			{
				Point p=m_Container.PointToScreen(new Point(x-splitterWidth/2,m_ResizeDockContainer.DisplayBounds.Y));
				splitterBounds.X=p.X;
				splitterBounds.Y=p.Y;
				splitterBounds.Height=m_ResizeDockContainer.DisplayBounds.Height;
				splitterBounds.Width=splitterWidth;
			}
            else if (m_ResizeDockContainer.Orientation == eOrientation.Vertical && m_ResizeDocument != null || 
                m_ResizeDocument == null && (m_Container.Dock == DockStyle.Bottom || m_Container.Dock == DockStyle.Top))
			{
				Point p=m_Container.PointToScreen(new Point(m_ResizeDockContainer.DisplayBounds.X,y-splitterWidth/2));
				splitterBounds.X=p.X;
				splitterBounds.Y=p.Y;
				splitterBounds.Width=m_ResizeDockContainer.DisplayBounds.Width;
				splitterBounds.Height=splitterWidth;
			}

			NativeFunctions.SetWindowPos(m_Splitter.Handle,new IntPtr(NativeFunctions.HWND_TOP),splitterBounds.X,splitterBounds.Y,splitterBounds.Width,splitterBounds.Height,NativeFunctions.SWP_SHOWWINDOW | NativeFunctions.SWP_NOACTIVATE);
		}

		private void DestroySplitter()
		{
			if(m_Splitter!=null)
			{
				m_Splitter.Visible=false;
				m_Splitter.Dispose();
				m_Splitter=null;
			}
		}

        internal Size GetContainerMinimumSize(DocumentDockContainer dockContainer)
        {
            Size minimumSize = Size.Empty;

            foreach (DocumentBaseContainer d in dockContainer.Documents)
            {
                Size dm = Size.Empty;

                if (d is DocumentBarContainer)
                {
                    if (!((DocumentBarContainer)d).Visible) continue;
                    dm = d.MinimumSize;
                }
                else if (d is DocumentDockContainer)
                {
                    dm = GetContainerMinimumSize(d as DocumentDockContainer);
                }

                if (dockContainer.Orientation == eOrientation.Horizontal)
                {
                    minimumSize.Width += dm.Width + Dpi.Width(dockContainer.SplitterSize);
                    if (dm.Height < minimumSize.Height || minimumSize.Height == 0)
                        minimumSize.Height = dm.Height;
                }
                else
                {
                    minimumSize.Height += dm.Height + Dpi.Width(dockContainer.SplitterSize);
                    if (dm.Width < minimumSize.Width || minimumSize.Width == 0)
                        minimumSize.Width = dm.Width;
                }
            }

            if (minimumSize.Width > 0 && dockContainer.Orientation == eOrientation.Horizontal)
                minimumSize.Width += Dpi.Width(dockContainer.SplitterSize);
            else if (minimumSize.Height > 0 && dockContainer.Orientation == eOrientation.Vertical)
                minimumSize.Height += Dpi.Width(dockContainer.SplitterSize);

            if (minimumSize.Width == 0)
                minimumSize.Width = 32;
            if (minimumSize.Height == 0)
                minimumSize.Height = 32;

            return minimumSize;
        }

		private Point GetResizeToPoint(int x, int y)
		{
			if(m_ResizeDockContainer==null)
				return Point.Empty;

			Point resizeTo=new Point(x,y);

			int xDiff=x-m_MouseDownPoint.X;
			int yDiff=y-m_MouseDownPoint.Y;

            if (m_ResizeDocument == null)
            {
                // Resizing the dock site
                if (m_Container.Dock == DockStyle.Left || m_Container.Dock == DockStyle.Right)
                {
                    if (m_Container.Dock == DockStyle.Right) xDiff *= -1;

                    Size minimumSize = GetContainerMinimumSize(m_ResizeDockContainer);
                    if (m_ResizeDockContainer.DisplayBounds.Width + xDiff < minimumSize.Width)
                        resizeTo.X -= ((m_ResizeDockContainer.DisplayBounds.Width + xDiff) - minimumSize.Width) * ((m_Container.Dock == DockStyle.Right ? -1 : 1));
                    else
                    {
                        int clientWidth = GetClientWidth();
                        int minClientWidth = 32;
                        if (m_Container.Owner != null)
                            minClientWidth = m_Container.Owner.MinimumClientSize.Width;

                        if (clientWidth - xDiff < minClientWidth)
                            resizeTo.X -= (minClientWidth - (clientWidth - xDiff)) * ((m_Container.Dock == DockStyle.Right ? -1 : 1));
                    }

                    return resizeTo;
                }
                else if (m_Container.Dock == DockStyle.Top || m_Container.Dock == DockStyle.Bottom)
                {
                    if (m_Container.Dock == DockStyle.Bottom) yDiff *= -1;

                    Size minimumSize = GetContainerMinimumSize(m_ResizeDockContainer);
                    if (m_ResizeDockContainer.DisplayBounds.Height + yDiff < minimumSize.Height)
                        resizeTo.Y -= ((m_ResizeDockContainer.DisplayBounds.Height + yDiff) - minimumSize.Height) * ((m_Container.Dock == DockStyle.Bottom ? -1 : 1));
                    else
                    {
                        int clientHeight = GetClientHeight();
                        int minClientHeight = 32;
                        if (m_Container.Owner != null)
                            minClientHeight = m_Container.Owner.MinimumClientSize.Height;
                        
                        if (clientHeight - yDiff < minClientHeight)
                            resizeTo.Y -= (minClientHeight - (clientHeight - yDiff)) * ((m_Container.Dock == DockStyle.Bottom ? -1 : 1));
                    }

                    return resizeTo;
                }

                return Point.Empty;
            }
			else if(m_ResizeDockContainer.Orientation==eOrientation.Horizontal)
			{
				if(m_ResizeDocument.DisplayBounds.Width+xDiff>=m_ResizeDocument.MinimumSize.Width)
				{
					// Verify document next to it
					DocumentBaseContainer nextDoc=GetNextDocument(m_ResizeDockContainer,m_ResizeDockContainer.Documents.IndexOf(m_ResizeDocument));
					if(nextDoc!=null)
					{
						if(nextDoc.DisplayBounds.Width-xDiff<nextDoc.MinimumSize.Width)
							resizeTo.X+=(nextDoc.DisplayBounds.Width-xDiff-nextDoc.MinimumSize.Width);
					}
				}
				else
					resizeTo.X-=(m_ResizeDocument.DisplayBounds.Width+xDiff-m_ResizeDocument.MinimumSize.Width);
			}
			else if(m_ResizeDockContainer.Orientation==eOrientation.Vertical)
			{
				if(m_ResizeDocument.DisplayBounds.Height+yDiff>=m_ResizeDocument.MinimumSize.Height)
				{
					DocumentBaseContainer nextDoc=GetNextDocument(m_ResizeDockContainer,m_ResizeDockContainer.Documents.IndexOf(m_ResizeDocument));
					if(nextDoc!=null)
					{
						if(nextDoc.DisplayBounds.Height-yDiff<nextDoc.MinimumSize.Height)
							resizeTo.Y+=(nextDoc.DisplayBounds.Height-yDiff-nextDoc.MinimumSize.Height);
					}
				}
				else
					resizeTo.Y-=(m_ResizeDocument.DisplayBounds.Height+yDiff-m_ResizeDocument.MinimumSize.Height);
			}

			return resizeTo;
		}

		private void ResetLayoutBounds(DocumentDockContainer doc)
		{
			foreach(DocumentBaseContainer d in doc.Documents)
				d.SetLayoutBounds(Rectangle.Empty);
		}

		private void ResizeTo(int x, int y)
		{
			if(m_ResizeDockContainer==null)
				return;

			Point resizeTo=GetResizeToPoint(x,y);
			
            int xDiff=resizeTo.X-m_MouseDownPoint.X;
			int yDiff=resizeTo.Y-m_MouseDownPoint.Y;

            if (m_ResizeDocument == null)
            {
                m_Container.SuspendLayout();
                if (m_Container.Dock == DockStyle.Left && xDiff!=0)
                {
                    if (m_DocumentDockContainer.Documents.Count > 0)
                    {
                        DocumentBaseContainer lastDoc = m_DocumentDockContainer.Documents[m_DocumentDockContainer.Documents.Count - 1];
                        int docWidth = lastDoc.DisplayBounds.Width + xDiff;
                        if (docWidth > lastDoc.MinimumSize.Width)
                            lastDoc.SetLayoutBounds(new Rectangle(lastDoc.DisplayBounds.X, lastDoc.DisplayBounds.Y, docWidth, lastDoc.DisplayBounds.Height));
						else
							ResetLayoutBounds(m_DocumentDockContainer);
                    }

                    m_Container.Width = m_Container.Width + xDiff;
					if(m_Container.Width <= this.GetContainerMinimumSize(m_DocumentDockContainer).Width)
						ResetLayoutBounds(m_DocumentDockContainer);
                }
                else if (m_Container.Dock == DockStyle.Right && xDiff != 0)
                {
                    if (m_DocumentDockContainer.Documents.Count > 0)
                    {
                        DocumentBaseContainer lastDoc = m_DocumentDockContainer.Documents[0];
                        int docWidth = lastDoc.DisplayBounds.Width - xDiff;
                        if (docWidth > lastDoc.MinimumSize.Width)
                            lastDoc.SetLayoutBounds(new Rectangle(lastDoc.DisplayBounds.X, lastDoc.DisplayBounds.Y, docWidth, lastDoc.DisplayBounds.Height));
                        else
                            ResetLayoutBounds(m_DocumentDockContainer);
                    }

                    m_Container.Width = m_Container.Width - xDiff;
					if(m_Container.Width <= this.GetContainerMinimumSize(m_DocumentDockContainer).Width)
						ResetLayoutBounds(m_DocumentDockContainer);
                }
                else if (m_Container.Dock == DockStyle.Top && yDiff != 0)
                {
                    if (m_DocumentDockContainer.Documents.Count > 0)
                    {
                        DocumentBaseContainer lastDoc = m_DocumentDockContainer.Documents[m_DocumentDockContainer.Documents.Count - 1];
                        int docHeight = lastDoc.DisplayBounds.Height + yDiff;
                        if (docHeight > lastDoc.MinimumSize.Height)
                            lastDoc.SetLayoutBounds(new Rectangle(lastDoc.DisplayBounds.X, lastDoc.DisplayBounds.Y, lastDoc.DisplayBounds.Width, docHeight));
                        else
                            ResetLayoutBounds(m_DocumentDockContainer);
                    }

                    m_Container.Height = m_Container.Height + yDiff;
					if(m_Container.Height <= this.GetContainerMinimumSize(m_DocumentDockContainer).Height)
						ResetLayoutBounds(m_DocumentDockContainer);
                }
                else if (m_Container.Dock == DockStyle.Bottom && yDiff != 0)
                {
                    if (m_DocumentDockContainer.Documents.Count > 0)
                    {
                        DocumentBaseContainer lastDoc = m_DocumentDockContainer.Documents[0];
                        int docHeight = lastDoc.DisplayBounds.Height - yDiff;
                        if (docHeight > lastDoc.MinimumSize.Height)
                            lastDoc.SetLayoutBounds(new Rectangle(lastDoc.DisplayBounds.X, lastDoc.DisplayBounds.Y, lastDoc.DisplayBounds.Width, docHeight));
                        else
                            ResetLayoutBounds(m_DocumentDockContainer);
                    }

                    m_Container.Height = m_Container.Height - yDiff;
					if(m_Container.Height <= this.GetContainerMinimumSize(m_DocumentDockContainer).Height)
						ResetLayoutBounds(m_DocumentDockContainer);
                }
                m_Container.ResumeLayout();
            }
			else if(m_ResizeDockContainer.Orientation==eOrientation.Horizontal && xDiff!=0)
			{
				m_ResizeDocument.SetWidth(m_ResizeDocument.DisplayBounds.Width+xDiff);
			}
            else if (m_ResizeDockContainer.Orientation == eOrientation.Vertical && yDiff != 0)
			{
				m_ResizeDocument.SetHeight(m_ResizeDocument.DisplayBounds.Height+yDiff);
			}

			m_Container.RecalcLayout();

            if (m_Container.Owner != null)
                ((IOwner)m_Container.Owner).InvokeUserCustomize(m_ResizeDocument, EventArgs.Empty);
		}

		private DocumentBaseContainer GetNextDocument(DocumentDockContainer parent, int refIndex)
		{
			int count=parent.Documents.Count;
			for(int i=refIndex+1;i<count;i++)
			{
				if(parent.Documents[i].Visible)
					return parent.Documents[i];
			}
			return null;
		}
        private DocumentBaseContainer GetPreviousDocument(DocumentDockContainer parent, int refIndex)
        {
            int count = parent.Documents.Count;
            for (int i = refIndex - 1; i >= 0; i--)
            {
                if (parent.Documents[i].Visible)
                    return parent.Documents[i];
            }
            return null;
        }

		/// <summary>
		/// Sets the width of the bar that is managed by this document layout. Width can be set only if parent container has
		/// Horizontal orientation. Note that bar minimum size is respected by this method and
		/// it will be enforced. If width is less than minimum width bar's width will be set to minimum width.
		/// </summary>
		/// <param name="bar">Reference to bar object.</param>
		/// <param name="width">Desired width.</param>
		public void SetBarWidth(Bar bar, int width)
		{
			DocumentBarContainer docBar=GetDocumentFromBar(bar) as DocumentBarContainer;
			if(docBar==null)
				return;
			if(docBar.Parent == m_DocumentDockContainer && (m_Container.Dock == DockStyle.Left || m_Container.Dock == DockStyle.Right)
				/*&& (m_DocumentDockContainer.Orientation == eOrientation.Vertical || m_DocumentDockContainer.Documents.Count == 1)*/)
			{
				m_Container.SuspendLayout();
				int diff = width;
				if(docBar.DisplayBounds.Width == 0)
					diff -= bar.GetBarDockedSize(eOrientation.Vertical);
				else
					diff -= docBar.DisplayBounds.Width;
                if (diff != 0)
                {
                    m_Container.Width += diff;
                    docBar.SetWidth(width);
                }
				//((DocumentDockContainer)docBar.Parent).SetWidth(width);
				m_Container.ResumeLayout(true);
			}
            else if (docBar.Parent is DocumentDockContainer && ((DocumentDockContainer)docBar.Parent).Orientation == eOrientation.Vertical)
            {
                ((DocumentDockContainer)docBar.Parent).SetWidth(width);
            }
            else
            {
                if (width < docBar.MinimumSize.Width)
                    width = docBar.MinimumSize.Width;
                docBar.SetWidth(width);
            }
			m_Container.RecalcLayout();
		}

		/// <summary>
		/// Sets the height of the bar that is managed by this document layout. Height can be set only if parent container has
		/// vertical orientation. Note that bar minimum size is respected by this method and
		/// it will be enforced. If height is less than minimum height bar's height will be set to minimum height.
		/// </summary>
		/// <param name="bar">Reference to bar object.</param>
		/// <param name="height">Desired height.</param>
		public void SetBarHeight(Bar bar, int height)
		{
			DocumentBarContainer docBar=GetDocumentFromBar(bar) as DocumentBarContainer;
			if(docBar==null)
				return;

            if (m_Container!=null && (m_Container.Dock == DockStyle.Top || m_Container.Dock== DockStyle.Bottom) && 
                docBar.Parent == m_DocumentDockContainer
                /*&& (m_DocumentDockContainer.Orientation == eOrientation.Horizontal || m_DocumentDockContainer.Documents.Count == 1)*/)
            {
                //m_Container.Height += (height - bar.Height);
                //m_DocumentDockContainer.SetHeight(height);
                m_Container.SuspendLayout();
                int diff = height;
                if (docBar.DisplayBounds.Height == 0)
                    diff -= bar.GetBarDockedSize(eOrientation.Vertical);
                else
                    diff -= docBar.DisplayBounds.Height;
                m_Container.Height += diff;
                //((DocumentDockContainer)docBar.Parent).SetHeight(height);
                docBar.SetHeight(height);
                m_Container.ResumeLayout(true);
            }
            else if (docBar.Parent is DocumentDockContainer && ((DocumentDockContainer)docBar.Parent).Orientation == eOrientation.Horizontal)
            {
                ((DocumentDockContainer)docBar.Parent).SetHeight(height);
            }
            else
            {
                if (height < docBar.MinimumSize.Height)
                    height = docBar.MinimumSize.Height;
                docBar.SetHeight(height);
            }
			m_Container.RecalcLayout();
		}
		#endregion

		#region Serialization
		internal void SerializeDefinition(XmlElement parent)
		{
            XmlElement docs = null;
            if (m_Container.Dock == DockStyle.Fill)
                docs = parent.OwnerDocument.CreateElement(DocumentSerializationXml.Documents);
            else
            {
                docs = parent.OwnerDocument.CreateElement(DocumentSerializationXml.DockSite);
                docs.SetAttribute(DocumentSerializationXml.DockSiteSize, XmlConvert.ToString((m_Container.Dock == DockStyle.Left || m_Container.Dock == DockStyle.Right) ? m_Container.Width : m_Container.Height));
                docs.SetAttribute(DocumentSerializationXml.DockingSide, Enum.GetName(typeof(DockStyle), m_Container.Dock));
            }

			parent.AppendChild(docs);

			SerializeDocumentDockContainer(docs,m_DocumentDockContainer, true);
		}

		internal void SerializeLayout(XmlElement parent)
		{
            XmlElement docs = null;
            if (m_Container.Dock == DockStyle.Fill)
                docs = parent.OwnerDocument.CreateElement(DocumentSerializationXml.Documents);
            else
            {
                docs = parent.OwnerDocument.CreateElement(DocumentSerializationXml.DockSite);
                docs.SetAttribute(DocumentSerializationXml.DockSiteSize, XmlConvert.ToString((m_Container.Dock == DockStyle.Left || m_Container.Dock == DockStyle.Right) ? m_Container.Width : m_Container.Height));
                docs.SetAttribute(DocumentSerializationXml.DockingSide, Enum.GetName(typeof(DockStyle), m_Container.Dock));
                docs.SetAttribute(DocumentSerializationXml.OriginalDockSiteSize, XmlConvert.ToString(m_Container.OriginalSize));
            }

			parent.AppendChild(docs);

			SerializeDocumentDockContainer(docs,m_DocumentDockContainer,false);
		}

        private bool SerializeDocument(DocumentDockContainer instance)
        {
            if (instance.Documents.Count == 0) return false;
            foreach (DocumentBaseContainer doc in instance.Documents)
            {
                DocumentBarContainer bar = doc as DocumentBarContainer;
                if (bar != null)
                {
                    if (bar.Bar != null && bar.Bar.SaveLayoutChanges) return true;
                }
                else
                    return true;
            }
            return false;
        }

		private void SerializeDocumentDockContainer(XmlElement parent, DocumentDockContainer instance, bool definitionSerialization)
		{
            if (!SerializeDocument(instance))
				return;
            XmlElement document = null;
			
            document=parent.OwnerDocument.CreateElement(DocumentSerializationXml.DockContainer);
			parent.AppendChild(document);
			document.SetAttribute(DocumentSerializationXml.Orientation,XmlConvert.ToString((int)instance.Orientation));
            document.SetAttribute(DocumentSerializationXml.Width, instance.LayoutBounds.Width.ToString());
            document.SetAttribute(DocumentSerializationXml.Height, instance.LayoutBounds.Height.ToString());

			foreach(DocumentBaseContainer doc in instance.Documents)
			{
				if(doc is DocumentDockContainer)
                    SerializeDocumentDockContainer(document,(DocumentDockContainer)doc,definitionSerialization);
				else if(doc is DocumentBarContainer)
					SerializeDocumentBarContainer(document,(DocumentBarContainer)doc,definitionSerialization);
			}
		}

		private void SerializeDocumentBarContainer(XmlElement parent, DocumentBarContainer instance, bool definitionSerialization)
		{
			if(instance.Bar==null || !instance.Bar.SaveLayoutChanges)
				return;
            
			XmlElement barDocument=parent.OwnerDocument.CreateElement(DocumentSerializationXml.BarContainer);
			parent.AppendChild(barDocument);
			
			barDocument.SetAttribute(DocumentSerializationXml.Width,instance.LayoutBounds.Width.ToString());
			barDocument.SetAttribute(DocumentSerializationXml.Height,instance.LayoutBounds.Height.ToString());
			
			XmlElement barElement=parent.OwnerDocument.CreateElement(BarSerializationXml.Bar);
			barDocument.AppendChild(barElement);
			
			if(definitionSerialization)
				instance.Bar.Serialize(barElement);
			else
				instance.Bar.SerializeLayout(barElement);
		}

		internal void DeserializeLayout(XmlElement parent)
		{
            if (parent.Name != DocumentSerializationXml.Documents && parent.Name != DocumentSerializationXml.DockSite || m_LoadingLayout)
				return;

			m_LoadingLayout=true;
            ItemSerializationContext context = new ItemSerializationContext();
			try
			{
				foreach(XmlElement elem in parent.ChildNodes)
				{
					if(elem.Name==DocumentSerializationXml.DockContainer)
					{
                        context.ItemXmlElement = elem;
						DeserializeDocumentDockContainer(context,m_DocumentDockContainer,false);
						break;
					}
				}
			}
			finally
			{
				m_LoadingLayout=false;
			}
            if (parent.Name == DocumentSerializationXml.DockSite)
            {
                if (m_Container.Dock == DockStyle.Left || m_Container.Dock == DockStyle.Right)
                    m_Container.Width = XmlConvert.ToInt32(parent.GetAttribute(DocumentSerializationXml.DockSiteSize));
                else if (m_Container.Dock == DockStyle.Top || m_Container.Dock == DockStyle.Bottom)
                    m_Container.Height = XmlConvert.ToInt32(parent.GetAttribute(DocumentSerializationXml.DockSiteSize));

                if (parent.HasAttribute(DocumentSerializationXml.OriginalDockSiteSize))
                    m_Container.OriginalSize = XmlConvert.ToInt32(parent.GetAttribute(DocumentSerializationXml.OriginalDockSiteSize));
            }

			m_Container.RecalcLayout();
		}

		internal void DeserializeDefinition(ItemSerializationContext context)
		{
            XmlElement parent = context.ItemXmlElement;
            if ((parent.Name != DocumentSerializationXml.Documents && parent.Name != DocumentSerializationXml.DockSite) || m_LoadingLayout)
				return;

			m_LoadingLayout=true;
			try
			{
				foreach(XmlElement elem in parent.ChildNodes)
				{
					if(elem.Name==DocumentSerializationXml.DockContainer)
					{
                        context.ItemXmlElement = elem;
						DeserializeDocumentDockContainer(context,m_DocumentDockContainer,true);
						break;
					}
				}

                if (parent.HasAttribute(DocumentSerializationXml.DockSiteSize))
                {
                    if (m_Container.Dock == DockStyle.Left || m_Container.Dock == DockStyle.Right)
                        m_Container.Width = XmlConvert.ToInt32(parent.GetAttribute(DocumentSerializationXml.DockSiteSize));
                    else if (m_Container.Dock == DockStyle.Top || m_Container.Dock == DockStyle.Bottom)
                        m_Container.Height = XmlConvert.ToInt32(parent.GetAttribute(DocumentSerializationXml.DockSiteSize));
                }
			}
			finally
			{
				m_LoadingLayout=false;
			}
			m_Container.RecalcLayout();
		}

		private void DeserializeDocumentDockContainer(ItemSerializationContext context, DocumentDockContainer instance, bool deserializeDefinition)
		{
            XmlElement docElement = context.ItemXmlElement;
			if(docElement.Name!=DocumentSerializationXml.DockContainer)
				return;

			instance.Documents.Clear();
			instance.Orientation=(eOrientation)XmlConvert.ToInt32(docElement.GetAttribute(DocumentSerializationXml.Orientation));
            if (docElement.HasAttribute(DocumentSerializationXml.Width) && docElement.HasAttribute(DocumentSerializationXml.Height))
            {
                instance.SetLayoutBounds(new Rectangle(0,0,
                    XmlConvert.ToInt32(docElement.GetAttribute(DocumentSerializationXml.Width)),
                    XmlConvert.ToInt32(docElement.GetAttribute(DocumentSerializationXml.Height))));
            }

			foreach(XmlElement elem in docElement.ChildNodes)
			{
				bool add=true;
				DocumentBaseContainer doc=DocumentSerializationXml.CreateDocument(elem.Name);
                context.ItemXmlElement = elem;
				if(doc is DocumentDockContainer)
					DeserializeDocumentDockContainer(context,(DocumentDockContainer)doc,deserializeDefinition);
				else if(doc is DocumentBarContainer)
                    add=DeserializeDocumentBarContainer(context,(DocumentBarContainer)doc,deserializeDefinition);
				if(add)
					instance.Documents.Add(doc);
			}
		}

		private bool DeserializeDocumentBarContainer(ItemSerializationContext context, DocumentBarContainer instance, bool deserializeDefinition)
		{
            XmlElement docElement = context.ItemXmlElement;
			if(docElement.Name!=DocumentSerializationXml.BarContainer)
				return false;
			
			instance.SetLayoutBounds(new Rectangle(0,0,XmlConvert.ToInt32(docElement.GetAttribute(DocumentSerializationXml.Width)),XmlConvert.ToInt32(docElement.GetAttribute(DocumentSerializationXml.Height))));
			
			foreach(XmlElement elem in docElement.ChildNodes)
			{
				if(elem.Name==BarSerializationXml.Bar)
				{
					instance.Bar=m_Container.Owner.Bars[elem.GetAttribute(BarSerializationXml.Name)];
					if(deserializeDefinition || instance.Bar==null && elem.HasAttribute(BarSerializationXml.Custom) && XmlConvert.ToBoolean(elem.GetAttribute(BarSerializationXml.Custom)))
					{
						// New bar that user has created try to deserialize but if it does not have items ignore it
						instance.Bar=new Bar();
						m_Container.Owner.Bars.Add(instance.Bar);
						if(deserializeDefinition)
							instance.Bar.Deserialize(elem, context);
						else
							instance.Bar.DeserializeLayout(elem);
						if(instance.Bar.Items.Count==0 && !deserializeDefinition)
						{
							m_Container.Owner.Bars.Remove(instance.Bar);
							return false;
						}
						return true;
					}

                    if (instance.Bar != null)
                    {
                        instance.Bar.DeserializeLayout(elem);
                        // Restore hidden dock container size so it can be used when bar is shown
                        if (!instance.Bar.IsVisible)
                        {
                            if (instance.LayoutBounds.Height > 0 && (instance.Bar.DockSide == eDockSide.Top || instance.Bar.DockSide == eDockSide.Bottom))
                            {
                                instance.Bar.Height = instance.LayoutBounds.Height;
                            }
                            else if (instance.LayoutBounds.Width > 0 && (instance.Bar.DockSide == eDockSide.Left || instance.Bar.DockSide == eDockSide.Right))
                            {
                                instance.Bar.Width = instance.LayoutBounds.Width;
                            }
                        }
                    }
                    else
                        return false;
					break;
				}
			}

			return true;
		}
		
		#endregion
	}
}