2445 lines
66 KiB
C#
2445 lines
66 KiB
C#
#if FRAMEWORK20
|
|
using System;
|
|
using System.ComponentModel;
|
|
using System.Drawing.Design;
|
|
using System.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Windows.Forms;
|
|
using DevComponents.DotNetBar.Rendering;
|
|
|
|
namespace DevComponents.DotNetBar
|
|
{
|
|
[Designer("DevComponents.DotNetBar.Design.SuperTabItemDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf")]
|
|
public class SuperTabItem : BaseItem
|
|
{
|
|
#region Events
|
|
|
|
/// <summary>
|
|
/// Occurs when text markup link is clicked
|
|
/// </summary>
|
|
[Description("Occurs when text markup link is clicked.")]
|
|
public event MarkupLinkClickEventHandler MarkupLinkClick;
|
|
|
|
/// <summary>
|
|
/// Occurs when the tab colors have changed
|
|
/// </summary>
|
|
[Description("Occurs when the tab colors have changed.")]
|
|
public event EventHandler<EventArgs> TabColorChanged;
|
|
|
|
#endregion
|
|
|
|
#region Private variables
|
|
|
|
private Icon _Icon;
|
|
private Image _Image;
|
|
private int _ImageIndex = -1;
|
|
private Rectangle _ImageBounds;
|
|
|
|
private eTabItemColor _PredefinedColor = eTabItemColor.Default;
|
|
private SuperTabItemColorTable _TabColor = new SuperTabItemColorTable();
|
|
|
|
private bool _EnableMarkup = true;
|
|
private eItemAlignment? _TextAlignment;
|
|
private Rectangle _TextBounds;
|
|
|
|
private Font _TabFont;
|
|
private Font _SelectedTabFont;
|
|
private Font _SizingFont;
|
|
|
|
private bool _CloseButtonVisible = true;
|
|
private bool _CloseButtonMouseOver;
|
|
private bool _CloseButtonPressed;
|
|
private Rectangle _CloseButtonBounds;
|
|
|
|
private SuperTabStripItem _TabStripItem;
|
|
private Control _AttachedControl;
|
|
|
|
private SuperTabItemBaseDisplay _TabItemDisplay;
|
|
|
|
private Font _DefaultSelectedTabFont;
|
|
private bool _EnableImageAnimation;
|
|
private bool _CanAnimateImage;
|
|
|
|
private ImageAlignment _ImageAlignment = ImageAlignment.NotSet;
|
|
private Padding _ImagePadding;
|
|
|
|
private Size _FixedTabSize = Size.Empty;
|
|
|
|
private Color _SymbolColor = Color.Empty;
|
|
private string _Symbol = "";
|
|
private float _SymbolSize = 0f;
|
|
|
|
private bool _StartsNewTabLine;
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Constructor
|
|
/// </summary>
|
|
public SuperTabItem()
|
|
{
|
|
Visible = true;
|
|
GlobalItem = false;
|
|
Stretch = false;
|
|
Displayed = true;
|
|
|
|
HookEvents(true);
|
|
}
|
|
|
|
#region Protected properties
|
|
|
|
#region IsMarkupSupported
|
|
|
|
/// <summary>
|
|
/// IsMarkupSupported
|
|
/// </summary>
|
|
protected override bool IsMarkupSupported
|
|
{
|
|
get { return _EnableMarkup; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DefaultSelectedTabFont
|
|
|
|
/// <summary>
|
|
/// Gets or sets the default SelectedTabFont
|
|
/// </summary>
|
|
protected Font DefaultSelectedTabFont
|
|
{
|
|
get
|
|
{
|
|
if (_DefaultSelectedTabFont == null)
|
|
_DefaultSelectedTabFont = new Font(SystemFonts.CaptionFont, FontStyle.Bold);
|
|
|
|
return (_DefaultSelectedTabFont);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_DefaultSelectedTabFont != null)
|
|
_DefaultSelectedTabFont.Dispose();
|
|
|
|
_DefaultSelectedTabFont = value;
|
|
|
|
_SizingFont = null;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Internal properties
|
|
|
|
#region CanAnimateImage
|
|
|
|
internal bool CanAnimateImage
|
|
{
|
|
get
|
|
{
|
|
return (_EnableImageAnimation == true &&
|
|
_CanAnimateImage == true);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CloseButtonBounds
|
|
|
|
/// <summary>
|
|
/// Gets the tab CloseButton Bounds
|
|
/// </summary>
|
|
internal Rectangle CloseButtonBounds
|
|
{
|
|
get
|
|
{
|
|
if (_CloseButtonBounds.IsEmpty)
|
|
_CloseButtonBounds = GetCloseButtonBounds();
|
|
|
|
return (_CloseButtonBounds);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CloseButtonMouseOver
|
|
|
|
/// <summary>
|
|
/// Gets or sets the CloseButtonMouseOver state
|
|
/// </summary>
|
|
internal bool CloseButtonMouseOver
|
|
{
|
|
get { return (_CloseButtonMouseOver); }
|
|
|
|
set
|
|
{
|
|
if (_CloseButtonMouseOver != value)
|
|
{
|
|
_CloseButtonMouseOver = value;
|
|
|
|
Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CloseButtonPressed
|
|
|
|
/// <summary>
|
|
/// Gets or sets the CloseButtonPressed state
|
|
/// </summary>
|
|
internal bool CloseButtonPressed
|
|
{
|
|
get { return (_CloseButtonPressed); }
|
|
|
|
set
|
|
{
|
|
if (_CloseButtonPressed != value)
|
|
{
|
|
_CloseButtonPressed = value;
|
|
|
|
Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region EffectiveImageAlignment
|
|
|
|
/// <summary>
|
|
/// Gets the effective image alignment
|
|
/// </summary>
|
|
internal ImageAlignment EffectiveImageAlignment
|
|
{
|
|
get
|
|
{
|
|
if (ImageAlignment != ImageAlignment.NotSet)
|
|
return (ImageAlignment);
|
|
|
|
if (TabStripItem.ImageAlignment != ImageAlignment.NotSet)
|
|
return (TabStripItem.ImageAlignment);
|
|
|
|
return (ImageAlignment.MiddleLeft);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageBounds
|
|
|
|
/// <summary>
|
|
/// Gets the tab Image Bounds
|
|
/// </summary>
|
|
internal Rectangle ImageBounds
|
|
{
|
|
get
|
|
{
|
|
if (_ImageBounds.IsEmpty)
|
|
_ImageBounds = GetImageBounds();
|
|
|
|
return (_ImageBounds);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsVertical
|
|
|
|
/// <summary>
|
|
/// Gets the tabs vertical orientation
|
|
/// </summary>
|
|
internal bool IsVertical
|
|
{
|
|
get
|
|
{
|
|
return (_TabStripItem.HorizontalText == false &&
|
|
(_TabStripItem.TabAlignment == eTabStripAlignment.Left ||
|
|
_TabStripItem.TabAlignment == eTabStripAlignment.Right));
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SelectedFont
|
|
|
|
internal Font SelectedFont
|
|
{
|
|
get { return (_SelectedTabFont ?? _TabStripItem.SelectedTabFont) ?? DefaultSelectedTabFont; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SizingFont
|
|
|
|
internal Font SizingFont
|
|
{
|
|
get { return (_SizingFont); }
|
|
set { _SizingFont = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TabDisplay
|
|
|
|
/// <summary>
|
|
/// Gets the TabItemDisplay
|
|
/// </summary>
|
|
internal SuperTabItemBaseDisplay TabItemDisplay
|
|
{
|
|
get { return (_TabItemDisplay); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TabStrip
|
|
|
|
/// <summary>
|
|
/// Gets the tabs TabStrip
|
|
/// </summary>
|
|
internal SuperTabStrip TabStrip
|
|
{
|
|
get { return (TabStripItem != null ? TabStripItem.TabStrip : null); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TextBounds
|
|
|
|
/// <summary>
|
|
/// Gets the tabs Text Bounds
|
|
/// </summary>
|
|
internal Rectangle TextBounds
|
|
{
|
|
get
|
|
{
|
|
if (_TextBounds.IsEmpty)
|
|
_TextBounds = GetTextBounds();
|
|
|
|
return (_TextBounds);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region UnselectedFont
|
|
|
|
internal Font UnselectedFont
|
|
{
|
|
get { return (_TabFont ?? _TabStripItem.TabFont) ?? SystemFonts.CaptionFont; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
#region Browsable properties
|
|
|
|
#region EnableImageAnimation
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether image animation is enabled
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true)]
|
|
[DefaultValue(false), Category("Appearance")]
|
|
[Description("Indicates whether image animation is enabled.")]
|
|
public bool EnableImageAnimation
|
|
{
|
|
get { return (_EnableImageAnimation); }
|
|
|
|
set
|
|
{
|
|
if (_EnableImageAnimation != value)
|
|
{
|
|
_EnableImageAnimation = value;
|
|
|
|
RefreshOwner();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TabColor
|
|
|
|
/// <summary>
|
|
/// Gets or sets user specified tab display colors
|
|
/// </summary>
|
|
[Browsable(true), Category("Style")]
|
|
[Description("Contains user specified tab display colors.")]
|
|
public SuperTabItemColorTable TabColor
|
|
{
|
|
get { return (_TabColor); }
|
|
|
|
set
|
|
{
|
|
if (_TabColor.Equals(value) == false)
|
|
{
|
|
if (_TabColor != null)
|
|
_TabColor.ColorTableChanged -= ColorTableColorTableChanged;
|
|
|
|
_TabColor = value;
|
|
|
|
if (value != null)
|
|
_TabColor.ColorTableChanged += ColorTableColorTableChanged;
|
|
|
|
OnTabColorChanged();
|
|
|
|
Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeTabColor()
|
|
{
|
|
return (_TabColor.IsEmpty == false);
|
|
}
|
|
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetTabColor()
|
|
{
|
|
TabColor = new SuperTabItemColorTable();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CloseButtonVisible
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether Close button on the tab is visible when SuperTabStrip.CloseButtonOnTabsVisible property is set to true
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(true), Category("Appearance")]
|
|
[Description("Indicates whether Close button on the tab is visible when SuperTabStrip.CloseButtonOnTabsVisible property is set to true.")]
|
|
public bool CloseButtonVisible
|
|
{
|
|
get { return (_CloseButtonVisible); }
|
|
|
|
set
|
|
{
|
|
if (_CloseButtonVisible != value)
|
|
{
|
|
_CloseButtonVisible = value;
|
|
|
|
RefreshOwner();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Enabled
|
|
|
|
/// <summary>
|
|
/// Enabled
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(true), Category("Behavior")]
|
|
[Description("Indicates whether the tab is enabled.")]
|
|
public override bool Enabled
|
|
{
|
|
get { return base.Enabled; }
|
|
|
|
set
|
|
{
|
|
if (base.Enabled != value)
|
|
{
|
|
base.Enabled = value;
|
|
|
|
if (_TabStripItem != null)
|
|
{
|
|
if (value == false && IsSelected == true && DesignMode == false)
|
|
_TabStripItem.SelectNewTab(this);
|
|
}
|
|
|
|
RefreshOwner();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region EnableMarkup
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether text-markup support is enabled for the control's Text property
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Appearance")]
|
|
[Description("Indicates whether text-markup support is enabled for the control's Text property.")]
|
|
public bool EnableMarkup
|
|
{
|
|
get { return (_EnableMarkup); }
|
|
|
|
set
|
|
{
|
|
if (_EnableMarkup != value)
|
|
{
|
|
_EnableMarkup = value;
|
|
NeedRecalcSize = true;
|
|
|
|
OnTextChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region FixedTabSize
|
|
|
|
/// <summary>
|
|
/// Gets or sets the FixedTabSize
|
|
/// </summary>
|
|
public Size FixedTabSize
|
|
{
|
|
get { return _FixedTabSize; }
|
|
|
|
set
|
|
{
|
|
value.Width = Math.Max(0, value.Width);
|
|
value.Height = Math.Max(0, value.Height);
|
|
|
|
if (_FixedTabSize != value)
|
|
{
|
|
_FixedTabSize = value;
|
|
|
|
RefreshOwner();
|
|
}
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeFixedTabSize()
|
|
{
|
|
return (_FixedTabSize.IsEmpty == false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Icon
|
|
|
|
/// <summary>
|
|
/// Gets or sets the tab icon. Icon has same functionality as Image except that it supports Alpha blending
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), DefaultValue(null), Category("Appearance")]
|
|
[Description("Indicates the tab icon. Icon has same functionality as Image except that it supports Alpha blending.")]
|
|
public Icon Icon
|
|
{
|
|
get { return _Icon; }
|
|
|
|
set
|
|
{
|
|
if (_Icon != value)
|
|
{
|
|
_Icon = value;
|
|
|
|
RefreshOwner();
|
|
}
|
|
}
|
|
}
|
|
|
|
[Browsable(false), DevCoBrowsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetIcon()
|
|
{
|
|
Icon = null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Image
|
|
|
|
/// <summary>
|
|
/// Gets or sets the tab image
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), DefaultValue(null), Category("Appearance")]
|
|
[Description("Indicates the tab image.")]
|
|
public Image Image
|
|
{
|
|
get { return (_Image); }
|
|
|
|
set
|
|
{
|
|
if (_Image != value)
|
|
{
|
|
_Image = value;
|
|
|
|
OnImageChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnImageChanged()
|
|
{
|
|
if (_EnableImageAnimation == true)
|
|
{
|
|
if (_TabItemDisplay != null)
|
|
_TabItemDisplay.StopImageAnimation();
|
|
}
|
|
|
|
Image image = GetImage();
|
|
|
|
_CanAnimateImage = ImageAnimator.CanAnimate(image);
|
|
|
|
RefreshOwner();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageIndex
|
|
|
|
/// <summary>
|
|
/// Gets or sets the tab image index
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), DefaultValue(-1)]
|
|
[Category("Appearance"), Description("Indicates the tab image index")]
|
|
[Editor("DevComponents.DotNetBar.Design.ImageIndexEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
|
|
[TypeConverter(typeof(ImageIndexConverter))]
|
|
public int ImageIndex
|
|
{
|
|
get { return (_ImageIndex); }
|
|
|
|
set
|
|
{
|
|
if (_ImageIndex != value)
|
|
{
|
|
_ImageIndex = value;
|
|
|
|
OnImageChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
[Browsable(false), DevCoBrowsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetImageIndex()
|
|
{
|
|
ImageIndex = -1;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageList
|
|
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public ImageList ImageList
|
|
{
|
|
get
|
|
{
|
|
if (_TabStripItem != null && _TabStripItem.TabStrip != null)
|
|
return (_TabStripItem.TabStrip.ImageList);
|
|
|
|
return (null);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageAlignment
|
|
|
|
/// <summary>
|
|
/// Gets or sets the alignment of the Image within the tab
|
|
/// </summary>
|
|
[DefaultValue(ImageAlignment.NotSet), Category("Appearance")]
|
|
[Description("Indicates the alignment of the Image within the tab.")]
|
|
public ImageAlignment ImageAlignment
|
|
{
|
|
get { return (_ImageAlignment); }
|
|
|
|
set
|
|
{
|
|
if (_ImageAlignment != value)
|
|
{
|
|
_ImageAlignment = value;
|
|
|
|
RefreshOwner();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImagePadding
|
|
|
|
/// <summary>
|
|
/// Gets or sets the spacing between content and edges of the Image
|
|
/// </summary>
|
|
[Description("Indicates the spacing between content and edges of the Image")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public Padding ImagePadding
|
|
{
|
|
get
|
|
{
|
|
if (_ImagePadding == null)
|
|
{
|
|
_ImagePadding = new Padding(0);
|
|
|
|
UpdateChangeHandler(null, _ImagePadding);
|
|
}
|
|
|
|
return (_ImagePadding);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_ImagePadding != value)
|
|
{
|
|
UpdateChangeHandler(_ImagePadding, value);
|
|
|
|
_ImagePadding = value;
|
|
|
|
RefreshOwner();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether property should be serialized.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private bool ShouldSerializeImagePadding()
|
|
{
|
|
return (_ImagePadding != null && _ImagePadding.IsEmpty == false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets property to its default value.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private void ResetImagePadding()
|
|
{
|
|
ImagePadding = null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PredefinedColor
|
|
|
|
/// <summary>
|
|
/// Gets or sets the predefined color for the tab
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(eTabItemColor.Default), Category("Style")]
|
|
[Description("Indicates the predefined color for the tab.")]
|
|
public eTabItemColor PredefinedColor
|
|
{
|
|
get { return (_PredefinedColor); }
|
|
|
|
set
|
|
{
|
|
_PredefinedColor = value;
|
|
|
|
OnTabColorChanged();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SelectedTabFont
|
|
|
|
/// <summary>
|
|
/// Gets or sets the selected tab Font
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), Category("Style"), DefaultValue(null)]
|
|
[Description("Indicates the selected tab Font")]
|
|
public Font SelectedTabFont
|
|
{
|
|
get { return (_SelectedTabFont); }
|
|
|
|
set
|
|
{
|
|
if (_SelectedTabFont != value)
|
|
{
|
|
if (value != null)
|
|
DefaultSelectedTabFont = null;
|
|
|
|
_SelectedTabFont = value;
|
|
_SizingFont = null;
|
|
|
|
RefreshOwner();
|
|
}
|
|
}
|
|
}
|
|
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeSelectedTabFont()
|
|
{
|
|
return (_SelectedTabFont != null);
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetSelectedTabFont()
|
|
{
|
|
SelectedTabFont = null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region StartsNewTabLine
|
|
|
|
/// <summary>
|
|
/// StartsNewTabLine
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(false), Category("Behavior")]
|
|
[Description("Indicates whether the tab starts a new tab line.")]
|
|
public bool StartsNewTabLine
|
|
{
|
|
get { return (_StartsNewTabLine); }
|
|
|
|
set
|
|
{
|
|
if (value != _StartsNewTabLine)
|
|
{
|
|
_StartsNewTabLine = value;
|
|
|
|
RefreshOwner();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Symbol
|
|
/// <summary>
|
|
/// Gets the realized symbol string.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public string SymbolRealized
|
|
{
|
|
get { return _SymbolRealized; }
|
|
}
|
|
private string _SymbolRealized = "";
|
|
/// <summary>
|
|
/// Indicates the symbol displayed on face of the button instead of
|
|
/// the image. Setting the symbol overrides the image setting.
|
|
/// </summary>
|
|
[DefaultValue(""), Category("Appearance"), Description("Indicates the symbol displayed on face of the button instead of the image. Setting the symbol overrides the image setting.")]
|
|
[Editor("DevComponents.DotNetBar.Design.SymbolTypeEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor))]
|
|
public string Symbol
|
|
{
|
|
get { return (_Symbol); }
|
|
|
|
set
|
|
{
|
|
if (value != _Symbol)
|
|
{
|
|
string oldValue = _Symbol;
|
|
_Symbol = value;
|
|
|
|
OnSymbolChanged(oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region OnSymbolChanged
|
|
|
|
/// <summary>
|
|
/// Called when Symbol property has changed.
|
|
/// </summary>
|
|
/// <param name="oldValue">Old property value</param>
|
|
/// <param name="newValue">New property value</param>
|
|
protected virtual void OnSymbolChanged(string oldValue, string newValue)
|
|
{
|
|
if (string.IsNullOrEmpty(newValue))
|
|
_SymbolRealized = "";
|
|
else
|
|
_SymbolRealized = Symbols.GetSymbol(newValue);
|
|
NeedRecalcSize = true;
|
|
|
|
OnAppearanceChanged();
|
|
Refresh();
|
|
}
|
|
|
|
#endregion
|
|
|
|
private eSymbolSet _SymbolSet = eSymbolSet.Awesome;
|
|
/// <summary>
|
|
/// Gets or sets the symbol set used to represent the Symbol.
|
|
/// </summary>
|
|
[Browsable(false), DefaultValue(eSymbolSet.Awesome)]
|
|
public eSymbolSet SymbolSet
|
|
{
|
|
get { return _SymbolSet; }
|
|
set
|
|
{
|
|
if (_SymbolSet != value)
|
|
{
|
|
eSymbolSet oldValue = _SymbolSet;
|
|
_SymbolSet = value;
|
|
OnSymbolSetChanged(oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Called when SymbolSet property value changes.
|
|
/// </summary>
|
|
/// <param name="oldValue">Indciates old value</param>
|
|
/// <param name="newValue">Indicates new value</param>
|
|
protected virtual void OnSymbolSetChanged(eSymbolSet oldValue, eSymbolSet newValue)
|
|
{
|
|
NeedRecalcSize = true;
|
|
OnAppearanceChanged();
|
|
this.Refresh();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SymbolColor
|
|
|
|
/// <summary>
|
|
/// Gets or sets the color of the Symbol.
|
|
/// </summary>
|
|
[Category("Appearance"), Description("Indicates color of the Symbol.")]
|
|
public Color SymbolColor
|
|
{
|
|
get { return (_SymbolColor); }
|
|
set { _SymbolColor = value; Refresh(); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether property should be serialized.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeSymbolColor()
|
|
{
|
|
return (_SymbolColor.IsEmpty == false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets property to its default value.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetSymbolColor()
|
|
{
|
|
SymbolColor = Color.Empty;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SymbolSize
|
|
|
|
/// <summary>
|
|
/// Indicates the size of the symbol in points.
|
|
/// </summary>
|
|
[DefaultValue(0f), Category("Appearance"), Description("Indicates the size of the symbol in points.")]
|
|
public float SymbolSize
|
|
{
|
|
get { return (_SymbolSize); }
|
|
|
|
set
|
|
{
|
|
if (value != _SymbolSize)
|
|
{
|
|
float oldValue = _SymbolSize;
|
|
_SymbolSize = value;
|
|
|
|
OnSymbolSizeChanged(oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region OnSymbolSizeChanged
|
|
|
|
/// <summary>
|
|
/// Called when SymbolSize property has changed.
|
|
/// </summary>
|
|
/// <param name="oldValue">Old property value</param>
|
|
/// <param name="newValue">New property value</param>
|
|
protected virtual void OnSymbolSizeChanged(float oldValue, float newValue)
|
|
{
|
|
NeedRecalcSize = true;
|
|
|
|
OnAppearanceChanged();
|
|
Refresh();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region TextAlignment
|
|
|
|
/// <summary>
|
|
/// Gets or sets the text alignment
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(null)]
|
|
[DevCoBrowsable(true), Category("Layout"), Description("Indicates text alignment.")]
|
|
public eItemAlignment? TextAlignment
|
|
{
|
|
get { return (_TextAlignment); }
|
|
|
|
set
|
|
{
|
|
if (_TextAlignment != value)
|
|
{
|
|
_TextAlignment = value;
|
|
|
|
Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TabFont
|
|
|
|
/// <summary>
|
|
/// Gets or sets the tab Font
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), Category("Style"), DefaultValue(null)]
|
|
[Description("Indicates the tab Font")]
|
|
public Font TabFont
|
|
{
|
|
get { return (_TabFont); }
|
|
|
|
set
|
|
{
|
|
if (_TabFont != value)
|
|
{
|
|
_TabFont = value;
|
|
_SizingFont = null;
|
|
|
|
RefreshOwner();
|
|
}
|
|
}
|
|
}
|
|
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeTabFont()
|
|
{
|
|
return (_TabFont != null);
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetTabFont()
|
|
{
|
|
TabFont = null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Text
|
|
|
|
/// <summary>
|
|
/// Gets or sets the tab text
|
|
/// </summary>
|
|
[Browsable(true)]
|
|
[Editor("DevComponents.DotNetBar.Design.TextMarkupUIEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
|
|
[Category("Appearance"), Description("Indicates the tab text.")]
|
|
public override string Text
|
|
{
|
|
get { return (base.Text); }
|
|
set { base.Text = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Non-Browsable properties
|
|
|
|
#region AttachedControl
|
|
|
|
/// <summary>
|
|
/// Gets or sets the control that is attached to this tab
|
|
/// </summary>
|
|
[Browsable(false), DevCoBrowsable(true), DefaultValue(null), Category("Behavior")]
|
|
public Control AttachedControl
|
|
{
|
|
get { return (_AttachedControl); }
|
|
|
|
set
|
|
{
|
|
SuperTabControlPanel panel = _AttachedControl as SuperTabControlPanel;
|
|
|
|
if (panel != null)
|
|
panel.PanelColorChanged -= ColorTableColorTableChanged;
|
|
|
|
_AttachedControl = value;
|
|
|
|
panel = _AttachedControl as SuperTabControlPanel;
|
|
|
|
if (panel != null)
|
|
{
|
|
panel.TabItem = this;
|
|
panel.Dock = DockStyle.Fill;
|
|
|
|
panel.PanelColorChanged += ColorTableColorTableChanged;
|
|
|
|
if (_TabStripItem != null && _TabStripItem.TabStrip != null)
|
|
{
|
|
if (DesignMode == true)
|
|
_TabStripItem.TabStrip.Controls.Add(panel);
|
|
|
|
panel.BringToFront();
|
|
panel.Visible = (_TabStripItem.SelectedTab == this);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Bounds
|
|
|
|
/// <summary>
|
|
/// Gets or sets the tab Bounds
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public override Rectangle Bounds
|
|
{
|
|
get { return (base.Bounds); }
|
|
|
|
set
|
|
{
|
|
base.Bounds = value;
|
|
|
|
_TextBounds = Rectangle.Empty;
|
|
_CloseButtonBounds = Rectangle.Empty;
|
|
_ImageBounds = Rectangle.Empty;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsMouseOver
|
|
|
|
/// <summary>
|
|
/// Gets the MouseOver state
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public bool IsMouseOver
|
|
{
|
|
get { return (_TabStripItem != null && _TabStripItem.MouseOverTab == this); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsSelected
|
|
|
|
/// <summary>
|
|
/// Gets the tab selected state
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public bool IsSelected
|
|
{
|
|
get { return (_TabStripItem != null && _TabStripItem.SelectedTab == this); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TabAlignment
|
|
|
|
/// <summary>
|
|
/// Gets the tab alignment
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public eTabStripAlignment TabAlignment
|
|
{
|
|
get
|
|
{
|
|
if (_TabStripItem != null)
|
|
return (_TabStripItem.TabAlignment);
|
|
|
|
return (eTabStripAlignment.Top);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ContentRectangle
|
|
|
|
/// <summary>
|
|
/// Gets the tab Content Rectangle
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public Rectangle ContentRectangle
|
|
{
|
|
get
|
|
{
|
|
if (_TabItemDisplay != null)
|
|
return (_TabItemDisplay.GetContentRectangle());
|
|
|
|
return (Rectangle.Empty);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TabStripItem
|
|
|
|
/// <summary>
|
|
/// Gets or sets the tab TabStripItem
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public SuperTabStripItem TabStripItem
|
|
{
|
|
get { return (_TabStripItem); }
|
|
|
|
set
|
|
{
|
|
_TabStripItem = value;
|
|
|
|
if(_TabStripItem!=null)
|
|
SetOwner(_TabStripItem.GetOwner());
|
|
|
|
if (_TabStripItem != null)
|
|
{
|
|
TabStyle = _TabStripItem.TabStyle;
|
|
ContainerControl = _TabStripItem.ContainerControl;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TabStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the tabs TabStyle
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public eSuperTabStyle TabStyle
|
|
{
|
|
get
|
|
{
|
|
if (_TabStripItem != null)
|
|
return (_TabStripItem.TabStyle);
|
|
|
|
return (eSuperTabStyle.Office2007);
|
|
}
|
|
|
|
internal set
|
|
{
|
|
if (_TabItemDisplay != null)
|
|
_TabItemDisplay.Dispose();
|
|
|
|
switch (value)
|
|
{
|
|
case eSuperTabStyle.Office2007:
|
|
_TabItemDisplay = new Office2007SuperTabItem(this);
|
|
break;
|
|
|
|
case eSuperTabStyle.Office2010BackstageBlue:
|
|
_TabItemDisplay = new Office2010BackstageSuperTabItem(this);
|
|
break;
|
|
|
|
case eSuperTabStyle.OneNote2007:
|
|
_TabItemDisplay = new OneNote2007SuperTabItem(this);
|
|
break;
|
|
|
|
case eSuperTabStyle.OfficeMobile2014:
|
|
_TabItemDisplay = new OfficeMobile2014SuperTabItem(this);
|
|
break;
|
|
|
|
case eSuperTabStyle.VisualStudio2008Dock:
|
|
_TabItemDisplay = new VS2008DockSuperTabItem(this);
|
|
break;
|
|
|
|
case eSuperTabStyle.VisualStudio2008Document:
|
|
_TabItemDisplay = new VS2008DocumentSuperTabItem(this);
|
|
break;
|
|
|
|
case eSuperTabStyle.WinMediaPlayer12:
|
|
_TabItemDisplay = new WinMediaPlayer12SuperTabItem(this);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Visible
|
|
|
|
/// <summary>
|
|
/// Visible
|
|
/// </summary>
|
|
public override bool Visible
|
|
{
|
|
get { return (base.Visible); }
|
|
|
|
set
|
|
{
|
|
base.Visible = value;
|
|
|
|
if (_TabStripItem != null)
|
|
{
|
|
if (value == false && IsSelected == true && DesignMode == false)
|
|
_TabStripItem.SelectNewTab(this);
|
|
|
|
RefreshOwner();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region HookEvents
|
|
|
|
/// <summary>
|
|
/// Hooks or unhooks control events
|
|
/// </summary>
|
|
/// <param name="hook">true to hook</param>
|
|
private void HookEvents(bool hook)
|
|
{
|
|
if (hook == true)
|
|
{
|
|
TextChanged += SuperTabItemTextChanged;
|
|
MarkupLinkClick += TextMarkupLinkClick;
|
|
|
|
_TabColor.ColorTableChanged += ColorTableColorTableChanged;
|
|
}
|
|
else
|
|
{
|
|
TextChanged -= SuperTabItemTextChanged;
|
|
MarkupLinkClick -= TextMarkupLinkClick;
|
|
|
|
if (_TabColor != null)
|
|
_TabColor.ColorTableChanged -= ColorTableColorTableChanged;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Event processing
|
|
|
|
#region SuperTabItem_TextChanged
|
|
|
|
/// <summary>
|
|
/// SuperTabItem_TextChanged processing
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void SuperTabItemTextChanged(object sender, EventArgs e)
|
|
{
|
|
NeedRecalcSize = true;
|
|
Refresh();
|
|
|
|
if (_TabStripItem != null)
|
|
{
|
|
_TabStripItem.NeedRecalcSize = true;
|
|
_TabStripItem.Refresh();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Markup Support
|
|
|
|
/// <summary>
|
|
/// TextMarkupLinkClick
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected override void TextMarkupLinkClick(object sender, EventArgs e)
|
|
{
|
|
TextMarkup.HyperLink link = sender as TextMarkup.HyperLink;
|
|
|
|
if (link != null)
|
|
OnMarkupLinkClick(new MarkupLinkClickEventArgs(link.Name, link.HRef));
|
|
|
|
base.TextMarkupLinkClick(sender, e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// OnMarkupLinkClick
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual void OnMarkupLinkClick(MarkupLinkClickEventArgs e)
|
|
{
|
|
if (MarkupLinkClick != null)
|
|
MarkupLinkClick(this, e);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ColorTable_ColorTableChanged
|
|
|
|
/// <summary>
|
|
/// ColorTable_ColorTableChanged
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void ColorTableColorTableChanged(object sender, EventArgs e)
|
|
{
|
|
OnTabColorChanged();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region OnColorTableChanged
|
|
|
|
/// <summary>
|
|
/// Processes ColorTable changes
|
|
/// </summary>
|
|
protected void OnTabColorChanged()
|
|
{
|
|
if (TabColorChanged != null)
|
|
TabColorChanged(this, EventArgs.Empty);
|
|
|
|
Refresh();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Close
|
|
|
|
/// <summary>
|
|
/// Closes the tab
|
|
/// </summary>
|
|
public void Close()
|
|
{
|
|
_TabStripItem.CloseTab(this);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetTabFont
|
|
|
|
/// <summary>
|
|
/// Gets the operational tab font
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public Font GetTabFont()
|
|
{
|
|
return ((IsSelected == true) ? SelectedFont : UnselectedFont);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetTabColorTable
|
|
|
|
/// <summary>
|
|
/// Gets the tab ColorTable
|
|
/// </summary>
|
|
/// <returns>SuperTabItemStateColorTable</returns>
|
|
internal SuperTabItemStateColorTable GetTabColorTable()
|
|
{
|
|
return (_TabItemDisplay.GetTabColorTable());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the tab ColorStateTable for the given state
|
|
/// </summary>
|
|
/// <param name="tabState">eTabState</param>
|
|
/// <returns>SuperTabItemStateColorTable</returns>
|
|
internal SuperTabItemStateColorTable GetTabColorTable(eTabState tabState)
|
|
{
|
|
return (_TabItemDisplay.GetTabColorTable(tabState));
|
|
}
|
|
|
|
internal SuperTabItemStateColorTable GetTabColorTableEx(eTabState tabState)
|
|
{
|
|
return (_TabItemDisplay.GetTabColorTableEx(tabState));
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region GetPanelColorTable
|
|
|
|
/// <summary>
|
|
/// Gets the tab Panel ColorTable
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
internal SuperTabPanelItemColorTable GetPanelColorTable()
|
|
{
|
|
return (_TabItemDisplay.GetPanelColorTable());
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetTabAreaFromPoint
|
|
|
|
/// <summary>
|
|
/// Gets the area of the tab that contains the given Point
|
|
/// </summary>
|
|
/// <param name="pt"></param>
|
|
/// <returns></returns>
|
|
public eSuperTabArea GetTabAreaFromPoint(Point pt)
|
|
{
|
|
if (Bounds.Contains(pt) == true)
|
|
{
|
|
if (CloseButtonBounds.Contains(pt) == true)
|
|
return (eSuperTabArea.InCloseBox);
|
|
|
|
if (ImageBounds.Contains(pt) == true)
|
|
return (eSuperTabArea.InImage);
|
|
|
|
return (eSuperTabArea.InContent);
|
|
}
|
|
|
|
return (eSuperTabArea.InNone);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PointInTab
|
|
|
|
/// <summary>
|
|
/// Determines if the given Point is in the tab
|
|
/// </summary>
|
|
/// <param name="pt">Point to test</param>
|
|
/// <returns>true if Point is in tab</returns>
|
|
public bool PointInTab(Point pt)
|
|
{
|
|
using (GraphicsPath path = GetTabItemPath())
|
|
{
|
|
if (path.IsVisible(pt))
|
|
return (true);
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetTabItemPath
|
|
|
|
/// <summary>
|
|
/// Gets the tab bordering GraphicsPath
|
|
/// </summary>
|
|
/// <returns>GraphicsPath</returns>
|
|
public GraphicsPath GetTabItemPath()
|
|
{
|
|
return (_TabItemDisplay != null ?
|
|
_TabItemDisplay.TabItemPath() : null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetCloseButtonBounds
|
|
|
|
/// <summary>
|
|
/// Gets the Close Button bounding Rectangle
|
|
/// </summary>
|
|
/// <returns>Bounding Rectangle</returns>
|
|
private Rectangle GetCloseButtonBounds()
|
|
{
|
|
if (CloseButtonVisible == false ||
|
|
_TabStripItem == null ||
|
|
_TabStripItem.CloseButtonOnTabsVisible == false)
|
|
{
|
|
return (Rectangle.Empty);
|
|
}
|
|
|
|
Rectangle r = TabItemDisplay.GetContentRectangle();
|
|
|
|
Rectangle t = r;
|
|
|
|
Size closeSize = _TabStripItem.TabCloseButtonSize;
|
|
int spacing = _TabStripItem.TabHorizontalSpacing;
|
|
|
|
if (IsVertical == true)
|
|
{
|
|
if (TabStripItem.CloseButtonPosition == eTabCloseButtonPosition.Left)
|
|
{
|
|
r = new Rectangle(r.X + (r.Width - closeSize.Width) / 2 + 1,
|
|
r.Bottom - spacing - closeSize.Height - 1,
|
|
closeSize.Width, closeSize.Height);
|
|
}
|
|
else
|
|
{
|
|
r = new Rectangle(r.X + (r.Width - closeSize.Width)/2 + 1,
|
|
r.Y + spacing, closeSize.Width, closeSize.Height);
|
|
}
|
|
|
|
if (TabStripItem.RotateVerticalText ^
|
|
TabStripItem.TabAlignment == eTabStripAlignment.Right)
|
|
{
|
|
r.X = t.X + (t.Right - r.Right);
|
|
r.Y = t.Y + (t.Bottom - r.Bottom);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_TabStripItem.CloseButtonPosition == eTabCloseButtonPosition.Left)
|
|
{
|
|
r = new Rectangle(r.X + spacing,
|
|
r.Y + (r.Height - closeSize.Height) / 2,
|
|
closeSize.Width, closeSize.Height);
|
|
|
|
if (_TabStripItem.TabAlignment == eTabStripAlignment.Right)
|
|
{
|
|
if (IsSelected == true)
|
|
r.X += _TabStripItem.TabDisplay.SelectedPaddingWidth;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
r = new Rectangle(r.Right - spacing - closeSize.Width,
|
|
r.Y + (r.Height - closeSize.Height) / 2 + 1,
|
|
closeSize.Width, closeSize.Height);
|
|
|
|
if (_TabStripItem.TabAlignment == eTabStripAlignment.Left)
|
|
{
|
|
if (IsSelected == true)
|
|
r.X -= _TabStripItem.TabDisplay.SelectedPaddingWidth;
|
|
}
|
|
}
|
|
}
|
|
|
|
r = _TabStripItem.OnGetCloseBounds(this, r);
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetImageBounds
|
|
|
|
/// <summary>
|
|
/// Gets the Image bounding Rectangle
|
|
/// </summary>
|
|
/// <returns>Bounding Rectangle</returns>
|
|
private Rectangle GetImageBounds()
|
|
{
|
|
CompositeImage image = GetTabImage();
|
|
|
|
if (string.IsNullOrEmpty(SymbolRealized) && image == null)
|
|
return (Rectangle.Empty);
|
|
|
|
Rectangle r = TabItemDisplay.GetContentRectangle();
|
|
|
|
r = ProcessCloseBounds(r);
|
|
|
|
r = (IsVertical == true)
|
|
? CalcVerticalImageBounds(image, r)
|
|
: CalcHorizontalImageBounds(image, r);
|
|
|
|
r = _TabStripItem.OnGetImageBounds(this, r);
|
|
|
|
return (r);
|
|
}
|
|
|
|
#region CalcVerticalImageBounds
|
|
|
|
private Rectangle CalcVerticalImageBounds(CompositeImage image, Rectangle r)
|
|
{
|
|
int h = 0;
|
|
int w = 0;
|
|
|
|
if (string.IsNullOrEmpty(SymbolRealized) == false)
|
|
{
|
|
Size size = GetSymbolSize();
|
|
|
|
w = size.Width;
|
|
h = size.Height;
|
|
}
|
|
else
|
|
{
|
|
w = Dpi.ImageWidth(image.Width);
|
|
h = Dpi.ImageHeight(image.Height);
|
|
}
|
|
|
|
Padding padding = Dpi.Size(ImagePadding);
|
|
|
|
Rectangle t = r;
|
|
|
|
switch (EffectiveImageAlignment)
|
|
{
|
|
case ImageAlignment.TopLeft:
|
|
r.X += padding.Top + TabStripItem.TabVerticalSpacing;
|
|
r.Y = r.Bottom - (w + padding.Left);
|
|
break;
|
|
|
|
case ImageAlignment.TopCenter:
|
|
r.X += padding.Top + TabStripItem.TabVerticalSpacing;
|
|
r.Y += (r.Height - (w + padding.Horizontal - TabStripItem.TabHorizontalSpacing))/2;
|
|
break;
|
|
|
|
case ImageAlignment.TopRight:
|
|
r.X += padding.Top + TabStripItem.TabVerticalSpacing;
|
|
r.Y += padding.Right + TabStripItem.TabHorizontalSpacing;
|
|
break;
|
|
|
|
case ImageAlignment.MiddleLeft:
|
|
r.X += (r.Width - (h + padding.Vertical))/2 + padding.Top;
|
|
r.Y = r.Bottom - (w + padding.Left);
|
|
break;
|
|
|
|
case ImageAlignment.MiddleCenter:
|
|
r.X += (r.Width - (h + padding.Vertical))/2 + padding.Top;
|
|
r.Y += (r.Height - (w + padding.Horizontal - TabStripItem.TabHorizontalSpacing)) / 2;
|
|
break;
|
|
|
|
case ImageAlignment.MiddleRight:
|
|
r.X += (r.Width - (h + padding.Vertical))/2 + padding.Top;
|
|
r.Y += padding.Right + TabStripItem.TabHorizontalSpacing;
|
|
break;
|
|
|
|
case ImageAlignment.BottomLeft:
|
|
r.X = r.Right - (w + padding.Right + TabStripItem.TabHorizontalSpacing);
|
|
r.Y = r.Bottom - (w + padding.Left);
|
|
break;
|
|
|
|
case ImageAlignment.BottomCenter:
|
|
r.X = r.Right - (w + padding.Right + TabStripItem.TabHorizontalSpacing);
|
|
r.Y += (r.Height - (w + padding.Horizontal - TabStripItem.TabHorizontalSpacing)) / 2;
|
|
break;
|
|
|
|
case ImageAlignment.BottomRight:
|
|
r.X = r.Right - (w + padding.Right + TabStripItem.TabHorizontalSpacing);
|
|
r.Y += padding.Right + TabStripItem.TabHorizontalSpacing;
|
|
break;
|
|
}
|
|
|
|
if (TabStripItem.RotateVerticalText ^
|
|
TabStripItem.TabAlignment == eTabStripAlignment.Right == true)
|
|
{
|
|
r.X = t.X + (t.Right - (r.X + h));
|
|
r.Y = t.Y + (t.Bottom - (r.Y + w));
|
|
}
|
|
|
|
r.Width = w;
|
|
r.Height = h;
|
|
|
|
return (r);
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region CalcHorizontalImageBounds
|
|
|
|
private Rectangle CalcHorizontalImageBounds(CompositeImage image, Rectangle r)
|
|
{
|
|
int h = 0;
|
|
int w = 0;
|
|
|
|
if (string.IsNullOrEmpty(SymbolRealized) == false)
|
|
{
|
|
Size size = GetSymbolSize();
|
|
|
|
w = size.Width;
|
|
h = size.Height;
|
|
}
|
|
else
|
|
{
|
|
w = image.Width;
|
|
h = image.Height;
|
|
}
|
|
|
|
Padding padding = ImagePadding;
|
|
|
|
switch (EffectiveImageAlignment)
|
|
{
|
|
case ImageAlignment.TopLeft:
|
|
r.X += padding.Left;
|
|
r.Y += padding.Top + TabStripItem.TabVerticalSpacing;
|
|
break;
|
|
|
|
case ImageAlignment.TopCenter:
|
|
r.X += (r.Width - (w + padding.Horizontal + TabStripItem.TabHorizontalSpacing)) / 2;
|
|
r.Y += padding.Top + TabStripItem.TabVerticalSpacing;
|
|
break;
|
|
|
|
case ImageAlignment.TopRight:
|
|
r.X = r.Right - w - padding.Right - TabStripItem.TabHorizontalSpacing;
|
|
r.Y += padding.Top + TabStripItem.TabVerticalSpacing;
|
|
break;
|
|
|
|
case ImageAlignment.MiddleLeft:
|
|
r.X += padding.Left;
|
|
r.Y += (r.Height - (h + padding.Vertical)) / 2 + padding.Top;
|
|
break;
|
|
|
|
case ImageAlignment.MiddleCenter:
|
|
r.X += (r.Width - (w + padding.Horizontal + TabStripItem.TabHorizontalSpacing)) / 2;
|
|
r.Y += (r.Height - (h + padding.Vertical)) / 2 + padding.Top;
|
|
break;
|
|
|
|
case ImageAlignment.MiddleRight:
|
|
r.X = r.Right - w - padding.Right - TabStripItem.TabHorizontalSpacing;
|
|
r.Y += (r.Height - (h + padding.Vertical)) / 2 + padding.Top;
|
|
break;
|
|
|
|
case ImageAlignment.BottomLeft:
|
|
r.X += padding.Left;
|
|
r.Y = r.Bottom - (h + padding.Bottom + TabStripItem.TabVerticalSpacing);
|
|
break;
|
|
|
|
case ImageAlignment.BottomCenter:
|
|
r.X += (r.Width - (w + padding.Horizontal + TabStripItem.TabHorizontalSpacing)) / 2;
|
|
r.Y = r.Bottom - (h + padding.Bottom + TabStripItem.TabVerticalSpacing);
|
|
break;
|
|
|
|
case ImageAlignment.BottomRight:
|
|
r.X = r.Right - w - padding.Right - TabStripItem.TabHorizontalSpacing;
|
|
r.Y = r.Bottom - (h + padding.Bottom + TabStripItem.TabVerticalSpacing);
|
|
break;
|
|
}
|
|
|
|
r.Width = w;
|
|
r.Height = h;
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetTabImage
|
|
|
|
internal CompositeImage GetTabImage()
|
|
{
|
|
Image image = GetImage();
|
|
|
|
if (image != null)
|
|
return (new CompositeImage(image, false));
|
|
|
|
return (Icon != null) ?
|
|
(new CompositeImage(Icon, false, Icon.Size)) : null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetImage
|
|
|
|
private Image GetImage()
|
|
{
|
|
if (_Image != null)
|
|
return (_Image);
|
|
|
|
if (_ImageIndex >= 0 && TabStrip != null)
|
|
{
|
|
ImageList imageList = TabStrip.ImageList;
|
|
|
|
if (imageList != null && _ImageIndex < imageList.Images.Count)
|
|
return (imageList.Images[_ImageIndex]);
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetSymbolSize
|
|
|
|
internal Size GetSymbolSize()
|
|
{
|
|
using (Graphics g = BarFunctions.CreateGraphics(TabStrip))
|
|
{
|
|
Font symFont = Symbols.GetFont(SymbolSize, SymbolSet);
|
|
|
|
Size size = TextDrawing.MeasureStringLegacy(g, SymbolRealized, symFont, Size.Empty, eTextFormat.Default);
|
|
|
|
int descent = (int)Math.Ceiling((symFont.FontFamily.GetCellDescent(symFont.Style) *
|
|
symFont.Size / symFont.FontFamily.GetEmHeight(symFont.Style)));
|
|
|
|
size.Height -= descent;
|
|
|
|
return (size);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetTextBounds
|
|
|
|
/// <summary>
|
|
/// Gets the Text bounding Rectangle
|
|
/// </summary>
|
|
/// <returns>Bounding Rectangle</returns>
|
|
private Rectangle GetTextBounds()
|
|
{
|
|
Rectangle r = TabItemDisplay.GetContentRectangle();
|
|
|
|
r = ProcessImageBounds(
|
|
ProcessCloseBounds(r));
|
|
|
|
if (IsVertical == false)
|
|
{
|
|
if (IsSelected == true)
|
|
{
|
|
if (_TabStripItem.TabAlignment == eTabStripAlignment.Left ||
|
|
_TabStripItem.TabAlignment == eTabStripAlignment.Right)
|
|
{
|
|
r.Width -= Dpi.Width(_TabStripItem.TabDisplay.SelectedPaddingWidth);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((_TabStripItem.TabAlignment == eTabStripAlignment.Left &&
|
|
_TabStripItem.RotateVerticalText == true) ||
|
|
(_TabStripItem.TabAlignment == eTabStripAlignment.Right &&
|
|
_TabStripItem.RotateVerticalText == false))
|
|
{
|
|
if (_TabStripItem.TabAlignment == eTabStripAlignment.Left)
|
|
{
|
|
r.X += Dpi.Width(_TabStripItem.TabVerticalSpacing);
|
|
r.Width -= Dpi.Width(_TabStripItem.TabVerticalSpacing);
|
|
}
|
|
else
|
|
{
|
|
r.Width -= Dpi.Width(_TabStripItem.TabVerticalSpacing);
|
|
}
|
|
}
|
|
}
|
|
|
|
r = _TabStripItem.OnGetTextBounds(this, r);
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ProcessCloseBounds
|
|
|
|
/// <summary>
|
|
/// Calculates Close button bounds
|
|
/// </summary>
|
|
/// <param name="r">Running rectangle</param>
|
|
/// <returns>Running rectangle</returns>
|
|
private Rectangle ProcessCloseBounds(Rectangle r)
|
|
{
|
|
int spacing = _TabStripItem.TabHorizontalSpacing;
|
|
|
|
Size size = new Size();
|
|
|
|
if (_TabStripItem.CloseButtonOnTabsVisible && CloseButtonVisible)
|
|
{
|
|
size += CloseButtonBounds.Size;
|
|
|
|
size.Width += spacing;
|
|
size.Height += spacing;
|
|
}
|
|
|
|
if (IsVertical == true)
|
|
{
|
|
Rectangle t = r;
|
|
|
|
if (TabStripItem.CloseButtonPosition == eTabCloseButtonPosition.Right)
|
|
r.Y += size.Width;
|
|
|
|
r.Height -= (size.Width + spacing);
|
|
|
|
if (TabStripItem.RotateVerticalText ^
|
|
TabStripItem.TabAlignment == eTabStripAlignment.Right)
|
|
{
|
|
r.X = t.X + (t.Right - r.Right);
|
|
r.Y = t.Y + (t.Bottom - r.Bottom);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (size.Width > 0)
|
|
{
|
|
if (_TabStripItem.CloseButtonPosition == eTabCloseButtonPosition.Left)
|
|
r.X += (size.Width + spacing);
|
|
|
|
r.Width -= (size.Width + spacing);
|
|
}
|
|
|
|
r.X += spacing;
|
|
r.Width -= (spacing * 2);
|
|
|
|
if (IsSelected == true)
|
|
{
|
|
if (_TabStripItem.TabAlignment == eTabStripAlignment.Right)
|
|
r.X += _TabStripItem.TabDisplay.SelectedPaddingWidth;
|
|
}
|
|
}
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ProcessImageBounds
|
|
|
|
/// <summary>
|
|
/// Calculates Image bounds
|
|
/// </summary>
|
|
/// <param name="r">Running rectangle</param>
|
|
/// <returns>Running rectangle</returns>
|
|
private Rectangle ProcessImageBounds(Rectangle r)
|
|
{
|
|
CompositeImage image = GetTabImage();
|
|
|
|
if (String.IsNullOrEmpty(SymbolRealized) == false || image != null)
|
|
{
|
|
r = (IsVertical == true)
|
|
? SubVerticalImageBounds(image, r)
|
|
: SubHorizontalImageBounds(image, r);
|
|
}
|
|
|
|
return (r);
|
|
}
|
|
|
|
#region SubHorizontalImageBounds
|
|
|
|
private Rectangle SubHorizontalImageBounds(CompositeImage image, Rectangle r)
|
|
{
|
|
int h = 0;
|
|
int w = 0;
|
|
|
|
if (string.IsNullOrEmpty(SymbolRealized) == false)
|
|
{
|
|
Size size = GetSymbolSize();
|
|
|
|
w = size.Width;
|
|
h = size.Height;
|
|
}
|
|
else
|
|
{
|
|
w = image.Width;
|
|
h = image.Height;
|
|
}
|
|
|
|
w += (_TabStripItem.TabHorizontalSpacing + ImagePadding.Horizontal);
|
|
h += (_TabStripItem.TabVerticalSpacing + ImagePadding.Vertical);
|
|
|
|
switch (EffectiveImageAlignment)
|
|
{
|
|
case ImageAlignment.TopLeft:
|
|
case ImageAlignment.TopCenter:
|
|
case ImageAlignment.TopRight:
|
|
r.Y += h;
|
|
r.Height -= h;
|
|
break;
|
|
|
|
case ImageAlignment.MiddleLeft:
|
|
r.X += w;
|
|
r.Width -= w;
|
|
break;
|
|
|
|
case ImageAlignment.MiddleRight:
|
|
r.Width -= w;
|
|
break;
|
|
|
|
case ImageAlignment.BottomLeft:
|
|
case ImageAlignment.BottomCenter:
|
|
case ImageAlignment.BottomRight:
|
|
r.Height -= h;
|
|
break;
|
|
}
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SubVerticalImageBounds
|
|
|
|
private Rectangle SubVerticalImageBounds(CompositeImage image, Rectangle r)
|
|
{
|
|
int h = 0;
|
|
int w = 0;
|
|
|
|
if (string.IsNullOrEmpty(SymbolRealized) == false)
|
|
{
|
|
Size size = GetSymbolSize();
|
|
|
|
w = size.Width;
|
|
h = size.Height;
|
|
}
|
|
else
|
|
{
|
|
w = image.Width;
|
|
h = image.Height;
|
|
}
|
|
|
|
w += (_TabStripItem.TabHorizontalSpacing + ImagePadding.Horizontal);
|
|
h += (_TabStripItem.TabVerticalSpacing + ImagePadding.Vertical);
|
|
|
|
Rectangle t = r;
|
|
|
|
switch (EffectiveImageAlignment)
|
|
{
|
|
case ImageAlignment.TopLeft:
|
|
case ImageAlignment.TopCenter:
|
|
case ImageAlignment.TopRight:
|
|
r.X += h;
|
|
r.Width -= h;
|
|
break;
|
|
|
|
case ImageAlignment.MiddleLeft:
|
|
r.Height -= w;
|
|
break;
|
|
|
|
case ImageAlignment.MiddleRight:
|
|
r.Y += w;
|
|
r.Height -= w;
|
|
break;
|
|
|
|
case ImageAlignment.BottomLeft:
|
|
case ImageAlignment.BottomCenter:
|
|
case ImageAlignment.BottomRight:
|
|
r.Width -= h;
|
|
break;
|
|
}
|
|
|
|
if (TabStripItem.RotateVerticalText ^
|
|
TabStripItem.TabAlignment == eTabStripAlignment.Right)
|
|
{
|
|
r.X = t.X + (t.Right - r.Right);
|
|
r.Y = t.Y + (t.Bottom - r.Bottom);
|
|
}
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region RefreshOwner
|
|
|
|
/// <summary>
|
|
/// Refreshes the tab owner
|
|
/// </summary>
|
|
private void RefreshOwner()
|
|
{
|
|
if (_TabStripItem != null)
|
|
{
|
|
_TabStripItem.NeedRecalcSize = true;
|
|
_TabStripItem.Refresh();
|
|
}
|
|
|
|
Refresh();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Refresh
|
|
|
|
/// <summary>
|
|
/// Refreshes the tab display
|
|
/// </summary>
|
|
public override void Refresh()
|
|
{
|
|
if (SuspendLayout == false)
|
|
{
|
|
if (Visible == true && Displayed == true && TabStripItem != null)
|
|
{
|
|
Control objCtrl = TabStripItem.ContainerControl as Control;
|
|
|
|
if (objCtrl != null && IsHandleValid(objCtrl))
|
|
{
|
|
if (NeedRecalcSize == true)
|
|
{
|
|
if (Parent is ItemContainer)
|
|
{
|
|
Parent.RecalcSize();
|
|
}
|
|
else
|
|
{
|
|
RecalcSize();
|
|
|
|
if (Parent != null)
|
|
Parent.SubItemSizeChanged(this);
|
|
}
|
|
}
|
|
|
|
Invalidate(objCtrl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Paint
|
|
|
|
/// <summary>
|
|
/// Paint processing
|
|
/// </summary>
|
|
/// <param name="p"></param>
|
|
public override void Paint(ItemPaintArgs p)
|
|
{
|
|
if (_TabItemDisplay != null)
|
|
_TabItemDisplay.Paint(p);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Mouse support
|
|
|
|
#region InternalMouseMove
|
|
|
|
/// <summary>
|
|
/// InternalMouseMove
|
|
/// </summary>
|
|
/// <param name="objArg"></param>
|
|
public override void InternalMouseMove(MouseEventArgs objArg)
|
|
{
|
|
base.InternalMouseMove(objArg);
|
|
|
|
CloseButtonMouseOver =
|
|
CloseButtonBounds.Contains(objArg.Location);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseEnter
|
|
|
|
/// <summary>
|
|
/// InternalMouseEnter
|
|
/// </summary>
|
|
public override void InternalMouseEnter()
|
|
{
|
|
base.InternalMouseEnter();
|
|
|
|
Refresh();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseLeave
|
|
|
|
/// <summary>
|
|
/// InternalMouseLeave
|
|
/// </summary>
|
|
public override void InternalMouseLeave()
|
|
{
|
|
base.InternalMouseLeave();
|
|
|
|
CloseButtonMouseOver = false;
|
|
CloseButtonPressed = false;
|
|
|
|
Refresh();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseDown
|
|
|
|
/// <summary>
|
|
/// InternalMouseDown
|
|
/// </summary>
|
|
/// <param name="objArg"></param>
|
|
public override void InternalMouseDown(MouseEventArgs objArg)
|
|
{
|
|
base.InternalMouseDown(objArg);
|
|
|
|
if (CloseButtonMouseOver == true)
|
|
{
|
|
CloseButtonPressed =
|
|
((objArg.Button & MouseButtons.Left) == MouseButtons.Left);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseUp
|
|
|
|
/// <summary>
|
|
/// InternalMouseUp
|
|
/// </summary>
|
|
/// <param name="objArg"></param>
|
|
public override void InternalMouseUp(MouseEventArgs objArg)
|
|
{
|
|
base.InternalMouseUp(objArg);
|
|
|
|
CloseButtonPressed = false;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region UpdateChangeHandler
|
|
|
|
protected void UpdateChangeHandler(
|
|
INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
|
|
{
|
|
if (oldValue != null)
|
|
oldValue.PropertyChanged -= ValuePropertyChanged;
|
|
|
|
if (newValue != null)
|
|
newValue.PropertyChanged += ValuePropertyChanged;
|
|
}
|
|
|
|
void ValuePropertyChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
RefreshOwner();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ToString
|
|
|
|
/// <summary>
|
|
/// ToString
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override string ToString()
|
|
{
|
|
return (Text);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Dispose
|
|
|
|
/// <summary>
|
|
/// Dispose
|
|
/// </summary>
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (disposing == true && IsDisposed == false)
|
|
HookEvents(false);
|
|
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Copy
|
|
|
|
/// <summary>
|
|
/// Returns copy of the item.
|
|
/// </summary>
|
|
public override BaseItem Copy()
|
|
{
|
|
SuperTabItem objCopy = new SuperTabItem();
|
|
CopyToItem(objCopy);
|
|
|
|
return (objCopy);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies specific properties to new instance of the item.
|
|
/// </summary>
|
|
/// <param name="copy">New SuperTabItem instance</param>
|
|
protected override void CopyToItem(BaseItem copy)
|
|
{
|
|
SuperTabItem objCopy = copy as SuperTabItem;
|
|
|
|
if (objCopy != null)
|
|
{
|
|
base.CopyToItem(objCopy);
|
|
|
|
objCopy.TabColor = _TabColor;
|
|
objCopy.CloseButtonVisible = _CloseButtonVisible;
|
|
objCopy.EnableImageAnimation = _EnableImageAnimation;
|
|
objCopy.EnableMarkup = _EnableMarkup;
|
|
objCopy.Icon = _Icon;
|
|
objCopy.Image = _Image;
|
|
objCopy.ImageIndex = _ImageIndex;
|
|
objCopy.PredefinedColor = _PredefinedColor;
|
|
objCopy.SelectedTabFont = _SelectedTabFont;
|
|
objCopy.TextAlignment = _TextAlignment;
|
|
objCopy.TabFont = _TabFont;
|
|
objCopy.Symbol = _Symbol;
|
|
objCopy.SymbolSet = _SymbolSet;
|
|
objCopy.SymbolColor = _SymbolColor;
|
|
objCopy.SymbolSize = _SymbolSize;
|
|
objCopy.AttachedControl = _AttachedControl;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#region enums
|
|
|
|
#region ImageAlignment
|
|
|
|
///<summary>
|
|
/// Alignment
|
|
///</summary>
|
|
public enum ImageAlignment
|
|
{
|
|
///<summary>
|
|
///</summary>
|
|
NotSet = -1,
|
|
|
|
///<summary>
|
|
/// TopLeft
|
|
///</summary>
|
|
TopLeft,
|
|
|
|
///<summary>
|
|
/// TopCenter
|
|
///</summary>
|
|
TopCenter,
|
|
|
|
///<summary>
|
|
/// TopRight
|
|
///</summary>
|
|
TopRight,
|
|
|
|
///<summary>
|
|
/// MiddleLeft
|
|
///</summary>
|
|
MiddleLeft,
|
|
|
|
///<summary>
|
|
/// MiddleCenter
|
|
///</summary>
|
|
MiddleCenter,
|
|
|
|
/// <summary>
|
|
/// MiddleRight
|
|
/// </summary>
|
|
MiddleRight,
|
|
|
|
/// <summary>
|
|
/// BottomLeft
|
|
/// </summary>
|
|
BottomLeft,
|
|
|
|
/// <summary>
|
|
/// BottomCenter
|
|
/// </summary>
|
|
BottomCenter,
|
|
|
|
/// <summary>
|
|
/// BottomRight
|
|
/// </summary>
|
|
BottomRight,
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region eSuperTabArea
|
|
|
|
/// <summary>
|
|
/// Tab area parts
|
|
/// </summary>
|
|
public enum eSuperTabArea
|
|
{
|
|
InNone,
|
|
InContent,
|
|
InImage,
|
|
InCloseBox
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region eTabState
|
|
|
|
/// <summary>
|
|
/// Tab states
|
|
/// </summary>
|
|
public enum eTabState
|
|
{
|
|
Default,
|
|
Selected,
|
|
MouseOver,
|
|
SelectedMouseOver,
|
|
|
|
Disabled,
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
}
|
|
#endif |