blender/release/scripts/modules/rna_xml.py
2012-01-17 17:57:20 +00:00

370 lines
13 KiB
Python

# ***** BEGIN GPL LICENSE BLOCK *****
#
# 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.
#
# Contributor(s): Campbell Barton
#
# ***** END GPL LICENSE BLOCK *****
# <pep8 compliant>
import bpy
def build_property_typemap(skip_classes):
property_typemap = {}
for attr in dir(bpy.types):
cls = getattr(bpy.types, attr)
if issubclass(cls, skip_classes):
continue
## to support skip-save we cant get all props
# properties = cls.bl_rna.properties.keys()
properties = []
for prop_id, prop in cls.bl_rna.properties.items():
if not prop.is_skip_save:
properties.append(prop_id)
properties.remove("rna_type")
property_typemap[attr] = properties
return property_typemap
def print_ln(data):
print(data, end="")
def rna2xml(fw=print_ln,
root_node="",
root_rna=None, # must be set
root_rna_skip=set(),
root_ident="",
ident_val=" ",
skip_classes=(bpy.types.Operator,
bpy.types.Panel,
bpy.types.KeyingSet,
bpy.types.Header,
),
pretty_format=True,
method='DATA'):
from xml.sax.saxutils import quoteattr
property_typemap = build_property_typemap(skip_classes)
def number_to_str(val, val_type):
if val_type == int:
return "%d" % val
elif val_type == float:
return "%.6g" % val
elif val_type == bool:
return "TRUE" if val else "FALSE"
else:
raise NotImplemented("this type is not a number %s" % val_type)
def rna2xml_node(ident, value, parent):
ident_next = ident + ident_val
# divide into attrs and nodes.
node_attrs = []
nodes_items = []
nodes_lists = []
value_type = type(value)
if issubclass(value_type, skip_classes):
return
# XXX, fixme, pointcache has eternal nested pointer to its self.
if value == parent:
return
value_type_name = value_type.__name__
for prop in property_typemap[value_type_name]:
subvalue = getattr(value, prop)
subvalue_type = type(subvalue)
if subvalue_type in (int, bool, float):
node_attrs.append("%s=\"%s\"" % (prop, number_to_str(subvalue, subvalue_type)))
elif subvalue_type is str:
node_attrs.append("%s=%s" % (prop, quoteattr(subvalue)))
elif subvalue_type == set:
node_attrs.append("%s=%s" % (prop, quoteattr("{" + ",".join(list(subvalue)) + "}")))
elif subvalue is None:
node_attrs.append("%s=\"NONE\"" % prop)
elif issubclass(subvalue_type, bpy.types.ID):
# special case, ID's are always referenced.
node_attrs.append("%s=%s" % (prop, quoteattr(subvalue_type.__name__ + "::" + subvalue.name)))
else:
try:
subvalue_ls = list(subvalue)
except:
subvalue_ls = None
if subvalue_ls is None:
nodes_items.append((prop, subvalue, subvalue_type))
else:
# check if the list contains native types
subvalue_rna = value.path_resolve(prop, False)
if type(subvalue_rna).__name__ == "bpy_prop_array":
# check if this is a 0-1 color (rgb, rgba)
# in that case write as a hexidecimal
prop_rna = value.bl_rna.properties[prop]
if (prop_rna.subtype == 'COLOR_GAMMA' and
prop_rna.hard_min == 0.0 and
prop_rna.hard_max == 1.0 and
prop_rna.array_length in {3, 4}):
# -----
# color
array_value = "#" + "".join(("%.2x" % int(v * 255) for v in subvalue_rna))
else:
# default
def str_recursive(s):
subsubvalue_type = type(s)
if subsubvalue_type in (int, float, bool):
return number_to_str(s, subsubvalue_type)
else:
return " ".join([str_recursive(si) for si in s])
array_value = " ".join(str_recursive(v) for v in subvalue_rna)
node_attrs.append("%s=\"%s\"" % (prop, array_value))
else:
nodes_lists.append((prop, subvalue_ls, subvalue_type))
# declare + attributes
if pretty_format:
tmp_str = "<%s " % value_type_name
tmp_ident = "\n" + ident + (" " * len(tmp_str))
fw("%s%s%s>\n" % (ident, tmp_str, tmp_ident.join(node_attrs)))
del tmp_str
del tmp_ident
else:
fw("%s<%s %s>\n" % (ident, value_type_name, " ".join(node_attrs)))
# unique members
for prop, subvalue, subvalue_type in nodes_items:
fw("%s<%s>\n" % (ident_next, prop)) # XXX, this is awkward, how best to solve?
rna2xml_node(ident_next + ident_val, subvalue, value)
fw("%s</%s>\n" % (ident_next, prop)) # XXX, need to check on this.
# list members
for prop, subvalue, subvalue_type in nodes_lists:
fw("%s<%s>\n" % (ident_next, prop))
for subvalue_item in subvalue:
if subvalue_item is not None:
rna2xml_node(ident_next + ident_val, subvalue_item, value)
fw("%s</%s>\n" % (ident_next, prop))
fw("%s</%s>\n" % (ident, value_type_name))
# -------------------------------------------------------------------------
# needs re-workign to be generic
if root_node:
fw("%s<%s>\n" % (root_ident, root_node))
# bpy.data
if method == 'DATA':
ident = root_ident + ident_val
for attr in dir(root_rna):
# exceptions
if attr.startswith("_"):
continue
elif attr in root_rna_skip:
continue
value = getattr(root_rna, attr)
try:
ls = value[:]
except:
ls = None
if type(ls) == list:
fw("%s<%s>\n" % (ident, attr))
for blend_id in ls:
rna2xml_node(ident + ident_val, blend_id, None)
fw("%s</%s>\n" % (ident_val, attr))
# any attribute
elif method == 'ATTR':
rna2xml_node(root_ident, root_rna, None)
if root_node:
fw("%s</%s>\n" % (root_ident, root_node))
def xml2rna(root_xml,
root_rna=None, # must be set
):
def rna2xml_node(xml_node, value):
# print("evaluating:", xml_node.nodeName)
# ---------------------------------------------------------------------
# Simple attributes
for attr in xml_node.attributes.keys():
# print(" ", attr)
subvalue = getattr(value, attr, Ellipsis)
if subvalue is Ellipsis:
print("%s.%s not found" % (type(value).__name__, attr))
else:
value_xml = xml_node.attributes[attr].value
subvalue_type = type(subvalue)
tp_name = 'UNKNOWN'
if subvalue_type == float:
value_xml_coerce = float(value_xml)
tp_name = 'FLOAT'
elif subvalue_type == int:
value_xml_coerce = int(value_xml)
tp_name = 'INT'
elif subvalue_type == bool:
value_xml_coerce = {'TRUE': True, 'FALSE': False}[value_xml]
tp_name = 'BOOL'
elif subvalue_type == str:
value_xml_coerce = value_xml
tp_name = 'STR'
elif hasattr(subvalue, "__len__"):
if value_xml.startswith("#"):
# read hexidecimal value as float array
value_xml_split = value_xml[1:]
value_xml_coerce = [int(value_xml_split[i:i + 2], 16) / 255 for i in range(0, len(value_xml_split), 2)]
del value_xml_split
else:
value_xml_split = value_xml.split()
try:
value_xml_coerce = [int(v) for v in value_xml_split]
except ValueError:
value_xml_coerce = [float(v) for v in value_xml_split]
del value_xml_split
tp_name = 'ARRAY'
# print(" %s.%s (%s) --- %s" % (type(value).__name__, attr, tp_name, subvalue_type))
setattr(value, attr, value_xml_coerce)
# ---------------------------------------------------------------------
# Complex attributes
for child_xml in xml_node.childNodes:
if child_xml.nodeType == child_xml.ELEMENT_NODE:
# print()
# print(child_xml.nodeName)
subvalue = getattr(value, child_xml.nodeName, None)
if subvalue is not None:
elems = []
for child_xml_real in child_xml.childNodes:
if child_xml_real.nodeType == child_xml_real.ELEMENT_NODE:
elems.append(child_xml_real)
del child_xml_real
if hasattr(subvalue, "__len__"):
# Collection
if len(elems) != len(subvalue):
print("Size Mismatch! collection:", child_xml.nodeName)
else:
for i in range(len(elems)):
child_xml_real = elems[i]
subsubvalue = subvalue[i]
if child_xml_real is None or subsubvalue is None:
print("None found %s - %d collection:", (child_xml.nodeName, i))
else:
rna2xml_node(child_xml_real, subsubvalue)
else:
# print(elems)
if len(elems) == 1:
# sub node named by its type
child_xml_real, = elems
# print(child_xml_real, subvalue)
rna2xml_node(child_xml_real, subvalue)
else:
# empty is valid too
pass
rna2xml_node(root_xml, root_rna)
# -----------------------------------------------------------------------------
# Utility function used by presets.
# The idea is you can run a preset like a script with a few args.
#
# This roughly matches the operator 'bpy.ops.script.python_file_run'
def _get_context_val(context, path):
path_full = "context." + path
try:
value = eval(path_full)
except:
import traceback
traceback.print_exc()
print("Error: %r could not be found" % path_full)
value = Ellipsis
return value
def xml_file_run(context, filepath, rna_map):
import xml.dom.minidom
xml_nodes = xml.dom.minidom.parse(filepath)
bpy_xml = xml_nodes.getElementsByTagName("bpy")[0]
for rna_path, xml_tag in rna_map:
# first get xml
# TODO, error check
xml_node = bpy_xml.getElementsByTagName(xml_tag)[0]
value = _get_context_val(context, rna_path)
if value is not Ellipsis and value is not None:
print(" loading XML: %r" % rna_path)
xml2rna(xml_node, root_rna=value)
def xml_file_write(context, filepath, rna_map):
file = open(filepath, 'w', encoding='utf-8')
fw = file.write
fw("<bpy>\n")
for rna_path, xml_tag in rna_map:
# xml_tag is ignored, we get this from the rna
value = _get_context_val(context, rna_path)
rna2xml(fw,
root_rna=value,
method='ATTR',
root_ident=" ",
ident_val=" ")
fw("</bpy>\n")
file.close()