def export_xml(cls):
from mosaicode.system import System as System
System()
ports = System.get_ports()
for port in ports:
print "Exporting port " + port
PortPersistence.save(ports[port])
def __create_side_panel(self, configuration):
self.__clean_side_panel()
connectors = []
ports = System.get_ports()
for key in ports:
if ports[key].language == self.block.language:
connectors.append(key)
data = {"label": _("Port Type"), "name":"type", "values": connectors}
field = ComboField(data, None)
self.side_panel.pack_start(field, False, False, 1)
if configuration is not None: field.set_value(configuration.type)
data = {"label": _("Connection Type"), "name":"conn_type", "values": [Port.INPUT, Port.OUTPUT]}
field = ComboField(data, None)
self.side_panel.pack_start(field, False, False, 1)
if configuration is not None: field.set_value(configuration.conn_type)
data = {"label": _("Label"), "name":"label"}
field = StringField(data, None)
self.side_panel.pack_start(field, False, False, 1)
if configuration is not None: field.set_value(configuration.label)
data = {"label": _("Name"), "name":"name"}
field = StringField(data, None)
self.side_panel.pack_start(field, False, False, 1)
if configuration is not None: field.set_value(configuration.name)
button = Gtk.Button.new_with_label("Save")
button.connect("clicked", self.__on_save, None)
self.side_panel.pack_start(button, False, False, 1)
self.side_panel.show_all()
def test_load_ports(self):
block = self.create_block()
# if it is not a dictionary
block.ports.append("x")
# if "type" not in port:
block.ports.append({
"label": "Output",
"conn_type": "Output",
"name": "output"
})
# if "conn_type" not in port
block.ports.append({
"type": "Output",
"label": "Output",
"name": "output"
})
# Port ok
block.ports.append({
"type": "Output",
"label": "Output",
"conn_type": "Output",
"name": "output"
})
BlockControl.load_ports(block, System.get_ports())
def create_block(self, diagram_control=None):
if diagram_control is None:
diagram_control = self.create_diagram_control()
block_model = BlockModel()
block_model.maxIO = 2
block = Block(diagram_control.diagram, block_model)
block.language = "language"
block.properties = [{"name": "test", "label": "Test", "type": "Test"}]
block.ports = [{
"type": "Test",
"label": "Input",
"conn_type": "Input",
"name": "input"
}, {
"type": "Test",
"label": "Output",
"conn_type": "Outpu",
"name": "output"
}]
BlockControl.load_ports(block, System.get_ports())
DiagramControl.add_block(diagram_control.diagram, block)
return block
def export_python(cls):
from mosaicode.system import System as System
System()
ports = System.get_ports()
for port in ports:
path = System.get_user_dir() + "/extensions/"
path = path + port.language + "/ports/"
PortPersistence.save_python(ports[port])
def export_xml(cls):
from mosaicode.system import System as System
System()
ports = System.get_ports()
for key in ports:
path = System.get_user_dir()
path = os.path.join(path, 'extensions', ports[key].language,
'ports')
PortPersistence.save_xml(ports[key], path)
def delete_port(cls, port_key):
from mosaicode.system import System
ports = System.get_ports()
port = ports[port_key]
if port.file is not None:
os.remove(port.file)
return True
else:
return False
def create_block(self, diagram_control=None):
if diagram_control is None:
diagram_control = self.create_diagram_control()
System()
block_model = BlockModel()
System.add_port(self.create_port())
block_model.ports = [{
"type": "Test",
"label": "Click",
"conn_type": "Input",
"name": "0"
}, {
"type": "Test",
"label": "Click",
"conn_type": "Output",
"name": "1"
}, {
"type": "Test",
"label": "Click",
"conn_type": "Input",
"name": "2"
}, {
"type": "Test",
"label": "Click",
"conn_type": "Output",
"name": "3"
}]
block_model.help = "Test"
block_model.label = "Test"
block_model.color = "200:200:25:150"
block_model.group = "Test"
block_model.codes = {"code0": "Test", "Code1": "Test", "Code2": "Test"}
block_model.type = "Test"
block_model.language = "Test"
block_model.properties = [{
"name": "test",
"label": "Test",
"value": "0",
"type": MOSAICODE_FLOAT
}]
block_model.extension = "Test"
block_model.file = None
result = BlockControl.load_ports(block_model, System.get_ports())
System.add_block(block_model)
self.assertEquals(result[1], "Success")
self.assertEquals(result[0], True)
self.assertEquals(len(block_model.ports), 4)
block = Block(diagram_control.diagram, block_model)
self.assertEquals(len(block.ports), 4)
return block
def __update(self):
System()
port_list = []
ports = System.get_ports()
for x in ports:
port_list.append([x])
port_list.sort()
self.tree_store.clear()
for x in port_list:
self.tree_store.append(None, x)
def export_port(cls, output):
from mosaicode.system import System as System
System()
ports = System.get_ports()
for port in ports:
path = System.get_user_dir() + "/extensions/"
path = path + port.language + "/ports/"
if output == "xml":
PortPersistence.save_xml(ports[port], path)
else:
PortPersistence.save_python(ports[port])
def delete_port(cls, port_key):
from mosaicode.system import System
System()
ports = System.get_ports()
if port_key not in ports:
return False, "This port does not exist in System!"
port = ports[port_key]
if port.file is not None:
os.remove(port.file)
return True, "Success"
else:
return False, "Could not remove port " + port_key
def test_load_ports(self):
block = self.create_block()
block.ports.append("x")
block.ports.append({
"type": "ERRO!",
"label": "Output",
"conn_type": "Output",
"name": "output"
})
block.ports.append({
"label": "Output",
"conn_type": "Output",
"name": "output"
})
BlockControl.load_ports(block, System.get_ports())
def export_extensions(self):
from mosaicode.system import System as System
System()
result = True
folder = "extension-" + datetime.datetime.now().strftime("%Y-%m-%d")
# Export ports
ports = System.get_ports()
for key in ports:
path = System.get_user_dir()
path = os.path.join(path, folder, ports[key].language, 'ports')
result = result and PortPersistence.save(ports[key], path)
# Export Blocks
blocks = System.get_blocks()
result = True
for key in blocks:
path = System.get_user_dir()
path = os.path.join(path,
folder,
blocks[key].language,
'blocks',
blocks[key].extension,
blocks[key].group)
result = result and BlockPersistence.save(blocks[key], path)
# Export Code Templates
code_templates = System.get_code_templates()
result = True
for key in code_templates:
path = System.get_user_dir()
path = os.path.join(path,
folder,
code_templates[key].language,
'codetemplates')
result = result and CodeTemplatePersistence.save(
code_templates[key], path)
# Export examples
path = System.get_user_dir()
path = os.path.join(path, "extensions")
examples = System.get_examples()
for example in examples:
relpath = os.path.relpath(example, path)
path = System.get_user_dir()
path = os.path.join(path, folder, relpath)
os.makedirs(os.path.dirname(path), exist_ok=True)
shutil.copy2(example, path)
# Create a zip file to the extension
path = System.get_user_dir()
path = os.path.join(path, folder+".zip")
zip_file = zipfile.ZipFile(path, 'w')
path = System.get_user_dir()
path = os.path.join(path, folder)
for folderName, subfolders, filenames in os.walk(path):
for filename in filenames:
filePath = os.path.join(folderName, filename)
#create complete filepath of file in directory
# Add file to zip
zip_file.write(filePath, os.path.relpath(filePath, path))
zip_file.close()
path = System.get_user_dir()
path = os.path.join(path, folder)
shutil.rmtree(path)
# create a publish file
filename = "resource.txt"
path = System.get_user_dir()
path = os.path.join(path, filename)
f = open(path, "w")
f.write(folder + ".zip")
f.close()
if result:
MessageDialog(
"Success",
"File " + folder + ".zip created successfully!",
self.main_window).run()
else:
MessageDialog(
"Error",
"Could not export extension",
self.main_window).run()
return result
def export_python(cls):
from mosaicode.system import System as System
System()
ports = System.get_ports()
for port in ports:
PortPersistence.save_python(ports[port])
def test_get_ports(self):
System.get_ports()
def print_ports(cls):
# This method is used by the launcher class
ports = System.get_ports()
for port in ports:
print "--------------------- "
PortControl.print_port(ports[port])
def __init__(self, port_manager, port):
self.port_manager = port_manager
self.port = System.get_ports()[port]
Gtk.Dialog.__init__(self, _("Port Editor"), self.port_manager, 0,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_SAVE, Gtk.ResponseType.OK))
self.main_control = self
self.set_default_size(800, 300)
self.tabs = Gtk.Notebook()
self.tabs.set_scrollable(True)
box = self.get_content_area()
box.pack_start(self.tabs, True, True, 0)
# Common Properties --------------------------------------------------
common_tab = Gtk.VBox()
self.tabs.append_page(common_tab, Gtk.Label(_("Common Properties")))
self.type = StringField({"label": _("Type")}, None)
self.language = StringField({"label": _("Language")}, None)
self.hint = StringField({"label": _("Hint")}, None)
self.color = ColorField({"label": _("Color")}, None)
self.color.set_parent_window(self)
self.multiple = CheckField({"label": _("Multiple")}, None)
self.var_name = StringField({"label": _("Var Name")}, None)
if port is not None:
System()
self.type.set_value(port)
self.language.set_value(self.port.language)
self.hint.set_value(self.port.hint)
self.color.set_value(self.port.color)
self.multiple.set_value(self.port.multiple)
self.var_name.set_value(self.port.var_name)
common_tab.pack_start(self.type, False, False, 1)
common_tab.pack_start(self.language, False, False, 1)
common_tab.pack_start(self.hint, False, False, 1)
common_tab.pack_start(self.color, False, False, 1)
common_tab.pack_start(self.multiple, False, False, 1)
common_tab.pack_start(self.var_name, False, False, 1)
# Connection Code ----------------------------------------------------
code_tab = Gtk.VBox()
self.tabs.append_page(code_tab, Gtk.Label(_("Connection Code")))
# Top Button bar
top_button_bar = Gtk.HBox()
code_tab.pack_start(top_button_bar, False, False, 1)
self.__populate_combos(top_button_bar)
self.code = CodeField({"label": _("Connection Code")}, None)
code_tab.pack_start(self.code, True, True, 1)
if port is not None:
System()
self.code.set_value(self.port.code)
self.show_all()
result = self.run()
if result == Gtk.ResponseType.OK:
self.__save()
self.close()
self.destroy()
