public void BeginDragContent(IDockContent content)
		{
			if (!InitDrag(content as Control, DragSource.Content))
				return;

			Content_BeginDrag(content);
		}

        /// <summary>
        /// Constructor used when window is created as consequence to user interaction.
        /// </summary>
        /// <param name="root">Parent dock panel</param>
        /// <param name="content">Content to host</param>
        /// <param name="origin">Origin, position on screen</param>
        /// <param name="size">Size of window</param>
        public FloatingWindow(DockPanel root, IDockContent content, Point origin, Size size)
            : this(root)
        {
            Left = origin.X;
            Top = origin.Y;
            Width = size.Width;
            Height = size.Height;
            if (content is TabLayout)
            {
                DockedContent = (TabLayout)content;
            }
            else
            {
                DockedContent = new TabLayout(Root);
                DockedContent.Dock(null, content, DockTo.Center);
            }
            foreach (DockContent subContent in DockedContent.Children)
            {
                subContent.Settings.DockState = DockState.Floating;				
            }
            Content = DockedContent;

            Binding b = new Binding("Header");
            b.Source = DockedContent;
            SetBinding(Window.TitleProperty, b);
        }

        protected internal DockPane(IDockContent content, FloatWindow floatWindow, bool show)
        {
            if (floatWindow == null)
                throw new ArgumentNullException("floatWindow");

            InternalConstruct(content, DockState.Float, false, Rectangle.Empty, floatWindow.NestedPanes.GetDefaultPreviousPane(this), DockAlignment.Right, 0.5, show);
        }

 protected internal DockPane(IDockContent content, DockPane previousPane, DockAlignment alignment, double proportion,
                             bool show)
 {
     if (previousPane == null)
         throw (new ArgumentNullException("previousPane"));
     InternalConstruct(content, previousPane.DockState, false, Rectangle.Empty, previousPane, alignment, proportion, show);
 }

		internal int Add(IDockContent content)
		{
			#if DEBUG
			if (DockPane != null)
				throw new InvalidOperationException();
			#endif

			if (Contains(content))
				return IndexOf(content);

			return InnerList.Add(content);
		}

        public ControlInfo(string name, string description, string id, Sce.Atf.Applications.StandardControlGroup group, object imageKey, IDockContent dockContent, IControlHostClient client)
        {
            Requires.NotNullOrEmpty(id, "id");
            Requires.NotNull(dockContent, "dockContent");
            Requires.NotNull(client, "client");

            DockContent = dockContent;
            dockContent.PropertyChanged += DockContent_PropertyChanged;
            Name = name;
            Description = description;
            Id = id;
            Group = group;
            ImageSourceKey = imageKey;
            Client = client;
        }

		internal void AddAt(IDockContent content, IDockContent before)
		{
			#if DEBUG
			if (DockPane != null)
				throw new InvalidOperationException();
			#endif

			if (!Contains(before))
				return;

			if (Contains(content))
				return;

			AddAt(content, IndexOf(before));
		}

		private void InternalConstruct(IDockContent content, DockState dockState, bool flagBounds, Rectangle floatWindowBounds, DockPane prevPane, DockAlignment alignment, double proportion, bool show)
		{
			if (dockState == DockState.Hidden || dockState == DockState.Unknown)
				throw new ArgumentException(Strings.DockPane_SetDockState_InvalidState);

			if (content == null)
				throw new ArgumentNullException(Strings.DockPane_Constructor_NullContent);

			if (content.DockHandler.DockPanel == null)
				throw new ArgumentException(Strings.DockPane_Constructor_NullDockPanel);


			SuspendLayout();
			SetStyle(ControlStyles.Selectable, false);

			m_isFloat = (dockState == DockState.Float);

			m_contents = new DockContentCollection();
			m_displayingContents = new DockContentCollection(this);
			m_dockPanel = content.DockHandler.DockPanel;
			m_dockPanel.AddPane(this);

			m_splitter = new SplitterControl(this);

			m_nestedDockingStatus = new NestedDockingStatus(this);

			m_captionControl = DockPanel.DockPaneCaptionFactory.CreateDockPaneCaption(this);
			m_tabStripControl = DockPanel.DockPaneStripFactory.CreateDockPaneStrip(this);
			Controls.AddRange(new Control[] {	m_captionControl, m_tabStripControl	});
			
			DockPanel.SuspendLayout(true);
			if (flagBounds)
				FloatWindow = DockPanel.FloatWindowFactory.CreateFloatWindow(DockPanel, this, floatWindowBounds);
			else if (prevPane != null)
				DockTo(prevPane.NestedPanesContainer, prevPane, alignment, proportion);

			SetDockState(dockState);
			if (show)
				content.DockHandler.Pane = this;
			else if (this.IsFloat)
				content.DockHandler.FloatPane = this;
			else
				content.DockHandler.PanelPane = this;

			ResumeLayout();
			DockPanel.ResumeLayout(true, true);
		}

 internal void RemoveContent(IDockContent content)
 {
     if (content == null)
         throw(new ArgumentNullException());
     
     if (Contents.Contains(content))
     {
         Contents.Remove(content);
         OnContentRemoved(new DockContentEventArgs(content));
     }
 }

        public IDockContent[] DocumentsToArray()
        {
            int count = DocumentsCount;
            IDockContent[] documents = new IDockContent[count];
            int i = 0;
            foreach (IDockContent content in Documents)
            {
                documents[i] = content;
                i++;
            }

            return documents;
        }

 protected override AutoHideStripBase.Tab CreateTab(IDockContent content)
 {
     return new TabVS2003(content);
 }

 public DockPane CreateDockPane(IDockContent content, DockPane prevPane, DockAlignment alignment,
                                double proportion, bool show)
 {
     return new DockPane(content, prevPane, alignment, proportion, show);
 }

 /// <summary>
 /// Return the content's parent as an IDockLayout</summary>
 /// <param name="content">The docked content whose parent is requested</param>
 /// <returns>The parent as IDockLayout</returns>
 IDockLayout IDockLayout.FindParentLayout(IDockContent content)
 {
     return (content is DockContent && Children.Contains((DockContent)content)) ? this : null;
 }

 /// <summary>
 /// Dock the new content next to content</summary>
 /// <param name="nextTo">Dock content to add new content next to</param>
 /// <param name="newContent">New content to be docked</param>
 /// <param name="dockTo">Side of nextTo content where new content should be docked</param>
 public void Dock(IDockContent nextTo, IDockContent newContent, DockTo dockTo)
 {
     TabLayout tabLayout = newContent as TabLayout;
     if (tabLayout != null)
     {
         IEnumerator<DockContent> contentEnumerator = tabLayout.Children.GetEnumerator();
         while (contentEnumerator.MoveNext())
         {
             DockContent content = contentEnumerator.Current;
             tabLayout.RemoveItem(content);
             AddOneItem((DockContent)nextTo, content);
             contentEnumerator = tabLayout.Children.GetEnumerator();
         }
     }
     else
     {
         AddOneItem((DockContent)nextTo, newContent as DockContent);
     }
     Focus();
     UpdateLayout();
 }

 /// <summary>
 /// Undock given content</summary>
 /// <param name="content">Content to undock</param>
 public void Undock(IDockContent content)
 {
     foreach (IDockContent contentItem in Children)
     {
         if (content == contentItem)
         {
             RemoveItem(content as DockContent);
             if (Parent is IDockLayout && Children.Count == 0)
             {
                 ((IDockLayout)Parent).Undock((IDockLayout)this);
             }
             break;
         }
     }
 }

			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 Show(DockPane pane, IDockContent beforeContent)
        {
            if (pane == null)
                throw(new ArgumentNullException(Strings.DockContentHandler_Show_NullPane));

            if (beforeContent != null && pane.Contents.IndexOf(beforeContent) == -1)
                throw(new ArgumentException(Strings.DockContentHandler_Show_InvalidBeforeContent));

            pane.DockPanel.SuspendLayout(true);

            DockPanel = pane.DockPanel;
            Pane = pane;
            pane.SetContentIndex(Content, pane.Contents.IndexOf(beforeContent));
            Show();

            pane.DockPanel.ResumeLayout(true, true);
        }

			public void 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;
			}

			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);
				}
			}