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);
}
