/// <exclude />
        protected override void WndProc(ref Message m)
        {
            if (m.Msg == (int)Win32.Msgs.WM_MOUSEACTIVATE)
            {
                DockPane.Activate();
                base.WndProc(ref m);
                return;
            }
            else if (m.Msg == (int)Win32.Msgs.WM_LBUTTONDOWN)
            {
                if (DockPane.DockPanel.AllowRedocking && DockPane.AllowRedocking &&
                    !DockHelper.IsDockStateAutoHide(DockPane.DockState))
                {
                    DockPane.DockPanel.DragHandler.BeginDragPane(DockPane, ClientRectangle.Location);
                }
                else
                {
                    base.WndProc(ref m);
                }
                return;
            }
            else if (m.Msg == (int)Win32.Msgs.WM_LBUTTONDBLCLK)
            {
                base.WndProc(ref m);

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

                DockContent activeContent = DockPane.DockPanel.ActiveContent;
                for (int i = 0; i < DockPane.Tabs.Count; i++)
                {
                    DockContent content = DockPane.Tabs[i].Content;
                    if (DockPane.IsFloat)
                    {
                        DockPane.RestoreToPanel();
                    }
                    else
                    {
                        DockPane.Float();
                    }
                    if (activeContent != null)
                    {
                        activeContent.Activate();
                    }
                }
                return;
            }

            base.WndProc(ref m);
        }
Ejemplo n.º 2
0
        /// <exclude/>
        protected override void WndProc(ref Message m)
        {
            if (m.Msg == (int)Win32.Msgs.WM_NCLBUTTONDOWN)
            {
                if (IsDisposed)
                {
                    return;
                }

                uint result = User32.SendMessage(this.Handle, (int)Win32.Msgs.WM_NCHITTEST, 0, (uint)m.LParam);
                if (result == 2 && DockPanel.AllowRedocking && this.AllowRedocking)                     // HITTEST_CAPTION
                {
                    Activate();
                    m_dockPanel.DragHandler.BeginDragFloatWindow(this);
                }
                else
                {
                    base.WndProc(ref m);
                }

                return;
            }
            else if (m.Msg == (int)Win32.Msgs.WM_CLOSE)
            {
                if (DockList.Count == 0)
                {
                    base.WndProc(ref m);
                    return;
                }

                for (int i = DockList.Count - 1; i >= 0; i--)
                {
                    DockContentCollection contents = DockList[i].Contents;
                    for (int j = contents.Count - 1; j >= 0; j--)
                    {
                        DockContent content = contents[j];
                        if (content.DockState != DockState.Float)
                        {
                            continue;
                        }

                        if (!content.CloseButton)
                        {
                            continue;
                        }

                        if (content.HideOnClose)
                        {
                            content.Hide();
                        }
                        else
                        {
                            content.Close();
                        }
                    }
                }

                return;
            }
            else if (m.Msg == (int)Win32.Msgs.WM_NCLBUTTONDBLCLK)
            {
                uint result = User32.SendMessage(this.Handle, (int)Win32.Msgs.WM_NCHITTEST, 0, (uint)m.LParam);
                if (result != 2)                        // HITTEST_CAPTION
                {
                    base.WndProc(ref m);
                    return;
                }

                // Restore to panel
                DockContent activeContent = DockPanel.ActiveContent;
                foreach (DockPane pane in DockList)
                {
                    if (pane.DockState != DockState.Float)
                    {
                        continue;
                    }
                    pane.RestoreToPanel();
                }
                if (activeContent != null)
                {
                    activeContent.Activate();
                }

                return;
            }
            else if (m.Msg == WM_CHECKDISPOSE)
            {
                if (DockList.Count == 0)
                {
                    Dispose();
                }

                return;
            }

            base.WndProc(ref m);
        }
Ejemplo n.º 3
0
        private void Content_OnEndDrag(bool abort)
        {
            User32.SetCursor(DragControl.Cursor.Handle);

            if (abort)
            {
                return;
            }

            DockContent content = ((DockPane)DragControl).ActiveContent;

            if (DropTarget.DropTo is DockPane)
            {
                DockPane paneTo = DropTarget.DropTo as DockPane;

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

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

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

                    pane.DockState = paneTo.DockState;
                    pane.Activate();
                }
            }
            else if (DropTarget.DropTo is DockPanel)
            {
                DockPane  pane;
                DockPanel dockPanel = content.DockPanel;
                if (DropTarget.Dock == DockStyle.Top)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockTop, true);
                }
                else if (DropTarget.Dock == DockStyle.Bottom)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockBottom, true);
                }
                else if (DropTarget.Dock == DockStyle.Left)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockLeft, true);
                }
                else if (DropTarget.Dock == DockStyle.Right)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockRight, true);
                }
                else if (DropTarget.Dock == DockStyle.Fill)
                {
                    pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.Document, true);
                }
                else
                {
                    return;
                }

                pane.Activate();
            }
            else if (IsDockStateValid(DockState.Float))
            {
                Point ptMouse = Control.MousePosition;

                Size  size = FloatWindow.DefaultWindowSize;
                Point location;
                if (content.DockState == DockState.Document)
                {
                    location = new Point(ptMouse.X + m_mouseOffset.X, ptMouse.Y + m_mouseOffset.Y);
                }
                else
                {
                    location = new Point(ptMouse.X + m_mouseOffset.X, ptMouse.Y + m_mouseOffset.Y - size.Height);
                }

                if (ptMouse.X > location.X + size.Width)
                {
                    location.X += ptMouse.X - (location.X + size.Width) + OutlineBorderWidth;
                }

                DockPane pane = content.DockPanel.DockPaneFactory.CreateDockPane(content, new Rectangle(location, size), true);
                pane.Activate();
            }
        }
