Example #1
0
        /// <summary>Get bounding rectangle for docked view.</summary>
        /// <param name="viewHost">Tested <see cref="ViewHost"/>.</param>
        /// <param name="dockResult">Position for docking.</param>
        /// <returns>Bounding rectangle for docked view.</returns>
        public Rectangle GetDockBounds(ViewHost viewHost, DockResult dockResult)
        {
            Verify.Argument.IsNotNull(viewHost, nameof(viewHost));

            var       rootBounds = RootControl.Bounds;
            Rectangle bounds;

            switch (dockResult)
            {
            case DockResult.Left:
            {
                var w1 = viewHost.Width;
                var w2 = rootBounds.Width;
                ViewSplit.OptimalSizes(w2, ViewConstants.MinimumHostWidth, ref w1, ref w2);
                bounds = new Rectangle(0, 0, w1, rootBounds.Height);
            }
            break;

            case DockResult.Top:
            {
                var h1 = viewHost.Height;
                var h2 = rootBounds.Height;
                ViewSplit.OptimalSizes(h2, ViewConstants.MinimumHostHeight, ref h1, ref h2);
                bounds = new Rectangle(0, 0, rootBounds.Width, h1);
            }
            break;

            case DockResult.Right:
            {
                var w1 = rootBounds.Width;
                var w2 = viewHost.Width;
                ViewSplit.OptimalSizes(w1, ViewConstants.MinimumHostWidth, ref w1, ref w2);
                bounds = new Rectangle(rootBounds.Width - w2, 0, w2, rootBounds.Height);
            }
            break;

            case DockResult.Bottom:
            {
                var h1 = rootBounds.Height;
                var h2 = viewHost.Height;
                ViewSplit.OptimalSizes(h1, ViewConstants.MinimumHostHeight, ref h1, ref h2);
                bounds = new Rectangle(0, rootBounds.Height - h2, rootBounds.Width, h2);
            }
            break;

            default:
                throw new ArgumentException(
                          "Unsuported DockResult value: {0}".UseAsFormat(dockResult),
                          "dockResult");
            }
            bounds.Offset(rootBounds.X, rootBounds.Y);
            return(RectangleToScreen(bounds));
        }
Example #2
0
        /// <summary>Docks <paramref name="viewHost"/> into this <see cref="IDockHost"/>.</summary>
        /// <param name="viewHost"><see cref="ViewHost"/> to dock.</param>
        /// <param name="dockResult">Position for docking.</param>
        public void PerformDock(ViewHost viewHost, DockResult dockResult)
        {
            Verify.Argument.IsNotNull(viewHost, nameof(viewHost));
            Verify.Argument.IsFalse(viewHost.IsDocumentWell, "viewHost");
            Verify.Argument.IsFalse(viewHost.ViewsCount == 1 && viewHost.GetView(0).IsDocument, "viewHost");

            switch (dockResult)
            {
            case DockResult.Left:
                DockSide(AnchorStyles.Left, viewHost, false);
                viewHost.Status = ViewHostStatus.Docked;
                break;

            case DockResult.Top:
                DockSide(AnchorStyles.Top, viewHost, false);
                viewHost.Status = ViewHostStatus.Docked;
                break;

            case DockResult.Right:
                DockSide(AnchorStyles.Right, viewHost, false);
                viewHost.Status = ViewHostStatus.Docked;
                break;

            case DockResult.Bottom:
                DockSide(AnchorStyles.Bottom, viewHost, false);
                viewHost.Status = ViewHostStatus.Docked;
                break;

            case DockResult.AutoHideLeft:
                GetCreateDockSide(AnchorStyles.Left).AddHost(viewHost);
                break;

            case DockResult.AutoHideTop:
                GetCreateDockSide(AnchorStyles.Top).AddHost(viewHost);
                break;

            case DockResult.AutoHideRight:
                GetCreateDockSide(AnchorStyles.Right).AddHost(viewHost);
                break;

            case DockResult.AutoHideBottom:
                GetCreateDockSide(AnchorStyles.Bottom).AddHost(viewHost);
                break;

            default:
                throw new ArgumentException(
                          "Unsupported DockResult value: {0}".UseAsFormat(dockResult),
                          "dockResult");
            }
        }
