def saveFile(self, executable, config_file, arguments_line, save_signal, no_save_level, stop_signal, wait_window): try: file = open(self.path, 'w') except BaseException: return if not save_signal: save_signal = 0 xml = QDomDocument() p = xml.createElement('RAY-PROXY') p.setAttribute('VERSION', ray.VERSION) p.setAttribute('executable', executable) p.setAttribute('arguments', arguments_line) p.setAttribute('config_file', config_file) p.setAttribute('save_signal', str(int(save_signal))) p.setAttribute('no_save_level', str(no_save_level)) p.setAttribute('stop_signal', str(int(stop_signal))) p.setAttribute('wait_window', wait_window) xml.appendChild(p) contents = "<?xml version='1.0' encoding='UTF-8'?>\n" contents += "<!DOCTYPE RAY-PROXY>\n" contents += xml.toString() file.write(contents) file.close() self.readFile()
def colorRampToString(self, ramp): if ramp is None: return '' d = QDomDocument() d.appendChild(QgsSymbolLayerUtils.saveColorRamp('ramp', ramp, d)) rampdef = d.toString() return rampdef
def new_project(): """ 所有的命令都存储在属性'cmd',参数都存储在属性’argv‘中,全局配置的词典key使用'cmd',方便解析 没有参数的命令,使能把命令的存储参数设置为True 有参数的命令,使能就存储参数 :return: """ doc = QDomDocument("PyQt5Helper.prj") # QDomDocument类 instruction: QDomProcessingInstruction = doc.createProcessingInstruction("PyQt5Helper", "version={} " "encoding=\"UTF-8\"".format(version)) doc.appendChild(instruction) root: QDomElement = doc.createElement("PyQt5Helper.prj-config") # 创建general节点 doc.appendChild(root) # 1. 通用选项 item_list = project_item_dict.keys() for item in item_list: logging.debug(item) # general,generate_what item_element: QDomElement = doc.createElement(item) # 创建general节点 root.appendChild(item_element) item_dict = project_item_dict[item] # dist_path_cmd: ['./restore_dist', True, 'dist_path']}, for child_item in item_dict.keys(): # dist_path_cmd save_item = item_dict[child_item] e: QDomElement = doc.createElement(save_item[2]) # child tag item_element.appendChild(e) # --onedir,--onefile e.setAttribute("argv", save_item[0]) e.setAttribute("cmd", child_item) e.setAttribute("state", save_item[1]) return doc
def colorRampToString( self, ramp ): if ramp is None: return ''; d=QDomDocument() d.appendChild(QgsSymbolLayerUtils.saveColorRamp('ramp',ramp,d)) rampdef=d.toString() return rampdef
def writePointShapeAsGPX(shapePath, nameAttribute, commentAttribute, outputFileName): #open shape layer layer = QgsVectorLayer(shapePath, "gpx", "ogr") if not layer.isValid( ) or layer.geometryType() != QgsWkbTypes.PointGeometry: return #open output file outputFile = QFile(outputFileName) if not outputFile.open(QIODevice.WriteOnly): return #create xml in memory gpxDoc = QDomDocument() gpxElem = gpxDoc.createElementNS("http://www.topografix.com/GPX/1/1", "gpx") gpxDoc.appendChild(gpxElem) #all points have to be transformed to wgs84 coordTransform = QgsCoordinateTransform( layer.crs(), QgsCoordinateReferenceSystem('EPSG:4326'), QgsProject.instance()) #iterate through the vector layer iter = layer.getFeatures() for feature in iter: waypointElem = gpxDoc.createElementNS( "http://www.topografix.com/GPX/1/1", "wpt") geom = feature.geometry() geom.transform(coordTransform) pointGeom = geom.asPoint() waypointElem.setAttribute("lon", str(pointGeom.x())) waypointElem.setAttribute("lat", str(pointGeom.y())) encodedNameAttribute = feature.attribute(nameAttribute) if isinstance(encodedNameAttribute, unicode): encodedNameAttribute = encodedNameAttribute.encode("UTF-8") nameElem = gpxDoc.createElementNS("http://www.topografix.com/GPX/1/1", "name") nameText = gpxDoc.createTextNode(str(encodedNameAttribute)) nameElem.appendChild(nameText) waypointElem.appendChild(nameElem) if len(commentAttribute) > 0: commentElem = gpxDoc.createElementNS( "http://www.topografix.com/GPX/1/1", "cmt") commentText = gpxDoc.createTextNode( str(feature.attribute(commentAttribute))) commentElem.appendChild(commentText) waypointElem.appendChild(commentElem) gpxElem.appendChild(waypointElem) #save gpx document outStream = QTextStream(outputFile) gpxDoc.save(outStream, 2)
def qgis_style(self): """Returns the current style, as a QDomDocument""" from PyQt5.QtXml import QDomDocument from qgis.core import QgsReadWriteContext doc = QDomDocument() elt = self.__renderer.save(doc, QgsReadWriteContext()) doc.appendChild(elt) return (doc, self.__render_type)
def get_layer_symbology(layer): doc = QDomDocument(QDomImplementation().createDocumentType("qgis", "http://mrcc.com/qgis.dtd", "SYSTEM")) rootNode = doc.createElement("qgis") doc.appendChild(rootNode) errorMsg = '' ctx = QgsReadWriteContext() layer.writeSymbology(rootNode, doc, errorMsg, ctx) return doc.toByteArray()
def _write_history_file(self, date_str, snapshot_name='', rewind_snapshot=''): if not self.session.path: return ray.Err.NO_SESSION_OPEN file_path = self._get_history_full_path() xml = QDomDocument() try: history_file = open(file_path, 'r') xml.setContent(history_file.read()) history_file.close() except: pass if xml.firstChild().isNull(): SNS_xml = xml.createElement('SNAPSHOTS') xml.appendChild(SNS_xml) else: SNS_xml = xml.firstChild() snapshot_el = xml.createElement('Snapshot') snapshot_el.setAttribute('ref', date_str) snapshot_el.setAttribute('name', snapshot_name) snapshot_el.setAttribute('rewind_snapshot', rewind_snapshot) snapshot_el.setAttribute('session_name', self.session.name) snapshot_el.setAttribute('VERSION', ray.VERSION) for client in self.session.clients + self.session.trashed_clients: client_el = xml.createElement('client') client.write_xml_properties(client_el) client_el.setAttribute('client_id', client.client_id) for client_file_path in client.get_project_files(): base_path = client_file_path.replace("%s/" % self.session.path, '', 1) file_xml = xml.createElement('file') file_xml.setAttribute('path', base_path) client_el.appendChild(file_xml) snapshot_el.appendChild(client_el) SNS_xml.appendChild(snapshot_el) try: history_file = open(file_path, 'w') history_file.write(xml.toString()) history_file.close() except: return ray.Err.CREATE_FAILED return ray.Err.OK
def save(self): name = QFileDialog.getSaveFileName(self, 'Save File')[0] if name: doc = QDomDocument() formatter = XmlFormat(doc) doc.appendChild(formatter.projectToXml(self)) saveFile = open(name,'w') saveFile.write(doc.toString()) saveFile.close() self.unsavedChanges = False self.setWindowTitle("playbook - {}".format(self.projectName))
def on_pushButton_item_clicked(self): text = self.lineEdit_item.text() # 如果这个项目已经存在就不再添加 items = self.listWidget_item.findItems(text, Qt.MatchContains) if len(items): return self.listWidget_item.addItem(text) n = QDomDocument().createElement("item") domtext = QDomDocument().createTextNode(text) n.appendChild(domtext) self.element.appendChild(n) self.itemlist.append(n)
def on_lineEdit_subfix_textEdited(self, p_str): if self.element.firstChildElement("subfix").isNull(): n = QDomDocument().createElement("subfix") text = QDomDocument().createTextNode(p_str) n.appendChild(text) self.element.appendChild(n) elif self.element.firstChildElement("subfix").firstChild().isNull(): self.element.firstChildElement("subfix").appendChild( QDomDocument().createTextNode(p_str)) else: self.element.firstChildElement("subfix").firstChild().setNodeValue( p_str) self.edited.emit()
def toXml(self, obj_, includeChildren=True, includeComplexTypes=False): xml_ = QDomDocument() if not obj_: return xml_ e = xml_.createElement(type(obj_).__name__) e.setAttribute("class", type(obj_).__name__) xml_.appendChild(e) _meta = obj_.metaObject() num = _meta.propertyCount() i = 0 _p_properties = [] while i < num: mp = _meta.property(i) if mp.name() in _p_properties: i += 1 continue _p_properties.append(mp.name()) val = getattr(obj_, mp.name(), None) try: val = val() except: pass if val is None: i += 1 continue val = str(val) if not val and not includeComplexTypes: i += 1 continue e.setAttribute(mp.name(), val) i += 1 if includeChildren == True: for child in obj_.children(): itd = self.toXml(child, includeChildren, includeComplexTypes) xml_.firstChild().appendChild(itd.firstChild()) return xml_
def saveFile(): if not file_path: return for connection in connection_list: if not connection in saved_connections: saved_connections.append(connection) delete_list = [] # delete connection of the saved_connections # if its two ports are still presents and not connected for i in range(len(saved_connections)): if (portExists(saved_connections[i][0], PORT_MODE_OUTPUT) and portExists(saved_connections[i][1], PORT_MODE_INPUT)): if not saved_connections[i] in connection_list: delete_list.append(i) delete_list.reverse() for i in delete_list: saved_connections.__delitem__(i) try: file = open(file_path, 'w') except: sys.stderr.write('unable to write file %s\n' % file_path) app.quit() return xml = QDomDocument() p = xml.createElement('RAY-JACKPATCH') for con in saved_connections: ct = xml.createElement('connection') ct.setAttribute('from', con[0]) ct.setAttribute('to', con[1]) p.appendChild(ct) xml.appendChild(p) file.write(xml.toString()) file.close() NSMServer.saveReply() setDirtyClean()
def installACL(self, idacl): """ Crea un nuevo fichero "acl.xml" y lo almacena sustituyendo el anterior, en el caso de que exista. @param idacl Identificador del registro de la tabla "flacls" a utilizar para crear "acl.xml". """ util = FLUtil() doc = QDomDocument("ACL") root = doc.createElement("ACL") doc.appendChild(root) name = doc.createElement("name") root.appendChild(name) n = doc.createTextNode(idacl) name.appendChild(n) q = FLSqlQuery() q.setTablesList("flacs") q.setSelect("idac,tipo,nombre,iduser,idgroup,degroup,permiso") q.setFrom("flacs") q.setWhere("idacl='%s'" % idacl) q.setOrderBy("prioridad DESC, tipo") q.setForwarOnly(True) if q.exec_(): step = 0 progress = util.ProgressDialog( util.tr("Instalando control de acceso..."), None, q.size(), None, None, True) progress.setCaption(util.tr("Instalando ACL")) progress.setMinimumDuration(0) progress.setProgress(++step) while q.next(): self.makeRule(q, doc) progress.setProgress(++step) self.database().managerModules().setContent( "acl.xml", "sys", doc.toString())
def _get_xml(self): xml = QDomDocument() file_exists = False if os.path.exists(self._bookmarks_memory): try: file = open(self._bookmarks_memory, 'r') xml.setContent(file.read()) file_exists = True except: try: os.path.remove(self._bookmarks_memory) except: return None if not file_exists: bms_xml = xml.createElement('Bookmarks') xml.appendChild(bms_xml) return xml
def installACL(self, idacl): """ Crea un nuevo fichero "acl.xml" y lo almacena sustituyendo el anterior, en el caso de que exista. @param idacl Identificador del registro de la tabla "flacls" a utilizar para crear "acl.xml". """ util = FLUtil() doc = QDomDocument("ACL") root = doc.createElement("ACL") doc.appendChild(root) name = doc.createElement("name") root.appendChild(name) n = doc.createTextNode(idacl) name.appendChild(n) q = FLSqlQuery() q.setTablesList("flacs") q.setSelect("idac,tipo,nombre,iduser,idgroup,degroup,permiso") q.setFrom("flacs") q.setWhere("idacl='%s'" % idacl) q.setOrderBy("prioridad DESC, tipo") q.setForwarOnly(True) if q.exec_(): step = 0 progress = util.ProgressDialog( util.tr("Instalando control de acceso..."), None, q.size(), None, None, True) progress.setCaption(util.tr("Instalando ACL")) progress.setMinimumDuration(0) progress.setProgress(++step) while q.next(): self.makeRule(q, doc) progress.setProgress(++step) from pineboolib.pnconrolsfactory import aqApp aqApp.db().managerModules().setContent("acl.xml", "sys", doc.toString())
def updateRasterToken(self, layer, uri): """ http://gis.stackexchange.com/questions/62610/changing-data-source-of-layer-in-qgis """ XMLDocument = QDomDocument("style") XMLMapLayers = QDomElement() XMLMapLayers = XMLDocument.createElement("maplayers") XMLMapLayer = QDomElement() XMLMapLayer = XMLDocument.createElement("maplayer") layer.writeLayerXML(XMLMapLayer,XMLDocument) # modify DOM element with new layer reference XMLMapLayer.firstChildElement("datasource").firstChild().setNodeValue( uri ) XMLMapLayers.appendChild(XMLMapLayer) XMLDocument.appendChild(XMLMapLayers) # reload layer definition layer.readLayerXML(XMLMapLayer) layer.reload() # apply to canvas and legend self.iface.actionDraw().trigger() self.iface.legendInterface().refreshLayerSymbology(layer)
class GrapholExporter(AbstractExporter): """ This class can be used to export Graphol diagrams to file. """ def __init__(self, scene): """ Initialize the Graphol exporter. :type scene: DiagramScene """ super().__init__(scene) self.document = None self.itemToXml = { Item.AttributeNode: 'attribute', Item.ComplementNode: 'complement', Item.ConceptNode: 'concept', Item.DatatypeRestrictionNode: 'datatype-restriction', Item.DisjointUnionNode: 'disjoint-union', Item.DomainRestrictionNode: 'domain-restriction', Item.EnumerationNode: 'enumeration', Item.IndividualNode: 'individual', Item.IntersectionNode: 'intersection', Item.PropertyAssertionNode: 'property-assertion', Item.RangeRestrictionNode: 'range-restriction', Item.RoleNode: 'role', Item.RoleChainNode: 'role-chain', Item.RoleInverseNode: 'role-inverse', Item.UnionNode: 'union', Item.ValueDomainNode: 'value-domain', Item.ValueRestrictionNode: 'value-restriction', Item.InclusionEdge: 'inclusion', Item.InputEdge: 'input', Item.InstanceOfEdge: 'instance-of', } #################################################################################################################### # # # NODES # # # #################################################################################################################### def exportAttributeNode(self, node): """ Export the given node into a QDomElement. :type node: AttributeNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportComplementNode(self, node): """ Export the given node into a QDomElement. :type node: ComplementNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportConceptNode(self, node): """ Export the given node into a QDomElement. :type node: ConceptNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportDatatypeRestrictionNode(self, node): """ Export the given node into a QDomElement. :type node: DatatypeRestrictionNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportDisjointUnionNode(self, node): """ Export the given node into a QDomElement. :type node: DisjointUnionNode :rtype: QDomElement """ return self.exportGenericNode(node) def exportDomainRestrictionNode(self, node): """ Export the given node into a QDomElement. :type node: DomainRestrictionNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportEnumerationNode(self, node): """ Export the given node into a QDomElement. :type node: EnumerationNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportIndividualNode(self, node): """ Export the given node into a QDomElement. :type node: IndividualNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportIntersectionNode(self, node): """ Export the given node into a QDomElement. :type node: IntersectionNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportPropertyAssertionNode(self, node): """ Export the given node into a QDomElement. :type node: PropertyAssertionNode :rtype: QDomElement """ element = self.exportGenericNode(node) element.setAttribute('inputs', ','.join(node.inputs)) return element def exportRangeRestrictionNode(self, node): """ Export the given node into a QDomElement. :type node: RangeRestrictionNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportRoleNode(self, node): """ Export the given node into a QDomElement. :type node: RoleNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportRoleChainNode(self, node): """ Export the given node into a QDomElement. :type node: RoleChainNode :rtype: QDomElement """ element = self.exportLabelNode(node) element.setAttribute('inputs', ','.join(node.inputs)) return element def exportRoleInverseNode(self, node): """ Export the given node into a QDomElement. :type node: RoleInverseNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportValueDomainNode(self, node): """ Export the given node into a QDomElement. :type node: ValueDomainNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportUnionNode(self, node): """ Export the given node into a QDomElement. :type node: UnionNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportValueRestrictionNode(self, node): """ Export the given node into a QDomElement. :type node: ValueRestrictionNode :rtype: QDomElement """ return self.exportLabelNode(node) #################################################################################################################### # # # EDGES # # # #################################################################################################################### def exportInclusionEdge(self, edge): """ Export the given edge into a QDomElement. :type edge: InclusionEdge :rtype: QDomElement """ element = self.exportGenericEdge(edge) element.setAttribute('complete', int(edge.complete)) return element def exportInputEdge(self, edge): """ Export the given edge into a QDomElement. :type edge: InputEdge :rtype: QDomElement """ return self.exportGenericEdge(edge) def exportInstanceOfEdge(self, edge): """ Export the given edge into a QDomElement. :type edge: InstanceOf :rtype: QDomElement """ return self.exportGenericEdge(edge) #################################################################################################################### # # # METADATA # # # #################################################################################################################### def exportPredicateMetadata(self, item, predicate): """ Export given predicate metadata. :type item: Item :type predicate: str :rtype: QDomElement """ meta = self.scene.meta.metaFor(item, predicate) if meta: element = self.document.createElement('meta') element.setAttribute('type', self.itemToXml[item]) element.setAttribute('predicate', predicate) url = self.document.createElement('data:url') url.appendChild(self.document.createTextNode(meta.url)) description = self.document.createElement('data:description') description.appendChild( self.document.createTextNode(meta.description)) element.appendChild(url) element.appendChild(description) return element return None def exportAttributeMetadata(self, item, predicate): """ Export given attribute metadata. :type item: Item :type predicate: str :rtype: QDomElement """ element = self.exportPredicateMetadata(item, predicate) if element: meta = self.scene.meta.metaFor(item, predicate) if meta: functionality = self.document.createElement( 'data:functionality') functionality.appendChild( self.document.createTextNode(str(int(meta.functionality)))) element.appendChild(functionality) return element return None def exportRoleMetadata(self, item, predicate): """ Export given role metadata :type item: Item :type predicate: str :rtype: QDomElement """ element = self.exportPredicateMetadata(item, predicate) if element: meta = self.scene.meta.metaFor(item, predicate) if meta: functionality = self.document.createElement( 'data:functionality') functionality.appendChild( self.document.createTextNode(str(int(meta.functionality)))) inverseFunctionality = self.document.createElement( 'data:inverseFunctionality') inverseFunctionality.appendChild( self.document.createTextNode( str(int(meta.inverseFunctionality)))) asymmetry = self.document.createElement('data:asymmetry') asymmetry.appendChild( self.document.createTextNode(str(int(meta.asymmetry)))) irreflexivity = self.document.createElement( 'data:irreflexivity') irreflexivity.appendChild( self.document.createTextNode(str(int(meta.irreflexivity)))) reflexivity = self.document.createElement('data:reflexivity') reflexivity.appendChild( self.document.createTextNode(str(int(meta.reflexivity)))) symmetry = self.document.createElement('data:symmetry') symmetry.appendChild( self.document.createTextNode(str(int(meta.symmetry)))) transitivity = self.document.createElement('data:transitivity') transitivity.appendChild( self.document.createTextNode(str(int(meta.transitivity)))) element.appendChild(functionality) element.appendChild(inverseFunctionality) element.appendChild(asymmetry) element.appendChild(irreflexivity) element.appendChild(reflexivity) element.appendChild(symmetry) element.appendChild(transitivity) return element return None #################################################################################################################### # # # AUXILIARY METHODS # # # #################################################################################################################### def exportLabelNode(self, node): """ Export the given node into a QDomElement. :type node: AbstractNode :rtype: QDomElement """ position = node.mapToScene(node.textPos()) label = self.document.createElement('shape:label') label.setAttribute('height', node.label.height()) label.setAttribute('width', node.label.width()) label.setAttribute('x', position.x()) label.setAttribute('y', position.y()) label.appendChild(self.document.createTextNode(node.text())) element = self.exportGenericNode(node) element.appendChild(label) return element def exportGenericEdge(self, edge): """ Export the given node into a QDomElement. :type edge: AbstractEdge :rtype: QDomElement """ element = self.document.createElement('edge') element.setAttribute('source', edge.source.id) element.setAttribute('target', edge.target.id) element.setAttribute('id', edge.id) element.setAttribute('type', self.itemToXml[edge.item]) for p in [edge.source.anchor(edge) ] + edge.breakpoints + [edge.target.anchor(edge)]: point = self.document.createElement('line:point') point.setAttribute('x', p.x()) point.setAttribute('y', p.y()) element.appendChild(point) return element def exportGenericNode(self, node): """ Export the given node into a QDomElement. :type node: AbstractNode :rtype: QDomElement """ element = self.document.createElement('node') element.setAttribute('id', node.id) element.setAttribute('type', self.itemToXml[node.item]) element.setAttribute('color', node.brush.color().name()) geometry = self.document.createElement('shape:geometry') geometry.setAttribute('height', node.height()) geometry.setAttribute('width', node.width()) geometry.setAttribute('x', node.pos().x()) geometry.setAttribute('y', node.pos().y()) element.appendChild(geometry) return element #################################################################################################################### # # # DOCUMENT EXPORT # # # #################################################################################################################### def export(self, indent=4): """ Export the coverted ontology. :type indent: int :rtype: str """ return self.document.toString(indent) #################################################################################################################### # # # DOCUMENT GENERATION # # # #################################################################################################################### def run(self): """ Perform Graphol ontology generation. """ # 1) CREATE THE DOCUMENT self.document = QDomDocument() self.document.appendChild( self.document.createProcessingInstruction( 'xml', 'version="1.0" ' 'encoding="UTF-8" ' 'standalone="no"')) # 2) CREATE ROOT ELEMENT root = self.document.createElement('graphol') root.setAttribute('xmlns', 'http://www.dis.uniroma1.it/~graphol/schema') root.setAttribute('xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance') root.setAttribute('xmlns:data', 'http://www.dis.uniroma1.it/~graphol/schema/data') root.setAttribute('xmlns:line', 'http://www.dis.uniroma1.it/~graphol/schema/line') root.setAttribute('xmlns:shape', 'http://www.dis.uniroma1.it/~graphol/schema/shape') root.setAttribute( 'xsi:schemaLocation', 'http://www.dis.uniroma1.it/~graphol/schema ' 'http://www.dis.uniroma1.it/~graphol/schema/graphol.xsd') self.document.appendChild(root) # 3) CREATE THE GRAPH NODE graph = self.document.createElement('graph') graph.setAttribute('width', self.scene.sceneRect().width()) graph.setAttribute('height', self.scene.sceneRect().height()) # 4) GENERATE NODES for node in self.scene.nodes(): element = None if node.item is Item.AttributeNode: element = self.exportAttributeNode(node) elif node.item is Item.ComplementNode: element = self.exportComplementNode(node) elif node.item is Item.ConceptNode: element = self.exportConceptNode(node) elif node.item is Item.DatatypeRestrictionNode: element = self.exportDatatypeRestrictionNode(node) elif node.item is Item.DisjointUnionNode: element = self.exportDisjointUnionNode(node) elif node.item is Item.DomainRestrictionNode: element = self.exportDomainRestrictionNode(node) elif node.item is Item.EnumerationNode: element = self.exportEnumerationNode(node) elif node.item is Item.IndividualNode: element = self.exportIndividualNode(node) elif node.item is Item.IntersectionNode: element = self.exportIntersectionNode(node) elif node.item is Item.PropertyAssertionNode: element = self.exportPropertyAssertionNode(node) elif node.item is Item.RangeRestrictionNode: element = self.exportRangeRestrictionNode(node) elif node.item is Item.RoleNode: element = self.exportRoleNode(node) elif node.item is Item.RoleChainNode: element = self.exportRoleChainNode(node) elif node.item is Item.RoleInverseNode: element = self.exportRoleInverseNode(node) elif node.item is Item.UnionNode: element = self.exportUnionNode(node) elif node.item is Item.ValueDomainNode: element = self.exportValueDomainNode(node) elif node.item is Item.ValueRestrictionNode: element = self.exportValueRestrictionNode(node) if not element: raise ValueError('unknown node: {}'.format(node)) graph.appendChild(element) # 5) GENERATE EDGES for edge in self.scene.edges(): element = None if edge.item is Item.InclusionEdge: element = self.exportInclusionEdge(edge) elif edge.item is Item.InputEdge: element = self.exportInputEdge(edge) elif edge.item is Item.InstanceOfEdge: element = self.exportInstanceOfEdge(edge) if not element: raise ValueError('unknown edge: {}'.format(edge)) graph.appendChild(element) # 6) APPEND THE GRAPH TO THE DOCUMENT root.appendChild(graph) # 7) GENERATE NODES META DATA collection = [] for item, predicate in self.scene.meta.entries(): if item is Item.RoleNode: element = self.exportRoleMetadata(item, predicate) elif item is Item.AttributeNode: element = self.exportAttributeMetadata(item, predicate) else: element = self.exportPredicateMetadata(item, predicate) if element: collection.append(element) if collection: metadata = self.document.createElement('metadata') for element in collection: metadata.appendChild(element) root.appendChild(metadata)
class MultiDaemonFile: file_path = '/tmp/RaySession/multi-daemon.xml' def __init__(self, session, server): self.session = session self.server = server self.xml = QDomDocument() global instance instance = self @staticmethod def getInstance(): return instance def pidExists(self, pid): if isinstance(pid, str): pid = int(pid) try: os.kill(pid, 0) except OSError: return False else: return True def removeFile(self): try: os.remove(self.file_path) except: return def openFile(self): if not os.path.exists(self.file_path): if not os.path.exists(os.path.dirname(self.file_path)): os.makedirs(os.path.dirname(self.file_path)) return False try: file = open(self.file_path, 'r') self.xml.setContent(file.read()) file.close() return True except: self.removeFile() return False def writeFile(self): try: file = open(self.file_path, 'w') file.write(self.xml.toString()) file.close() except: return def setAttributes(self, element): element.setAttribute('net_daemon_id', self.server.net_daemon_id) element.setAttribute('root', self.session.root) element.setAttribute('session_path', self.session.path) element.setAttribute('pid', os.getpid()) element.setAttribute('port', self.server.port) element.setAttribute('user', os.getenv('USER')) element.setAttribute( 'not_default', int(bool(self.server.is_nsm_locked or self.server.not_default))) element.setAttribute('has_gui', int(self.server.hasGui())) element.setAttribute('version', ray.VERSION) def update(self): has_dirty_pid = False if not self.openFile(): ds = self.xml.createElement('Daemons') dm_xml = self.xml.createElement('Daemon') self.setAttributes(dm_xml) ds.appendChild(dm_xml) self.xml.appendChild(ds) else: found = False xml_content = self.xml.documentElement() nodes = xml_content.childNodes() for i in range(nodes.count()): node = nodes.at(i) dxe = node.toElement() pid = dxe.attribute('pid') if pid.isdigit() and pid == str(os.getpid()): self.setAttributes(dxe) found = True elif not pid.isdigit() or not self.pidExists(int(pid)): has_dirty_pid = True if not found: dm_xml = self.xml.createElement('Daemon') self.setAttributes(dm_xml) self.xml.firstChild().appendChild(dm_xml) if has_dirty_pid: self.cleanDirtyPids() self.writeFile() def quit(self): if not self.openFile(): return xml_content = self.xml.documentElement() nodes = xml_content.childNodes() for i in range(nodes.count()): node = nodes.at(i) dxe = node.toElement() pid = dxe.attribute('pid') if pid.isdigit() and pid == str(os.getpid()): break else: return xml_content.removeChild(node) self.writeFile() def isFreeForRoot(self, daemon_id, root_path): if not self.openFile(): return True xml_content = self.xml.documentElement() nodes = xml_content.childNodes() for i in range(nodes.count()): node = nodes.at(i) dxe = node.toElement() if (dxe.attribute('net_daemon_id') == str(daemon_id) and dxe.attribute('root') == root_path): pid = dxe.attribute('pid') if pid.isdigit() and self.pidExists(int(pid)): return False return True def isFreeForSession(self, session_path): if not self.openFile(): return True xml_content = self.xml.documentElement() nodes = xml_content.childNodes() for i in range(nodes.count()): node = nodes.at(i) dxe = node.toElement() if dxe.attribute('session_path') == session_path: pid = dxe.attribute('pid') if pid.isdigit() and self.pidExists(int(pid)): return False return True def getAllSessionPaths(self): if not self.openFile(): return [] all_session_paths = [] xml_content = self.xml.documentElement() nodes = xml_content.childNodes() for i in range(nodes.count()): node = nodes.at(i) dxe = node.toElement() spath = dxe.attribute('session_path') pid = dxe.attribute('pid') if spath and pid.isdigit() and self.pidExists(int(pid)): all_session_paths.append(spath) return all_session_paths def cleanDirtyPids(self): xml_content = self.xml.documentElement() nodes = xml_content.childNodes() rm_nodes = [] for i in range(nodes.count()): node = nodes.at(i) dxe = node.toElement() pid = dxe.attribute('pid') if not pid.isdigit() or not self.pidExists(int(pid)): rm_nodes.append(node) for node in rm_nodes: xml_content.removeChild(node) def getDaemonList(self): daemon_list = [] has_dirty_pid = False if not self.openFile(): return daemon_list xml_content = self.xml.documentElement() nodes = xml_content.childNodes() for i in range(nodes.count()): node = nodes.at(i) dxe = node.toElement() daemon = Daemon() daemon.root = dxe.attribute('root') daemon.session_path = dxe.attribute('session_path') daemon.user = dxe.attribute('user') daemon.not_default = bool(dxe.attribute('not_default') == 'true') net_daemon_id = dxe.attribute('net_daemon_id') pid = dxe.attribute('pid') port = dxe.attribute('port') if net_daemon_id.isdigit(): daemon.net_daemon_id = net_daemon_id if pid.isdigit(): daemon.pid = pid if port.isdigit(): daemon.port = port if not self.pidExists(daemon.pid): has_dirty_pid = True continue if not (daemon.net_daemon_id and daemon.pid and daemon.port): continue daemon_list.append(daemon) if has_dirty_pid: self.cleanDirtyPids() return daemon_list
def writeOutputFile(self, rasterLayer, outputFile, pointDistance, maxValueTolerance, startPoint, endPoint): resultXmlDocument = QDomDocument() encodingInstruction = resultXmlDocument.createProcessingInstruction( "encoding", "UTF-8") resultXmlDocument.appendChild(encodingInstruction) documentElement = resultXmlDocument.createElement("VFPData") resultXmlDocument.appendChild(documentElement) #profile length profileTotalDx = endPoint.x() - startPoint.x() profileTotalDy = endPoint.y() - startPoint.y() profileLength = math.sqrt(profileTotalDx * profileTotalDx + profileTotalDy * profileTotalDy) #single step dx = profileTotalDx / profileLength * pointDistance dy = profileTotalDy / profileLength * pointDistance dist = 0.0 lastDist = 0.0 currentValue = 0.0 sumDz = 0.0 #Just to check if sum(dz) equals (z - z_start) firstZ = self.firstRasterBandValue(startPoint, rasterLayer) if firstZ is None: #makes only sense if initial z is set QMessageBox.critical( None, QCoreApplication.translate("ProfileExportPlugin", "First z value invalid"), QCoreApplication.translate( "ProfileExportPlugin", "The first z-Value of the profile is invalid. Please make sure the profile start point is on the elevation model" )) return lastValue = firstZ currentX = startPoint.x() currentY = startPoint.y() while dist < profileLength: currentValue = self.firstRasterBandValue( QgsPointXY(currentX, currentY), rasterLayer) #elevation tolerance between two points exceeded. Insert additional points if not currentValue is None and not lastValue is None and ( currentValue - lastValue) > maxValueTolerance: nIntermediatePoints = int( (currentValue - lastValue) / maxValueTolerance) dIntermediatePointDist = math.sqrt( (dx / (nIntermediatePoints + 1)) * (dx / (nIntermediatePoints + 1)) + (dy / (nIntermediatePoints + 1)) * (dy / (nIntermediatePoints + 1))) lastIntermediateValue = lastValue for i in range(nIntermediatePoints): #print 'inserting additional point' dxIntermediate = dx / (nIntermediatePoints + 1) * (i + 1) dyIntermediate = dy / (nIntermediatePoints + 1) * (i + 1) xIntermediate = currentX - dx + dxIntermediate yIntermediate = currentY - dy + dyIntermediate intermediateDist = math.sqrt( dxIntermediate * dxIntermediate + dyIntermediate * dyIntermediate) currentIntermediateValue = self.firstRasterBandValue( QgsPointXY(xIntermediate, yIntermediate), rasterLayer) if not currentIntermediateValue is None and not lastValue is None: self.addElevationPoint( resultXmlDocument, documentElement, dist - pointDistance + intermediateDist, dIntermediatePointDist, currentIntermediateValue - lastValue, currentIntermediateValue - firstZ, xIntermediate, yIntermediate) sumDz = sumDz + (currentIntermediateValue - lastValue) lastValue = currentIntermediateValue lastDist = dist - pointDistance + intermediateDist if not currentValue is None and not lastValue is None: self.addElevationPoint(resultXmlDocument, documentElement, dist, dist - lastDist, currentValue - lastValue, currentValue - firstZ, currentX, currentY) sumDz = sumDz + currentValue - lastValue currentX += dx currentY += dy lastDist = dist dist += pointDistance lastValue = currentValue #last value normally does not fit into the point interval if currentX != endPoint.x() or currentY != entPoint.y(): currentValue = self.firstRasterBandValue(endPoint, rasterLayer) if not currentValue is None: self.addElevationPoint(resultXmlDocument, documentElement, profileLength, pointDistance - (dist - profileLength), currentValue - lastValue, currentValue - firstZ, endPoint.x(), endPoint.y()) sumDz = sumDz + currentValue - lastValue #debug #print( 'sumDz: {}'.format( sumDz ) ) #print( 'z0 : {}'.format( currentValue - firstZ ) ) #write dom document to file resultXmlFile = QFile(outputFile) if not resultXmlFile.open(QIODevice.WriteOnly): QMessageBox.critical( None, QCoreApplication.translate("ProfileExportPlugin", "Error"), QCoreApplication.translate( "ProfileExportPlugin", "The output file could not be written to disk")) return resultTextStream = QTextStream(resultXmlFile) resultTextStream.setCodec("UTF-8") resultTextStream.__lshift__(resultXmlDocument.toString()) resultXmlFile.close() if abs(sumDz - (currentValue - firstZ)) > 0.000001: QMessageBox.critical( None, QCoreApplication.translate("ProfileExportPlugin", "Error"), QCoreApplication.translate( "ProfileExportPlugin", "An error occured during checking the written elevation values. The values might not be correct" )) else: QMessageBox.information( None, QCoreApplication.translate("ProfileExportPlugin", "Export finished"), QCoreApplication.translate( "ProfileExportPlugin", "The profile export is successfully finished"))
def write_xml(configDictionary={}, pageData=[], pagesLocationList=[], locationBasic=str(), locationStandAlone=str(), projectUrl=str()): acbfGenreList = [ "science_fiction", "fantasy", "adventure", "horror", "mystery", "crime", "military", "real_life", "superhero", "humor", "western", "manga", "politics", "caricature", "sports", "history", "biography", "education", "computer", "religion", "romance", "children", "non-fiction", "adult", "alternative", "other", "artbook" ] acbfAuthorRolesList = [ "Writer", "Adapter", "Artist", "Penciller", "Inker", "Colorist", "Letterer", "Cover Artist", "Photographer", "Editor", "Assistant Editor", "Translator", "Other", "Designer" ] document = QDomDocument() root = document.createElement("ACBF") root.setAttribute("xmlns", "http://www.acbf.info/xml/acbf/1.1") document.appendChild(root) emphasisStyle = {} strongStyle = {} if "acbfStyles" in configDictionary.keys(): stylesDictionary = configDictionary.get("acbfStyles", {}) emphasisStyle = stylesDictionary.get("emphasis", {}) strongStyle = stylesDictionary.get("strong", {}) styleString = "\n" tabs = " " for key in sorted(stylesDictionary.keys()): style = stylesDictionary.get(key, {}) if key == "emphasis" or key == "strong": styleClass = key + " {\n" elif key == "speech": styleClass = "text-area {\n" elif key == "general": styleClass = "* {\n" elif key == "inverted": styleClass = "text-area[inverted=\"true\"] {\n" else: styleClass = "text-area[type=\"" + key + "\"] {\n" styleString += tabs + styleClass if "color" in style.keys(): styleString += tabs + tabs + "color:" + style["color"] + ";\n" if "font" in style.keys(): fonts = style["font"] genericfont = style.get("genericfont", "sans-serif") if isinstance(fonts, list): styleString += tabs + tabs + "font-family:\"" + str( "\", \"").join(fonts) + "\", " + genericfont + ";\n" else: styleString += tabs + tabs + "font-family:\"" + fonts + "\", " + genericfont + ";\n" if "bold" in style.keys(): if style["bold"]: styleString += tabs + tabs + "font-weight: bold;\n" if "ital" in style.keys(): if style["ital"]: styleString += tabs + tabs + "font-style: italic;\n" else: styleString += tabs + tabs + "font-style: normal;\n" styleString += tabs + "}\n" style = document.createElement("style") style.setAttribute("type", "text/css") style.appendChild(document.createTextNode(styleString)) root.appendChild(style) meta = document.createElement("meta-data") translationFolder = configDictionary.get("translationLocation", "translations") fullTranslationPath = os.path.join(projectUrl, translationFolder) poParser = po_parser.po_file_parser(fullTranslationPath, True) bookInfo = document.createElement("book-info") if "authorList" in configDictionary.keys(): for authorE in range(len(configDictionary["authorList"])): author = document.createElement("author") authorDict = configDictionary["authorList"][authorE] if "first-name" in authorDict.keys(): authorN = document.createElement("first-name") authorN.appendChild( document.createTextNode(str(authorDict["first-name"]))) author.appendChild(authorN) if "last-name" in authorDict.keys(): authorN = document.createElement("last-name") authorN.appendChild( document.createTextNode(str(authorDict["last-name"]))) author.appendChild(authorN) if "initials" in authorDict.keys(): authorN = document.createElement("middle-name") authorN.appendChild( document.createTextNode(str(authorDict["initials"]))) author.appendChild(authorN) if "nickname" in authorDict.keys(): authorN = document.createElement("nickname") authorN.appendChild( document.createTextNode(str(authorDict["nickname"]))) author.appendChild(authorN) if "homepage" in authorDict.keys(): authorN = document.createElement("home-page") authorN.appendChild( document.createTextNode(str(authorDict["homepage"]))) author.appendChild(authorN) if "email" in authorDict.keys(): authorN = document.createElement("email") authorN.appendChild( document.createTextNode(str(authorDict["email"]))) author.appendChild(authorN) if "role" in authorDict.keys(): if str(authorDict["role"]).title() in acbfAuthorRolesList: author.setAttribute("activity", str(authorDict["role"])) if "language" in authorDict.keys(): author.setAttribute( "lang", str(authorDict["language"]).replace("_", "-")) bookInfo.appendChild(author) bookTitle = document.createElement("book-title") if "title" in configDictionary.keys(): bookTitle.appendChild( document.createTextNode(str(configDictionary["title"]))) else: bookTitle.appendChild( document.createTextNode(str("Comic with no Name"))) bookInfo.appendChild(bookTitle) extraGenres = [] if "genre" in configDictionary.keys(): genreListConf = configDictionary["genre"] if isinstance(configDictionary["genre"], dict): genreListConf = configDictionary["genre"].keys() for genre in genreListConf: genreModified = str(genre).lower() genreModified.replace(" ", "_") if genreModified in acbfGenreList: bookGenre = document.createElement("genre") bookGenre.appendChild( document.createTextNode(str(genreModified))) if isinstance(configDictionary["genre"], dict): genreMatch = configDictionary["genre"][genreModified] if genreMatch > 0: bookGenre.setAttribute("match", str(genreMatch)) bookInfo.appendChild(bookGenre) else: extraGenres.append(genre) if "characters" in configDictionary.keys(): character = document.createElement("characters") for name in configDictionary["characters"]: char = document.createElement("name") char.appendChild(document.createTextNode(str(name))) character.appendChild(char) bookInfo.appendChild(character) annotation = document.createElement("annotation") if "summary" in configDictionary.keys(): paragraphList = str(configDictionary["summary"]).split("\n") for para in paragraphList: p = document.createElement("p") p.appendChild(document.createTextNode(str(para))) annotation.appendChild(p) else: p = document.createElement("p") p.appendChild( document.createTextNode( str("There was no summary upon generation of this file."))) annotation.appendChild(p) bookInfo.appendChild(annotation) keywords = document.createElement("keywords") stringKeywordsList = [] for key in extraGenres: stringKeywordsList.append(str(key)) if "otherKeywords" in configDictionary.keys(): for key in configDictionary["otherKeywords"]: stringKeywordsList.append(str(key)) if "format" in configDictionary.keys(): for key in configDictionary["format"]: stringKeywordsList.append(str(key)) keywords.appendChild(document.createTextNode( ", ".join(stringKeywordsList))) bookInfo.appendChild(keywords) coverpageurl = "" coverpage = document.createElement("coverpage") if "pages" in configDictionary.keys(): if "cover" in configDictionary.keys(): pageList = [] pageList = configDictionary["pages"] coverNumber = max([pageList.index(configDictionary["cover"]), 0]) image = document.createElement("image") if len(pagesLocationList) >= coverNumber: coverpageurl = pagesLocationList[coverNumber] image.setAttribute("href", os.path.basename(coverpageurl)) coverpage.appendChild(image) bookInfo.appendChild(coverpage) if "language" in configDictionary.keys(): language = document.createElement("languages") textlayer = document.createElement("text-layer") textlayer.setAttribute( "lang", str(configDictionary["language"]).replace("_", "-")) textlayer.setAttribute("show", "false") textlayerNative = document.createElement("text-layer") textlayerNative.setAttribute( "lang", str(configDictionary["language"]).replace("_", "-")) textlayerNative.setAttribute("show", "true") language.appendChild(textlayer) language.appendChild(textlayerNative) translationComments = {} for lang in poParser.get_translation_list(): textlayer = document.createElement("text-layer") textlayer.setAttribute("lang", lang) textlayer.setAttribute("show", "true") language.appendChild(textlayer) translationComments[lang] = [] translation = poParser.get_entry_for_key( "@meta-title " + configDictionary["title"], lang).get("trans", None) if translation is not None: bookTitleTr = document.createElement("book-title") bookTitleTr.setAttribute("lang", lang) bookTitleTr.appendChild(document.createTextNode(translation)) bookInfo.insertAfter(bookTitleTr, bookTitle) translation = poParser.get_entry_for_key( "@meta-summary " + configDictionary["summary"], lang).get("trans", None) if translation is not None: annotationTr = document.createElement("annotation") annotationTr.setAttribute("lang", lang) paragraph = document.createElement("p") paragraph.appendChild(document.createTextNode(translation)) annotationTr.appendChild(paragraph) bookInfo.insertAfter(annotationTr, annotation) translation = poParser.get_entry_for_key( "@meta-keywords " + ", ".join(configDictionary["otherKeywords"]), lang).get("trans", None) if translation is not None: keywordsTr = document.createElement("keywords") keywordsTr.setAttribute("lang", lang) keywordsTr.appendChild(document.createTextNode(translation)) bookInfo.insertAfter(keywordsTr, keywords) bookInfo.appendChild(language) bookTitle.setAttribute( "lang", str(configDictionary["language"]).replace("_", "-")) annotation.setAttribute( "lang", str(configDictionary["language"]).replace("_", "-")) keywords.setAttribute( "lang", str(configDictionary["language"]).replace("_", "-")) if "databaseReference" in configDictionary.keys(): database = document.createElement("databaseref") dbRef = configDictionary["databaseReference"] database.setAttribute("dbname", dbRef.get("name", "")) if "type" in dbRef.keys(): database.setAttribute("type", dbRef["type"]) database.appendChild(document.createTextNode(dbRef.get("entry", ""))) bookInfo.appendChild(database) if "seriesName" in configDictionary.keys(): sequence = document.createElement("sequence") sequence.setAttribute("title", configDictionary["seriesName"]) if "seriesVolume" in configDictionary.keys(): sequence.setAttribute("volume", str(configDictionary["seriesVolume"])) if "seriesNumber" in configDictionary.keys(): sequence.appendChild( document.createTextNode(str(configDictionary["seriesNumber"]))) else: sequence.appendChild(document.createTextNode(str(0))) bookInfo.appendChild(sequence) contentrating = document.createElement("content-rating") if "rating" in configDictionary.keys(): contentrating.appendChild( document.createTextNode(str(configDictionary["rating"]))) else: contentrating.appendChild(document.createTextNode(str("Unrated."))) if "ratingSystem" in configDictionary.keys(): contentrating.setAttribute("type", configDictionary["ratingSystem"]) bookInfo.appendChild(contentrating) if "readingDirection" in configDictionary.keys(): readingDirection = document.createElement("reading-direction") if configDictionary["readingDirection"] is "rightToLeft": readingDirection.appendChild(document.createTextNode(str("RTL"))) else: readingDirection.appendChild(document.createTextNode(str("LTR"))) bookInfo.appendChild(readingDirection) meta.appendChild(bookInfo) publisherInfo = document.createElement("publish-info") if "publisherName" in configDictionary.keys(): publisherName = document.createElement("publisher") publisherName.appendChild( document.createTextNode(str(configDictionary["publisherName"]))) publisherInfo.appendChild(publisherName) if "publishingDate" in configDictionary.keys(): publishingDate = document.createElement("publish-date") publishingDate.setAttribute("value", configDictionary["publishingDate"]) publishingDate.appendChild( document.createTextNode( QDate.fromString(configDictionary["publishingDate"], Qt.ISODate).toString( Qt.SystemLocaleLongDate))) publisherInfo.appendChild(publishingDate) if "publisherCity" in configDictionary.keys(): publishCity = document.createElement("city") publishCity.appendChild( document.createTextNode(str(configDictionary["publisherCity"]))) publisherInfo.appendChild(publishCity) if "isbn-number" in configDictionary.keys(): publishISBN = document.createElement("isbn") publishISBN.appendChild( document.createTextNode(str(configDictionary["isbn-number"]))) publisherInfo.appendChild(publishISBN) license = str(configDictionary.get("license", "")) if license.isspace() is False and len(license) > 0: publishLicense = document.createElement("license") publishLicense.appendChild(document.createTextNode(license)) publisherInfo.appendChild(publishLicense) meta.appendChild(publisherInfo) documentInfo = document.createElement("document-info") # TODO: ACBF apparently uses first/middle/last/nick/email/homepage for the document author too... # The following code compensates for me not understanding this initially. if "acbfAuthor" in configDictionary.keys(): if isinstance(configDictionary["acbfAuthor"], list): for e in configDictionary["acbfAuthor"]: acbfAuthor = document.createElement("author") authorDict = e if "first-name" in authorDict.keys(): authorN = document.createElement("first-name") authorN.appendChild( document.createTextNode(str(authorDict["first-name"]))) acbfAuthor.appendChild(authorN) if "last-name" in authorDict.keys(): authorN = document.createElement("last-name") authorN.appendChild( document.createTextNode(str(authorDict["last-name"]))) acbfAuthor.appendChild(authorN) if "initials" in authorDict.keys(): authorN = document.createElement("middle-name") authorN.appendChild( document.createTextNode(str(authorDict["initials"]))) acbfAuthor.appendChild(authorN) if "nickname" in authorDict.keys(): authorN = document.createElement("nickname") authorN.appendChild( document.createTextNode(str(authorDict["nickname"]))) acbfAuthor.appendChild(authorN) if "homepage" in authorDict.keys(): authorN = document.createElement("home-page") authorN.appendChild( document.createTextNode(str(authorDict["homepage"]))) acbfAuthor.appendChild(authorN) if "email" in authorDict.keys(): authorN = document.createElement("email") authorN.appendChild( document.createTextNode(str(authorDict["email"]))) acbfAuthor.appendChild(authorN) if "language" in authorDict.keys(): acbfAuthor.setAttribute( "lang", str(authorDict["language"]).replace("_", "-")) documentInfo.appendChild(acbfAuthor) else: acbfAuthor = document.createElement("author") acbfAuthorNick = document.createElement("nickname") acbfAuthorNick.appendChild( document.createTextNode(str(configDictionary["acbfAuthor"]))) acbfAuthor.appendChild(acbfAuthorNick) documentInfo.appendChild(acbfAuthor) else: acbfAuthor = document.createElement("author") acbfAuthorNick = document.createElement("nickname") acbfAuthorNick.appendChild(document.createTextNode(str("Anon"))) acbfAuthor.appendChild(acbfAuthorNick) documentInfo.appendChild(acbfAuthor) acbfDate = document.createElement("creation-date") now = QDate.currentDate() acbfDate.setAttribute("value", now.toString(Qt.ISODate)) acbfDate.appendChild( document.createTextNode(str(now.toString(Qt.SystemLocaleLongDate)))) documentInfo.appendChild(acbfDate) if "acbfSource" in configDictionary.keys(): acbfSource = document.createElement("source") acbfSourceP = document.createElement("p") acbfSourceP.appendChild( document.createTextNode(str(configDictionary["acbfSource"]))) acbfSource.appendChild(acbfSourceP) documentInfo.appendChild(acbfSource) if "acbfID" in configDictionary.keys(): acbfID = document.createElement("id") acbfID.appendChild( document.createTextNode(str(configDictionary["acbfID"]))) documentInfo.appendChild(acbfID) if "acbfVersion" in configDictionary.keys(): acbfVersion = document.createElement("version") acbfVersion.appendChild( document.createTextNode(str(configDictionary["acbfVersion"]))) documentInfo.appendChild(acbfVersion) if "acbfHistory" in configDictionary.keys(): if len(configDictionary["acbfHistory"]) > 0: acbfHistory = document.createElement("history") for h in configDictionary["acbfHistory"]: p = document.createElement("p") p.appendChild(document.createTextNode(str(h))) acbfHistory.appendChild(p) documentInfo.appendChild(acbfHistory) meta.appendChild(documentInfo) root.appendChild(meta) body = document.createElement("body") references = document.createElement("references") def figure_out_type(svg=QDomElement()): type = None skipList = ["speech", "emphasis", "strong", "inverted", "general"] if svg.attribute("text-anchor") == "middle" or svg.attribute( "text-align") == "center": if "acbfStyles" in configDictionary.keys(): stylesDictionary = configDictionary.get("acbfStyles", {}) for key in stylesDictionary.keys(): if key not in skipList: style = stylesDictionary.get(key, {}) font = style.get("font", "") if isinstance(fonts, list): if svg.attribute("family") in font: type = key elif svg.attribute("family") == font: type = key else: type = None elif svg.attribute("text-align") == "justified": type = "formal" else: type = "commentary" inverted = None #Figure out whether this is inverted colored text. if svg.hasAttribute("fill"): stylesDictionary = configDictionary.get("acbfStyles", {}) key = stylesDictionary.get("general", {}) regular = QColor(key.get("color", "#000000")) key = stylesDictionary.get("inverted", {}) invertedColor = QColor(key.get("color", "#FFFFFF")) textColor = QColor(svg.attribute("fill")) # Proceed to get luma for the three colors. lightnessR = (0.21 * regular.redF()) + ( 0.72 * regular.greenF()) + (0.07 * regular.blueF()) lightnessI = (0.21 * invertedColor.redF()) + ( 0.72 * invertedColor.greenF()) + (0.07 * invertedColor.blueF()) lightnessT = (0.21 * textColor.redF()) + ( 0.72 * textColor.greenF()) + (0.07 * textColor.blueF()) if lightnessI > lightnessR: if lightnessT > (lightnessI + lightnessR) * 0.5: inverted = "true" else: if lightnessT < (lightnessI + lightnessR) * 0.5: inverted = "true" return [type, inverted] listOfPageColors = [] for p in range(0, len(pagesLocationList)): page = pagesLocationList[p] imageFile = QImage() imageFile.load(page) imageRect = imageFile.rect().adjusted(0, 0, -1, -1) pageColor = findDominantColor([ imageFile.pixelColor(imageRect.topLeft()), imageFile.pixelColor(imageRect.topRight()), imageFile.pixelColor(imageRect.bottomRight()), imageFile.pixelColor(imageRect.bottomLeft()) ]) listOfPageColors.append(pageColor) language = "en" if "language" in configDictionary.keys(): language = str(configDictionary["language"]).replace("_", "-") textLayer = document.createElement("text-layer") textLayer.setAttribute("lang", language) data = pageData[p] transform = data["transform"] frameList = [] listOfTextColors = [] for v in data["vector"]: boundingBoxText = [] listOfBoundaryColors = [] for point in v["boundingBox"]: offset = QPointF(transform["offsetX"], transform["offsetY"]) pixelPoint = QPointF(point.x() * transform["resDiff"], point.y() * transform["resDiff"]) newPoint = pixelPoint - offset x = max( 0, min(imageRect.width(), int(newPoint.x() * transform["scaleWidth"]))) y = max( 0, min(imageRect.height(), int(newPoint.y() * transform["scaleHeight"]))) listOfBoundaryColors.append(imageFile.pixelColor(x, y)) pointText = str(x) + "," + str(y) boundingBoxText.append(pointText) mainColor = findDominantColor(listOfBoundaryColors) if "text" in v.keys(): textArea = document.createElement("text-area") textArea.setAttribute("points", " ".join(boundingBoxText)) # TODO: Rotate will require proper global transform api as transform info is not written intotext. #textArea.setAttribute("text-rotation", str(v["rotate"])) svg = QDomDocument() svg.setContent(v["text"]) figureOut = figure_out_type(svg.documentElement()) type = figureOut[0] inverted = figureOut[1] paragraph = QDomDocument() paragraph.appendChild(paragraph.createElement("p")) parseTextChildren(paragraph, svg.documentElement(), paragraph.documentElement(), emphasisStyle, strongStyle) textArea.appendChild(paragraph.documentElement()) textArea.setAttribute("bgcolor", mainColor.name()) if type is not None: textArea.setAttribute("type", type) if inverted is not None: textArea.setAttribute("inverted", inverted) textLayer.appendChild(textArea) else: f = {} f["points"] = " ".join(boundingBoxText) frameList.append(f) listOfTextColors.append(mainColor) textLayer.setAttribute("bgcolor", findDominantColor(listOfTextColors).name()) textLayerList = document.createElement("trlist") for lang in poParser.get_translation_list(): textLayerTr = document.createElement("text-layer") textLayerTr.setAttribute("lang", lang) for i in range(len(data["vector"])): d = data["vector"] v = d[i] boundingBoxText = [] for point in v["boundingBox"]: offset = QPointF(transform["offsetX"], transform["offsetY"]) pixelPoint = QPointF(point.x() * transform["resDiff"], point.y() * transform["resDiff"]) newPoint = pixelPoint - offset x = int(newPoint.x() * transform["scaleWidth"]) y = int(newPoint.y() * transform["scaleHeight"]) pointText = str(x) + "," + str(y) boundingBoxText.append(pointText) if "text" in v.keys(): textArea = document.createElement("text-area") textArea.setAttribute("points", " ".join(boundingBoxText)) # TODO: Rotate will require proper global transform api as transform info is not written intotext. #textArea.setAttribute("text-rotation", str(v["rotate"])) svg = QDomDocument() svg.setContent(v["text"]) figureOut = figure_out_type(svg.documentElement()) type = figureOut[0] inverted = figureOut[1] string = re.sub("\<\/*?text.*?\>", '', str(v["text"])) string = re.sub("\s+?", " ", string) translationEntry = poParser.get_entry_for_key(string, lang) string = translationEntry.get("trans", string) svg.setContent("<text>" + string + "</text>") paragraph = QDomDocument() paragraph.appendChild(paragraph.createElement("p")) parseTextChildren(paragraph, svg.documentElement(), paragraph.documentElement(), emphasisStyle, strongStyle) if "translComment" in translationEntry.keys(): key = translationEntry["translComment"] listOfComments = [] listOfComments = translationComments[lang] index = 0 if key in listOfComments: index = listOfComments.index(key) + 1 else: listOfComments.append(key) index = len(listOfComments) translationComments[lang] = listOfComments refID = "-".join(["tn", lang, str(index)]) anchor = document.createElement("a") anchor.setAttribute("href", "#" + refID) anchor.appendChild(document.createTextNode("*")) paragraph.documentElement().appendChild(anchor) textArea.appendChild(paragraph.documentElement()) textLayerTr.appendChild(textArea) if type is not None: textArea.setAttribute("type", type) if inverted is not None: textArea.setAttribute("inverted", inverted) textArea.setAttribute("bgcolor", listOfTextColors[i].name()) if textLayerTr.hasChildNodes(): textLayerTr.setAttribute( "bgcolor", findDominantColor(listOfTextColors).name()) textLayerList.appendChild(textLayerTr) if page is not coverpageurl: pg = document.createElement("page") image = document.createElement("image") image.setAttribute("href", os.path.basename(page)) pg.appendChild(image) if "acbf_title" in data["keys"]: title = document.createElement("title") title.setAttribute("lang", language) title.appendChild(document.createTextNode(str(data["title"]))) pg.appendChild(title) for lang in poParser.get_translation_list(): titleTrans = " " titlekey = "@page-title " + str(data["title"]) translationEntry = poParser.get_entry_for_key( titlekey, lang) titleTrans = translationEntry.get("trans", titleTrans) if titleTrans.isspace() is False: titleT = document.createElement("title") titleT.setAttribute("lang", lang) titleT.appendChild(document.createTextNode(titleTrans)) pg.appendChild(titleT) if "acbf_none" in data["keys"]: pg.setAttribute("transition", "none") if "acbf_blend" in data["keys"]: pg.setAttribute("transition", "blend") if "acbf_fade" in data["keys"]: pg.setAttribute("transition", "fade") if "acbf_horizontal" in data["keys"]: pg.setAttribute("transition", "scroll_right") if "acbf_vertical" in data["keys"]: pg.setAttribute("transition", "scroll_down") if textLayer.hasChildNodes(): pg.appendChild(textLayer) pg.setAttribute("bgcolor", pageColor.name()) for n in range(0, textLayerList.childNodes().size()): node = textLayerList.childNodes().at(n) pg.appendChild(node) for f in frameList: frame = document.createElement("frame") frame.setAttribute("points", f["points"]) pg.appendChild(frame) body.appendChild(pg) else: for f in frameList: frame = document.createElement("frame") frame.setAttribute("points", f["points"]) coverpage.appendChild(frame) coverpage.appendChild(textLayer) for n in range(0, textLayerList.childNodes().size()): node = textLayerList.childNodes().at(n) coverpage.appendChild(node) bodyColor = findDominantColor(listOfPageColors) body.setAttribute("bgcolor", bodyColor.name()) if configDictionary.get("includeTranslComment", False): for lang in translationComments.keys(): for key in translationComments[lang]: index = translationComments[lang].index(key) + 1 refID = "-".join(["tn", lang, str(index)]) ref = document.createElement("reference") ref.setAttribute("lang", lang) ref.setAttribute("id", refID) transHeaderStr = configDictionary.get("translatorHeader", "Translator's Notes") transHeaderStr = poParser.get_entry_for_key( "@meta-translator " + transHeaderStr, lang).get("trans", transHeaderStr) translatorHeader = document.createElement("p") translatorHeader.appendChild( document.createTextNode(transHeaderStr + ":")) ref.appendChild(translatorHeader) refPara = document.createElement("p") refPara.appendChild(document.createTextNode(key)) ref.appendChild(refPara) references.appendChild(ref) root.appendChild(body) if references.childNodes().size(): root.appendChild(references) f = open(locationBasic, 'w', newline="", encoding="utf-8") f.write(document.toString(indent=2)) f.close() success = True success = createStandAloneACBF(configDictionary, document, locationStandAlone, pagesLocationList) return success
def write_ncx_file(path, configDictionary, htmlFiles, listOfNavItems): tocDoc = QDomDocument() ncx = tocDoc.createElement("ncx") ncx.setAttribute("version", "2005-1") ncx.setAttribute("xmlns", "http://www.daisy.org/z3986/2005/ncx/") tocDoc.appendChild(ncx) tocHead = tocDoc.createElement("head") # NCX also has some meta values that are in the head. # They are shared with the opf metadata document. uuid = str(configDictionary["uuid"]) uuid = uuid.strip("{") uuid = uuid.strip("}") metaID = tocDoc.createElement("meta") metaID.setAttribute("content", uuid) metaID.setAttribute("name", "dtb:uid") tocHead.appendChild(metaID) metaDepth = tocDoc.createElement("meta") metaDepth.setAttribute("content", str(1)) metaDepth.setAttribute("name", "dtb:depth") tocHead.appendChild(metaDepth) metaTotal = tocDoc.createElement("meta") metaTotal.setAttribute("content", str(len(htmlFiles))) metaTotal.setAttribute("name", "dtb:totalPageCount") tocHead.appendChild(metaTotal) metaMax = tocDoc.createElement("meta") metaMax.setAttribute("content", str(len(htmlFiles))) metaMax.setAttribute("name", "dtb:maxPageNumber") tocHead.appendChild(metaDepth) ncx.appendChild(tocHead) docTitle = tocDoc.createElement("docTitle") text = tocDoc.createElement("text") if "title" in configDictionary.keys(): text.appendChild(tocDoc.createTextNode(str(configDictionary["title"]))) else: text.appendChild(tocDoc.createTextNode("Comic with no Name")) docTitle.appendChild(text) ncx.appendChild(docTitle) # The navmap is a table of contents. navmap = tocDoc.createElement("navMap") navPoint = tocDoc.createElement("navPoint") navPoint.setAttribute("id", "navPoint-1") navPoint.setAttribute("playOrder", "1") navLabel = tocDoc.createElement("navLabel") navLabelText = tocDoc.createElement("text") navLabelText.appendChild(tocDoc.createTextNode("Start")) navLabel.appendChild(navLabelText) navContent = tocDoc.createElement("content") navContent.setAttribute("src", os.path.relpath(htmlFiles[0], str(path))) navPoint.appendChild(navLabel) navPoint.appendChild(navContent) navmap.appendChild(navPoint) entry = 1 for fileName in listOfNavItems.keys(): entry += 1 navPointT = tocDoc.createElement("navPoint") navPointT.setAttribute("id", "navPoint-" + str(entry)) navPointT.setAttribute("playOrder", str(entry)) navLabelT = tocDoc.createElement("navLabel") navLabelTText = tocDoc.createElement("text") navLabelTText.appendChild( tocDoc.createTextNode(listOfNavItems[fileName])) navLabelT.appendChild(navLabelTText) navContentT = tocDoc.createElement("content") navContentT.setAttribute("src", os.path.relpath(fileName, str(path))) navPointT.appendChild(navLabelT) navPointT.appendChild(navContentT) navmap.appendChild(navPointT) ncx.appendChild(navmap) # The pages list on the other hand just lists all pages. pagesList = tocDoc.createElement("pageList") navLabelPages = tocDoc.createElement("navLabel") navLabelPagesText = tocDoc.createElement("text") navLabelPagesText.appendChild(tocDoc.createTextNode("Pages")) navLabelPages.appendChild(navLabelPagesText) pagesList.appendChild(navLabelPages) for i in range(len(htmlFiles)): pageTarget = tocDoc.createElement("pageTarget") pageTarget.setAttribute("type", "normal") pageTarget.setAttribute("id", "page-" + str(i)) pageTarget.setAttribute("value", str(i)) navLabelPagesTarget = tocDoc.createElement("navLabel") navLabelPagesTargetText = tocDoc.createElement("text") navLabelPagesTargetText.appendChild(tocDoc.createTextNode(str(i + 1))) navLabelPagesTarget.appendChild(navLabelPagesTargetText) pageTarget.appendChild(navLabelPagesTarget) pageTargetContent = tocDoc.createElement("content") pageTargetContent.setAttribute( "src", os.path.relpath(htmlFiles[i], str(path))) pageTarget.appendChild(pageTargetContent) pagesList.appendChild(pageTarget) ncx.appendChild(pagesList) # Save the document. docFile = open(str(Path(path / "toc.ncx")), 'w', newline="", encoding="utf-8") docFile.write(tocDoc.toString(indent=2)) docFile.close() return str(Path(path / "toc.ncx"))
def write_region_nav_file(path, configDictionary, htmlFiles, regions=[]): navDoc = QDomDocument() navRoot = navDoc.createElement("html") navRoot.setAttribute("xmlns", "http://www.w3.org/1999/xhtml") navRoot.setAttribute("xmlns:epub", "http://www.idpf.org/2007/ops") navDoc.appendChild(navRoot) head = navDoc.createElement("head") title = navDoc.createElement("title") title.appendChild(navDoc.createTextNode("Region Navigation")) head.appendChild(title) navRoot.appendChild(head) body = navDoc.createElement("body") navRoot.appendChild(body) nav = navDoc.createElement("nav") nav.setAttribute("epub:type", "region-based") nav.setAttribute("prefix", "ahl: http://idpf.org/epub/vocab/ahl") body.appendChild(nav) # Let's write the panels and balloons down now. olPanels = navDoc.createElement("ol") for region in regions: if region["type"] == "panel": pageName = os.path.relpath(region["page"], str(path)) print("accessing panel") li = navDoc.createElement("li") li.setAttribute("epub:type", "panel") anchor = navDoc.createElement("a") bounds = region["points"] anchor.setAttribute( "href", pageName + "#xywh=percent:" + str(bounds.x()) + "," + str(bounds.y()) + "," + str(bounds.width()) + "," + str(bounds.height())) if len(region["primaryColor"]) > 0: primaryC = navDoc.createElement("meta") primaryC.setAttribute("property", "ahl:primary-color") primaryC.setAttribute("content", region["primaryColor"]) anchor.appendChild(primaryC) li.appendChild(anchor) olBalloons = navDoc.createElement("ol") """ The region nav spec specifies that we should have text-areas/balloons as a refinement on the panel. For each panel, we'll check if there's balloons/text-areas inside, and we'll do that by checking whether the center point is inside the panel because some comics have balloons that overlap the gutters. """ for balloon in regions: if balloon["type"] == "text" and balloon["page"] == region[ "page"] and bounds.contains( balloon["points"].center()): liBalloon = navDoc.createElement("li") liBalloon.setAttribute("epub:type", "text-area") anchorBalloon = navDoc.createElement("a") BBounds = balloon["points"] anchorBalloon.setAttribute( "href", pageName + "#xywh=percent:" + str(BBounds.x()) + "," + str(BBounds.y()) + "," + str(BBounds.width()) + "," + str(BBounds.height())) liBalloon.appendChild(anchorBalloon) olBalloons.appendChild(liBalloon) if olBalloons.hasChildNodes(): li.appendChild(olBalloons) olPanels.appendChild(li) nav.appendChild(olPanels) navFile = open(str(Path(path / "region-nav.xhtml")), 'w', newline="", encoding="utf-8") navFile.write(navDoc.toString(indent=2)) navFile.close() return str(Path(path / "region-nav.xhtml"))
def write_nav_file(path, configDictionary, htmlFiles, listOfNavItems): navDoc = QDomDocument() navRoot = navDoc.createElement("html") navRoot.setAttribute("xmlns", "http://www.w3.org/1999/xhtml") navRoot.setAttribute("xmlns:epub", "http://www.idpf.org/2007/ops") navDoc.appendChild(navRoot) head = navDoc.createElement("head") title = navDoc.createElement("title") title.appendChild(navDoc.createTextNode("Table of Contents")) head.appendChild(title) navRoot.appendChild(head) body = navDoc.createElement("body") navRoot.appendChild(body) # The Table of Contents toc = navDoc.createElement("nav") toc.setAttribute("epub:type", "toc") oltoc = navDoc.createElement("ol") li = navDoc.createElement("li") anchor = navDoc.createElement("a") anchor.setAttribute("href", os.path.relpath(htmlFiles[0], str(path))) anchor.appendChild(navDoc.createTextNode("Start")) li.appendChild(anchor) oltoc.appendChild(li) for fileName in listOfNavItems.keys(): li = navDoc.createElement("li") anchor = navDoc.createElement("a") anchor.setAttribute("href", os.path.relpath(fileName, str(path))) anchor.appendChild(navDoc.createTextNode(listOfNavItems[fileName])) li.appendChild(anchor) oltoc.appendChild(li) toc.appendChild(oltoc) body.appendChild(toc) # The Pages List. pageslist = navDoc.createElement("nav") pageslist.setAttribute("epub:type", "page-list") olpages = navDoc.createElement("ol") entry = 1 for i in range(len(htmlFiles)): li = navDoc.createElement("li") anchor = navDoc.createElement("a") anchor.setAttribute("href", os.path.relpath(htmlFiles[1], str(path))) anchor.appendChild(navDoc.createTextNode(str(i))) li.appendChild(anchor) olpages.appendChild(li) pageslist.appendChild(olpages) body.appendChild(pageslist) navFile = open(str(Path(path / "nav.xhtml")), 'w', newline="", encoding="utf-8") navFile.write(navDoc.toString(indent=2)) navFile.close() return str(Path(path / "nav.xhtml"))
def write_opf_file(path, configDictionary, htmlFiles, pagesList, coverpageurl, coverpagehtml, listofSpreads): # marc relators # This has several entries removed to reduce it to the most relevant entries. marcRelators = { "abr": i18n("Abridger"), "acp": i18n("Art copyist"), "act": i18n("Actor"), "adi": i18n("Art director"), "adp": i18n("Adapter"), "ann": i18n("Annotator"), "ant": i18n("Bibliographic antecedent"), "arc": i18n("Architect"), "ard": i18n("Artistic director"), "art": i18n("Artist"), "asn": i18n("Associated name"), "ato": i18n("Autographer"), "att": i18n("Attributed name"), "aud": i18n("Author of dialog"), "aut": i18n("Author"), "bdd": i18n("Binding designer"), "bjd": i18n("Bookjacket designer"), "bkd": i18n("Book designer"), "bkp": i18n("Book producer"), "blw": i18n("Blurb writer"), "bnd": i18n("Binder"), "bpd": i18n("Bookplate designer"), "bsl": i18n("Bookseller"), "cll": i18n("Calligrapher"), "clr": i18n("Colorist"), "cns": i18n("Censor"), "cov": i18n("Cover designer"), "cph": i18n("Copyright holder"), "cre": i18n("Creator"), "ctb": i18n("Contributor"), "cur": i18n("Curator"), "cwt": i18n("Commentator for written text"), "drm": i18n("Draftsman"), "dsr": i18n("Designer"), "dub": i18n("Dubious author"), "edt": i18n("Editor"), "etr": i18n("Etcher"), "exp": i18n("Expert"), "fnd": i18n("Funder"), "ill": i18n("Illustrator"), "ilu": i18n("Illuminator"), "ins": i18n("Inscriber"), "lse": i18n("Licensee"), "lso": i18n("Licensor"), "ltg": i18n("Lithographer"), "mdc": i18n("Metadata contact"), "oth": i18n("Other"), "own": i18n("Owner"), "pat": i18n("Patron"), "pbd": i18n("Publishing director"), "pbl": i18n("Publisher"), "prt": i18n("Printer"), "sce": i18n("Scenarist"), "scr": i18n("Scribe"), "spn": i18n("Sponsor"), "stl": i18n("Storyteller"), "trc": i18n("Transcriber"), "trl": i18n("Translator"), "tyd": i18n("Type designer"), "tyg": i18n("Typographer"), "wac": i18n("Writer of added commentary"), "wal": i18n("Writer of added lyrics"), "wam": i18n("Writer of accompanying material"), "wat": i18n("Writer of added text"), "win": i18n("Writer of introduction"), "wpr": i18n("Writer of preface"), "wst": i18n("Writer of supplementary textual content") } # opf file opfFile = QDomDocument() opfRoot = opfFile.createElement("package") opfRoot.setAttribute("version", "3.0") opfRoot.setAttribute("unique-identifier", "BookId") opfRoot.setAttribute("xmlns", "http://www.idpf.org/2007/opf") opfRoot.setAttribute("prefix", "rendition: http://www.idpf.org/vocab/rendition/#") opfFile.appendChild(opfRoot) opfMeta = opfFile.createElement("metadata") opfMeta.setAttribute("xmlns:dc", "http://purl.org/dc/elements/1.1/") opfMeta.setAttribute("xmlns:dcterms", "http://purl.org/dc/terms/") # EPUB metadata requires a title, language and uuid langString = "en-US" if "language" in configDictionary.keys(): langString = str(configDictionary["language"]).replace("_", "-") bookLang = opfFile.createElement("dc:language") bookLang.appendChild(opfFile.createTextNode(langString)) opfMeta.appendChild(bookLang) bookTitle = opfFile.createElement("dc:title") if "title" in configDictionary.keys(): bookTitle.appendChild( opfFile.createTextNode(str(configDictionary["title"]))) else: bookTitle.appendChild(opfFile.createTextNode("Comic with no Name")) opfMeta.appendChild(bookTitle) # Generate series title and the like here too. if "seriesName" in configDictionary.keys(): bookTitle.setAttribute("id", "main") refine = opfFile.createElement("meta") refine.setAttribute("refines", "#main") refine.setAttribute("property", "title-type") refine.appendChild(opfFile.createTextNode("main")) opfMeta.appendChild(refine) refine2 = opfFile.createElement("meta") refine2.setAttribute("refines", "#main") refine2.setAttribute("property", "display-seq") refine2.appendChild(opfFile.createTextNode("1")) opfMeta.appendChild(refine2) seriesTitle = opfFile.createElement("dc:title") seriesTitle.appendChild( opfFile.createTextNode(str(configDictionary["seriesName"]))) seriesTitle.setAttribute("id", "series") opfMeta.appendChild(seriesTitle) refineS = opfFile.createElement("meta") refineS.setAttribute("refines", "#series") refineS.setAttribute("property", "title-type") refineS.appendChild(opfFile.createTextNode("collection")) opfMeta.appendChild(refineS) refineS2 = opfFile.createElement("meta") refineS2.setAttribute("refines", "#series") refineS2.setAttribute("property", "display-seq") refineS2.appendChild(opfFile.createTextNode("2")) opfMeta.appendChild(refineS2) if "seriesNumber" in configDictionary.keys(): refineS3 = opfFile.createElement("meta") refineS3.setAttribute("refines", "#series") refineS3.setAttribute("property", "group-position") refineS3.appendChild( opfFile.createTextNode(str(configDictionary["seriesNumber"]))) opfMeta.appendChild(refineS3) uuid = str(configDictionary["uuid"]) uuid = uuid.strip("{") uuid = uuid.strip("}") # Append the id, and assign it as the bookID. uniqueID = opfFile.createElement("dc:identifier") uniqueID.appendChild(opfFile.createTextNode("urn:uuid:" + uuid)) uniqueID.setAttribute("id", "BookId") opfMeta.appendChild(uniqueID) if "authorList" in configDictionary.keys(): authorEntry = 0 for authorE in range(len(configDictionary["authorList"])): authorDict = configDictionary["authorList"][authorE] authorType = "dc:creator" if "role" in authorDict.keys(): # This determines if someone was just a contributor, but might need a more thorough version. if str(authorDict["role"]).lower() in [ "editor", "assistant editor", "proofreader", "beta", "patron", "funder" ]: authorType = "dc:contributor" author = opfFile.createElement(authorType) authorName = [] if "last-name" in authorDict.keys(): authorName.append(authorDict["last-name"]) if "first-name" in authorDict.keys(): authorName.append(authorDict["first-name"]) if "initials" in authorDict.keys(): authorName.append(authorDict["initials"]) if "nickname" in authorDict.keys(): authorName.append("(" + authorDict["nickname"] + ")") author.appendChild(opfFile.createTextNode(", ".join(authorName))) author.setAttribute("id", "cre" + str(authorE)) opfMeta.appendChild(author) if "role" in authorDict.keys(): role = opfFile.createElement("meta") role.setAttribute("refines", "#cre" + str(authorE)) role.setAttribute("scheme", "marc:relators") role.setAttribute("property", "role") roleString = str(authorDict["role"]) if roleString in marcRelators.values( ) or roleString in marcRelators.keys(): i = list(marcRelators.values()).index(roleString) roleString = list(marcRelators.keys())[i] else: roleString = "oth" role.appendChild(opfFile.createTextNode(roleString)) opfMeta.appendChild(role) refine = opfFile.createElement("meta") refine.setAttribute("refines", "#cre" + str(authorE)) refine.setAttribute("property", "display-seq") refine.appendChild(opfFile.createTextNode(str(authorE + 1))) opfMeta.appendChild(refine) if "publishingDate" in configDictionary.keys(): date = opfFile.createElement("dc:date") date.appendChild( opfFile.createTextNode(configDictionary["publishingDate"])) opfMeta.appendChild(date) #Creation date modified = opfFile.createElement("meta") modified.setAttribute("property", "dcterms:modified") modified.appendChild( opfFile.createTextNode(QDateTime.currentDateTimeUtc().toString( Qt.ISODate))) opfMeta.appendChild(modified) if "source" in configDictionary.keys(): if len(configDictionary["source"]) > 0: source = opfFile.createElement("dc:source") source.appendChild( opfFile.createTextNode(configDictionary["source"])) opfMeta.appendChild(source) description = opfFile.createElement("dc:description") if "summary" in configDictionary.keys(): description.appendChild( opfFile.createTextNode(configDictionary["summary"])) else: description.appendChild( opfFile.createTextNode( "There was no summary upon generation of this file.")) opfMeta.appendChild(description) # Type can be dictionary or index, or one of those edupub thingies. Not necessary for comics. # typeE = opfFile.createElement("dc:type") # opfMeta.appendChild(typeE) if "publisherName" in configDictionary.keys(): publisher = opfFile.createElement("dc:publisher") publisher.appendChild( opfFile.createTextNode(configDictionary["publisherName"])) opfMeta.appendChild(publisher) if "isbn-number" in configDictionary.keys(): isbnnumber = configDictionary["isbn-number"] if len(isbnnumber) > 0: publishISBN = opfFile.createElement("dc:identifier") publishISBN.appendChild( opfFile.createTextNode(str("urn:isbn:") + isbnnumber)) opfMeta.appendChild(publishISBN) if "license" in configDictionary.keys(): if len(configDictionary["license"]) > 0: rights = opfFile.createElement("dc:rights") rights.appendChild( opfFile.createTextNode(configDictionary["license"])) opfMeta.appendChild(rights) """ Not handled Relation - This is for whether the work has a relationship with another work. It could be fanart, but also adaptation, an academic work, etc. Coverage - This is for the time/place that the work covers. Typically to determine whether an academic work deals with a certain time period or place. For comics you could use this to mark historical comics, but other than that we'd need a much better ui to define this. """ # These are all dublin core subjects. # 3.1 defines the ability to use an authority, but that # might be a bit too complicated right now. if "genre" in configDictionary.keys(): genreListConf = configDictionary["genre"] if isinstance(configDictionary["genre"], dict): genreListConf = configDictionary["genre"].keys() for g in genreListConf: subject = opfFile.createElement("dc:subject") subject.appendChild(opfFile.createTextNode(g)) opfMeta.appendChild(subject) if "characters" in configDictionary.keys(): for name in configDictionary["characters"]: char = opfFile.createElement("dc:subject") char.appendChild(opfFile.createTextNode(name)) opfMeta.appendChild(char) if "format" in configDictionary.keys(): for formatF in configDictionary["format"]: f = opfFile.createElement("dc:subject") f.appendChild(opfFile.createTextNode(formatF)) opfMeta.appendChild(f) if "otherKeywords" in configDictionary.keys(): for key in configDictionary["otherKeywords"]: word = opfFile.createElement("dc:subject") word.appendChild(opfFile.createTextNode(key)) opfMeta.appendChild(word) # Pre-pagination and layout # Comic are always prepaginated. elLayout = opfFile.createElement("meta") elLayout.setAttribute("property", "rendition:layout") elLayout.appendChild(opfFile.createTextNode("pre-paginated")) opfMeta.appendChild(elLayout) # We should figure out if the pages are portrait or not... elOrientation = opfFile.createElement("meta") elOrientation.setAttribute("property", "rendition:orientation") elOrientation.appendChild(opfFile.createTextNode("portrait")) opfMeta.appendChild(elOrientation) elSpread = opfFile.createElement("meta") elSpread.setAttribute("property", "rendition:spread") elSpread.appendChild(opfFile.createTextNode("landscape")) opfMeta.appendChild(elSpread) opfRoot.appendChild(opfMeta) # Manifest opfManifest = opfFile.createElement("manifest") toc = opfFile.createElement("item") toc.setAttribute("id", "ncx") toc.setAttribute("href", "toc.ncx") toc.setAttribute("media-type", "application/x-dtbncx+xml") opfManifest.appendChild(toc) region = opfFile.createElement("item") region.setAttribute("id", "regions") region.setAttribute("href", "region-nav.xhtml") region.setAttribute("media-type", "application/xhtml+xml") region.setAttribute("properties", "data-nav") # Set the propernavmap to use this later) opfManifest.appendChild(region) nav = opfFile.createElement("item") nav.setAttribute("id", "nav") nav.setAttribute("href", "nav.xhtml") nav.setAttribute("media-type", "application/xhtml+xml") nav.setAttribute("properties", "nav") # Set the propernavmap to use this later) opfManifest.appendChild(nav) ids = 0 for p in pagesList: item = opfFile.createElement("item") item.setAttribute("id", "img" + str(ids)) ids += 1 item.setAttribute("href", os.path.relpath(p, str(path))) item.setAttribute("media-type", "image/png") if os.path.basename(p) == os.path.basename(coverpageurl): item.setAttribute("properties", "cover-image") opfManifest.appendChild(item) ids = 0 for p in htmlFiles: item = opfFile.createElement("item") item.setAttribute("id", "p" + str(ids)) ids += 1 item.setAttribute("href", os.path.relpath(p, str(path))) item.setAttribute("media-type", "application/xhtml+xml") opfManifest.appendChild(item) opfRoot.appendChild(opfManifest) # Spine opfSpine = opfFile.createElement("spine") # this sets the table of contents to use the ncx file opfSpine.setAttribute("toc", "ncx") # Reading Direction: spreadRight = True direction = 0 if "readingDirection" in configDictionary.keys(): if configDictionary["readingDirection"] == "rightToLeft": opfSpine.setAttribute("page-progression-direction", "rtl") spreadRight = False direction = 1 else: opfSpine.setAttribute("page-progression-direction", "ltr") # Here we'd need to switch between the two and if spread keywrod use neither but combine with spread-none ids = 0 for p in htmlFiles: item = opfFile.createElement("itemref") item.setAttribute("idref", "p" + str(ids)) ids += 1 props = [] if p in listofSpreads: # Put this one in the center. props.append("rendition:page-spread-center") # Reset the spread boolean. # It needs to point at the first side after the spread. # So ltr -> spread-left, rtl->spread-right if direction == 0: spreadRight = False else: spreadRight = True else: if spreadRight: props.append("page-spread-right") spreadRight = False else: props.append("page-spread-left") spreadRight = True item.setAttribute("properties", " ".join(props)) opfSpine.appendChild(item) opfRoot.appendChild(opfSpine) # Guide opfGuide = opfFile.createElement("guide") if coverpagehtml is not None and coverpagehtml.isspace() is False and len( coverpagehtml) > 0: item = opfFile.createElement("reference") item.setAttribute("type", "cover") item.setAttribute("title", "Cover") item.setAttribute("href", coverpagehtml) opfGuide.appendChild(item) opfRoot.appendChild(opfGuide) docFile = open(str(Path(path / "content.opf")), 'w', newline="", encoding="utf-8") docFile.write(opfFile.toString(indent=2)) docFile.close() return str(Path(path / "content.opf"))
def export(configDictionary={}, projectURL=str(), pagesLocationList=[], pageData=[]): path = Path(os.path.join(projectURL, configDictionary["exportLocation"])) exportPath = path / "EPUB-files" metaInf = exportPath / "META-INF" oebps = exportPath / "OEBPS" imagePath = oebps / "Images" # Don't write empty folders. Epubcheck doesn't like that. # stylesPath = oebps / "Styles" textPath = oebps / "Text" if exportPath.exists() is False: exportPath.mkdir() metaInf.mkdir() oebps.mkdir() imagePath.mkdir() # stylesPath.mkdir() textPath.mkdir() # Due the way EPUB verifies, the mimetype needs to be packaged in first. # Due the way zips are constructed, the only way to ensure that is to # Fill the zip as we go along... # Use the project name if there's no title to avoid sillyness with unnamed zipfiles. title = configDictionary["projectName"] if "title" in configDictionary.keys(): title = str(configDictionary["title"]).replace(" ", "_") # Get the appropriate path. url = str(path / str(title + ".epub")) # Create a zip file. epubArchive = zipfile.ZipFile(url, mode="w", compression=zipfile.ZIP_STORED) mimetype = open(str(Path(exportPath / "mimetype")), mode="w") mimetype.write("application/epub+zip") mimetype.close() # Write to zip. epubArchive.write(Path(exportPath / "mimetype"), Path("mimetype")) container = QDomDocument() cRoot = container.createElement("container") cRoot.setAttribute("version", "1.0") cRoot.setAttribute("xmlns", "urn:oasis:names:tc:opendocument:xmlns:container") container.appendChild(cRoot) rootFiles = container.createElement("rootfiles") rootfile = container.createElement("rootfile") rootfile.setAttribute("full-path", "OEBPS/content.opf") rootfile.setAttribute("media-type", "application/oebps-package+xml") rootFiles.appendChild(rootfile) cRoot.appendChild(rootFiles) containerFileName = str(Path(metaInf / "container.xml")) containerFile = open(containerFileName, 'w', newline="", encoding="utf-8") containerFile.write(container.toString(indent=2)) containerFile.close() # Write to zip. epubArchive.write(containerFileName, os.path.relpath(containerFileName, str(exportPath))) # copyimages to images pagesList = [] if len(pagesLocationList) > 0: if "cover" in configDictionary.keys(): coverNumber = configDictionary["pages"].index( configDictionary["cover"]) else: coverNumber = 0 for p in pagesLocationList: if os.path.exists(p): shutil.copy2(p, str(imagePath)) filename = str(Path(imagePath / os.path.basename(p))) pagesList.append(filename) epubArchive.write(filename, os.path.relpath(filename, str(exportPath))) if len(pagesLocationList) >= coverNumber: coverpageurl = pagesList[coverNumber] else: print("CPMT: Couldn't find the location for the epub images.") return False # for each image, make an xhtml file htmlFiles = [] listOfNavItems = {} listofSpreads = [] regions = [] for i in range(len(pagesList)): pageName = "Page" + str(i) + ".xhtml" doc = QDomDocument() html = doc.createElement("html") doc.appendChild(html) html.setAttribute("xmlns", "http://www.w3.org/1999/xhtml") html.setAttribute("xmlns:epub", "http://www.idpf.org/2007/ops") # The viewport is a prerequisite to get pre-paginated # layouts working. We'll make the layout the same size # as the image. head = doc.createElement("head") viewport = doc.createElement("meta") viewport.setAttribute("name", "viewport") img = QImage() img.load(pagesLocationList[i]) w = img.width() h = img.height() widthHeight = "width=" + str(w) + ", height=" + str(h) viewport.setAttribute("content", widthHeight) head.appendChild(viewport) html.appendChild(head) # Here, we process the region navigation data to percentages # because we have access here to the width and height of the viewport. data = pageData[i] transform = data["transform"] for v in data["vector"]: pointsList = [] dominantColor = QColor(Qt.white) listOfColors = [] for point in v["boundingBox"]: offset = QPointF(transform["offsetX"], transform["offsetY"]) pixelPoint = QPointF(point.x() * transform["resDiff"], point.y() * transform["resDiff"]) newPoint = pixelPoint - offset x = max(0, min(w, int(newPoint.x() * transform["scaleWidth"]))) y = max(0, min(h, int(newPoint.y() * transform["scaleHeight"]))) listOfColors.append(img.pixelColor(QPointF(x, y).toPoint())) pointsList.append(QPointF((x / w) * 100, (y / h) * 100)) regionType = "panel" if "text" in v.keys(): regionType = "text" if len(listOfColors) > 0: dominantColor = listOfColors[-1] listOfColors = listOfColors[:-1] for color in listOfColors: dominantColor.setRedF( 0.5 * (dominantColor.redF() + color.redF())) dominantColor.setGreenF( 0.5 * (dominantColor.greenF() + color.greenF())) dominantColor.setBlueF( 0.5 * (dominantColor.blueF() + color.blueF())) region = {} bounds = QPolygonF(pointsList).boundingRect() region["points"] = bounds region["type"] = regionType region["page"] = str(Path(textPath / pageName)) region["primaryColor"] = dominantColor.name() regions.append(region) # We can also figureout here whether the page can be seen as a table of contents entry. if "acbf_title" in data["keys"]: listOfNavItems[str(Path(textPath / pageName))] = data["title"] # Or spreads... if "epub_spread" in data["keys"]: listofSpreads.append(str(Path(textPath / pageName))) body = doc.createElement("body") img = doc.createElement("img") img.setAttribute("src", os.path.relpath(pagesList[i], str(textPath))) body.appendChild(img) html.appendChild(body) filename = str(Path(textPath / pageName)) docFile = open(filename, 'w', newline="", encoding="utf-8") docFile.write(doc.toString(indent=2)) docFile.close() if pagesList[i] == coverpageurl: coverpagehtml = os.path.relpath(filename, str(oebps)) htmlFiles.append(filename) # Write to zip. epubArchive.write(filename, os.path.relpath(filename, str(exportPath))) # metadata filename = write_opf_file(oebps, configDictionary, htmlFiles, pagesList, coverpageurl, coverpagehtml, listofSpreads) epubArchive.write(filename, os.path.relpath(filename, str(exportPath))) filename = write_region_nav_file(oebps, configDictionary, htmlFiles, regions) epubArchive.write(filename, os.path.relpath(filename, str(exportPath))) # toc filename = write_nav_file(oebps, configDictionary, htmlFiles, listOfNavItems) epubArchive.write(filename, os.path.relpath(filename, str(exportPath))) filename = write_ncx_file(oebps, configDictionary, htmlFiles, listOfNavItems) epubArchive.write(filename, os.path.relpath(filename, str(exportPath))) epubArchive.close() return True
def qml2Sld(self): try: layer = self.allMapLayers[self.dlg.comboBox.currentIndex()] except: return qmlDocument = QDomDocument() root = qmlDocument.createElement('SLD4raster') qmlDocument.appendChild(root) qgisNode = qmlDocument.createElement('qgis') root.appendChild(qgisNode) errorMessage = None context = QgsReadWriteContext() layer.writeSymbology(qgisNode, qmlDocument, errorMessage, context) qmlString = minidom.parseString(qmlDocument.toString().encode('utf-8')) # for non ASCII labels. sldRoot = Element('sld:StyledLayerDescriptor') sldRoot.attrib['xmlns'] = 'http://www.opengis.net/sld' sldRoot.attrib['xmlns:sld'] = 'http://www.opengis.net/sld' sldRoot.attrib['xmlns:ogc'] = 'http://www.opengis.net/ogc' sldRoot.attrib['xmlns:gml'] = 'http://www.opengis.net/gml' sldRoot.attrib['version'] = '1.0.0' userLayer = SubElement(sldRoot, 'sld:UserLayer') layerFeatureConstraints = SubElement(userLayer, 'sld:LayerFeatureConstraints') featureTypeConstraint = SubElement(layerFeatureConstraints, 'sld:FeatureTypeConstraint') userStyle = SubElement(userLayer, 'sld:UserStyle') styleName = SubElement(userStyle, 'sld:Name') styleName.text = self.dlg.comboBox.currentText() styleDescription = SubElement(userStyle, 'sld:Description') styleDescription.text = 'Generated by SLD4raster - https://cbsuygulama.wordpress.com/sld4raster' styleTitle = SubElement(userStyle, 'sld:Title') featureTypeStyle = SubElement(userStyle, 'sld:FeatureTypeStyle') featureName = SubElement(featureTypeStyle, 'sld:Name') featureRule = SubElement(featureTypeStyle, 'sld:Rule') rasterSymbolizer = SubElement(featureRule, 'sld:RasterSymbolizer') geometry = SubElement(rasterSymbolizer, 'sld:Geometry') ogcPropertyName = SubElement(geometry, 'ogc:PropertyName') ogcPropertyName.text = 'grid' opacity = SubElement(rasterSymbolizer, 'sld:Opacity') ###Getting raster type parameters rasterType = str(qmlString.getElementsByTagName('rasterrenderer')[0].attributes['type'].value) isGradient = 'gradient' in qmlString.getElementsByTagName('rasterrenderer')[0].attributes.keys() ###SLD for multiband raster if rasterType == 'multibandcolor': ###Getting RGB band order. redBand = str(qmlString.getElementsByTagName('rasterrenderer')[0].attributes['redBand'].value) greenBand = str(qmlString.getElementsByTagName('rasterrenderer')[0].attributes['greenBand'].value) blueBand = str(qmlString.getElementsByTagName('rasterrenderer')[0].attributes['blueBand'].value) channelSelection = SubElement(rasterSymbolizer, 'sld:ChannelSelection') redChannel = SubElement(channelSelection, 'sld:RedChannel') redSourceChannel = SubElement(redChannel, 'sld:SourceChannelName') redSourceChannel.text = redBand greenChannel = SubElement(channelSelection, 'sld:GreenChannel') greenSourceChannel = SubElement(greenChannel, 'sld:SourceChannelName') greenSourceChannel.text = greenBand blueChannel = SubElement(channelSelection, 'sld:BlueChannel') blueSourceChannel = SubElement(blueChannel, 'sld:SourceChannelName') blueSourceChannel.text = blueBand ###SLD for gradiented (black to white) raster elif isGradient: blackWhiteColor = ['#000000', '#FFFFFF'] colorMap = SubElement(rasterSymbolizer, 'sld:ColorMap') gradientType = qmlString.getElementsByTagName('rasterrenderer')[0].attributes['gradient'].value blackWhiteValue = [qmlString.getElementsByTagName('minValue')[0].firstChild.nodeValue, qmlString.getElementsByTagName('maxValue')[0].firstChild.nodeValue] ###Getting gradient color type if gradientType == 'WhiteToBlack': blackWhiteColor.reverse() for i in range(len(blackWhiteColor)): colorMapEntry = SubElement(colorMap, 'sld:ColorMapEntry') colorMapEntry.attrib['color'] = blackWhiteColor[i] colorMapEntry.attrib['opacity'] = '1.0' colorMapEntry.attrib['quantity'] = blackWhiteValue[i] ###SLD for singleband raster else: colorMap = SubElement(rasterSymbolizer, 'sld:ColorMap') ###Getting color ramp type colorType = str(qmlString.getElementsByTagName('colorrampshader')[0].attributes['colorRampType'].value) if colorType == 'DISCRETE': colorMap.attrib['type'] = "intervals" ###Getting color values colorValue = list() itemlist = qmlString.getElementsByTagName('item') for n in itemlist: colorValue.append( [n.attributes['color'].value, n.attributes['value'].value, n.attributes['label'].value]) ###Color values posting to SLD document for i in range(len(colorValue)): colorMapEntry = SubElement(colorMap, 'sld:ColorMapEntry') colorMapEntry.attrib['color'] = colorValue[i][0] colorMapEntry.attrib['quantity'] = colorValue[i][1] colorMapEntry.attrib['label'] = colorValue[i][2] colorMapEntry.attrib['opacity'] = '1.0' rasterOpacity = str(qmlString.getElementsByTagName('rasterrenderer')[0].attributes['opacity'].value) opacity.text = rasterOpacity textSLD = minidom.parseString(tostring(sldRoot)) self.dlg.sldText1.setText(textSLD.toprettyxml(indent=" "))
class MultiDaemonFile: file_path = '/tmp/RaySession/multi-daemon.xml' def __init__(self, session, server): self.session = session self.server = server self._xml = QDomDocument() global instance instance = self self._locked_session_paths = set() @staticmethod def get_instance(): return instance def _pid_exists(self, pid)->bool: if isinstance(pid, str): pid = int(pid) try: os.kill(pid, 0) except OSError: return False else: return True def _remove_file(self): try: os.remove(self.file_path) except: return def _open_file(self)->bool: if not os.path.exists(self.file_path): dir_path = os.path.dirname(self.file_path) if not os.path.exists(dir_path): os.makedirs(dir_path) # give read/write access for all users os.chmod(dir_path, 0o777) return False try: file = open(self.file_path, 'r') self._xml.setContent(file.read()) file.close() return True except: self._remove_file() return False def _write_file(self): try: file = open(self.file_path, 'w') file.write(self._xml.toString()) file.close() except: return def _set_attributes(self, element): element.setAttribute('net_daemon_id', self.server.net_daemon_id) element.setAttribute('root', self.session.root) element.setAttribute('session_path', self.session.path) element.setAttribute('pid', os.getpid()) element.setAttribute('port', self.server.port) element.setAttribute('user', os.getenv('USER')) element.setAttribute('not_default', int(bool(self.server.is_nsm_locked or self.server.not_default))) element.setAttribute('has_gui', int(self.server.has_gui())) element.setAttribute('version', ray.VERSION) element.setAttribute('local_gui_pids', self.server.get_local_gui_pid_list()) for locked_path in self._locked_session_paths: locked_paths_xml = self._xml.createElement('locked_session') locked_paths_xml.setAttribute('path', locked_path) element.appendChild(locked_paths_xml) def _clean_dirty_pids(self): xml_content = self._xml.documentElement() nodes = xml_content.childNodes() rm_nodes = [] for i in range(nodes.count()): node = nodes.at(i) dxe = node.toElement() pid = dxe.attribute('pid') if not pid.isdigit() or not self._pid_exists(int(pid)): rm_nodes.append(node) for node in rm_nodes: xml_content.removeChild(node) def update(self): has_dirty_pid = False if not self._open_file(): ds = self._xml.createElement('Daemons') dm_xml = self._xml.createElement('Daemon') self._set_attributes(dm_xml) ds.appendChild(dm_xml) self._xml.appendChild(ds) else: xml_content = self._xml.documentElement() nodes = xml_content.childNodes() self_node = None for i in range(nodes.count()): node = nodes.at(i) dxe = node.toElement() pid = dxe.attribute('pid') if pid.isdigit() and pid == str(os.getpid()): self_node = node elif not pid.isdigit() or not self._pid_exists(int(pid)): has_dirty_pid = True if self_node is not None: xml_content.removeChild(self_node) dm_xml = self._xml.createElement('Daemon') self._set_attributes(dm_xml) self._xml.firstChild().appendChild(dm_xml) if has_dirty_pid: self._clean_dirty_pids() self._write_file() def quit(self): if not self._open_file(): return xml_content = self._xml.documentElement() nodes = xml_content.childNodes() for i in range(nodes.count()): node = nodes.at(i) dxe = node.toElement() pid = dxe.attribute('pid') if pid.isdigit() and pid == str(os.getpid()): break else: return xml_content.removeChild(node) self._write_file() def is_free_for_root(self, daemon_id, root_path)->bool: if not self._open_file(): return True xml_content = self._xml.documentElement() nodes = xml_content.childNodes() for i in range(nodes.count()): node = nodes.at(i) dxe = node.toElement() if (dxe.attribute('net_daemon_id') == str(daemon_id) and dxe.attribute('root') == root_path): pid = dxe.attribute('pid') if pid.isdigit() and self._pid_exists(int(pid)): return False return True def is_free_for_session(self, session_path)->bool: if not self._open_file(): return True xml_content = self._xml.documentElement() nodes = xml_content.childNodes() for i in range(nodes.count()): node = nodes.at(i) dxe = node.toElement() pid = dxe.attribute('pid') if dxe.attribute('session_path') == session_path: if pid.isdigit() and self._pid_exists(int(pid)): return False sub_nodes = node.childNodes() for j in range(sub_nodes.count()): sub_node = sub_nodes.at(j) sub_nod_el = sub_node.toElement() if sub_nod_el.attribute('path') == session_path: if pid.isdigit() and self._pid_exists(int(pid)): return False return True def get_all_session_paths(self)->list: if not self._open_file(): return [] all_session_paths = [] xml_content = self._xml.documentElement() nodes = xml_content.childNodes() for i in range(nodes.count()): node = nodes.at(i) dxe = node.toElement() spath = dxe.attribute('session_path') pid = dxe.attribute('pid') if spath and pid.isdigit() and self._pid_exists(int(pid)): all_session_paths.append(spath) return all_session_paths def add_locked_path(self, path:str): self._locked_session_paths.add(path) self.update() def unlock_path(self, path:str): self._locked_session_paths.discard(path) self.update() def get_daemon_list(self)->list: daemon_list = [] has_dirty_pid = False if not self._open_file(): return daemon_list xml_content = self._xml.documentElement() nodes = xml_content.childNodes() for i in range(nodes.count()): node = nodes.at(i) dxe = node.toElement() daemon = Daemon() daemon.root = dxe.attribute('root') daemon.session_path = dxe.attribute('session_path') daemon.user = dxe.attribute('user') daemon.not_default = bool(dxe.attribute('not_default') == 'true') net_daemon_id = dxe.attribute('net_daemon_id') pid = dxe.attribute('pid') port = dxe.attribute('port') if net_daemon_id.isdigit(): daemon.net_daemon_id = net_daemon_id if pid.isdigit(): daemon.pid = pid if port.isdigit(): daemon.port = port if not self._pid_exists(daemon.pid): has_dirty_pid = True continue if not (daemon.net_daemon_id and daemon.pid and daemon.port): continue daemon_list.append(daemon) if has_dirty_pid: self._clean_dirty_pids() return daemon_list
class GrapholExporter(AbstractExporter): """ This class can be used to export Graphol diagrams to file. """ def __init__(self, scene): """ Initialize the Graphol exporter. :type scene: DiagramScene """ super().__init__(scene) self.document = None self.itemToXml = { Item.AttributeNode: 'attribute', Item.ComplementNode: 'complement', Item.ConceptNode: 'concept', Item.DatatypeRestrictionNode: 'datatype-restriction', Item.DisjointUnionNode: 'disjoint-union', Item.DomainRestrictionNode: 'domain-restriction', Item.EnumerationNode: 'enumeration', Item.IndividualNode: 'individual', Item.IntersectionNode: 'intersection', Item.PropertyAssertionNode: 'property-assertion', Item.RangeRestrictionNode: 'range-restriction', Item.RoleNode: 'role', Item.RoleChainNode: 'role-chain', Item.RoleInverseNode: 'role-inverse', Item.UnionNode: 'union', Item.ValueDomainNode: 'value-domain', Item.ValueRestrictionNode: 'value-restriction', Item.InclusionEdge: 'inclusion', Item.InputEdge: 'input', Item.InstanceOfEdge: 'instance-of', } #################################################################################################################### # # # NODES # # # #################################################################################################################### def exportAttributeNode(self, node): """ Export the given node into a QDomElement. :type node: AttributeNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportComplementNode(self, node): """ Export the given node into a QDomElement. :type node: ComplementNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportConceptNode(self, node): """ Export the given node into a QDomElement. :type node: ConceptNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportDatatypeRestrictionNode(self, node): """ Export the given node into a QDomElement. :type node: DatatypeRestrictionNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportDisjointUnionNode(self, node): """ Export the given node into a QDomElement. :type node: DisjointUnionNode :rtype: QDomElement """ return self.exportGenericNode(node) def exportDomainRestrictionNode(self, node): """ Export the given node into a QDomElement. :type node: DomainRestrictionNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportEnumerationNode(self, node): """ Export the given node into a QDomElement. :type node: EnumerationNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportIndividualNode(self, node): """ Export the given node into a QDomElement. :type node: IndividualNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportIntersectionNode(self, node): """ Export the given node into a QDomElement. :type node: IntersectionNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportPropertyAssertionNode(self, node): """ Export the given node into a QDomElement. :type node: PropertyAssertionNode :rtype: QDomElement """ element = self.exportGenericNode(node) element.setAttribute('inputs', ','.join(node.inputs)) return element def exportRangeRestrictionNode(self, node): """ Export the given node into a QDomElement. :type node: RangeRestrictionNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportRoleNode(self, node): """ Export the given node into a QDomElement. :type node: RoleNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportRoleChainNode(self, node): """ Export the given node into a QDomElement. :type node: RoleChainNode :rtype: QDomElement """ element = self.exportLabelNode(node) element.setAttribute('inputs', ','.join(node.inputs)) return element def exportRoleInverseNode(self, node): """ Export the given node into a QDomElement. :type node: RoleInverseNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportValueDomainNode(self, node): """ Export the given node into a QDomElement. :type node: ValueDomainNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportUnionNode(self, node): """ Export the given node into a QDomElement. :type node: UnionNode :rtype: QDomElement """ return self.exportLabelNode(node) def exportValueRestrictionNode(self, node): """ Export the given node into a QDomElement. :type node: ValueRestrictionNode :rtype: QDomElement """ return self.exportLabelNode(node) #################################################################################################################### # # # EDGES # # # #################################################################################################################### def exportInclusionEdge(self, edge): """ Export the given edge into a QDomElement. :type edge: InclusionEdge :rtype: QDomElement """ element = self.exportGenericEdge(edge) element.setAttribute('complete', int(edge.complete)) return element def exportInputEdge(self, edge): """ Export the given edge into a QDomElement. :type edge: InputEdge :rtype: QDomElement """ return self.exportGenericEdge(edge) def exportInstanceOfEdge(self, edge): """ Export the given edge into a QDomElement. :type edge: InstanceOf :rtype: QDomElement """ return self.exportGenericEdge(edge) #################################################################################################################### # # # METADATA # # # #################################################################################################################### def exportPredicateMetadata(self, item, predicate): """ Export given predicate metadata. :type item: Item :type predicate: str :rtype: QDomElement """ meta = self.scene.meta.metaFor(item, predicate) if meta: element = self.document.createElement('meta') element.setAttribute('type', self.itemToXml[item]) element.setAttribute('predicate', predicate) url = self.document.createElement('data:url') url.appendChild(self.document.createTextNode(meta.url)) description = self.document.createElement('data:description') description.appendChild(self.document.createTextNode(meta.description)) element.appendChild(url) element.appendChild(description) return element return None def exportAttributeMetadata(self, item, predicate): """ Export given attribute metadata. :type item: Item :type predicate: str :rtype: QDomElement """ element = self.exportPredicateMetadata(item, predicate) if element: meta = self.scene.meta.metaFor(item, predicate) if meta: functionality = self.document.createElement('data:functionality') functionality.appendChild(self.document.createTextNode(str(int(meta.functionality)))) element.appendChild(functionality) return element return None def exportRoleMetadata(self, item, predicate): """ Export given role metadata :type item: Item :type predicate: str :rtype: QDomElement """ element = self.exportPredicateMetadata(item, predicate) if element: meta = self.scene.meta.metaFor(item, predicate) if meta: functionality = self.document.createElement('data:functionality') functionality.appendChild(self.document.createTextNode(str(int(meta.functionality)))) inverseFunctionality = self.document.createElement('data:inverseFunctionality') inverseFunctionality.appendChild(self.document.createTextNode(str(int(meta.inverseFunctionality)))) asymmetry = self.document.createElement('data:asymmetry') asymmetry.appendChild(self.document.createTextNode(str(int(meta.asymmetry)))) irreflexivity = self.document.createElement('data:irreflexivity') irreflexivity.appendChild(self.document.createTextNode(str(int(meta.irreflexivity)))) reflexivity = self.document.createElement('data:reflexivity') reflexivity.appendChild(self.document.createTextNode(str(int(meta.reflexivity)))) symmetry = self.document.createElement('data:symmetry') symmetry.appendChild(self.document.createTextNode(str(int(meta.symmetry)))) transitivity = self.document.createElement('data:transitivity') transitivity.appendChild(self.document.createTextNode(str(int(meta.transitivity)))) element.appendChild(functionality) element.appendChild(inverseFunctionality) element.appendChild(asymmetry) element.appendChild(irreflexivity) element.appendChild(reflexivity) element.appendChild(symmetry) element.appendChild(transitivity) return element return None #################################################################################################################### # # # AUXILIARY METHODS # # # #################################################################################################################### def exportLabelNode(self, node): """ Export the given node into a QDomElement. :type node: AbstractNode :rtype: QDomElement """ position = node.mapToScene(node.textPos()) label = self.document.createElement('shape:label') label.setAttribute('height', node.label.height()) label.setAttribute('width', node.label.width()) label.setAttribute('x', position.x()) label.setAttribute('y', position.y()) label.appendChild(self.document.createTextNode(node.text())) element = self.exportGenericNode(node) element.appendChild(label) return element def exportGenericEdge(self, edge): """ Export the given node into a QDomElement. :type edge: AbstractEdge :rtype: QDomElement """ element = self.document.createElement('edge') element.setAttribute('source', edge.source.id) element.setAttribute('target', edge.target.id) element.setAttribute('id', edge.id) element.setAttribute('type', self.itemToXml[edge.item]) for p in [edge.source.anchor(edge)] + edge.breakpoints + [edge.target.anchor(edge)]: point = self.document.createElement('line:point') point.setAttribute('x', p.x()) point.setAttribute('y', p.y()) element.appendChild(point) return element def exportGenericNode(self, node): """ Export the given node into a QDomElement. :type node: AbstractNode :rtype: QDomElement """ element = self.document.createElement('node') element.setAttribute('id', node.id) element.setAttribute('type', self.itemToXml[node.item]) element.setAttribute('color', node.brush.color().name()) geometry = self.document.createElement('shape:geometry') geometry.setAttribute('height', node.height()) geometry.setAttribute('width', node.width()) geometry.setAttribute('x', node.pos().x()) geometry.setAttribute('y', node.pos().y()) element.appendChild(geometry) return element #################################################################################################################### # # # DOCUMENT EXPORT # # # #################################################################################################################### def export(self, indent=4): """ Export the coverted ontology. :type indent: int :rtype: str """ return self.document.toString(indent) #################################################################################################################### # # # DOCUMENT GENERATION # # # #################################################################################################################### def run(self): """ Perform Graphol ontology generation. """ # 1) CREATE THE DOCUMENT self.document = QDomDocument() self.document.appendChild(self.document.createProcessingInstruction('xml', 'version="1.0" ' 'encoding="UTF-8" ' 'standalone="no"')) # 2) CREATE ROOT ELEMENT root = self.document.createElement('graphol') root.setAttribute('xmlns', 'http://www.dis.uniroma1.it/~graphol/schema') root.setAttribute('xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance') root.setAttribute('xmlns:data', 'http://www.dis.uniroma1.it/~graphol/schema/data') root.setAttribute('xmlns:line', 'http://www.dis.uniroma1.it/~graphol/schema/line') root.setAttribute('xmlns:shape', 'http://www.dis.uniroma1.it/~graphol/schema/shape') root.setAttribute('xsi:schemaLocation', 'http://www.dis.uniroma1.it/~graphol/schema ' 'http://www.dis.uniroma1.it/~graphol/schema/graphol.xsd') self.document.appendChild(root) # 3) CREATE THE GRAPH NODE graph = self.document.createElement('graph') graph.setAttribute('width', self.scene.sceneRect().width()) graph.setAttribute('height', self.scene.sceneRect().height()) # 4) GENERATE NODES for node in self.scene.nodes(): element = None if node.item is Item.AttributeNode: element = self.exportAttributeNode(node) elif node.item is Item.ComplementNode: element = self.exportComplementNode(node) elif node.item is Item.ConceptNode: element = self.exportConceptNode(node) elif node.item is Item.DatatypeRestrictionNode: element = self.exportDatatypeRestrictionNode(node) elif node.item is Item.DisjointUnionNode: element = self.exportDisjointUnionNode(node) elif node.item is Item.DomainRestrictionNode: element = self.exportDomainRestrictionNode(node) elif node.item is Item.EnumerationNode: element = self.exportEnumerationNode(node) elif node.item is Item.IndividualNode: element = self.exportIndividualNode(node) elif node.item is Item.IntersectionNode: element = self.exportIntersectionNode(node) elif node.item is Item.PropertyAssertionNode: element = self.exportPropertyAssertionNode(node) elif node.item is Item.RangeRestrictionNode: element = self.exportRangeRestrictionNode(node) elif node.item is Item.RoleNode: element = self.exportRoleNode(node) elif node.item is Item.RoleChainNode: element = self.exportRoleChainNode(node) elif node.item is Item.RoleInverseNode: element = self.exportRoleInverseNode(node) elif node.item is Item.UnionNode: element = self.exportUnionNode(node) elif node.item is Item.ValueDomainNode: element = self.exportValueDomainNode(node) elif node.item is Item.ValueRestrictionNode: element = self.exportValueRestrictionNode(node) if not element: raise ValueError('unknown node: {}'.format(node)) graph.appendChild(element) # 5) GENERATE EDGES for edge in self.scene.edges(): element = None if edge.item is Item.InclusionEdge: element = self.exportInclusionEdge(edge) elif edge.item is Item.InputEdge: element = self.exportInputEdge(edge) elif edge.item is Item.InstanceOfEdge: element = self.exportInstanceOfEdge(edge) if not element: raise ValueError('unknown edge: {}'.format(edge)) graph.appendChild(element) # 6) APPEND THE GRAPH TO THE DOCUMENT root.appendChild(graph) # 7) GENERATE NODES META DATA collection = [] for item, predicate in self.scene.meta.entries(): if item is Item.RoleNode: element = self.exportRoleMetadata(item, predicate) elif item is Item.AttributeNode: element = self.exportAttributeMetadata(item, predicate) else: element = self.exportPredicateMetadata(item, predicate) if element: collection.append(element) if collection: metadata = self.document.createElement('metadata') for element in collection: metadata.appendChild(element) root.appendChild(metadata)
def SeveToFile(self, path): #print(path) f = QFile(path) if f.open(QIODevice.WriteOnly): stream = QTextStream(f) stream.setCodec("UTF-8") doc = QDomDocument() xmlInstruct = doc.createProcessingInstruction( "xml", "version=\"1\" encoding=\"UTF-8\"") doc.appendChild(xmlInstruct) mainEl = doc.createElement("Nodes") doc.appendChild(mainEl) for i in range(0, len(self.nodes)): objectEl = doc.createElement("Node") mainEl.appendChild(objectEl) idoEl = doc.createElement("Id") objectEl.appendChild(idoEl) idoEltext = doc.createTextNode(str(i)) idoEl.appendChild(idoEltext) typeEl = doc.createElement("Type") objectEl.appendChild(typeEl) nameEltext = doc.createTextNode(type(self.nodes[i]).__name__) typeEl.appendChild(nameEltext) posEl = doc.createElement("Pos") objectEl.appendChild(posEl) pos = self.nodes[i].item.scenePos() posEltext = doc.createTextNode( str(pos.x()) + "," + str(pos.y())) posEl.appendChild(posEltext) liksEl = doc.createElement("Links") objectEl.appendChild(liksEl) inputs = self.nodes[i].inputs for j in range(0, len(inputs)): if inputs[j].node is not None: linkEl = doc.createElement("Link") liksEl.appendChild(linkEl) idEl = doc.createElement("Id") linkEl.appendChild(idEl) idEltext = doc.createTextNode(str(j)) idEl.appendChild(idEltext) nodeEl = doc.createElement("Node") linkEl.appendChild(nodeEl) idnEltext = doc.createTextNode( str(self.indexOfNode(inputs[j].node))) nodeEl.appendChild(idnEltext) outEl = doc.createElement("Out") linkEl.appendChild(outEl) outEltext = doc.createTextNode(str(inputs[j].out)) outEl.appendChild(outEltext) doc.save(stream, 4) f.close() return True return False
def export(self): # open the appropriate file... svgFile = open(self.fileName + "/" + self.paletteName + ".svg", "w") svgDoc = QDomDocument() svgBaseElement = svgDoc.createElement("svg") svgBaseElement.setAttribute( "xmlns:osb", "http://www.openswatchbook.org/uri/2009/osb") svgBaseElement.setAttribute("xmlns:svg", "http://www.w3.org/2000/svg") svgBaseElement.setAttribute("xmlns:dc", "http://purl.org/dc/elements/1.1/") svgBaseElement.setAttribute("xmlns:cc", "http://creativecommons.org/ns#") svgBaseElement.setAttribute( "xmlns:rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#") svgDefs = svgDoc.createElement("defs") svgSwatches = svgDoc.createElement("g") svgSwatches.setAttribute("id", "Swatches") svgMeta = svgDoc.createElement("metadata") svgBaseElement.appendChild(svgMeta) rdf = svgDoc.createElement("rdf:RDF") ccwork = svgDoc.createElement("cc:Work") dctitle = svgDoc.createElement("dc:title") dcdescription = svgDoc.createElement("dc:description") dctitle.appendChild(svgDoc.createTextNode(self.paletteName)) dcdescription.appendChild( svgDoc.createTextNode(self.currentPalette.comment())) ccwork.appendChild(dctitle) ccwork.appendChild(dcdescription) rdf.appendChild(ccwork) svgMeta.appendChild(rdf) Row = 0 Column = 0 iccProfileList = [] colorCount = self.currentPalette.colorsCountGroup("") for i in range(colorCount): entry = self.currentPalette.colorSetEntryFromGroup(i, "") color = self.currentPalette.colorForEntry(entry) iccColor = "icc-color(" + color.colorProfile() for c in range(len(color.componentsOrdered()) - 1): iccColor = "{col},{c}".format(col=iccColor, c=color.componentsOrdered()[c]) iccColor = iccColor + ")" if color.colorProfile() not in iccProfileList: iccProfileList.append(color.colorProfile()) # convert to sRGB color.setColorSpace("RGBA", "U8", "sRGB built-in") red = max(min(int(color.componentsOrdered()[0] * 255), 255), 0) green = max(min(int(color.componentsOrdered()[1] * 255), 255), 0) blue = max(min(int(color.componentsOrdered()[2] * 255), 255), 0) hexcode = "#{red:02x}{green:02x}{blue:02x}".format(red=red, green=green, blue=blue) swatchName = "{i}-{name}".format(i=i, name=entry.name()) swatchName = swatchName.replace(" ", "-") swatchName = swatchName.replace("(", "-") swatchName = swatchName.replace(")", "-") swatchMain = svgDoc.createElement("linearGradient") swatchMain.setAttribute("osb:paint", "solid") swatchMain.setAttribute("id", swatchName) swatchSub = svgDoc.createElement("stop") swatchSub.setAttribute( "style", "stop-color: {hex} {color};stop-opacity:1;".format( hex=hexcode, color=iccColor)) swatchMain.appendChild(swatchSub) svgDefs.appendChild(swatchMain) svgSingleSwatch = svgDoc.createElement("rect") svgSingleSwatch.setAttribute("x", str(int(Column * 20))) svgSingleSwatch.setAttribute("y", str(int(Row * 20))) svgSingleSwatch.setAttribute("width", str(int(20))) svgSingleSwatch.setAttribute("height", str(int(20))) svgSingleSwatch.setAttribute("fill", "url(#%s)" % swatchName) svgSingleSwatch.setAttribute("id", "swatch %s" % swatchName) if entry.spotColor() is True: svgSingleSwatch.setAttribute("rx", str(10)) svgSingleSwatch.setAttribute("ry", str(10)) svgSwatches.appendChild(svgSingleSwatch) Column += 1 if (Column >= self.currentPalette.columnCount()): Column = 0 Row += 1 groupNames = self.currentPalette.groupNames() for groupName in groupNames: Column = 0 Row += 1 groupTitle = svgDoc.createElement("text") groupTitle.setAttribute("x", str(int(Column * 20))) groupTitle.setAttribute("y", str(int(Row * 20) + 15)) groupTitle.appendChild(svgDoc.createTextNode(groupName)) svgSwatches.appendChild(groupTitle) Row += 1 colorCount = self.currentPalette.colorsCountGroup(groupName) for i in range(colorCount): entry = self.currentPalette.colorSetEntryFromGroup( i, groupName) color = self.currentPalette.colorForEntry(entry) iccColor = "icc-color(" + color.colorProfile() for c in range(len(color.componentsOrdered()) - 1): iccColor = "{col},{c}".format( col=iccColor, c=color.componentsOrdered()[c]) iccColor = iccColor + ")" if color.colorProfile() not in iccProfileList: iccProfileList.append(color.colorProfile()) # convert to sRGB color.setColorSpace("RGBA", "U8", "sRGB built-in") red = max(min(int(color.componentsOrdered()[0] * 255), 255), 0) green = max(min(int(color.componentsOrdered()[1] * 255), 255), 0) blue = max(min(int(color.componentsOrdered()[2] * 255), 255), 0) hexcode = "#{red:02x}{green:02x}{blue:02x}".format(red=red, green=green, blue=blue) swatchName = groupName + str(i) + "-" + entry.name() swatchName = swatchName.replace(" ", "-") swatchName = swatchName.replace("(", "-") swatchName = swatchName.replace(")", "-") swatchMain = svgDoc.createElement("linearGradient") swatchMain.setAttribute("osb:paint", "solid") swatchMain.setAttribute("id", swatchName) swatchSub = svgDoc.createElement("stop") swatchSub.setAttribute( "style", "stop-color: {hex} {color};stop-opacity:1;".format( hex=hexcode, color=iccColor)) swatchMain.appendChild(swatchSub) svgDefs.appendChild(swatchMain) svgSingleSwatch = svgDoc.createElement("rect") svgSingleSwatch.setAttribute("x", str(int(Column * 20))) svgSingleSwatch.setAttribute("y", str(int(Row * 20))) svgSingleSwatch.setAttribute("width", str(int(20))) svgSingleSwatch.setAttribute("height", str(int(20))) svgSingleSwatch.setAttribute("fill", "url(#%s)" % swatchName) svgSingleSwatch.setAttribute("id", "swatch %s" % swatchName) if entry.spotColor() is True: svgSingleSwatch.setAttribute("rx", str(10)) svgSingleSwatch.setAttribute("ry", str(10)) svgSwatches.appendChild(svgSingleSwatch) Column += 1 if (Column >= self.currentPalette.columnCount()): Column = 0 Row += 1 for profile in iccProfileList: svgProfileDesc = svgDoc.createElement("color-profile") svgProfileDesc.setAttribute("name", profile) # This is incomplete because python api doesn't have any # way to ask for this data yet. # svgProfileDesc.setAttribute("local", "sRGB") # svgProfileDesc.setAttribute("xlink:href", colorprofileurl) svgProfileDesc.setAttribute("rendering-intent", "perceptual") svgDefs.appendChild(svgProfileDesc) svgBaseElement.appendChild(svgDefs) svgBaseElement.appendChild(svgSwatches) svgBaseElement.setAttribute( "viewBox", "0 0 {cols} {row}".format( cols=self.currentPalette.columnCount() * 20, row=int((Row + 1) * 20))) svgDoc.appendChild(svgBaseElement) svgFile.write(svgDoc.toString()) svgFile.close()