コード例 #1
0
 protected override void OnMouseDown(MouseEventArgs e)
 {
     base.OnMouseDown(e);
     if (e.Button == MouseButtons.Left && this.DockPane.DockPanel.AllowEndUserDocking && this.DockPane.AllowDockDragAndDrop && !DockHelper.IsDockStateAutoHide(this.DockPane.DockState) && this.DockPane.ActiveContent != null)
     {
         this.DockPane.DockPanel.BeginDrag(this.DockPane);
     }
 }
コード例 #2
0
ファイル: DockPane.cs プロジェクト: luochunchun/dockbrowser
        private void RefreshStateChange(INestedPanesContainer oldContainer, DockState oldDockState)
        {
            lock (this)
            {
                if (IsRefreshStateChangeSuspended)
                {
                    return;
                }

                SuspendRefreshStateChange();
            }

            DockPanel.SuspendLayout(true);

            IDockContent contentFocused = GetFocusedContent();

            if (contentFocused != null)
            {
                DockPanel.SaveFocus();
            }
            SetParent();

            if (ActiveContent != null)
            {
                ActiveContent.DockHandler.SetDockState(ActiveContent.DockHandler.IsHidden, DockState, ActiveContent.DockHandler.Pane);
            }
            foreach (IDockContent content in Contents)
            {
                if (content.DockHandler.Pane == this)
                {
                    content.DockHandler.SetDockState(content.DockHandler.IsHidden, DockState, content.DockHandler.Pane);
                }
            }

            if (oldContainer != null)
            {
                Control oldContainerControl = (Control)oldContainer;
                if (oldContainer.DockState == oldDockState && !oldContainerControl.IsDisposed)
                {
                    oldContainerControl.PerformLayout();
                }
            }
            if (DockHelper.IsDockStateAutoHide(oldDockState))
            {
                DockPanel.RefreshActiveAutoHideContent();
            }

            if (NestedPanesContainer.DockState == DockState)
            {
                ((Control)NestedPanesContainer).PerformLayout();
            }
            if (DockHelper.IsDockStateAutoHide(DockState))
            {
                DockPanel.RefreshActiveAutoHideContent();
            }

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

            ResumeRefreshStateChange();

            if (contentFocused != null)
            {
                contentFocused.DockHandler.Activate();
            }

            DockPanel.ResumeLayout(true, true);

            if (oldDockState != DockState)
            {
                OnDockStateChanged(EventArgs.Empty);
            }
        }
コード例 #3
0
        private Rectangle GetLogicalTabStripRectangle(DockState dockState, bool transformed)
        {
            if (!DockHelper.IsDockStateAutoHide(dockState))
            {
                return(Rectangle.Empty);
            }

            int leftPanes   = GetPanes(DockState.DockLeftAutoHide).Count;
            int rightPanes  = GetPanes(DockState.DockRightAutoHide).Count;
            int topPanes    = GetPanes(DockState.DockTopAutoHide).Count;
            int bottomPanes = GetPanes(DockState.DockBottomAutoHide).Count;

            int x, y, width, height;

            height = MeasureHeight();
            if (dockState == DockState.DockLeftAutoHide && leftPanes > 0)
            {
                x     = 0;
                y     = (topPanes == 0) ? 0 : height;
                width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 : height);
            }
            else if (dockState == DockState.DockRightAutoHide && rightPanes > 0)
            {
                x = Width - height;
                if (leftPanes != 0 && x < height)
                {
                    x = height;
                }
                y     = (topPanes == 0) ? 0 : height;
                width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 : height);
            }
            else if (dockState == DockState.DockTopAutoHide && topPanes > 0)
            {
                x     = leftPanes == 0 ? 0 : height;
                y     = 0;
                width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
            }
            else if (dockState == DockState.DockBottomAutoHide && bottomPanes > 0)
            {
                x = leftPanes == 0 ? 0 : height;
                y = Height - height;
                if (topPanes != 0 && y < height)
                {
                    y = height;
                }
                width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
            }
            else
            {
                return(Rectangle.Empty);
            }

            if (!transformed)
            {
                return(new Rectangle(x, y, width, height));
            }
            else
            {
                return(GetTransformedRectangle(dockState, new Rectangle(x, y, width, height)));
            }
        }