Example #3
0
        /// <summary>Determines if <see cref="ViewHost"/> cn be docked into this <see cref="IDockHost"/>.</summary>
        /// <param name="viewHost"><see cref="ViewHost"/> to dock.</param>
        /// <param name="dockResult">Position for docking.</param>
        /// <returns>true if docking is possible.</returns>
        public bool CanDock(ViewHost viewHost, DockResult dockResult)
        {
            Verify.Argument.IsNotNull(viewHost, nameof(viewHost));

            if (viewHost.IsDocumentWell || (viewHost.ViewsCount == 1 && viewHost.GetView(0).IsDocument))
            {
                return(false);
            }
            switch (dockResult)
            {
            case DockResult.Left:
            case DockResult.Top:
            case DockResult.Right:
            case DockResult.Bottom:
                return(true);

            default:
                return(false);
            }
        }
Example #4
0
 /// <summary>Initializes a new instance of the <see cref="DockMarkerButton"/> class.</summary>
 /// <param name="bounds">Button bounds.</param>
 /// <param name="type">Button type.</param>
 internal DockMarkerButton(Rectangle bounds, DockResult type)
 {
     _bounds = bounds;
     _type = type;
 }
Example #5
0
 /// <summary>Initializes a new instance of the <see cref="DockMarkerButton"/> class.</summary>
 /// <param name="bounds">Button bounds.</param>
 /// <param name="type">Button type.</param>
 internal DockMarkerButton(Rectangle bounds, DockResult type)
 {
     Bounds = bounds;
     Type   = type;
 }
Example #6
0
        /// <summary>
        /// Docks <paramref name="viewHost"/> into this <see cref="IDockHost"/>.
        /// </summary>
        /// <param name="viewHost"><see cref="ViewHost"/> to dock.</param>
        /// <param name="dockResult">Position for docking.</param>
        public void PerformDock(ViewHost viewHost, DockResult dockResult)
        {
            Verify.Argument.IsNotNull(viewHost, "viewHost");

            switch(dockResult)
            {
                case DockResult.Left:
                    viewHost.DockToSide(this, AnchorStyles.Left);
                    if(_status == ViewHostStatus.DockedOnFloat || _status == ViewHostStatus.Floating)
                    {
                        viewHost.Status = ViewHostStatus.DockedOnFloat;
                    }
                    break;
                case DockResult.Top:
                    viewHost.DockToSide(this, AnchorStyles.Top);
                    if(_status == ViewHostStatus.DockedOnFloat || _status == ViewHostStatus.Floating)
                    {
                        viewHost.Status = ViewHostStatus.DockedOnFloat;
                    }
                    break;
                case DockResult.Right:
                    viewHost.DockToSide(this, AnchorStyles.Right);
                    if(_status == ViewHostStatus.DockedOnFloat || _status == ViewHostStatus.Floating)
                    {
                        viewHost.Status = ViewHostStatus.DockedOnFloat;
                    }
                    break;
                case DockResult.Bottom:
                    viewHost.DockToSide(this, AnchorStyles.Bottom);
                    if(_status == ViewHostStatus.DockedOnFloat || _status == ViewHostStatus.Floating)
                    {
                        viewHost.Status = ViewHostStatus.DockedOnFloat;
                    }
                    break;
                case DockResult.DocumentLeft:
                    viewHost.DockToSideAsDocument(this, AnchorStyles.Left);
                    break;
                case DockResult.DocumentTop:
                    viewHost.DockToSideAsDocument(this, AnchorStyles.Top);
                    break;
                case DockResult.DocumentRight:
                    viewHost.DockToSideAsDocument(this, AnchorStyles.Right);
                    break;
                case DockResult.DocumentBottom:
                    viewHost.DockToSideAsDocument(this, AnchorStyles.Bottom);
                    break;
                case DockResult.Fill:
                    viewHost.DockInto(this);
                    Activate();
                    break;
                default:
                    throw new ArgumentException(
                        "Unsupported DockResult value: {0}".UseAsFormat(dockResult),
                        "dockResult");
            }
        }
