def setupui(self): vbl = QVBoxLayout(self) self.details = QCheckBox('Details', self) vbl.addWidget(self.details, alignment=Qt.AlignRight) grp_bx = self._get_acq_commom_params_grpbx() vbl.addWidget(grp_bx) vbl.addStretch() tabw = QTabWidget(self) grp_bx = self._get_single_pass_acq_grpbx() tabw.addTab(grp_bx, 'SinglePass') if self.isring: grp_bx = self._get_multturn_acq_grpbx() tabw.addTab(grp_bx, 'MultiTurn') tabw.setCurrentIndex(1) vbl.addWidget(tabw) vbl.addStretch() tabw = QTabWidget(self) self._set_detailed(tabw) grp_bx = _HLTriggerSimple(parent=tabw, device=self._csorb.trigger_acq_name, prefix=self.prefix, src=True) tabw.addTab(grp_bx, 'External Trigger') grp_bx = self._get_trigdata_params_grpbx() tabw.addTab(grp_bx, 'Data-Driven Trigger') vbl.addWidget(tabw)
class CurveBenchmark1(QMainWindow): TITLE = "Curve benchmark" SIZE = (1000, 500) def __init__(self, max_n=1000000, parent=None, **kwargs): super(CurveBenchmark1, self).__init__(parent=parent) title = self.TITLE if kwargs.get("only_lines", False): title = "%s (%s)" % (title, "only lines") self.setWindowTitle(title) self.tabs = QTabWidget() self.setCentralWidget(self.tabs) self.text = BMText(self) self.tabs.addTab(self.text, "Contents") self.resize(*self.SIZE) # Force window to show up and refresh (for test purpose only) self.show() QApplication.processEvents() t0g = time.time() self.run_benchmark(max_n, **kwargs) dt = time.time() - t0g self.text.append("<br><br><u>Total elapsed time</u>: %d ms" % (dt * 1e3)) if os.environ.get("TEST_UNATTENDED") is None: self.tabs.setCurrentIndex(0) else: self.tabs.setCurrentIndex(1) def process_iteration(self, title, description, widget, t0): self.tabs.addTab(widget, title) self.tabs.setCurrentWidget(widget) # Force widget to refresh (for test purpose only) QApplication.processEvents() time_str = "Elapsed time: %d ms" % ((time.time() - t0) * 1000) widget.text.setText(time_str) self.text.append("<br><i>%s:</i><br>%s" % (description, time_str)) def run_benchmark(self, max_n, **kwargs): for idx in range(4, -1, -1): points = int(max_n / 10**idx) t0 = time.time() widget = BMWidget(points, **kwargs) title = "%d points" % points description = "%d plots with %d curves of %d points" % ( widget.plot_nb, widget.curve_nb, points, ) self.process_iteration(title, description, widget, t0)
class Collections(QWidget): """Just a widget contains a sub tab widget.""" def __init__(self, parent: MainWindowBase): """Create two widget page and using main window to make their parent.""" super(Collections, self).__init__(parent) layout = QVBoxLayout(self) self.tab_widget = QTabWidget(self) layout.addWidget(self.tab_widget) self.setWindowIcon(QIcon(QPixmap("icons:collections.png"))) self.structure_widget = StructureWidget(parent) self.configure_widget = ConfigureWidget( self.structure_widget.add_collection, parent) self.tab_widget.addTab(self.structure_widget, self.structure_widget.windowIcon(), "Structures") self.tab_widget.addTab(self.configure_widget, self.configure_widget.windowIcon(), "Configuration") self.structure_widget.configure_button.clicked.connect( lambda: self.tab_widget.setCurrentIndex(1)) self.structure_widget.layout_sender.connect( self.configure_widget.set_graph) def clear(self) -> None: """Clear the sub-widgets.""" self.structure_widget.clear() self.configure_widget.clear() def collect_data(self) -> List[Sequence[Tuple[int, int]]]: """Return collections to database.""" return [tuple(G.edges) for G in self.structure_widget.collections] def config_data(self) -> Dict[str, Dict[str, Any]]: """Return profiles to database.""" return self.configure_widget.collections
class Ui_MainWindow(object): def setupUi(self, MainWindow): MainWindow.setObjectName(_fromUtf8("MainWindow")) MainWindow.resize(1155, 853) self.centralwidget = QWidget(MainWindow) self.centralwidget.setObjectName(_fromUtf8("centralwidget")) self.verticalLayout = QVBoxLayout(self.centralwidget) self.verticalLayout.setObjectName(_fromUtf8("verticalLayout")) self.tabWidget = QTabWidget(self.centralwidget) self.tabWidget.setObjectName(_fromUtf8("tabWidget")) self.tab = QWidget() self.tab.setObjectName(_fromUtf8("tab")) self.tabWidget.addTab(self.tab, _fromUtf8("")) self.tab_2 = QWidget() self.tab_2.setObjectName(_fromUtf8("tab_2")) self.tabWidget.addTab(self.tab_2, _fromUtf8("")) self.verticalLayout.addWidget(self.tabWidget) MainWindow.setCentralWidget(self.centralwidget) self.menubar = QMenuBar(MainWindow) self.menubar.setGeometry(QRect(0, 0, 1155, 20)) self.menubar.setObjectName(_fromUtf8("menubar")) MainWindow.setMenuBar(self.menubar) self.statusbar = QStatusBar(MainWindow) self.statusbar.setObjectName(_fromUtf8("statusbar")) MainWindow.setStatusBar(self.statusbar) self.retranslateUi(MainWindow) self.tabWidget.setCurrentIndex(0) QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow", None)) self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab), _translate("MainWindow", "Tab 1", None)) self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2), _translate("MainWindow", "Tab 2", None))
class MasterControl(QWidget): def __init__(self, parent, initialTab=0, b=config.mainB, c=config.mainC, v=config.mainV, text=config.mainText): super().__init__() self.isRefreshing = True self.parent = parent # set title self.setWindowTitle(config.thisTranslation["controlPanel"]) if config.restrictControlPanelWidth and config.screenWidth > config.masterControlWidth: self.setFixedWidth(config.masterControlWidth) # setup item option lists self.setupResourceLists() # setup interface self.text = text self.setupUI(b, c, v, text, initialTab) self.isRefreshing = False # manage key capture def event(self, event): if event.type() == QEvent.KeyRelease: if event.modifiers() == Qt.ControlModifier: if event.key() == Qt.Key_B: self.tabs.setCurrentIndex(0) elif event.key() == Qt.Key_L: self.tabs.setCurrentIndex(1) elif event.key() == Qt.Key_F: self.tabs.setCurrentIndex(2) elif event.key() == Qt.Key_Y: self.tabs.setCurrentIndex(3) elif event.key() == Qt.Key_M: self.tabs.setCurrentIndex(4) elif event.key() == Qt.Key_Escape: self.hide() return QWidget.event(self, event) def closeEvent(self, event): # Control panel is designed for frequent use # Hiding it instead of closing may save time from reloading event.ignore() self.hide() def setupResourceLists(self): self.parent.setupResourceLists() # bible versions self.textList = self.parent.textList self.textFullNameList = self.parent.textFullNameList self.strongBibles = self.parent.strongBibles if self.parent.versionCombo is not None and config.menuLayout in ( "classic", "focus", "aleph"): for index, fullName in enumerate(self.textFullNameList): self.parent.versionCombo.setItemData(index, fullName, Qt.ToolTipRole) # commentaries self.commentaryList = self.parent.commentaryList #self.commentaryFullNameList = [Commentary(module).commentaryInfo() for module in self.commentaryList] self.commentaryFullNameList = self.parent.commentaryFullNameList # reference book # menu10_dialog self.referenceBookList = self.parent.referenceBookList # topic # menu5_topics self.topicListAbb = self.parent.topicListAbb self.topicList = self.parent.topicList # lexicon # context1_originalLexicon self.lexiconList = self.parent.lexiconList # dictionary # context1_dict self.dictionaryListAbb = self.parent.dictionaryListAbb self.dictionaryList = self.parent.dictionaryList # encyclopedia # context1_encyclopedia self.encyclopediaListAbb = self.parent.encyclopediaListAbb self.encyclopediaList = self.parent.encyclopediaList # 3rd-party dictionary # menu5_3rdDict self.thirdPartyDictionaryList = self.parent.thirdPartyDictionaryList # def setupItemLists(self): # # bible versions # self.textList = BiblesSqlite().getBibleList() # self.textFullNameList = [Bible(text).bibleInfo() for text in self.textList] # self.strongBibles = [text for text in self.textList if Bible(text).bibleStrong()] # if self.parent.versionCombo is not None and config.menuLayout in ("classic", "focus", "aleph"): # for index, fullName in enumerate(self.textFullNameList): # self.parent.versionCombo.setItemData(index, fullName, Qt.ToolTipRole) # # commentaries # self.commentaryList = Commentary().getCommentaryList() # #self.commentaryFullNameList = [Commentary(module).commentaryInfo() for module in self.commentaryList] # self.commentaryFullNameList = [] # for module in self.commentaryList: # info = Commentary(module).commentaryInfo() # if info == "https://Marvel.Bible Commentary" and module in Commentary.marvelCommentaries: # info = Commentary.marvelCommentaries[module] # self.commentaryFullNameList.append(info) # # reference book # # menu10_dialog # bookData = BookData() # self.referenceBookList = [book for book, *_ in bookData.getBookList()] # # open database # indexes = IndexesSqlite() # # topic # # menu5_topics # topicDictAbb2Name = {abb: name for abb, name in indexes.topicList} # self.topicListAbb = list(topicDictAbb2Name.keys()) # topicDict = {name: abb for abb, name in indexes.topicList} # self.topicList = list(topicDict.keys()) # # lexicon # # context1_originalLexicon # self.lexiconList = LexiconData().lexiconList # # dictionary # # context1_dict # dictionaryDictAbb2Name = {abb: name for abb, name in indexes.dictionaryList} # self.dictionaryListAbb = list(dictionaryDictAbb2Name.keys()) # dictionaryDict = {name: abb for abb, name in indexes.dictionaryList} # self.dictionaryList = list(dictionaryDict.keys()) # # encyclopedia # # context1_encyclopedia # encyclopediaDictAbb2Name = {abb: name for abb, name in indexes.encyclopediaList} # self.encyclopediaListAbb = list(encyclopediaDictAbb2Name.keys()) # encyclopediaDict = {name: abb for abb, name in indexes.encyclopediaList} # self.encyclopediaList = list(encyclopediaDict.keys()) # # 3rd-party dictionary # # menu5_3rdDict # self.thirdPartyDictionaryList = ThirdPartyDictionary(self.parent.textCommandParser.isThridPartyDictionary(config.thirdDictionary)).moduleList def setupUI(self, b, c, v, text, initialTab): mainLayout = QVBoxLayout() mainLayout.addWidget(self.sharedWidget()) mainLayout.addWidget(self.tabWidget(b, c, v, text, initialTab)) self.setLayout(mainLayout) def sharedWidget(self): sharedWidget = QWidget() sharedWidgetLayout = QVBoxLayout() subLayout = QHBoxLayout() subLayout.addWidget(self.commandFieldWidget()) subLayout.addWidget(self.autoCloseCheckBox()) sharedWidgetLayout.addLayout(subLayout) sharedWidget.setLayout(sharedWidgetLayout) return sharedWidget def updateBibleTabText(self, reference): self.tabs.setTabText(0, reference) def tabWidget(self, b, c, v, text, initialTab): self.tabs = QTabWidget() # 0 self.bibleTab = BibleExplorer(self, (b, c, v, text)) self.tabs.addTab(self.bibleTab, config.thisTranslation["cp0"]) self.tabs.setTabToolTip(0, config.thisTranslation["cp0Tip"]) # 1 libraryTab = LibraryLauncher(self) self.tabs.addTab(libraryTab, config.thisTranslation["cp1"]) self.tabs.setTabToolTip(1, config.thisTranslation["cp1Tip"]) # 2 self.toolTab = SearchLauncher(self) self.tabs.addTab(self.toolTab, config.thisTranslation["cp2"]) self.tabs.setTabToolTip(2, config.thisTranslation["cp2Tip"]) # 3 self.historyTab = HistoryLauncher(self) self.tabs.addTab(self.historyTab, config.thisTranslation["cp3"]) self.tabs.setTabToolTip(3, config.thisTranslation["cp3Tip"]) # 4 self.miscellaneousTab = MiscellaneousLauncher(self) self.tabs.addTab(self.miscellaneousTab, config.thisTranslation["cp4"]) self.tabs.setTabToolTip(4, config.thisTranslation["cp4Tip"]) # set action with changing tabs self.tabs.currentChanged.connect(self.tabChanged) # set initial tab self.tabs.setCurrentIndex(initialTab) return self.tabs def commandFieldWidget(self): self.commandField = QLineEdit() self.commandField.setClearButtonEnabled(True) self.commandField.setToolTip( config.thisTranslation["enter_command_here"]) self.commandField.returnPressed.connect(self.commandEntered) return self.commandField def autoCloseCheckBox(self): checkbox = QCheckBox() checkbox.setText(config.thisTranslation["autoClose"]) checkbox.setToolTip(config.thisTranslation["autoCloseToolTip"]) checkbox.setChecked(config.closeControlPanelAfterRunningCommand) checkbox.stateChanged.connect( self.closeControlPanelAfterRunningCommandChanged) return checkbox # Common layout def buttonsWidget(self, buttonElementTupleTuple, r2l=False, translation=True): buttons = QWidget() buttonsLayouts = QVBoxLayout() buttonsLayouts.setSpacing(3) for buttonElementTuple in buttonElementTupleTuple: buttonsLayouts.addLayout( self.buttonsLayout(buttonElementTuple, r2l, translation)) buttons.setLayout(buttonsLayouts) return buttons def buttonsLayout(self, buttonElementTuple, r2l=False, translation=True): buttonsLayout = QBoxLayout( QBoxLayout.RightToLeft if r2l else QBoxLayout.LeftToRight) buttonsLayout.setSpacing(5) for label, action in buttonElementTuple: buttonLabel = config.thisTranslation[ label] if translation else label button = QPushButton(buttonLabel) button.clicked.connect(action) buttonsLayout.addWidget(button) return buttonsLayout def comboFeatureLayout(self, feature, combo, action): # QGridLayout: https://stackoverflow.com/questions/61451279/how-does-setcolumnstretch-and-setrowstretch-works layout = QGridLayout() layout.setSpacing(5) # combo layout.addWidget(combo, 0, 0, 1, 3) # button button = QPushButton(config.thisTranslation[feature]) button.clicked.connect(action) layout.addWidget(button, 0, 3, 1, 1) return layout # Actions def closeControlPanelAfterRunningCommandChanged(self): config.closeControlPanelAfterRunningCommand = not config.closeControlPanelAfterRunningCommand def updateBCVText(self, b, c, v, text): self.bibleTab.updateBCVText(b, c, v, text) def commandEntered(self): command = self.commandField.text() self.runTextCommand(command, False) def runTextCommand(self, command, printCommand=True, reloadMainWindow=False): if printCommand: self.commandField.setText(command) self.parent.textCommandLineEdit.setText(command) self.parent.runTextCommand(command) if reloadMainWindow: self.parent.reloadCurrentRecord() if config.closeControlPanelAfterRunningCommand and not self.isRefreshing: self.hide() def tabChanged(self, index): self.isRefreshing = True # refresh content if index == 3: self.historyTab.refresh() elif index == 4: self.miscellaneousTab.refresh() # set focus if index == 2: self.toolTab.searchField.setFocus() if config.contextItem: self.toolTab.searchField.setText(config.contextItem) config.contextItem = "" elif self.parent.mainView.currentWidget().selectedText(): self.toolTab.searchField.setText( self.parent.mainView.currentWidget().selectedText()) elif self.parent.studyView.currentWidget().selectedText(): self.toolTab.searchField.setText( self.parent.studyView.currentWidget().selectedText()) else: self.commandField.setFocus() self.isRefreshing = False def displayMessage(self, message="", title="UniqueBible"): reply = QMessageBox.information(self, title, message)
class ImportWizard(BaseDialog): """Text data import wizard""" def __init__(self, parent, text, title=None, icon=None, contents_title=None, varname=None): QDialog.__init__(self, parent) # Destroying the C++ object right after closing the dialog box, # otherwise it may be garbage-collected in another QThread # (e.g. the editor's analysis thread in Spyder), thus leading to # a segmentation fault on UNIX or an application crash on Windows self.setAttribute(Qt.WA_DeleteOnClose) if title is None: title = _("Import wizard") self.setWindowTitle(title) if icon is None: self.setWindowIcon(ima.icon('fileimport')) if contents_title is None: contents_title = _("Raw text") if varname is None: varname = _("variable_name") self.var_name, self.clip_data = None, None # Setting GUI self.tab_widget = QTabWidget(self) self.text_widget = ContentsWidget(self, text) self.table_widget = PreviewWidget(self) self.tab_widget.addTab(self.text_widget, _("text")) self.tab_widget.setTabText(0, contents_title) self.tab_widget.addTab(self.table_widget, _("table")) self.tab_widget.setTabText(1, _("Preview")) self.tab_widget.setTabEnabled(1, False) name_layout = QHBoxLayout() name_label = QLabel(_("Variable Name")) name_layout.addWidget(name_label) self.name_edt = QLineEdit() self.name_edt.setText(varname) name_layout.addWidget(self.name_edt) btns_layout = QHBoxLayout() cancel_btn = QPushButton(_("Cancel")) btns_layout.addWidget(cancel_btn) cancel_btn.clicked.connect(self.reject) h_spacer = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum) btns_layout.addItem(h_spacer) self.back_btn = QPushButton(_("Previous")) self.back_btn.setEnabled(False) btns_layout.addWidget(self.back_btn) self.back_btn.clicked.connect(ft_partial(self._set_step, step=-1)) self.fwd_btn = QPushButton(_("Next")) if not text: self.fwd_btn.setEnabled(False) btns_layout.addWidget(self.fwd_btn) self.fwd_btn.clicked.connect(ft_partial(self._set_step, step=1)) self.done_btn = QPushButton(_("Done")) self.done_btn.setEnabled(False) btns_layout.addWidget(self.done_btn) self.done_btn.clicked.connect(self.process) self.text_widget.asDataChanged.connect(self.fwd_btn.setEnabled) self.text_widget.asDataChanged.connect(self.done_btn.setDisabled) layout = QVBoxLayout() layout.addLayout(name_layout) layout.addWidget(self.tab_widget) layout.addLayout(btns_layout) self.setLayout(layout) def _focus_tab(self, tab_idx): """Change tab focus""" for i in range(self.tab_widget.count()): self.tab_widget.setTabEnabled(i, False) self.tab_widget.setTabEnabled(tab_idx, True) self.tab_widget.setCurrentIndex(tab_idx) def _set_step(self, step): """Proceed to a given step""" new_tab = self.tab_widget.currentIndex() + step assert new_tab < self.tab_widget.count() and new_tab >= 0 if new_tab == self.tab_widget.count() - 1: try: self.table_widget.open_data( self._get_plain_text(), self.text_widget.get_col_sep(), self.text_widget.get_row_sep(), self.text_widget.trnsp_box.isChecked(), self.text_widget.get_skiprows(), self.text_widget.get_comments()) self.done_btn.setEnabled(True) self.done_btn.setDefault(True) self.fwd_btn.setEnabled(False) self.back_btn.setEnabled(True) except (SyntaxError, AssertionError) as error: QMessageBox.critical( self, _("Import wizard"), _("<b>Unable to proceed to next step</b>" "<br><br>Please check your entries." "<br><br>Error message:<br>%s") % str(error)) return elif new_tab == 0: self.done_btn.setEnabled(False) self.fwd_btn.setEnabled(True) self.back_btn.setEnabled(False) self._focus_tab(new_tab) def get_data(self): """Return processed data""" # It is import to avoid accessing Qt C++ object as it has probably # already been destroyed, due to the Qt.WA_DeleteOnClose attribute return self.var_name, self.clip_data def _simplify_shape(self, alist, rec=0): """Reduce the alist dimension if needed""" if rec != 0: if len(alist) == 1: return alist[-1] return alist if len(alist) == 1: return self._simplify_shape(alist[-1], 1) return [self._simplify_shape(al, 1) for al in alist] def _get_table_data(self): """Return clipboard processed as data""" data = self._simplify_shape(self.table_widget.get_data()) if self.table_widget.array_btn.isChecked(): return array(data) elif pd and self.table_widget.df_btn.isChecked(): info = self.table_widget.pd_info buf = io.StringIO(self.table_widget.pd_text) return pd.read_csv(buf, **info) return data def _get_plain_text(self): """Return clipboard as text""" return self.text_widget.text_editor.toPlainText() @Slot() def process(self): """Process the data from clipboard""" var_name = self.name_edt.text() try: self.var_name = str(var_name) except UnicodeEncodeError: self.var_name = to_text_string(var_name) if self.text_widget.get_as_data(): self.clip_data = self._get_table_data() elif self.text_widget.get_as_code(): self.clip_data = try_to_eval(to_text_string( self._get_plain_text())) else: self.clip_data = to_text_string(self._get_plain_text()) self.accept()
class MainWindow(QMainWindow): def __init__(self, log, app): self.log = log.getChild('Main') self.app = app super().__init__() self.dark_theme = CONFIG['dark_theme_default'] self.single_tab_mode = CONFIG['single_tab_mode_default'] self.loggers_by_name = {} # name -> LoggerTab self.popped_out_loggers = {} self.server_running = False self.shutting_down = False self.setupUi() self.start_server() def setupUi(self): self.resize(800, 600) self.setWindowTitle('cutelog') self.loggerTabWidget = QTabWidget(self) self.loggerTabWidget.setTabsClosable(True) self.loggerTabWidget.setMovable(True) self.loggerTabWidget.setTabBarAutoHide(True) self.loggerTabWidget.currentChanged.connect(self.change_actions_state) self.setCentralWidget(self.loggerTabWidget) self.statusbar = QStatusBar(self) self.setStatusBar(self.statusbar) self.setup_menubar() self.setup_action_triggers() self.setup_shortcuts() self.loggerTabWidget.tabCloseRequested.connect(self.close_tab) self.reload_stylesheet() self.restore_geometry() self.show() def setup_menubar(self): self.menubar = QMenuBar(self) self.setMenuBar(self.menubar) # File menu self.menuFile = self.menubar.addMenu("File") self.actionLoadRecords = self.menuFile.addAction('Load records') self.actionSaveRecords = self.menuFile.addAction('Save records') self.menuFile.addSeparator() self.actionDarkTheme = self.menuFile.addAction('Dark theme') self.actionDarkTheme.setCheckable(True) self.actionDarkTheme.setChecked(self.dark_theme) self.actionSingleTab = self.menuFile.addAction('Single tab mode') self.actionSingleTab.setCheckable(True) self.actionSingleTab.setChecked(self.single_tab_mode) # self.actionReloadStyle = self.menuFile.addAction('Reload style') self.actionSettings = self.menuFile.addAction('Settings') self.menuFile.addSeparator() self.actionQuit = self.menuFile.addAction('Quit') # Tab menu self.menuTab = self.menubar.addMenu("Tab") self.actionCloseTab = self.menuTab.addAction('Close') self.actionPopOut = self.menuTab.addAction('Pop out') self.actionRenameTab = self.menuTab.addAction('Rename') self.menuTab.addSeparator() self.actionPopIn = self.menuTab.addAction('Pop in tabs...') self.actionMergeTabs = self.menuTab.addAction('Merge tabs...') self.menuTab.addSeparator() self.actionExtraMode = self.menuTab.addAction('Extra mode') self.actionExtraMode.setCheckable(True) # Server menu self.menuServer = self.menubar.addMenu("Server") self.actionRestartServer = self.menuServer.addAction('Restart server') self.actionStartStopServer = self.menuServer.addAction('Stop server') # Records menu self.menuRecords = self.menubar.addMenu("Records") self.actionTrimTabRecords = self.menuRecords.addAction('Trim records') self.actionSetMaxCapacity = self.menuRecords.addAction( 'Set max capacity') # Help menu self.menuHelp = self.menubar.addMenu("Help") self.actionAbout = self.menuHelp.addAction("About cutelog") self.change_actions_state( ) # to disable all logger actions, since they don't function yet def setup_action_triggers(self): # File menu self.actionLoadRecords.triggered.connect(self.open_load_records_dialog) self.actionSaveRecords.triggered.connect(self.open_save_records_dialog) self.actionDarkTheme.toggled.connect(self.toggle_dark_theme) self.actionSingleTab.triggered.connect(self.set_single_tab_mode) # self.actionReloadStyle.triggered.connect(self.reload_stylesheet) self.actionSettings.triggered.connect(self.settings_dialog) self.actionQuit.triggered.connect(self.shutdown) # Tab meny self.actionCloseTab.triggered.connect(self.close_current_tab) self.actionPopOut.triggered.connect(self.pop_out_tab) self.actionRenameTab.triggered.connect(self.rename_tab_dialog) self.actionPopIn.triggered.connect(self.pop_in_tabs_dialog) self.actionMergeTabs.triggered.connect(self.merge_tabs_dialog) self.actionExtraMode.triggered.connect(self.toggle_extra_mode) # Server menu self.actionRestartServer.triggered.connect(self.restart_server) self.actionStartStopServer.triggered.connect(self.start_or_stop_server) # Records menu self.actionTrimTabRecords.triggered.connect(self.trim_records_dialog) self.actionSetMaxCapacity.triggered.connect(self.max_capacity_dialog) # About menu self.actionAbout.triggered.connect(self.about_dialog) def change_actions_state(self, index=None): logger, _ = self.current_logger_and_index() # if there are no loggers in tabs, these actions will be disabled: actions = [ self.actionCloseTab, self.actionExtraMode, self.actionPopOut, self.actionRenameTab, self.actionPopIn, self.actionTrimTabRecords, self.actionSetMaxCapacity, self.actionSaveRecords ] if not logger: for action in actions: action.setDisabled(True) self.actionExtraMode.setChecked(False) if len(self.popped_out_loggers) > 0: self.actionPopIn.setDisabled(False) else: for action in actions: action.setDisabled(False) if len(self.loggers_by_name) == self.loggerTabWidget.count(): self.actionPopIn.setDisabled(True) self.actionExtraMode.setChecked(logger.extra_mode) # if all loggers are popped in if len(self.popped_out_loggers) == 0: self.actionPopIn.setDisabled(True) if len(self.loggers_by_name) <= 1: self.actionMergeTabs.setDisabled(True) else: self.actionMergeTabs.setDisabled(False) def set_single_tab_mode(self, enabled): self.single_tab_mode = enabled def setup_shortcuts(self): self.actionQuit.setShortcut('Ctrl+Q') self.actionDarkTheme.setShortcut('Ctrl+S') # self.actionReloadStyle.setShortcut('Ctrl+R') # self.actionSettings.setShortcut('Ctrl+A') self.actionCloseTab.setShortcut('Ctrl+W') def save_geometry(self): CONFIG.save_geometry(self.geometry()) def restore_geometry(self): geometry = CONFIG.load_geometry() if geometry: self.resize(geometry.width(), geometry.height()) def settings_dialog(self): d = SettingsDialog(self) d.setWindowModality(Qt.ApplicationModal) d.setAttribute(Qt.WA_DeleteOnClose, True) d.open() def about_dialog(self): d = AboutDialog(self) d.open() def reload_stylesheet(self): if self.dark_theme: self.reload_dark_style() else: self.reload_light_style() def reload_light_style(self): if CONFIG['light_theme_is_native']: self.set_style_to_stock() return f = QFile(":/light_theme.qss") f.open(QFile.ReadOnly | QFile.Text) ts = QTextStream(f) qss = ts.readAll() # f = open(Config.get_resource_path('light_theme.qss', 'resources/ui'), 'r') # qss = f.read() self.app.setStyleSheet(qss) def reload_dark_style(self): f = QFile(":/dark_theme.qss") f.open(QFile.ReadOnly | QFile.Text) ts = QTextStream(f) qss = ts.readAll() # f = open(Config.get_resource_path('dark_theme.qss', 'resources/ui'), 'r') # qss = f.read() self.app.setStyleSheet(qss) def set_style_to_stock(self): self.app.setStyleSheet('') def toggle_dark_theme(self, enabled): self.dark_theme = enabled self.reload_stylesheet() for logger in self.loggers_by_name.values(): logger.set_dark_theme(enabled) def toggle_extra_mode(self, enabled): logger, _ = self.current_logger_and_index() if not logger: return logger.set_extra_mode(enabled) def start_server(self): self.log.debug('Starting the server') self.server = LogServer(self, self.on_connection, self.log) self.server.start() self.server_running = True self.actionStartStopServer.setText('Stop server') def stop_server(self): if self.server_running: self.log.debug('Stopping the server') self.server.close_server() self.server_running = False del self.server self.server = None self.actionStartStopServer.setText('Start server') def restart_server(self): self.log.debug('Restarting the server') self.stop_server() self.start_server() def start_or_stop_server(self): if self.server_running: self.stop_server() else: self.start_server() def on_connection(self, conn, conn_id): self.log.debug('New connection id={}'.format(conn_id)) if self.single_tab_mode and len(self.loggers_by_name) > 0: new_logger = list(self.loggers_by_name.values())[0] new_logger.add_connection(conn) else: new_logger, index = self.create_logger(conn) self.loggerTabWidget.setCurrentIndex(index) conn.new_record.connect(new_logger.on_record) conn.connection_finished.connect(new_logger.remove_connection) if self.server.benchmark and conn_id == -1: from .listener import BenchmarkMonitor bm = BenchmarkMonitor(self, new_logger) bm.speed_readout.connect(self.set_status) conn.connection_finished.connect(bm.requestInterruption) self.server.threads.append(bm) bm.start() def create_logger(self, conn, name=None): name = self.make_logger_name_unique("Logger" if name is None else name) new_logger = LoggerTab(self.loggerTabWidget, name, conn, self.log, self) new_logger.set_dark_theme(self.dark_theme) self.loggers_by_name[name] = new_logger index = self.loggerTabWidget.addTab(new_logger, name) return new_logger, index def make_logger_name_unique(self, name): name_f = "{} {{}}".format(name) c = 1 while name in self.loggers_by_name: name = name_f.format(c) c += 1 return name def set_status(self, string, timeout=3000): self.statusBar().showMessage(string, timeout) def rename_tab_dialog(self): logger, index = self.current_logger_and_index() if not logger: return d = QInputDialog(self) d.setLabelText('Enter the new name for the "{}" tab:'.format( logger.name)) d.setWindowTitle('Rename the "{}" tab'.format(logger.name)) d.textValueSelected.connect(self.rename_current_tab) d.open() def rename_current_tab(self, new_name): logger, index = self.current_logger_and_index() if new_name in self.loggers_by_name and new_name != logger.name: show_warning_dialog( self, "Rename error", 'Logger named "{}" already exists.'.format(new_name)) return self.log.debug('Renaming logger "{}" to "{}"'.format( logger.name, new_name)) del self.loggers_by_name[logger.name] logger.name = new_name self.loggers_by_name[new_name] = logger logger.log.name = '.'.join( logger.log.name.split('.')[:-1]) + '.{}'.format(new_name) self.loggerTabWidget.setTabText(index, new_name) def trim_records_dialog(self): logger, index = self.current_logger_and_index() if not logger: return d = QInputDialog(self) d.setInputMode(QInputDialog.IntInput) d.setIntRange( 0, 100000000) # because it sets intMaximum to 99 by default. why?? d.setLabelText('Keep this many records out of {}:'.format( logger.record_model.rowCount())) d.setWindowTitle('Trim tab records of "{}" logger'.format(logger.name)) d.intValueSelected.connect(self.trim_current_tab_records) d.open() def trim_current_tab_records(self, n): logger, index = self.current_logger_and_index() logger.record_model.trim_except_last_n(n) def max_capacity_dialog(self): logger, index = self.current_logger_and_index() if not logger: return d = QInputDialog(self) d.setInputMode(QInputDialog.IntInput) d.setIntRange( 0, 100000000) # because it sets intMaximum to 99 by default. why?? max_now = logger.record_model.max_capacity max_now = "not set" if max_now is None else max_now label_str = 'Set max capacity for "{}" logger\nCurrently {}. Set to 0 to disable:' d.setLabelText(label_str.format(logger.name, max_now)) d.setWindowTitle('Set max capacity') d.intValueSelected.connect(self.set_max_capacity) d.open() def set_max_capacity(self, n): logger, index = self.current_logger_and_index() logger.set_max_capacity(n) def merge_tabs_dialog(self): d = MergeDialog(self, self.loggers_by_name) d.setWindowModality(Qt.WindowModal) d.merge_tabs_signal.connect(self.merge_tabs) d.show() def merge_tabs(self, dst, srcs, keep_alive): self.log.debug('Merging tabs: dst="{}", srcs={}, keep={}'.format( dst, srcs, keep_alive)) dst_logger = self.loggers_by_name[dst] for src_name in srcs: src_logger = self.loggers_by_name[src_name] dst_logger.merge_with_records(src_logger.record_model.records) if keep_alive: for conn in src_logger.connections: conn.new_record.disconnect(src_logger.on_record) conn.connection_finished.disconnect( src_logger.remove_connection) conn.new_record.connect(dst_logger.on_record) dst_logger.add_connection(conn) src_logger.connections.clear() self.destroy_logger(src_logger) def close_current_tab(self): _, index = self.current_logger_and_index() if index is None: return self.close_tab(index) def close_tab(self, index): self.log.debug("Tab close requested: {}".format(index)) logger = self.loggerTabWidget.widget(index) self.loggerTabWidget.removeTab(index) self.log.debug(logger.name) self.destroy_logger(logger) def destroy_logger(self, logger): del self.loggers_by_name[logger.name] logger.setParent(None) logger.destroy() del logger def close_popped_out_logger(self, logger): del self.loggers_by_name[logger.name] del self.popped_out_loggers[logger.name] del logger if len(self.popped_out_loggers): self.actionPopIn.setDisabled(True) def current_logger_and_index(self): index = self.loggerTabWidget.currentIndex() if index == -1: return None, None logger = self.loggerTabWidget.widget(index) return logger, index def pop_out_tab(self): logger, index = self.current_logger_and_index() if not logger: return self.log.debug("Tab pop out requested: {}".format(int(index))) logger.destroyed.connect(logger.closeEvent) logger.setAttribute(Qt.WA_DeleteOnClose, True) logger.setWindowFlags(Qt.Window) logger.setWindowTitle('cutelog: "{}"'.format( self.loggerTabWidget.tabText(index))) self.popped_out_loggers[logger.name] = logger self.loggerTabWidget.removeTab(index) logger.popped_out = True logger.show() center_widget_on_screen(logger) def pop_in_tabs_dialog(self): d = PopInDialog(self, self.loggers_by_name.values()) d.pop_in_tabs.connect(self.pop_in_tabs) d.setWindowModality(Qt.ApplicationModal) d.open() def pop_in_tabs(self, names): for name in names: self.log.debug('Popping in logger "{}"'.format(name)) logger = self.loggers_by_name[name] self.pop_in_tab(logger) def pop_in_tab(self, logger): logger.setWindowFlags(Qt.Widget) logger.setAttribute(Qt.WA_DeleteOnClose, False) logger.destroyed.disconnect(logger.closeEvent) logger.setWindowTitle(logger.name) logger.popped_out = False del self.popped_out_loggers[logger.name] index = self.loggerTabWidget.addTab(logger, logger.windowTitle()) self.loggerTabWidget.setCurrentIndex(index) def open_load_records_dialog(self): d = QFileDialog(self) d.setFileMode(QFileDialog.ExistingFile) d.fileSelected.connect(self.load_records) d.setWindowTitle('Load records from...') d.open() def load_records(self, load_path): import json from os import path class RecordDecoder(json.JSONDecoder): def __init__(self, *args, **kwargs): json.JSONDecoder.__init__(self, object_hook=self.object_hook, *args, **kwargs) def object_hook(self, obj): if '_created' in obj: obj['created'] = obj['_created'] del obj['_created'] record = LogRecord(obj) del record._logDict['created'] else: record = LogRecord(obj) return record name = path.basename(load_path) index = None try: with open(load_path, 'r') as f: records = json.load(f, cls=RecordDecoder) new_logger, index = self.create_logger(None, name) new_logger.merge_with_records(records) self.loggerTabWidget.setCurrentIndex(index) self.set_status('Records have been loaded into "{}" tab'.format( new_logger.name)) except Exception as e: if index: self.close_tab(index) text = "Error while loading records: \n{}".format(e) self.log.error(text, exc_info=True) show_critical_dialog(self, "Couldn't load records", text) def open_save_records_dialog(self): from functools import partial logger, _ = self.current_logger_and_index() if not logger: return d = QFileDialog(self) d.selectFile(logger.name + '.log') d.setFileMode(QFileDialog.AnyFile) d.fileSelected.connect(partial(self.save_records, logger)) d.setWindowTitle('Save records of "{}" tab to...'.format(logger.name)) d.open() def save_records(self, logger, path): import json # needed because a deque is not serializable class RecordList(list): def __init__(self, records): self.records = records def __len__(self): return len(self.records) def __iter__(self): for record in self.records: d = record._logDict if not d.get('created', False) and not d.get( 'time', False): d['_created'] = record.created yield d try: records = logger.record_model.records record_list = RecordList(records) with open(path, 'w') as f: json.dump(record_list, f, indent=2) self.set_status('Records have been saved to "{}"'.format(path)) except Exception as e: text = "Error while saving records: \n{}".format(e) self.log.error(text, exc_info=True) show_critical_dialog(self, "Couldn't save records", text) def closeEvent(self, event): self.log.info('Close event on main window') self.shutdown() event.ignore( ) # prevents errors due to closing the program before server has stopped def destroy_all_tabs(self): self.log.debug('Destroying tabs') delete_this = list(self.loggers_by_name.values() ) # to prevent changing during iteration for logger in delete_this: self.destroy_logger(logger) def shutdown(self): self.log.info('Shutting down') if self.shutting_down: self.log.error('Exiting forcefully') raise SystemExit self.shutting_down = True self.stop_server() self.save_geometry() self.destroy_all_tabs() self.app.quit() def signal_handler(self, *args): self.shutdown()
class MainWidget(QWidget): """Main Widget, contains everything Attributes ---------- main_window : MainWindow A reference to the main window of the application main_menu : ??? the top bar menu layout : QLayout The main layout for the widget data_handler : DataHandler The instance that controls all interactions with dataset thread_list : List[Thread] A list of all the possible running threads, used to ensure only 1 thread is running at a time preprocess_image_view : ImageViewModule The image view for the preprocess tab roi_image_view : ImageViewModule The image view for the roi extraction tab tab_widget : QTabWidget Controls the main tabs of the application console : ConsoleWidget Widget for the console tabs : List[Tabs] A list of the currently active tabs not used until after init_w_data is run """ def __init__(self, parent, dev=False, preload=True): """ Initialize the main widget to load files Parameters ---------- parent """ super().__init__(parent) self.scale = (self.logicalDpiX() / 96.0 - 1) / 2 + 1 self.main_window = parent self.threadpool = QThreadPool() self.main_menu = self.main_window.main_menu self.layout = QVBoxLayout(self) self.data_handler = None self.thread_list = [] self.dev = dev self.tab_widget = QTabWidget() self.fileOpenTab = FileOpenTab(self) self.tab_widget.addTab(self.fileOpenTab, "Open Dataset") # This part add placeholder tabs until data is loaded self.tabs = ["Preprocessing", "ROI Extraction", "Analysis"] for num, tab in enumerate(self.tabs): self.tab_widget.addTab(QWidget(), tab) self.tab_widget.setTabEnabled(num + 1, False) self.layout.addWidget(self.tab_widget) # # self.console = ConsoleWidget() # self.console.setMaximumHeight(150) # self.console.setMinimumHeight(150) # self.layout.addWidget(self.console) self.setLayout(self.layout) # Initialize top bar menu fileMenu = self.main_menu.addMenu('&File') openFileAction = QAction("Open File", self) openFileAction.setStatusTip('Open a single file') openFileAction.triggered.connect(lambda: self.selectOpenFileTab(0)) fileMenu.addAction(openFileAction) openFolderAction = QAction("Open Folder", self) openFolderAction.setStatusTip('Open a folder') openFolderAction.triggered.connect(lambda: self.selectOpenFileTab(1)) fileMenu.addAction(openFolderAction) openPrevAction = QAction("Open Previous Session", self) openPrevAction.setStatusTip('Open a previous session') openPrevAction.triggered.connect(lambda: self.selectOpenFileTab(2)) fileMenu.addAction(openPrevAction) # Below here in this function is just code for testing # TODO check if it can load data twice if preload and dev: try: # auto loads a small dataset self.data_handler = DataHandler( "/Users/sschickler/Code_Devel/LSSC-python/input_images/", "/Users/sschickler/Documents/LSSC-python", trials=["small_dataset1.tif"], save_dir_already_created=True) self.init_w_data() except IndentationError: pass if False and dev: # auto loads a large dataset self.data_handler = DataHandler( "/Users/sschickler/Code Devel/LSSC-python/input_images/dataset_1", "/Users/sschickler/Code Devel/LSSC-python/input_images/test3", save_dir_already_created=False) self.init_w_data() def init_w_data(self): """ Initialize main widget with data It activates the other tabs and helps load the data into image views Returns ------- """ self.thread_list = [] self.preprocess_image_view = ImageViewModule(self) for num, _ in enumerate(self.tabs): self.tab_widget.removeTab(1) # TODO add to export tab to export all time traces or just currently caclulated ones self.tabs = [ PreprocessingTab(self), ROIExtractionTab(self), AnalysisTab(self) ] # Add tabs for tab in self.tabs: self.tab_widget.addTab(tab, tab.name) self.tab_widget.setCurrentIndex(1) self.image_view_list = [x.image_view for x in self.tabs] # self.tab_widget.currentChanged.connect( # lambda x: self.tabs[1].image_view.set_background("", # self.tabs[ # 1].image_view.background_chooser.current_state(), # update_image=True)) # self.tab_widget.currentChanged.connect( # lambda x: self.tabs[2].image_view.reset_view()) # self.tab_widget.currentChanged.connect( # lambda x: self.tabs[2].reset_view()) if not hasattr(self, "export_menu"): self.export_menu = self.main_menu.addMenu("&Export") export_action = QAction("Export Time Traces/ROIs", self) export_action.setStatusTip('Export Time Traces/ROIs') export_action.triggered.connect(lambda: self.exportStuff()) self.export_menu.addAction(export_action) def selectOpenFileTab(self, index): self.tab_widget.setCurrentIndex(0) self.fileOpenTab.tab_selector.setCurrentIndex(index) def exportStuff(self): dialog = QDialog() dialog.setStyleSheet(qdarkstyle.load_stylesheet()) dialog.layout = QVBoxLayout() dialog.setWindowTitle("Select Trials to Export") trial_dialog = TrialListWidget() trial_dialog.set_items_from_list( self.data_handler.trials_all, trials_selected_indices=self.data_handler. trials_loaded_time_trace_indices) def export_func(): self.data_handler.update_selected_trials( trial_dialog.selectedTrials()) self.data_handler.export() dialog.close() msg = QMessageBox() msg.setStyleSheet(qdarkstyle.load_stylesheet()) msg.setWindowTitle("Export data") msg.setText("Data Exported to save directory: " + self.data_handler.save_dir_path) msg.setIcon(QMessageBox.Information) x = msg.exec_() dialog.layout.addWidget(trial_dialog) export_button = QPushButton("Export") export_button.clicked.connect(lambda x: export_func()) dialog.layout.addWidget(export_button) dialog.setLayout(dialog.layout) dialog.show() def checkThreadRunning(self): if (any([x.isRunning() for x in self.thread_list])): msg = QMessageBox() msg.setStyleSheet(qdarkstyle.load_stylesheet()) msg.setWindowTitle("Operation Denied") msg.setText( "Sorry we can't preform this operation until current process is " "finished") msg.setIcon(QMessageBox.Information) x = msg.exec_() return False else: return True def updateTabs(self): for x in self.tabs: x.updateTab()
class CentralWidget(QWidget): """The PyNetAnalyzer central widget""" def __init__(self, parent): QWidget.__init__(self) self.parent = parent self.appdata: CnaData = parent.appdata self.map_counter = 0 self.searchbar = QLineEdit() self.searchbar.setPlaceholderText("Enter search term") self.throttler = SignalThrottler(300) self.searchbar.textChanged.connect(self.throttler.throttle) self.throttler.triggered.connect(self.update_selected) self.tabs = QTabWidget() self.reaction_list = ReactionList(self.appdata) self.metabolite_list = MetaboliteList(self.appdata) self.model_info = ModelInfo(self.appdata) self.tabs.addTab(self.reaction_list, "Reactions") self.tabs.addTab(self.metabolite_list, "Metabolites") self.tabs.addTab(self.model_info, "Model") self.map_tabs = QTabWidget() self.map_tabs.setTabsClosable(True) self.map_tabs.setMovable(True) # Create an in-process kernel kernel_manager = QtInProcessKernelManager() kernel_manager.start_kernel(show_banner=False) kernel = kernel_manager.kernel kernel.gui = 'qt' myglobals = globals() myglobals["cna"] = self.parent self.kernel_shell = kernel_manager.kernel.shell self.kernel_shell.push(myglobals) self.kernel_client = kernel_manager.client() self.kernel_client.start_channels() # Check if client is working self.kernel_client.execute('import matplotlib.pyplot as plt') self.kernel_client.execute('%matplotlib inline') self.kernel_client.execute( "%config InlineBackend.figure_format = 'svg'") self.console = RichJupyterWidget() self.console.kernel_manager = kernel_manager self.console.kernel_client = self.kernel_client self.splitter = QSplitter() self.splitter2 = QSplitter() self.splitter2.addWidget(self.map_tabs) self.mode_navigator = ModeNavigator(self.appdata) self.splitter2.addWidget(self.mode_navigator) self.splitter2.addWidget(self.console) self.splitter2.setOrientation(Qt.Vertical) self.splitter.addWidget(self.splitter2) self.splitter.addWidget(self.tabs) self.console.show() layout = QVBoxLayout() layout.addWidget(self.searchbar) layout.addWidget(self.splitter) self.setLayout(layout) self.tabs.currentChanged.connect(self.tabs_changed) self.reaction_list.jumpToMap.connect(self.jump_to_map) self.reaction_list.jumpToMetabolite.connect(self.jump_to_metabolite) self.reaction_list.reactionChanged.connect( self.handle_changed_reaction) self.reaction_list.reactionDeleted.connect( self.handle_deleted_reaction) self.metabolite_list.metaboliteChanged.connect( self.handle_changed_metabolite) self.metabolite_list.jumpToReaction.connect(self.jump_to_reaction) self.metabolite_list.computeInOutFlux.connect(self.in_out_fluxes) self.model_info.optimizationDirectionChanged.connect( self.handle_changed_optimization_direction) self.map_tabs.tabCloseRequested.connect(self.delete_map) self.mode_navigator.changedCurrentMode.connect(self.update_mode) self.mode_navigator.modeNavigatorClosed.connect(self.update) self.update() def fit_mapview(self): self.map_tabs.currentWidget().fit() def show_bottom_of_console(self): (_, r) = self.splitter2.getRange(1) self.splitter2.moveSplitter(r * 0.5, 1) vSB = self.console.children()[2].verticalScrollBar() max_scroll = vSB.maximum() vSB.setValue(max_scroll - 100) def handle_changed_reaction(self, old_id: str, reaction: cobra.Reaction): self.parent.unsaved_changes() for mmap in self.appdata.project.maps: if old_id in self.appdata.project.maps[mmap]["boxes"].keys(): self.appdata.project.maps[mmap]["boxes"][ reaction. id] = self.appdata.project.maps[mmap]["boxes"].pop(old_id) # TODO update only relevant reaction boxes on maps self.update_maps() def handle_deleted_reaction(self, reaction: cobra.Reaction): self.appdata.project.cobra_py_model.remove_reactions( [reaction], remove_orphans=True) self.parent.unsaved_changes() for mmap in self.appdata.project.maps: if reaction.id in self.appdata.project.maps[mmap]["boxes"].keys(): self.appdata.project.maps[mmap]["boxes"].pop(reaction.id) # TODO update only relevant reaction boxes on maps self.update_maps() def handle_changed_metabolite(self, old_id: str, metabolite: cobra.Metabolite): self.parent.unsaved_changes() # TODO update only relevant reaction boxes on maps self.update_maps() def handle_changed_optimization_direction(self, direction: str): self.parent.unsaved_changes() def shutdown_kernel(self): self.console.kernel_client.stop_channels() self.console.kernel_manager.shutdown_kernel() def switch_to_reaction(self, reaction: str): self.tabs.setCurrentIndex(0) self.reaction_list.set_current_item(reaction) def minimize_reaction(self, reaction: str): self.parent.fba_optimize_reaction(reaction, mmin=True) def maximize_reaction(self, reaction: str): self.parent.fba_optimize_reaction(reaction, mmin=False) def update_reaction_value(self, reaction: str, value: str): if value == "": self.appdata.scen_values_pop(reaction) self.appdata.project.comp_values.pop(reaction, None) else: try: x = float(value) self.appdata.scen_values_set(reaction, (x, x)) except ValueError: (vl, vh) = make_tuple(value) self.appdata.scen_values_set(reaction, (vl, vh)) self.reaction_list.update() def update_reaction_maps(self, _reaction: str): self.parent.unsaved_changes() self.reaction_list.reaction_mask.update_state() def handle_mapChanged(self, _reaction: str): self.parent.unsaved_changes() def tabs_changed(self, idx): if idx == 0: self.reaction_list.update() elif idx == 1: (clean_model, unused_mets) = prune_unused_metabolites( self.appdata.project.cobra_py_model) self.appdata.project.cobra_py_model = clean_model self.metabolite_list.update() elif idx == 2: self.model_info.update() def add_map(self): while True: name = "Map " + str(self.map_counter) self.map_counter += 1 if name not in self.appdata.project.maps.keys(): break m = CnaMap(name) self.appdata.project.maps[name] = m mmap = MapView(self.appdata, name) mmap.switchToReactionMask.connect(self.switch_to_reaction) mmap.minimizeReaction.connect(self.minimize_reaction) mmap.maximizeReaction.connect(self.maximize_reaction) mmap.reactionValueChanged.connect(self.update_reaction_value) mmap.reactionRemoved.connect(self.update_reaction_maps) mmap.reactionAdded.connect(self.update_reaction_maps) mmap.mapChanged.connect(self.handle_mapChanged) self.map_tabs.addTab(mmap, m["name"]) self.update_maps() self.map_tabs.setCurrentIndex(len(self.appdata.project.maps)) self.parent.unsaved_changes() def delete_map(self, idx: int): name = self.map_tabs.tabText(idx) diag = ConfirmMapDeleteDialog(self, idx, name) diag.exec() def update_selected(self): x = self.searchbar.text() idx = self.tabs.currentIndex() if idx == 0: self.reaction_list.update_selected(x) if idx == 1: self.metabolite_list.update_selected(x) idx = self.map_tabs.currentIndex() if idx >= 0: m = self.map_tabs.widget(idx) m.update_selected(x) def update_mode(self): if len(self.appdata.project.modes) > self.mode_navigator.current: values = self.appdata.project.modes[self.mode_navigator.current] # set values self.appdata.project.scen_values.clear() self.appdata.project.comp_values.clear() for i in values: self.appdata.project.comp_values[i] = (values[i], values[i]) self.appdata.modes_coloring = True self.update() self.appdata.modes_coloring = False def update(self): if len(self.appdata.project.modes) == 0: self.mode_navigator.hide() self.mode_navigator.current = 0 else: self.mode_navigator.show() self.mode_navigator.update() idx = self.tabs.currentIndex() if idx == 0: self.reaction_list.update() elif idx == 1: self.metabolite_list.update() elif idx == 2: self.model_info.update() idx = self.map_tabs.currentIndex() if idx >= 0: m = self.map_tabs.widget(idx) m.update() def update_map(self, idx): m = self.map_tabs.widget(idx) if m is not None: m.update() def update_maps(self): for idx in range(0, self.map_tabs.count()): m = self.map_tabs.widget(idx) m.update() def jump_to_map(self, identifier: str, reaction: str): for idx in range(0, self.map_tabs.count()): name = self.map_tabs.tabText(idx) if name == identifier: m = self.map_tabs.widget(idx) self.map_tabs.setCurrentIndex(idx) m.update() m.focus_reaction(reaction) m.highlight_reaction(reaction) break def jump_to_metabolite(self, metabolite: str): self.tabs.setCurrentIndex(1) m = self.tabs.widget(1) m.set_current_item(metabolite) def jump_to_reaction(self, reaction: str): self.tabs.setCurrentIndex(0) m = self.tabs.widget(0) m.set_current_item(reaction) def in_out_fluxes(self, metabolite): self.kernel_client.execute("cna.print_in_out_fluxes('" + metabolite + "')") self.show_bottom_of_console()
class ImportWizard(QDialog): """Text data import wizard""" def __init__(self, parent, text, title=None, icon=None, contents_title=None, varname=None): QDialog.__init__(self, parent) # Destroying the C++ object right after closing the dialog box, # otherwise it may be garbage-collected in another QThread # (e.g. the editor's analysis thread in Spyder), thus leading to # a segmentation fault on UNIX or an application crash on Windows self.setAttribute(Qt.WA_DeleteOnClose) if title is None: title = _("Import wizard") self.setWindowTitle(title) if icon is None: self.setWindowIcon(ima.icon('fileimport')) if contents_title is None: contents_title = _("Raw text") if varname is None: varname = _("variable_name") self.var_name, self.clip_data = None, None # Setting GUI self.tab_widget = QTabWidget(self) self.text_widget = ContentsWidget(self, text) self.table_widget = PreviewWidget(self) self.tab_widget.addTab(self.text_widget, _("text")) self.tab_widget.setTabText(0, contents_title) self.tab_widget.addTab(self.table_widget, _("table")) self.tab_widget.setTabText(1, _("Preview")) self.tab_widget.setTabEnabled(1, False) name_layout = QHBoxLayout() name_label = QLabel(_("Variable Name")) name_layout.addWidget(name_label) self.name_edt = QLineEdit() self.name_edt.setText(varname) name_layout.addWidget(self.name_edt) btns_layout = QHBoxLayout() cancel_btn = QPushButton(_("Cancel")) btns_layout.addWidget(cancel_btn) cancel_btn.clicked.connect(self.reject) h_spacer = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum) btns_layout.addItem(h_spacer) self.back_btn = QPushButton(_("Previous")) self.back_btn.setEnabled(False) btns_layout.addWidget(self.back_btn) self.back_btn.clicked.connect(ft_partial(self._set_step, step=-1)) self.fwd_btn = QPushButton(_("Next")) btns_layout.addWidget(self.fwd_btn) self.fwd_btn.clicked.connect(ft_partial(self._set_step, step=1)) self.done_btn = QPushButton(_("Done")) self.done_btn.setEnabled(False) btns_layout.addWidget(self.done_btn) self.done_btn.clicked.connect(self.process) self.text_widget.asDataChanged.connect(self.fwd_btn.setEnabled) self.text_widget.asDataChanged.connect(self.done_btn.setDisabled) layout = QVBoxLayout() layout.addLayout(name_layout) layout.addWidget(self.tab_widget) layout.addLayout(btns_layout) self.setLayout(layout) def _focus_tab(self, tab_idx): """Change tab focus""" for i in range(self.tab_widget.count()): self.tab_widget.setTabEnabled(i, False) self.tab_widget.setTabEnabled(tab_idx, True) self.tab_widget.setCurrentIndex(tab_idx) def _set_step(self, step): """Proceed to a given step""" new_tab = self.tab_widget.currentIndex() + step assert new_tab < self.tab_widget.count() and new_tab >= 0 if new_tab == self.tab_widget.count()-1: try: self.table_widget.open_data(self._get_plain_text(), self.text_widget.get_col_sep(), self.text_widget.get_row_sep(), self.text_widget.trnsp_box.isChecked(), self.text_widget.get_skiprows(), self.text_widget.get_comments()) self.done_btn.setEnabled(True) self.done_btn.setDefault(True) self.fwd_btn.setEnabled(False) self.back_btn.setEnabled(True) except (SyntaxError, AssertionError) as error: QMessageBox.critical(self, _("Import wizard"), _("<b>Unable to proceed to next step</b>" "<br><br>Please check your entries." "<br><br>Error message:<br>%s") % str(error)) return elif new_tab == 0: self.done_btn.setEnabled(False) self.fwd_btn.setEnabled(True) self.back_btn.setEnabled(False) self._focus_tab(new_tab) def get_data(self): """Return processed data""" # It is import to avoid accessing Qt C++ object as it has probably # already been destroyed, due to the Qt.WA_DeleteOnClose attribute return self.var_name, self.clip_data def _simplify_shape(self, alist, rec=0): """Reduce the alist dimension if needed""" if rec != 0: if len(alist) == 1: return alist[-1] return alist if len(alist) == 1: return self._simplify_shape(alist[-1], 1) return [self._simplify_shape(al, 1) for al in alist] def _get_table_data(self): """Return clipboard processed as data""" data = self._simplify_shape( self.table_widget.get_data()) if self.table_widget.array_btn.isChecked(): return array(data) elif pd and self.table_widget.df_btn.isChecked(): info = self.table_widget.pd_info buf = io.StringIO(self.table_widget.pd_text) return pd.read_csv(buf, **info) return data def _get_plain_text(self): """Return clipboard as text""" return self.text_widget.text_editor.toPlainText() @Slot() def process(self): """Process the data from clipboard""" var_name = self.name_edt.text() try: self.var_name = str(var_name) except UnicodeEncodeError: self.var_name = to_text_string(var_name) if self.text_widget.get_as_data(): self.clip_data = self._get_table_data() elif self.text_widget.get_as_code(): self.clip_data = try_to_eval( to_text_string(self._get_plain_text())) else: self.clip_data = to_text_string(self._get_plain_text()) self.accept()
class MiniControl(QWidget): def __init__(self, parent, selectedTab=0): super().__init__() self.textButtonStyleEnabled = "QPushButton {background-color: #151B54; color: white;} QPushButton:hover {background-color: #333972;} QPushButton:pressed { background-color: #515790;}" self.textButtonStyleDisabled = "QPushButton {background-color: #323232; color: #323232;} QPushButton:hover {background-color: #323232;} QPushButton:pressed { background-color: #323232;}" self.setWindowTitle(config.thisTranslation["remote_control"]) self.parent = parent self.devotionals = sorted( glob.glob(config.marvelData + "/devotionals/*.devotional")) # specify window size if config.qtMaterial and config.qtMaterialTheme: self.resizeWindow(1 / 2, 1 / 3) else: self.resizeWindow(2 / 5, 1 / 3) self.resizeEvent = (lambda old_method: (lambda event: (self.onResized(event), old_method(event))[-1]))( self.resizeEvent) self.bibleButtons = {} self.commentaryButtons = {} self.bookIntroButtons = {} # setup interface self.bible_layout = None self.setupUI() self.tabs.setCurrentIndex(selectedTab) # window appearance def resizeWindow(self, widthFactor, heightFactor): availableGeometry = QGuiApplication.instance().desktop( ).availableGeometry() self.setMinimumWidth(500) self.resize(availableGeometry.width() * widthFactor, availableGeometry.height() * heightFactor) def onResized(self, event): pass def closeEvent(self, event): config.miniControl = False # manage key capture def event(self, event): if event.type() == QEvent.KeyRelease: if event.modifiers() == Qt.ControlModifier: if event.key() == Qt.Key_B: self.tabs.setCurrentIndex(0) elif event.key() == Qt.Key_T: self.tabs.setCurrentIndex(1) elif event.key() == Qt.Key_C: self.tabs.setCurrentIndex(2) elif event.key() == Qt.Key_L: self.tabs.setCurrentIndex(3) elif event.key() == Qt.Key_D: self.tabs.setCurrentIndex(4) elif event.key() == Qt.Key_O: self.tabs.setCurrentIndex(5) elif event.key() == Qt.Key_Escape: self.close() return QWidget.event(self, event) # setup ui def setupUI(self): textButtonStyle = "QPushButton {background-color: #151B54; color: white;} QPushButton:hover {background-color: #333972;} QPushButton:pressed { background-color: #515790;}" mainLayout = QGridLayout() commandBox = QVBoxLayout() commandBox.setSpacing(3) commandBar = QWidget() commandLayout1 = QBoxLayout(QBoxLayout.LeftToRight) commandLayout1.setSpacing(5) self.searchLineEdit = QLineEdit() self.searchLineEdit.setClearButtonEnabled(True) self.searchLineEdit.setToolTip( config.thisTranslation["enter_command_here"]) self.searchLineEdit.returnPressed.connect(self.searchLineEntered) self.searchLineEdit.setFixedWidth(450) commandLayout1.addWidget(self.searchLineEdit) enterButton = QPushButton(config.thisTranslation["enter"]) enterButton.setFixedWidth(100) enterButton.clicked.connect(self.searchLineEntered) commandLayout1.addWidget(enterButton) # commandLayout1.addStretch() commandBox.addLayout(commandLayout1) if config.showMiniKeyboardInMiniControl: commandLayout2 = QBoxLayout(QBoxLayout.LeftToRight) commandLayout2.setSpacing(5) keys = [ '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', ':', '-', ',', '.', ' ', '<', 'X' ] for key in keys: button = QPushButton(key) button.setMaximumWidth(30) button.clicked.connect(partial(self.keyEntryAction, key)) commandLayout2.addWidget(button) commandLayout2.addStretch() commandBox.addLayout(commandLayout2) if config.showMiniKeyboardInMiniControl and config.isTtsInstalled: ttsLayout = QBoxLayout(QBoxLayout.LeftToRight) ttsLayout.setSpacing(5) self.languageCombo = QComboBox() ttsLayout.addWidget(self.languageCombo) if config.espeak: languages = TtsLanguages().isoLang2epeakLang else: languages = TtsLanguages().isoLang2qlocaleLang self.languageCodes = list(languages.keys()) for code in self.languageCodes: self.languageCombo.addItem(languages[code][1]) # Check if selected tts engine has the language user specify. if not (config.ttsDefaultLangauge in self.languageCodes): config.ttsDefaultLangauge = "en" # Set initial item initialIndex = self.languageCodes.index(config.ttsDefaultLangauge) self.languageCombo.setCurrentIndex(initialIndex) # setting tts default language here is confusing; better place in menu #setDefaultButton = QPushButton(config.thisTranslation["setDefault"]) #setDefaultButton.setFixedWidth(130) #setDefaultButton.clicked.connect(self.setTtsDefaultLanguage) #ttsLayout.addWidget(setDefaultButton) speakButton = QPushButton(config.thisTranslation["speak"]) speakButton.setFixedWidth(100) speakButton.clicked.connect(self.speakCommandFieldText) ttsLayout.addWidget(speakButton) stopButton = QPushButton(config.thisTranslation["stop"]) stopButton.setFixedWidth(100) stopButton.clicked.connect( self.parent.textCommandParser.stopTtsAudio) ttsLayout.addWidget(stopButton) ttsLayout.addStretch() commandBox.addLayout(ttsLayout) commandBar.setLayout(commandBox) mainLayout.addWidget(commandBar, 0, 0, Qt.AlignCenter) self.tabs = QTabWidget() self.tabs.currentChanged.connect(self.tabChanged) mainLayout.addWidget(self.tabs, 1, 0, Qt.AlignCenter) parser = BibleVerseParser(config.parserStandarisation) self.bookMap = parser.standardAbbreviation bookNums = list(self.bookMap.keys()) self.bookNumGps = [ bookNums[0:10], bookNums[10:20], bookNums[20:30], bookNums[30:39], bookNums[39:49], bookNums[49:59], bookNums[59:69], bookNums[69:79], bookNums[79:86], bookNums[86:94], bookNums[94:99], bookNums[99:104], bookNums[104:110], bookNums[110:119], bookNums[119:124], bookNums[124:129], bookNums[129:139], bookNums[139:149], bookNums[149:159], bookNums[159:169], bookNums[169:174], bookNums[174:179], bookNums[179:189], bookNums[189:199], ] # Bible books tab self.bible = QWidget() self.populateBooksButtons(config.mainText) self.tabs.addTab(self.bible, config.thisTranslation["bible"]) # Bible translations tab self.biblesBox = QWidget() self.biblesBoxContainer = QVBoxLayout() collectionsLayout = self.newRowLayout() if len(config.bibleCollections) > 0: button = QPushButton("All") button.setStyleSheet(textButtonStyle) button.clicked.connect(partial(self.selectCollection, "All")) collectionsLayout.addWidget(button) count = 0 for collection in sorted(config.bibleCollections.keys()): button = QPushButton(collection) button.setStyleSheet(textButtonStyle) button.clicked.connect( partial(self.selectCollection, collection)) collectionsLayout.addWidget(button) count += 1 if count > 5: count = 0 self.biblesBoxContainer.addLayout(collectionsLayout) collectionsLayout = self.newRowLayout() self.biblesBoxContainer.addLayout(collectionsLayout) self.bibleBoxWidget = QWidget() self.bibleBoxLayout = QVBoxLayout() self.bibleBoxLayout.setContentsMargins(0, 0, 0, 0) self.bibleBoxLayout.setSpacing(1) row_layout = self.newRowLayout() row_layout.setContentsMargins(0, 0, 0, 0) row_layout.setSpacing(1) biblesSqlite = BiblesSqlite() bibles = biblesSqlite.getBibleList() count = 0 for bible in bibles: button = QPushButton(bible) if bible in config.bibleDescription: button.setToolTip("{0}".format(config.bibleDescription[bible])) button.clicked.connect(partial(self.bibleAction, bible)) row_layout.addWidget(button) count += 1 if count > 6: count = 0 self.bibleBoxLayout.addLayout(row_layout) row_layout = self.newRowLayout() self.bibleButtons[bible] = button self.bibleBoxLayout.addLayout(row_layout) self.bibleBoxLayout.addStretch() self.biblesBoxContainer.addLayout(self.bibleBoxLayout) self.biblesBoxContainer.addStretch() self.biblesBox.setLayout(self.biblesBoxContainer) self.tabs.addTab(self.biblesBox, config.thisTranslation["translations"]) # Commentaries tab commentaries_box = QWidget() box_layout = QVBoxLayout() box_layout.setContentsMargins(0, 0, 0, 0) box_layout.setSpacing(1) row_layout = self.newRowLayout() button = QPushButton(config.thisTranslation["activeOnly"]) button.setStyleSheet(textButtonStyle) button.clicked.connect(self.activeCommentaries) row_layout.addWidget(button) box_layout.addLayout(row_layout) row_layout = self.newRowLayout() commentaries = Commentary().getCommentaryList() count = 0 for commentary in commentaries: button = QPushButton(commentary) button.setToolTip(Commentary.fileLookup[commentary]) button.clicked.connect(partial(self.commentaryAction, commentary)) self.commentaryButtons[commentary] = button row_layout.addWidget(button) count += 1 if count > 6: count = 0 box_layout.addLayout(row_layout) row_layout = self.newRowLayout() box_layout.addLayout(row_layout) box_layout.addStretch() commentaries_box.setLayout(box_layout) self.tabs.addTab(commentaries_box, config.thisTranslation["commentaries"]) # Lexicons tab lexicons_box = QWidget() box_layout = QVBoxLayout() box_layout.setContentsMargins(0, 0, 0, 0) box_layout.setSpacing(1) row_layout = self.newRowLayout() lexicons = LexiconData().lexiconList count = 0 for lexicon in lexicons: button = QPushButton(lexicon) if lexicon in config.lexiconDescription: button.setToolTip("{0}".format( config.lexiconDescription[lexicon])) button.clicked.connect(partial(self.lexiconAction, lexicon)) row_layout.addWidget(button) count += 1 if count > 6: count = 0 box_layout.addLayout(row_layout) row_layout = self.newRowLayout() box_layout.addLayout(row_layout) box_layout.addStretch() lexicons_box.setLayout(box_layout) self.tabs.addTab(lexicons_box, config.thisTranslation["lexicons"]) # Dictionaries tab dictionaries_box = QWidget() box_layout = QVBoxLayout() box_layout.setContentsMargins(0, 0, 0, 0) box_layout.setSpacing(1) row_layout = self.newRowLayout() dictionaries = IndexesSqlite().dictionaryList count = 0 for dictionary in dictionaries: button = QPushButton(dictionary[0]) button.setToolTip(dictionary[1]) button.clicked.connect( partial(self.dictionaryAction, dictionary[0])) row_layout.addWidget(button) count += 1 if count > 6: count = 0 box_layout.addLayout(row_layout) row_layout = self.newRowLayout() box_layout.addLayout(row_layout) box_layout.addStretch() dictionaries_box.setLayout(box_layout) self.tabs.addTab(dictionaries_box, config.thisTranslation["dictionaries"]) # Book intros tab bookIntros_box = QWidget() box_layout = QVBoxLayout() box_layout.setContentsMargins(0, 0, 0, 0) box_layout.setSpacing(1) row_layout = self.newRowLayout() button = QPushButton(config.thisTranslation["activeOnly"]) button.setStyleSheet(textButtonStyle) button.clicked.connect(self.activeBookIntros) row_layout.addWidget(button) box_layout.addLayout(row_layout) row_layout = self.newRowLayout() commentaries = Commentary().getCommentaryList() count = 0 for commentary in commentaries: button = QPushButton(commentary) button.setToolTip(Commentary.fileLookup[commentary]) button.clicked.connect(partial(self.bookIntroAction, commentary)) self.bookIntroButtons[commentary] = button row_layout.addWidget(button) count += 1 if count > 6: count = 0 box_layout.addLayout(row_layout) row_layout = self.newRowLayout() box_layout.addLayout(row_layout) box_layout.addStretch() bookIntros_box.setLayout(box_layout) self.tabs.addTab(bookIntros_box, config.thisTranslation["bookIntro"]) # Devotionals tab if len(self.devotionals) > 0: devotionals_box = QWidget() box_layout = QVBoxLayout() box_layout.setContentsMargins(0, 0, 0, 0) box_layout.setSpacing(1) row_layout = self.newRowLayout() count = 0 for file in self.devotionals: name = Path(file).stem button = QPushButton(name) # button.setToolTip(dictionary[1]) button.clicked.connect(partial(self.devotionalAction, name)) row_layout.addWidget(button) count += 1 if count > 2: count = 0 box_layout.addLayout(row_layout) row_layout.addStretch() row_layout = self.newRowLayout() for i in range(count, 3): button = QPushButton("") row_layout.addWidget(button) box_layout.addLayout(row_layout) box_layout.addStretch() devotionals_box.setLayout(box_layout) self.tabs.addTab(devotionals_box, config.thisTranslation["devotionals"]) self.tabs.setCurrentIndex(config.miniControlInitialTab) self.setLayout(mainLayout) def populateBooksButtons(self, bibleName): books = Bible(bibleName).getBookList() if self.bible_layout is not None: while self.bible_layout.count(): child = self.bible_layout.takeAt(0) if child.widget(): child.widget().deleteLater() else: self.bible_layout = QVBoxLayout() self.bible_layout.setContentsMargins(0, 0, 0, 0) self.bible_layout.setSpacing(1) for bookNumGp in self.bookNumGps: gp = QWidget() layout = self.newRowLayout() for bookNum in bookNumGp: if int(bookNum) in books: text = self.bookMap[bookNum] button = QPushButton(text) if config.developer: button.setToolTip("{0} - {1}".format( BibleBooks.eng[bookNum][1], bookNum)) else: button.setToolTip("{0}".format( BibleBooks.eng[bookNum][1])) button.clicked.connect( partial(self.bibleBookAction, bookNum)) layout.addWidget(button) gp.setLayout(layout) self.bible_layout.addWidget(gp) # for bookNumGp in self.bookNumGps[5:]: # gp = QWidget() # layout = self.newRowLayout() # for bookNum in bookNumGp: # text = self.bookMap[bookNum] # button = QPushButton(text) # button.clicked.connect(partial(self.bibleBookAction, bookNum)) # layout.addWidget(button) # gp.setLayout(layout) # bible_layout.addWidget(gp) self.bible_layout.addStretch() self.bible.setLayout(self.bible_layout) def newRowLayout(self): row_layout = QHBoxLayout() row_layout.setContentsMargins(0, 0, 0, 0) row_layout.setSpacing(1) return row_layout def tabChanged(self, index): prefix = "" if index == 0: prefix = "BIBLE:::{0}:::".format(config.mainText) elif index == 1: prefix = "TEXT:::" elif index == 2: prefix = "COMMENTARY:::{0}:::".format(config.commentaryText) elif index == 3: prefix = "LEXICON:::" elif index == 4: prefix = "SEARCHTOOL:::" if not config.clearCommandEntry: self.searchLineEdit.setText(prefix) def searchLineEntered(self): saveOpenBibleWindowContentOnNextTab = config.openBibleWindowContentOnNextTab searchString = self.searchLineEdit.text() if ":::" not in searchString or ":::{0}:::".format( config.mainText) in searchString: config.openBibleWindowContentOnNextTab = False self.parent.textCommandLineEdit.setText(searchString) self.parent.runTextCommand(searchString) self.searchLineEdit.setFocus() self.populateBooksButtons(config.mainText) config.openBibleWindowContentOnNextTab = saveOpenBibleWindowContentOnNextTab #def setTtsDefaultLanguage(self): #config.ttsDefaultLangauge = self.languageCodes[self.languageCombo.currentIndex()] def speakCommandFieldText(self): text = self.searchLineEdit.text() if ":::" in text: text = text.split(":::")[-1] command = "SPEAK:::{0}:::{1}".format( self.languageCodes[self.languageCombo.currentIndex()], text) self.runCommmand(command) def bibleBookAction(self, book): command = "{0} ".format(self.bookMap[book]) self.runCommmand(command) self.searchLineEdit.setFocus() def keyEntryAction(self, key): text = self.searchLineEdit.text() if key == "X": text = "" elif key == "<": text = text[:-1] else: text += key self.searchLineEdit.setText(text) def bibleAction(self, bible): command = "BIBLE:::{0}:::{1}".format( bible, self.parent.verseReference("main")[1]) self.runCommmand(command) command = "_bibleinfo:::{0}".format(bible) self.parent.runTextCommand(command) self.populateBooksButtons(config.mainText) def commentaryAction(self, commentary): command = "COMMENTARY:::{0}:::{1}".format( commentary, self.parent.verseReference("main")[1]) self.runCommmand(command) command = "_commentaryinfo:::{0}".format(commentary) self.parent.runTextCommand(command) def bookIntroAction(self, commentary): command = "COMMENTARY:::{0}:::{1}".format( commentary, BibleBooks().eng[str(config.mainB)][-1]) self.runCommmand(command) command = "_commentaryinfo:::{0}".format(commentary) self.parent.runTextCommand(command) def devotionalAction(self, devotional): command = "DEVOTIONAL:::{0}".format(devotional) self.runCommmand(command) def lexiconAction(self, lexicon): searchString = self.searchLineEdit.text() if ":::" not in searchString: TextCommandParser.last_lexicon_entry = searchString command = "SEARCHLEXICON:::{0}:::{1}".format( lexicon, TextCommandParser.last_lexicon_entry) self.runCommmand(command) def dictionaryAction(self, dictionary): searchString = self.searchLineEdit.text() if ":::" not in searchString: TextCommandParser.last_text_search = searchString command = "SEARCHTOOL:::{0}:::{1}".format( dictionary, TextCommandParser.last_text_search) self.runCommmand(command) def runCommmand(self, command): self.searchLineEdit.setText(command) self.parent.runTextCommand(command) self.parent.textCommandLineEdit.setText(command) self.populateBooksButtons(config.mainText) def selectCollection(self, collection): if not collection == "All": biblesInCollection = config.bibleCollections[collection] for bible in self.bibleButtons.keys(): button = self.bibleButtons[bible] if collection == "All": button.setEnabled(True) button.setStyleSheet("") else: if bible in biblesInCollection: button.setEnabled(True) button.setStyleSheet("") else: button.setEnabled(False) button.setStyleSheet(self.textButtonStyleDisabled) def activeCommentaries(self): activeCommentaries = [ item[0] for item in Commentary().getCommentaryListThatHasBookAndChapter( config.mainB, config.mainC) ] for commentary in self.commentaryButtons.keys(): button = self.commentaryButtons[commentary] if commentary in activeCommentaries: button.setEnabled(True) button.setStyleSheet("") else: button.setEnabled(False) button.setStyleSheet(self.textButtonStyleDisabled) def activeBookIntros(self): activeCommentaries = [ item[0] for item in Commentary().getCommentaryListThatHasBookAndChapter( config.mainB, 0) ] for commentary in self.bookIntroButtons.keys(): button = self.bookIntroButtons[commentary] if commentary in activeCommentaries: button.setEnabled(True) button.setStyleSheet("") else: button.setEnabled(False) button.setStyleSheet(self.textButtonStyleDisabled)
class TimeChartDisplay(Display): def __init__(self, parent=None, args=[], macros=None, show_pv_add_panel=True, config_file=None): """ Create all the widgets, including any child dialogs. Parameters ---------- parent : QWidget The parent widget of the charting display args : list The command parameters macros : str Macros to modify the UI parameters at runtime show_pv_add_panel : bool Whether or not to show the PV add panel on top of the graph """ super(TimeChartDisplay, self).__init__(parent=parent, args=args, macros=macros) self.legend_font = None self.channel_map = dict() self.setWindowTitle("TimeChart Tool") self.main_layout = QVBoxLayout() self.body_layout = QVBoxLayout() self.pv_add_panel = QFrame() self.pv_add_panel.setVisible(show_pv_add_panel) self.pv_add_panel.setMaximumHeight(50) self.pv_layout = QHBoxLayout() self.pv_name_line_edt = QLineEdit() self.pv_name_line_edt.setAcceptDrops(True) self.pv_name_line_edt.returnPressed.connect(self.add_curve) self.pv_protocol_cmb = QComboBox() self.pv_protocol_cmb.addItems(["ca://", "archive://"]) self.pv_protocol_cmb.setEnabled(False) self.pv_connect_push_btn = QPushButton("Connect") self.pv_connect_push_btn.clicked.connect(self.add_curve) self.tab_panel = QTabWidget() self.tab_panel.setMinimumWidth(350) self.tab_panel.setMaximumWidth(350) self.curve_settings_tab = QWidget() self.data_settings_tab = QWidget() self.chart_settings_tab = QWidget() self.charting_layout = QHBoxLayout() self.chart = PyDMTimePlot(plot_by_timestamps=False) self.chart.setDownsampling(ds=False, auto=False, mode=None) self.chart.plot_redrawn_signal.connect(self.update_curve_data) self.chart.setBufferSize(DEFAULT_BUFFER_SIZE) self.chart.setPlotTitle(DEFAULT_CHART_TITLE) self.splitter = QSplitter() self.curve_settings_layout = QVBoxLayout() self.curve_settings_layout.setAlignment(Qt.AlignTop) self.curve_settings_layout.setSizeConstraint(QLayout.SetMinAndMaxSize) self.curve_settings_layout.setSpacing(5) self.crosshair_settings_layout = QVBoxLayout() self.crosshair_settings_layout.setAlignment(Qt.AlignTop) self.crosshair_settings_layout.setSpacing(5) self.enable_crosshair_chk = QCheckBox("Crosshair") self.crosshair_coord_lbl = QLabel() self.crosshair_coord_lbl.setWordWrap(True) self.curve_settings_inner_frame = QFrame() self.curve_settings_inner_frame.setLayout(self.curve_settings_layout) self.curve_settings_scroll = QScrollArea() self.curve_settings_scroll.setVerticalScrollBarPolicy( Qt.ScrollBarAsNeeded) self.curve_settings_scroll.setHorizontalScrollBarPolicy( Qt.ScrollBarAlwaysOff) self.curve_settings_scroll.setWidget(self.curve_settings_inner_frame) self.curve_settings_scroll.setWidgetResizable(True) self.enable_crosshair_chk.setChecked(False) self.enable_crosshair_chk.clicked.connect( self.handle_enable_crosshair_checkbox_clicked) self.enable_crosshair_chk.clicked.emit(False) self.curves_tab_layout = QHBoxLayout() self.curves_tab_layout.addWidget(self.curve_settings_scroll) self.data_tab_layout = QVBoxLayout() self.data_tab_layout.setAlignment(Qt.AlignTop) self.data_tab_layout.setSpacing(5) self.chart_settings_layout = QVBoxLayout() self.chart_settings_layout.setAlignment(Qt.AlignTop) self.chart_settings_layout.setSpacing(5) self.chart_layout = QVBoxLayout() self.chart_layout.setSpacing(10) self.chart_panel = QWidget() self.chart_panel.setMinimumHeight(400) self.chart_control_layout = QHBoxLayout() self.chart_control_layout.setAlignment(Qt.AlignHCenter) self.chart_control_layout.setSpacing(10) self.zoom_x_layout = QVBoxLayout() self.zoom_x_layout.setAlignment(Qt.AlignTop) self.zoom_x_layout.setSpacing(5) self.plus_icon = IconFont().icon("plus", color=QColor("green")) self.minus_icon = IconFont().icon("minus", color=QColor("red")) self.view_all_icon = IconFont().icon("globe", color=QColor("blue")) self.reset_icon = IconFont().icon("circle-o-notch", color=QColor("green")) self.zoom_in_x_btn = QPushButton("X Zoom") self.zoom_in_x_btn.setIcon(self.plus_icon) self.zoom_in_x_btn.clicked.connect( partial(self.handle_zoom_in_btn_clicked, "x", True)) self.zoom_in_x_btn.setEnabled(False) self.zoom_out_x_btn = QPushButton("X Zoom") self.zoom_out_x_btn.setIcon(self.minus_icon) self.zoom_out_x_btn.clicked.connect( partial(self.handle_zoom_in_btn_clicked, "x", False)) self.zoom_out_x_btn.setEnabled(False) self.zoom_y_layout = QVBoxLayout() self.zoom_y_layout.setAlignment(Qt.AlignTop) self.zoom_y_layout.setSpacing(5) self.zoom_in_y_btn = QPushButton("Y Zoom") self.zoom_in_y_btn.setIcon(self.plus_icon) self.zoom_in_y_btn.clicked.connect( partial(self.handle_zoom_in_btn_clicked, "y", True)) self.zoom_in_y_btn.setEnabled(False) self.zoom_out_y_btn = QPushButton("Y Zoom") self.zoom_out_y_btn.setIcon(self.minus_icon) self.zoom_out_y_btn.clicked.connect( partial(self.handle_zoom_in_btn_clicked, "y", False)) self.zoom_out_y_btn.setEnabled(False) self.view_all_btn = QPushButton("View All") self.view_all_btn.setIcon(self.view_all_icon) self.view_all_btn.clicked.connect(self.handle_view_all_button_clicked) self.view_all_btn.setEnabled(False) self.view_all_reset_chart_layout = QVBoxLayout() self.view_all_reset_chart_layout.setAlignment(Qt.AlignTop) self.view_all_reset_chart_layout.setSpacing(5) self.pause_chart_layout = QVBoxLayout() self.pause_chart_layout.setAlignment(Qt.AlignTop) self.pause_chart_layout.setSpacing(5) self.reset_chart_btn = QPushButton("Reset") self.reset_chart_btn.setIcon(self.reset_icon) self.reset_chart_btn.clicked.connect( self.handle_reset_chart_btn_clicked) self.reset_chart_btn.setEnabled(False) self.pause_icon = IconFont().icon("pause", color=QColor("red")) self.play_icon = IconFont().icon("play", color=QColor("green")) self.pause_chart_btn = QPushButton() self.pause_chart_btn.setIcon(self.pause_icon) self.pause_chart_btn.clicked.connect( self.handle_pause_chart_btn_clicked) self.title_settings_layout = QVBoxLayout() self.title_settings_layout.setAlignment(Qt.AlignTop) self.title_settings_layout.setSpacing(5) self.title_settings_grpbx = QGroupBox("Title and Legend") self.title_settings_grpbx.setMaximumHeight(120) self.import_export_data_layout = QVBoxLayout() self.import_export_data_layout.setAlignment(Qt.AlignTop) self.import_export_data_layout.setSpacing(5) self.import_data_btn = QPushButton("Import...") self.import_data_btn.clicked.connect( self.handle_import_data_btn_clicked) self.export_data_btn = QPushButton("Export...") self.export_data_btn.clicked.connect( self.handle_export_data_btn_clicked) self.chart_title_layout = QHBoxLayout() self.chart_title_layout.setSpacing(10) self.chart_title_lbl = QLabel(text="Graph Title") self.chart_title_line_edt = QLineEdit() self.chart_title_line_edt.setText(self.chart.getPlotTitle()) self.chart_title_line_edt.textChanged.connect( self.handle_title_text_changed) self.chart_title_font_btn = QPushButton() self.chart_title_font_btn.setFixedHeight(24) self.chart_title_font_btn.setFixedWidth(24) self.chart_title_font_btn.setIcon(IconFont().icon("font")) self.chart_title_font_btn.clicked.connect( partial(self.handle_chart_font_changed, "title")) self.chart_change_axis_settings_btn = QPushButton( text="Change Axis Settings...") self.chart_change_axis_settings_btn.clicked.connect( self.handle_change_axis_settings_clicked) self.update_datetime_timer = QTimer(self) self.update_datetime_timer.timeout.connect( self.handle_update_datetime_timer_timeout) self.chart_sync_mode_layout = QVBoxLayout() self.chart_sync_mode_layout.setSpacing(5) self.chart_sync_mode_grpbx = QGroupBox("Data Sampling Mode") self.chart_sync_mode_grpbx.setMaximumHeight(100) self.chart_sync_mode_sync_radio = QRadioButton("Synchronous") self.chart_sync_mode_async_radio = QRadioButton("Asynchronous") self.chart_sync_mode_async_radio.setChecked(True) self.graph_drawing_settings_layout = QVBoxLayout() self.graph_drawing_settings_layout.setAlignment(Qt.AlignVCenter) self.chart_interval_layout = QFormLayout() self.chart_redraw_rate_lbl = QLabel("Redraw Rate (Hz)") self.chart_redraw_rate_spin = QSpinBox() self.chart_redraw_rate_spin.setRange(MIN_REDRAW_RATE_HZ, MAX_REDRAW_RATE_HZ) self.chart_redraw_rate_spin.setValue(DEFAULT_REDRAW_RATE_HZ) self.chart_redraw_rate_spin.editingFinished.connect( self.handle_redraw_rate_changed) self.chart_data_sampling_rate_lbl = QLabel("Data Sampling Rate (Hz)") self.chart_data_async_sampling_rate_spin = QSpinBox() self.chart_data_async_sampling_rate_spin.setRange( MIN_DATA_SAMPLING_RATE_HZ, MAX_DATA_SAMPLING_RATE_HZ) self.chart_data_async_sampling_rate_spin.setValue( DEFAULT_DATA_SAMPLING_RATE_HZ) self.chart_data_async_sampling_rate_spin.editingFinished.connect( self.handle_data_sampling_rate_changed) self.chart_data_sampling_rate_lbl.hide() self.chart_data_async_sampling_rate_spin.hide() self.chart_limit_time_span_layout = QHBoxLayout() self.chart_limit_time_span_layout.setSpacing(5) self.limit_time_plan_text = "Limit Time Span" self.chart_limit_time_span_chk = QCheckBox(self.limit_time_plan_text) self.chart_limit_time_span_chk.hide() self.chart_limit_time_span_lbl = QLabel("Hr:Min:Sec") self.chart_limit_time_span_hours_spin_box = QSpinBox() self.chart_limit_time_span_hours_spin_box.setMaximum(999) self.chart_limit_time_span_minutes_spin_box = QSpinBox() self.chart_limit_time_span_minutes_spin_box.setMaximum(59) self.chart_limit_time_span_seconds_spin_box = QSpinBox() self.chart_limit_time_span_seconds_spin_box.setMaximum(59) self.chart_limit_time_span_activate_btn = QPushButton("Apply") self.chart_limit_time_span_activate_btn.setDisabled(True) self.chart_ring_buffer_layout = QFormLayout() self.chart_ring_buffer_size_lbl = QLabel("Ring Buffer Size") self.chart_ring_buffer_size_edt = QLineEdit() self.chart_ring_buffer_size_edt.returnPressed.connect( self.handle_buffer_size_changed) self.chart_ring_buffer_size_edt.setText(str(DEFAULT_BUFFER_SIZE)) self.show_legend_chk = QCheckBox("Show Legend") self.show_legend_chk.clicked.connect( self.handle_show_legend_checkbox_clicked) self.show_legend_chk.setChecked(self.chart.showLegend) self.legend_font_btn = QPushButton() self.legend_font_btn.setFixedHeight(24) self.legend_font_btn.setFixedWidth(24) self.legend_font_btn.setIcon(IconFont().icon("font")) self.legend_font_btn.clicked.connect( partial(self.handle_chart_font_changed, "legend")) self.graph_background_color_layout = QFormLayout() self.axis_grid_color_layout = QFormLayout() self.background_color_lbl = QLabel("Graph Background Color ") self.background_color_btn = QPushButton() self.background_color_btn.setStyleSheet( "background-color: " + self.chart.getBackgroundColor().name()) self.background_color_btn.setContentsMargins(10, 0, 5, 5) self.background_color_btn.setMaximumWidth(20) self.background_color_btn.clicked.connect( self.handle_background_color_button_clicked) self.axis_settings_layout = QVBoxLayout() self.axis_settings_layout.setSpacing(10) self.show_x_grid_chk = QCheckBox("Show x Grid") self.show_x_grid_chk.setChecked(self.chart.showXGrid) self.show_x_grid_chk.clicked.connect( self.handle_show_x_grid_checkbox_clicked) self.show_y_grid_chk = QCheckBox("Show y Grid") self.show_y_grid_chk.setChecked(self.chart.showYGrid) self.show_y_grid_chk.clicked.connect( self.handle_show_y_grid_checkbox_clicked) self.axis_color_lbl = QLabel("Axis and Grid Color") self.axis_color_btn = QPushButton() self.axis_color_btn.setStyleSheet("background-color: " + DEFAULT_CHART_AXIS_COLOR.name()) self.axis_color_btn.setContentsMargins(10, 0, 5, 5) self.axis_color_btn.setMaximumWidth(20) self.axis_color_btn.clicked.connect( self.handle_axis_color_button_clicked) self.grid_opacity_lbl = QLabel("Grid Opacity") self.grid_opacity_lbl.setEnabled(False) self.grid_opacity_slr = QSlider(Qt.Horizontal) self.grid_opacity_slr.setFocusPolicy(Qt.StrongFocus) self.grid_opacity_slr.setRange(0, 10) self.grid_opacity_slr.setValue(5) self.grid_opacity_slr.setTickInterval(1) self.grid_opacity_slr.setSingleStep(1) self.grid_opacity_slr.setTickPosition(QSlider.TicksBelow) self.grid_opacity_slr.valueChanged.connect( self.handle_grid_opacity_slider_mouse_release) self.grid_opacity_slr.setEnabled(False) self.reset_data_settings_btn = QPushButton("Reset Data Settings") self.reset_data_settings_btn.clicked.connect( self.handle_reset_data_settings_btn_clicked) self.reset_chart_settings_btn = QPushButton("Reset Chart Settings") self.reset_chart_settings_btn.clicked.connect( self.handle_reset_chart_settings_btn_clicked) self.curve_checkbox_panel = QWidget() self.graph_drawing_settings_grpbx = QGroupBox("Graph Intervals") self.graph_drawing_settings_grpbx.setAlignment(Qt.AlignTop) self.axis_settings_grpbx = QGroupBox("Graph Appearance") self.app = QApplication.instance() self.setup_ui() self.curve_settings_disp = None self.axis_settings_disp = None self.chart_data_export_disp = None self.chart_data_import_disp = None self.grid_alpha = 5 self.time_span_limit_hours = None self.time_span_limit_minutes = None self.time_span_limit_seconds = None self.data_sampling_mode = ASYNC_DATA_SAMPLING # If there is an imported config file, let's start TimeChart with the imported configuration data if config_file: importer = SettingsImporter(self) try: importer.import_settings(config_file) except SettingsImporterException: display_message_box( QMessageBox.Critical, "Import Failure", "Cannot import the file '{0}'. Check the log for the error details." .format(config_file)) logger.exception( "Cannot import the file '{0}'.".format(config_file)) def ui_filepath(self): """ The path to the UI file created by Qt Designer, if applicable. """ # No UI file is being used return None def ui_filename(self): """ The name the UI file created by Qt Designer, if applicable. """ # No UI file is being used return None def setup_ui(self): """ Initialize the widgets and layouts. """ self.setLayout(self.main_layout) self.pv_layout.addWidget(self.pv_protocol_cmb) self.pv_layout.addWidget(self.pv_name_line_edt) self.pv_layout.addWidget(self.pv_connect_push_btn) self.pv_add_panel.setLayout(self.pv_layout) QTimer.singleShot(0, self.pv_name_line_edt.setFocus) self.curve_settings_tab.setLayout(self.curves_tab_layout) self.chart_settings_tab.setLayout(self.chart_settings_layout) self.setup_chart_settings_layout() self.data_settings_tab.setLayout(self.data_tab_layout) self.setup_data_tab_layout() self.tab_panel.addTab(self.curve_settings_tab, "Curves") self.tab_panel.addTab(self.data_settings_tab, "Data") self.tab_panel.addTab(self.chart_settings_tab, "Graph") self.crosshair_settings_layout.addWidget(self.enable_crosshair_chk) self.crosshair_settings_layout.addWidget(self.crosshair_coord_lbl) self.zoom_x_layout.addWidget(self.zoom_in_x_btn) self.zoom_x_layout.addWidget(self.zoom_out_x_btn) self.zoom_y_layout.addWidget(self.zoom_in_y_btn) self.zoom_y_layout.addWidget(self.zoom_out_y_btn) self.view_all_reset_chart_layout.addWidget(self.reset_chart_btn) self.view_all_reset_chart_layout.addWidget(self.view_all_btn) self.pause_chart_layout.addWidget(self.pause_chart_btn) self.import_export_data_layout.addWidget(self.import_data_btn) self.import_export_data_layout.addWidget(self.export_data_btn) self.chart_control_layout.addLayout(self.zoom_x_layout) self.chart_control_layout.addLayout(self.zoom_y_layout) self.chart_control_layout.addLayout(self.view_all_reset_chart_layout) self.chart_control_layout.addLayout(self.pause_chart_layout) self.chart_control_layout.addLayout(self.crosshair_settings_layout) self.chart_control_layout.addLayout(self.import_export_data_layout) self.chart_control_layout.insertSpacing(5, 30) self.chart_layout.addWidget(self.chart) self.chart_layout.addLayout(self.chart_control_layout) self.chart_panel.setLayout(self.chart_layout) self.splitter.addWidget(self.chart_panel) self.splitter.addWidget(self.tab_panel) self.splitter.setSizes([1, 0]) self.splitter.setHandleWidth(10) self.splitter.setStretchFactor(0, 0) self.splitter.setStretchFactor(1, 1) self.charting_layout.addWidget(self.splitter) self.body_layout.addWidget(self.pv_add_panel) self.body_layout.addLayout(self.charting_layout) self.body_layout.setSpacing(0) self.body_layout.setContentsMargins(0, 0, 0, 0) self.main_layout.addLayout(self.body_layout) self.enable_chart_control_buttons(False) handle = self.splitter.handle(1) layout = QVBoxLayout() layout.setContentsMargins(0, 0, 0, 0) button = QToolButton(handle) button.setArrowType(Qt.LeftArrow) button.clicked.connect(lambda: self.handle_splitter_button(True)) layout.addWidget(button) button = QToolButton(handle) button.setArrowType(Qt.RightArrow) button.clicked.connect(lambda: self.handle_splitter_button(False)) layout.addWidget(button) handle.setLayout(layout) def handle_splitter_button(self, left=True): if left: self.splitter.setSizes([1, 1]) else: self.splitter.setSizes([1, 0]) def change_legend_font(self, font): if font is None: return self.legend_font = font items = self.chart.plotItem.legend.items for i in items: i[1].item.setFont(font) i[1].resizeEvent(None) i[1].updateGeometry() def change_title_font(self, font): current_text = self.chart.plotItem.titleLabel.text args = { "family": font.family, "size": "{}pt".format(font.pointSize()), "bold": font.bold(), "italic": font.italic(), } self.chart.plotItem.titleLabel.setText(current_text, **args) def handle_chart_font_changed(self, target): if target not in ("title", "legend"): return dialog = QFontDialog(self) dialog.setOption(QFontDialog.DontUseNativeDialog, True) if target == "title": dialog.fontSelected.connect(self.change_title_font) else: dialog.fontSelected.connect(self.change_legend_font) dialog.open() def setup_data_tab_layout(self): self.chart_sync_mode_sync_radio.toggled.connect( partial(self.handle_sync_mode_radio_toggle, self.chart_sync_mode_sync_radio)) self.chart_sync_mode_async_radio.toggled.connect( partial(self.handle_sync_mode_radio_toggle, self.chart_sync_mode_async_radio)) self.chart_sync_mode_layout.addWidget(self.chart_sync_mode_sync_radio) self.chart_sync_mode_layout.addWidget(self.chart_sync_mode_async_radio) self.chart_sync_mode_grpbx.setLayout(self.chart_sync_mode_layout) self.data_tab_layout.addWidget(self.chart_sync_mode_grpbx) self.chart_limit_time_span_layout.addWidget( self.chart_limit_time_span_lbl) self.chart_limit_time_span_layout.addWidget( self.chart_limit_time_span_hours_spin_box) self.chart_limit_time_span_layout.addWidget( self.chart_limit_time_span_minutes_spin_box) self.chart_limit_time_span_layout.addWidget( self.chart_limit_time_span_seconds_spin_box) self.chart_limit_time_span_layout.addWidget( self.chart_limit_time_span_activate_btn) self.chart_limit_time_span_lbl.hide() self.chart_limit_time_span_hours_spin_box.hide() self.chart_limit_time_span_minutes_spin_box.hide() self.chart_limit_time_span_seconds_spin_box.hide() self.chart_limit_time_span_activate_btn.hide() self.chart_limit_time_span_hours_spin_box.valueChanged.connect( self.handle_time_span_changed) self.chart_limit_time_span_minutes_spin_box.valueChanged.connect( self.handle_time_span_changed) self.chart_limit_time_span_seconds_spin_box.valueChanged.connect( self.handle_time_span_changed) self.chart_limit_time_span_chk.clicked.connect( self.handle_limit_time_span_checkbox_clicked) self.chart_limit_time_span_activate_btn.clicked.connect( self.handle_chart_limit_time_span_activate_btn_clicked) self.chart_interval_layout.addRow(self.chart_redraw_rate_lbl, self.chart_redraw_rate_spin) self.chart_interval_layout.addRow( self.chart_data_sampling_rate_lbl, self.chart_data_async_sampling_rate_spin) self.graph_drawing_settings_layout.addLayout( self.chart_interval_layout) self.graph_drawing_settings_layout.addWidget( self.chart_limit_time_span_chk) self.graph_drawing_settings_layout.addLayout( self.chart_limit_time_span_layout) self.chart_ring_buffer_layout.addRow(self.chart_ring_buffer_size_lbl, self.chart_ring_buffer_size_edt) self.graph_drawing_settings_layout.addLayout( self.chart_ring_buffer_layout) self.graph_drawing_settings_grpbx.setLayout( self.graph_drawing_settings_layout) self.data_tab_layout.addWidget(self.graph_drawing_settings_grpbx) self.chart_sync_mode_async_radio.toggled.emit(True) self.data_tab_layout.addWidget(self.reset_data_settings_btn) def setup_chart_settings_layout(self): self.chart_title_layout.addWidget(self.chart_title_lbl) self.chart_title_layout.addWidget(self.chart_title_line_edt) self.chart_title_layout.addWidget(self.chart_title_font_btn) self.title_settings_layout.addLayout(self.chart_title_layout) legend_layout = QHBoxLayout() legend_layout.addWidget(self.show_legend_chk) legend_layout.addWidget(self.legend_font_btn) self.title_settings_layout.addLayout(legend_layout) self.title_settings_layout.addWidget( self.chart_change_axis_settings_btn) self.title_settings_grpbx.setLayout(self.title_settings_layout) self.chart_settings_layout.addWidget(self.title_settings_grpbx) self.graph_background_color_layout.addRow(self.background_color_lbl, self.background_color_btn) self.axis_settings_layout.addLayout(self.graph_background_color_layout) self.axis_grid_color_layout.addRow(self.axis_color_lbl, self.axis_color_btn) self.axis_settings_layout.addLayout(self.axis_grid_color_layout) self.axis_settings_layout.addWidget(self.show_x_grid_chk) self.axis_settings_layout.addWidget(self.show_y_grid_chk) self.axis_settings_layout.addWidget(self.grid_opacity_lbl) self.axis_settings_layout.addWidget(self.grid_opacity_slr) self.axis_settings_grpbx.setLayout(self.axis_settings_layout) self.chart_settings_layout.addWidget(self.axis_settings_grpbx) self.chart_settings_layout.addWidget(self.reset_chart_settings_btn) self.update_datetime_timer.start(1000) def add_curve(self): """ Add a new curve to the chart. """ pv_name = self._get_full_pv_name(self.pv_name_line_edt.text()) if pv_name and len(pv_name): color = random_color(curve_colors_only=True) for k, v in self.channel_map.items(): if color == v.color: color = random_color(curve_colors_only=True) self.add_y_channel(pv_name=pv_name, curve_name=pv_name, color=color) self.handle_splitter_button(left=True) def show_mouse_coordinates(self, x, y): self.crosshair_coord_lbl.clear() self.crosshair_coord_lbl.setText("x = {0:.3f}\ny = {1:.3f}".format( x, y)) def handle_enable_crosshair_checkbox_clicked(self, is_checked): self.chart.enableCrosshair(is_checked) self.crosshair_coord_lbl.setVisible(is_checked) self.chart.crosshair_position_updated.connect( self.show_mouse_coordinates) def add_y_channel(self, pv_name, curve_name, color, line_style=Qt.SolidLine, line_width=2, symbol=None, symbol_size=None, is_visible=True): if pv_name in self.channel_map: logger.error("'{0}' has already been added.".format(pv_name)) return curve = self.chart.addYChannel(y_channel=pv_name, name=curve_name, color=color, lineStyle=line_style, lineWidth=line_width, symbol=symbol, symbolSize=symbol_size) curve.show() if is_visible else curve.hide() if self.show_legend_chk.isChecked(): self.change_legend_font(self.legend_font) self.channel_map[pv_name] = curve self.generate_pv_controls(pv_name, color) self.enable_chart_control_buttons() try: self.app.add_connection(curve.channel) except AttributeError: # these methods are not needed on future versions of pydm pass def generate_pv_controls(self, pv_name, curve_color): """ Generate a set of widgets to manage the appearance of a curve. The set of widgets includes: 1. A checkbox which shows the curve on the chart if checked, and hide the curve if not checked 2. Three buttons -- Modify..., Focus, and Remove. Modify... will bring up the Curve Settings dialog. Focus adjusts the chart's zooming for the current curve. Remove will delete the curve from the chart Parameters ---------- pv_name: str The name of the PV the current curve is being plotted for curve_color : QColor The color of the curve to paint for the checkbox label to help the user track the curve to the checkbox """ individual_curve_layout = QVBoxLayout() size_policy = QSizePolicy() size_policy.setVerticalPolicy(QSizePolicy.Fixed) size_policy.setHorizontalPolicy(QSizePolicy.Fixed) individual_curve_grpbx = QGroupBox() individual_curve_grpbx.setMinimumWidth(300) individual_curve_grpbx.setMinimumHeight(120) individual_curve_grpbx.setAlignment(Qt.AlignTop) individual_curve_grpbx.setSizePolicy(size_policy) individual_curve_grpbx.setObjectName(pv_name + "_grb") individual_curve_grpbx.setLayout(individual_curve_layout) checkbox = QCheckBox(parent=individual_curve_grpbx) checkbox.setObjectName(pv_name + "_chb") palette = checkbox.palette() palette.setColor(QPalette.Active, QPalette.WindowText, curve_color) checkbox.setPalette(palette) display_name = pv_name.split("://")[1] if len(display_name) > MAX_DISPLAY_PV_NAME_LENGTH: # Only display max allowed number of characters of the PV Name display_name = display_name[ :int(MAX_DISPLAY_PV_NAME_LENGTH / 2) - 1] + "..." + \ display_name[ -int(MAX_DISPLAY_PV_NAME_LENGTH / 2) + 2:] checkbox.setText(display_name) data_text = QLabel(parent=individual_curve_grpbx) data_text.setWordWrap(True) data_text.setObjectName(pv_name + "_lbl") data_text.setPalette(palette) checkbox.setChecked(True) checkbox.toggled.connect( partial(self.handle_curve_chkbox_toggled, checkbox)) if not self.chart.findCurve(pv_name).isVisible(): checkbox.setChecked(False) modify_curve_btn = QPushButton("Modify...", parent=individual_curve_grpbx) modify_curve_btn.setObjectName(pv_name + "_btn_modify") modify_curve_btn.setMaximumWidth(80) modify_curve_btn.clicked.connect( partial(self.display_curve_settings_dialog, pv_name)) focus_curve_btn = QPushButton("Focus", parent=individual_curve_grpbx) focus_curve_btn.setObjectName(pv_name + "_btn_focus") focus_curve_btn.setMaximumWidth(80) focus_curve_btn.clicked.connect(partial(self.focus_curve, pv_name)) clear_curve_btn = QPushButton("Clear", parent=individual_curve_grpbx) clear_curve_btn.setObjectName(pv_name + "_btn_clear") clear_curve_btn.setMaximumWidth(80) clear_curve_btn.clicked.connect(partial(self.clear_curve, pv_name)) # annotate_curve_btn = QPushButton("Annotate...", # parent=individual_curve_grpbx) # annotate_curve_btn.setObjectName(pv_name+"_btn_ann") # annotate_curve_btn.setMaximumWidth(80) # annotate_curve_btn.clicked.connect( # partial(self.annotate_curve, pv_name)) remove_curve_btn = QPushButton("Remove", parent=individual_curve_grpbx) remove_curve_btn.setObjectName(pv_name + "_btn_remove") remove_curve_btn.setMaximumWidth(80) remove_curve_btn.clicked.connect(partial(self.remove_curve, pv_name)) curve_btn_layout = QHBoxLayout() curve_btn_layout.setSpacing(5) curve_btn_layout.addWidget(modify_curve_btn) curve_btn_layout.addWidget(focus_curve_btn) curve_btn_layout.addWidget(clear_curve_btn) # curve_btn_layout.addWidget(annotate_curve_btn) curve_btn_layout.addWidget(remove_curve_btn) individual_curve_layout.addWidget(checkbox) individual_curve_layout.addWidget(data_text) individual_curve_layout.addLayout(curve_btn_layout) self.curve_settings_layout.addWidget(individual_curve_grpbx) self.tab_panel.setCurrentIndex(0) def handle_curve_chkbox_toggled(self, checkbox): """ Handle a checkbox's checked and unchecked events. If a checkbox is checked, find the curve from the channel map. If found, re-draw the curve with its previous appearance settings. If a checkbox is unchecked, remove the curve from the chart, but keep the cached data in the channel map. Parameters ---------- checkbox : QCheckBox The current checkbox being toggled """ pv_name = self._get_full_pv_name(checkbox.text()) if checkbox.isChecked(): curve = self.channel_map.get(pv_name, None) if curve: curve.show() self.chart.addLegendItem(curve, pv_name, self.show_legend_chk.isChecked()) self.change_legend_font(self.legend_font) else: curve = self.chart.findCurve(pv_name) if curve: curve.hide() self.chart.removeLegendItem(pv_name) def display_curve_settings_dialog(self, pv_name): """ Bring up the Curve Settings dialog to modify the appearance of a curve. Parameters ---------- pv_name : str The name of the PV the curve is being plotted for """ self.curve_settings_disp = CurveSettingsDisplay(self, pv_name) self.curve_settings_disp.show() def focus_curve(self, pv_name): curve = self.chart.findCurve(pv_name) if curve: self.chart.plotItem.setYRange(curve.minY, curve.maxY, padding=0) def clear_curve(self, pv_name): curve = self.chart.findCurve(pv_name) if curve: curve.initialize_buffer() def annotate_curve(self, pv_name): curve = self.chart.findCurve(pv_name) if curve: annot = TextItem( html= '<div style="text-align: center"><span style="color: #FFF;">This is the' '</span><br><span style="color: #FF0; font-size: 16pt;">PEAK</span></div>', anchor=(-0.3, 0.5), border='w', fill=(0, 0, 255, 100)) self.chart.annotateCurve(curve, annot) def remove_curve(self, pv_name): """ Remove a curve from the chart permanently. This will also clear the channel map cache from retaining the removed curve's appearance settings. Parameters ---------- pv_name : str The name of the PV the curve is being plotted for """ curve = self.chart.findCurve(pv_name) if curve: try: self.app.remove_connection(curve.channel) except AttributeError: # these methods are not needed on future versions of pydm pass self.chart.removeYChannel(curve) del self.channel_map[pv_name] self.chart.removeLegendItem(pv_name) widget = self.findChild(QGroupBox, pv_name + "_grb") if widget: widget.deleteLater() if len(self.chart.getCurves()) < 1: self.enable_chart_control_buttons(False) self.show_legend_chk.setChecked(False) def handle_title_text_changed(self, new_text): self.chart.setPlotTitle(new_text) def handle_change_axis_settings_clicked(self): self.axis_settings_disp = AxisSettingsDisplay(self) self.axis_settings_disp.show() def handle_limit_time_span_checkbox_clicked(self, is_checked): self.chart_limit_time_span_lbl.setVisible(is_checked) self.chart_limit_time_span_hours_spin_box.setVisible(is_checked) self.chart_limit_time_span_minutes_spin_box.setVisible(is_checked) self.chart_limit_time_span_seconds_spin_box.setVisible(is_checked) self.chart_limit_time_span_activate_btn.setVisible(is_checked) self.chart_ring_buffer_size_lbl.setDisabled(is_checked) self.chart_ring_buffer_size_edt.setDisabled(is_checked) if not is_checked: self.chart_limit_time_span_chk.setText(self.limit_time_plan_text) def handle_time_span_changed(self): self.time_span_limit_hours = self.chart_limit_time_span_hours_spin_box.value( ) self.time_span_limit_minutes = self.chart_limit_time_span_minutes_spin_box.value( ) self.time_span_limit_seconds = self.chart_limit_time_span_seconds_spin_box.value( ) status = self.time_span_limit_hours > 0 or self.time_span_limit_minutes > 0 or self.time_span_limit_seconds > 0 self.chart_limit_time_span_activate_btn.setEnabled(status) def handle_chart_limit_time_span_activate_btn_clicked(self): timeout_milliseconds = (self.time_span_limit_hours * 3600 + self.time_span_limit_minutes * 60 + self.time_span_limit_seconds) * 1000 self.chart.setTimeSpan(timeout_milliseconds / 1000.0) self.chart_ring_buffer_size_edt.setText(str( self.chart.getBufferSize())) def handle_buffer_size_changed(self): try: new_buffer_size = int(self.chart_ring_buffer_size_edt.text()) if new_buffer_size and int(new_buffer_size) >= MINIMUM_BUFFER_SIZE: self.chart.setBufferSize(new_buffer_size) except ValueError: display_message_box(QMessageBox.Critical, "Invalid Values", "Only integer values are accepted.") def handle_redraw_rate_changed(self): self.chart.maxRedrawRate = self.chart_redraw_rate_spin.value() def handle_data_sampling_rate_changed(self): # The chart expects the value in milliseconds sampling_rate_seconds = 1.0 / self.chart_data_async_sampling_rate_spin.value( ) buffer_size = self.chart.getBufferSize() self.chart.setUpdateInterval(sampling_rate_seconds) if self.chart.getBufferSize() < buffer_size: self.chart.setBufferSize(buffer_size) self.chart_ring_buffer_size_edt.setText(str( self.chart.getBufferSize())) def handle_background_color_button_clicked(self): selected_color = QColorDialog.getColor() self.chart.setBackgroundColor(selected_color) self.background_color_btn.setStyleSheet("background-color: " + selected_color.name()) def handle_axis_color_button_clicked(self): selected_color = QColorDialog.getColor() self.chart.setAxisColor(selected_color) self.axis_color_btn.setStyleSheet("background-color: " + selected_color.name()) def handle_grid_opacity_slider_mouse_release(self): self.grid_alpha = float(self.grid_opacity_slr.value()) / 10.0 self.chart.setShowXGrid(self.show_x_grid_chk.isChecked(), self.grid_alpha) self.chart.setShowYGrid(self.show_y_grid_chk.isChecked(), self.grid_alpha) def handle_show_x_grid_checkbox_clicked(self, is_checked): self.chart.setShowXGrid(is_checked, self.grid_alpha) self.grid_opacity_lbl.setEnabled(is_checked or self.show_y_grid_chk.isChecked()) self.grid_opacity_slr.setEnabled(is_checked or self.show_y_grid_chk.isChecked()) def handle_show_y_grid_checkbox_clicked(self, is_checked): self.chart.setShowYGrid(is_checked, self.grid_alpha) self.grid_opacity_lbl.setEnabled(is_checked or self.show_x_grid_chk.isChecked()) self.grid_opacity_slr.setEnabled(is_checked or self.show_x_grid_chk.isChecked()) def handle_show_legend_checkbox_clicked(self, is_checked): self.chart.setShowLegend(is_checked) def handle_export_data_btn_clicked(self): self.chart_data_export_disp = ChartDataExportDisplay(self) self.chart_data_export_disp.show() def handle_import_data_btn_clicked(self): open_file_info = QFileDialog.getOpenFileName( self, caption="Open File", directory=os.path.expanduser('~'), filter=IMPORT_FILE_FORMAT) open_filename = open_file_info[0] if open_filename: try: importer = SettingsImporter(self) importer.import_settings(open_filename) except SettingsImporterException: display_message_box( QMessageBox.Critical, "Import Failure", "Cannot import the file '{0}'. Check the log for the error details." .format(open_filename)) logger.exception( "Cannot import the file '{0}'".format(open_filename)) def handle_sync_mode_radio_toggle(self, radio_btn): if radio_btn.isChecked(): if radio_btn.text() == "Synchronous": self.data_sampling_mode = SYNC_DATA_SAMPLING self.chart_data_sampling_rate_lbl.hide() self.chart_data_async_sampling_rate_spin.hide() self.chart.resetTimeSpan() self.chart_limit_time_span_chk.setChecked(False) self.chart_limit_time_span_chk.clicked.emit(False) self.chart_limit_time_span_chk.hide() self.chart.setUpdatesAsynchronously(False) elif radio_btn.text() == "Asynchronous": self.data_sampling_mode = ASYNC_DATA_SAMPLING self.chart_data_sampling_rate_lbl.show() self.chart_data_async_sampling_rate_spin.show() self.chart_limit_time_span_chk.show() self.chart.setUpdatesAsynchronously(True) def handle_zoom_in_btn_clicked(self, axis, is_zoom_in): scale_factor = 0.5 if not is_zoom_in: scale_factor += 1.0 if axis == "x": self.chart.getViewBox().scaleBy(x=scale_factor) elif axis == "y": self.chart.getViewBox().scaleBy(y=scale_factor) def handle_view_all_button_clicked(self): self.chart.plotItem.getViewBox().autoRange() def handle_pause_chart_btn_clicked(self): if self.chart.pausePlotting(): self.pause_chart_btn.setIcon(self.pause_icon) else: self.pause_chart_btn.setIcon(self.play_icon) def handle_reset_chart_btn_clicked(self): self.chart.getViewBox().setXRange(DEFAULT_X_MIN, 0) self.chart.resetAutoRangeY() @Slot() def handle_reset_chart_settings_btn_clicked(self): self.chart.setBackgroundColor(DEFAULT_CHART_BACKGROUND_COLOR) self.background_color_btn.setStyleSheet( "background-color: " + DEFAULT_CHART_BACKGROUND_COLOR.name()) self.chart.setAxisColor(DEFAULT_CHART_AXIS_COLOR) self.axis_color_btn.setStyleSheet("background-color: " + DEFAULT_CHART_AXIS_COLOR.name()) self.grid_opacity_slr.setValue(5) self.show_x_grid_chk.setChecked(False) self.show_x_grid_chk.clicked.emit(False) self.show_y_grid_chk.setChecked(False) self.show_y_grid_chk.clicked.emit(False) self.show_legend_chk.setChecked(False) self.chart.setShowXGrid(False) self.chart.setShowYGrid(False) self.chart.setShowLegend(False) @Slot() def handle_reset_data_settings_btn_clicked(self): self.chart_ring_buffer_size_edt.setText(str(DEFAULT_BUFFER_SIZE)) self.chart_redraw_rate_spin.setValue(DEFAULT_REDRAW_RATE_HZ) self.handle_redraw_rate_changed() self.chart_data_async_sampling_rate_spin.setValue( DEFAULT_DATA_SAMPLING_RATE_HZ) self.chart_data_sampling_rate_lbl.hide() self.chart_data_async_sampling_rate_spin.hide() self.chart_sync_mode_async_radio.setChecked(True) self.chart_sync_mode_async_radio.toggled.emit(True) self.chart_limit_time_span_chk.setChecked(False) self.chart_limit_time_span_chk.setText(self.limit_time_plan_text) self.chart_limit_time_span_chk.clicked.emit(False) self.chart.setUpdatesAsynchronously(True) self.chart.resetTimeSpan() self.chart.resetUpdateInterval() self.chart.setBufferSize(DEFAULT_BUFFER_SIZE) def enable_chart_control_buttons(self, enabled=True): self.zoom_in_x_btn.setEnabled(enabled) self.zoom_out_x_btn.setEnabled(enabled) self.zoom_in_y_btn.setEnabled(enabled) self.zoom_out_y_btn.setEnabled(enabled) self.view_all_btn.setEnabled(enabled) self.reset_chart_btn.setEnabled(enabled) self.pause_chart_btn.setIcon(self.pause_icon) self.pause_chart_btn.setEnabled(enabled) self.export_data_btn.setEnabled(enabled) def _get_full_pv_name(self, pv_name): """ Append the protocol to the PV Name. Parameters ---------- pv_name : str The name of the PV the curve is being plotted for """ if pv_name and "://" not in pv_name: pv_name = ''.join([self.pv_protocol_cmb.currentText(), pv_name]) return pv_name def handle_update_datetime_timer_timeout(self): current_label = self.chart.getBottomAxisLabel() new_label = "Current Time: " + TimeChartDisplay.get_current_datetime() if X_AXIS_LABEL_SEPARATOR in current_label: current_label = current_label[current_label. find(X_AXIS_LABEL_SEPARATOR) + len(X_AXIS_LABEL_SEPARATOR):] new_label += X_AXIS_LABEL_SEPARATOR + current_label self.chart.setLabel("bottom", text=new_label) def update_curve_data(self, curve): """ Determine if the PV is active. If not, disable the related PV controls. If the PV is active, update the PV controls' states. Parameters ---------- curve : PlotItem A PlotItem, i.e. a plot, to draw on the chart. """ pv_name = curve.address min_y = curve.minY if curve.minY else 0 max_y = curve.maxY if curve.maxY else 0 current_y = curve.data_buffer[1, -1] grb = self.findChild(QGroupBox, pv_name + "_grb") lbl = grb.findChild(QLabel, pv_name + "_lbl") lbl.setText("(yMin = {0:.3f}, yMax = {1:.3f}) y = {2:.3f}".format( min_y, max_y, current_y)) chb = grb.findChild(QCheckBox, pv_name + "_chb") connected = curve.connected if connected and chb.isEnabled(): return chb.setEnabled(connected) btn_modify = grb.findChild(QPushButton, pv_name + "_btn_modify") btn_modify.setEnabled(connected) btn_focus = grb.findChild(QPushButton, pv_name + "_btn_focus") btn_focus.setEnabled(connected) # btn_ann = grb.findChild(QPushButton, pv_name + "_btn_ann") # btn_ann.setEnabled(connected) @staticmethod def get_current_datetime(): current_date = datetime.datetime.now().strftime("%b %d, %Y") current_time = datetime.datetime.now().strftime("%H:%M:%S") current_datetime = current_time + ' (' + current_date + ')' return current_datetime @property def gridAlpha(self): return self.grid_alpha
class MiniControl(QWidget): def __init__(self, parent): super().__init__() self.setWindowTitle(config.thisTranslation["remote_control"]) self.parent = parent # specify window size if config.qtMaterial and config.qtMaterialTheme: self.resizeWindow(1 / 2, 1 / 3) else: self.resizeWindow(2 / 5, 1 / 3) self.resizeEvent = (lambda old_method: (lambda event: (self.onResized(event), old_method(event))[-1]))( self.resizeEvent) # setup interface self.setupUI() # window appearance def resizeWindow(self, widthFactor, heightFactor): availableGeometry = QGuiApplication.instance().desktop( ).availableGeometry() self.setMinimumWidth(500) self.resize(availableGeometry.width() * widthFactor, availableGeometry.height() * heightFactor) def onResized(self, event): pass def closeEvent(self, event): config.miniControl = False # manage key capture def event(self, event): if event.type() == QEvent.KeyRelease: if event.modifiers() == Qt.ControlModifier: if event.key() == Qt.Key_B: self.tabs.setCurrentIndex(0) elif event.key() == Qt.Key_T: self.tabs.setCurrentIndex(1) elif event.key() == Qt.Key_C: self.tabs.setCurrentIndex(2) elif event.key() == Qt.Key_L: self.tabs.setCurrentIndex(3) elif event.key() == Qt.Key_D: self.tabs.setCurrentIndex(4) elif event.key() == Qt.Key_Escape: self.close() return QWidget.event(self, event) # setup ui def setupUI(self): mainLayout = QGridLayout() commandBox = QVBoxLayout() commandBox.setSpacing(3) commandBar = QWidget() commandLayout1 = QBoxLayout(QBoxLayout.LeftToRight) commandLayout1.setSpacing(5) self.searchLineEdit = QLineEdit() self.searchLineEdit.setClearButtonEnabled(True) self.searchLineEdit.setToolTip( config.thisTranslation["enter_command_here"]) self.searchLineEdit.returnPressed.connect(self.searchLineEntered) self.searchLineEdit.setFixedWidth(300) commandLayout1.addWidget(self.searchLineEdit) enterButton = QPushButton(config.thisTranslation["enter"]) enterButton.setFixedWidth(100) enterButton.clicked.connect(self.searchLineEntered) commandLayout1.addWidget(enterButton) commandLayout1.addStretch() commandBox.addLayout(commandLayout1) commandLayout2 = QBoxLayout(QBoxLayout.LeftToRight) commandLayout2.setSpacing(5) keys = [ '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', ':', '-', ',', '.', ' ', '<', 'X' ] for key in keys: button = QPushButton(key) button.setMaximumWidth(30) button.clicked.connect(partial(self.keyEntryAction, key)) commandLayout2.addWidget(button) commandLayout2.addStretch() commandBox.addLayout(commandLayout2) if config.isTtsInstalled: ttsLayout = QBoxLayout(QBoxLayout.LeftToRight) ttsLayout.setSpacing(5) self.languageCombo = QComboBox() ttsLayout.addWidget(self.languageCombo) if config.espeak: languages = TtsLanguages().isoLang2epeakLang else: languages = TtsLanguages().isoLang2qlocaleLang self.languageCodes = list(languages.keys()) for code in self.languageCodes: self.languageCombo.addItem(languages[code][1]) # Check if selected tts engine has the language user specify. if not (config.ttsDefaultLangauge in self.languageCodes): config.ttsDefaultLangauge = "en" # Set initial item initialIndex = self.languageCodes.index(config.ttsDefaultLangauge) self.languageCombo.setCurrentIndex(initialIndex) # setting tts default language here is confusing; better place in menu #setDefaultButton = QPushButton(config.thisTranslation["setDefault"]) #setDefaultButton.setFixedWidth(130) #setDefaultButton.clicked.connect(self.setTtsDefaultLanguage) #ttsLayout.addWidget(setDefaultButton) speakButton = QPushButton(config.thisTranslation["speak"]) speakButton.setFixedWidth(100) speakButton.clicked.connect(self.speakCommandFieldText) ttsLayout.addWidget(speakButton) stopButton = QPushButton(config.thisTranslation["stop"]) stopButton.setFixedWidth(100) stopButton.clicked.connect( self.parent.textCommandParser.stopTtsAudio) ttsLayout.addWidget(stopButton) ttsLayout.addStretch() commandBox.addLayout(ttsLayout) commandBar.setLayout(commandBox) mainLayout.addWidget(commandBar, 0, 0, Qt.AlignCenter) self.tabs = QTabWidget() self.tabs.currentChanged.connect(self.tabChanged) mainLayout.addWidget(self.tabs, 1, 0, Qt.AlignCenter) parser = BibleVerseParser(config.parserStandarisation) self.bookMap = parser.standardAbbreviation bookNums = list(self.bookMap.keys()) bookNumGps = [ bookNums[0:10], bookNums[10:20], bookNums[20:30], bookNums[30:39], bookNums[39:49], bookNums[49:59], bookNums[59:66], ] bible = QWidget() bible_layout = QVBoxLayout() bible_layout.setMargin(0) bible_layout.setSpacing(0) for bookNumGp in bookNumGps[0:5]: gp = QWidget() layout = self.newRowLayout() for bookNum in bookNumGp: text = self.bookMap[bookNum] button = QPushButton(text) button.clicked.connect(partial(self.bibleBookAction, bookNum)) layout.addWidget(button) gp.setLayout(layout) bible_layout.addWidget(gp) for bookNumGp in bookNumGps[5:]: gp = QWidget() layout = self.newRowLayout() for bookNum in bookNumGp: text = self.bookMap[bookNum] button = QPushButton(text) button.clicked.connect(partial(self.bibleBookAction, bookNum)) layout.addWidget(button) gp.setLayout(layout) bible_layout.addWidget(gp) bible_layout.addStretch() bible.setLayout(bible_layout) self.tabs.addTab(bible, config.thisTranslation["bible"]) bibles_box = QWidget() box_layout = QVBoxLayout() box_layout.setMargin(0) box_layout.setSpacing(0) row_layout = self.newRowLayout() biblesSqlite = BiblesSqlite() bibles = biblesSqlite.getBibleList() count = 0 for bible in bibles: button = QPushButton(bible) button.clicked.connect(partial(self.bibleAction, bible)) row_layout.addWidget(button) count += 1 if count > 6: count = 0 box_layout.addLayout(row_layout) row_layout = self.newRowLayout() box_layout.addLayout(row_layout) box_layout.addStretch() bibles_box.setLayout(box_layout) self.tabs.addTab(bibles_box, config.thisTranslation["translations"]) commentaries_box = QWidget() box_layout = QVBoxLayout() box_layout.setMargin(0) box_layout.setSpacing(0) row_layout = self.newRowLayout() commentaries = Commentary().getCommentaryList() count = 0 for commentary in commentaries: button = QPushButton(commentary) button.clicked.connect(partial(self.commentaryAction, commentary)) row_layout.addWidget(button) count += 1 if count > 6: count = 0 box_layout.addLayout(row_layout) row_layout = self.newRowLayout() box_layout.addLayout(row_layout) box_layout.addStretch() commentaries_box.setLayout(box_layout) self.tabs.addTab(commentaries_box, config.thisTranslation["commentaries"]) lexicons_box = QWidget() box_layout = QVBoxLayout() box_layout.setMargin(0) box_layout.setSpacing(0) row_layout = self.newRowLayout() lexicons = LexiconData().lexiconList count = 0 for lexicon in lexicons: button = QPushButton(lexicon) button.clicked.connect(partial(self.lexiconAction, lexicon)) row_layout.addWidget(button) count += 1 if count > 6: count = 0 box_layout.addLayout(row_layout) row_layout = self.newRowLayout() box_layout.addLayout(row_layout) box_layout.addStretch() lexicons_box.setLayout(box_layout) self.tabs.addTab(lexicons_box, config.thisTranslation["lexicons"]) dictionaries_box = QWidget() box_layout = QVBoxLayout() box_layout.setMargin(0) box_layout.setSpacing(0) row_layout = self.newRowLayout() dictionaries = IndexesSqlite().dictionaryList count = 0 for dictionary in dictionaries: button = QPushButton(dictionary[0]) button.setToolTip(dictionary[1]) button.clicked.connect( partial(self.dictionaryAction, dictionary[0])) row_layout.addWidget(button) count += 1 if count > 6: count = 0 box_layout.addLayout(row_layout) row_layout = self.newRowLayout() box_layout.addLayout(row_layout) box_layout.addStretch() dictionaries_box.setLayout(box_layout) self.tabs.addTab(dictionaries_box, config.thisTranslation["dictionaries"]) self.tabs.setCurrentIndex(config.miniControlInitialTab) self.setLayout(mainLayout) def newRowLayout(self): row_layout = QHBoxLayout() row_layout.setSpacing(0) row_layout.setMargin(0) return row_layout def tabChanged(self, index): prefix = "" if index == 0: prefix = "BIBLE:::{0}:::".format(config.mainText) elif index == 1: prefix = "TEXT:::" elif index == 2: prefix = "COMMENTARY:::{0}:::".format(config.commentaryText) elif index == 3: prefix = "LEXICON:::" elif index == 4: prefix = "SEARCHTOOL:::" if not config.clearCommandEntry: self.searchLineEdit.setText(prefix) def searchLineEntered(self): searchString = self.searchLineEdit.text() self.parent.textCommandLineEdit.setText(searchString) self.parent.runTextCommand(searchString) self.searchLineEdit.setFocus() #def setTtsDefaultLanguage(self): #config.ttsDefaultLangauge = self.languageCodes[self.languageCombo.currentIndex()] def speakCommandFieldText(self): text = self.searchLineEdit.text() if ":::" in text: text = text.split(":::")[-1] command = "SPEAK:::{0}:::{1}".format( self.languageCodes[self.languageCombo.currentIndex()], text) self.runCommmand(command) def bibleBookAction(self, book): command = "{0} ".format(self.bookMap[book]) self.runCommmand(command) self.searchLineEdit.setFocus() def keyEntryAction(self, key): text = self.searchLineEdit.text() if key == "X": text = "" elif key == "<": text = text[:-1] else: text += key self.searchLineEdit.setText(text) def bibleAction(self, bible): command = "BIBLE:::{0}:::{1}".format( bible, self.parent.verseReference("main")[1]) self.runCommmand(command) command = "_bibleinfo:::{0}".format(bible) self.parent.runTextCommand(command) def commentaryAction(self, commentary): command = "COMMENTARY:::{0}:::{1}".format( commentary, self.parent.verseReference("main")[1]) self.runCommmand(command) command = "_commentaryinfo:::{0}".format(commentary) self.parent.runTextCommand(command) def lexiconAction(self, lexicon): command = "LEXICON:::{0}:::{1}".format( lexicon, TextCommandParser.last_lexicon_entry) self.runCommmand(command) def dictionaryAction(self, dictionary): command = "SEARCHTOOL:::{0}:::{1}".format( dictionary, TextCommandParser.last_text_search) self.runCommmand(command) def runCommmand(self, command): self.searchLineEdit.setText(command) self.parent.runTextCommand(command) self.parent.textCommandLineEdit.setText(command)
class MasterControl(QWidget): def __init__(self, parent, initialTab=0, b=config.mainB, c=config.mainC, v=config.mainV, text=config.mainText): super().__init__() self.isRefreshing = True self.parent = parent # set title self.setWindowTitle(config.thisTranslation["controlPanel"]) if config.restrictControlPanelWidth and config.screenWidth > config.masterControlWidth: self.setFixedWidth(config.masterControlWidth) # setup item option lists self.setupResourceLists() # setup interface self.text = text self.setupUI(b, c, v, text, initialTab) # setup keyboard shortcuts self.setupKeyboardShortcuts() self.isRefreshing = False def setupKeyboardShortcuts(self): for index, shortcut in enumerate( (sc.openControlPanelTab0, sc.openControlPanelTab1, sc.openControlPanelTab2, sc.openControlPanelTab3, sc.openControlPanelTab4, sc.openControlPanelTab5)): shortcut = QShortcut(QKeySequence(shortcut), self) shortcut.activated.connect( lambda index=index: self.tabs.setCurrentIndex(index)) # manage key capture def event(self, event): if event.type() == QEvent.KeyRelease: if event.key() == Qt.Key_Escape: self.hide() if isinstance(event, QEvent): return QWidget.event(self, event) def closeEvent(self, event): # Control panel is designed for frequent use # Hiding it instead of closing may save time from reloading event.ignore() self.hide() def setupResourceLists(self): self.parent.setupResourceLists() # bible versions self.textList = self.parent.textList self.textFullNameList = self.parent.textFullNameList self.strongBibles = self.parent.strongBibles if self.parent.versionCombo is not None and config.menuLayout in ( "classic", "focus", "aleph"): for index, fullName in enumerate(self.textFullNameList): self.parent.versionCombo.setItemData(index, fullName, Qt.ToolTipRole) # commentaries self.commentaryList = self.parent.commentaryList #self.commentaryFullNameList = [Commentary(module).commentaryInfo() for module in self.commentaryList] self.commentaryFullNameList = self.parent.commentaryFullNameList # reference book # menu10_dialog self.referenceBookList = self.parent.referenceBookList # topic # menu5_topics self.topicListAbb = self.parent.topicListAbb self.topicList = self.parent.topicList # lexicon # context1_originalLexicon self.lexiconList = self.parent.lexiconList # dictionary # context1_dict self.dictionaryListAbb = self.parent.dictionaryListAbb self.dictionaryList = self.parent.dictionaryList # encyclopedia # context1_encyclopedia self.encyclopediaListAbb = self.parent.encyclopediaListAbb self.encyclopediaList = self.parent.encyclopediaList # 3rd-party dictionary # menu5_3rdDict self.thirdPartyDictionaryList = self.parent.thirdPartyDictionaryList # pdf list self.pdfList = self.parent.pdfList # docx list self.docxList = self.parent.docxList def setupUI(self, b, c, v, text, initialTab): mainLayout = QVBoxLayout() mainLayout.addWidget(self.sharedWidget()) mainLayout.addWidget(self.tabWidget(b, c, v, text, initialTab)) self.setLayout(mainLayout) def sharedWidget(self): sharedWidget = QWidget() sharedWidgetLayout = QVBoxLayout() subLayout = QHBoxLayout() subLayout.addWidget(self.commandFieldWidget()) subLayout.addWidget(self.autoCloseCheckBox()) sharedWidgetLayout.addLayout(subLayout) sharedWidget.setLayout(sharedWidgetLayout) return sharedWidget def updateBibleTabText(self, reference): self.tabs.setTabText(0, reference) def tabWidget(self, b, c, v, text, initialTab): self.tabs = QTabWidget() # 0 self.bibleTab = BibleExplorer(self, (b, c, v, text)) self.tabs.addTab(self.bibleTab, config.thisTranslation["cp0"]) self.tabs.setTabToolTip(0, sc.openControlPanelTab0) # 1 libraryTab1 = LibraryLauncher(self) self.tabs.addTab(libraryTab1, config.thisTranslation["cp1"]) self.tabs.setTabToolTip(1, sc.openControlPanelTab1) # 2 libraryTab2 = Library2Launcher(self) self.tabs.addTab(libraryTab2, config.thisTranslation["cp2"]) self.tabs.setTabToolTip(2, sc.openControlPanelTab2) # 3 self.toolTab = SearchLauncher(self) self.tabs.addTab(self.toolTab, config.thisTranslation["cp3"]) self.tabs.setTabToolTip(3, sc.openControlPanelTab3) # 4 self.historyTab = HistoryLauncher(self) self.tabs.addTab(self.historyTab, config.thisTranslation["cp4"]) self.tabs.setTabToolTip(4, sc.openControlPanelTab4) # 5 self.miscellaneousTab = MiscellaneousLauncher(self) self.tabs.addTab(self.miscellaneousTab, config.thisTranslation["cp5"]) self.tabs.setTabToolTip(5, sc.openControlPanelTab5) # 6 if config.isVlcInstalled: mediaTab = MediaLauncher(self) self.tabs.addTab(mediaTab, config.thisTranslation["mediaPlayer"]) self.tabs.setTabToolTip(6, sc.openControlPanelTab6) #7 self.morphologyTab = MorphologyLauncher(self) self.tabs.addTab(self.morphologyTab, config.thisTranslation["cp7"]) self.tabs.setTabToolTip(7, sc.openControlPanelTab7) # set action with changing tabs self.tabs.currentChanged.connect(self.tabChanged) # set initial tab self.tabs.setCurrentIndex(initialTab) return self.tabs def commandFieldWidget(self): self.commandField = QLineEdit() self.commandField.setClearButtonEnabled(True) self.commandField.setToolTip( config.thisTranslation["enter_command_here"]) self.commandField.returnPressed.connect(self.commandEntered) return self.commandField def autoCloseCheckBox(self): checkbox = QCheckBox() checkbox.setText(config.thisTranslation["autoClose"]) checkbox.setToolTip(config.thisTranslation["autoCloseToolTip"]) checkbox.setChecked(config.closeControlPanelAfterRunningCommand) checkbox.stateChanged.connect( self.closeControlPanelAfterRunningCommandChanged) return checkbox # Common layout def buttonsWidget(self, buttonElementTupleTuple, r2l=False, translation=True): buttons = QWidget() buttonsLayouts = QVBoxLayout() buttonsLayouts.setSpacing(3) for buttonElementTuple in buttonElementTupleTuple: buttonsLayouts.addLayout( self.buttonsLayout(buttonElementTuple, r2l, translation)) buttons.setLayout(buttonsLayouts) return buttons def buttonsLayout(self, buttonElementTuple, r2l=False, translation=True): buttonsLayout = QBoxLayout( QBoxLayout.RightToLeft if r2l else QBoxLayout.LeftToRight) buttonsLayout.setSpacing(5) for label, action in buttonElementTuple: buttonLabel = config.thisTranslation[ label] if translation else label button = QPushButton(buttonLabel) button.clicked.connect(action) buttonsLayout.addWidget(button) return buttonsLayout def comboFeatureLayout(self, feature, combo, action): # QGridLayout: https://stackoverflow.com/questions/61451279/how-does-setcolumnstretch-and-setrowstretch-works layout = QGridLayout() layout.setSpacing(5) # combo layout.addWidget(combo, 0, 0, 1, 3) # button button = QPushButton(config.thisTranslation[feature]) button.clicked.connect(action) layout.addWidget(button, 0, 3, 1, 1) return layout # Actions def closeControlPanelAfterRunningCommandChanged(self): config.closeControlPanelAfterRunningCommand = not config.closeControlPanelAfterRunningCommand def updateBCVText(self, b, c, v, text): self.bibleTab.updateBCVText(b, c, v, text) def commandEntered(self): command = self.commandField.text() self.runTextCommand(command, False) def runTextCommand(self, command, printCommand=True, reloadMainWindow=False): if printCommand: self.commandField.setText(command) self.parent.textCommandLineEdit.setText(command) self.parent.runTextCommand(command) if reloadMainWindow: self.parent.reloadCurrentRecord() if config.closeControlPanelAfterRunningCommand and not self.isRefreshing: self.hide() def tabChanged(self, index): self.isRefreshing = True # refresh content if index == 4: self.historyTab.refresh() elif index == 5: self.miscellaneousTab.refresh() # set focus if index == 3: self.toolTab.searchField.setFocus() if config.contextItem: self.toolTab.searchField.setText(config.contextItem) config.contextItem = "" elif self.parent.mainView.currentWidget().selectedText(): self.toolTab.searchField.setText( self.parent.mainView.currentWidget().selectedText()) elif self.parent.studyView.currentWidget().selectedText(): self.toolTab.searchField.setText( self.parent.studyView.currentWidget().selectedText()) else: self.commandField.setFocus() self.isRefreshing = False def displayMessage(self, message="", title="UniqueBible"): reply = QMessageBox.information(self, title, message)