/// <summary> /// Parse and display the new input stream /// </summary> private void CreatePaths(string stream) { try { var streamGeometryParser = new StreamGeometryParser(); var graphicPathGeometry = streamGeometryParser.ParseGeometry(stream); var path = new GraphicPath(); selectedPath = path; path.Geometry = graphicPathGeometry; path.FillBrush = new GraphicSolidColorBrush { Color = Color.FromRgb(128, 128, 128) }; ErrorIndicator.Visibility = Visibility.Collapsed; if (path.Geometry.Segments.Count > 0) { ExportButton.IsEnabled = true; //ExportIcoButton.IsEnabled = true; } else { DisableExportButtons(); } } catch { selectedPath = null; ErrorIndicator.Visibility = Visibility.Visible; DisableExportButtons(); } UpdateAll(); }
public void AddGraphicPath(InfoGraphicObject currentObject, params InfoGraphicObject[] graphicObjects) { RemoveCurrentObjectHelpers(false); CurrentObject = currentObject; GraphicPath.Clear(); GraphicPath.AddRange(graphicObjects); }
/// <summary> /// Generate code for a path /// </summary> private void GeneratePath(GraphicPath graphicPath) { foreach (var segment in graphicPath.Geometry.Segments) { switch (segment) { case GraphicMoveSegment graphicsMove: { BeginFigure(graphicsMove.StartPoint, true, graphicsMove.IsClosed); break; } case GraphicLineSegment graphicsLineTo: { LineTo(graphicsLineTo.To, true, true); break; } case GraphicCubicBezierSegment graphicsCubicBezier: { BezierTo(graphicsCubicBezier.ControlPoint1, graphicsCubicBezier.ControlPoint2, graphicsCubicBezier.EndPoint, true, true); break; } case GraphicQuadraticBezierSegment graphicQuadraticBezier: { QuadraticBezierTo(graphicQuadraticBezier.ControlPoint, graphicQuadraticBezier.EndPoint, true, true); break; } default: break; } } }
/// <summary> /// Get the path /// </summary> private GraphicPath ParsePath(IPsdLayer layer, Size size) { var graphicPath = new GraphicPath(); foreach (var resource in layer.Resources) { switch (resource) { // vector mask equals paths // vsmsResource inherits from smsk: we don't need to add the extra 'case' case vmskResource vmsk: { ReadBezier(vmsk.Beziers, graphicPath, size); break; } } } if (graphicPath.Geometry.Segments.Count == 0) { graphicPath = null; } return(graphicPath); }
/// <summary> /// Parse and display the new input stream /// </summary> private void CreatePaths(string stream) { GraphicPath path; try { var streamGeometryParser = new StreamGeometryParser(); var graphicPathGeometry = streamGeometryParser.ParseGeometry(stream); path = new GraphicPath(); path.Geometry = graphicPathGeometry; path.FillBrush = new GraphicSolidColorBrush { Color = Color.FromRgb(128, 128, 128) }; ShowError = false; } catch { path = null; ShowError = true; } PreviewViewModel.SetNewGraphicPath(path); ResourceViewModel.SetNewGraphicVisual(path); XamlViewModel.SetNewGraphicVisual(path); CSharpViewModel.SetNewGraphicVisual(path); ExportViewModel.SetNewGraphicVisual(path); }
public void AddGraphicPath(InfoGraphicObject currentObject, params InfoGraphicObject[] graphicObjects) { RemoveAnimationHelpers(); _currentObject = currentObject; GraphicPath.Clear(); GraphicPath.AddRange(graphicObjects); Invalidate(); }
/// <summary> /// Create a GeometryDrawing from a single graphic path /// </summary> private static Drawing GeneratePath(GraphicPath graphicPath) { var geometryDrawing = new GeometryDrawing(); geometryDrawing.Geometry = GeometryBinaryGenerator.GenerateGeometry(graphicPath.Geometry); SetColors(graphicPath, geometryDrawing); return(geometryDrawing); }
public void ClearObjects() { RemoveAnimationHelpers(); _currentObject = null; GraphicObject.Clear(); GraphicRelation.Clear(); GraphicPath.Clear(); }
/// <summary> /// Get the colors /// </summary> private void ParseColors(IPsdLayer layer, GraphicPath graphicPath) { var bounds = graphicPath.Geometry.Bounds; var aspectRatio = bounds.Height / bounds.Width; foreach (var resource in layer.Resources) { switch (resource) { // backwards compatibility solid color case vscgResource vscg: { var(color, colorPrecision) = colorManager.GetBrush(vscg.Color, aspectRatio, false); graphicPath.FillBrush = color; graphicPath.ColorPrecision = colorPrecision; break; } // solid color case SoCoResource soCo: { var(color, colorPrecision) = colorManager.GetBrush(soCo.Color, aspectRatio, false); graphicPath.FillBrush = color; graphicPath.ColorPrecision = colorPrecision; break; } // pattern fill case PtFlResource ptFl: { var(color, colorPrecision) = colorManager.GetBrush(ptFl.Color, aspectRatio, false); graphicPath.FillBrush = color; graphicPath.ColorPrecision = colorPrecision; break; } // gradient fill case GdFlResource gdFl: { var(color, colorPrecision) = colorManager.GetBrush(gdFl.Color, aspectRatio, false); graphicPath.FillBrush = color; graphicPath.ColorPrecision = colorPrecision; break; } // stroke infos case vstkResource vstk: { var(color, colorPrecision) = colorManager.GetBrush(vstk.Color, aspectRatio, true); graphicPath.StrokeBrush = color; graphicPath.StrokeThickness = vstk.Width; graphicPath.ColorPrecision = colorPrecision; break; } } } }
/// <summary> /// Create a brush from a single graphic paths /// </summary> public static Brush Generate(GraphicPath graphicPath) { var drawingBrush = new DrawingBrush(); drawingBrush.Stretch = Stretch.Uniform; drawingBrush.Drawing = GeneratePath(graphicPath); return(drawingBrush); }
/// <summary> /// Set all colors of the graphic path /// </summary> public void SetFillAndStroke(XElement path, GraphicPath graphicPath, Matrix currentTransformationMatrix, double parentOpacity, double parentFillOpacity, double parentStrokeOpacity) { SetFill(path, graphicPath, currentTransformationMatrix, parentOpacity * parentFillOpacity); SetStroke(path, graphicPath, currentTransformationMatrix, parentOpacity * parentStrokeOpacity); }
/// <summary> /// Set the colors /// </summary> private static void SetColors(GraphicPath graphicPath, XElement pathElement, XNamespace ns, XElement definitions, ref int definitionsCount) { if (graphicPath.FillBrush != null) { GenerateBrush(graphicPath.FillBrush, pathElement, ns, "fill", definitions, ref definitionsCount); } else { pathElement.Add(new XAttribute("fill", "none")); } if (graphicPath.StrokeBrush != null) { GenerateBrush(graphicPath.StrokeBrush, pathElement, ns, "stroke", definitions, ref definitionsCount); pathElement.Add(new XAttribute("stroke-width", DoubleUtilities.FormatString(graphicPath.StrokeThickness))); if (graphicPath.StrokeLineCap != GraphicLineCap.Flat) { pathElement.Add(new XAttribute("stroke-linecap", ConvertToSvg(graphicPath.StrokeLineCap))); } if (graphicPath.StrokeLineJoin != GraphicLineJoin.Miter) { pathElement.Add(new XAttribute("stroke-linejoin", ConvertToSvg(graphicPath.StrokeLineJoin))); } if (!DoubleUtilities.IsEqual(graphicPath.StrokeMiterLimit, 4)) { pathElement.Add(new XAttribute("stroke-miterlimit", DoubleUtilities.FormatString(graphicPath.StrokeMiterLimit))); } if (graphicPath.StrokeDashes != null) { var result = new StringBuilder(); for (int i = 0; i < graphicPath.StrokeDashes.Count; i++) { if (i != 0) { result.Append(" "); } result.Append(DoubleUtilities.FormatString(graphicPath.StrokeDashes[i] * graphicPath.StrokeThickness)); } pathElement.Add(new XAttribute("stroke-dasharray", result.ToString())); if (!DoubleUtilities.IsZero(graphicPath.StrokeDashOffset)) { pathElement.Add(new XAttribute("stroke-dashoffset", DoubleUtilities.FormatString(graphicPath.StrokeDashOffset * graphicPath.StrokeThickness))); } } } }
/// <summary> /// Build up a path from the current geometry and the current fill /// </summary> private GraphicPath GetCurrentPathFilled() { var path = new GraphicPath(); path.Geometry = currentGeometry; path.FillBrush = currentGraphicsState.FillBrush.GetBrush(currentGeometry.Bounds, currentGraphicsState.SoftMask); path.ColorPrecision = currentGraphicsState.FillBrush.ColorPrecision; return(path); }
/// <summary> /// Set common shape attributes /// </summary> private void SetShapeAttributes(GraphicPath graphicPath, GraphicPath normalizedPath) { normalizedPath.FillBrush = NormalizeBrush(graphicPath.FillBrush); normalizedPath.StrokeBrush = NormalizeBrush(graphicPath.StrokeBrush); normalizedPath.StrokeThickness = NormalizeThickness(graphicPath.StrokeThickness); normalizedPath.StrokeLineCap = graphicPath.StrokeLineCap; normalizedPath.StrokeLineJoin = graphicPath.StrokeLineJoin; normalizedPath.StrokeDashOffset = graphicPath.StrokeDashOffset; normalizedPath.StrokeDashes = graphicPath.StrokeDashes; normalizedPath.StrokeMiterLimit = NormalizeThickness(graphicPath.StrokeMiterLimit); }
/// <summary> /// Generate a shape /// </summary> private static XElement GeneratePath(GraphicPath graphicPath, XNamespace ns, XElement definitions, ref int definitionsCount) { var pathElement = new XElement(ns + "path"); var pathStr = StreamSourceGenerator.GenerateStreamGeometry(graphicPath.Geometry, false); pathElement.Add(new XAttribute("d", pathStr)); SetColors(graphicPath, pathElement, ns, definitions, ref definitionsCount); return(pathElement); }
/// <summary> /// Set a new visual /// </summary> public void SetNewGraphicPath(GraphicPath path) { if (path == null) { Preview = null; } var geometry = GeometryBinaryGenerator.GenerateGeometry(path.Geometry); Preview = geometry; UpdatePreviewAll(); }
/// <summary> /// Set common shape attributes /// </summary> private void SetShapeAttributes(GraphicPath graphicPath, GraphicPath transformedPath) { transformedPath.FillBrush = TransformBrush(graphicPath.FillBrush); transformedPath.StrokeBrush = TransformBrush(graphicPath.StrokeBrush); transformedPath.StrokeThickness = MatrixUtilities.TransformScale(graphicPath.StrokeThickness, transformMatrix); transformedPath.StrokeMiterLimit = MatrixUtilities.TransformScale(graphicPath.StrokeMiterLimit, transformMatrix); transformedPath.StrokeLineCap = graphicPath.StrokeLineCap; transformedPath.StrokeLineJoin = graphicPath.StrokeLineJoin; transformedPath.StrokeDashOffset = graphicPath.StrokeDashOffset; transformedPath.StrokeDashes = graphicPath.StrokeDashes; }
/// <summary> /// Generate the XAML source code (a <Path/> for a single graphic path /// </summary> public static string GenerateGeometry(GraphicPath graphicPath) { var tag = "Geometry"; var indentTag = SourceGeneratorHelper.GetTagIndent(0); var indentProperty = SourceGeneratorHelper.GetPropertyIndent(0, tag); StringBuilder result = new StringBuilder(); result.Append($"<{tag} x:Key=\"xyzIcon\">"); result.Append(GenerateStreamGeometry(graphicPath.Geometry, false)); result.Append($"\"</{tag}>"); return(result.ToString()); }
/// <summary> /// Parse one layer /// </summary> private GraphicPath ParseLayer(IPsdLayer layer, Size size) { GraphicPath graphicPath = ParsePath(layer, size); if (graphicPath == null || graphicPath.Geometry.Segments.Count == 0) { return(null); } ParseColors(layer, graphicPath); return(graphicPath); }
/// <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> /// Set all colors of the graphic path /// </summary> private void SetStroke(XElement path, GraphicPath graphicPath, Matrix currentTransformationMatrix, double parentOpacity) { graphicPath.StrokeBrush = CreateBrush(path, "stroke", false, graphicPath, currentTransformationMatrix, parentOpacity); if (graphicPath.StrokeBrush != null) { graphicPath.StrokeThickness = MatrixUtilities.TransformScale(GetLengthPercentFromCascade("stroke-width", 1), currentTransformationMatrix); graphicPath.StrokeMiterLimit = MatrixUtilities.TransformScale(cssStyleCascade.GetNumber("stroke-miterlimit", 4), currentTransformationMatrix); graphicPath.StrokeLineCap = GetLineCap(); graphicPath.StrokeLineJoin = GetLineJoin(); graphicPath.StrokeDashOffset = MatrixUtilities.TransformScale(GetLengthPercentFromCascade("stroke-dashoffset", 0), currentTransformationMatrix) / graphicPath.StrokeThickness; graphicPath.StrokeDashes = GetDashes(graphicPath.StrokeThickness, currentTransformationMatrix); } }
/// <summary> /// Build up a path from the current geometry and the current fill /// </summary> public static void Fill(EpsInterpreter interpreter, GraphicFillRule fillRule) { GraphicsState graphicState = interpreter.GraphicState; graphicState.CurrentGeometry.FillRule = fillRule; var path = new GraphicPath(); path.Geometry = graphicState.CurrentGeometry; path.FillBrush = graphicState.FillBrush.GetBrush(graphicState.CurrentGeometry.Bounds); path.ColorPrecision = graphicState.FillBrush.ColorPrecision; interpreter.GraphicGroup.Children.Add(path); interpreter.ResetCurrentGeometry(); }
/// <summary> /// Parse a single SVG shape /// </summary> public GraphicVisual Parse(XElement shape, XNamespace svgNamespace, Matrix currentTransformationMatrix, CssStyleCascade cssStyleCascade, Dictionary <string, XElement> globalDefinitions) { GraphicVisual graphicVisual = null; cssStyleCascade.PushStyles(shape); var transform = cssStyleCascade.GetPropertyFromTop("transform"); if (!string.IsNullOrEmpty(transform)) { var transformMatrix = TransformMatrixParser.GetTransformMatrix(transform); currentTransformationMatrix = transformMatrix * currentTransformationMatrix; } var geometry = GeometryParser.Parse(shape, currentTransformationMatrix); if (geometry != null) { var graphicPath = new GraphicPath(); graphicPath.Geometry = geometry; graphicVisual = graphicPath; this.svgNamespace = svgNamespace; this.globalDefinitions = globalDefinitions; this.currentTransformationMatrix = currentTransformationMatrix; this.cssStyleCascade = cssStyleCascade; SetFillAndStroke(shape, graphicPath); if (Clipping.IsClipPathSet(cssStyleCascade)) { // shapes don't support clipping, create a group around it var group = new GraphicGroup(); graphicVisual = group; group.Childreen.Add(graphicPath); Clipping.SetClipPath(group, currentTransformationMatrix, cssStyleCascade, globalDefinitions); } cssStyleCascade.Pop(); } return(graphicVisual); }
public override void Execute(EpsInterpreter interpreter) { var shadingDict = interpreter.OperandStack.PopDictionary(); GraphicsState graphicState = interpreter.GraphicState; var graphicPath = new GraphicPath(); var shadingDescriptor = ShadingActivator.CreateShading(interpreter, shadingDict); graphicPath.Geometry = graphicState.ClippingPath; graphicPath.FillBrush = shadingDescriptor.GetBrush(graphicState.CurrentTransformationMatrix, graphicState.ClippingPath.Bounds); graphicPath.ColorPrecision = shadingDescriptor.ColorPrecision; interpreter.GraphicGroup.Childreen.Add(graphicPath); }
/// <summary> /// Build up a path from the current geometry and the current stroke /// </summary> private GraphicPath GetCurrentPathStroked() { var path = new GraphicPath(); path.Geometry = currentGeometry; path.StrokeThickness = currentGraphicsState.LineWidth; path.StrokeBrush = currentGraphicsState.StrokeBrush.GetBrush(currentGeometry.Bounds, currentGraphicsState.SoftMask); path.StrokeLineCap = currentGraphicsState.LineCap; path.StrokeLineJoin = currentGraphicsState.LineJoin; SetFinalDashes(path); path.ColorPrecision = currentGraphicsState.StrokeBrush.ColorPrecision; return(path); }
/// <summary> /// Create a WPF Brush used as preview. /// We want to show any shape even more or less invisible shapes. A shape is invisible when: /// - there is no fill color or the fill color is almost white /// - there is no stroke color or the stroke color is almost white /// - the stroke is too thin /// To judge the stroke thickness we normalize the shape to the size of the preview. This also /// normalizes the stroke thickness. /// </summary> public static Brush GeneratePreview(GraphicPath graphicPath, Size previewSize) { var normalizer = new NormalizeVisual(); var normalizedPath = (GraphicPath)normalizer.Normalize(graphicPath, previewSize); if (!IsShapeVisible(normalizedPath)) { byte gray = 0xD0; normalizedPath.StrokeBrush = new GraphicSolidColorBrush { Color = Color.FromRgb(gray, gray, gray) }; normalizedPath.StrokeThickness = 1; } var brush = DrawingBrushBinaryGenerator.Generate(normalizedPath); return(brush); }
/// <summary> /// Set all colors of the graphic path /// </summary> private void SetFillAndStroke(XElement path, GraphicPath graphicPath) { // fill graphicPath.FillBrush = CreateBrush(path, "fill", true, graphicPath); // stroke graphicPath.StrokeBrush = CreateBrush(path, "stroke", false, graphicPath); if (graphicPath.StrokeBrush != null) { graphicPath.StrokeThickness = MatrixUtilities.TransformScale(cssStyleCascade.GetDouble("stroke-width", 1), currentTransformationMatrix); graphicPath.StrokeMiterLimit = MatrixUtilities.TransformScale(cssStyleCascade.GetDouble("stroke-miterlimit", 4), currentTransformationMatrix); graphicPath.StrokeLineCap = GetLineCap(); graphicPath.StrokeLineJoin = GetLineJoin(); graphicPath.StrokeDashOffset = MatrixUtilities.TransformScale(cssStyleCascade.GetDouble("stroke-dashoffset", 0), currentTransformationMatrix) / graphicPath.StrokeThickness; graphicPath.StrokeDashes = GetDashes(graphicPath.StrokeThickness); } }
/// <summary> /// Set the dashes of the final path /// </summary> /// <param name="path"></param> private void SetFinalDashes(GraphicPath path) { if (currentGraphicsState.Dashes == null) { return; } var relativeDashes = new List <double>(); var thickness = currentGraphicsState.LineWidth; foreach (var dash in currentGraphicsState.Dashes) { var relativeDash = dash / thickness; relativeDashes.Add(relativeDash); } path.StrokeDashes = relativeDashes; path.StrokeDashOffset = currentGraphicsState.DashOffset / thickness; }
/// <summary> /// Build up a path from the current geometry and the current fill and stroke /// </summary> private GraphicPath GetCurrentPathFilledAndStroked() { var path = new GraphicPath(); path.Geometry = currentGeometry; path.FillBrush = currentGraphicsState.FillBrush.GetBrush(currentGeometry.Bounds, currentGraphicsState.SoftMask); path.StrokeThickness = currentGraphicsState.LineWidth; path.StrokeBrush = currentGraphicsState.StrokeBrush.GetBrush(currentGeometry.Bounds, currentGraphicsState.SoftMask); path.StrokeLineCap = currentGraphicsState.LineCap; path.StrokeLineJoin = currentGraphicsState.LineJoin; path.StrokeMiterLimit = currentGraphicsState.MiterLimit; SetFinalDashes(path); path.ColorPrecision = EvalWeakestColorPrecision(currentGraphicsState.FillBrush.ColorPrecision, currentGraphicsState.StrokeBrush.ColorPrecision); return(path); }
/// <summary> /// Set the fill and stroke colors /// </summary> private static bool IsShapeVisible(GraphicPath graphicPath) { bool isFillVisible = false; bool isStrokeVisible = false; if (graphicPath.FillBrush != null) { isFillVisible = IsBrushVisible(graphicPath.FillBrush); } if (graphicPath.StrokeBrush != null) { if (graphicPath.StrokeThickness > 0.1) { isStrokeVisible = IsBrushVisible(graphicPath.StrokeBrush); } } return(isFillVisible || isStrokeVisible); }