def __stop_server(self):
self.httpd.shutdown()
self.httpd.server_close()
self.httpd.socket.close()
self.httpd_thread.join()
self.httpd = None
System.log("Server stopped")
def __init__(self, diagram=None, code_template=None):
self.diagram = diagram
self.code_template = code_template
self.dir_name = ""
self.filename = ""
self.old_path = os.path.realpath(os.curdir)
self.blockList = []
self.connections = []
self.codes = [[], [], [], [], []]
if diagram is None:
return
if code_template is None:
return
if self.diagram.language is None:
System.log("No language, no block, no code")
return
if not len(self.diagram.blocks) > 0:
System.log("Diagram is empty. Nothing to generate.")
return
self.dir_name = self.get_dir_name()
self.filename = self.get_filename()
def end_connection(self, block, block_input):
"""
This method end a connection.
Parameters:
* **block**
* **block_input**
Returns:
* **Types** (:class:`boolean<boolean>`)
"""
if self.curr_connector is None:
return False
self.curr_connector.sink = block
self.curr_connector.sink_port = block_input
if not self.__valid_connector(self.curr_connector):
self.__abort_connection()
return False
out_type = self.curr_connector.source.out_ports[int(
self.curr_connector.source_port)]["type"]
in_type = self.curr_connector.sink.in_ports[int(
self.curr_connector.sink_port)]["type"]
if not out_type == in_type:
System.log(_("Connection Types mismatch"))
self.__abort_connection()
return False
self.connectors.append(self.curr_connector)
self.curr_connector = None
self.update_flows()
return True
def export_png(self, file_name="diagrama.png"):
"""
This method export a png.
Returns:
* **Types** (:class:`boolean<boolean>`): True to Success.
"""
if file_name is None:
file_name = "diagrama.png"
x, y, width, height = self.diagram.get_min_max()
if x < 0 or y < 0:
self.diagram.reload()
x, y, width, height = self.diagram.get_min_max()
pixbuf = Gdk.pixbuf_get_from_window(self.diagram.get_window(), x, y,
width, height)
if pixbuf is None:
return False, "No image to export"
test, tmp_buffer = pixbuf.save_to_bufferv("png", [], [])
try:
save_file = open(file_name, "w")
save_file.write(tmp_buffer)
save_file.close()
except IOError as e:
System.log(e.strerror)
return False, e.strerror
return True, ""
def run(self, codes=None):
"""
This method runs the code.
"""
diagram = self.get_current_diagram()
generator, message = CodeGenerator.get_code_generator(diagram)
if generator is None:
return False
self.save_source(codes=codes, generator=generator)
command = diagram.code_template.command
command = command.replace("$dir_name$", System.get_dir_name(diagram))
def __run(self):
process = subprocess.Popen(command,
cwd=System.get_dir_name(diagram),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
preexec_fn=os.setsid)
self.threads[thread] = diagram, process
self.main_window.toolbar.update_threads(self.threads)
(stdout_data, stderr_data) = process.communicate()
System.log(stdout_data + "\n")
System.log(stderr_data + "\n")
del self.threads[thread]
self.main_window.toolbar.update_threads(self.threads)
System.log("Executing Code:\n" + command)
thread = Thread(target=__run, args=(self, ))
thread.start()
return True
def save(cls, diagram):
"""
This method save a file.
Returns:
* **Types** (:class:`boolean<boolean>`)
"""
parser = XMLParser()
parser.addTag(tag_name)
parser.appendToTag(tag_name, 'version', value=System.VERSION)
parser.appendToTag(tag_name, 'zoom', value=diagram.zoom)
parser.appendToTag(tag_name, 'language', value=diagram.language)
parser.appendToTag(tag_name, 'blocks')
for block_id in diagram.blocks:
block = diagram.blocks[block_id]
pos = block.get_position()
parser.appendToTag('blocks',
'block',
type=block.type,
id=block.id,
collapsed=block.is_collapsed)
parser.appendToLastTag('block', 'position', x=pos[0], y=pos[1])
props = block.get_properties()
for prop in props:
parser.appendToLastTag('block',
'property',
key=str(prop["name"]),
value=str(prop["value"]))
parser.appendToTag(tag_name, 'connections')
for connector in diagram.connectors:
parser.appendToTag('connections',
'connection',
from_block=connector.output.id,
from_out=int(connector.output_port.index),
to_block=connector.input.id,
to_in=int(connector.input_port.index))
parser.appendToTag(tag_name, 'comments')
for comment in diagram.comments:
pos = comment.get_position()
parser.appendToTag('comments',
'comment',
text=comment.text,
x=pos[0],
y=pos[1])
try:
save_file = open(str(diagram.file_name), "w")
save_file.write(parser.prettify())
save_file.close()
except IOError as e:
System.log(e.strerror)
return False, e.strerror
diagram.set_modified(False)
return True, "Success"
def set_properties(self, data):
for prop in self.get_properties():
key = prop.get("name")
if key in data:
prop["value"] = data[key]
else:
from mosaicode.system import System as System
System.log("BlockModel.set_property (" + self.type + \
") ERROR: key " + key + " not present")
def do(self, new_msg):
"""
This method do something
Parameters:
* **new_msg** (:class:`str<str>`)
"""
self.set_modified(True)
action = (copy.copy(self.blocks), copy.copy(self.connectors), new_msg)
self.undo_stack.append(action)
System.log(_("Do: " + new_msg))
def __run(self):
process = subprocess.Popen(command,
cwd=System.get_dir_name(diagram),
shell=True,
preexec_fn=os.setsid)
self.threads[thread] = diagram, process
self.main_window.toolbar.update_threads(self.threads)
System.log(process.communicate())
del self.threads[thread]
self.main_window.toolbar.update_threads(self.threads)
def delete_code_template(cls, code_template_key):
from mosaicode.system import System
code_templates = System.get_code_templates()
if code_template_key not in code_templates:
System.log("Error: This code template does not exist")
return False
code_template = code_templates[code_template_key]
if code_template.file is not None:
os.remove(code_template.file)
else:
System.log("Error: This code template does not have a file.")
return code_template.file
def open(self, file_name):
"""
This method open a file.
"""
diagram = Diagram(self.main_window)
self.main_window.work_area.add_diagram(diagram)
if not DiagramControl(diagram).load(file_name):
System.log("Problem Loading the Diagram")
diagram.redraw()
diagram.set_modified(False)
self.set_recent_files(file_name)
def insert_block(self, block):
if self.language is not None and self.language != block.language:
System.log("Block language is different from diagram language.")
return False
if self.language is None or self.language == 'None':
self.language = block.language
self.last_id = max(int(self.last_id), int(block.id))
if block.id < 0:
block.id = self.last_id
self.blocks[block.id] = block
self.last_id += 1
return True
def save_code(self, name=None, code=None):
"""
This method generate the save log.
"""
if name is None:
name = self.dir_name + self.filename + self.code_template.extension
self.__change_directory()
self.__return_to_old_directory()
System.log("Saving Code to " + name)
codeFile = open(name, 'w')
if code is None:
code = self.generate_code()
codeFile.write(code)
codeFile.close()
def load(cls, file_name):
"""
This method loads the block from XML file.
Returns:
* **Types** (:class:`boolean<boolean>`)
"""
file_name = file_name.replace(" ", "\\ ")
try:
return BlockPersistence.load(file_name)
except:
from mosaicode.system import System
System.log("Block " + file_name + " could not load")
def __run(self):
process = subprocess.Popen(command,
cwd=System.get_dir_name(diagram),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
preexec_fn=os.setsid)
self.threads[thread] = diagram, process
self.main_window.toolbar.update_threads(self.threads)
(stdout_data, stderr_data) = process.communicate()
System.log(stdout_data + "\n")
System.log(stderr_data + "\n")
del self.threads[thread]
self.main_window.toolbar.update_threads(self.threads)
def redo(self):
"""
This method redo a modification.
"""
if len(self.redo_stack) < 1:
return
self.set_modified(True)
action = self.redo_stack.pop()
self.blocks = action[0]
self.connectors = action[1]
msg = action[2]
self.redraw()
self.undo_stack.append(action)
System.log(_("Redo: " + msg))
def load(cls, path):
"""
This method loads the preference from JSON file.
Returns:
* **Types** (:class:`boolean<boolean>`)
"""
prefs = Preferences()
file_name = path + "/" + prefs.conf_file_path + ".json"
file_name = os.path.expanduser(file_name)
if os.path.exists(file_name) is False:
return prefs
# load the port
if os.path.exists(file_name) is False:
return None
data = ""
try:
data_file = open(file_name, 'r')
data = json.load(data_file)
data_file.close()
if data["data"] != "PREFERENCES":
return None
prefs.author = data["author"]
prefs.license = data["license"]
prefs.version = data["version"]
prefs.default_directory = data["default_directory"]
prefs.default_filename = data["default_filename"]
prefs.grid = int(data["grid"])
prefs.width = int(data["width"])
prefs.height = int(data["height"])
prefs.hpaned_work_area = int(data["hpaned_work_area"])
prefs.vpaned_bottom = int(data["vpaned_bottom"])
prefs.vpaned_left = int(data["vpaned_left"])
files = data["recent_files"]
for file_name in files:
prefs.recent_files.append(file_name)
except:
from mosaicode.system import System as System
System.log("Problem loading preferences")
return prefs
def generate_code(self):
"""
This method generate the source code.
"""
System.log("Generating Code")
self.__prepare_block_list()
self.__sort_block_list()
self.__generate_block_code_parts()
files = self.diagram.code_template.files
for key in files:
files[key] = self.__generate_file_code(files[key])
return files
def save_xml(cls, code_template, path):
"""
This method save the code_template in user space.
Returns:
* **Types** (:class:`boolean<boolean>`)
"""
code_template.source = "xml"
parser = XMLParser()
parser.addTag(tag_name)
parser.setTagAttr(tag_name, 'name', code_template.name)
parser.setTagAttr(tag_name, 'type', code_template.type)
parser.setTagAttr(tag_name, 'description', code_template.description)
parser.setTagAttr(tag_name, 'language', code_template.language)
parser.setTagAttr(tag_name, 'command', code_template.command)
parser.appendToTag(tag_name, 'code_parts')
for key in code_template.code_parts:
parser.appendToTag('code_parts', 'code_part', value=key.strip())
parser.appendToTag(tag_name, 'files')
for key in code_template.files:
parser.appendToTag('files',
'file',
name_=key,
value=code_template.files[key])
parser.appendToTag(tag_name, 'properties')
for key in code_template.properties:
parser.appendToTag('properties', 'property', value=key)
if not Persistence.create_dir(path):
return False
try:
file_name = code_template.name
code_template_file = file(os.path.join(path, file_name + '.xml'),
'w')
code_template_file.write(parser.prettify())
code_template_file.close()
except IOError as e:
from mosaicode.system import System
System()
System.log(e)
return False
return True
def __valid_connector(self, newCon):
"""
Parameters:
Returns
* **Types** (:class:`boolean<boolean>`)
"""
for oldCon in self.connectors:
if oldCon.sink == newCon.sink \
and oldCon.sink_port == newCon.sink_port\
and not System.ports[newCon.conn_type].multiple:
System.log(_("Connector Already exists"))
return False
if (newCon.sink == newCon.source) or self.__cycle_detection(newCon):
System.log(_("Recursive connection is not allowed"))
return False
return True
def delete_block(self, block):
"""
This method delete a block.
Parameters:
block
"""
if block.id not in self.blocks:
System.log("Block " + str(block.id) + \
" is not present in this diagram.")
return
for idx in reversed(range(len(self.connectors))):
if self.connectors[idx].source == block \
or self.connectors[idx].sink == block:
self.delete_connection(self.connectors[idx])
self.blocks[block.id].remove()
del self.blocks[block.id]
self.update_flows()
def save(cls, code_template, path):
"""
This method save the code_template in user space.
Returns:
* **Types** (:class:`boolean<boolean>`)
"""
x = {
"source": "JSON",
"data": "CODE_TEMPLATE",
"version": code_template.version,
'name': code_template.name,
'type': code_template.type,
'description': code_template.description,
'language': code_template.language,
'command': code_template.command,
"code_parts": code_template.code_parts,
"properties": [],
"codes": {}
}
for key in code_template.properties:
x["properties"].append(key)
for key in code_template.codes:
x["codes"][key] = code_template.codes[key]
if not Persistence.create_dir(path):
from mosaicode.system import System as System
System.log("Problem creating dir to save Code templates")
return False
try:
file_name = code_template.name
data_file = open(os.path.join(path, file_name + '.json'), 'w')
data_file.write(json.dumps(x, indent=4))
data_file.close()
except IOError as e:
from mosaicode.system import System as System
System.log("Problem saving Code template: " + e)
return False
return True
def load(self, file_name=None):
"""
This method load a file.
Returns:
* **Types** (:class:`boolean<boolean>`)
"""
if file_name is not None:
self.diagram.file_name = file_name
else:
if self.diagram.file_name is None:
System.log("Cannot Load without filename")
return False
if not os.path.exists(self.diagram.file_name):
System.log("File '" + self.diagram.file_name + "' does not exist!")
return False
DiagramPersistence.load(self.diagram)
self.diagram.redo_stack = []
self.diagram.undo_stack = []
def __init__(self, diagram=None):
self.diagram = diagram
self.blockList = []
self.connections = []
self.codes = {}
if diagram is None:
return False
if self.diagram.code_template is None:
return False
if self.diagram.language is None:
System.log("No language, no block, no code")
return False
if not len(self.diagram.blocks) > 0:
System.log("Diagram is empty. Nothing to generate.")
return False
def save(self, save_as=False):
"""
This method save the file.
"""
diagram = self.main_window.work_area.get_current_diagram()
if diagram is None:
return False
if diagram.file_name == "Untitled" or save_as:
while True:
dialog = SaveDialog(
self.main_window,
title=_("Save Diagram"),
filename=System.get_user_dir() + "/" + diagram.patch_name,
filetype="*.mscd")
name = dialog.run()
if name is None:
System.log("File not saved")
return
if not name.endswith("mscd"):
name = (("%s" + ".mscd") % name)
if os.path.exists(name) is True:
msg = _("File exists. Overwrite?")
result = ConfirmDialog(msg, self.main_window).run()
if result == Gtk.ResponseType.CANCEL:
continue
diagram.file_name = name
self.main_window.work_area.rename_diagram(diagram)
break
result, message = False, ""
if diagram.file_name is not None:
if len(diagram.file_name) > 0:
result, message = DiagramControl(diagram).save()
self.set_recent_files(diagram.file_name)
if not result:
MessageDialog("Error", message, self.main_window).run()
def generate_code(self):
"""
This method generate the source code.
"""
System.log("Generating Code")
self.__prepare_block_list()
self.__sort_block_list()
self.__generate_block_code_parts()
if self.__diagram.code_template is None:
System.log("Code template is none")
return {}
codes = {}
for key in self.__diagram.code_template.codes:
codes[key] = self.__diagram.code_template.codes[key]
for key in codes:
codes[key] = self.__generate_file_code(codes[key])
return codes
def __start_server(self):
self.port = System.properties.port
while self.httpd is None:
try:
path = System.properties.default_directory
my_path = os.curdir
os.chdir(path)
System.log("Trying to run the server")
handler = SimpleHTTPServer.SimpleHTTPRequestHandler
SocketServer.ThreadingTCPServer.allow_reuse_address = True
self.httpd = SocketServer.ThreadingTCPServer(('', self.port),
handler)
self.httpd_thread = threading.Thread(
target=self.httpd.serve_forever)
self.httpd_thread.setDaemon(True)
self.httpd_thread.start()
count = 0
ip_aux = 0
System.log("Server running on ip and port:")
while self.ip != ip_aux:
ip_aux = self.ip
self.ip = self.get_ip(count)
count = count + 1
if ip_aux != self.ip:
System.log(str(self.ip) + ":" + str(self.port))
os.chdir(my_path)
except:
self.port = self.port + 1
def save_source(self, codes=None, generator=None):
"""
This method saves the source codes.
"""
diagram = self.main_window.work_area.get_current_diagram()
if diagram is None:
return False
# If it is not called from the run method
if generator is None:
generator = self.__get_code_generator(diagram)
if generator is None:
return False
if codes is None:
files = generator.generate_code()
else:
files = codes
for key in files:
file_name = System.get_dir_name(diagram) + key
System.log("Saving Code to " + file_name)
try:
codeFile = open(file_name, 'w')
codeFile.write(files[key])
codeFile.close()
except Exception as error:
System.log("File or directory not found!")
System.log(error)
return True
def add_block(self, block):
"""
This method add a block in the diagram.
Parameters:
* **block**
Returns:
* **Types** (:class:`boolean<boolean>`)
"""
if self.diagram.language is not None and self.diagram.language != block.language:
System.log("Block language is different from diagram language.")
return False
if self.diagram.language is None or self.diagram.language == 'None':
self.diagram.language = block.language
self.do("Add Block")
self.diagram.last_id = max(int(self.diagram.last_id), int(block.id))
if block.id < 0:
block.id = self.diagram.last_id
self.diagram.last_id += 1
self.diagram.blocks[block.id] = block
return True
def save_code(self, name=None, code=None):
"""
This method generate the save log.
"""
if name is None:
name = self.dir_name + self.filename + self.code_template.extension
try:
os.makedirs(self.dir_name)
except:
pass
System.log("Saving Code to " + name)
try:
codeFile = open(name, 'w')
if code is None:
code = self.generate_code()
codeFile.write(code)
codeFile.close()
return False
except IOError:
System.log("File or directory not found!")
return True
