1357 lines
44 KiB
C#
1357 lines
44 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Data;
|
|
using System.Windows.Forms;
|
|
using System.Reflection;
|
|
|
|
namespace DevComponents.DotNetBar
|
|
{
|
|
/// <summary>
|
|
/// Summary description for TabControl.
|
|
/// </summary>
|
|
[ToolboxItem(true), Designer("DevComponents.DotNetBar.Design.TabControlDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf")]
|
|
public class TabControl : System.Windows.Forms.Control,ISupportInitialize
|
|
{
|
|
#region Events
|
|
/// <summary>
|
|
/// Occurs when selected tab changes.
|
|
/// </summary>
|
|
public event TabStrip.SelectedTabChangedEventHandler SelectedTabChanged;
|
|
/// <summary>
|
|
/// Occurs before selected tab changes and gives you opportunity to cancel the change.
|
|
/// </summary>
|
|
public event TabStrip.SelectedTabChangingEventHandler SelectedTabChanging;
|
|
/// <summary>
|
|
/// Occurs when tab is dragged by user.
|
|
/// </summary>
|
|
public event TabStrip.TabMovedEventHandler TabMoved;
|
|
/// <summary>
|
|
/// Occurs when the user navigates back using the back arrow.
|
|
/// </summary>
|
|
public event TabStrip.UserActionEventHandler NavigateBack;
|
|
/// <summary>
|
|
/// Occurs when the user navigates forward using the forward arrow.
|
|
/// </summary>
|
|
public event TabStrip.UserActionEventHandler NavigateForward;
|
|
/// <summary>
|
|
/// Occurs when tab item is closing.
|
|
/// </summary>
|
|
public event TabStrip.UserActionEventHandler TabItemClose;
|
|
/// <summary>
|
|
/// Occurs when tab item is added to the tabs collection.
|
|
/// </summary>
|
|
public event EventHandler TabItemOpen;
|
|
/// <summary>
|
|
/// Occurs before control or item attached to the tab is displayed.
|
|
/// </summary>
|
|
public event EventHandler BeforeTabDisplay;
|
|
/// <summary>
|
|
/// Occurs after tab item has been removed from tabs collection.
|
|
/// </summary>
|
|
public event EventHandler TabRemoved;
|
|
#endregion
|
|
|
|
#region Private Variables & Constructor, Dispose
|
|
private DevComponents.DotNetBar.TabStrip tabStrip1;
|
|
//private int m_SelectedTabIndex=0;
|
|
private System.Windows.Forms.Timer m_ClickTimer=null;
|
|
private bool m_AutoCloseTabs = false;
|
|
private bool m_TabStripVisible = true;
|
|
private int m_LoadSelectedTabIndex = -1;
|
|
private bool m_SyncingTabStripSize = false;
|
|
|
|
/// <summary>
|
|
/// Required designer variable.
|
|
/// </summary>
|
|
private System.ComponentModel.Container components = null;
|
|
|
|
public TabControl()
|
|
{
|
|
this.SetStyle(ControlStyles.Opaque,true);
|
|
this.SetStyle(DisplayHelp.DoubleBufferFlag,true);
|
|
this.SetStyle(ControlStyles.AllPaintingInWmPaint,true);
|
|
this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
|
|
|
|
// This call is required by the Windows.Forms Form Designer.
|
|
InitializeComponent();
|
|
//tabStrip1.VariableTabWidth=false;
|
|
tabStrip1.TabLayoutType=eTabLayoutType.FixedWithNavigationBox;
|
|
tabStrip1.SizeRecalculated+=new EventHandler(this.TabStripSizeRecalculated);
|
|
|
|
StyleManager.Register(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clean up any resources being used.
|
|
/// </summary>
|
|
protected override void Dispose( bool disposing )
|
|
{
|
|
if( disposing )
|
|
{
|
|
if(components != null)
|
|
{
|
|
components.Dispose();
|
|
}
|
|
StyleManager.Unregister(this);
|
|
}
|
|
base.Dispose( disposing );
|
|
}
|
|
#endregion
|
|
|
|
#region Component Designer generated code
|
|
/// <summary>
|
|
/// Required method for Designer support - do not modify
|
|
/// the contents of this method with the code editor.
|
|
/// </summary>
|
|
private void InitializeComponent()
|
|
{
|
|
this.tabStrip1 = new DevComponents.DotNetBar.TabStrip();
|
|
this.SuspendLayout();
|
|
//
|
|
// tabStrip1
|
|
//
|
|
this.tabStrip1.CanReorderTabs = true;
|
|
this.tabStrip1.CloseButtonVisible = true;
|
|
this.tabStrip1.Dock = System.Windows.Forms.DockStyle.Top;
|
|
this.tabStrip1.ImageList = null;
|
|
this.tabStrip1.Name = "tabStrip1";
|
|
this.tabStrip1.SelectedTab = null;
|
|
this.tabStrip1.Size = new System.Drawing.Size(256, 26);
|
|
this.tabStrip1.Style = DevComponents.DotNetBar.eTabStripStyle.OneNote;
|
|
this.tabStrip1.TabAlignment = DevComponents.DotNetBar.eTabStripAlignment.Top;
|
|
this.tabStrip1.TabIndex = 0;
|
|
this.tabStrip1.Text = "tabStrip1";
|
|
this.tabStrip1.AutoHideSystemBox=true;
|
|
this.tabStrip1.CloseButtonVisible=false;
|
|
this.tabStrip1.TabRemoved += new System.EventHandler(this.tabStrip1_TabRemoved);
|
|
this.tabStrip1.TabItemOpen += new EventHandler(tabStrip1_TabItemAdded);
|
|
this.tabStrip1.SelectedTabChanged += new DevComponents.DotNetBar.TabStrip.SelectedTabChangedEventHandler(this.tabStrip1_SelectedTabChanged);
|
|
this.tabStrip1.SelectedTabChanging += new DevComponents.DotNetBar.TabStrip.SelectedTabChangingEventHandler(this.tabStrip1_SelectedTabChanging);
|
|
this.tabStrip1.TabMoved+=new TabStrip.TabMovedEventHandler(this.tabStrip1_TabMoved);
|
|
this.tabStrip1.NavigateBack+=new TabStrip.UserActionEventHandler(this.tabStrip1_NavigateBack);
|
|
this.tabStrip1.NavigateForward+=new TabStrip.UserActionEventHandler(this.tabStrip1_NavigateForward);
|
|
this.tabStrip1.TabItemClose+=new TabStrip.UserActionEventHandler(this.tabStrip1_TabItemClose);
|
|
this.tabStrip1.TabItemOpen+=new EventHandler(this.tabStrip1_TabItemOpen);
|
|
this.tabStrip1.TabsCleared += new EventHandler(this.tabStrip1_TabsCleared);
|
|
this.tabStrip1.BeforeTabDisplay+=new EventHandler(this.tabStrip1_BeforeTabDisplay);
|
|
this.tabStrip1.TabStop=false;
|
|
//
|
|
// TabControl
|
|
//
|
|
this.Controls.AddRange(new System.Windows.Forms.Control[] {
|
|
this.tabStrip1});
|
|
this.Name = "TabControl";
|
|
this.Size = new System.Drawing.Size(256, 152);
|
|
this.ResumeLayout(false);
|
|
|
|
}
|
|
#endregion
|
|
|
|
#region Hidden Properties
|
|
/// <summary>
|
|
/// Gets or sets the background color.
|
|
/// </summary>
|
|
[Browsable(true),Description("Indicates the background color."),Category("Style")]
|
|
public override Color BackColor
|
|
{
|
|
get {return base.BackColor;}
|
|
set
|
|
{
|
|
base.BackColor=value;
|
|
if (tabStrip1 != null)
|
|
tabStrip1.BackColor = value;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Gets whether property should be serialized. Used by Windows Forms designer.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeBackColor()
|
|
{
|
|
return (BackColor != SystemColors.Control);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Internal Implementation
|
|
/// <summary>
|
|
/// Called by StyleManager to notify control that style on manager has changed and that control should refresh its appearance if
|
|
/// its style is controlled by StyleManager.
|
|
/// </summary>
|
|
/// <param name="newStyle">New active style.</param>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void StyleManagerStyleChanged(eDotNetBarStyle newStyle)
|
|
{
|
|
UpdateTabPanelStyle();
|
|
}
|
|
|
|
protected override void OnGotFocus(EventArgs e)
|
|
{
|
|
if (this.TabStripTabStop)
|
|
tabStrip1.Focus();
|
|
base.OnGotFocus(e);
|
|
}
|
|
#if FRAMEWORK20
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public virtual bool ValidateChildren()
|
|
{
|
|
return this.ValidateChildren(ValidationConstraints.Selectable);
|
|
}
|
|
|
|
[Browsable(false)]
|
|
public virtual bool ValidateChildren(ValidationConstraints validationConstraints)
|
|
{
|
|
if ((validationConstraints < ValidationConstraints.None) || (validationConstraints > (ValidationConstraints.ImmediateChildren | ValidationConstraints.TabStop | ValidationConstraints.Visible | ValidationConstraints.Enabled | ValidationConstraints.Selectable)))
|
|
{
|
|
throw new InvalidEnumArgumentException("validationConstraints", (int)validationConstraints, typeof(ValidationConstraints));
|
|
}
|
|
Type t = typeof(Control);
|
|
MethodInfo mi = t.GetMethod("PerformContainerValidation", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance);
|
|
if (mi != null)
|
|
{
|
|
bool b = (bool)mi.Invoke(this, new object[] { validationConstraints });
|
|
return !b;
|
|
}
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
/// <summary>
|
|
/// Gets the collection of all tabs.
|
|
/// </summary>
|
|
[Browsable(false), System.ComponentModel.Editor("DevComponents.DotNetBar.Design.TabStripTabsEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor)), DesignerSerializationVisibility(DesignerSerializationVisibility.Content), System.ComponentModel.Category("Data"), System.ComponentModel.Description("Returns the collection of Tabs.")]
|
|
public TabsCollection Tabs
|
|
{
|
|
get { return tabStrip1.Tabs; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether tabs are visible. Default value is true.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Appearance"), Description("Indicates whether tabs are visible")]
|
|
public bool TabsVisible
|
|
{
|
|
get { return m_TabStripVisible; }
|
|
set
|
|
{
|
|
m_TabStripVisible = value;
|
|
tabStrip1.Visible = value;
|
|
RefreshPanelsStyle();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns reference to internal tab strip control.
|
|
/// </summary>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public TabStrip TabStrip
|
|
{
|
|
get { return tabStrip1; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether TabStrip will get focus when Tab key is used. Default value is false.
|
|
/// </summary>
|
|
[DefaultValue(false), Category("Behavior"), Description("Gets or sets whether TabStrip will get focus when Tab key is used.")]
|
|
public bool TabStripTabStop
|
|
{
|
|
get { return tabStrip1.TabStop; }
|
|
set
|
|
{
|
|
tabStrip1.TabStop = value;
|
|
}
|
|
}
|
|
|
|
|
|
public void RecalcLayout()
|
|
{
|
|
tabStrip1.Refresh();
|
|
this.SyncTabStripSize();
|
|
}
|
|
|
|
|
|
private void tabStrip1_SelectedTabChanged(object sender, DevComponents.DotNetBar.TabStripTabChangedEventArgs e)
|
|
{
|
|
if(e.NewTab!=null && e.NewTab.AttachedControl!=null)
|
|
e.NewTab.AttachedControl.BringToFront();
|
|
|
|
InvokeSelectedTabChanged(e);
|
|
}
|
|
|
|
protected virtual void InvokeSelectedTabChanged(DevComponents.DotNetBar.TabStripTabChangedEventArgs e)
|
|
{
|
|
if(SelectedTabChanged!=null)
|
|
SelectedTabChanged(this,e);
|
|
}
|
|
|
|
private void tabStrip1_SelectedTabChanging(object sender, DevComponents.DotNetBar.TabStripTabChangingEventArgs e)
|
|
{
|
|
InvokeSelectedTabChanging(e);
|
|
}
|
|
|
|
protected virtual void InvokeSelectedTabChanging(DevComponents.DotNetBar.TabStripTabChangingEventArgs e)
|
|
{
|
|
if(SelectedTabChanging!=null)
|
|
SelectedTabChanging(this,e);
|
|
}
|
|
|
|
private void tabStrip1_TabMoved(object sender, TabStripTabMovedEventArgs e)
|
|
{
|
|
InvokeTabMoved(e);
|
|
}
|
|
|
|
protected virtual void InvokeTabMoved(TabStripTabMovedEventArgs e)
|
|
{
|
|
if(TabMoved!=null)
|
|
TabMoved(this,e);
|
|
}
|
|
|
|
private void tabStrip1_NavigateBack(object sender, TabStripActionEventArgs e)
|
|
{
|
|
InvokeNavigateBack(e);
|
|
}
|
|
|
|
protected virtual void InvokeNavigateBack(TabStripActionEventArgs e)
|
|
{
|
|
if(NavigateBack!=null)
|
|
NavigateBack(this,e);
|
|
}
|
|
|
|
private void tabStrip1_NavigateForward(object sender, TabStripActionEventArgs e)
|
|
{
|
|
InvokeNavigateForward(e);
|
|
}
|
|
|
|
protected virtual void InvokeNavigateForward(TabStripActionEventArgs e)
|
|
{
|
|
if(NavigateForward!=null)
|
|
NavigateForward(this,e);
|
|
}
|
|
|
|
private void tabStrip1_TabItemClose(object sender, TabStripActionEventArgs e)
|
|
{
|
|
InvokeTabItemClose(e);
|
|
|
|
if (!e.Cancel && m_AutoCloseTabs && !this.DesignMode)
|
|
{
|
|
TabItem tab = tabStrip1.SelectedTab;
|
|
if (tab != null)
|
|
{
|
|
tabStrip1.Tabs.Remove(tab);
|
|
Control c = tab.AttachedControl;
|
|
if (c != null)
|
|
{
|
|
if (this.Controls.Contains(c))
|
|
this.Controls.Remove(c);
|
|
c.Dispose();
|
|
}
|
|
}
|
|
this.RecalcLayout();
|
|
}
|
|
}
|
|
|
|
protected virtual void InvokeTabItemClose(TabStripActionEventArgs e)
|
|
{
|
|
if(TabItemClose!=null)
|
|
TabItemClose(this,e);
|
|
}
|
|
|
|
private void tabStrip1_TabItemOpen(object sender, EventArgs e)
|
|
{
|
|
InvokeTabItemOpen(e);
|
|
}
|
|
|
|
protected virtual void InvokeTabItemOpen(EventArgs e)
|
|
{
|
|
if(TabItemOpen!=null)
|
|
TabItemOpen(this,e);
|
|
}
|
|
|
|
private void tabStrip1_BeforeTabDisplay(object sender, EventArgs e)
|
|
{
|
|
InvokeBeforeTabDisplay(e);
|
|
}
|
|
|
|
protected virtual void InvokeBeforeTabDisplay(EventArgs e)
|
|
{
|
|
if(BeforeTabDisplay!=null)
|
|
BeforeTabDisplay(this,e);
|
|
}
|
|
|
|
protected override void OnControlAdded(ControlEventArgs e)
|
|
{
|
|
base.OnControlAdded(e);
|
|
|
|
if (this.DesignMode)
|
|
return;
|
|
TabControlPanel panel=e.Control as TabControlPanel;
|
|
if(panel==null)
|
|
return;
|
|
if(panel.TabItem!=null)
|
|
{
|
|
if(this.Tabs.Contains(panel.TabItem) && this.SelectedTab==panel.TabItem)
|
|
{
|
|
panel.Visible=true;
|
|
panel.BringToFront();
|
|
}
|
|
else
|
|
panel.Visible=false;
|
|
}
|
|
else
|
|
panel.Visible=false;
|
|
}
|
|
|
|
protected override void OnControlRemoved(ControlEventArgs e)
|
|
{
|
|
base.OnControlRemoved(e);
|
|
|
|
TabControlPanel panel=e.Control as TabControlPanel;
|
|
if(panel==null)
|
|
return;
|
|
if(panel.TabItem!=null)
|
|
{
|
|
if(this.Tabs.Contains(panel.TabItem))
|
|
this.Tabs.Remove(panel.TabItem);
|
|
}
|
|
}
|
|
|
|
// protected override void OnEnter(EventArgs e)
|
|
// {
|
|
// base.OnEnter(e);
|
|
// if(this.Controls.Count>0)
|
|
// {
|
|
// foreach(Control c in this.Controls)
|
|
// {
|
|
// if(c.Visible && c.Controls.Count>0)
|
|
// {
|
|
// this.SelectNextControl(c,true,true,true,true);
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
private void tabStrip1_TabRemoved(object sender, System.EventArgs e)
|
|
{
|
|
if(sender is TabItem)
|
|
{
|
|
TabItem tab=sender as TabItem;
|
|
if(tab.AttachedControl!=null && this.Controls.Contains(tab.AttachedControl))
|
|
{
|
|
this.Controls.Remove(tab.AttachedControl);
|
|
}
|
|
}
|
|
|
|
InvokeTabRemoved(e);
|
|
}
|
|
|
|
void tabStrip1_TabItemAdded(object sender, EventArgs e)
|
|
{
|
|
TabItem item = sender as TabItem;
|
|
if (!this.DesignMode && !m_Initializing && item!=null && item.AttachedControl!=null && !this.Controls.Contains(item.AttachedControl))
|
|
{
|
|
this.Controls.Add(item.AttachedControl);
|
|
}
|
|
}
|
|
|
|
protected virtual void InvokeTabRemoved(EventArgs e)
|
|
{
|
|
if(TabRemoved!=null)
|
|
TabRemoved(this,e);
|
|
}
|
|
|
|
private void tabStrip1_TabsCleared(object sender, EventArgs e)
|
|
{
|
|
if (this.DesignMode) return;
|
|
Control[] cs = new Control[this.Controls.Count];
|
|
this.Controls.CopyTo(cs, 0);
|
|
foreach (Control c in cs)
|
|
{
|
|
if (c is TabControlPanel)
|
|
{
|
|
this.Controls.Remove(c);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnPaint(PaintEventArgs e)
|
|
{
|
|
base.OnPaint(e);
|
|
|
|
if (this.BackColor == Color.Transparent || this.ColorScheme.TabBackground == Color.Transparent)
|
|
{
|
|
base.OnPaintBackground(e);
|
|
}
|
|
|
|
if(this.Controls.Count<=1)
|
|
{
|
|
using(SolidBrush brush=new SolidBrush(SystemColors.Control))
|
|
e.Graphics.FillRectangle(brush,this.DisplayRectangle);
|
|
}
|
|
}
|
|
|
|
protected override void OnResize(EventArgs e)
|
|
{
|
|
base.OnResize(e);
|
|
|
|
if (this.Width == 0 || this.Height == 0)
|
|
return;
|
|
|
|
if(tabStrip1.IsMultiLine)
|
|
{
|
|
CreateSyncSizeTimer();
|
|
}
|
|
}
|
|
|
|
private void CreateSyncSizeTimer()
|
|
{
|
|
if(m_ClickTimer!=null)
|
|
return;
|
|
m_ClickTimer=new Timer();
|
|
m_ClickTimer.Interval=10;
|
|
m_ClickTimer.Tick+=new EventHandler(this.SyncSizeTimerTick);
|
|
m_ClickTimer.Enabled=true;
|
|
m_ClickTimer.Start();
|
|
}
|
|
private void SyncSizeTimerTick(object sender, EventArgs e)
|
|
{
|
|
m_ClickTimer.Stop();
|
|
m_ClickTimer.Enabled=false;
|
|
m_ClickTimer=null;
|
|
try
|
|
{
|
|
this.PerformLayout();
|
|
}
|
|
catch{}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Applies default tab colors to the panel
|
|
/// </summary>
|
|
/// <param name="panel">Panel to apply colors to.</param>
|
|
public void ApplyDefaultPanelStyle(TabControlPanel panel)
|
|
{
|
|
if(panel==null || panel.UseCustomStyle)
|
|
return;
|
|
|
|
if(panel.TabItem!=null && !panel.TabItem.BackColor.IsEmpty)
|
|
{
|
|
if(!panel.TabItem.BackColor2.IsEmpty)
|
|
{
|
|
panel.Style.BackColor1.Color=panel.TabItem.BackColor;
|
|
panel.Style.BackColor2.Color=panel.TabItem.BackColor2;
|
|
switch(tabStrip1.TabAlignment)
|
|
{
|
|
case eTabStripAlignment.Top:
|
|
panel.Style.GradientAngle=panel.TabItem.BackColorGradientAngle-180;
|
|
break;
|
|
case eTabStripAlignment.Bottom:
|
|
panel.Style.GradientAngle=panel.TabItem.BackColorGradientAngle;
|
|
break;
|
|
case eTabStripAlignment.Left:
|
|
panel.Style.GradientAngle=panel.TabItem.BackColorGradientAngle-90;
|
|
break;
|
|
case eTabStripAlignment.Right:
|
|
panel.Style.GradientAngle=panel.TabItem.BackColorGradientAngle+90;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
panel.Style.BackColor1.Color=tabStrip1.ColorScheme.TabPanelBackground;
|
|
panel.Style.BackColor2.Color=tabStrip1.ColorScheme.TabPanelBackground2;
|
|
|
|
switch(tabStrip1.TabAlignment)
|
|
{
|
|
case eTabStripAlignment.Top:
|
|
{
|
|
panel.Style.GradientAngle=tabStrip1.ColorScheme.TabPanelBackgroundGradientAngle;
|
|
break;
|
|
}
|
|
case eTabStripAlignment.Bottom:
|
|
{
|
|
panel.Style.GradientAngle=tabStrip1.ColorScheme.TabPanelBackgroundGradientAngle-180;
|
|
break;
|
|
}
|
|
case eTabStripAlignment.Left:
|
|
{
|
|
panel.Style.GradientAngle=tabStrip1.ColorScheme.TabPanelBackgroundGradientAngle-90;
|
|
break;
|
|
}
|
|
case eTabStripAlignment.Right:
|
|
{
|
|
panel.Style.GradientAngle=tabStrip1.ColorScheme.TabPanelBackgroundGradientAngle+90;
|
|
break;
|
|
}
|
|
}
|
|
panel.Style.BorderColor.Color=tabStrip1.ColorScheme.TabPanelBorder;
|
|
|
|
}
|
|
|
|
panel.Style.Border=eBorderType.SingleLine;
|
|
|
|
if (m_TabStripVisible)
|
|
{
|
|
switch (tabStrip1.TabAlignment)
|
|
{
|
|
case eTabStripAlignment.Top:
|
|
panel.Style.BorderSide = (eBorderSide.Left | eBorderSide.Right | eBorderSide.Bottom);
|
|
break;
|
|
case eTabStripAlignment.Bottom:
|
|
panel.Style.BorderSide = (eBorderSide.Left | eBorderSide.Right | eBorderSide.Top);
|
|
break;
|
|
case eTabStripAlignment.Left:
|
|
panel.Style.BorderSide = (eBorderSide.Top | eBorderSide.Right | eBorderSide.Bottom);
|
|
break;
|
|
case eTabStripAlignment.Right:
|
|
panel.Style.BorderSide = (eBorderSide.Left | eBorderSide.Top | eBorderSide.Bottom);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
panel.Style.BorderSide = eBorderSide.All;
|
|
|
|
|
|
if(tabStrip1.IsThemed)
|
|
panel.DrawThemedPane=true;
|
|
else
|
|
panel.DrawThemedPane=false;
|
|
}
|
|
|
|
private void UpdateTabPanelStyle()
|
|
{
|
|
foreach (Control c in this.Controls)
|
|
{
|
|
if (c is TabControlPanel)
|
|
{
|
|
TabControlPanel panel = c as TabControlPanel;
|
|
ApplyDefaultPanelStyle(panel);
|
|
}
|
|
}
|
|
}
|
|
protected override void OnSystemColorsChanged(EventArgs e)
|
|
{
|
|
base.OnSystemColorsChanged(e);
|
|
Application.DoEvents();
|
|
UpdateTabPanelStyle();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resumes normal layout logic. Optionally forces an immediate layout of pending layout requests.
|
|
/// </summary>
|
|
public new void ResumeLayout(bool performLayout)
|
|
{
|
|
base.ResumeLayout(performLayout);
|
|
if (!this.IsHandleCreated)
|
|
{
|
|
m_DelayedSync = true;
|
|
}
|
|
else
|
|
{
|
|
tabStrip1.ResetTabHeight();
|
|
SyncTabStripSize();
|
|
}
|
|
}
|
|
private bool m_DelayedSync = false;
|
|
protected override void OnHandleCreated(EventArgs e)
|
|
{
|
|
if (m_DelayedSync || this.DesignMode)
|
|
{
|
|
m_DelayedSync = false;
|
|
tabStrip1.ResetTabHeight();
|
|
SyncTabStripSize();
|
|
|
|
if (this.DesignMode) // There is bug in VS2010 designer where tab alignment is not updated we need to remedy that
|
|
{
|
|
InvokeDelayed(new MethodInvoker(delegate { this.PerformLayout(); }));
|
|
}
|
|
}
|
|
|
|
base.OnHandleCreated(e);
|
|
}
|
|
|
|
private void RefreshPanelsStyle()
|
|
{
|
|
if (m_Initializing) return;
|
|
foreach(Control c in this.Controls)
|
|
{
|
|
if(c is TabControlPanel)
|
|
ApplyDefaultPanelStyle(c as TabControlPanel);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Use TabControlPanel.Style property to set the background image for each tab panel.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false),System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
|
public override Image BackgroundImage
|
|
{
|
|
get{return base.BackgroundImage;}
|
|
set{base.BackgroundImage=value;}
|
|
}
|
|
|
|
private void TabStripSizeRecalculated(object sender, EventArgs e)
|
|
{
|
|
//if (tabStrip1.IsMultiLine)
|
|
SyncTabStripSize();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resizes the portion of the control that holds the tabs.
|
|
/// </summary>
|
|
public void SyncTabStripSize()
|
|
{
|
|
if (m_SyncingTabStripSize)
|
|
return;
|
|
m_SyncingTabStripSize = true;
|
|
try
|
|
{
|
|
switch (tabStrip1.Dock)
|
|
{
|
|
case DockStyle.Left:
|
|
case DockStyle.Right:
|
|
tabStrip1.Width = tabStrip1.MinTabStripHeight;
|
|
break;
|
|
default:
|
|
tabStrip1.Height = tabStrip1.MinTabStripHeight;
|
|
break;
|
|
}
|
|
//this.PerformLayout();
|
|
tabStrip1.SendToBack();
|
|
}
|
|
finally
|
|
{
|
|
m_SyncingTabStripSize = false;
|
|
}
|
|
//this.ResumeLayout();
|
|
}
|
|
private void InvokeDelayed(MethodInvoker method)
|
|
{
|
|
Timer delayedInvokeTimer = new Timer();
|
|
delayedInvokeTimer = new Timer();
|
|
delayedInvokeTimer.Tag = method;
|
|
delayedInvokeTimer.Interval = 10;
|
|
delayedInvokeTimer.Tick += new EventHandler(DelayedInvokeTimerTick);
|
|
delayedInvokeTimer.Start();
|
|
}
|
|
void DelayedInvokeTimerTick(object sender, EventArgs e)
|
|
{
|
|
Timer timer = (Timer)sender;
|
|
MethodInvoker method = (MethodInvoker)timer.Tag;
|
|
timer.Stop();
|
|
timer.Dispose();
|
|
method.Invoke();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates new tab and tab panel and adds it to the Tabs collection.
|
|
/// </summary>
|
|
/// <param name="tabText">Tab text.</param>
|
|
/// <returns>Reference to newly created TabItem.</returns>
|
|
public TabItem CreateTab(string tabText)
|
|
{
|
|
return CreateTab(tabText, -1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates new tab and tab panel and inserts it at specified position inside of Tabs collection.
|
|
/// </summary>
|
|
/// <param name="tabText">Tab text.</param>
|
|
/// <param name="insertAt">Index to insert newly created tab at. -1 will append tab to the end of Tabs collection.</param>
|
|
/// <returns>Reference to newly created TabItem.</returns>
|
|
public TabItem CreateTab(string tabText, int insertAt)
|
|
{
|
|
TabItem tab = new TabItem();
|
|
tab.Text = tabText;
|
|
TabControlPanel panel = new TabControlPanel();
|
|
this.ApplyDefaultPanelStyle(panel);
|
|
tab.AttachedControl = panel;
|
|
panel.TabItem = tab;
|
|
|
|
if (insertAt < 0 || insertAt >= tabStrip1.Tabs.Count)
|
|
{
|
|
tabStrip1.Tabs.Add(tab);
|
|
this.Controls.Add(panel);
|
|
}
|
|
else
|
|
{
|
|
tabStrip1.Tabs.Insert(insertAt, tab);
|
|
this.Controls.Add(panel);
|
|
}
|
|
|
|
panel.Dock = DockStyle.Fill;
|
|
panel.SendToBack();
|
|
|
|
this.RecalcLayout();
|
|
|
|
return tab;
|
|
}
|
|
|
|
protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
|
|
{
|
|
if (_ControlTabNavigationEnabled)
|
|
{
|
|
if (keyData == (Keys.Tab | Keys.Control))
|
|
{
|
|
tabStrip1.SelectNextTab(eEventSource.Keyboard, true);
|
|
return true;
|
|
}
|
|
else if (keyData == (Keys.Tab | Keys.Control | Keys.Shift))
|
|
{
|
|
tabStrip1.SelectPreviousTab(eEventSource.Keyboard, true);
|
|
return true;
|
|
}
|
|
}
|
|
return base.ProcessCmdKey(ref msg, keyData);
|
|
}
|
|
|
|
private bool _ControlTabNavigationEnabled = true;
|
|
/// <summary>
|
|
/// Gets or sets whether pressing Ctrl+Tab keys will cycle through the selected tabs. Default value is true.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Behavior"), Description("Indicates whether pressing Ctrl+Tab keys will cycle through the selected tabs.")]
|
|
public bool ControlTabNavigationEnabled
|
|
{
|
|
get { return _ControlTabNavigationEnabled; }
|
|
set
|
|
{
|
|
_ControlTabNavigationEnabled = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ISupportInitialize
|
|
private bool m_Initializing=false;
|
|
void ISupportInitialize.BeginInit()
|
|
{
|
|
m_Initializing = true;
|
|
}
|
|
void ISupportInitialize.EndInit()
|
|
{
|
|
m_Initializing = false;
|
|
// Apply default panel style
|
|
RefreshPanelsStyle();
|
|
if(m_LoadSelectedTabIndex>=0)
|
|
tabStrip1.SelectedTabIndex = m_LoadSelectedTabIndex;
|
|
m_LoadSelectedTabIndex = -1;
|
|
if(tabStrip1.SelectedTab!=null && tabStrip1.SelectedTab.AttachedControl!=null)
|
|
{
|
|
//if(!this.DesignMode)
|
|
tabStrip1.SelectedTab.AttachedControl.Visible=true;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Properties
|
|
/// <summary>
|
|
/// Gets or sets whether tabs use anti-alias smoothing when painted. Default value is false.
|
|
/// </summary>
|
|
[DefaultValue(false), Browsable(true), Category("Appearance"), Description("Gets or sets whether tabs use anti-aliasing when painted.")]
|
|
public bool AntiAlias
|
|
{
|
|
get { return tabStrip1.AntiAlias; }
|
|
set
|
|
{
|
|
tabStrip1.AntiAlias = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether the tab scrolling is animated.
|
|
/// </summary>
|
|
[Browsable(true),DevCoBrowsable(true),Description("Indicates whether the tab scrolling is animanted."),Category("Behavior"),DefaultValue(true)]
|
|
public bool Animate
|
|
{
|
|
get{return tabStrip1.Animate;}
|
|
set {tabStrip1.Animate=value;}
|
|
}
|
|
/// <summary>
|
|
/// Gets or sets whether system box that enables scrolling and closing of the tabs is automatically hidden when tab items size does not exceed the size of the control.
|
|
/// </summary>
|
|
[Browsable(true),DefaultValue(true),Category("Behavior"),Description("Indicates whether system box that enables scrolling and closing of the tabs is automatically hidden when tab items size does not exceed the size of the control.")]
|
|
public bool AutoHideSystemBox
|
|
{
|
|
get {return tabStrip1.AutoHideSystemBox;}
|
|
set
|
|
{
|
|
tabStrip1.AutoHideSystemBox=value;
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Specifes whether end-user can reorder the tabs.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(true),DevCoBrowsable(true),System.ComponentModel.Category("Behavior"),System.ComponentModel.Description("Specifes whether end-user can reorder the tabs.")]
|
|
public bool CanReorderTabs
|
|
{
|
|
get
|
|
{
|
|
return tabStrip1.CanReorderTabs;
|
|
}
|
|
set
|
|
{
|
|
tabStrip1.CanReorderTabs=value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether tab is automatically closed when close button is clicked. Closing the tab will remove tab being closed from Tabs collection
|
|
/// and it will remove the panel as well. Default value is false which means that tab will not be closed and you should handle TabClose event to
|
|
/// perform desired action as result of user closing the tab.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(false), Category("Close Button"), Description("Indicates whether tab is automatically closed when close button is clicked.")]
|
|
public bool AutoCloseTabs
|
|
{
|
|
get { return m_AutoCloseTabs; }
|
|
set { m_AutoCloseTabs = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether the Close button that closes the active tab is visible on system box.
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), Category("Close Button"), Description("Indicates whether the Close button that closes the active tab is visible."), DefaultValue(false)]
|
|
public bool CloseButtonVisible
|
|
{
|
|
get
|
|
{
|
|
return tabStrip1.CloseButtonVisible;
|
|
}
|
|
set
|
|
{
|
|
tabStrip1.CloseButtonVisible=value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether close button is visible on each tab instead of in system box.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(false), DevCoBrowsable(true), Category("Close Button"), Description("Indicates whether close button is visible on each tab instead of in system box.")]
|
|
public bool CloseButtonOnTabsVisible
|
|
{
|
|
get
|
|
{
|
|
return tabStrip1.CloseButtonOnTabsVisible;
|
|
}
|
|
set
|
|
{
|
|
tabStrip1.CloseButtonOnTabsVisible = value;
|
|
this.Refresh();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether close button on tabs when visible is displayed for every tab state. Default value is true. When set to false
|
|
/// the close button will be displayed only for selected and tab that mouse is currently over.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(true), DevCoBrowsable(true), Category("Close Button"), Description("Indicates whether close button on tabs when visible is displayed for every tab state.")]
|
|
public bool CloseButtonOnTabsAlwaysDisplayed
|
|
{
|
|
get
|
|
{
|
|
return tabStrip1.CloseButtonOnTabsAlwaysDisplayed;
|
|
}
|
|
set
|
|
{
|
|
tabStrip1.CloseButtonOnTabsAlwaysDisplayed = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the position of the close button displayed on each tab. Default value is Left.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(eTabCloseButtonPosition.Left), DevCoBrowsable(true), Category("Close Button"), Description("Indicates position of the close button displayed on each tab.")]
|
|
public eTabCloseButtonPosition CloseButtonPosition
|
|
{
|
|
get { return tabStrip1.CloseButtonPosition; }
|
|
set
|
|
{
|
|
tabStrip1.CloseButtonPosition = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Gets or sets custom image that is used on tabs as Close button that allows user to close the tab.
|
|
/// Use TabCloseButtonHot property to specify image that is used when mouse is over the close button. Note that image size must
|
|
/// be same for both images.
|
|
/// Default value is null
|
|
/// which means that internal representation of close button is used.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(null), Category("Close Button"), Description("Indicates custom image that is used on tabs as Close button that allows user to close the tab.")]
|
|
public Image TabCloseButtonNormal
|
|
{
|
|
get { return tabStrip1.TabCloseButtonNormal; }
|
|
set {tabStrip1.TabCloseButtonNormal = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets custom image that is used on tabs as Close button whem mouse is over the close button.
|
|
/// To use this property you must set TabCloseButtonNormal as well. Note that image size for both images must be same.
|
|
/// Default value is null which means that internal representation of close button is used.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(null), Category("Close Button"), Description("Indicates custom image that is used on tabs as Close button whem mouse is over the close button.")]
|
|
public Image TabCloseButtonHot
|
|
{
|
|
get { return tabStrip1.TabCloseButtonHot; }
|
|
set {tabStrip1.TabCloseButtonHot = value;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether only selected tab is displaying it's text.
|
|
/// </summary>
|
|
[Browsable(true),DevCoBrowsable(true),Category("Behavior"),Description("Specifes whether only selected tab is displaying it's text."),DefaultValue(false)]
|
|
public bool DisplaySelectedTextOnly
|
|
{
|
|
get {return tabStrip1.DisplaySelectedTextOnly;}
|
|
set
|
|
{
|
|
tabStrip1.DisplaySelectedTextOnly=value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the image list used by tab items.
|
|
/// </summary>
|
|
[Browsable(true),DevCoBrowsable(true),Category("Appearance"),DefaultValue(null)]
|
|
public System.Windows.Forms.ImageList ImageList
|
|
{
|
|
get
|
|
{
|
|
return tabStrip1.ImageList;
|
|
}
|
|
set
|
|
{
|
|
tabStrip1.ImageList=value;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Gets or sets scrolling offset of the first tab. You can use this property to programmatically scroll the tab strip.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(false),DefaultValue(0),DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public int ScrollOffset
|
|
{
|
|
get {return tabStrip1.ScrollOffset;}
|
|
set {tabStrip1.ScrollOffset=value;}
|
|
}
|
|
/// <summary>
|
|
/// Selects previous visible tab. Returns true if previous tab was found for selection.
|
|
/// </summary>
|
|
public bool SelectPreviousTab()
|
|
{
|
|
return tabStrip1.SelectPreviousTab();
|
|
}
|
|
/// <summary>
|
|
/// Selects next visible tab. Returns true if next tab was found for selection.
|
|
/// </summary>
|
|
public bool SelectNextTab()
|
|
{
|
|
return tabStrip1.SelectNextTab();
|
|
}
|
|
/// <summary>
|
|
/// Gets or sets Tab Control style. Theme style is supported only on themed OS and only for bottom or top aligned tabs.
|
|
/// </summary>
|
|
[Browsable(true),DevCoBrowsable(true),Category("Appearance"),Description("Specifies the Tab Control style."),DefaultValue(eTabStripStyle.OneNote)]
|
|
public eTabStripStyle Style
|
|
{
|
|
get
|
|
{
|
|
return tabStrip1.Style;
|
|
}
|
|
set
|
|
{
|
|
tabStrip1.Style=value;
|
|
this.SyncTabStripSize();
|
|
this.RefreshPanelsStyle();
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
|
|
protected override void OnParentChanged(EventArgs e)
|
|
{
|
|
if (this.Style == eTabStripStyle.Office2007Dock || this.Style == eTabStripStyle.Office2007Document)
|
|
{
|
|
tabStrip1.Style = this.Style;
|
|
this.RefreshPanelsStyle();
|
|
}
|
|
base.OnParentChanged(e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies whether tab is drawn using Themes when running on OS that supports themes like Windows XP.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(true),DevCoBrowsable(true),System.ComponentModel.DefaultValue(false),System.ComponentModel.Category("Appearance"),System.ComponentModel.Description("Specifies whether tab is drawn using Themes when running on OS that supports themes like Windows XP.")]
|
|
public virtual bool ThemeAware
|
|
{
|
|
get
|
|
{
|
|
return tabStrip1.ThemeAware;
|
|
}
|
|
set
|
|
{
|
|
tabStrip1.ThemeAware=value;
|
|
this.RefreshPanelsStyle();
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether tabs are scrolled continuously while mouse is pressed over the scroll tab button.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(true),DevCoBrowsable(true),System.ComponentModel.DefaultValue(false),System.ComponentModel.Category("Behavior"),System.ComponentModel.Description("Indicates whether tabs are scrolled continuously while mouse is pressed over the scroll tab button.")]
|
|
public virtual bool TabScrollAutoRepeat
|
|
{
|
|
get
|
|
{
|
|
return tabStrip1.TabScrollAutoRepeat;
|
|
}
|
|
set
|
|
{
|
|
tabStrip1.TabScrollAutoRepeat=value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the auto-repeat interval for the tab scrolling while mouse button is kept pressed over the scroll tab button.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(true),DevCoBrowsable(true),System.ComponentModel.DefaultValue(300),System.ComponentModel.Category("Behavior"),System.ComponentModel.Description("Indicates auto-repeat interval for the tab scrolling while mouse button is kept pressed over the scroll tab button.")]
|
|
public virtual int TabScrollRepeatInterval
|
|
{
|
|
get
|
|
{
|
|
return tabStrip1.TabScrollRepeatInterval;
|
|
}
|
|
set
|
|
{
|
|
tabStrip1.TabScrollRepeatInterval=value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets Tab Color Scheme.
|
|
/// </summary>
|
|
[Browsable(true),DevCoBrowsable(true),Category("Style"),Description("Gets or sets Tab Color Scheme."),DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public TabColorScheme ColorScheme
|
|
{
|
|
get {return tabStrip1.ColorScheme;}
|
|
set
|
|
{
|
|
tabStrip1.ColorScheme=value;
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
[Browsable(false),EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeColorScheme()
|
|
{
|
|
return tabStrip1.ColorScheme.SchemeChanged;
|
|
}
|
|
/// <summary>
|
|
/// Resets color scheme to default value.
|
|
/// </summary>
|
|
public void ResetColorScheme()
|
|
{
|
|
tabStrip1.ResetColorScheme();
|
|
if(this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the tab alignment within the Tab-Strip control.
|
|
/// </summary>
|
|
[DefaultValue(eTabStripAlignment.Top),Browsable(true),DevCoBrowsable(true),Category("Appearance"),Description("Indicates the tab alignment within the Tab-Strip control.")]
|
|
public eTabStripAlignment TabAlignment
|
|
{
|
|
get {return tabStrip1.TabAlignment;}
|
|
set
|
|
{
|
|
if(tabStrip1.TabAlignment==value)
|
|
return;
|
|
this.SuspendLayout();
|
|
try
|
|
{
|
|
switch(value)
|
|
{
|
|
case eTabStripAlignment.Top:
|
|
tabStrip1.Dock=DockStyle.Top;
|
|
break;
|
|
case eTabStripAlignment.Bottom:
|
|
tabStrip1.Dock=DockStyle.Bottom;
|
|
break;
|
|
case eTabStripAlignment.Left:
|
|
tabStrip1.Dock=DockStyle.Left;
|
|
break;
|
|
case eTabStripAlignment.Right:
|
|
tabStrip1.Dock=DockStyle.Right;
|
|
break;
|
|
}
|
|
tabStrip1.TabAlignment=value;
|
|
RefreshPanelsStyle();
|
|
}
|
|
finally
|
|
{
|
|
this.ResumeLayout(true);
|
|
}
|
|
if (this.Visible)
|
|
SyncTabStripSize();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the selected tab.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(false),Category("Behavior"),Description("Indicates selected tab."),DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public TabItem SelectedTab
|
|
{
|
|
get
|
|
{
|
|
return tabStrip1.SelectedTab;
|
|
}
|
|
set
|
|
{
|
|
tabStrip1.SelectedTab=value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the selected tab Font
|
|
/// </summary>
|
|
[Browsable(true),DevCoBrowsable(true),Category("Style"),DefaultValue(null),Description("Gets or sets the selected tab Font")]
|
|
public System.Drawing.Font SelectedTabFont
|
|
{
|
|
get
|
|
{
|
|
return tabStrip1.SelectedTabFont;
|
|
}
|
|
set
|
|
{
|
|
tabStrip1.SelectedTabFont=value;
|
|
}
|
|
}
|
|
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
|
public void ResetSelectedTabFont()
|
|
{
|
|
tabStrip1.ResetSelectedTabFont();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether focus rectangle is displayed on the tab when tab has input focus.
|
|
/// </summary>
|
|
[Browsable(true),DefaultValue(true),Category("Behavior"),Description("Indicates whether focus rectangle is displayed on the tab when tab has input focus.")]
|
|
public bool ShowFocusRectangle
|
|
{
|
|
get {return tabStrip1.ShowFocusRectangle;}
|
|
set {tabStrip1.ShowFocusRectangle=value;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether keyboard navigation using Left and Right arrow keys to select tabs is enabled. Default value is true.
|
|
/// </summary>
|
|
[Category("Behavior"), DefaultValue(true), Description("Indicates whether keyboard navigation using Left and Right arrow keys to select tabs is enabled.")]
|
|
public bool KeyboardNavigationEnabled
|
|
{
|
|
get { return tabStrip1.KeyboardNavigationEnabled; }
|
|
set
|
|
{
|
|
tabStrip1.KeyboardNavigationEnabled = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the index of the selected tab.
|
|
/// </summary>
|
|
[Browsable(true),DevCoBrowsable(true),Category("Behavior"),Description("Indicates the index of selected tab.")]
|
|
public int SelectedTabIndex
|
|
{
|
|
get { return tabStrip1.SelectedTabIndex; }
|
|
set
|
|
{
|
|
if (m_Initializing)
|
|
m_LoadSelectedTabIndex = value;
|
|
else
|
|
tabStrip1.SelectedTabIndex = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets selected tab panel.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(false),DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public TabControlPanel SelectedPanel
|
|
{
|
|
get
|
|
{
|
|
if(tabStrip1.SelectedTab!=null)
|
|
return tabStrip1.SelectedTab.AttachedControl as TabControlPanel;
|
|
return null;
|
|
}
|
|
set
|
|
{
|
|
if(value!=null && this.Controls.Contains(value) && value.TabItem!=null && this.Tabs.Contains(value.TabItem))
|
|
{
|
|
tabStrip1.SelectedTab=value.TabItem;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the type of the tab layout.
|
|
/// </summary>
|
|
[Browsable(true),DefaultValue(eTabLayoutType.FitContainer),Category("Appearance"),Description("Indicates the type of the tab layout.")]
|
|
public eTabLayoutType TabLayoutType
|
|
{
|
|
get {return tabStrip1.TabLayoutType;}
|
|
set {tabStrip1.TabLayoutType=value;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates whether selected tab is aligned with the panel in multiple lines use case.
|
|
/// </summary>
|
|
[Browsable(true), Category("Appearance"), DefaultValue(true), Description("Indicates whether selected tab is aligned with the panel in multiple lines use case.")]
|
|
public bool MultiLinePanelAlignSelectedTab
|
|
{
|
|
get { return tabStrip1.MultiLinePanelAlignSelectedTab; }
|
|
set { tabStrip1.MultiLinePanelAlignSelectedTab = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the fixed tab size in pixels. Either Height or Width can be set or both.
|
|
/// Value of 0 indicates that size is automatically calculated which is
|
|
/// default behavior.
|
|
/// </summary>
|
|
[Browsable(true), Category("Appearance"), Description("Gets or sets the fixed tab size in pixels. Either Height or Width can be set or both.")]
|
|
public Size FixedTabSize
|
|
{
|
|
get { return tabStrip1.FixedTabSize; }
|
|
set
|
|
{
|
|
tabStrip1.FixedTabSize = value;
|
|
this.RecalcLayout();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Memeber used by Windows Forms designer.
|
|
/// </summary>
|
|
/// <returns>true if property should be serialized.</returns>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeFixedTabSize()
|
|
{
|
|
return tabStrip1.ShouldSerializeFixedTabSize();
|
|
}
|
|
/// <summary>
|
|
/// Memeber used by Windows Forms designer to reset property to default value.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetFixedTabSize()
|
|
{
|
|
TypeDescriptor.GetProperties(this)["FixedTabSize"].SetValue(this, Size.Empty);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|