builder.py

Go to the documentation of this file.

import re
import math
from xml.etree import ElementTree
 
from .handler import SvgHandler, NameMode
from ... import objects
from ...nvector import NVector
from ...utils import restructure
from ...utils.transform import TransformMatrix
from ...parsers import glaxnimate_helpers
from ...utils.color import Color, ColorMode
try:
    from ...utils import font
    has_font = True
except ImportError:
    has_font = False
 
 
_supported_font_weights = {
    "Thin": 100, "Hairline": 100,
    "ExtraLight": 200, "UltraLight": 200,
    "Light": 300,
    "Regular": 400, "Normal": 400, "Plain": 400, "Standard": 400, "Roman": 400,
    "Medium": 500,
    "SemiBold": 600, "Demi": 600, "DemiBold": 600,
    "Bold": 700,
    "Extra": 800, "ExtraBold": 800, "Ultra": 800, "UltraBold": 800,
    "Black": 900, "Heavy": 900,
    "ExtraBlack": 1000, "UltraBlack": 1000, "UltraHeavy": 1000,
}
 
 
class PrecompTime:
    def __init__(self, pcl: objects.PreCompLayer):
        self.pcl = pcl
 
    def get_time_offset(self, time, lot):
        remap = time
        if self.pcl.time_remapping:
            remapf = self.pcl.time_remapping.get_value(time)
            remap = lot.in_point * (1-remapf) + lot.out_point * remapf
 
        return remap - self.pcl.start_time
 
 
