Beispiel #1
0
        protected override void Drop(LayoutAnchorableFloatingWindow floatingWindow)
        {
            ILayoutAnchorablePane model            = this._targetPane.Model as ILayoutAnchorablePane;
            LayoutAnchorable      layoutAnchorable = floatingWindow.Descendents().OfType <LayoutAnchorable>().FirstOrDefault <LayoutAnchorable>();

            switch (base.Type)
            {
            case DropTargetType.AnchorablePaneDockLeft:
            {
                ILayoutGroup           parent = model.Parent as ILayoutGroup;
                ILayoutOrientableGroup layoutOrientableGroup = model.Parent as ILayoutOrientableGroup;
                int num = parent.IndexOfChild(model);
                if (layoutOrientableGroup.Orientation != Orientation.Horizontal && parent.ChildrenCount == 1)
                {
                    layoutOrientableGroup.Orientation = Orientation.Horizontal;
                }
                if (layoutOrientableGroup.Orientation != Orientation.Horizontal)
                {
                    ILayoutPositionableElement layoutPositionableElement = model as ILayoutPositionableElement;
                    LayoutAnchorablePaneGroup  layoutAnchorablePaneGroup = new LayoutAnchorablePaneGroup()
                    {
                        Orientation = Orientation.Horizontal,
                        DockWidth   = layoutPositionableElement.DockWidth,
                        DockHeight  = layoutPositionableElement.DockHeight
                    };
                    parent.InsertChildAt(num, layoutAnchorablePaneGroup);
                    layoutAnchorablePaneGroup.Children.Add(model);
                    layoutAnchorablePaneGroup.Children.Insert(0, floatingWindow.RootPanel);
                    break;
                }
                else
                {
                    LayoutAnchorablePaneGroup rootPanel = floatingWindow.RootPanel;
                    if (rootPanel == null || rootPanel.Children.Count != 1 && rootPanel.Orientation != Orientation.Horizontal)
                    {
                        parent.InsertChildAt(num, floatingWindow.RootPanel);
                        break;
                    }
                    else
                    {
                        ILayoutAnchorablePane[] array = rootPanel.Children.ToArray <ILayoutAnchorablePane>();
                        for (int i = 0; i < (int)array.Length; i++)
                        {
                            parent.InsertChildAt(num + i, array[i]);
                        }
                        break;
                    }
                }
            }

            case DropTargetType.AnchorablePaneDockTop:
            {
                ILayoutGroup           layoutGroup = model.Parent as ILayoutGroup;
                ILayoutOrientableGroup parent1     = model.Parent as ILayoutOrientableGroup;
                int num1 = layoutGroup.IndexOfChild(model);
                if (parent1.Orientation != Orientation.Vertical && layoutGroup.ChildrenCount == 1)
                {
                    parent1.Orientation = Orientation.Vertical;
                }
                if (parent1.Orientation != Orientation.Vertical)
                {
                    ILayoutPositionableElement layoutPositionableElement1 = model as ILayoutPositionableElement;
                    LayoutAnchorablePaneGroup  layoutAnchorablePaneGroup1 = new LayoutAnchorablePaneGroup()
                    {
                        Orientation = Orientation.Vertical,
                        DockWidth   = layoutPositionableElement1.DockWidth,
                        DockHeight  = layoutPositionableElement1.DockHeight
                    };
                    layoutGroup.InsertChildAt(num1, layoutAnchorablePaneGroup1);
                    layoutAnchorablePaneGroup1.Children.Add(model);
                    layoutAnchorablePaneGroup1.Children.Insert(0, floatingWindow.RootPanel);
                    break;
                }
                else
                {
                    LayoutAnchorablePaneGroup rootPanel1 = floatingWindow.RootPanel;
                    if (rootPanel1 == null || rootPanel1.Children.Count != 1 && rootPanel1.Orientation != Orientation.Vertical)
                    {
                        layoutGroup.InsertChildAt(num1, floatingWindow.RootPanel);
                        break;
                    }
                    else
                    {
                        ILayoutAnchorablePane[] layoutAnchorablePaneArray = rootPanel1.Children.ToArray <ILayoutAnchorablePane>();
                        for (int j = 0; j < (int)layoutAnchorablePaneArray.Length; j++)
                        {
                            layoutGroup.InsertChildAt(num1 + j, layoutAnchorablePaneArray[j]);
                        }
                        break;
                    }
                }
            }

            case DropTargetType.AnchorablePaneDockRight:
            {
                ILayoutGroup           layoutGroup1           = model.Parent as ILayoutGroup;
                ILayoutOrientableGroup layoutOrientableGroup1 = model.Parent as ILayoutOrientableGroup;
                int num2 = layoutGroup1.IndexOfChild(model);
                if (layoutOrientableGroup1.Orientation != Orientation.Horizontal && layoutGroup1.ChildrenCount == 1)
                {
                    layoutOrientableGroup1.Orientation = Orientation.Horizontal;
                }
                if (layoutOrientableGroup1.Orientation != Orientation.Horizontal)
                {
                    ILayoutPositionableElement layoutPositionableElement2 = model as ILayoutPositionableElement;
                    LayoutAnchorablePaneGroup  layoutAnchorablePaneGroup2 = new LayoutAnchorablePaneGroup()
                    {
                        Orientation = Orientation.Horizontal,
                        DockWidth   = layoutPositionableElement2.DockWidth,
                        DockHeight  = layoutPositionableElement2.DockHeight
                    };
                    layoutGroup1.InsertChildAt(num2, layoutAnchorablePaneGroup2);
                    layoutAnchorablePaneGroup2.Children.Add(model);
                    layoutAnchorablePaneGroup2.Children.Add(floatingWindow.RootPanel);
                    break;
                }
                else
                {
                    LayoutAnchorablePaneGroup rootPanel2 = floatingWindow.RootPanel;
                    if (rootPanel2 == null || rootPanel2.Children.Count != 1 && rootPanel2.Orientation != Orientation.Horizontal)
                    {
                        layoutGroup1.InsertChildAt(num2 + 1, floatingWindow.RootPanel);
                        break;
                    }
                    else
                    {
                        ILayoutAnchorablePane[] array1 = rootPanel2.Children.ToArray <ILayoutAnchorablePane>();
                        for (int k = 0; k < (int)array1.Length; k++)
                        {
                            layoutGroup1.InsertChildAt(num2 + 1 + k, array1[k]);
                        }
                        break;
                    }
                }
            }

            case DropTargetType.AnchorablePaneDockBottom:
            {
                ILayoutGroup           parent2 = model.Parent as ILayoutGroup;
                ILayoutOrientableGroup layoutOrientableGroup2 = model.Parent as ILayoutOrientableGroup;
                int num3 = parent2.IndexOfChild(model);
                if (layoutOrientableGroup2.Orientation != Orientation.Vertical && parent2.ChildrenCount == 1)
                {
                    layoutOrientableGroup2.Orientation = Orientation.Vertical;
                }
                if (layoutOrientableGroup2.Orientation != Orientation.Vertical)
                {
                    ILayoutPositionableElement layoutPositionableElement3 = model as ILayoutPositionableElement;
                    LayoutAnchorablePaneGroup  layoutAnchorablePaneGroup3 = new LayoutAnchorablePaneGroup()
                    {
                        Orientation = Orientation.Vertical,
                        DockWidth   = layoutPositionableElement3.DockWidth,
                        DockHeight  = layoutPositionableElement3.DockHeight
                    };
                    parent2.InsertChildAt(num3, layoutAnchorablePaneGroup3);
                    layoutAnchorablePaneGroup3.Children.Add(model);
                    layoutAnchorablePaneGroup3.Children.Add(floatingWindow.RootPanel);
                    break;
                }
                else
                {
                    LayoutAnchorablePaneGroup rootPanel3 = floatingWindow.RootPanel;
                    if (rootPanel3 == null || rootPanel3.Children.Count != 1 && rootPanel3.Orientation != Orientation.Vertical)
                    {
                        parent2.InsertChildAt(num3 + 1, floatingWindow.RootPanel);
                        break;
                    }
                    else
                    {
                        ILayoutAnchorablePane[] layoutAnchorablePaneArray1 = rootPanel3.Children.ToArray <ILayoutAnchorablePane>();
                        for (int l = 0; l < (int)layoutAnchorablePaneArray1.Length; l++)
                        {
                            parent2.InsertChildAt(num3 + 1 + l, layoutAnchorablePaneArray1[l]);
                        }
                        break;
                    }
                }
            }

            case DropTargetType.AnchorablePaneDockInside:
            {
                LayoutAnchorablePane      layoutAnchorablePane = model as LayoutAnchorablePane;
                LayoutAnchorablePaneGroup rootPanel4           = floatingWindow.RootPanel;
                int num4 = (this._tabIndex == -1 ? 0 : this._tabIndex);
                LayoutAnchorable[] layoutAnchorableArray = rootPanel4.Descendents().OfType <LayoutAnchorable>().ToArray <LayoutAnchorable>();
                for (int m = 0; m < (int)layoutAnchorableArray.Length; m++)
                {
                    LayoutAnchorable layoutAnchorable1 = layoutAnchorableArray[m];
                    layoutAnchorablePane.Children.Insert(num4, layoutAnchorable1);
                    num4++;
                }
                break;
            }
            }
            layoutAnchorable.IsActive = true;
            base.Drop(floatingWindow);
        }
