public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if(destinationType==null)
throw new ArgumentNullException("destinationType");
if((destinationType==typeof(InstanceDescriptor)) && (value is DocumentDockContainer))
{
DocumentDockContainer doc=(DocumentDockContainer)value;
Type[] constructorParams=null;
MemberInfo constructorMemberInfo = null;
object[] constructorValues = null;
if(doc.Documents.Count==0)
{
constructorParams = new Type[0];
constructorMemberInfo = typeof(DocumentDockContainer).GetConstructor(constructorParams);
constructorValues = new object[0];
}
else
{
constructorParams = new Type[2] { typeof(DocumentBaseContainer[]), typeof(eOrientation) } ;
constructorMemberInfo = typeof(DocumentDockContainer).GetConstructor(constructorParams);
DocumentBaseContainer[] documentsArray = new DocumentBaseContainer[doc.Documents.Count];
doc.Documents.CopyTo(documentsArray);
constructorValues=new object[2] {documentsArray,doc.Orientation};
}
if(constructorMemberInfo!=null)
{
return new InstanceDescriptor(constructorMemberInfo, constructorValues);
}
}
return base.ConvertTo(context, culture, value, destinationType);
}
/// <summary>
/// Creates new instance of the object and initializes it with specified values.
/// </summary>
/// <param name="documents">Array of documents to host in this container.</param>
/// <param name="orientation">Container orientation</param>
public DocumentDockContainer(DocumentBaseContainer[] documents, eOrientation orientation)
{
m_Orientation=orientation;
m_Documents.Owner=this;
m_Documents.DocumentAdded+=new EventHandler(DocumentAdded);
m_Documents.DocumentRemoved+=new EventHandler(DocumentRemoved);
if(documents!=null)
{
foreach(DocumentBaseContainer doc in documents)
m_Documents.Add(doc);
}
}
/// <summary>
/// Occurs when height is being set on child document.
/// </summary>
/// <param name="doc">Reference document being changed</param>
/// <param name="height">Height in pixels</param>
/// <returns>True if width was applied by parent otherwise false</returns>
protected internal override bool OnSetHeight(DocumentBaseContainer doc, int height)
{
bool ret=false;
if(m_Orientation!=eOrientation.Vertical || height<doc.MinimumSize.Height && doc.MinimumSize.Height>0)
return ret;
DocumentBaseContainer pairDoc=null;
DocumentBaseContainer previousDoc=null;
int refIndex=m_Documents.IndexOf(doc);
// Lock in the display size if it is set
for(int i=0;i<m_Documents.Count;i++)
{
DocumentBaseContainer dc=m_Documents[i];
if (!dc.Visible) continue;
if(dc.DisplayBounds.Height>0)
dc.SetLayoutBounds(dc.DisplayBounds);
if(i>refIndex && dc.Visible && pairDoc==null)
pairDoc=dc;
else if(i<refIndex && dc.Visible)
previousDoc=dc;
}
if(pairDoc==null) pairDoc=previousDoc;
int diff=doc.LayoutBounds.Height-height;
if(pairDoc!=null && pairDoc.LayoutBounds.Height>0 && pairDoc.LayoutBounds.Height+diff>0 &&
(pairDoc.LayoutBounds.Height+diff>=pairDoc.MinimumSize.Height || pairDoc.MinimumSize.Height==0))
{
pairDoc.SetLayoutBounds(new Rectangle(pairDoc.LayoutBounds.X,pairDoc.LayoutBounds.Y,pairDoc.LayoutBounds.Width,pairDoc.LayoutBounds.Height+diff));
ret=true;
}
else if (pairDoc == null && previousDoc != null && previousDoc.LayoutBounds.Height > 0 && previousDoc.LayoutBounds.Height + diff > 0 &&
(previousDoc.LayoutBounds.Height + diff >= previousDoc.MinimumSize.Height || previousDoc.MinimumSize.Height == 0))
{
doc.SetLayoutBounds(new Rectangle(doc.LayoutBounds.X, doc.LayoutBounds.Y, doc.LayoutBounds.Width, height));
previousDoc.SetLayoutBounds(new Rectangle(previousDoc.LayoutBounds.X, previousDoc.LayoutBounds.Y, previousDoc.LayoutBounds.Width, 0));
ret = true;
}
return ret;
}
/// <summary>
/// Occurs when width is being set on child document.
/// </summary>
/// <param name="doc">Reference document being changed</param>
/// <param name="width">Width in pixels</param>
/// <returns>True if width was applied by parent otherwise false</returns>
protected internal override bool OnSetWidth(DocumentBaseContainer doc, int width)
{
bool ret=false;
if(m_Orientation!=eOrientation.Horizontal || width<doc.MinimumSize.Width && doc.MinimumSize.Width>0)
return ret;
DocumentBaseContainer pairDoc=null;
DocumentBaseContainer previousDoc=null;
int refIndex=m_Documents.IndexOf(doc);
// Lock in the display size if it is set
for(int i=0;i<m_Documents.Count;i++)
{
DocumentBaseContainer dc=m_Documents[i];
if (!dc.Visible) continue;
if(dc.DisplayBounds.Width>0)
dc.SetLayoutBounds(dc.DisplayBounds);
if(i>refIndex && dc.Visible && pairDoc==null)
pairDoc=dc;
else if(i<refIndex && dc.Visible)
previousDoc=dc;
}
int diff=doc.LayoutBounds.Width-width;
if(pairDoc!=null && pairDoc.LayoutBounds.Width>0 && pairDoc.LayoutBounds.Width+diff>0 &&
(pairDoc.LayoutBounds.Width+diff>=pairDoc.MinimumSize.Width || pairDoc.MinimumSize.Width==0))
{
pairDoc.SetLayoutBounds(new Rectangle(pairDoc.LayoutBounds.X,pairDoc.LayoutBounds.Y,pairDoc.LayoutBounds.Width+diff,pairDoc.LayoutBounds.Height));
ret=true;
}
else if (pairDoc == null && previousDoc != null && previousDoc.LayoutBounds.Width > 0 && previousDoc.LayoutBounds.Width + diff > 0 &&
(previousDoc.LayoutBounds.Width + diff >= previousDoc.MinimumSize.Width || previousDoc.MinimumSize.Width == 0))
{
doc.SetLayoutBounds(new Rectangle(doc.LayoutBounds.X, doc.LayoutBounds.Y, width, doc.LayoutBounds.Height));
// Resetting previous document width caused problem with ever growing bar when Width of single bar is set
// Reason is that resetting width here will cause the new space in container to be proportionally allocated thus setting single bar width which is intent of this function never works
//previousDoc.SetLayoutBounds(new Rectangle(previousDoc.LayoutBounds.X, previousDoc.LayoutBounds.Y, 0, previousDoc.LayoutBounds.Height));
ret = true;
}
return ret;
}
/// <summary>
/// Occurs when width is being set on child document.
/// </summary>
/// <param name="doc">Reference document being changed</param>
/// <param name="width">Width in pixels</param>
/// <returns>True if width was applied by parent otherwise false</returns>
protected internal virtual bool OnSetWidth(DocumentBaseContainer doc, int width){return false;}
/// <summary>
/// Removes specified object from the collection.
/// </summary>
/// <param name="value"></param>
public void Remove(DocumentBaseContainer value)
{
List.Remove(value);
}
/// <summary>
/// Inserts new object into the collection.
/// </summary>
/// <param name="index">Position of the object.</param>
/// <param name="value">Object to insert.</param>
public void Insert(int index, DocumentBaseContainer value)
{
List.Insert(index, value);
}
public void OnMouseDown(MouseEventArgs e)
{
int x=e.X, y=e.Y;
if(e.Button==MouseButtons.Left)
{
m_MouseDownPoint=new Point(x,y);
DocumentDockContainer context=this.GetContainerFromRoot(x,y);
if(context!=null)
{
m_ResizeDocument=this.GetClosestDocument(context,x,y);
if(m_ResizeDocument==null)
return;
m_ResizeDockContainer=context;
if(!m_ResizePreview)
{
CreateSplitter();
SplitterMouseMove(x,y);
}
}
else if (m_Container != null && m_Container.Dock != DockStyle.Fill)
{
m_ResizeDockContainer = m_DocumentDockContainer;
if (!m_ResizePreview)
{
CreateSplitter();
SplitterMouseMove(x, y);
}
}
}
}
/// <summary>
/// Adds new object to the collection.
/// </summary>
/// <param name="tab">Object to add.</param>
/// <returns>Index of newly added object.</returns>
public int Add(DocumentBaseContainer tab)
{
return List.Add(tab);
}
/// <summary>
/// Adds new objects to the collection.
/// </summary>
/// <param name="documents">Array of documents to add.</param>
public void AddRange(DocumentBaseContainer[] documents)
{
foreach(DocumentBaseContainer doc in documents)
List.Add(doc);
}
/// <summary>
/// Copies contained items to the DocumentBaseContainer array.
/// </summary>
/// <param name="array">Array to copy to.</param>
internal void CopyTo(DocumentBaseContainer[] array)
{
List.CopyTo(array,0);
}
/// <summary>
/// Copies collection into the specified array.
/// </summary>
/// <param name="array">Array to copy collection to.</param>
/// <param name="index">Starting index.</param>
public void CopyTo(DocumentBaseContainer[] array, int index)
{
List.CopyTo(array, index);
}
/// <summary>
/// Occurs when height is being set on child document.
/// </summary>
/// <param name="doc">Reference document being changed</param>
/// <param name="height">Height in pixels</param>
/// <returns>True if width was applied by parent otherwise false</returns>
protected internal virtual bool OnSetHeight(DocumentBaseContainer doc, int height){return false;}
/// <summary>
/// Docks specified bar by appending it to the container. Bar will be added according to the container's orientation.
/// </summary>
/// <param name="barToDock">Bar to dock.</param>
/// <param name="dockSide">Side to dock bar at.</param>
public void Dock(Bar referenceBar, Bar barToDock, eDockSide dockSide)
{
if(dockSide==eDockSide.None && barToDock.Parent==m_Container)
{
ApplyBarStyle(barToDock);
return;
}
if(barToDock.Parent is DockSite && ((DockSite)barToDock.Parent).DocumentDockContainer!=null)
((DockSite)barToDock.Parent).GetDocumentUIManager().UnDock(barToDock);
else if(barToDock.Parent is DockSite && barToDock.Parent!=m_Container)
((DockSite)barToDock.Parent).RemoveBar(barToDock);
else if (barToDock.Parent != null && barToDock.Parent != m_Container)
{
if (barToDock.Parent is FloatingContainer)
{
barToDock.RemoveFromFloatingContainer();
barToDock.SetBarState(eBarState.Docked);
}
else
barToDock.Parent.Controls.Remove(barToDock);
}
if(!m_LoadingLayout)
{
// TODO: Add Docking as Document, i.e. add DockContainerItems from barToDock...
DocumentBarContainer doc=this.CreateDocumentBarContainer(barToDock);
DocumentBaseContainer referenceDoc = this.GetDocumentFromBar(referenceBar);
if (referenceBar == null || dockSide == eDockSide.None || referenceBar == barToDock || referenceDoc == null)
{
if (m_Container.Dock == DockStyle.Fill)
m_DocumentDockContainer.Documents.Add(doc);
else
{
eOrientation containerOrientation = eOrientation.Horizontal; // Needed container orientation
if (m_Container.Dock == DockStyle.Top || m_Container.Dock == DockStyle.Bottom)
containerOrientation = eOrientation.Vertical;
// Switch orientation when adding new bar if possible
if (m_DocumentDockContainer.Orientation != containerOrientation)
{
if (m_DocumentDockContainer.Documents.Count <= 1)
{
m_DocumentDockContainer.Orientation = containerOrientation;
if (IsAddedInFront(dockSide))
m_DocumentDockContainer.Documents.Insert(0, doc);
else
m_DocumentDockContainer.Documents.Add(doc);
}
else
{
DocumentBaseContainer[] docs = new DocumentBaseContainer[m_DocumentDockContainer.Documents.Count];
m_DocumentDockContainer.Documents.CopyTo(docs);
m_DocumentDockContainer.Documents.Clear();
DocumentDockContainer newParent = new DocumentDockContainer(docs, m_DocumentDockContainer.Orientation);
newParent.SetLayoutBounds(m_DocumentDockContainer.DisplayBounds);
m_DocumentDockContainer.Orientation = containerOrientation;
m_DocumentDockContainer.Documents.Add(newParent);
if (IsAddedInFront(dockSide))
m_DocumentDockContainer.Documents.Insert(0, doc);
else
m_DocumentDockContainer.Documents.Add(doc);
}
}
else
{
if (IsAddedInFront(dockSide))
m_DocumentDockContainer.Documents.Insert(0, doc);
else
m_DocumentDockContainer.Documents.Add(doc);
}
}
}
else
{
DocumentDockContainer parent=referenceDoc.Parent as DocumentDockContainer;
referenceDoc.SetLayoutBounds(Rectangle.Empty);
doc.SetLayoutBounds(Rectangle.Empty);
if((parent.Orientation==eOrientation.Horizontal && (dockSide==eDockSide.Left || dockSide==eDockSide.Right)) ||
(parent.Orientation==eOrientation.Vertical && (dockSide==eDockSide.Top || dockSide==eDockSide.Bottom)))
{
if(dockSide==eDockSide.Right || dockSide==eDockSide.Bottom)
parent.Documents.Insert(parent.Documents.IndexOf(referenceDoc)+1,doc);
else
parent.Documents.Insert(parent.Documents.IndexOf(referenceDoc),doc);
}
else if(parent.Documents.Count==1)
{
// Orientation of the parent dock container can be changed
if(parent.Orientation==eOrientation.Vertical)
parent.Orientation=eOrientation.Horizontal;
else
parent.Orientation=eOrientation.Vertical;
if(dockSide==eDockSide.Right || dockSide==eDockSide.Bottom)
parent.Documents.Insert(parent.Documents.IndexOf(referenceDoc)+1,doc);
else
parent.Documents.Insert(parent.Documents.IndexOf(referenceDoc),doc);
}
else
{
// New DocumentDockContainer needs to be inserted with appropriate orientation and referenceBar needs
// to be moved into it.
DocumentDockContainer newParent=new DocumentDockContainer();
if(parent.Orientation==eOrientation.Horizontal)
newParent.Orientation=eOrientation.Vertical;
else
newParent.Orientation=eOrientation.Horizontal;
parent.Documents.Insert(parent.Documents.IndexOf(referenceDoc),newParent);
parent.Documents.Remove(referenceDoc);
if(dockSide==eDockSide.Right || dockSide==eDockSide.Bottom)
{
newParent.Documents.Add(referenceDoc);
newParent.Documents.Add(doc);
}
else
{
newParent.Documents.Add(doc);
newParent.Documents.Add(referenceDoc);
}
}
}
AdjustContainerSize(barToDock, false);
}
if(m_Container!=null)
{
if(barToDock.Parent==null)
m_Container.Controls.Add(barToDock);
ApplyBarStyle(barToDock);
m_Container.RecalcLayout();
}
else
ApplyBarStyle(barToDock);
}
/// <summary>
/// Returns index of the object inside of the collection.
/// </summary>
/// <param name="value">Reference to the object.</param>
/// <returns>Index of the object.</returns>
public int IndexOf(DocumentBaseContainer value)
{
return List.IndexOf(value);
}
private void RemoveEmptyContainers(DocumentDockContainer parent)
{
while(parent.Documents.Count==0 && parent.Parent!=null && parent.Parent is DocumentDockContainer ||
parent.Parent!=null && parent.Parent is DocumentDockContainer && ((DocumentDockContainer)parent.Parent).Documents.Count==1)
{
if(parent.Parent!=null && parent.Parent is DocumentDockContainer && ((DocumentDockContainer)parent.Parent).Documents.Count==1)
{
// Removes the instances where DocumentDockContainer hosts another one and only one DocumentDockContainer object
DocumentDockContainer p=parent.Parent as DocumentDockContainer;
p.Documents.Remove(parent);
p.Orientation=parent.Orientation;
DocumentBaseContainer[] documents=new DocumentBaseContainer[parent.Documents.Count];
parent.Documents.CopyTo(documents);
p.Documents.AddRange(documents);
parent=p;
}
else
{
DocumentDockContainer p=parent.Parent as DocumentDockContainer;
p.Documents.Remove(parent);
parent=p;
}
}
}
/// <summary>
/// Returns whether collection contains specified object.
/// </summary>
/// <param name="value">Object to look for.</param>
/// <returns>true if object is part of the collection, otherwise false.</returns>
public bool Contains(DocumentBaseContainer value)
{
return List.Contains(value);
}
public void OnMouseUp(MouseEventArgs e)
{
if(m_ResizeDockContainer!=null && !m_MouseDownPoint.IsEmpty)
{
ResizeTo(e.X,e.Y);
}
m_MouseDownPoint=Point.Empty;
m_ResizeDockContainer=null;
m_ResizeDocument=null;
DestroySplitter();
}
/// <summary>
/// Sets the parent document.
/// </summary>
/// <param name="parent">Parent container.</param>
internal void SetParent(DocumentBaseContainer parent)
{
m_Parent=parent;
}
