| using System; |
| using System.Windows.Forms; |
| using System.Drawing; |
|
|
| namespace WeifenLuo.WinFormsUI.Docking |
| { |
| partial class DockPanel |
| { |
| internal class DefaultAutoHideWindowControl : AutoHideWindowControl |
| { |
| public DefaultAutoHideWindowControl(DockPanel dockPanel) : base(dockPanel) |
| { |
| m_splitter = new SplitterControl(this); |
| Controls.Add(m_splitter); |
| } |
|
|
| protected override void OnLayout(LayoutEventArgs levent) |
| { |
| DockPadding.All = 0; |
| if (DockState == DockState.DockLeftAutoHide) |
| { |
| DockPadding.Right = 2; |
| m_splitter.Dock = DockStyle.Right; |
| } |
| else if (DockState == DockState.DockRightAutoHide) |
| { |
| DockPadding.Left = 2; |
| m_splitter.Dock = DockStyle.Left; |
| } |
| else if (DockState == DockState.DockTopAutoHide) |
| { |
| DockPadding.Bottom = 2; |
| m_splitter.Dock = DockStyle.Bottom; |
| } |
| else if (DockState == DockState.DockBottomAutoHide) |
| { |
| DockPadding.Top = 2; |
| m_splitter.Dock = DockStyle.Top; |
| } |
|
|
| Rectangle rectDisplaying = DisplayingRectangle; |
| Rectangle rectHidden = new Rectangle(-rectDisplaying.Width, rectDisplaying.Y, rectDisplaying.Width, rectDisplaying.Height); |
| foreach (Control c in Controls) |
| { |
| DockPane pane = c as DockPane; |
| if (pane == null) |
| continue; |
|
|
|
|
| if (pane == ActivePane) |
| pane.Bounds = rectDisplaying; |
| else |
| pane.Bounds = rectHidden; |
| } |
|
|
| base.OnLayout(levent); |
| } |
|
|
| protected override void OnPaint(PaintEventArgs e) |
| { |
| |
| Graphics g = e.Graphics; |
|
|
| if (DockState == DockState.DockBottomAutoHide) |
| g.DrawLine(SystemPens.ControlLightLight, 0, 1, ClientRectangle.Right, 1); |
| else if (DockState == DockState.DockRightAutoHide) |
| g.DrawLine(SystemPens.ControlLightLight, 1, 0, 1, ClientRectangle.Bottom); |
| else if (DockState == DockState.DockTopAutoHide) |
| { |
| g.DrawLine(SystemPens.ControlDark, 0, ClientRectangle.Height - 2, ClientRectangle.Right, ClientRectangle.Height - 2); |
| g.DrawLine(SystemPens.ControlDarkDark, 0, ClientRectangle.Height - 1, ClientRectangle.Right, ClientRectangle.Height - 1); |
| } |
| else if (DockState == DockState.DockLeftAutoHide) |
| { |
| g.DrawLine(SystemPens.ControlDark, ClientRectangle.Width - 2, 0, ClientRectangle.Width - 2, ClientRectangle.Bottom); |
| g.DrawLine(SystemPens.ControlDarkDark, ClientRectangle.Width - 1, 0, ClientRectangle.Width - 1, ClientRectangle.Bottom); |
| } |
|
|
| base.OnPaint(e); |
| } |
| } |
|
|
| public class AutoHideWindowControl : Panel, ISplitterDragSource |
| { |
| protected class SplitterControl : SplitterBase |
| { |
| public SplitterControl(AutoHideWindowControl autoHideWindow) |
| { |
| m_autoHideWindow = autoHideWindow; |
| } |
|
|
| private AutoHideWindowControl m_autoHideWindow; |
| private AutoHideWindowControl AutoHideWindow |
| { |
| get { return m_autoHideWindow; } |
| } |
|
|
| protected override int SplitterSize |
| { |
| get { return Measures.SplitterSize; } |
| } |
|
|
| protected override void StartDrag() |
| { |
| AutoHideWindow.DockPanel.BeginDrag(AutoHideWindow, AutoHideWindow.RectangleToScreen(Bounds)); |
| } |
| } |
|
|
| #region consts |
| private const int ANIMATE_TIME = 100; |
| #endregion |
|
|
| private Timer m_timerMouseTrack; |
| protected SplitterBase m_splitter; |
|
|
| public AutoHideWindowControl(DockPanel dockPanel) |
| { |
| m_dockPanel = dockPanel; |
|
|
| m_timerMouseTrack = new Timer(); |
| m_timerMouseTrack.Tick += new EventHandler(TimerMouseTrack_Tick); |
|
|
| Visible = false; |
| } |
|
|
| protected override void Dispose(bool disposing) |
| { |
| if (disposing) |
| { |
| m_timerMouseTrack.Dispose(); |
| } |
| base.Dispose(disposing); |
| } |
|
|
| private DockPanel m_dockPanel = null; |
| public DockPanel DockPanel |
| { |
| get { return m_dockPanel; } |
| } |
|
|
| private DockPane m_activePane = null; |
| public DockPane ActivePane |
| { |
| get { return m_activePane; } |
| } |
| private void SetActivePane() |
| { |
| DockPane value = (ActiveContent == null ? null : ActiveContent.DockHandler.Pane); |
|
|
| if (value == m_activePane) |
| return; |
|
|
| m_activePane = value; |
| } |
|
|
| private static readonly object ActiveContentChangedEvent = new object(); |
| public event EventHandler ActiveContentChanged |
| { |
| add { Events.AddHandler(ActiveContentChangedEvent, value); } |
| remove { Events.RemoveHandler(ActiveContentChangedEvent, value); } |
| } |
|
|
| protected virtual void OnActiveContentChanged(EventArgs e) |
| { |
| EventHandler handler = (EventHandler)Events[ActiveContentChangedEvent]; |
| if (handler != null) |
| handler(this, e); |
| } |
|
|
| private IDockContent m_activeContent = null; |
| public IDockContent ActiveContent |
| { |
| get { return m_activeContent; } |
| set |
| { |
| if (value == m_activeContent) |
| return; |
|
|
| if (value != null) |
| { |
| if (!DockHelper.IsDockStateAutoHide(value.DockHandler.DockState) || value.DockHandler.DockPanel != DockPanel) |
| throw (new InvalidOperationException(Strings.DockPanel_ActiveAutoHideContent_InvalidValue)); |
| } |
|
|
| DockPanel.SuspendLayout(); |
|
|
| if (m_activeContent != null) |
| { |
| if (m_activeContent.DockHandler.Form.ContainsFocus) |
| { |
| if (!Win32Helper.IsRunningOnMono) |
| { |
| DockPanel.ContentFocusManager.GiveUpFocus(m_activeContent); |
| } |
| } |
|
|
| AnimateWindow(false); |
| } |
|
|
| m_activeContent = value; |
| SetActivePane(); |
| if (ActivePane != null) |
| ActivePane.ActiveContent = m_activeContent; |
|
|
| if (m_activeContent != null) |
| AnimateWindow(true); |
|
|
| DockPanel.ResumeLayout(); |
| DockPanel.RefreshAutoHideStrip(); |
|
|
| SetTimerMouseTrack(); |
|
|
| OnActiveContentChanged(EventArgs.Empty); |
| } |
| } |
|
|
| public DockState DockState |
| { |
| get { return ActiveContent == null ? DockState.Unknown : ActiveContent.DockHandler.DockState; } |
| } |
|
|
| private bool m_flagAnimate = true; |
| private bool FlagAnimate |
| { |
| get { return m_flagAnimate; } |
| set { m_flagAnimate = value; } |
| } |
|
|
| private bool m_flagDragging = false; |
| internal bool FlagDragging |
| { |
| get { return m_flagDragging; } |
| set |
| { |
| if (m_flagDragging == value) |
| return; |
|
|
| m_flagDragging = value; |
| SetTimerMouseTrack(); |
| } |
| } |
|
|
| private void AnimateWindow(bool show) |
| { |
| if (!FlagAnimate && Visible != show) |
| { |
| Visible = show; |
| return; |
| } |
|
|
| Parent.SuspendLayout(); |
|
|
| Rectangle rectSource = GetRectangle(!show); |
| Rectangle rectTarget = GetRectangle(show); |
| int dxLoc, dyLoc; |
| int dWidth, dHeight; |
| dxLoc = dyLoc = dWidth = dHeight = 0; |
| if (DockState == DockState.DockTopAutoHide) |
| dHeight = show ? 1 : -1; |
| else if (DockState == DockState.DockLeftAutoHide) |
| dWidth = show ? 1 : -1; |
| else if (DockState == DockState.DockRightAutoHide) |
| { |
| dxLoc = show ? -1 : 1; |
| dWidth = show ? 1 : -1; |
| } |
| else if (DockState == DockState.DockBottomAutoHide) |
| { |
| dyLoc = (show ? -1 : 1); |
| dHeight = (show ? 1 : -1); |
| } |
|
|
| if (show) |
| { |
| Bounds = DockPanel.GetAutoHideWindowBounds(new Rectangle(-rectTarget.Width, -rectTarget.Height, rectTarget.Width, rectTarget.Height)); |
| if (Visible == false) |
| Visible = true; |
| PerformLayout(); |
| } |
|
|
| SuspendLayout(); |
|
|
| LayoutAnimateWindow(rectSource); |
| if (Visible == false) |
| Visible = true; |
|
|
| int speedFactor = 1; |
| int totalPixels = (rectSource.Width != rectTarget.Width) ? |
| Math.Abs(rectSource.Width - rectTarget.Width) : |
| Math.Abs(rectSource.Height - rectTarget.Height); |
| int remainPixels = totalPixels; |
| DateTime startingTime = DateTime.Now; |
| while (rectSource != rectTarget) |
| { |
| DateTime startPerMove = DateTime.Now; |
|
|
| rectSource.X += dxLoc * speedFactor; |
| rectSource.Y += dyLoc * speedFactor; |
| rectSource.Width += dWidth * speedFactor; |
| rectSource.Height += dHeight * speedFactor; |
| if (Math.Sign(rectTarget.X - rectSource.X) != Math.Sign(dxLoc)) |
| rectSource.X = rectTarget.X; |
| if (Math.Sign(rectTarget.Y - rectSource.Y) != Math.Sign(dyLoc)) |
| rectSource.Y = rectTarget.Y; |
| if (Math.Sign(rectTarget.Width - rectSource.Width) != Math.Sign(dWidth)) |
| rectSource.Width = rectTarget.Width; |
| if (Math.Sign(rectTarget.Height - rectSource.Height) != Math.Sign(dHeight)) |
| rectSource.Height = rectTarget.Height; |
|
|
| LayoutAnimateWindow(rectSource); |
| if (Parent != null) |
| Parent.Update(); |
|
|
| remainPixels -= speedFactor; |
|
|
| while (true) |
| { |
| TimeSpan time = new TimeSpan(0, 0, 0, 0, ANIMATE_TIME); |
| TimeSpan elapsedPerMove = DateTime.Now - startPerMove; |
| TimeSpan elapsedTime = DateTime.Now - startingTime; |
| if (((int)((time - elapsedTime).TotalMilliseconds)) <= 0) |
| { |
| speedFactor = remainPixels; |
| break; |
| } |
| else |
| speedFactor = remainPixels * (int)elapsedPerMove.TotalMilliseconds / (int)((time - elapsedTime).TotalMilliseconds); |
| if (speedFactor >= 1) |
| break; |
| } |
| } |
| ResumeLayout(); |
| Parent.ResumeLayout(); |
| } |
|
|
| private void LayoutAnimateWindow(Rectangle rect) |
| { |
| Bounds = DockPanel.GetAutoHideWindowBounds(rect); |
|
|
| Rectangle rectClient = ClientRectangle; |
|
|
| if (DockState == DockState.DockLeftAutoHide) |
| ActivePane.Location = new Point(rectClient.Right - 2 - Measures.SplitterSize - ActivePane.Width, ActivePane.Location.Y); |
| else if (DockState == DockState.DockTopAutoHide) |
| ActivePane.Location = new Point(ActivePane.Location.X, rectClient.Bottom - 2 - Measures.SplitterSize - ActivePane.Height); |
| } |
|
|
| private Rectangle GetRectangle(bool show) |
| { |
| if (DockState == DockState.Unknown) |
| return Rectangle.Empty; |
|
|
| Rectangle rect = DockPanel.AutoHideWindowRectangle; |
|
|
| if (show) |
| return rect; |
|
|
| if (DockState == DockState.DockLeftAutoHide) |
| rect.Width = 0; |
| else if (DockState == DockState.DockRightAutoHide) |
| { |
| rect.X += rect.Width; |
| rect.Width = 0; |
| } |
| else if (DockState == DockState.DockTopAutoHide) |
| rect.Height = 0; |
| else |
| { |
| rect.Y += rect.Height; |
| rect.Height = 0; |
| } |
|
|
| return rect; |
| } |
|
|
| private void SetTimerMouseTrack() |
| { |
| if (ActivePane == null || ActivePane.IsActivated || FlagDragging) |
| { |
| m_timerMouseTrack.Enabled = false; |
| return; |
| } |
|
|
| |
| int hovertime = SystemInformation.MouseHoverTime ; |
|
|
| |
| if (hovertime <= 0) |
| hovertime = 400; |
|
|
| m_timerMouseTrack.Interval = 2 * (int)hovertime; |
| m_timerMouseTrack.Enabled = true; |
| } |
|
|
| protected virtual Rectangle DisplayingRectangle |
| { |
| get |
| { |
| Rectangle rect = ClientRectangle; |
|
|
| |
| if (DockState == DockState.DockBottomAutoHide) |
| { |
| rect.Y += 2 + Measures.SplitterSize; |
| rect.Height -= 2 + Measures.SplitterSize; |
| } |
| else if (DockState == DockState.DockRightAutoHide) |
| { |
| rect.X += 2 + Measures.SplitterSize; |
| rect.Width -= 2 + Measures.SplitterSize; |
| } |
| else if (DockState == DockState.DockTopAutoHide) |
| rect.Height -= 2 + Measures.SplitterSize; |
| else if (DockState == DockState.DockLeftAutoHide) |
| rect.Width -= 2 + Measures.SplitterSize; |
|
|
| return rect; |
| } |
| } |
|
|
| public void RefreshActiveContent() |
| { |
| if (ActiveContent == null) |
| return; |
|
|
| if (!DockHelper.IsDockStateAutoHide(ActiveContent.DockHandler.DockState)) |
| { |
| FlagAnimate = false; |
| ActiveContent = null; |
| FlagAnimate = true; |
| } |
| } |
|
|
| public void RefreshActivePane() |
| { |
| SetTimerMouseTrack(); |
| } |
|
|
| private void TimerMouseTrack_Tick(object sender, EventArgs e) |
| { |
| if (IsDisposed) |
| return; |
|
|
| if (ActivePane == null || ActivePane.IsActivated) |
| { |
| m_timerMouseTrack.Enabled = false; |
| return; |
| } |
|
|
| DockPane pane = ActivePane; |
| Point ptMouseInAutoHideWindow = PointToClient(Control.MousePosition); |
| Point ptMouseInDockPanel = DockPanel.PointToClient(Control.MousePosition); |
|
|
| Rectangle rectTabStrip = DockPanel.GetTabStripRectangle(pane.DockState); |
|
|
| if (!ClientRectangle.Contains(ptMouseInAutoHideWindow) && !rectTabStrip.Contains(ptMouseInDockPanel)) |
| { |
| ActiveContent = null; |
| m_timerMouseTrack.Enabled = false; |
| } |
| } |
|
|
| #region ISplitterDragSource Members |
|
|
| void ISplitterDragSource.BeginDrag(Rectangle rectSplitter) |
| { |
| FlagDragging = true; |
| } |
|
|
| void ISplitterDragSource.EndDrag() |
| { |
| FlagDragging = false; |
| } |
|
|
| bool ISplitterDragSource.IsVertical |
| { |
| get { return (DockState == DockState.DockLeftAutoHide || DockState == DockState.DockRightAutoHide); } |
| } |
|
|
| Rectangle ISplitterDragSource.DragLimitBounds |
| { |
| get |
| { |
| Rectangle rectLimit = DockPanel.DockArea; |
|
|
| if ((this as ISplitterDragSource).IsVertical) |
| { |
| rectLimit.X += MeasurePane.MinSize; |
| rectLimit.Width -= 2 * MeasurePane.MinSize; |
| } |
| else |
| { |
| rectLimit.Y += MeasurePane.MinSize; |
| rectLimit.Height -= 2 * MeasurePane.MinSize; |
| } |
|
|
| return DockPanel.RectangleToScreen(rectLimit); |
| } |
| } |
|
|
| void ISplitterDragSource.MoveSplitter(int offset) |
| { |
| Rectangle rectDockArea = DockPanel.DockArea; |
| IDockContent content = ActiveContent; |
| if (DockState == DockState.DockLeftAutoHide && rectDockArea.Width > 0) |
| { |
| if (content.DockHandler.AutoHidePortion < 1) |
| content.DockHandler.AutoHidePortion += ((double)offset) / (double)rectDockArea.Width; |
| else |
| content.DockHandler.AutoHidePortion = Width + offset; |
| } |
| else if (DockState == DockState.DockRightAutoHide && rectDockArea.Width > 0) |
| { |
| if (content.DockHandler.AutoHidePortion < 1) |
| content.DockHandler.AutoHidePortion -= ((double)offset) / (double)rectDockArea.Width; |
| else |
| content.DockHandler.AutoHidePortion = Width - offset; |
| } |
| else if (DockState == DockState.DockBottomAutoHide && rectDockArea.Height > 0) |
| { |
| if (content.DockHandler.AutoHidePortion < 1) |
| content.DockHandler.AutoHidePortion -= ((double)offset) / (double)rectDockArea.Height; |
| else |
| content.DockHandler.AutoHidePortion = Height - offset; |
| } |
| else if (DockState == DockState.DockTopAutoHide && rectDockArea.Height > 0) |
| { |
| if (content.DockHandler.AutoHidePortion < 1) |
| content.DockHandler.AutoHidePortion += ((double)offset) / (double)rectDockArea.Height; |
| else |
| content.DockHandler.AutoHidePortion = Height + offset; |
| } |
| } |
|
|
| #region IDragSource Members |
|
|
| Control IDragSource.DragControl |
| { |
| get { return this; } |
| } |
|
|
| #endregion |
|
|
| #endregion |
| } |
|
|
| private AutoHideWindowControl AutoHideWindow |
| { |
| get { return m_autoHideWindow; } |
| } |
|
|
| internal Control AutoHideControl |
| { |
| get { return m_autoHideWindow; } |
| } |
|
|
| internal void RefreshActiveAutoHideContent() |
| { |
| AutoHideWindow.RefreshActiveContent(); |
| } |
|
|
| internal Rectangle AutoHideWindowRectangle |
| { |
| get |
| { |
| DockState state = AutoHideWindow.DockState; |
| Rectangle rectDockArea = DockArea; |
| if (ActiveAutoHideContent == null) |
| return Rectangle.Empty; |
|
|
| if (Parent == null) |
| return Rectangle.Empty; |
|
|
| Rectangle rect = Rectangle.Empty; |
| double autoHideSize = ActiveAutoHideContent.DockHandler.AutoHidePortion; |
| if (state == DockState.DockLeftAutoHide) |
| { |
| if (autoHideSize < 1) |
| autoHideSize = rectDockArea.Width * autoHideSize; |
| if (autoHideSize > rectDockArea.Width - MeasurePane.MinSize) |
| autoHideSize = rectDockArea.Width - MeasurePane.MinSize; |
| rect.X = rectDockArea.X; |
| rect.Y = rectDockArea.Y; |
| rect.Width = (int)autoHideSize; |
| rect.Height = rectDockArea.Height; |
| } |
| else if (state == DockState.DockRightAutoHide) |
| { |
| if (autoHideSize < 1) |
| autoHideSize = rectDockArea.Width * autoHideSize; |
| if (autoHideSize > rectDockArea.Width - MeasurePane.MinSize) |
| autoHideSize = rectDockArea.Width - MeasurePane.MinSize; |
| rect.X = rectDockArea.X + rectDockArea.Width - (int)autoHideSize; |
| rect.Y = rectDockArea.Y; |
| rect.Width = (int)autoHideSize; |
| rect.Height = rectDockArea.Height; |
| } |
| else if (state == DockState.DockTopAutoHide) |
| { |
| if (autoHideSize < 1) |
| autoHideSize = rectDockArea.Height * autoHideSize; |
| if (autoHideSize > rectDockArea.Height - MeasurePane.MinSize) |
| autoHideSize = rectDockArea.Height - MeasurePane.MinSize; |
| rect.X = rectDockArea.X; |
| rect.Y = rectDockArea.Y; |
| rect.Width = rectDockArea.Width; |
| rect.Height = (int)autoHideSize; |
| } |
| else if (state == DockState.DockBottomAutoHide) |
| { |
| if (autoHideSize < 1) |
| autoHideSize = rectDockArea.Height * autoHideSize; |
| if (autoHideSize > rectDockArea.Height - MeasurePane.MinSize) |
| autoHideSize = rectDockArea.Height - MeasurePane.MinSize; |
| rect.X = rectDockArea.X; |
| rect.Y = rectDockArea.Y + rectDockArea.Height - (int)autoHideSize; |
| rect.Width = rectDockArea.Width; |
| rect.Height = (int)autoHideSize; |
| } |
|
|
| return rect; |
| } |
| } |
|
|
| internal Rectangle GetAutoHideWindowBounds(Rectangle rectAutoHideWindow) |
| { |
| if (DocumentStyle == DocumentStyle.SystemMdi || |
| DocumentStyle == DocumentStyle.DockingMdi) |
| return (Parent == null) ? Rectangle.Empty : Parent.RectangleToClient(RectangleToScreen(rectAutoHideWindow)); |
| else |
| return rectAutoHideWindow; |
| } |
|
|
| internal void RefreshAutoHideStrip() |
| { |
| AutoHideStripControl.RefreshChanges(); |
| } |
|
|
| } |
| } |
|
|