Beispiel #2
0
        protected override void Drop(LayoutAnchorableFloatingWindow floatingWindow)
        {
            LayoutAnchorable[] array;
            int i;
            ILayoutDocumentPane model = this._targetPane.Model as ILayoutDocumentPane;

            switch (base.Type)
            {
            case DropTargetType.DocumentPaneDockLeft:
            {
                LayoutDocumentPaneGroup parent             = model.Parent as LayoutDocumentPaneGroup;
                LayoutDocumentPane      layoutDocumentPane = new LayoutDocumentPane();
                if (parent == null)
                {
                    ILayoutContainer        layoutContainer         = model.Parent;
                    LayoutDocumentPaneGroup layoutDocumentPaneGroup = new LayoutDocumentPaneGroup()
                    {
                        Orientation = Orientation.Horizontal
                    };
                    layoutContainer.ReplaceChild(model, layoutDocumentPaneGroup);
                    layoutDocumentPaneGroup.Children.Add(layoutDocumentPane);
                    layoutDocumentPaneGroup.Children.Add(model as LayoutDocumentPane);
                }
                else if (!parent.Root.Manager.AllowMixedOrientation || parent.Orientation == Orientation.Horizontal)
                {
                    parent.Orientation = Orientation.Horizontal;
                    int num = parent.IndexOfChild(model);
                    parent.Children.Insert(num, layoutDocumentPane);
                }
                else
                {
                    LayoutDocumentPaneGroup layoutDocumentPaneGroup1 = new LayoutDocumentPaneGroup()
                    {
                        Orientation = Orientation.Horizontal
                    };
                    parent.ReplaceChild(model, layoutDocumentPaneGroup1);
                    layoutDocumentPaneGroup1.Children.Add(layoutDocumentPane);
                    layoutDocumentPaneGroup1.Children.Add(model);
                }
                array = floatingWindow.RootPanel.Descendents().OfType <LayoutAnchorable>().ToArray <LayoutAnchorable>();
                for (i = 0; i < (int)array.Length; i++)
                {
                    LayoutAnchorable layoutAnchorable = array[i];
                    layoutDocumentPane.Children.Add(layoutAnchorable);
                }
                break;
            }

            case DropTargetType.DocumentPaneDockTop:
            {
                LayoutDocumentPaneGroup parent1             = model.Parent as LayoutDocumentPaneGroup;
                LayoutDocumentPane      layoutDocumentPane1 = new LayoutDocumentPane();
                if (parent1 == null)
                {
                    ILayoutContainer        layoutContainer1         = model.Parent;
                    LayoutDocumentPaneGroup layoutDocumentPaneGroup2 = new LayoutDocumentPaneGroup()
                    {
                        Orientation = Orientation.Vertical
                    };
                    layoutContainer1.ReplaceChild(model, layoutDocumentPaneGroup2);
                    layoutDocumentPaneGroup2.Children.Add(layoutDocumentPane1);
                    layoutDocumentPaneGroup2.Children.Add(model as LayoutDocumentPane);
                }
                else if (!parent1.Root.Manager.AllowMixedOrientation || parent1.Orientation == Orientation.Vertical)
                {
                    parent1.Orientation = Orientation.Vertical;
                    int num1 = parent1.IndexOfChild(model);
                    parent1.Children.Insert(num1, layoutDocumentPane1);
                }
                else
                {
                    LayoutDocumentPaneGroup layoutDocumentPaneGroup3 = new LayoutDocumentPaneGroup()
                    {
                        Orientation = Orientation.Vertical
                    };
                    parent1.ReplaceChild(model, layoutDocumentPaneGroup3);
                    layoutDocumentPaneGroup3.Children.Add(layoutDocumentPane1);
                    layoutDocumentPaneGroup3.Children.Add(model);
                }
                array = floatingWindow.RootPanel.Descendents().OfType <LayoutAnchorable>().ToArray <LayoutAnchorable>();
                for (i = 0; i < (int)array.Length; i++)
                {
                    LayoutAnchorable layoutAnchorable1 = array[i];
                    layoutDocumentPane1.Children.Add(layoutAnchorable1);
                }
                break;
            }

            case DropTargetType.DocumentPaneDockRight:
            {
                LayoutDocumentPaneGroup parent2             = model.Parent as LayoutDocumentPaneGroup;
                LayoutDocumentPane      layoutDocumentPane2 = new LayoutDocumentPane();
                if (parent2 == null)
                {
                    ILayoutContainer        layoutContainer2         = model.Parent;
                    LayoutDocumentPaneGroup layoutDocumentPaneGroup4 = new LayoutDocumentPaneGroup()
                    {
                        Orientation = Orientation.Horizontal
                    };
                    layoutContainer2.ReplaceChild(model, layoutDocumentPaneGroup4);
                    layoutDocumentPaneGroup4.Children.Add(model as LayoutDocumentPane);
                    layoutDocumentPaneGroup4.Children.Add(layoutDocumentPane2);
                }
                else if (!parent2.Root.Manager.AllowMixedOrientation || parent2.Orientation == Orientation.Horizontal)
                {
                    parent2.Orientation = Orientation.Horizontal;
                    int num2 = parent2.IndexOfChild(model);
                    parent2.Children.Insert(num2 + 1, layoutDocumentPane2);
                }
                else
                {
                    LayoutDocumentPaneGroup layoutDocumentPaneGroup5 = new LayoutDocumentPaneGroup()
                    {
                        Orientation = Orientation.Horizontal
                    };
                    parent2.ReplaceChild(model, layoutDocumentPaneGroup5);
                    layoutDocumentPaneGroup5.Children.Add(model);
                    layoutDocumentPaneGroup5.Children.Add(layoutDocumentPane2);
                }
                array = floatingWindow.RootPanel.Descendents().OfType <LayoutAnchorable>().ToArray <LayoutAnchorable>();
                for (i = 0; i < (int)array.Length; i++)
                {
                    LayoutAnchorable layoutAnchorable2 = array[i];
                    layoutDocumentPane2.Children.Add(layoutAnchorable2);
                }
                break;
            }

            case DropTargetType.DocumentPaneDockBottom:
            {
                LayoutDocumentPaneGroup parent3             = model.Parent as LayoutDocumentPaneGroup;
                LayoutDocumentPane      layoutDocumentPane3 = new LayoutDocumentPane();
                if (parent3 == null)
                {
                    ILayoutContainer        layoutContainer3         = model.Parent;
                    LayoutDocumentPaneGroup layoutDocumentPaneGroup6 = new LayoutDocumentPaneGroup()
                    {
                        Orientation = Orientation.Vertical
                    };
                    layoutContainer3.ReplaceChild(model, layoutDocumentPaneGroup6);
                    layoutDocumentPaneGroup6.Children.Add(model as LayoutDocumentPane);
                    layoutDocumentPaneGroup6.Children.Add(layoutDocumentPane3);
                }
                else if (!parent3.Root.Manager.AllowMixedOrientation || parent3.Orientation == Orientation.Vertical)
                {
                    parent3.Orientation = Orientation.Vertical;
                    int num3 = parent3.IndexOfChild(model);
                    parent3.Children.Insert(num3 + 1, layoutDocumentPane3);
                }
                else
                {
                    LayoutDocumentPaneGroup layoutDocumentPaneGroup7 = new LayoutDocumentPaneGroup()
                    {
                        Orientation = Orientation.Vertical
                    };
                    parent3.ReplaceChild(model, layoutDocumentPaneGroup7);
                    layoutDocumentPaneGroup7.Children.Add(model);
                    layoutDocumentPaneGroup7.Children.Add(layoutDocumentPane3);
                }
                array = floatingWindow.RootPanel.Descendents().OfType <LayoutAnchorable>().ToArray <LayoutAnchorable>();
                for (i = 0; i < (int)array.Length; i++)
                {
                    LayoutAnchorable layoutAnchorable3 = array[i];
                    layoutDocumentPane3.Children.Add(layoutAnchorable3);
                }
                break;
            }

            case DropTargetType.DocumentPaneDockInside:
            {
                LayoutDocumentPane        layoutDocumentPane4 = model as LayoutDocumentPane;
                LayoutAnchorablePaneGroup rootPanel           = floatingWindow.RootPanel;
                bool flag = true;
                int  previousContainerIndex = 0;
                if (this._tabIndex != -1)
                {
                    previousContainerIndex = this._tabIndex;
                    flag = false;
                }
                LayoutAnchorable layoutAnchorable4 = null;
                array = rootPanel.Descendents().OfType <LayoutAnchorable>().ToArray <LayoutAnchorable>();
                for (i = 0; i < (int)array.Length; i++)
                {
                    LayoutAnchorable layoutAnchorable5 = array[i];
                    if (flag)
                    {
                        if (((ILayoutPreviousContainer)layoutAnchorable5).PreviousContainer == model && layoutAnchorable5.PreviousContainerIndex != -1)
                        {
                            previousContainerIndex = layoutAnchorable5.PreviousContainerIndex;
                        }
                        flag = false;
                    }
                    layoutDocumentPane4.Children.Insert(previousContainerIndex, layoutAnchorable5);
                    previousContainerIndex++;
                    layoutAnchorable4 = layoutAnchorable5;
                }
                layoutAnchorable4.IsActive = true;
                break;
            }
            }
            base.Drop(floatingWindow);
        }