예제 #1
0
파일: DockPane.cs 프로젝트: NTDLS/SyntaxBox
        /// <include file='CodeDoc\DockPane.xml' path='//CodeDoc/Class[@name="DockPane"]/Method[@name="Float()"]/*'/>
        public DockPane Float()
        {
            IDockableWindow activeContent = ActiveContent;

            DockPane floatPane = GetFloatPaneFromContents();

            if (floatPane == null)
            {
                IDockableWindow firstContent = GetFirstContent(DockState.Float);
                if (firstContent == null)
                {
                    return(null);
                }
                floatPane = DockPanel.DockPaneFactory.CreateDockPane(firstContent, DockState.Float, true);
            }
            SetVisibleContentsToPane(floatPane, activeContent);
            floatPane.Activate();

            return(floatPane);
        }
예제 #2
0
        /// <exclude/>
        protected override void WndProc(ref Message m)
        {
            if (m.Msg == (int)Win32.Msgs.WM_LBUTTONDOWN)
            {
                int index = GetHitTest();
                if (index != -1)
                {
                    IDockableWindow content = Tabs[index].Content;
                    if (DockPane.ActiveContent != content)
                    {
                        DockPane.ActiveContent = content;
                        DockPane.Activate();
                        Update();
                    }
                    if (DockPane.DockPanel.AllowRedocking && DockPane.AllowRedocking && DockPane.ActiveContent.DockHandler.AllowRedocking)
                    {
                        DockPane.DockPanel.DragHandler.BeginDragContent(DockPane.ActiveContent);
                    }
                }
                else
                {
                    base.WndProc(ref m);
                }
                return;
            }
            else if (m.Msg == (int)Win32.Msgs.WM_RBUTTONDOWN)
            {
                int index = GetHitTest();
                if (index != -1)
                {
                    IDockableWindow content = Tabs[index].Content;
                    if (DockPane.ActiveContent != content)
                    {
                        DockPane.ActiveContent = content;
                    }
                }
                base.WndProc(ref m);
                return;
            }
            else if (m.Msg == (int)Win32.Msgs.WM_RBUTTONUP)
            {
                int index = GetHitTest();
                if (index != -1)
                {
                    IDockableWindow content = Tabs[index].Content;
                    #if FRAMEWORK_VER_2x
                    if (content.DockHandler.TabPageContextMenuStrip != null)
                    {
                        content.DockHandler.TabPageContextMenuStrip.Show(this, this.PointToClient(Control.MousePosition));
                    }
                    else if (content.DockHandler.TabPageContextMenu != null)
                    {
                        content.DockHandler.TabPageContextMenu.Show(this, this.PointToClient(Control.MousePosition));
                    }
                    #else
                    if (content.DockHandler.TabPageContextMenu != null)
                    {
                        content.DockHandler.TabPageContextMenu.Show(this, this.PointToClient(Control.MousePosition));
                    }
                    #endif
                }
                base.WndProc(ref m);
                return;
            }
            else if (m.Msg == (int)Win32.Msgs.WM_LBUTTONDBLCLK)
            {
                base.WndProc(ref m);

                int index = GetHitTest();
                if (DockPane.DockPanel.AllowRedocking && index != -1)
                {
                    IDockableWindow content = Tabs[index].Content;
                    try     { content.DockHandler.IsFloat = !content.DockHandler.IsFloat; }
                    catch   {       }
                }

                return;
            }

            base.WndProc(ref m);
            return;
        }
