def populate_recent_files_menu(self, recents):
"""Populate the open recent files menu.
Populate the recent files with a list of recent file names.
Args:
recents (list): A list of recent file names.
"""
if self._recent_files_actions:
for action in self._recent_files_actions:
self.ui.menuOpen_Recent.removeAction(action)
if recents:
actions = [QtGui.QAction(f) for f in recents]
self.ui.menuOpen_Recent.insertActions(
self.ui._recent_files_separator, actions
)
for action in actions:
action.triggered.connect(
partial(self.open_recent_project_action, action.text())
)
self.ui.actionClear_Menu.setEnabled(True)
self._recent_files_actions = actions
def __init__(self, game_connection: GameConnection, options: Options):
super().__init__()
self.setupUi(self)
self.game_connection = game_connection
self.options = options
common_qt_lib.set_default_window_icon(self)
with get_data_path().joinpath(f"gui_assets/tracker/trackers.json"
).open("r") as trackers_file:
self.trackers = json.load(trackers_file)["trackers"]
self._action_to_name = {}
theme_group = QtGui.QActionGroup(self)
for name in self.trackers.keys():
action = QtGui.QAction(self.menu_tracker)
action.setText(name)
action.setCheckable(True)
action.setChecked(name == options.selected_tracker)
action.triggered.connect(self._on_action_select_tracker)
self.menu_tracker.addAction(action)
self._action_to_name[action] = name
theme_group.addAction(action)
self._tracker_elements: List[Element] = []
self.create_tracker()
self.game_connection_setup = GameConnectionSetup(
self, self.connection_status_label, self.game_connection, options)
self.game_connection_setup.create_backend_entries(self.menu_backend)
self.game_connection_setup.create_upload_nintendont_action(
self.menu_options)
self.game_connection_setup.refresh_backend()
self.action_force_update.triggered.connect(self.on_force_update_button)
self._update_timer = QtCore.QTimer(self)
self._update_timer.setInterval(100)
self._update_timer.timeout.connect(self._on_timer_update)
self._update_timer.setSingleShot(True)
def _generate_menu_bar(self):
self.menu_bar = factories.atomic_widget_factory(component='menu-bar',
title=None)
self.menus = []
for j, menu in enumerate(definitions.MENUBAR_WIDGET):
self.menus.append(self.menu_bar.addMenu(menu))
for i, action in enumerate(definitions.MENUBAR_WIDGET[menu]):
q_action = QtGui.QAction(action['name'], self)
q_action.setShortcut(action['shortcut'])
if menu == 'Functions':
q_action.triggered.connect(
(lambda i: lambda: self._show_widget(i))(i))
elif menu == 'Account':
pass
elif menu == 'View':
if action['name'] == 'Function Menu':
q_action.triggered.connect(
lambda: self.function_menu.setVisible(
(not self.function_menu.isVisible())))
elif action['name'] == 'Splash Menu':
q_action.triggered.connect(self._clear)
self.menus[j].addAction(q_action)
def createTools(self):
"""create the toolbar and populate it automatically
from method toolData
"""
# create a toolbar
self.toolbar = QtWidgets.QToolBar('Toolbar')
self.parent.addToolBar(self.toolbar)
for tip, icon, handler in self.getToolbarData():
if len(tip) == 0:
self.toolbar.addSeparator()
continue
icon = QtGui.QIcon(os.path.join(ICONS_L, icon))
# guislot converts to:
# self.parent.slots.slotMethod()
guislot = getattr(self.parent.slots, handler)
action = QtGui.QAction(icon, tip, parent=self.parent)
# action.setIcon(icon)
# action.setToolTip(tip)
action.triggered.connect(guislot)
self.toolbar.addAction(action)
def __init__(self):
super().__init__()
self.table = QtWidgets.QTableWidget(self)
self._double_spinbox_delegate = DoubleSpinBoxDelegate()
self._spinbox_delegate = SpinBoxDelegate()
self._checkbox_delegate = CheckBoxDelegate()
self.set_central_widget(self.table)
self._setup_table()
self.change_action = QtGui.QAction(self)
self.save_action = QtGui.QAction(self)
self.copy_action = QtGui.QAction(self)
self.new_route_action = QtGui.QAction(self)
self.settings_action = QtGui.QAction(self)
self.about_action = QtGui.QAction(self)
self.context_menu_policy = QtCore.Qt.ContextMenuPolicy.CustomContextMenu
self.table.context_menu_policy = QtCore.Qt.ContextMenuPolicy.CustomContextMenu
self.customContextMenuRequested.connect(self._main_context)
self.table.customContextMenuRequested.connect(self._table_context)
def initUI(self):
exitIcon = "resources/icons/exit22.png"
newIcon = "resources/icons/document2.png"
saveIcon = "resources/icons/document-save.png"
openIcon = "resources/icons/document-open.png"
exportIcon = "resources/icons/document-print.png"
exportHtmlIcon = "resources/icons/goto.png"
appIcon = "resources/icons/krita.png"
self.initGrid()
exitAction = QtGui.QAction(QIcon(exitIcon), 'Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.close)
newAction = QtGui.QAction(QIcon(newIcon), 'New', self)
newAction.setShortcut('Ctrl+N')
newAction.setStatusTip('New Beat Sheet')
newAction.triggered.connect(self.new)
saveAction = QtGui.QAction(QIcon(saveIcon), 'Save', self)
saveAction.setShortcut('Ctrl+S')
saveAction.setStatusTip('Save Beat Sheet')
saveAction.triggered.connect(self.save)
openAction = QtGui.QAction(QIcon(openIcon), 'Open', self)
openAction.setShortcut('Ctrl+S')
openAction.setStatusTip('Open Beat Sheet')
openAction.triggered.connect(self.open)
exportAction = QtGui.QAction(QIcon(exportIcon), 'Export', self)
exportAction.setShortcut('Ctrl+E')
exportAction.setStatusTip('Export Beat Sheet')
exportAction.triggered.connect(self.export)
exportHtmlAction = QtGui.QAction(QIcon(exportHtmlIcon), 'Export HTML',
self)
exportHtmlAction.setShortcut('Ctrl+H')
exportHtmlAction.setStatusTip('Export Beat Sheet (HTML)')
exportHtmlAction.triggered.connect(self.exportHtml)
exportOdtAction = QtGui.QAction(QIcon(exportHtmlIcon), 'Export ODT',
self)
exportOdtAction.setShortcut('Ctrl+T')
exportOdtAction.setStatusTip('Export Beat Sheet (ODT)')
exportOdtAction.triggered.connect(self.exportOdt)
self.statusBar()
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(exitAction)
toolbar = self.addToolBar('BeatSheet')
toolbar.addAction(exitAction)
fileMenu = menubar.addMenu('&Export')
fileMenu.addAction(exportAction)
fileMenu.addAction(exportHtmlAction)
fileMenu.addAction(exportOdtAction)
toolbar.addAction(newAction)
toolbar.addAction(saveAction)
toolbar.addAction(openAction)
toolbar.addAction(exportAction)
toolbar.addAction(exportHtmlAction)
toolbar.addAction(exportOdtAction)
self.setWindowTitle('Save the Cat Beat Sheet')
MainAppIcon = QIcon(appIcon)
self.setWindowIcon(MainAppIcon)
self.setGeometry(0, 0, 1920, 1080)
self.showMaximized()
self.show()
def setup_menu(self):
self.file_menu = self.w.menuBar().addMenu("&File")
self.file_menu_actions = []
newAct = qtg.QAction('&New')
newAct.setShortcut(qtg.QKeySequence.New)
newAct.setStatusTip('Create a new Design')
newAct.triggered.connect(self.clearWindow)
self.file_menu.addAction(newAct)
self.file_menu_actions.append(newAct)
openAct = qtg.QAction('&Open')
openAct.setShortcut(qtg.QKeySequence.Open)
openAct.setStatusTip('Open an existing Design Plan')
openAct.triggered.connect(self.open_plan)
self.file_menu.addAction(openAct)
self.file_menu_actions.append(openAct)
saveAct = qtg.QAction('&Save Plan')
saveAct.setShortcut(qtg.QKeySequence.Save)
saveAct.setStatusTip('Save the Design Plan')
saveAct.triggered.connect(lambda: self.save_plan(False))
self.file_menu.addAction(saveAct)
self.file_menu_actions.append(saveAct)
saveAsAct = qtg.QAction('Save Plan &As')
saveAsAct.setShortcut(qtg.QKeySequence.SaveAs)
saveAsAct.setStatusTip('Save the Design Plan As')
saveAsAct.triggered.connect(lambda: self.save_plan(True))
self.file_menu.addAction(saveAsAct)
self.file_menu_actions.append(saveAsAct)
svgAct = qtg.QAction('&Export Image')
svgAct.setShortcut(qtg.QKeySequence(qtc.Qt.CTRL | qtc.Qt.Key_E))
svgAct.setStatusTip('Save the implementation Image')
svgAct.triggered.connect(self.saveSvg)
self.file_menu.addAction(svgAct)
self.file_menu_actions.append(svgAct)
quitAct = qtg.QAction('&Quit')
quitAct.setShortcut(qtg.QKeySequence(qtc.Qt.CTRL | qtc.Qt.Key_Q))
quitAct.setStatusTip('Quit the application')
quitAct.triggered.connect(self.quit) # TODO prompt for save
self.file_menu.addAction(quitAct)
self.file_menu_actions.append(quitAct)
self.edit_menu = self.w.menuBar().addMenu("&Edit")
self.edit_menu_actions = []
recipeAct = qtg.QAction('Enabled &Recipes')
recipeAct.setStatusTip('Edit the Enabled Recipes')
recipeAct.triggered.connect(self.recipe_window.show)
self.edit_menu.addAction(recipeAct)
self.edit_menu_actions.append(recipeAct)
self.distAct = qtg.QAction('&Distribute Machines')
self.distAct.setStatusTip(
'Show a recipe quantity distributed across an integer number of machines'
)
self.distAct.setCheckable(True)
self.distAct.triggered.connect(self.go_fn)
self.edit_menu.addAction(self.distAct)
self.edit_menu_actions.append(self.distAct)
excessAct = qtg.QAction('Remove &Excess')
excessAct.setStatusTip('Remove excess Inputs from Plan')
excessAct.triggered.connect(self.remove_excess_inputs)
self.edit_menu.addAction(excessAct)
self.edit_menu_actions.append(excessAct)
def __init__(self, main_page):
self.__main_page = main_page
self.patient_dict_container = PatientDictContainer()
self.is_four_view = False
self.has_image_registration_single = False
self.has_image_registration_four = False
##############################
# Init all actions and icons #
##############################
# Open patient
self.icon_open = QtGui.QIcon()
self.icon_open.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/open_patient_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_open = QtGui.QAction()
self.action_open.setIcon(self.icon_open)
self.action_open.setText("Open new patient")
self.action_open.setIconVisibleInMenu(True)
# Save RTSTRUCT changes action
self.icon_save_structure = QtGui.QIcon()
self.icon_save_structure.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/save_all_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_save_structure = QtGui.QAction()
self.action_save_structure.setIcon(self.icon_save_structure)
self.action_save_structure.setText("Save RTSTRUCT changes")
self.action_save_structure.setIconVisibleInMenu(True)
self.action_save_structure.triggered.connect(self.save_struct_handler)
# Save as Anonymous Action
self.icon_save_as_anonymous = QtGui.QIcon()
self.icon_save_as_anonymous.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/anonlock_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_save_as_anonymous = QtGui.QAction()
self.action_save_as_anonymous.setIcon(self.icon_save_as_anonymous)
self.action_save_as_anonymous.setText("Save as Anonymous")
self.action_save_as_anonymous.triggered.connect(
self.anonymization_handler)
# Exit action
self.action_exit = QtGui.QAction()
self.action_exit.setText("Exit")
self.action_exit.triggered.connect(self.action_exit_handler)
# Zoom Out Action
self.icon_zoom_out = QtGui.QIcon()
self.icon_zoom_out.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/zoom_out_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_zoom_out = QtGui.QAction()
self.action_zoom_out.setIcon(self.icon_zoom_out)
self.action_zoom_out.setIconVisibleInMenu(True)
self.action_zoom_out.setText("Zoom Out")
self.action_zoom_out.triggered.connect(self.zoom_out_handler)
# Zoom In Action
self.icon_zoom_in = QtGui.QIcon()
self.icon_zoom_in.addPixmap(
QtGui.QPixmap(
resource_path("res/images/btn-icons/zoom_in_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_zoom_in = QtGui.QAction()
self.action_zoom_in.setIcon(self.icon_zoom_in)
self.action_zoom_in.setIconVisibleInMenu(True)
self.action_zoom_in.setText("Zoom In")
self.action_zoom_in.triggered.connect(self.zoom_in_handler)
# Transect Action
self.icon_transect = QtGui.QIcon()
self.icon_transect.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/transect_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_transect = QtGui.QAction()
self.action_transect.setIcon(self.icon_transect)
self.action_transect.setIconVisibleInMenu(True)
self.action_transect.setText("Transect")
self.action_transect.triggered.connect(self.transect_handler)
# Add-On Options Action
self.icon_add_ons = QtGui.QIcon()
self.icon_add_ons.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/management_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_add_ons = QtGui.QAction()
self.action_add_ons.setIcon(self.icon_add_ons)
self.action_add_ons.setIconVisibleInMenu(True)
self.action_add_ons.setText("Add-On Options")
self.action_add_ons.triggered.connect(self.add_on_options_handler)
# Switch to Single View Action
self.icon_one_view = QtGui.QIcon()
self.icon_one_view.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/axial_view_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_one_view = QtGui.QAction()
self.action_one_view.setIcon(self.icon_one_view)
self.action_one_view.setIconVisibleInMenu(True)
self.action_one_view.setText("One View")
self.action_one_view.triggered.connect(self.one_view_handler)
# Switch to 4 Views Action
self.icon_four_views = QtGui.QIcon()
self.icon_four_views.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/four_views_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_four_views = QtGui.QAction()
self.action_four_views.setIcon(self.icon_four_views)
self.action_four_views.setIconVisibleInMenu(True)
self.action_four_views.setText("Four Views")
self.action_four_views.triggered.connect(self.four_views_handler)
# Show cut lines
self.icon_cut_lines = QtGui.QIcon()
self.icon_cut_lines.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/cut_line_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_show_cut_lines = QtGui.QAction()
self.action_show_cut_lines.setIcon(self.icon_cut_lines)
self.action_show_cut_lines.setIconVisibleInMenu(True)
self.action_show_cut_lines.setText("Show Cut Lines")
self.action_show_cut_lines.triggered.connect(self.cut_lines_handler)
# Export Pyradiomics Action
self.action_pyradiomics_export = QtGui.QAction()
self.action_pyradiomics_export.setText("Export Pyradiomics")
self.action_pyradiomics_export.triggered.connect(
self.pyradiomics_export_handler)
# Export DVH Action
self.action_dvh_export = QtGui.QAction()
self.action_dvh_export.setText("Export DVH")
self.action_dvh_export.triggered.connect(self.export_dvh_handler)
# Create Windowing menu
self.icon_windowing = QtGui.QIcon()
self.icon_windowing.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/windowing_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.menu_windowing = QtWidgets.QMenu()
self.init_windowing_menu()
self.windowing_window = Windowing(self)
self.windowing_window.done_signal.connect(self.update_views)
# Create Export menu
self.icon_export = QtGui.QIcon()
self.icon_export.addPixmap(
QtGui.QPixmap(
resource_path("res/images/btn-icons/export_purple_icon.png")),
QtGui.QIcon.Normal,
QtGui.QIcon.On,
)
self.menu_export = QtWidgets.QMenu()
self.menu_export.setTitle("Export")
self.menu_export.addAction(self.action_pyradiomics_export)
self.menu_export.addAction(self.action_dvh_export)
# Image Fusion Action
self.icon_image_fusion = QtGui.QIcon()
self.icon_image_fusion.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/image_fusion_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_image_fusion = QtGui.QAction()
self.action_image_fusion.setIcon(self.icon_image_fusion)
self.action_image_fusion.setIconVisibleInMenu(True)
self.action_image_fusion.setText("Image Fusion")
def _add_title(self, menu, text: str, action_parent=None):
action = QtGui.QAction(text, action_parent or menu)
action.setEnabled(False)
action.setFont(self.title_font)
menu.addAction(action)
def __init__(self):
super().__init__()
self._dataset: Optional[Dataset] = None
self._translator: Optional[QtCore.QTranslator] = None
self._client = QGrainClient()
self.setWindowTitle("QGrain")
self.ssu_setting_dialog = SSUSettings(self)
self.emma_setting_dialog = EMMASettings(parent=self,
client=self._client)
self.udm_setting_dialog = UDMSettings(parent=self, client=self._client)
self.parameter_editor = ParameterEditor(self)
self.ssu_multicore_analyzer = SSUMulticoreAnalyzer(self)
self.tab_widget = QtWidgets.QTabWidget(self)
self.tab_widget.setTabPosition(QtWidgets.QTabWidget.West)
self.setCentralWidget(self.tab_widget)
self.dataset_generator = DatasetGenerator()
self.tab_widget.addTab(self.dataset_generator, self.tr("Generator"))
self.dataset_viewer = StatisticalAnalyzer()
self.tab_widget.addTab(self.dataset_viewer, self.tr("Statistics"))
self.pca_analyzer = PCAAnalyzer()
self.tab_widget.addTab(self.pca_analyzer, self.tr("PCA"))
self.clustering_analyzer = ClusteringAnalyzer()
self.tab_widget.addTab(self.clustering_analyzer, self.tr("Clustering"))
self.ssu_analyzer = SSUAnalyzer(self.ssu_setting_dialog,
self.parameter_editor)
self.tab_widget.addTab(self.ssu_analyzer, self.tr("SSU"))
self.emma_analyzer = EMMAAnalyzer(self.emma_setting_dialog,
self.parameter_editor,
client=self._client)
self.tab_widget.addTab(self.emma_analyzer, self.tr("EMMA"))
self.udm_analyzer = UDMAnalyzer(self.udm_setting_dialog,
self.parameter_editor,
client=self._client)
self.tab_widget.addTab(self.udm_analyzer, self.tr("UDM"))
# Open
self.open_menu = self.menuBar().addMenu(self.tr("Open"))
self.open_dataset_action = self.open_menu.addAction(
self.tr("Grain Size Dataset"))
self.open_dataset_action.triggered.connect(
lambda: self.load_dataset_dialog.show())
self.load_ssu_result_action = self.open_menu.addAction(
self.tr("SSU Results"))
self.load_ssu_result_action.triggered.connect(
self.ssu_analyzer.result_view.load_results)
self.load_emma_result_action = self.open_menu.addAction(
self.tr("EMMA Result"))
self.load_emma_result_action.triggered.connect(
self.emma_analyzer.load_result)
self.load_udm_result_action = self.open_menu.addAction(
self.tr("UDM Result"))
self.load_udm_result_action.triggered.connect(
self.udm_analyzer.load_result)
# Save
self.save_menu = self.menuBar().addMenu(self.tr("Save"))
self.save_artificial_action = self.save_menu.addAction(
self.tr("Artificial Dataset"))
self.save_artificial_action.triggered.connect(
self.dataset_generator.on_save_clicked)
self.save_statistics_action = self.save_menu.addAction(
self.tr("Statistical Result"))
self.save_statistics_action.triggered.connect(
self.on_save_statistics_clicked)
self.save_pca_action = self.save_menu.addAction(self.tr("PCA Result"))
self.save_pca_action.triggered.connect(self.on_save_pca_clicked)
self.save_clustering_action = self.save_menu.addAction(
self.tr("Clustering Result"))
self.save_clustering_action.triggered.connect(
self.clustering_analyzer.save_result)
self.save_ssu_result_action = self.save_menu.addAction(
self.tr("SSU Results"))
self.save_ssu_result_action.triggered.connect(
self.ssu_analyzer.result_view.save_results)
self.save_emma_result_action = self.save_menu.addAction(
self.tr("EMMA Result"))
self.save_emma_result_action.triggered.connect(
self.emma_analyzer.save_selected_result)
self.save_udm_result_action = self.save_menu.addAction(
self.tr("UDM Result"))
self.save_udm_result_action.triggered.connect(
self.udm_analyzer.save_selected_result)
# Config
self.config_menu = self.menuBar().addMenu(self.tr("Configure"))
self.config_ssu_action = self.config_menu.addAction(
self.tr("SSU Algorithm"))
self.config_ssu_action.triggered.connect(self.ssu_setting_dialog.show)
self.config_emma_action = self.config_menu.addAction(
self.tr("EMMA Algorithm"))
self.config_emma_action.triggered.connect(
self.emma_setting_dialog.show)
self.config_udm_action = self.config_menu.addAction(
self.tr("UDM Algorithm"))
self.config_udm_action.triggered.connect(self.udm_setting_dialog.show)
# Experimental
self.experimental_menu = self.menuBar().addMenu(
self.tr("Experimental"))
self.ssu_fit_all_action = self.experimental_menu.addAction(
self.tr("Perform SSU For All Samples"))
self.ssu_fit_all_action.triggered.connect(self.ssu_fit_all_samples)
self.convert_udm_to_ssu_action = self.experimental_menu.addAction(
self.tr("Convert Selected UDM Result To SSU Results"))
self.convert_udm_to_ssu_action.triggered.connect(
self.convert_udm_to_ssu)
self.save_all_ssu_figures_action = self.experimental_menu.addAction(
self.tr("Save Figures For All SSU Results"))
self.save_all_ssu_figures_action.triggered.connect(
self.save_all_ssu_figure)
# Language
self.language_menu = self.menuBar().addMenu(self.tr("Language"))
self.language_group = QtGui.QActionGroup(self.language_menu)
self.language_group.setExclusive(True)
self.language_actions: List[QtGui.QAction] = []
for key, name in self.supported_languages:
action = self.language_group.addAction(name)
action.setCheckable(True)
action.triggered.connect(lambda checked=False, language=key: self.
switch_language(language))
self.language_menu.addAction(action)
self.language_actions.append(action)
self.language_actions[0].setChecked(True)
# Theme
self.theme_menu = self.menuBar().addMenu(self.tr("Theme"))
self.theme_group = QtGui.QActionGroup(self.theme_menu)
self.theme_group.setExclusive(True)
self.theme_actions = []
self.default_theme_action = self.theme_group.addAction(
self.tr("Default"))
self.default_theme_action.setCheckable(True)
self.default_theme_action.setChecked(True)
self.default_theme_action.triggered.connect(lambda: apply_stylesheet(
app,
theme=os.path.join(QGRAIN_ROOT_PATH, "assets", "default_theme.xml"
),
invert_secondary=True,
extra=EXTRA))
self.theme_menu.addAction(self.default_theme_action)
self.theme_actions.append(self.default_theme_action)
self.light_theme_menu = self.theme_menu.addMenu(self.tr("Light Theme"))
self.dark_theme_menu = self.theme_menu.addMenu(self.tr("Dark Theme"))
for theme in list_themes():
theme_name = string.capwords(" ".join(theme[:-4].split("_")[1:]))
action = self.theme_group.addAction(theme_name)
action.setCheckable(True)
app = QtCore.QCoreApplication.instance()
invert = theme.startswith("light")
action.triggered.connect(
lambda checked=False, t=theme, i=invert: apply_stylesheet(
app, theme=t, invert_secondary=i, extra=EXTRA))
self.theme_actions.append(action)
if invert:
self.light_theme_menu.addAction(action)
else:
self.dark_theme_menu.addAction(action)
# Log
self.log_action = QtGui.QAction(self.tr("Log"))
self.log_action.triggered.connect(lambda: self.log_dialog.show())
self.menuBar().addAction(self.log_action)
# About
self.about_action = QtGui.QAction(self.tr("About"))
self.about_action.triggered.connect(lambda: self.about_dialog.show())
self.menuBar().addAction(self.about_action)
# Connect signals
self.ssu_multicore_analyzer.result_finished.connect(
self.ssu_analyzer.result_view.add_result)
self.load_dataset_dialog = DatasetLoader(self)
self.load_dataset_dialog.dataset_loaded.connect(self.on_dataset_loaded)
self.load_dataset_dialog.dataset_loaded.connect(
self.dataset_viewer.on_dataset_loaded)
self.load_dataset_dialog.dataset_loaded.connect(
self.pca_analyzer.on_dataset_loaded)
self.load_dataset_dialog.dataset_loaded.connect(
self.clustering_analyzer.on_dataset_loaded)
self.load_dataset_dialog.dataset_loaded.connect(
self.ssu_analyzer.on_dataset_loaded)
self.load_dataset_dialog.dataset_loaded.connect(
self.emma_analyzer.on_dataset_loaded)
self.load_dataset_dialog.dataset_loaded.connect(
self.udm_analyzer.on_dataset_loaded)
self.log_dialog = RuntimeLog(self)
self.about_dialog = About(self)
self.file_dialog = QtWidgets.QFileDialog(parent=self)
self.normal_msg = QtWidgets.QMessageBox(self)
self.close_msg = QtWidgets.QMessageBox(self)
self.close_msg.setWindowTitle(self.tr("Warning"))
self.close_msg.setText(
self.
tr("Closing this window will terminate all running tasks, are you sure to close it?"
))
self.close_msg.setStandardButtons(QtWidgets.QMessageBox.Yes
| QtWidgets.QMessageBox.No)
self.close_msg.setDefaultButton(QtWidgets.QMessageBox.No)
def createActions(self):
self.newAct = QtGui.QAction(QtGui.QIcon(':/images/new.png'),
"&New",
self,
shortcut=QtGui.QKeySequence.New,
statusTip="Create a new file",
triggered=self.newFile)
self.openAct = QtGui.QAction(QtGui.QIcon(':/images/open.png'),
"&Open...",
self,
shortcut=QtGui.QKeySequence.Open,
statusTip="Open an existing file",
triggered=self.open)
self.saveAct = QtGui.QAction(QtGui.QIcon(':/images/save.png'),
"&Save",
self,
shortcut=QtGui.QKeySequence.Save,
statusTip="Save the document to disk",
triggered=self.save)
self.saveAsAct = QtGui.QAction(
"Save &As...",
self,
shortcut=QtGui.QKeySequence.SaveAs,
statusTip="Save the document under a new name",
triggered=self.saveAs)
self.exitAct = QtGui.QAction("E&xit",
self,
shortcut="Ctrl+Q",
statusTip="Exit the application",
triggered=self.close)
self.cutAct = QtGui.QAction(
QtGui.QIcon(':/images/cut.png'),
"Cu&t",
self,
shortcut=QtGui.QKeySequence.Cut,
statusTip="Cut the current selection's contents to the clipboard",
triggered=self.textEdit.cut)
self.copyAct = QtGui.QAction(
QtGui.QIcon(':/images/copy.png'),
"&Copy",
self,
shortcut=QtGui.QKeySequence.Copy,
statusTip="Copy the current selection's contents to the clipboard",
triggered=self.textEdit.copy)
self.pasteAct = QtGui.QAction(
QtGui.QIcon(':/images/paste.png'),
"&Paste",
self,
shortcut=QtGui.QKeySequence.Paste,
statusTip=
"Paste the clipboard's contents into the current selection",
triggered=self.textEdit.paste)
self.aboutAct = QtGui.QAction(
"&About",
self,
statusTip="Show the application's About box",
triggered=self.about)
self.aboutQtAct = QtGui.QAction(
"About &Qt",
self,
statusTip="Show the Qt library's About box",
triggered=qApp.aboutQt)
self.cutAct.setEnabled(False)
self.copyAct.setEnabled(False)
self.textEdit.copyAvailable.connect(self.cutAct.setEnabled)
self.textEdit.copyAvailable.connect(self.copyAct.setEnabled)
def contextMenuEvent(self, event: QtGui.QContextMenuEvent) -> None:
local_pos = QPointF(self.mapFromGlobal(event.globalPos()))
local_pos -= self.get_area_canvas_offset()
self._next_node_location = self.qt_local_to_game_loc(local_pos)
menu = QtWidgets.QMenu(self)
if self.state is None:
menu.addAction(self._show_all_connections_action)
if self.edit_mode:
menu.addAction(self._create_node_action)
menu.addAction(self._move_node_action)
self._move_node_action.setEnabled(
self.highlighted_node is not None)
if self.highlighted_node is not None:
self._move_node_action.setText(
f"Move {self.highlighted_node.name} here")
# Areas Menu
menu.addSeparator()
areas_at_mouse = self._other_areas_at_position(local_pos)
for area in areas_at_mouse:
sub_menu = QtWidgets.QMenu(f"Area: {area.name}", self)
sub_menu.addAction("View area").triggered.connect(
functools.partial(self.SelectAreaRequest.emit, area))
if self.edit_mode:
sub_menu.addAction(
"Create dock here to this area").triggered.connect(
functools.partial(self.CreateDockRequest.emit,
self._next_node_location, area))
menu.addMenu(sub_menu)
if not areas_at_mouse:
sub_menu = QtGui.QAction("No areas here", self)
sub_menu.setEnabled(False)
menu.addAction(sub_menu)
# Nodes Menu
menu.addSeparator()
nodes_at_mouse = self._nodes_at_position(local_pos)
if self.highlighted_node in nodes_at_mouse:
nodes_at_mouse.remove(self.highlighted_node)
for node in nodes_at_mouse:
if len(nodes_at_mouse) == 1:
menu.addAction(node.name).setEnabled(False)
sub_menu = menu
else:
sub_menu = QtWidgets.QMenu(node.name, self)
sub_menu.addAction("Highlight this").triggered.connect(
functools.partial(self.SelectNodeRequest.emit, node))
view_connections = sub_menu.addAction("View connections to this")
view_connections.setEnabled(
(self.edit_mode and self.highlighted_node != node) or
(node in self.area.connections.get(self.highlighted_node, {})))
view_connections.triggered.connect(
functools.partial(self.SelectConnectionsRequest.emit, node))
if self.edit_mode:
sub_menu.addSeparator()
sub_menu.addAction(
"Replace connection with Trivial").triggered.connect(
functools.partial(
self.ReplaceConnectionsRequest.emit,
node,
Requirement.trivial(),
))
sub_menu.addAction("Remove connection").triggered.connect(
functools.partial(
self.ReplaceConnectionsRequest.emit,
node,
Requirement.impossible(),
))
if areas_at_mouse:
move_menu = QtWidgets.QMenu("Move to...", self)
for area in areas_at_mouse:
move_menu.addAction(area.name).triggered.connect(
functools.partial(
self.MoveNodeToAreaRequest.emit,
node,
area,
))
sub_menu.addMenu(move_menu)
if sub_menu != menu:
menu.addMenu(sub_menu)
if not nodes_at_mouse:
sub_menu = QtGui.QAction("No other nodes here", self)
sub_menu.setEnabled(False)
menu.addAction(sub_menu)
# Done
menu.exec_(event.globalPos())
def onTrayIconActivated(self, reason):
print("onTrayIconActivated:", reason)
if reason == QSystemTrayIcon.Trigger:
print("JAWOLLO")
elif reason == QSystemTrayIcon.DoubleClick:
print("Tray icon double clicked")
# Creating the options
menu = QtWidgets.QMenu()
# FAlls es keine Daten gibt ... dann zeig nix an ;)
try:
option1 = QtGui.QAction(QtGui.QIcon(':/images/icon.png'),
naechste_stunde(data)['Fach'])
option2 = QtGui.QAction(naechste_stunde(data)['Uhrzeit'], )
#option2.triggered.connect(print("test"))
except:
option1 = QtGui.QAction(QtGui.QIcon(':/images/icon.png'), "")
option2 = QtGui.QAction("", )
#option2.setText("JAWOLLO")
menu.addAction(option1)
menu.addAction(option2)
#menu.addAction("test", notifcation)
edit = menu.addMenu("Stundenplan")
tag_1 = edit.addMenu("Montag")
tag_2 = edit.addMenu("Dienstag")
def __init__(self, options: Options, preset_manager: PresetManager,
network_client, preview: bool):
super().__init__()
self.setupUi(self)
self.setWindowTitle("Randovania {}".format(VERSION))
self._is_preview_mode = preview
self.setAcceptDrops(True)
common_qt_lib.set_default_window_icon(self)
self.setup_about_text()
self.setup_welcome_text()
self.browse_racetime_label.setText(
self.browse_racetime_label.text().replace("color:#0000ff;", ""))
self._preset_manager = preset_manager
self.network_client = network_client
if preview:
debug.set_level(2)
if randovania.is_frozen():
self.menu_bar.removeAction(self.menu_edit.menuAction())
# Signals
self.options_changed_signal.connect(self.on_options_changed)
self.GameDetailsSignal.connect(self._open_game_details)
self.InitPostShowSignal.connect(self.initialize_post_show)
self.intro_play_now_button.clicked.connect(
lambda: self.main_tab_widget.setCurrentWidget(self.tab_play))
self.open_faq_button.clicked.connect(self._open_faq)
self.open_database_viewer_button.clicked.connect(
partial(self._open_data_visualizer_for_game,
RandovaniaGame.METROID_PRIME_ECHOES))
self.import_permalink_button.clicked.connect(self._import_permalink)
self.import_game_file_button.clicked.connect(self._import_spoiler_log)
self.browse_racetime_button.clicked.connect(self._browse_racetime)
self.create_new_seed_button.clicked.connect(
lambda: self.main_tab_widget.setCurrentWidget(self.tab_create_seed
))
# Menu Bar
self.game_menus = []
self.menu_action_edits = []
for game in RandovaniaGame.sorted_all_games():
# Sub-Menu in Open Menu
game_menu = QtWidgets.QMenu(self.menu_open)
game_menu.setTitle(_t(game.long_name))
game_menu.game = game
if game.data.development_state.can_view(False):
self.menu_open.addAction(game_menu.menuAction())
self.game_menus.append(game_menu)
game_trick_details_menu = QtWidgets.QMenu(game_menu)
game_trick_details_menu.setTitle(_t("Trick Details"))
self._setup_trick_difficulties_menu_on_show(
game_trick_details_menu, game)
game_data_visualizer_action = QtGui.QAction(game_menu)
game_data_visualizer_action.setText(_t("Data Visualizer"))
game_data_visualizer_action.triggered.connect(
partial(self._open_data_visualizer_for_game, game))
game_menu.addAction(game_trick_details_menu.menuAction())
game_menu.addAction(game_data_visualizer_action)
# Data Editor
action = QtGui.QAction(self)
action.setText(_t(game.long_name))
self.menu_internal.addAction(action)
action.triggered.connect(
partial(self._open_data_editor_for_game, game))
self.menu_action_edits.append(action)
self.menu_action_edit_existing_database.triggered.connect(
self._open_data_editor_prompt)
self.menu_action_validate_seed_after.triggered.connect(
self._on_validate_seed_change)
self.menu_action_timeout_generation_after_a_time_limit.triggered.connect(
self._on_generate_time_limit_change)
self.menu_action_dark_mode.triggered.connect(
self._on_menu_action_dark_mode)
self.menu_action_experimental_games.triggered.connect(
self._on_menu_action_experimental_games)
self.menu_action_open_auto_tracker.triggered.connect(
self._open_auto_tracker)
self.menu_action_previously_generated_games.triggered.connect(
self._on_menu_action_previously_generated_games)
self.menu_action_log_files_directory.triggered.connect(
self._on_menu_action_log_files_directory)
self.menu_action_layout_editor.triggered.connect(
self._on_menu_action_layout_editor)
# Setting this event only now, so all options changed trigger only once
options.on_options_changed = self.options_changed_signal.emit
self._options = options
self.main_tab_widget.setCurrentIndex(0)
def __init__(self, main_page):
self.__main_page = main_page
self.patient_dict_container = PatientDictContainer()
##############################
# Init all actions and icons #
##############################
# Open patient
self.icon_open = QtGui.QIcon()
self.icon_open.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/open_patient_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_open = QtGui.QAction()
self.action_open.setIcon(self.icon_open)
self.action_open.setText("Open new patient")
self.action_open.setIconVisibleInMenu(True)
# Save RTSTRUCT changes action
self.icon_save_structure = QtGui.QIcon()
self.icon_save_structure.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/save_all_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_save_structure = QtGui.QAction()
self.action_save_structure.setIcon(self.icon_save_structure)
self.action_save_structure.setText("Save RTSTRUCT changes")
self.action_save_structure.setIconVisibleInMenu(True)
self.action_save_structure.triggered.connect(self.save_struct_handler)
# Save as Anonymous Action
self.icon_save_as_anonymous = QtGui.QIcon()
self.icon_save_as_anonymous.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/anonlock_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_save_as_anonymous = QtGui.QAction()
self.action_save_as_anonymous.setIcon(self.icon_save_as_anonymous)
self.action_save_as_anonymous.setText("Save as Anonymous")
self.action_save_as_anonymous.triggered.connect(
self.anonymization_handler)
# Exit action
self.action_exit = QtGui.QAction()
self.action_exit.setText("Exit")
self.action_exit.triggered.connect(self.action_exit_handler)
# Zoom Out Action
self.icon_zoom_out = QtGui.QIcon()
self.icon_zoom_out.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/zoom_out_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_zoom_out = QtGui.QAction()
self.action_zoom_out.setIcon(self.icon_zoom_out)
self.action_zoom_out.setIconVisibleInMenu(True)
self.action_zoom_out.setText("Zoom Out")
self.action_zoom_out.triggered.connect(self.__main_page.zoom_out)
# Zoom In Action
self.icon_zoom_in = QtGui.QIcon()
self.icon_zoom_in.addPixmap(
QtGui.QPixmap(
resource_path("res/images/btn-icons/zoom_in_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_zoom_in = QtGui.QAction()
self.action_zoom_in.setIcon(self.icon_zoom_in)
self.action_zoom_in.setIconVisibleInMenu(True)
self.action_zoom_in.setText("Zoom In")
self.action_zoom_in.triggered.connect(self.__main_page.zoom_in)
# Transect Action
self.icon_transect = QtGui.QIcon()
self.icon_transect.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/transect_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_transect = QtGui.QAction()
self.action_transect.setIcon(self.icon_transect)
self.action_transect.setIconVisibleInMenu(True)
self.action_transect.setText("Transect")
self.action_transect.triggered.connect(self.transect_handler)
# Add-On Options Action
self.icon_add_ons = QtGui.QIcon()
self.icon_add_ons.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/management_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_add_ons = QtGui.QAction()
self.action_add_ons.setIcon(self.icon_add_ons)
self.action_add_ons.setIconVisibleInMenu(True)
self.action_add_ons.setText("Add-On Options")
self.action_add_ons.triggered.connect(self.add_on_options_handler)
# Export Clinical Data Action
self.action_clinical_data_export = QtGui.QAction()
self.action_clinical_data_export.setText("Export Clinical Data")
# TODO self.action_clinical_data_export.triggered.connect(clinical data check)
# Export Pyradiomics Action
self.action_pyradiomics_export = QtGui.QAction()
self.action_pyradiomics_export.setText("Export Pyradiomics")
self.action_pyradiomics_export.triggered.connect(
self.pyradiomics_export_handler)
# Export DVH Action
self.action_dvh_export = QtGui.QAction()
self.action_dvh_export.setText("Export DVH")
self.action_dvh_export.triggered.connect(self.export_dvh_handler)
# Create Windowing menu
self.icon_windowing = QtGui.QIcon()
self.icon_windowing.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/windowing_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.menu_windowing = QtWidgets.QMenu()
self.init_windowing_menu()
# Create Export menu
self.icon_export = QtGui.QIcon()
self.icon_export.addPixmap(
QtGui.QPixmap(
resource_path("res/images/btn-icons/export_purple_icon.png")),
QtGui.QIcon.Normal,
QtGui.QIcon.On,
)
self.menu_export = QtWidgets.QMenu()
self.menu_export.setTitle("Export")
self.menu_export.addAction(self.action_clinical_data_export)
self.menu_export.addAction(self.action_pyradiomics_export)
self.menu_export.addAction(self.action_dvh_export)
def __init__(self):
QtWidgets.QMainWindow.__init__(self, flags=QtCore.Qt.WindowType.Window)
# Fix icon issues on windows systems
if sys.platform == 'win32':
# Explicitly set app-id as suggested by https://stackoverflow.com/a/1552105
appid = u'vxpy.application.0.0.1' # arbitrary string
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(appid)
# Set offsets
row2_yoffset = 0
row2_xoffset = 0
side_window_borders = 5
x_spacing = 5
# Set icon
iconpath = os.path.join(str(vxpy.__path__[0]), 'vxpy_icon.svg')
self.setWindowIcon(QtGui.QIcon(iconpath))
self.subwindows = []
# Set up main window
self.setWindowTitle('vxPy - vision experiments in Python')
# Setup central widget
self.setCentralWidget(QtWidgets.QWidget(parent=self, f=QtCore.Qt.WindowType.Widget))
self.centralWidget().setLayout(QtWidgets.QHBoxLayout())
# Control widgets
self.control_wdgt = QtWidgets.QWidget()
self.control_wdgt.setLayout(QtWidgets.QHBoxLayout())
self.centralWidget().layout().addWidget(self.control_wdgt)
# Main monitoring widget
self.monitoring_wdgt = QtWidgets.QWidget()
self.monitoring_wdgt.setLayout(QtWidgets.QVBoxLayout())
self.centralWidget().layout().addWidget(self.monitoring_wdgt)
# Process monitor
self.process_monitor = core_widgets.ProcessMonitorWidget(self)
self.process_monitor.create_hooks()
self.monitoring_wdgt.layout().addWidget(self.process_monitor)
# Recordings
self.recordings = core_widgets.RecordingWidget(self)
self.recordings.create_hooks()
self.control_wdgt.layout().addWidget(self.recordings)
# Protocols}
self.protocols = core_widgets.Protocols(self)
self.protocols.create_hooks()
self.control_wdgt.layout().addWidget(self.protocols)
# Logger
self.log_display = core_widgets.LoggingWidget(self)
self.monitoring_wdgt.layout().addWidget(self.log_display)
# Set geometry
self.setMinimumHeight(500)
screen = vxipc.Process.app.screens()[config.CONF_GUI_SCREEN]
self.screenGeo = screen.geometry()
width, height = self.screenGeo.width(), self.screenGeo.height()
xpos, ypos = self.screenGeo.x(), self.screenGeo.y()
self.move(xpos, ypos)
self.resize(width-side_window_borders, height // 2 if height <= 1080 else 540)
# Optional sub windows
titlebar_height = 40
bottom_height_offset = 80
# if sys.platform == 'win32':
# titlebar_height = 40
# bottom_height_offset = 120
# else:
# titlebar_height = 0
# bottom_height_offset = 120
main_window_height = self.size().height() + titlebar_height
addon_window_default_dims = (600, 600)
# Addon widget window if any addons are selected in config
self.addon_widget_window = None
if any([config.CONF_DISPLAY_USE, config.CONF_CAMERA_USE, config.CONF_IO_USE]) and bool(config.CONF_GUI_ADDONS):
# Create windowed tab
self.addon_widget_window = vxgui.AddonWindow(self)
for process_name, addons in config.CONF_GUI_ADDONS.items():
self.addon_widget_window.create_addon_tabs(process_name)
# Create hooks
self.addon_widget_window.create_hooks()
# Place and resize addon widget
self.addon_widget_window.move(xpos + row2_xoffset,
ypos + main_window_height + row2_yoffset)
if height - self.size().height() - addon_window_default_dims[1] > bottom_height_offset:
addon_height = addon_window_default_dims[1]
else:
addon_height = height - self.size().height() - bottom_height_offset
self.addon_widget_window.resize(addon_window_default_dims[0], addon_height)
# Add subwindow
self.subwindows.append(self.addon_widget_window)
# Add Plotter
self.plotter = core_widgets.PlottingWindow(self)
self.plotter.setMinimumHeight(300)
# Place and resize
addon_win_width = self.addon_widget_window.size().width() if self.addon_widget_window is not None else 0
self.plotter.move(xpos + row2_xoffset + addon_win_width + x_spacing,
ypos + self.size().height() + titlebar_height + row2_yoffset)
if height - self.size().height() - addon_window_default_dims[1] > bottom_height_offset:
plotter_height = addon_window_default_dims[1]
else:
plotter_height = height - self.size().height() - bottom_height_offset
self.plotter.resize(width - addon_win_width - x_spacing,
plotter_height)
self.plotter.create_hooks()
self.subwindows.append(self.plotter)
# Setup menubar
self.setMenuBar(QtWidgets.QMenuBar())
# Windows actions
self.menu_windows = QtWidgets.QMenu('Windows')
self.menuBar().addMenu(self.menu_windows)
self.window_toggles = []
for subwin in self.subwindows:
self.window_toggles.append(QtGui.QAction(f'Toggle {subwin.windowTitle()}'))
self.window_toggles[-1].triggered.connect(subwin.toggle_visibility)
self.menu_windows.addAction(self.window_toggles[-1])
# Processes actions
self.menu_process = QtWidgets.QMenu('Processes')
self.menuBar().addMenu(self.menu_process)
# Restart display module
if config.CONF_DISPLAY_USE:
self.menu_process.restart_display = QtGui.QAction('Restart display')
self.menu_process.restart_display.triggered.connect(self.restart_display)
self.menu_process.addAction(self.menu_process.restart_display)
self.menu_process.restart_display.setShortcut('Ctrl+Alt+Shift+d')
self.menu_process.restart_display.setAutoRepeat(False)
# Restart camera module
if config.CONF_CAMERA_USE:
self.menu_process.restart_camera = QtGui.QAction('Restart camera')
self.menu_process.restart_camera.triggered.connect(self.restart_camera)
self.menu_process.addAction(self.menu_process.restart_camera)
self.menu_process.restart_camera.setShortcut('Ctrl+Alt+Shift+c')
self.menu_process.restart_camera.setAutoRepeat(False)
# Set theme
extra = {'density_scale': '-3', }
apply_stylesheet(vxipc.Process.app, theme='dark_amber.xml', invert_secondary=False, extra=extra)
def menu(self):
menubar = QMenuBar(self)
#--------------
file_menu = menubar.addMenu('File')
# open_act = QtGui.QAction('Open', self, checkable=True)
# open_act = QtGui.QAction('Open', self)
# open_act.triggered.connect(self.open_as_cb)
file_menu.addAction("New (template)", self.new_model_cb,
QtGui.QKeySequence('Ctrl+n'))
file_menu.addAction("Open", self.open_as_cb,
QtGui.QKeySequence('Ctrl+o'))
file_menu.addAction("Save", self.save_cb, QtGui.QKeySequence('Ctrl+s'))
# recent_act = QtGui.QAction('Recent', self)
# save_act = QtGui.QAction('Save', self)
# save_act.triggered.connect(self.save_cb)
# saveas_act = QtGui.QAction('Save As my.xml', self)
# file_menu.setStatusTip('enable/disable Dark mode')
# new_model_act = QtGui.QAction('', self)
# file_menu.addAction(new_model_act)
# new_model_act.triggered.connect(self.new_model_cb)
#--------------
samples_menu = file_menu.addMenu("Samples (copy of)")
biorobots_act = QtGui.QAction('biorobots', self)
samples_menu.addAction(biorobots_act)
biorobots_act.triggered.connect(self.biorobots_cb)
cancer_biorobots_act = QtGui.QAction('cancer biorobots', self)
samples_menu.addAction(cancer_biorobots_act)
cancer_biorobots_act.triggered.connect(self.cancer_biorobots_cb)
hetero_act = QtGui.QAction('heterogeneity', self)
samples_menu.addAction(hetero_act)
hetero_act.triggered.connect(self.hetero_cb)
pred_prey_act = QtGui.QAction('predator-prey-farmer', self)
samples_menu.addAction(pred_prey_act)
pred_prey_act.triggered.connect(self.pred_prey_cb)
virus_mac_act = QtGui.QAction('virus-macrophage', self)
samples_menu.addAction(virus_mac_act)
virus_mac_act.triggered.connect(self.virus_mac_cb)
worm_act = QtGui.QAction('worm', self)
samples_menu.addAction(worm_act)
worm_act.triggered.connect(self.worm_cb)
cancer_immune_act = QtGui.QAction('cancer immune (3D)', self)
samples_menu.addAction(cancer_immune_act)
cancer_immune_act.triggered.connect(self.cancer_immune_cb)
template_act = QtGui.QAction('template', self)
samples_menu.addAction(template_act)
template_act.triggered.connect(self.template_cb)
subcell_act = QtGui.QAction('subcellular', self)
samples_menu.addAction(subcell_act)
subcell_act.triggered.connect(self.subcell_cb)
#--------------
# file_menu.addAction(open_act)
# file_menu.addAction(recent_act)
# file_menu.addAction(save_act)
# file_menu.addAction(save_act, self.save_act, QtGui.QKeySequence("Ctrl+s"))
# file_menu.addAction(saveas_act)
#--------------
self.models_menu = menubar.addMenu('Models')
models_menu_act = QtGui.QAction('-----', self)
self.models_menu.addAction(models_menu_act)
models_menu_act.triggered.connect(self.select_current_model_cb)
# self.models_menu.addAction('Load sample', self.select_current_model_cb)
#--------------
tools_menu = menubar.addMenu('Tools')
tools_menu_act = QtGui.QAction('Validate', self)
tools_menu.addAction(tools_menu_act)
def add_action(name: str, signal: QtCore.Signal) -> None:
set_unimportant_task = QtGui.QAction(name)
set_unimportant_task.triggered.connect(lambda: signal.emit(task))
actions.append(set_unimportant_task)
def __init__(self, *args):
super().__init__(*args)
self.config = config.read()
self.resize(1000, 600)
self.setWindowTitle(APP_NAME)
self.about_dialog = None
self.connection_dialog = None
self.preferences_dialog = None
# network
self.network = Network()
self.network.statusChanged.connect(self._network_status_changed)
self.network.messageFromWeechat.connect(self._network_weechat_msg)
# list of buffers
self.list_buffers = BufferListWidget()
self.list_buffers.currentRowChanged.connect(self._buffer_switch)
# default buffer
self.buffers = [Buffer()]
self.stacked_buffers = QtWidgets.QStackedWidget()
self.stacked_buffers.addWidget(self.buffers[0].widget)
# splitter with buffers + chat/input
splitter = QtWidgets.QSplitter()
splitter.addWidget(self.list_buffers)
splitter.addWidget(self.stacked_buffers)
self.setCentralWidget(splitter)
if self.config.getboolean('look', 'statusbar'):
self.statusBar().visible = True
# actions for menu and toolbar
actions_def = {
'connect': [
'network-connect.png',
'Connect to WeeChat',
'Ctrl+O',
self.open_connection_dialog,
],
'disconnect': [
'network-disconnect.png',
'Disconnect from WeeChat',
'Ctrl+D',
self.network.disconnect_weechat,
],
'debug': [
'edit-find.png',
'Open debug console window',
'Ctrl+B',
self.network.open_debug_dialog,
],
'preferences': [
'preferences-other.png',
'Change preferences',
'Ctrl+P',
self.open_preferences_dialog,
],
'about': [
'help-about.png',
'About QWeeChat',
'Ctrl+H',
self.open_about_dialog,
],
'save connection': [
'document-save.png',
'Save connection configuration',
'Ctrl+S',
self.save_connection,
],
'quit': [
'application-exit.png',
'Quit application',
'Ctrl+Q',
self.close,
],
}
self.actions = {}
for name, action in list(actions_def.items()):
self.actions[name] = QtGui.QAction(
QtGui.QIcon(
resource_filename(__name__, 'data/icons/%s' % action[0])),
name.capitalize(), self)
self.actions[name].setToolTip(f'{action[1]} ({action[2]})')
self.actions[name].setShortcut(action[2])
self.actions[name].triggered.connect(action[3])
# menu
self.menu = self.menuBar()
menu_file = self.menu.addMenu('&File')
menu_file.addActions([
self.actions['connect'], self.actions['disconnect'],
self.actions['preferences'], self.actions['save connection'],
self.actions['quit']
])
menu_window = self.menu.addMenu('&Window')
menu_window.addAction(self.actions['debug'])
menu_help = self.menu.addMenu('&Help')
menu_help.addAction(self.actions['about'])
self.network_status = QtWidgets.QLabel()
self.network_status.setFixedHeight(20)
self.network_status.setFixedWidth(200)
self.network_status.setContentsMargins(0, 0, 10, 0)
self.network_status.setAlignment(QtCore.Qt.AlignRight)
if hasattr(self.menu, 'setCornerWidget'):
self.menu.setCornerWidget(self.network_status,
QtCore.Qt.TopRightCorner)
self.network_status_set(STATUS_DISCONNECTED)
# toolbar
toolbar = self.addToolBar('toolBar')
toolbar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
toolbar.addActions([
self.actions['connect'], self.actions['disconnect'],
self.actions['debug'], self.actions['preferences'],
self.actions['about'], self.actions['quit']
])
self.buffers[0].widget.input.setFocus()
# open debug dialog
if self.config.getboolean('look', 'debug'):
self.network.open_debug_dialog()
# auto-connect to relay
if self.config.getboolean('relay', 'autoconnect'):
self.network.connect_weechat(
hostname=self.config.get('relay', 'hostname', fallback=''),
port=self.config.get('relay', 'port', fallback=''),
ssl=self.config.getboolean('relay', 'ssl', fallback=''),
password=self.config.get('relay', 'password', fallback=''),
totp=None,
lines=self.config.get('relay', 'lines', fallback=''),
)
self.show()
