def export_materials(target):
if target.endswith(".zip")==False:
target=target+".zip"
file_list=[]
progress_window=progress_class()
progress_window.show()
progress_window.start()
process_events()
mat_files=["alpha_eq.inp","alpha_gen.omat","alpha.omat","cost.xlsx","dos.inp","fit.inp","info.txt","mat.inp","n_eq.inp","n_gen.omat","n.omat","pl.inp"]
for path, dirs, files in os.walk(os.path.join(os.getcwd(),"materials")):
for file_name in files:
if file_name in mat_files:
file_list.append(os.path.join(path,file_name))
zf = zipfile.ZipFile(target, 'a')
for i in range(0,len(file_list)):
cur_file=file_list[i]
lines=[]
if os.path.isfile(cur_file):
f=open(cur_file, mode='rb')
lines = f.read()
f.close()
zf.writestr(remove_cwdfrompath(cur_file), lines)
progress_window.set_fraction(float(i)/float(len(file_list)))
progress_window.set_text("Adding"+cur_file[len(os.getcwd()):])
process_events()
zf.close()
progress_window.stop()
def export_archive(target,everything):
if target.endswith(".opvdm")==False:
target=target+".opvdm"
file_list=[]
progress_window=progress_class()
progress_window.init()
progress_window.show()
progress_window.start()
process_events()
if everything==True:
for path, dirs, files in os.walk(os.getcwd()):
for file_name in files:
if file_name.endswith(".inp") or file_name.endswith(".dat") or file_name.endswith(".omat"):
file_list.append(os.path.join(path,file_name))
else:
files=os.listdir(os.getcwd())
for file_name in files:
if file_name.endswith(".inp"):
file_list.append(os.path.join(os.getcwd(),file_name))
zf = zipfile.ZipFile(target, 'a')
for i in range(0,len(file_list)):
cur_file=file_list[i]
lines=[]
if os.path.isfile(cur_file):
f=open(cur_file, mode='rb')
lines = f.read()
f.close()
zf.writestr(remove_cwdfrompath(cur_file), lines)
progress_window.set_fraction(float(i)/float(len(file_list)))
progress_window.set_text("Adding"+cur_file[len(os.getcwd()):])
process_events()
src_zf = zipfile.ZipFile(os.path.join(os.getcwd(),"sim.opvdm"), 'r')
for file_name in src_zf.namelist():
if file_name not in zf.namelist():
#print "adding from archive",file_name
lines=src_zf.read(file_name)
zf.writestr(file_name, lines)
zf.close()
src_zf.close()
progress_window.stop()
def load(self):
self.clean_menu()
self.last_page=0
#print "paths",os.getcwd(),get_bin_path(),(os.path.normcase(os.getcwd())!=os.path.normcase(get_bin_path()))
if (os.path.exists("sim.opvdm")==True) and (os.path.normcase(os.getcwd())!=os.path.normcase(get_bin_path())):
self.finished_loading=False
self.progress.init()
self.progress.show()
self.progress.start()
self.progress.set_text("Loading..")
process_events()
for child in self.get_children():
self.remove(child)
dos_files=inp_get_token_value("device_epitaxy.inp", "#layers")
self.main_tab=tab_main()
self.main_tab.init()
self.main_tab.show()
self.append_page(self.main_tab, gtk.Label(_("Device structure")))
lines=[]
pos=0
if inp_load_file(lines,"gui_config.inp")==True:
pos=0
tab_number=0
tabs=(len(lines)-3)/2
print "tabs=",tabs
while (1):
add_to_widget=False
ret,pos=inp_get_next_token_array(lines,pos)
if ret[0]=="#ver":
break
file_name=ret[0]
if file_name[0]=="#":
file_name=file_name[1:]
name=inp_file_to_description(file_name)
if name==False:
print "name not found",name
break
visible=bool(int(ret[1]))
self.progress.set_fraction(float(tab_number)/float(tabs))
tab_number=tab_number+1
self.progress.set_text(_("Loading ")+name)
process_events()
if file_name=="pl0.inp":
tab=pl_main()
tab.init()
tab.update()
add_to_widget=True
tab.visible=visible
tab.label_name=name
tab.file_name=file_name
elif file_name=="epitaxy.inp":
tab=dos_main()
tab.init()
tab.update()
add_to_widget=True
tab.visible=visible
tab.label_name=name
tab.file_name=file_name
elif file_name=="lumo0.inp":
tab=tab_bands()
tab.update()
if tab.enabled==True:
add_to_widget=True
tab.visible=visible
tab.wow()
tab.label_name=name
tab.file_name=file_name
elif inp_isfile(file_name)==True:
add_to_widget=True
tab=tab_class()
tab.visible=visible
tab.init(file_name,name)
tab.label_name=name
tab.file_name=file_name
if add_to_widget==True:
#print file_name,name,visible,type(tab)
hbox=gtk.HBox()
hbox.set_size_request(-1, 25)
mytext=name
if len(mytext)<10:
for i in range(len(mytext),10):
mytext=mytext+" "
label=gtk.Label(mytext)
label.set_justify(gtk.JUSTIFY_LEFT)
self.connect("switch-page", self.callback_switch_page)
hbox.pack_start(label, False, True, 0)
button = gtk.Button()
close_image = gtk.Image()
close_image.set_from_file(os.path.join(get_image_file_path(),"close.png"))
print os.path.join(get_image_file_path(),"close.png")
close_image.show()
button = gtk.Button()
button.add(close_image)
button.props.relief = gtk.RELIEF_NONE
button.connect("clicked", self.callback_close_button,name)
button.set_size_request(25, 25)
button.show()
hbox.pack_end(button, False, False, 0)
hbox.show_all()
if (visible==True):
tab.show()
self.append_page(tab,hbox)
self.set_tab_reorderable(tab,True)
self.add_to_menu(name,visible)
else:
print _("No gui_config.inp file found\n")
#for child in self.get_children():
# print type(child)
if self.terminal_widget!=None:
self.terminal_widget.show()
self.append_page(self.terminal_widget, gtk.Label(_("Terminal")))
self.add_welcome_page()
self.finished_loading=True
self.progress.stop()
self.progress.set_fraction(0.0)
self.goto_page("tab_main")
self.set_tab_pos(gtk.POS_TOP)
#self.set_current_page(1)
return True
else:
self.add_welcome_page()
self.goto_page(_("Welcome"))
return False
def __init__(self):
gobject.GObject.__init__(self)
self.my_server=server()
self.my_server.init(os.getcwd())
self.my_server.statusicon.connect('popup-menu', self.on_status_icon_right_click)
self.my_server.setup_gui(self.gui_sim_start,self.gui_sim_stop)
if running_on_linux()==True:
DBusGMainLoop(set_as_default=True)
self.bus = dbus.SessionBus()
self.bus.add_match_string_non_blocking("type='signal',interface='org.my.opvdm'")
self.bus.add_message_filter(self.adbus)
else:
self.win_pipe=win_pipe()
self.win_pipe.connect('new-data', self.win_dbus)
self.win_pipe.start()
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
#self.window.set_size_request(-1,1000)
self.window.set_border_width(10)
self.window.set_title(_("Organic Photovoltaic Device Model (www.opvdm.com)"))
splash=splash_window()
splash.init()
temp_error=ver_error()
print temp_error
if len(temp_error)>0:
md = gtk.MessageDialog(self.window,gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, temp_error)
md.run()
md.destroy()
self.undo_list=undo_list_class()
self.undo_list.init()
self.experiment_window=None
self.fxexperiment_window=None
self.qe_window=None
self.win_list=windows()
self.win_list.load()
self.config=config()
#table = gtk.Table(3,6,False)
self.window.set_icon_from_file(os.path.join(get_image_file_path(),"image.jpg"))
self.show_tabs = True
self.show_border = True
self.menu_items = (
( _("/_File"), None, None, 0, "<Branch>" ),
(_("/File/_New simulation"), "<control>N", self.callback_new, 0, "<StockItem>", "gtk-new" ),
(_("/File/_Open simulation"), "<control>O", self.callback_open, 0, "<StockItem>", "gtk-open" ),
( _("/File/_Export data"), None, self.callback_export, 0, "<StockItem>", "gtk-save" ),
( _("/File/Import data"), None, self.callback_import, 0 , "<StockItem>", "gtk-harddisk"),
( _("/File/Import from library"), None, self.callback_import_from_lib, 0 , "<StockItem>", "gtk-harddisk"),
( _("/File/Quit"), "<control>Q", gtk.main_quit, 0, "<StockItem>", "gtk-quit" ),
( _("/_Simulate"), None, None, 0, "<Branch>" ),
( _("/Simulate/Run"), None, self.callback_simulate, 0, "<StockItem>", "gtk-media-play" ),
( _("/Simulate/Parameter scan"), None, self.callback_scan , 0, None ),
( _("/Simulate/Start cluster server"), None, self.callback_start_cluster_server , 0, None ),
( _("/_View"), None, None, 0, "<Branch>" ),
( _("/_Plots"), None, None, 0, "<Branch>" ),
( _("/Plots/Plot simulation result"), None, self.callback_plot_select, 0, "<StockItem>", "gtk-open"),
( _("/_Plots/"), None, None, 0, "<Separator>" ),
( _("/_Help"), None, None, 0, "<LastBranch>" ),
( _("/_Help/Help Index"), None, self.callback_help, 0, "<StockItem>", "gtk-help" ),
( _("/_Help/About"), None, self.callback_about_dialog, 0, "<StockItem>", "gtk-about" ),
)
pos=0
self.menubar = self.get_main_menu(self.window)
#a = (( "/Plots/Plot after simulation", None, self.callback_plot_after_run_toggle, 0, "<ToggleItem>" ), )
#self.item_factory.create_items( a, )
#a = (( "/Plots/One plot window", None, self.callback_set_plot_auto_close, 0, "<ToggleItem>" ), )
#self.item_factory.create_items( a, )
#table.show()
self.window.connect("destroy", gtk.main_quit)
self.tooltips = gtk.Tooltips()
self.window.set_size_request(-1, 780)
main_vbox = gtk.VBox(False, 5)
main_vbox.set_border_width(1)
self.window.add(main_vbox)
#window.add(table)
main_vbox.show()
toolbar = gtk.Toolbar()
toolbar.set_style(gtk.TOOLBAR_ICONS)
toolbar.set_size_request(-1, 50)
open_sim = gtk.ToolButton(gtk.STOCK_OPEN)
self.tooltips.set_tip(open_sim, _("Open a simulation"))
toolbar.insert(open_sim, pos)
pos=pos+1
#self.save_sim = gtk.ToolButton(gtk.STOCK_SAVE)
#self.tooltips.set_tip(self.save_sim, "Save a simulation")
#toolbar.insert(self.save_sim, pos)
#pos=pos+1
new_sim = gtk.ToolButton(gtk.STOCK_NEW)
self.tooltips.set_tip(new_sim, _("Make a new simulation"))
toolbar.insert(new_sim, pos)
pos=pos+1
sep_lhs = gtk.SeparatorToolItem()
sep_lhs.set_draw(True)
sep_lhs.set_expand(False)
toolbar.insert(sep_lhs, pos)
pos=pos+1
self.undo = gtk.ToolButton(gtk.STOCK_UNDO)
self.tooltips.set_tip(self.undo, "Undo")
toolbar.insert(self.undo, pos)
self.undo.connect("clicked", self.callback_undo)
pos=pos+1
sep_lhs = gtk.SeparatorToolItem()
sep_lhs.set_draw(True)
sep_lhs.set_expand(False)
toolbar.insert(sep_lhs, pos)
pos=pos+1
image = gtk.Image()
image.set_from_file(os.path.join(get_image_file_path(),"play.png"))
self.play = gtk.ToolButton(image)
self.tooltips.set_tip(self.play, _("Run the simulation"))
toolbar.insert(self.play, pos)
self.play.connect("clicked", self.callback_simulate)
pos=pos+1
image = gtk.Image()
image.set_from_file(os.path.join(get_image_file_path(),"forward.png"))
self.tb_run_scan = gtk.ToolButton(image)
self.tb_run_scan.connect("clicked", self.callback_run_scan)
self.tooltips.set_tip(self.tb_run_scan, _("Run parameter scan"))
toolbar.insert(self.tb_run_scan, pos)
self.tb_run_scan.set_sensitive(False)
pos=pos+1
if debug_mode()==True:
image = gtk.Image()
image.set_from_file(os.path.join(get_image_file_path(),"fit.png"))
self.tb_run_fit = gtk.ToolButton(image)
self.tb_run_fit.connect("clicked", self.callback_run_fit)
self.tooltips.set_tip(self.tb_run_fit, _("Run a fit command"))
toolbar.insert(self.tb_run_fit, pos)
self.tb_run_fit.set_sensitive(True)
pos=pos+1
image = gtk.Image()
image.set_from_file(os.path.join(get_image_file_path(),"pause.png"))
self.stop = gtk.ToolButton(image )
self.tooltips.set_tip(self.stop, _("Stop the simulation"))
self.stop.connect("clicked", self.callback_simulate_stop)
toolbar.insert(self.stop, pos)
pos=pos+1
sep = gtk.SeparatorToolItem()
sep.set_draw(True)
sep.set_expand(False)
toolbar.insert(sep, pos)
pos=pos+1
image = gtk.Image()
image.set_from_file(os.path.join(get_image_file_path(),"scan.png"))
self.param_scan = gtk.ToolButton(image)
self.param_scan.connect("clicked", self.callback_scan)
self.tooltips.set_tip(self.param_scan, _("Parameter scan"))
toolbar.insert(self.param_scan, pos)
pos=pos+1
sep = gtk.SeparatorToolItem()
sep.set_draw(True)
sep.set_expand(False)
toolbar.insert(sep, pos)
pos=pos+1
image = gtk.Image()
image.set_from_file(os.path.join(get_image_file_path(),"plot.png"))
self.plot_select = gtk.MenuToolButton(image,"hello")
self.tooltips.set_tip(self.plot_select, _("Find a file to plot"))
self.plotted_graphs = used_files_menu()
self.plot_select.set_menu(self.plotted_graphs.menu)
toolbar.insert(self.plot_select, pos)
self.plot_select.connect("clicked", self.callback_plot_select)
self.plot_select.set_sensitive(False)
pos=pos+1
#image = gtk.Image()
#image.set_from_file(os.path.join(get_image_file_path(),"refresh.png"))
#self.plot_open = gtk.ToolButton(image)
#self.tooltips.set_tip(self.plot_open, "Replot the graph")
#toolbar.insert(self.plot_open, pos)
#self.plot_open.set_sensitive(False)
#os=pos+1
image = gtk.Image()
image.set_from_file(os.path.join(get_image_file_path(),"plot_time.png"))
self.examine = gtk.ToolButton(image)
self.tooltips.set_tip(self.examine, _("Examine results in time domain"))
self.examine.connect("clicked", self.callback_examine)
toolbar.insert(self.examine, pos)
pos=pos+1
sep = gtk.SeparatorToolItem()
sep.set_draw(True)
sep.set_expand(False)
toolbar.insert(sep, pos)
pos=pos+1
image = gtk.Image()
image.set_from_file(os.path.join(get_image_file_path(),"time.png"))
self.experiment_window_button = gtk.ToolButton(image)
self.tooltips.set_tip(self.experiment_window_button, _("Edit the time mesh"))
self.experiment_window_button.connect("clicked", self.callback_edit_experiment_window)
toolbar.insert(self.experiment_window_button, pos)
pos=pos+1
image = gtk.Image()
image.set_from_file(os.path.join(get_image_file_path(),"spectrum.png"))
self.examine = gtk.ToolButton(image)
self.tooltips.set_tip(self.examine, _("Frequency domain mesh editor"))
self.examine.connect("clicked", self.callback_fxexperiment_window)
toolbar.insert(self.examine, pos)
pos=pos+1
sep2 = gtk.SeparatorToolItem()
sep2.set_draw(False)
sep2.set_expand(True)
toolbar.insert(sep2, pos)
pos=pos+1
help = gtk.ToolButton(gtk.STOCK_HELP)
self.tooltips.set_tip(help, "Help")
help.connect("clicked", self.callback_help)
toolbar.insert(help, pos)
pos=pos+1
#quittb = gtk.ToolButton(gtk.STOCK_QUIT)
#self.tooltips.set_tip(quittb, "Quit")
#toolbar.insert(quittb, pos)
#quittb.connect("clicked", gtk.main_quit)
#pos=pos+1
new_sim.connect("clicked", self.callback_new)
open_sim.connect("clicked", self.callback_open)
#self.save_sim.connect("clicked", self.callback_export)
#self.plot_open.connect("clicked", self.callback_plot_open)
toolbar1=self.make_tool_box1()
toolbar.show_all()
main_vbox.pack_start(self.menubar, False, True, 0)
handlebox = gtk.HandleBox()
handlebox.set_snap_edge(gtk.POS_LEFT)
handlebox.show()
toolbar.set_size_request(1000, -1)
tb_vbox=gtk.VBox()
tb_vbox.add(toolbar)
tb_vbox.add(toolbar1)
tb_vbox.show()
handlebox.add(tb_vbox)
main_vbox.pack_start(handlebox, False, False, 0)
self.window.connect("delete-event", self.callback_close_window)
self.win_list.set_window(self.window,"main_window")
self.menubar.show()
self.make_window2(main_vbox)
self.window.show()
process_events()
