/// <summary>
/// Create a brush from the specified graphic brush
/// </summary>
private static bool IsBrushVisible(GraphicBrush graphicBrush)
{
bool isVisible = true;
switch (graphicBrush)
{
case GraphicSolidColorBrush graphicSolidColor:
{
if (!IsColorVisible(graphicSolidColor.Color))
{
isVisible = false;
}
break;
}
case GraphicGradientBrush graphicGradientBrush:
{
foreach (var stop in graphicGradientBrush.GradientStops)
{
if (!IsColorVisible(stop.Color))
{
isVisible = false;
break;
}
}
break;
}
}
return(isVisible);
}
/// <summary>
/// Generate a WPF brush
/// </summary>
private static Brush GenerateBrush(GraphicBrush graphicBrush)
{
Brush brush;
switch (graphicBrush)
{
case GraphicSolidColorBrush graphicSolidColor:
{
brush = new SolidColorBrush(graphicSolidColor.Color);
break;
}
case GraphicLinearGradientBrush graphicLinearGradientBrush:
{
var linearGradientBrush = new LinearGradientBrush();
brush = linearGradientBrush;
linearGradientBrush.StartPoint = graphicLinearGradientBrush.StartPoint;
linearGradientBrush.EndPoint = graphicLinearGradientBrush.EndPoint;
linearGradientBrush.MappingMode = Converter.ConvertToWpf(graphicLinearGradientBrush.MappingMode);
foreach (var stop in graphicLinearGradientBrush.GradientStops)
{
var gs = new GradientStop(stop.Color, stop.Position);
linearGradientBrush.GradientStops.Add(gs);
}
break;
}
case GraphicRadialGradientBrush graphicRadialGradientBrush:
{
var radialGradientBrush = new RadialGradientBrush();
brush = radialGradientBrush;
radialGradientBrush.GradientOrigin = graphicRadialGradientBrush.StartPoint;
radialGradientBrush.Center = graphicRadialGradientBrush.EndPoint;
radialGradientBrush.RadiusX = graphicRadialGradientBrush.RadiusX;
radialGradientBrush.RadiusY = graphicRadialGradientBrush.RadiusY;
radialGradientBrush.MappingMode = Converter.ConvertToWpf(graphicRadialGradientBrush.MappingMode);
foreach (var stop in graphicRadialGradientBrush.GradientStops)
{
var gs = new GradientStop(stop.Color, stop.Position);
radialGradientBrush.GradientStops.Add(gs);
}
break;
}
default:
{
brush = new SolidColorBrush(Colors.LightGray);
break;
}
}
return(brush);
}
/// <summary>
/// Normalize a brush
/// </summary>
private GraphicBrush NormalizeBrush(GraphicBrush graphicBrush)
{
GraphicBrush retBrush;
switch (graphicBrush)
{
case GraphicLinearGradientBrush linearGradientBrush:
{
if (linearGradientBrush.MappingMode == GraphicBrushMappingMode.Absolute)
{
var newlinearGradientBrush = new GraphicLinearGradientBrush();
retBrush = newlinearGradientBrush;
newlinearGradientBrush.StartPoint = NormalizePoint(linearGradientBrush.StartPoint);
newlinearGradientBrush.EndPoint = NormalizePoint(linearGradientBrush.EndPoint);
newlinearGradientBrush.MappingMode = linearGradientBrush.MappingMode;
newlinearGradientBrush.GradientStops = linearGradientBrush.GradientStops;
}
else
{
retBrush = linearGradientBrush;
}
break;
}
case GraphicRadialGradientBrush radialGradientBrush:
{
if (radialGradientBrush.MappingMode == GraphicBrushMappingMode.Absolute)
{
var newlinearGradientBrush = new GraphicRadialGradientBrush();
retBrush = newlinearGradientBrush;
newlinearGradientBrush.StartPoint = NormalizePoint(radialGradientBrush.StartPoint);
newlinearGradientBrush.EndPoint = NormalizePoint(radialGradientBrush.EndPoint);
newlinearGradientBrush.RadiusX = NormalizeWidth(radialGradientBrush.RadiusX);
newlinearGradientBrush.RadiusY = NormalizeWidth(radialGradientBrush.RadiusY);
newlinearGradientBrush.MappingMode = radialGradientBrush.MappingMode;
newlinearGradientBrush.GradientStops = radialGradientBrush.GradientStops;
}
else
{
retBrush = radialGradientBrush;
}
break;
}
default:
retBrush = graphicBrush;
break;
}
return(retBrush);
}
/// <summary>
/// Normalize a brush
/// </summary>
private GraphicBrush TransformBrush(GraphicBrush graphicBrush)
{
GraphicBrush retBrush;
switch (graphicBrush)
{
case GraphicLinearGradientBrush linearGradientBrush:
{
if (linearGradientBrush.MappingMode == GraphicBrushMappingMode.Absolute)
{
var newlinearGradientBrush = new GraphicLinearGradientBrush();
retBrush = newlinearGradientBrush;
newlinearGradientBrush.StartPoint = MatrixUtilities.TransformPoint(linearGradientBrush.StartPoint, transformMatrix);
newlinearGradientBrush.EndPoint = MatrixUtilities.TransformPoint(linearGradientBrush.EndPoint, transformMatrix);
newlinearGradientBrush.MappingMode = linearGradientBrush.MappingMode;
newlinearGradientBrush.GradientStops = linearGradientBrush.GradientStops;
}
else
{
retBrush = linearGradientBrush;
}
break;
}
case GraphicRadialGradientBrush radialGradientBrush:
{
if (radialGradientBrush.MappingMode == GraphicBrushMappingMode.Absolute)
{
var newlinearGradientBrush = new GraphicRadialGradientBrush();
retBrush = newlinearGradientBrush;
newlinearGradientBrush.StartPoint = MatrixUtilities.TransformPoint(radialGradientBrush.StartPoint, transformMatrix);
newlinearGradientBrush.EndPoint = MatrixUtilities.TransformPoint(radialGradientBrush.EndPoint, transformMatrix);
(newlinearGradientBrush.RadiusX, newlinearGradientBrush.RadiusY) = MatrixUtilities.TransformSize(radialGradientBrush.RadiusX, radialGradientBrush.RadiusY, transformMatrix);
newlinearGradientBrush.MappingMode = radialGradientBrush.MappingMode;
newlinearGradientBrush.GradientStops = radialGradientBrush.GradientStops;
}
else
{
retBrush = radialGradientBrush;
}
break;
}
default:
retBrush = graphicBrush;
break;
}
return(retBrush);
}
/// <summary>
/// Write a brush to the stream
/// </summary>
private void WriteBrush(GraphicBrush graphicBrush, Rect boundingBox)
{
switch (graphicBrush)
{
case GraphicSolidColorBrush solidStrokeColor:
{
WriteSetColor(solidStrokeColor.Color);
break;
}
case GraphicLinearGradientBrush linearGradientBrush:
{
WriteLinearShading(linearGradientBrush, boundingBox);
break;
}
case GraphicRadialGradientBrush radialGradientBrush:
{
WriteRadialShading(radialGradientBrush, boundingBox);
break;
}
}
}
/// <summary>
/// Create a gradient brush of the specified id
/// </summary>
private GraphicBrush CreateGradientBrush(string gradientId, double opacity, Matrix currentTransformationMatrix, Rect bounds)
{
GraphicBrush brush = null;
if (!globalDefinitions.ContainsKey(gradientId))
{
return(brush);
}
var gradientElem = globalDefinitions[gradientId];
switch (gradientElem.Name.LocalName)
{
case "linearGradient":
{
var gradient = new GraphicLinearGradientBrush();
brush = gradient;
ReadGradientProperties(gradientElem, opacity, gradient);
Matrix matrix = GetGradientTransformMatrix(gradientElem) * currentTransformationMatrix;
var x = doubleParser.GetLength(gradientElem, "x1", 0);
var y = doubleParser.GetLength(gradientElem, "y1", 0);
gradient.StartPoint = new Point(x, y);
x = doubleParser.GetLength(gradientElem, "x2", 1);
y = doubleParser.GetLength(gradientElem, "y2", 0);
gradient.EndPoint = new Point(x, y);
// see comment in LinearGradientShading.cs of the pdf parser in GetBrush for more details
if (gradient.MappingMode == GraphicBrushMappingMode.Absolute)
{
gradient.MappingMode = GraphicBrushMappingMode.RelativeToBoundingBox;
gradient.StartPoint = GetRelativePosition(bounds, gradient.StartPoint * matrix);
gradient.EndPoint = GetRelativePosition(bounds, gradient.EndPoint * matrix);
}
break;
}
case "radialGradient":
{
var gradient = new GraphicRadialGradientBrush();
brush = gradient;
ReadGradientProperties(gradientElem, opacity, gradient);
Matrix matrix = GetGradientTransformMatrix(gradientElem);
var x = doubleParser.GetLength(gradientElem, "cx", 0.5);
var y = doubleParser.GetLength(gradientElem, "cy", 0.5);
gradient.EndPoint = new Point(x, y);
x = doubleParser.GetLength(gradientElem, "fx", x);
y = doubleParser.GetLength(gradientElem, "fy", y);
gradient.StartPoint = new Point(x, y);
var r = doubleParser.GetLength(gradientElem, "r", 0.5);
gradient.RadiusX = r;
gradient.RadiusY = r;
// see comment in LinearGradientShading.cs of the pdf parser in GetBrush for more details
if (gradient.MappingMode == GraphicBrushMappingMode.Absolute)
{
gradient.MappingMode = GraphicBrushMappingMode.RelativeToBoundingBox;
// calculate the start position relative to the object rectangle
gradient.StartPoint = GetRelativePosition(bounds, gradient.StartPoint * matrix);
// calculate the end position relative to the object rectangle
gradient.EndPoint = GetRelativePosition(bounds, gradient.EndPoint * matrix);
// get the center point and a point on the outer ring
// in user space coordinates
var centerPointUserSpace = new Point(0, 0) * matrix;
var outerPointUserSpace = new Point(1, 1) * matrix;
// get the radii in user space
var gradientRadiusXUserSpace = Math.Abs(outerPointUserSpace.X - centerPointUserSpace.X);
var gradientRadiusYUserSpace = Math.Abs(outerPointUserSpace.Y - centerPointUserSpace.Y);
// get the object's size in the user space, we need the radii relative to this size
var objectWidth = Math.Abs(bounds.Right - bounds.Left);
var objectHeight = Math.Abs(bounds.Bottom - bounds.Top);
// calculate the relative radius X
var relativeRadiusX = gradientRadiusXUserSpace / objectWidth;
gradient.RadiusX = gradient.RadiusX * relativeRadiusX;
// calculate the relative radius Y
var relativeRadiusY = gradientRadiusYUserSpace / objectHeight;
gradient.RadiusY = gradient.RadiusY * relativeRadiusY;
}
break;
}
}
return(brush);
}
/// <summary>
/// Generate the source code for a complex brush
/// </summary>
public static void GenerateBrush(StringBuilder result, GraphicBrush graphicBrush, string element, int level)
{
var indentTag = GetTagIndent(level);
var indent1Tag = GetTagIndent(level + 1);
var indent2Tag = GetTagIndent(level + 2);
result.AppendLine(string.Format("{0}<{1}>", indentTag, element));
switch (graphicBrush)
{
case GraphicLinearGradientBrush linearGradientBrush:
{
var tag = "LinearGradientBrush";
var indentProperty = GetPropertyIndent(level + 1, tag);
result.AppendLine(string.Format(CultureInfo.InvariantCulture, "{0}<{1} StartPoint=\"{2}\"",
indent1Tag,
tag,
FormatPointParamter(linearGradientBrush.StartPoint)));
result.Append(string.Format(CultureInfo.InvariantCulture, "{0}EndPoint=\"{1}\"",
indentProperty,
FormatPointParamter(linearGradientBrush.EndPoint)));
if (linearGradientBrush.MappingMode != GraphicBrushMappingMode.RelativeToBoundingBox)
{
result.AppendLine("");
result.Append(string.Format(CultureInfo.InvariantCulture, "{0}MappingMode=\"{1}\"",
indentProperty,
Converter.ConvertToWpf(linearGradientBrush.MappingMode).ToString()));
}
result.AppendLine(">");
GenerateGradientStops(result, indent2Tag, linearGradientBrush.GradientStops);
result.AppendLine(string.Format("{0}</{1}>", indent1Tag, tag));
break;
}
case GraphicRadialGradientBrush radialGradientBrush:
{
var tag = "RadialGradientBrush";
var indentProperty = GetPropertyIndent(level + 1, tag);
result.AppendLine(string.Format(CultureInfo.InvariantCulture, "{0}<{1} GradientOrigin=\"{2}\"",
indent1Tag,
tag,
FormatPointParamter(radialGradientBrush.StartPoint)));
result.AppendLine(string.Format(CultureInfo.InvariantCulture, "{0}Center=\"{1}\"",
indentProperty,
FormatPointParamter(radialGradientBrush.EndPoint)));
result.AppendLine(string.Format(CultureInfo.InvariantCulture, "{0}RadiusX=\"{1}\"",
indentProperty,
DoubleUtilities.FormatString(radialGradientBrush.RadiusX)));
result.Append(string.Format(CultureInfo.InvariantCulture, "{0}RadiusY=\"{1}\"",
indentProperty,
DoubleUtilities.FormatString(radialGradientBrush.RadiusY)));
if (radialGradientBrush.MappingMode != GraphicBrushMappingMode.RelativeToBoundingBox)
{
result.AppendLine("");
result.Append(string.Format(CultureInfo.InvariantCulture, "{0}MappingMode=\"{1}\"",
indentProperty,
Converter.ConvertToWpf(radialGradientBrush.MappingMode).ToString()));
}
result.AppendLine(">");
GenerateGradientStops(result, indent2Tag, radialGradientBrush.GradientStops);
result.AppendLine(string.Format("{0}</{1}>", indent1Tag, tag));
break;
}
default:
{
result.AppendLine(string.Format("{0}<SolidColorBrush Color=\"#FFB0B0B0\" />", indent1Tag));
break;
}
}
result.AppendLine(string.Format("{0}</{1}>", indentTag, element));
}
/// <summary>
/// Generate a brush
/// </summary>
private static void GenerateBrush(GraphicBrush graphicBrush, XElement pathElement, XNamespace ns, string property, XElement definitions, ref int definitionsCount)
{
switch (graphicBrush)
{
case GraphicSolidColorBrush graphicSolidColor:
{
var color = graphicSolidColor.Color;
pathElement.Add(new XAttribute(property, FormatColor(color)));
var alpha = color.A;
if (alpha != 255)
{
pathElement.Add(new XAttribute($"{property}-opacity", DoubleUtilities.FormatString(alpha / 255.0)));
}
break;
}
case GraphicLinearGradientBrush linearGradientBrush:
{
var gradientElement = new XElement(ns + "linearGradient");
definitions.Add(gradientElement);
definitionsCount++;
string defId = $"lingrad{definitionsCount}";
gradientElement.Add(new XAttribute("id", defId));
pathElement.Add(new XAttribute(property, $"url(#{defId})"));
gradientElement.Add(new XAttribute("x1", DoubleUtilities.FormatString(linearGradientBrush.StartPoint.X)));
gradientElement.Add(new XAttribute("y1", DoubleUtilities.FormatString(linearGradientBrush.StartPoint.Y)));
gradientElement.Add(new XAttribute("x2", DoubleUtilities.FormatString(linearGradientBrush.EndPoint.X)));
gradientElement.Add(new XAttribute("y2", DoubleUtilities.FormatString(linearGradientBrush.EndPoint.Y)));
foreach (var stop in linearGradientBrush.GradientStops)
{
var stopElement = new XElement(ns + "stop");
stopElement.Add(new XAttribute("offset", DoubleUtilities.FormatString(stop.Position)));
stopElement.Add(new XAttribute("stop-color", FormatColor(stop.Color)));
var alpha = stop.Color.A;
if (alpha != 255)
{
stopElement.Add(new XAttribute("stop-opacity", DoubleUtilities.FormatString(alpha / 255.0)));
}
gradientElement.Add(stopElement);
}
break;
}
case GraphicRadialGradientBrush radialGradientBrush:
{
var gradientElement = new XElement(ns + "radialGradient");
definitions.Add(gradientElement);
definitionsCount++;
string defId = $"radgrad{definitionsCount}";
gradientElement.Add(new XAttribute("id", defId));
pathElement.Add(new XAttribute(property, $"url(#{defId})"));
gradientElement.Add(new XAttribute("fx", DoubleUtilities.FormatString(radialGradientBrush.StartPoint.X)));
gradientElement.Add(new XAttribute("fy", DoubleUtilities.FormatString(radialGradientBrush.StartPoint.Y)));
gradientElement.Add(new XAttribute("cx", DoubleUtilities.FormatString(radialGradientBrush.EndPoint.X)));
gradientElement.Add(new XAttribute("cy", DoubleUtilities.FormatString(radialGradientBrush.EndPoint.Y)));
gradientElement.Add(new XAttribute("r", DoubleUtilities.FormatString((radialGradientBrush.RadiusX + radialGradientBrush.RadiusY) / 2)));
foreach (var stop in radialGradientBrush.GradientStops)
{
var stopElement = new XElement(ns + "stop");
stopElement.Add(new XAttribute("offset", DoubleUtilities.FormatString(stop.Position)));
stopElement.Add(new XAttribute("stop-color", FormatColor(stop.Color)));
var alpha = stop.Color.A;
if (alpha != 255)
{
stopElement.Add(new XAttribute("stop-opacity", DoubleUtilities.FormatString(alpha / 255.0)));
}
gradientElement.Add(stopElement);
}
break;
}
}
}
