Esempio n. 1
0
        /// <summary>
        /// Generate the XAML Path source code for a visual
        /// </summary>
        private static void GeneratePathGroup(GraphicVisual visual, StringBuilder result, int level, GeometryGeneratorType geometryGeneratorType)
        {
            switch (visual)
            {
            case GraphicGroup group:
            {
                var tag       = "Grid";
                var indentTag = SourceFormatterHelper.GetTagIndent(level);
                result.Append($"{indentTag}<{tag}");

                bool tagIndent = false;

                if (!DoubleUtilities.IsEqual(group.Opacity, 1.0))
                {
                    tagIndent = true;
                    string opac = string.Format(CultureInfo.InvariantCulture, " Opacity=\"{0}\"", DoubleUtilities.FormatString(group.Opacity));
                    result.Append(opac);
                }

                if (group.Clip != null)
                {
                    if (tagIndent)
                    {
                        var indentProperty = SourceFormatterHelper.GetPropertyIndent(level, tag);
                        result.AppendLine();
                        result.Append(indentProperty);
                    }
                    else
                    {
                        result.Append(" ");
                    }

                    result.Append(string.Format("Clip=\""));
                    var stream = StreamSourceGenerator.GenerateStreamGeometry(group.Clip);
                    result.Append(stream);
                    result.Append("\"");
                }

                result.AppendLine(">");

                foreach (var childVisual in group.Children)
                {
                    GeneratePathGroup(childVisual, result, level + 1, geometryGeneratorType);
                }

                result.AppendLine($"{indentTag}</{tag}>");

                break;
            }

            case GraphicPath graphicPath:
            {
                result.AppendLine(GeneratePath(graphicPath, false, level, geometryGeneratorType));
                break;
            }
            }
        }
        /// <summary>
        /// Generate path
        /// </summary>
        private static void GeneratePath(GraphicPath graphicPath, StringBuilder result, int level)
        {
            var tag            = "GeometryDrawing";
            var indentTag      = SourceGeneratorHelper.GetTagIndent(level);
            var indentProperty = SourceGeneratorHelper.GetPropertyIndent(level, tag);

            result.Append($"{indentTag}<{tag} ");

            bool fillColorInExtendedProperties = false;

            if (graphicPath.FillBrush != null)
            {
                if (graphicPath.FillBrush is GraphicSolidColorBrush solidFillColor)
                {
                    Color color = solidFillColor.Color;
                    var   brush = string.Format("Brush=\"{0}\"", SourceGeneratorHelper.FormatColorParamter(color));
                    result.AppendLine(brush);
                    result.Append(indentProperty);
                }
                else
                {
                    fillColorInExtendedProperties = true;
                }
            }

            result.Append(string.Format("Geometry=\""));
            var stream = StreamSourceGenerator.GenerateStreamGeometry(graphicPath.Geometry);

            result.Append(stream);
            result.Append("\"");

            if (fillColorInExtendedProperties || graphicPath.StrokeBrush != null)
            {
                result.AppendLine(">");

                if (fillColorInExtendedProperties)
                {
                    SourceGeneratorHelper.GenerateBrush(result, graphicPath.FillBrush, "GeometryDrawing.Brush", level + 1);
                }

                GeneratePen(result, graphicPath, level + 1);

                result.Append(indentTag);
                result.AppendLine("</GeometryDrawing>");
            }
            else
            {
                result.AppendLine("/>");
            }
        }
        /// <summary>
        /// Generate the XAML source code (a <Path/> for a single graphic path
        /// </summary>
        public static string GenerateGeometry(GraphicVisual visual)
        {
            var           tag    = "Geometry";
            StringBuilder result = new StringBuilder();

            var geometries = StreamSourceGenerator.GenerateStreamGeometries(visual);
            int i          = 1;

            foreach (var geometry in geometries)
            {
                result.Append($"<{tag} x:Key=\"shape{i}\">");
                result.Append(geometry);
                result.AppendLine($"</{tag}>");
                i++;
            }

            return(result.ToString());
        }
