From 55e472a6add1b3d3452ada98015080c1d1d55799 Mon Sep 17 00:00:00 2001 From: Suzanne Soy Date: Sat, 13 Mar 2021 05:47:02 +0000 Subject: [PATCH] 02021-03-13 stream: Added XML model in FreeCAD, WIP on syncing the XML model and the FreeCAD UI --- XternalAppsParametricTool.py | 154 +++++++++++++++++++++++++++++------ myTool.xforms | 12 ++- 2 files changed, 137 insertions(+), 29 deletions(-) diff --git a/XternalAppsParametricTool.py b/XternalAppsParametricTool.py index 9bd8988..a7b5aa1 100644 --- a/XternalAppsParametricTool.py +++ b/XternalAppsParametricTool.py @@ -1,14 +1,16 @@ import FreeCAD as App import FreeCADGui -#from xml.etree import ElementTree from lxml import etree import ExternalAppsList from ToolXML import * from collections import namedtuple import re +from copy import deepcopy +from collections import defaultdict -XFormsInput = namedtuple('XFormsInput', ['input', 'modelElement', 'type', 'maybeEnum']) +XFormsInput = namedtuple('XFormsInput', ['input', 'modelElementPath', 'type', 'maybeEnum', 'InputValueToModelValue', 'ModelValueToInputValue']) XFormsEnum = namedtuple('XFormsEnum', ['labels', 'values']) +InterpretedXML = namedtuple('InterpretedXML', ['xml', 'types', 'inputs']) # Parsed XML, dictionary(modelElementPath) -> type, dictionary(formElementPath) -> XFormsInput def CreateCommand(appName, toolName): App.ActiveDocument.openTransaction('Create parametric %s from %s'%(toolName, appName)) @@ -45,14 +47,71 @@ def MIMETypeToFreeCADType(MIMEType): else: raise ArgumentException('Unsupported MIME type') +def encode_bytes(bytestring): + try: + return ("utf-8", bytestring.decode('utf-8', errors='strict')) + except ValueError: + from base64 import b64encode + return ("base64", b64encode(bytestring)) + +def decode_bytes(encoding_and_string): + encoding, string = encoding_and_string + if encoding == "utf-8": + return string.encode('utf-8') + elif encoding == "base64": + from base64 import b64decode + return b64decode(string) + else: + raise ValueError("invalid encoding: expected utf-8 or base64") + class XternalAppsParametricTool(): def __init__(self, obj, appName, toolName): self.Type = "XternalAppsParametricTool" self.AppName = appName self.ToolName = toolName obj.Proxy = self + self.ModelInstance = self.getDefaultModelInstance(obj) + self.ModelToProperties = {} + self.ModelOnChanged = defaultdict(set) self.createPropertiesFromXML(obj) + def __getstate__(self): + copied = self.__dict__.copy() + copied['ModelInstance'] = encode_bytes(etree.tostring(copied['ModelInstance'])) + return copied + + def __setstate__(self, state): + if state: + state['ModelInstance'] = etree.fromstring(decode_bytes(state['ModelInstance'])) + self.__dict__ = state + + def getDefaultModelInstance(self, obj): + xml = etree.parse(self.Tool.XForms) + model = xml.find('./xforms:model', ns) + instanceDocument = etree.ElementTree(model.find('./xforms:instance/*', ns)) + return deepcopy(instanceDocument) + + def typecheckModelInstance(self, types, instance): + """TODO""" + + def updateModelInstance(self, instance, ref, value): + """TODO""" + + def onChanged(self, obj, prop): + if hasattr(self, 'SimpleInputNameToInput'): + inputPath = self.SimpleInputNameToInput.get(prop, None) + if inputPath is not None: + modelElementPath = self.Inputs[inputPath].modelElementPath + modelElement = self.ModelInstance.find(modelElementPath) + newText = self.Inputs[inputPath].InputValueToModelValue(getattr(obj, prop)) + print((prop, getattr(obj, prop), modelElement.text, newText)) + if modelElement.text != newText: + modelElement.text = newText + for inputPathToUpdate in self.ModelOnChanged[modelElementPath]: + if inputPathToUpdate != inputPath: + # TODO: this is terrible and will lead to infinite update loops + setattr(obj, self.InputToSimpleInputName[inputPathToUpdate], self.Inputs[inputPathToUpdate].ModelValueToInputValue(newText)) + def interpretFormElement(self, xmlXFormsElement, xml, instanceDocument, types): # TODO: is it safe to pass input unprotected here? modelElement = instanceDocument.find(xmlXFormsElement.attrib['ref'], @@ -60,11 +119,12 @@ class XternalAppsParametricTool(): if modelElement is None: raise Exception('Could not find ' + xmlXFormsElement.attrib['ref'] \ + ' in instance document with namespaces=' + repr(xmlXFormsElement.nsmap)) - type = types.get(instanceDocument.getpath(modelElement)) + modelElementPath = instanceDocument.getelementpath(modelElement) + type = types.get(modelElementPath) if type is None: - raise Exception('Could not find type for ' + instanceDocument.getpath(modelElement)) - path = xml.getpath(xmlXFormsElement) - return (path, xmlXFormsElement, modelElement, type) + raise Exception('Could not find type for ' + modelElementPath) + path = xml.getelementpath(xmlXFormsElement) + return (path, xmlXFormsElement, modelElementPath, type) def interpretXML(self): """Parse the self.Tool.XForms document, and return @@ -72,22 +132,17 @@ class XternalAppsParametricTool(): * a dictionary types[path] = "type" * a dictionary inputs[path] = (xml_input_element, xml_model_element, type).""" types = {} - modelInstance = {} + #modelInstance = {} inputs = {} xml = etree.parse(self.Tool.XForms) model = xml.find('./xforms:model', ns) instanceDocument = etree.ElementTree(model.find('./xforms:instance/*', ns)) - # Traverse the XForms instance and register all elements in modelInstance[pathToElement] - for element in instanceDocument.findall('.//*'): - path = instanceDocument.getpath(element) - modelInstance[path] = element.text - # register all xform:bind to types[pathToTargetElement] for bind in model.findall('xforms:bind', ns): for bound in instanceDocument.findall(bind.attrib['ref'], namespaces=bind.nsmap): - path = instanceDocument.getpath(bound) + path = instanceDocument.getelementpath(bound) # TODO: if has attrib type then … type = bind.attrib['type'] # TODO: I guess XForms implicitly allows intersection types by using several bind statements? @@ -97,37 +152,86 @@ class XternalAppsParametricTool(): # register all inputs to inputs[pathToElement] for group in xml.findall('./xforms:group', ns): for input in group.findall('./xforms:input', ns): - path, xmlXFormsElement, modelElement, type = self.interpretFormElement(input, xml, instanceDocument, types) - inputs[path] = XFormsInput(input=xmlXFormsElement, modelElement=modelElement, type=type, maybeEnum=None) + path, xmlXFormsElement, modelElementPath, type = self.interpretFormElement(input, xml, instanceDocument, types) + inputs[path] = XFormsInput(input=xmlXFormsElement, modelElementPath=modelElementPath, type=type, maybeEnum=None, InputValueToModelValue = None, ModelValueToInputValue = None) for select1 in group.findall('./xforms:select1', ns): - path, xmlXFormsElement, modelElement, type = self.interpretFormElement(select1, xml, instanceDocument, types) + path, xmlXFormsElement, modelElementPath, type = self.interpretFormElement(select1, xml, instanceDocument, types) # Gather the allowed elements for the enum enum = {} for item in select1.findall('./xforms:item', ns): enum[item.attrib['label']] = item.attrib['value'] - inputs[path] = XFormsInput(input=xmlXFormsElement, modelElement=modelElement, type=type, maybeEnum=enum) - return (xml, types, modelInstance, inputs) + inputs[path] = XFormsInput(input=xmlXFormsElement, modelElementPath=modelElementPath, type=type, maybeEnum=enum, InputValueToModelValue = None, ModelValueToInputValue = None) + return InterpretedXML(xml=xml, types=types, inputs=inputs) # modelInstance, def toSimpleName(self, name): return re.sub(r'( |[^-a-zA-Z0-9])+', ' ', name).title().replace(' ', '') + def toUniqueSimpleName(self, name, mutableNextUnique): + m = re.match(r'^((.*[^0-9])?)([0-9]*)$', name) + base = m.group(1) + counter = m.group(3) + if counter == '' and mutableNextUnique[base] == 0: + mutableNextUnique[name] = 1 + elif counter == '': + counter = str(mutableNextUnique[name]) + mutableNextUnique[name] = mutableNextUnique[name] + 1 + elif int(counter) > mutableNextUnique[name]: + mutableNextUnique[name] = str(int(counter)+1) + else: + counter = str(mutableNextUnique[name]) + mutableNextUnique[name] = mutableNextUnique[name] + 1 + return base + counter + def createPropertiesFromXML(self, obj): - xml, types, modelInstance, inputs = self.interpretXML() - for (input, modelElement, type, maybeEnum) in inputs.values(): - simpleName = self.toSimpleName(input.attrib['label']) + xml, types, inputs = self.interpretXML() # modelInstance, + simpleInputNameToInput = {} + inputToSimpleInputName = {} + nextUniqueSimpleName = defaultdict(lambda: 0) + inputs2 = {} + for inputPath, (input, modelElementPath, type, maybeEnum, _1, _2) in inputs.items(): + simpleName = self.toUniqueSimpleName(self.toSimpleName(input.attrib['label']), nextUniqueSimpleName) + simpleInputNameToInput[simpleName] = inputPath + inputToSimpleInputName[inputPath] = simpleName + group = "/".join(input.xpath('ancestor-or-self::xforms:group/xforms:label/text()', namespaces=ns)) or None - print((simpleName, typeToFreeCADType(type, maybeEnum), maybeEnum)) + + loadedValue = self.ModelInstance.find(modelElementPath).text + obj.addProperty(typeToFreeCADType(type, maybeEnum), simpleName, group, input.attrib['label'] + '\nA value of type ' + type) + + inputValueToModelValue = str + modelValueToInputValue = lambda x: x if maybeEnum is not None: - setattr(obj, simpleName, [self.toSimpleName(k) for k in maybeEnum.keys()]) - # TODO: have a converter from the labels to the values + enumWithSimpleNames = { self.toSimpleName(k): v for k, v in maybeEnum.items() } + setattr(obj, simpleName, list(enumWithSimpleNames.keys())) + inputValueToModelValue = enumWithSimpleNames.get + modelValueToInputValue = {v: l for l, v in enumWithSimpleNames.items()}.get + + if loadedValue is not None: + print("setting " + simpleName + "(full label = " + input.attrib['label'] + ") to " + str(loadedValue)) + setattr(obj, simpleName, modelValueToInputValue(loadedValue)) + + # TODO: refactor this! + inputs2[inputPath] = XFormsInput( + input=input, + modelElementPath=modelElementPath, + type=type, + maybeEnum=maybeEnum, + InputValueToModelValue = inputValueToModelValue, + ModelValueToInputValue = modelValueToInputValue) + + self.ModelOnChanged[modelElementPath].add(inputPath) + self.Types = types + self.Inputs = inputs2 + self.SimpleInputNameToInput = simpleInputNameToInput + self.InputToSimpleInputName = inputToSimpleInputName @property def Tool(self): return ExternalAppsList.apps[self.AppName].Tools[self.ToolName] -def execute(self, obj): + def execute(self, obj): """This is called when the object is recomputed""" diff --git a/myTool.xforms b/myTool.xforms index c58450b..5ba14bb 100644 --- a/myTool.xforms +++ b/myTool.xforms @@ -12,8 +12,8 @@ - - default value + default value + bar @@ -22,8 +22,8 @@ --> - - + + @@ -48,5 +48,9 @@ + + + +