예제 #3
0
        private void Pane_OnEndDrag(bool abort)
        {
            User32.SetCursor(DragControl.Cursor.Handle);

            if (abort)
            {
                return;
            }

            DockPane pane = (DockPane)DragControl;

            if (!DockOutline.FloatWindowBounds.IsEmpty)
            {
                if (pane.FloatWindow == null || pane.FloatWindow.DockList.Count != 1)
                {
                    pane.FloatWindow = pane.DockPanel.FloatWindowFactory.CreateFloatWindow(pane.DockPanel, pane, DockOutline.FloatWindowBounds);
                }
                else
                {
                    pane.FloatWindow.Bounds = DockOutline.FloatWindowBounds;
                }

                pane.DockState = DockState.Float;
                pane.Activate();
            }
            else if (DockOutline.DockTo is DockPane)
            {
                DockPane paneTo = DockOutline.DockTo as DockPane;

                if (DockOutline.Dock == DockStyle.Fill)
                {
                    for (int i = pane.Contents.Count - 1; i >= 0; i--)
                    {
                        IDockableWindow c = pane.Contents[i];
                        c.DockHandler.Pane = paneTo;
                        if (DockOutline.ContentIndex != -1)
                        {
                            paneTo.SetContentIndex(c, DockOutline.ContentIndex);
                        }
                        c.DockHandler.Activate();
                    }
                }
                else
                {
                    if (DockOutline.Dock == DockStyle.Left)
                    {
                        pane.AddToDockList(paneTo.DockListContainer, paneTo, DockAlignment.Left, 0.5);
                    }
                    else if (DockOutline.Dock == DockStyle.Right)
                    {
                        pane.AddToDockList(paneTo.DockListContainer, paneTo, DockAlignment.Right, 0.5);
                    }
                    else if (DockOutline.Dock == DockStyle.Top)
                    {
                        pane.AddToDockList(paneTo.DockListContainer, paneTo, DockAlignment.Top, 0.5);
                    }
                    else if (DockOutline.Dock == DockStyle.Bottom)
                    {
                        pane.AddToDockList(paneTo.DockListContainer, paneTo, DockAlignment.Bottom, 0.5);
                    }

                    pane.DockState = paneTo.DockState;
                    pane.Activate();
                }
            }
            else if (DockOutline.DockTo is DockContainer)
            {
                SetDockWindow();
                if (DockOutline.Dock == DockStyle.Top)
                {
                    pane.DockState = DockState.DockTop;
                }
                else if (DockOutline.Dock == DockStyle.Bottom)
                {
                    pane.DockState = DockState.DockBottom;
                }
                else if (DockOutline.Dock == DockStyle.Left)
                {
                    pane.DockState = DockState.DockLeft;
                }
                else if (DockOutline.Dock == DockStyle.Right)
                {
                    pane.DockState = DockState.DockRight;
                }
                else if (DockOutline.Dock == DockStyle.Fill)
                {
                    pane.DockState = DockState.Document;
                }

                pane.Activate();
            }
        }
예제 #4
0
        private void Content_OnEndDrag(bool abort)
        {
            User32.SetCursor(DragControl.Cursor.Handle);

            if (abort)
            {
                return;
            }

            IDockableWindow content = DragControl as IDockableWindow;

            if (!DockOutline.FloatWindowBounds.IsEmpty)
            {
                DockPane pane = content.DockHandler.DockPanel.DockPaneFactory.CreateDockPane(content, DockOutline.FloatWindowBounds, true);
                pane.Activate();
            }
            else if (DockOutline.DockTo is DockPane)
            {
                DockPane paneTo = DockOutline.DockTo as DockPane;

                if (DockOutline.Dock == DockStyle.Fill)
                {
                    bool samePane = (content.DockHandler.Pane == paneTo);
                    if (!samePane)
                    {
                        content.DockHandler.Pane = paneTo;
                    }

                    if (DockOutline.ContentIndex == -1 || !samePane)
                    {
                        paneTo.SetContentIndex(content, DockOutline.ContentIndex);
                    }
                    else
                    {
                        DockContentCollection contents = paneTo.Contents;
                        int oldIndex = contents.IndexOf(content);
                        int newIndex = DockOutline.ContentIndex;
                        if (oldIndex < newIndex)
                        {
                            newIndex += 1;
                            if (newIndex > contents.Count - 1)
                            {
                                newIndex = -1;
                            }
                        }
                        paneTo.SetContentIndex(content, newIndex);
                    }

                    content.DockHandler.Activate();
                }
                else
                {
                    DockPane           pane      = content.DockHandler.DockPanel.DockPaneFactory.CreateDockPane(content, paneTo.DockState, true);
                    IDockListContainer container = paneTo.DockListContainer;
                    if (DockOutline.Dock == DockStyle.Left)
                    {
                        pane.AddToDockList(container, paneTo, DockAlignment.Left, 0.5);
                    }
                    else if (DockOutline.Dock == DockStyle.Right)
                    {
                        pane.AddToDockList(container, paneTo, DockAlignment.Right, 0.5);
                    }
                    else if (DockOutline.Dock == DockStyle.Top)
                    {
                        pane.AddToDockList(container, paneTo, DockAlignment.Top, 0.5);
                    }
                    else if (DockOutline.Dock == DockStyle.Bottom)
                    {
                        pane.AddToDockList(container, paneTo, DockAlignment.Bottom, 0.5);
                    }

                    pane.DockState = paneTo.DockState;
                    pane.Activate();
                }
            }
            else if (DockOutline.DockTo is DockContainer)
            {
                DockPane      pane;
                DockContainer dockPanel = content.DockHandler.DockPanel;

                SetDockWindow();
                if (DockOutline.Dock == DockStyle.Top)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockTop, true);
                }
                else if (DockOutline.Dock == DockStyle.Bottom)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockBottom, true);
                }
                else if (DockOutline.Dock == DockStyle.Left)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockLeft, true);
                }
                else if (DockOutline.Dock == DockStyle.Right)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockRight, true);
                }
                else if (DockOutline.Dock == DockStyle.Fill)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.Document, true);
                }
                else
                {
                    return;
                }

                pane.Activate();
            }
        }