private void OnChildModelPropertyChanged(object sender, PropertyChangedEventArgs e) { if (this.AsyncRefreshCalled) { return; } if (this._fixingChildrenDockLengths.CanEnter && e.PropertyName == "DockWidth" && this.Orientation == System.Windows.Controls.Orientation.Horizontal) { if (base.ColumnDefinitions.Count == base.InternalChildren.Count) { ILayoutPositionableElement layoutPositionableElement = sender as ILayoutPositionableElement; UIElement uIElement = base.InternalChildren.OfType <ILayoutControl>().First <ILayoutControl>((ILayoutControl ch) => ch.Model == layoutPositionableElement) as UIElement; int dockWidth = base.InternalChildren.IndexOf(uIElement); base.ColumnDefinitions[dockWidth].Width = layoutPositionableElement.DockWidth; return; } } else if (this._fixingChildrenDockLengths.CanEnter && e.PropertyName == "DockHeight" && this.Orientation == System.Windows.Controls.Orientation.Vertical) { if (base.RowDefinitions.Count == base.InternalChildren.Count) { ILayoutPositionableElement layoutPositionableElement1 = sender as ILayoutPositionableElement; UIElement uIElement1 = base.InternalChildren.OfType <ILayoutControl>().First <ILayoutControl>((ILayoutControl ch) => ch.Model == layoutPositionableElement1) as UIElement; int dockHeight = base.InternalChildren.IndexOf(uIElement1); base.RowDefinitions[dockHeight].Height = layoutPositionableElement1.DockHeight; return; } } else if (e.PropertyName == "IsVisible") { this.UpdateRowColDefinitions(); } }
public override Geometry GetPreviewPath(OverlayWindow overlayWindow, LayoutFloatingWindow floatingWindowModel) { LayoutAnchorableFloatingWindow layoutAnchorableFloatingWindow = floatingWindowModel as LayoutAnchorableFloatingWindow; ILayoutPositionableElement rootPanel = layoutAnchorableFloatingWindow.RootPanel; ILayoutPositionableElementWithActualSize layoutPositionableElementWithActualSize = layoutAnchorableFloatingWindow.RootPanel; Rect screenArea = base.TargetElement.GetScreenArea(); switch (base.Type) { case DropTargetType.DockingManagerDockLeft: { double num = (rootPanel.DockWidth.IsAbsolute ? rootPanel.DockWidth.Value : layoutPositionableElementWithActualSize.ActualWidth); return(new RectangleGeometry(new Rect(screenArea.Left - overlayWindow.Left, screenArea.Top - overlayWindow.Top, Math.Min(num, screenArea.Width / 2), screenArea.Height))); } case DropTargetType.DockingManagerDockTop: { double num1 = (rootPanel.DockHeight.IsAbsolute ? rootPanel.DockHeight.Value : layoutPositionableElementWithActualSize.ActualHeight); return(new RectangleGeometry(new Rect(screenArea.Left - overlayWindow.Left, screenArea.Top - overlayWindow.Top, screenArea.Width, Math.Min(num1, screenArea.Height / 2)))); } case DropTargetType.DockingManagerDockRight: { double num2 = (rootPanel.DockWidth.IsAbsolute ? rootPanel.DockWidth.Value : layoutPositionableElementWithActualSize.ActualWidth); return(new RectangleGeometry(new Rect(screenArea.Right - overlayWindow.Left - Math.Min(num2, screenArea.Width / 2), screenArea.Top - overlayWindow.Top, Math.Min(num2, screenArea.Width / 2), screenArea.Height))); } case DropTargetType.DockingManagerDockBottom: { double num3 = (rootPanel.DockHeight.IsAbsolute ? rootPanel.DockHeight.Value : layoutPositionableElementWithActualSize.ActualHeight); return(new RectangleGeometry(new Rect(screenArea.Left - overlayWindow.Left, screenArea.Bottom - overlayWindow.Top - Math.Min(num3, screenArea.Height / 2), screenArea.Width, Math.Min(num3, screenArea.Height / 2)))); } } throw new InvalidOperationException(); }
/// <summary> /// This method controls the DropTargetInto button of the overlay window. /// It checks that only 1 of the defined ContentLayouts can be present on the LayoutDocumentPane or LayoutAnchorablePane. /// The combination between the ContentLayout Title and the ContentId is the search key, and has to be unique. /// If a floating window is dropped on a LayoutDocumentPane or LayoutAnchorablePane, it checks if one of the containing LayoutContents /// is already present on the LayoutDocumentPane or LayoutAnchorablePane. If so, then it will disable the DropTargetInto button. /// </summary> /// <param name="positionableElement">The given LayoutDocumentPane or LayoutAnchorablePane</param> private void SetDropTargetIntoVisibility(ILayoutPositionableElement positionableElement) { if (positionableElement is LayoutAnchorablePane) { _anchorablePaneDropTargetInto.Visibility = Visibility.Visible; } else if (positionableElement is LayoutDocumentPane) { _documentPaneDropTargetInto.Visibility = Visibility.Visible; } if (positionableElement == null || _floatingWindow.Model == null || positionableElement.AllowDuplicateContent) { return; } // Find all content layouts in the anchorable pane (object to drop on) var contentLayoutsOnPositionableElementPane = GetAllLayoutContents(positionableElement); // Find all content layouts in the floating window (object to drop) var contentLayoutsOnFloatingWindow = GetAllLayoutContents(_floatingWindow.Model); // If any of the content layouts is present in the drop area, then disable the DropTargetInto button. foreach (var content in contentLayoutsOnFloatingWindow) { if (!contentLayoutsOnPositionableElementPane.Any(item => item.Title == content.Title && item.ContentId == content.ContentId)) { continue; } if (positionableElement is LayoutAnchorablePane) { _anchorablePaneDropTargetInto.Visibility = Visibility.Hidden; } else if (positionableElement is LayoutDocumentPane) { _documentPaneDropTargetInto.Visibility = Visibility.Hidden; } break; } }
protected override void OnFixChildrenDockLengths() { if (this._model.Orientation == System.Windows.Controls.Orientation.Horizontal) { for (int i = 0; i < this._model.Children.Count; i++) { ILayoutPositionableElement item = this._model.Children[i] as ILayoutPositionableElement; if (!item.DockWidth.IsStar) { item.DockWidth = new GridLength(1, GridUnitType.Star); } } return; } for (int j = 0; j < this._model.Children.Count; j++) { ILayoutPositionableElement gridLength = this._model.Children[j] as ILayoutPositionableElement; if (!gridLength.DockHeight.IsStar) { gridLength.DockHeight = new GridLength(1, GridUnitType.Star); } } }
private void WriteSize(LayoutPartSize size, ILayoutPositionableElement element, LayoutItem layoutItem) { if (element != null) { var container = (ILayoutOrientableGroup)element.Parent; switch (container.Orientation) { case Orientation.Horizontal: element.DockMinWidth = size.MinWidth; element.IsDockWidthFixed = size.IsWidthFixed; element.DockWidth = new GridLength(size.Width, size.WidthType); //layoutItem.View.Width = size.WidthType == GridUnitType.Auto ? (size.Width < size.MinWidth ? size.MinWidth : size.Width) : double.NaN; break; case Orientation.Vertical: element.DockMinHeight = size.MinHeight; element.IsDockHeightFixed = size.IsHeightFixed; element.DockHeight = new GridLength(size.Height, size.HeightType); //layoutItem.View.Height = size.HeightType == GridUnitType.Auto ? (size.Height < size.MinHeight?size.MinHeight:size.Height): double.NaN; break; } } }
private void ReadSize(LayoutPartSize size, ILayoutPositionableElement element, LayoutItem layoutItem) { if (element != null) { var container = (ILayoutOrientableGroup)element.Parent; switch (container.Orientation) { case Orientation.Horizontal: size.MinWidth = element.DockMinWidth; size.IsWidthFixed = element.IsDockWidthFixed; size.WidthType = element.DockWidth.GridUnitType; //size.Width = element.DockWidth.IsAuto ? layoutItem.View.Width : element.DockWidth.Value; size.Width = element.DockWidth.Value; break; case Orientation.Vertical: size.MinHeight = element.DockMinHeight; size.IsHeightFixed = element.IsDockHeightFixed; size.HeightType = element.DockHeight.GridUnitType; //size.Height = element.DockHeight.IsAuto ? layoutItem.View.Height : element.DockHeight.Value; size.Height = element.DockHeight.Value; break; } } }
void WriteSize(LayoutPartSize size, ILayoutPositionableElement element, LayoutItem layoutItem) { if (element != null) { var container = (ILayoutOrientableGroup)element.Parent; switch (container.Orientation) { case Orientation.Horizontal: element.DockMinWidth = size.MinWidth; element.IsDockWidthFixed = size.IsWidthFixed; element.DockWidth = new GridLength(size.Width, size.WidthType); break; case Orientation.Vertical: element.DockMinHeight = size.MinHeight; element.IsDockHeightFixed = size.IsHeightFixed; element.DockHeight = new GridLength(size.Height, size.HeightType); break; } } }
private void UpdateRowColDefinitions() { ILayoutRoot root = this._model.Root; if (root == null) { return; } DockingManager manager = root.Manager; if (manager == null) { return; } this.FixChildrenDockLengths(); base.RowDefinitions.Clear(); base.ColumnDefinitions.Clear(); if (this.Orientation == System.Windows.Controls.Orientation.Horizontal) { int num = 0; int num1 = 0; int num2 = 0; while (num2 < this._model.Children.Count) { ILayoutPositionableElement item = (object)this._model.Children[num2] as ILayoutPositionableElement; base.ColumnDefinitions.Add(new ColumnDefinition() { Width = (item.IsVisible ? item.DockWidth : new GridLength(0, GridUnitType.Pixel)), MinWidth = (item.IsVisible ? item.DockMinWidth : 0) }); Grid.SetColumn(base.InternalChildren[num1], num); if (num1 < base.InternalChildren.Count - 1) { num1++; num++; bool flag = false; int num3 = num2 + 1; while (num3 < this._model.Children.Count) { if (!((object)this._model.Children[num3] as ILayoutPositionableElement).IsVisible) { num3++; } else { flag = true; break; } } base.ColumnDefinitions.Add(new ColumnDefinition() { Width = (item.IsVisible & flag ? new GridLength(manager.GridSplitterWidth) : new GridLength(0, GridUnitType.Pixel)) }); Grid.SetColumn(base.InternalChildren[num1], num); } num2++; num++; num1++; } return; } int num4 = 0; int num5 = 0; int num6 = 0; while (num6 < this._model.Children.Count) { ILayoutPositionableElement layoutPositionableElement = (object)this._model.Children[num6] as ILayoutPositionableElement; base.RowDefinitions.Add(new RowDefinition() { Height = (layoutPositionableElement.IsVisible ? layoutPositionableElement.DockHeight : new GridLength(0, GridUnitType.Pixel)), MinHeight = (layoutPositionableElement.IsVisible ? layoutPositionableElement.DockMinHeight : 0) }); Grid.SetRow(base.InternalChildren[num5], num4); if (num5 < base.InternalChildren.Count - 1) { num5++; num4++; bool flag1 = false; int num7 = num6 + 1; while (num7 < this._model.Children.Count) { if (!((object)this._model.Children[num7] as ILayoutPositionableElement).IsVisible) { num7++; } else { flag1 = true; break; } } base.RowDefinitions.Add(new RowDefinition() { Height = (layoutPositionableElement.IsVisible & flag1 ? new GridLength(manager.GridSplitterHeight) : new GridLength(0, GridUnitType.Pixel)) }); Grid.SetRow(base.InternalChildren[num5], num4); } num6++; num4++; num5++; } }
private void ShowResizerOverlayWindow(LayoutGridResizerControl splitter) { Size size; this._resizerGhost = new Border() { Background = splitter.BackgroundWhileDragging, Opacity = splitter.OpacityWhileDragging }; int num = base.InternalChildren.IndexOf(splitter); FrameworkElement item = base.InternalChildren[num - 1] as FrameworkElement; FrameworkElement nextVisibleChild = this.GetNextVisibleChild(num); Size ancestor = item.TransformActualSizeToAncestor(); Size ancestor1 = nextVisibleChild.TransformActualSizeToAncestor(); ILayoutPositionableElement model = (ILayoutPositionableElement)(item as ILayoutControl).Model; ILayoutPositionableElement layoutPositionableElement = (ILayoutPositionableElement)(nextVisibleChild as ILayoutControl).Model; Point point = new Point(); Point screenDPIWithoutFlowDirection = item.PointToScreenDPIWithoutFlowDirection(point); if (this.Orientation != System.Windows.Controls.Orientation.Horizontal) { size = new Size(ancestor.Width, ancestor.Height - model.DockMinHeight + splitter.ActualHeight + ancestor1.Height - layoutPositionableElement.DockMinHeight); this._resizerGhost.Height = splitter.ActualHeight; this._resizerGhost.Width = size.Width; screenDPIWithoutFlowDirection.Offset(0, model.DockMinHeight); } else { size = new Size(ancestor.Width - model.DockMinWidth + splitter.ActualWidth + ancestor1.Width - layoutPositionableElement.DockMinWidth, ancestor1.Height); this._resizerGhost.Width = splitter.ActualWidth; this._resizerGhost.Height = size.Height; screenDPIWithoutFlowDirection.Offset(model.DockMinWidth, 0); } point = new Point(); this._initialStartPoint = splitter.PointToScreenDPIWithoutFlowDirection(point) - screenDPIWithoutFlowDirection; if (this.Orientation != System.Windows.Controls.Orientation.Horizontal) { Canvas.SetTop(this._resizerGhost, this._initialStartPoint.Y); } else { Canvas.SetLeft(this._resizerGhost, this._initialStartPoint.X); } Canvas canva = new Canvas() { HorizontalAlignment = System.Windows.HorizontalAlignment.Stretch, VerticalAlignment = System.Windows.VerticalAlignment.Stretch }; canva.Children.Add(this._resizerGhost); this._resizerWindowHost = new Window() { SizeToContent = SizeToContent.Manual, ResizeMode = ResizeMode.NoResize, WindowStyle = WindowStyle.None, ShowInTaskbar = false, AllowsTransparency = true, Background = null, Width = size.Width, Height = size.Height, Left = screenDPIWithoutFlowDirection.X, Top = screenDPIWithoutFlowDirection.Y, ShowActivated = false, Content = canva }; this._resizerWindowHost.Loaded += new RoutedEventHandler((object s, RoutedEventArgs e) => this._resizerWindowHost.SetParentToMainWindowOf(this)); this._resizerWindowHost.Show(); }
private void OnSplitterDragCompleted(object sender, DragCompletedEventArgs e) { double num; GridLength dockHeight; LayoutGridResizerControl layoutGridResizerControl = sender as LayoutGridResizerControl; GeneralTransform ancestor = base.TransformToAncestor(this.FindVisualTreeRoot() as Visual); Vector vector = ancestor.Transform(new Point(e.HorizontalChange, e.VerticalChange)) - ancestor.Transform(new Point()); num = (this.Orientation != System.Windows.Controls.Orientation.Horizontal ? Canvas.GetTop(this._resizerGhost) - this._initialStartPoint.Y : Canvas.GetLeft(this._resizerGhost) - this._initialStartPoint.X); int num1 = base.InternalChildren.IndexOf(layoutGridResizerControl); FrameworkElement item = base.InternalChildren[num1 - 1] as FrameworkElement; FrameworkElement nextVisibleChild = this.GetNextVisibleChild(num1); Size size = item.TransformActualSizeToAncestor(); Size ancestor1 = nextVisibleChild.TransformActualSizeToAncestor(); ILayoutPositionableElement model = (ILayoutPositionableElement)(item as ILayoutControl).Model; ILayoutPositionableElement gridLength = (ILayoutPositionableElement)(nextVisibleChild as ILayoutControl).Model; if (this.Orientation != System.Windows.Controls.Orientation.Horizontal) { if (!model.DockHeight.IsStar) { dockHeight = model.DockHeight; model.DockHeight = new GridLength(dockHeight.Value + num, GridUnitType.Pixel); } else { dockHeight = model.DockHeight; model.DockHeight = new GridLength(dockHeight.Value * (size.Height + num) / size.Height, GridUnitType.Star); } if (!gridLength.DockHeight.IsStar) { dockHeight = gridLength.DockHeight; gridLength.DockHeight = new GridLength(dockHeight.Value - num, GridUnitType.Pixel); } else { dockHeight = gridLength.DockHeight; gridLength.DockHeight = new GridLength(dockHeight.Value * (ancestor1.Height - num) / ancestor1.Height, GridUnitType.Star); } } else { if (!model.DockWidth.IsStar) { dockHeight = model.DockWidth; model.DockWidth = new GridLength(dockHeight.Value + num, GridUnitType.Pixel); } else { dockHeight = model.DockWidth; model.DockWidth = new GridLength(dockHeight.Value * (size.Width + num) / size.Width, GridUnitType.Star); } if (!gridLength.DockWidth.IsStar) { dockHeight = gridLength.DockWidth; gridLength.DockWidth = new GridLength(dockHeight.Value - num, GridUnitType.Pixel); } else { dockHeight = gridLength.DockWidth; gridLength.DockWidth = new GridLength(dockHeight.Value * (ancestor1.Width - num) / ancestor1.Width, GridUnitType.Star); } } this.HideResizerOverlayWindow(); }
protected override void OnFixChildrenDockLengths() { if (base.ActualWidth == 0 || base.ActualHeight == 0) { return; } LayoutPanel layoutPanel = this._model; if (this._model.Orientation == System.Windows.Controls.Orientation.Horizontal) { if (!this._model.ContainsChildOfType <LayoutDocumentPane, LayoutDocumentPaneGroup>()) { for (int i = 0; i < this._model.Children.Count; i++) { ILayoutPositionableElement item = this._model.Children[i] as ILayoutPositionableElement; if (!item.DockWidth.IsStar) { item.DockWidth = new GridLength(1, GridUnitType.Star); } } return; } for (int j = 0; j < this._model.Children.Count; j++) { ILayoutContainer layoutContainer = this._model.Children[j] as ILayoutContainer; ILayoutPositionableElement gridLength = this._model.Children[j] as ILayoutPositionableElement; if (layoutContainer != null && (layoutContainer.IsOfType <LayoutDocumentPane, LayoutDocumentPaneGroup>() || layoutContainer.ContainsChildOfType <LayoutDocumentPane, LayoutDocumentPaneGroup>())) { gridLength.DockWidth = new GridLength(1, GridUnitType.Star); } else if (gridLength != null && gridLength.DockWidth.IsStar) { double num = Math.Max((gridLength as ILayoutPositionableElementWithActualSize).ActualWidth, gridLength.DockMinWidth); num = Math.Min(num, base.ActualWidth / 2); num = Math.Max(num, gridLength.DockMinWidth); gridLength.DockWidth = new GridLength(num, GridUnitType.Pixel); } } return; } if (!this._model.ContainsChildOfType <LayoutDocumentPane, LayoutDocumentPaneGroup>()) { for (int k = 0; k < this._model.Children.Count; k++) { ILayoutPositionableElement layoutPositionableElement = this._model.Children[k] as ILayoutPositionableElement; if (!layoutPositionableElement.DockHeight.IsStar) { layoutPositionableElement.DockHeight = new GridLength(1, GridUnitType.Star); } } return; } for (int l = 0; l < this._model.Children.Count; l++) { ILayoutContainer item1 = this._model.Children[l] as ILayoutContainer; ILayoutPositionableElement gridLength1 = this._model.Children[l] as ILayoutPositionableElement; if (item1 != null && (item1.IsOfType <LayoutDocumentPane, LayoutDocumentPaneGroup>() || item1.ContainsChildOfType <LayoutDocumentPane, LayoutDocumentPaneGroup>())) { gridLength1.DockHeight = new GridLength(1, GridUnitType.Star); } else if (gridLength1 != null && gridLength1.DockHeight.IsStar) { double num1 = Math.Max((gridLength1 as ILayoutPositionableElementWithActualSize).ActualHeight, gridLength1.DockMinHeight); num1 = Math.Min(num1, base.ActualHeight / 2); num1 = Math.Max(num1, gridLength1.DockMinHeight); gridLength1.DockHeight = new GridLength(num1, GridUnitType.Pixel); } } }
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); }