public static bool IsDockStateDocked(DockState dockState)
{
return (dockState == DockState.DockLeft ||
dockState == DockState.DockRight ||
dockState == DockState.DockTop ||
dockState == DockState.DockBottom);
}
/// <summary>
/// Setup constructor with non-default default dock state (if that makes sense...)
/// </summary>
/// <param name="group">Window group</param>
/// <param name="menuName">Window name, decorated with an ampersand to designate the menu shortcut key </param>
/// <param name="create">Window creation function</param>
/// <param name="defaultDockState">Default dock state</param>
public WorkspaceWindowInfo( string group, string menuName, FunctionDelegates.Function<Control> create, DockState defaultDockState )
{
m_Group = group;
m_Name = menuName;
m_Create = create;
m_DefaultDockState = defaultDockState;
}
//public O2DockContent(Control controlToLoad, DockState controlDockState, string controlName)
/*public O2DockContent(Control controlToLoad)
: this(controlToLoad, DockState.Document)
{
}
public O2DockContent(Control controlToLoad, DockState controlDockState)
: this(controlToLoad, controlDockState, controlToLoad.Name)
{
}*/
/// <summary>
/// _note this will not create the Control, it expects a type and the control creation should be done by the form host
/// (this way we avoid the multi thread problems of this control being created on a diferent thread from the main hosting Form
/// </summary>
/// <param name="typeOfControlToLoad"></param>
/// <param name="controlDockState"></param>
/// <param name="controlName"></param>
public O2DockContent(Type typeOfControlToLoad, DockState controlDockState, string controlName)
{
type = typeOfControlToLoad;
dockContent = new GenericDockContent {Text = controlName};
dockState = controlDockState;
name = controlName;
}
public static bool IsValidRestoreState( DockState state ) {
if( state == DockState.DockLeft || state == DockState.DockRight || state == DockState.DockTop ||
state == DockState.DockBottom || state == DockState.Document )
return true;
else
return false;
}
internal DockWindow(DockPanel dockPanel, DockState dockState) {
m_nestedPanes = new NestedPaneCollection(this);
m_dockPanel = dockPanel;
m_dockState = dockState;
Visible = false;
SuspendLayout();
if (DockState == DockState.DockLeft || DockState == DockState.DockRight ||
DockState == DockState.DockTop || DockState == DockState.DockBottom) {
m_splitter = new SplitterControl();
Controls.Add(m_splitter);
}
if (DockState == DockState.DockLeft) {
Dock = DockStyle.Left;
m_splitter.Dock = DockStyle.Right;
} else if (DockState == DockState.DockRight) {
Dock = DockStyle.Right;
m_splitter.Dock = DockStyle.Left;
} else if (DockState == DockState.DockTop) {
Dock = DockStyle.Top;
m_splitter.Dock = DockStyle.Bottom;
} else if (DockState == DockState.DockBottom) {
Dock = DockStyle.Bottom;
m_splitter.Dock = DockStyle.Top;
} else if (DockState == DockState.Document) {
Dock = DockStyle.Fill;
}
ResumeLayout();
}
//private DockPanel _DockPanel;
//private DockState _DockState;
public EditorContainer(Editor editor, DockPanel dock, DockState dockState = DockState.Document)
{
Editor = editor;
Editor.UndoRedoStateChanged += Editor_UndoRedoStateChanged;
Editor.TextChangedDelayed += Editor_TextChangedDelayed;
Splitter = new Splitter() { Dock = DockStyle.Right, BackColor = SystemColors.ControlDarkDark, Width = 4 };
DocumentMap = new DocumentMap() {
Target = editor,
Dock = DockStyle.Right,
Width = DocumentMapInitialWidth,
MinimumSize = new Size(DocumentMapMinimumWidth, 0),
Scale = DocumentMapInitialWidth * DocumentMapScaleFactor,
BackColor = EditorSyntax.Styles.Background,
ForeColor = Color.FromArgb(0, 122, 204)
};
DocumentMap.DoubleClick += DocumentMap_DoubleClick;
DocumentMap.MouseWheel += DocumentMap_MouseWheel;
Splitter.SplitterMoved += Splitter_SplitterMoved;
Name = Editor.File.FileName;
ToolTipText = Editor.File.Path;
Controls.Add(Editor);
Controls.Add(Splitter);
Controls.Add(DocumentMap);
UpdateText(true);
FormClosing += EditorContainer_FormClosing;
FormClosed += EditorContainer_FormClosed;
System.Threading.Thread.Sleep(10);
dock.Invoke(new Action(() => { Show(dock, dockState); }));
}
public static bool IsDockWindowState(DockState state)
{
if (state == DockState.DockTop || state == DockState.DockBottom || state == DockState.DockLeft ||
state == DockState.DockRight || state == DockState.Document)
return true;
return false;
}
public static bool IsDockStateValid(DockState dockState, DockAreas dockableAreas)
{
if (((dockableAreas & DockAreas.Float) == 0) &&
(dockState == DockState.Float))
{
return false;
}
if (((dockableAreas & DockAreas.Document) == 0) &&
(dockState == DockState.Document))
{
return false;
}
if (((dockableAreas & DockAreas.DockLeft) == 0) &&
(dockState == DockState.DockLeft || dockState == DockState.DockLeftAutoHide))
{
return false;
}
if (((dockableAreas & DockAreas.DockRight) == 0) &&
(dockState == DockState.DockRight || dockState == DockState.DockRightAutoHide))
{
return false;
}
if (((dockableAreas & DockAreas.DockTop) == 0) &&
(dockState == DockState.DockTop || dockState == DockState.DockTopAutoHide))
{
return false;
}
if (((dockableAreas & DockAreas.DockBottom) == 0) &&
(dockState == DockState.DockBottom || dockState == DockState.DockBottomAutoHide))
{
return false;
}
return true;
}
public UIToolBarSettings(string name, int priority, Bitmap icon, DockState dockState = DockState.DockTopAutoHide, bool mainToolbar=false)
{
Name = name;
Priority = priority;
Icon = icon;
DockState = dockState;
MainToolbar = mainToolbar;
}
private bool IsDockStateAutoHide(DockState dockState)
{
if (((dockState != DockState.DockLeftAutoHide) && (dockState != DockState.DockRightAutoHide)) && ((dockState != DockState.DockTopAutoHide) && (dockState != DockState.DockBottomAutoHide)))
{
return false;
}
return true;
}
public static bool IsDockStateAutoHide(DockState dockState)
{
if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide ||
dockState == DockState.DockTopAutoHide || dockState == DockState.DockBottomAutoHide)
return true;
else
return false;
}
public void AddForm(DockContent dc, DockState ds)
{
if (dc == null)
return;
//FIXME: set 'dc.ShowHint = ds' without failing from no active content
dc.ShowHint = DockState.Document;
dc.MdiParent = this;
dc.Show(dockPanel1);
}
internal AutoHidePaneCollection(DockPanel panel, DockState dockState)
{
m_dockPanel = panel;
m_states = new AutoHideStateCollection();
States[DockState.DockTopAutoHide].Selected = (dockState==DockState.DockTopAutoHide);
States[DockState.DockBottomAutoHide].Selected = (dockState==DockState.DockBottomAutoHide);
States[DockState.DockLeftAutoHide].Selected = (dockState==DockState.DockLeftAutoHide);
States[DockState.DockRightAutoHide].Selected = (dockState==DockState.DockRightAutoHide);
}
public static bool setDockState(string name, DockState state)
{
if (DI.dO2LoadedO2DockContent.ContainsKey(name))
{
DI.dO2LoadedO2DockContent[name].dockContent.DockState = state;
return true;
}
return false;
}
public static bool IsDockRight(DockState dockState)
{
if (dockState == DockState.DockRight || dockState == DockState.DockRightAutoHide)
{
return true;
}
else
{
return false;
}
}
public static bool IsDockBottom(DockState dockState)
{
if (dockState == DockState.DockBottom || dockState == DockState.DockBottomAutoHide)
{
return true;
}
else
{
return false;
}
}
/// <include file='CodeDoc/AutoHideStripBase.xml' path='//CodeDoc/Class[@name="AutoHideStripBase"]/Method[@name="GetPanes(DockState)"]/*'/>
protected internal AutoHidePaneCollection GetPanes(DockState dockState) {
if (dockState == DockState.DockTopAutoHide)
return PanesTop;
else if (dockState == DockState.DockBottomAutoHide)
return PanesBottom;
else if (dockState == DockState.DockLeftAutoHide)
return PanesLeft;
else if (dockState == DockState.DockRightAutoHide)
return PanesRight;
else
throw new IndexOutOfRangeException();
}
public AutoHideState this[DockState dockState]
{
get
{
for (int i=0; i<m_states.Length; i++)
{
if (m_states[i].DockState == dockState)
return m_states[i];
}
throw new IndexOutOfRangeException();
}
}
public ApplicationDockedWindow()
{
InitializeComponent();
Icon = ApplicationIcons.Application;
dock_state = DockState.Document;
HideOnClose = true;
activated = x => { };
deactivated = x => { };
closed = x => { };
closing = x => { };
}
internal bool IsDockStateValid(DockState dockState)
{
foreach (var pane in NestedPanes)
{
foreach (var content in pane.Contents)
{
if (!DockHelper.IsDockStateValid(dockState, content.DockHandler.DockAreas))
return false;
}
}
return true;
}
public ViewGroup(DockingBase dockingOwner, DockState visibleOwnerDockState, DockState validDockStates)
{
if (dockingOwner == null)
throw new ArgumentNullException("dockingOwner", "dockingOwner is null.");
_validDockStates = validDockStates;
DockingOwner = dockingOwner;
DockState = visibleOwnerDockState;
_viewsInternal = new ObservableCollection<View>();
Views = new ReadOnlyObservableCollection<View>(_viewsInternal);
_viewsInternal.CollectionChanged += OnViewsChangedInternal;
}
public Dock(int iconNumber)
{
iconNumber_ = iconNumber;
hidingPoint_ = new Vector2(-58f, 42f);
state_ = DockState.hide;
displayTime = 0;
dockBoundX_ = 0;
for (int i = 0; i < iconNumber; i++)
{
icons_.Add(new Icon(i, hidingPoint_, 1 << i));
}
//initial state: move photo
touchState = PieMenu.PieMode.DragPhoto;
}
private void InternalConstruct(IDockContent 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(Strings.DockPane_SetDockState_InvalidState);
if (content == null)
throw new ArgumentNullException(Strings.DockPane_Constructor_NullContent);
if (content.DockHandler.DockPanel == null)
throw new ArgumentException(Strings.DockPane_Constructor_NullDockPanel);
SuspendLayout();
SetStyle(ControlStyles.Selectable, false);
m_isFloat = (dockState == DockState.Float);
m_contents = new DockContentCollection();
m_displayingContents = new DockContentCollection(this);
m_dockPanel = content.DockHandler.DockPanel;
m_dockPanel.AddPane(this);
m_splitter = new SplitterControl(this);
m_nestedDockingStatus = new NestedDockingStatus(this);
m_captionControl = DockPanel.DockPaneCaptionFactory.CreateDockPaneCaption(this);
m_tabStripControl = DockPanel.DockPaneStripFactory.CreateDockPaneStrip(this);
Controls.AddRange(new Control[] { m_captionControl, m_tabStripControl });
DockPanel.SuspendLayout(true);
if (flagBounds)
FloatWindow = DockPanel.FloatWindowFactory.CreateFloatWindow(DockPanel, this, floatWindowBounds);
else if (prevPane != null)
DockTo(prevPane.NestedPanesContainer, prevPane, alignment, proportion);
SetDockState(dockState);
if (show)
content.DockHandler.Pane = this;
else if (this.IsFloat)
content.DockHandler.FloatPane = this;
else
content.DockHandler.PanelPane = this;
ResumeLayout();
DockPanel.ResumeLayout(true, true);
}
public void Execute()
{
if (_form.Visible)
{
dockState = _form.DockState;
_form.Hide();
_form.SaveCurrentFile();
((DockPanel)(_workbench as Form1).Controls["MainDockPanel"]).ActiveDocumentChanged -= ActiveDocumentChanged;
}
else
{
DockPanel mdp = (DockPanel)(_workbench as Form1).Controls["MainDockPanel"];
_form.Show(mdp, dockState);
ActiveDocumentChanged(null, null);
((DockPanel)(_workbench as Form1).Controls["MainDockPanel"]).ActiveDocumentChanged += ActiveDocumentChanged;
}
}
/// <include file='CodeDoc\DockWindowCollection.xml' path='//CodeDoc/Class[@name="DockWindowCollection"]/Property[@name="Item"]/*'/>>
public DockWindow this [DockState dockState]
{
get
{
if (dockState == DockState.Document)
return InnerList[0] as DockWindow;
else if (dockState == DockState.DockLeft || dockState == DockState.DockLeftAutoHide)
return InnerList[1] as DockWindow;
else if (dockState == DockState.DockRight || dockState == DockState.DockRightAutoHide)
return InnerList[2] as DockWindow;
else if (dockState == DockState.DockTop || dockState == DockState.DockTopAutoHide)
return InnerList[3] as DockWindow;
else if (dockState == DockState.DockBottom || dockState == DockState.DockBottomAutoHide)
return InnerList[4] as DockWindow;
throw (new ArgumentOutOfRangeException());
}
}
private AutoHideMode MapDockStateToAutoHideMode( DockState state )
{
switch( state )
{
case DockState.Floating:
return AutoHideMode.None;
case DockState.LeftDock:
return AutoHideMode.CollapseLeft;
case DockState.TopDock:
return AutoHideMode.CollapseTop;
case DockState.RightDock:
return AutoHideMode.CollapseRight;
case DockState.BottomDock:
return AutoHideMode.CollapseBottom;
default:
throw new InvalidOperationException( string.Format(
"Invalid DockState value: {0}", _docker.State ) );
}
}
public static DockState ToggleAutoHideState( DockState state ) {
if( state == DockState.DockLeft )
return DockState.DockLeftAutoHide;
else if( state == DockState.DockRight )
return DockState.DockRightAutoHide;
else if( state == DockState.DockTop )
return DockState.DockTopAutoHide;
else if( state == DockState.DockBottom )
return DockState.DockBottomAutoHide;
else if( state == DockState.DockLeftAutoHide )
return DockState.DockLeft;
else if( state == DockState.DockRightAutoHide )
return DockState.DockRight;
else if( state == DockState.DockTopAutoHide )
return DockState.DockTop;
else if( state == DockState.DockBottomAutoHide )
return DockState.DockBottom;
else
return state;
}
public Dock(int iconNumber)
{
iconNumber_ = iconNumber;
hidingPoint_ = new Vector2(-58f, 42f);
state_ = DockState.hide;
displayTime = 0;
//if (state_ == DockState.show)
//{
// dockBoundX_ = hideThreshold_;
// for (int i = 0; i < iconNumber - 1; i++)
// {
// icons_.Add(new Icon(i, new Vector2(42f, (float)(84 * i + 42)), 1 << i));
// }
// icons_.Add(new Icon(iconNumber - 1, new Vector2(42f, (float)(84 * iconNumber - 42)), 0));
//}
//else
//{
dockBoundX_ = 0;
for (int i = 0; i < iconNumber; i++)
{
icons_.Add(new Icon(i, hidingPoint_, 1 << i));
}
//}
}
internal void SetDockState(bool isHidden, DockState visibleState, DockPane oldPane)
{
if (IsSuspendSetDockState)
{
return;
}
if (DockPanel == null && visibleState != DockState.Unknown)
{
throw new InvalidOperationException(Strings.DockContentHandler_SetDockState_NullPanel);
}
if (visibleState == DockState.Hidden || (visibleState != DockState.Unknown && !IsDockStateValid(visibleState)))
{
throw new InvalidOperationException(Strings.DockContentHandler_SetDockState_InvalidState);
}
DockPanel dockPanel = DockPanel;
if (dockPanel != null)
{
dockPanel.SuspendLayout(true);
}
SuspendSetDockState();
DockState oldDockState = DockState;
if (m_isHidden != isHidden || oldDockState == DockState.Unknown)
{
m_isHidden = isHidden;
}
m_visibleState = visibleState;
m_dockState = isHidden ? DockState.Hidden : visibleState;
//Remove hidden content (shown content is added last so removal is done first to invert the operation)
bool hidingContent = (DockState == DockState.Hidden) || (DockState == DockState.Unknown) || DockHelper.IsDockStateAutoHide(DockState);
if (PatchController.EnableContentOrderFix == true && oldDockState != DockState)
{
if (hidingContent)
{
if (!Win32Helper.IsRunningOnMono)
{
DockPanel.ContentFocusManager.RemoveFromList(Content);
}
}
}
if (visibleState == DockState.Unknown)
{
Pane = null;
}
else
{
m_isFloat = (m_visibleState == DockState.Float);
if (Pane == null)
{
Pane = DockPanel.Theme.Extender.DockPaneFactory.CreateDockPane(Content, visibleState, true);
}
else if (Pane.DockState != visibleState)
{
if (Pane.Contents.Count == 1)
{
Pane.SetDockState(visibleState);
}
else
{
Pane = DockPanel.Theme.Extender.DockPaneFactory.CreateDockPane(Content, visibleState, true);
}
}
}
if (Form.ContainsFocus)
{
if (DockState == DockState.Hidden || DockState == DockState.Unknown)
{
if (!Win32Helper.IsRunningOnMono)
{
DockPanel.ContentFocusManager.GiveUpFocus(Content);
}
}
}
SetPaneAndVisible(Pane);
if (oldPane != null && !oldPane.IsDisposed && oldDockState == oldPane.DockState)
{
RefreshDockPane(oldPane);
}
if (Pane != null && DockState == Pane.DockState)
{
if ((Pane != oldPane) ||
(Pane == oldPane && oldDockState != oldPane.DockState))
{
// Avoid early refresh of hidden AutoHide panes
if ((Pane.DockWindow == null || Pane.DockWindow.Visible || Pane.IsHidden) && !Pane.IsAutoHide)
{
RefreshDockPane(Pane);
}
}
}
if (oldDockState != DockState)
{
if (PatchController.EnableContentOrderFix == true)
{
//Add content that is being shown
if (!hidingContent)
{
if (!Win32Helper.IsRunningOnMono)
{
DockPanel.ContentFocusManager.AddToList(Content);
}
}
}
else
{
if (DockState == DockState.Hidden || DockState == DockState.Unknown ||
DockHelper.IsDockStateAutoHide(DockState))
{
if (!Win32Helper.IsRunningOnMono)
{
DockPanel.ContentFocusManager.RemoveFromList(Content);
}
}
else if (!Win32Helper.IsRunningOnMono)
{
DockPanel.ContentFocusManager.AddToList(Content);
}
}
ResetAutoHidePortion(oldDockState, DockState);
OnDockStateChanged(EventArgs.Empty);
}
ResumeSetDockState();
if (dockPanel != null)
{
dockPanel.ResumeLayout(true, true);
}
}
private void ResumeRefreshStateChange(INestedPanesContainer oldContainer, DockState oldDockState)
{
ResumeRefreshStateChange();
RefreshStateChange(oldContainer, oldDockState);
}
internal Rectangle GetTabStripRectangle(DockState dockState)
{
return(AutoHideStripControl.GetTabStripRectangle(dockState));
}
private void RefreshStateChange(INestedPanesContainer oldContainer, DockState oldDockState)
{
if (IsRefreshStateChangeSuspended)
{
return;
}
SuspendRefreshStateChange();
DockPanel.SuspendLayout(true);
var contentFocused = GetFocusedContent();
if (contentFocused != null)
{
DockPanel.SaveFocus();
}
SetParent();
ActiveContent?.DockHandler.SetDockState(ActiveContent.DockHandler.IsHidden, DockState, ActiveContent.DockHandler.Pane);
foreach (var content in Contents.Where(content => content.DockHandler.Pane == this))
{
content.DockHandler.SetDockState(content.DockHandler.IsHidden, DockState, content.DockHandler.Pane);
}
var oldContainerControl = (Control)oldContainer;
if (oldContainer?.DockState == oldDockState && !oldContainerControl.IsDisposed)
{
oldContainerControl.PerformLayout();
}
if (DockHelper.IsDockStateAutoHide(oldDockState))
{
DockPanel.RefreshActiveAutoHideContent();
}
if (NestedPanesContainer.DockState == DockState)
{
((Control)NestedPanesContainer).PerformLayout();
}
if (DockHelper.IsDockStateAutoHide(DockState))
{
DockPanel.RefreshActiveAutoHideContent();
}
if (DockHelper.IsDockStateAutoHide(oldDockState) ||
DockHelper.IsDockStateAutoHide(DockState))
{
DockPanel.RefreshAutoHideStrip();
DockPanel.PerformLayout();
}
ResumeRefreshStateChange();
contentFocused?.DockHandler.Activate();
DockPanel.ResumeLayout(true, true);
if (oldDockState != DockState)
{
OnDockStateChanged(EventArgs.Empty);
}
}
public DockPane CreateDockPane(IDockContent content, DockState visibleState, bool show)
{
return(new DockPane(content, visibleState, show));
}
public AutoHideState(DockState dockState)
{
m_dockState = dockState;
}
public static Syncfusion.Windows.Tools.Controls.DockState ToSfDockState(this DockState dockState) =>
dockState switch
{
/// <summary>
/// Initializes a new instance of the <see cref="VS2012DockWindow"/> class.
/// </summary>
/// <param name="dockPanel">The dock panel.</param>
/// <param name="dockState">State of the dock.</param>
public VS2012DockWindow(DockPanel dockPanel, DockState dockState) : base(dockPanel, dockState)
{
}
/// <summary>
/// This function allows DockContents to place themselves within the
/// DockPanel of the main IDE.
/// </summary>
/// <param name="dc">The DockContent to place in the IDE.</param>
/// <param name="state">Where and how the DockContent should be placed.</param>
public void ShowDock(DockContent dc, DockState state)
{
dc.Show(this.c_DockWorkspace, state);
}
public void Show(DockPanel dockPanel, DockState dockState)
{
DockHandler.Show(dockPanel, dockState);
}
private void InternalConstruct(IDockContent 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(Strings.DockPane_SetDockState_InvalidState);
}
if (content == null)
{
throw new ArgumentNullException(Strings.DockPane_Constructor_NullContent);
}
if (content.DockHandler.DockPanel == null)
{
throw new ArgumentException(Strings.DockPane_Constructor_NullDockPanel);
}
SuspendLayout();
SetStyle(ControlStyles.Selectable, false);
IsFloat = dockState == DockState.Float;
Contents = new DockContentCollection();
DisplayingContents = new DockContentCollection(this);
DockPanel = content.DockHandler.DockPanel;
DockPanel.AddPane(this);
Splitter = content.DockHandler.DockPanel.Extender.DockPaneSplitterControlFactory.CreateSplitterControl(this);
NestedDockingStatus = new NestedDockingStatus(this);
CaptionControl = DockPanel.DockPaneCaptionFactory.CreateDockPaneCaption(this);
TabStripControl = DockPanel.DockPaneStripFactory.CreateDockPaneStrip(this);
Controls.AddRange(new Control[] { CaptionControl, TabStripControl });
DockPanel.SuspendLayout(true);
if (flagBounds)
{
FloatWindow = DockPanel.FloatWindowFactory.CreateFloatWindow(DockPanel, this, floatWindowBounds);
}
else if (prevPane != null)
{
DockTo(prevPane.NestedPanesContainer, prevPane, alignment, proportion);
}
SetDockState(dockState);
if (show)
{
content.DockHandler.Pane = this;
}
else if (IsFloat)
{
content.DockHandler.FloatPane = this;
}
else
{
content.DockHandler.PanelPane = this;
}
ResumeLayout();
DockPanel.ResumeLayout(true, true);
}
private void DrawTab(Graphics g, TabVS2003 tab)
{
Rectangle rectTab = GetTabRectangle(tab);
if (rectTab.IsEmpty)
{
return;
}
DockState dockState = tab.Content.DockHandler.DockState;
IDockContent 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(((Form)content).Icon, rectImage);
// Draw the text
if (content == content.DockHandler.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.DockHandler.TabText, Font, brushTabText, rectText, StringFormatTabVertical);
}
else
{
g.DrawString(content.DockHandler.TabText, Font, brushTabText, rectText, StringFormatTabHorizontal);
}
}
// Set rotate back
g.Transform = matrixRotate;
OnEndDrawTab(tab);
}
private Rectangle GetLogicalTabStripRectangle(DockState dockState)
{
return(GetLogicalTabStripRectangle(dockState, false));
}
private Rectangle GetLogicalTabStripRectangle(DockState dockState, bool transformed)
{
if (!DockHelper.IsDockStateAutoHide(dockState))
{
return(Rectangle.Empty);
}
int leftPanes = GetPanes(DockState.DockLeftAutoHide).Count;
int rightPanes = GetPanes(DockState.DockRightAutoHide).Count;
int topPanes = GetPanes(DockState.DockTopAutoHide).Count;
int bottomPanes = GetPanes(DockState.DockBottomAutoHide).Count;
int x, y, width, height;
height = MeasureHeight();
if (dockState == DockState.DockLeftAutoHide && leftPanes > 0)
{
x = 0;
y = (topPanes == 0) ? 0 : height;
width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 : height);
}
else if (dockState == DockState.DockRightAutoHide && rightPanes > 0)
{
x = Width - height;
if (leftPanes != 0 && x < height)
{
x = height;
}
y = (topPanes == 0) ? 0 : height;
width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 : height);
}
else if (dockState == DockState.DockTopAutoHide && topPanes > 0)
{
x = leftPanes == 0 ? 0 : height;
y = 0;
width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
}
else if (dockState == DockState.DockBottomAutoHide && bottomPanes > 0)
{
x = leftPanes == 0 ? 0 : height;
y = Height - height;
if (topPanes != 0 && y < height)
{
y = height;
}
width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
}
else
{
return(Rectangle.Empty);
}
if (!transformed)
{
return(new Rectangle(x, y, width, height));
}
else
{
return(GetTransformedRectangle(dockState, new Rectangle(x, y, width, height)));
}
}
internal void SetDockState(bool isHidden, DockState visibleState, DockPane oldPane)
{
if (IsSuspendSetDockState)
{
return;
}
if (DockPanel == null && visibleState != DockState.Unknown)
{
throw new InvalidOperationException(ResourceHelper.GetString("IDockContent.SetDockState.NullPanel"));
}
if (visibleState == DockState.Hidden || (visibleState != DockState.Unknown && !IsDockStateValid(visibleState)))
{
throw new InvalidOperationException(ResourceHelper.GetString("IDockContent.SetDockState.InvalidState"));
}
SuspendSetDockState();
DockState oldDockState = DockState;
if (_isHidden != isHidden || oldDockState == DockState.Unknown)
{
_isHidden = isHidden;
}
_visibleState = visibleState;
_dockState = isHidden ? DockState.Hidden : visibleState;
if (visibleState == DockState.Unknown)
{
Pane = null;
}
else
{
_isFloat = (_visibleState == DockState.Float);
if (Pane == null)
{
Pane = DockPanel.DockPaneFactory.CreateDockPane(Content, visibleState, true);
}
else if (Pane.DockState != visibleState)
{
if (Pane.Contents.Count == 1)
{
Pane.SetDockState(visibleState);
}
else
{
Pane = DockPanel.DockPaneFactory.CreateDockPane(Content, visibleState, true);
}
}
}
SetPane(Pane);
SetVisible();
if (oldPane != null && !oldPane.IsDisposed && oldDockState == oldPane.DockState)
{
RefreshDockPane(oldPane);
}
if (Pane != null && DockState == Pane.DockState)
{
if ((Pane != oldPane) ||
(Pane == oldPane && oldDockState != oldPane.DockState))
{
RefreshDockPane(Pane);
}
}
if (oldDockState != DockState)
{
OnDockStateChanged(EventArgs.Empty);
}
ResumeSetDockState();
}
public bool IsDockStateValid(DockState dockState)
{
return(DockHandler.IsDockStateValid(dockState));
}
internal int GetNumberOfPanes(DockState dockState)
{
return(GetPanes(dockState).Count);
}
internal void SetDockState(bool isHidden, DockState visibleState, DockPane oldPane)
{
if (IsSuspendSetDockState)
{
return;
}
if (DockPanel == null && visibleState != DockState.Unknown)
{
throw new InvalidOperationException(Strings.DockContentHandler_SetDockState_NullPanel);
}
if (visibleState == DockState.Hidden || (visibleState != DockState.Unknown && !IsDockStateValid(visibleState)))
{
throw new InvalidOperationException(Strings.DockContentHandler_SetDockState_InvalidState);
}
DockPanel dockPanel = DockPanel;
if (dockPanel != null)
{
dockPanel.SuspendLayout(true);
}
SuspendSetDockState();
DockState oldDockState = DockState;
if (m_isHidden != isHidden || oldDockState == DockState.Unknown)
{
m_isHidden = isHidden;
}
m_visibleState = visibleState;
m_dockState = isHidden ? DockState.Hidden : visibleState;
if (visibleState == DockState.Unknown)
{
Pane = null;
}
else
{
m_isFloat = (m_visibleState == DockState.Float);
if (Pane == null)
{
Pane = DockPanel.DockPaneFactory.CreateDockPane(Content, visibleState, true);
}
else if (Pane.DockState != visibleState)
{
if (Pane.Contents.Count == 1)
{
Pane.SetDockState(visibleState);
}
else
{
Pane = DockPanel.DockPaneFactory.CreateDockPane(Content, visibleState, true);
}
}
}
if (Form.ContainsFocus)
{
if (DockState == DockState.Hidden || DockState == DockState.Unknown)
{
DockPanel.ContentFocusManager.GiveUpFocus(Content);
}
}
SetPaneAndVisible(Pane);
if (oldPane != null && !oldPane.IsDisposed && oldDockState == oldPane.DockState)
{
RefreshDockPane(oldPane);
}
if (Pane != null && DockState == Pane.DockState)
{
if ((Pane != oldPane) ||
(Pane == oldPane && oldDockState != oldPane.DockState))
{
RefreshDockPane(Pane);
}
}
if (oldDockState != DockState)
{
if (DockState == DockState.Hidden || DockState == DockState.Unknown ||
DockHelper.IsDockStateAutoHide(DockState))
{
DockPanel.ContentFocusManager.RemoveFromList(Content);
}
else
{
DockPanel.ContentFocusManager.AddToList(Content);
}
OnDockStateChanged(EventArgs.Empty);
}
ResumeSetDockState();
if (dockPanel != null)
{
dockPanel.ResumeLayout(true, true);
}
}
public void LoadDockContent(DockContent DockContent, DockState dockState)
{
dockContent = DockContent;
dockContent.Show(dockPanel, dockState);
}
private void ResumeSetDockState(bool isHidden, DockState visibleState, DockPane oldPane)
{
ResumeSetDockState();
SetDockState(isHidden, visibleState, oldPane);
}
public DockWindow CreateDockWindow(DockPanel dockPanel, DockState dockState)
{
return(new VS2012LightDockWindow(dockPanel, dockState));
}
private void DrawTab(Graphics g, TabVS2005 tab)
{
Rectangle rectTabOrigin = GetTabRectangle(tab);
if (rectTabOrigin.IsEmpty)
{
return;
}
DockState dockState = tab.Content.DockHandler.DockState;
IDockContent content = tab.Content;
GraphicsPath path = GetTabOutline(tab, false, true);
Color startColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.StartColor;
Color endColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.EndColor;
LinearGradientMode gradientMode = DockPanel.Skin.AutoHideStripSkin.TabGradient.LinearGradientMode;
g.FillPath(new LinearGradientBrush(rectTabOrigin, startColor, endColor, gradientMode), path);
g.DrawPath(PenTabBorder, path);
// Set no rotate for drawing icon and text
using (Matrix matrixRotate = g.Transform)
{
g.Transform = MatrixIdentity;
// Draw the icon
Rectangle rectImage = rectTabOrigin;
rectImage.X += ImageGapLeft;
rectImage.Y += ImageGapTop;
int imageHeight = rectTabOrigin.Height - ImageGapTop - ImageGapBottom;
int imageWidth = ImageWidth;
if (imageHeight > ImageHeight)
{
imageWidth = ImageWidth * (imageHeight / ImageHeight);
}
rectImage.Height = imageHeight;
rectImage.Width = imageWidth;
rectImage = GetTransformedRectangle(dockState, rectImage);
if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
{
// The DockState is DockLeftAutoHide or DockRightAutoHide, so rotate the image 90 degrees to the right.
Rectangle rectTransform = RtlTransform(rectImage, dockState);
Point[] rotationPoints =
{
new Point(rectTransform.X + rectTransform.Width, rectTransform.Y),
new Point(rectTransform.X + rectTransform.Width, rectTransform.Y + rectTransform.Height),
new Point(rectTransform.X, rectTransform.Y)
};
using (Icon rotatedIcon = new Icon(((Form)content).Icon, 16, 16))
{
g.DrawImage(rotatedIcon.ToBitmap(), rotationPoints);
}
}
else
{
// Draw the icon normally without any rotation.
g.DrawIcon(((Form)content).Icon, RtlTransform(rectImage, dockState));
}
// Draw the text
Rectangle rectText = rectTabOrigin;
rectText.X += ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
rectText.Width -= ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
rectText = RtlTransform(GetTransformedRectangle(dockState, rectText), dockState);
Color textColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.TextColor;
if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
{
g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabVertical);
}
else
{
g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabHorizontal);
}
// Set rotate back
g.Transform = matrixRotate;
}
}
public DockWindow CreateDockWindow(DockPanel dockPanel, DockState dockState)
{
return(new DefaultDockWindow(dockPanel, dockState));
}
private void DrawTab(Graphics g, AutoHideTabFromBase tab)
{
Rectangle rectTab = GetTabRectangle(tab);
if (rectTab.IsEmpty)
{
return;
}
DockState dockState = tab.Content.DockState;
DockContent content = tab.Content;
BeginDrawTab();
Pen penTabBorder = PenTabBorder;
Brush brushTabText = new SolidBrush(ColorMixer.AutoHideTabTextColor);
if (dockState == DockState.DockTopAutoHide || dockState == DockState.DockRightAutoHide)
{
DrawUtil.DrawTab(g, rectTab, Corners.RB, GradientType.Bell, ColorMixer.DarkColor, ColorMixer.LightColor, Color.Black, false);
}
else
{
DrawUtil.DrawTab(g, rectTab, Corners.RT, GradientType.Bell, ColorMixer.DarkColor, ColorMixer.LightColor, Color.Black, false);
}
// g.FillRectangle(new LinearGradientBrush(rectTab,ColorMixer.DarkColor,ColorMixer.LightColor,LinearGradientMode.Vertical)
// , 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;
EndDrawTab();
}
bool IDockDragSource.IsDockStateValid(DockState dockState)
{
return(IsDockStateValid(dockState));
}
public AutoHideState(DockState dockState)
{
m_dockState = dockState;
m_selected = false;
}
public int GetDockWindowSize(DockState dockState)
{
if (dockState == DockState.DockLeft || dockState == DockState.DockRight)
{
int width = ClientRectangle.Width - DockPadding.Left - DockPadding.Right;
int dockLeftSize = m_dockLeftPortion >= 1 ? (int)m_dockLeftPortion : (int)(width * m_dockLeftPortion);
int dockRightSize = m_dockRightPortion >= 1 ? (int)m_dockRightPortion : (int)(width * m_dockRightPortion);
if (dockLeftSize < MeasurePane.MinSize)
dockLeftSize = MeasurePane.MinSize;
if (dockRightSize < MeasurePane.MinSize)
dockRightSize = MeasurePane.MinSize;
if (dockLeftSize + dockRightSize > width - MeasurePane.MinSize)
{
int adjust = (dockLeftSize + dockRightSize) - (width - MeasurePane.MinSize);
dockLeftSize -= adjust / 2;
dockRightSize -= adjust / 2;
}
return dockState == DockState.DockLeft ? dockLeftSize : dockRightSize;
}
else if (dockState == DockState.DockTop || dockState == DockState.DockBottom)
{
int height = ClientRectangle.Height - DockPadding.Top - DockPadding.Bottom;
int dockTopSize = m_dockTopPortion >= 1 ? (int)m_dockTopPortion : (int)(height * m_dockTopPortion);
int dockBottomSize = m_dockBottomPortion >= 1 ? (int)m_dockBottomPortion : (int)(height * m_dockBottomPortion);
if (dockTopSize < MeasurePane.MinSize)
dockTopSize = MeasurePane.MinSize;
if (dockBottomSize < MeasurePane.MinSize)
dockBottomSize = MeasurePane.MinSize;
if (dockTopSize + dockBottomSize > height - MeasurePane.MinSize)
{
int adjust = (dockTopSize + dockBottomSize) - (height - MeasurePane.MinSize);
dockTopSize -= adjust / 2;
dockBottomSize -= adjust / 2;
}
return dockState == DockState.DockTop ? dockTopSize : dockBottomSize;
}
else
return 0;
}
private void DrawTab(Graphics g, TabVS2012Light tab)
{
Rectangle rectTabOrigin = GetTabRectangle(tab);
if (rectTabOrigin.IsEmpty)
{
return;
}
DockState dockState = tab.Content.DockHandler.DockState;
IDockContent content = tab.Content;
Color textColor;
if (tab.Content.DockHandler.IsActivated || tab.IsMouseOver)
{
textColor = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.StartColor;
}
else
{
textColor = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.EndColor;
}
Rectangle rectThickLine = rectTabOrigin;
rectThickLine.X += _TabGapLeft + _TextGapLeft + _ImageGapLeft + _ImageWidth;
rectThickLine.Width = TextRenderer.MeasureText(tab.Content.DockHandler.TabText, TextFont).Width - 8;
rectThickLine.Height = Measures.AutoHideTabLineWidth;
if (dockState == DockState.DockBottomAutoHide || dockState == DockState.DockLeftAutoHide)
{
rectThickLine.Y += rectTabOrigin.Height - Measures.AutoHideTabLineWidth;
}
else
if (dockState == DockState.DockTopAutoHide || dockState == DockState.DockRightAutoHide)
{
rectThickLine.Y += 0;
}
g.FillRectangle(new SolidBrush(textColor), rectThickLine);
//Set no rotate for drawing icon and text
Matrix matrixRotate = g.Transform;
g.Transform = MatrixIdentity;
// Draw the icon
Rectangle rectImage = rectTabOrigin;
rectImage.X += ImageGapLeft;
rectImage.Y += ImageGapTop;
int imageHeight = rectTabOrigin.Height - ImageGapTop - ImageGapBottom;
int imageWidth = ImageWidth;
if (imageHeight > ImageHeight)
{
imageWidth = ImageWidth * (imageHeight / ImageHeight);
}
rectImage.Height = imageHeight;
rectImage.Width = imageWidth;
rectImage = GetTransformedRectangle(dockState, rectImage);
if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
{
// The DockState is DockLeftAutoHide or DockRightAutoHide, so rotate the image 90 degrees to the right.
Rectangle rectTransform = RtlTransform(rectImage, dockState);
Point[] rotationPoints =
{
new Point(rectTransform.X + rectTransform.Width, rectTransform.Y),
new Point(rectTransform.X + rectTransform.Width, rectTransform.Y + rectTransform.Height),
new Point(rectTransform.X, rectTransform.Y)
};
using (Icon rotatedIcon = new Icon(((Form)content).Icon, 16, 16))
{
g.DrawImage(rotatedIcon.ToBitmap(), rotationPoints);
}
}
else
{
// Draw the icon normally without any rotation.
g.DrawIcon(((Form)content).Icon, RtlTransform(rectImage, dockState));
}
// Draw the text
Rectangle rectText = rectTabOrigin;
rectText.X += ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
rectText.Width -= ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
rectText = RtlTransform(GetTransformedRectangle(dockState, rectText), dockState);
if (DockPanel.ActiveContent == content || tab.IsMouseOver)
{
textColor = DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveTabGradient.TextColor;
}
else
{
textColor = DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveTabGradient.TextColor;
}
if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
{
g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabVertical);
}
else
{
g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabHorizontal);
}
// Set rotate back
g.Transform = matrixRotate;
}
public bool IsDockStateValid(DockState dockState)
{
return(Contents.All(content => content.DockHandler.IsDockStateValid(dockState)));
}
internal DefaultDockWindow(DockPanel dockPanel, DockState dockState) : base(dockPanel, dockState)
{
}
internal Rectangle GetTabStripRectangle(DockState dockState)
{
return AutoHideStripControl.GetTabStripRectangle(dockState);
}
protected internal DockPane(IDockContent content, DockState visibleState, bool show)
{
InternalConstruct(content, visibleState, false, Rectangle.Empty, null, DockAlignment.Right, 0.5, show);
}
