internal HiddenMdiChild(DockContent content)
: base()
{
SetStyle(ControlStyles.Selectable, false);
if (content == null)
throw(new ArgumentNullException());
Form mdiParent = (content.DockPanel == null) ? null : content.DockPanel.FindForm();
if (mdiParent != null)
if (!mdiParent.IsMdiContainer)
mdiParent = null;
if (mdiParent == null)
throw(new InvalidOperationException());
m_content = content;
Menu = ((Form)content).Menu;
FormBorderStyle = FormBorderStyle.None;
Text = m_content.Text;
SetMdiParent(mdiParent);
}
private void SetVisibleContentsToPane(DockPane pane, DockContent activeContent)
{
for (int i=0; i<DisplayingContents.Count; i++)
{
DockContent content = DisplayingContents[i];
if (content.IsDockStateValid(pane.DockState))
{
content.Pane = pane;
i--;
}
}
if (activeContent != null && pane.DisplayingContents.Contains(activeContent))
pane.ActiveContent = activeContent;
}
internal DockPaneTabVS2003(DockContent content)
: base(content)
{
}
/// <include file='CodeDoc/AutoHideTab.xml' path='//CodeDoc/Class[@name="AutoHideTab"]/Construct[@name="(DockContent)"]/*'/>
public AutoHideTab(DockContent content)
{
m_content = content;
}
private void DrawTab_Document(Graphics g, DockContent content, Rectangle rect)
{
Rectangle rectText = rect;
rectText.X += DocumentTextExtraWidth / 2;
rectText.Width -= DocumentTextExtraWidth;
if (DockPane.ActiveContent == content)
{
g.FillRectangle(ActiveBackBrush, rect);
g.DrawLine(OutlineOuterPen, rect.X, rect.Y, rect.X, rect.Y + rect.Height);
g.DrawLine(OutlineOuterPen, rect.X, rect.Y, rect.X + rect.Width - 1, rect.Y);
g.DrawLine(OutlineInnerPen,
rect.X + rect.Width - 1, rect.Y,
rect.X + rect.Width - 1, rect.Y + rect.Height - 1);
if (DockPane.IsActiveDocumentPane)
{
using (Font boldFont = new Font(this.Font, FontStyle.Bold))
{
g.DrawString(content.Text, boldFont, ActiveTextBrush, rectText, DocumentTextStringFormat);
}
}
else
g.DrawString(content.Text, Font, InactiveTextBrush, rectText, DocumentTextStringFormat);
}
else
{
if (Tabs.IndexOf(DockPane.ActiveContent) != Tabs.IndexOf(content) + 1)
g.DrawLine(TabSeperatorPen,
rect.X + rect.Width - 1, rect.Y,
rect.X + rect.Width - 1, rect.Y + rect.Height - 1 - DocumentTabGapTop);
g.DrawString(content.Text, Font, InactiveTextBrush, rectText, DocumentTextStringFormat);
}
}
public DockPaneTab CreateDockPaneTab(DockContent content)
{
return new DockPaneTabVS2003(content);
}
public DockPane CreateDockPane(DockContent content, DockState visibleState, bool show)
{
return new DockPane(content, visibleState, show);
}
/// <include file='CodeDoc\DockPane.xml' path='//CodeDoc/Class[@name="DockPane"]/Constructor[@name="(DockContent, DockPane, DockAlignment, double, bool)"]/*'/>
public DockPane(DockContent content, DockPane prevPane, DockAlignment alignment, double proportion, bool show)
{
if (prevPane == null)
throw(new ArgumentNullException());
InternalConstruct(content, prevPane.DockState, false, Rectangle.Empty, prevPane, alignment, proportion, show);
}
public DockPane CreateDockPane(DockContent content, DockState visibleState, bool show)
{
return(new DockPane(content, visibleState, show));
}
public AutoHideTab CreateAutoHideTab(DockContent content)
{
return(new AutoHideTabVS2003(content));
}
public DockPaneTab CreateDockPaneTab(DockContent content)
{
return(new DockPaneTabVS2003(content));
}
public DockPane CreateDockPane(DockContent content, Rectangle floatWindowBounds, bool show)
{
return(new DockPane(content, floatWindowBounds, show));
}
public DockPane CreateDockPane(DockContent content, DockPane prevPane, DockAlignment alignment, double proportion, bool show)
{
return(new DockPane(content, prevPane, alignment, proportion, show));
}
private void Pane_OnEndDrag(bool abort)
{
User32.SetCursor(DragControl.Cursor.Handle);
if (abort)
{
return;
}
DockPane pane = (DockPane)DragControl;
if (DropTarget.DropTo is DockPane)
{
DockPane paneTo = DropTarget.DropTo as DockPane;
if (DropTarget.Dock == DockStyle.Fill)
{
for (int i = pane.Contents.Count - 1; i >= 0; i--)
{
DockContent c = pane.Contents[i];
c.Pane = paneTo;
if (DropTarget.ContentIndex != -1)
{
paneTo.SetContentIndex(c, DropTarget.ContentIndex);
}
c.Activate();
}
}
else
{
if (DropTarget.Dock == DockStyle.Left)
{
pane.AddToDockList(paneTo.DockListContainer, paneTo, DockAlignment.Left, 0.5);
}
else if (DropTarget.Dock == DockStyle.Right)
{
pane.AddToDockList(paneTo.DockListContainer, paneTo, DockAlignment.Right, 0.5);
}
else if (DropTarget.Dock == DockStyle.Top)
{
pane.AddToDockList(paneTo.DockListContainer, paneTo, DockAlignment.Top, 0.5);
}
else if (DropTarget.Dock == DockStyle.Bottom)
{
pane.AddToDockList(paneTo.DockListContainer, paneTo, DockAlignment.Bottom, 0.5);
}
pane.DockState = paneTo.DockState;
pane.Activate();
}
}
else if (DropTarget.DropTo is DockPanel)
{
if (DropTarget.Dock == DockStyle.Top)
{
pane.DockState = DockState.DockTop;
}
else if (DropTarget.Dock == DockStyle.Bottom)
{
pane.DockState = DockState.DockBottom;
}
else if (DropTarget.Dock == DockStyle.Left)
{
pane.DockState = DockState.DockLeft;
}
else if (DropTarget.Dock == DockStyle.Right)
{
pane.DockState = DockState.DockRight;
}
else if (DropTarget.Dock == DockStyle.Fill)
{
pane.DockState = DockState.Document;
}
pane.Activate();
}
else if (IsDockStateValid(DockState.Float))
{
Point ptMouse = Control.MousePosition;
Point location = new Point(ptMouse.X + m_mouseOffset.X, ptMouse.Y + m_mouseOffset.Y);
Size size;
bool createFloatWindow = true;
if (pane.FloatWindow == null)
{
size = FloatWindow.DefaultWindowSize;
}
else if (pane.FloatWindow.DockList.Count == 1)
{
size = pane.FloatWindow.Size;
createFloatWindow = false;
}
else
{
size = FloatWindow.DefaultWindowSize;
}
if (ptMouse.X > location.X + size.Width)
{
location.X += ptMouse.X - (location.X + size.Width) + OutlineBorderWidth;
}
if (createFloatWindow)
{
pane.FloatWindow = pane.DockPanel.FloatWindowFactory.CreateFloatWindow(pane.DockPanel, pane, new Rectangle(location, size));
}
else
{
pane.FloatWindow.Bounds = new Rectangle(location, size);
}
pane.DockState = DockState.Float;
pane.Activate();
}
}
/// <include file='CodeDoc\DockPane.xml' path='//CodeDoc/Class[@name="DockPane"]/Constructor[@name="Overloads"]/*'/>
/// <include file='CodeDoc\DockPane.xml' path='//CodeDoc/Class[@name="DockPane"]/Constructor[@name="(DockContent, DockState, bool)"]/*'/>
public DockPane(DockContent content, DockState visibleState, bool show)
{
InternalConstruct(content, visibleState, false, Rectangle.Empty, null, DockAlignment.Right, 0.5, show);
}
internal void AddContent(DockContent content)
{
if (Contents.Contains(content))
return;
Contents.Add(content);
}
public DockPane CreateDockPane(DockContent content, FloatWindow floatWindow, bool show)
{
return(new DockPane(content, floatWindow, show));
}
/// <include file='CodeDoc\DockPane.xml' path='//CodeDoc/Class[@name="DockPane"]/Constructor[@name="(DockContent, Rectangle, bool)"]/*'/>
public DockPane(DockContent content, Rectangle floatWindowBounds, bool show)
{
InternalConstruct(content, DockState.Float, true, floatWindowBounds, null, DockAlignment.Right, 0.5, show);
}
/// <include file='CodeDoc/AutoHideTab.xml' path='//CodeDoc/Class[@name="AutoHideTab"]/Construct[@name="(DockContent)"]/*'/>
public AutoHideTab(DockContent content)
{
m_content = content;
}
public DockPane CreateDockPane(DockContent content, DockPane prevPane, DockAlignment alignment, double proportion, bool show)
{
return new DockPane(content, prevPane, alignment, proportion, show);
}
/// <include file='CodeDoc\AutoHideTabCollection.xml' path='//CodeDoc/Class[@name="AutoHideTabCollection"]/Method[@name="Contains(DockContent)"]/*'/>>
public bool Contains(DockContent content)
{
return(IndexOf(content) != -1);
}
private void Content_OnEndDrag(bool abort)
{
User32.SetCursor(DragControl.Cursor.Handle);
if (abort)
{
return;
}
DockContent content = ((DockPane)DragControl).ActiveContent;
if (DropTarget.DropTo is DockPane)
{
DockPane paneTo = DropTarget.DropTo as DockPane;
if (DropTarget.Dock == DockStyle.Fill)
{
bool samePane = (content.Pane == paneTo);
if (!samePane)
{
content.Pane = paneTo;
}
if (DropTarget.ContentIndex == -1 || !samePane)
{
paneTo.SetContentIndex(content, DropTarget.ContentIndex);
}
else
{
DockContentCollection contents = paneTo.Contents;
int oldIndex = contents.IndexOf(content);
int newIndex = DropTarget.ContentIndex;
if (oldIndex < newIndex)
{
newIndex += 1;
if (newIndex > contents.Count - 1)
{
newIndex = -1;
}
}
paneTo.SetContentIndex(content, newIndex);
}
content.Activate();
}
else
{
DockPane pane = content.DockPanel.DockPaneFactory.CreateDockPane(content, paneTo.DockState, true);
IDockListContainer container = paneTo.DockListContainer;
if (DropTarget.Dock == DockStyle.Left)
{
pane.AddToDockList(container, paneTo, DockAlignment.Left, 0.5);
}
else if (DropTarget.Dock == DockStyle.Right)
{
pane.AddToDockList(container, paneTo, DockAlignment.Right, 0.5);
}
else if (DropTarget.Dock == DockStyle.Top)
{
pane.AddToDockList(container, paneTo, DockAlignment.Top, 0.5);
}
else if (DropTarget.Dock == DockStyle.Bottom)
{
pane.AddToDockList(container, paneTo, DockAlignment.Bottom, 0.5);
}
pane.DockState = paneTo.DockState;
pane.Activate();
}
}
else if (DropTarget.DropTo is DockPanel)
{
DockPane pane;
DockPanel dockPanel = content.DockPanel;
if (DropTarget.Dock == DockStyle.Top)
{
pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockTop, true);
}
else if (DropTarget.Dock == DockStyle.Bottom)
{
pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockBottom, true);
}
else if (DropTarget.Dock == DockStyle.Left)
{
pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockLeft, true);
}
else if (DropTarget.Dock == DockStyle.Right)
{
pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.DockRight, true);
}
else if (DropTarget.Dock == DockStyle.Fill)
{
pane = dockPanel.DockPaneFactory.CreateDockPane(content, DockState.Document, true);
}
else
{
return;
}
pane.Activate();
}
else if (IsDockStateValid(DockState.Float))
{
Point ptMouse = Control.MousePosition;
Size size = FloatWindow.DefaultWindowSize;
Point location;
if (content.DockState == DockState.Document)
{
location = new Point(ptMouse.X + m_mouseOffset.X, ptMouse.Y + m_mouseOffset.Y);
}
else
{
location = new Point(ptMouse.X + m_mouseOffset.X, ptMouse.Y + m_mouseOffset.Y - size.Height);
}
if (ptMouse.X > location.X + size.Width)
{
location.X += ptMouse.X - (location.X + size.Width) + OutlineBorderWidth;
}
DockPane pane = content.DockPanel.DockPaneFactory.CreateDockPane(content, new Rectangle(location, size), true);
pane.Activate();
}
}
/// <include file='CodeDoc\AutoHideTabCollection.xml' path='//CodeDoc/Class[@name="AutoHideTabCollection"]/Method[@name="IndexOf(DockContent)"]/*'/>>
public int IndexOf(DockContent content)
{
return(DockPane.DisplayingContents.IndexOf(content));
}
private void DrawTab_ToolWindow(Graphics g, DockContent content, Rectangle rect)
{
Rectangle rectIcon = new Rectangle(
rect.X + ToolWindowImageGapLeft,
rect.Y + rect.Height - 1 - ToolWindowImageGapBottom - ToolWindowImageHeight,
ToolWindowImageWidth, ToolWindowImageHeight);
Rectangle rectText = rectIcon;
rectText.X += rectIcon.Width + ToolWindowImageGapRight;
rectText.Width = rect.Width - rectIcon.Width - ToolWindowImageGapLeft -
ToolWindowImageGapRight - ToolWindowTextGapRight;
if (DockPane.ActiveContent == content)
{
g.FillRectangle(ActiveBackBrush, rect);
g.DrawLine(OutlineOuterPen,
rect.X, rect.Y, rect.X, rect.Y + rect.Height - 1);
g.DrawLine(OutlineInnerPen,
rect.X, rect.Y + rect.Height - 1, rect.X + rect.Width - 1, rect.Y + rect.Height - 1);
g.DrawLine(OutlineInnerPen,
rect.X + rect.Width - 1, rect.Y, rect.X + rect.Width - 1, rect.Y + rect.Height - 1);
g.DrawString(content.TabText, Font, ActiveTextBrush, rectText, ToolWindowTextStringFormat);
}
else
{
if (Tabs.IndexOf(DockPane.ActiveContent) != Tabs.IndexOf(content) + 1)
g.DrawLine(TabSeperatorPen,
rect.X + rect.Width - 1,
rect.Y + ToolWindowTabSeperatorGapTop,
rect.X + rect.Width - 1,
rect.Y + rect.Height - 1 - ToolWindowTabSeperatorGapBottom);
g.DrawString(content.TabText, Font, InactiveTextBrush, rectText, ToolWindowTextStringFormat);
}
if (rect.Contains(rectIcon))
g.DrawIcon(content.Icon, rectIcon);
}
/// <include file='CodeDoc/DockPaneStripBase.xml' path='//CodeDoc/Class[@name="DockPaneStripBase"]/Method[@name="EnsureTabVisible(DockContent)"]/*'/> protected internal abstract void EnsureTabVisible(DockContent content);
/// <include file='CodeDoc\EventArgs.xml' path='//CodeDoc/Class[@name="DockContentEventArgs"]/Constructor[@name="(DockContent)"]/*'/>
public DockContentEventArgs(DockContent content)
{
m_content = content;
}
/// <exclude/>
protected override void WndProc(ref Message m)
{
if (m.Msg == (int)Win32.Msgs.WM_MOUSEACTIVATE)
{
DockPane.Activate();
base.WndProc(ref m);
return;
}
else if (m.Msg == (int)Win32.Msgs.WM_LBUTTONDOWN)
{
int index = GetHitTest();
if (index != -1)
{
DockContent content = Tabs[index].Content;
if (DockPane.ActiveContent != content)
{
DockPane.ActiveContent = content;
Update();
}
if (DockPane.DockPanel.AllowRedocking && DockPane.AllowRedocking && DockPane.ActiveContent.AllowRedocking)
{
DockPane.DockPanel.DragHandler.BeginDragContent(DockPane, DockPane.ClientRectangle); //DockPane.DisplayingRectangle);
}
}
else
{
base.WndProc(ref m);
}
return;
}
else if (m.Msg == (int)Win32.Msgs.WM_RBUTTONDOWN)
{
int index = GetHitTest();
if (index != -1)
{
DockContent content = Tabs[index].Content;
if (DockPane.ActiveContent != content)
{
DockPane.ActiveContent = content;
}
}
base.WndProc(ref m);
return;
}
else if (m.Msg == (int)Win32.Msgs.WM_RBUTTONUP)
{
int index = GetHitTest();
if (index != -1)
{
DockContent content = Tabs[index].Content;
if (content.TabPageContextMenu != null)
{
content.TabPageContextMenu.Show(this, this.PointToClient(Control.MousePosition));
}
}
base.WndProc(ref m);
return;
}
else if (m.Msg == (int)Win32.Msgs.WM_LBUTTONDBLCLK)
{
base.WndProc(ref m);
int index = GetHitTest();
if (DockPane.DockPanel.AllowRedocking && index != -1)
{
DockContent content = Tabs[index].Content;
try { content.IsFloat = !content.IsFloat; }
catch { }
}
return;
}
base.WndProc(ref m);
return;
}
private void InternalConstruct(DockContent content, DockState dockState, bool flagBounds, Rectangle floatWindowBounds, DockPane prevPane, DockAlignment alignment, double proportion, bool show)
{
if (dockState == DockState.Hidden || dockState == DockState.Unknown)
throw new ArgumentException(ResourceHelper.GetString("DockPane.DockState.InvalidState"));
if (content == null)
throw new ArgumentNullException(ResourceHelper.GetString("DockPane.Constructor.NullContent"));
if (content.DockPanel == null)
throw new ArgumentException(ResourceHelper.GetString("DockPane.Constructor.NullDockPanel"));
SuspendLayout();
SetStyle(ControlStyles.ResizeRedraw, true);
SetStyle(ControlStyles.UserPaint, true);
SetStyle(ControlStyles.AllPaintingInWmPaint, true);
SetStyle(ControlStyles.DoubleBuffer, true);
SetStyle(ControlStyles.Selectable, true);
m_isFloat = (dockState == DockState.Float);
m_contents = new DockContentCollection();
m_displayingContents = new DockContentCollection(this);
m_tabs = new DockPaneTabCollection(this);
m_dockPanel = content.DockPanel;
m_dockPanel.AddPane(this);
m_splitter = new DockPaneSplitter(this);
m_nestedDockingStatus = new NestedDockingStatus(this);
m_autoHidePane = DockPanel.AutoHidePaneFactory.CreateAutoHidePane(this);
m_captionControl = DockPanel.DockPaneCaptionFactory.CreateDockPaneCaption(this);
m_tabStripControl = DockPanel.DockPaneStripFactory.CreateDockPaneStrip(this);
Controls.AddRange(new Control[] { m_captionControl, m_tabStripControl });
if (flagBounds)
FloatWindow = DockPanel.FloatWindowFactory.CreateFloatWindow(DockPanel, this, floatWindowBounds);
else if (prevPane != null)
AddToDockList(prevPane.DockListContainer, prevPane, alignment, proportion);
SetDockState(dockState);
if (show)
content.Pane = this;
else if (this.IsFloat)
content.FloatPane = this;
else
content.PanelPane = this;
ResumeLayout();
}
private void DrawTab(Graphics g, AutoHideTabVS2003 tab)
{
Rectangle rectTab = GetTabRectangle(tab);
if (rectTab.IsEmpty)
{
return;
}
DockState dockState = tab.Content.DockState;
DockContent content = tab.Content;
OnBeginDrawTab(tab);
Brush brushTabBackGround = BrushTabBackground;
Pen penTabBorder = PenTabBorder;
Brush brushTabText = BrushTabText;
g.FillRectangle(brushTabBackGround, rectTab);
g.DrawLine(penTabBorder, rectTab.Left, rectTab.Top, rectTab.Left, rectTab.Bottom);
g.DrawLine(penTabBorder, rectTab.Right, rectTab.Top, rectTab.Right, rectTab.Bottom);
if (dockState == DockState.DockTopAutoHide || dockState == DockState.DockRightAutoHide)
{
g.DrawLine(penTabBorder, rectTab.Left, rectTab.Bottom, rectTab.Right, rectTab.Bottom);
}
else
{
g.DrawLine(penTabBorder, rectTab.Left, rectTab.Top, rectTab.Right, rectTab.Top);
}
// Set no rotate for drawing icon and text
Matrix matrixRotate = g.Transform;
g.Transform = MatrixIdentity;
// Draw the icon
Rectangle rectImage = rectTab;
rectImage.X += ImageGapLeft;
rectImage.Y += ImageGapTop;
int imageHeight = rectTab.Height - ImageGapTop - ImageGapBottom;
int imageWidth = ImageWidth;
if (imageHeight > ImageHeight)
{
imageWidth = ImageWidth * (imageHeight / ImageHeight);
}
rectImage.Height = imageHeight;
rectImage.Width = imageWidth;
rectImage = GetTransformedRectangle(dockState, rectImage);
g.DrawIcon(content.Icon, rectImage);
// Draw the text
if (content == content.Pane.ActiveContent)
{
Rectangle rectText = rectTab;
rectText.X += ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
rectText.Width -= ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
rectText = GetTransformedRectangle(dockState, rectText);
if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
{
g.DrawString(content.TabText, Font, brushTabText, rectText, StringFormatTabVertical);
}
else
{
g.DrawString(content.TabText, Font, brushTabText, rectText, StringFormatTabHorizontal);
}
}
// Set rotate back
g.Transform = matrixRotate;
OnEndDrawTab(tab);
}
/// <include file='CodeDoc\DockPane.xml' path='//CodeDoc/Class[@name="DockPane"]/Method[@name="SetContentIndex(DockContent, int)"]/*'/>
public void SetContentIndex(DockContent content, int index)
{
int oldIndex = Contents.IndexOf(content);
if (oldIndex == -1)
throw(new ArgumentException(ResourceHelper.GetString("DockPane.SetContentIndex.InvalidContent")));
if (index < 0 || index > Contents.Count - 1)
if (index != -1)
throw(new ArgumentOutOfRangeException(ResourceHelper.GetString("DockPane.SetContentIndex.InvalidIndex")));
if (oldIndex == index)
return;
if (oldIndex == Contents.Count - 1 && index == -1)
return;
Contents.Remove(content);
if (index == -1)
Contents.Add(content);
else if (oldIndex < index)
Contents.AddAt(content, index - 1);
else
Contents.AddAt(content, index);
RefreshChanges();
}
internal DockContent[] Select(DockAreas stateFilter)
{
if (DockPane != null)
throw new InvalidOperationException();
int count = 0;
foreach (DockContent c in this)
if (DockHelper.IsDockStateValid(c.DockState, stateFilter))
count ++;
DockContent[] contents = new DockContent[count];
count = 0;
foreach (DockContent c in this)
if (DockHelper.IsDockStateValid(c.DockState, stateFilter))
contents[count++] = c;
return contents;
}
/// <include file='CodeDoc\DockPane.xml' path='//CodeDoc/Class[@name="DockPane"]/Constructor[@name="(DockContent, FloatWindow, bool)"]/*'/>
public DockPane(DockContent content, FloatWindow floatWindow, bool show)
{
InternalConstruct(content, DockState.Float, false, Rectangle.Empty, floatWindow.DockList.GetDefaultPrevPane(this), DockAlignment.Right, 0.5, show);
}
private int GetIndexOfVisibleContents(DockContent content)
{
#if DEBUG
if (DockPane == null)
throw new InvalidOperationException();
#endif
if (content == null)
return -1;
int index = -1;
foreach (DockContent c in DockPane.Contents)
{
if (c.DockState == DockPane.DockState)
{
index++;
if (c == content)
return index;
}
}
return -1;
}
internal void CloseContent(DockContent content)
{
if (content == null)
return;
if (!content.CloseButton)
return;
if (content.HideOnClose)
content.Hide();
else
{
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// Workaround for .Net Framework bug: removing control from Form may cause form
// unclosable.
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Form form = FindForm();
if (ContainsFocus)
{
if (form is FloatWindow)
{
((FloatWindow)form).DummyControl.Focus();
form.ActiveControl = ((FloatWindow)form).DummyControl;
}
else if (DockPanel != null)
{
DockPanel.DummyControl.Focus();
if (form != null)
form.ActiveControl = DockPanel.DummyControl;
}
}
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
content.Close();
}
}
internal AutoHideTabVS2003(DockContent content)
: base(content)
{
}
internal void RemoveContent(DockContent content)
{
if (!Contents.Contains(content))
return;
Contents.Remove(content);
if (content.Parent == this)
content.SetParent(null);
if (Contents.Count == 0)
Dispose();
}
/// <include file='CodeDoc\AutoHideTabCollection.xml' path='//CodeDoc/Class[@name="AutoHideTabCollection"]/Method[@name="IndexOf(DockContent)"]/*'/>>
public int IndexOf(DockContent content)
{
return DockPane.DisplayingContents.IndexOf(content);
}
public AutoHideTab CreateAutoHideTab(DockContent content)
{
return new AutoHideTabVS2003(content);
}
/// <include file='CodeDoc\AutoHideTabCollection.xml' path='//CodeDoc/Class[@name="AutoHideTabCollection"]/Method[@name="Contains(DockContent)"]/*'/>>
public bool Contains(DockContent content)
{
return (IndexOf(content) != -1);
}
public DockPane CreateDockPane(DockContent content, FloatWindow floatWindow, bool show)
{
return new DockPane(content, floatWindow, show);
}
/// <exclude />
protected internal override void EnsureTabVisible(DockContent content)
{
if (Appearance != DockPane.AppearanceStyle.Document || !Tabs.Contains(content))
return;
Rectangle rectTabStrip = TabsRectangle;
Rectangle rectTab = GetTabRectangle(Tabs.IndexOf(content));
if (rectTab.Right > rectTabStrip.Right)
{
OffsetX -= rectTab.Right - rectTabStrip.Right;
rectTab.X -= rectTab.Right - rectTabStrip.Right;
}
if (rectTab.Left < rectTabStrip.Left)
OffsetX += rectTabStrip.Left - rectTab.Left;
OnRefreshChanges();
}
public DockPane CreateDockPane(DockContent content, Rectangle floatWindowBounds, bool show)
{
return new DockPane(content, floatWindowBounds, show);
}
private void DrawTab(Graphics g, DockContent content, Rectangle rect)
{
OnBeginDrawTab(content.DockPaneTab);
if (Appearance == DockPane.AppearanceStyle.ToolWindow)
DrawTab_ToolWindow(g, content, rect);
else
DrawTab_Document(g, content, rect);
OnEndDrawTab(content.DockPaneTab);
}
/// <include file='CodeDoc/DockPaneStripBase.xml' path='//CodeDoc/Class[@name="DockPaneStripBase"]/Method[@name="EnsureTabVisible(DockContent)"]/*'/> protected internal abstract void EnsureTabVisible(DockContent content);
private void FloatWindow_OnEndDrag(bool abort)
{
if (abort)
{
return;
}
FloatWindow floatWindow = (FloatWindow)DragControl;
if (DropTarget.DropTo == null)
{
Rectangle rect = DragControl.Bounds;
rect.X = Control.MousePosition.X + m_mouseOffset.X;
rect.Y = Control.MousePosition.Y + m_mouseOffset.Y;
DragControl.Bounds = rect;
}
else if (DropTarget.DropTo is DockPane)
{
DockPane paneTo = DropTarget.DropTo as DockPane;
if (DropTarget.Dock == DockStyle.Fill)
{
for (int i = floatWindow.DockList.Count - 1; i >= 0; i--)
{
DockPane pane = floatWindow.DockList[i];
for (int j = pane.Contents.Count - 1; j >= 0; j--)
{
DockContent c = pane.Contents[j];
c.Pane = paneTo;
if (DropTarget.ContentIndex != -1)
{
paneTo.SetContentIndex(c, DropTarget.ContentIndex);
}
c.Activate();
}
}
}
else
{
DockAlignment alignment = DockAlignment.Left;
if (DropTarget.Dock == DockStyle.Left)
{
alignment = DockAlignment.Left;
}
else if (DropTarget.Dock == DockStyle.Right)
{
alignment = DockAlignment.Right;
}
else if (DropTarget.Dock == DockStyle.Top)
{
alignment = DockAlignment.Top;
}
else if (DropTarget.Dock == DockStyle.Bottom)
{
alignment = DockAlignment.Bottom;
}
MergeDockList(floatWindow.DisplayingList, paneTo.DockListContainer.DockList, paneTo, alignment, 0.5);
}
}
else if (DropTarget.DropTo is DockPanel)
{
DockList dockListTo = null;
if (DropTarget.Dock == DockStyle.Top)
{
dockListTo = floatWindow.DockPanel.DockWindows[DockState.DockTop].DockList;
}
else if (DropTarget.Dock == DockStyle.Bottom)
{
dockListTo = floatWindow.DockPanel.DockWindows[DockState.DockBottom].DockList;
}
else if (DropTarget.Dock == DockStyle.Left)
{
dockListTo = floatWindow.DockPanel.DockWindows[DockState.DockLeft].DockList;
}
else if (DropTarget.Dock == DockStyle.Right)
{
dockListTo = floatWindow.DockPanel.DockWindows[DockState.DockRight].DockList;
}
else if (DropTarget.Dock == DockStyle.Fill)
{
dockListTo = floatWindow.DockPanel.DockWindows[DockState.Document].DockList;
}
DockPane prevPane = null;
for (int i = dockListTo.Count - 1; i >= 0; i--)
{
if (dockListTo[i] != floatWindow.DisplayingList[0])
{
prevPane = dockListTo[i];
}
}
MergeDockList(floatWindow.DisplayingList, dockListTo, prevPane, DockAlignment.Left, 0.5);
}
}
