zilinsoft/RaUI
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
master
RaUI/Source/ryControls/Sheng.Winform.Controls/Renderer/SEToolStripRender.cs
鑫Intel c3d4ddf574 ### 2021-07-29更新 
------
#### MyDbV4   V3.0.2107.2901
- *.[新增]新增支持计算文件MD5。
- *.[新增]部分DataProvider功能移植到DbExtension里,增加扩展性。
- *.[新增]UnixTimeToDateTime和JSTimeToDateTime新增支持long参数。
- *.[合并]合并RyWeb项目到MyDb里。

#### ryControlsV4    V3.0.2107.2901
  -  *.[改进]优化减少大量IDE警告和消息。
2021-07-29 17:09:32 +08:00

3462 lines
106 KiB
C#
Raw Permalink Blame History

using System;
using System.Collections.Generic;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Data;
using System.Text;
using System.Windows.Forms;
using System.Threading;
namespace Sheng.Winform.Controls
{
#region "EasyRender based renderer class"
/// <summary>
/// A ToolstripManager rendering class with advanced control features
/// </summary>
public class SEToolStripRender : ToolStripProfessionalRenderer
{
#region "Initialization and Setup"
/// <summary>
/// Creates a new EasyRender class for modifications
/// </summary>
public SEToolStripRender()
{
_tsManager = new IToolstrip();
_btnManager = new IButton();
_dBtnManager = new IDropDownButton();
_tsCtrlManager = new IToolstripControls();
_pManager = new IPanel();
_sBtnManager = new ISplitButton();
_sBarManager = new IStatusBar();
_mnuManager = new IMenustrip();
}
#endregion
#region "Private variables"
private readonly IToolstrip _tsManager = null;
private readonly IButton _btnManager = null;
private readonly IToolstripControls _tsCtrlManager = null;
private readonly IPanel _pManager = null;
private readonly ISplitButton _sBtnManager = null;
private readonly IStatusBar _sBarManager = null;
private readonly IMenustrip _mnuManager = null;
private readonly IDropDownButton _dBtnManager = null;
/// <summary>
///
/// </summary>
protected Boolean _smoothText = true;
/// <summary>
///
/// </summary>
protected Color _overrideColor = Color.FromArgb(47, 92, 150);
/// <summary>
///
/// </summary>
protected Boolean _overrideText = true;
#endregion
#region "Properties"
/// <summary>
/// Gets the manager to edit and change the appearance of the Toolstrip
/// </summary>
[ReadOnly(true)]
public IToolstrip Toolstrip
{
get
{
return _tsManager;
}
}
/// <summary>
/// Gets the manager to edit and change the appearance of Toolstrip buttons
/// </summary>
[ReadOnly(true)]
public IButton ToolstripButton
{
get
{
return _btnManager;
}
}
/// <summary>
/// Gets the manager to edit and change the appearance of other Toolstrip controls
/// </summary>
[ReadOnly(true)]
public IToolstripControls ToolstripControls
{
get { return _tsCtrlManager; }
}
/// <summary>
/// Gets the manager to edit and change the appearance of the Panels
/// </summary>
[ReadOnly(true)]
public IPanel Panels
{
get { return _pManager; }
}
/// <summary>
/// Gets the manager to edit and change the appearance of the Toolstrip split buttons
/// </summary>
[ReadOnly(true)]
public ISplitButton SplitButton
{
get { return _sBtnManager; }
}
/// <summary>
/// Gets the manager to edit and change the appearance of the Status-bar
/// </summary>
[ReadOnly(true)]
public IStatusBar StatusBar
{
get { return _sBarManager; }
}
/// <summary>
/// Gets or sets whether to smooth the font text on all controls
/// </summary>
public Boolean SmoothText
{
get { return _smoothText; }
set { _smoothText = value; }
}
/// <summary>
/// Gets or sets the color of the text if the AlterColor is set to true
/// </summary>
public Color OverrideColor
{
get { return _overrideColor; }
set { _overrideColor = value; }
}
/// <summary>
/// Gets or sets whether to override the font-color on all controls
/// </summary>
public Boolean AlterColor
{
get { return _overrideText; }
set { _overrideText = value; }
}
#endregion
#region "Important -- Functions for getting drawing pointers"
#region "CreatePanelBrush -- Gets a brush based on the docking position of a panel"
/*
/// <summary>
/// Gets a brush dependent on the dock style of a panel
/// </summary>
/// <param name="Panel">The panel which is docked</param>
/// <returns></returns>
private Brush CreatePanelBrush(ToolStripPanel Panel)
{
switch (Panel.Dock)
{
case DockStyle.Top: return new SolidBrush(ContentPanelTop);
case DockStyle.Bottom: return new SolidBrush(ContentPanelBottom);
case DockStyle.Left:
case DockStyle.Right:
return new LinearGradientBrush(Panel.ClientRectangle, ContentPanelTop, ContentPanelBottom, 90f);
}
return null;
}
*/
#endregion
#region "CreateDrawingPath -- Gets a path based on a rectangular area and a provided curve value"
/// <summary>
/// Creates a GraphicsPath that appreciates an area where things can be drawn
/// </summary>
/// <param name="Area">The rectangular area which will serve as the base</param>
/// <param name="Curve">The curve amount of the corners</param>
/// <returns></returns>
private GraphicsPath CreateDrawingPath(Rectangle Area, float Curve)
{
GraphicsPath Result = new GraphicsPath();
Result.AddLine(Area.Left + Curve, Area.Top, Area.Right - Curve, Area.Top); // Top
Result.AddLine(Area.Right - Curve, Area.Top, Area.Right, Area.Top + Curve); // Top-right
Result.AddLine(Area.Right, Area.Top + Curve, Area.Right, Area.Bottom - Curve); // Right
Result.AddLine(Area.Right, Area.Bottom - Curve, Area.Right - Curve, Area.Bottom); // Bottom-right
Result.AddLine(Area.Right - Curve, Area.Bottom, Area.Left + Curve, Area.Bottom); // Bottom
Result.AddLine(Area.Left + Curve, Area.Bottom, Area.Left, Area.Bottom - Curve); // Bottom-left
Result.AddLine(Area.Left, Area.Bottom - Curve, Area.Left, Area.Top + Curve); // Left
Result.AddLine(Area.Left, Area.Top + Curve, Area.Left + Curve, Area.Top); // Top-left
return Result;
}
#endregion
#region "CreateTrianglePath -- Gets a path based on a rectangle boundary as a triangle shape"
/// <summary>
/// Creates a triangle based on the size and bounds sectors
/// </summary>
/// <param name="Bounds">The area which the triangle is confined to</param>
/// <param name="Size">The size of the triangle</param>
/// <param name="Direction">The direction which the triangle is pointing</param>
/// <returns></returns>
private GraphicsPath CreateTrianglePath(Rectangle Bounds, Int32 Size, ArrowDirection Direction)
{
GraphicsPath Result = new GraphicsPath();
int x, y, c, j;
if (Direction == ArrowDirection.Left || Direction == ArrowDirection.Right)
{
x = Bounds.Right - (Bounds.Width - Size) / 2;
y = Bounds.Y + Bounds.Height / 2;
c = Size;
j = 0;
}
else
{
x = Bounds.X + Bounds.Width / 2;
y = Bounds.Bottom - ((Bounds.Height - (Size - 1)) / 2);
c = Size - 1;
j = Size - 2;
}
switch (Direction)
{
case ArrowDirection.Right:
Result.AddLine(x, y, x - c, y - c);
Result.AddLine(x - c, y - c, x - c, y + c);
Result.AddLine(x - c, y + c, x, y);
break;
case ArrowDirection.Down:
Result.AddLine(x + j, y - j, x - j, y - j);
Result.AddLine(x - j, y - j, x, y);
Result.AddLine(x, y, x + j, y - j);
break;
case ArrowDirection.Left:
Result.AddLine(x - c, y, x, y - c);
Result.AddLine(x, y - c, x, y + c);
Result.AddLine(x, y + c, x - c, y);
break;
}
return Result;
}
#endregion
#region "GetButtonBackColor -- Returns different background gradient colors for a normal button state"
/// <summary>
/// Gets a color array based on the state of a normal button
/// </summary>
/// <param name="Item">The button to check the state of</param>
/// <param name="Type"></param>
/// <returns></returns>
private Color[] GetButtonBackColor(ToolStripButton Item, ButtonType Type)
{
Color[] Return = new Color[2];
if (
(!Item.Selected) &&
(!Item.Pressed && !Item.Checked)
)
{
Return[0] = Color.Transparent;
Return[1] = Color.Transparent;
}
else if (
(Item.Selected) &&
(!Item.Pressed && !Item.Checked)
)
{
Return[0] = _btnManager.HoverBackgroundTop;
Return[1] = _btnManager.HoverBackgroundBottom;
}
else
{
Return[0] = _btnManager.ClickBackgroundTop;
Return[1] = _btnManager.ClickBackgroundBottom;
}
return Return;
}
#endregion
#region "GetButtonBackColor -- Returns different background gradient colors for a split-button state"
/// <summary>
/// Gets a color array based on the state of a split-button
/// </summary>
/// <param name="Item">The button to check the state of</param>
/// <param name="Type"></param>
/// <returns></returns>
private Color[] GetButtonBackColor(ToolStripSplitButton Item, ButtonType Type)
{
Color[] Return = new Color[2];
if (
(!Item.Selected) &&
(!Item.ButtonPressed && !Item.DropDownButtonPressed)
)
{
Return[0] = Color.Transparent;
Return[1] = Color.Transparent;
}
else if (
(Item.Selected) &&
(!Item.ButtonPressed && !Item.DropDownButtonPressed)
)
{
Return[0] = _sBtnManager.HoverBackgroundTop;
Return[1] = _sBtnManager.HoverBackgroundBottom;
}
else
{
if (Item.ButtonPressed)
{
Return[0] = _sBtnManager.ClickBackgroundTop;
Return[1] = _sBtnManager.ClickBackgroundBottom;
}
else if (Item.DropDownButtonPressed)
{
Return[0] = _mnuManager.MenustripButtonBackground;
Return[1] = _mnuManager.MenustripButtonBackground;
}
}
return Return;
}
#endregion
#region "GetButtonBackColor -- Returns different background gradient colors for a menu-item state"
/// <summary>
/// Gets a color array based on the state of a menu-item
/// </summary>
/// <param name="Item">The button to check the state of</param>
/// <param name="Type"></param>
/// <returns></returns>
private Color[] GetButtonBackColor(ToolStripMenuItem Item, ButtonType Type)
{
Color[] Return = new Color[2];
if (
(!Item.Selected) &&
(!Item.Pressed && !Item.Checked)
)
{
Return[0] = Color.Transparent;
Return[1] = Color.Transparent;
}
else if (
(Item.Selected || Item.Pressed) &&
(!Item.Checked)
)
{
if (Item.Pressed && Item.OwnerItem == null)
{
Return[0] = _mnuManager.MenustripButtonBackground;
Return[1] = _mnuManager.MenustripButtonBackground;
}
else
{
Return[0] = _mnuManager.Items.HoverBackgroundTop;
Return[1] = _mnuManager.Items.HoverBackgroundBottom;
}
}
else
{
Return[0] = _mnuManager.Items.ClickBackgroundTop;
Return[1] = _mnuManager.Items.ClickBackgroundBottom;
}
return Return;
}
#endregion
#region "GetButtonBackColor -- Returns different background gradient colors for a dropdownbutton state"
/// <summary>
/// Gets a color array based on the state of a drop-down button
/// </summary>
/// <param name="Item">The button to check the state of</param>
/// <param name="Type"></param>
/// <returns></returns>
private Color[] GetButtonBackColor(ToolStripDropDownButton Item, ButtonType Type)
{
Color[] Return = new Color[2];
if (
(!Item.Selected) &&
(!Item.Pressed)
)
{
Return[0] = Color.Transparent;
Return[1] = Color.Transparent;
}
else if (
(Item.Selected) &&
(!Item.Pressed)
)
{
Return[0] = _dBtnManager.HoverBackgroundTop;
Return[1] = _dBtnManager.HoverBackgroundBottom;
}
else
{
Return[0] = _mnuManager.MenustripButtonBackground;
Return[1] = _mnuManager.MenustripButtonBackground;
}
return Return;
}
#endregion
#region "GetBlend -- Gets a blend property based on the blending options and current state"
/// <summary>
/// Gets a blending property for a specified type of Toolstrip item
/// </summary>
/// <param name="TSItem">The Toolstrip item</param>
/// <param name="Type">The type of item this is</param>
/// <returns></returns>
private Blend GetBlend(ToolStripItem TSItem, ButtonType Type)
{
Blend BackBlend = null;
if (Type == ButtonType.NormalButton)
{
ToolStripButton Item = (ToolStripButton)TSItem;
if (Item.Selected &&
(!Item.Checked && !Item.Pressed) &&
(_btnManager.BlendOptions & BlendRender.Hover) == BlendRender.Hover)
{
BackBlend = _btnManager.BackgroundBlend;
}
else if (Item.Pressed &&
(!Item.Checked) &&
(_btnManager.BlendOptions & BlendRender.Click) == BlendRender.Click)
{
BackBlend = _btnManager.BackgroundBlend;
}
else if (Item.Checked &&
(_btnManager.BlendOptions & BlendRender.Check) == BlendRender.Check)
{
BackBlend = _btnManager.BackgroundBlend;
}
}
if (Type == ButtonType.DropDownButton)
{
ToolStripDropDownButton Item = (ToolStripDropDownButton)TSItem;
if (Item.Selected &&
(!Item.Pressed) &&
(_btnManager.BlendOptions & BlendRender.Hover) == BlendRender.Hover)
{
BackBlend = _btnManager.BackgroundBlend;
}
}
else if (Type == ButtonType.MenuItem)
{
ToolStripMenuItem Item = (ToolStripMenuItem)TSItem;
if (Item.Selected &&
(!Item.Checked && !Item.Pressed) &&
(_btnManager.BlendOptions & BlendRender.Hover) == BlendRender.Hover)
{
BackBlend = _mnuManager.Items.BackgroundBlend;
}
else if (Item.Pressed &&
(!Item.Checked) &&
(_btnManager.BlendOptions & BlendRender.Click) == BlendRender.Click)
{
BackBlend = _mnuManager.Items.BackgroundBlend;
}
else if (Item.Checked &&
(_btnManager.BlendOptions & BlendRender.Check) == BlendRender.Check)
{
BackBlend = _mnuManager.Items.BackgroundBlend;
}
}
else if (Type == ButtonType.SplitButton)
{
ToolStripSplitButton Item = (ToolStripSplitButton)TSItem;
if (Item.Selected &&
(!Item.ButtonPressed && !Item.DropDownButtonPressed) &&
(_sBtnManager.BlendOptions & BlendRender.Hover) == BlendRender.Hover)
{
BackBlend = _sBtnManager.BackgroundBlend;
}
else if (Item.ButtonPressed &&
(!Item.DropDownButtonPressed) &&
(_sBtnManager.BlendOptions & BlendRender.Click) == BlendRender.Click)
{
BackBlend = _sBtnManager.BackgroundBlend;
}
}
return BackBlend;
}
#endregion
#endregion
#region "Important -- Functions for drawing"
#region "PaintBackground -- Simply fills a rectangle with a color"
/// <summary>
/// Fills a specified boundary with color
/// </summary>
/// <param name="Link">The Graphics object to draw onto</param>
/// <param name="Boundary">The boundaries to draw the color</param>
/// <param name="Brush">The brush to fill the color</param>
public void PaintBackground(Graphics Link, Rectangle Boundary, Brush Brush)
{
Link.FillRectangle(Brush, Boundary);
}
#endregion
#region "PaintBackground -- Fills a rectangle with Top and Bottom colors"
/// <summary>
/// Fills a specified boundary with a gradient with specified colors
/// </summary>
/// <param name="Link">The Graphics object to draw onto</param>
/// <param name="Boundary">The boundaries to draw the color</param>
/// <param name="Top">The color of the gradient at the top</param>
/// <param name="Bottom">The color of the gradient at the bottom</param>
public void PaintBackground(Graphics Link, Rectangle Boundary, Color Top, Color Bottom)
{
PaintBackground(Link, Boundary, Top, Bottom, 90f, null);
}
#endregion
#region "PaintBackground -- Fills a rectangle with Top and Bottom colors at a given angle"
/// <summary>
/// Fills a specified boundary with a gradient with specified colors at a given angle
/// </summary>
/// <param name="Link">The Graphics object to draw onto</param>
/// <param name="Boundary">The boundaries to draw the color</param>
/// <param name="Top">The color of the gradient at the top</param>
/// <param name="Bottom">The color of the gradient at the bottom</param>
/// <param name="Angle">The angle which the gradient is drawn (null defaults to 90f)</param>
public void PaintBackground(Graphics Link, Rectangle Boundary, Color Top, Color Bottom, float Angle)
{
PaintBackground(Link, Boundary, Top, Bottom, Angle, null);
}
#endregion
#region "PaintBackground -- Fills a rectangle with Top and Bottom colors at a given angle with blending"
/// <summary>
/// Fills a specified boundary with a gradient with specified colors at a given angle and with blending properties
/// </summary>
/// <param name="Link">The Graphics object to draw onto</param>
/// <param name="Boundary">The boundaries to draw the color</param>
/// <param name="Top">The color of the gradient at the top</param>
/// <param name="Bottom">The color of the gradient at the bottom</param>
/// <param name="Angle">The angle which the gradient is drawn (null defaults to 90f)</param>
/// <param name="Blend">The blending options to draw the gradient</param>
public void PaintBackground(Graphics Link, Rectangle Boundary, Color Top, Color Bottom, float Angle, Blend Blend)
{
if ( float.IsNaN(Angle))
{
Angle = 90f;
}
using (LinearGradientBrush Fill = new LinearGradientBrush(Boundary, Top, Bottom, Angle))
{
if (Blend != null)
{
Fill.Blend = Blend;
}
Link.FillRectangle(Fill, Boundary);
Fill.Dispose();
}
}
#endregion
#region "PaintBorder -- Draws a border along a set path"
/// <summary>
/// Draws a set path with a defined brush
/// </summary>
/// <param name="Link">The Graphics object to draw onto</param>
/// <param name="Path">The path to draw along</param>
/// <param name="Brush">The brush to fill the color</param>
public void PaintBorder(Graphics Link, GraphicsPath Path, Brush Brush)
{
Link.DrawPath(new Pen(Brush), Path);
}
#endregion
#region "PaintBorder -- Draws a border along a set path with Top and Bottom colors"
/// <summary>
/// Draws a set path with specified colors
/// </summary>
/// <param name="Link">The Graphics object to draw onto</param>
/// <param name="Path">The path to draw along</param>
/// <param name="Area">The area of span the border gradient covers</param>
/// <param name="Top">The color of the gradient at the top</param>
/// <param name="Bottom">The color of the gradient at the bottom</param>
public void PaintBorder(Graphics Link, GraphicsPath Path, Rectangle Area, Color Top, Color Bottom)
{
PaintBorder(Link, Path, Area, Top, Bottom, 90f, null);
}
#endregion
#region "PaintBorder -- Draws a border along a set path with Top and Bottom colors at a given angle"
/// <summary>
/// Draws a set path with specified colors at a given angle
/// </summary>
/// <param name="Link">The Graphics object to draw onto</param>
/// <param name="Path">The path to draw along</param>
/// <param name="Area">The area of span the border gradient covers</param>
/// <param name="Top">The color of the gradient at the top</param>
/// <param name="Bottom">The color of the gradient at the bottom</param>
/// <param name="Angle">The angle which the gradient is drawn (null defaults to 90f)</param>
public void PaintBorder(Graphics Link, GraphicsPath Path, Rectangle Area, Color Top, Color Bottom, float Angle)
{
PaintBorder(Link, Path, Area, Top, Bottom, Angle, null);
}
#endregion
#region "PaintBorder -- Draws a border along a set path with Top and Bottom colors at a given angle with blending"
/// <summary>
/// Draws a set path with specified colors at a given angle with blending properties
/// </summary>
/// <param name="Link">The Graphics object to draw onto</param>
/// <param name="Path">The path to draw along</param>
/// <param name="Area"></param>
/// <param name="Top">The color of the gradient at the top</param>
/// <param name="Bottom">The color of the gradient at the bottom</param>
/// <param name="Angle">The angle which the gradient is drawn (null defaults to 90f)</param>
/// <param name="Blend">The blending options to draw the gradient</param>
public void PaintBorder(Graphics Link, GraphicsPath Path, Rectangle Area, Color Top, Color Bottom, float Angle, Blend Blend)
{
if (float.IsNaN(Angle))
{
Angle = 90f;
}
using (LinearGradientBrush Fill = new LinearGradientBrush(Area, Top, Bottom, Angle))
{
if (Blend != null)
{
Fill.Blend = Blend;
}
Link.DrawPath(new Pen(Fill), Path);
Fill.Dispose();
}
}
#endregion
#endregion
#region "Important -- Functions handling the OnRender delegations"
#region "IDrawToolstripButton -- Draws a Toolstrip button applying the backround and border"
/// <summary>
/// Draws a Toolstrip button
/// </summary>
/// <param name="Item">The Toolstrip button</param>
/// <param name="Link">The Graphics object to handle</param>
/// <param name="Parent">The parent Toolstrip</param>
public void IDrawToolstripButton(ToolStripButton Item, Graphics Link, ToolStrip Parent)
{
Rectangle Area = new Rectangle(
new Point(0, 0),
new Size(Item.Bounds.Size.Width - 1, Item.Bounds.Size.Height - 1)
);
Blend BackBlend = GetBlend(Item, ButtonType.NormalButton);
Color[] Render = GetButtonBackColor(Item, ButtonType.NormalButton);
using (GraphicsPath Path = CreateDrawingPath(Area, _btnManager.Curve))
{
Link.SetClip(Path);
PaintBackground(
Link,
Area,
Render[0],
Render[1],
_btnManager.BackgroundAngle,
BackBlend
);
Link.ResetClip();
Link.SmoothingMode = SmoothingMode.AntiAlias;
using (GraphicsPath OBPath = CreateDrawingPath(Area, _btnManager.Curve))
{
PaintBorder(
Link,
OBPath,
Area,
_btnManager.BorderTop,
_btnManager.BorderBottom,
_btnManager.BorderAngle,
_btnManager.BorderBlend
);
OBPath.Dispose();
}
Area.Inflate(-1, -1);
using (GraphicsPath IBPath = CreateDrawingPath(Area, _btnManager.Curve))
{
using (SolidBrush InnerBorder = new SolidBrush(_btnManager.InnerBorder))
{
PaintBorder(
Link,
IBPath,
InnerBorder
);
InnerBorder.Dispose();
}
}
Link.SmoothingMode = SmoothingMode.Default;
}
}
#endregion
#region "IDrawDropDownButton -- Draws a Toolstrip dropdownbutton applying the backround and border"
/// <summary>
/// Draws a Toolstrip button
/// </summary>
/// <param name="Item">The Toolstrip button</param>
/// <param name="Link">The Graphics object to handle</param>
/// <param name="Parent">The parent Toolstrip</param>
public void IDrawDropDownButton(ToolStripDropDownButton Item, Graphics Link, ToolStrip Parent)
{
Rectangle Area = new Rectangle(
new Point(0, 0),
new Size(Item.Bounds.Size.Width - 1, Item.Bounds.Size.Height - 1)
);
Blend BackBlend = GetBlend(Item, ButtonType.DropDownButton);
Color[] Render = GetButtonBackColor(Item, ButtonType.DropDownButton);
using (GraphicsPath Path = CreateDrawingPath(Area, _btnManager.Curve))
{
Link.SetClip(Path);
PaintBackground(
Link,
Area,
Render[0],
Render[1],
_btnManager.BackgroundAngle,
BackBlend
);
Link.ResetClip();
Link.SmoothingMode = SmoothingMode.AntiAlias;
using (GraphicsPath OBPath = CreateDrawingPath(Area, _btnManager.Curve))
{
PaintBorder(
Link,
OBPath,
Area,
_btnManager.BorderTop,
_btnManager.BorderBottom,
_btnManager.BorderAngle,
_btnManager.BorderBlend
);
OBPath.Dispose();
}
if (!Item.Pressed)
{
Area.Inflate(-1, -1);
using (GraphicsPath IBPath = CreateDrawingPath(Area, _dBtnManager.Curve))
{
using (SolidBrush InnerBorder = new SolidBrush(_dBtnManager.InnerBorder))
{
PaintBorder(
Link,
IBPath,
InnerBorder
);
InnerBorder.Dispose();
}
}
}
Link.SmoothingMode = SmoothingMode.Default;
}
}
#endregion
#region "IDrawToolstripBackground -- Draws a Toolstrip background"
/// <summary>
/// Draws the Toolstrip background
/// </summary>
/// <param name="Item">The Toolstrip being drawn</param>
/// <param name="Link">The Graphics object to handle</param>
/// <param name="Bounds">The affected bounds</param>
public void IDrawToolstripBackground(ToolStrip Item, Graphics Link, Rectangle Bounds)
{
Rectangle Area = new Rectangle(
0,
0,
Bounds.Width - 1,
Bounds.Height - 1
);
Link.SmoothingMode = SmoothingMode.None;
using (GraphicsPath Path = CreateDrawingPath(Area, _tsManager.Curve))
{
Link.SetClip(Path);
PaintBackground(
Link,
Area,
_tsManager.BackgroundTop,
_tsManager.BackgroundBottom,
_tsManager.BackgroundAngle,
_tsManager.BackgroundBlend
);
Link.ResetClip();
Path.Dispose();
}
}
#endregion
#region "IDrawToolstripSplitButton -- Draws a Toolstrip split-button with the arrow"
/// <summary>
/// Draws a Toolstrip split-button
/// </summary>
/// <param name="Item">The Toolstrip split-button</param>
/// <param name="Link">The Graphics object to handle</param>
/// <param name="Parent">The parent Toolstrip</param>
public void IDrawToolstripSplitButton(ToolStripSplitButton Item, Graphics Link, ToolStrip Parent)
{
if (Item.Selected || Item.DropDownButtonPressed || Item.ButtonPressed)
{
Rectangle Area = new Rectangle(
new Point(0, 0),
new Size(Item.Bounds.Size.Width - 1, Item.Bounds.Size.Height - 1)
);
Blend BackBlend = GetBlend(Item, ButtonType.SplitButton);
Color[] NormalRender = new Color[] { _sBtnManager.HoverBackgroundTop, _sBtnManager.HoverBackgroundBottom };
Color[] Render = GetButtonBackColor(Item, ButtonType.SplitButton);
using (GraphicsPath Path = CreateDrawingPath(Area, _sBtnManager.Curve))
{
Link.SetClip(Path);
if (!Item.DropDownButtonPressed)
{
PaintBackground(
Link,
Area,
NormalRender[0],
NormalRender[1],
_sBtnManager.BackgroundAngle,
BackBlend
);
}
else
{
PaintBackground(
Link,
Area,
Render[0],
Render[1]
);
}
if (Item.ButtonPressed)
{
Rectangle ButtonArea = new Rectangle(
new Point(0, 0),
new Size(Item.ButtonBounds.Width, Item.ButtonBounds.Height - 1)
);
PaintBackground(
Link,
ButtonArea,
Render[0],
Render[1],
_sBtnManager.BackgroundAngle,
_sBtnManager.BackgroundBlend
);
}
Link.ResetClip();
Link.SmoothingMode = SmoothingMode.AntiAlias;
using (GraphicsPath OBPath = CreateDrawingPath(Area, _sBtnManager.Curve))
{
Color TopColor = (Item.DropDownButtonPressed ? _mnuManager.MenustripButtonBorder : _sBtnManager.BorderTop);
Color BottomColor = (Item.DropDownButtonPressed ? _mnuManager.MenustripButtonBorder : _sBtnManager.BorderBottom);
PaintBorder(
Link,
OBPath,
Area,
TopColor,
BottomColor,
_sBtnManager.BorderAngle,
_sBtnManager.BorderBlend
);
OBPath.Dispose();
}
if (!Item.DropDownButtonPressed)
{
Area.Inflate(-1, -1);
using (GraphicsPath IBPath = CreateDrawingPath(Area, _sBtnManager.Curve))
{
using (SolidBrush InnerBorder = new SolidBrush(_sBtnManager.InnerBorder))
{
PaintBorder(
Link,
IBPath,
InnerBorder
);
Link.DrawRectangle(
new Pen(_sBtnManager.InnerBorder),
new Rectangle(
Item.ButtonBounds.Width,
1,
2,
Item.ButtonBounds.Height - 3
)
);
InnerBorder.Dispose();
}
}
using (LinearGradientBrush SplitLine = new LinearGradientBrush(
new Rectangle(0, 0, 1, Item.Height),
_sBtnManager.BorderTop,
_sBtnManager.BorderBottom,
_sBtnManager.BackgroundAngle
))
{
if (_sBtnManager.BackgroundBlend != null)
{
SplitLine.Blend = _sBtnManager.BackgroundBlend;
}
Link.DrawLine(
new Pen(SplitLine),
Item.ButtonBounds.Width + 1,
0,
Item.ButtonBounds.Width + 1,
Item.Height - 1
);
SplitLine.Dispose();
}
}
Link.SmoothingMode = SmoothingMode.Default;
}
}
Int32 ArrowSize = 5;
if (
(_sBtnManager.ArrowDisplay == ArrowDisplay.Always) ||
(_sBtnManager.ArrowDisplay == ArrowDisplay.Hover && Item.Selected)
)
{
using (GraphicsPath TrianglePath = CreateTrianglePath(
new Rectangle(
Item.DropDownButtonBounds.Left + (ArrowSize / 2) - 1,
(Item.DropDownButtonBounds.Height / 2) - (ArrowSize / 2) - 3,
ArrowSize * 2,
ArrowSize * 2
),
ArrowSize,
ArrowDirection.Down
))
{
Link.FillPath(new SolidBrush(_sBtnManager.ArrowColor), TrianglePath);
TrianglePath.Dispose();
}
}
}
#endregion
#region "IDrawStatusbarBackground -- Draws the statusbar background"
/// <summary>
/// Draws the Statusbar background
/// </summary>
/// <param name="Item">The Statusbar being drawn</param>
/// <param name="Link">The Graphics object to handle</param>
/// <param name="Bounds">The affected bounds</param>
public void IDrawStatusbarBackground(StatusStrip Item, Graphics Link, Rectangle Bounds)
{
PaintBackground(
Link,
Bounds,
_sBarManager.BackgroundTop,
_sBarManager.BackgroundBottom,
_sBarManager.BackgroundAngle,
_sBarManager.BackgroundBlend
);
Link.DrawLine(
new Pen(_sBarManager.DarkBorder),
0, 0, Bounds.Width, 0
);
Link.DrawLine(
new Pen(_sBarManager.LightBorder),
0, 1, Bounds.Width, 1
);
}
#endregion
#region "IDrawMenustripItem -- Draws a Menustrip item applying the background and border"
/// <summary>
/// Draws a Menustrip item
/// </summary>
/// <param name="Item">The Menustrip item</param>
/// <param name="Link">The Graphics object to handle</param>
/// <param name="Parent">The parent Toolstrip</param>
public void IDrawMenustripItem(ToolStripMenuItem Item, Graphics Link, ToolStrip Parent)
{
Rectangle Area = new Rectangle(
new Point(0, 0),
new Size(Item.Bounds.Size.Width - 1, Item.Bounds.Size.Height - 1)
);
if (Item.OwnerItem != null)
{
Area.X += 2;
Area.Width -= 3;
}
Blend BackBlend = GetBlend(Item, ButtonType.MenuItem);
Color[] Render = GetButtonBackColor(Item, ButtonType.MenuItem);
using (GraphicsPath Path = CreateDrawingPath(Area, _btnManager.Curve))
{
Link.SetClip(Path);
PaintBackground(
Link,
Area,
Render[0],
Render[1],
_btnManager.BackgroundAngle,
BackBlend
);
Link.ResetClip();
Link.SmoothingMode = SmoothingMode.AntiAlias;
using (GraphicsPath OBPath = CreateDrawingPath(Area, _btnManager.Curve))
{
PaintBorder(
Link,
OBPath,
Area,
_mnuManager.MenustripButtonBorder,
_mnuManager.MenustripButtonBorder,
_btnManager.BorderAngle,
_btnManager.BorderBlend
);
OBPath.Dispose();
}
if (!Item.Pressed)
{
Area.Inflate(-1, -1);
using (GraphicsPath IBPath = CreateDrawingPath(Area, _btnManager.Curve))
{
using (SolidBrush InnerBorder = new SolidBrush(_btnManager.InnerBorder))
{
PaintBorder(
Link,
IBPath,
InnerBorder
);
InnerBorder.Dispose();
}
}
}
Link.SmoothingMode = SmoothingMode.Default;
}
}
#endregion
#endregion
#region "Important* -- The OnRender protected overrides"
#region "Render Button Background -- Handles drawing toolstrip/menu/status-strip buttons"
/// <summary>
/// Covers the button background rendering
/// </summary>
/// <param name="e"></param>
protected override void OnRenderButtonBackground(ToolStripItemRenderEventArgs e)
{
if (
e.ToolStrip is ContextMenuStrip ||
e.ToolStrip is ToolStripDropDownMenu ||
e.ToolStrip is MenuStrip
)
{
ToolStripMenuItem Item = (ToolStripMenuItem)e.Item;
if (Item.Selected || Item.Checked || Item.Pressed)
IDrawMenustripItem(Item, e.Graphics, e.ToolStrip);
}
else if (
e.ToolStrip is StatusStrip
)
{
}
else
{
ToolStripButton Item = (ToolStripButton)e.Item;
if (Item.Selected || Item.Checked || Item.Pressed)
IDrawToolstripButton(Item, e.Graphics, e.ToolStrip);
}
}
#endregion
#region "Render Dropdown Button Background"
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected override void OnRenderDropDownButtonBackground(ToolStripItemRenderEventArgs e)
{
if (e.Item.Selected || e.Item.Pressed)
IDrawDropDownButton((ToolStripDropDownButton)e.Item, e.Graphics, e.ToolStrip);
}
#endregion
#region "Render Image Margin -- Handles drawing the image margin on drop-down menus"
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected override void OnRenderImageMargin(ToolStripRenderEventArgs e)
{
Rectangle Area = new Rectangle(
2,
2,
e.AffectedBounds.Width,
e.AffectedBounds.Height - 4
);
PaintBackground(e.Graphics, Area, _mnuManager.MarginLeft, _mnuManager.MarginRight, 0f);
e.Graphics.DrawLine(
new Pen(_mnuManager.MenuBorderDark),
e.AffectedBounds.Width + 1,
2,
e.AffectedBounds.Width + 1,
e.AffectedBounds.Height - 3
);
}
#endregion
#region "Render Item Text -- Allows smoothing of text and changing the color"
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected override void OnRenderItemText(ToolStripItemTextRenderEventArgs e)
{
if (_smoothText)
e.Graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;
if (_overrideText)
e.TextColor = _overrideColor;
base.OnRenderItemText(e);
}
#endregion
#region "Render Menuitem Background -- Handles drawing menu-item backgrounds"
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected override void OnRenderMenuItemBackground(ToolStripItemRenderEventArgs e)
{
ToolStripMenuItem Item = (ToolStripMenuItem)e.Item;
if ((!Item.Selected && !Item.Checked && !Item.Pressed) || Item.Enabled == false)
{
return;
}
if (
e.ToolStrip is MenuStrip ||
e.ToolStrip is ToolStripDropDownMenu ||
e.ToolStrip is ContextMenuStrip
)
{
IDrawMenustripItem(Item, e.Graphics, e.ToolStrip);
}
}
#endregion
#region "Render Seperator -- Handles drawing the seperator for the toolstrip and contextmenu controls"
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected override void OnRenderSeparator(ToolStripSeparatorRenderEventArgs e)
{
if (
e.ToolStrip is ContextMenuStrip ||
e.ToolStrip is ToolStripDropDownMenu
)
{
// Draw it
e.Graphics.DrawLine(new Pen(_mnuManager.SeperatorDark), _mnuManager.SeperatorInset, 3, e.Item.Width + 1, 3);
e.Graphics.DrawLine(new Pen(_mnuManager.SeperatorLight), _mnuManager.SeperatorInset, 4, e.Item.Width + 1, 4);
}
else
{
if (e.Vertical)
{
e.Graphics.DrawLine(new Pen(_tsCtrlManager.SeperatorDark), 3, 5, 3, e.Item.Height - 6);
e.Graphics.DrawLine(new Pen(_tsCtrlManager.SeperatorLight), 4, 6, 4, e.Item.Height - 6);
}
else
{
e.Graphics.DrawLine(new Pen(_tsCtrlManager.SeperatorDark), 8, 0, e.Item.Width - 6, 0);
e.Graphics.DrawLine(new Pen(_tsCtrlManager.SeperatorLight), 9, 1, e.Item.Width - 6, 1);
}
}
}
#endregion
#region "Render SplitButton Background -- Handles drawing the split button"
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected override void OnRenderSplitButtonBackground(ToolStripItemRenderEventArgs e)
{
ToolStripSplitButton Item = (ToolStripSplitButton)e.Item;
IDrawToolstripSplitButton(Item, e.Graphics, e.ToolStrip);
}
#endregion
#region "Render Statusstrip Sizing Grip"
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected override void OnRenderStatusStripSizingGrip(ToolStripRenderEventArgs e)
{
using (SolidBrush Top = new SolidBrush(_sBarManager.GripTop),
Bottom = new SolidBrush(_sBarManager.GripBottom))
{
Int32 d = _sBarManager.GripSpacing;
Int32 y = e.AffectedBounds.Bottom - (d * 4);
for (int a = 1; a < 4; a++)
{
y += d;
for (int b = 1; a >= b; b++)
{
Int32 x = e.AffectedBounds.Right - (d * b);
e.Graphics.FillRectangle(Bottom, x + 1, y + 1, 2, 2);
e.Graphics.FillRectangle(Top, x, y, 2, 2);
}
}
}
}
#endregion
#region "Render Toolstrip Background -- Handles drawing toolstrip/menu/status-strip backgrounds"
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected override void OnRenderToolStripBackground(ToolStripRenderEventArgs e)
{
if (
e.ToolStrip is ContextMenuStrip ||
e.ToolStrip is ToolStripDropDownMenu
)
{
PaintBackground(e.Graphics, e.AffectedBounds, _mnuManager.BackgroundTop, _mnuManager.BackgroundBottom, 90f, _mnuManager.BackgroundBlend);
Rectangle Border = new Rectangle(
0,
0,
e.AffectedBounds.Width - 1,
e.AffectedBounds.Height - 1
);
using (GraphicsPath Path = CreateDrawingPath(Border, 0))
{
e.Graphics.ExcludeClip(new Rectangle(
1,
0,
e.ConnectedArea.Width,
e.ConnectedArea.Height - 1
));
PaintBorder(e.Graphics, Path, new SolidBrush(_mnuManager.MenuBorderDark));
e.Graphics.ResetClip();
Path.Dispose();
}
}
else if (
e.ToolStrip is MenuStrip)
{
Rectangle Area = e.AffectedBounds;
PaintBackground(e.Graphics, Area, new SolidBrush(_pManager.ContentPanelTop));
}
else if (
e.ToolStrip is StatusStrip strip
)
{
IDrawStatusbarBackground(strip, e.Graphics, e.AffectedBounds);
}
else
{
e.ToolStrip.BackColor = Color.Transparent;
IDrawToolstripBackground(e.ToolStrip, e.Graphics, e.AffectedBounds);
}
}
#endregion
#region "Render Toolstrip Border -- Handles drawing the border for toolstrip/menu/status-strip controls"
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected override void OnRenderToolStripBorder(ToolStripRenderEventArgs e)
{
if (
e.ToolStrip is ContextMenuStrip ||
e.ToolStrip is ToolStripDropDownMenu
)
{
}
else if (
e.ToolStrip is StatusStrip
)
{
}
else if (
e.ToolStrip is MenuStrip
)
{
}
else
{
Rectangle Area = new Rectangle(
0,
-2,
e.AffectedBounds.Width - 2,
e.AffectedBounds.Height + 1
);
using (GraphicsPath Path = CreateDrawingPath(Area, _tsManager.Curve))
{
PaintBorder(
e.Graphics,
Path,
e.AffectedBounds,
_tsManager.BorderTop,
_tsManager.BorderBottom,
_tsManager.BorderAngle,
_tsManager.BorderBlend
);
Path.Dispose();
}
}
}
#endregion
#region "Render Toolstrip Content Panel Background -- Handles drawing the content panel background"
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected override void OnRenderToolStripContentPanelBackground(ToolStripContentPanelRenderEventArgs e)
{
if (e.ToolStripContentPanel.ClientRectangle.Width < 3 || e.ToolStripContentPanel.ClientRectangle.Height < 3)
{
return;
}
e.Handled = true;
e.Graphics.SmoothingMode = _pManager.Mode;
PaintBackground(
e.Graphics,
e.ToolStripContentPanel.ClientRectangle,
_pManager.ContentPanelTop,
_pManager.ContentPanelBottom,
_pManager.BackgroundAngle,
_pManager.BackgroundBlend
);
}
#endregion
#region "Render Toolstrip Panel Background -- Handles drawing the backgrounds for each panel"
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected override void OnRenderToolStripPanelBackground(ToolStripPanelRenderEventArgs e)
{
if (e.ToolStripPanel.ClientRectangle.Width < 3 || e.ToolStripPanel.ClientRectangle.Height < 3)
return;
e.Handled = true;
switch (e.ToolStripPanel.Dock)
{
case DockStyle.Top:
PaintBackground(
e.Graphics,
e.ToolStripPanel.ClientRectangle,
new SolidBrush(_pManager.ContentPanelTop)
);
break;
case DockStyle.Bottom:
PaintBackground(
e.Graphics,
e.ToolStripPanel.ClientRectangle,
new SolidBrush(_pManager.ContentPanelBottom)
);
break;
case DockStyle.Left:
case DockStyle.Right:
PaintBackground(
e.Graphics,
e.ToolStripPanel.ClientRectangle,
_pManager.ContentPanelTop,
_pManager.ContentPanelBottom,
_pManager.BackgroundAngle,
_pManager.BackgroundBlend
);
break;
}
}
#endregion
#endregion
#region "Other functions"
#region "Apply -- Applies any recent changes to the renderer"
/// <summary>
/// Applies any and all changes made to the Renderer
/// </summary>
public void Apply()
{
ToolStripManager.Renderer = this;
}
#endregion
#endregion
}
#endregion
#region "EasyRender -- Toolstrip controlling class"
/// <summary>
/// A class designed to be used in the EasyRender master control to customize the look and feel of the base Toolstrip
/// </summary>
public class IToolstrip : IDisposable
{
#region "Initialization and Setup"
/// <summary>
/// Creates a new IToolstrip class for customization
/// </summary>
public IToolstrip()
{
DefaultBlending();
}
/// <summary>
/// Creates a new IToolstrip class for customization
/// </summary>
/// <param name="Import">The IToolstrip to import the settings from</param>
public IToolstrip(IToolstrip Import)
{
DefaultBlending();
Apply(Import);
}
/// <summary>
/// Disposes of the IToolstrip class and clears all resources related to it
/// </summary>
public void Dispose()
{
GC.SuppressFinalize(this);
}
#endregion
#region "Private variables"
private int _curve = 2;
private Color _borderTop = Color.Transparent;
private Color _borderBottom = Color.FromArgb(71, 117, 177);
private Blend _borderBlend = null;
private float _borderAngle = 90;
private Color _backTop = Color.FromArgb(227, 239, 255);
private Color _backBottom = Color.FromArgb(163, 193, 234);
private Blend _backBlend = null;
private float _backAngle = 90;
#endregion
#region "Properties"
/// <summary>
/// Gets or sets the color of the Toolstrip background gradient from the top
/// </summary>
public Color BackgroundTop
{
get
{
return _backTop;
}
set
{
_backTop = value;
}
}
/// <summary>
/// Gets or sets the color of the Toolstrip background gradient from the bottom
/// </summary>
public Color BackgroundBottom
{
get
{
return _backBottom;
}
set
{
_backBottom = value;
}
}
/// <summary>
/// Gets or sets the blending that will occur when rendering the Toolstrip background
/// If set to null, the Toolstrip will simply draw the gradient
/// </summary>
public Blend BackgroundBlend
{
get
{
return _backBlend;
}
set
{
_backBlend = value;
}
}
/// <summary>
/// Gets or sets the angle which the Toolstrip background will be drawn
/// </summary>
public float BackgroundAngle
{
get
{
return _backAngle;
}
set
{
_backAngle = value;
}
}
/// <summary>
/// Gets or sets the color of the Toolstrip border gradient from the top
/// </summary>
public Color BorderTop
{
get
{
return _borderTop;
}
set
{
_borderTop = value;
}
}
/// <summary>
/// Gets or sets the color of the Toolstrip border gradient from the bottom
/// </summary>
public Color BorderBottom
{
get
{
return _borderBottom;
}
set
{
_borderBottom = value;
}
}
/// <summary>
/// Gets or sets the blending that will occur when rendering the Toolstrip border
/// If set to null, the Toolstrip will simply draw the border
/// </summary>
public Blend BorderBlend
{
get
{
return _borderBlend;
}
set
{
_borderBlend = value;
}
}
/// <summary>
/// Gets or sets the angle which the Toolstrip border will be drawn
/// </summary>
public float BorderAngle
{
get
{
return _borderAngle;
}
set
{
_borderAngle = value;
}
}
/// <summary>
/// Gets or sets the curve of the border of the Toolstrip
/// </summary>
public int Curve
{
get
{
return _curve;
}
set
{
_curve = value;
}
}
#endregion
#region "Methods"
/// <summary>
/// Imports the settings from a previous or pre-defined IToolstrip and applies it to the current
/// </summary>
/// <param name="Import">The IToolstrip to import the settings from</param>
public void Apply(IToolstrip Import)
{
_backTop = Import._borderTop;
_backBottom = Import._borderBottom;
_backAngle = Import._borderAngle;
_backBlend = Import._backBlend;
_borderTop = Import._borderTop;
_borderBottom = Import._borderBottom;
_borderAngle = Import._borderAngle;
_borderBlend = Import._borderBlend;
_curve = Import._curve;
}
/// <summary>
/// Sets the blending for both border and background to their defaults
/// </summary>
public void DefaultBlending()
{
_borderBlend = new Blend
{
Positions = new float[] { 0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1f },
Factors = new float[] { 0.1f, 0.2f, 0.3f, 0.3f, 0.3f, 0.4f, 0.4f, 0.4f, 0.5f, 0.7f, 0.7f }
};
_backBlend = new Blend
{
Positions = new float[] { 0f, 0.3f, 0.5f, 0.8f, 1f },
Factors = new float[] { 0f, 0f, 0f, 0.5f, 1f }
};
}
#endregion
}
#endregion
#region "EasyRender -- Toolstrip extended controls"
/// <summary>
///
/// </summary>
public class IToolstripControls : IDisposable
{
#region "Initialization and Setup"
/// <summary>
/// Creates a new IToolstripControls class for customization
/// </summary>
public IToolstripControls()
{
}
/// <summary>
/// Disposes of the IToolstripControls class and clears all resources related to it
/// </summary>
public void Dispose()
{
GC.SuppressFinalize(this);
}
#endregion
#region "Private variables"
private Color _sepDark = Color.FromArgb(154, 198, 255);
private Color _sepLight = Color.White;
private int _sepHeight = 8;
private Color _gripTop = Color.FromArgb(111, 157, 217);
private Color _gripBottom = Color.White;
private GripType _gripStyle = GripType.Dotted;
private int _gripDistance = 4;
private Size _gripSize = new Size(2, 2);
#endregion
#region "Properties"
/// <summary>
/// Gets or sets the color of the Toolstrip seperator on the dark side
/// </summary>
public Color SeperatorDark
{
get
{
return _sepDark;
}
set
{
_sepDark = value;
}
}
/// <summary>
/// Gets or sets the color of the Toolstrip seperator on the light side
/// </summary>
public Color SeperatorLight
{
get
{
return _sepLight;
}
set
{
_sepLight = value;
}
}
/// <summary>
/// Gets or sets the height of the Toolstrip seperator control
/// </summary>
public int SeperatorHeight
{
get
{
return _sepHeight;
}
set
{
_sepHeight = value;
}
}
/// <summary>
/// Gets or sets the color of the grip dots/line at the top
/// </summary>
public Color GripTop
{
get
{
return _gripTop;
}
set
{
_gripTop = value;
}
}
/// <summary>
/// Gets or sets the color of the grip shadow
/// </summary>
public Color GripShadow
{
get
{
return _gripBottom;
}
set
{
_gripBottom = value;
}
}
/// <summary>
/// Gets or sets in what mode the grip will be drawn
/// </summary>
public GripType GripStyle
{
get { return _gripStyle; }
set { _gripStyle = value; }
}
/// <summary>
/// Gets or sets the distance, in pixels, between each grip dot
/// </summary>
public int GripDistance
{
get { return _gripDistance; }
set { _gripDistance = value; }
}
/// <summary>
/// Gets or sets the size of the dots or lines for the grip
/// </summary>
public Size GripSize
{
get { return _gripSize; }
set { _gripSize = value; }
}
#endregion
#region "Methods"
/// <summary>
/// Imports the settings from a previous or pre-defined IToolstripControls and applies it to the current
/// </summary>
/// <param name="Import">The IToolstripControls to import the settings from</param>
public void Apply(IToolstripControls Import)
{
_sepDark = Import._sepDark;
_sepLight = Import._sepLight;
_sepHeight = Import._sepHeight;
_gripTop = Import._gripTop;
_gripBottom = Import._gripBottom;
_gripDistance = Import._gripDistance;
_gripStyle = Import._gripStyle;
_gripSize = Import._gripSize;
}
#endregion
}
#endregion
#region "EasyRender -- Button controlling class"
/// <summary>
///
/// </summary>
public class IButton : IDisposable
{
#region "Initialization and Setup"
/// <summary>
/// Creates a new IButton class for customization
/// </summary>
public IButton()
{
DefaultBlending();
}
/// <summary>
/// Creates a new IButton class for customization
/// </summary>
/// <param name="Import">The IButton to import the settings from</param>
public IButton(IButton Import)
{
DefaultBlending();
Apply(Import);
}
/// <summary>
/// Disposes of the IButton class and clears all resources related to it
/// </summary>
public void Dispose()
{
GC.SuppressFinalize(this);
}
#endregion
#region "Private variables"
private Color _borderTop = Color.FromArgb(157, 183, 217);
private Color _borderBottom = Color.FromArgb(157, 183, 217);
private Color _borderInner = Color.FromArgb(255, 247, 185);
private Blend _borderBlend = null;
private float _borderAngle = 90f;
private Color _hoverBackTop = Color.FromArgb(255, 249, 218);
private Color _hoverBackBottom = Color.FromArgb(237, 189, 62);
private Color _clickBackTop = Color.FromArgb(245, 207, 57);
private Color _clickBackBottom = Color.FromArgb(245, 225, 124);
private float _backAngle = 90f;
private Blend _backBlend = null;
private BlendRender _blendRender = BlendRender.Hover | BlendRender.Click | BlendRender.Check;
private int _curve = 1;
#endregion
#region "Properties"
/// <summary>
/// Gets or sets the color of the Button background at the top, when hovered over
/// </summary>
public Color HoverBackgroundTop
{
get
{
return _hoverBackTop;
}
set
{
_hoverBackTop = value;
}
}
/// <summary>
/// Gets or sets the color of the Button background at the bottom, when hovered over
/// </summary>
public Color HoverBackgroundBottom
{
get
{
return _hoverBackBottom;
}
set
{
_hoverBackBottom = value;
}
}
/// <summary>
/// Gets or sets the color of the Button background at the top, when clicked
/// </summary>
public Color ClickBackgroundTop
{
get
{
return _clickBackTop;
}
set
{
_clickBackTop = value;
}
}
/// <summary>
/// Gets or sets the color of the Button background at the bottom, when clicked
/// </summary>
public Color ClickBackgroundBottom
{
get
{
return _clickBackBottom;
}
set
{
_clickBackBottom = value;
}
}
/// <summary>
/// Gets or sets the blending that will occur when rendering the Button background
/// If set to null, the Button will simply draw the gradient
/// </summary>
public Blend BackgroundBlend
{
get
{
return _backBlend;
}
set
{
_backBlend = value;
}
}
/// <summary>
/// Gets or sets the angle which the Button background will be drawn
/// </summary>
public float BackgroundAngle
{
get
{
return _backAngle;
}
set
{
_backAngle = value;
}
}
/// <summary>
/// Gets or sets the color of the Button border gradient from the top
/// </summary>
public Color BorderTop
{
get
{
return _borderTop;
}
set
{
_borderTop = value;
}
}
/// <summary>
/// Gets or sets the color of the Button border gradient from the bottom
/// </summary>
public Color BorderBottom
{
get
{
return _borderBottom;
}
set
{
_borderBottom = value;
}
}
/// <summary>
/// Gets or sets the blending that will occur when rendering the Button border
/// If set to null, the Button will simply draw the border
/// </summary>
public Blend BorderBlend
{
get
{
return _borderBlend;
}
set
{
_borderBlend = value;
}
}
/// <summary>
/// Gets or sets the angle which the Button border will be drawn
/// </summary>
public float BorderAngle
{
get
{
return _borderAngle;
}
set
{
_borderAngle = value;
}
}
/// <summary>
/// Gets or sets the color of the inside border
/// </summary>
public Color InnerBorder
{
get { return _borderInner; }
set { _borderInner = value; }
}
/// <summary>
/// Gets or sets when to apply the rendering ("Normal" does not apply here)
/// </summary>
public BlendRender BlendOptions
{
get
{
return _blendRender;
}
set
{
_blendRender = value;
}
}
/// <summary>
/// Gets or sets the curve of the border of the Button
/// </summary>
public int Curve
{
get
{
return _curve;
}
set
{
_curve = value;
}
}
#endregion
#region "Methods"
/// <summary>
/// Imports the settings from a previous or pre-defined IButton and applies it to the current
/// </summary>
/// <param name="Import">The IButton to import the settings from</param>
public void Apply(IButton Import)
{
_borderTop = Import._borderTop;
_borderBottom = Import._borderBottom;
_borderAngle = Import._borderAngle;
_borderBlend = Import._borderBlend;
_hoverBackTop = Import._hoverBackTop;
_hoverBackBottom = Import._hoverBackBottom;
_clickBackTop = Import._clickBackTop;
_clickBackBottom = Import._clickBackBottom;
_backAngle = Import._backAngle;
_backBlend = Import._backBlend;
_blendRender = Import._blendRender;
_curve = Import._curve;
}
/// <summary>
/// Sets the blending for both border and background to their defaults
/// </summary>
public void DefaultBlending()
{
_borderBlend = null;
_backBlend = new Blend
{
Positions = new float[] { 0f, 0.5f, 0.5f, 1f },
Factors = new float[] { 0f, 0.2f, 1f, 0.3f }
};
}
#endregion
}
#endregion
#region "EasyRender -- Dropdown Button controlling class"
/// <summary>
///
/// </summary>
public class IDropDownButton : IDisposable
{
#region "Initialization and Setup"
/// <summary>
/// Creates a new IButton class for customization
/// </summary>
public IDropDownButton()
{
DefaultBlending();
}
/// <summary>
/// Creates a new IButton class for customization
/// </summary>
/// <param name="Import">The IButton to import the settings from</param>
public IDropDownButton(IDropDownButton Import)
{
DefaultBlending();
Apply(Import);
}
/// <summary>
/// Disposes of the IButton class and clears all resources related to it
/// </summary>
public void Dispose()
{
GC.SuppressFinalize(this);
}
#endregion
#region "Private variables"
private Color _borderTop = Color.FromArgb(157, 183, 217);
private Color _borderBottom = Color.FromArgb(157, 183, 217);
private Color _borderInner = Color.FromArgb(255, 247, 185);
private Blend _borderBlend = null;
private float _borderAngle = 90f;
private Color _hoverBackTop = Color.FromArgb(255, 249, 218);
private Color _hoverBackBottom = Color.FromArgb(237, 189, 62);
private float _backAngle = 90f;
private Blend _backBlend = null;
private BlendRender _blendRender = BlendRender.Hover | BlendRender.Check;
private int _curve = 1;
#endregion
#region "Properties"
/// <summary>
/// Gets or sets the color of the Button background at the top, when hovered over
/// </summary>
public Color HoverBackgroundTop
{
get
{
return _hoverBackTop;
}
set
{
_hoverBackTop = value;
}
}
/// <summary>
/// Gets or sets the color of the Button background at the bottom, when hovered over
/// </summary>
public Color HoverBackgroundBottom
{
get
{
return _hoverBackBottom;
}
set
{
_hoverBackBottom = value;
}
}
/// <summary>
/// Gets or sets the blending that will occur when rendering the Button background
/// If set to null, the Button will simply draw the gradient
/// </summary>
public Blend BackgroundBlend
{
get
{
return _backBlend;
}
set
{
_backBlend = value;
}
}
/// <summary>
/// Gets or sets the angle which the Button background will be drawn
/// </summary>
public float BackgroundAngle
{
get
{
return _backAngle;
}
set
{
_backAngle = value;
}
}
/// <summary>
/// Gets or sets the color of the Button border gradient from the top
/// </summary>
public Color BorderTop
{
get
{
return _borderTop;
}
set
{
_borderTop = value;
}
}
/// <summary>
/// Gets or sets the color of the Button border gradient from the bottom
/// </summary>
public Color BorderBottom
{
get
{
return _borderBottom;
}
set
{
_borderBottom = value;
}
}
/// <summary>
/// Gets or sets the blending that will occur when rendering the Button border
/// If set to null, the Button will simply draw the border
/// </summary>
public Blend BorderBlend
{
get
{
return _borderBlend;
}
set
{
_borderBlend = value;
}
}
/// <summary>
/// Gets or sets the angle which the Button border will be drawn
/// </summary>
public float BorderAngle
{
get
{
return _borderAngle;
}
set
{
_borderAngle = value;
}
}
/// <summary>
/// Gets or sets the color of the inside border
/// </summary>
public Color InnerBorder
{
get { return _borderInner; }
set { _borderInner = value; }
}
/// <summary>
/// Gets or sets when to apply the rendering ("Normal" and "Click" do not apply here)
/// </summary>
public BlendRender BlendOptions
{
get
{
return _blendRender;
}
set
{
_blendRender = value;
}
}
/// <summary>
/// Gets or sets the curve of the border of the Button
/// </summary>
public int Curve
{
get
{
return _curve;
}
set
{
_curve = value;
}
}
#endregion
#region "Methods"
/// <summary>
/// Imports the settings from a previous or pre-defined IDropDownButton and applies it to the current
/// </summary>
/// <param name="Import">The IDropDownButton to import the settings from</param>
public void Apply(IDropDownButton Import)
{
_borderTop = Import._borderTop;
_borderBottom = Import._borderBottom;
_borderAngle = Import._borderAngle;
_borderBlend = Import._borderBlend;
_hoverBackTop = Import._hoverBackTop;
_hoverBackBottom = Import._hoverBackBottom;
_backAngle = Import._backAngle;
_backBlend = Import._backBlend;
_blendRender = Import._blendRender;
_curve = Import._curve;
}
/// <summary>
/// Sets the blending for both border and background to their defaults
/// </summary>
public void DefaultBlending()
{
_borderBlend = null;
_backBlend = new Blend
{
Positions = new float[] { 0f, 0.5f, 0.5f, 1f },
Factors = new float[] { 0f, 0.2f, 1f, 0.3f }
};
}
#endregion
}
#endregion
#region "EasyRender -- Split Button controlling class"
/// <summary>
///
/// </summary>
public class ISplitButton : IDisposable
{
#region "Initialization and Setup"
/// <summary>
/// Creates a new ISplitButton class for customization
/// </summary>
public ISplitButton()
{
DefaultBlending();
}
/// <summary>
/// Disposes of the ISplitButton class and clears all resources related to it
/// </summary>
public void Dispose()
{
GC.SuppressFinalize(this);
}
#endregion
#region "Private variables"
private Color _borderTop = Color.FromArgb(157, 183, 217);
private Color _borderBottom = Color.FromArgb(157, 183, 217);
private Color _borderInner = Color.FromArgb(255, 247, 185);
private Blend _borderBlend = null;
private float _borderAngle = 90f;
private Color _hoverBackTop = Color.FromArgb(255, 249, 218);
private Color _hoverBackBottom = Color.FromArgb(237, 189, 62);
private Color _clickBackTop = Color.FromArgb(245, 207, 57);
private Color _clickBackBottom = Color.FromArgb(245, 225, 124);
private float _backAngle = 90f;
private Blend _backBlend = null;
private ArrowDisplay _arrowDisplay = ArrowDisplay.Always;
private Color _arrowColor = Color.Black;
private BlendRender _blendRender = BlendRender.Hover | BlendRender.Click | BlendRender.Check;
private int _curve = 1;
#endregion
#region "Properties"
/// <summary>
/// Gets or sets the color of the Button background at the top, when hovered over
/// </summary>
public Color HoverBackgroundTop
{
get
{
return _hoverBackTop;
}
set
{
_hoverBackTop = value;
}
}
/// <summary>
/// Gets or sets the color of the Button background at the bottom, when hovered over
/// </summary>
public Color HoverBackgroundBottom
{
get
{
return _hoverBackBottom;
}
set
{
_hoverBackBottom = value;
}
}
/// <summary>
/// Gets or sets the color of the Button background at the top, when clicked
/// </summary>
public Color ClickBackgroundTop
{
get
{
return _clickBackTop;
}
set
{
_clickBackTop = value;
}
}
/// <summary>
/// Gets or sets the color of the Button background at the bottom, when clicked
/// </summary>
public Color ClickBackgroundBottom
{
get
{
return _clickBackBottom;
}
set
{
_clickBackBottom = value;
}
}
/// <summary>
/// Gets or sets the blending that will occur when rendering the Button background
/// If set to null, the Button will simply draw the gradient
/// </summary>
public Blend BackgroundBlend
{
get
{
return _backBlend;
}
set
{
_backBlend = value;
}
}
/// <summary>
/// Gets or sets the angle which the Button background will be drawn
/// </summary>
public float BackgroundAngle
{
get
{
return _backAngle;
}
set
{
_backAngle = value;
}
}
/// <summary>
/// Gets or sets the color of the Button border gradient from the top
/// </summary>
public Color BorderTop
{
get
{
return _borderTop;
}
set
{
_borderTop = value;
}
}
/// <summary>
/// Gets or sets the color of the Button border gradient from the bottom
/// </summary>
public Color BorderBottom
{
get
{
return _borderBottom;
}
set
{
_borderBottom = value;
}
}
/// <summary>
/// Gets or sets the blending that will occur when rendering the Button border
/// If set to null, the Button will simply draw the border
/// </summary>
public Blend BorderBlend
{
get
{
return _borderBlend;
}
set
{
_borderBlend = value;
}
}
/// <summary>
/// Gets or sets the angle which the Button border will be drawn
/// </summary>
public float BorderAngle
{
get
{
return _borderAngle;
}
set
{
_borderAngle = value;
}
}
/// <summary>
/// Gets or sets the color of the inside border
/// </summary>
public Color InnerBorder
{
get { return _borderInner; }
set { _borderInner = value; }
}
/// <summary>
/// Gets or sets when to apply the rendering ("Normal" does not apply here)
/// </summary>
public BlendRender BlendOptions
{
get
{
return _blendRender;
}
set
{
_blendRender = value;
}
}
/// <summary>
/// Gets or sets the curve of the border of the Button
/// </summary>
public int Curve
{
get
{
return _curve;
}
set
{
_curve = value;
}
}
/// <summary>
/// Gets or sets when to display the drop-down arrow
/// </summary>
public ArrowDisplay ArrowDisplay
{
get { return _arrowDisplay; }
set { _arrowDisplay = value; }
}
/// <summary>
/// Gets or sets the color of the drop-down arrow
/// </summary>
public Color ArrowColor
{
get { return _arrowColor; }
set { _arrowColor = value; }
}
#endregion
#region "Methods"
/// <summary>
/// Imports the settings from a previous or pre-defined ISplitButton and applies it to the current
/// </summary>
/// <param name="Import">The ISplitButton to import the settings from</param>
public void Apply(ISplitButton Import)
{
_borderTop = Import._borderTop;
_borderBottom = Import._borderBottom;
_borderAngle = Import._borderAngle;
_borderBlend = Import._borderBlend;
_hoverBackTop = Import._hoverBackTop;
_hoverBackBottom = Import._hoverBackBottom;
_clickBackTop = Import._clickBackTop;
_clickBackBottom = Import._clickBackBottom;
_backAngle = Import._backAngle;
_backBlend = Import._backBlend;
_blendRender = Import._blendRender;
_curve = Import._curve;
_arrowDisplay = Import._arrowDisplay;
_arrowColor = Import._arrowColor;
}
/// <summary>
/// Sets the blending for both border and background to their defaults
/// </summary>
public void DefaultBlending()
{
_borderBlend = null;
_backBlend = new Blend
{
Positions = new float[] { 0f, 0.5f, 0.5f, 1f },
Factors = new float[] { 0f, 0.2f, 1f, 0.3f }
};
}
#endregion
}
#endregion
#region "EasyRender -- Content and Panel controlling class"
/// <summary>
///
/// </summary>
public class IPanel : IDisposable
{
#region "Initialization and Setup"
/// <summary>
/// Creates a new IPanel class for customization
/// </summary>
public IPanel()
{
}
/// <summary>
/// Disposes of the IButton class and clears all resources related to it
/// </summary>
public void Dispose()
{
GC.SuppressFinalize(this);
}
#endregion
#region "Private variables"
private Color _cPanelTop = Color.FromArgb(191, 219, 255);
private Color _cPanelBottom = Color.FromArgb(132, 171, 227);
private float _cPanelAngle = 90f;
private Blend _cPanelBlend = null;
private SmoothingMode _mode = SmoothingMode.HighSpeed;
private Boolean _panelsInherit = false;
#endregion
#region "Properties"
/// <summary>
/// Gets or sets the color of the gradient at the top of the content panel
/// </summary>
public Color ContentPanelTop
{
get { return _cPanelTop; }
set { _cPanelTop = value; }
}
/// <summary>
/// Gets or sets the color of the gradient at the bottom of the content panel
/// </summary>
public Color ContentPanelBottom
{
get { return _cPanelBottom; }
set { _cPanelBottom = value; }
}
/// <summary>
/// Gets or sets whether each panel inherits the shading from the content panel
/// </summary>
public Boolean PanelInheritance
{
get { return _panelsInherit; }
set { _panelsInherit = value; }
}
/// <summary>
/// Gets or sets the angle which the background gradient is drawn
/// </summary>
public float BackgroundAngle
{
get { return _cPanelAngle; }
set { _cPanelAngle = value; }
}
/// <summary>
/// Gets or sets the blend of the background
/// </summary>
public Blend BackgroundBlend
{
get { return _cPanelBlend; }
set { _cPanelBlend = value; }
}
/// <summary>
/// Gets or sets a mode to render the background in
/// </summary>
public SmoothingMode Mode
{
get { return _mode; }
set { _mode = value; }
}
#endregion
}
#endregion
#region "EasyRender -- Status bar controlling class
/// <summary>
///
/// </summary>
public class IStatusBar : IDisposable
{
#region "Initialization and Setup"
/// <summary>
/// Creates a new IStatusBar class for customization
/// </summary>
public IStatusBar()
{
DefaultBlending();
}
/// <summary>
/// Disposes of the IButton class and clears all resources related to it
/// </summary>
public void Dispose()
{
GC.SuppressFinalize(this);
}
#endregion
#region "Private variables"
private Color _backTop = Color.FromArgb(227, 239, 255);
private Color _backBottom = Color.FromArgb(173, 209, 255);
private Blend _backBlend = null;
private float _backAngle = 90;
private Color _borderDark = Color.FromArgb(86, 125, 176);
private Color _borderLight = Color.White;
//private Blend _borderBlend = null;
//private float _borderAngle = 90;
private Color _gripTop = Color.FromArgb(114, 152, 204);
private Color _gripBottom = Color.FromArgb(248, 248, 248);
private Int32 _gripSpacing = 4;
#endregion
#region "Properties"
/// <summary>
/// Gets or sets the color of the gradient of the background at the top
/// </summary>
public Color BackgroundTop
{
get { return _backTop; }
set { _backTop = value; }
}
/// <summary>
/// Gets or sets the color of the gradient of the background at the bottom
/// </summary>
public Color BackgroundBottom
{
get { return _backBottom; }
set { _backBottom = value; }
}
/// <summary>
/// Gets or sets the blending that will apply to the background
/// </summary>
public Blend BackgroundBlend
{
get { return _backBlend; }
set { _backBlend = value; }
}
/// <summary>
/// Gets or sets the angle which the background gradient will be drawn
/// </summary>
public float BackgroundAngle
{
get { return _backAngle; }
set { _backAngle = value; }
}
/// <summary>
/// Gets or sets the color of the dark border
/// </summary>
public Color DarkBorder
{
get { return _borderDark; }
set { _borderDark = value; }
}
/// <summary>
/// Gets or sets the color of the light border
/// </summary>
public Color LightBorder
{
get { return _borderLight; }
set { _borderLight = value; }
}
/// <summary>
/// Gets or sets the color of the grip at the top-most
/// </summary>
public Color GripTop
{
get { return _gripTop; }
set { _gripTop = value; }
}
/// <summary>
/// Gets or sets the color of the grip at the bottom-most
/// </summary>
public Color GripBottom
{
get { return _gripBottom; }
set { _gripBottom = value; }
}
/// <summary>
/// Gets or sets the spacing of the grip blocks
/// </summary>
public Int32 GripSpacing
{
get { return _gripSpacing; }
set { _gripSpacing = value; }
}
#endregion
#region "Methods"
/// <summary>
/// Imports the settings from a previous or pre-defined IStatusBar and applies it to the current
/// </summary>
/// <param name="Import">The IStatusBar to import the settings from</param>
public void Apply(IStatusBar Import)
{
_borderDark = Import._borderDark;
_borderLight = Import._borderLight;
_backTop = Import._backTop;
_backBottom = Import._backBottom;
_backAngle = Import._backAngle;
_backBlend = Import._backBlend;
}
/// <summary>
/// Sets the blending for both border and background to their defaults
/// </summary>
public void DefaultBlending()
{
//_borderBlend = null;
_backBlend = new Blend
{
Positions = new float[] { 0f, 0.25f, 0.25f, 0.57f, 0.86f, 1f },
Factors = new float[] { 0.1f, 0.6f, 1f, 0.4f, 0f, 0.95f }
};
}
#endregion
}
#endregion
#region "EasyRender -- Menustrip controlling class"
/// <summary>
/// A class designed to be used in the EasyRender master control to customize the look and feel of the base Menustrip
/// </summary>
public class IMenustrip : IDisposable
{
#region "Initialization and Setup"
/// <summary>
/// Creates a new IToolstrip class for customization
/// </summary>
public IMenustrip()
{
_buttons = new IButton();
DefaultBlending();
}
/// <summary>
/// Creates a new IMenustrip class for customization
/// </summary>
/// <param name="Import">The IMenustrip to import the settings from</param>
public IMenustrip(IMenustrip Import)
{
_buttons = new IButton();
DefaultBlending();
Apply(Import);
}
/// <summary>
/// Disposes of the IMenustrip class and clears all resources related to it
/// </summary>
public void Dispose()
{
GC.SuppressFinalize(this);
}
#endregion
#region "Private variables"
private Color _menuBorderDark = Color.FromArgb(157, 183, 217);
private Color _menuBorderLight = Color.Transparent;
private InheritenceType _menuBackInh = InheritenceType.FromContentPanel;
private Color _menuBackTop = Color.White;
private Color _menuBackBottom = Color.White;
private Blend _menuBackBlend = null;
private Color _menuStripBtnBackground = Color.White;
private Color _menuStripBtnBorder = Color.FromArgb(157, 183, 217);
private IButton _buttons = null;
private Color _marginLeft = Color.FromArgb(242, 255, 255);
private Color _marginRight = Color.FromArgb(233, 238, 238);
private Color _marginBorder = Color.FromArgb(197, 197, 197);
private Color _sepDark = Color.FromArgb(197, 197, 197);
private Color _sepLight = Color.FromArgb(254, 254, 254);
private Int32 _sepInset = 30;
#endregion
#region "Properties"
/// <summary>
/// Gets or sets the color of the menu-strip border (dark)
/// </summary>
public Color MenuBorderDark
{
get { return _menuBorderDark; }
set { _menuBorderDark = value; }
}
/// <summary>
/// Gets or sets the color of the menu-strip border (light)
/// </summary>
public Color MenuBorderLight
{
get { return _menuBorderLight; }
set { _menuBorderLight = value; }
}
/// <summary>
/// Gets or sets how the background of the menu-strip is inherited
/// </summary>
public InheritenceType BackgroundInheritence
{
get { return _menuBackInh; }
set { _menuBackInh = value; }
}
/// <summary>
/// If inheritence is set to none, the color of the background gradient at the top
/// </summary>
public Color BackgroundTop
{
get { return _menuBackTop; }
set { _menuBackTop = value; }
}
/// <summary>
/// If inheritence is set to none, the color of the background gradient at the bottom
/// </summary>
public Color BackgroundBottom
{
get { return _menuBackBottom; }
set { _menuBackBottom = value; }
}
/// <summary>
/// If inheritence is set to none, the blending option for the background
/// </summary>
public Blend BackgroundBlend
{
get { return _menuBackBlend; }
set { _menuBackBlend = value; }
}
/// <summary>
/// Gets or sets the color of the margin gradient at the left
/// </summary>
public Color MarginLeft
{
get { return _marginLeft; }
set { _marginLeft = value; }
}
/// <summary>
/// Gets or sets the color of the margin gradient at the right
/// </summary>
public Color MarginRight
{
get { return _marginRight; }
set { _marginRight = value; }
}
/// <summary>
/// Gets or sets the color of the margin border (displayed to the right)
/// </summary>
public Color MarginBorder
{
get { return _marginBorder; }
set { _marginBorder = value; }
}
/// <summary>
/// Gets or sets the color of the root menu-strip button background when it is selected
/// </summary>
public Color MenustripButtonBackground
{
get { return _menuStripBtnBackground; }
set { _menuStripBtnBackground = value; }
}
/// <summary>
/// Gets or sets the color of the root menu-strip button border when it is selected
/// </summary>
public Color MenustripButtonBorder
{
get { return _menuStripBtnBorder; }
set { _menuStripBtnBorder = value; }
}
/// <summary>
/// Gets or sets the color of the seperator dark color
/// </summary>
public Color SeperatorDark
{
get { return _sepDark; }
set { _sepDark = value; }
}
/// <summary>
/// Gets or sets the color of the seperator light color
/// </summary>
public Color SeperatorLight
{
get { return _sepLight; }
set { _sepLight = value; }
}
/// <summary>
/// Gets or sets the inset position of the seperator from the left
/// </summary>
public Int32 SeperatorInset
{
get { return _sepInset; }
set { _sepInset = value; }
}
/// <summary>
/// Gets the class that handles the look and feel of the menu-strip items
/// </summary>
[ReadOnly(true)]
public IButton Items
{
get { return _buttons; }
}
#endregion
#region "Methods"
/// <summary>
/// Imports the settings from a previous or pre-defined IMenustrip and applies it to the current
/// </summary>
/// <param name="Import">The IMenustrip to import the settings from</param>
public void Apply(IMenustrip Import)
{
_menuBackInh = Import._menuBackInh;
_menuBackTop = Import._menuBackTop;
_menuBackBottom = Import._menuBackBottom;
_menuBorderDark = Import._menuBorderDark;
_menuBorderLight = Import._menuBorderLight;
_menuBackBlend = Import._menuBackBlend;
_buttons = Import._buttons;
}
/// <summary>
/// Sets the blending for the background to it's default
/// </summary>
public void DefaultBlending()
{
_menuBackBlend = new Blend
{
Positions = new float[] { 0f, 0.3f, 0.5f, 0.8f, 1f },
Factors = new float[] { 0f, 0f, 0f, 0.5f, 1f }
};
}
#endregion
}
#endregion
#region "EasyRender -- Enumerators"
/// <summary>
/// Defines when to show an arrow
/// </summary>
public enum ArrowDisplay
{
/// <summary>
///
/// </summary>
Always,
/// <summary>
///
/// </summary>
Hover,
/// <summary>
///
/// </summary>
Never
}
/// <summary>
/// Defines when to use a blend property
/// </summary>
public enum BlendRender
{
/// <summary>
/// Use the blend when the object is drawn
/// </summary>
Normal,
/// <summary>
/// Use the blend when the object is hovered over
/// </summary>
Hover,
/// <summary>
/// Use the blend when the object is clicked
/// </summary>
Click,
/// <summary>
/// Use the blend when the object is checked
/// </summary>
Check,
/// <summary>
/// Always use the blend regardless of the state of the object
/// </summary>
All = Normal | Hover | Click | Check
}
/// <summary>
/// Defines a method of drawing a grip on a control
/// </summary>
public enum GripType
{
/// <summary>
/// Draws the grip as a set of dots
/// </summary>
Dotted,
/// <summary>
/// Draws the grip as two lines
/// </summary>
Lines,
/// <summary>
/// Does not draw the grip at all, but the object remains moveable
/// </summary>
None
}
/// <summary>
/// Defines a specific type of button to search by
/// </summary>
public enum ButtonType
{
/// <summary>
///
/// </summary>
NormalButton,
/// <summary>
///
/// </summary>
SplitButton,
/// <summary>
///
/// </summary>
MenuItem,
/// <summary>
///
/// </summary>
DropDownButton
}
/// <summary>
/// Defines a method for background or object inheritence
/// </summary>
public enum InheritenceType
{
/// <summary>
///
/// </summary>
FromContentPanel,
/// <summary>
///
/// </summary>
None
}
/// <summary>
/// Defines a method of rendering
/// </summary>
public enum RenderingMode
{
/// <summary>
///
/// </summary>
System,
/// <summary>
///
/// </summary>
Professional,
/// <summary>
///
/// </summary>
Custom
}
#endregion
}
Reference in New Issue View Git Blame Copy Permalink