コード例 #4
0
        internal void SetDockState(bool isHidden, DockState visibleState, DockPane oldPane)
        {
            if (IsSuspendSetDockState)
            {
                return;
            }

            if (DockPanel == null && visibleState != DockState.Unknown)
            {
                throw new InvalidOperationException(Strings.DockContentHandler_SetDockState_NullPanel);
            }

            if (visibleState == DockState.Hidden || (visibleState != DockState.Unknown && !IsDockStateValid(visibleState)))
            {
                throw new InvalidOperationException(Strings.DockContentHandler_SetDockState_InvalidState);
            }

            DockPanel dockPanel = DockPanel;

            if (dockPanel != null)
            {
                dockPanel.SuspendLayout(true);
            }

            SuspendSetDockState();

            DockState oldDockState = DockState;

            if (m_isHidden != isHidden || oldDockState == DockState.Unknown)
            {
                m_isHidden = isHidden;
            }
            m_visibleState = visibleState;
            m_dockState    = isHidden ? DockState.Hidden : visibleState;

            if (visibleState == DockState.Unknown)
            {
                Pane = null;
            }
            else
            {
                m_isFloat = (m_visibleState == DockState.Float);

                if (Pane == null)
                {
                    Pane = DockPanel.DockPaneFactory.CreateDockPane(Content, visibleState, true);
                }
                else if (Pane.DockState != visibleState)
                {
                    if (Pane.Contents.Count == 1)
                    {
                        Pane.SetDockState(visibleState);
                    }
                    else
                    {
                        Pane = DockPanel.DockPaneFactory.CreateDockPane(Content, visibleState, true);
                    }
                }
            }

            if (Form.ContainsFocus)
            {
                if (DockState == DockState.Hidden || DockState == DockState.Unknown)
                {
                    DockPanel.ContentFocusManager.GiveUpFocus(Content);
                }
            }

            SetPaneAndVisible(Pane);

            if (oldPane != null && !oldPane.IsDisposed && oldDockState == oldPane.DockState)
            {
                RefreshDockPane(oldPane);
            }

            if (Pane != null && DockState == Pane.DockState)
            {
                if ((Pane != oldPane) ||
                    (Pane == oldPane && oldDockState != oldPane.DockState))
                {
                    // Avoid early refresh of hidden AutoHide panes
                    if ((Pane.DockWindow == null || Pane.DockWindow.Visible || Pane.IsHidden) && !Pane.IsAutoHide)
                    {
                        RefreshDockPane(Pane);
                    }
                }
            }

            if (oldDockState != DockState)
            {
                if (DockState == DockState.Hidden || DockState == DockState.Unknown ||
                    DockHelper.IsDockStateAutoHide(DockState))
                {
                    DockPanel.ContentFocusManager.RemoveFromList(Content);
                }
                else
                {
                    DockPanel.ContentFocusManager.AddToList(Content);
                }

                OnDockStateChanged(EventArgs.Empty);
            }
            ResumeSetDockState();

            if (dockPanel != null)
            {
                dockPanel.ResumeLayout(true, true);
            }
        }
コード例 #5
0
 public bool IsDockStateValid(DockState dockState)
 {
     return((this.DockPanel == null || dockState != DockState.Document || this.DockPanel.DocumentStyle != DocumentStyle.SystemMdi) && DockHelper.IsDockStateValid(dockState, this.DockAreas));
 }
