dockpanel.cs

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

		private Rectangle DocumentRectangle
		{
			get
			{
				Rectangle rect = DockArea;
				if (DockWindows[DockState.DockLeft].DisplayingList.Count != 0)
				{
					rect.X += (int)(DockArea.Width * DockLeftPortion);
					rect.Width -= (int)(DockArea.Width * DockLeftPortion);
				}
				if (DockWindows[DockState.DockRight].DisplayingList.Count != 0)
					rect.Width -= (int)(DockArea.Width * DockRightPortion);
				if (DockWindows[DockState.DockTop].DisplayingList.Count != 0)
				{
					rect.Y += (int)(DockArea.Height * DockTopPortion);
					rect.Height -= (int)(DockArea.Height * DockTopPortion);
				}
				if (DockWindows[DockState.DockBottom].DisplayingList.Count != 0)
					rect.Height -= (int)(DockArea.Height * DockBottomPortion);

				return rect;
			}
		}

		private DragHandler m_dragHandler;
		internal DragHandler DragHandler
		{
			get	{	return m_dragHandler;	}
		}

		private Control m_dummyControl;
		internal Control DummyControl
		{
			get	{	return m_dummyControl;	}
		}

		protected internal virtual IFloatWindowFactory FloatWindowFactory
		{
			get	{	return DefaultFloatWindowFactory;	}
		}

		private FloatWindowCollection m_floatWindows;
		[Browsable(false)]
		public FloatWindowCollection FloatWindows
		{
			get	{	return m_floatWindows;	}
		}

		private bool m_mdiIntegration = true;
		[LocalizedCategory("Category.Docking")]
		[LocalizedDescription("DockPanel.MdiIntegration.Description")]
		[DefaultValue(true)]
		public bool MdiIntegration
		{
			get	{	return m_mdiIntegration;	}
			set
			{
				if (value == m_mdiIntegration)
					return;

				m_mdiIntegration = value;
				RefreshMdiIntegration();
			}
		}

		protected override void OnLayout(LayoutEventArgs levent)
		{
			CalculateDockPadding();

			int width = ClientRectangle.Width - DockPadding.Left - DockPadding.Right;
			int height = ClientRectangle.Height - DockPadding.Top - DockPadding.Bottom;
			int dockLeftSize = (int)(width * m_dockLeftPortion);
			int dockRightSize = (int)(width * m_dockRightPortion);
			int dockTopSize = (int)(height * m_dockTopPortion);
			int dockBottomSize = (int)(height * m_dockBottomPortion);

			if (dockLeftSize < MeasurePane.MinSize)
				dockLeftSize = MeasurePane.MinSize;
			if (dockRightSize < MeasurePane.MinSize)
				dockRightSize = MeasurePane.MinSize;
			if (dockTopSize < MeasurePane.MinSize)
				dockTopSize = MeasurePane.MinSize;
			if (dockBottomSize < MeasurePane.MinSize)
				dockBottomSize = MeasurePane.MinSize;

			DockWindows[DockState.DockLeft].Width = dockLeftSize;
			DockWindows[DockState.DockRight].Width = dockRightSize;
			DockWindows[DockState.DockTop].Height = dockTopSize;
			DockWindows[DockState.DockBottom].Height = dockBottomSize;

			AutoHideWindow.Bounds = AutoHideWindowBounds;

			DockWindows[DockState.Document].BringToFront();
			AutoHideWindow.BringToFront();

			base.OnLayout(levent);
		}

		protected override void OnMouseDown(MouseEventArgs e)
		{
			base.OnMouseDown(e);

			if (e.Button != MouseButtons.Left)
				return;

			DockContent content = GetHitTest();
			if (content == null)
				return;

			if (content != ActiveAutoHideContent)
				ActiveAutoHideContent = content;

			if (!content.Pane.IsActivated)
				content.Pane.Activate();
		}

		protected override void OnMouseHover(EventArgs e)
		{
			base.OnMouseHover(e);

			DockContent content = GetHitTest();
			if (content != null && ActiveAutoHideContent != content)
			{
				ActiveAutoHideContent = content;
				Invalidate();
			}

			// requires further tracking of mouse hover behavior,
			// call TrackMouseEvent
			Win32.TRACKMOUSEEVENTS tme = new Win32.TRACKMOUSEEVENTS(Win32.TRACKMOUSEEVENTS.TME_HOVER, Handle, Win32.TRACKMOUSEEVENTS.HOVER_DEFAULT);
			User32.TrackMouseEvent(ref tme);
		}

		protected override void OnPaint(PaintEventArgs e)
		{
			base.OnPaint(e);

			CalculateDockPadding();

			Graphics g = e.Graphics;
			g.FillRectangle(SystemBrushes.AppWorkspace, ClientRectangle);

			CalculateTabs(DockState.DockLeftAutoHide);
			CalculateTabs(DockState.DockRightAutoHide);
			CalculateTabs(DockState.DockTopAutoHide);
			CalculateTabs(DockState.DockBottomAutoHide);

			int leftAutoHideWindows = GetCountOfAutoHidePanes(DockState.DockLeftAutoHide);
			int rightAutoHideWindows = GetCountOfAutoHidePanes(DockState.DockRightAutoHide);
			int topAutoHideWindows = GetCountOfAutoHidePanes(DockState.DockTopAutoHide);
			int bottomAutoHideWindows = GetCountOfAutoHidePanes(DockState.DockBottomAutoHide);

			Brush brush = Brushes.WhiteSmoke;
			int height = GetTabStripHeight();
			if (leftAutoHideWindows != 0 && topAutoHideWindows != 0)
				g.FillRectangle(brush, 0, 0, height, height);
			if (leftAutoHideWindows != 0 && bottomAutoHideWindows != 0)
				g.FillRectangle(brush, 0, Height - height, height, height);
			if (topAutoHideWindows != 0 && rightAutoHideWindows != 0)
				g.FillRectangle(brush, Width - height, 0, height, height);
			if (rightAutoHideWindows != 0 && bottomAutoHideWindows != 0)
				g.FillRectangle(brush, Width - height, Height - height, height, height);
			
			DrawTabStrip(e.Graphics, DockState.DockLeftAutoHide);
			DrawTabStrip(e.Graphics, DockState.DockRightAutoHide);
			DrawTabStrip(e.Graphics, DockState.DockTopAutoHide);
			DrawTabStrip(e.Graphics, DockState.DockBottomAutoHide);
		}

		internal void AddContent(DockContent content)
		{
			if (content == null)
				throw(new ArgumentNullException());

			if (!Contents.Contains(content))
			{
				Contents.Add(content);
				OnContentAdded(new DockContentEventArgs(content));
			}
		}

		internal void AddPane(DockPane pane)
		{
			if (Panes.Contains(pane))
				return;

			Panes.Add(pane);
		}

		internal void AddFloatWindow(FloatWindow floatWindow)
		{
			if (FloatWindows.Contains(floatWindow))
				return;

			FloatWindows.Add(floatWindow);
		}

		private void CalculateDockPadding()
		{
			DockPadding.All = 0;

			foreach (DockState state in AutoHideDockStates)
			{
				int countAutoHidePanes = GetCountOfAutoHidePanes(state);

				if (countAutoHidePanes == 0)
					continue;

				Rectangle rectTabStrip = GetTabStripRectangle(state);

				if (state == DockState.DockLeftAutoHide)
					DockPadding.Left = rectTabStrip.Height;
				else if (state == DockState.DockRightAutoHide)
					DockPadding.Right = rectTabStrip.Height;
				else if (state == DockState.DockTopAutoHide)
					DockPadding.Top = rectTabStrip.Height;
				else if (state == DockState.DockBottomAutoHide)
					DockPadding.Bottom = rectTabStrip.Height;
			}
		}

		private void CalculateTabs(DockState dockState)
		{
			Rectangle rectTabStrip = GetTabStripRectangle(dockState);

			int imageHeight = rectTabStrip.Height - MeasureAutoHideTab.ImageGapTop -
				MeasureAutoHideTab.ImageGapBottom;
			int imageWidth = MeasureAutoHideTab.ImageWidth;
			if (imageHeight > MeasureAutoHideTab.ImageHeight)
				imageWidth = MeasureAutoHideTab.ImageWidth * (imageHeight/MeasureAutoHideTab.ImageHeight);

			using (Graphics g = this.CreateGraphics())
			{
				int x = MeasureAutoHideTab.TabGapLeft + rectTabStrip.X;
				foreach (DockPane pane in Panes)
				{
					if (pane.DockState != dockState)
						continue;

					int maxWidth = 0;
					foreach (DockContent content in pane.Contents)
					{
						int width = imageWidth + MeasureAutoHideTab.ImageGapLeft +
							MeasureAutoHideTab.ImageGapRight +
							(int)g.MeasureString(content.TabText, Font).Width + 1 +
							MeasureAutoHideTab.TextGapLeft + MeasureAutoHideTab.TextGapRight;
						if (width > maxWidth)
							maxWidth = width;
					}

					foreach (DockContent content in pane.Contents)
					{
						if (content.IsHidden)
							continue;

						content.TabX = x;
						if (content == pane.ActiveContent)
							content.TabWidth = maxWidth;
						else
							content.TabWidth = imageWidth + MeasureAutoHideTab.ImageGapLeft + MeasureAutoHideTab.ImageGapRight;
						x += content.TabWidth;
					}
					x += MeasureAutoHideTab.TabGapBetween;
				}
			}
		}

		private void DrawTab(Graphics g, DockState dockState, DockPane pane, DockContent content)
		{
			Rectangle rectTab = GetTabRectangle(dockState, content);
			if (rectTab.IsEmpty)
				return;

			g.FillRectangle(SystemBrushes.Control, rectTab);

			g.DrawLine(SystemPens.GrayText, rectTab.Left, rectTab.Top, rectTab.Left, rectTab.Bottom);
			g.DrawLine(SystemPens.GrayText, rectTab.Right, rectTab.Top, rectTab.Right, rectTab.Bottom);
			if (dockState == DockState.DockTopAutoHide || dockState == DockState.DockRightAutoHide)
				g.DrawLine(SystemPens.GrayText, rectTab.Left, rectTab.Bottom, rectTab.Right, rectTab.Bottom);
			else
				g.DrawLine(SystemPens.GrayText, rectTab.Left, rectTab.Top, rectTab.Right, rectTab.Top);


			// Set no rotate for drawing icon and text
			Matrix matrixRotate = g.Transform;
			g.Transform = MatrixIdentity;

			// Draw the icon
			Rectangle rectImage = rectTab;
			rectImage.X += MeasureAutoHideTab.ImageGapLeft;
			rectImage.Y += MeasureAutoHideTab.ImageGapTop;
			int imageHeight = rectTab.Height - MeasureAutoHideTab.ImageGapTop -	MeasureAutoHideTab.ImageGapBottom;
			int imageWidth = MeasureAutoHideTab.ImageWidth;
			if (imageHeight > MeasureAutoHideTab.ImageHeight)
				imageWidth = MeasureAutoHideTab.ImageWidth * (imageHeight/MeasureAutoHideTab.ImageHeight);
			rectImage.Height = imageHeight;
			rectImage.Width = imageWidth;
			rectImage = GetTransformedRectangle(dockState, rectImage);
			g.DrawIcon(content.Icon, rectImage);

			// Draw the text
			if (content == pane.ActiveContent)
			{
				Rectangle rectText = rectTab;
				rectText.X += MeasureAutoHideTab.ImageGapLeft + imageWidth + MeasureAutoHideTab.ImageGapRight + MeasureAutoHideTab.TextGapLeft;
				rectText.Width -= MeasureAutoHideTab.ImageGapLeft + imageWidth + MeasureAutoHideTab.ImageGapRight + MeasureAutoHideTab.TextGapLeft;
				rectText = GetTransformedRectangle(dockState, rectText);
				if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
					g.DrawString(content.TabText, Font, SystemBrushes.FromSystemColor(SystemColors.ControlDarkDark), rectText, StringFormatTabVertical);
				else
					g.DrawString(content.TabText, Font, SystemBrushes.FromSystemColor(SystemColors.ControlDarkDark), rectText, StringFormatTabHorizontal);
			}

			// Set rotate back
			g.Transform = matrixRotate;
		}

		private void DrawTabStrip(Graphics g, DockState dockState)
		{
			Rectangle rectTabStrip = GetTabStripRectangle(dockState);

			if (rectTabStrip.IsEmpty)
				return;

			Matrix matrixIdentity = g.Transform;
			if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
			{
				Matrix matrixRotated = new Matrix();
				matrixRotated.RotateAt(90, new PointF((float)rectTabStrip.X + (float)rectTabStrip.Height / 2,
					(float)rectTabStrip.Y + (float)rectTabStrip.Height / 2));
				g.Transform = matrixRotated;
			}

			g.FillRectangle(Brushes.WhiteSmoke, rectTabStrip);

			foreach (DockPane pane in Panes)
			{
				if (pane.DockState != dockState)
					continue;

				foreach (DockContent content in pane.Contents)
				{
					if (!content.IsHidden)
						DrawTab(g, dockState, pane, content);
				}
			}
			g.Transform = matrixIdentity;
		}

		internal Rectangle AutoHideWindowBounds
		{
			get
			{
				DockState state = AutoHideWindow.DockState;
				Rectangle rectDockArea = DockArea;
				if (ActiveAutoHideContent == null)
					return Rectangle.Empty;

				Rectangle rect = Rectangle.Empty;
				if (state == DockState.DockLeftAutoHide)
				{
					int autoHideSize = (int)(rectDockArea.Width * ActiveAutoHideContent.AutoHidePortion);
					rect.X = rectDockArea.X;
					rect.Y = rectDockArea.Y;
					rect.Width = autoHideSize;
					rect.Height = rectDockArea.Height;
				}
				else if (state == DockState.DockRightAutoHide)
				{
					int autoHideSize = (int)(rectDockArea.Width * ActiveAutoHideContent.AutoHidePortion);
					rect.X = rectDockArea.X + rectDockArea.Width - autoHideSize;
					rect.Y = rectDockArea.Y;
					rect.Width = autoHideSize;
					rect.Height = rectDockArea.Height;
				}
				else if (state == DockState.DockTopAutoHide)
				{
					int autoHideSize = (int)(rectDockArea.Height * ActiveAutoHideContent.AutoHidePortion);
					rect.X = rectDockArea.X;
					rect.Y = rectDockArea.Y;
					rect.Width = rectDockArea.Width;
					rect.Height = autoHideSize;
				}
				else if (state == DockState.DockBottomAutoHide)
				{
					int autoHideSize = (int)(rectDockArea.Height * ActiveAutoHideContent.AutoHidePortion);
					rect.X = rectDockArea.X;
					rect.Y = rectDockArea.Y + rectDockArea.Height - autoHideSize;
					rect.Width = rectDockArea.Width;
					rect.Height = autoHideSize;
				}

				return rect;
			}
		}

		private int GetCountOfAutoHidePanes(DockState dockState)
		{
			int result = 0;

			foreach (DockPane pane in Panes)
			{
				if (pane.DockState == dockState)
					result ++;