Esempio n. 4
0
        /// <summary>
        /// Generate the XAML source code (a <Path/> for a single graphic path
        /// </summary>
        private static string GeneratePath(GraphicPath graphicPath, bool stretch, int level, GeometryGeneratorType geometryGeneratorType)
        {
            var           tag            = "Path";
            var           indentTag      = SourceFormatterHelper.GetTagIndent(level);
            var           indentProperty = SourceFormatterHelper.GetPropertyIndent(level, tag);
            StringBuilder result         = new StringBuilder();

            string stretchParam = stretch ? "Uniform" : "None";

            result.Append($"{indentTag}<{tag} Stretch=\"{stretchParam}\"");

            bool fillColorInExtendedProperties   = false;
            bool strokeColorInExtendedProperties = false;

            if (graphicPath.FillBrush != null)
            {
                if (graphicPath.FillBrush is GraphicSolidColorBrush solidFillColor)
                {
                    result.AppendLine();

                    Color color = solidFillColor.Color;
                    result.Append(indentProperty);
                    result.Append(string.Format("Fill=\"{0}\"", SourceFormatterHelper.FormatColorParamter(color)));
                }
                else
                {
                    fillColorInExtendedProperties = true;
                }
            }

            if (graphicPath.StrokeBrush != null)
            {
                if (graphicPath.StrokeBrush is GraphicSolidColorBrush solidStrokeColor)
                {
                    result.AppendLine();

                    Color color = solidStrokeColor.Color;
                    result.Append(indentProperty);
                    result.Append(string.Format("Stroke=\"{0}\" ", SourceFormatterHelper.FormatColorParamter(color)));
                }
                else
                {
                    strokeColorInExtendedProperties = true;
                }

                result.AppendLine();
                result.Append(indentProperty);
                result.Append(string.Format(CultureInfo.InvariantCulture, "StrokeThickness=\"{0}\" ", DoubleUtilities.FormatString(graphicPath.StrokeThickness)));

                if (graphicPath.StrokeLineCap != GraphicLineCap.Flat)
                {
                    result.AppendLine();
                    result.Append(indentProperty);
                    result.AppendLine(string.Format(CultureInfo.InvariantCulture, "StrokeStartLineCap=\"{0}\" ", Converter.ConvertToWPF(graphicPath.StrokeLineCap).ToString()));
                    result.Append(indentProperty);
                    result.Append(string.Format(CultureInfo.InvariantCulture, "StrokeEndLineCap=\"{0}\" ", Converter.ConvertToWPF(graphicPath.StrokeLineCap).ToString()));
                }

                if (graphicPath.StrokeDashes != null)
                {
                    if (graphicPath.StrokeLineCap != GraphicLineCap.Flat)
                    {
                        result.AppendLine();
                        result.Append(indentProperty);
                        result.Append(string.Format(CultureInfo.InvariantCulture, "StrokeDashCap=\"{0}\" ", Converter.ConvertToWPF(graphicPath.StrokeLineCap).ToString()));
                    }

                    result.AppendLine();
                    result.Append(indentProperty);
                    result.Append("StrokeDashArray=\"");

                    for (int i = 0; i < graphicPath.StrokeDashes.Count; i++)
                    {
                        if (i != 0)
                        {
                            result.Append(" ");
                        }

                        result.Append(DoubleUtilities.FormatString(graphicPath.StrokeDashes[i]));
                    }

                    result.AppendLine("\"");

                    if (!DoubleUtilities.IsZero(graphicPath.StrokeDashOffset))
                    {
                        result.AppendLine();
                        result.Append(indentProperty);
                        result.Append(string.Format(CultureInfo.InvariantCulture, "StrokeDashOffset=\"{0}\"", DoubleUtilities.FormatString(graphicPath.StrokeDashOffset)));
                    }
                }

                if (graphicPath.StrokeLineJoin != GraphicLineJoin.Miter)
                {
                    result.AppendLine();
                    result.Append(indentProperty);
                    result.Append(string.Format(CultureInfo.InvariantCulture, "StrokeLineJoin=\"{0}\" ", Converter.ConvertToWpf(graphicPath.StrokeLineJoin).ToString()));
                }
                else
                if (!DoubleUtilities.IsEqual(graphicPath.StrokeMiterLimit, 10))
                {
                    result.AppendLine();
                    result.Append(indentProperty);
                    result.Append(string.Format(CultureInfo.InvariantCulture, "MiterLimit=\"{0}\"", DoubleUtilities.FormatString(graphicPath.StrokeMiterLimit)));
                }
            }

            if (geometryGeneratorType == GeometryGeneratorType.Stream)
            {
                result.AppendLine();
                result.Append(indentProperty);
                result.Append("Data=\"");
                result.Append(StreamSourceGenerator.GenerateStreamGeometry(graphicPath.Geometry));
                result.Append("\"");
            }

            if (geometryGeneratorType == GeometryGeneratorType.PathGeometry || fillColorInExtendedProperties || strokeColorInExtendedProperties)
            {
                result.AppendLine(">");

                if (geometryGeneratorType == GeometryGeneratorType.PathGeometry)
                {
                    var indent1 = SourceFormatterHelper.GetTagIndent(level + 1);
                    result.Append(indent1);
                    result.AppendLine("<Path.Data>");

                    PathGeometrySourceGenerator.GeneratePathGeometry(result, graphicPath.Geometry, level + 2);

                    result.Append(indent1);
                    result.AppendLine("</Path.Data>");
                }

                if (fillColorInExtendedProperties)
                {
                    BrushSourceGenerator.GenerateBrush(result, graphicPath.FillBrush, "Path.Fill", level + 1);
                }

                if (strokeColorInExtendedProperties)
                {
                    BrushSourceGenerator.GenerateBrush(result, graphicPath.StrokeBrush, "Path.Stroke", level + 1);
                }

                result.Append(indentTag);
                result.Append($"</{tag}>");
            }
            else
            {
                result.Append(" />");
            }

            return(result.ToString());
        }