コード例 #6
0
 internal void SetDockState(bool isHidden, DockState visibleState, DockPane oldPane)
 {
     if (!this.IsSuspendSetDockState)
     {
         if (this.DockPanel == null && visibleState != DockState.Unknown)
         {
             throw new InvalidOperationException(Strings.DockContentHandler_SetDockState_NullPanel);
         }
         if (visibleState == DockState.Hidden || (visibleState != DockState.Unknown && !this.IsDockStateValid(visibleState)))
         {
             throw new InvalidOperationException(Strings.DockContentHandler_SetDockState_InvalidState);
         }
         DockPanel dockPanel = this.DockPanel;
         if (dockPanel != null)
         {
             dockPanel.SuspendLayout(true);
         }
         this.SuspendSetDockState();
         DockState dockState = this.DockState;
         if (this.m_isHidden != isHidden || dockState == DockState.Unknown)
         {
             this.m_isHidden = isHidden;
         }
         this.m_visibleState = visibleState;
         this.m_dockState    = (isHidden ? DockState.Hidden : visibleState);
         if (visibleState == DockState.Unknown)
         {
             this.Pane = null;
         }
         else
         {
             this.m_isFloat = (this.m_visibleState == DockState.Float);
             if (this.Pane == null)
             {
                 this.Pane = this.DockPanel.DockPaneFactory.CreateDockPane(this.Content, visibleState, true);
             }
             else
             {
                 if (this.Pane.DockState != visibleState)
                 {
                     if (this.Pane.Contents.Count == 1)
                     {
                         this.Pane.SetDockState(visibleState);
                     }
                     else
                     {
                         this.Pane = this.DockPanel.DockPaneFactory.CreateDockPane(this.Content, visibleState, true);
                     }
                 }
             }
         }
         if (this.Form.ContainsFocus && (this.DockState == DockState.Hidden || this.DockState == DockState.Unknown))
         {
             this.DockPanel.ContentFocusManager.GiveUpFocus(this.Content);
         }
         this.SetPaneAndVisible(this.Pane);
         if (oldPane != null && !oldPane.IsDisposed && dockState == oldPane.DockState)
         {
             DockContentHandler.RefreshDockPane(oldPane);
         }
         if (this.Pane != null && this.DockState == this.Pane.DockState)
         {
             if ((this.Pane != oldPane || (this.Pane == oldPane && dockState != oldPane.DockState)) && (this.Pane.DockWindow == null || this.Pane.DockWindow.Visible || this.Pane.IsHidden) && !this.Pane.IsAutoHide)
             {
                 DockContentHandler.RefreshDockPane(this.Pane);
             }
         }
         if (dockState != this.DockState)
         {
             if (this.DockState == DockState.Hidden || this.DockState == DockState.Unknown || DockHelper.IsDockStateAutoHide(this.DockState))
             {
                 this.DockPanel.ContentFocusManager.RemoveFromList(this.Content);
             }
             else
             {
                 this.DockPanel.ContentFocusManager.AddToList(this.Content);
             }
             this.OnDockStateChanged(EventArgs.Empty);
         }
         this.ResumeSetDockState();
         if (dockPanel != null)
         {
             dockPanel.ResumeLayout(true, true);
         }
     }
 }
コード例 #7
0
 private void AutoHide_Click(object sender, EventArgs e)
 {
     DockPane.DockState = DockHelper.ToggleAutoHideState(DockPane.DockState);
 }
コード例 #8
0
 private Rectangle GetLogicalTabStripRectangle(DockState dockState, bool transformed)
 {
     checked
     {
         Rectangle result;
         if (!DockHelper.IsDockStateAutoHide(dockState))
         {
             result = Rectangle.Empty;
         }
         else
         {
             int count  = base.GetPanes(DockState.DockLeftAutoHide).Count;
             int count2 = base.GetPanes(DockState.DockRightAutoHide).Count;
             int count3 = base.GetPanes(DockState.DockTopAutoHide).Count;
             int count4 = base.GetPanes(DockState.DockBottomAutoHide).Count;
             int num    = this.MeasureHeight();
             int num2;
             int num3;
             int width;
             if (dockState == DockState.DockLeftAutoHide && count > 0)
             {
                 num2  = 0;
                 num3  = ((count3 == 0) ? 0 : num);
                 width = base.Height - ((count3 == 0) ? 0 : num) - ((count4 == 0) ? 0 : num);
             }
             else
             {
                 if (dockState == DockState.DockRightAutoHide && count2 > 0)
                 {
                     num2 = base.Width - num;
                     if (count != 0 && num2 < num)
                     {
                         num2 = num;
                     }
                     num3  = ((count3 == 0) ? 0 : num);
                     width = base.Height - ((count3 == 0) ? 0 : num) - ((count4 == 0) ? 0 : num);
                 }
                 else
                 {
                     if (dockState == DockState.DockTopAutoHide && count3 > 0)
                     {
                         num2  = ((count == 0) ? 0 : num);
                         num3  = 0;
                         width = base.Width - ((count == 0) ? 0 : num) - ((count2 == 0) ? 0 : num);
                     }
                     else
                     {
                         if (dockState != DockState.DockBottomAutoHide || count4 <= 0)
                         {
                             result = Rectangle.Empty;
                             return(result);
                         }
                         num2 = ((count == 0) ? 0 : num);
                         num3 = base.Height - num;
                         if (count3 != 0 && num3 < num)
                         {
                             num3 = num;
                         }
                         width = base.Width - ((count == 0) ? 0 : num) - ((count2 == 0) ? 0 : num);
                     }
                 }
             }
             if (!transformed)
             {
                 result = new Rectangle(num2, num3, width, num);
             }
             else
             {
                 result = this.GetTransformedRectangle(dockState, new Rectangle(num2, num3, width, num));
             }
         }
         return(result);
     }
 }