1545 lines
74 KiB
C#
1545 lines
74 KiB
C#
using System;
|
|
using System.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Drawing.Imaging;
|
|
|
|
#if AdvTree
|
|
namespace DevComponents.Tree
|
|
#elif DOTNETBAR
|
|
namespace DevComponents.DotNetBar
|
|
#endif
|
|
{
|
|
/// <summary>
|
|
/// Paints the ElementStyle
|
|
/// </summary>
|
|
public class ElementStyleDisplay
|
|
{
|
|
/// <summary>Creates new instance of the object.</summary>
|
|
public ElementStyleDisplay()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Paints text for given style.
|
|
/// </summary>
|
|
/// <param name="e">Display information.</param>
|
|
/// <param name="text">Text to paint.</param>
|
|
/// <param name="defaultFont">Default font if no font by style is specified.</param>
|
|
public static void PaintText(ElementStyleDisplayInfo e, string text, Font defaultFont)
|
|
{
|
|
PaintText(e, text, defaultFont, false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Paints text for given style.
|
|
/// </summary>
|
|
/// <param name="e">Display information.</param>
|
|
/// <param name="text"><Text to paint./param>
|
|
/// <param name="defaultFont">Default font if no font by style is specified.</param>
|
|
/// <param name="useDefaultFont">Specifies whether to use default font for painting regardless of style settings.</param>
|
|
public static void PaintText(ElementStyleDisplayInfo e, string text, Font defaultFont, bool useDefaultFont)
|
|
{
|
|
PaintText(e, text, defaultFont, useDefaultFont, e.Style.TextFormat);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Paints text for given style.
|
|
/// </summary>
|
|
/// <param name="e">Display information.</param>
|
|
/// <param name="text"><Text to paint./param>
|
|
/// <param name="defaultFont">Default font if no font by style is specified.</param>
|
|
/// <param name="useDefaultFont">Specifies whether to use default font for painting regardless of style settings.</param>
|
|
public static void PaintText(ElementStyleDisplayInfo e, string text, Font defaultFont, bool useDefaultFont, eTextFormat textFormat)
|
|
{
|
|
Rectangle textBounds = e.Bounds;
|
|
bool disposeStyle = false;
|
|
ElementStyle style = GetElementStyle(e.Style, out disposeStyle);
|
|
|
|
if (text == "" || textBounds.IsEmpty)
|
|
{
|
|
if (disposeStyle) style.Dispose();
|
|
return;
|
|
}
|
|
|
|
Font font = style.Font;
|
|
if (font == null || useDefaultFont)
|
|
font = defaultFont;
|
|
|
|
textBounds.X += style.MarginLeft + style.PaddingLeft;
|
|
textBounds.Width -= (style.MarginLeft + style.MarginRight + style.PaddingLeft + style.PaddingRight);
|
|
textBounds.Y += style.MarginTop + style.PaddingTop;
|
|
textBounds.Height -= (style.MarginTop + style.MarginBottom + style.PaddingTop + style.PaddingBottom);
|
|
|
|
if (!style.TextShadowColor.IsEmpty && Math.Abs(style.TextShadowColor.GetBrightness() - style.TextColor.GetBrightness()) > .2)
|
|
{
|
|
using (SolidBrush brush = new SolidBrush(style.TextShadowColor))
|
|
{
|
|
Rectangle r = textBounds;
|
|
r.Offset(style.TextShadowOffset);
|
|
TextDrawing.DrawString(e.Graphics, text, font, style.TextShadowColor, r, textFormat);
|
|
//e.Graphics.DrawString(text,font,brush,r,style.StringFormat);
|
|
}
|
|
}
|
|
Color textColor = style.TextColor;
|
|
if (textColor.IsEmpty && style.TextShadowColor.IsEmpty)
|
|
textColor = SystemColors.ControlText;
|
|
if (!textColor.IsEmpty)
|
|
TextDrawing.DrawString(e.Graphics, text, font, textColor, textBounds, textFormat);
|
|
|
|
if (disposeStyle) style.Dispose();
|
|
}
|
|
|
|
/// <summary>Returns new Region object for given ElementStyle.</summary>
|
|
/// <returns>New instance of Region object.</returns>
|
|
/// <param name="e">Information to describe ElementStyle.</param>
|
|
public static Region GetStyleRegion(ElementStyleDisplayInfo e)
|
|
{
|
|
Rectangle rectPath = e.Bounds;
|
|
if (e.Style.PaintBorder && e.Style.CornerType != eCornerType.Square)
|
|
{
|
|
rectPath.Width--;
|
|
rectPath.Height--;
|
|
}
|
|
|
|
Region r = new Region();
|
|
using (GraphicsPath path = ElementStyleDisplay.GetBackgroundPath(e.Style, rectPath))
|
|
{
|
|
r.MakeEmpty();
|
|
r.Union(path);
|
|
// Widen path for the border...
|
|
if (e.Style.PaintBorder && (e.Style.CornerType == eCornerType.Rounded || e.Style.CornerType == eCornerType.Diagonal ||
|
|
e.Style.CornerTypeTopLeft == eCornerType.Rounded || e.Style.CornerTypeTopLeft == eCornerType.Diagonal ||
|
|
e.Style.CornerTypeTopRight == eCornerType.Rounded || e.Style.CornerTypeTopRight == eCornerType.Diagonal ||
|
|
e.Style.CornerTypeBottomLeft == eCornerType.Rounded || e.Style.CornerTypeBottomLeft == eCornerType.Diagonal ||
|
|
e.Style.CornerTypeBottomRight == eCornerType.Rounded || e.Style.CornerTypeBottomRight == eCornerType.Diagonal))
|
|
{
|
|
using (Pen pen = new Pen(Color.Black, (e.Style.BorderTopWidth > 0 ? e.Style.BorderTopWidth : 1)))
|
|
{
|
|
path.Widen(pen);
|
|
}
|
|
//Region r2 = new Region(path);
|
|
r.Union(path);
|
|
}
|
|
}
|
|
|
|
return r;
|
|
//GraphicsPath path=ElementStyleDisplay.GetBackgroundPath(e.Style,e.Bounds,false);
|
|
//return new Region(path);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the clipping for the content of the element style.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
/// <returns></returns>
|
|
public static GraphicsPath GetInsideClip(ElementStyleDisplayInfo e)
|
|
{
|
|
Rectangle rectPath = e.Bounds;
|
|
// GDI bug
|
|
if (e.Style.PaintBorder)
|
|
{
|
|
if (e.Style.PaintTopBorder)
|
|
{
|
|
rectPath.Y += e.Style.BorderTopWidth;
|
|
rectPath.Height -= e.Style.BorderTopWidth;
|
|
|
|
if (e.Style.BorderTop == eStyleBorderType.Etched || e.Style.BorderTop == eStyleBorderType.Double)
|
|
{
|
|
rectPath.Y += e.Style.BorderTopWidth;
|
|
rectPath.Height -= e.Style.BorderTopWidth;
|
|
}
|
|
}
|
|
|
|
if (e.Style.PaintBottomBorder)
|
|
{
|
|
rectPath.Height -= e.Style.BorderBottomWidth;
|
|
if (e.Style.BorderBottom == eStyleBorderType.Etched || e.Style.BorderBottom == eStyleBorderType.Double)
|
|
rectPath.Height -= e.Style.BorderBottomWidth;
|
|
}
|
|
|
|
if (e.Style.PaintLeftBorder)
|
|
{
|
|
rectPath.X += e.Style.BorderLeftWidth;
|
|
rectPath.Width -= e.Style.BorderLeftWidth;
|
|
if (e.Style.BorderLeft == eStyleBorderType.Etched || e.Style.BorderLeft == eStyleBorderType.Double)
|
|
{
|
|
rectPath.X += e.Style.BorderLeftWidth;
|
|
rectPath.Width -= e.Style.BorderLeftWidth;
|
|
}
|
|
}
|
|
|
|
if (e.Style.PaintRightBorder)
|
|
{
|
|
rectPath.Width -= e.Style.BorderRightWidth;
|
|
if (e.Style.BorderRight == eStyleBorderType.Etched || e.Style.BorderRight == eStyleBorderType.Double)
|
|
rectPath.Width -= e.Style.BorderRightWidth;
|
|
}
|
|
}
|
|
|
|
GraphicsPath path = ElementStyleDisplay.GetBackgroundPath(e.Style, rectPath);
|
|
|
|
return path;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Paints the element style on the canvas.
|
|
/// </summary>
|
|
/// <param name="e">Holds information necessary to paint style on canvas.</param>
|
|
public static void Paint(ElementStyleDisplayInfo e)
|
|
{
|
|
ElementStyleDisplay.PaintBackground(e);
|
|
ElementStyleDisplay.PaintBackgroundImage(e);
|
|
ElementStyleDisplay.PaintBorder(e);
|
|
}
|
|
|
|
private static eCornerType GetCornerType(eCornerType baseType, eCornerType specificType)
|
|
{
|
|
if (specificType != eCornerType.Inherit)
|
|
return specificType;
|
|
return baseType;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Paint style border.
|
|
/// </summary>
|
|
/// <param name="e">Style display information.</param>
|
|
public static void PaintBorder(ElementStyleDisplayInfo e)
|
|
{
|
|
bool disposeStyle = false;
|
|
ElementStyle style = GetElementStyle(e.Style, out disposeStyle);
|
|
Rectangle backBounds = GetBackgroundRectangle(style, e.Bounds);
|
|
Rectangle bounds = ElementStyleDisplay.GetBorderRectangle(style, backBounds);
|
|
try
|
|
{
|
|
if (bounds.Width < 2 || bounds.Height < 2)
|
|
{
|
|
return;
|
|
}
|
|
|
|
eCornerType cornerTopLeft = GetCornerType(style.CornerType, style.CornerTypeTopLeft);
|
|
eCornerType cornerTopRight = GetCornerType(style.CornerType, style.CornerTypeTopRight);
|
|
eCornerType cornerBottomLeft = GetCornerType(style.CornerType, style.CornerTypeBottomLeft);
|
|
eCornerType cornerBottomRight = GetCornerType(style.CornerType, style.CornerTypeBottomRight);
|
|
|
|
if (style.PaintBorder && style.Border == eStyleBorderType.Solid && cornerTopLeft == eCornerType.Rounded &&
|
|
cornerTopRight == eCornerType.Rounded &&
|
|
cornerBottomLeft == eCornerType.Rounded && cornerBottomRight == eCornerType.Rounded &&
|
|
style.BorderLeftWidth == style.BorderWidth && style.BorderRightWidth == style.BorderWidth
|
|
&& style.BorderTopWidth == style.BorderWidth && style.BorderBottomWidth == style.BorderWidth)
|
|
{
|
|
if (style.BorderWidth == 1)
|
|
{
|
|
bounds.Width++;
|
|
bounds.Height++;
|
|
}
|
|
DisplayHelp.DrawRoundGradientRectangle(e.Graphics, bounds, style.BorderColor, style.BorderColor2,
|
|
style.BorderGradientAngle, style.BorderWidth,
|
|
style.CornerDiameter);
|
|
return;
|
|
}
|
|
else if (style.PaintAllBorders && style.Border == eStyleBorderType.Solid &&
|
|
cornerTopLeft == eCornerType.Square && cornerTopRight == eCornerType.Square &&
|
|
cornerBottomLeft == eCornerType.Square && cornerBottomRight == eCornerType.Square &&
|
|
style.BorderLeftWidth == style.BorderWidth && style.BorderRightWidth == style.BorderWidth
|
|
&& style.BorderTopWidth == style.BorderWidth && style.BorderBottomWidth == style.BorderWidth)
|
|
{
|
|
if (style.BorderWidth == 1)
|
|
{
|
|
bounds.Width++;
|
|
bounds.Height++;
|
|
}
|
|
DisplayHelp.DrawGradientRectangle(e.Graphics, bounds, style.BorderColor, style.BorderColor2,
|
|
style.BorderGradientAngle, style.BorderWidth);
|
|
return;
|
|
}
|
|
else if (style.Border == eStyleBorderType.None && style.BorderRight == eStyleBorderType.Etched &&
|
|
style.BorderLeft == eStyleBorderType.None &&
|
|
style.BorderTop == eStyleBorderType.None && style.BorderBottom == eStyleBorderType.None)
|
|
{
|
|
DisplayHelp.DrawGradientRectangle(e.Graphics,
|
|
new Rectangle(bounds.Right - 2, bounds.Y, 3,
|
|
bounds.Height + 1),
|
|
style.BorderColorLight,
|
|
style.BorderColorLight2,
|
|
90,
|
|
1);
|
|
DisplayHelp.DrawGradientLine(e.Graphics,
|
|
new Point(bounds.Right, bounds.Y),
|
|
new Point(bounds.Right, bounds.Bottom + 1),
|
|
style.BorderColor,
|
|
style.BorderColor2,
|
|
90,
|
|
1);
|
|
return;
|
|
}
|
|
|
|
if (!style.BorderColor2.IsEmpty || !style.BorderColorLight.IsEmpty)
|
|
{
|
|
if (style.Border == eStyleBorderType.Solid)
|
|
{
|
|
using (
|
|
GraphicsPath path = DisplayHelp.GetRoundedRectanglePath(bounds, style.CornerDiameter,
|
|
eStyleBackgroundPathPart.Complete,
|
|
cornerTopLeft, cornerTopRight,
|
|
cornerBottomLeft, cornerBottomRight)
|
|
)
|
|
{
|
|
DisplayHelp.DrawGradientPathBorder(e.Graphics, path, style.BorderColor, style.BorderColor2,
|
|
style.BorderGradientAngle, style.BorderWidth);
|
|
}
|
|
return;
|
|
}
|
|
else if (style.Border == eStyleBorderType.Etched)
|
|
{
|
|
Rectangle r = bounds;
|
|
|
|
r.Width -= style.BorderWidth;
|
|
r.Height -= style.BorderWidth;
|
|
r.Offset(style.BorderWidth, style.BorderWidth);
|
|
if (r.Width > 2 && r.Height > 2)
|
|
{
|
|
using (
|
|
GraphicsPath path = DisplayHelp.GetRoundedRectanglePath(r, style.CornerDiameter,
|
|
eStyleBackgroundPathPart.
|
|
Complete,
|
|
cornerTopLeft, cornerTopRight,
|
|
cornerBottomLeft,
|
|
cornerBottomRight)
|
|
)
|
|
{
|
|
DisplayHelp.DrawGradientPathBorder(e.Graphics, path, style.BorderColorLight,
|
|
style.BorderColorLight2,
|
|
style.BorderLightGradientAngle,
|
|
style.BorderWidth);
|
|
}
|
|
r.Offset(-style.BorderWidth, -style.BorderWidth);
|
|
using (
|
|
GraphicsPath path = DisplayHelp.GetRoundedRectanglePath(r, style.CornerDiameter,
|
|
eStyleBackgroundPathPart.
|
|
Complete,
|
|
cornerTopLeft, cornerTopRight,
|
|
cornerBottomLeft,
|
|
cornerBottomRight)
|
|
)
|
|
{
|
|
DisplayHelp.DrawGradientPathBorder(e.Graphics, path, style.BorderColor,
|
|
style.BorderColor2,
|
|
style.BorderGradientAngle, style.BorderWidth);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
else if ((style.BorderTop == eStyleBorderType.Double && style.BorderLeft == eStyleBorderType.Double &&
|
|
style.BorderRight == eStyleBorderType.Double &&
|
|
style.BorderBottom == eStyleBorderType.Double) ||
|
|
(style.BorderTop == eStyleBorderType.None && style.BorderLeft == eStyleBorderType.Double &&
|
|
style.BorderRight == eStyleBorderType.Double &&
|
|
style.BorderBottom == eStyleBorderType.Double))
|
|
{
|
|
Rectangle r = bounds;
|
|
Region oldClip = null;
|
|
bool clipSet = false;
|
|
if (style.BorderTop == eStyleBorderType.None)
|
|
{
|
|
Rectangle clipRect = r;
|
|
clipRect.Width++;
|
|
clipRect.Height++;
|
|
e.Graphics.SetClip(clipRect);
|
|
r.Y -= 3;
|
|
r.Height += 3;
|
|
}
|
|
using (
|
|
GraphicsPath path = DisplayHelp.GetBorderPath(r, style.CornerDiameter,
|
|
eStyleBackgroundPathPart.Complete,
|
|
cornerTopLeft, cornerTopRight,
|
|
cornerBottomLeft,
|
|
cornerBottomRight, style.PaintLeftBorder,
|
|
style.PaintRightBorder,
|
|
style.PaintTopBorder,
|
|
style.PaintBottomBorder))
|
|
{
|
|
using (Pen pen = new Pen(style.BorderColor, style.BorderWidth))
|
|
path.Widen(pen);
|
|
DisplayHelp.FillPath(e.Graphics, path, style.BorderColor, style.BorderColor2);
|
|
}
|
|
r.Inflate(-style.BorderWidth, -style.BorderWidth);
|
|
using (
|
|
GraphicsPath path = DisplayHelp.GetBorderPath(r, style.CornerDiameter,
|
|
eStyleBackgroundPathPart.Complete,
|
|
cornerTopLeft, cornerTopRight,
|
|
cornerBottomLeft,
|
|
cornerBottomRight, style.PaintLeftBorder,
|
|
style.PaintRightBorder,
|
|
style.PaintTopBorder,
|
|
style.PaintBottomBorder))
|
|
{
|
|
using (Pen pen = new Pen(style.BorderColor, style.BorderWidth))
|
|
path.Widen(pen);
|
|
DisplayHelp.FillPath(e.Graphics, path, style.BorderColorLight, style.BorderColorLight2);
|
|
}
|
|
|
|
if (clipSet)
|
|
e.Graphics.Clip = oldClip;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
Color colorStart = style.BorderColor;
|
|
Color colorEnd = style.BorderColor2;
|
|
Color colorLightStart = style.BorderColorLight;
|
|
Color colorLightEnd = style.BorderColorLight2;
|
|
BorderDrawInfo borderDrawInfo = new BorderDrawInfo(style.PaintLeftBorder, style.PaintRightBorder,
|
|
style.PaintTopBorder, style.PaintBottomBorder,
|
|
e.IsTwistedDoubleBorder);
|
|
|
|
if (style.PaintLeftBorder)
|
|
{
|
|
Color color = style.BorderColor;
|
|
if (!style.BorderLeftColor.IsEmpty)
|
|
color = style.BorderLeftColor;
|
|
Point[] p = new Point[2];
|
|
|
|
// Corner type square is default setting
|
|
p[0] = bounds.Location;
|
|
p[1].X = bounds.X;
|
|
p[1].Y = bounds.Bottom;
|
|
|
|
if (cornerTopLeft != eCornerType.Square)
|
|
{
|
|
p[0].Y += style.CornerDiameter;
|
|
}
|
|
if (cornerBottomLeft != eCornerType.Square)
|
|
{
|
|
p[1].Y -= style.CornerDiameter;
|
|
}
|
|
|
|
ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderLeft, style.BorderLeftWidth, color,
|
|
colorEnd, colorLightStart, colorLightEnd, eBorderSide.Left,
|
|
borderDrawInfo);
|
|
|
|
if (style.PaintTopBorder && cornerTopLeft != eCornerType.Square)
|
|
{
|
|
if (cornerTopLeft == eCornerType.Diagonal)
|
|
{
|
|
p[0].X = bounds.X;
|
|
p[0].Y = bounds.Y + style.CornerDiameter;
|
|
p[1].X = bounds.X + style.CornerDiameter;
|
|
p[1].Y = bounds.Y;
|
|
ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderLeft, style.BorderLeftWidth, color,
|
|
colorEnd, colorLightStart, colorLightEnd, eBorderSide.TopLeft,
|
|
borderDrawInfo);
|
|
}
|
|
else if (cornerTopLeft == eCornerType.Rounded)
|
|
{
|
|
ArcData a = GetCornerArc(bounds, style.CornerDiameter, eCornerArc.TopLeft);
|
|
// new ArcData(bounds.X,bounds.Y,style.CornerDiameter*2,style.CornerDiameter*2,180,90);
|
|
ElementStyleDisplay.DrawCornerArc(e.Graphics, a, style.BorderLeft, style.BorderLeftWidth, color);
|
|
}
|
|
}
|
|
|
|
if (style.PaintBottomBorder && cornerBottomLeft != eCornerType.Square)
|
|
{
|
|
if (cornerBottomLeft == eCornerType.Diagonal)
|
|
{
|
|
p[0].X = bounds.X;
|
|
p[0].Y = bounds.Bottom - style.CornerDiameter;
|
|
p[1].X = bounds.X + style.CornerDiameter;
|
|
p[1].Y = bounds.Bottom;
|
|
ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderLeft, style.BorderLeftWidth, color,
|
|
colorEnd, colorLightStart, colorLightEnd,
|
|
eBorderSide.BottomLeft, borderDrawInfo);
|
|
}
|
|
else if (cornerBottomLeft == eCornerType.Rounded)
|
|
{
|
|
ArcData a = GetCornerArc(bounds, style.CornerDiameter, eCornerArc.BottomLeft);
|
|
// new ArcData(bounds.X,bounds.Y,style.CornerDiameter*2,style.CornerDiameter*2,180,90);
|
|
ElementStyleDisplay.DrawCornerArc(e.Graphics, a, style.BorderLeft, style.BorderLeftWidth, color);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (style.PaintTopBorder)
|
|
{
|
|
Color color = style.BorderColor;
|
|
if (!style.BorderTopColor.IsEmpty)
|
|
color = style.BorderTopColor;
|
|
Point[] p = new Point[2];
|
|
// Default setting for Square corner type on both sides
|
|
p[0] = bounds.Location;
|
|
p[1].X = bounds.Right;
|
|
p[1].Y = bounds.Y;
|
|
|
|
if (cornerTopLeft != eCornerType.Square)
|
|
{
|
|
p[0].X += style.CornerDiameter;
|
|
}
|
|
if (cornerTopRight != eCornerType.Square)
|
|
{
|
|
p[1].X -= style.CornerDiameter;
|
|
}
|
|
ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderTop, style.BorderTopWidth, color, colorEnd,
|
|
colorLightStart, colorLightEnd, eBorderSide.Top, borderDrawInfo);
|
|
}
|
|
|
|
if (style.PaintBottomBorder)
|
|
{
|
|
Color color = style.BorderColor;
|
|
if (!style.BorderBottomColor.IsEmpty)
|
|
color = style.BorderBottomColor;
|
|
Point[] p = new Point[2];
|
|
// Default for Square corner type on both sides
|
|
p[0].X = bounds.X;
|
|
p[0].Y = bounds.Bottom;
|
|
p[1].X = bounds.Right;
|
|
p[1].Y = bounds.Bottom;
|
|
|
|
if (cornerBottomLeft != eCornerType.Square)
|
|
{
|
|
p[0].X += style.CornerDiameter;
|
|
}
|
|
if (cornerBottomRight != eCornerType.Square)
|
|
{
|
|
p[1].X -= style.CornerDiameter;
|
|
}
|
|
|
|
ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderBottom, style.BorderBottomWidth, color,
|
|
colorEnd, colorLightStart, colorLightEnd, eBorderSide.Bottom,
|
|
borderDrawInfo);
|
|
}
|
|
|
|
if (style.PaintRightBorder)
|
|
{
|
|
Color color = style.BorderColor;
|
|
if (!style.BorderRightColor.IsEmpty)
|
|
color = style.BorderRightColor;
|
|
Point[] p = new Point[2];
|
|
// Default for Square corner type on both sides
|
|
p[0].X = bounds.Right;
|
|
p[0].Y = bounds.Y;
|
|
p[1].X = bounds.Right;
|
|
p[1].Y = bounds.Bottom;
|
|
|
|
if (cornerTopRight != eCornerType.Square)
|
|
{
|
|
p[0].Y += style.CornerDiameter;
|
|
}
|
|
if (cornerBottomRight != eCornerType.Square)
|
|
{
|
|
p[1].Y -= style.CornerDiameter;
|
|
}
|
|
|
|
ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderRight, style.BorderRightWidth, color,
|
|
colorEnd, colorLightStart, colorLightEnd, eBorderSide.Right,
|
|
borderDrawInfo);
|
|
|
|
if (style.PaintTopBorder && cornerTopRight != eCornerType.Square)
|
|
{
|
|
if (cornerTopRight == eCornerType.Diagonal)
|
|
{
|
|
p[0].X = bounds.Right - style.CornerDiameter;
|
|
p[0].Y = bounds.Y;
|
|
p[1].X = bounds.Right;
|
|
p[1].Y = bounds.Y + style.CornerDiameter;
|
|
ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderLeft, style.BorderRightWidth,
|
|
color, colorEnd, colorLightStart, colorLightEnd,
|
|
eBorderSide.TopRight, borderDrawInfo);
|
|
}
|
|
else if (cornerTopRight == eCornerType.Rounded)
|
|
{
|
|
ArcData a = GetCornerArc(bounds, style.CornerDiameter, eCornerArc.TopRight);
|
|
// new ArcData(bounds.X,bounds.Y,style.CornerDiameter*2,style.CornerDiameter*2,180,90);
|
|
ElementStyleDisplay.DrawCornerArc(e.Graphics, a, style.BorderLeft, style.BorderLeftWidth, color);
|
|
}
|
|
}
|
|
|
|
if (style.PaintBottomBorder && cornerBottomRight != eCornerType.Square)
|
|
{
|
|
if (cornerBottomRight == eCornerType.Diagonal)
|
|
{
|
|
p[0].X = bounds.Right;
|
|
p[0].Y = bounds.Bottom - style.CornerDiameter;
|
|
p[1].X = bounds.Right - style.CornerDiameter;
|
|
p[1].Y = bounds.Bottom;
|
|
ElementStyleDisplay.DrawBorderLine(e.Graphics, p, style.BorderLeft, style.BorderRightWidth,
|
|
color, colorEnd, colorLightStart, colorLightEnd,
|
|
eBorderSide.BottomRight, borderDrawInfo);
|
|
}
|
|
else if (cornerBottomRight == eCornerType.Rounded)
|
|
{
|
|
ArcData a = GetCornerArc(bounds, style.CornerDiameter, eCornerArc.BottomRight);
|
|
// new ArcData(bounds.X,bounds.Y,style.CornerDiameter*2,style.CornerDiameter*2,180,90);
|
|
ElementStyleDisplay.DrawCornerArc(e.Graphics, a, style.BorderLeft, style.BorderLeftWidth, color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (disposeStyle) style.Dispose();
|
|
}
|
|
}
|
|
|
|
private static Pen CreatePen(eStyleBorderType border, int lineWidth, Color color)
|
|
{
|
|
Pen pen = new Pen(color, lineWidth);
|
|
pen.Alignment = PenAlignment.Inset;
|
|
pen.DashStyle = ElementStyleDisplay.GetDashStyle(border);
|
|
return pen;
|
|
}
|
|
|
|
private static void DrawBorderLine(Graphics g, Point[] p, eStyleBorderType border, int lineWidth, Color colorStart, Color colorEnd, Color colorLightStart, Color colorLightEnd, eBorderSide side, BorderDrawInfo drawInfo)
|
|
{
|
|
if (border == eStyleBorderType.Etched || border == eStyleBorderType.Double)
|
|
{
|
|
if (colorLightStart.IsEmpty)
|
|
{
|
|
colorLightStart = System.Windows.Forms.ControlPaint.Light(colorStart);
|
|
colorStart = System.Windows.Forms.ControlPaint.Dark(colorStart);
|
|
}
|
|
|
|
if (drawInfo.IsTwistedDoubleBorder && (side == eBorderSide.Bottom || side == eBorderSide.Right))
|
|
{
|
|
Color ct1 = colorStart;
|
|
Color ct2 = colorEnd;
|
|
colorStart = colorLightStart;
|
|
colorEnd = colorLightEnd;
|
|
colorLightStart = ct1;
|
|
colorLightEnd = ct2;
|
|
}
|
|
|
|
DisplayHelp.DrawGradientLine(g, p[0], p[1], colorStart, colorEnd, 90, lineWidth);
|
|
|
|
if (side == eBorderSide.Top)
|
|
{
|
|
p[0].Y += lineWidth;
|
|
p[1].Y += lineWidth;
|
|
if (drawInfo.HasLeftBorder)
|
|
p[0].X += 1;
|
|
if (drawInfo.HasRightBorder)
|
|
p[1].X -= 1;
|
|
}
|
|
else if (side == eBorderSide.Bottom)
|
|
{
|
|
p[0].Y -= lineWidth;
|
|
p[1].Y -= lineWidth;
|
|
if (!drawInfo.IsTwistedDoubleBorder)
|
|
{
|
|
if (drawInfo.HasLeftBorder)
|
|
p[0].X += 1;
|
|
if (drawInfo.HasRightBorder)
|
|
p[1].X -= 1;
|
|
}
|
|
}
|
|
else if (side == eBorderSide.Left || side == eBorderSide.BottomLeft || side == eBorderSide.TopLeft)
|
|
{
|
|
p[0].X += lineWidth;
|
|
p[1].X += lineWidth;
|
|
if (drawInfo.HasTopBorder)
|
|
p[0].Y += 1;
|
|
if (drawInfo.HasBottomBorder)
|
|
p[1].Y -= 1;
|
|
}
|
|
else if (side == eBorderSide.Right || side == eBorderSide.BottomRight || side == eBorderSide.TopRight)
|
|
{
|
|
p[0].X -= lineWidth;
|
|
p[1].X -= lineWidth;
|
|
if (!drawInfo.IsTwistedDoubleBorder)
|
|
{
|
|
if (drawInfo.HasTopBorder)
|
|
p[0].Y += 1;
|
|
if (drawInfo.HasBottomBorder)
|
|
p[1].Y -= 1;
|
|
}
|
|
}
|
|
|
|
DisplayHelp.DrawGradientLine(g, p[0], p[1], colorLightStart, colorLightEnd, 90, lineWidth);
|
|
}
|
|
else
|
|
{
|
|
if (colorEnd.IsEmpty)
|
|
{
|
|
SmoothingMode sm = g.SmoothingMode;
|
|
g.SmoothingMode = SmoothingMode.None;
|
|
using (Pen pen = CreatePen(border, lineWidth, colorStart))
|
|
g.DrawLine(pen, p[0], p[1]);
|
|
g.SmoothingMode = sm;
|
|
}
|
|
else
|
|
DisplayHelp.DrawGradientLine(g, p[0], p[1], colorStart, colorEnd, 90, lineWidth);
|
|
}
|
|
}
|
|
|
|
private static void DrawCornerArc(Graphics g, ArcData arc, eStyleBorderType border, int lineWidth, Color color)
|
|
{
|
|
SmoothingMode sm = g.SmoothingMode;
|
|
if (sm == SmoothingMode.None) g.SmoothingMode = SmoothingMode.HighQuality;
|
|
using (Pen pen = CreatePen(border, lineWidth, color))
|
|
{
|
|
g.DrawArc(pen, arc.X, arc.Y, arc.Width, arc.Height, arc.StartAngle, arc.SweepAngle);
|
|
}
|
|
if (sm == SmoothingMode.None) g.SmoothingMode = sm;
|
|
}
|
|
|
|
private static DashStyle GetDashStyle(eStyleBorderType border)
|
|
{
|
|
DashStyle style = DashStyle.Solid;
|
|
switch (border)
|
|
{
|
|
case eStyleBorderType.Dash:
|
|
style = DashStyle.Dash;
|
|
break;
|
|
case eStyleBorderType.DashDot:
|
|
style = DashStyle.DashDot;
|
|
break;
|
|
case eStyleBorderType.DashDotDot:
|
|
style = DashStyle.DashDotDot;
|
|
break;
|
|
case eStyleBorderType.Dot:
|
|
style = DashStyle.Dot;
|
|
break;
|
|
}
|
|
return style;
|
|
}
|
|
|
|
internal static ElementStyle GetElementStyle(ElementStyle style, out bool dispose)
|
|
{
|
|
dispose = false;
|
|
if (style.Class == "")
|
|
return style;
|
|
IElementStyleClassProvider provider = GetIElementStyleClassProvider();
|
|
if (provider != null)
|
|
{
|
|
ElementStyle baseStyle = provider.GetClass(style.Class);
|
|
if (baseStyle != null)
|
|
{
|
|
if (style.Custom)
|
|
{
|
|
ElementStyle copy = baseStyle.Copy();
|
|
copy.ApplyStyle(style);
|
|
dispose = true;
|
|
return copy;
|
|
}
|
|
return baseStyle;
|
|
}
|
|
}
|
|
|
|
return style;
|
|
}
|
|
|
|
private static IElementStyleClassProvider GetIElementStyleClassProvider()
|
|
{
|
|
#if DOTNETBAR
|
|
if (Rendering.GlobalManager.Renderer is Rendering.Office2007Renderer)
|
|
{
|
|
return ((Rendering.Office2007Renderer)Rendering.GlobalManager.Renderer).ColorTable as IElementStyleClassProvider;
|
|
}
|
|
#endif
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Paints style background.
|
|
/// </summary>
|
|
/// <param name="e">Style display information.</param>
|
|
public static void PaintBackground(ElementStyleDisplayInfo e)
|
|
{
|
|
PaintBackground(e, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Paints style background.
|
|
/// </summary>
|
|
/// <param name="e">Style display information.</param>
|
|
public static void PaintBackground(ElementStyleDisplayInfo e, bool shapeBackground)
|
|
{
|
|
Region oldClip = e.Graphics.Clip;
|
|
if (oldClip != null)
|
|
e.Graphics.SetClip(e.Bounds, CombineMode.Intersect);
|
|
else
|
|
e.Graphics.SetClip(e.Bounds, CombineMode.Replace);
|
|
|
|
bool disposeStyle = false;
|
|
ElementStyle style = GetElementStyle(e.Style, out disposeStyle);
|
|
|
|
SmoothingMode sm = e.Graphics.SmoothingMode;
|
|
e.Graphics.SmoothingMode = SmoothingMode.Default;
|
|
|
|
// Paint Background
|
|
Rectangle bounds = DisplayHelp.GetDrawRectangle(ElementStyleDisplay.GetBackgroundRectangle(style, e.Bounds));
|
|
|
|
GraphicsPath path = null;
|
|
if (shapeBackground && !IsSquareCornerType(style))
|
|
{
|
|
path = ElementStyleDisplay.GetBackgroundPath(style, GetBorderRectangle(e.Style, e.Bounds));
|
|
}
|
|
else
|
|
{
|
|
path = new GraphicsPath();
|
|
path.AddRectangle(ElementStyleDisplay.GetBackgroundRectangle(style, e.Bounds));
|
|
}
|
|
|
|
eBackgroundColorBlendType blendType = style.BackColorBlend.GetBlendType();
|
|
if (blendType != eBackgroundColorBlendType.Invalid)
|
|
{
|
|
if (blendType == eBackgroundColorBlendType.Relative)
|
|
{
|
|
try
|
|
{
|
|
if (style.BackColorGradientType == eGradientType.Linear)
|
|
{
|
|
Rectangle rb = bounds;
|
|
rb.Inflate(1, 1);
|
|
using (LinearGradientBrush brush = DisplayHelp.CreateLinearGradientBrush(rb, style.BackColor, style.BackColor2, style.BackColorGradientAngle))
|
|
{
|
|
brush.InterpolationColors = style.BackColorBlend.GetColorBlend();
|
|
e.Graphics.FillPath(brush, path);
|
|
}
|
|
}
|
|
else if (style.BackColorGradientType == eGradientType.Radial)
|
|
{
|
|
int d = (int)Math.Sqrt(bounds.Width * bounds.Width + bounds.Height * bounds.Height) + 4;
|
|
GraphicsPath fillPath = new GraphicsPath();
|
|
fillPath.AddEllipse(bounds.X - (d - bounds.Width) / 2, bounds.Y - (d - bounds.Height) / 2, d, d);
|
|
using (PathGradientBrush brush = new PathGradientBrush(fillPath))
|
|
{
|
|
brush.CenterColor = style.BackColor;
|
|
brush.SurroundColors = new Color[] { style.BackColor2 };
|
|
brush.InterpolationColors = style.BackColorBlend.GetColorBlend();
|
|
e.Graphics.FillPath(brush, path);
|
|
}
|
|
fillPath.Dispose();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
blendType = eBackgroundColorBlendType.Invalid;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Graphics g = e.Graphics;
|
|
bounds = e.Bounds;
|
|
if (oldClip != null)
|
|
{
|
|
e.Graphics.SetClip(oldClip, CombineMode.Replace);
|
|
e.Graphics.SetClip(path, CombineMode.Intersect);
|
|
}
|
|
else
|
|
e.Graphics.SetClip(path, CombineMode.Replace);
|
|
BackgroundColorBlendCollection bc = style.BackColorBlend;
|
|
for (int i = 0; i < bc.Count; i += 2)
|
|
{
|
|
BackgroundColorBlend b1 = bc[i];
|
|
BackgroundColorBlend b2 = null;
|
|
if (i + 1 < bc.Count)
|
|
b2 = bc[i + 1];
|
|
if (b1 != null && b2 != null)
|
|
{
|
|
Rectangle rb = new Rectangle(bounds.X, bounds.Y + (int)b1.Position, bounds.Width,
|
|
(b2.Position == 1f ? bounds.Height : (int)b2.Position) - (int)b1.Position);
|
|
using (LinearGradientBrush brush = DisplayHelp.CreateLinearGradientBrush(rb, b1.Color, b2.Color, style.BackColorGradientAngle))
|
|
g.FillRectangle(brush, rb);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (blendType == eBackgroundColorBlendType.Invalid)
|
|
{
|
|
if (style.BackColor2.IsEmpty)
|
|
{
|
|
if (!style.BackColor.IsEmpty)
|
|
{
|
|
using (SolidBrush brush = new SolidBrush(style.BackColor))
|
|
e.Graphics.FillPath(brush, path);
|
|
//if(e.Style.BackColor.A==255)
|
|
//{
|
|
// // Correct problems with FillPath where path was not filled properly...
|
|
// using(Pen pen=new Pen(e.Style.BackColor,1))
|
|
// e.Graphics.DrawPath(pen,path);
|
|
//}
|
|
}
|
|
}
|
|
else if (!style.BackColor.IsEmpty)
|
|
{
|
|
if (style.BackColorGradientType == eGradientType.Linear)
|
|
{
|
|
Rectangle rb = bounds;
|
|
rb.X--;
|
|
rb.Height++;
|
|
rb.Width += 2;
|
|
using (LinearGradientBrush brush = DisplayHelp.CreateLinearGradientBrush(rb, style.BackColor, style.BackColor2, style.BackColorGradientAngle))
|
|
{
|
|
e.Graphics.FillPath(brush, path);
|
|
}
|
|
}
|
|
else if (style.BackColorGradientType == eGradientType.Radial)
|
|
{
|
|
int d = (int)Math.Sqrt(bounds.Width * bounds.Width + bounds.Height * bounds.Height) + 4;
|
|
GraphicsPath fillPath = new GraphicsPath();
|
|
fillPath.AddEllipse(bounds.X - (d - bounds.Width) / 2, bounds.Y - (d - bounds.Height) / 2, d, d);
|
|
using (PathGradientBrush brush = new PathGradientBrush(fillPath))
|
|
{
|
|
brush.CenterColor = style.BackColor;
|
|
brush.SurroundColors = new Color[] { style.BackColor2 };
|
|
e.Graphics.FillPath(brush, path);
|
|
}
|
|
fillPath.Dispose();
|
|
}
|
|
}
|
|
}
|
|
if (path != null) path.Dispose();
|
|
|
|
e.Graphics.SmoothingMode = sm;
|
|
|
|
if (oldClip != null)
|
|
{
|
|
e.Graphics.Clip = oldClip;
|
|
oldClip.Dispose();
|
|
oldClip = null;
|
|
}
|
|
else
|
|
e.Graphics.ResetClip();
|
|
|
|
if (disposeStyle) style.Dispose();
|
|
}
|
|
|
|
private static bool IsSquareCornerType(ElementStyle style)
|
|
{
|
|
return (style.CornerType == eCornerType.Square || style.CornerType == eCornerType.Inherit) &&
|
|
(style.CornerTypeTopLeft == eCornerType.Square || style.CornerTypeTopLeft == eCornerType.Inherit) &&
|
|
(style.CornerTypeTopRight == eCornerType.Square || style.CornerTypeTopRight == eCornerType.Inherit);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Paints style background image.
|
|
/// </summary>
|
|
/// <param name="e">Style display information.</param>
|
|
public static void PaintBackgroundImage(ElementStyleDisplayInfo e)
|
|
{
|
|
bool disposeStyle = false;
|
|
ElementStyle style = GetElementStyle(e.Style, out disposeStyle);
|
|
GraphicsPath path = null;
|
|
try
|
|
{
|
|
if (style.BackgroundImage == null)
|
|
return;
|
|
|
|
Rectangle bounds = ElementStyleDisplay.GetBackgroundRectangle(style, e.Bounds);
|
|
if (e.Graphics.SmoothingMode == SmoothingMode.AntiAlias)
|
|
{
|
|
Rectangle r = e.Bounds;
|
|
//r.Width--;
|
|
//r.Height--;
|
|
path = ElementStyleDisplay.GetBackgroundPath(style, r);
|
|
}
|
|
else
|
|
path = ElementStyleDisplay.GetBackgroundPath(style, e.Bounds);
|
|
|
|
ImageAttributes imageAtt = null;
|
|
|
|
if (style.BackgroundImageAlpha != 255)
|
|
{
|
|
//ColorMatrix colorMatrix = new ColorMatrix();
|
|
//colorMatrix.Matrix33 = 255 - style.BackgroundImageAlpha;
|
|
float[][] matrixItems ={
|
|
new float[] {1, 0, 0, 0, 0},
|
|
new float[] {0, 1, 0, 0, 0},
|
|
new float[] {0, 0, 1, 0, 0},
|
|
new float[] {0, 0, 0, (float)style.BackgroundImageAlpha/255, 0},
|
|
new float[] {0, 0, 0, 0, 1}};
|
|
System.Drawing.Imaging.ColorMatrix colorMatrix = new System.Drawing.Imaging.ColorMatrix(matrixItems);
|
|
imageAtt = new ImageAttributes();
|
|
imageAtt.SetColorMatrix(colorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
|
|
}
|
|
|
|
Region clip = e.Graphics.Clip;
|
|
e.Graphics.SetClip(path, CombineMode.Intersect);
|
|
|
|
eStyleBackgroundImage imagePosition = style.BackgroundImagePosition;
|
|
bool transform = false;
|
|
Image backgroundImage = style.BackgroundImage;
|
|
|
|
if (e.RightToLeft)
|
|
{
|
|
if (imagePosition == eStyleBackgroundImage.TopLeft)
|
|
{
|
|
imagePosition = eStyleBackgroundImage.TopRight;
|
|
transform = true;
|
|
}
|
|
else if (imagePosition == eStyleBackgroundImage.TopRight)
|
|
imagePosition = eStyleBackgroundImage.TopLeft;
|
|
else if (imagePosition == eStyleBackgroundImage.BottomLeft)
|
|
imagePosition = eStyleBackgroundImage.BottomRight;
|
|
else if (imagePosition == eStyleBackgroundImage.BottomRight)
|
|
imagePosition = eStyleBackgroundImage.BottomLeft;
|
|
}
|
|
|
|
if (transform)
|
|
{
|
|
backgroundImage = backgroundImage.Clone() as Image;
|
|
backgroundImage.RotateFlip(RotateFlipType.RotateNoneFlipX);
|
|
}
|
|
|
|
switch (imagePosition)
|
|
{
|
|
case eStyleBackgroundImage.Stretch:
|
|
{
|
|
if (imageAtt != null)
|
|
e.Graphics.DrawImage(backgroundImage, bounds, 0, 0, backgroundImage.Width,
|
|
backgroundImage.Height, GraphicsUnit.Pixel, imageAtt);
|
|
else
|
|
e.Graphics.DrawImage(backgroundImage, bounds, 0, 0, backgroundImage.Width,
|
|
backgroundImage.Height, GraphicsUnit.Pixel);
|
|
break;
|
|
}
|
|
case eStyleBackgroundImage.Zoom:
|
|
{
|
|
Size backImageSize = backgroundImage.Size;
|
|
Rectangle newImageBounds = Rectangle.Empty;
|
|
float horizontalRatio = ((float)bounds.Width) / ((float)backImageSize.Width);
|
|
float verticalRatio = ((float)bounds.Height) / ((float)backImageSize.Height);
|
|
if (horizontalRatio >= verticalRatio)
|
|
{
|
|
newImageBounds.Height = bounds.Height;
|
|
newImageBounds.Width = (int)((backImageSize.Width * verticalRatio) + 0.5);
|
|
if (bounds.X >= 0)
|
|
{
|
|
newImageBounds.X = (bounds.Width - newImageBounds.Width) / 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
newImageBounds.Width = bounds.Width;
|
|
newImageBounds.Height = (int)((backImageSize.Height * horizontalRatio) + 0.5);
|
|
if (bounds.Y >= 0)
|
|
{
|
|
newImageBounds.Y = (bounds.Height - newImageBounds.Height) / 2;
|
|
}
|
|
}
|
|
bounds = newImageBounds;
|
|
|
|
if (imageAtt != null)
|
|
{
|
|
|
|
e.Graphics.DrawImage(backgroundImage, bounds, 0, 0, backgroundImage.Width,
|
|
backgroundImage.Height, GraphicsUnit.Pixel, imageAtt);
|
|
}
|
|
else
|
|
e.Graphics.DrawImage(backgroundImage, bounds, 0, 0, backgroundImage.Width,
|
|
backgroundImage.Height, GraphicsUnit.Pixel);
|
|
break;
|
|
}
|
|
case eStyleBackgroundImage.Center:
|
|
{
|
|
Rectangle destRect = new Rectangle(bounds.X, bounds.Y, Dpi.Width(backgroundImage.Width),
|
|
Dpi.Height(backgroundImage.Height));
|
|
if (bounds.Width > destRect.Width)
|
|
destRect.X += (bounds.Width - destRect.Width) / 2;
|
|
if (bounds.Height > destRect.Height)
|
|
destRect.Y += (bounds.Height - destRect.Height) / 2;
|
|
if (imageAtt != null)
|
|
e.Graphics.DrawImage(backgroundImage, destRect, 0, 0, backgroundImage.Width,
|
|
backgroundImage.Height, GraphicsUnit.Pixel, imageAtt);
|
|
else
|
|
e.Graphics.DrawImage(backgroundImage, destRect, 0, 0, backgroundImage.Width,
|
|
backgroundImage.Height, GraphicsUnit.Pixel);
|
|
|
|
break;
|
|
}
|
|
case eStyleBackgroundImage.TopLeft:
|
|
case eStyleBackgroundImage.TopRight:
|
|
case eStyleBackgroundImage.BottomLeft:
|
|
case eStyleBackgroundImage.BottomRight:
|
|
{
|
|
Rectangle destRect = new Rectangle(bounds.X, bounds.Y, Dpi.Width(backgroundImage.Width),
|
|
Dpi.Height(backgroundImage.Height));
|
|
if (imagePosition == eStyleBackgroundImage.TopRight)
|
|
destRect.X = bounds.Right - destRect.Width;
|
|
else if (imagePosition == eStyleBackgroundImage.BottomLeft)
|
|
destRect.Y = bounds.Bottom - destRect.Height;
|
|
else if (imagePosition == eStyleBackgroundImage.BottomRight)
|
|
{
|
|
destRect.Y = bounds.Bottom - destRect.Height;
|
|
destRect.X = bounds.Right - destRect.Width;
|
|
}
|
|
|
|
if (imageAtt != null)
|
|
e.Graphics.DrawImage(backgroundImage, destRect, 0, 0, backgroundImage.Width,
|
|
backgroundImage.Height, GraphicsUnit.Pixel, imageAtt);
|
|
else
|
|
e.Graphics.DrawImage(backgroundImage, destRect, 0, 0, backgroundImage.Width,
|
|
backgroundImage.Height, GraphicsUnit.Pixel);
|
|
break;
|
|
}
|
|
case eStyleBackgroundImage.Tile:
|
|
{
|
|
if (imageAtt != null)
|
|
{
|
|
if (bounds.Width > backgroundImage.Width || bounds.Height > backgroundImage.Height)
|
|
{
|
|
int x = bounds.X, y = bounds.Y;
|
|
while (y < bounds.Bottom)
|
|
{
|
|
while (x < bounds.Right)
|
|
{
|
|
Rectangle destRect = new Rectangle(x, y, Dpi.Width(backgroundImage.Width),
|
|
Dpi.Height(backgroundImage.Height));
|
|
if (destRect.Right > bounds.Right)
|
|
destRect.Width = destRect.Width - (destRect.Right - bounds.Right);
|
|
if (destRect.Bottom > bounds.Bottom)
|
|
destRect.Height = destRect.Height - (destRect.Bottom - bounds.Bottom);
|
|
e.Graphics.DrawImage(backgroundImage, destRect, 0, 0, destRect.Width,
|
|
destRect.Height, GraphicsUnit.Pixel, imageAtt);
|
|
x += Dpi.Width(backgroundImage.Width);
|
|
}
|
|
x = bounds.X;
|
|
y += Dpi.Height(backgroundImage.Height);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
e.Graphics.DrawImage(backgroundImage,
|
|
new Rectangle(0, 0, Dpi.Width(backgroundImage.Width),
|
|
Dpi.Height(backgroundImage.Height)), 0, 0,
|
|
backgroundImage.Width, backgroundImage.Height,
|
|
GraphicsUnit.Pixel, imageAtt);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TextureBrush brush = new TextureBrush(backgroundImage);
|
|
brush.WrapMode = WrapMode.Tile;
|
|
e.Graphics.FillPath(brush, path);
|
|
brush.Dispose();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (transform)
|
|
{
|
|
backgroundImage.Dispose();
|
|
}
|
|
|
|
if (clip != null)
|
|
{
|
|
e.Graphics.Clip = clip;
|
|
clip.Dispose();
|
|
}
|
|
else
|
|
e.Graphics.ResetClip();
|
|
}
|
|
finally
|
|
{
|
|
if (path != null) path.Dispose();
|
|
if (disposeStyle) style.Dispose();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns background rectangle for given style by taking in account margins.
|
|
/// </summary>
|
|
/// <param name="style">Reference to style object.</param>
|
|
/// <param name="bounds">Style bounds</param>
|
|
/// <returns>Background rectangle.</returns>
|
|
public static Rectangle GetBackgroundRectangle(ElementStyle style, Rectangle bounds)
|
|
{
|
|
// Reduce the bounds rectangle size by the margin size
|
|
bounds.X += style.MarginLeft;
|
|
bounds.Width -= (style.MarginLeft + style.MarginRight);
|
|
bounds.Y += style.MarginTop;
|
|
bounds.Height -= (style.MarginTop + style.MarginBottom);
|
|
return bounds;
|
|
}
|
|
|
|
private static Rectangle GetBorderRectangle(ElementStyle style, Rectangle bounds)
|
|
{
|
|
if (style.PaintRightBorder)
|
|
{
|
|
if (style.BorderRightWidth <= 1)
|
|
bounds.Width -= style.BorderRightWidth;
|
|
else
|
|
bounds.Width -= style.BorderRightWidth / 2;
|
|
}
|
|
|
|
if (style.PaintBottomBorder)
|
|
{
|
|
if (style.BorderBottomWidth <= 1)
|
|
bounds.Height -= style.BorderBottomWidth;
|
|
else
|
|
bounds.Height -= style.BorderBottomWidth / 2;
|
|
}
|
|
|
|
if (style.PaintLeftBorder && style.BorderLeftWidth > 1)
|
|
{
|
|
bounds.X += style.BorderLeftWidth / 2;
|
|
bounds.Width -= style.BorderLeftWidth / 2;
|
|
}
|
|
|
|
if (style.PaintTopBorder && style.BorderTopWidth > 1)
|
|
{
|
|
bounds.Y += style.BorderTopWidth / 2;
|
|
bounds.Height -= style.BorderTopWidth / 2;
|
|
}
|
|
|
|
return bounds;
|
|
}
|
|
|
|
private static Rectangle GetTextRectangle(ElementStyle style, Rectangle bounds)
|
|
{
|
|
bounds = ElementStyleDisplay.GetBackgroundRectangle(style, bounds);
|
|
|
|
// Reduce the bounds rectangle size by the padding size
|
|
bounds.X += style.PaddingLeft;
|
|
bounds.Width -= (style.PaddingLeft + style.PaddingRight);
|
|
bounds.Y += style.PaddingTop;
|
|
bounds.Height -= (style.PaddingTop + style.PaddingBottom);
|
|
return bounds;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns GraphicsPath for given style.
|
|
/// </summary>
|
|
/// <param name="style">Reference to style.</param>
|
|
/// <param name="bounds">Style bounds.</param>
|
|
/// <returns>New instance of GraphicsPath</returns>
|
|
public static GraphicsPath GetBackgroundPath(ElementStyle style, Rectangle bounds)
|
|
{
|
|
return GetBackgroundPath(style, bounds, eStyleBackgroundPathPart.Complete);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns GraphicsPath for given style.
|
|
/// </summary>
|
|
/// <param name="style">Reference to style.</param>
|
|
/// <param name="bounds">Style bounds.</param>
|
|
/// <returns>New instance of GraphicsPath</returns>
|
|
public static GraphicsPath GetBackgroundPath(ElementStyle style, Rectangle bounds, eStyleBackgroundPathPart pathPart)
|
|
{
|
|
GraphicsPath path = new GraphicsPath();
|
|
|
|
Rectangle clientRectangle;
|
|
//if(drawPath)
|
|
clientRectangle =/*DisplayHelp.GetDrawRectangle*/(ElementStyleDisplay.GetBackgroundRectangle(style, bounds));
|
|
//else
|
|
// clientRectangle =/*DisplayHelp.GetDrawRectangle*/(ElementStyleDisplay.GetBackgroundRectangle(style, bounds));
|
|
|
|
if (pathPart == eStyleBackgroundPathPart.Complete && style.CornerTypeBottomLeft == eCornerType.Inherit && style.CornerTypeBottomRight == eCornerType.Inherit &&
|
|
style.CornerTypeTopLeft == eCornerType.Inherit && style.CornerTypeTopRight == eCornerType.Inherit)
|
|
{
|
|
switch (style.CornerType)
|
|
{
|
|
case eCornerType.Square:
|
|
{
|
|
path.AddRectangle(clientRectangle);
|
|
break;
|
|
}
|
|
case eCornerType.Rounded:
|
|
{
|
|
ArcData ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.TopLeft);
|
|
path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
|
|
ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.TopRight);
|
|
path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
|
|
ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.BottomRight);
|
|
path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
|
|
ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.BottomLeft);
|
|
path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
|
|
path.CloseAllFigures();
|
|
break;
|
|
}
|
|
case eCornerType.Diagonal:
|
|
{
|
|
path.AddLine(clientRectangle.X, clientRectangle.Bottom - style.CornerDiameter - 1, clientRectangle.X, clientRectangle.Y + style.CornerDiameter);
|
|
path.AddLine(clientRectangle.X + style.CornerDiameter, clientRectangle.Y, clientRectangle.Right - style.CornerDiameter, clientRectangle.Y);
|
|
path.AddLine(clientRectangle.Right, clientRectangle.Y + style.CornerDiameter, clientRectangle.Right, clientRectangle.Bottom - style.CornerDiameter - 1);
|
|
path.AddLine(clientRectangle.Right - style.CornerDiameter - 1, clientRectangle.Bottom, clientRectangle.X + style.CornerDiameter, clientRectangle.Bottom);
|
|
path.CloseAllFigures();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pathPart == eStyleBackgroundPathPart.TopHalf)
|
|
clientRectangle.Height = clientRectangle.Height / 2;
|
|
else if (pathPart == eStyleBackgroundPathPart.BottomHalf)
|
|
{
|
|
int h = clientRectangle.Height;
|
|
clientRectangle.Height = clientRectangle.Height / 2;
|
|
clientRectangle.Y += (h - clientRectangle.Height - 1);
|
|
}
|
|
|
|
eCornerType corner = style.CornerTypeTopLeft;
|
|
if (corner == eCornerType.Inherit)
|
|
corner = style.CornerType;
|
|
|
|
if (pathPart == eStyleBackgroundPathPart.BottomHalf)
|
|
corner = eCornerType.Square;
|
|
|
|
if (corner == eCornerType.Rounded)
|
|
{
|
|
ArcData ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.TopLeft);
|
|
path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
|
|
}
|
|
else if (corner == eCornerType.Diagonal)
|
|
{
|
|
path.AddLine(clientRectangle.X, clientRectangle.Y + style.CornerDiameter, clientRectangle.X + style.CornerDiameter, clientRectangle.Y);
|
|
}
|
|
else
|
|
{
|
|
path.AddLine(clientRectangle.X, clientRectangle.Y + 2, clientRectangle.X, clientRectangle.Y);
|
|
path.AddLine(clientRectangle.X, clientRectangle.Y, clientRectangle.X + 2, clientRectangle.Y);
|
|
}
|
|
|
|
corner = style.CornerTypeTopRight;
|
|
if (corner == eCornerType.Inherit)
|
|
corner = style.CornerType;
|
|
if (pathPart == eStyleBackgroundPathPart.BottomHalf)
|
|
corner = eCornerType.Square;
|
|
if (corner == eCornerType.Rounded)
|
|
{
|
|
ArcData ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.TopRight);
|
|
path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
|
|
}
|
|
else if (corner == eCornerType.Diagonal)
|
|
{
|
|
path.AddLine(clientRectangle.Right - style.CornerDiameter - 1, clientRectangle.Y, clientRectangle.Right, clientRectangle.Y + style.CornerDiameter);
|
|
}
|
|
else
|
|
{
|
|
path.AddLine(clientRectangle.Right - 2, clientRectangle.Y, clientRectangle.Right, clientRectangle.Y);
|
|
path.AddLine(clientRectangle.Right, clientRectangle.Y, clientRectangle.Right, clientRectangle.Y + 2);
|
|
}
|
|
|
|
corner = style.CornerTypeBottomRight;
|
|
if (corner == eCornerType.Inherit)
|
|
corner = style.CornerType;
|
|
if (pathPart == eStyleBackgroundPathPart.TopHalf)
|
|
corner = eCornerType.Square;
|
|
if (corner == eCornerType.Rounded)
|
|
{
|
|
ArcData ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.BottomRight);
|
|
path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
|
|
}
|
|
else if (corner == eCornerType.Diagonal)
|
|
{
|
|
path.AddLine(clientRectangle.Right, clientRectangle.Bottom - style.CornerDiameter - 1, clientRectangle.Right - style.CornerDiameter - 1, clientRectangle.Bottom);
|
|
}
|
|
else
|
|
{
|
|
path.AddLine(clientRectangle.Right, clientRectangle.Bottom - 2, clientRectangle.Right, clientRectangle.Bottom);
|
|
path.AddLine(clientRectangle.Right, clientRectangle.Bottom, clientRectangle.Right - 2, clientRectangle.Bottom);
|
|
}
|
|
|
|
corner = style.CornerTypeBottomLeft;
|
|
if (corner == eCornerType.Inherit)
|
|
corner = style.CornerType;
|
|
if (pathPart == eStyleBackgroundPathPart.TopHalf)
|
|
corner = eCornerType.Square;
|
|
if (corner == eCornerType.Rounded)
|
|
{
|
|
ArcData ad = GetCornerArc(clientRectangle, style.CornerDiameter, eCornerArc.BottomLeft);
|
|
path.AddArc(ad.X, ad.Y, ad.Width, ad.Height, ad.StartAngle, ad.SweepAngle);
|
|
}
|
|
else if (corner == eCornerType.Diagonal)
|
|
{
|
|
path.AddLine(clientRectangle.X + 2, clientRectangle.Bottom, clientRectangle.X, clientRectangle.Bottom - style.CornerDiameter - 1);
|
|
}
|
|
else
|
|
{
|
|
path.AddLine(clientRectangle.X + 2, clientRectangle.Bottom, clientRectangle.X, clientRectangle.Bottom);
|
|
path.AddLine(clientRectangle.X, clientRectangle.Bottom, clientRectangle.X, clientRectangle.Bottom - 2);
|
|
}
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
public static void AddCornerArc(GraphicsPath path, Rectangle bounds, int cornerDiameter, eCornerArc corner)
|
|
{
|
|
if (cornerDiameter > 0)
|
|
{
|
|
ArcData a = GetCornerArc(bounds, cornerDiameter, corner);
|
|
path.AddArc(a.X, a.Y, a.Width, a.Height, a.StartAngle, a.SweepAngle);
|
|
}
|
|
else
|
|
{
|
|
if (corner == eCornerArc.TopLeft)
|
|
{
|
|
path.AddLine(bounds.X, bounds.Y + 2, bounds.X, bounds.Y);
|
|
}
|
|
else if (corner == eCornerArc.BottomLeft)
|
|
{
|
|
path.AddLine(bounds.X + 2, bounds.Bottom, bounds.X, bounds.Bottom);
|
|
}
|
|
else if (corner == eCornerArc.TopRight)
|
|
{
|
|
path.AddLine(bounds.Right - 2, bounds.Y, bounds.Right, bounds.Y);
|
|
}
|
|
else if (corner == eCornerArc.BottomRight)
|
|
{
|
|
path.AddLine(bounds.Right, bounds.Bottom - 2, bounds.Right, bounds.Bottom);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal static ArcData GetCornerArc(Rectangle bounds, int cornerDiameter, eCornerArc corner)
|
|
{
|
|
ArcData a;
|
|
if (cornerDiameter == 0) cornerDiameter = 1;
|
|
int diameter = cornerDiameter * 2;
|
|
switch (corner)
|
|
{
|
|
case eCornerArc.TopLeft:
|
|
a = new ArcData(bounds.X, bounds.Y, diameter, diameter, 180, 90);
|
|
break;
|
|
case eCornerArc.TopRight:
|
|
a = new ArcData(bounds.Right - diameter, bounds.Y, diameter, diameter, 270, 90);
|
|
break;
|
|
case eCornerArc.BottomLeft:
|
|
a = new ArcData(bounds.X, bounds.Bottom - diameter, diameter, diameter, 90, 90);
|
|
break;
|
|
default: // eCornerArc.BottomRight:
|
|
a = new ArcData(bounds.Right - diameter, bounds.Bottom - diameter, diameter, diameter, 0, 90);
|
|
break;
|
|
}
|
|
return a;
|
|
}
|
|
|
|
enum eBorderSide
|
|
{
|
|
Top,
|
|
Bottom,
|
|
Left,
|
|
Right,
|
|
TopLeft,
|
|
TopRight,
|
|
BottomLeft,
|
|
BottomRight
|
|
}
|
|
|
|
internal struct BorderDrawInfo
|
|
{
|
|
public bool HasLeftBorder;
|
|
public bool HasRightBorder;
|
|
public bool HasTopBorder;
|
|
public bool HasBottomBorder;
|
|
public bool IsTwistedDoubleBorder;
|
|
/// <summary>
|
|
/// Initializes a new instance of the BorderDrawInfo structure.
|
|
/// </summary>
|
|
/// <param name="hasLeftBorder"></param>
|
|
/// <param name="hasRightBorder"></param>
|
|
/// <param name="hasTopBorder"></param>
|
|
/// <param name="hasBottomBorder"></param>
|
|
/// <param name="isTwistedDoubleBorder"></param>
|
|
public BorderDrawInfo(bool hasLeftBorder, bool hasRightBorder, bool hasTopBorder, bool hasBottomBorder, bool isTwistedDoubleBorder)
|
|
{
|
|
HasLeftBorder = hasLeftBorder;
|
|
HasRightBorder = hasRightBorder;
|
|
HasTopBorder = hasTopBorder;
|
|
HasBottomBorder = hasBottomBorder;
|
|
IsTwistedDoubleBorder = isTwistedDoubleBorder;
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum eCornerArc
|
|
{
|
|
TopLeft,
|
|
TopRight,
|
|
BottomLeft,
|
|
BottomRight
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents information necessary to paint the style on canvas.
|
|
/// </summary>
|
|
public class ElementStyleDisplayInfo
|
|
{
|
|
/// <summary>Reference to ElementStyle object.</summary>
|
|
public ElementStyle Style = null;
|
|
/// <summary>Reference to Graphics object.</summary>
|
|
public Graphics Graphics = null;
|
|
/// <summary>ElementStyle bounds.</summary>
|
|
public Rectangle Bounds = Rectangle.Empty;
|
|
/// <summary>Get or sets whether layout is right-to-left.</summary>
|
|
public bool RightToLeft = false;
|
|
/// <summary>
|
|
/// Gets or sets whether bottom and right border is "twisted" giving beveled look when double border is used.
|
|
/// </summary>
|
|
public bool IsTwistedDoubleBorder = false;
|
|
|
|
/// <summary>Creates new instance of the object.</summary>
|
|
public ElementStyleDisplayInfo()
|
|
{
|
|
}
|
|
|
|
/// <summary>Creates new instance of the object and initializes it with default values.</summary>
|
|
/// <param name="style">Style to initialize object with.</param>
|
|
/// <param name="g">Graphics object to initialize object with.</param>
|
|
/// <param name="bounds">Bounds to initialize object with.</param>
|
|
public ElementStyleDisplayInfo(ElementStyle style, Graphics g, Rectangle bounds)
|
|
{
|
|
this.Style = style;
|
|
this.Graphics = g;
|
|
this.Bounds = bounds;
|
|
}
|
|
/// <summary>Creates new instance of the object and initializes it with default values.</summary>
|
|
/// <param name="style">Style to initialize object with.</param>
|
|
/// <param name="g">Graphics object to initialize object with.</param>
|
|
/// <param name="bounds">Bounds to initialize object with.</param>
|
|
public ElementStyleDisplayInfo(ElementStyle style, Graphics g, Rectangle bounds, bool isTwistedDoubleBorder)
|
|
{
|
|
this.Style = style;
|
|
this.Graphics = g;
|
|
this.Bounds = bounds;
|
|
this.IsTwistedDoubleBorder = isTwistedDoubleBorder;
|
|
}
|
|
}
|
|
|
|
#region eStyleBackgroundPathPart
|
|
/// <summary>
|
|
/// Specifies part of the background path.
|
|
/// </summary>
|
|
public enum eStyleBackgroundPathPart
|
|
{
|
|
/// <summary>
|
|
/// Indicates complete background path
|
|
/// </summary>
|
|
Complete,
|
|
/// <summary>
|
|
/// Indicates Top half of background path
|
|
/// </summary>
|
|
TopHalf,
|
|
/// <summary>
|
|
/// Indicates Bottom half of background path
|
|
/// </summary>
|
|
BottomHalf
|
|
}
|
|
#endregion
|
|
|
|
#region ArcData
|
|
internal struct ArcData
|
|
{
|
|
public int X;
|
|
public int Y;
|
|
public int Width;
|
|
public int Height;
|
|
public float StartAngle;
|
|
public float SweepAngle;
|
|
public ArcData(int x, int y, int width, int height, float startAngle, float sweepAngle)
|
|
{
|
|
this.X = x;
|
|
this.Y = y;
|
|
this.Width = width;
|
|
this.Height = height;
|
|
this.StartAngle = startAngle;
|
|
this.SweepAngle = sweepAngle;
|
|
}
|
|
}
|
|
#endregion
|
|
}
|