dockpane.cs

来自「全功能c#编译器」· CS 代码 · 共 1,899 行 · 第 1/4 页

			if (DockHelper.IsDockStateAutoHide(DockState))
				return;

			if (!dragHandler.IsDockStateValid(DockState))
				return;

			if (dragHandler.DragSource == DragSource.FloatWindow &&
				FloatWindow == dragHandler.DragControl)
				return;

			if (dragHandler.DragSource == DragSource.Pane &&
				dragHandler.DragControl == this)
				return;

			if (dragHandler.DragSource == DragSource.Content && 
				dragHandler.DragControl == this &&
				DockState == DockState.Document &&
				CountOfVisibleContents == 1)
				return;

			Point ptClient = PointToClient(pt);
			Rectangle rectPane = DisplayingRectangle;
			int dragSize = MeasurePane.DragSize;
			if (ptClient.Y - rectPane.Top >= 0 && ptClient.Y - rectPane.Top < dragSize)
				dragHandler.DropTarget.SetDropTarget(this, DockStyle.Top);
			else if (rectPane.Bottom - ptClient.Y >= 0 && rectPane.Bottom - ptClient.Y < dragSize)
				dragHandler.DropTarget.SetDropTarget(this, DockStyle.Bottom);
			else if (rectPane.Right - ptClient.X >= 0 && rectPane.Right - ptClient.X < dragSize)
				dragHandler.DropTarget.SetDropTarget(this, DockStyle.Right);
			else if (ptClient.X - rectPane.Left >= 0 && ptClient.X - rectPane.Left < dragSize)
				dragHandler.DropTarget.SetDropTarget(this, DockStyle.Left);
			else
			{
				if (rectPane.Height <= GetTabStripRectangle().Height)
					return;

				HitTestResult hitTestResult = GetHitTest(pt);
				if (hitTestResult.HitArea == HitTestArea.Caption)
					dragHandler.DropTarget.SetDropTarget(this, -1);
				else if (hitTestResult.HitArea == HitTestArea.TabStrip && hitTestResult.Index != -1)
					dragHandler.DropTarget.SetDropTarget(this, hitTestResult.Index);
				else if (DockState == DockState.Float && !HasCaption &&
					((ptClient.Y - rectPane.Top >= dragSize && ptClient.Y - rectPane.Top < 2 * dragSize) ||
					(rectPane.Bottom - ptClient.Y >= dragSize && rectPane.Bottom - ptClient.Y < 2 * dragSize) ||
					(rectPane.Right - ptClient.X >= dragSize && rectPane.Right - ptClient.X < 2 * dragSize) ||
					(ptClient.X - rectPane.Left >= dragSize && ptClient.X - rectPane.Left < 2 * dragSize)))
					dragHandler.DropTarget.SetDropTarget(this, -1);
				else
					return;
			}

			if (dragHandler.DropTarget.SameAsOldValue)
				return;

			dragHandler.DragOutline = GetTestDropOutline(dragHandler.DropTarget.Dock, dragHandler.DropTarget.ContentIndex);
		}

		internal void ValidateActiveContent()
		{
			if (ActiveContent == null)
				return;

			if (GetIndexOfVisibleContents(ActiveContent) >= 0)
				return;

			DockContent prevVisible = null;
			for (int i=Contents.IndexOf(ActiveContent)-1; i>=0; i--)
				if (!Contents[i].IsHidden)
				{
					prevVisible = Contents[i];
					break;
				}

			DockContent nextVisible = null;
			for (int i=Contents.IndexOf(ActiveContent)+1; i<Contents.Count; i++)
				if (!Contents[i].IsHidden)
				{
					nextVisible = Contents[i];
					break;
				}

			if (prevVisible != null)
				ActiveContent = prevVisible;
			else if (nextVisible != null)
				ActiveContent = nextVisible;
			else
				ActiveContent = null;
		}

		protected override void WndProc(ref Message m)
		{
			if (m.Msg == (int)Win32.Msgs.WM_MOUSEACTIVATE)
			{
				Activate();
				base.WndProc(ref m);
				return;
			}
			else if (m.Msg == (int)Win32.Msgs.WM_LBUTTONDOWN)
			{
				HitTestResult hitTestResult = GetHitTest();
				if (hitTestResult.HitArea == HitTestArea.TabStrip && hitTestResult.Index != -1)
				{
					DockContent content = GetVisibleContent(hitTestResult.Index);
					if (ActiveContent != content)
					{
						ActiveContent = content;
						Update();
					}
					if (DockPanel.AllowRedocking && AllowRedocking && ActiveContent.AllowRedocking)
						DockPanel.DragHandler.BeginDragContent(this, DisplayingRectangle);
				}
				else if (hitTestResult.HitArea == HitTestArea.Caption &&
					DockPanel.AllowRedocking && AllowRedocking &&
					!DockHelper.IsDockStateAutoHide(DockState))
					DockPanel.DragHandler.BeginDragPane(this, CaptionRectangle.Location);
				else
					base.WndProc(ref m);
				return;
			}
			else if (m.Msg == (int)Win32.Msgs.WM_RBUTTONDOWN)
			{
				HitTestResult hitTestResult = GetHitTest();
				if (hitTestResult.HitArea == HitTestArea.TabStrip && hitTestResult.Index != -1)
				{
					DockContent content = 
						GetVisibleContent(hitTestResult.Index);
					if (ActiveContent != content)
					{
						ActiveContent = content;
						Update();
					}
					if (content.TabPageContextMenu != null) 
					{
						content.TabPageContextMenu.Show(this, this.PointToClient(Control.MousePosition));
					}
				}
			}
			else if (m.Msg == (int)Win32.Msgs.WM_LBUTTONDBLCLK)
			{
				base.WndProc(ref m);

				HitTestResult hitTestResult = GetHitTest();
				if (hitTestResult.HitArea == HitTestArea.Caption)
				{

					if (DockHelper.IsDockStateAutoHide(DockState))
					{
						DockPanel.ActiveAutoHideContent = null;
						return;
					}

					if (DockPanel.AllowRedocking && DockHelper.IsDockStateDocked(DockState) && IsDockStateValid(DockState.Float))
					{
						DockState = DockState.Float;
						Activate();
					}
					else if (DockPanel.AllowRedocking && DockState == DockState.Float && DockWindow != null && IsDockStateValid(DockWindow.DockState))
					{
						DockState = DockWindow.DockState;
						Activate();
					}
				}
				else if (DockPanel.AllowRedocking && hitTestResult.HitArea == HitTestArea.TabStrip && hitTestResult.Index != -1)
				{
					DockContent content = GetVisibleContent(hitTestResult.Index);
					if (content.IsDockStateValid(DockState.Float))
					{
						DockState dockState = DockState;
						content.DockState = DockState.Float;
						if (content.Pane != this)
						{
							DockAlignment alignment = (dockState == DockState.DockLeft || dockState == DockState.DockRight) ? DockAlignment.Bottom : DockAlignment.Right;
							content.Pane.AddToDockList(DockListContainer, this, alignment, 0.5);
						}
					}
				}

				return;
			}

			base.WndProc(ref m);
			return;
		}

		private static readonly object DockStateChangedEvent = new object();
		public event EventHandler DockStateChanged
		{
			add	{	Events.AddHandler(DockStateChangedEvent, value);	}
			remove	{	Events.RemoveHandler(DockStateChangedEvent, value);	}
		}
		protected virtual void OnDockStateChanged(EventArgs e)
		{
			EventHandler handler = (EventHandler)Events[DockStateChangedEvent];
			if (handler != null)
				handler(this, e);
		}

		private static readonly object IsActivatedChangedEvent = new object();
		public event EventHandler IsActivatedChanged
		{
			add	{	Events.AddHandler(IsActivatedChangedEvent, value);	}
			remove	{	Events.RemoveHandler(IsActivatedChangedEvent, value);	}
		}
		protected virtual void OnIsActivatedChanged(EventArgs e)
		{
			EventHandler handler = (EventHandler)Events[IsActivatedChangedEvent];
			if (handler != null)
				handler(this, e);
		}

		private static readonly object IsActiveDocumentPaneChangedEvent = new object();
		public event EventHandler IsActiveDocumentPaneChanged
		{
			add	{	Events.AddHandler(IsActiveDocumentPaneChangedEvent, value);	}
			remove	{	Events.RemoveHandler(IsActiveDocumentPaneChangedEvent, value);	}
		}
		protected virtual void OnIsActiveDocumentPaneChanged(EventArgs e)
		{
			EventHandler handler = (EventHandler)Events[IsActiveDocumentPaneChangedEvent];
			if (handler != null)
				handler(this, e);
		}

		public DockWindow DockWindow
		{
			get	{	return (m_nestedDockingNormal.DockList == null) ? null : m_nestedDockingNormal.DockList.Container as DockWindow;	}
			set
			{
				DockWindow oldValue = DockWindow;
				if (oldValue == value)
					return;

				if (value != null)
					AddToDockList(value);
				else if (oldValue != null)
					RemoveFromDockList(oldValue);
			}
		}

		public FloatWindow FloatWindow
		{
			get	{	return (m_nestedDockingFloat.DockList == null) ? null : m_nestedDockingFloat.DockList.Container as FloatWindow;	}
			set
			{
				FloatWindow oldValue = FloatWindow;
				if (oldValue == value)
					return;

				if (value != null)
					AddToDockList(value);
				else if (oldValue != null)
					RemoveFromDockList(oldValue);
			}
		}

		public NestedDockingStatus GetNestedDockingStatus(bool isFloat)
		{
			return isFloat ? m_nestedDockingFloat : m_nestedDockingNormal;
		}

		public NestedDockingStatus NestedDockingStatus
		{
			get
			{
				if (DockState == DockState.Float)
					return m_nestedDockingFloat;
				else if (DockHelper.IsDockWindowState(DockState))
					return m_nestedDockingNormal;
				else
					return null;
			}
		}
		
		public IDockListContainer DockListContainer
		{
			get
			{
				if (DockState == DockState.Float)
					return m_nestedDockingFloat.DockList.Container;
				else if (DockHelper.IsDockWindowState(DockState))
					return m_nestedDockingNormal.DockList.Container;
				else
					return null;
			}
		}

		private DockState m_visibleState = DockState.Unknown;
		public DockState VisibleState
		{
			get	{	return m_visibleState;	}
			set
			{
				if (m_visibleState == value)
					return;

				if (value == DockState.Unknown || value == DockState.Hidden)
					throw new InvalidOperationException(ResourceHelper.GetString("DockPane.VisibleState.InvalidState"));

				m_visibleState = value;
				SetDockState();
			}
		}
		private DockState m_dockState = DockState.Unknown;
		public DockState DockState
		{
			get	{	return m_dockState;	}
			set
			{
				if (m_dockState == value)
					return;

				if (value == DockState.Unknown)
					throw new InvalidOperationException(ResourceHelper.GetString("DockPane.VisibleState.InvalidState"));
				if (value == DockState.Hidden)
					IsHidden = true;
				else
				{
					m_isHidden = false;
					m_visibleState = value;
					SetDockState();
				}
			}
		}
		internal void SetDockState()
		{
			DockState value, oldDockState;

			if (CountOfVisibleContents == 0)
				value = DockState.Unknown;
			else if (IsHidden)
				value = DockState.Hidden;
			else
				value = m_visibleState;

			if (m_dockState == value)
				return;

			oldDockState = m_dockState;
			FloatWindow oldFloatWindow = oldDockState == DockState.Float ? FloatWindow : null;
			m_dockState = value;

			if (DockState == DockState.Float && FloatWindow == null)
				DockPanel.FloatWindowFactory.CreateFloatWindow(DockPanel, this);

			if (DockHelper.IsDockWindowState(DockState) && (DockWindow == null || DockWindow.DockState != DockState))
				DockWindow = DockPanel.DockWindows[DockState];

			SetParent();

			foreach (DockContent content in Contents)
				content.SetDockState();

			if (oldFloatWindow != null && !oldFloatWindow.IsDisposed)
				oldFloatWindow.PerformLayout();
			else if (DockHelper.IsDockStateAutoHide(oldDockState))
				DockPanel.AutoHideWindow.RefreshActiveContent();
			else if (DockHelper.IsDockWindowState(oldDockState))
				DockPanel.DockWindows[oldDockState].PerformLayout();

			if (DockState == DockState.Float)
				FloatWindow.PerformLayout();
			else if (DockHelper.IsDockStateAutoHide(DockState))
				DockPanel.AutoHideWindow.RefreshActiveContent();
			else if (DockHelper.IsDockWindowState(DockState))
				DockPanel.DockWindows[DockState].PerformLayout();

			if (DockHelper.IsDockStateAutoHide(oldDockState) ||
				DockHelper.IsDockStateAutoHide(DockState))
			{
				DockPanel.Invalidate();
				DockPanel.PerformLayout();
			}

			DockPanel.RefreshActiveWindow();

			//*** Use PostMessage instead
			User32.PostMessage(this.Handle, WM_DOCKSTATECHANGED, 0, 0);
			OnDockStateChanged(EventArgs.Empty);
		}

		public void AddToDockList(IDockListContainer container)
		{
			if (container == null)
				throw new InvalidOperationException(ResourceHelper.GetString("DockPane.AddToDockList.NullContainer"));

			DockAlignment alignment;
			if (container.DockState == DockState.DockLeft || container.DockState == DockState.DockRight)
				alignment = DockAlignment.Bottom;
			else
				alignment = DockAlignment.Right;

			DockPane prevPane = null;
			for (int i=container.DockList.Count-1; i>=0; i++)
				if (container.DockList[i] != this)
				{
					prevPane = container.DockList[i];
					break;
				}
			AddToDockList(container, prevPane, alignment, 0.5);
		}

		public void AddToDockList(IDockListContainer container, DockPane prevPane, DockAlignment alignment, double proportion)
		{
			if (container == null)
				throw new InvalidOperationException(ResourceHelper.GetString("DockPane.AddToDockList.NullContainer"));

			int count = container.DockList.Count;
			if (container.DockList.Contains(this))
				count --;
			if (prevPane == null && count > 0)
				throw new InvalidOperationException(ResourceHelper.GetString("DockPane.AddToDockList.NullPrevPane"));

			if (prevPane != null && !container.DockList.Contains(prevPane))
				throw new InvalidOperationException(ResourceHelper.GetString("DockPane.AddToDockList.NoPrevPane"));

			if (prevPane == this)
				throw new InvalidOperationException(ResourceHelper.GetString("DockPane.AddToDockList.SelfPrevPane"));

			IDockListContainer oldContainer = (container.DockState == DockState.Float)
				? FloatWindow as IDockListContainer : DockWindow as IDockListContainer;
			if (oldContainer != null)
				oldContainer.DockList.Remove(this);
			container.DockList.Add(this);
			NestedDockingStatus status = GetNestedDockingStatus(container.DockState == DockState.Float);
			status.SetStatus(container.DockList, prevPane, alignment, proportion);

			DockState oldState = DockState;
			if (oldContainer != null && oldContainer.DockState == oldState)
					DockState = container.DockState;

			if (oldState == DockState.Float && DockState == DockState.Float && oldContainer != container)
				SetParent();

			if (oldContainer != null)
			{	
				if (oldContainer.DockState == DockState.Float && oldContainer.DockList.Count == 0)
					((FloatWindow)oldContainer).Close();
				else if (oldState == oldContainer.DockState)
					((Control)oldContainer).PerformLayout();
			}

			if (container != null && container != oldContainer)
				((Control)container).PerformLayout();
		}

		public void RemoveFromDockList(IDockListContainer container)
		{
			if (!container.DockList.Contains(this))
				return;

			container.DockList.Remove(this);
			if (DockState == container.DockState)
				DockState = DockState.Unknown;
			if (container.DockState == DockState.Float && container.DockList.Count == 0)
				((FloatWindow)container).Close();
			else
				((Control)container).PerformLayout();
		}

		public void SetNestedDockingProportion(double proportion)
		{
			SetNestedDockingProportion(proportion, DockState == DockState.Float);
		}

		public void SetNestedDockingProportion(double proportion, bool isFloat)
		{
			NestedDockingStatus status = this.GetNestedDockingStatus(isFloat);
			status.SetStatus(status.DockList, status.PrevPane, status.Alignment, proportion);
			if ((this.DockState == DockState.Float) == isFloat)
				((Control)this.DockListContainer).PerformLayout();
		}
	}
}