Example #7
0
        /// <summary>Get bounding rectangle for docked view.</summary>
        /// <param name="viewHost">Tested <see cref="ViewHost"/>.</param>
        /// <param name="dockResult">Position for docking.</param>
        /// <returns>Bounding rectangle for docked view.</returns>
        public Rectangle GetDockBounds(ViewHost viewHost, DockResult dockResult)
        {
            Verify.Argument.IsNotNull(viewHost, "viewHost");

            Rectangle bounds;
            var size = Size;
            switch(dockResult)
            {
                case DockResult.Left:
                case DockResult.DocumentLeft:
                    {
                        var w1 = viewHost.Width;
                        var w2 = size.Width;
                        ViewSplit.OptimalSizes(w2, ViewConstants.MinimumHostWidth, ref w1, ref w2);
                        bounds = new Rectangle(0, 0, w1, size.Height);
                    }
                    break;
                case DockResult.Top:
                case DockResult.DocumentTop:
                    {
                        var h1 = viewHost.Height;
                        var h2 = size.Height;
                        ViewSplit.OptimalSizes(h2, ViewConstants.MinimumHostHeight, ref h1, ref h2);
                        bounds = new Rectangle(0, 0, size.Width, h1);
                    }
                    break;
                case DockResult.Right:
                case DockResult.DocumentRight:
                    {
                        var w1 = size.Width;
                        var w2 = viewHost.Width;
                        ViewSplit.OptimalSizes(w1, ViewConstants.MinimumHostWidth, ref w1, ref w2);
                        bounds = new Rectangle(size.Width - w2, 0, w2, size.Height);
                    }
                    break;
                case DockResult.Bottom:
                case DockResult.DocumentBottom:
                    {
                        var h1 = size.Height;
                        var h2 = viewHost.Height;
                        ViewSplit.OptimalSizes(h1, ViewConstants.MinimumHostHeight, ref h1, ref h2);
                        bounds = new Rectangle(0, size.Height - h2, size.Width, h2);
                    }
                    break;
                case DockResult.Fill:
                    bounds = new Rectangle(0, 0, size.Width, size.Height);
                    bounds.Intersect(_viewContainer.Bounds);
                    break;
                default:
                    throw new ArgumentException(
                        "Unsupported DockResult value: {0}".UseAsFormat(dockResult),
                        "dockResult");
            }
            return RectangleToScreen(bounds);
        }
Example #8
0
        /// <summary>
        /// Determines if <see cref="ViewHost"/> cn be docked into this <see cref="IDockHost"/>.
        /// </summary>
        /// <param name="viewHost"><see cref="ViewHost"/> to dock.</param>
        /// <param name="dockResult">Position for docking.</param>
        /// <returns>true if docking is possible.</returns>
        public bool CanDock(ViewHost viewHost, DockResult dockResult)
        {
            Verify.Argument.IsNotNull(viewHost, "viewHost");

            switch(dockResult)
            {
                case DockResult.Left:
                case DockResult.Top:
                case DockResult.Right:
                case DockResult.Bottom:
                case DockResult.Fill:
                    return true;
                case DockResult.DocumentLeft:
                case DockResult.DocumentTop:
                case DockResult.DocumentRight:
                case DockResult.DocumentBottom:
                    return _isDocumentWell;
                default:
                    return false;
            }
        }
