def __init__(self, verbose=True):
self.save_dir = os.getcwd()
self.server = base_server()
if verbose == True:
self.server.pipe_to_null = False
else:
self.server.pipe_to_null = True
#self.server.base_server_init(get_sim_path())
if server_get() != False:
self.server = server_get()
self.server.clear_cache()
self.epi = get_epi()
if self.epi.loaded == False:
self.epi.load(os.getcwd())
self.scan = api_scan(self.server)
#image ops
self.Image = Image
self.ImageFilter = ImageFilter
self.ImageOps = ImageOps
self.path = ""
self.callback = None
self.get_scan_human_labels = get_scan_human_labels()
self.get_scan_human_labels.clear()
self.get_scan_human_labels.populate_from_known_tokens()
self.get_scan_human_labels.populate_from_files()
def __init__(self, treeview):
QWidget.__init__(self)
self.dest_treeview = treeview
self.setFixedSize(500, 700)
self.file_name_tab_pos = 0
self.token_tab_pos = 1
self.path_tab_pos = 2
self.main_vbox = QVBoxLayout()
self.save_function = None
self.setWindowIcon(icon_get("scan"))
self.setWindowTitle(
_("Select simulation parameter") + " (https://www.gpvdm.com)")
self.tab = QTreeWidget()
self.scan_human_labels = get_scan_human_labels()
#self.tab.setHeaderItem("Scan items")
self.font = QFont()
# self.font.setFamily('DejaVu Sans')
# self.font.setBold(True)
# self.font.setStyleHint(QFont.Monospace)
# self.font.setFixedPitch(True)
self.font.setPointSize(int(20))
self.tab.setFont(self.font)
self.main_vbox.addWidget(self.tab)
self.hwidget = QWidget()
okButton = QPushButton(_("OK"))
cancelButton = QPushButton(_("Cancel"))
hbox = QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(okButton)
hbox.addWidget(cancelButton)
self.hwidget.setLayout(hbox)
self.main_vbox.addWidget(self.hwidget)
self.setLayout(self.main_vbox)
okButton.clicked.connect(self.tree_apply_click)
cancelButton.clicked.connect(self.close)
#self.tab.itemSelectionChanged.connect(self.tree_apply_click)
self.tab.header().close()
self.update()
def __init__(self):
super(gpvdm_main_window, self).__init__()
icon_init_db()
#from scans_io import scans_io
#from cal_path import get_sim_path
#scans=scans_io(get_sim_path())
#sims=scans.get_scan_dirs()
#print(sims)
#asdsa
self.splash = splash_window()
self.scan_human_labels = get_scan_human_labels()
self.splash.inc_value()
process_events()
process_events()
#from wiz import wiz
#a=wiz()
#a.exec_()
#sys.exit()
do_import()
if os.path.isdir(os.path.dirname(sys.argv[0])) == False:
error_dlg(self, _("I can't run from inside a zip file!"))
sys.exit()
self.splash.inc_value()
self.splash.inc_value()
server_init()
self.splash.inc_value()
self.check_sim_exists = check_sim_exists()
self.splash.inc_value()
self.check_sim_exists.start_thread()
self.splash.inc_value()
self.check_sim_exists.sim_gone.connect(self.sim_gone)
self.splash.inc_value()
self.my_server = server_get()
self.my_server.init(get_sim_path())
self.splash.inc_value()
self.undo_list = undo_list_class()
wpos_load()
self.splash.inc_value()
self.ribbon = ribbon()
self.splash.inc_value()
self.notebook_active_page = None
self.setAcceptDrops(True)
#self.setGeometry(200, 100, 1300, 600)
self.setWindowTitle(
"General-purpose Photovoltaic Device Model (https://www.gpvdm.com)"
)
self.l = lock_gui()
#self.l.disable_all.connect(self.disable_interface)
#self.l.enable_all.connect(self.enable_disable_buttons)
#super(gpvdm_main_window, self).__init__(parent, QtCore.Qt.FramelessWindowHint)
#gobject.GObject.__init__(self)
#self.my_server.setup_gui(self.gui_sim_start)
self.my_server.sim_started.connect(self.gui_sim_start)
self.splash.inc_value()
self.my_server.sim_finished.connect(self.gui_sim_stop)
self.splash.inc_value()
help_init()
self.splash.inc_value()
#help_window().help_set_help(["star.png",_("<big><b>Update available!</b></big><br>")])
#self.show()
if running_on_linux() == True:
self.bus = dbus.SessionBus()
self.bus.add_match_string_non_blocking(
"type='signal',interface='org.my.gpvdm'")
self.bus.add_message_filter(self.adbus)
else:
self.win_pipe = win_pipe()
self.win_pipe.new_data.connect(self.win_dbus)
self.win_pipe.start()
self.notebook = gpvdm_notebook()
vbox = QVBoxLayout()
self.splash.inc_value()
vbox.addWidget(self.ribbon)
self.ribbon.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.notebook.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
vbox.addWidget(self.notebook)
wvbox = QWidget()
self.splash.inc_value()
wvbox.setLayout(vbox)
self.setCentralWidget(wvbox)
self.splash.inc_value()
self.statusBar()
temp_error = ver_error()
#print(temp_error)
if len(temp_error) > 0:
error_dlg(self, temp_error)
return
self.setWindowIcon(
QIcon(os.path.join(get_image_file_path(), "image.jpg")))
self.splash.inc_value()
self.show_tabs = True
self.show_border = True
self.ribbon.file.home_new.clicked.connect(self.callback_new)
self.ribbon.file.home_open.clicked.connect(self.callback_open)
self.ribbon.file.used_files_click.connect(self.load_sim)
self.ribbon.home.undo.triggered.connect(self.callback_undo)
self.ribbon.home.run.start_sim.connect(self.callback_simulate)
self.splash.inc_value()
#self.ribbon.home.stop.setEnabled(False)
self.ribbon.home.scan.setEnabled(False)
self.ribbon.thermal.setEnabled(False)
self.ribbon.home.help.triggered.connect(self.callback_on_line_help)
update_init()
resize_window_to_be_sane(self, 0.7, 0.75)
self.change_dir_and_refresh_interface(get_sim_path())
self.splash.inc_value()
#self.ribbon.home.sun.changed.connect(self.notebook.update)
self.ribbon.setAutoFillBackground(True)
self.splash.inc_value()
self.show()
help_window().show()
self.enable_disable_buttons()
val = inp_get_token_value(os.path.join(get_sim_path(), "config.inp"),
"#use_gpvdm_local")
if val != "false":
if os.path.isdir(get_materials_path()) == False:
clone_materials(get_materials_path(), get_base_material_path(),
"material")
if os.path.isdir(get_emission_path()) == False:
clone_materials(get_emission_path(), get_base_emission_path(),
"emission")
if os.path.isdir(get_shape_path()) == False:
clone_materials(get_shape_path(), get_base_shape_path(),
"shape")
if os.path.isdir(get_scripts_path()) == False:
shutil.copytree(get_base_scripts_path(),
get_scripts_path(),
symlinks=True)
if os.path.isdir(get_spectra_path()) == False:
clone_spectras(get_spectra_path())
self.cache = cache(only_open_if_full=True)
#from shape_editor import shape_editor
#self.shape_window=shape_editor("/home/rod/gpvdm_local/shape/pedot")
#self.shape_window.show()
#from shape_import import shape_import
#self.shape_import=shape_import("/home/rod/gpvdm_local/shape/pedot")
#self.shape_import.show()
check_lib_in_bash_rc()
def __init__(self, index):
self.index = index
self.file_name = os.path.join(
get_sim_path(), "time_mesh_config" + str(self.index) + ".inp")
self.scan_human_labels = get_scan_human_labels()
QWidget.__init__(self)
self.main_vbox = QVBoxLayout()
self.time = []
self.voltage = []
self.sun = []
self.laser = []
self.edit_list = []
self.line_number = []
self.list = []
self.fig = Figure(figsize=(5, 4), dpi=100)
self.canvas = FigureCanvas(self.fig)
self.canvas.figure.patch.set_facecolor('white')
#toolbar=QToolBar()
#toolbar.setIconSize(QSize(48, 48))
#nav_bar=NavigationToolbar(self.canvas,self)
#toolbar.addWidget(nav_bar)
#self.main_vbox.addWidget(toolbar)
#canvas.set_size_request(500, 150)
self.ax1 = None
self.show_key = True
self.main_vbox.addWidget(self.canvas)
#self.canvas.show()
#toolbar 2
toolbar2 = QToolBar()
toolbar2.setIconSize(QSize(32, 32))
self.tb_add = QAction(icon_get("list-add"), _("Add section"), self)
self.tb_add.triggered.connect(self.callback_add_section)
toolbar2.addAction(self.tb_add)
self.tb_remove = QAction(icon_get("list-remove"), _("Delete section"),
self)
self.tb_remove.triggered.connect(self.callback_remove_item)
toolbar2.addAction(self.tb_remove)
self.tb_move = QAction(icon_get("go-down"), _("Move down"), self)
self.tb_move.triggered.connect(self.callback_move_down)
toolbar2.addAction(self.tb_move)
self.tb_move_up = QAction(icon_get("go-up"), _("Move up"), self)
self.tb_move_up.triggered.connect(self.callback_move_up)
toolbar2.addAction(self.tb_move_up)
self.main_vbox.addWidget(toolbar2)
self.tab = gpvdm_tab()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.load_data()
self.update_scan_tokens()
self.build_mesh()
self.draw_graph()
self.tab.cellChanged.connect(self.on_cell_edited)
self.main_vbox.addWidget(self.tab)
w = self.width()
#self.canvas.setMinimumSize(w, 400)
self.tab.setMinimumSize(w, 120)
self.setLayout(self.main_vbox)
def __init__(self):
QWidget.__init__(self)
self.file_name = os.path.join(get_sim_path(), "fit_constraints.inp")
self.setWindowTitle(
_("Fit constraints window") + " - https://www.gpvdm.com")
self.setWindowIcon(icon_get("constraints"))
self.setFixedSize(900, 700)
self.vbox = QVBoxLayout()
########################mm##########################
toolbar_mm = QToolBar()
toolbar_mm.setIconSize(QSize(32, 32))
self.tb_save = QAction(icon_get("list-add"), _("Add"), self)
self.tb_save.triggered.connect(self.callback_add_item_mm)
toolbar_mm.addAction(self.tb_save)
self.tb_save = QAction(icon_get("list-remove"), _("Minus"), self)
self.tb_save.triggered.connect(self.callback_delete_item_mm)
toolbar_mm.addAction(self.tb_save)
self.tb_down = QAction(icon_get("go-down"), _("Move down"), self)
self.tb_down.triggered.connect(self.on_move_down)
toolbar_mm.addAction(self.tb_down)
self.tb_up = QAction(icon_get("go-up"), _("Move up"), self)
self.tb_up.triggered.connect(self.on_move_up)
toolbar_mm.addAction(self.tb_up)
self.vbox.addWidget(toolbar_mm)
self.tab_mm = gpvdm_tab()
self.tab_mm.resizeColumnsToContents()
self.tab_mm.verticalHeader().setVisible(False)
self.create_model_mm()
self.tab_mm.cellChanged.connect(self.tab_changed)
self.select_param_window_mm = select_param(self.tab_mm)
self.select_param_window_mm.set_save_function(self.save_combo)
self.select_param_window_mm.file_name_tab_pos = 0
self.select_param_window_mm.token_tab_pos = 1
self.select_param_window_mm.path_tab_pos = 2
self.vbox.addWidget(self.tab_mm)
#####################math##########################
toolbar_math = QToolBar()
toolbar_math.setIconSize(QSize(32, 32))
self.tb_save = QAction(icon_get("list-add"), _("Add"), self)
self.tb_save.triggered.connect(self.callback_add_item_math)
toolbar_math.addAction(self.tb_save)
self.tb_save = QAction(icon_get("list-remove"), _("Minus"), self)
self.tb_save.triggered.connect(self.callback_delete_item_math)
toolbar_math.addAction(self.tb_save)
self.vbox.addWidget(toolbar_math)
self.tab_math = gpvdm_tab()
self.tab_math.resizeColumnsToContents()
self.tab_math.verticalHeader().setVisible(False)
self.create_model_math()
self.tab_math.cellChanged.connect(self.tab_changed)
self.select_param_window_math_a = select_param(self.tab_math)
self.select_param_window_math_a.set_save_function(self.save_combo)
self.select_param_window_math_a.file_name_tab_pos = 0
self.select_param_window_math_a.token_tab_pos = 1
self.select_param_window_math_a.path_tab_pos = 2
self.select_param_window_math_b = select_param(self.tab_math)
self.select_param_window_math_b.set_save_function(self.save_combo)
self.select_param_window_math_b.file_name_tab_pos = 4
self.select_param_window_math_b.token_tab_pos = 5
self.select_param_window_math_b.path_tab_pos = 6
self.vbox.addWidget(self.tab_math)
self.setLayout(self.vbox)
self.get_scan_human_labels = get_scan_human_labels()
def __init__(self,my_server):
QWidgetSavePos.__init__(self,"scan_window")
self.myserver=my_server
self.setMinimumSize(1000,500)
self.setWindowTitle(_("Parameter scan - gpvdm"))
self.setWindowIcon(icon_get("scan"))
self.rod=[]
self.sim_dir=get_sim_path()
self.main_vbox = QVBoxLayout()
self.ribbon=scan_ribbon()
self.main_vbox.addWidget(self.ribbon)
self.ribbon.menu_plot_fits.triggered.connect(self.callback_plot_fits)
self.ribbon.sim_no_gen.triggered.connect(self.callback_run_simulation_nogen)
self.ribbon.single_fit.triggered.connect(self.callback_run_single_fit)
self.ribbon.clean_unconverged.triggered.connect(self.callback_clean_unconverged_simulation)
self.ribbon.clean_sim_output.triggered.connect(self.callback_clean_simulation_output)
self.ribbon.push_unconverged_to_hpc.triggered.connect(self.callback_push_unconverged_to_hpc)
self.ribbon.report.triggered.connect(self.callback_report)
self.ribbon.tb_new.triggered.connect(self.callback_new_scan)
self.ribbon.tb_delete.triggered.connect(self.callback_delete_page)
self.ribbon.tb_clone.triggered.connect(self.callback_clone)
self.ribbon.tb_rename.triggered.connect(self.callback_rename)
#self.ribbon.tb_simulate.start_sim.connect(self.callback_run_simulation)
#self.ribbon.tb_build.triggered.connect(self.callback_build_scan)
#self.ribbon.tb_rerun.triggered.connect(self.callback_scan_run)
#self.ribbon.tb_zip.triggered.connect(self.callback_scan_archive)
self.ribbon.tb_run_all.triggered.connect(self.callback_run_all_simulations)
#self.ribbon.tb_plot.triggered.connect(self.callback_plot)
#self.ribbon.tb_plot_time.triggered.connect(self.callback_examine)
self.ribbon.tb_ml_build_vectors.triggered.connect(self.callback_mb_build_vectors)
#self.ribbon.tb_notes.triggered.connect(self.callback_notes)
self.ribbon.tb_clean.triggered.connect(self.callback_clean_all)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.notebook = QTabWidget()
self.notebook.setTabBar(QHTabBar())
css_apply(self.notebook,"style_h.css")
self.notebook.setTabPosition(QTabWidget.West)
self.notebook.setMovable(True)
#self.main_vbox.addWidget(self.notebook)
self.viewer=gpvdm_viewer(self.sim_dir)
self.viewer.allow_navigation=True
self.viewer.set_directory_view(True)
self.viewer.set_back_arrow(False)
self.viewer.show_only=["scan_dir"]
self.viewer.set_multi_select()
self.viewer.selection_changed.connect(self.callback_selection_changed)
self.callback_selection_changed()
self.main_vbox.addWidget(self.viewer)
self.status_bar=QStatusBar()
self.main_vbox.addWidget(self.status_bar)
print("!!!!!!!!!!!!>>>>>>>>>>>>>>>>>>>>>")
get_scan_human_labels().populate_from_files()
self.setLayout(self.main_vbox)
def __init__(self,index):
QWidget.__init__(self)
self.index=index
self.ax1=None
self.show_key=True
self.edit_list=[]
self.line_number=[]
self.list=[]
self.fig = Figure(figsize=(5,4), dpi=100)
self.canvas = FigureCanvas(self.fig)
self.canvas.figure.patch.set_facecolor('white')
self.get_scan_human_labels=get_scan_human_labels()
self.main_vbox = QHBoxLayout()
self.main_vbox.addWidget(self.canvas)
self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
#toolbar 2
toolbar2=QToolBar()
toolbar2.setIconSize(QSize(32, 32))
self.tb_add = QAction(icon_get("list-add"), _("Add section"), self)
self.tb_add.triggered.connect(self.callback_add_section)
toolbar2.addAction(self.tb_add)
self.tb_remove = QAction(icon_get("list-remove"), _("Delete section"), self)
self.tb_remove.triggered.connect(self.callback_remove_item)
toolbar2.addAction(self.tb_remove)
self.tb_move = QAction(icon_get("go-down"), _("Move down"), self)
self.tb_move.triggered.connect(self.callback_move_down)
toolbar2.addAction(self.tb_move)
self.tb_move_up = QAction(icon_get("go-up"), _("Move up"), self)
self.tb_move_up.triggered.connect(self.callback_move_up)
toolbar2.addAction(self.tb_move_up)
tab_holder=QWidget()
tab_vbox_layout= QVBoxLayout()
tab_holder.setLayout(tab_vbox_layout)
tab_vbox_layout.addWidget(toolbar2)
self.tab = gpvdm_tab()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.load_data()
self.build_mesh()
self.draw_graph()
self.update_scan_tokens()
self.tab.cellChanged.connect(self.on_cell_edited)
self.tab.changed.connect(self.redraw_and_save)
#self.tab.paste_callback=self.paste_action
tab_vbox_layout.addWidget(self.tab)
self.main_vbox.addWidget(tab_holder)
self.setLayout(self.main_vbox)
self.tab.menu_paste.triggered.connect(self.paste_action)
def listdir(self):
ret = []
if self.path == "/gpvdmroot":
itm = file_store()
itm.file_name = "simulation_dir"
itm.icon = "si"
itm.display_name = _("Simulation")
ret.append(itm)
itm = file_store()
itm.file_name = "home_dir"
itm.icon = "user-home"
itm.display_name = _("Home")
ret.append(itm)
if get_desktop_path() != False:
itm = file_store()
itm.file_name = "desktop_dir"
itm.icon = "desktop"
itm.display_name = _("Desktop")
ret.append(itm)
if get_downloads_path() != False:
itm = file_store()
itm.file_name = "downloads_dir"
itm.icon = "folder-download"
itm.display_name = _("Downloads")
ret.append(itm)
itm = file_store()
itm.file_name = "gpvdm_configure"
itm.icon = "cog"
itm.display_name = _("Configure")
ret.append(itm)
for p in psutil.disk_partitions():
name = p.mountpoint
if running_on_linux() == True:
name = os.path.basename(name)
if name == "":
name = "/"
itm = file_store()
itm.file_name = "mount_point::::" + p.mountpoint
itm.icon = "drive-harddisk"
itm.display_name = name
ret.append(itm)
elif self.path == "/gpvdmroot/gpvdm_configure":
itm = file_store()
itm.file_name = "gpvdm_cluster_config"
itm.icon = "server"
itm.display_name = _("Cluster")
ret.append(itm)
itm = file_store()
itm.file_name = "gpvdm_language_config"
itm.icon = "internet-chat"
itm.display_name = _("Language")
ret.append(itm)
itm = file_store()
itm.file_name = "gpvdm_solver_config"
itm.icon = "accessories-calculator"
itm.display_name = _("Solver")
ret.append(itm)
#itm=file_store()
#itm.file_name="gpvdm_led_config"
#itm.icon="oled"
#itm.display_name=_("LED")
#ret.append(itm)
itm = file_store()
itm.file_name = "gpvdm_dump_config"
itm.icon = "hdd_custom"
itm.display_name = _("Output files")
ret.append(itm)
itm = file_store()
itm.file_name = "gpvdm_gui_config"
itm.icon = "applications-interfacedesign"
itm.display_name = _("GUI configuration")
ret.append(itm)
itm = file_store()
itm.file_name = "gpvdm_server_config"
itm.icon = "cpu"
itm.display_name = _("Server")
ret.append(itm)
itm = file_store()
itm.file_name = "gpvdm_key"
itm.icon = "gnome-dialog-password"
itm.display_name = _("License")
ret.append(itm)
itm = file_store()
itm.file_name = "gpvdm_cache"
itm.icon = "cache"
itm.display_name = _("Cache")
ret.append(itm)
elif self.path.startswith(os.path.join(get_sim_path(),
"parameters")) == True:
from scan_human_labels import get_scan_human_labels
s = get_scan_human_labels()
s.ls_dir("/")
itm = file_store()
itm.file_name = "star"
itm.icon = "star"
itm.display_name = _("Cache")
ret.append(itm)
else:
files = os.listdir(self.path)
for f in files:
itm = file_store()
itm.file_name = f
itm.isdir = os.path.isdir(os.path.join(self.path, f))
itm.type = get_dir_type(os.path.join(self.path, f))
if itm.type != "scan_dir":
ret.append(itm)
#print(get_sim_path(),self.path)
if get_sim_path() == self.path:
itm = file_store()
itm.file_name = "parameters"
itm.type = "parameter_dir"
itm.icon = "star"
itm.display_name = _("parameters")
ret.append(itm)
scan = scans_io(get_sim_path())
scans = scan.get_scans()
for s in scans:
for i in range(0, len(ret)):
if ret[i].file_name == s.human_name:
ret.pop(i)
break
itm = file_store()
itm.type = "scan_dir"
itm.isdir = True
itm.file_name = os.path.basename(s.config_file)
itm.display_name = s.human_name
ret.append(itm)
ret = sorted(ret, key=operator.attrgetter('display_name'))
#files = sorted(files, key=operator.attrgetter('file_name'))
return ret
def __init__(self, scan_file):
QWidget.__init__(self)
self.notebook = QTabWidget()
self.setWindowTitle(_("Parameter scan editor - (www.gpvdm.com)"))
self.setWindowIcon(icon_get("scan"))
self.main_vbox = QVBoxLayout()
self.scan_tab_vbox = QVBoxLayout()
self.tokens = tokens()
self.myserver = server_get()
self.status_bar = QStatusBar()
self.param_list = get_scan_human_labels().list
#self.tab_label=tab_label
self.scan_io = scan_io()
self.scan_io.parent_window = self
#self.scan_io.set_path(self.scan_io.scan_dir)
self.scan_io.load(scan_file)
self.scan_io.make_dir()
toolbar = QToolBar()
toolbar.setIconSize(QSize(32, 32))
self.tb_add = QAction(icon_get("list-add"), _("Add parameter to scan"),
self)
self.tb_add.triggered.connect(self.callback_add_item)
toolbar.addAction(self.tb_add)
self.tb_minus = QAction(icon_get("list-remove"), _("Delete item"),
self)
self.tb_minus.triggered.connect(self.callback_delete_item)
toolbar.addAction(self.tb_minus)
self.tb_down = QAction(icon_get("go-down"), _("Move down"), self)
self.tb_down.triggered.connect(self.callback_move_down)
toolbar.addAction(self.tb_down)
self.tb_up = QAction(icon_get("go-up"), _("Move up"), self)
self.tb_up.triggered.connect(self.callback_move_up)
toolbar.addAction(self.tb_up)
self.tb_command = QAction(icon_get("utilities-terminal"),
_("Insert python command"), self)
self.tb_command.triggered.connect(self.callback_insert_command)
toolbar.addAction(self.tb_command)
self.scan_tab_vbox.addWidget(toolbar)
self.tab = gpvdm_tab()
css_apply(self.notebook, "tab_default.css")
self.notebook.setMovable(True)
self.tab.verticalHeader().setVisible(False)
self.tab.setColumnCount(5)
#if enable_betafeatures()==False:
# self.tab.setColumnHidden(0, True)
# self.tab.setColumnHidden(1, True)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tab.setColumnWidth(2, 300)
self.tab.setColumnWidth(3, 300)
self.tab.setColumnWidth(4, 300)
self.load()
self.tab.cellChanged.connect(self.tab_changed)
self.scan_tab_vbox.addWidget(self.tab)
self.notebook.popMenu = QMenu(self)
#self.mp_show_list=QAction(_("Select parameter to scan"), self)
#self.mp_show_list.triggered.connect(self.callback_show_list)
#self.popMenu.addAction(self.mp_show_list)
self.notebook.popMenu.addSeparator()
self.mp_delete = QAction(_("Delete item"), self)
self.mp_delete.triggered.connect(self.callback_delete_item)
self.notebook.popMenu.addAction(self.mp_delete)
self.mp_copy = QAction(_("Copy"), self)
self.mp_copy.triggered.connect(self.callback_copy_item)
self.notebook.popMenu.addAction(self.mp_copy)
self.mp_paste = QAction(_("Paste"), self)
self.mp_paste.triggered.connect(self.callback_paste_item)
self.notebook.popMenu.addAction(self.mp_paste)
self.notebook.popMenu.addSeparator()
self.mp_add = QAction(_("Add item"), self)
self.mp_add.triggered.connect(self.callback_add_item)
self.notebook.popMenu.addAction(self.mp_add)
self.mp_down = QAction(_("Move down"), self)
self.mp_down.triggered.connect(self.callback_move_down)
self.notebook.popMenu.addAction(self.mp_down)
self.mp_down = QAction(_("Move down"), self)
self.mp_down.triggered.connect(self.callback_move_down)
self.notebook.popMenu.addAction(self.mp_down)
self.notebook.popMenu.addSeparator()
self.notebook.setMinimumSize(700, 500)
self.program_widget = QWidget()
self.program_widget.setLayout(self.scan_tab_vbox)
self.notebook.addTab(self.program_widget, "Commands")
self.viewer = gpvdm_viewer(self.scan_io.scan_dir)
self.viewer.show_back_arrow = True
self.notebook.addTab(self.viewer, "Output")
self.ribbon = scan_tab_ribbon()
self.ribbon.tb_simulate.triggered.connect(self.callback_run_simulation)
self.ribbon.tb_clean.triggered.connect(self.clean_scan_dir)
self.ribbon.tb_plot.triggered.connect(self.callback_gen_plot_command)
self.ribbon.tb_notes.triggered.connect(self.callback_notes)
self.main_vbox.addWidget(self.ribbon)
self.main_vbox.addWidget(self.notebook)
self.main_vbox.addWidget(self.status_bar)
self.setLayout(self.main_vbox)
self.select_param_window = select_param(self.tab)
def __init__(self): self.scan_human_labels=get_scan_human_labels() #self.scan_human_labels.dump() self.directory=None self.program_list=[]