/// <summary>
/// Function called when dragged window is dropped over already docked window</summary>
/// <param name="sender">Dockable window being dragged</param>
/// <param name="e">Drag and drop arguments when window is dropped to be docked to dockpanel</param>
public void DockDrop(object sender, DockDragDropEventArgs e)
{
DockPanel parent = Root;
DockTo dockTo = (DockTo)m_dockPreview;
if (e.Content is TabLayout)
{
foreach (DockContent subContent in ((TabLayout)e.Content).Children)
{
ContentSettings contentSettings = subContent.Settings;
contentSettings.DockState = DockState.Docked;
}
}
else
{
ContentSettings contentSettings = ((DockContent)e.Content).Settings;
contentSettings.DockState = DockState.Docked;
}
switch (dockTo)
{
case DockTo.Left:
case DockTo.Right:
case DockTo.Top:
case DockTo.Bottom:
((IDockLayout)Parent).Dock(DockedContent, e.Content, dockTo);
break;
case DockTo.Center:
Dock(null, e.Content, dockTo);
break;
}
parent.CheckConsistency();
}
private void Exit_Click(object sender, EventArgs e)
{
if (lastFindPos != -1)
{
DockTo.SelectionStart = lastFindPos;
DockTo.SelectionLength = lastSearchQuery.Length;
DockTo.SelectionColor = SystemColors.WindowText;
}
this.Visible = false;
DockTo.Focus();
DockTo.SelectionLength = 0;
lastFindPos = -1;
lastSearchQuery = "";
Query.Text = "";
}
/// <summary>
/// Dock the new content next to content</summary>
/// <param name="nextTo">Dock content to add new content next to</param>
/// <param name="newContent">New content to be docked</param>
/// <param name="dockTo">Side of nextTo content where new content should be docked</param>
public void Dock(IDockContent nextTo, IDockContent newContent, DockTo dockTo)
{
TabLayout tabLayout = newContent as TabLayout;
if (tabLayout != null)
{
IEnumerator <DockContent> contentEnumerator = tabLayout.Children.GetEnumerator();
while (contentEnumerator.MoveNext())
{
DockContent content = contentEnumerator.Current;
tabLayout.RemoveItem(content);
AddContent(content);
contentEnumerator = tabLayout.Children.GetEnumerator();
}
}
else
{
AddContent((DockContent)newContent);
}
}
private static DockTo ControlGroupToDockTo(Sce.Atf.Applications.StandardControlGroup standardControlGroup)
{
DockTo dockTo = DockTo.Top;
switch (standardControlGroup)
{
case Sce.Atf.Applications.StandardControlGroup.Bottom:
dockTo = DockTo.Bottom;
break;
case Sce.Atf.Applications.StandardControlGroup.Center:
dockTo = DockTo.Center;
break;
case Sce.Atf.Applications.StandardControlGroup.CenterPermanent:
dockTo = DockTo.Center;
break;
case Sce.Atf.Applications.StandardControlGroup.Floating:
dockTo = DockTo.Center;
break;
case Sce.Atf.Applications.StandardControlGroup.Left:
dockTo = DockTo.Left;
break;
case Sce.Atf.Applications.StandardControlGroup.Right:
dockTo = DockTo.Right;
break;
case Sce.Atf.Applications.StandardControlGroup.Top:
dockTo = DockTo.Top;
break;
}
return(dockTo);
}
public static void Add(this ValuesInitializer @this, DockTo value) => @this.Element <BlockElement, DockTo>().SetValue(Dock.ToProperty, value);
public void Dock(IDockContent nextTo, IDockContent newContent, DockTo dockTo)
{
IDockLayout targetChild = null;
if (nextTo != null)
{
foreach (IDockLayout child in m_children)
{
if (child.HasChild(nextTo))
{
targetChild = child;
break;
}
}
}
if (targetChild == null)
{
foreach (IDockLayout child in m_children)
{
if (child.HasDescendant(nextTo))
{
child.Dock(nextTo, newContent, dockTo);
// child was docked, nothing else is necessary
return;
}
}
}
if (dockTo == DockTo.Center && m_children.Count == 1)
{
m_children[0].Dock(null, newContent, dockTo);
}
else if (m_children.Count < 2)
{
if (dockTo == DockTo.Center)
{
dockTo = DockTo.Right;
}
if (dockTo == DockTo.Top || dockTo == DockTo.Bottom)
{
m_orientation = Orientation.Vertical;
}
else
{
m_orientation = Orientation.Horizontal;
}
DockedWindow newChild = new DockedWindow(Root, newContent);
if (Children.Count == 0)
{
AddFirstChild(newChild);
}
else
{
if (targetChild == null)
{
if (dockTo == DockTo.Top || dockTo == DockTo.Left)
{
targetChild = m_children[0];
}
else
{
targetChild = m_children[m_children.Count - 1];
}
}
FrameworkElement control = (FrameworkElement)targetChild;
int index = m_children.IndexOf(targetChild);
if (dockTo == DockTo.Left || dockTo == DockTo.Right)
{
GridSplitter splitter = NewGridSplitter(Orientation.Horizontal);
int column = (int)control.GetValue(Grid.ColumnProperty);
ColumnDefinition oldColumn = ColumnDefinitions[index * 2];
ContentSettings contentSettings = (newContent is TabLayout) ? ((TabLayout)newContent).Children[0].Settings : ((DockContent)newContent).Settings;
double totalWidth = ((FrameworkElement)targetChild).ActualWidth;
double width = Math.Max(Math.Min(contentSettings.Size.Width, (totalWidth - splitter.Width) / 2), (totalWidth - splitter.Width) / 5);
double ratioNew = width / totalWidth;
double ratioOld = (totalWidth - width - splitter.Width) / totalWidth;
if (dockTo == DockTo.Left)
{
ColumnDefinition leftColumn = NewColumnDefinition(new GridLength(oldColumn.Width.Value * ratioNew, oldColumn.Width.GridUnitType), m_minGridSize.Width);
ColumnDefinition rightColumn = NewColumnDefinition(new GridLength(oldColumn.Width.Value * ratioOld, oldColumn.Width.GridUnitType), m_minGridSize.Width);
ColumnDefinitions[index * 2] = leftColumn;
ColumnDefinitions.Insert(index * 2 + 1, rightColumn);
ColumnDefinitions.Insert(index * 2 + 1, NewColumnDefinition(new GridLength(1, GridUnitType.Auto), 0));
m_children.Insert(index, newChild);
Children.Insert(index * 2, splitter);
Children.Insert(index * 2, newChild);
}
else
{
ColumnDefinition leftColumn = NewColumnDefinition(new GridLength(oldColumn.Width.Value * ratioOld, oldColumn.Width.GridUnitType), m_minGridSize.Width);
ColumnDefinition rightColumn = NewColumnDefinition(new GridLength(oldColumn.Width.Value * ratioNew, oldColumn.Width.GridUnitType), m_minGridSize.Width);
ColumnDefinitions[index * 2] = leftColumn;
ColumnDefinitions.Insert(index * 2 + 1, rightColumn);
ColumnDefinitions.Insert(index * 2 + 1, NewColumnDefinition(new GridLength(1, GridUnitType.Auto), 0));
m_children.Insert(index + 1, newChild);
Children.Insert(index * 2 + 1, newChild);
Children.Insert(index * 2 + 1, splitter);
}
for (int i = index * 2; i < Children.Count; i++)
{
Grid.SetColumn(Children[i], i);
}
}
else
{
GridSplitter splitter = NewGridSplitter(Orientation.Vertical);
int row = (int)control.GetValue(Grid.RowProperty);
RowDefinition oldRow = RowDefinitions[index * 2];
ContentSettings contentSettings = (newContent is TabLayout) ? ((TabLayout)newContent).Children[0].Settings : ((DockContent)newContent).Settings;
double totalHeight = ((FrameworkElement)targetChild).ActualHeight;
double height = Math.Max(Math.Min(contentSettings.Size.Height, (totalHeight - splitter.Height) / 2), (totalHeight - splitter.Height) / 5);
double ratioNew = height / totalHeight;
double ratioOld = (totalHeight - height - splitter.Height) / totalHeight;
if (dockTo == DockTo.Top)
{
RowDefinition topRow = NewRowDefinition(new GridLength(oldRow.Height.Value * ratioNew, oldRow.Height.GridUnitType), m_minGridSize.Height);
RowDefinition bottomRow = NewRowDefinition(new GridLength(oldRow.Height.Value * ratioOld, oldRow.Height.GridUnitType), m_minGridSize.Height);
RowDefinitions[index * 2] = topRow;
RowDefinitions.Insert(index * 2 + 1, bottomRow);
RowDefinitions.Insert(index * 2 + 1, NewRowDefinition(new GridLength(1, GridUnitType.Auto), 0));
m_children.Insert(index, newChild);
Children.Insert(index * 2, splitter);
Children.Insert(index * 2, newChild);
}
else
{
RowDefinition topRow = NewRowDefinition(new GridLength(oldRow.Height.Value * ratioOld, oldRow.Height.GridUnitType), m_minGridSize.Height);
RowDefinition bottomRow = NewRowDefinition(new GridLength(oldRow.Height.Value * ratioNew, oldRow.Height.GridUnitType), m_minGridSize.Height);
RowDefinitions[index * 2] = topRow;
RowDefinitions.Insert(index * 2 + 1, bottomRow);
RowDefinitions.Insert(index * 2 + 1, NewRowDefinition(new GridLength(1, GridUnitType.Auto), 0));
m_children.Insert(index + 1, newChild);
Children.Insert(index * 2 + 1, newChild);
Children.Insert(index * 2 + 1, splitter);
}
for (int i = index * 2; i < Children.Count; i++)
{
Grid.SetRow(Children[i], i);
}
}
}
}
else if (dockTo == DockTo.Left || dockTo == DockTo.Right || dockTo == DockTo.Top || dockTo == DockTo.Bottom)
{
DockedWindow dockedWindow = (DockedWindow)targetChild;
int index = m_children.IndexOf(targetChild);
GridLayout gridLayout = new GridLayout(Root);
gridLayout.SetValue(Grid.ColumnProperty, dockedWindow.GetValue(Grid.ColumnProperty));
gridLayout.SetValue(Grid.RowProperty, dockedWindow.GetValue(Grid.RowProperty));
Children.Remove(dockedWindow);
IDockContent content = dockedWindow.DockedContent;
dockedWindow.Undock(content);
m_children[index] = gridLayout;
Children.Insert(index * 2, gridLayout);
gridLayout.Dock(null, content, DockTo.Center);
UpdateLayout();
gridLayout.Dock(content, newContent, dockTo);
}
else if (targetChild != null)
{
targetChild.Dock(nextTo, newContent, dockTo);
}
}
/// <summary>
/// Dock the new content next to content</summary>
/// <param name="nextTo">Dock content to add new content next to</param>
/// <param name="newContent">New content to be docked</param>
/// <param name="dockTo">Side of nextTo content where new content should be docked</param>
public void Dock(IDockContent nextTo, IDockContent newContent, DockTo dockTo)
{
DockedContent.Dock(nextTo as DockContent, newContent, dockTo);
}
public static void SetTo([NotNull] BlockElement @this, DockTo value) => @this.SetValueSafe(ToProperty, value);
/// <summary>
/// Register content with docking panel</summary>
/// <param name="content">Content to register</param>
/// <param name="ucid">Unique name for content (identifier, won't be visible anywhere in UI)</param>
/// <param name="dockSide">Default docking place (center, left, right, top, bottom)</param>
/// <returns>New dock content</returns>
public IDockContent RegisterContent(object content, String ucid, DockTo dockSide) //where T : FrameworkElement, IDockContent
{
return RegisterContent(content, ucid, dockSide, String.Empty, null);
}
public void Dock(IDockContent nextTo, IDockContent newContent, DockTo dockTo)
{
IDockLayout targetChild = null;
if (nextTo != null)
{
foreach (IDockLayout child in m_children)
{
if (child.HasChild(nextTo))
{
targetChild = child;
break;
}
}
}
if (targetChild == null)
{
foreach (IDockLayout child in m_children)
{
if (child.HasDescendant(nextTo))
{
child.Dock(nextTo, newContent, dockTo);
// child was docked, nothing else is necessary
return;
}
}
}
if (dockTo == DockTo.Center && m_children.Count == 1)
{
m_children[0].Dock(null, newContent, dockTo);
}
else if (m_children.Count < 2)
{
if (dockTo == DockTo.Center)
{
dockTo = DockTo.Right;
}
if (dockTo == DockTo.Top || dockTo == DockTo.Bottom)
{
m_orientation = Orientation.Vertical;
}
else
{
m_orientation = Orientation.Horizontal;
}
DockedWindow newChild = new DockedWindow(Root, newContent);
if (Children.Count == 0)
{
AddFirstChild(newChild);
}
else
{
if (targetChild == null)
{
if (dockTo == DockTo.Top || dockTo == DockTo.Left)
{
targetChild = m_children[0];
}
else
{
targetChild = m_children[m_children.Count - 1];
}
}
FrameworkElement control = (FrameworkElement)targetChild;
int index = m_children.IndexOf(targetChild);
if (dockTo == DockTo.Left || dockTo == DockTo.Right)
{
GridSplitter splitter = NewGridSplitter(Orientation.Horizontal);
int column = (int)control.GetValue(Grid.ColumnProperty);
ColumnDefinition oldColumn = ColumnDefinitions[index * 2];
ContentSettings contentSettings = (newContent is TabLayout) ? ((TabLayout)newContent).Children[0].Settings : ((DockContent)newContent).Settings;
double totalWidth = ((FrameworkElement)targetChild).ActualWidth;
double width = Math.Max(Math.Min(contentSettings.Size.Width, (totalWidth - splitter.Width) / 2), (totalWidth - splitter.Width) / 5);
double ratioNew = width / totalWidth;
double ratioOld = (totalWidth - width - splitter.Width) / totalWidth;
if (dockTo == DockTo.Left)
{
ColumnDefinition leftColumn = NewColumnDefinition(new GridLength(oldColumn.Width.Value * ratioNew, oldColumn.Width.GridUnitType), m_minGridSize.Width);
ColumnDefinition rightColumn = NewColumnDefinition(new GridLength(oldColumn.Width.Value * ratioOld, oldColumn.Width.GridUnitType), m_minGridSize.Width);
ColumnDefinitions[index * 2] = leftColumn;
ColumnDefinitions.Insert(index * 2 + 1, rightColumn);
ColumnDefinitions.Insert(index * 2 + 1, NewColumnDefinition(new GridLength(1, GridUnitType.Auto), 0));
m_children.Insert(index, newChild);
Children.Insert(index * 2, splitter);
Children.Insert(index * 2, newChild);
}
else
{
ColumnDefinition leftColumn = NewColumnDefinition(new GridLength(oldColumn.Width.Value * ratioOld, oldColumn.Width.GridUnitType), m_minGridSize.Width);
ColumnDefinition rightColumn = NewColumnDefinition(new GridLength(oldColumn.Width.Value * ratioNew, oldColumn.Width.GridUnitType), m_minGridSize.Width);
ColumnDefinitions[index * 2] = leftColumn;
ColumnDefinitions.Insert(index * 2 + 1, rightColumn);
ColumnDefinitions.Insert(index * 2 + 1, NewColumnDefinition(new GridLength(1, GridUnitType.Auto), 0));
m_children.Insert(index + 1, newChild);
Children.Insert(index * 2 + 1, newChild);
Children.Insert(index * 2 + 1, splitter);
}
for (int i = index * 2; i < Children.Count; i++)
{
Grid.SetColumn(Children[i], i);
}
}
else
{
GridSplitter splitter = NewGridSplitter(Orientation.Vertical);
int row = (int)control.GetValue(Grid.RowProperty);
RowDefinition oldRow = RowDefinitions[index * 2];
ContentSettings contentSettings = (newContent is TabLayout) ? ((TabLayout)newContent).Children[0].Settings : ((DockContent)newContent).Settings;
double totalHeight = ((FrameworkElement)targetChild).ActualHeight;
double height = Math.Max(Math.Min(contentSettings.Size.Height, (totalHeight - splitter.Height) / 2), (totalHeight - splitter.Height) / 5);
double ratioNew = height / totalHeight;
double ratioOld = (totalHeight - height - splitter.Height) / totalHeight;
if (dockTo == DockTo.Top)
{
RowDefinition topRow = NewRowDefinition(new GridLength(oldRow.Height.Value * ratioNew, oldRow.Height.GridUnitType), m_minGridSize.Height);
RowDefinition bottomRow = NewRowDefinition(new GridLength(oldRow.Height.Value *ratioOld, oldRow.Height.GridUnitType), m_minGridSize.Height);
RowDefinitions[index * 2] = topRow;
RowDefinitions.Insert(index * 2 + 1, bottomRow);
RowDefinitions.Insert(index * 2 + 1, NewRowDefinition(new GridLength(1, GridUnitType.Auto), 0));
m_children.Insert(index, newChild);
Children.Insert(index * 2, splitter);
Children.Insert(index * 2, newChild);
}
else
{
RowDefinition topRow = NewRowDefinition(new GridLength(oldRow.Height.Value * ratioOld, oldRow.Height.GridUnitType), m_minGridSize.Height);
RowDefinition bottomRow = NewRowDefinition(new GridLength(oldRow.Height.Value * ratioNew, oldRow.Height.GridUnitType), m_minGridSize.Height);
RowDefinitions[index * 2] = topRow;
RowDefinitions.Insert(index * 2 + 1, bottomRow);
RowDefinitions.Insert(index * 2 + 1, NewRowDefinition(new GridLength(1, GridUnitType.Auto), 0));
m_children.Insert(index + 1, newChild);
Children.Insert(index * 2 + 1, newChild);
Children.Insert(index * 2 + 1, splitter);
}
for (int i = index * 2; i < Children.Count; i++)
{
Grid.SetRow(Children[i], i);
}
}
}
}
else if (dockTo == DockTo.Left || dockTo == DockTo.Right || dockTo == DockTo.Top || dockTo == DockTo.Bottom)
{
DockedWindow dockedWindow = (DockedWindow)targetChild;
int index = m_children.IndexOf(targetChild);
GridLayout gridLayout = new GridLayout(Root);
gridLayout.SetValue(Grid.ColumnProperty, dockedWindow.GetValue(Grid.ColumnProperty));
gridLayout.SetValue(Grid.RowProperty, dockedWindow.GetValue(Grid.RowProperty));
Children.Remove(dockedWindow);
IDockContent content = dockedWindow.DockedContent;
dockedWindow.Undock(content);
m_children[index] = gridLayout;
Children.Insert(index * 2, gridLayout);
gridLayout.Dock(null, content, DockTo.Center);
UpdateLayout();
gridLayout.Dock(content, newContent, dockTo);
}
else if (targetChild != null)
{
targetChild.Dock(nextTo, newContent, dockTo);
}
}
/// <summary>
/// Constructor</summary>
/// <param name="defaultDock">Default dock side</param>
public ContentSettings(DockTo defaultDock)
{
DefaultDock = defaultDock;
Size = new Size(0, 0);
DockState = DockState.Docked;
}
/// <summary>
/// Constructor</summary>
/// <param name="defaultDock">Default dock side</param>
public ContentSettings(DockTo defaultDock)
{
DefaultDock = defaultDock;
Size = new Size(0, 0);
DockState = DockState.Docked;
}
private void FloatingToolStrip_Move(object sender, EventArgs e)
{
_toolstrip.LayoutStyle = ToolStripLayoutStyle.HorizontalStackWithOverflow;
bool CanDock = false;
if (candockcheck)
{
for (int i = 0; i < _parentpanels.Length; i++)
{
Point ParentPoint = _parentpanels[i].Parent.PointToScreen(_parentpanels[i].Location);
Rectangle ParentRect = _parentpanels[i].Parent.RectangleToScreen(_parentpanels[i].ClientRectangle);
/*
* Rectangle toprect = new Rectangle(ParentPoint, new Size(_parentpanels[i].Width, _parentpanels[i].Height + _toolstrip.Height)); //_parentcontainer.RectangleToScreen(_parentcontainer.TopToolStripPanel.ClientRectangle);
*
* Rectangle bottomrect = new Rectangle(new Point(ParentPoint.X, ParentPoint.Y + _parentcontainer.Height - _toolstrip.Height - _parentcontainer.BottomToolStripPanel.Height),
* new Size(_parentcontainer.Width, _parentcontainer.BottomToolStripPanel.Height + _toolstrip.Height));//_parentcontainer.RectangleToScreen(_parentcontainer.BottomToolStripPanel.ClientRectangle);
*
* Rectangle leftrect = new Rectangle(ParentPoint, new Size(_parentcontainer.LeftToolStripPanel.Width + _toolstrip.Height, _parentcontainer.Height)); //_parentcontainer.RectangleToScreen(_parentcontainer.LeftToolStripPanel.ClientRectangle);
*
* Rectangle rightrect = new Rectangle(new Point(ParentPoint.X + _parentcontainer.Width - _toolstrip.Height - _parentcontainer.RightToolStripPanel.Width, ParentPoint.Y/*_parentcontainer.Height),
* new Size(_parentcontainer.RightToolStripPanel.Width + _toolstrip.Height, _parentcontainer.Height));//_parentcontainer.RectangleToScreen(_parentcontainer.RightToolStripPanel.ClientRectangle);
*/
//Console.WriteLine(bottomrect.ToString());
bool Virtual = false;
dockto = DockTo.None;
switch (_parentpanels[i].Dock)
{
case DockStyle.Top:
ParentRect.Height += _toolstrip.Height;
dockto = DockTo.Top;
break;
case DockStyle.Bottom:
ParentRect.Height += _toolstrip.Height;
ParentRect.Y += _parentpanels[i].Parent.Height - ParentRect.Height;
if (_parentpanels[i].Parent is Form)
{
ParentRect.Y = ParentRect.Y - GetSystemMetrics(SystemMetric.SM_CXSIZEFRAME) * 2 - GetSystemMetrics(SystemMetric.SM_CYCAPTION);
}
dockto = DockTo.Bottom;
break;
case DockStyle.Left:
ParentRect.Width += _toolstrip.Height;
Virtual = true;
dockto = DockTo.Left;
break;
case DockStyle.Right:
ParentRect.Width += _toolstrip.Height;
ParentRect.X += _parentpanels[i].Parent.Width - ParentRect.Width;
Virtual = true;
if (_parentpanels[i].Parent is Form)
{
ParentRect.X = ParentRect.X - GetSystemMetrics(SystemMetric.SM_CXSIZEFRAME) * 2;
}
dockto = DockTo.Right;
break;
}
if (CheckCloss(ParentRect, MousePosition))
{
DrawRectangleToScreen(_parentpanels[i], Virtual, ParentRect);
CanDock = true;
dockindex = i;
break;
}
else
{
dockindex = -1;
dockto = DockTo.Float;
}
#region botsu
/*
* if (CheckCloss(toprect, MousePosition) &&
* _parentcontainer.TopToolStripPanelVisible)
* {
* dockto = DockTo.Top;
* DrawRectangleToScreen(_parentcontainer.TopToolStripPanel, false, toprect);
* //MessageBox.Show("TOP");
* }
* else if (CheckCloss(bottomrect, MousePosition) &&
* _parentcontainer.BottomToolStripPanelVisible)
* {
* dockto = DockTo.Bottom;
* DrawRectangleToScreen(_parentcontainer.BottomToolStripPanel, false, bottomrect);
* //MessageBox.Show("Bottom");
* }
* else if (CheckCloss(leftrect, MousePosition) &&
* _parentcontainer.LeftToolStripPanelVisible)
* {
* dockto = DockTo.Left;
* DrawRectangleToScreen(_parentcontainer.LeftToolStripPanel, true, leftrect);
* //MessageBox.Show("Left");
* }
* else if (CheckCloss(rightrect, MousePosition) &&
* _parentcontainer.RightToolStripPanelVisible)
* {
* dockto = DockTo.Right;
* DrawRectangleToScreen(_parentcontainer.RightToolStripPanel, true, rightrect);
* //MessageBox.Show("Right");
* }
* else
* {
* dockto = DockTo.Float;
* rectform.Hide();
* this.Opacity = 1.0;
* }
* */
#endregion
}
if (CanDock)
{
}
else
{
rectform.Hide();
this.Opacity = 1.0;
}
}
else
{
candockcheck = true;
}
}
/// <summary>
/// Register content with docking panel</summary>
/// <param name="content">Content to register</param>
/// <param name="ucid">Unique name for content (identifier, won't be visible anywhere in UI)</param>
/// <param name="dockSide">Default docking place (center, left, right, top, bottom)</param>
/// <param name="header">Header information to display in the docked tab or title bar</param>
/// <param name="icon">Icon to display</param>
/// <returns>New dock content</returns>
public IDockContent RegisterContent(object content, String ucid, DockTo dockSide, String header, ImageSource icon) //where T : FrameworkElement, IDockContent
{
if (m_registeredContents.ContainsKey(ucid))
{
throw new ArgumentException("Content with given id already exists, id/name must be unique");
}
DockContent dockContent = new DockContent(content, ucid, header, icon) { Settings = new ContentSettings(dockSide) };
dockContent.IsFocusedChanged += DockContent_IsFocusedChanged;
m_registeredContents.Add(ucid, dockContent);
RegisteredContents.Add(dockContent);
return dockContent;
}
public void Dock(IDockContent nextTo, IDockContent newContent, DockTo dockTo)
{
DockedContent.Dock(nextTo as DockContent, newContent, dockTo);
}
/// <summary>
/// Dock the new content next to content</summary>
/// <param name="nextTo">Dock content to add new content next to</param>
/// <param name="newContent">New content to be docked</param>
/// <param name="dockTo">Side of nextTo content where new content should be docked</param>
public void Dock(IDockContent nextTo, IDockContent newContent, DockTo dockTo)
{
TabLayout tabLayout = newContent as TabLayout;
if (tabLayout != null)
{
IEnumerator<DockContent> contentEnumerator = tabLayout.Children.GetEnumerator();
while (contentEnumerator.MoveNext())
{
DockContent content = contentEnumerator.Current;
tabLayout.RemoveItem(content);
AddOneItem((DockContent)nextTo, content);
contentEnumerator = tabLayout.Children.GetEnumerator();
}
}
else
{
AddOneItem((DockContent)nextTo, newContent as DockContent);
}
Focus();
UpdateLayout();
}
/// <summary>
/// Dock the new content next to content</summary>
/// <param name="nextTo">Dock content to add new content next to</param>
/// <param name="newContent">New content to be docked</param>
/// <param name="dockTo">Side of nextTo content where new content should be docked</param>
void IDockLayout.Dock(IDockContent nextTo, IDockContent newContent, DockTo dockTo)
{
if (GridLayout == null)
{
GridLayout = new GridLayout(this);
GridLayout.Dock(null, newContent, DockTo.Center);
}
else
{
if (nextTo == null)
{
if (GridLayout.Children.Count < 2)
{
GridLayout.Dock(null, newContent, dockTo);
}
else
{
if (dockTo == DockTo.Center)
{
dockTo = DockTo.Right;
}
GridLayout gridLayout = GridLayout;
GridLayout = null;
gridLayout = new GridLayout(this, gridLayout);
GridLayout = gridLayout;
gridLayout.Dock(null, newContent, dockTo);
}
}
else
{
GridLayout.Dock(nextTo, newContent, dockTo);
}
CheckConsistency();
}
}