Example #9
0
        /// <summary>Docks <paramref name="viewHost"/> into this <see cref="IDockHost"/>.</summary>
        /// <param name="viewHost"><see cref="ViewHost"/> to dock.</param>
        /// <param name="dockResult">Position for docking.</param>
        public void PerformDock(ViewHost viewHost, DockResult dockResult)
        {
            Verify.Argument.IsNotNull(viewHost, "viewHost");
            Verify.Argument.IsFalse(viewHost.IsDocumentWell, "viewHost");
            Verify.Argument.IsFalse(viewHost.ViewsCount == 1 && viewHost.GetView(0).IsDocument, "viewHost");

            switch(dockResult)
            {
                case DockResult.Left:
                    DockSide(AnchorStyles.Left, viewHost, false);
                    viewHost.Status = ViewHostStatus.Docked;
                    break;
                case DockResult.Top:
                    DockSide(AnchorStyles.Top, viewHost, false);
                    viewHost.Status = ViewHostStatus.Docked;
                    break;
                case DockResult.Right:
                    DockSide(AnchorStyles.Right, viewHost, false);
                    viewHost.Status = ViewHostStatus.Docked;
                    break;
                case DockResult.Bottom:
                    DockSide(AnchorStyles.Bottom, viewHost, false);
                    viewHost.Status = ViewHostStatus.Docked;
                    break;
                case DockResult.AutoHideLeft:
                    GetCreateDockSide(AnchorStyles.Left).AddHost(viewHost);
                    break;
                case DockResult.AutoHideTop:
                    GetCreateDockSide(AnchorStyles.Top).AddHost(viewHost);
                    break;
                case DockResult.AutoHideRight:
                    GetCreateDockSide(AnchorStyles.Right).AddHost(viewHost);
                    break;
                case DockResult.AutoHideBottom:
                    GetCreateDockSide(AnchorStyles.Bottom).AddHost(viewHost);
                    break;
                default:
                    throw new ArgumentException(
                        "Unsupported DockResult value: {0}".UseAsFormat(dockResult),
                        "dockResult");
            }
        }
Example #10
0
        /// <summary>Get bounding rectangle for docked view.</summary>
        /// <param name="viewHost">Tested <see cref="ViewHost"/>.</param>
        /// <param name="dockResult">Position for docking.</param>
        /// <returns>Bounding rectangle for docked view.</returns>
        public Rectangle GetDockBounds(ViewHost viewHost, DockResult dockResult)
        {
            Verify.Argument.IsNotNull(viewHost, "viewHost");

            var rootBounds = RootControl.Bounds;
            Rectangle bounds;
            switch(dockResult)
            {
                case DockResult.Left:
                    {
                        var w1 = viewHost.Width;
                        var w2 = rootBounds.Width;
                        ViewSplit.OptimalSizes(w2, ViewConstants.MinimumHostWidth, ref w1, ref w2);
                        bounds = new Rectangle(0, 0, w1, rootBounds.Height);
                    }
                    break;
                case DockResult.Top:
                    {
                        var h1 = viewHost.Height;
                        var h2 = rootBounds.Height;
                        ViewSplit.OptimalSizes(h2, ViewConstants.MinimumHostHeight, ref h1, ref h2);
                        bounds = new Rectangle(0, 0, rootBounds.Width, h1);
                    }
                    break;
                case DockResult.Right:
                    {
                        var w1 = rootBounds.Width;
                        var w2 = viewHost.Width;
                        ViewSplit.OptimalSizes(w1, ViewConstants.MinimumHostWidth, ref w1, ref w2);
                        bounds = new Rectangle(rootBounds.Width - w2, 0, w2, rootBounds.Height);
                    }
                    break;
                case DockResult.Bottom:
                    {
                        var h1 = rootBounds.Height;
                        var h2 = viewHost.Height;
                        ViewSplit.OptimalSizes(h1, ViewConstants.MinimumHostHeight, ref h1, ref h2);
                        bounds = new Rectangle(0, rootBounds.Height - h2, rootBounds.Width, h2);
                    }
                    break;
                default:
                    throw new ArgumentException(
                        "Unsuported DockResult value: {0}".UseAsFormat(dockResult),
                        "dockResult");
            }
            bounds.Offset(rootBounds.X, rootBounds.Y);
            return RectangleToScreen(bounds);
        }
Example #11
0
        /// <summary>Determines if <see cref="ViewHost"/> cn be docked into this <see cref="IDockHost"/>.</summary>
        /// <param name="viewHost"><see cref="ViewHost"/> to dock.</param>
        /// <param name="dockResult">Position for docking.</param>
        /// <returns>true if docking is possible.</returns>
        public bool CanDock(ViewHost viewHost, DockResult dockResult)
        {
            Verify.Argument.IsNotNull(viewHost, "viewHost");

            if(viewHost.IsDocumentWell || (viewHost.ViewsCount == 1 && viewHost.GetView(0).IsDocument))
            {
                return false;
            }
            switch(dockResult)
            {
                case DockResult.Left:
                case DockResult.Top:
                case DockResult.Right:
                case DockResult.Bottom:
                    return true;
                default:
                    return false;
            }
        }