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)