class SvgBuilder(SvgHandler, restructure.AbstractBuilder):
    merge_paths = True
    namestart = (
        r":_A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF" +
        r"\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF" +
        r"\uFDF0-\uFFFD\U00010000-\U000EFFFF"
    )
    namenostart = r"-.0-9\xB7\u0300-\u036F\u203F-\u2040"
    id_re = re.compile("^[%s][%s%s]*$" % (namestart, namenostart, namestart))
 
    def __init__(self, time=0):
        super().__init__()
        self.svg = ElementTree.Element("svg")
        self.dom = ElementTree.ElementTree(self.svg)
        self.svg.attrib["xmlns"] = self.ns_map["svg"]
        self.ids = set()
        self.idc = 0
        self.name_mode = NameMode.Inkscape
        self.actual_time = time
        self.precomp_times = []
        self._precomps = {}
        self._assets = {}
        self._fonts = {}
        self._current_layer = []
 
    @property
    def time(self):
        time = self.actual_time
        if self.precomp_times:
            for pct in self.precomp_times:
                time = pct.get_time_offset(time, self._current_layer[-1])
        return time
 
    def gen_id(self, prefix="id"):
        while True:
            self.idc += 1
            id = "%s_%s" % (prefix, self.idc)
            if id not in self.ids:
                break
        self.ids.add(id)
        return id
 
    def set_clean_id(self, dom, n):
        idn = n.replace(" ", "_")
        if self.id_re.match(idn) and idn not in self.ids:
            self.ids.add(idn)
        else:
            idn = self.gen_id(dom.tag)
 
        dom.attrib["id"] = idn
        return idn
 
    def set_id(self, dom, lottieobj, inkscape_qual=None, force=False):
        n = getattr(lottieobj, "name", None)
        if n is None or self.name_mode == NameMode.NoName:
            if force:
                id = self.gen_id(dom.tag)
                dom.attrib["id"] = id
                return id
            return None
 
        idn = self.set_clean_id(dom, n)
        if inkscape_qual is None:
            inkscape_qual = self.qualified("inkscape", "label")
        if inkscape_qual:
            dom.attrib[inkscape_qual] = n
        return idn
 
    def _on_animation(self, animation: objects.Animation):
        self.svg.attrib["width"] = str(animation.width)
        self.svg.attrib["height"] = str(animation.height)
        self.svg.attrib["viewBox"] = "0 0 %s %s" % (animation.width, animation.height)
        self.svg.attrib["version"] = "1.1"
        self.set_id(self.svg, animation, self.qualified("sodipodi", "docname"))
        self.defs = ElementTree.SubElement(self.svg, "defs")
        if self.name_mode == NameMode.Inkscape:
            self.svg.attrib[self.qualified("inkscape", "export-xdpi")] = "96"
            self.svg.attrib[self.qualified("inkscape", "export-ydpi")] = "96"
            namedview = ElementTree.SubElement(self.svg, self.qualified("sodipodi", "namedview"))
            namedview.attrib[self.qualified("inkscape", "pagecheckerboard")] = "true"
            namedview.attrib["borderlayer"] = "true"
            namedview.attrib["bordercolor"] = "#666666"
            namedview.attrib["pagecolor"] = "#ffffff"
        self.svg.attrib["style"] = "fill: none; stroke: none"
 
        self._current_layer = [animation]
        return self.svg
 
    def _mask_to_def(self, mask):
        svgmask = ElementTree.SubElement(self.defs, "mask")
        mask_id = self.gen_id()
        svgmask.attrib["id"] = mask_id
        svgmask.attrib["mask-type"] = "alpha"
        path = ElementTree.SubElement(svgmask, "path")
        path.attrib["d"] = self._bezier_to_d(mask.shape.get_value(self.time))
        path.attrib["fill"] = "#fff"
        path.attrib["fill-opacity"] = str(mask.opacity.get_value(self.time) / 100)
        return mask_id
 
    def _matte_source_to_def(self, layer_builder):
        svgmask = ElementTree.SubElement(self.defs, "mask")
        if not layer_builder.matte_id:
            layer_builder.matte_id = self.gen_id()
        svgmask.attrib["id"] = layer_builder.matte_id
        matte_mode = layer_builder.matte_target.lottie.matte_mode
 
        mask_type = "alpha"
        if matte_mode == objects.MatteMode.Luma:
            mask_type = "luminance"
        svgmask.attrib["mask-type"] = mask_type
        return svgmask
 
    def _on_masks(self, masks):
        if len(masks) == 1:
            return self._mask_to_def(masks[0])
        mask_ids = list(map(self._mask_to_def, masks))
        mask_def = ElementTree.SubElement(self.defs, "mask")
        mask_id = self.gen_id()
        mask_def.attrib["id"] = mask_id
        g = mask_def
        for mid in mask_ids:
            g = ElementTree.SubElement(g, "g")
            g.attrib["mask"] = "url(#%s)" % mid
        full = ElementTree.SubElement(g, "rect")
        full.attrib["fill"] = "#fff"
        full.attrib["width"] = self.svg.attrib["width"]
        full.attrib["height"] = self.svg.attrib["height"]
        full.attrib["x"] = "0"
        full.attrib["y"] = "0"
        return mask_id
 
    def _on_layer(self, layer_builder, dom_parent):
        lot = layer_builder.lottie
        self._current_layer.append(lot)
 
        if not self.precomp_times and (lot.in_point > self.time or lot.out_point < self.time):
            self._current_layer.pop()
            return None
 
        if layer_builder.matte_target:
            dom_parent = self._matte_source_to_def(layer_builder)
 
        g = self.group_from_lottie(lot, dom_parent, True)
 
        if lot.masks:
            g.attrib["mask"] = "url(#%s)" % self._on_masks(lot.masks)
        elif layer_builder.matte_source:
            matte_id = layer_builder.matte_source.matte_id
            if not matte_id:
                matte_id = layer_builder.matte_source.matte_id = self.gen_id()
            g.attrib["mask"] = "url(#%s)" % matte_id
 
        if isinstance(lot, objects.PreCompLayer):
            self.precomp_times.append(PrecompTime(lot))
 
            for layer in self._precomps.get(lot.reference_id, []):
                self.process_layer(layer, g)
 
            self.precomp_times.pop()
        elif isinstance(lot, objects.NullLayer):
            g.attrib["opacity"] = "1"
        elif isinstance(lot, objects.ImageLayer):
            use = ElementTree.SubElement(g, "use")
            use.attrib[self.qualified("xlink", "href")] = "#" + self._assets[lot.image_id]
        elif isinstance(lot, objects.TextLayer):
            self._on_text_layer(g, lot)
        elif isinstance(lot, objects.SolidColorLayer):
            rect = ElementTree.SubElement(g, "rect")
            rect.attrib["width"] = str(lot.width)
            rect.attrib["height"] = str(lot.height)
            rect.attrib["fill"] = color_to_css(lot.color)
 
        if not lot.name:
            g.attrib[self.qualified("inkscape", "label")] = lot.__class__.__name__
        if layer_builder.shapegroup:
            g.attrib["style"] = self.group_to_style(layer_builder.shapegroup)
            self._split_stroke(layer_builder.shapegroup, g, dom_parent)
        #if lot.hidden:
            #g.attrib.setdefault("style", "")
            #g.attrib["style"] += "display: none;"
 
        return g
 
    def _on_font(self, font):
        self._fonts[font.name] = {
            "font-family": font.font_family,
            "font-weight": str(_supported_font_weights.get(font.font_style, 400)),
        }
 
    def _on_text_layer(self, g, lot):
        text = ElementTree.SubElement(g, "text")
        doc = lot.data.get_value(self.time)
        if doc:
            text.attrib.update(self._fonts.get(doc.font_family, {}))
            text.attrib["font-size"] = str(doc.font_size)
            if doc.line_height:
                text.attrib["line-height"] = "%s%%" % doc.line_height
            if doc.justify == objects.text.TextJustify.Left:
                text.attrib["text-anchor"] = "start"
            elif doc.justify == objects.text.TextJustify.Center:
                text.attrib["text-anchor"] = "middle"
            elif doc.justify == objects.text.TextJustify.Right:
                text.attrib["text-anchor"] = "end"
 
            text.attrib["fill"] = color_to_css(doc.color)
            text.text = doc.text
 
    def _on_layer_end(self, out_layer):
        self._current_layer.pop()
 
    def _on_precomp(self, id, dom_parent, layers):
        self._precomps[id] = layers
 
    def _on_asset(self, asset):
        if isinstance(asset, objects.assets.Image):
            img = ElementTree.SubElement(self.defs, "image")
            xmlid = self.set_clean_id(img, asset.id)
            self._assets[asset.id] = xmlid
            if asset.is_embedded:
                url = asset.image
            else:
                url = asset.image_path + asset.image
            img.attrib[self.qualified("xlink", "href")] = url
            img.attrib["width"] = str(asset.width)
            img.attrib["height"] = str(asset.height)
 
    def _get_value(self, prop, default=NVector(0, 0)):
        if prop:
            v = prop.get_value(self.time)
        else:
            v = default
 
        if v is None:
            return default
        if isinstance(v, NVector):
            return v.clone()
        return v
 
    def set_transform(self, dom, transform, auto_orient=False):
        if not transform:
            return
 
        mat = transform.to_matrix(self.time, auto_orient)
        dom.attrib["transform"] = mat.to_css_2d()
 
        if transform.opacity is not None:
            op = transform.opacity.get_value(self.time)
            if op != 100:
                dom.attrib["opacity"] = str(op/100)
 
    def _get_group_stroke(self, group):
        style = {}
        if group.stroke:
            if isinstance(group.stroke, objects.GradientStroke):
                style["stroke"] = "url(#%s)" % self.process_gradient(group.stroke)
            else:
                style["stroke"] = color_to_css(group.stroke.color.get_value(self.time))
 
            style["stroke-opacity"] = group.stroke.opacity.get_value(self.time) / 100
            style["stroke-width"] = group.stroke.width.get_value(self.time)
            if group.stroke.miter_limit is not None:
                style["stroke-miterlimit"] = group.stroke.miter_limit
 
            if group.stroke.line_cap == objects.LineCap.Round:
                style["stroke-linecap"] = "round"
            elif group.stroke.line_cap == objects.LineCap.Butt:
                style["stroke-linecap"] = "butt"
            elif group.stroke.line_cap == objects.LineCap.Square:
                style["stroke-linecap"] = "square"
 
            if group.stroke.line_join == objects.LineJoin.Round:
                style["stroke-linejoin"] = "round"
            elif group.stroke.line_join == objects.LineJoin.Bevel:
                style["stroke-linejoin"] = "bevel"
            elif group.stroke.line_join == objects.LineJoin.Miter:
                style["stroke-linejoin"] = "miter"
 
            if group.stroke.dashes:
                dasharray = []
                last = 0
                last_mode = objects.StrokeDashType.Dash
                for dash in group.stroke.dashes:
                    if last_mode == dash.type:
                        last += dash.length.get_value(self.time)
                    else:
                        if last_mode != objects.StrokeDashType.Offset:
                            dasharray.append(str(last))
                            last = 0
                        last_mode = dash.type
                style["stroke-dasharray"] = " ".join(dasharray)
        return style
 
    def _style_to_css(self, style):
        return ";".join(map(
            lambda x: ":".join(map(str, x)),
            style.items()
        ))
 
    def _split_stroke(self, group, fill_layer, out_parent):
        if not group.stroke:# or group.stroke_above:
            return
 
        style = self._get_group_stroke(group)
        if style.get("stroke-width", 0) <= 0 or style["stroke-opacity"] <= 0:
            return
 
        if group.stroke_above:
            if fill_layer.attrib.get("style", ""):
                fill_layer.attrib["style"] += ";"
            else:
                fill_layer.attrib["style"] = ""
            fill_layer.attrib["style"] += self._style_to_css(style)
            return fill_layer
 
        g = ElementTree.Element("g")
        self.set_clean_id(g, "stroke")
        use = ElementTree.Element("use")
        for i, e in enumerate(out_parent):
            if e is fill_layer:
                out_parent.insert(i, g)
                out_parent.remove(fill_layer)
                break
        else:
            return
 
        g.append(use)
        g.append(fill_layer)
 
        use.attrib[self.qualified("xlink", "href")] = "#" + fill_layer.attrib["id"]
        use.attrib["style"] = self._style_to_css(style)
        return g
 
    def group_to_style(self, group):
        style = {}
        if group.fill:
            style["fill-opacity"] = group.fill.opacity.get_value(self.time) / 100
            if isinstance(group.fill, objects.GradientFill):
                style["fill"] = "url(#%s)" % self.process_gradient(group.fill)
            else:
                style["fill"] = color_to_css(group.fill.color.get_value(self.time))
 
            if group.fill.fill_rule:
                style["fill-rule"] = "evenodd" if group.fill.fill_rule == objects.FillRule.EvenOdd else "nonzero"
 
        if group.lottie.hidden:
            style["display"] = "none"
        #if group.stroke_above:
            #style.update(self._get_group_stroke(group))
 
        return self._style_to_css(style)
 
    def process_gradient(self, gradient):
        spos = gradient.start_point.get_value(self.time)
        epos = gradient.end_point.get_value(self.time)
 
        if gradient.gradient_type == objects.GradientType.Linear:
            dom = ElementTree.SubElement(self.defs, "linearGradient")
            dom.attrib["x1"] = str(spos[0])
            dom.attrib["y1"] = str(spos[1])
            dom.attrib["x2"] = str(epos[0])
            dom.attrib["y2"] = str(epos[1])
        elif gradient.gradient_type == objects.GradientType.Radial:
            dom = ElementTree.SubElement(self.defs, "radialGradient")
            dom.attrib["cx"] = str(spos[0])
            dom.attrib["cy"] = str(spos[1])
            dom.attrib["r"] = str((epos-spos).length)
            a = gradient.highlight_angle.get_value(self.time) * math.pi / 180
            l = gradient.highlight_length.get_value(self.time)
            dom.attrib["fx"] = str(spos[0] + math.cos(a) * l)
            dom.attrib["fy"] = str(spos[1] + math.sin(a) * l)
 
        id = self.set_id(dom, gradient, force=True)
        dom.attrib["gradientUnits"] = "userSpaceOnUse"
 
        for off, color in gradient.colors.stops_at(self.time):
            stop = ElementTree.SubElement(dom, "stop")
            stop.attrib["offset"] = "%s%%" % (off * 100)
            stop.attrib["stop-color"] = color_to_css(color[:3])
            if len(color) > 3:
                stop.attrib["stop-opacity"] = str(color[3])
 
        return id
 
    def group_from_lottie(self, lottie, dom_parent, layer):
        g = ElementTree.SubElement(dom_parent, "g")
        if layer and self.name_mode == NameMode.Inkscape:
            g.attrib[self.qualified("inkscape", "groupmode")] = "layer"
        self.set_id(g, lottie, force=True)
        self.set_transform(g, lottie.transform, getattr(lottie, "auto_orient", False))
        return g
 
    def _on_shapegroup(self, group, dom_parent):
        if group.empty():
            return
 
        if len(group.children) == 1 and isinstance(group.children[0], restructure.RestructuredPathMerger):
            path = self.build_path(group.paths.paths, dom_parent)
            self.set_id(path, group.paths.paths[0], force=True)
            path.attrib["style"] = self.group_to_style(group)
            self.set_transform(path, group.lottie.transform)
            return self._split_stroke(group, path, dom_parent)
 
        g = self.group_from_lottie(group.lottie, dom_parent, group.layer)
        g.attrib["style"] = self.group_to_style(group)
        self.shapegroup_process_children(group, g)
        return self._split_stroke(group, g, dom_parent)
 
    def _on_merged_path(self, shape, shapegroup, out_parent):
        path = self.build_path(shape.paths, out_parent)
        self.set_id(path, shape.paths[0])
        path.attrib["style"] = self.group_to_style(shapegroup)
        #self._split_stroke(shapegroup, path, out_parent)
        return path
 
    def _on_shape(self, shape, shapegroup, out_parent):
        if isinstance(shape, objects.Rect):
            svgshape = self.build_rect(shape, out_parent)
        elif isinstance(shape, objects.Ellipse):
            svgshape = self.build_ellipse(shape, out_parent)
        elif isinstance(shape, objects.Star):
            svgshape = self.build_path([shape.to_bezier()], out_parent)
        elif isinstance(shape, objects.Path):
            svgshape = self.build_path([shape], out_parent)
        elif has_font and isinstance(shape, font.FontShape):
            svgshape = self.build_text(shape, out_parent)
        else:
            return
        self.set_id(svgshape, shape, force=True)
        if "style" not in svgshape.attrib:
            svgshape.attrib["style"] = ""
        svgshape.attrib["style"] += self.group_to_style(shapegroup)
        #self._split_stroke(shapegroup, svgshape, out_parent)
 
        if shape.hidden:
            svgshape.attrib["style"] += "display: none;"
        return svgshape
 
    def build_rect(self, shape, parent):
        rect = ElementTree.SubElement(parent, "rect")
        size = shape.size.get_value(self.time)
        pos = shape.position.get_value(self.time)
        rect.attrib["width"] = str(size[0])
        rect.attrib["height"] = str(size[1])
        rect.attrib["x"] = str(pos[0] - size[0] / 2)
        rect.attrib["y"] = str(pos[1] - size[1] / 2)
        rect.attrib["rx"] = str(shape.rounded.get_value(self.time))
        return rect
 
    def build_ellipse(self, shape, parent):
        ellipse = ElementTree.SubElement(parent, "ellipse")
        size = shape.size.get_value(self.time)
        pos = shape.position.get_value(self.time)
        ellipse.attrib["rx"] = str(size[0] / 2)
        ellipse.attrib["ry"] = str(size[1] / 2)
        ellipse.attrib["cx"] = str(pos[0])
        ellipse.attrib["cy"] = str(pos[1])
        return ellipse
 
    def build_path(self, shapes, parent):
        path = ElementTree.SubElement(parent, "path")
        d = ""
        for shape in shapes:
            bez = shape.shape.get_value(self.time)
            if isinstance(bez, list):
                bez = bez[0]
            if not bez.vertices:
                continue
            if d:
                d += "\n"
            d += self._bezier_to_d(bez)
 
        path.attrib["d"] = d
        return path
 
    def _bezier_tangent(self, tangent):
        _tangent_threshold = 0.5
        if tangent.length < _tangent_threshold:
            return NVector(0, 0)
        return tangent
 
    def _bezier_to_d(self, bez):
        d = "M %s,%s " % tuple(bez.vertices[0].components[:2])
        for i in range(1, len(bez.vertices)):
            qfrom = bez.vertices[i-1]
            h1 = self._bezier_tangent(bez.out_tangents[i-1]) + qfrom
            qto = bez.vertices[i]
            h2 = self._bezier_tangent(bez.in_tangents[i]) + qto
 
            d += "C %s,%s %s,%s %s,%s " % (
                h1[0], h1[1],
                h2[0], h2[1],
                qto[0], qto[1],
            )
        if bez.closed:
            qfrom = bez.vertices[-1]
            h1 = self._bezier_tangent(bez.out_tangents[-1]) + qfrom
            qto = bez.vertices[0]
            h2 = self._bezier_tangent(bez.in_tangents[0]) + qto
            d += "C %s,%s %s,%s %s,%s Z" % (
                h1[0], h1[1],
                h2[0], h2[1],
                qto[0], qto[1],
            )
 
        return d
 
    def _on_shape_modifier(self, shape, shapegroup, out_parent):
        if isinstance(shape.lottie, objects.Repeater):
            svgshape = self.build_repeater(shape.lottie, shape.child, shapegroup, out_parent)
        elif isinstance(shape.lottie, objects.RoundedCorners):
            svgshape = self.build_rouded_corners(shape.lottie, shape.child, shapegroup, out_parent)
        elif isinstance(shape.lottie, objects.Trim):
            svgshape = self.build_trim_path(shape.lottie, shape.child, shapegroup, out_parent)
        else:
            return self.shapegroup_process_child(shape.child, shapegroup, out_parent)
        return svgshape
 
    def build_repeater(self, shape, child, shapegroup, out_parent):
        original = self.shapegroup_process_child(child, shapegroup, out_parent)
        if not original:
            return
 
        ncopies = int(round(shape.copies.get_value(self.time)))
        if ncopies == 1:
            return
 
        out_parent.remove(original)
 
        g = ElementTree.SubElement(out_parent, "g")
        self.set_clean_id(g, "repeater")
 
        for copy in range(ncopies-1):
            use = ElementTree.SubElement(g, "use")
            use.attrib[self.qualified("xlink", "href")] = "#" + original.attrib["id"]
 
        orig_wrapper = ElementTree.SubElement(g, "g")
        orig_wrapper.append(original)
 
        transform = objects.Transform()
        so = shape.transform.start_opacity.get_value(self.time)
        eo = shape.transform.end_opacity.get_value(self.time)
        position = shape.transform.position.get_value(self.time)
        rotation = shape.transform.rotation.get_value(self.time)
        anchor_point = shape.transform.anchor_point.get_value(self.time)
        for i in range(ncopies-1, -1, -1):
            of = i / (ncopies-1)
            transform.opacity.value = so * of + eo * (1 - of)
            self.set_transform(g[i], transform)
            transform.position.value += position
            transform.rotation.value += rotation
            transform.anchor_point.value += anchor_point
 
        return g
 
    def build_rouded_corners(self, shape, child, shapegroup, out_parent):
        round_amount = shape.radius.get_value(self.time)
        return self._modifier_process(child, shapegroup, out_parent, self._build_rouded_corners_shape, round_amount)
 
    def _build_rouded_corners_shape(self, shape, round_amount):
        if not isinstance(shape, objects.Shape):
            return [shape]
        path = shape.to_bezier()
        bezier = path.shape.get_value(self.time).rounded(round_amount)
        path.shape.clear_animation(bezier)
        return [path]
 
    def build_trim_path(self, shape, child, shapegroup, out_parent):
        start = max(0, min(1, shape.start.get_value(self.time) / 100))
        end = max(0, min(1, shape.end.get_value(self.time) / 100))
        offset = shape.offset.get_value(self.time) / 360 % 1
 
        multidata = {}
        length = 0
 
        if shape.multiple == objects.TrimMultipleShapes.Individually:
            for visishape in reversed(list(self._modifier_foreach_shape(child))):
                bez = visishape.to_bezier().shape.get_value(self.time)
                local_length = bez.rough_length()
                multidata[visishape] = (bez, length, local_length)
                length += local_length
 
        return self._modifier_process(
            child, shapegroup, out_parent, self._build_trim_path_shape,
            start+offset, end+offset, multidata, length
        )
 
    def _modifier_foreach_shape(self, shape):
        if isinstance(shape, restructure.RestructuredShapeGroup):
            for child in shape.children:
                for chsh in self._modifier_foreach_shape(child):
                    yield chsh
        elif isinstance(shape, restructure.RestructuredPathMerger):
            for p in shape.paths:
                yield p
        elif isinstance(shape, objects.Shape):
            yield shape
 
    def _modifier_process(self, child, shapegroup, out_parent, callback, *args):
        children = self._modifier_process_child(child, shapegroup, out_parent, callback, *args)
        return [self.shapegroup_process_child(ch, shapegroup, out_parent) for ch in children]
 
    def _trim_offlocal(self, t, local_start, local_length, total_length):
        gt = (t * total_length - local_start) / local_length
        return max(0, min(1, gt))
 
    def _build_trim_path_shape(self, shape, start, end, multidata, total_length):
        if not isinstance(shape, objects.Shape):
            return [shape]
 
        if multidata:
            bezier, local_start, local_length = multidata[shape]
            if end > 1:
                lstart = self._trim_offlocal(start, local_start, local_length, total_length)
                lend = self._trim_offlocal(end-1, local_start, local_length, total_length)
                out = []
                if lstart < 1:
                    out.append(objects.Path(bezier.segment(lstart, 1)))
                if lend > 0:
                    out.append(objects.Path(bezier.segment(0, lend)))
                return out
 
            lstart = self._trim_offlocal(start, local_start, local_length, total_length)
            lend = self._trim_offlocal(end, local_start, local_length, total_length)
            if lend <= 0 or lstart >= 1:
                return []
            if lstart <= 0 and lend >= 1:
                return [objects.Path(bezier)]
            seg = bezier.segment(lstart, lend)
            return [objects.Path(seg)]
 
        path = shape.to_bezier()
        bezier = path.shape.get_value(self.time)
        if end > 1:
            bez1 = bezier.segment(start, 1)
            bez2 = bezier.segment(0, end-1)
            return [objects.Path(bez1), objects.Path(bez2)]
        else:
            seg = bezier.segment(start, end)
            return [objects.Path(seg)]
 
    def _modifier_process_children(self, shapegroup, out_parent, callback, *args):
        children = []
        for shape in shapegroup.children:
            children.extend(self._modifier_process_child(shape, shapegroup, out_parent, callback, *args))
        shapegroup.children = children
 
    def _modifier_process_child(self, shape, shapegroup, out_parent, callback, *args):
        if isinstance(shape, restructure.RestructuredShapeGroup):
            self._modifier_process_children(shape, out_parent, callback, *args)
            return [shape]
        elif isinstance(shape, restructure.RestructuredPathMerger):
            paths = []
            for p in shape.paths:
                paths.extend(callback(p, *args))
            shape.paths = paths
            if paths:
                return [shape]
            return []
        else:
            return callback(shape, *args)
 
    def _custom_object_supported(self, shape):
        if has_font and isinstance(shape, font.FontShape):
            return True
        return False
 
    def build_text(self, shape, parent):
        text = ElementTree.SubElement(parent, "text")
        if "family" in shape.query:
            text.attrib["font-family"] = shape.query["family"]
        if "weight" in shape.query:
            text.attrib["font-weight"] = str(shape.query.weight_to_css())
        slant = int(shape.query.get("slant", 0))
        if slant > 0 and slant < 110:
            text.attrib["font-style"] = "italic"
        elif slant >= 110:
            text.attrib["font-style"] = "oblique"
 
        text.attrib["font-size"] = str(shape.size)
 
        text.attrib["white-space"] = "pre"
 
        pos = shape.style.position
        text.attrib["x"] = str(pos.x)
        text.attrib["y"] = str(pos.y)
        text.text = shape.text
 
        return text
 
 
def color_to_css(color):
    #if len(color) == 4:
        #return ("rgba(%s, %s, %s" % tuple(map(lambda c: int(round(c*255)), color[:3]))) + ", %s)" % color[3]
    if isinstance(color, Color) and color.mode != ColorMode.RGB:
        color = color.converted(ColorMode.RGB)
    return "rgb(%s, %s, %s)" % tuple(map(lambda c: int(round(c*255)), color[:3]))
 
 
def to_svg(animation, time, animated=False):
    if animated:
        data = glaxnimate_helpers.convert(animation, "svg")
        return ElementTree.ElementTree(ElementTree.fromstring(data.decode("utf8")))
 
    if glaxnimate_helpers.has_glaxnimate:
        data = glaxnimate_helpers.serialize(animation, "svg")
        return ElementTree.ElementTree(ElementTree.fromstring(data.decode("utf8")))
 
    builder = SvgBuilder(time)
    builder.process(animation)
    return builder.dom