Initial Commit

lottie/parsers/sif/xml/wrappers.py

@@ -0,0 +1,217 @@
+from .utils import *
+from .core_nodes import XmlDescriptor, ObjectRegistry
+
+
+class XmlParamSif(XmlDescriptor):
+    def __init__(self, name, child_node, default_ctor=None):
+        super().__init__(name)
+        self.child_node = child_node
+        self.default_ctor = default_ctor or child_node
+
+    def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry):
+        for cn in xml_child_elements(parent, "param"):
+            if cn.getAttribute("name") == self.name:
+                value = self.child_node.from_dom(xml_first_element_child(cn), registry)
+                break
+        else:
+            value = self.default()
+
+        setattr(obj, self.att_name, value)
+
+    def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document):
+        param = parent.appendChild(dom.createElement("param"))
+        param.setAttribute("name", self.name)
+        param.appendChild(getattr(obj, self.att_name).to_dom(dom))
+        return param
+
+    def clean(self, value):
+        if not isinstance(value, self.child_node):
+            raise ValueError("%s isn't a valid value for %s" % (value, self.name))
+        return value
+
+    def default(self):
+        return self.default_ctor()
+
+
+class SifNodeList:
+    def __init__(self, type):
+        self._items = []
+        self._type = type
+
+    def __len__(self):
+        return len(self._items)
+
+    def __iter__(self):
+        return iter(self._items)
+
+    def __getitem__(self, name):
+        return self._items[name]
+
+    def __getslice__(self, i, j):
+        return self._items[i:j]
+
+    def __setitem__(self, key, value: "Layer"):
+        self.validate(value)
+        self._items[key] = value
+
+    def append(self, value: "Layer"):
+        self.validate(value)
+        self._items.append(value)
+
+    def __str__(self):
+        return str(self._items)
+
+    def __repr__(self):
+        return "<SifNodeList %s>" % self._items
+
+    def validate(self, value):
+        if not isinstance(value, self._type):
+            raise ValueError("Not a valid object: %s" % value)
+
+
+class XmlSifElement(XmlDescriptor):
+    def __init__(self, name, child_node, nested=True):
+        super().__init__(name)
+        self.child_node = child_node
+        self.nested = nested
+
+    def default(self):
+        return self.child_node()
+
+    def from_python(self, value):
+        if not isinstance(value, self.child_node):
+            raise ValueError("Invalid value for %s: %s" % (self.name, value))
+        return value
+
+    def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry):
+        cn = xml_first_element_child(parent, self.name, allow_none=True)
+        if cn:
+            if self.nested:
+                element = xml_first_element_child(cn)
+            else:
+                element = cn
+            value = self.child_node.from_dom(element, registry)
+        else:
+            value = self.default()
+
+        setattr(obj, self.att_name, value)
+
+    def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document):
+        value = getattr(obj, self.att_name)
+        if self.nested:
+            node = dom.createElement(self.name)
+            parent.appendChild(node)
+        else:
+            node = parent
+        node.appendChild(value.to_dom(dom))
+
+
+class XmlList(XmlDescriptor):
+    def __init__(self, child_node, name=None, wrapper_tag=None, tags=None):
+        super().__init__(wrapper_tag or child_node._tag)
+        self.child_node = child_node
+        self.att_name = self.att_name + "s" if name is None else name
+        self.wrapper_tag = wrapper_tag
+        if tags is None:
+            self.tags = {self.name}
+        else:
+            self.tags = tags
+
+    def default(self):
+        return SifNodeList(self.child_node)
+
+    def clean(self, value):
+        return value
+
+    def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry):
+        values = self.default()
+        for cn in xml_child_elements(parent):
+            if cn.tagName in self.tags:
+                value_node = cn
+                if self.wrapper_tag:
+                    value_node = xml_first_element_child(cn)
+                values.append(self.child_node.from_dom(value_node, registry))
+
+        setattr(obj, self.att_name, values)
+
+    def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document):
+        for value in getattr(obj, self.att_name):
+            value_node = value.to_dom(dom)
+            if self.wrapper_tag:
+                wrapper = dom.createElement(self.wrapper_tag)
+                wrapper.appendChild(value_node)
+                value_node = wrapper
+            parent.appendChild(value_node)
+
+
+class XmlWrapper(XmlDescriptor):
+    def __init__(self, name, wrapped: XmlDescriptor):
+        super().__init__(name)
+        self.wrapped = wrapped
+
+    def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document):
+        wrapper = parent.appendChild(dom.createElement(self.name))
+        self.wrapped.to_xml(obj, wrapper, dom)
+
+    def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry):
+        wrapper = xml_first_element_child(parent, self.name, True)
+        if wrapper:
+            return self.wrapped.from_xml(obj, wrapper, registry)
+        return self.default()
+
+    def from_python(self, value):
+        return self.wrapped.from_python(value)
+
+    def initialize_object(self, dict, obj):
+        return self.wrapped.initialize_object(dict, obj)
+
+    def clean(self, value):
+        return self.wrapped.clean(value)
+
+    def default(self):
+        return self.wrapped.default()
+
+
+class XmlWrapperParam(XmlWrapper):
+    def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document):
+        wrapper = parent.appendChild(dom.createElement("param"))
+        wrapper.setAttribute("name", self.name)
+        self.wrapped.to_xml(obj, wrapper, dom)
+
+    def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry):
+        for wrapper in xml_child_elements(parent, "param"):
+            if wrapper.getAttribute("name") == self.name:
+                return self.wrapped.from_xml(obj, wrapper, registry)
+        return self.default()
+
+
+class XmlBoneReference(XmlDescriptor):
+    def __init__(self, name):
+        super().__init__(name)
+
+    def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document):
+        value = getattr(obj, self.name, None)
+        if not value:
+            return
+
+        node = parent.appendChild(dom.createElement(self.name))
+        value_node = node.appendChild(dom.createElement("bone_valuenode"))
+        value_node.setAttribute("type", value.type)
+        value_node.setAttribute("guid", value.guid)
+
+        return node
+
+    def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry):
+        node = xml_first_element_child(parent, self.name, True)
+        value = None
+        if node:
+            value_node = xml_first_element_child(node, "bone_valuenode", True)
+            if value_node:
+                value = registry.get_object(value_node.getAttribute("guid"))
+                if value.type != value_node.getAttribute("type"):
+                    raise ValueError("Bone type %s is not %s" % (value.type, value_node.getAttribute("type")))
+
+        setattr(obj, self.att_name, value)
+
+    def from_python(self, value):
+        return value