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