wrappers.py

Go to the documentation of this file.

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_nodechild_node = child_node
        self.default_ctordefault_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.namename:
                value = self.child_nodechild_node.from_dom(xml_first_element_child(cn), registry)
                break
        else:
            value = self.defaultdefaultdefault()
 
        setattr(obj, self.att_nameatt_name, value)
 
    def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document):
        param = parent.appendChild(dom.createElement("param"))
        param.setAttribute("name", self.namename)
        param.appendChild(getattr(obj, self.att_nameatt_name).to_dom(dom))
        return param
 
    def clean(self, value):
        if not isinstance(value, self.child_nodechild_node):
            raise ValueError("%s isn't a valid value for %s" % (value, self.namename))
        return value
 
    def default(self):
        return self.default_ctordefault_ctor()
 
 
class SifNodeList:
    def __init__(self, type):
        self._items_items = []
        self._type_type = type
 
    def __len__(self):
        return len(self._items_items)
 
    def __iter__(self):
        return iter(self._items_items)
 
    def __getitem__(self, name):
        return self._items_items[name]
 
    def __getslice__(self, i, j):
        return self._items_items[i:j]
 
    def __setitem__(self, key, value: "Layer"):
        self.validatevalidate(value)
        self._items_items[key] = value
 
    def append(self, value: "Layer"):
        self.validatevalidate(value)
        self._items_items.append(value)
 
    def __str__(self):
        return str(self._items_items)
 
    def __repr__(self):
        return "<SifNodeList %s>" % self._items_items
 
    def validate(self, value):
        if not isinstance(value, self._type_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_nodechild_node = child_node
        self.nestednested = nested
 
    def default(self):
        return self.child_nodechild_node()
 
    def from_python(self, value):
        if not isinstance(value, self.child_nodechild_node):
            raise ValueError("Invalid value for %s: %s" % (self.namename, value))
        return value
 
    def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry):
        cn = xml_first_element_child(parent, self.namename, allow_none=True)
        if cn:
            if self.nestednested:
                element = xml_first_element_child(cn)
            else:
                element = cn
            value = self.child_nodechild_node.from_dom(element, registry)
        else:
            value = self.defaultdefaultdefault()
 
        setattr(obj, self.att_nameatt_name, value)
 
    def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document):
        value = getattr(obj, self.att_nameatt_name)
        if self.nestednested:
            node = dom.createElement(self.namename)
            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_nodechild_node = child_node
        self.att_nameatt_nameatt_name = self.att_nameatt_nameatt_name + "s" if name is None else name
        self.wrapper_tagwrapper_tag = wrapper_tag
        if tags is None:
            self.tagstags = {self.namename}
        else:
            self.tagstags = tags
 
    def default(self):
        return SifNodeList(self.child_nodechild_node)
 
    def clean(self, value):
        return value
 
    def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry):
        values = self.defaultdefaultdefault()
        for cn in xml_child_elements(parent):
            if cn.tagName in self.tagstags:
                value_node = cn
                if self.wrapper_tagwrapper_tag:
                    value_node = xml_first_element_child(cn)
                values.append(self.child_nodechild_node.from_dom(value_node, registry))
 
        setattr(obj, self.att_nameatt_nameatt_name, values)
 
    def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document):
        for value in getattr(obj, self.att_nameatt_nameatt_name):
            value_node = value.to_dom(dom)
            if self.wrapper_tagwrapper_tag:
                wrapper = dom.createElement(self.wrapper_tagwrapper_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.wrappedwrapped = wrapped
 
    def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document):
        wrapper = parent.appendChild(dom.createElement(self.namename))
        self.wrappedwrapped.to_xml(obj, wrapper, dom)
 
    def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry):
        wrapper = xml_first_element_child(parent, self.namename, True)
        if wrapper:
            return self.wrappedwrapped.from_xml(obj, wrapper, registry)
        return self.defaultdefaultdefault()
 
    def from_python(self, value):
        return self.wrappedwrapped.from_python(value)
 
    def initialize_object(self, dict, obj):
        return self.wrappedwrapped.initialize_object(dict, obj)
 
    def clean(self, value):
        return self.wrappedwrapped.clean(value)
 
    def default(self):
        return self.wrappedwrapped.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.namename)
        self.wrappedwrapped.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.namename:
                return self.wrappedwrapped.from_xml(obj, wrapper, registry)
        return self.defaultdefaultdefault()
 
 
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.namename, None)
        if not value:
            return
 
        node = parent.appendChild(dom.createElement(self.namename))
        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.namename, 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_nameatt_name, value)
 
    def from_python(self, value):
        return value