Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 323 insertions, 0 deletions

diff --git a/share/extensions/synfig_prepare.py b/share/extensions/synfig_prepare.py
new file mode 100755
index 0000000..9899eec
--- /dev/null
+++ b/share/extensions/synfig_prepare.py
@@ -0,0 +1,323 @@
+#!/usr/bin/env python
+# coding=utf-8
+#
+# Copyright (C) 2011 Nikita Kitaev
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+#
+"""
+Simplifies SVG files in preparation for sif export.
+"""
+
+import os
+import tempfile
+from subprocess import PIPE, Popen
+from inkex.command import inkscape, write_svg, ProgramRunError
+from inkex.localization import inkex_gettext as _
+from inkex.base import TempDirMixin
+
+import inkex
+from inkex import (
+    load_svg,
+    Group,
+    PathElement,
+    ShapeElement,
+    Anchor,
+    Switch,
+    SvgDocumentElement,
+    Transform,
+)
+
+###### Utility Classes ####################################
+
+
+class MalformedSVGError(Exception):
+    """Raised when the SVG document is invalid or contains unsupported features"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return (
+            _(
+                """SVG document is invalid or contains unsupported features
+
+Error message: %s
+
+The SVG to Synfig converter is designed to handle SVG files that were created using Inkscape. Unsupported features are most likely to occur in SVG files written by other programs.
+"""
+            )
+            % repr(self.value)
+        )
+
+
+###### Utility Functions ##################################
+
+### Path related
+
+
+def fuse_subpaths(path: inkex.Path):
+    """Fuse subpaths of a path. Should only be used on unstroked paths.
+    The idea is to replace every moveto by a lineto, and then walk all the extra lines
+    backwards to get the same fill. For unfilled paths, this gives visually good results
+    in cases with not-too-complex paths, i.e. no intersections.
+    There may be extra zero-length Lineto commands."""
+
+    result = inkex.Path()
+    return_stack = []
+    for i, seg in enumerate(path.proxy_iterator()):
+        if seg.letter not in "zZmM":
+            result.append(seg.command)
+        elif i == 0:
+            result.append(seg.command)
+            first = seg.end_point
+        else:
+            # Add a line instead of the ZoneClose / Move command, and store
+            # the initial position.
+            return_to = seg.previous_end_point
+            if seg.letter in "mM":
+                if seg.previous_end_point != first:  # only close if needed
+                    # all paths must be closed for this algorithm to work. Since
+                    # the path doesn't have a stroke, it's visually irrellevant.
+                    result.append(inkex.paths.Line(*first))
+                    return_to = first
+
+                return_stack += [return_to]
+            result.append(inkex.paths.Line(*seg.end_point))
+
+            first = seg.end_point
+
+    # also close the last subpath
+    return_stack += [first]
+
+    # now apply the return stack backwards
+    for point in return_stack[::-1]:
+        result.append(inkex.paths.Line(*point))
+
+    return result
+
+
+def split_fill_and_stroke(path_node):
+    """Split a path into two paths, one filled and one stroked
+
+    Returns a the list [fill, stroke], where each is the XML element of the
+    fill or stroke, or None.
+    """
+    style = dict(inkex.Style.parse_str(path_node.get("style", "")))
+
+    # If there is only stroke or only fill, don't split anything
+    if "fill" in style and style["fill"] == "none":
+        if "stroke" not in style or style["stroke"] == "none":
+            return [None, None]  # Path has neither stroke nor fill
+        else:
+            return [None, path_node]
+    if "stroke" not in style.keys() or style["stroke"] == "none":
+        return [path_node, None]
+
+    group = Group()
+    fill = group.add(PathElement())
+    stroke = group.add(PathElement())
+
+    d = path_node.pop("d")
+    if d is None:
+        raise AssertionError("Cannot split stroke and fill of non-path element")
+
+    nodetypes = path_node.pop("sodipodi:nodetypes", None)
+    path_id = path_node.pop("id", str(id(path_node)))
+    transform = path_node.pop("transform", None)
+    path_node.pop("style")
+
+    # Pass along all remaining attributes to the group
+    for attrib_name, attrib_value in path_node.attrib.items():
+        group.set(attrib_name, attrib_value)
+
+    group.set("id", path_id)
+
+    # Next split apart the style attribute
+    style_group = {}
+    style_fill = {"stroke": "none", "fill": "#000000"}
+    style_stroke = {"fill": "none", "stroke": "none"}
+
+    for key in style.keys():
+        if key.startswith("fill"):
+            style_fill[key] = style[key]
+        elif key.startswith("stroke"):
+            style_stroke[key] = style[key]
+        elif key.startswith("marker"):
+            style_stroke[key] = style[key]
+        elif key.startswith("filter"):
+            style_group[key] = style[key]
+        else:
+            style_fill[key] = style[key]
+            style_stroke[key] = style[key]
+
+    if len(style_group) != 0:
+        group.set("style", str(inkex.Style(style_group)))
+
+    fill.set("style", str(inkex.Style(style_fill)))
+    stroke.set("style", str(inkex.Style(style_stroke)))
+
+    # Finalize the two paths
+    fill.set("d", d)
+    stroke.set("d", d)
+    if nodetypes is not None:
+        fill.set("sodipodi:nodetypes", nodetypes)
+        stroke.set("sodipodi:nodetypes", nodetypes)
+    fill.set("id", path_id + "-fill")
+    stroke.set("id", path_id + "-stroke")
+    if transform is not None:
+        fill.set("transform", transform)
+        stroke.set("transform", transform)
+
+    # Replace the original node with the group
+    path_node.getparent().replace(path_node, group)
+
+    return [fill, stroke]
+
+
+### Object related
+
+
+def propagate_attribs(
+    node, parent_style={}, parent_transform=[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]
+):
+    """Propagate style and transform to remove inheritance"""
+
+    # Don't enter non-graphical portions of the document
+    if not isinstance(node, (ShapeElement, SvgDocumentElement)):
+        return
+
+    # Compose the transformations
+    if isinstance(node, SvgDocumentElement) and node.get("viewBox"):
+        vx, vy, vw, vh = [get_dimension(x) for x in node.get_viewbox()]
+        dw = get_dimension(node.get("width", vw))
+        dh = get_dimension(node.get("height", vh))
+        this_transform = Transform(translate=(-vx, -vy), scale=(dw / vw, dh / vh))
+        del node.attrib["viewBox"]
+    else:
+        this_transform = Transform(parent_transform)
+
+    this_transform @= node.transform
+
+    # Compose the style attribs
+    this_style = dict(inkex.Style.parse_str(node.get("style", "")))
+    remaining_style = {}  # Style attributes that are not propagated
+
+    non_propagated = ["filter"]  # Filters should remain on the topmost ancestor
+    for key in non_propagated:
+        if key in this_style.keys():
+            remaining_style[key] = this_style[key]
+            del this_style[key]
+
+    # Create a copy of the parent style, and merge this style into it
+    parent_style_copy = parent_style.copy()
+    parent_style_copy.update(this_style)
+    this_style = parent_style_copy
+
+    # Merge in any attributes outside of the style
+    style_attribs = ["fill", "stroke"]
+    for attrib in style_attribs:
+        if node.get(attrib):
+            this_style[attrib] = node.get(attrib)
+            del node.attrib[attrib]
+
+    if isinstance(node, (SvgDocumentElement, Group, Anchor, Switch)):
+        # Leave only non-propagating style attributes
+        if remaining_style:
+            node.style = remaining_style
+        else:
+            if "style" in node.keys():
+                del node.attrib["style"]
+
+        # Remove the transform attribute
+        if "transform" in node.keys():
+            del node.attrib["transform"]
+
+        # Continue propagating on subelements
+        for child in node.iterchildren():
+            propagate_attribs(child, this_style, this_transform)
+    else:
+        # This element is not a container
+
+        # Merge remaining_style into this_style
+        this_style.update(remaining_style)
+
+        # Set the element's style and transform attribs
+        node.style = this_style
+        node.transform = this_transform
+
+
+### Style related
+
+
+def get_dimension(s="1024"):
+    """Convert an SVG length string from arbitrary units to pixels"""
+    return inkex.units.convert_unit(s, "px")
+
+
+###### Main Class #########################################
+class SynfigPrep(TempDirMixin, inkex.EffectExtension):
+    def effect(self):
+        """Transform document in preparation for exporting it into the Synfig format"""
+
+        self.preprocess()
+
+        # Remove inheritance of attributes
+        propagate_attribs(self.document.getroot())
+
+        # Fuse multiple subpaths in fills
+        for node in self.document.getroot().xpath("//svg:path"):
+            if node.get("d", "").lower().count("m") > 1:
+                # There are multiple subpaths
+                fill = split_fill_and_stroke(node)[0]
+                if fill is not None:
+                    fill.path = fuse_subpaths(fill.path)
+
+    def preprocess(self):
+
+        actions = [
+            "unlock-all",
+            # Flow roots contain rectangles inside them, so they need to be
+            # converted to paths separately from other shapes
+            "select-by-element:flowRoot",
+            "object-to-path",
+            "select-clear",
+        ]
+
+        # Now convert all non-paths to paths
+        elements = ["rect", "circle", "ellipse", "line", "polyline", "polygon", "text"]
+        actions += ["select-by-element:" + i for i in elements]
+        actions += ["object-to-path", "select-clear"]
+        # unlink clones
+        actions += ["select-by-element:use", "object-unlink-clones"]
+        # save and overwrite
+        actions += ["export-overwrite", "export-do"]
+
+        infile = os.path.join(self.tempdir, "input.svg")
+        write_svg(self.document, infile)
+        try:
+            inkscape(infile, actions=";".join(actions))
+        except ProgramRunError as err:
+            inkex.errormsg(_("An error occurred during document preparation"))
+            inkex.errormsg(err.stderr.decode("utf-8"))
+
+        with open(infile, "r") as stream:
+            self.document = load_svg(stream)
+
+        return self.document
+
+
+if __name__ == "__main__":
+    SynfigPrep().run()