1319 lines
40 KiB
C#
1319 lines
40 KiB
C#
#if FRAMEWORK20
|
|
using System;
|
|
using System.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Drawing.Imaging;
|
|
using System.Windows.Forms;
|
|
using DevComponents.DotNetBar.Rendering;
|
|
|
|
namespace DevComponents.DotNetBar
|
|
{
|
|
public class SuperTabItemBaseDisplay : IDisposable
|
|
{
|
|
#region Private variables
|
|
|
|
private SuperTabItem _TabItem;
|
|
|
|
private Bitmap _CloseButtonBitmap;
|
|
private Bitmap _CloseButtonHotBitmap;
|
|
private Bitmap _CloseButtonPressedBitmap;
|
|
private Color _CloseMarkerColor;
|
|
|
|
private SuperTabItemColorTable _DefaultTabColorTable;
|
|
private SuperTabPanelColorTable _DefaultPanelColorTable;
|
|
|
|
private bool _CurrentlyAnimating;
|
|
private Image _AnimateImage;
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Constructor
|
|
/// </summary>
|
|
/// <param name="tabItem">Associated SuperTabItem</param>
|
|
public SuperTabItemBaseDisplay(SuperTabItem tabItem)
|
|
{
|
|
_TabItem = tabItem;
|
|
|
|
SetDefaultColorTable();
|
|
}
|
|
|
|
#region Internal properties
|
|
|
|
/// <summary>
|
|
/// Gets or sets the default item ColorTable
|
|
/// </summary>
|
|
internal SuperTabItemColorTable DefaultItemColorTable
|
|
{
|
|
get { return (_DefaultTabColorTable); }
|
|
set { _DefaultTabColorTable = value; }
|
|
}
|
|
|
|
#region TabItem
|
|
|
|
internal SuperTabItem TabItem
|
|
{
|
|
get { return (_TabItem); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TabStripItem
|
|
|
|
internal SuperTabStripItem TabStripItem
|
|
{
|
|
get { return (_TabItem.TabStripItem); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TabDisplay
|
|
|
|
internal SuperTabStripBaseDisplay TabDisplay
|
|
{
|
|
get { return (_TabItem.TabStripItem.TabDisplay); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Paint
|
|
|
|
/// <summary>
|
|
/// Paint processing
|
|
/// </summary>
|
|
/// <param name="p"></param>
|
|
public virtual void Paint(ItemPaintArgs p)
|
|
{
|
|
if (TabItem.Visible == true)
|
|
{
|
|
Graphics g = p.Graphics;
|
|
|
|
if (TabStripItem.OnPreRenderTabItem(TabItem, g) == false)
|
|
{
|
|
SuperTabItemStateColorTable colors = GetTabColorTable();
|
|
|
|
using (GraphicsPath path = TabItemPath())
|
|
{
|
|
DrawTabItemBackground(g, path, colors);
|
|
|
|
DrawTabContent(g, colors);
|
|
DrawTabBorder(g, path, colors);
|
|
|
|
TabStripItem.OnPostRenderTabItem(TabItem, g);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetContentRectangle
|
|
|
|
/// <summary>
|
|
/// Gets the default tab ContentRectangle
|
|
/// </summary>
|
|
/// <returns>Rectangle</returns>
|
|
internal virtual Rectangle ContentRectangle()
|
|
{
|
|
return (_TabItem.DisplayRectangle);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the tab ContentRectangle
|
|
/// </summary>
|
|
/// <returns>Rectangle</returns>
|
|
internal Rectangle GetContentRectangle()
|
|
{
|
|
Rectangle r = TabStripItem.OnGetTabItemContentRectangle(_TabItem);
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TabItemPath
|
|
|
|
/// <summary>
|
|
/// Gets the tab path
|
|
/// </summary>
|
|
/// <returns>GraphicsPath</returns>
|
|
internal virtual GraphicsPath TabItemPath()
|
|
{
|
|
GraphicsPath path = TabStripItem.OnGetTabItemPath(_TabItem);
|
|
|
|
return (path);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SetDefaultColorTable
|
|
|
|
/// <summary>
|
|
/// Sets the default color tables
|
|
/// </summary>
|
|
internal void SetDefaultColorTable()
|
|
{
|
|
_DefaultTabColorTable =
|
|
SuperTabStyleColorFactory.GetItemColorTable(TabItem.TabStyle, ColorFactory.Empty);
|
|
|
|
_DefaultPanelColorTable =
|
|
SuperTabStyleColorFactory.GetPanelColorTable(TabItem.TabStyle, ColorFactory.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetColorTable
|
|
|
|
/// <summary>
|
|
/// Gets the tab ColorTable
|
|
/// </summary>
|
|
/// <returns>ColorTable</returns>
|
|
internal virtual SuperTabItemStateColorTable GetTabColorTable()
|
|
{
|
|
eTabState tabState = GetTabState();
|
|
|
|
return (GetTabColorTable(tabState));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the tab state
|
|
/// </summary>
|
|
/// <returns>eTabState</returns>
|
|
private eTabState GetTabState()
|
|
{
|
|
if (TabItem.Enabled == false)
|
|
return (eTabState.Disabled);
|
|
|
|
if (TabItem == TabStripItem.HotTab)
|
|
return (TabItem.IsSelected ? eTabState.SelectedMouseOver : eTabState.MouseOver);
|
|
|
|
return (TabItem.IsSelected ? eTabState.Selected : eTabState.Default);
|
|
}
|
|
|
|
#region GetTabColorTable
|
|
|
|
internal virtual SuperTabItemStateColorTable GetTabColorTable(eTabState tabState)
|
|
{
|
|
SuperTabItemStateColorTable sct = GetTabColorTableEx(tabState);
|
|
|
|
if (sct.SelectionMarker.IsEmpty == true &&
|
|
(tabState == eTabState.Selected || tabState == eTabState.SelectedMouseOver))
|
|
{
|
|
using (SuperTabColorTable ct = TabDisplay.GetColorTable())
|
|
sct.SelectionMarker = ct.SelectionMarker;
|
|
}
|
|
|
|
return (sct);
|
|
}
|
|
|
|
internal SuperTabItemStateColorTable GetTabColorTableEx(eTabState tabState)
|
|
{
|
|
SuperTabItemStateColorTable sct = GetStateColorTable(tabState, _DefaultTabColorTable.Default);
|
|
SuperTabItemStateColorTable tct = GetStateColorTable(tabState, TabItem.TabColor.Default);
|
|
|
|
sct = (SuperTabItemStateColorTable)sct.Clone();
|
|
tct = (SuperTabItemStateColorTable)tct.Clone();
|
|
|
|
switch (TabItem.TabAlignment)
|
|
{
|
|
case eTabStripAlignment.Left:
|
|
ApplyTabColors(sct, GetStateColorTable(tabState, _DefaultTabColorTable.Left));
|
|
ApplyTabColors(tct, GetStateColorTable(tabState, TabItem.TabColor.Left));
|
|
break;
|
|
|
|
case eTabStripAlignment.Bottom:
|
|
ApplyTabColors(sct, GetStateColorTable(tabState, _DefaultTabColorTable.Bottom));
|
|
ApplyTabColors(tct, GetStateColorTable(tabState, TabItem.TabColor.Bottom));
|
|
break;
|
|
|
|
case eTabStripAlignment.Right:
|
|
ApplyTabColors(sct, GetStateColorTable(tabState, _DefaultTabColorTable.Right));
|
|
ApplyTabColors(tct, GetStateColorTable(tabState, TabItem.TabColor.Right));
|
|
break;
|
|
}
|
|
|
|
ApplyPredefinedColor(tabState, sct);
|
|
ApplyTabColors(sct, tct);
|
|
|
|
return (sct);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetStateColorTable
|
|
|
|
private SuperTabItemStateColorTable GetStateColorTable(
|
|
eTabState tabState, SuperTabColorStates cs)
|
|
{
|
|
switch (tabState)
|
|
{
|
|
case eTabState.MouseOver:
|
|
return (cs.MouseOver);
|
|
|
|
case eTabState.Selected:
|
|
return (cs.Selected);
|
|
|
|
case eTabState.SelectedMouseOver:
|
|
return (cs.SelectedMouseOver);
|
|
|
|
case eTabState.Disabled:
|
|
return (cs.Disabled);
|
|
|
|
default:
|
|
return (cs.Normal);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ApplyPredefinedColor
|
|
|
|
internal virtual void ApplyPredefinedColor(eTabState tabState, SuperTabItemStateColorTable sct)
|
|
{
|
|
if (TabItem.PredefinedColor != eTabItemColor.Default)
|
|
{
|
|
SuperTabItemColorTable ct =
|
|
SuperTabStyleColorFactory.GetPredefinedTabColors(TabItem.PredefinedColor, ColorFactory.Empty);
|
|
|
|
SuperTabItemStateColorTable ict = ct.Default.Normal;
|
|
|
|
switch (tabState)
|
|
{
|
|
case eTabState.SelectedMouseOver:
|
|
ict = ct.Default.SelectedMouseOver;
|
|
break;
|
|
|
|
case eTabState.MouseOver:
|
|
ict = ct.Default.MouseOver;
|
|
break;
|
|
|
|
case eTabState.Selected:
|
|
ict = ct.Default.Selected;
|
|
break;
|
|
}
|
|
|
|
sct.Text = ict.Text;
|
|
sct.InnerBorder = ict.InnerBorder;
|
|
sct.OuterBorder = ict.OuterBorder;
|
|
sct.Background = ict.Background;
|
|
sct.CloseMarker = ict.CloseMarker;
|
|
sct.SelectionMarker = ict.SelectionMarker;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ApplyTabColors
|
|
|
|
private void ApplyTabColors(
|
|
SuperTabItemStateColorTable sct, SuperTabItemStateColorTable tct)
|
|
{
|
|
if (tct.Background.IsEmpty == false)
|
|
{
|
|
if (tct.Background.IsEmpty == false)
|
|
{
|
|
if (tct.Background.Colors != null)
|
|
sct.Background.Colors = tct.Background.Colors;
|
|
|
|
if (tct.Background.Positions != null)
|
|
sct.Background.Positions = tct.Background.Positions;
|
|
|
|
if (tct.Background.AdaptiveGradient.HasValue)
|
|
sct.Background.AdaptiveGradient = tct.Background.AdaptiveGradient;
|
|
}
|
|
|
|
sct.Background.GradientAngle = tct.Background.GradientAngle;
|
|
}
|
|
|
|
if (tct.InnerBorder != Color.Empty)
|
|
sct.InnerBorder = tct.InnerBorder;
|
|
|
|
if (tct.OuterBorder != Color.Empty)
|
|
sct.OuterBorder = tct.OuterBorder;
|
|
|
|
if (tct.Text != Color.Empty)
|
|
sct.Text = tct.Text;
|
|
|
|
if (tct.CloseMarker != Color.Empty)
|
|
sct.CloseMarker = tct.CloseMarker;
|
|
|
|
if (tct.SelectionMarker != Color.Empty)
|
|
sct.SelectionMarker = tct.SelectionMarker;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetPanelColorTable
|
|
|
|
/// <summary>
|
|
/// Gets the tab panel Color Table
|
|
/// </summary>
|
|
/// <returns>Color Table</returns>
|
|
internal virtual SuperTabPanelItemColorTable GetPanelColorTable()
|
|
{
|
|
SuperTabPanelItemColorTable sct =
|
|
(SuperTabPanelItemColorTable)_DefaultPanelColorTable.Default.Clone();
|
|
|
|
SuperTabControlPanel cp = TabItem.AttachedControl as SuperTabControlPanel;
|
|
|
|
if (cp != null)
|
|
{
|
|
SuperTabPanelItemColorTable tct =
|
|
(SuperTabPanelItemColorTable) cp.PanelColor.Default.Clone();
|
|
|
|
switch (TabItem.TabAlignment)
|
|
{
|
|
case eTabStripAlignment.Left:
|
|
ApplyPanelColors(sct, _DefaultPanelColorTable.Left);
|
|
ApplyPanelColors(tct, cp.PanelColor.Left);
|
|
break;
|
|
|
|
case eTabStripAlignment.Bottom:
|
|
ApplyPanelColors(sct, _DefaultPanelColorTable.Bottom);
|
|
ApplyPanelColors(tct, cp.PanelColor.Bottom);
|
|
break;
|
|
|
|
case eTabStripAlignment.Right:
|
|
ApplyPanelColors(sct, _DefaultPanelColorTable.Right);
|
|
ApplyPanelColors(tct, cp.PanelColor.Right);
|
|
break;
|
|
}
|
|
|
|
ApplyPredefinedColor(sct);
|
|
ApplyPanelColors(sct, tct);
|
|
}
|
|
|
|
return (sct);
|
|
}
|
|
|
|
#region ApplyPredefinedColor
|
|
|
|
internal virtual void ApplyPredefinedColor(SuperTabPanelItemColorTable pct)
|
|
{
|
|
if (TabItem.PredefinedColor != eTabItemColor.Default)
|
|
{
|
|
SuperTabPanelItemColorTable ct =
|
|
SuperTabStyleColorFactory.GetPredefinedPanelColors(TabItem.PredefinedColor, ColorFactory.Empty);
|
|
|
|
pct.InnerBorder = ct.InnerBorder;
|
|
pct.OuterBorder = ct.OuterBorder;
|
|
|
|
pct.Background = ct.Background;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ApplyPanelColors
|
|
|
|
private void ApplyPanelColors(SuperTabPanelItemColorTable sct, SuperTabPanelItemColorTable tct)
|
|
{
|
|
if (tct.Background.IsEmpty == false)
|
|
{
|
|
if (tct.Background.Colors != null)
|
|
sct.Background.Colors = tct.Background.Colors;
|
|
|
|
if (tct.Background.Positions != null)
|
|
sct.Background.Positions = tct.Background.Positions;
|
|
|
|
if (tct.Background.AdaptiveGradient.HasValue)
|
|
sct.Background.AdaptiveGradient = tct.Background.AdaptiveGradient;
|
|
|
|
sct.Background.GradientAngle = tct.Background.GradientAngle;
|
|
}
|
|
|
|
if (tct.InnerBorder.IsEmpty == false)
|
|
sct.InnerBorder = tct.InnerBorder;
|
|
|
|
if (tct.OuterBorder.IsEmpty == false)
|
|
sct.OuterBorder = tct.OuterBorder;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region DrawTabItemBackground
|
|
|
|
/// <summary>
|
|
/// Draws the tab background
|
|
/// </summary>
|
|
/// <param name="g">Graphics</param>
|
|
/// <param name="path">Tab path</param>
|
|
/// <param name="tabColors">StateColorTable</param>
|
|
protected virtual void DrawTabItemBackground(
|
|
Graphics g, GraphicsPath path, SuperTabItemStateColorTable tabColors)
|
|
{
|
|
Rectangle r = Rectangle.Round(path.GetBounds());
|
|
|
|
if (r.Width > 0 && r.Height > 0)
|
|
{
|
|
if (tabColors.Background.Colors != null)
|
|
{
|
|
if (tabColors.Background.Colors.Length == 1)
|
|
DrawTabItemSolidBackground(g, path, tabColors, r);
|
|
else
|
|
DrawTabItemGradientBackground(g, path, tabColors, r);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region DrawTabItemSolidBackground
|
|
|
|
internal void DrawTabItemSolidBackground(
|
|
Graphics g, GraphicsPath path, SuperTabItemStateColorTable tabColors, Rectangle r)
|
|
{
|
|
using (Brush br = tabColors.Background.GetBrush(r))
|
|
{
|
|
if (br != null)
|
|
{
|
|
g.FillPath(br, path);
|
|
|
|
using (Pen pen = new Pen(tabColors.Background.Colors[0]))
|
|
{
|
|
int n = (_TabItem.IsSelected == true) ? 3 : 1;
|
|
|
|
for (int i = 0; i < n; i++)
|
|
{
|
|
switch (_TabItem.TabAlignment)
|
|
{
|
|
case eTabStripAlignment.Top:
|
|
g.DrawLine(pen, r.X, r.Bottom + i, r.Right, r.Bottom + i);
|
|
break;
|
|
|
|
case eTabStripAlignment.Left:
|
|
g.DrawLine(pen, r.Right + i, r.Top, r.Right + i, r.Bottom);
|
|
break;
|
|
|
|
case eTabStripAlignment.Bottom:
|
|
g.DrawLine(pen, r.X, r.Top - i, r.Right, r.Top - i);
|
|
break;
|
|
|
|
case eTabStripAlignment.Right:
|
|
g.DrawLine(pen, r.X - i, r.Top, r.X - i, r.Bottom);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DrawTabItemGradientBackground
|
|
|
|
internal void DrawTabItemGradientBackground(
|
|
Graphics g, GraphicsPath path, SuperTabItemStateColorTable tabColors, Rectangle r)
|
|
{
|
|
int angle = tabColors.Background.GradientAngle;
|
|
|
|
if (tabColors.Background.AdaptiveGradient != false)
|
|
{
|
|
switch (_TabItem.TabAlignment)
|
|
{
|
|
case eTabStripAlignment.Left:
|
|
angle -= 90;
|
|
break;
|
|
|
|
case eTabStripAlignment.Bottom:
|
|
angle += 180;
|
|
break;
|
|
|
|
case eTabStripAlignment.Right:
|
|
angle += 90;
|
|
break;
|
|
}
|
|
}
|
|
|
|
using (LinearGradientBrush lbr =
|
|
(LinearGradientBrush)tabColors.Background.GetBrush(r, angle))
|
|
{
|
|
if (lbr != null)
|
|
{
|
|
lbr.WrapMode = WrapMode.TileFlipXY;
|
|
|
|
g.FillPath(lbr, path);
|
|
|
|
SmoothingMode sm = g.SmoothingMode;
|
|
g.SmoothingMode = SmoothingMode.None;
|
|
|
|
int n = (_TabItem.IsSelected == true) ? 3 : 1;
|
|
|
|
switch (_TabItem.TabAlignment)
|
|
{
|
|
case eTabStripAlignment.Top:
|
|
g.FillRectangle(lbr, r.X, r.Bottom, r.Width, n);
|
|
break;
|
|
|
|
case eTabStripAlignment.Left:
|
|
g.FillRectangle(lbr, r.Right, r.Top, n, r.Height);
|
|
break;
|
|
|
|
case eTabStripAlignment.Bottom:
|
|
g.FillRectangle(lbr, r.X, r.Top - n + 1, r.Width, n);
|
|
break;
|
|
|
|
case eTabStripAlignment.Right:
|
|
g.FillRectangle(lbr, r.X - n + 1, r.Top, n, r.Height);
|
|
break;
|
|
}
|
|
|
|
g.SmoothingMode = sm;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region DrawTabBorder
|
|
|
|
/// <summary>
|
|
/// Draws the tab border
|
|
/// </summary>
|
|
/// <param name="g">Graphics</param>
|
|
/// <param name="path">Tab path</param>
|
|
/// <param name="ct">Color table</param>
|
|
protected virtual void DrawTabBorder(
|
|
Graphics g, GraphicsPath path, SuperTabItemStateColorTable ct)
|
|
{
|
|
if (ct.InnerBorder.IsEmpty == false)
|
|
{
|
|
using (Pen pen = new Pen(ct.InnerBorder, 2))
|
|
{
|
|
Region rgn = g.Clip;
|
|
g.SetClip(path);
|
|
|
|
g.DrawPath(pen, path);
|
|
g.DrawPath(pen, path);
|
|
g.DrawPath(pen, path);
|
|
g.DrawPath(pen, path);
|
|
|
|
g.Clip = rgn;
|
|
if (rgn != null) rgn.Dispose();
|
|
}
|
|
}
|
|
|
|
if (ct.OuterBorder.IsEmpty == false)
|
|
{
|
|
using (Pen pen = new Pen(ct.OuterBorder))
|
|
g.DrawPath(pen, path);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DrawTabContent
|
|
|
|
/// <summary>
|
|
/// Draws the tab contents
|
|
/// </summary>
|
|
/// <param name="g">Graphics</param>
|
|
/// <param name="colors">State color table</param>
|
|
protected virtual void DrawTabContent(Graphics g, SuperTabItemStateColorTable colors)
|
|
{
|
|
// Draw image and text
|
|
|
|
if (DrawTabSymbol(g) == false)
|
|
DrawTabImage(g);
|
|
|
|
DrawTabText(g, colors);
|
|
|
|
// Draw the close button
|
|
|
|
if (TabStripItem.CloseButtonOnTabsVisible && TabItem.CloseButtonVisible)
|
|
{
|
|
if (TabStripItem.CloseButtonOnTabsAlwaysDisplayed == true || TabItem.IsMouseOver == true)
|
|
DrawCloseButton(g, colors);
|
|
}
|
|
}
|
|
|
|
#region DrawTabSymbol
|
|
|
|
private bool DrawTabSymbol(Graphics g)
|
|
{
|
|
if (string.IsNullOrEmpty(TabItem.SymbolRealized) == false)
|
|
{
|
|
Font font = Symbols.GetFont(TabItem.SymbolSize, TabItem.SymbolSet);
|
|
|
|
Color color = GetSymbolColor();
|
|
|
|
Region clip = g.Clip;
|
|
|
|
g.SetClip(TabItem.ContentRectangle, CombineMode.Intersect);
|
|
|
|
Rectangle r = SetTransform(g, TabItem.ImageBounds);
|
|
r.Height += 10;
|
|
|
|
if (TabItem.IsVertical == true)
|
|
{
|
|
if ((TabStripItem.TabAlignment == eTabStripAlignment.Right && TabStripItem.RotateVerticalText == false) ||
|
|
(TabStripItem.TabAlignment == eTabStripAlignment.Left && TabStripItem.RotateVerticalText == true))
|
|
{
|
|
r.X += TabStripItem.TabHorizontalSpacing;
|
|
}
|
|
}
|
|
|
|
TextDrawing.DrawStringLegacy(g, TabItem.SymbolRealized, font, color,
|
|
r, eTextFormat.Default | eTextFormat.HorizontalCenter);
|
|
|
|
ResetTransform(g);
|
|
|
|
g.Clip = clip;
|
|
|
|
return (true);
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
#region GetSymbolColor
|
|
|
|
internal Color GetSymbolColor()
|
|
{
|
|
if (TabItem.SymbolColor.IsEmpty == false)
|
|
return (TabItem.SymbolColor);
|
|
|
|
eTabState state = GetTabState();
|
|
SuperTabItemStateColorTable sct = TabItem.GetTabColorTableEx(state);
|
|
|
|
return ((sct.Text.IsEmpty == false) ? sct.Text : SystemColors.ControlDark);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region DrawTabImage
|
|
|
|
/// <summary>
|
|
/// Draws the tab image
|
|
/// </summary>
|
|
/// <param name="g">Graphics</param>
|
|
protected virtual void DrawTabImage(Graphics g)
|
|
{
|
|
CompositeImage image = TabItem.GetTabImage();
|
|
|
|
if (image != null)
|
|
{
|
|
if (_CurrentlyAnimating == true)
|
|
{
|
|
if (TabItem.CanAnimateImage == false)
|
|
StopImageAnimation();
|
|
}
|
|
|
|
if (TabItem.CanAnimateImage == true)
|
|
{
|
|
if (_CurrentlyAnimating == false)
|
|
StartImageAnimation(image.Image);
|
|
|
|
ImageAnimator.UpdateFrames();
|
|
}
|
|
|
|
Region clip = g.Clip;
|
|
|
|
g.SetClip(TabItem.ContentRectangle, CombineMode.Intersect);
|
|
|
|
Rectangle t = TabItem.ImageBounds;
|
|
|
|
if (TabItem.IsVertical == true)
|
|
{
|
|
int w = t.Width;
|
|
t.Width = t.Height;
|
|
t.Height = w;
|
|
}
|
|
|
|
Rectangle r = SetTransform(g, t);
|
|
|
|
image.DrawImage(g, r);
|
|
|
|
ResetTransform(g);
|
|
|
|
g.Clip = clip;
|
|
}
|
|
}
|
|
|
|
#region StartImageAnimation
|
|
|
|
internal void StartImageAnimation(Image image)
|
|
{
|
|
_CurrentlyAnimating = true;
|
|
_AnimateImage = image;
|
|
|
|
ImageAnimator.Animate(image, OnFrameChanged);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region StopImageAnimation
|
|
|
|
internal void StopImageAnimation()
|
|
{
|
|
if (_CurrentlyAnimating == true)
|
|
{
|
|
_CurrentlyAnimating = false;
|
|
|
|
ImageAnimator.StopAnimate(_AnimateImage, OnFrameChanged);
|
|
|
|
FrameDimension frameDimensions =
|
|
new FrameDimension(_AnimateImage.FrameDimensionsList[0]);
|
|
|
|
_AnimateImage.SelectActiveFrame(frameDimensions, 0);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OnFrameChanged
|
|
|
|
private void OnFrameChanged(object o, EventArgs e)
|
|
{
|
|
if (_CurrentlyAnimating == true &&
|
|
TabItem.Visible == true && TabItem.Parent != null)
|
|
{
|
|
TabItem.Refresh();
|
|
}
|
|
else
|
|
{
|
|
_CurrentlyAnimating = false;
|
|
|
|
ImageAnimator.StopAnimate((Image)o, OnFrameChanged);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region DrawTabText
|
|
|
|
/// <summary>
|
|
/// Draws the tab text
|
|
/// </summary>
|
|
/// <param name="g"></param>
|
|
/// <param name="colors"></param>
|
|
protected virtual void DrawTabText(Graphics g, SuperTabItemStateColorTable colors)
|
|
{
|
|
if (TabStripItem.DisplaySelectedTextOnly == false || TabItem.IsSelected == true)
|
|
{
|
|
Rectangle r = TabItem.TextBounds;
|
|
|
|
if (r.Height > 0 && r.Width > 0)
|
|
{
|
|
Font font = TabItem.GetTabFont();
|
|
|
|
if (TabItem.IsVertical == false)
|
|
{
|
|
if (TabItem.TextMarkupBody != null)
|
|
{
|
|
r = AlignText(r);
|
|
|
|
TextMarkup.MarkupDrawContext d =
|
|
new TextMarkup.MarkupDrawContext(g, font, colors.Text, TabItem.IsRightToLeft);
|
|
|
|
TabItem.TextMarkupBody.Arrange(new
|
|
Rectangle(r.Location, TabItem.TextMarkupBody.Bounds.Size), d);
|
|
|
|
RenderMarkup(g, r, d);
|
|
}
|
|
else
|
|
{
|
|
eTextFormat strFormat;
|
|
|
|
r = AlignText(r, out strFormat);
|
|
|
|
TextDrawing.DrawString(g, TabItem.Text, font, colors.Text, r, strFormat);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (TabItem.TextMarkupBody != null)
|
|
{
|
|
Rectangle t = TabItem.TextMarkupBody.Bounds;
|
|
|
|
r = SetTransform(g, r);
|
|
r = AlignText(r);
|
|
|
|
TextMarkup.MarkupDrawContext d =
|
|
new TextMarkup.MarkupDrawContext(g, font, colors.Text, TabItem.IsRightToLeft);
|
|
|
|
TabItem.TextMarkupBody.Bounds = r;
|
|
RenderMarkup(g, r, d);
|
|
TabItem.TextMarkupBody.Bounds = t;
|
|
}
|
|
else
|
|
{
|
|
eTextFormat strFormat;
|
|
|
|
r = SetTransform(g, r);
|
|
r = AlignText(r, out strFormat);
|
|
|
|
TextDrawing.DrawStringLegacy(g, TabItem.Text, font, colors.Text, r, strFormat);
|
|
}
|
|
|
|
ResetTransform(g);
|
|
}
|
|
|
|
if (TabDisplay.ShowFocusRectangle == true)
|
|
{
|
|
if (IsFocused() == true)
|
|
ControlPaint.DrawFocusRectangle(g, GetFocusRectangle(GetContentRectangle()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#region AlignText
|
|
|
|
private Rectangle AlignText(Rectangle r, out eTextFormat strFormat)
|
|
{
|
|
strFormat = eTextFormat.Default | eTextFormat.SingleLine |
|
|
eTextFormat.EndEllipsis | eTextFormat.VerticalCenter;
|
|
|
|
eItemAlignment alignment = TabItem.TextAlignment.HasValue ?
|
|
TabItem.TextAlignment.Value : TabItem.TabStripItem.TextAlignment;
|
|
|
|
switch (alignment)
|
|
{
|
|
case eItemAlignment.Center:
|
|
strFormat |= eTextFormat.HorizontalCenter;
|
|
|
|
if (TabItem.IsVertical == true)
|
|
{
|
|
int tabHorizontalSpacing = Dpi.Width(TabStripItem.TabHorizontalSpacing);
|
|
r.X -= tabHorizontalSpacing;
|
|
r.Width += tabHorizontalSpacing;
|
|
}
|
|
break;
|
|
|
|
case eItemAlignment.Far:
|
|
strFormat |= eTextFormat.Right;
|
|
|
|
if (TabItem.IsVertical == true)
|
|
{
|
|
r.X -= Dpi.Width3;
|
|
r.Width -= Dpi.Width3;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return (r);
|
|
}
|
|
|
|
private Rectangle AlignText(Rectangle r)
|
|
{
|
|
if (r.Height > TabItem.TextMarkupBody.Bounds.Height)
|
|
r.Y += (r.Height - TabItem.TextMarkupBody.Bounds.Height) / 2;
|
|
|
|
if (r.Width > TabItem.TextMarkupBody.Bounds.Width)
|
|
{
|
|
eItemAlignment alignment = TabItem.TextAlignment.HasValue ?
|
|
TabItem.TextAlignment.Value : TabItem.TabStripItem.TextAlignment;
|
|
|
|
switch (alignment)
|
|
{
|
|
case eItemAlignment.Center:
|
|
r.X += (r.Width - TabItem.TextMarkupBody.Bounds.Width) / 2;
|
|
break;
|
|
|
|
case eItemAlignment.Far:
|
|
r.X += (r.Width - TabItem.TextMarkupBody.Bounds.Width);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderMarkup
|
|
|
|
private void RenderMarkup(Graphics g,
|
|
Rectangle r, TextMarkup.MarkupDrawContext d)
|
|
{
|
|
Region oldClip = g.Clip;
|
|
Rectangle clipRect = r;
|
|
|
|
g.SetClip(clipRect, CombineMode.Replace);
|
|
|
|
TabItem.TextMarkupBody.Render(d);
|
|
|
|
g.Clip = oldClip;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsFocused
|
|
|
|
private bool IsFocused()
|
|
{
|
|
if (TabItem.IsSelected == true && TabItem.DesignMode == false)
|
|
return (TabItem.TabStrip.ContainsFocus);
|
|
|
|
return (false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region DrawCloseButton
|
|
|
|
/// <summary>
|
|
/// Draws the tab close button
|
|
/// </summary>
|
|
/// <param name="g">Graphics</param>
|
|
/// <param name="colors">State color table</param>
|
|
protected virtual void DrawCloseButton(Graphics g, SuperTabItemStateColorTable colors)
|
|
{
|
|
Rectangle r = TabItem.CloseButtonBounds;
|
|
|
|
if (TabItem.CloseButtonMouseOver == true || TabItem.CloseButtonPressed == true)
|
|
{
|
|
if (TabItem.CloseButtonMouseOver == true && TabItem.CloseButtonPressed == true)
|
|
{
|
|
if (TabStripItem.TabCloseButtonPressed != null)
|
|
g.DrawImageUnscaled(TabStripItem.TabCloseButtonPressed, r);
|
|
else
|
|
g.DrawImageUnscaled(GetCloseButtonPressedBitmap(g), r);
|
|
}
|
|
else
|
|
{
|
|
if (TabStripItem.TabCloseButtonHot != null)
|
|
g.DrawImageUnscaled(TabStripItem.TabCloseButtonHot, r);
|
|
else
|
|
g.DrawImageUnscaled(GetCloseButtonHotBitmap(g), r);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (TabStripItem.TabCloseButtonNormal != null)
|
|
g.DrawImageUnscaled(TabStripItem.TabCloseButtonNormal, r);
|
|
else
|
|
g.DrawImageUnscaled(GetCloseButtonBitmap(g, colors), r);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region SetTransform
|
|
|
|
/// <summary>
|
|
/// Sets the GraphicsTransform for the given alignment
|
|
/// and Horizontal text setting
|
|
/// </summary>
|
|
/// <param name="g">Graphics</param>
|
|
/// <param name="r">Rectangle to transform</param>
|
|
/// <returns>Transformed rectangle</returns>
|
|
private Rectangle SetTransform(Graphics g, Rectangle r)
|
|
{
|
|
if (TabItem.IsVertical == true)
|
|
{
|
|
if (TabDisplay.Alignment == eTabStripAlignment.Left)
|
|
{
|
|
if (TabStripItem.RotateVerticalText == true)
|
|
{
|
|
g.RotateTransform(90);
|
|
r = new Rectangle(r.Top, -r.Right, r.Height, r.Width);
|
|
}
|
|
else
|
|
{
|
|
g.RotateTransform(-90);
|
|
r = new Rectangle(-r.Bottom, r.X, r.Height, r.Width);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (TabStripItem.RotateVerticalText == true)
|
|
{
|
|
g.RotateTransform(-90);
|
|
r = new Rectangle(-r.Bottom, r.X, r.Height, r.Width);
|
|
}
|
|
else
|
|
{
|
|
g.RotateTransform(90);
|
|
r = new Rectangle(r.Top, -r.Right, r.Height, r.Width);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ResetTransform
|
|
|
|
/// <summary>
|
|
/// Resets out transform
|
|
/// </summary>
|
|
/// <param name="g">Graphics</param>
|
|
private void ResetTransform(Graphics g)
|
|
{
|
|
if (TabItem.IsVertical == true)
|
|
g.ResetTransform();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetFocusRectangle
|
|
|
|
/// <summary>
|
|
/// Gets the focus rectangle
|
|
/// </summary>
|
|
/// <param name="rText"></param>
|
|
/// <returns></returns>
|
|
protected virtual Rectangle GetFocusRectangle(Rectangle rText)
|
|
{
|
|
rText.Inflate(-3, -3);
|
|
|
|
return (rText);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetCloseButtonBitmap
|
|
|
|
/// <summary>
|
|
/// Gets the tab close button bitmap
|
|
/// </summary>
|
|
/// <param name="g">Graphics</param>
|
|
/// <param name="colors">State color table</param>
|
|
/// <returns>Button bitmap</returns>
|
|
public Bitmap GetCloseButtonBitmap(Graphics g, SuperTabItemStateColorTable colors)
|
|
{
|
|
if (_CloseMarkerColor != colors.CloseMarker || _CloseButtonBitmap == null)
|
|
{
|
|
if (_CloseButtonBitmap != null)
|
|
_CloseButtonBitmap.Dispose();
|
|
|
|
_CloseButtonBitmap = CreateCloseButtonBitmap(g, colors);
|
|
|
|
_CloseMarkerColor = colors.CloseMarker;
|
|
}
|
|
|
|
return (_CloseButtonBitmap);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CreateCloseButtonBitmap
|
|
|
|
/// <summary>
|
|
/// Creates the close button bitmap
|
|
/// </summary>
|
|
/// <param name="g">Graphics</param>
|
|
/// <param name="colors">State color table</param>
|
|
/// <returns>Close bitmap</returns>
|
|
public virtual Bitmap CreateCloseButtonBitmap(Graphics g, SuperTabItemStateColorTable colors)
|
|
{
|
|
Bitmap bmp = new Bitmap(16, 16, g);
|
|
|
|
using (Graphics gBmp = Graphics.FromImage(bmp))
|
|
{
|
|
gBmp.CompositingQuality = CompositingQuality.HighQuality;
|
|
gBmp.SmoothingMode = g.SmoothingMode;
|
|
|
|
using (Pen pen = new Pen(colors.CloseMarker))
|
|
{
|
|
gBmp.DrawLine(pen, new Point(4, 4), new Point(10, 9));
|
|
gBmp.DrawLine(pen, new Point(10, 4), new Point(4, 9));
|
|
}
|
|
}
|
|
|
|
return (bmp);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetCloseButtonHotBitmap
|
|
|
|
/// <summary>
|
|
/// Gets the hot close button bitmap
|
|
/// </summary>
|
|
/// <param name="g">Graphics</param>
|
|
/// <returns>Close bitmap</returns>
|
|
public Bitmap GetCloseButtonHotBitmap(Graphics g)
|
|
{
|
|
if (_CloseButtonHotBitmap == null)
|
|
_CloseButtonHotBitmap = CreateCloseButtonHotBitmap(g);
|
|
|
|
return (_CloseButtonHotBitmap);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CreateCloseButtonHotBitmap
|
|
|
|
/// <summary>
|
|
/// Creates the hot button bitmap
|
|
/// </summary>
|
|
/// <param name="g">Graphics</param>
|
|
/// <returns>Close bitmap</returns>
|
|
public virtual Bitmap CreateCloseButtonHotBitmap(Graphics g)
|
|
{
|
|
Bitmap bmp = new Bitmap(16, 16, g);
|
|
|
|
using (Graphics gBmp = Graphics.FromImage(bmp))
|
|
{
|
|
gBmp.CompositingQuality = CompositingQuality.HighQuality;
|
|
gBmp.SmoothingMode = g.SmoothingMode;
|
|
|
|
Rectangle r = new Rectangle(0, 0, 15, 15);
|
|
|
|
using (GraphicsPath path = GetClosePath(r, 4))
|
|
{
|
|
using (LinearGradientBrush lbr = new
|
|
LinearGradientBrush(r, Color.White, Color.Pink, 90))
|
|
{
|
|
gBmp.FillPath(lbr, path);
|
|
}
|
|
|
|
r.Inflate(-1, -1);
|
|
|
|
using (GraphicsPath path2 = GetClosePath(r, 6))
|
|
{
|
|
using (LinearGradientBrush lbr = new
|
|
LinearGradientBrush(r, Color.Pink, Color.Crimson, 90))
|
|
{
|
|
gBmp.FillPath(lbr, path2);
|
|
}
|
|
}
|
|
|
|
using (Pen pen = new Pen(Color.White, 2))
|
|
{
|
|
gBmp.DrawLine(pen, new Point(4, 4), new Point(10, 10));
|
|
gBmp.DrawLine(pen, new Point(10, 4), new Point(4, 10));
|
|
}
|
|
|
|
gBmp.DrawPath(Pens.DarkRed, path);
|
|
}
|
|
}
|
|
|
|
return (bmp);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetCloseButtonPressedBitmap
|
|
|
|
/// <summary>
|
|
/// Gets the pressed close button bitmap
|
|
/// </summary>
|
|
/// <param name="g">Graphics</param>
|
|
/// <returns>Close bitmap</returns>
|
|
public Bitmap GetCloseButtonPressedBitmap(Graphics g)
|
|
{
|
|
if (_CloseButtonPressedBitmap == null)
|
|
_CloseButtonPressedBitmap = CreateCloseButtonPressedBitmap(g);
|
|
|
|
return (_CloseButtonPressedBitmap);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CreateCloseButtonPressedBitmap
|
|
|
|
/// <summary>
|
|
/// Creates the pressed button bitmap
|
|
/// </summary>
|
|
/// <param name="g">Graphics</param>
|
|
/// <returns>Close bitmap</returns>
|
|
public virtual Bitmap CreateCloseButtonPressedBitmap(Graphics g)
|
|
{
|
|
Bitmap bmp = new Bitmap(16, 16, g);
|
|
|
|
using (Graphics gBmp = Graphics.FromImage(bmp))
|
|
{
|
|
gBmp.CompositingQuality = CompositingQuality.HighQuality;
|
|
gBmp.SmoothingMode = g.SmoothingMode;
|
|
|
|
Rectangle r = new Rectangle(0, 0, 15, 15);
|
|
|
|
using (GraphicsPath path = GetClosePath(r, 4))
|
|
{
|
|
using (LinearGradientBrush lbr = new
|
|
LinearGradientBrush(r, Color.LightGray, Color.Red, 90))
|
|
{
|
|
gBmp.FillPath(lbr, path);
|
|
}
|
|
|
|
r.Inflate(-1, -1);
|
|
|
|
using (GraphicsPath path2 = GetClosePath(r, 6))
|
|
{
|
|
using (LinearGradientBrush lbr = new
|
|
LinearGradientBrush(r, Color.Red, Color.Maroon, 90))
|
|
{
|
|
gBmp.FillPath(lbr, path2);
|
|
}
|
|
}
|
|
|
|
using (Pen pen = new Pen(Color.LightGray, 2))
|
|
{
|
|
gBmp.DrawLine(pen, new Point(4, 4), new Point(10, 10));
|
|
gBmp.DrawLine(pen, new Point(10, 4), new Point(4, 10));
|
|
}
|
|
|
|
gBmp.DrawPath(Pens.DarkRed, path);
|
|
}
|
|
}
|
|
|
|
return (bmp);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetClosePath
|
|
|
|
/// <summary>
|
|
/// Gets the close button path
|
|
/// </summary>
|
|
/// <param name="r">Close rectangle</param>
|
|
/// <param name="rad">Corner radius</param>
|
|
/// <returns></returns>
|
|
private GraphicsPath GetClosePath(Rectangle r, int rad)
|
|
{
|
|
GraphicsPath path = new GraphicsPath();
|
|
|
|
Rectangle ar = new
|
|
Rectangle(r.Right - rad, r.Bottom - rad, rad, rad);
|
|
|
|
path.AddArc(ar, 0, 90);
|
|
|
|
ar.X = r.X;
|
|
path.AddArc(ar, 90, 90);
|
|
|
|
ar.Y = r.Y;
|
|
path.AddArc(ar, 180, 90);
|
|
|
|
ar.X = r.Right - rad;
|
|
path.AddArc(ar, 270, 90);
|
|
|
|
path.CloseAllFigures();
|
|
|
|
return (path);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Dispose
|
|
|
|
public void Dispose()
|
|
{
|
|
StopImageAnimation();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
#endif |