Ejemplo n.º 4
0
        private void Pane_OnEndDrag(bool abort)
        {
            User32.SetCursor(DragControl.Cursor.Handle);

            if (abort)
            {
                return;
            }

            DockPane pane = (DockPane)DragControl;

            if (DropTarget.DropTo is DockPane)
            {
                DockPane paneTo = DropTarget.DropTo as DockPane;

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

                    pane.DockState = paneTo.DockState;
                    pane.Activate();
                }
            }
            else if (DropTarget.DropTo is DockPanel)
            {
                if (DropTarget.Dock == DockStyle.Top)
                {
                    pane.DockState = DockState.DockTop;
                }
                else if (DropTarget.Dock == DockStyle.Bottom)
                {
                    pane.DockState = DockState.DockBottom;
                }
                else if (DropTarget.Dock == DockStyle.Left)
                {
                    pane.DockState = DockState.DockLeft;
                }
                else if (DropTarget.Dock == DockStyle.Right)
                {
                    pane.DockState = DockState.DockRight;
                }
                else if (DropTarget.Dock == DockStyle.Fill)
                {
                    pane.DockState = DockState.Document;
                }

                pane.Activate();
            }
            else if (IsDockStateValid(DockState.Float))
            {
                Point ptMouse = Control.MousePosition;

                Point location = new Point(ptMouse.X + m_mouseOffset.X, ptMouse.Y + m_mouseOffset.Y);
                Size  size;
                bool  createFloatWindow = true;
                if (pane.FloatWindow == null)
                {
                    size = FloatWindow.DefaultWindowSize;
                }
                else if (pane.FloatWindow.DockList.Count == 1)
                {
                    size = pane.FloatWindow.Size;
                    createFloatWindow = false;
                }
                else
                {
                    size = FloatWindow.DefaultWindowSize;
                }

                if (ptMouse.X > location.X + size.Width)
                {
                    location.X += ptMouse.X - (location.X + size.Width) + OutlineBorderWidth;
                }

                if (createFloatWindow)
                {
                    pane.FloatWindow = pane.DockPanel.FloatWindowFactory.CreateFloatWindow(pane.DockPanel, pane, new Rectangle(location, size));
                }
                else
                {
                    pane.FloatWindow.Bounds = new Rectangle(location, size);
                }

                pane.DockState = DockState.Float;
                pane.Activate();
            }
        }
Ejemplo n.º 5
0
        private void FloatWindow_OnEndDrag(bool abort)
        {
            if (abort)
            {
                return;
            }

            FloatWindow floatWindow = (FloatWindow)DragControl;

            if (DropTarget.DropTo == null)
            {
                Rectangle rect = DragControl.Bounds;
                rect.X             = Control.MousePosition.X + m_mouseOffset.X;
                rect.Y             = Control.MousePosition.Y + m_mouseOffset.Y;
                DragControl.Bounds = rect;
            }
            else if (DropTarget.DropTo is DockPane)
            {
                DockPane paneTo = DropTarget.DropTo as DockPane;

                if (DropTarget.Dock == DockStyle.Fill)
                {
                    for (int i = floatWindow.DockList.Count - 1; i >= 0; i--)
                    {
                        DockPane pane = floatWindow.DockList[i];
                        for (int j = pane.Contents.Count - 1; j >= 0; j--)
                        {
                            DockContent c = pane.Contents[j];
                            c.Pane = paneTo;
                            if (DropTarget.ContentIndex != -1)
                            {
                                paneTo.SetContentIndex(c, DropTarget.ContentIndex);
                            }
                            c.Activate();
                        }
                    }
                }
                else
                {
                    DockAlignment alignment = DockAlignment.Left;
                    if (DropTarget.Dock == DockStyle.Left)
                    {
                        alignment = DockAlignment.Left;
                    }
                    else if (DropTarget.Dock == DockStyle.Right)
                    {
                        alignment = DockAlignment.Right;
                    }
                    else if (DropTarget.Dock == DockStyle.Top)
                    {
                        alignment = DockAlignment.Top;
                    }
                    else if (DropTarget.Dock == DockStyle.Bottom)
                    {
                        alignment = DockAlignment.Bottom;
                    }

                    MergeDockList(floatWindow.DisplayingList, paneTo.DockListContainer.DockList, paneTo, alignment, 0.5);
                }
            }
            else if (DropTarget.DropTo is DockPanel)
            {
                DockList dockListTo = null;

                if (DropTarget.Dock == DockStyle.Top)
                {
                    dockListTo = floatWindow.DockPanel.DockWindows[DockState.DockTop].DockList;
                }
                else if (DropTarget.Dock == DockStyle.Bottom)
                {
                    dockListTo = floatWindow.DockPanel.DockWindows[DockState.DockBottom].DockList;
                }
                else if (DropTarget.Dock == DockStyle.Left)
                {
                    dockListTo = floatWindow.DockPanel.DockWindows[DockState.DockLeft].DockList;
                }
                else if (DropTarget.Dock == DockStyle.Right)
                {
                    dockListTo = floatWindow.DockPanel.DockWindows[DockState.DockRight].DockList;
                }
                else if (DropTarget.Dock == DockStyle.Fill)
                {
                    dockListTo = floatWindow.DockPanel.DockWindows[DockState.Document].DockList;
                }

                DockPane prevPane = null;
                for (int i = dockListTo.Count - 1; i >= 0; i--)
                {
                    if (dockListTo[i] != floatWindow.DisplayingList[0])
                    {
                        prevPane = dockListTo[i];
                    }
                }
                MergeDockList(floatWindow.DisplayingList, dockListTo, prevPane, DockAlignment.Left, 0.5);
            }
        }