#add AUTO_INCREMENT
if (a[3] == 1 and re.match('.*int.*',a[1],re.I)) :
tables[table] += ' AUTO_INCREMENT'
#Commens
if (len(a[2])>1) :
tables[table] += ' COMMENT "%s"' % (a[2])
tables[table] += '\n'
elif o.type.name == 'Database - Reference':
continue
'''src = o.properties['start_point_desc'].value.split('.')
desc = o.properties['end_point_desc'].value.split('.')
if len(src) != 2 and len(desc) != 2:
continue
if not tables.has_key(desc[0]):
tables[desc[0]] = ''
tables[desc[0]] += '%0.3d\tFOREIGN KEY (%s) REFERENCES %s(%s)\n' % (priority['foreign_keys'],desc[1],src[0],src[1])'''
for k in tables.keys():
self.f.write('\n-- %s --\nDROP TABLE IF EXISTS `%s`;\n' % (k,k) )
self.f.write ('CREATE TABLE IF NOT EXISTS `%s` (\n' % k)
sentences = sorted( tables[k].split('\n') )
sentences = [str(s[3:]) for s in sentences if len(s)>4]
sentences = ",\n".join( sentences)
self.f.write ('%s\n' % sentences)
self.f.write (') ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;\n')
def end_render (self) :
self.f.write ('-- End SQL-Dump\n')
self.f.close()
# reference
dia.register_export ("SICASQL generado de esquema en SQL", "sql", SQLRenderer())
if join == 0 : # MITER
pass # st = st + ' stroke-linejoin="bevel"'
elif join == 1 : # ROUND
st = st + ' stroke-linejoin="round"'
elif join == 2 : # BEVEL
st = st + ' stroke-linejoin="bevel"'
if caps == 0 : # BUTT
pass # default stroke-linecap="butt"
elif caps == 1 : # ROUND
st = st + ' stroke-linecap="round"'
elif caps == 2 : # PROJECTING
st = st + ' stroke-linecap="square"' # is this the same ?
return st
class SvgzRenderer(SvgRenderer) :
def _open(self, filename) :
# There is some (here) not wanted behaviour in gzip.open/GzipFile :
# the filename with path is not only used to adress the file but also
# completely stored in the file itself. Correct it here.
import os, os.path, gzip
path, name = os.path.split(filename)
os.chdir(path)
self.f = gzip.open (name, "wb")
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export ("SVG plain", "svg", SvgRenderer())
dia.register_export ("SVG compressed", "svgz", SvgzRenderer())
if o.type.name == 'Database - Table' :
if o.properties.has_key ("name") :
table = o.properties["name"].value
self.f.write('\n\n#Section %s\n#%s' % (table,"="*79) )
else :
continue
if len(table) == 0 or string.find (table, " ") >= 0 :
continue
if not tables.has_key(table):
tables[table] = ''
atributes = o.properties['attributes'].value
for i in range(0,len(atributes)):
a = atributes[i]
if len(a[0])<1:
continue
#convirtiendo los campos de referencia 'table_id' a 'table'
inputName = re.sub('_id$', '', a[0],1)
self.f.write('\n\n#%s.%s' % (table,inputName ))
comment = a[2].split('\n')
if len(comment)>0 and len(comment[0])>0:
self.append_nmsgid(self.camel_field(inputName), comment[0])
if len(comment)>1 and len(comment[1])>0:
self.append_nmsgid(table+'.'+inputName, comment[1])
def end_render (self) :
self.f.close()
# reference
dia.register_export ("SICACakePHP archivo de traducción", "po", PORenderer())
def end_render(self):
module = self.data_get()['module']
xip = zipfile.ZipFile(self.filename, 'w')
zip_files = {
'__init__.py': env.get_template('__init__.py').render(module=module, packages=['models']),
'__openerp__.py': env.get_template('__openerp__.py').render(module=module, data=self, packages=self.packages.keys()),
'models/__init__.py': env.get_template('models/__init__.py').render(module=module, data=self, packages=self.packages.keys()),
'views/menu.xml': env.get_template('menu.xml').render(module=module, data=self, packages=self.packages.keys()),
'security/ir.model.access.csv': env.get_template('security/ir.model.access.csv').render(module=module, data=self),
}
for name, package in self.packages.items():
zip_files['models/{package}.py'.format(package=package.name)] = env.get_template('models/package.py').render(module=module, data=self, package=package, models=package.classes)
zip_files['views/{package}.xml'.format(package=package.name)] = env.get_template('view.xml').render(module=module, data=self, package=package, models=package.classes)
for name, datastr in zip_files.items():
info = zipfile.ZipInfo(module + '/' + name)
info.compress_type = zipfile.ZIP_DEFLATED
info.external_attr = 2175008768
xip.writestr(info, datastr)
xip.close()
ObjRenderer.end_render(self)
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export("PyDia Code Generation (Odoo v8)", "zip", OdooRenderer())
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
+ str(r.right) + "," + str(r.bottom) + "</bbox>\n")
self.f.write("\t" * 2 + "<connections>\n")
for c in o.connections:
if (len(c.connected) < 1):
continue
self.f.write("\t" * 3 + str(c) + "\n")
for co in c.connected:
self.f.write("\t" * 4 + str(co) + "\n")
self.f.write("\t" * 3 + "</DiaConnectionPoint>\n")
self.f.write("\t" * 2 + "</connections>\n")
self.f.write("\t" * 2 + str(o.properties) + "\n")
keys = list(o.properties.keys())
for s in keys:
self.f.write("\t" * 3 + str(o.properties[s]) + "\n")
if o.properties[s].type == "string":
self.f.write("\t" * 3 + str(o.properties[s].value) +
"\n")
self.f.write("\t" * 3 + "</DiaProperty>\n")
self.f.write("\t" * 2 + "</DiaProperties>\n")
self.f.write("\t" * 1 + "</DiaObject>\n\n")
self.f.write("\t" * 0 + "</layer>\n")
def end_render(self):
self.f.close()
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export(_("PyDia Object Export"), "diapyo", ObjRenderer())
if klass.inheritance_type == "template" or method[3] == 0:
f.write(";\n\n")
else:
f.write(
"\n\t{\n\t\t// TODO Auto-generated method stub\n\t}\n\n"
)
f.write("}\n\n")
f.close()
mainfile.write(" *\t%s\n" % classfile)
mainfile.write(" */\n")
mainfile.close()
ObjRenderer.end_render(self)
def fill_rect(*args):
pass
def draw_line(*args):
pass
def draw_string(*args):
pass
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export("PyDia Code Generation (Python)", "py", PyRenderer())
dia.register_export("PyDia Code Generation (C++)", "cxx", CxxRenderer())
dia.register_export("PyDia Code Generation (Pascal)", "pas", PascalRenderer())
dia.register_export("PyDia Code Generation (Java)", "java", JavaRenderer())
dia.register_export("PyDia Code Generation (JavaScript)", "js", JsRenderer())
dia.register_export("PyDia Code Generation (PHP)", "php", PhpRenderer())
for methodname, method in klass.operations :
if method[4]: f.write("\t/** %s */\n" % method[4])
# if there are no parameter names, something else should appear
pars = []
v = ord("a")
for name, type, value, comment, kind in method[2]:
#TODO: also use: value, comment, kind
if not name:
pars.append((type,chr(v)))
v += 1
else: pars.append((type,name))
pars = ", ".join([type+" "+name for type, name in pars])
vis = method[1] in visibilities and visibilities[method[1]] or ""
returntype = method[0]=="" and "void" or method[0]
inheritance_type = method[3]==0 and "abstract " or ""
static = method[4] and "static " or ""
f.write("\t%s %s%s%s %s (%s)" % (vis, static, inheritance_type, returntype, methodname, pars))
if klass.inheritance_type == "template" or method[3]==0:
f.write(";\n\n")
else: f.write(" {\n\t\t\n\t}\n\n")
f.write ("}\n\n")
f.close()
ObjRenderer.end_render(self)
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export ("PyDia Code Generation (Python)", "py", PyRenderer())
dia.register_export ("PyDia Code Generation (C++)", "cxx", CxxRenderer())
dia.register_export ("PyDia Code Generation (Pascal)", "pas", PascalRenderer())
dia.register_export ("PyDia Code Generation (Java)", "java", JavaRenderer())
comment = ops["__init__"][0].Comment()
else:
params = []
indent = NCGenConfig.indent
self.out.write("%sdef __init__(%s)\n"
% (indent, self._strParameters(params)))
indent = indent * 2
self._conditionallyWriteDocComment(comment,indent)
strAttribs = ''
for a in attribs.itervalues():
if not a.HasClassScope():
strAttribs = ''.join([strAttribs,indent,"self.", a.Name(), " = "
, a.Name() if attribHasParam(a,params) else "None", "\n"])
self.out.write(strAttribs if strAttribs else "%spass\n"%indent)
def _strParameters(self, params, isClassMethod=False):
strParams = 'cls' if isClassMethod else 'self'
for p in params:
strParams = ''.join([strParams,', ',p.Name(),ConditionallyPrefix("=",p.Value())])
return strParams
def _conditionallyWriteDocComment(self, comment, indent):
if comment and (comment!="(NULL)"):
self.out.write("%s''' %s '''\n" % (indent, comment))
class PythonCodeGenRenderer(CodeGenRenderer):
''' Python specific CodeGenRenderer subclass '''
def __init__(self):
CodeGenRenderer.__init__(self, PythonWriter)
# Register the code generation export renderers with Dia
dia.register_export ("Next Gen Dia Code Generation (Python)", "py", PythonCodeGenRenderer())
value = 1
generated = []
for transition in self.transitions:
if len(transition.trigger) > 0:
if transition.trigger not in generated:
generated.append(transition.trigger)
f.write("#define %s_%s_EVENT 0x%02x \n" %
(self.basename.upper(), transition.trigger.upper(),
value))
value = value * 2
f.write("\n")
def generate_states_typedef(self, f):
f.write("typedef enum _%s_fsm_st_t\n{\n" % (self.basename))
states_keys_list = self.states.keys()
for key in states_keys_list:
state = self.states[key].name
if key == states_keys_list[-1]:
f.write("\t%s_%s_fsm_st\n" % (self.basename, state))
else:
f.write("\t%s_%s_fsm_st,\n" % (self.basename, state))
f.write("} %s_fsm_st_t;\n" % (self.basename))
f.write("\n")
INITIAL_STATE, STANDARD_STATE, FINAL_STATE = range(3)
SM_EXPORT_VERSION = "2.1"
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export("State Machine C code export", "fsm", DiagramRenderer())
"# source_state,target_state,trigger,action\n" + \
"# [STATES] is states zone begin tag\n" + \
"# [TRANSITIONS] is transitions zone begin tag\n" + \
"#---------------------------------------------------------\n"
def __init__(self):
uml_stm_export.SimpleSTM.__init__(self)
self.filename = ""
def begin_render (self, data, filename):
self.filename = filename
uml_stm_export.SimpleSTM.parse(self, data)
def end_render(self) :
f = open(self.filename, "w")
f.write(self.CODE_PREAMBLE)
f.write("[STATES]\n")
for key in self.states.keys():
state = self.states[key]
f.write("%s, %s, %s\n" % (state.name, state.iaction, state.oaction))
f.write("[TRANSITIONS]\n")
for transition in self.transitions:
f.write("%s, %s, %s, %s\n" % (transition.source, transition.target, transition.trigger, transition.action))
f.close()
self.states = {}
self.transitions = []
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export("State Machine Textual Dump", "txt", TxtDiagramRenderer())
fun,
bp.type,
))
def draw_bezier(self, bezpoints, color):
if len(bezpoints) < 2:
self.Error("draw_bezier too few points")
self._bezier(bezpoints, "draw_bezier")
def fill_bezier(self, bezpoints, color):
if len(bezpoints) < 3:
self.Error("fill_bezier too few points")
self._bezier(bezpoints, "fill_bezier")
def draw_string(self, text, pos, alignment, color):
if len(text) < 1:
self.Warning("draw_string empty text")
if alignment < 0 or alignment > 2:
self.Error("draw_string unknown alignmern '%d'" % (alignment, ))
def draw_image(self, point, width, height, image):
if width <= 0:
self.Warning("draw_image width too small")
if height <= 0:
self.Warning("draw_image height too small")
# XXX: check image, e.g. existing file name
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export("Dissect", "dissect", DissectRenderer())
hbox.show()
self.win.set_position(gtk.WIN_POS_CENTER)
self.win.show()
# set up as a dia plugin
try :
import dia
def open_dialog_import(data, flags):
ImportDbDialog(data, "import")
def open_dialog_export(data, flags):
ImportDbDialog(data, "export")
dia.register_action ("DialogsPostgresImp", "Import Postgres database",
"/DisplayMenu/Dialogs/DialogsExtensionStart",
open_dialog_import)
dia.register_action ("DialogsPostgresExp", "Export diagram to Postgres",
"/DisplayMenu/Dialogs/DialogsExtensionStart",
open_dialog_export)
dia.register_export ("Postgres SQL Export", "sql", SQLRenderer())
except :
print 'Failed to import Dia ...'
ImportDbDialog(None, "import")
gtk.main()
tables[table] += '"auto_increment": false'
tables[table] += '}\n'
elif o.type.name == 'Database - Reference':
#for p in o.properties.keys():
# print p, '\t', o.properties[p]
continue
tbs=''
for k in tables.keys():
tbs += '{\n"nombre" : "%s",\n' % k
tbs += values[k]
tbs += '"campos" : [\n'
campos = sorted( tables[k].split('\n') )
campos = [str(s[3:]) for s in campos if len(s)>4] #
campos = ",\n".join( campos)
tbs += '%s\n' % campos
tbs += ' ]\n},\n'
if len(tables)>1 :
tbs = '%s' % tbs[0:-2]
self.f.write (tbs)
def end_render (self) :
self.f.write ("\n]")
self.f.close()
# reference
def rgb (color) :
#convert the color into a string in RGB
rgb = "#%02X%02X%02X" #% (int(255 * color.red), int(color.green * 255), int(color.blue * 255))
return rgb
dia.register_export ("SICAJSON exportar datos en formato JSON(JavaScript Object Notation)", "js", JSONRenderer())
f.write(" add_initial_state( stm, %s, %s );\n" %
(initial_state.name, initial_state.doaction))
for key in self.states.keys():
state = self.states[key]
# initial_state has already been output
# TODO: the fact that state can be None looks like a bug to me
if (state != None and state.name != initial_state.name):
f.write(" add_state( stm, %s, %s );\n" %
(state.name, state.doaction))
# (state.name, state.iaction, state.oaction, state.doaction)
f.write(self.TRANSITIONS_PREAMBLE)
for transition in self.transitions:
if (transition.source == "INITIAL_STATE"):
continue # skip the initial state transition
f.write(" add_transition( stm, %s, %s, %s );\n" %
(transition.source, transition.trigger, transition.target))
# (transition.source, transition.trigger, transition.target, transition.action))
f.write(self.CODE_POSTAMBLE)
f.close()
self.states = {}
self.transitions = []
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export("State Machine Cstma Dump", "c", CDiagramRenderer())
def WriteTables (self, layer):
for o in layer.objects :
if o.type.name == 'Database - Table' :
if not o.properties.has_key ("name") :
continue
if not o.properties["name"].value == self.fileName :
continue
atributes = o.properties['attributes'].value
for i in range(0,len(atributes)):
a = atributes[i]
if len(a[0])<1:
continue
inputName = a[0]
comment = a[2].split('\n')
if len(comment)>0 and len(comment[0])>0:
inputName = comment[0]
if len(inputName)<1:
continue
self.f.write('\n\t<th width="%spx">%s</th>' % (10*len( inputName), inputName))
self.count = self.count + 1
def end_render (self) :
#Me latio esta implementacion se me hiso bastante H4ck!
self.f.write ('\n</tr>\n<tr>%s\n</tr>\n</table>' % ('\n\t<td></td>'* self.count))
self.f.write('\n</body>\n</html>')
self.f.close()
# Bind reference
dia.register_export ("SICAODS Hoja Calculo para el oocalc", "ods", CalcRender())
hbox.show()
self.win.set_position(gtk.WIN_POS_CENTER)
self.win.show()
# set up as a dia plugin
try:
import dia
def open_dialog_import(data, flags):
ImportDbDialog(data, "import")
def open_dialog_export(data, flags):
ImportDbDialog(data, "export")
dia.register_action("DialogsPostgresImp", "Import Postgres database",
"/DisplayMenu/Dialogs/DialogsExtensionStart",
open_dialog_import)
dia.register_action("DialogsPostgresExp", "Export diagram to Postgres",
"/DisplayMenu/Dialogs/DialogsExtensionStart",
open_dialog_export)
dia.register_export("Postgres SQL Export", "sql", SQLRenderer())
except:
print 'Failed to import Dia ...'
ImportDbDialog(None, "import")
gtk.main()
<dia:real val="%.3f"/>
</dia:attribute>
<dia:attribute name="file">
<dia:string>#%s#</dia:string>
</dia:attribute>
<dia:attribute name="draw_border">
<dia:boolean val="false"/>
</dia:attribute>
<dia:attribute name="keep_aspect">
<dia:boolean val="%s"/>
</dia:attribute>
</dia:object>''' %
(self.oid, point.x, point.y, width, height, fname, keep_aspect))
# defining only this line drawer makes almost everything interpolated
def draw_line(self, start, end, color):
self.oid = self.oid + 1
self.f.write('''
<dia:object type="Standard - Line" version="0" id="O%d">
<dia:attribute name="conn_endpoints">
<dia:point val="%.3f,%.3f"/>
<dia:point val="%.3f,%.3f"/>
</dia:attribute>
%s%s
</dia:object>''' % (self.oid, start.x, start.y, end.x, end.y,
self._tinting(color), self._stroke_style()))
# register the renderer
dia.register_export(_("Dia plain"), "dia", StandardDiaRenderer())
result+=" # returns %s\n" % (op[0], )
#result += cname+"()\n\n"
result += "\n\n"
return result
def end_render(self) :
module = self.data_get()['module']
zip = zipfile.ZipFile(self.filename, 'w')
filewrite = {
'__init__.py':self.init_get(),
'__manifest__.py':self.terp_get(),
'models/__init__.py':self.init_model_get(),
'models/'+module+'.py': self.code_get(),
'views/'+module+'_view.xml': self.view_get(),
'security/ir.model.access.csv': self.security_get(),
'static/description/index.html': self.html_get(),
'static/src/less/'+module+'.less': self.less_get()
}
for name,datastr in filewrite.items():
info = zipfile.ZipInfo(module+'/'+name)
info.compress_type = zipfile.ZIP_DEFLATED
info.external_attr = 2175008768
zip.writestr(info, datastr)
zip.close()
ObjRenderer.end_render(self)
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export ("PyDia Generador de Código (Odoo)", "zip", OpenERPRenderer())
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
st = 'stroke-dasharray="%.2f,%.2f"' % (dashlen, dashlen)
elif style == 2: # DASH_DOT,
gaplen = (dashlen - dotlen) / 2.0
st = 'stroke-dasharray="%.2f,%.2f,%.2f,%.2f"' % (dashlen, gaplen, dotlen, gaplen)
elif style == 3: # DASH_DOT_DOT,
gaplen = (dashlen - dotlen) / 3.0
st = 'stroke-dasharray="%.2f,%.2f,%.2f,%.2f,%.2f,%.2f"' % (dashlen, gaplen, dotlen, gaplen, dotlen, gaplen)
elif style == 4: # DOTTED
st = 'stroke-dasharray="%.2f,%.2f"' % (dotlen, dotlen)
if join == 0: # MITER
pass # st = st + ' stroke-linejoin="bevel"'
elif join == 1: # ROUND
st += ' stroke-linejoin="round"'
elif join == 2: # BEVEL
st += ' stroke-linejoin="bevel"'
if caps == 0: # BUTT
pass # default stroke-linecap="butt"
elif caps == 1: # ROUND
st += ' stroke-linecap="round"'
elif caps == 2: # PROJECTING
st += ' stroke-linecap="square"' # is this the same ?
return st
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export( "MIF/FrameMaker", "mif", MIFMaker())
# vim:ts=4:sw=4:expandtab
#result += cname+"()\n\n"
result += "\n\n"
return result
def end_render(self) :
module = self.data_get()['module']
zip = zipfile.ZipFile(self.filename, 'w')
filewrite = {
'__init__.py':self.init_get(),
'__openerp__.py':self.terp_get(),
'models/__init__.py':self.init_model_get(),
'models/'+module+'.py': self.code_get(),
'views/'+module+'_view.xml': self.view_get(),
'security/ir.model.access.csv': self.security_get()
}
for name,datastr in filewrite.items():
info = zipfile.ZipInfo(module+'/'+name)
info.compress_type = zipfile.ZIP_DEFLATED
info.external_attr = 2175008768
zip.writestr(info, datastr)
zip.close()
ObjRenderer.end_render(self)
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export ("PyDia Generador de Código (Odoo)", "zip", OpenERPRenderer())
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
file.write(" %s" % val)
file.write("\n")
def get_sense_id(self, sense_name) :
# print "sense_name ", sense_name
sense_id = 0
if sense_name in self.senses.keys() :
if "SenseID" in self.senses[sense_name].attributes.keys() :
sense_id = self.senses[sense_name].attributes["SenseID"][1]
return sense_id
def get_action_id(self, action_name) :
# print "action_name ", action_name
action_id = 0
if action_name in self.actions.keys() :
if "ActionID" in self.actions[action_name].attributes.keys() :
action_id = self.actions[action_name].attributes["ActionID"][1]
return action_id
def get_comparator_val(self, comparator_name) :
# print "comparator_name ", comparator_name
comp_val = 0
comp_values = {'EQ':0, 'NE':1, 'GT':2, 'LT':3, 'TR':4, 'FL':5,}
if comparator_name in comp_values.keys() :
comp_val = comp_values[comparator_name]
return comp_val
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export ("Instinct Plan Generation", "inst", InstinctRenderer())
if op[4]: result+=" \"\"\" %s \"\"\"\n" % op[4]
result+=" # returns %s\n" % (op[0], )
#result += cname+"()\n\n"
result += "\n\n"
return result
def end_render(self) :
module = self.data_get()['module']
zip = zipfile.ZipFile(self.filename, 'w')
filewrite = {
'__init__.py':self.init_get(),
'__manifest__.py':self.terp_get(),
'models/__init__.py':self.init_model_get(),
'models/'+module+'.py': self.code_get(),
'views/'+module+'_view.xml': self.view_get(),
'security/ir.model.access.csv': self.security_get(),
'static/description/index.html': self.html_get(),
'static/src/less/'+module+'.less': self.less_get(),
'static/src/js/'+module+'.js': self.java_get()
}
for name,datastr in filewrite.items():
info = zipfile.ZipInfo(module+'/'+name)
info.compress_type = zipfile.ZIP_DEFLATED
info.external_attr = 2175008768
zip.writestr(info, datastr)
zip.close()
ObjRenderer.end_render(self)
# dia-python mantiene una referencia a la clase renderer y la usa a demanda
dia.register_export ("CODEGEN ODOO V10)", "zip", ODOORenderer())
class UninlineRenderer :
def __init__ (self) :
self.count = 0
def begin_render (self, data, filename) :
imgmap = {}
dirname = os.path.dirname (filename)
basename = os.path.basename(filename)
ext = filename[string.rfind(filename, ".")+1:]
for layer in data.layers :
for o in layer.objects :
if "inline_data" in o.properties.keys() :
if o.properties["inline_data"].value :
# remember by position
pos = o.properties["obj_pos"].value
xk = "%03g" % pos.x
yk = "%03g" % pos.y
key = basename + "-" + layer.name + "x" + xk + "y" + yk
imgmap[key] = o
for k, o in imgmap.iteritems() :
fname = dirname + "/" + k + "." + ext
print fname
o.properties["image_file"] = fname
o.properties["inline_data"] = 0
def end_render (self) :
pass
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export ("Uninline Images", "png", UninlineRenderer())
def footer(self):
s = "\n\n"
s += "all_classes = ["
i = 0
for k in self.built:
i += 1
s += "{:s}".format(k)
if i < len(self.built):
s += ", "
s += "]\n"
return s
def end_render(self):
f = open(self.filename, 'w')
f.write(self.header())
for sk in self.klasses.keys():
self.to_build["_{:s}".format(sk)] = \
self.build_classes(self.klasses[sk])
for k in self.to_build.keys():
self.tree_build(f, k)
f.write(self.footer())
f.close()
self.to_build = {}
self.built = []
ObjRenderer.end_render(self)
dia.register_export("Gas chemistry code generation (Python)", "py",
MyPyRenderer())
self.WriteAreas (layer, scale)
self.f.write ('</map>\n')
def WriteAreas (self, layer, scale) :
for o in layer.objects :
r = o.bounding_box
if o.properties.has_key ("name") :
url = o.properties["name"].value
elif o.properties.has_key ("text") :
url = o.properties["text"].value.text
else :
continue
if len(url) == 0 or string.find (url, " ") >= 0 :
continue
alt = url
if o.properties.has_key ("comment") :
alt = o.properties["comment"].value
# need to sale the original coords to the bitmap size
x1 = int(r.left * scale) + self.xofs
y1 = int(r.top * scale) + self.yofs
x2 = int(r.right * scale) + self.xofs
y2 = int(r.bottom * scale) + self.yofs
self.f.write (' <area shape="rect" href="%s" title="%s" alt="%s" coords="%d,%d,%d,%d">\n' % \
("#" + url, url, alt, x1, y1, x2, y2))
def end_render (self) :
self.f.close()
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export (_("Imagemap"), "cmap", ObjRenderer())
for c in o.connections :
# these are the connection points of the objects. We will have e.g. "UML - Dependency"
for n in c.connected :
# we see the connecting lines multiple times, just process once
if self.edges.has_key(str(n)) :
continue
self.edges[str(n)] = 1
if not (n.handles[0].connected_to and n.handles[1].connected_to) :
continue
# the right handles give us the direction
a = n.handles[0].connected_to.object
b = n.handles[1].connected_to.objectlabel = ""
label = ''
try:
label = ' [ label = "%s" ]' % n.properties['text'].value
except:
pass
try :
self.f.write('"%s" -> "%s"%s\n' % (self.GetName(a), self.GetName(b), label))
#self.f.write('"%s" -> "%s"\n' % (str(a.properties["text"].value.text), str(b.properties["text"].value.text)))
except :
print a, b, " writing connection failed."
else :
pass
self.f.write('}\n')
def end_render (self) :
self.f.close()
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export ("PyDia DOT Export", "dot", DotRenderer())
self.WriteAreas (layer, scale)
self.f.write ('</map>\n')
def WriteAreas (self, layer, scale) :
for o in layer.objects :
r = o.bounding_box
if o.properties.has_key ("name") :
url = o.properties["name"].value
elif o.properties.has_key ("text") :
url = o.properties["text"].value.text
else :
continue
if len(url) == 0 or string.find (url, " ") >= 0 :
continue
alt = url
if o.properties.has_key ("comment") :
alt = o.properties["comment"].value
# need to sale the original coords to the bitmap size
x1 = int(r.left * scale) + self.xofs
y1 = int(r.top * scale) + self.yofs
x2 = int(r.right * scale) + self.xofs
y2 = int(r.bottom * scale) + self.yofs
self.f.write (' <area shape="rect" href="%s" title="%s" alt="%s" coords="%d,%d,%d,%d">\n' % \
("#" + url, url, alt, x1, y1, x2, y2))
def end_render (self) :
self.f.close()
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export ("Imagemap", "cmap", ObjRenderer())
self.f.write('"%s" [fillcolor="%s"];\n' % (self.GetName(o), self.GetColor(o)))
for layer in data.layers:
for o in layer.objects:
for c in o.connections:
# these are the connection points of the objects. We will have e.g. "UML - Dependency"
for n in c.connected:
# we see the connecting lines multiple times, just process once
if self.edges.has_key(str(n)):
continue
self.edges[str(n)] = 1
if not (n.handles[0].connected_to and n.handles[1].connected_to):
continue
# the right handles give us the direction
a = n.handles[0].connected_to.object
b = n.handles[1].connected_to.object
try:
self.f.write('"%s" -> "%s"\n' % (self.GetName(a), self.GetName(b)))
# self.f.write('"%s" -> "%s"\n' % (str(a.properties["text"].value.text), str(b.properties["text"].value.text)))
except:
print a, b, " writing connection failed."
else:
pass
self.f.write("}\n")
def end_render(self):
self.f.close()
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export("PyDia DOT Export", "dot", DotRenderer())
+ ";" + str(fill) + ";" + str(stroke) + "\n")
## \brief Draw a bezier line
def draw_bezier(self, bezpoints, color):
self.f.write("draw_bezier: " + str(color) + "\n")
for pt in bezpoints:
self.f.write("\t" + str(pt) + "\n")
## \brief Fill a bezier shape
def draw_beziergon(self, bezpoints, fill, stroke):
self.f.write("draw_bezier: " + str(fill) + "; " + str(stroke) + "\n")
for pt in bezpoints:
self.f.write("\t" + str(pt) + "\n")
## \brief Draw a string
def draw_string(self, text, pos, alignment, color):
self.f.write("draw_string: [" + text + "]; " + str(pos) \
+ str(alignment) + "; " +str(color))
## \brief Draw an image
def draw_image(self, point, width, height, image):
self.f.write("draw_image: " + str(point) + str(width) + "x" +str(height) \
+ " " + image.filename + "\n")
self.f.write("<rgb_data>" + image.rgb_data + "</rgb_data>")
self.f.write("<mask_data>" + image.mask_data + "</mask_data>")
## \brief Register the renderer with Dia's export system
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export(_("PyDia Render Export"), "diapyr", DumpRenderer())
initial_state = self.states[transition.target]
f.write(" add_initial_state( stm, %s, %s );\n" %
(initial_state.name, initial_state.doaction))
for key in self.states.keys():
state = self.states[key]
# initial_state has already been output
# TODO: the fact that state can be None looks like a bug to me
if(state != None and state.name != initial_state.name):
f.write(" add_state( stm, %s, %s );\n" %
(state.name, state.doaction))
# (state.name, state.iaction, state.oaction, state.doaction)
f.write(self.TRANSITIONS_PREAMBLE)
for transition in self.transitions:
if(transition.source == "INITIAL_STATE"):
continue # skip the initial state transition
f.write(" add_transition( stm, %s, %s, %s );\n" %
(transition.source, transition.trigger, transition.target ))
# (transition.source, transition.trigger, transition.target, transition.action))
f.write(self.CODE_POSTAMBLE)
f.close()
self.states = {}
self.transitions = []
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export("State Machine Cstma Dump", "c", CDiagramRenderer())
result += " def %s(%s) :\n" % (so, pars)
if op[4]: result += " \"\"\" %s \"\"\"\n" % op[4]
result += " # returns %s\n" % (op[0], )
result += cname + "()\n\n"
return result
def end_render(self):
module = self.data_get()['module']
zip = zipfile.ZipFile(self.filename, 'w')
filewrite = {
'__init__.py': self.init_get(),
'__openerp__.py': self.terp_get(),
module + '.py': self.code_get(),
module + '_view.xml': self.view_get(),
'security/ir.model.access.csv': self.security_get()
}
for name, datastr in filewrite.items():
info = zipfile.ZipInfo(module + '/' + name)
info.compress_type = zipfile.ZIP_DEFLATED
info.external_attr = 2175008768
zip.writestr(info, datastr)
zip.close()
ObjRenderer.end_render(self)
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export("PyDia Code Generation (OpenERP)", "zip",
OpenERPRenderer())
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
+ str(angle1) + "," + str(angle2) + ";" + str(color) + "\n")
def fill_arc (self, center, width, height, angle1, angle2, color) :
self.f.write("fill_arc: " + str(center) + ";" \
+ str(width) + "x" + str(height) + ";" \
+ str(angle1) + "," + str(angle2) + ";" + str(color) + "\n")
def draw_ellipse (self, center, width, height, color) :
self.f.write("draw_ellipse: " + str(center) \
+ str(width) + "x" +str(height) + ";" + str(color) + "\n")
def fill_ellipse (self, center, width, height, color) :
self.f.write("fill_ellipse: " + str(center) \
+ str(width) + "x" +str(height) + ";" + str(color) + "\n")
def draw_bezier (self, bezpoints, color) :
self.f.write("draw_bezier: " + str(color) + "\n")
for pt in bezpoints :
self.f.write ("\t" + str(pt) + "\n")
def fill_bezier (self, bezpoints, color) :
self.f.write("fill_bezier: " + str(color) + "\n")
for pt in bezpoints :
self.f.write ("\t" + str(pt) + "\n")
def draw_string (self, text, pos, alignment, color) :
self.f.write("draw_string: [" + text + "]; " + str(pos) \
+ str(alignment) + "; " +str(color))
def draw_image (self, point, width, height, image) :
self.f.write("draw_image: " + str(point) + str(width) + "x" +str(height) \
+ " " + image.filename + "\n")
self.f.write("<rgb_data>" + image.rgb_data + "</rgb_data>")
self.f.write("<mask_data>" + image.mask_data + "</mask_data>")
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export ("PyDia Render Export", "diapyr", DumpRenderer())
class UninlineRenderer:
def __init__(self):
self.count = 0
def begin_render(self, data, filename):
imgmap = {}
dirname = os.path.dirname(filename)
ext = filename[string.rfind(filename, ".") + 1:]
for layer in data.layers:
for o in layer.objects:
if "inline_data" in o.properties.keys():
if o.properties["inline_data"].value:
# remember by position
pos = o.properties["obj_pos"].value
xk = "%03g" % pos.x
yk = "%03g" % pos.y
key = "L" + layer.name + "x" + xk + "y" + yk
imgmap[key] = o
for k, o in imgmap.iteritems():
fname = dirname + "/" + k + "." + ext
print fname
o.properties["image_file"] = fname
o.properties["inline_data"] = 0
def end_render(self):
pass
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export("Uninline Images", "png", UninlineRenderer())
self.f.write ("\t"*1 + str(o) + "\n")
r = o.bounding_box
self.f.write ("\t"*2 + "<bbox>" + str(r.left) + "," + str(r.top) + ";" \
+ str(r.right) + "," + str(r.bottom) + "</bbox>\n")
self.f.write ("\t"*2 + "<connections>\n")
for c in o.connections :
if (len(c.connected) < 1) :
continue
self.f.write ("\t"*3 + str(c) + "\n")
for co in c.connected :
self.f.write ("\t"*4 + str(co) + "\n")
self.f.write ("\t"*3 + "</DiaConnectionPoint>\n")
self.f.write ("\t"*2 + "</connections>\n")
self.f.write ("\t"*2 + str(o.properties) + "\n")
keys = o.properties.keys()
for s in keys :
self.f.write ("\t"*3 + str(o.properties[s]) + "\n")
if o.properties[s].type == "string" :
self.f.write ("\t"*3 + str(o.properties[s].value) + "\n")
self.f.write ("\t"*3 + "</DiaProperty>\n")
self.f.write ("\t"*2 + "</DiaProperties>\n")
self.f.write ("\t"*1 + "</DiaObject>\n\n")
self.f.write ("\t"*0 + "</layer>\n")
def end_render (self) :
self.f.close()
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export ("PyDia Object Export", "diapyo", ObjRenderer())
pass # st = st + ' stroke-linejoin="bevel"'
elif join == 1: # ROUND
st = st + ' stroke-linejoin="round"'
elif join == 2: # BEVEL
st = st + ' stroke-linejoin="bevel"'
if caps == 0: # BUTT
pass # default stroke-linecap="butt"
elif caps == 1: # ROUND
st = st + ' stroke-linecap="round"'
elif caps == 2: # PROJECTING
st = st + ' stroke-linecap="square"' # is this the same ?
return st
class SvgzRenderer(SvgRenderer):
def _open(self, filename):
# There is some (here) not wanted behaviour in gzip.open/GzipFile :
# the filename with path is not only used to adress the file but also
# completely stored in the file itself. Correct it here.
import os, os.path, gzip
path, name = os.path.split(filename)
os.chdir(path)
self.f = gzip.open(name, "wb")
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export("SVG plain", "svg", SvgRenderer())
dia.register_export("SVG compressed", "svgz", SvgzRenderer())
if op[4]: result+=" \"\"\" %s \"\"\"\n" % op[4]
result+=" # returns %s\n" % (op[0], )
result += cname+"()\n\n"
return result
def end_render(self) :
module = self.data_get()['module']
zip = zipfile.ZipFile(self.filename, 'w')
filewrite = {
'__init__.py':self.init_get(),
'__openerp__.py':self.terp_get(),
module+'.py': self.code_get(),
module+'_view.xml': self.view_get(),
'security/ir.model.access.csv': self.security_get()
}
for name,datastr in filewrite.items():
info = zipfile.ZipInfo(module+'/'+name)
info.compress_type = zipfile.ZIP_DEFLATED
info.external_attr = 2175008768
zip.writestr(info, datastr)
zip.close()
ObjRenderer.end_render(self)
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export ("PyDia Code Generation (OpenERP 6.1 v2)", "zip", OpenERPRenderer())
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
<dia:attribute name="elem_height">
<dia:real val="%.3f"/>
</dia:attribute>
<dia:attribute name="file">
<dia:string>#%s#</dia:string>
</dia:attribute>
<dia:attribute name="draw_border">
<dia:boolean val="false"/>
</dia:attribute>
<dia:attribute name="keep_aspect">
<dia:boolean val="%s"/>
</dia:attribute>
</dia:object>''' % (self.oid, point.x,point.y, width, height, fname, keep_aspect))
# defining only this line drawer makes almost everything interpolated
def draw_line (self, start, end, color) :
self.oid = self.oid + 1
self.f.write('''
<dia:object type="Standard - Line" version="0" id="O%d">
<dia:attribute name="conn_endpoints">
<dia:point val="%.3f,%.3f"/>
<dia:point val="%.3f,%.3f"/>
</dia:attribute>
%s%s
</dia:object>''' % (self.oid, start.x,start.y, end.x, end.y,
self._tinting(color), self._stroke_style()))
# register the renderer
dia.register_export ("Dia plain", "dia", StandardDiaRenderer())
nMoves = nMoves + 1
if nMoves > 1 :
self.Warning ("%s move-to within", (fun,))
elif bp.type == 1 : # BEZ_LINE_TO
pass
elif bp.type == 2 : # BEZ_CURVE_TO
pass
else :
self.Error ("%s invalid BezPoint type='%d'" % (fun, bp.type,))
def draw_bezier (self, bezpoints, color) :
if len(bezpoints) < 2 :
self.Error ("draw_bezier too few points");
self._bezier (bezpoints, "draw_bezier")
def fill_bezier (self, bezpoints, color) :
if len(bezpoints) < 3 :
self.Error ("fill_bezier too few points");
self._bezier (bezpoints, "fill_bezier")
def draw_string (self, text, pos, alignment, color) :
if len(text) < 1 :
self.Warning ("draw_string empty text")
if alignment < 0 or alignment > 2 :
self.Error ("draw_string unknown alignmern '%d'" % (alignment,))
def draw_image (self, point, width, height, image) :
if width <= 0 :
self.Warning ("draw_image width too small")
if height <= 0 :
self.Warning ("draw_image height too small")
# XXX: check image, e.g. existing file name
# dia-python keeps a reference to the renderer class and uses it on demand
dia.register_export ("Dissect", "dissect", DissectRenderer())