class PipOutput(QDialog):
def __init__(self, parent=None):
super(PipOutput, self).__init__(parent)
self.create_controls()
def sizeHint(self):
def_sz = super(PipOutput, self).sizeHint()
def_sz.setWidth(500)
return def_sz
def create_controls(self):
self.setWindowTitle(tr("Updating via pip"))
wFlags = self.windowFlags()
if Qt.WindowCloseButtonHint == (wFlags & Qt.WindowCloseButtonHint):
wFlags ^= Qt.WindowCloseButtonHint
self.setWindowFlags(wFlags)
vbox = QVBoxLayout()
self.output = QTextEdit()
if self.parent() and hasattr(self.parent(), 'console'):
self.output.setFont(self.parent().console.font)
vbox.addWidget(self.output)
hbox = QHBoxLayout()
hbox.addStretch()
self.btn_close = QPushButton(tr("Close"))
self.btn_close.clicked.connect(self.accept)
self.btn_close.setEnabled(False)
hbox.addWidget(self.btn_close)
vbox.addLayout(hbox)
self.setLayout(vbox)
def keyPressEvent(self, event):
"""Reimplement Qt Method - Basic keypress event handler"""
event, text, key, ctrl, shift = restore_keyevent(event)
if key == Qt.Key_ParenLeft and not self.has_selected_text() and self.help_enabled:
self._key_paren_left(text)
else:
# Let the parent widget handle the key press event
QTextEdit.keyPressEvent(self, event)
def __init__(self, parent=None):
QTextEdit.__init__(self, parent)
BaseEditMixin.__init__(self)
TracebackLinksMixin.__init__(self)
GetHelpMixin.__init__(self)
self.calltip_widget = CallTipWidget(self, hide_timer_on=True)
self.found_results = []
# To not use Spyder calltips obtained through the monitor
self.calltips = False
class TextView(View):
title = "Text"
supported_types = ("text",)
def __init__(self, data_object):
super(TextView, self).__init__(data_object)
def create_widget(self, parent=None):
self.text_widget = QTextEdit(parent)
self.text_widget.setReadOnly(True)
do = self.data_object.convert("text")
self.text_widget.setText(do.inner_data)
return self.text_widget
def showText(self):
"""
Creates a dialog to show the generated text output.
"""
try:
generatedText = self.genText()
except ValueError:
return
self.txtwin = QDialog()
self.txtedt = QTextEdit()
self.txtbtn = QPushButton('OK')
self.txtwin.layout = QVBoxLayout(self.txtwin)
self.txtwin.layout.addWidget(self.txtedt)
self.txtwin.layout.addWidget(self.txtbtn)
self.txtbtn.clicked.connect(self.txtwin.deleteLater)
self.txtedt.setText(generatedText)
self.txtedt.setReadOnly(True)
self.txtwin.setWindowTitle('Resolution information')
self.txtwin.setWindowModality(Qt.ApplicationModal)
self.txtwin.setAttribute(Qt.WA_DeleteOnClose)
self.txtwin.setMinimumSize(400, 600)
self.txtwin.resize(400, 600)
self.txtwin.show()
self.txtloop = QEventLoop()
self.txtloop.exec_()
def __init__(self, text, title='', font=None, parent=None,
readonly=False, size=(400, 300)):
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)
self.text = None
self.btn_save_and_close = None
# Display text as unicode if it comes as bytes, so users see
# its right representation
if is_binary_string(text):
self.is_binary = True
text = to_text_string(text, 'utf8')
else:
self.is_binary = False
self.layout = QVBoxLayout()
self.setLayout(self.layout)
# Text edit
self.edit = QTextEdit(parent)
self.edit.setReadOnly(readonly)
self.edit.textChanged.connect(self.text_changed)
self.edit.setPlainText(text)
if font is None:
font = get_font()
self.edit.setFont(font)
self.layout.addWidget(self.edit)
# Buttons configuration
btn_layout = QHBoxLayout()
btn_layout.addStretch()
if not readonly:
self.btn_save_and_close = QPushButton(_('Save and Close'))
self.btn_save_and_close.setDisabled(True)
self.btn_save_and_close.clicked.connect(self.accept)
btn_layout.addWidget(self.btn_save_and_close)
self.btn_close = QPushButton(_('Close'))
self.btn_close.setAutoDefault(True)
self.btn_close.setDefault(True)
self.btn_close.clicked.connect(self.reject)
btn_layout.addWidget(self.btn_close)
self.layout.addLayout(btn_layout)
# Make the dialog act as a window
self.setWindowFlags(Qt.Window)
self.setWindowIcon(ima.icon('edit'))
self.setWindowTitle(_("Text editor") + \
"%s" % (" - "+str(title) if str(title) else ""))
self.resize(size[0], size[1])
def create_controls(self):
self.setWindowTitle(tr("Updating via pip"))
wFlags = self.windowFlags()
if Qt.WindowCloseButtonHint == (wFlags & Qt.WindowCloseButtonHint):
wFlags ^= Qt.WindowCloseButtonHint
self.setWindowFlags(wFlags)
vbox = QVBoxLayout()
self.output = QTextEdit()
if self.parent() and hasattr(self.parent(), 'console'):
self.output.setFont(self.parent().console.font)
vbox.addWidget(self.output)
hbox = QHBoxLayout()
hbox.addStretch()
self.btn_close = QPushButton(tr("Close"))
self.btn_close.clicked.connect(self.accept)
self.btn_close.setEnabled(False)
hbox.addWidget(self.btn_close)
vbox.addLayout(hbox)
self.setLayout(vbox)
def fill_mantid(self):
self.row_height = 62
o_step1_handler = Step1Utilities(main_window=self.parent.parent)
o_step2_handler = Step2Utilities(parent=self.parent.parent)
# vanadium
_row = 0
self.parent.ui.table_status.insertRow(_row)
self.parent.ui.table_status.setRowHeight(_row, self.row_height)
_widget = QTextEdit()
_text = "Vanadium Field Empty?<br/><b>AutoNom>Vanadium</b>"
_widget.setHtml(_text)
if o_step1_handler.is_vanadium_text_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(_row, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step1_handler.is_vanadium_text_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step1_vanadium)
self.parent.ui.table_status.setCellWidget(_row, 1, _widget_2)
# vanadium background
_row = 1
self.parent.ui.table_status.insertRow(_row)
self.parent.ui.table_status.setRowHeight(_row, self.row_height)
_widget = QTextEdit()
_text = "Vanadium Background Field Empty?<br/><b>AutoNom>Vanadium Background</b>"
_widget.setHtml(_text)
if o_step1_handler.is_vanadium_background_text_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(_row, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step1_handler.is_vanadium_background_text_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step1_vanadium_background)
self.parent.ui.table_status.setCellWidget(_row, 1, _widget_2)
# table status
_row = 2
self.parent.ui.table_status.insertRow(_row)
self.parent.ui.table_status.setRowHeight(_row, self.row_height)
_widget = QTextEdit()
_text = "Main Table Empty?<br/><b>Post Processing>Table</b>"
_widget.setHtml(_text)
if o_step2_handler.is_table_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(_row, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_table_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_table)
self.parent.ui.table_status.setCellWidget(_row, 1, _widget_2)
# at least one row checked
_row = 3
self.parent.ui.table_status.insertRow(_row)
self.parent.ui.table_status.setRowHeight(_row, self.row_height)
_widget = QTextEdit()
_text = "Main Table Row Selected?<br/><b>Post Processing>Table</b>"
_widget.setHtml(_text)
if o_step2_handler.at_least_one_row_checked():
_widget.setStyleSheet(self.widget_ok)
else:
_widget.setStyleSheet(self.widget_bad)
self.parent.ui.table_status.setCellWidget(_row, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(not o_step2_handler.at_least_one_row_checked())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_table)
self.parent.ui.table_status.setCellWidget(_row, 1, _widget_2)
# calibration
_row = 4
self.parent.ui.table_status.insertRow(_row)
self.parent.ui.table_status.setRowHeight(_row, self.row_height)
_widget = QTextEdit()
_text = "Calibration File Selected?<br/><b>Post Processing>Rietveld>Calibration</b>"
_widget.setHtml(_text)
if o_step2_handler.is_mantid_calibration_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(_row, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_mantid_calibration_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_mantid_browse_calibration)
self.parent.ui.table_status.setCellWidget(_row, 1, _widget_2)
# characterization
_row += 1
self.parent.ui.table_status.insertRow(_row)
self.parent.ui.table_status.setRowHeight(_row, self.row_height)
_widget = QTextEdit()
_text = "Characterization File Selected?<br/><b>Post Processing>Rietveld>Characterization</b>"
_widget.setHtml(_text)
if o_step2_handler.is_mantid_characterization_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(_row, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_mantid_characterization_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_mantid_browse_characterization)
self.parent.ui.table_status.setCellWidget(_row, 1, _widget_2)
# number of bins int
_row += 1
self.parent.ui.table_status.insertRow(_row)
self.parent.ui.table_status.setRowHeight(_row, self.row_height)
_widget = QTextEdit()
_text = "Is Number of Bins an Int?<br/><b>Post Processing>Rietveld>Number of Bins</b>"
_widget.setHtml(_text)
if o_step2_handler.is_mantid_number_of_bins_no_int():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(_row, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_mantid_number_of_bins_no_int())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_mantid_number_of_bins)
self.parent.ui.table_status.setCellWidget(_row, 1, _widget_2)
# min crop wavelegenth
_row += 1
self.parent.ui.table_status.insertRow(_row)
self.parent.ui.table_status.setRowHeight(_row, self.row_height)
_widget = QTextEdit()
_text = "Is min Crop Wavelength a float?<br/><b>Post Processing>Rietveld>Crop Wavelength Min</b>"
_widget.setHtml(_text)
if o_step2_handler.is_mantid_min_crop_wavelength_no_float():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(_row, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_mantid_min_crop_wavelength_no_float())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_mantid_min_crop_wavelength)
self.parent.ui.table_status.setCellWidget(_row, 1, _widget_2)
# max crop wavelegenth
_row += 1
self.parent.ui.table_status.insertRow(_row)
self.parent.ui.table_status.setRowHeight(_row, self.row_height)
_widget = QTextEdit()
_text = "Is max Crop Wavelength a float?<br/><b>Post Processing>Rietveld>Crop Wavelength Max</b>"
_widget.setHtml(_text)
if o_step2_handler.is_mantid_max_crop_wavelength_no_float():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(_row, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_mantid_max_crop_wavelength_no_float())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_mantid_max_crop_wavelength)
self.parent.ui.table_status.setCellWidget(_row, 1, _widget_2)
# vanadium radius
_row += 1
self.parent.ui.table_status.insertRow(_row)
self.parent.ui.table_status.setRowHeight(_row, self.row_height)
_widget = QTextEdit()
_text = "Is Vanadium Radius a float?<br/><b>Post Processing>Rietveld>Vanadium Radius</b>"
_widget.setHtml(_text)
if o_step2_handler.is_mantid_vanadium_radius_not_float():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(_row, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_mantid_vanadium_radius_not_float())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_mantid_vanadium_radius)
self.parent.ui.table_status.setCellWidget(_row, 1, _widget_2)
# output directory
_row += 1
self.parent.ui.table_status.insertRow(_row)
self.parent.ui.table_status.setRowHeight(_row, self.row_height)
_widget = QTextEdit()
_text = "Is Output Directory Empty?<br/><b>Post Processing>Rietveld>Output Directory</b>"
_widget.setHtml(_text)
if o_step2_handler.is_mantid_output_directory_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(_row, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_mantid_output_directory_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_mantid_output_directory_button)
self.parent.ui.table_status.setCellWidget(_row, 1, _widget_2)
def fill_scans(self):
o_step2_handler = Step2Utilities(parent=self.parent.parent)
# table status
self.parent.ui.table_status.insertRow(0)
self.parent.ui.table_status.setRowHeight(0, self.row_height)
_widget = QTextEdit()
_text = "Main Table Empty?<br/><b>Post Processing>Table</b>"
_widget.setHtml(_text)
if o_step2_handler.is_table_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(0, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_table_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_table)
self.parent.ui.table_status.setCellWidget(0, 1, _widget_2)
# at least one row checked
self.parent.ui.table_status.insertRow(1)
self.parent.ui.table_status.setRowHeight(1, self.row_height)
_widget = QTextEdit()
_text = "Main Table Row Selected?<br/><b>Post Processing>Table</b>"
_widget.setHtml(_text)
if o_step2_handler.at_least_one_row_checked():
_widget.setStyleSheet(self.widget_ok)
else:
_widget.setStyleSheet(self.widget_bad)
self.parent.ui.table_status.setCellWidget(1, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(not o_step2_handler.at_least_one_row_checked())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_table)
self.parent.ui.table_status.setCellWidget(1, 1, _widget_2)
# output file name
self.parent.ui.table_status.insertRow(2)
self.parent.ui.table_status.setRowHeight(2, self.row_height)
_widget = QTextEdit()
_text = "Output File Name?<br/><b>Post Processing>Output File Name</b>"
_widget.setHtml(_text)
if not o_step2_handler.is_scans_output_file_name_empty():
_widget.setStyleSheet(self.widget_ok)
else:
_widget.setStyleSheet(self.widget_bad)
self.parent.ui.table_status.setCellWidget(2, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_scans_output_file_name_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_scans_output_file_name)
self.parent.ui.table_status.setCellWidget(2, 1, _widget_2)
class TextEditor(QDialog):
"""Array Editor Dialog"""
def __init__(self, text, title='', font=None, parent=None,
readonly=False, size=(400, 300)):
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)
self.text = None
self.btn_save_and_close = None
# Display text as unicode if it comes as bytes, so users see
# its right representation
if is_binary_string(text):
self.is_binary = True
text = to_text_string(text, 'utf8')
else:
self.is_binary = False
self.layout = QVBoxLayout()
self.setLayout(self.layout)
# Text edit
self.edit = QTextEdit(parent)
self.edit.setReadOnly(readonly)
self.edit.textChanged.connect(self.text_changed)
self.edit.setPlainText(text)
if font is None:
font = get_font()
self.edit.setFont(font)
self.layout.addWidget(self.edit)
# Buttons configuration
btn_layout = QHBoxLayout()
btn_layout.addStretch()
if not readonly:
self.btn_save_and_close = QPushButton(_('Save and Close'))
self.btn_save_and_close.setDisabled(True)
self.btn_save_and_close.clicked.connect(self.accept)
btn_layout.addWidget(self.btn_save_and_close)
self.btn_close = QPushButton(_('Close'))
self.btn_close.setAutoDefault(True)
self.btn_close.setDefault(True)
self.btn_close.clicked.connect(self.reject)
btn_layout.addWidget(self.btn_close)
self.layout.addLayout(btn_layout)
# Make the dialog act as a window
self.setWindowFlags(Qt.Window)
self.setWindowIcon(ima.icon('edit'))
self.setWindowTitle(_("Text editor") + \
"%s" % (" - "+str(title) if str(title) else ""))
self.resize(size[0], size[1])
@Slot()
def text_changed(self):
"""Text has changed"""
# Save text as bytes, if it was initially bytes
if self.is_binary:
self.text = to_binary_string(self.edit.toPlainText(), 'utf8')
else:
self.text = to_text_string(self.edit.toPlainText())
if self.btn_save_and_close:
self.btn_save_and_close.setEnabled(True)
self.btn_save_and_close.setAutoDefault(True)
self.btn_save_and_close.setDefault(True)
def get_value(self):
"""Return modified text"""
# 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.text
def setup_and_check(self, value):
"""Verify if TextEditor is able to display strings passed to it."""
try:
to_text_string(value, 'utf8')
return True
except:
return False
def __init__(
self,
plugin_manager: Optional[PluginManager] = None,
*,
parent: Optional[QWidget] = None,
initial_plugin: Optional[str] = None,
) -> None:
super().__init__(parent)
if not plugin_manager:
from ...plugins import plugin_manager as _pm
self.plugin_manager = _pm
else:
self.plugin_manager = plugin_manager
self.setWindowTitle(trans._('Recorded Plugin Exceptions'))
self.setWindowModality(Qt.NonModal)
self.layout = QVBoxLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(10, 10, 10, 10)
self.setLayout(self.layout)
self.text_area = QTextEdit()
self.text_area.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.text_area.setMinimumWidth(360)
# Create plugin dropdown menu
self.plugin_combo = QComboBox()
self.plugin_combo.addItem(self.NULL_OPTION)
bad_plugins = [e.plugin_name for e in self.plugin_manager.get_errors()]
self.plugin_combo.addItems(list(sorted(set(bad_plugins))))
self.plugin_combo.currentTextChanged.connect(self.set_plugin)
self.plugin_combo.setCurrentText(self.NULL_OPTION)
# create github button (gets connected in self.set_plugin)
self.github_button = QPushButton(trans._('Open issue on GitHub'), self)
self.github_button.setToolTip(
trans._("Open a web browser to submit this error log\n"
"to the developer's GitHub issue tracker"))
self.github_button.hide()
# create copy to clipboard button
self.clipboard_button = QPushButton()
self.clipboard_button.hide()
self.clipboard_button.setObjectName("QtCopyToClipboardButton")
self.clipboard_button.setToolTip(
trans._("Copy error log to clipboard"))
self.clipboard_button.clicked.connect(self.copyToClipboard)
# plugin_meta contains a URL to the home page, (and/or other details)
self.plugin_meta = QLabel('', parent=self)
self.plugin_meta.setObjectName("pluginInfo")
self.plugin_meta.setTextFormat(Qt.RichText)
self.plugin_meta.setTextInteractionFlags(Qt.TextBrowserInteraction)
self.plugin_meta.setOpenExternalLinks(True)
self.plugin_meta.setAlignment(Qt.AlignRight)
# make layout
row_1_layout = QHBoxLayout()
row_1_layout.setContentsMargins(11, 5, 10, 0)
row_1_layout.addStretch(1)
row_1_layout.addWidget(self.plugin_meta)
row_2_layout = QHBoxLayout()
row_2_layout.setContentsMargins(11, 5, 10, 0)
row_2_layout.addWidget(self.plugin_combo)
row_2_layout.addStretch(1)
row_2_layout.addWidget(self.github_button)
row_2_layout.addWidget(self.clipboard_button)
row_2_layout.setSpacing(5)
self.layout.addLayout(row_1_layout)
self.layout.addLayout(row_2_layout)
self.layout.addWidget(self.text_area, 1)
self.setMinimumWidth(750)
self.setMinimumHeight(600)
if initial_plugin:
self.set_plugin(initial_plugin)
def mousePressEvent(self, event):
"""called when you click a result"""
if event.button() == Qt.RightButton:
pass
else:
QTextEdit.mousePressEvent(self, event)
class QtAbout(QDialog):
def __init__(self):
super().__init__()
self.layout = QVBoxLayout()
# Description
title_label = QLabel(
"<b>napari: a multi-dimensional image viewer for python</b>")
title_label.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.layout.addWidget(title_label)
# Add information
self.infoTextBox = QTextEdit()
self.infoTextBox.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.infoTextBox.setLineWrapMode(QTextEdit.NoWrap)
# Add text copy button
self.infoCopyButton = QtCopyToClipboardButton(self.infoTextBox)
self.info_layout = QHBoxLayout()
self.info_layout.addWidget(self.infoTextBox, 1)
self.info_layout.addWidget(self.infoCopyButton, 0, Qt.AlignTop)
self.info_layout.setAlignment(Qt.AlignTop)
self.layout.addLayout(self.info_layout)
self.infoTextBox.setText(sys_info(as_html=True))
self.infoTextBox.setMinimumSize(
self.infoTextBox.document().size().width() + 19,
self.infoTextBox.document().size().height() + 10,
)
self.layout.addWidget(QLabel('<b>citation information:</b>'))
self.citationTextBox = QTextEdit(citation_text)
self.citationTextBox.setFixedHeight(64)
self.citationCopyButton = QtCopyToClipboardButton(self.citationTextBox)
self.citation_layout = QHBoxLayout()
self.citation_layout.addWidget(self.citationTextBox, 1)
self.citation_layout.addWidget(self.citationCopyButton, 0, Qt.AlignTop)
self.layout.addLayout(self.citation_layout)
self.setLayout(self.layout)
@staticmethod
def showAbout(qt_viewer):
d = QtAbout()
d.setObjectName('QtAbout')
d.setStyleSheet(qt_viewer.styleSheet())
d.setWindowTitle('About')
d.setWindowModality(Qt.ApplicationModal)
d.exec_()
class PackagesDialog(DialogBase):
"""Package dependencies dialog."""
sig_setup_ready = Signal()
def __init__(
self,
parent=None,
packages=None,
pip_packages=None,
remove_only=False,
update_only=False,
):
"""About dialog."""
super(PackagesDialog, self).__init__(parent=parent)
# Variables
self.api = AnacondaAPI()
self.actions = None
self.packages = packages or []
self.pip_packages = pip_packages or []
# Widgets
self.stack = QStackedWidget()
self.table = QTableWidget()
self.text = QTextEdit()
self.label_description = LabelBase()
self.label_status = LabelBase()
self.progress_bar = QProgressBar()
self.button_ok = ButtonPrimary('Apply')
self.button_cancel = ButtonNormal('Cancel')
# Widget setup
self.text.setReadOnly(True)
self.stack.addWidget(self.table)
self.stack.addWidget(self.text)
if remove_only:
text = 'The following packages will be removed:<br>'
else:
text = 'The following packages will be modified:<br>'
self.label_description.setText(text)
self.label_description.setWordWrap(True)
self.label_description.setWordWrap(True)
self.label_status.setWordWrap(True)
self.table.horizontalScrollBar().setVisible(False)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setAlternatingRowColors(True)
self.table.setSelectionMode(QAbstractItemView.NoSelection)
self.table.setSortingEnabled(True)
self._hheader = self.table.horizontalHeader()
self._vheader = self.table.verticalHeader()
self._hheader.setStretchLastSection(True)
self._hheader.setDefaultAlignment(Qt.AlignLeft)
self._hheader.setSectionResizeMode(self._hheader.Fixed)
self._vheader.setSectionResizeMode(self._vheader.Fixed)
self.button_ok.setMinimumWidth(70)
self.button_ok.setDefault(True)
self.base_minimum_width = 300 if remove_only else 420
if remove_only:
self.setWindowTitle("Remove Packages")
elif update_only:
self.setWindowTitle("Update Packages")
else:
self.setWindowTitle("Install Packages")
self.setMinimumWidth(self.base_minimum_width)
# Layouts
layout_progress = QHBoxLayout()
layout_progress.addWidget(self.label_status)
layout_progress.addWidget(SpacerHorizontal())
layout_progress.addWidget(self.progress_bar)
layout_buttons = QHBoxLayout()
layout_buttons.addStretch()
layout_buttons.addWidget(self.button_cancel)
layout_buttons.addWidget(SpacerHorizontal())
layout_buttons.addWidget(self.button_ok)
layout = QVBoxLayout()
layout.addWidget(self.label_description)
layout.addWidget(SpacerVertical())
layout.addWidget(self.stack)
layout.addWidget(SpacerVertical())
layout.addLayout(layout_progress)
layout.addWidget(SpacerVertical())
layout.addWidget(SpacerVertical())
layout.addLayout(layout_buttons)
self.setLayout(layout)
# Signals
self.button_ok.clicked.connect(self.accept)
self.button_cancel.clicked.connect(self.reject)
self.button_ok.setDisabled(True)
# Setup
self.table.setDisabled(True)
self.update_status('Solving package specifications',
value=0,
max_value=0)
def setup(self, worker, output, error):
"""Setup the widget to include the list of dependencies."""
if not isinstance(output, dict):
output = {}
packages = sorted(pkg.split('==')[0] for pkg in self.packages)
success = output.get('success')
error = output.get('error', '')
exception_name = output.get('exception_name', '')
actions = output.get('actions', [])
prefix = worker.prefix
if exception_name:
message = exception_name
else:
# All requested packages already installed
message = output.get('message', ' ')
navi_deps_error = self.api.check_navigator_dependencies(
actions, prefix)
description = self.label_description.text()
if error:
description = 'No packages will be modified.'
self.stack.setCurrentIndex(1)
self.button_ok.setDisabled(True)
if self.api.is_offline():
error = ("Some of the functionality of Anaconda Navigator "
"will be limited in <b>offline mode</b>. <br><br>"
"Installation and upgrade actions will be subject to "
"the packages currently available on your package "
"cache.")
self.text.setText(error)
elif navi_deps_error:
description = 'No packages will be modified.'
error = ('Downgrading/removing these packages will modify '
'Anaconda Navigator dependencies.')
self.text.setText(error)
self.stack.setCurrentIndex(1)
message = 'NavigatorDependenciesError'
self.button_ok.setDisabled(True)
elif success and actions:
self.stack.setCurrentIndex(0)
# Conda 4.3.x
if isinstance(actions, list):
actions_link = actions[0].get('LINK', [])
actions_unlink = actions[0].get('UNLINK', [])
# Conda 4.4.x
else:
actions_link = actions.get('LINK', [])
actions_unlink = actions.get('UNLINK', [])
deps = set()
deps = deps.union({p['name'] for p in actions_link})
deps = deps.union({p['name'] for p in actions_unlink})
deps = deps - set(packages)
deps = sorted(list(deps))
count_total_packages = len(packages) + len(deps)
plural_total = 's' if count_total_packages != 1 else ''
plural_selected = 's' if len(packages) != 1 else ''
self.table.setRowCount(count_total_packages)
self.table.setColumnCount(4)
if actions_link:
description = '{0} package{1} will be installed'.format(
count_total_packages, plural_total)
self.table.showColumn(2)
self.table.showColumn(3)
elif actions_unlink and not actions_link:
self.table.hideColumn(2)
self.table.hideColumn(3)
self.table.setHorizontalHeaderLabels(
['Name', 'Unlink', 'Link', 'Channel'])
description = '{0} package{1} will be removed'.format(
count_total_packages, plural_total)
for row, pkg in enumerate(packages + deps):
link_item = [p for p in actions_link if p['name'] == pkg]
if not link_item:
link_item = {
'version': '-'.center(len('link')),
'channel': '-'.center(len('channel')),
}
else:
link_item = link_item[0]
unlink_item = [p for p in actions_unlink if p['name'] == pkg]
if not unlink_item:
unlink_item = {
'version': '-'.center(len('link')),
}
else:
unlink_item = unlink_item[0]
unlink_version = str(unlink_item['version'])
link_version = str(link_item['version'])
item_unlink_v = QTableWidgetItem(unlink_version)
item_link_v = QTableWidgetItem(link_version)
item_link_c = QTableWidgetItem(link_item['channel'])
if pkg in packages:
item_name = QTableWidgetItem(pkg)
else:
item_name = QTableWidgetItem('*' + pkg)
items = [item_name, item_unlink_v, item_link_v, item_link_c]
for column, item in enumerate(items):
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.table.setItem(row, column, item)
if deps:
message = (
'<b>*</b> indicates the package is a dependency of a '
'selected package{0}<br>').format(plural_selected)
self.button_ok.setEnabled(True)
self.table.resizeColumnsToContents()
unlink_width = self.table.columnWidth(1)
if unlink_width < 60:
self.table.setColumnWidth(1, 60)
self.table.setHorizontalHeaderLabels(
['Name ', 'Unlink ', 'Link ', 'Channel '])
self.table.setEnabled(True)
self.update_status(message=message)
self.label_description.setText(description)
# Adjust size after data has populated the table
self.table.resizeColumnsToContents()
width = sum(
self.table.columnWidth(i) for i in range(self.table.columnCount()))
delta = (self.width() - self.table.width() +
self.table.verticalHeader().width() + 10)
new_width = width + delta
if new_width < self.base_minimum_width:
new_width = self.base_minimum_width
self.setMinimumWidth(new_width)
self.setMaximumWidth(new_width)
self.sig_setup_ready.emit()
def update_status(self, message='', value=None, max_value=None):
"""Update status of packages dialog."""
self.label_status.setText(message)
if max_value is None and value is None:
self.progress_bar.setVisible(False)
else:
self.progress_bar.setVisible(True)
self.progress_bar.setMaximum(max_value)
self.progress_bar.setValue(value)
class PythonConsoleWidget(QDockWidget):
"""
original code pulled from:
http://stackoverflow.com/questions/31380457/add-right-click-functionality-to-listwidget-in-pyqt4
http://stackoverflow.com/questions/20951660/creating-a-syntax-highlighter-in-pythonpyqt4
http://eli.thegreenplace.net/2011/04/01/sample-using-qscintilla-with-pyqt
"""
def __init__(self, parent):
self.parent = parent
super(PythonConsoleWidget, self).__init__('Python Console',
parent=parent)
# I think this works by accident in qt4/5
#super(QDockWidget, self).__init__('Python Console', parent=parent)
#self.listMenu = QMenu()
self.execute_python_button = QPushButton('Execute')
self.execute_and_clear_python_button = QPushButton('Execute and Clear')
if is_pygments and IS_SCINTILLA:
#self.enter_data = QSyntaxHighlighting()
self.enter_data = SimplePythonEditorWidget()
else:
self.enter_data = QTextEdit()
font = QFont()
font.setFamily('Courier')
self.enter_data.setFont(font)
self.setup_connections()
self.layout()
def layout(self):
vbox = QVBoxLayout()
hbox = QHBoxLayout()
vbox.addWidget(self.enter_data)
hbox.addWidget(self.execute_python_button)
hbox.addWidget(self.execute_and_clear_python_button)
vbox.addLayout(hbox)
vbox_widget = QWidget()
vbox_widget.setLayout(vbox)
self.setWidget(vbox_widget)
def setup_connections(self):
self.execute_python_button.clicked.connect(
self.on_execute_python_button)
self.execute_and_clear_python_button.clicked.connect(
self.on_execute_and_clear_python_button)
#self.on_rig
# TODO: enables the right click menu
# messes up the previous right click menu
#self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
#self.connect(self, QtCore.SIGNAL("customContextMenuRequested(QPoint)"),
# self.listItemRightClicked)
#properties = self.listMenu.addAction("Properties...")
#select_all = self.listMenu.addAction("Select All")
#copy = self.listMenu.addAction("Copy")
#clear = self.listMenu.addAction("Clear...")
#properties.triggered.connect(self.on_properties)
#select_all.triggered.connect(self.on_select_all)
#copy.triggered.connect(self.on_copy)
#clear.triggered.connect(self.on_clear)
#self.connect(properties, QtCore.SIGNAL("triggered()"), self.on_properties)
#self.connect(select_all, QtCore.SIGNAL("triggered()"), self.on_select_all)
#self.connect(copy, QtCore.SIGNAL("triggered()"), self.on_copy)
# we have to create a QWidget to put the console vbox into vbox_widget because
# self.setLayout(vbox)
# is not supported in a QDockWidget
def on_execute_and_clear_python_button(self):
if self.parent is not None:
self.parent._on_execute_python_button(clear=True)
def on_execute_python_button(self):
if self.parent is not None:
self.parent._on_execute_python_button(clear=False)
def listItemRightClicked(self, QPos):
"""
TDOO: not done...
"""
return
class ImageInformation(QWidget):
def __init__(self, settings: StackSettings, parent=None):
""":type settings: ImageSettings"""
super().__init__(parent)
self._settings = settings
self.path = QTextEdit("<b>Path:</b> example image")
self.path.setWordWrapMode(QTextOption.WrapAnywhere)
self.path.setReadOnly(True)
self.setMinimumHeight(20)
self.spacing = [QDoubleSpinBox() for _ in range(3)]
self.multiple_files = QCheckBox("Show multiple files panel")
self.multiple_files.setChecked(
settings.get("multiple_files_widget", True))
self.multiple_files.stateChanged.connect(self.set_multiple_files)
units_value = self._settings.get("units_value", Units.nm)
for el in self.spacing:
el.setAlignment(Qt.AlignRight)
el.setButtonSymbols(QAbstractSpinBox.NoButtons)
el.setRange(0, 100000)
# noinspection PyUnresolvedReferences
el.valueChanged.connect(self.image_spacing_change)
self.units = QEnumComboBox(enum_class=Units)
self.units.setCurrentEnum(units_value)
# noinspection PyUnresolvedReferences
self.units.currentIndexChanged.connect(self.update_spacing)
self.add_files = AddFiles(settings, btn_layout=FlowLayout)
spacing_layout = QFormLayout()
spacing_layout.addRow("x:", self.spacing[0])
spacing_layout.addRow("y:", self.spacing[1])
spacing_layout.addRow("z:", self.spacing[2])
spacing_layout.addRow("Units:", self.units)
layout = QVBoxLayout()
layout.addWidget(self.path)
layout.addWidget(QLabel("Image spacing:"))
layout.addLayout(spacing_layout)
layout.addWidget(self.add_files)
layout.addStretch(1)
layout.addWidget(self.multiple_files)
self.setLayout(layout)
self._settings.image_changed[str].connect(self.set_image_path)
@Slot(int)
def set_multiple_files(self, val):
self._settings.set("multiple_files_widget", val)
def update_spacing(self, index=None):
units_value = self.units.currentEnum()
if index is not None:
self._settings.set("units_value", units_value)
for el, val in zip(self.spacing, self._settings.image_spacing[::-1]):
el.blockSignals(True)
el.setValue(val * UNIT_SCALE[units_value.value])
el.blockSignals(False)
if self._settings.is_image_2d():
# self.spacing[2].setValue(0)
self.spacing[2].setDisabled(True)
else:
self.spacing[2].setDisabled(False)
def set_image_path(self, value):
self.path.setText(f"<b>Path:</b> {value}")
self.update_spacing()
def image_spacing_change(self):
self._settings.image_spacing = [
el.value() / UNIT_SCALE[self.units.currentIndex()]
for i, el in enumerate(self.spacing[::-1])
]
def showEvent(self, _a0):
units_value = self._settings.get("units_value", Units.nm)
for el, val in zip(self.spacing, self._settings.image_spacing[::-1]):
el.setValue(val * UNIT_SCALE[units_value.value])
if self._settings.is_image_2d():
self.spacing[2].setValue(0)
self.spacing[2].setDisabled(True)
else:
self.spacing[2].setDisabled(False)
class TextEditor(BaseDialog):
"""Array Editor Dialog"""
def __init__(self, text, title='', font=None, parent=None, readonly=False):
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)
self.text = None
self.btn_save_and_close = None
# Display text as unicode if it comes as bytes, so users see
# its right representation
if is_binary_string(text):
self.is_binary = True
text = to_text_string(text, 'utf8')
else:
self.is_binary = False
self.layout = QVBoxLayout()
self.setLayout(self.layout)
# Text edit
self.edit = QTextEdit(parent)
self.edit.setReadOnly(readonly)
self.edit.textChanged.connect(self.text_changed)
self.edit.setPlainText(text)
if font is None:
font = get_font()
self.edit.setFont(font)
self.layout.addWidget(self.edit)
# Buttons configuration
btn_layout = QHBoxLayout()
btn_layout.addStretch()
if not readonly:
self.btn_save_and_close = QPushButton(_('Save and Close'))
self.btn_save_and_close.setDisabled(True)
self.btn_save_and_close.clicked.connect(self.accept)
btn_layout.addWidget(self.btn_save_and_close)
self.btn_close = QPushButton(_('Close'))
self.btn_close.setAutoDefault(True)
self.btn_close.setDefault(True)
self.btn_close.clicked.connect(self.reject)
btn_layout.addWidget(self.btn_close)
self.layout.addLayout(btn_layout)
# Make the dialog act as a window
if sys.platform == 'darwin':
# See spyder-ide/spyder#12825
self.setWindowFlags(Qt.Tool)
else:
# Make the dialog act as a window
self.setWindowFlags(Qt.Window)
self.setWindowIcon(ima.icon('edit'))
if title:
try:
unicode_title = to_text_string(title)
except UnicodeEncodeError:
unicode_title = u''
else:
unicode_title = u''
self.setWindowTitle(_("Text editor") + \
u"%s" % (u" - " + unicode_title
if unicode_title else u""))
@Slot()
def text_changed(self):
"""Text has changed"""
# Save text as bytes, if it was initially bytes
if self.is_binary:
self.text = to_binary_string(self.edit.toPlainText(), 'utf8')
else:
self.text = to_text_string(self.edit.toPlainText())
if self.btn_save_and_close:
self.btn_save_and_close.setEnabled(True)
self.btn_save_and_close.setAutoDefault(True)
self.btn_save_and_close.setDefault(True)
def get_value(self):
"""Return modified text"""
# 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.text
def setup_and_check(self, value):
"""Verify if TextEditor is able to display strings passed to it."""
try:
to_text_string(value, 'utf8')
return True
except:
return False
def test_qtbug35861(qtbot):
"""This test will detect if upstream QTBUG-35861 is fixed.
If that happens, then the workarounds for spyder-ide/spyder#12663
can be removed. Such a fix would probably only happen in the most
recent Qt version however...
See also https://bugreports.qt.io/browse/QTBUG-35861
"""
widget = QTextEdit(None)
qtbot.addWidget(widget)
widget.show()
cursor = widget.textCursor()
cursor.setPosition(0)
# Build the text from a single character since a non-fixed width
# font is used by default.
cursor.insertText("0000000000\n" * 5)
expected_column = 5
cursor.setPosition(expected_column)
widget.setTextCursor(cursor)
assert widget.textCursor().columnNumber() == expected_column
for line in range(4):
qtbot.keyClick(widget, Qt.Key_Backspace)
assert widget.textCursor().columnNumber() == (expected_column - 1)
qtbot.keyClick(widget, Qt.Key_Down)
assert widget.textCursor().columnNumber() == expected_column
for line in range(4):
qtbot.keyClick(widget, Qt.Key_Backspace)
assert widget.textCursor().columnNumber() == (expected_column - 1)
qtbot.keyClick(widget, Qt.Key_Up)
assert widget.textCursor().columnNumber() == expected_column
def setup_ui(self):
self.resize(1080, 640)
vlay_1 = QVBoxLayout(self)
self.h_splitter = QSplitter(self)
vlay_1.addWidget(self.h_splitter)
self.h_splitter.setOrientation(Qt.Horizontal)
self.v_splitter = QSplitter(self.h_splitter)
self.v_splitter.setOrientation(Qt.Vertical)
self.v_splitter.setMinimumWidth(500)
installed = QWidget(self.v_splitter)
lay = QVBoxLayout(installed)
lay.setContentsMargins(0, 2, 0, 2)
self.installed_label = QLabel(trans._("Installed Plugins"))
self.packages_filter = QLineEdit()
self.packages_filter.setPlaceholderText(trans._("filter..."))
self.packages_filter.setMaximumWidth(350)
self.packages_filter.setClearButtonEnabled(True)
mid_layout = QVBoxLayout()
mid_layout.addWidget(self.packages_filter)
mid_layout.addWidget(self.installed_label)
lay.addLayout(mid_layout)
self.installed_list = QPluginList(installed, self.installer)
self.packages_filter.textChanged.connect(self.installed_list.filter)
lay.addWidget(self.installed_list)
uninstalled = QWidget(self.v_splitter)
lay = QVBoxLayout(uninstalled)
lay.setContentsMargins(0, 2, 0, 2)
self.avail_label = QLabel(trans._("Available Plugins"))
mid_layout = QHBoxLayout()
mid_layout.addWidget(self.avail_label)
mid_layout.addStretch()
lay.addLayout(mid_layout)
self.available_list = QPluginList(uninstalled, self.installer)
self.packages_filter.textChanged.connect(self.available_list.filter)
lay.addWidget(self.available_list)
self.stdout_text = QTextEdit(self.v_splitter)
self.stdout_text.setReadOnly(True)
self.stdout_text.setObjectName("pip_install_status")
self.stdout_text.hide()
buttonBox = QHBoxLayout()
self.working_indicator = QLabel(trans._("loading ..."), self)
sp = self.working_indicator.sizePolicy()
sp.setRetainSizeWhenHidden(True)
self.working_indicator.setSizePolicy(sp)
self.process_error_indicator = QLabel(self)
self.process_error_indicator.setObjectName("error_label")
self.process_error_indicator.hide()
load_gif = str(Path(napari.resources.__file__).parent / "loading.gif")
mov = QMovie(load_gif)
mov.setScaledSize(QSize(18, 18))
self.working_indicator.setMovie(mov)
mov.start()
visibility_direct_entry = not running_as_constructor_app()
self.direct_entry_edit = QLineEdit(self)
self.direct_entry_edit.installEventFilter(self)
self.direct_entry_edit.setPlaceholderText(
trans._('install by name/url, or drop file...'))
self.direct_entry_edit.setVisible(visibility_direct_entry)
self.direct_entry_btn = QPushButton(trans._("Install"), self)
self.direct_entry_btn.setVisible(visibility_direct_entry)
self.direct_entry_btn.clicked.connect(self._install_packages)
self.show_status_btn = QPushButton(trans._("Show Status"), self)
self.show_status_btn.setFixedWidth(100)
self.cancel_all_btn = QPushButton(trans._("cancel all actions"), self)
self.cancel_all_btn.setObjectName("remove_button")
self.cancel_all_btn.setVisible(False)
self.cancel_all_btn.clicked.connect(lambda: self.installer.cancel())
self.close_btn = QPushButton(trans._("Close"), self)
self.close_btn.clicked.connect(self.accept)
self.close_btn.setObjectName("close_button")
buttonBox.addWidget(self.show_status_btn)
buttonBox.addWidget(self.working_indicator)
buttonBox.addWidget(self.direct_entry_edit)
buttonBox.addWidget(self.direct_entry_btn)
if not visibility_direct_entry:
buttonBox.addStretch()
buttonBox.addWidget(self.process_error_indicator)
buttonBox.addSpacing(20)
buttonBox.addWidget(self.cancel_all_btn)
buttonBox.addSpacing(20)
buttonBox.addWidget(self.close_btn)
buttonBox.setContentsMargins(0, 0, 4, 0)
vlay_1.addLayout(buttonBox)
self.show_status_btn.setCheckable(True)
self.show_status_btn.setChecked(False)
self.show_status_btn.toggled.connect(self._toggle_status)
self.v_splitter.setStretchFactor(1, 2)
self.h_splitter.setStretchFactor(0, 2)
self.packages_filter.setFocus()
class QtPluginDialog(QDialog):
def __init__(self, parent=None):
super().__init__(parent)
self.refresh_state = RefreshState.DONE
self.already_installed = set()
installer_type = "mamba" if running_as_constructor_app() else "pip"
self.installer = Installer(installer=installer_type)
self.setup_ui()
self.installer.set_output_widget(self.stdout_text)
self.installer.started.connect(self._on_installer_start)
self.installer.finished.connect(self._on_installer_done)
self.refresh()
def _on_installer_start(self):
self.cancel_all_btn.setVisible(True)
self.working_indicator.show()
self.process_error_indicator.hide()
self.close_btn.setDisabled(True)
def _on_installer_done(self, exit_code):
self.working_indicator.hide()
if exit_code:
self.process_error_indicator.show()
self.cancel_all_btn.setVisible(False)
self.close_btn.setDisabled(False)
self.refresh()
def closeEvent(self, event):
if self.close_btn.isEnabled():
super().closeEvent(event)
event.ignore()
def refresh(self):
if self.refresh_state != RefreshState.DONE:
self.refresh_state = RefreshState.OUTDATED
return
self.refresh_state = RefreshState.REFRESHING
self.installed_list.clear()
self.available_list.clear()
# fetch installed
from npe2 import PluginManager
from ...plugins import plugin_manager
plugin_manager.discover() # since they might not be loaded yet
self.already_installed = set()
def _add_to_installed(distname, enabled, npe_version=1):
norm_name = normalized_name(distname or '')
if distname:
try:
meta = metadata(distname)
except PackageNotFoundError:
self.refresh_state = RefreshState.OUTDATED
return # a race condition has occurred and the package is uninstalled by another thread
if len(meta) == 0:
# will not add builtins.
return
self.already_installed.add(norm_name)
else:
meta = {}
self.installed_list.addItem(
PackageMetadata(
metadata_version="1.0",
name=norm_name,
version=meta.get('version', ''),
summary=meta.get('summary', ''),
home_page=meta.get('url', ''),
author=meta.get('author', ''),
license=meta.get('license', ''),
),
installed=True,
enabled=enabled,
npe_version=npe_version,
)
pm2 = PluginManager.instance()
for manifest in pm2.iter_manifests():
distname = normalized_name(manifest.name or '')
if distname in self.already_installed or distname == 'napari':
continue
enabled = not pm2.is_disabled(manifest.name)
# if it's an Npe1 adaptor, call it v1
npev = 'shim' if 'npe1' in type(manifest).__name__.lower() else 2
_add_to_installed(distname, enabled, npe_version=npev)
for (
plugin_name,
_mod_name,
distname,
) in plugin_manager.iter_available():
# not showing these in the plugin dialog
if plugin_name in ('napari_plugin_engine', ):
continue
if distname in self.already_installed:
continue
_add_to_installed(distname,
not plugin_manager.is_blocked(plugin_name))
self.installed_label.setText(
trans._(
"Installed Plugins ({amount})",
amount=len(self.already_installed),
))
# fetch available plugins
settings = get_settings()
use_hub = (running_as_bundled_app() or running_as_constructor_app()
or settings.plugins.plugin_api.name == "napari_hub")
if use_hub:
conda_forge = running_as_constructor_app()
self.worker = create_worker(iter_hub_plugin_info,
conda_forge=conda_forge)
else:
self.worker = create_worker(iter_napari_plugin_info)
self.worker.yielded.connect(self._handle_yield)
self.worker.finished.connect(self.working_indicator.hide)
self.worker.finished.connect(self._update_count_in_label)
self.worker.finished.connect(self._end_refresh)
self.worker.start()
def setup_ui(self):
self.resize(1080, 640)
vlay_1 = QVBoxLayout(self)
self.h_splitter = QSplitter(self)
vlay_1.addWidget(self.h_splitter)
self.h_splitter.setOrientation(Qt.Horizontal)
self.v_splitter = QSplitter(self.h_splitter)
self.v_splitter.setOrientation(Qt.Vertical)
self.v_splitter.setMinimumWidth(500)
installed = QWidget(self.v_splitter)
lay = QVBoxLayout(installed)
lay.setContentsMargins(0, 2, 0, 2)
self.installed_label = QLabel(trans._("Installed Plugins"))
self.packages_filter = QLineEdit()
self.packages_filter.setPlaceholderText(trans._("filter..."))
self.packages_filter.setMaximumWidth(350)
self.packages_filter.setClearButtonEnabled(True)
mid_layout = QVBoxLayout()
mid_layout.addWidget(self.packages_filter)
mid_layout.addWidget(self.installed_label)
lay.addLayout(mid_layout)
self.installed_list = QPluginList(installed, self.installer)
self.packages_filter.textChanged.connect(self.installed_list.filter)
lay.addWidget(self.installed_list)
uninstalled = QWidget(self.v_splitter)
lay = QVBoxLayout(uninstalled)
lay.setContentsMargins(0, 2, 0, 2)
self.avail_label = QLabel(trans._("Available Plugins"))
mid_layout = QHBoxLayout()
mid_layout.addWidget(self.avail_label)
mid_layout.addStretch()
lay.addLayout(mid_layout)
self.available_list = QPluginList(uninstalled, self.installer)
self.packages_filter.textChanged.connect(self.available_list.filter)
lay.addWidget(self.available_list)
self.stdout_text = QTextEdit(self.v_splitter)
self.stdout_text.setReadOnly(True)
self.stdout_text.setObjectName("pip_install_status")
self.stdout_text.hide()
buttonBox = QHBoxLayout()
self.working_indicator = QLabel(trans._("loading ..."), self)
sp = self.working_indicator.sizePolicy()
sp.setRetainSizeWhenHidden(True)
self.working_indicator.setSizePolicy(sp)
self.process_error_indicator = QLabel(self)
self.process_error_indicator.setObjectName("error_label")
self.process_error_indicator.hide()
load_gif = str(Path(napari.resources.__file__).parent / "loading.gif")
mov = QMovie(load_gif)
mov.setScaledSize(QSize(18, 18))
self.working_indicator.setMovie(mov)
mov.start()
visibility_direct_entry = not running_as_constructor_app()
self.direct_entry_edit = QLineEdit(self)
self.direct_entry_edit.installEventFilter(self)
self.direct_entry_edit.setPlaceholderText(
trans._('install by name/url, or drop file...'))
self.direct_entry_edit.setVisible(visibility_direct_entry)
self.direct_entry_btn = QPushButton(trans._("Install"), self)
self.direct_entry_btn.setVisible(visibility_direct_entry)
self.direct_entry_btn.clicked.connect(self._install_packages)
self.show_status_btn = QPushButton(trans._("Show Status"), self)
self.show_status_btn.setFixedWidth(100)
self.cancel_all_btn = QPushButton(trans._("cancel all actions"), self)
self.cancel_all_btn.setObjectName("remove_button")
self.cancel_all_btn.setVisible(False)
self.cancel_all_btn.clicked.connect(lambda: self.installer.cancel())
self.close_btn = QPushButton(trans._("Close"), self)
self.close_btn.clicked.connect(self.accept)
self.close_btn.setObjectName("close_button")
buttonBox.addWidget(self.show_status_btn)
buttonBox.addWidget(self.working_indicator)
buttonBox.addWidget(self.direct_entry_edit)
buttonBox.addWidget(self.direct_entry_btn)
if not visibility_direct_entry:
buttonBox.addStretch()
buttonBox.addWidget(self.process_error_indicator)
buttonBox.addSpacing(20)
buttonBox.addWidget(self.cancel_all_btn)
buttonBox.addSpacing(20)
buttonBox.addWidget(self.close_btn)
buttonBox.setContentsMargins(0, 0, 4, 0)
vlay_1.addLayout(buttonBox)
self.show_status_btn.setCheckable(True)
self.show_status_btn.setChecked(False)
self.show_status_btn.toggled.connect(self._toggle_status)
self.v_splitter.setStretchFactor(1, 2)
self.h_splitter.setStretchFactor(0, 2)
self.packages_filter.setFocus()
def _update_count_in_label(self):
count = self.available_list.count()
self.avail_label.setText(
trans._("Available Plugins ({count})", count=count))
def _end_refresh(self):
refresh_state = self.refresh_state
self.refresh_state = RefreshState.DONE
if refresh_state == RefreshState.OUTDATED:
self.refresh()
def eventFilter(self, watched, event):
if event.type() == QEvent.DragEnter:
# we need to accept this event explicitly to be able
# to receive QDropEvents!
event.accept()
if event.type() == QEvent.Drop:
md = event.mimeData()
if md.hasUrls():
files = [url.toLocalFile() for url in md.urls()]
self.direct_entry_edit.setText(files[0])
return True
return super().eventFilter(watched, event)
def _toggle_status(self, show):
if show:
self.show_status_btn.setText(trans._("Hide Status"))
self.stdout_text.show()
else:
self.show_status_btn.setText(trans._("Show Status"))
self.stdout_text.hide()
def _install_packages(self, packages: Sequence[str] = ()):
if not packages:
_packages = self.direct_entry_edit.text()
if os.path.exists(_packages):
packages = [_packages]
else:
packages = _packages.split()
self.direct_entry_edit.clear()
if packages:
self.installer.install(packages)
def _handle_yield(self, data: Tuple[PackageMetadata, bool]):
project_info, is_available = data
if project_info.name in self.already_installed:
self.installed_list.tag_outdated(project_info, is_available)
else:
self.available_list.addItem(project_info)
if not is_available:
self.available_list.tag_unavailable(project_info)
self.filter()
def filter(self, text: str = None) -> None:
"""Filter by text or set current text as filter."""
if text is None:
text = self.packages_filter.text()
else:
self.packages_filter.setText(text)
self.installed_list.filter(text)
self.available_list.filter(text)
class ContentsWidget(QWidget):
"""Import wizard contents widget"""
asDataChanged = Signal(bool)
def __init__(self, parent, text):
QWidget.__init__(self, parent)
self.text_editor = QTextEdit(self)
self.text_editor.setText(text)
self.text_editor.setReadOnly(True)
# Type frame
type_layout = QHBoxLayout()
type_label = QLabel(_("Import as"))
type_layout.addWidget(type_label)
data_btn = QRadioButton(_("data"))
data_btn.setChecked(True)
self._as_data= True
type_layout.addWidget(data_btn)
code_btn = QRadioButton(_("code"))
self._as_code = False
type_layout.addWidget(code_btn)
txt_btn = QRadioButton(_("text"))
type_layout.addWidget(txt_btn)
h_spacer = QSpacerItem(40, 20,
QSizePolicy.Expanding, QSizePolicy.Minimum)
type_layout.addItem(h_spacer)
type_frame = QFrame()
type_frame.setLayout(type_layout)
# Opts frame
grid_layout = QGridLayout()
grid_layout.setSpacing(0)
col_label = QLabel(_("Column separator:"))
grid_layout.addWidget(col_label, 0, 0)
col_w = QWidget()
col_btn_layout = QHBoxLayout()
self.tab_btn = QRadioButton(_("Tab"))
self.tab_btn.setChecked(False)
col_btn_layout.addWidget(self.tab_btn)
other_btn_col = QRadioButton(_("other"))
other_btn_col.setChecked(True)
col_btn_layout.addWidget(other_btn_col)
col_w.setLayout(col_btn_layout)
grid_layout.addWidget(col_w, 0, 1)
self.line_edt = QLineEdit(",")
self.line_edt.setMaximumWidth(30)
self.line_edt.setEnabled(True)
other_btn_col.toggled.connect(self.line_edt.setEnabled)
grid_layout.addWidget(self.line_edt, 0, 2)
row_label = QLabel(_("Row separator:"))
grid_layout.addWidget(row_label, 1, 0)
row_w = QWidget()
row_btn_layout = QHBoxLayout()
self.eol_btn = QRadioButton(_("EOL"))
self.eol_btn.setChecked(True)
row_btn_layout.addWidget(self.eol_btn)
other_btn_row = QRadioButton(_("other"))
row_btn_layout.addWidget(other_btn_row)
row_w.setLayout(row_btn_layout)
grid_layout.addWidget(row_w, 1, 1)
self.line_edt_row = QLineEdit(";")
self.line_edt_row.setMaximumWidth(30)
self.line_edt_row.setEnabled(False)
other_btn_row.toggled.connect(self.line_edt_row.setEnabled)
grid_layout.addWidget(self.line_edt_row, 1, 2)
grid_layout.setRowMinimumHeight(2, 15)
other_group = QGroupBox(_("Additional options"))
other_layout = QGridLayout()
other_group.setLayout(other_layout)
skiprows_label = QLabel(_("Skip rows:"))
other_layout.addWidget(skiprows_label, 0, 0)
self.skiprows_edt = QLineEdit('0')
self.skiprows_edt.setMaximumWidth(30)
intvalid = QIntValidator(0, len(to_text_string(text).splitlines()),
self.skiprows_edt)
self.skiprows_edt.setValidator(intvalid)
other_layout.addWidget(self.skiprows_edt, 0, 1)
other_layout.setColumnMinimumWidth(2, 5)
comments_label = QLabel(_("Comments:"))
other_layout.addWidget(comments_label, 0, 3)
self.comments_edt = QLineEdit('#')
self.comments_edt.setMaximumWidth(30)
other_layout.addWidget(self.comments_edt, 0, 4)
self.trnsp_box = QCheckBox(_("Transpose"))
#self.trnsp_box.setEnabled(False)
other_layout.addWidget(self.trnsp_box, 1, 0, 2, 0)
grid_layout.addWidget(other_group, 3, 0, 2, 0)
opts_frame = QFrame()
opts_frame.setLayout(grid_layout)
data_btn.toggled.connect(opts_frame.setEnabled)
data_btn.toggled.connect(self.set_as_data)
code_btn.toggled.connect(self.set_as_code)
# self.connect(txt_btn, SIGNAL("toggled(bool)"),
# self, SLOT("is_text(bool)"))
# Final layout
layout = QVBoxLayout()
layout.addWidget(type_frame)
layout.addWidget(self.text_editor)
layout.addWidget(opts_frame)
self.setLayout(layout)
def get_as_data(self):
"""Return if data type conversion"""
return self._as_data
def get_as_code(self):
"""Return if code type conversion"""
return self._as_code
def get_as_num(self):
"""Return if numeric type conversion"""
return self._as_num
def get_col_sep(self):
"""Return the column separator"""
if self.tab_btn.isChecked():
return u"\t"
return to_text_string(self.line_edt.text())
def get_row_sep(self):
"""Return the row separator"""
if self.eol_btn.isChecked():
return u"\n"
return to_text_string(self.line_edt_row.text())
def get_skiprows(self):
"""Return number of lines to be skipped"""
return int(to_text_string(self.skiprows_edt.text()))
def get_comments(self):
"""Return comment string"""
return to_text_string(self.comments_edt.text())
@Slot(bool)
def set_as_data(self, as_data):
"""Set if data type conversion"""
self._as_data = as_data
self.asDataChanged.emit(as_data)
@Slot(bool)
def set_as_code(self, as_code):
"""Set if code type conversion"""
self._as_code = as_code
class ContentsWidget(QWidget):
"""Import wizard contents widget"""
asDataChanged = Signal(bool)
def __init__(self, parent, text):
QWidget.__init__(self, parent)
self.text_editor = QTextEdit(self)
self.text_editor.setText(text)
self.text_editor.setReadOnly(True)
# Type frame
type_layout = QHBoxLayout()
type_label = QLabel(_("Import as"))
type_layout.addWidget(type_label)
data_btn = QRadioButton(_("data"))
data_btn.setChecked(True)
self._as_data = True
type_layout.addWidget(data_btn)
code_btn = QRadioButton(_("code"))
self._as_code = False
type_layout.addWidget(code_btn)
txt_btn = QRadioButton(_("text"))
type_layout.addWidget(txt_btn)
h_spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
type_layout.addItem(h_spacer)
type_frame = QFrame()
type_frame.setLayout(type_layout)
# Opts frame
grid_layout = QGridLayout()
grid_layout.setSpacing(0)
col_label = QLabel(_("Column separator:"))
grid_layout.addWidget(col_label, 0, 0)
col_w = QWidget()
col_btn_layout = QHBoxLayout()
self.tab_btn = QRadioButton(_("Tab"))
self.tab_btn.setChecked(False)
col_btn_layout.addWidget(self.tab_btn)
self.ws_btn = QRadioButton(_("Whitespace"))
self.ws_btn.setChecked(False)
col_btn_layout.addWidget(self.ws_btn)
other_btn_col = QRadioButton(_("other"))
other_btn_col.setChecked(True)
col_btn_layout.addWidget(other_btn_col)
col_w.setLayout(col_btn_layout)
grid_layout.addWidget(col_w, 0, 1)
self.line_edt = QLineEdit(",")
self.line_edt.setMaximumWidth(30)
self.line_edt.setEnabled(True)
other_btn_col.toggled.connect(self.line_edt.setEnabled)
grid_layout.addWidget(self.line_edt, 0, 2)
row_label = QLabel(_("Row separator:"))
grid_layout.addWidget(row_label, 1, 0)
row_w = QWidget()
row_btn_layout = QHBoxLayout()
self.eol_btn = QRadioButton(_("EOL"))
self.eol_btn.setChecked(True)
row_btn_layout.addWidget(self.eol_btn)
other_btn_row = QRadioButton(_("other"))
row_btn_layout.addWidget(other_btn_row)
row_w.setLayout(row_btn_layout)
grid_layout.addWidget(row_w, 1, 1)
self.line_edt_row = QLineEdit(";")
self.line_edt_row.setMaximumWidth(30)
self.line_edt_row.setEnabled(False)
other_btn_row.toggled.connect(self.line_edt_row.setEnabled)
grid_layout.addWidget(self.line_edt_row, 1, 2)
grid_layout.setRowMinimumHeight(2, 15)
other_group = QGroupBox(_("Additional options"))
other_layout = QGridLayout()
other_group.setLayout(other_layout)
skiprows_label = QLabel(_("Skip rows:"))
other_layout.addWidget(skiprows_label, 0, 0)
self.skiprows_edt = QLineEdit('0')
self.skiprows_edt.setMaximumWidth(30)
intvalid = QIntValidator(0, len(to_text_string(text).splitlines()),
self.skiprows_edt)
self.skiprows_edt.setValidator(intvalid)
other_layout.addWidget(self.skiprows_edt, 0, 1)
other_layout.setColumnMinimumWidth(2, 5)
comments_label = QLabel(_("Comments:"))
other_layout.addWidget(comments_label, 0, 3)
self.comments_edt = QLineEdit('#')
self.comments_edt.setMaximumWidth(30)
other_layout.addWidget(self.comments_edt, 0, 4)
self.trnsp_box = QCheckBox(_("Transpose"))
#self.trnsp_box.setEnabled(False)
other_layout.addWidget(self.trnsp_box, 1, 0, 2, 0)
grid_layout.addWidget(other_group, 3, 0, 2, 0)
opts_frame = QFrame()
opts_frame.setLayout(grid_layout)
data_btn.toggled.connect(opts_frame.setEnabled)
data_btn.toggled.connect(self.set_as_data)
code_btn.toggled.connect(self.set_as_code)
# self.connect(txt_btn, SIGNAL("toggled(bool)"),
# self, SLOT("is_text(bool)"))
# Final layout
layout = QVBoxLayout()
layout.addWidget(type_frame)
layout.addWidget(self.text_editor)
layout.addWidget(opts_frame)
self.setLayout(layout)
def get_as_data(self):
"""Return if data type conversion"""
return self._as_data
def get_as_code(self):
"""Return if code type conversion"""
return self._as_code
def get_as_num(self):
"""Return if numeric type conversion"""
return self._as_num
def get_col_sep(self):
"""Return the column separator"""
if self.tab_btn.isChecked():
return u"\t"
elif self.ws_btn.isChecked():
return None
return to_text_string(self.line_edt.text())
def get_row_sep(self):
"""Return the row separator"""
if self.eol_btn.isChecked():
return u"\n"
return to_text_string(self.line_edt_row.text())
def get_skiprows(self):
"""Return number of lines to be skipped"""
return int(to_text_string(self.skiprows_edt.text()))
def get_comments(self):
"""Return comment string"""
return to_text_string(self.comments_edt.text())
@Slot(bool)
def set_as_data(self, as_data):
"""Set if data type conversion"""
self._as_data = as_data
self.asDataChanged.emit(as_data)
@Slot(bool)
def set_as_code(self, as_code):
"""Set if code type conversion"""
self._as_code = as_code
class QtAboutKeybindings(QDialog):
ALL_ACTIVE_KEYBINDINGS = 'All active keybindings'
def __init__(self, viewer):
super().__init__()
self.viewer = viewer
self.layout = QVBoxLayout()
self.setWindowTitle('Keybindings')
self.setWindowModality(Qt.NonModal)
self.setLayout(self.layout)
# stacked keybindings widgets
self.textEditBox = QTextEdit()
self.textEditBox.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.textEditBox.setMinimumWidth(360)
# Can switch to a normal dict when our minimum Python is 3.7
self.keybindings_strs = OrderedDict()
self.keybindings_strs[self.ALL_ACTIVE_KEYBINDINGS] = ''
col = self.viewer.palette['secondary']
layers = [
napari.layers.Image,
napari.layers.Labels,
napari.layers.Points,
napari.layers.Shapes,
napari.layers.Surface,
napari.layers.Vectors,
]
for layer in layers:
if len(layer.class_keymap) == 0:
text = 'No keybindings'
else:
text = get_keybindings_summary(layer.class_keymap, col=col)
self.keybindings_strs[f"{layer.__name__} layer"] = text
# layer type selection
self.layerTypeComboBox = QComboBox()
self.layerTypeComboBox.addItems(list(self.keybindings_strs))
self.layerTypeComboBox.activated[str].connect(self.change_layer_type)
self.layerTypeComboBox.setCurrentText(self.ALL_ACTIVE_KEYBINDINGS)
# self.change_layer_type(current_layer)
layer_type_layout = QHBoxLayout()
layer_type_layout.setContentsMargins(10, 5, 0, 0)
layer_type_layout.addWidget(self.layerTypeComboBox)
layer_type_layout.addStretch(1)
layer_type_layout.setSpacing(0)
self.layout.addLayout(layer_type_layout)
self.layout.addWidget(self.textEditBox, 1)
self.viewer.events.active_layer.connect(self.update_active_layer)
self.viewer.events.palette.connect(self.update_active_layer)
self.update_active_layer()
def change_layer_type(self, text):
self.textEditBox.setHtml(self.keybindings_strs[text])
def update_active_layer(self, event=None):
col = self.viewer.palette['secondary']
text = ''
# Add class and instance viewer keybindings
text += get_keybindings_summary(self.viewer.class_keymap, col=col)
text += get_keybindings_summary(self.viewer.keymap, col=col)
layer = self.viewer.active_layer
if layer is not None:
# Add class and instance layer keybindings for the active layer
text += get_keybindings_summary(layer.class_keymap, col=col)
text += get_keybindings_summary(layer.keymap, col=col)
# Update layer speficic keybindings if all active are displayed
self.keybindings_strs[self.ALL_ACTIVE_KEYBINDINGS] = text
if self.layerTypeComboBox.currentText() == self.ALL_ACTIVE_KEYBINDINGS:
self.textEditBox.setHtml(text)
def toggle_visible(self, event):
if self.isVisible():
self.hide()
else:
self.show()
self.raise_()
def __init__(self, text, title='', font=None, parent=None, readonly=False):
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)
self.text = None
self.btn_save_and_close = None
# Display text as unicode if it comes as bytes, so users see
# its right representation
if is_binary_string(text):
self.is_binary = True
text = to_text_string(text, 'utf8')
else:
self.is_binary = False
self.layout = QVBoxLayout()
self.setLayout(self.layout)
# Text edit
self.edit = QTextEdit(parent)
self.edit.setReadOnly(readonly)
self.edit.textChanged.connect(self.text_changed)
self.edit.setPlainText(text)
if font is None:
font = get_font()
self.edit.setFont(font)
self.layout.addWidget(self.edit)
# Buttons configuration
btn_layout = QHBoxLayout()
btn_layout.addStretch()
if not readonly:
self.btn_save_and_close = QPushButton(_('Save and Close'))
self.btn_save_and_close.setDisabled(True)
self.btn_save_and_close.clicked.connect(self.accept)
btn_layout.addWidget(self.btn_save_and_close)
self.btn_close = QPushButton(_('Close'))
self.btn_close.setAutoDefault(True)
self.btn_close.setDefault(True)
self.btn_close.clicked.connect(self.reject)
btn_layout.addWidget(self.btn_close)
self.layout.addLayout(btn_layout)
# Make the dialog act as a window
if sys.platform == 'darwin':
# See spyder-ide/spyder#12825
self.setWindowFlags(Qt.Tool)
else:
# Make the dialog act as a window
self.setWindowFlags(Qt.Window)
self.setWindowIcon(ima.icon('edit'))
if title:
try:
unicode_title = to_text_string(title)
except UnicodeEncodeError:
unicode_title = u''
else:
unicode_title = u''
self.setWindowTitle(_("Text editor") + \
u"%s" % (u" - " + unicode_title
if unicode_title else u""))
class QtAbout(QDialog):
"""Qt dialog window for displaying 'About napari' information.
Parameters
----------
parent : QWidget, optional
Parent of the dialog, to correctly inherit and apply theme.
Default is None.
Attributes
----------
citationCopyButton : napari._qt.qt_about.QtCopyToClipboardButton
Button to copy citation information to the clipboard.
citationTextBox : qtpy.QtWidgets.QTextEdit
Text box containing napari citation information.
citation_layout : qtpy.QtWidgets.QHBoxLayout
Layout widget for napari citation information.
infoCopyButton : napari._qt.qt_about.QtCopyToClipboardButton
Button to copy napari version information to the clipboard.
info_layout : qtpy.QtWidgets.QHBoxLayout
Layout widget for napari version information.
infoTextBox : qtpy.QtWidgets.QTextEdit
Text box containing napari version information.
layout : qtpy.QtWidgets.QVBoxLayout
Layout widget for the entire 'About napari' dialog.
"""
def __init__(self, parent=None):
super().__init__(parent)
self.layout = QVBoxLayout()
# Description
title_label = QLabel(
trans._(
"<b>napari: a multi-dimensional image viewer for python</b>"))
title_label.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.layout.addWidget(title_label)
# Add information
self.infoTextBox = QTextEdit()
self.infoTextBox.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.infoTextBox.setLineWrapMode(QTextEdit.NoWrap)
# Add text copy button
self.infoCopyButton = QtCopyToClipboardButton(self.infoTextBox)
self.info_layout = QHBoxLayout()
self.info_layout.addWidget(self.infoTextBox, 1)
self.info_layout.addWidget(self.infoCopyButton, 0, Qt.AlignTop)
self.info_layout.setAlignment(Qt.AlignTop)
self.layout.addLayout(self.info_layout)
self.infoTextBox.setText(sys_info(as_html=True))
self.infoTextBox.setMinimumSize(
int(self.infoTextBox.document().size().width() + 19),
int(min(self.infoTextBox.document().size().height() + 10, 500)),
)
self.layout.addWidget(QLabel(trans._('<b>citation information:</b>')))
self.citationTextBox = QTextEdit(citation_text)
self.citationTextBox.setFixedHeight(64)
self.citationCopyButton = QtCopyToClipboardButton(self.citationTextBox)
self.citation_layout = QHBoxLayout()
self.citation_layout.addWidget(self.citationTextBox, 1)
self.citation_layout.addWidget(self.citationCopyButton, 0, Qt.AlignTop)
self.layout.addLayout(self.citation_layout)
self.setLayout(self.layout)
@staticmethod
def showAbout(parent=None):
"""Display the 'About napari' dialog box.
Parameters
----------
parent : QWidget, optional
Parent of the dialog, to correctly inherit and apply theme.
Default is None.
"""
d = QtAbout(parent)
d.setObjectName('QtAbout')
d.setWindowTitle(trans._('About'))
d.setWindowModality(Qt.ApplicationModal)
d.exec_()
def __init__(self, parent):
QTextEdit.__init__(self, parent=parent)
self.setReadOnly(True)
def __init__(
self,
parent=None,
packages=None,
pip_packages=None,
remove_only=False,
update_only=False,
):
"""About dialog."""
super(PackagesDialog, self).__init__(parent=parent)
# Variables
self.api = AnacondaAPI()
self.actions = None
self.packages = packages or []
self.pip_packages = pip_packages or []
# Widgets
self.stack = QStackedWidget()
self.table = QTableWidget()
self.text = QTextEdit()
self.label_description = LabelBase()
self.label_status = LabelBase()
self.progress_bar = QProgressBar()
self.button_ok = ButtonPrimary('Apply')
self.button_cancel = ButtonNormal('Cancel')
# Widget setup
self.text.setReadOnly(True)
self.stack.addWidget(self.table)
self.stack.addWidget(self.text)
if remove_only:
text = 'The following packages will be removed:<br>'
else:
text = 'The following packages will be modified:<br>'
self.label_description.setText(text)
self.label_description.setWordWrap(True)
self.label_description.setWordWrap(True)
self.label_status.setWordWrap(True)
self.table.horizontalScrollBar().setVisible(False)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setAlternatingRowColors(True)
self.table.setSelectionMode(QAbstractItemView.NoSelection)
self.table.setSortingEnabled(True)
self._hheader = self.table.horizontalHeader()
self._vheader = self.table.verticalHeader()
self._hheader.setStretchLastSection(True)
self._hheader.setDefaultAlignment(Qt.AlignLeft)
self._hheader.setSectionResizeMode(self._hheader.Fixed)
self._vheader.setSectionResizeMode(self._vheader.Fixed)
self.button_ok.setMinimumWidth(70)
self.button_ok.setDefault(True)
self.base_minimum_width = 300 if remove_only else 420
if remove_only:
self.setWindowTitle("Remove Packages")
elif update_only:
self.setWindowTitle("Update Packages")
else:
self.setWindowTitle("Install Packages")
self.setMinimumWidth(self.base_minimum_width)
# Layouts
layout_progress = QHBoxLayout()
layout_progress.addWidget(self.label_status)
layout_progress.addWidget(SpacerHorizontal())
layout_progress.addWidget(self.progress_bar)
layout_buttons = QHBoxLayout()
layout_buttons.addStretch()
layout_buttons.addWidget(self.button_cancel)
layout_buttons.addWidget(SpacerHorizontal())
layout_buttons.addWidget(self.button_ok)
layout = QVBoxLayout()
layout.addWidget(self.label_description)
layout.addWidget(SpacerVertical())
layout.addWidget(self.stack)
layout.addWidget(SpacerVertical())
layout.addLayout(layout_progress)
layout.addWidget(SpacerVertical())
layout.addWidget(SpacerVertical())
layout.addLayout(layout_buttons)
self.setLayout(layout)
# Signals
self.button_ok.clicked.connect(self.accept)
self.button_cancel.clicked.connect(self.reject)
self.button_ok.setDisabled(True)
# Setup
self.table.setDisabled(True)
self.update_status('Solving package specifications',
value=0,
max_value=0)
def __init__(self):
super().__init__()
self.layout = QVBoxLayout()
# Description
title_label = QLabel(
"<b>napari: a multi-dimensional image viewer for python</b>")
title_label.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.layout.addWidget(title_label)
# Add information
self.infoTextBox = QTextEdit()
self.infoTextBox.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.infoTextBox.setLineWrapMode(QTextEdit.NoWrap)
# Add text copy button
self.infoCopyButton = QtCopyToClipboardButton(self.infoTextBox)
self.info_layout = QHBoxLayout()
self.info_layout.addWidget(self.infoTextBox, 1)
self.info_layout.addWidget(self.infoCopyButton, 0, Qt.AlignTop)
self.info_layout.setAlignment(Qt.AlignTop)
self.layout.addLayout(self.info_layout)
if API_NAME == 'PySide2':
API_VERSION = PYSIDE_VERSION
elif API_NAME == 'PyQt5':
API_VERSION = PYQT_VERSION
else:
API_VERSION = ''
sys_version = sys.version.replace('\n', ' ')
versions = (f"<b>napari</b>: {napari.__version__} <br>"
f"<b>Platform</b>: {platform.platform()} <br>"
f"<b>Python</b>: {sys_version} <br>"
f"<b>{API_NAME}</b>: {API_VERSION} <br>"
f"<b>Qt</b>: {QtCore.__version__} <br>"
f"<b>VisPy</b>: {vispy.__version__} <br>"
f"<b>NumPy</b>: {numpy.__version__} <br>"
f"<b>SciPy</b>: {scipy.__version__} <br>"
f"<b>scikit-image</b>: {skimage.__version__} <br>"
f"<b>Dask</b>: {dask.__version__} <br>")
sys_info_text = "<br>".join(
[vispy.sys_info().split("\n")[index] for index in [-4, -3]])
text = f'{versions} <br> {sys_info_text} <br>'
self.infoTextBox.setText(text)
self.layout.addWidget(QLabel('<b>citation information:</b>'))
citation_text = ('napari contributors (2019). napari: a '
'multi-dimensional image viewer for python. '
'doi:10.5281/zenodo.3555620')
self.citationTextBox = QTextEdit(citation_text)
self.citationTextBox.setFixedHeight(64)
self.citationCopyButton = QtCopyToClipboardButton(self.citationTextBox)
self.citation_layout = QHBoxLayout()
self.citation_layout.addWidget(self.citationTextBox, 1)
self.citation_layout.addWidget(self.citationCopyButton, 0, Qt.AlignTop)
self.layout.addLayout(self.citation_layout)
self.setLayout(self.layout)
def __init__(self, parent=None):
QTextEdit.__init__(self, parent)
BaseEditMixin.__init__(self)
self.found_results = []
class CreatePlan(QWidget):
plan_created = Signal()
plan_node_changed = Signal()
def __init__(self, settings: PartSettings):
super().__init__()
self.settings = settings
self.save_translate_dict: typing.Dict[str, SaveBase] = {
x.get_short_name(): x
for x in save_dict.values()
}
self.plan = PlanPreview(self)
self.save_plan_btn = QPushButton("Save")
self.clean_plan_btn = QPushButton("Remove all")
self.remove_btn = QPushButton("Remove")
self.update_element_chk = QCheckBox("Update element")
self.change_root = EnumComboBox(RootType)
self.save_choose = QComboBox()
self.save_choose.addItem("<none>")
self.save_choose.addItems(list(self.save_translate_dict.keys()))
self.save_btn = QPushButton("Save")
self.segment_profile = QListWidget()
self.pipeline_profile = QListWidget()
self.segment_stack = QTabWidget()
self.segment_stack.addTab(self.segment_profile, "Profile")
self.segment_stack.addTab(self.pipeline_profile, "Pipeline")
self.generate_mask_btn = QPushButton("Add mask")
self.generate_mask_btn.setToolTip("Mask need to have unique name")
self.mask_name = QLineEdit()
self.mask_operation = EnumComboBox(MaskOperation)
self.chanel_num = QSpinBox()
self.choose_channel_for_measurements = QComboBox()
self.choose_channel_for_measurements.addItems(
["Same as segmentation"] +
[str(x + 1) for x in range(MAX_CHANNEL_NUM)])
self.units_choose = EnumComboBox(Units)
self.units_choose.set_value(self.settings.get("units_value", Units.nm))
self.chanel_num.setRange(0, 10)
self.expected_node_type = None
self.save_constructor = None
self.chose_profile_btn = QPushButton("Add Profile")
self.get_big_btn = QPushButton("Leave the biggest")
self.get_big_btn.hide()
self.add_new_segmentation_btn = QPushButton("Add new profile")
self.get_big_btn.setDisabled(True)
self.add_new_segmentation_btn.setDisabled(True)
self.measurements_list = QListWidget(self)
self.measurement_name_prefix = QLineEdit(self)
self.add_calculation_btn = QPushButton("Add measurement calculation")
self.information = QTextEdit()
self.information.setReadOnly(True)
self.protect = False
self.mask_set = set()
self.calculation_plan = CalculationPlan()
self.plan.set_plan(self.calculation_plan)
self.segmentation_mask = MaskWidget(settings)
self.file_mask = FileMask()
self.change_root.currentIndexChanged.connect(self.change_root_type)
self.save_choose.currentTextChanged.connect(self.save_changed)
self.measurements_list.currentTextChanged.connect(
self.show_measurement)
self.segment_profile.currentTextChanged.connect(self.show_segment)
self.measurements_list.currentTextChanged.connect(
self.show_measurement_info)
self.segment_profile.currentTextChanged.connect(self.show_segment_info)
self.pipeline_profile.currentTextChanged.connect(
self.show_segment_info)
self.pipeline_profile.currentTextChanged.connect(self.show_segment)
self.mask_name.textChanged.connect(self.mask_name_changed)
self.generate_mask_btn.clicked.connect(self.create_mask)
self.clean_plan_btn.clicked.connect(self.clean_plan)
self.remove_btn.clicked.connect(self.remove_element)
self.mask_name.textChanged.connect(self.mask_text_changed)
self.chose_profile_btn.clicked.connect(self.add_segmentation)
self.get_big_btn.clicked.connect(self.add_leave_biggest)
self.add_calculation_btn.clicked.connect(self.add_measurement)
self.save_plan_btn.clicked.connect(self.add_calculation_plan)
# self.forgot_mask_btn.clicked.connect(self.forgot_mask)
# self.cmap_save_btn.clicked.connect(self.save_to_cmap)
self.save_btn.clicked.connect(self.add_save_to_project)
self.update_element_chk.stateChanged.connect(self.mask_text_changed)
self.update_element_chk.stateChanged.connect(self.show_measurement)
self.update_element_chk.stateChanged.connect(self.show_segment)
self.update_element_chk.stateChanged.connect(self.update_names)
self.segment_stack.currentChanged.connect(
self.change_segmentation_table)
plan_box = QGroupBox("Prepare workflow:")
lay = QVBoxLayout()
lay.addWidget(self.plan)
bt_lay = QGridLayout()
bt_lay.setSpacing(0)
bt_lay.addWidget(self.save_plan_btn, 0, 0)
bt_lay.addWidget(self.clean_plan_btn, 0, 1)
bt_lay.addWidget(self.remove_btn, 1, 0)
bt_lay.addWidget(self.update_element_chk, 1, 1)
lay.addLayout(bt_lay)
plan_box.setLayout(lay)
plan_box.setStyleSheet(group_sheet)
other_box = QGroupBox("Other operations:")
other_box.setContentsMargins(0, 0, 0, 0)
bt_lay = QVBoxLayout()
bt_lay.setSpacing(0)
bt_lay.addWidget(QLabel("Root type:"))
bt_lay.addWidget(self.change_root)
bt_lay.addStretch(1)
bt_lay.addWidget(QLabel("Saving:"))
bt_lay.addWidget(self.save_choose)
bt_lay.addWidget(self.save_btn)
other_box.setLayout(bt_lay)
other_box.setStyleSheet(group_sheet)
mask_box = QGroupBox("Use mask from:")
mask_box.setStyleSheet(group_sheet)
self.mask_stack = QTabWidget()
self.mask_stack.addTab(stretch_widget(self.file_mask), "File")
self.mask_stack.addTab(stretch_widget(self.segmentation_mask),
"Current segmentation")
self.mask_stack.addTab(stretch_widget(self.mask_operation),
"Operations on masks")
self.mask_stack.setTabToolTip(
2,
"Allows to create mask which is based on masks previously added to plan."
)
lay = QGridLayout()
lay.setSpacing(0)
lay.addWidget(self.mask_stack, 0, 0, 1, 2)
label = QLabel("Mask name:")
label.setToolTip(
"Needed if you would like to reuse this mask in tab 'Operations on masks'"
)
self.mask_name.setToolTip(
"Needed if you would like to reuse this mask in tab 'Operations on masks'"
)
lay.addWidget(label, 1, 0)
lay.addWidget(self.mask_name, 1, 1)
lay.addWidget(self.generate_mask_btn, 2, 0, 1, 2)
mask_box.setLayout(lay)
segment_box = QGroupBox("Segmentation:")
segment_box.setStyleSheet(group_sheet)
lay = QVBoxLayout()
lay.setSpacing(0)
lay.addWidget(self.segment_stack)
lay.addWidget(self.chose_profile_btn)
lay.addWidget(self.get_big_btn)
lay.addWidget(self.add_new_segmentation_btn)
segment_box.setLayout(lay)
measurement_box = QGroupBox("Set of measurements:")
measurement_box.setStyleSheet(group_sheet)
lay = QGridLayout()
lay.setSpacing(0)
lay.addWidget(self.measurements_list, 0, 0, 1, 2)
lab = QLabel("Name prefix:")
lab.setToolTip("Prefix added before each column name")
lay.addWidget(lab, 1, 0)
lay.addWidget(self.measurement_name_prefix, 1, 1)
lay.addWidget(QLabel("Channel:"), 2, 0)
lay.addWidget(self.choose_channel_for_measurements, 2, 1)
lay.addWidget(QLabel("Units:"))
lay.addWidget(self.units_choose, 3, 1)
lay.addWidget(self.add_calculation_btn, 4, 0, 1, 2)
measurement_box.setLayout(lay)
info_box = QGroupBox("Information")
info_box.setStyleSheet(group_sheet)
lay = QVBoxLayout()
lay.addWidget(self.information)
info_box.setLayout(lay)
layout = QGridLayout()
fst_col = QVBoxLayout()
fst_col.addWidget(plan_box, 1)
fst_col.addWidget(mask_box)
layout.addWidget(plan_box, 0, 0, 5, 1)
# layout.addWidget(plan_box, 0, 0, 3, 1)
# layout.addWidget(mask_box, 3, 0, 2, 1)
# layout.addWidget(segmentation_mask_box, 1, 1)
layout.addWidget(mask_box, 0, 2, 1, 2)
layout.addWidget(other_box, 0, 1)
layout.addWidget(segment_box, 1, 1, 1, 2)
layout.addWidget(measurement_box, 1, 3)
layout.addWidget(info_box, 3, 1, 1, 3)
self.setLayout(layout)
self.generate_mask_btn.setDisabled(True)
self.chose_profile_btn.setDisabled(True)
self.add_calculation_btn.setDisabled(True)
self.mask_allow = False
self.segment_allow = False
self.file_mask_allow = False
self.node_type = NodeType.root
self.node_name = ""
self.plan_node_changed.connect(self.mask_text_changed)
self.plan.changed_node.connect(self.node_type_changed)
self.plan_node_changed.connect(self.show_segment)
self.plan_node_changed.connect(self.show_measurement)
self.plan_node_changed.connect(self.mask_stack_change)
self.mask_stack.currentChanged.connect(self.mask_stack_change)
self.file_mask.value_changed.connect(self.mask_stack_change)
self.mask_name.textChanged.connect(self.mask_stack_change)
self.node_type_changed()
def change_root_type(self):
value: RootType = self.change_root.get_value()
self.calculation_plan.set_root_type(value)
self.plan.update_view()
def change_segmentation_table(self):
index = self.segment_stack.currentIndex()
text = self.segment_stack.tabText(index)
if self.update_element_chk.isChecked():
self.chose_profile_btn.setText("Replace " + text)
else:
self.chose_profile_btn.setText("Add " + text)
self.segment_profile.setCurrentItem(None)
self.pipeline_profile.setCurrentItem(None)
def save_changed(self, text):
text = str(text)
if text == "<none>":
self.save_btn.setText("Save")
self.save_btn.setToolTip("Choose file type")
self.expected_node_type = None
self.save_constructor = None
else:
save_class = self.save_translate_dict.get(text, None)
if save_class is None:
self.save_choose.setCurrentText("<none>")
return
self.save_btn.setText(f"Save to {save_class.get_short_name()}")
self.save_btn.setToolTip("Choose mask create in plan view")
if save_class.need_mask():
self.expected_node_type = NodeType.mask
elif save_class.need_segmentation():
self.expected_node_type = NodeType.segment
else:
self.expected_node_type = NodeType.root
self.save_constructor = Save
self.save_activate()
def save_activate(self):
self.save_btn.setDisabled(True)
if self.node_type == self.expected_node_type:
self.save_btn.setEnabled(True)
return
def segmentation_from_project(self):
self.calculation_plan.add_step(Operations.reset_to_base)
self.plan.update_view()
def update_names(self):
if self.update_element_chk.isChecked():
self.chose_profile_btn.setText("Replace Profile")
self.add_calculation_btn.setText("Replace set of measurements")
self.generate_mask_btn.setText("Replace mask")
else:
self.chose_profile_btn.setText("Add Profile")
self.add_calculation_btn.setText("Add set of measurements")
self.generate_mask_btn.setText("Generate mask")
def node_type_changed(self):
# self.cmap_save_btn.setDisabled(True)
self.save_btn.setDisabled(True)
self.node_name = ""
if self.plan.currentItem() is None:
self.mask_allow = False
self.file_mask_allow = False
self.segment_allow = False
self.remove_btn.setDisabled(True)
self.plan_node_changed.emit()
logging.debug("[node_type_changed] return")
return
node_type = self.calculation_plan.get_node_type()
self.node_type = node_type
if node_type in [
NodeType.file_mask, NodeType.mask, NodeType.segment,
NodeType.measurement, NodeType.save
]:
self.remove_btn.setEnabled(True)
else:
self.remove_btn.setEnabled(False)
if node_type == NodeType.mask or node_type == NodeType.file_mask:
self.mask_allow = False
self.segment_allow = True
self.file_mask_allow = False
self.node_name = self.calculation_plan.get_node().operation.name
elif node_type == NodeType.segment:
self.mask_allow = True
self.segment_allow = False
self.file_mask_allow = False
self.save_btn.setEnabled(True)
# self.cmap_save_btn.setEnabled(True)
elif node_type == NodeType.root:
self.mask_allow = False
self.segment_allow = True
self.file_mask_allow = True
elif node_type == NodeType.none or node_type == NodeType.measurement or node_type == NodeType.save:
self.mask_allow = False
self.segment_allow = False
self.file_mask_allow = False
self.save_activate()
self.plan_node_changed.emit()
def add_save_to_project(self):
save_class = self.save_translate_dict.get(
self.save_choose.currentText(), None)
if save_class is None:
QMessageBox.warning(self, "Save problem", "Not found save class")
dial = FormDialog([
AlgorithmProperty("suffix", "File suffix", ""),
AlgorithmProperty("directory", "Sub directory", "")
] + save_class.get_fields())
if dial.exec():
values = dial.get_values()
suffix = values["suffix"]
directory = values["directory"]
del values["suffix"]
del values["directory"]
save_elem = Save(suffix, directory, save_class.get_name(),
save_class.get_short_name(), values)
if self.update_element_chk.isChecked():
self.calculation_plan.replace_step(save_elem)
else:
self.calculation_plan.add_step(save_elem)
self.plan.update_view()
def create_mask(self):
text = str(self.mask_name.text()).strip()
if text != "" and text in self.mask_set:
QMessageBox.warning(self, "Already exists",
"Mask with this name already exists",
QMessageBox.Ok)
return
if _check_widget(self.mask_stack, EnumComboBox): # existing mask
mask_dialog = TwoMaskDialog
if self.mask_operation.get_value(
) == MaskOperation.mask_intersection: # Mask intersection
MaskConstruct = MaskIntersection
else:
MaskConstruct = MaskSum
dial = mask_dialog(self.mask_set)
if not dial.exec():
return
names = dial.get_result()
mask_ob = MaskConstruct(text, *names)
elif _check_widget(self.mask_stack, MaskWidget):
mask_ob = MaskCreate(text,
self.segmentation_mask.get_mask_property())
elif _check_widget(self.mask_stack, FileMask):
mask_ob = self.file_mask.get_value(text)
else:
raise ValueError("Unknowsn widget")
if self.update_element_chk.isChecked():
node = self.calculation_plan.get_node()
name = node.operation.name
if name in self.calculation_plan.get_reused_mask(
) and name != text:
QMessageBox.warning(
self, "Cannot remove",
f"Cannot remove mask '{name}' from plan because it is used in other elements"
)
return
self.mask_set.remove(name)
self.mask_set.add(mask_ob.name)
self.calculation_plan.replace_step(mask_ob)
else:
self.mask_set.add(mask_ob.name)
self.calculation_plan.add_step(mask_ob)
self.plan.update_view()
self.mask_text_changed()
def mask_stack_change(self):
node_type = self.calculation_plan.get_node_type()
if self.update_element_chk.isChecked() and node_type not in [
NodeType.mask, NodeType.file_mask
]:
self.generate_mask_btn.setDisabled(True)
text = self.mask_name.text()
update = self.update_element_chk.isChecked()
if self.node_type == NodeType.none:
self.generate_mask_btn.setDisabled(True)
return
operation = self.calculation_plan.get_node().operation
if (not update and isinstance(operation, (MaskMapper, MaskBase))
and self.calculation_plan.get_node().operation.name == text):
self.generate_mask_btn.setDisabled(True)
return
if _check_widget(self.mask_stack, EnumComboBox): # reuse mask
if len(self.mask_set) > 1 and (
(not update and node_type == NodeType.root) or
(update and node_type == NodeType.file_mask)):
self.generate_mask_btn.setEnabled(True)
else:
self.generate_mask_btn.setEnabled(False)
self.generate_mask_btn.setToolTip(
"Need at least two named mask and root selected")
elif _check_widget(self.mask_stack,
MaskWidget): # mask from segmentation
if (not update and node_type == NodeType.segment) or (
update and node_type == NodeType.mask):
self.generate_mask_btn.setEnabled(True)
else:
self.generate_mask_btn.setEnabled(False)
self.generate_mask_btn.setToolTip("Select segmentation")
else:
if (not update and node_type == NodeType.root) or (
update and node_type == NodeType.file_mask):
self.generate_mask_btn.setEnabled(self.file_mask.is_valid())
else:
self.generate_mask_btn.setEnabled(False)
self.generate_mask_btn.setToolTip("Need root selected")
def mask_name_changed(self, text):
if str(text) in self.mask_set:
self.generate_mask_btn.setDisabled(True)
else:
self.generate_mask_btn.setDisabled(False)
def add_leave_biggest(self):
profile = self.calculation_plan.get_node().operation
profile.leave_biggest_swap()
self.calculation_plan.replace_step(profile)
self.plan.update_view()
def add_segmentation(self):
if self.segment_stack.currentIndex() == 0:
text = str(self.segment_profile.currentItem().text())
if text not in self.settings.segmentation_profiles:
self.refresh_all_profiles()
return
profile = self.settings.segmentation_profiles[text]
if self.update_element_chk.isChecked():
self.calculation_plan.replace_step(profile)
else:
self.calculation_plan.add_step(profile)
self.plan.update_view()
else: # self.segment_stack.currentIndex() == 1
text = self.pipeline_profile.currentItem().text()
segmentation_pipeline = self.settings.segmentation_pipelines[text]
pos = self.calculation_plan.current_pos[:]
old_pos = self.calculation_plan.current_pos[:]
for el in segmentation_pipeline.mask_history:
self.calculation_plan.add_step(el.segmentation)
self.plan.update_view()
node = self.calculation_plan.get_node(pos)
pos.append(len(node.children) - 1)
self.calculation_plan.set_position(pos)
self.calculation_plan.add_step(MaskCreate(
"", el.mask_property))
self.plan.update_view()
pos.append(0)
self.calculation_plan.set_position(pos)
self.calculation_plan.add_step(segmentation_pipeline.segmentation)
self.calculation_plan.set_position(old_pos)
self.plan.update_view()
def add_measurement(self):
text = str(self.measurements_list.currentItem().text())
measurement_copy = deepcopy(self.settings.measurement_profiles[text])
prefix = str(self.measurement_name_prefix.text()).strip()
channel = self.choose_channel_for_measurements.currentIndex() - 1
measurement_copy.name_prefix = prefix
# noinspection PyTypeChecker
measurement_calculate = MeasurementCalculate(
channel=channel,
statistic_profile=measurement_copy,
name_prefix=prefix,
units=self.units_choose.get_value())
if self.update_element_chk.isChecked():
self.calculation_plan.replace_step(measurement_calculate)
else:
self.calculation_plan.add_step(measurement_calculate)
self.plan.update_view()
def remove_element(self):
conflict_mask, used_mask = self.calculation_plan.get_file_mask_names()
if len(conflict_mask) > 0:
logging.info("Mask in use")
QMessageBox.warning(
self, "In use", "Masks {} are used in other places".format(
", ".join(conflict_mask)))
return
self.mask_set -= used_mask
self.calculation_plan.remove_step()
self.plan.update_view()
def clean_plan(self):
self.calculation_plan = CalculationPlan()
self.plan.set_plan(self.calculation_plan)
self.node_type_changed()
self.mask_set = set()
def mask_text_changed(self):
name = str(self.mask_name.text()).strip()
self.generate_mask_btn.setDisabled(True)
# load mask from file
if not self.update_element_chk.isChecked():
# generate mask from segmentation
if self.mask_allow and (name == "" or name not in self.mask_set):
self.generate_mask_btn.setEnabled(True)
else:
if self.node_type != NodeType.file_mask and self.node_type != NodeType.mask:
return
# generate mask from segmentation
if self.node_type == NodeType.mask and (
name == "" or name == self.node_name
or name not in self.mask_set):
self.generate_mask_btn.setEnabled(True)
def add_calculation_plan(self, text=None):
if text is None or isinstance(text, bool):
text, ok = QInputDialog.getText(self, "Plan title",
"Set plan title")
else:
text, ok = QInputDialog.getText(
self,
"Plan title",
"Set plan title. Previous ({}) is already in use".format(text),
text=text)
text = text.strip()
if ok:
if text == "":
QMessageBox.information(
self, "Name cannot be empty",
"Name cannot be empty, Please set correct name",
QMessageBox.Ok)
self.add_calculation_plan()
return
if text in self.settings.batch_plans:
res = QMessageBox.information(
self,
"Name already in use",
"Name already in use. Would like to overwrite?",
QMessageBox.Yes | QMessageBox.No,
)
if res == QMessageBox.No:
self.add_calculation_plan(text)
return
plan = copy(self.calculation_plan)
plan.set_name(text)
self.settings.batch_plans[text] = plan
self.settings.dump()
self.plan_created.emit()
@staticmethod
def get_index(item: QListWidgetItem, new_values: typing.List[str]) -> int:
if item is None:
return -1
text = item.text()
try:
return new_values.index(text)
except ValueError:
return -1
@staticmethod
def refresh_profiles(list_widget: QListWidget,
new_values: typing.List[str], index: int):
list_widget.clear()
list_widget.addItems(new_values)
if index != -1:
list_widget.setCurrentRow(index)
def showEvent(self, event):
self.refresh_all_profiles()
def refresh_all_profiles(self):
new_measurements = list(
sorted(self.settings.measurement_profiles.keys()))
new_segment = list(sorted(self.settings.segmentation_profiles.keys()))
new_pipelines = list(
sorted(self.settings.segmentation_pipelines.keys()))
measurement_index = self.get_index(
self.measurements_list.currentItem(), new_measurements)
segment_index = self.get_index(self.segment_profile.currentItem(),
new_segment)
pipeline_index = self.get_index(self.pipeline_profile.currentItem(),
new_pipelines)
self.protect = True
self.refresh_profiles(self.measurements_list, new_measurements,
measurement_index)
self.refresh_profiles(self.segment_profile, new_segment, segment_index)
self.refresh_profiles(self.pipeline_profile, new_pipelines,
pipeline_index)
self.protect = False
def show_measurement_info(self, text=None):
if self.protect:
return
if text is None:
if self.measurements_list.currentItem() is not None:
text = str(self.measurements_list.currentItem().text())
else:
return
profile = self.settings.measurement_profiles[text]
self.information.setText(str(profile))
def show_measurement(self):
if self.update_element_chk.isChecked():
if self.node_type == NodeType.measurement:
self.add_calculation_btn.setEnabled(True)
else:
self.add_calculation_btn.setDisabled(True)
else:
if self.measurements_list.currentItem() is not None:
self.add_calculation_btn.setEnabled(self.mask_allow)
else:
self.add_calculation_btn.setDisabled(True)
def show_segment_info(self, text=None):
if self.protect:
return
if text == "":
return
if self.segment_stack.currentIndex() == 0:
if text is None:
if self.segment_profile.currentItem() is not None:
text = str(self.segment_profile.currentItem().text())
else:
return
profile = self.settings.segmentation_profiles[text]
else:
if text is None:
if self.pipeline_profile.currentItem() is not None:
text = str(self.pipeline_profile.currentItem().text())
else:
return
profile = self.settings.segmentation_pipelines[text]
self.information.setText(profile.pretty_print(analysis_algorithm_dict))
def show_segment(self):
if self.update_element_chk.isChecked(
) and self.segment_stack.currentIndex() == 0:
self.get_big_btn.setDisabled(True)
if self.node_type == NodeType.segment:
self.chose_profile_btn.setEnabled(True)
else:
self.chose_profile_btn.setDisabled(True)
else:
if self.node_type == NodeType.segment:
self.get_big_btn.setEnabled(True)
else:
self.get_big_btn.setDisabled(True)
if self.segment_stack.currentIndex() == 0:
if self.segment_profile.currentItem() is not None:
self.chose_profile_btn.setEnabled(self.segment_allow)
else:
self.chose_profile_btn.setDisabled(True)
else:
if self.pipeline_profile.currentItem() is not None:
self.chose_profile_btn.setEnabled(self.segment_allow)
else:
self.chose_profile_btn.setDisabled(True)
def edit_plan(self):
plan = self.sender().plan_to_edit # type: CalculationPlan
self.calculation_plan = copy(plan)
self.plan.set_plan(self.calculation_plan)
self.mask_set.clear()
self.calculation_plan.set_position([])
self.mask_set.update(self.calculation_plan.get_mask_names())
def __init__(self, parent, text):
QWidget.__init__(self, parent)
self.text_editor = QTextEdit(self)
self.text_editor.setText(text)
self.text_editor.setReadOnly(True)
# Type frame
type_layout = QHBoxLayout()
type_label = QLabel(_("Import as"))
type_layout.addWidget(type_label)
data_btn = QRadioButton(_("data"))
data_btn.setChecked(True)
self._as_data = True
type_layout.addWidget(data_btn)
code_btn = QRadioButton(_("code"))
self._as_code = False
type_layout.addWidget(code_btn)
txt_btn = QRadioButton(_("text"))
type_layout.addWidget(txt_btn)
h_spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
type_layout.addItem(h_spacer)
type_frame = QFrame()
type_frame.setLayout(type_layout)
# Opts frame
grid_layout = QGridLayout()
grid_layout.setSpacing(0)
col_label = QLabel(_("Column separator:"))
grid_layout.addWidget(col_label, 0, 0)
col_w = QWidget()
col_btn_layout = QHBoxLayout()
self.tab_btn = QRadioButton(_("Tab"))
self.tab_btn.setChecked(False)
col_btn_layout.addWidget(self.tab_btn)
self.ws_btn = QRadioButton(_("Whitespace"))
self.ws_btn.setChecked(False)
col_btn_layout.addWidget(self.ws_btn)
other_btn_col = QRadioButton(_("other"))
other_btn_col.setChecked(True)
col_btn_layout.addWidget(other_btn_col)
col_w.setLayout(col_btn_layout)
grid_layout.addWidget(col_w, 0, 1)
self.line_edt = QLineEdit(",")
self.line_edt.setMaximumWidth(30)
self.line_edt.setEnabled(True)
other_btn_col.toggled.connect(self.line_edt.setEnabled)
grid_layout.addWidget(self.line_edt, 0, 2)
row_label = QLabel(_("Row separator:"))
grid_layout.addWidget(row_label, 1, 0)
row_w = QWidget()
row_btn_layout = QHBoxLayout()
self.eol_btn = QRadioButton(_("EOL"))
self.eol_btn.setChecked(True)
row_btn_layout.addWidget(self.eol_btn)
other_btn_row = QRadioButton(_("other"))
row_btn_layout.addWidget(other_btn_row)
row_w.setLayout(row_btn_layout)
grid_layout.addWidget(row_w, 1, 1)
self.line_edt_row = QLineEdit(";")
self.line_edt_row.setMaximumWidth(30)
self.line_edt_row.setEnabled(False)
other_btn_row.toggled.connect(self.line_edt_row.setEnabled)
grid_layout.addWidget(self.line_edt_row, 1, 2)
grid_layout.setRowMinimumHeight(2, 15)
other_group = QGroupBox(_("Additional options"))
other_layout = QGridLayout()
other_group.setLayout(other_layout)
skiprows_label = QLabel(_("Skip rows:"))
other_layout.addWidget(skiprows_label, 0, 0)
self.skiprows_edt = QLineEdit('0')
self.skiprows_edt.setMaximumWidth(30)
intvalid = QIntValidator(0, len(to_text_string(text).splitlines()),
self.skiprows_edt)
self.skiprows_edt.setValidator(intvalid)
other_layout.addWidget(self.skiprows_edt, 0, 1)
other_layout.setColumnMinimumWidth(2, 5)
comments_label = QLabel(_("Comments:"))
other_layout.addWidget(comments_label, 0, 3)
self.comments_edt = QLineEdit('#')
self.comments_edt.setMaximumWidth(30)
other_layout.addWidget(self.comments_edt, 0, 4)
self.trnsp_box = QCheckBox(_("Transpose"))
#self.trnsp_box.setEnabled(False)
other_layout.addWidget(self.trnsp_box, 1, 0, 2, 0)
grid_layout.addWidget(other_group, 3, 0, 2, 0)
opts_frame = QFrame()
opts_frame.setLayout(grid_layout)
data_btn.toggled.connect(opts_frame.setEnabled)
data_btn.toggled.connect(self.set_as_data)
code_btn.toggled.connect(self.set_as_code)
# self.connect(txt_btn, SIGNAL("toggled(bool)"),
# self, SLOT("is_text(bool)"))
# Final layout
layout = QVBoxLayout()
layout.addWidget(type_frame)
layout.addWidget(self.text_editor)
layout.addWidget(opts_frame)
self.setLayout(layout)
def __init__(self, settings: PartSettings):
super().__init__()
self.settings = settings
self.save_translate_dict: typing.Dict[str, SaveBase] = {
x.get_short_name(): x
for x in save_dict.values()
}
self.plan = PlanPreview(self)
self.save_plan_btn = QPushButton("Save")
self.clean_plan_btn = QPushButton("Remove all")
self.remove_btn = QPushButton("Remove")
self.update_element_chk = QCheckBox("Update element")
self.change_root = EnumComboBox(RootType)
self.save_choose = QComboBox()
self.save_choose.addItem("<none>")
self.save_choose.addItems(list(self.save_translate_dict.keys()))
self.save_btn = QPushButton("Save")
self.segment_profile = QListWidget()
self.pipeline_profile = QListWidget()
self.segment_stack = QTabWidget()
self.segment_stack.addTab(self.segment_profile, "Profile")
self.segment_stack.addTab(self.pipeline_profile, "Pipeline")
self.generate_mask_btn = QPushButton("Add mask")
self.generate_mask_btn.setToolTip("Mask need to have unique name")
self.mask_name = QLineEdit()
self.mask_operation = EnumComboBox(MaskOperation)
self.chanel_num = QSpinBox()
self.choose_channel_for_measurements = QComboBox()
self.choose_channel_for_measurements.addItems(
["Same as segmentation"] +
[str(x + 1) for x in range(MAX_CHANNEL_NUM)])
self.units_choose = EnumComboBox(Units)
self.units_choose.set_value(self.settings.get("units_value", Units.nm))
self.chanel_num.setRange(0, 10)
self.expected_node_type = None
self.save_constructor = None
self.chose_profile_btn = QPushButton("Add Profile")
self.get_big_btn = QPushButton("Leave the biggest")
self.get_big_btn.hide()
self.add_new_segmentation_btn = QPushButton("Add new profile")
self.get_big_btn.setDisabled(True)
self.add_new_segmentation_btn.setDisabled(True)
self.measurements_list = QListWidget(self)
self.measurement_name_prefix = QLineEdit(self)
self.add_calculation_btn = QPushButton("Add measurement calculation")
self.information = QTextEdit()
self.information.setReadOnly(True)
self.protect = False
self.mask_set = set()
self.calculation_plan = CalculationPlan()
self.plan.set_plan(self.calculation_plan)
self.segmentation_mask = MaskWidget(settings)
self.file_mask = FileMask()
self.change_root.currentIndexChanged.connect(self.change_root_type)
self.save_choose.currentTextChanged.connect(self.save_changed)
self.measurements_list.currentTextChanged.connect(
self.show_measurement)
self.segment_profile.currentTextChanged.connect(self.show_segment)
self.measurements_list.currentTextChanged.connect(
self.show_measurement_info)
self.segment_profile.currentTextChanged.connect(self.show_segment_info)
self.pipeline_profile.currentTextChanged.connect(
self.show_segment_info)
self.pipeline_profile.currentTextChanged.connect(self.show_segment)
self.mask_name.textChanged.connect(self.mask_name_changed)
self.generate_mask_btn.clicked.connect(self.create_mask)
self.clean_plan_btn.clicked.connect(self.clean_plan)
self.remove_btn.clicked.connect(self.remove_element)
self.mask_name.textChanged.connect(self.mask_text_changed)
self.chose_profile_btn.clicked.connect(self.add_segmentation)
self.get_big_btn.clicked.connect(self.add_leave_biggest)
self.add_calculation_btn.clicked.connect(self.add_measurement)
self.save_plan_btn.clicked.connect(self.add_calculation_plan)
# self.forgot_mask_btn.clicked.connect(self.forgot_mask)
# self.cmap_save_btn.clicked.connect(self.save_to_cmap)
self.save_btn.clicked.connect(self.add_save_to_project)
self.update_element_chk.stateChanged.connect(self.mask_text_changed)
self.update_element_chk.stateChanged.connect(self.show_measurement)
self.update_element_chk.stateChanged.connect(self.show_segment)
self.update_element_chk.stateChanged.connect(self.update_names)
self.segment_stack.currentChanged.connect(
self.change_segmentation_table)
plan_box = QGroupBox("Prepare workflow:")
lay = QVBoxLayout()
lay.addWidget(self.plan)
bt_lay = QGridLayout()
bt_lay.setSpacing(0)
bt_lay.addWidget(self.save_plan_btn, 0, 0)
bt_lay.addWidget(self.clean_plan_btn, 0, 1)
bt_lay.addWidget(self.remove_btn, 1, 0)
bt_lay.addWidget(self.update_element_chk, 1, 1)
lay.addLayout(bt_lay)
plan_box.setLayout(lay)
plan_box.setStyleSheet(group_sheet)
other_box = QGroupBox("Other operations:")
other_box.setContentsMargins(0, 0, 0, 0)
bt_lay = QVBoxLayout()
bt_lay.setSpacing(0)
bt_lay.addWidget(QLabel("Root type:"))
bt_lay.addWidget(self.change_root)
bt_lay.addStretch(1)
bt_lay.addWidget(QLabel("Saving:"))
bt_lay.addWidget(self.save_choose)
bt_lay.addWidget(self.save_btn)
other_box.setLayout(bt_lay)
other_box.setStyleSheet(group_sheet)
mask_box = QGroupBox("Use mask from:")
mask_box.setStyleSheet(group_sheet)
self.mask_stack = QTabWidget()
self.mask_stack.addTab(stretch_widget(self.file_mask), "File")
self.mask_stack.addTab(stretch_widget(self.segmentation_mask),
"Current segmentation")
self.mask_stack.addTab(stretch_widget(self.mask_operation),
"Operations on masks")
self.mask_stack.setTabToolTip(
2,
"Allows to create mask which is based on masks previously added to plan."
)
lay = QGridLayout()
lay.setSpacing(0)
lay.addWidget(self.mask_stack, 0, 0, 1, 2)
label = QLabel("Mask name:")
label.setToolTip(
"Needed if you would like to reuse this mask in tab 'Operations on masks'"
)
self.mask_name.setToolTip(
"Needed if you would like to reuse this mask in tab 'Operations on masks'"
)
lay.addWidget(label, 1, 0)
lay.addWidget(self.mask_name, 1, 1)
lay.addWidget(self.generate_mask_btn, 2, 0, 1, 2)
mask_box.setLayout(lay)
segment_box = QGroupBox("Segmentation:")
segment_box.setStyleSheet(group_sheet)
lay = QVBoxLayout()
lay.setSpacing(0)
lay.addWidget(self.segment_stack)
lay.addWidget(self.chose_profile_btn)
lay.addWidget(self.get_big_btn)
lay.addWidget(self.add_new_segmentation_btn)
segment_box.setLayout(lay)
measurement_box = QGroupBox("Set of measurements:")
measurement_box.setStyleSheet(group_sheet)
lay = QGridLayout()
lay.setSpacing(0)
lay.addWidget(self.measurements_list, 0, 0, 1, 2)
lab = QLabel("Name prefix:")
lab.setToolTip("Prefix added before each column name")
lay.addWidget(lab, 1, 0)
lay.addWidget(self.measurement_name_prefix, 1, 1)
lay.addWidget(QLabel("Channel:"), 2, 0)
lay.addWidget(self.choose_channel_for_measurements, 2, 1)
lay.addWidget(QLabel("Units:"))
lay.addWidget(self.units_choose, 3, 1)
lay.addWidget(self.add_calculation_btn, 4, 0, 1, 2)
measurement_box.setLayout(lay)
info_box = QGroupBox("Information")
info_box.setStyleSheet(group_sheet)
lay = QVBoxLayout()
lay.addWidget(self.information)
info_box.setLayout(lay)
layout = QGridLayout()
fst_col = QVBoxLayout()
fst_col.addWidget(plan_box, 1)
fst_col.addWidget(mask_box)
layout.addWidget(plan_box, 0, 0, 5, 1)
# layout.addWidget(plan_box, 0, 0, 3, 1)
# layout.addWidget(mask_box, 3, 0, 2, 1)
# layout.addWidget(segmentation_mask_box, 1, 1)
layout.addWidget(mask_box, 0, 2, 1, 2)
layout.addWidget(other_box, 0, 1)
layout.addWidget(segment_box, 1, 1, 1, 2)
layout.addWidget(measurement_box, 1, 3)
layout.addWidget(info_box, 3, 1, 1, 3)
self.setLayout(layout)
self.generate_mask_btn.setDisabled(True)
self.chose_profile_btn.setDisabled(True)
self.add_calculation_btn.setDisabled(True)
self.mask_allow = False
self.segment_allow = False
self.file_mask_allow = False
self.node_type = NodeType.root
self.node_name = ""
self.plan_node_changed.connect(self.mask_text_changed)
self.plan.changed_node.connect(self.node_type_changed)
self.plan_node_changed.connect(self.show_segment)
self.plan_node_changed.connect(self.show_measurement)
self.plan_node_changed.connect(self.mask_stack_change)
self.mask_stack.currentChanged.connect(self.mask_stack_change)
self.file_mask.value_changed.connect(self.mask_stack_change)
self.mask_name.textChanged.connect(self.mask_stack_change)
self.node_type_changed()
class QtPluginErrReporter(QDialog):
"""Dialog that allows users to review and report PluginError tracebacks.
Parameters
----------
parent : QWidget, optional
Optional parent widget for this widget.
initial_plugin : str, optional
If provided, errors from ``initial_plugin`` will be shown when the
dialog is created, by default None
Attributes
----------
text_area : qtpy.QtWidgets.QTextEdit
The text area where traceback information will be shown.
plugin_combo : qtpy.QtWidgets.QComboBox
The dropdown menu used to select the current plugin
github_button : qtpy.QtWidgets.QPushButton
A button that, when pressed, will open an issue at the current plugin's
github issue tracker, prepopulated with a formatted traceback. Button
is only visible if a github URL is detected in the package metadata for
the current plugin.
clipboard_button : qtpy.QtWidgets.QPushButton
A button that, when pressed, copies the current traceback information
to the clipboard. (HTML tags are removed in the copied text.)
plugin_meta : qtpy.QtWidgets.QLabel
A label that will show available plugin metadata (such as home page).
"""
NULL_OPTION = trans._('select plugin... ')
def __init__(
self,
plugin_manager: Optional[PluginManager] = None,
*,
parent: Optional[QWidget] = None,
initial_plugin: Optional[str] = None,
) -> None:
super().__init__(parent)
if not plugin_manager:
from ...plugins import plugin_manager as _pm
self.plugin_manager = _pm
else:
self.plugin_manager = plugin_manager
self.setWindowTitle(trans._('Recorded Plugin Exceptions'))
self.setWindowModality(Qt.NonModal)
self.layout = QVBoxLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(10, 10, 10, 10)
self.setLayout(self.layout)
self.text_area = QTextEdit()
self.text_area.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.text_area.setMinimumWidth(360)
# Create plugin dropdown menu
self.plugin_combo = QComboBox()
self.plugin_combo.addItem(self.NULL_OPTION)
bad_plugins = [e.plugin_name for e in self.plugin_manager.get_errors()]
self.plugin_combo.addItems(list(sorted(set(bad_plugins))))
self.plugin_combo.currentTextChanged.connect(self.set_plugin)
self.plugin_combo.setCurrentText(self.NULL_OPTION)
# create github button (gets connected in self.set_plugin)
self.github_button = QPushButton(trans._('Open issue on GitHub'), self)
self.github_button.setToolTip(
trans._("Open a web browser to submit this error log\n"
"to the developer's GitHub issue tracker"))
self.github_button.hide()
# create copy to clipboard button
self.clipboard_button = QPushButton()
self.clipboard_button.hide()
self.clipboard_button.setObjectName("QtCopyToClipboardButton")
self.clipboard_button.setToolTip(
trans._("Copy error log to clipboard"))
self.clipboard_button.clicked.connect(self.copyToClipboard)
# plugin_meta contains a URL to the home page, (and/or other details)
self.plugin_meta = QLabel('', parent=self)
self.plugin_meta.setObjectName("pluginInfo")
self.plugin_meta.setTextFormat(Qt.RichText)
self.plugin_meta.setTextInteractionFlags(Qt.TextBrowserInteraction)
self.plugin_meta.setOpenExternalLinks(True)
self.plugin_meta.setAlignment(Qt.AlignRight)
# make layout
row_1_layout = QHBoxLayout()
row_1_layout.setContentsMargins(11, 5, 10, 0)
row_1_layout.addStretch(1)
row_1_layout.addWidget(self.plugin_meta)
row_2_layout = QHBoxLayout()
row_2_layout.setContentsMargins(11, 5, 10, 0)
row_2_layout.addWidget(self.plugin_combo)
row_2_layout.addStretch(1)
row_2_layout.addWidget(self.github_button)
row_2_layout.addWidget(self.clipboard_button)
row_2_layout.setSpacing(5)
self.layout.addLayout(row_1_layout)
self.layout.addLayout(row_2_layout)
self.layout.addWidget(self.text_area, 1)
self.setMinimumWidth(750)
self.setMinimumHeight(600)
if initial_plugin:
self.set_plugin(initial_plugin)
def set_plugin(self, plugin: str) -> None:
"""Set the current plugin shown in the dropdown and text area.
Parameters
----------
plugin : str
name of a plugin that has created an error this session.
"""
self.github_button.hide()
self.clipboard_button.hide()
try:
self.github_button.clicked.disconnect()
# when disconnecting a non-existent signal
# PySide2 raises runtimeError, PyQt5 raises TypeError
except (RuntimeError, TypeError):
pass
if not plugin or (plugin == self.NULL_OPTION):
self.plugin_meta.setText('')
self.text_area.setHtml('')
return
if not self.plugin_manager.get_errors(plugin):
raise ValueError(
trans._("No errors reported for plugin '{plugin}'".format(
plugin=plugin)))
self.plugin_combo.setCurrentText(plugin)
err_string = format_exceptions(plugin, as_html=True)
self.text_area.setHtml(err_string)
self.clipboard_button.show()
# set metadata and outbound links/buttons
err0 = self.plugin_manager.get_errors(plugin)[0]
meta = standard_metadata(err0.plugin) if err0.plugin else {}
meta_text = ''
if not meta:
self.plugin_meta.setText(meta_text)
return
url = meta.get('url')
if url:
meta_text += (
'<span style="color:#999;">plugin home page: '
f'</span><a href="{url}" style="color:#999">{url}</a>')
if 'github.com' in url:
def onclick():
import webbrowser
err = format_exceptions(plugin, as_html=False)
err = (
"<!--Provide detail on the error here-->\n\n\n\n"
"<details>\n<summary>Traceback from napari</summary>"
f"\n\n```\n{err}\n```\n</details>")
url = f'{meta.get("url")}/issues/new?&body={err}'
webbrowser.open(url, new=2)
self.github_button.clicked.connect(onclick)
self.github_button.show()
self.plugin_meta.setText(meta_text)
def copyToClipboard(self) -> None:
"""Copy current plugin traceback info to clipboard as plain text."""
plugin = self.plugin_combo.currentText()
err_string = format_exceptions(plugin, as_html=False)
cb = QGuiApplication.clipboard()
cb.setText(err_string)
import time
from qtpy.QtWidgets import QTextEdit, QApplication
from pmgwidgets import PMGLoopThreadRunner
def run(i, j):
time.sleep(0.1)
return i + j
def on_step_finished(step, result):
global text1
text1.append('传入每步不同的可迭代参数\nstep:%d,result:%s\n' % (step, repr(result)))
def on_finished():
global text1
text1.append('所有任务完成！')
app = QApplication(sys.argv)
text1 = QTextEdit()
text1.show()
oneshot = PMGLoopThreadRunner(run, iter_args=[(i, i + 1) for i in range(36)])
# 传入一个列表可迭代对象（当然也可以是其他迭代器。）作为参数。列表的长度就是循环的次数，列表的每一个元素代表每一步传入的参数。
oneshot.signal_step_finished.connect(
on_step_finished) # 每一步执行后的结果由signal_step_finished传回。多参数则会放进tuple里面。
oneshot.signal_finished.connect(on_finished)
sys.exit(app.exec_())
class PyChopGui(QMainWindow):
"""
GUI Class using PyQT for PyChop to help users plan inelastic neutron experiments
at spallation sources by calculating the resolution and flux at a given neutron energies.
"""
instruments = {}
choppers = {}
minE = {}
maxE = {}
def __init__(self):
super(PyChopGui, self).__init__()
self.folder = os.path.dirname(sys.modules[self.__module__].__file__)
for fname in os.listdir(self.folder):
if fname.endswith('.yaml'):
instobj = Instrument(os.path.join(self.folder, fname))
self.instruments[instobj.name] = instobj
self.choppers[instobj.name] = instobj.getChopperNames()
self.minE[instobj.name] = max([instobj.emin, 0.01])
self.maxE[instobj.name] = instobj.emax
self.drawLayout()
self.setInstrument(list(self.instruments.keys())[0])
self.resaxes_xlim = 0
self.qeaxes_xlim = 0
self.isFramePlotted = 0
def setInstrument(self, instname):
"""
Defines the instrument parameters by the name of the instrument.
"""
self.engine = self.instruments[str(instname)]
self.tabs.setTabEnabled(self.tdtabID, False)
self.widgets['ChopperCombo']['Combo'].clear()
self.widgets['FrequencyCombo']['Combo'].clear()
self.widgets['FrequencyCombo']['Label'].setText('Frequency')
self.widgets['PulseRemoverCombo']['Combo'].clear()
for item in self.choppers[str(instname)]:
self.widgets['ChopperCombo']['Combo'].addItem(item)
rep = self.engine.moderator.source_rep
maxfreq = self.engine.chopper_system.max_frequencies
# At the moment, the GUI only supports up to two independent frequencies
if not hasattr(maxfreq, '__len__') or len(maxfreq) == 1:
self.widgets['PulseRemoverCombo']['Combo'].hide()
self.widgets['PulseRemoverCombo']['Label'].hide()
for fq in range(rep, (maxfreq[0] if hasattr(maxfreq, '__len__') else maxfreq) + 1, rep):
self.widgets['FrequencyCombo']['Combo'].addItem(str(fq))
if hasattr(self.engine.chopper_system, 'frequency_names'):
self.widgets['FrequencyCombo']['Label'].setText(self.engine.chopper_system.frequency_names[0])
else:
self.widgets['PulseRemoverCombo']['Combo'].show()
self.widgets['PulseRemoverCombo']['Label'].show()
if hasattr(self.engine.chopper_system, 'frequency_names'):
for idx, chp in enumerate([self.widgets['FrequencyCombo']['Label'], self.widgets['PulseRemoverCombo']['Label']]):
chp.setText(self.engine.chopper_system.frequency_names[idx])
for fq in range(rep, maxfreq[0] + 1, rep):
self.widgets['FrequencyCombo']['Combo'].addItem(str(fq))
for fq in range(rep, maxfreq[1] + 1, rep):
self.widgets['PulseRemoverCombo']['Combo'].addItem(str(fq))
if len(self.engine.chopper_system.choppers) > 1:
self.widgets['MultiRepCheck'].setEnabled(True)
self.tabs.setTabEnabled(self.tdtabID, True)
else:
self.widgets['MultiRepCheck'].setEnabled(False)
self.widgets['MultiRepCheck'].setChecked(False)
self.widgets['Chopper2Phase']['Edit'].hide()
self.widgets['Chopper2Phase']['Label'].hide()
if self.engine.chopper_system.isPhaseIndependent:
self.widgets['Chopper2Phase']['Edit'].show()
self.widgets['Chopper2Phase']['Label'].show()
self.widgets['Chopper2Phase']['Edit'].setText(str(self.engine.chopper_system.defaultPhase[0]))
self.widgets['Chopper2Phase']['Label'].setText(self.engine.chopper_system.phaseNames[0])
# Special case for MERLIN - hide phase control from normal users
if 'MERLIN' in str(instname) and not self.instSciAct.isChecked():
self.widgets['Chopper2Phase']['Edit'].hide()
self.widgets['Chopper2Phase']['Label'].hide()
self.engine.setChopper(str(self.widgets['ChopperCombo']['Combo'].currentText()))
self.engine.setFrequency(float(self.widgets['FrequencyCombo']['Combo'].currentText()))
val = self.flxslder.val * self.maxE[self.engine.instname] / 100
self.flxedt.setText('%3.2f' % (val))
nframe = self.engine.moderator.n_frame if hasattr(self.engine.moderator, 'n_frame') else 1
self.repfig_nframe_edit.setText(str(nframe))
self.repfig_nframe_rep1only.setChecked(False)
if hasattr(self.engine.chopper_system, 'default_frequencies'):
cb = [self.widgets['FrequencyCombo']['Combo'], self.widgets['PulseRemoverCombo']['Combo']]
for idx, freq in enumerate(self.engine.chopper_system.default_frequencies):
cb[idx].setCurrentIndex([i for i in range(cb[idx].count()) if str(freq) in cb[idx].itemText(i)][0])
if idx > 1:
break
self.tabs.setTabEnabled(self.qetabID, False)
if self.engine.has_detector and hasattr(self.engine.detector, 'tthlims'):
self.tabs.setTabEnabled(self.qetabID, True)
def setChopper(self, choppername):
"""
Defines the Fermi chopper slit package type by name, or the disk chopper arrangement variant.
"""
self.engine.setChopper(str(choppername))
self.engine.setFrequency(float(self.widgets['FrequencyCombo']['Combo'].currentText()))
# Special case for MERLIN - only enable multirep for 'G' chopper
if 'MERLIN' in self.engine.instname:
if 'G' in str(choppername):
self.widgets['MultiRepCheck'].setEnabled(True)
self.tabs.setTabEnabled(self.tdtabID, True)
self.widgets['Chopper2Phase']['Edit'].setText('1500')
self.widgets['Chopper2Phase']['Label'].setText('Disk chopper phase delay time')
if self.instSciAct.isChecked():
self.widgets['Chopper2Phase']['Edit'].show()
self.widgets['Chopper2Phase']['Label'].show()
else:
self.widgets['MultiRepCheck'].setEnabled(False)
self.widgets['MultiRepCheck'].setChecked(False)
self.tabs.setTabEnabled(self.tdtabID, False)
self.widgets['Chopper2Phase']['Edit'].hide()
self.widgets['Chopper2Phase']['Label'].hide()
def setFreq(self, freqtext=None, **kwargs):
"""
Sets the chopper frequency(ies), in Hz.
"""
freq_gui = float(self.widgets['FrequencyCombo']['Combo'].currentText())
freq_in = kwargs['manual_freq'] if ('manual_freq' in kwargs.keys()) else freq_gui
if len(self.engine.getFrequency()) > 1 and (not hasattr(freq_in, '__len__') or len(freq_in)==1):
freqpr = float(self.widgets['PulseRemoverCombo']['Combo'].currentText())
freq_in = [freq_in, freqpr]
if not self.widgets['Chopper2Phase']['Label'].isHidden():
chop2phase = self.widgets['Chopper2Phase']['Edit'].text()
if isinstance(self.engine.chopper_system.defaultPhase[0], string_types):
chop2phase = str(chop2phase)
else:
chop2phase = float(chop2phase) % (1e6 / self.engine.moderator.source_rep)
self.engine.setFrequency(freq_in, phase=chop2phase)
else:
self.engine.setFrequency(freq_in)
def setEi(self):
"""
Sets the incident energy (or focused incident energy for multi-rep case).
"""
try:
eitxt = float(self.widgets['EiEdit']['Edit'].text())
self.engine.setEi(eitxt)
if self.eiPlots.isChecked():
self.calc_callback()
except ValueError:
raise ValueError('No Ei specified, or Ei string not understood')
def calc_callback(self):
"""
Calls routines to calculate the resolution / flux and to update the Matplotlib graphs.
"""
try:
if self.engine.getChopper() is None:
self.setChopper(self.widgets['ChopperCombo']['Combo'].currentText())
self.setEi()
self.setFreq()
self.calculate()
if self.errormess:
idx = [i for i, ei in enumerate(self.eis) if np.abs(ei - self.engine.getEi()) < 1.e-4]
if idx and self.flux[idx[0]] == 0:
raise ValueError(self.errormess)
self.errormessage(self.errormess)
self.plot_res()
self.plot_frame()
if self.instSciAct.isChecked():
self.update_script()
except ValueError as err:
self.errormessage(err)
self.plot_flux_ei()
self.plot_flux_hz()
def calculate(self):
"""
Performs the resolution and flux calculations.
"""
self.errormess = None
if self.engine.getEi() is None:
self.setEi()
if self.widgets['MultiRepCheck'].isChecked():
en = np.linspace(0, 0.95, 200)
self.eis = self.engine.getAllowedEi()
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always', UserWarning)
self.res = self.engine.getMultiRepResolution(en)
self.flux = self.engine.getMultiRepFlux()
if len(w) > 0:
mess = [str(w[i].message) for i in range(len(w))]
self.errormess = '\n'.join([m for m in mess if 'tchop' in m])
else:
en = np.linspace(0, 0.95*self.engine.getEi(), 200)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always', UserWarning)
self.res = self.engine.getResolution(en)
self.flux = self.engine.getFlux()
if len(w) > 0:
raise ValueError(w[0].message)
def _set_overplot(self, overplot, axisname):
axis = getattr(self, axisname)
if overplot:
if matplotlib.compare_versions('2.1.0',matplotlib.__version__):
axis.hold(True)
else:
setattr(self, axisname+'_xlim', 0)
axis.clear()
axis.axhline(color='k')
def plot_res(self):
"""
Plots the resolution in the resolution tab
"""
overplot = self.widgets['HoldCheck'].isChecked()
multiplot = self.widgets['MultiRepCheck'].isChecked()
self._set_overplot(overplot, 'resaxes')
self._set_overplot(overplot, 'qeaxes')
inst = self.engine.instname
freq = self.engine.getFrequency()
if hasattr(freq, '__len__'):
freq = freq[0]
if multiplot:
if matplotlib.compare_versions('2.1.0',matplotlib.__version__):
self.resaxes.hold(True)
for ie, Ei in enumerate(self.eis):
en = np.linspace(0, 0.95*Ei, 200)
if any(self.res[ie]):
if not self.flux[ie]:
continue
line, = self.resaxes.plot(en, self.res[ie])
label_text = '%s_%3.2fmeV_%dHz_Flux=%fn/cm2/s' % (inst, Ei, freq, self.flux[ie])
line.set_label(label_text)
if self.tabs.isTabEnabled(self.qetabID):
self.plot_qe(Ei, label_text, hold=True)
self.resaxes_xlim = max(Ei, self.resaxes_xlim)
if matplotlib.compare_versions('2.1.0',matplotlib.__version__):
self.resaxes.hold(False)
else:
ei = self.engine.getEi()
en = np.linspace(0, 0.95*ei, 200)
line, = self.resaxes.plot(en, self.res)
chopper = self.engine.getChopper()
label_text = '%s_%s_%3.2fmeV_%dHz_Flux=%fn/cm2/s' % (inst, chopper, ei, freq, self.flux)
line.set_label(label_text)
if self.tabs.isTabEnabled(self.qetabID):
self.plot_qe(ei, label_text, overplot)
self.resaxes_xlim = max(ei, self.resaxes_xlim)
self.resaxes.set_xlim([0, self.resaxes_xlim])
self.resaxes.legend().draggable()
self.resaxes.set_xlabel('Energy Transfer (meV)')
self.resaxes.set_ylabel(r'$\Delta$E (meV FWHM)')
self.rescanvas.draw()
def plot_qe(self, Ei, label_text, hold=False):
""" Plots the Q-E diagram """
from scipy import constants
E2q, meV2J = (2. * constants.m_n / (constants.hbar ** 2), constants.e / 1000.)
en = np.linspace(-Ei / 5., Ei, 100)
q2 = []
for tth in self.engine.detector.tthlims:
q = np.sqrt(E2q * (2 * Ei - en - 2 * np.sqrt(Ei * (Ei - en)) * np.cos(np.deg2rad(tth))) * meV2J) / 1e10
q2.append(np.concatenate((np.flipud(q), q)))
self._set_overplot(hold, 'qeaxes')
self.qeaxes_xlim = max(np.max(q2), self.qeaxes_xlim)
line, = self.qeaxes.plot(np.hstack(q2), np.concatenate((np.flipud(en), en)).tolist() * len(self.engine.detector.tthlims))
line.set_label(label_text)
self.qeaxes.set_xlim([0, self.qeaxes_xlim])
self.qeaxes.legend().draggable()
self.qeaxes.set_xlabel(r'$|Q| (\mathrm{\AA}^{-1})$')
self.qeaxes.set_ylabel('Energy Transfer (meV)')
self.qecanvas.draw()
def plot_flux_ei(self, **kwargs):
"""
Plots the flux vs Ei in the middle tab
"""
inst = self.engine.instname
chop = self.engine.getChopper()
freq = self.engine.getFrequency()
overplot = self.widgets['HoldCheck'].isChecked()
if hasattr(freq, '__len__'):
freq = freq[0]
update = kwargs['update'] if 'update' in kwargs.keys() else False
# Do not recalculate if all relevant parameters still the same.
_, labels = self.flxaxes2.get_legend_handles_labels()
searchStr = '([A-Z]+) "(.+)" ([0-9]+) Hz'
tmpinst = []
if (labels and (overplot or len(labels) == 1)) or update:
for prevtitle in labels:
prevInst, prevChop, prevFreq = re.search(searchStr, prevtitle).groups()
if update:
tmpinst.append(copy.deepcopy(Instrument(self.instruments[prevInst], prevChop, float(prevFreq))))
else:
if inst == prevInst and chop == prevChop and freq == float(prevFreq):
return
ne = 25
mn = self.minE[inst]
mx = (self.flxslder.val/100)*self.maxE[inst]
eis = np.linspace(mn, mx, ne)
flux = eis*0
elres = eis*0
if update:
self.flxaxes1.clear()
self.flxaxes2.clear()
if matplotlib.compare_versions('2.1.0',matplotlib.__version__):
self.flxaxes1.hold(True)
self.flxaxes2.hold(True)
for ii, instrument in enumerate(tmpinst):
for ie, ei in enumerate(eis):
with warnings.catch_warnings(record=True):
warnings.simplefilter('always', UserWarning)
flux[ie] = instrument.getFlux(ei)
elres[ie] = instrument.getResolution(0., ei)[0]
self.flxaxes1.plot(eis, flux)
line, = self.flxaxes2.plot(eis, elres)
line.set_label(labels[ii])
else:
for ie, ei in enumerate(eis):
with warnings.catch_warnings(record=True):
warnings.simplefilter('always', UserWarning)
flux[ie] = self.engine.getFlux(ei)
elres[ie] = self.engine.getResolution(0., ei)[0]
if overplot:
if matplotlib.compare_versions('2.1.0',matplotlib.__version__):
self.flxaxes1.hold(True)
self.flxaxes2.hold(True)
else:
self.flxaxes1.clear()
self.flxaxes2.clear()
self.flxaxes1.plot(eis, flux)
line, = self.flxaxes2.plot(eis, elres)
line.set_label('%s "%s" %d Hz' % (inst, chop, freq))
self.flxaxes1.set_xlim([mn, mx])
self.flxaxes2.set_xlim([mn, mx])
self.flxaxes1.set_xlabel('Incident Energy (meV)')
self.flxaxes1.set_ylabel('Flux (n/cm$^2$/s)')
self.flxaxes1.set_xlabel('Incident Energy (meV)')
self.flxaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
lg = self.flxaxes2.legend()
lg.draggable()
self.flxcanvas.draw()
def update_slider(self, val=None):
"""
Callback function for the x-axis slider of the flux tab
"""
if val is None:
val = float(self.flxedt.text()) / self.maxE[self.engine.instname] * 100
if val < self.minE[self.engine.instname]:
self.errormessage("Max Ei must be greater than %2.1f" % (self.minE[self.engine.instname]))
val = (self.minE[self.engine.instname]+0.1) / self.maxE[self.engine.instname] * 100
self.flxslder.set_val(val)
else:
val = self.flxslder.val * self.maxE[self.engine.instname] / 100
self.flxedt.setText('%3.2f' % (val))
self.plot_flux_ei(update=True)
self.flxcanvas.draw()
def plot_flux_hz(self):
"""
Plots the flux vs freq in the middle tab
"""
inst = self.engine.instname
chop = self.engine.getChopper()
ei = float(self.widgets['EiEdit']['Edit'].text())
overplot = self.widgets['HoldCheck'].isChecked()
# Do not recalculate if one of the plots has the same parametersc
_, labels = self.frqaxes2.get_legend_handles_labels()
searchStr = '([A-Z]+) "(.+)" Ei = ([0-9.-]+) meV'
if labels and (overplot or len(labels) == 1):
for prevtitle in labels:
prevInst, prevChop, prevEi = re.search(searchStr, prevtitle).groups()
if inst == prevInst and chop == prevChop and abs(ei-float(prevEi)) < 0.01:
return
freq0 = self.engine.getFrequency()
rep = self.engine.moderator.source_rep
maxfreq = self.engine.chopper_system.max_frequencies
freqs = range(rep, (maxfreq[0] if hasattr(maxfreq, '__len__') else maxfreq) + 1, rep)
flux = np.zeros(len(freqs))
elres = np.zeros(len(freqs))
for ie, freq in enumerate(freqs):
if hasattr(freq0, '__len__'):
self.setFreq(manual_freq=[freq] + freq0[1:])
else:
self.setFreq(manual_freq=freq)
with warnings.catch_warnings(record=True):
warnings.simplefilter('always', UserWarning)
flux[ie] = self.engine.getFlux(ei)
elres[ie] = self.engine.getResolution(0., ei)[0]
if overplot:
if matplotlib.compare_versions('2.1.0',matplotlib.__version__):
self.frqaxes1.hold(True)
self.frqaxes2.hold(True)
else:
self.frqaxes1.clear()
self.frqaxes2.clear()
self.setFreq(manual_freq=freq0)
self.frqaxes1.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes1.set_ylabel('Flux (n/cm$^2$/s)')
line, = self.frqaxes1.plot(freqs, flux, 'o-')
self.frqaxes1.set_xlim([0, np.max(freqs)])
self.frqaxes2.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
line, = self.frqaxes2.plot(freqs, elres, 'o-')
line.set_label('%s "%s" Ei = %5.3f meV' % (inst, chop, ei))
lg = self.frqaxes2.legend()
lg.draggable()
self.frqaxes2.set_xlim([0, np.max(freqs)])
self.frqcanvas.draw()
def instSciCB(self):
"""
Callback function for the "Instrument Scientist Mode" menu option
"""
# MERLIN is a special case - want to hide ability to change phase from users
if 'MERLIN' in self.engine.instname and 'G' in self.engine.getChopper():
if self.instSciAct.isChecked():
self.widgets['Chopper2Phase']['Edit'].show()
self.widgets['Chopper2Phase']['Label'].show()
self.widgets['Chopper2Phase']['Edit'].setText('1500')
self.widgets['Chopper2Phase']['Label'].setText('Disk chopper phase delay time')
else:
self.widgets['Chopper2Phase']['Edit'].hide()
self.widgets['Chopper2Phase']['Label'].hide()
if self.instSciAct.isChecked():
self.tabs.insertTab(self.scrtabID, self.scrtab, 'ScriptOutput')
self.scrtab.show()
else:
self.tabs.removeTab(self.scrtabID)
self.scrtab.hide()
def errormessage(self, message):
msg = QMessageBox()
msg.setText(str(message))
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
def loadYaml(self):
yaml_file = QFileDialog().getOpenFileName(self.mainWidget, 'Open Instrument YAML File', self.folder, 'Files (*.yaml)')
if isinstance(yaml_file, tuple):
yaml_file = yaml_file[0]
yaml_file = str(yaml_file)
new_folder = os.path.dirname(yaml_file)
if new_folder != self.folder:
self.folder = new_folder
try:
new_inst = Instrument(yaml_file)
except (RuntimeError, AttributeError, ValueError) as err:
self.errormessage(err)
newname = new_inst.name
if newname in self.instruments.keys() and not self.overwriteload.isChecked():
overwrite, newname = self._ask_overwrite()
if overwrite == 1:
return
elif overwrite == 0:
newname = new_inst.name
self.instruments[newname] = new_inst
self.choppers[newname] = new_inst.getChopperNames()
self.minE[newname] = max([new_inst.emin, 0.01])
self.maxE[newname] = new_inst.emax
self.updateInstrumentList()
combo = self.widgets['InstrumentCombo']['Combo']
idx = [i for i in range(combo.count()) if str(combo.itemText(i)) == newname]
combo.setCurrentIndex(idx[0])
self.setInstrument(newname)
def _ask_overwrite(self):
msg = QDialog()
msg.setWindowTitle('Load overwrite')
layout = QGridLayout()
layout.addWidget(QLabel('Instrument %s already exists in memory. Overwrite this?'), 0, 0, 1, -1)
buttons = [QPushButton(label) for label in ['Load and overwrite', 'Cancel Load', 'Load and rename to']]
locations = [[1, 0], [1, 1], [2, 0]]
self.overwrite_flag = 1
def overwriteCB(idx):
self.overwrite_flag = idx
msg.accept()
for idx, button in enumerate(buttons):
button.clicked.connect(lambda _, idx=idx: overwriteCB(idx))
layout.addWidget(button, locations[idx][0], locations[idx][1])
newname = QLineEdit()
newname.editingFinished.connect(lambda: overwriteCB(2))
layout.addWidget(newname, 2, 1)
msg.setLayout(layout)
msg.exec_()
newname = str(newname.text())
if not newname or newname in self.instruments:
self.errormessage('Invalid instrument name. Cancelling load.')
self.overwrite_flag = 1
return self.overwrite_flag, newname
def updateInstrumentList(self):
combo = self.widgets['InstrumentCombo']['Combo']
old_instruments = [str(combo.itemText(i)) for i in range(combo.count())]
new_instruments = [inst for inst in self.instruments if inst not in old_instruments]
for inst in new_instruments:
combo.addItem(inst)
def plot_frame(self):
"""
Plots the distance-time diagram in the right tab
"""
if len(self.engine.chopper_system.choppers) > 1:
self.engine.n_frame = int(self.repfig_nframe_edit.text())
self.repaxes.clear()
self.engine.plotMultiRepFrame(self.repaxes, first_rep=self.repfig_nframe_rep1only.isChecked())
self.repcanvas.draw()
def _gen_text_ei(self, ei, obj_in):
obj = Instrument(obj_in)
obj.setEi(ei)
en = np.linspace(0, 0.95*ei, 10)
try:
flux = self.engine.getFlux()
res = self.engine.getResolution(en)
except ValueError as err:
self.errormessage(err)
raise ValueError(err)
tsqvan, tsqdic, tsqmodchop = obj.getVanVar()
v_mod, v_chop = tuple(np.sqrt(tsqmodchop[:2]) * 1e6)
x0, _, x1, x2, _ = obj.chopper_system.getDistances()
first_component = 'moderator'
if x0 != tsqmodchop[2]:
x0 = tsqmodchop[2]
first_component = 'chopper 1'
txt = '# ------------------------------------------------------------- #\n'
txt += '# Ei = %8.2f meV\n' % (ei)
txt += '# Flux = %8.2f n/cm2/s\n' % (flux)
txt += '# Elastic resolution = %6.2f meV\n' % (res[0])
txt += '# Time width at sample = %6.2f us, of which:\n' % (1e6*np.sqrt(tsqvan))
for ky, val in list(tsqdic.items()):
txt += '# %20s : %6.2f us\n' % (ky, 1e6*np.sqrt(val))
txt += '# %s distances:\n' % (obj.instname)
txt += '# x0 = %6.2f m (%s to Fermi)\n' % (x0, first_component)
txt += '# x1 = %6.2f m (Fermi to sample)\n' % (x1)
txt += '# x2 = %6.2f m (sample to detector)\n' % (x2)
txt += '# Approximate inelastic resolution is given by:\n'
txt += '# dE = 2 * E2V * sqrt(ef**3 * t_van**2) / x2\n'
txt += '# where: E2V = 4.373e-4 meV/(m/us) conversion from energy to speed\n'
txt += '# t_van**2 = (geom*t_mod)**2 + ((1+geom)*t_chop)**2\n'
txt += '# geom = (x1 + x2*(ei/ef)**1.5) / x0\n'
txt += '# and t_mod and t_chop are the moderator and chopper time widths at the\n'
txt += '# moderator and chopper positions (not at the sample as listed above).\n'
txt += '# Which in this case is:\n'
txt += '# %.4e*sqrt(ef**3 * ( (%6.5f*(%.3f+%.3f*(ei/ef)**1.5))**2 \n' % (874.78672e-6/x2, v_mod, x1/x0, x2/x0)
txt += '# + (%6.5f*(%.3f+%.3f*(ei/ef)**1.5))**2) )\n' % (v_chop, 1+x1/x0, x2/x0)
txt += '# EN (meV) Full dE (meV) Approx dE (meV)\n'
for ii in range(len(res)):
ef = ei-en[ii]
approx = (874.78672e-6/x2)*np.sqrt(ef**3 * ((v_mod*((x1/x0)+(x2/x0)*(ei/ef)**1.5))**2
+ (v_chop*(1+(x1/x0)+(x2/x0)*(ei/ef)**1.5))**2))
txt += '%12.5f %12.5f %12.5f\n' % (en[ii], res[ii], approx)
return txt
def genText(self):
"""
Generates text output of the resolution function versus energy transfer and other information.
"""
multiplot = self.widgets['MultiRepCheck'].isChecked()
obj = self.engine
if obj.getChopper() is None:
self.setChopper(self.widgets['ChopperCombo']['Combo'].currentText())
if obj.getEi() is None:
self.setEi()
instname, chtyp, freqs, ei_in = tuple([obj.instname, obj.getChopper(), obj.getFrequency(), obj.getEi()])
txt = '# ------------------------------------------------------------- #\n'
txt += '# Chop calculation for instrument %s\n' % (instname)
if obj.isFermi:
txt += '# with chopper %s at %3i Hz\n' % (chtyp, freqs[0])
else:
txt += '# in %s mode with:\n' % (chtyp)
freq_names = obj.chopper_system.frequency_names
for idx in range(len(freq_names)):
txt += '# %s at %3i Hz\n' % (freq_names[idx], freqs[idx])
txt += self._gen_text_ei(ei_in, obj)
if multiplot:
for ei in sorted(self.engine.getAllowedEi()):
if np.abs(ei - ei_in) > 0.001:
txt += self._gen_text_ei(ei, obj)
return txt
def showText(self):
"""
Creates a dialog to show the generated text output.
"""
try:
generatedText = self.genText()
except ValueError:
return
self.txtwin = QDialog()
self.txtedt = QTextEdit()
self.txtbtn = QPushButton('OK')
self.txtwin.layout = QVBoxLayout(self.txtwin)
self.txtwin.layout.addWidget(self.txtedt)
self.txtwin.layout.addWidget(self.txtbtn)
self.txtbtn.clicked.connect(self.txtwin.deleteLater)
self.txtedt.setText(generatedText)
self.txtedt.setReadOnly(True)
self.txtwin.setWindowTitle('Resolution information')
self.txtwin.setWindowModality(Qt.ApplicationModal)
self.txtwin.setAttribute(Qt.WA_DeleteOnClose)
self.txtwin.setMinimumSize(400, 600)
self.txtwin.resize(400, 600)
self.txtwin.show()
self.txtloop = QEventLoop()
self.txtloop.exec_()
def saveText(self):
"""
Saves the generated text to a file (opens file dialog).
"""
fname = QFileDialog.getSaveFileName(self, 'Open file', '')
if isinstance(fname, tuple):
fname = fname[0]
fid = open(fname, 'w')
fid.write(self.genText())
fid.close()
def update_script(self):
"""
Updates the text window with information about the previous calculation.
"""
if self.widgets['MultiRepCheck'].isChecked():
out = self.engine.getMultiWidths()
new_str = '\n'
for ie, ee in enumerate(out['Eis']):
res = out['Energy'][ie]
percent = res / ee * 100
chop_width = out['chopper'][ie]
mod_width = out['moderator'][ie]
new_str += 'Ei is %6.2f meV, resolution is %6.2f ueV, percentage resolution is %6.3f\n' % (ee, res * 1000, percent)
new_str += 'FWHM at sample from chopper and moderator are %6.2f us, %6.2f us\n' % (chop_width, mod_width)
else:
ei = self.engine.getEi()
out = self.engine.getWidths()
res = out['Energy']
percent = res / ei * 100
chop_width = out['chopper']
mod_width = out['moderator']
new_str = '\nEi is %6.2f meV, resolution is %6.2f ueV, percentage resolution is %6.3f\n' % (ei, res * 1000, percent)
new_str += 'FWHM at sample from chopper and moderator are %6.2f us, %6.2f us\n' % (chop_width, mod_width)
self.scredt.append(new_str)
def onHelp(self):
"""
Shows the help page
"""
try:
from pymantidplot.proxies import showCustomInterfaceHelp
showCustomInterfaceHelp("PyChop")
except ImportError:
helpTxt = "PyChop is a tool to allow direct inelastic neutron\nscattering users to estimate the inelastic resolution\n"
helpTxt += "and incident flux for a given spectrometer setting.\n\nFirst select the instrument, chopper settings and\n"
helpTxt += "Ei, and then click 'Calculate and Plot'. Data for all\nthe graphs will be generated (may take 1-2s) and\n"
helpTxt += "all graphs will be updated. If the 'Hold current plot'\ncheck box is ticked, additional settings will be\n"
helpTxt += "overplotted on the existing graphs if they are\ndifferent from previous settings.\n\nMore in-depth help "
helpTxt += "can be obtained from the\nMantid help pages."
self.hlpwin = QDialog()
self.hlpedt = QLabel(helpTxt)
self.hlpbtn = QPushButton('OK')
self.hlpwin.layout = QVBoxLayout(self.hlpwin)
self.hlpwin.layout.addWidget(self.hlpedt)
self.hlpwin.layout.addWidget(self.hlpbtn)
self.hlpbtn.clicked.connect(self.hlpwin.deleteLater)
self.hlpwin.setWindowTitle('Help')
self.hlpwin.setWindowModality(Qt.ApplicationModal)
self.hlpwin.setAttribute(Qt.WA_DeleteOnClose)
self.hlpwin.setMinimumSize(370, 300)
self.hlpwin.resize(370, 300)
self.hlpwin.show()
self.hlploop = QEventLoop()
self.hlploop.exec_()
def drawLayout(self):
"""
Draws the GUI layout.
"""
self.widgetslist = [
['pair', 'show', 'Instrument', 'combo', self.instruments, self.setInstrument, 'InstrumentCombo'],
['pair', 'show', 'Chopper', 'combo', '', self.setChopper, 'ChopperCombo'],
['pair', 'show', 'Frequency', 'combo', '', self.setFreq, 'FrequencyCombo'],
['pair', 'hide', 'Pulse remover chopper freq', 'combo', '', self.setFreq, 'PulseRemoverCombo'],
['pair', 'show', 'Ei', 'edit', '', self.setEi, 'EiEdit'],
['pair', 'hide', 'Chopper 2 phase delay time', 'edit', '5', self.setFreq, 'Chopper2Phase'],
['spacer'],
['single', 'show', 'Calculate and Plot', 'button', self.calc_callback, 'CalculateButton'],
['single', 'show', 'Hold current plot', 'check', lambda: None, 'HoldCheck'],
['single', 'show', 'Show multi-reps', 'check', lambda: None, 'MultiRepCheck'],
['spacer'],
['single', 'show', 'Show data ascii window', 'button', self.showText, 'ShowAsciiButton'],
['single', 'show', 'Save data as ascii', 'button', self.saveText, 'SaveAsciiButton']
]
self.droplabels = []
self.dropboxes = []
self.singles = []
self.widgets = {}
self.leftPanel = QVBoxLayout()
self.rightPanel = QVBoxLayout()
self.tabs = QTabWidget(self)
self.fullWindow = QGridLayout()
for widget in self.widgetslist:
if 'pair' in widget[0]:
self.droplabels.append(QLabel(widget[2]))
if 'combo' in widget[3]:
self.dropboxes.append(QComboBox(self))
self.dropboxes[-1].activated['QString'].connect(widget[5])
for item in widget[4]:
self.dropboxes[-1].addItem(item)
self.widgets[widget[-1]] = {'Combo':self.dropboxes[-1], 'Label':self.droplabels[-1]}
elif 'edit' in widget[3]:
self.dropboxes.append(QLineEdit(self))
self.dropboxes[-1].returnPressed.connect(widget[5])
self.widgets[widget[-1]] = {'Edit':self.dropboxes[-1], 'Label':self.droplabels[-1]}
else:
raise RuntimeError('Bug in code - widget %s is not recognised.' % (widget[3]))
self.leftPanel.addWidget(self.droplabels[-1])
self.leftPanel.addWidget(self.dropboxes[-1])
if 'hide' in widget[1]:
self.droplabels[-1].hide()
self.dropboxes[-1].hide()
elif 'single' in widget[0]:
if 'check' in widget[3]:
self.singles.append(QCheckBox(widget[2], self))
self.singles[-1].stateChanged.connect(widget[4])
elif 'button' in widget[3]:
self.singles.append(QPushButton(widget[2]))
self.singles[-1].clicked.connect(widget[4])
else:
raise RuntimeError('Bug in code - widget %s is not recognised.' % (widget[3]))
self.leftPanel.addWidget(self.singles[-1])
if 'hide' in widget[1]:
self.singles[-1].hide()
self.widgets[widget[-1]] = self.singles[-1]
elif 'spacer' in widget[0]:
self.leftPanel.addItem(QSpacerItem(0, 35))
else:
raise RuntimeError('Bug in code - widget class %s is not recognised.' % (widget[0]))
# Right panel, matplotlib figures
self.resfig = Figure()
self.resfig.patch.set_facecolor('white')
self.rescanvas = FigureCanvas(self.resfig)
self.resaxes = self.resfig.add_subplot(111)
self.resaxes.axhline(color='k')
self.resaxes.set_xlabel('Energy Transfer (meV)')
self.resaxes.set_ylabel(r'$\Delta$E (meV FWHM)')
self.resfig_controls = NavigationToolbar(self.rescanvas, self)
self.restab = QWidget(self.tabs)
self.restabbox = QVBoxLayout()
self.restabbox.addWidget(self.rescanvas)
self.restabbox.addWidget(self.resfig_controls)
self.restab.setLayout(self.restabbox)
self.flxfig = Figure()
self.flxfig.patch.set_facecolor('white')
self.flxcanvas = FigureCanvas(self.flxfig)
self.flxaxes1 = self.flxfig.add_subplot(121)
self.flxaxes1.set_xlabel('Incident Energy (meV)')
self.flxaxes1.set_ylabel('Flux (n/cm$^2$/s)')
self.flxaxes2 = self.flxfig.add_subplot(122)
self.flxaxes2.set_xlabel('Incident Energy (meV)')
self.flxaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
self.flxfig_controls = NavigationToolbar(self.flxcanvas, self)
self.flxsldfg = Figure()
self.flxsldfg.patch.set_facecolor('white')
self.flxsldcv = FigureCanvas(self.flxsldfg)
self.flxsldax = self.flxsldfg.add_subplot(111)
self.flxslder = Slider(self.flxsldax, 'Ei (meV)', 0, 100, valinit=100)
self.flxslder.valtext.set_visible(False)
self.flxslder.on_changed(self.update_slider)
self.flxedt = QLineEdit()
self.flxedt.setText('1000')
self.flxedt.returnPressed.connect(self.update_slider)
self.flxtab = QWidget(self.tabs)
self.flxsldbox = QHBoxLayout()
self.flxsldbox.addWidget(self.flxsldcv)
self.flxsldbox.addWidget(self.flxedt)
self.flxsldwdg = QWidget()
self.flxsldwdg.setLayout(self.flxsldbox)
sz = self.flxsldwdg.maximumSize()
sz.setHeight(50)
self.flxsldwdg.setMaximumSize(sz)
self.flxtabbox = QVBoxLayout()
self.flxtabbox.addWidget(self.flxcanvas)
self.flxtabbox.addWidget(self.flxsldwdg)
self.flxtabbox.addWidget(self.flxfig_controls)
self.flxtab.setLayout(self.flxtabbox)
self.frqfig = Figure()
self.frqfig.patch.set_facecolor('white')
self.frqcanvas = FigureCanvas(self.frqfig)
self.frqaxes1 = self.frqfig.add_subplot(121)
self.frqaxes1.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes1.set_ylabel('Flux (n/cm$^2$/s)')
self.frqaxes2 = self.frqfig.add_subplot(122)
self.frqaxes1.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
self.frqfig_controls = NavigationToolbar(self.frqcanvas, self)
self.frqtab = QWidget(self.tabs)
self.frqtabbox = QVBoxLayout()
self.frqtabbox.addWidget(self.frqcanvas)
self.frqtabbox.addWidget(self.frqfig_controls)
self.frqtab.setLayout(self.frqtabbox)
self.repfig = Figure()
self.repfig.patch.set_facecolor('white')
self.repcanvas = FigureCanvas(self.repfig)
self.repaxes = self.repfig.add_subplot(111)
self.repaxes.axhline(color='k')
self.repaxes.set_xlabel(r'TOF ($\mu$sec)')
self.repaxes.set_ylabel('Distance (m)')
self.repfig_controls = NavigationToolbar(self.repcanvas, self)
self.repfig_nframe_label = QLabel('Number of frames to plot')
self.repfig_nframe_edit = QLineEdit('1')
self.repfig_nframe_button = QPushButton('Replot')
self.repfig_nframe_button.clicked.connect(lambda: self.plot_frame())
self.repfig_nframe_rep1only = QCheckBox('First Rep Only')
self.repfig_nframe_box = QHBoxLayout()
self.repfig_nframe_box.addWidget(self.repfig_nframe_label)
self.repfig_nframe_box.addWidget(self.repfig_nframe_edit)
self.repfig_nframe_box.addWidget(self.repfig_nframe_button)
self.repfig_nframe_box.addWidget(self.repfig_nframe_rep1only)
self.reptab = QWidget(self.tabs)
self.repfig_nframe = QWidget(self.reptab)
self.repfig_nframe.setLayout(self.repfig_nframe_box)
self.repfig_nframe.setSizePolicy(QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed))
self.reptabbox = QVBoxLayout()
self.reptabbox.addWidget(self.repcanvas)
self.reptabbox.addWidget(self.repfig_nframe)
self.reptabbox.addWidget(self.repfig_controls)
self.reptab.setLayout(self.reptabbox)
self.qefig = Figure()
self.qefig.patch.set_facecolor('white')
self.qecanvas = FigureCanvas(self.qefig)
self.qeaxes = self.qefig.add_subplot(111)
self.qeaxes.axhline(color='k')
self.qeaxes.set_xlabel(r'$|Q| (\mathrm{\AA}^{-1})$')
self.qeaxes.set_ylabel('Energy Transfer (meV)')
self.qefig_controls = NavigationToolbar(self.qecanvas, self)
self.qetabbox = QVBoxLayout()
self.qetabbox.addWidget(self.qecanvas)
self.qetabbox.addWidget(self.qefig_controls)
self.qetab = QWidget(self.tabs)
self.qetab.setLayout(self.qetabbox)
self.scrtab = QWidget(self.tabs)
self.scredt = QTextEdit()
self.scrcls = QPushButton("Clear")
self.scrcls.clicked.connect(lambda: self.scredt.clear())
self.scrbox = QVBoxLayout()
self.scrbox.addWidget(self.scredt)
self.scrbox.addWidget(self.scrcls)
self.scrtab.setLayout(self.scrbox)
self.scrtab.hide()
self.tabs.addTab(self.restab, 'Resolution')
self.tabs.addTab(self.flxtab, 'Flux-Ei')
self.tabs.addTab(self.frqtab, 'Flux-Freq')
self.tabs.addTab(self.reptab, 'Time-Distance')
self.tdtabID = 3
self.tabs.setTabEnabled(self.tdtabID, False)
self.tabs.addTab(self.qetab, 'Q-E')
self.qetabID = 4
self.tabs.setTabEnabled(self.qetabID, False)
self.scrtabID = 5
self.rightPanel.addWidget(self.tabs)
self.menuLoad = QMenu('Load')
self.loadAct = QAction('Load YAML', self.menuLoad)
self.loadAct.triggered.connect(self.loadYaml)
self.menuLoad.addAction(self.loadAct)
self.menuOptions = QMenu('Options')
self.instSciAct = QAction('Instrument Scientist Mode', self.menuOptions, checkable=True)
self.instSciAct.triggered.connect(self.instSciCB)
self.menuOptions.addAction(self.instSciAct)
self.eiPlots = QAction('Press Enter in Ei box updates plots', self.menuOptions, checkable=True)
self.menuOptions.addAction(self.eiPlots)
self.overwriteload = QAction('Always overwrite instruments in memory', self.menuOptions, checkable=True)
self.menuOptions.addAction(self.overwriteload)
self.menuBar().addMenu(self.menuLoad)
self.menuBar().addMenu(self.menuOptions)
self.leftPanelWidget = QWidget()
self.leftPanelWidget.setLayout(self.leftPanel)
self.leftPanelWidget.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred))
self.fullWindow.addWidget(self.leftPanelWidget, 0, 0)
self.fullWindow.addLayout(self.rightPanel, 0, 1)
self.helpbtn = QPushButton("?", self)
self.helpbtn.setMaximumWidth(30)
self.helpbtn.clicked.connect(self.onHelp)
self.fullWindow.addWidget(self.helpbtn, 1, 0, 1, -1)
self.mainWidget = QWidget()
self.mainWidget.setLayout(self.fullWindow)
self.setCentralWidget(self.mainWidget)
self.setWindowTitle('PyChopGUI')
self.show()
class PyChopGui(QMainWindow):
"""
GUI Class using PyQT for PyChop to help users plan inelastic neutron experiments
at spallation sources by calculating the resolution and flux at a given neutron energies.
"""
instruments = {}
choppers = {}
minE = {}
maxE = {}
def __init__(self):
super(PyChopGui, self).__init__()
self.folder = os.path.dirname(sys.modules[self.__module__].__file__)
for fname in os.listdir(self.folder):
if fname.endswith('.yaml'):
instobj = Instrument(os.path.join(self.folder, fname))
self.instruments[instobj.name] = instobj
self.choppers[instobj.name] = instobj.getChopperNames()
self.minE[instobj.name] = max([instobj.emin, 0.01])
self.maxE[instobj.name] = instobj.emax
self.drawLayout()
self.setInstrument(list(self.instruments.keys())[0])
self.resaxes_xlim = 0
self.qeaxes_xlim = 0
self.isFramePlotted = 0
def setInstrument(self, instname):
"""
Defines the instrument parameters by the name of the instrument.
"""
self.engine = self.instruments[str(instname)]
self.tabs.setTabEnabled(self.tdtabID, False)
self.widgets['ChopperCombo']['Combo'].clear()
self.widgets['FrequencyCombo']['Combo'].clear()
self.widgets['FrequencyCombo']['Label'].setText('Frequency')
self.widgets['PulseRemoverCombo']['Combo'].clear()
for item in self.choppers[str(instname)]:
self.widgets['ChopperCombo']['Combo'].addItem(item)
rep = self.engine.moderator.source_rep
maxfreq = self.engine.chopper_system.max_frequencies
# At the moment, the GUI only supports up to two independent frequencies
if not hasattr(maxfreq, '__len__') or len(maxfreq) == 1:
self.widgets['PulseRemoverCombo']['Combo'].hide()
self.widgets['PulseRemoverCombo']['Label'].hide()
for fq in range(
rep,
(maxfreq[0] if hasattr(maxfreq, '__len__') else maxfreq) + 1,
rep):
self.widgets['FrequencyCombo']['Combo'].addItem(str(fq))
if hasattr(self.engine.chopper_system, 'frequency_names'):
self.widgets['FrequencyCombo']['Label'].setText(
self.engine.chopper_system.frequency_names[0])
else:
self.widgets['PulseRemoverCombo']['Combo'].show()
self.widgets['PulseRemoverCombo']['Label'].show()
if hasattr(self.engine.chopper_system, 'frequency_names'):
for idx, chp in enumerate([
self.widgets['FrequencyCombo']['Label'],
self.widgets['PulseRemoverCombo']['Label']
]):
chp.setText(
self.engine.chopper_system.frequency_names[idx])
for fq in range(rep, maxfreq[0] + 1, rep):
self.widgets['FrequencyCombo']['Combo'].addItem(str(fq))
for fq in range(rep, maxfreq[1] + 1, rep):
self.widgets['PulseRemoverCombo']['Combo'].addItem(str(fq))
if len(self.engine.chopper_system.choppers) > 1:
self.widgets['MultiRepCheck'].setEnabled(True)
self.tabs.setTabEnabled(self.tdtabID, True)
else:
self.widgets['MultiRepCheck'].setEnabled(False)
self.widgets['MultiRepCheck'].setChecked(False)
self._hide_phases()
if self.engine.chopper_system.isPhaseIndependent:
for idx in range(len(
self.engine.chopper_system.isPhaseIndependent)):
if idx > self.n_indep_phase:
chopper_number = self.engine.chopper_system.isPhaseIndependent[
idx]
phase_label = QLabel("")
phase_edit = QLineEdit(self)
phase_edit.returnPressed.connect(self.setFreq)
self.leftPanel.insertWidget(self.phase_index, phase_edit)
self.leftPanel.insertWidget(self.phase_index, phase_label)
self.widgets[f"Chopper{idx}Phase"] = {
'Edit': phase_edit,
'Label': phase_label
}
self.n_indep_phase += 1
self.phase_index += 2
else:
self.widgets[f"Chopper{idx}Phase"]['Edit'].show()
self.widgets[f"Chopper{idx}Phase"]['Label'].show()
self.widgets[f"Chopper{idx}Phase"]['Edit'].setText(
str(self.engine.chopper_system.defaultPhase[idx]))
self.widgets[f"Chopper{idx}Phase"]['Label'].setText(
self.engine.chopper_system.phaseNames[idx])
# Special case for MERLIN - hide phase control from normal users
if 'MERLIN' in str(instname) and not self.instSciAct.isChecked():
self.widgets['Chopper0Phase']['Edit'].hide()
self.widgets['Chopper0Phase']['Label'].hide()
self.engine.setChopper(
str(self.widgets['ChopperCombo']['Combo'].currentText()))
self.engine.setFrequency(
float(self.widgets['FrequencyCombo']['Combo'].currentText()))
val = self.flxslder.val * self.maxE[self.engine.instname] / 100
self.flxedt.setText('%3.2f' % (val))
nframe = self.engine.moderator.n_frame if hasattr(
self.engine.moderator, 'n_frame') else 1
self.repfig_nframe_edit.setText(str(nframe))
self.repfig_nframe_rep1only.setChecked(False)
if hasattr(self.engine.chopper_system, 'default_frequencies'):
cb = [
self.widgets['FrequencyCombo']['Combo'],
self.widgets['PulseRemoverCombo']['Combo']
]
for idx, freq in enumerate(
self.engine.chopper_system.default_frequencies):
cb[idx].setCurrentIndex([
i for i in range(cb[idx].count())
if str(freq) in cb[idx].itemText(i)
][0])
if idx > 1:
break
self.tabs.setTabEnabled(self.qetabID, False)
if self.engine.has_detector and hasattr(self.engine.detector,
'tthlims'):
self.tabs.setTabEnabled(self.qetabID, True)
def setChopper(self, choppername):
"""
Defines the Fermi chopper slit package type by name, or the disk chopper arrangement variant.
"""
self.engine.setChopper(str(choppername))
self.engine.setFrequency(
float(self.widgets['FrequencyCombo']['Combo'].currentText()))
# Special case for MERLIN - only enable multirep for 'G' chopper
self._merlin_chopper()
def setFreq(self, freqtext=None, **kwargs):
"""
Sets the chopper frequency(ies), in Hz.
"""
freq_gui = float(self.widgets['FrequencyCombo']['Combo'].currentText())
freq_in = kwargs['manual_freq'] if ('manual_freq'
in kwargs.keys()) else freq_gui
if len(self.engine.getFrequency()) > 1 and (
not hasattr(freq_in, '__len__') or len(freq_in) == 1):
freqpr = float(
self.widgets['PulseRemoverCombo']['Combo'].currentText())
freq_in = [freq_in, freqpr]
# Checks for independent phases
phases = []
for key, widget in self.widgets.items():
if key.endswith('Phase') and not widget['Label'].isHidden():
idx = int(key[7])
phase = widget['Edit'].text()
if isinstance(self.engine.chopper_system.defaultPhase[idx],
str):
phase = str(phase)
else:
phase = float(phase) % (1e6 /
self.engine.moderator.source_rep)
phases.append(phase)
if phases:
self.engine.setFrequency(freq_in, phase=phases)
else:
self.engine.setFrequency(freq_in)
def _hide_phases(self):
for widget in [
wdg for key, wdg in self.widgets.items()
if key.endswith('Phase')
]:
widget['Edit'].hide()
widget['Label'].hide()
def _merlin_chopper(self):
if 'MERLIN' in self.engine.instname:
if 'G' in self.engine.getChopper() and self.instSciAct.isChecked():
self.widgets['MultiRepCheck'].setEnabled(True)
self.tabs.setTabEnabled(self.tdtabID, True)
self.widgets['Chopper0Phase']['Edit'].setText('1500')
self.widgets['Chopper0Phase']['Label'].setText(
'Disk chopper phase delay time')
self.widgets['Chopper0Phase']['Edit'].show()
self.widgets['Chopper0Phase']['Label'].show()
else:
self.widgets['MultiRepCheck'].setEnabled(False)
self.widgets['MultiRepCheck'].setChecked(False)
self.tabs.setTabEnabled(self.tdtabID, False)
self._hide_phases()
def setEi(self):
"""
Sets the incident energy (or focused incident energy for multi-rep case).
"""
try:
eitxt = float(self.widgets['EiEdit']['Edit'].text())
self.engine.setEi(eitxt)
if self.eiPlots.isChecked():
self.calc_callback()
except ValueError:
raise ValueError('No Ei specified, or Ei string not understood')
def calc_callback(self):
"""
Calls routines to calculate the resolution / flux and to update the Matplotlib graphs.
"""
try:
if self.engine.getChopper() is None:
self.setChopper(
self.widgets['ChopperCombo']['Combo'].currentText())
self.setEi()
self.setFreq()
self.calculate()
if self.errormess:
idx = [
i for i, ei in enumerate(self.eis)
if np.abs(ei - self.engine.getEi()) < 1.e-4
]
if idx and self.flux[idx[0]] == 0:
raise ValueError(self.errormess)
self.errormessage(self.errormess)
self.plot_res()
self.plot_frame()
if self.instSciAct.isChecked():
self.update_script()
except ValueError as err:
self.errormessage(err)
self.plot_flux_ei()
self.plot_flux_hz()
def calculate(self):
"""
Performs the resolution and flux calculations.
"""
self.errormess = None
if self.engine.getEi() is None:
self.setEi()
if self.widgets['MultiRepCheck'].isChecked():
en = np.linspace(0, 0.95, 200)
self.eis = self.engine.getAllowedEi()
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always', UserWarning)
self.res = self.engine.getMultiRepResolution(en)
self.flux = self.engine.getMultiRepFlux()
if len(w) > 0:
mess = [str(w[i].message) for i in range(len(w))]
self.errormess = '\n'.join(
[m for m in mess if 'tchop' in m])
else:
en = np.linspace(0, 0.95 * self.engine.getEi(), 200)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always', UserWarning)
self.res = self.engine.getResolution(en)
self.flux = self.engine.getFlux()
if len(w) > 0:
raise ValueError(w[0].message)
def _set_overplot(self, overplot, axisname):
axis = getattr(self, axisname)
if overplot:
if matplotlib.compare_versions('2.1.0', matplotlib.__version__):
axis.hold(True)
else:
setattr(self, axisname + '_xlim', 0)
axis.clear()
axis.axhline(color='k')
def plot_res(self):
"""
Plots the resolution in the resolution tab
"""
overplot = self.widgets['HoldCheck'].isChecked()
multiplot = self.widgets['MultiRepCheck'].isChecked()
self._set_overplot(overplot, 'resaxes')
self._set_overplot(overplot, 'qeaxes')
inst = self.engine.instname
freq = self.engine.getFrequency()
if hasattr(freq, '__len__'):
freq = freq[0]
if multiplot:
if matplotlib.compare_versions('2.1.0', matplotlib.__version__):
self.resaxes.hold(True)
for ie, Ei in enumerate(self.eis):
en = np.linspace(0, 0.95 * Ei, 200)
if any(self.res[ie]):
if not self.flux[ie]:
continue
line, = self.resaxes.plot(en, self.res[ie])
label_text = '%s_%3.2fmeV_%dHz_Flux=%fn/cm2/s' % (
inst, Ei, freq, self.flux[ie])
line.set_label(label_text)
if self.tabs.isTabEnabled(self.qetabID):
self.plot_qe(Ei, label_text, hold=True)
self.resaxes_xlim = max(Ei, self.resaxes_xlim)
if matplotlib.compare_versions('2.1.0', matplotlib.__version__):
self.resaxes.hold(False)
else:
ei = self.engine.getEi()
en = np.linspace(0, 0.95 * ei, 200)
line, = self.resaxes.plot(en, self.res)
chopper = self.engine.getChopper()
label_text = '%s_%s_%3.2fmeV_%dHz_Flux=%fn/cm2/s' % (
inst, chopper, ei, freq, self.flux)
line.set_label(label_text)
if self.tabs.isTabEnabled(self.qetabID):
self.plot_qe(ei, label_text, overplot)
self.resaxes_xlim = max(ei, self.resaxes_xlim)
self.resaxes.set_xlim([0, self.resaxes_xlim])
legend_set_draggable(self.resaxes.legend(), True)
self.resaxes.set_xlabel('Energy Transfer (meV)')
self.resaxes.set_ylabel(r'$\Delta$E (meV FWHM)')
self.rescanvas.draw()
def plot_qe(self, Ei, label_text, hold=False):
""" Plots the Q-E diagram """
from scipy import constants
E2q, meV2J = (2. * constants.m_n / (constants.hbar**2),
constants.e / 1000.)
en = np.linspace(-Ei / 5., Ei, 100)
q2 = []
for tth in self.engine.detector.tthlims:
q = np.sqrt(E2q * (2 * Ei - en - 2 * np.sqrt(Ei * (Ei - en)) *
np.cos(np.deg2rad(tth))) * meV2J) / 1e10
q2.append(np.concatenate((np.flipud(q), q)))
self._set_overplot(hold, 'qeaxes')
self.qeaxes_xlim = max(np.max(q2), self.qeaxes_xlim)
line, = self.qeaxes.plot(
np.hstack(q2),
np.concatenate((np.flipud(en), en)).tolist() *
len(self.engine.detector.tthlims))
line.set_label(label_text)
self.qeaxes.set_xlim([0, self.qeaxes_xlim])
legend_set_draggable(self.qeaxes.legend(), True)
self.qeaxes.set_xlabel(r'$|Q| (\mathrm{\AA}^{-1})$')
self.qeaxes.set_ylabel('Energy Transfer (meV)')
self.qecanvas.draw()
def plot_flux_ei(self, **kwargs):
"""
Plots the flux vs Ei in the middle tab
"""
inst = self.engine.instname
chop = self.engine.getChopper()
freq = self.engine.getFrequency()
overplot = self.widgets['HoldCheck'].isChecked()
if hasattr(freq, '__len__'):
freq = freq[0]
update = kwargs['update'] if 'update' in kwargs.keys() else False
# Do not recalculate if all relevant parameters still the same.
_, labels = self.flxaxes2.get_legend_handles_labels()
searchStr = '([A-Z0-9]+) "(.+)" ([0-9]+) Hz'
tmpinst = []
if (labels and (overplot or len(labels) == 1)) or update:
for prevtitle in labels:
prevInst, prevChop, prevFreq = re.search(searchStr,
prevtitle).groups()
if update:
tmpinst.append(
copy.deepcopy(
Instrument(self.instruments[prevInst], prevChop,
float(prevFreq))))
else:
if inst == prevInst and chop == prevChop and freq == float(
prevFreq):
return
ne = 25
mn = self.minE[inst]
mx = (self.flxslder.val / 100) * self.maxE[inst]
eis = np.linspace(mn, mx, ne)
flux = eis * 0
elres = eis * 0
if update:
self.flxaxes1.clear()
self.flxaxes2.clear()
if matplotlib.compare_versions('2.1.0', matplotlib.__version__):
self.flxaxes1.hold(True)
self.flxaxes2.hold(True)
for ii, instrument in enumerate(tmpinst):
for ie, ei in enumerate(eis):
with warnings.catch_warnings(record=True):
warnings.simplefilter('always', UserWarning)
flux[ie] = instrument.getFlux(ei)
elres[ie] = instrument.getResolution(0., ei)[0]
self.flxaxes1.plot(eis, flux)
line, = self.flxaxes2.plot(eis, elres)
line.set_label(labels[ii])
else:
for ie, ei in enumerate(eis):
with warnings.catch_warnings(record=True):
warnings.simplefilter('always', UserWarning)
flux[ie] = self.engine.getFlux(ei)
elres[ie] = self.engine.getResolution(0., ei)[0]
if overplot:
if matplotlib.compare_versions('2.1.0',
matplotlib.__version__):
self.flxaxes1.hold(True)
self.flxaxes2.hold(True)
else:
self.flxaxes1.clear()
self.flxaxes2.clear()
self.flxaxes1.plot(eis, flux)
line, = self.flxaxes2.plot(eis, elres)
line.set_label('%s "%s" %d Hz' % (inst, chop, freq))
self.flxaxes1.set_xlim([mn, mx])
self.flxaxes2.set_xlim([mn, mx])
self.flxaxes1.set_xlabel('Incident Energy (meV)')
self.flxaxes1.set_ylabel('Flux (n/cm$^2$/s)')
self.flxaxes1.set_xlabel('Incident Energy (meV)')
self.flxaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
lg = self.flxaxes2.legend()
legend_set_draggable(lg, True)
self.flxcanvas.draw()
def update_slider(self, val=None):
"""
Callback function for the x-axis slider of the flux tab
"""
if val is None:
val = float(
self.flxedt.text()) / self.maxE[self.engine.instname] * 100
if val < self.minE[self.engine.instname]:
self.errormessage("Max Ei must be greater than %2.1f" %
(self.minE[self.engine.instname]))
val = (self.minE[self.engine.instname] +
0.1) / self.maxE[self.engine.instname] * 100
self.flxslder.set_val(val)
else:
val = self.flxslder.val * self.maxE[self.engine.instname] / 100
self.flxedt.setText('%3.2f' % (val))
self.plot_flux_ei(update=True)
self.flxcanvas.draw()
def plot_flux_hz(self):
"""
Plots the flux vs freq in the middle tab
"""
inst = self.engine.instname
chop = self.engine.getChopper()
ei = float(self.widgets['EiEdit']['Edit'].text())
overplot = self.widgets['HoldCheck'].isChecked()
# Do not recalculate if one of the plots has the same parametersc
_, labels = self.frqaxes2.get_legend_handles_labels()
searchStr = '([A-Z0-9]+) "(.+)" Ei = ([0-9.-]+) meV'
if labels and (overplot or len(labels) == 1):
for prevtitle in labels:
prevInst, prevChop, prevEi = re.search(searchStr,
prevtitle).groups()
if inst == prevInst and chop == prevChop and abs(
ei - float(prevEi)) < 0.01:
return
freq0 = self.engine.getFrequency()
rep = self.engine.moderator.source_rep
maxfreq = self.engine.chopper_system.max_frequencies
freqs = range(
rep, (maxfreq[0] if hasattr(maxfreq, '__len__') else maxfreq) + 1,
rep)
flux = np.zeros(len(freqs))
elres = np.zeros(len(freqs))
for ie, freq in enumerate(freqs):
if hasattr(freq0, '__len__'):
self.setFreq(manual_freq=[freq] + freq0[1:])
else:
self.setFreq(manual_freq=freq)
with warnings.catch_warnings(record=True):
warnings.simplefilter('always', UserWarning)
flux[ie] = self.engine.getFlux(ei)
elres[ie] = self.engine.getResolution(0., ei)[0]
if overplot:
if matplotlib.compare_versions('2.1.0', matplotlib.__version__):
self.frqaxes1.hold(True)
self.frqaxes2.hold(True)
else:
self.frqaxes1.clear()
self.frqaxes2.clear()
self.setFreq(manual_freq=freq0)
self.frqaxes1.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes1.set_ylabel('Flux (n/cm$^2$/s)')
line, = self.frqaxes1.plot(freqs, flux, 'o-')
self.frqaxes1.set_xlim([0, np.max(freqs)])
self.frqaxes2.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
line, = self.frqaxes2.plot(freqs, elres, 'o-')
line.set_label('%s "%s" Ei = %5.3f meV' % (inst, chop, ei))
lg = self.frqaxes2.legend()
legend_set_draggable(lg, True)
self.frqaxes2.set_xlim([0, np.max(freqs)])
self.frqcanvas.draw()
def instSciCB(self):
"""
Callback function for the "Instrument Scientist Mode" menu option
"""
# MERLIN is a special case - want to hide ability to change phase from users
self._merlin_chopper()
if self.instSciAct.isChecked():
self.tabs.insertTab(self.scrtabID, self.scrtab, 'ScriptOutput')
self.scrtab.show()
else:
self.tabs.removeTab(self.scrtabID)
self.scrtab.hide()
def errormessage(self, message):
msg = QMessageBox()
msg.setText(str(message))
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
def loadYaml(self):
yaml_file = QFileDialog().getOpenFileName(self.mainWidget,
'Open Instrument YAML File',
self.folder,
'Files (*.yaml)')
if isinstance(yaml_file, tuple):
yaml_file = yaml_file[0]
yaml_file = str(yaml_file)
new_folder = os.path.dirname(yaml_file)
if new_folder != self.folder:
self.folder = new_folder
try:
new_inst = Instrument(yaml_file)
except (RuntimeError, AttributeError, ValueError) as err:
self.errormessage(err)
newname = new_inst.name
if newname in self.instruments.keys(
) and not self.overwriteload.isChecked():
overwrite, newname = self._ask_overwrite()
if overwrite == 1:
return
elif overwrite == 0:
newname = new_inst.name
self.instruments[newname] = new_inst
self.choppers[newname] = new_inst.getChopperNames()
self.minE[newname] = max([new_inst.emin, 0.01])
self.maxE[newname] = new_inst.emax
self.updateInstrumentList()
combo = self.widgets['InstrumentCombo']['Combo']
idx = [
i for i in range(combo.count())
if str(combo.itemText(i)) == newname
]
combo.setCurrentIndex(idx[0])
self.setInstrument(newname)
def _ask_overwrite(self):
msg = QDialog()
msg.setWindowTitle('Load overwrite')
layout = QGridLayout()
layout.addWidget(
QLabel('Instrument %s already exists in memory. Overwrite this?'),
0, 0, 1, -1)
buttons = [
QPushButton(label) for label in
['Load and overwrite', 'Cancel Load', 'Load and rename to']
]
locations = [[1, 0], [1, 1], [2, 0]]
self.overwrite_flag = 1
def overwriteCB(idx):
self.overwrite_flag = idx
msg.accept()
for idx, button in enumerate(buttons):
button.clicked.connect(lambda _, idx=idx: overwriteCB(idx))
layout.addWidget(button, locations[idx][0], locations[idx][1])
newname = QLineEdit()
newname.editingFinished.connect(lambda: overwriteCB(2))
layout.addWidget(newname, 2, 1)
msg.setLayout(layout)
msg.exec_()
newname = str(newname.text())
if not newname or newname in self.instruments:
self.errormessage('Invalid instrument name. Cancelling load.')
self.overwrite_flag = 1
return self.overwrite_flag, newname
def updateInstrumentList(self):
combo = self.widgets['InstrumentCombo']['Combo']
old_instruments = [
str(combo.itemText(i)) for i in range(combo.count())
]
new_instruments = [
inst for inst in self.instruments if inst not in old_instruments
]
for inst in new_instruments:
combo.addItem(inst)
def plot_frame(self):
"""
Plots the distance-time diagram in the right tab
"""
if len(self.engine.chopper_system.choppers) > 1:
self.engine.n_frame = int(self.repfig_nframe_edit.text())
self.repaxes.clear()
self.engine.plotMultiRepFrame(
self.repaxes,
first_rep=self.repfig_nframe_rep1only.isChecked())
self.repcanvas.draw()
def _gen_text_ei(self, ei, obj_in):
obj = Instrument(obj_in)
obj.setEi(ei)
en = np.linspace(0, 0.95 * ei, 10)
try:
flux = self.engine.getFlux()
res = self.engine.getResolution(en)
except ValueError as err:
self.errormessage(err)
raise ValueError(err)
tsqvan, tsqdic, tsqmodchop = obj.getVanVar()
v_mod, v_chop = tuple(np.sqrt(tsqmodchop[:2]) * 1e6)
x0, _, x1, x2, _ = obj.chopper_system.getDistances()
first_component = 'moderator'
if x0 != tsqmodchop[2]:
x0 = tsqmodchop[2]
first_component = 'chopper 1'
txt = '# ------------------------------------------------------------- #\n'
txt += '# Ei = %8.2f meV\n' % (ei)
txt += '# Flux = %8.2f n/cm2/s\n' % (flux)
txt += '# Elastic resolution = %6.2f meV\n' % (res[0])
txt += '# Time width at sample = %6.2f us, of which:\n' % (
1e6 * np.sqrt(tsqvan))
for ky, val in list(tsqdic.items()):
txt += '# %20s : %6.2f us\n' % (ky, 1e6 * np.sqrt(val))
txt += '# %s distances:\n' % (obj.instname)
txt += '# x0 = %6.2f m (%s to Fermi)\n' % (x0, first_component)
txt += '# x1 = %6.2f m (Fermi to sample)\n' % (x1)
txt += '# x2 = %6.2f m (sample to detector)\n' % (x2)
txt += '# Approximate inelastic resolution is given by:\n'
txt += '# dE = 2 * E2V * sqrt(ef**3 * t_van**2) / x2\n'
txt += '# where: E2V = 4.373e-4 meV/(m/us) conversion from energy to speed\n'
txt += '# t_van**2 = (geom*t_mod)**2 + ((1+geom)*t_chop)**2\n'
txt += '# geom = (x1 + x2*(ei/ef)**1.5) / x0\n'
txt += '# and t_mod and t_chop are the moderator and chopper time widths at the\n'
txt += '# moderator and chopper positions (not at the sample as listed above).\n'
txt += '# Which in this case is:\n'
txt += '# %.4e*sqrt(ef**3 * ( (%6.5f*(%.3f+%.3f*(ei/ef)**1.5))**2 \n' % (
874.78672e-6 / x2, v_mod, x1 / x0, x2 / x0)
txt += '# + (%6.5f*(%.3f+%.3f*(ei/ef)**1.5))**2) )\n' % (
v_chop, 1 + x1 / x0, x2 / x0)
txt += '# EN (meV) Full dE (meV) Approx dE (meV)\n'
for ii in range(len(res)):
ef = ei - en[ii]
approx = (874.78672e-6 / x2) * np.sqrt(ef**3 * (
(v_mod * ((x1 / x0) + (x2 / x0) * (ei / ef)**1.5))**2 +
(v_chop * (1 + (x1 / x0) + (x2 / x0) * (ei / ef)**1.5))**2))
txt += '%12.5f %12.5f %12.5f\n' % (en[ii], res[ii], approx)
return txt
def genText(self):
"""
Generates text output of the resolution function versus energy transfer and other information.
"""
multiplot = self.widgets['MultiRepCheck'].isChecked()
obj = self.engine
if obj.getChopper() is None:
self.setChopper(
self.widgets['ChopperCombo']['Combo'].currentText())
if obj.getEi() is None:
self.setEi()
instname, chtyp, freqs, ei_in = tuple(
[obj.instname,
obj.getChopper(),
obj.getFrequency(),
obj.getEi()])
txt = '# ------------------------------------------------------------- #\n'
txt += '# Chop calculation for instrument %s\n' % (instname)
if obj.isFermi:
txt += '# with chopper %s at %3i Hz\n' % (chtyp, freqs[0])
else:
txt += '# in %s mode with:\n' % (chtyp)
freq_names = obj.chopper_system.frequency_names
for idx in range(len(freq_names)):
txt += '# %s at %3i Hz\n' % (freq_names[idx], freqs[idx])
txt += self._gen_text_ei(ei_in, obj)
if multiplot:
for ei in sorted(self.engine.getAllowedEi()):
if np.abs(ei - ei_in) > 0.001:
txt += self._gen_text_ei(ei, obj)
return txt
def showText(self):
"""
Creates a dialog to show the generated text output.
"""
try:
generatedText = self.genText()
except ValueError:
return
self.txtwin = QDialog()
self.txtedt = QTextEdit()
self.txtbtn = QPushButton('OK')
self.txtwin.layout = QVBoxLayout(self.txtwin)
self.txtwin.layout.addWidget(self.txtedt)
self.txtwin.layout.addWidget(self.txtbtn)
self.txtbtn.clicked.connect(self.txtwin.deleteLater)
self.txtedt.setText(generatedText)
self.txtedt.setReadOnly(True)
self.txtwin.setWindowTitle('Resolution information')
self.txtwin.setWindowModality(Qt.ApplicationModal)
self.txtwin.setAttribute(Qt.WA_DeleteOnClose)
self.txtwin.setMinimumSize(400, 600)
self.txtwin.resize(400, 600)
self.txtwin.show()
self.txtloop = QEventLoop()
self.txtloop.exec_()
def saveText(self):
"""
Saves the generated text to a file (opens file dialog).
"""
fname = QFileDialog.getSaveFileName(self, 'Open file', '')
if isinstance(fname, tuple):
fname = fname[0]
fid = open(fname, 'w')
fid.write(self.genText())
fid.close()
def update_script(self):
"""
Updates the text window with information about the previous calculation.
"""
if self.widgets['MultiRepCheck'].isChecked():
out = self.engine.getMultiWidths()
new_str = '\n'
for ie, ee in enumerate(out['Eis']):
res = out['Energy'][ie]
percent = res / ee * 100
chop_width = out['chopper'][ie]
mod_width = out['moderator'][ie]
new_str += 'Ei is %6.2f meV, resolution is %6.2f ueV, percentage resolution is %6.3f\n' % (
ee, res * 1000, percent)
new_str += 'FWHM at sample from chopper and moderator are %6.2f us, %6.2f us\n' % (
chop_width, mod_width)
else:
ei = self.engine.getEi()
out = self.engine.getWidths()
res = out['Energy']
percent = res / ei * 100
chop_width = out['chopper']
mod_width = out['moderator']
new_str = '\nEi is %6.2f meV, resolution is %6.2f ueV, percentage resolution is %6.3f\n' % (
ei, res * 1000, percent)
new_str += 'FWHM at sample from chopper and moderator are %6.2f us, %6.2f us\n' % (
chop_width, mod_width)
self.scredt.append(new_str)
def onHelp(self):
"""
Shows the help page
"""
try:
from pymantidplot.proxies import showCustomInterfaceHelp
showCustomInterfaceHelp("PyChop")
except ImportError:
helpTxt = "PyChop is a tool to allow direct inelastic neutron\nscattering users to estimate the inelastic resolution\n"
helpTxt += "and incident flux for a given spectrometer setting.\n\nFirst select the instrument, chopper settings and\n"
helpTxt += "Ei, and then click 'Calculate and Plot'. Data for all\nthe graphs will be generated (may take 1-2s) and\n"
helpTxt += "all graphs will be updated. If the 'Hold current plot'\ncheck box is ticked, additional settings will be\n"
helpTxt += "overplotted on the existing graphs if they are\ndifferent from previous settings.\n\nMore in-depth help "
helpTxt += "can be obtained from the\nMantid help pages."
self.hlpwin = QDialog()
self.hlpedt = QLabel(helpTxt)
self.hlpbtn = QPushButton('OK')
self.hlpwin.layout = QVBoxLayout(self.hlpwin)
self.hlpwin.layout.addWidget(self.hlpedt)
self.hlpwin.layout.addWidget(self.hlpbtn)
self.hlpbtn.clicked.connect(self.hlpwin.deleteLater)
self.hlpwin.setWindowTitle('Help')
self.hlpwin.setWindowModality(Qt.ApplicationModal)
self.hlpwin.setAttribute(Qt.WA_DeleteOnClose)
self.hlpwin.setMinimumSize(370, 300)
self.hlpwin.resize(370, 300)
self.hlpwin.show()
self.hlploop = QEventLoop()
self.hlploop.exec_()
def drawLayout(self):
"""
Draws the GUI layout.
"""
self.widgetslist = [[
'pair', 'show', 'Instrument', 'combo', self.instruments,
self.setInstrument, 'InstrumentCombo'
],
[
'pair', 'show', 'Chopper', 'combo', '',
self.setChopper, 'ChopperCombo'
],
[
'pair', 'show', 'Frequency', 'combo', '',
self.setFreq, 'FrequencyCombo'
],
[
'pair', 'hide', 'Pulse remover chopper freq',
'combo', '', self.setFreq, 'PulseRemoverCombo'
],
[
'pair', 'show', 'Ei', 'edit', '', self.setEi,
'EiEdit'
],
[
'pair', 'hide', 'Chopper 2 phase delay time',
'edit', '5', self.setFreq, 'Chopper2Phase'
], ['spacer'],
[
'single', 'show', 'Calculate and Plot',
'button', self.calc_callback, 'CalculateButton'
],
[
'single', 'show', 'Hold current plot', 'check',
lambda: None, 'HoldCheck'
],
[
'single', 'show', 'Show multi-reps', 'check',
lambda: None, 'MultiRepCheck'
], ['spacer'],
[
'single', 'show', 'Show data ascii window',
'button', self.showText, 'ShowAsciiButton'
],
[
'single', 'show', 'Save data as ascii',
'button', self.saveText, 'SaveAsciiButton'
]]
self.droplabels = []
self.dropboxes = []
self.singles = []
self.widgets = {}
self.leftPanel = QVBoxLayout()
self.rightPanel = QVBoxLayout()
self.tabs = QTabWidget(self)
self.fullWindow = QGridLayout()
self.n_indep_phase = -1
idx = 0
for widget in self.widgetslist:
if widget[-1] == 'Chopper2Phase':
self.phase_index = idx
continue
if 'pair' in widget[0]:
self.droplabels.append(QLabel(widget[2]))
if 'combo' in widget[3]:
self.dropboxes.append(QComboBox(self))
self.dropboxes[-1].activated['QString'].connect(widget[5])
for item in widget[4]:
self.dropboxes[-1].addItem(item)
self.widgets[widget[-1]] = {
'Combo': self.dropboxes[-1],
'Label': self.droplabels[-1]
}
elif 'edit' in widget[3]:
self.dropboxes.append(QLineEdit(self))
self.dropboxes[-1].returnPressed.connect(widget[5])
self.widgets[widget[-1]] = {
'Edit': self.dropboxes[-1],
'Label': self.droplabels[-1]
}
else:
raise RuntimeError(
'Bug in code - widget %s is not recognised.' %
(widget[3]))
self.leftPanel.addWidget(self.droplabels[-1])
self.leftPanel.addWidget(self.dropboxes[-1])
idx += 2
if 'hide' in widget[1]:
self.droplabels[-1].hide()
self.dropboxes[-1].hide()
elif 'single' in widget[0]:
if 'check' in widget[3]:
self.singles.append(QCheckBox(widget[2], self))
self.singles[-1].stateChanged.connect(widget[4])
elif 'button' in widget[3]:
self.singles.append(QPushButton(widget[2]))
self.singles[-1].clicked.connect(widget[4])
else:
raise RuntimeError(
'Bug in code - widget %s is not recognised.' %
(widget[3]))
self.leftPanel.addWidget(self.singles[-1])
idx += 1
if 'hide' in widget[1]:
self.singles[-1].hide()
self.widgets[widget[-1]] = self.singles[-1]
elif 'spacer' in widget[0]:
self.leftPanel.addItem(QSpacerItem(0, 35))
idx += 1
else:
raise RuntimeError(
'Bug in code - widget class %s is not recognised.' %
(widget[0]))
# Right panel, matplotlib figures
self.resfig = Figure()
self.resfig.patch.set_facecolor('white')
self.rescanvas = FigureCanvas(self.resfig)
self.resaxes = self.resfig.add_subplot(111)
self.resaxes.axhline(color='k')
self.resaxes.set_xlabel('Energy Transfer (meV)')
self.resaxes.set_ylabel(r'$\Delta$E (meV FWHM)')
self.resfig_controls = NavigationToolbar(self.rescanvas, self)
self.restab = QWidget(self.tabs)
self.restabbox = QVBoxLayout()
self.restabbox.addWidget(self.rescanvas)
self.restabbox.addWidget(self.resfig_controls)
self.restab.setLayout(self.restabbox)
self.flxfig = Figure()
self.flxfig.patch.set_facecolor('white')
self.flxcanvas = FigureCanvas(self.flxfig)
self.flxaxes1 = self.flxfig.add_subplot(121)
self.flxaxes1.set_xlabel('Incident Energy (meV)')
self.flxaxes1.set_ylabel('Flux (n/cm$^2$/s)')
self.flxaxes2 = self.flxfig.add_subplot(122)
self.flxaxes2.set_xlabel('Incident Energy (meV)')
self.flxaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
self.flxfig_controls = NavigationToolbar(self.flxcanvas, self)
self.flxsldfg = Figure()
self.flxsldfg.patch.set_facecolor('white')
self.flxsldcv = FigureCanvas(self.flxsldfg)
self.flxsldax = self.flxsldfg.add_subplot(111)
self.flxslder = Slider(self.flxsldax, 'Ei (meV)', 0, 100, valinit=100)
self.flxslder.valtext.set_visible(False)
self.flxslder.on_changed(self.update_slider)
self.flxedt = QLineEdit()
self.flxedt.setText('1000')
self.flxedt.returnPressed.connect(self.update_slider)
self.flxtab = QWidget(self.tabs)
self.flxsldbox = QHBoxLayout()
self.flxsldbox.addWidget(self.flxsldcv)
self.flxsldbox.addWidget(self.flxedt)
self.flxsldwdg = QWidget()
self.flxsldwdg.setLayout(self.flxsldbox)
sz = self.flxsldwdg.maximumSize()
sz.setHeight(50)
self.flxsldwdg.setMaximumSize(sz)
self.flxtabbox = QVBoxLayout()
self.flxtabbox.addWidget(self.flxcanvas)
self.flxtabbox.addWidget(self.flxsldwdg)
self.flxtabbox.addWidget(self.flxfig_controls)
self.flxtab.setLayout(self.flxtabbox)
self.frqfig = Figure()
self.frqfig.patch.set_facecolor('white')
self.frqcanvas = FigureCanvas(self.frqfig)
self.frqaxes1 = self.frqfig.add_subplot(121)
self.frqaxes1.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes1.set_ylabel('Flux (n/cm$^2$/s)')
self.frqaxes2 = self.frqfig.add_subplot(122)
self.frqaxes1.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
self.frqfig_controls = NavigationToolbar(self.frqcanvas, self)
self.frqtab = QWidget(self.tabs)
self.frqtabbox = QVBoxLayout()
self.frqtabbox.addWidget(self.frqcanvas)
self.frqtabbox.addWidget(self.frqfig_controls)
self.frqtab.setLayout(self.frqtabbox)
self.repfig = Figure()
self.repfig.patch.set_facecolor('white')
self.repcanvas = FigureCanvas(self.repfig)
self.repaxes = self.repfig.add_subplot(111)
self.repaxes.axhline(color='k')
self.repaxes.set_xlabel(r'TOF ($\mu$sec)')
self.repaxes.set_ylabel('Distance (m)')
self.repfig_controls = NavigationToolbar(self.repcanvas, self)
self.repfig_nframe_label = QLabel('Number of frames to plot')
self.repfig_nframe_edit = QLineEdit('1')
self.repfig_nframe_button = QPushButton('Replot')
self.repfig_nframe_button.clicked.connect(lambda: self.plot_frame())
self.repfig_nframe_rep1only = QCheckBox('First Rep Only')
self.repfig_nframe_box = QHBoxLayout()
self.repfig_nframe_box.addWidget(self.repfig_nframe_label)
self.repfig_nframe_box.addWidget(self.repfig_nframe_edit)
self.repfig_nframe_box.addWidget(self.repfig_nframe_button)
self.repfig_nframe_box.addWidget(self.repfig_nframe_rep1only)
self.reptab = QWidget(self.tabs)
self.repfig_nframe = QWidget(self.reptab)
self.repfig_nframe.setLayout(self.repfig_nframe_box)
self.repfig_nframe.setSizePolicy(
QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed))
self.reptabbox = QVBoxLayout()
self.reptabbox.addWidget(self.repcanvas)
self.reptabbox.addWidget(self.repfig_nframe)
self.reptabbox.addWidget(self.repfig_controls)
self.reptab.setLayout(self.reptabbox)
self.qefig = Figure()
self.qefig.patch.set_facecolor('white')
self.qecanvas = FigureCanvas(self.qefig)
self.qeaxes = self.qefig.add_subplot(111)
self.qeaxes.axhline(color='k')
self.qeaxes.set_xlabel(r'$|Q| (\mathrm{\AA}^{-1})$')
self.qeaxes.set_ylabel('Energy Transfer (meV)')
self.qefig_controls = NavigationToolbar(self.qecanvas, self)
self.qetabbox = QVBoxLayout()
self.qetabbox.addWidget(self.qecanvas)
self.qetabbox.addWidget(self.qefig_controls)
self.qetab = QWidget(self.tabs)
self.qetab.setLayout(self.qetabbox)
self.scrtab = QWidget(self.tabs)
self.scredt = QTextEdit()
self.scrcls = QPushButton("Clear")
self.scrcls.clicked.connect(lambda: self.scredt.clear())
self.scrbox = QVBoxLayout()
self.scrbox.addWidget(self.scredt)
self.scrbox.addWidget(self.scrcls)
self.scrtab.setLayout(self.scrbox)
self.scrtab.hide()
self.tabs.addTab(self.restab, 'Resolution')
self.tabs.addTab(self.flxtab, 'Flux-Ei')
self.tabs.addTab(self.frqtab, 'Flux-Freq')
self.tabs.addTab(self.reptab, 'Time-Distance')
self.tdtabID = 3
self.tabs.setTabEnabled(self.tdtabID, False)
self.tabs.addTab(self.qetab, 'Q-E')
self.qetabID = 4
self.tabs.setTabEnabled(self.qetabID, False)
self.scrtabID = 5
self.rightPanel.addWidget(self.tabs)
self.menuLoad = QMenu('Load')
self.loadAct = QAction('Load YAML', self.menuLoad)
self.loadAct.triggered.connect(self.loadYaml)
self.menuLoad.addAction(self.loadAct)
self.menuOptions = QMenu('Options')
self.instSciAct = QAction('Instrument Scientist Mode',
self.menuOptions,
checkable=True)
self.instSciAct.triggered.connect(self.instSciCB)
self.menuOptions.addAction(self.instSciAct)
self.eiPlots = QAction('Press Enter in Ei box updates plots',
self.menuOptions,
checkable=True)
self.menuOptions.addAction(self.eiPlots)
self.overwriteload = QAction('Always overwrite instruments in memory',
self.menuOptions,
checkable=True)
self.menuOptions.addAction(self.overwriteload)
self.menuBar().addMenu(self.menuLoad)
self.menuBar().addMenu(self.menuOptions)
self.leftPanelWidget = QWidget()
self.leftPanelWidget.setLayout(self.leftPanel)
self.leftPanelWidget.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred))
self.fullWindow.addWidget(self.leftPanelWidget, 0, 0)
self.fullWindow.addLayout(self.rightPanel, 0, 1)
self.helpbtn = QPushButton("?", self)
self.helpbtn.setMaximumWidth(30)
self.helpbtn.clicked.connect(self.onHelp)
self.fullWindow.addWidget(self.helpbtn, 1, 0, 1, -1)
self.mainWidget = QWidget()
self.mainWidget.setLayout(self.fullWindow)
self.setCentralWidget(self.mainWidget)
self.setWindowTitle('PyChopGUI')
self.show()
def drawLayout(self):
"""
Draws the GUI layout.
"""
self.widgetslist = [
['pair', 'show', 'Instrument', 'combo', self.instruments, self.setInstrument, 'InstrumentCombo'],
['pair', 'show', 'Chopper', 'combo', '', self.setChopper, 'ChopperCombo'],
['pair', 'show', 'Frequency', 'combo', '', self.setFreq, 'FrequencyCombo'],
['pair', 'hide', 'Pulse remover chopper freq', 'combo', '', self.setFreq, 'PulseRemoverCombo'],
['pair', 'show', 'Ei', 'edit', '', self.setEi, 'EiEdit'],
['pair', 'hide', 'Chopper 2 phase delay time', 'edit', '5', self.setFreq, 'Chopper2Phase'],
['spacer'],
['single', 'show', 'Calculate and Plot', 'button', self.calc_callback, 'CalculateButton'],
['single', 'show', 'Hold current plot', 'check', lambda: None, 'HoldCheck'],
['single', 'show', 'Show multi-reps', 'check', lambda: None, 'MultiRepCheck'],
['spacer'],
['single', 'show', 'Show data ascii window', 'button', self.showText, 'ShowAsciiButton'],
['single', 'show', 'Save data as ascii', 'button', self.saveText, 'SaveAsciiButton']
]
self.droplabels = []
self.dropboxes = []
self.singles = []
self.widgets = {}
self.leftPanel = QVBoxLayout()
self.rightPanel = QVBoxLayout()
self.tabs = QTabWidget(self)
self.fullWindow = QGridLayout()
for widget in self.widgetslist:
if 'pair' in widget[0]:
self.droplabels.append(QLabel(widget[2]))
if 'combo' in widget[3]:
self.dropboxes.append(QComboBox(self))
self.dropboxes[-1].activated['QString'].connect(widget[5])
for item in widget[4]:
self.dropboxes[-1].addItem(item)
self.widgets[widget[-1]] = {'Combo':self.dropboxes[-1], 'Label':self.droplabels[-1]}
elif 'edit' in widget[3]:
self.dropboxes.append(QLineEdit(self))
self.dropboxes[-1].returnPressed.connect(widget[5])
self.widgets[widget[-1]] = {'Edit':self.dropboxes[-1], 'Label':self.droplabels[-1]}
else:
raise RuntimeError('Bug in code - widget %s is not recognised.' % (widget[3]))
self.leftPanel.addWidget(self.droplabels[-1])
self.leftPanel.addWidget(self.dropboxes[-1])
if 'hide' in widget[1]:
self.droplabels[-1].hide()
self.dropboxes[-1].hide()
elif 'single' in widget[0]:
if 'check' in widget[3]:
self.singles.append(QCheckBox(widget[2], self))
self.singles[-1].stateChanged.connect(widget[4])
elif 'button' in widget[3]:
self.singles.append(QPushButton(widget[2]))
self.singles[-1].clicked.connect(widget[4])
else:
raise RuntimeError('Bug in code - widget %s is not recognised.' % (widget[3]))
self.leftPanel.addWidget(self.singles[-1])
if 'hide' in widget[1]:
self.singles[-1].hide()
self.widgets[widget[-1]] = self.singles[-1]
elif 'spacer' in widget[0]:
self.leftPanel.addItem(QSpacerItem(0, 35))
else:
raise RuntimeError('Bug in code - widget class %s is not recognised.' % (widget[0]))
# Right panel, matplotlib figures
self.resfig = Figure()
self.resfig.patch.set_facecolor('white')
self.rescanvas = FigureCanvas(self.resfig)
self.resaxes = self.resfig.add_subplot(111)
self.resaxes.axhline(color='k')
self.resaxes.set_xlabel('Energy Transfer (meV)')
self.resaxes.set_ylabel(r'$\Delta$E (meV FWHM)')
self.resfig_controls = NavigationToolbar(self.rescanvas, self)
self.restab = QWidget(self.tabs)
self.restabbox = QVBoxLayout()
self.restabbox.addWidget(self.rescanvas)
self.restabbox.addWidget(self.resfig_controls)
self.restab.setLayout(self.restabbox)
self.flxfig = Figure()
self.flxfig.patch.set_facecolor('white')
self.flxcanvas = FigureCanvas(self.flxfig)
self.flxaxes1 = self.flxfig.add_subplot(121)
self.flxaxes1.set_xlabel('Incident Energy (meV)')
self.flxaxes1.set_ylabel('Flux (n/cm$^2$/s)')
self.flxaxes2 = self.flxfig.add_subplot(122)
self.flxaxes2.set_xlabel('Incident Energy (meV)')
self.flxaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
self.flxfig_controls = NavigationToolbar(self.flxcanvas, self)
self.flxsldfg = Figure()
self.flxsldfg.patch.set_facecolor('white')
self.flxsldcv = FigureCanvas(self.flxsldfg)
self.flxsldax = self.flxsldfg.add_subplot(111)
self.flxslder = Slider(self.flxsldax, 'Ei (meV)', 0, 100, valinit=100)
self.flxslder.valtext.set_visible(False)
self.flxslder.on_changed(self.update_slider)
self.flxedt = QLineEdit()
self.flxedt.setText('1000')
self.flxedt.returnPressed.connect(self.update_slider)
self.flxtab = QWidget(self.tabs)
self.flxsldbox = QHBoxLayout()
self.flxsldbox.addWidget(self.flxsldcv)
self.flxsldbox.addWidget(self.flxedt)
self.flxsldwdg = QWidget()
self.flxsldwdg.setLayout(self.flxsldbox)
sz = self.flxsldwdg.maximumSize()
sz.setHeight(50)
self.flxsldwdg.setMaximumSize(sz)
self.flxtabbox = QVBoxLayout()
self.flxtabbox.addWidget(self.flxcanvas)
self.flxtabbox.addWidget(self.flxsldwdg)
self.flxtabbox.addWidget(self.flxfig_controls)
self.flxtab.setLayout(self.flxtabbox)
self.frqfig = Figure()
self.frqfig.patch.set_facecolor('white')
self.frqcanvas = FigureCanvas(self.frqfig)
self.frqaxes1 = self.frqfig.add_subplot(121)
self.frqaxes1.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes1.set_ylabel('Flux (n/cm$^2$/s)')
self.frqaxes2 = self.frqfig.add_subplot(122)
self.frqaxes1.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
self.frqfig_controls = NavigationToolbar(self.frqcanvas, self)
self.frqtab = QWidget(self.tabs)
self.frqtabbox = QVBoxLayout()
self.frqtabbox.addWidget(self.frqcanvas)
self.frqtabbox.addWidget(self.frqfig_controls)
self.frqtab.setLayout(self.frqtabbox)
self.repfig = Figure()
self.repfig.patch.set_facecolor('white')
self.repcanvas = FigureCanvas(self.repfig)
self.repaxes = self.repfig.add_subplot(111)
self.repaxes.axhline(color='k')
self.repaxes.set_xlabel(r'TOF ($\mu$sec)')
self.repaxes.set_ylabel('Distance (m)')
self.repfig_controls = NavigationToolbar(self.repcanvas, self)
self.repfig_nframe_label = QLabel('Number of frames to plot')
self.repfig_nframe_edit = QLineEdit('1')
self.repfig_nframe_button = QPushButton('Replot')
self.repfig_nframe_button.clicked.connect(lambda: self.plot_frame())
self.repfig_nframe_rep1only = QCheckBox('First Rep Only')
self.repfig_nframe_box = QHBoxLayout()
self.repfig_nframe_box.addWidget(self.repfig_nframe_label)
self.repfig_nframe_box.addWidget(self.repfig_nframe_edit)
self.repfig_nframe_box.addWidget(self.repfig_nframe_button)
self.repfig_nframe_box.addWidget(self.repfig_nframe_rep1only)
self.reptab = QWidget(self.tabs)
self.repfig_nframe = QWidget(self.reptab)
self.repfig_nframe.setLayout(self.repfig_nframe_box)
self.repfig_nframe.setSizePolicy(QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed))
self.reptabbox = QVBoxLayout()
self.reptabbox.addWidget(self.repcanvas)
self.reptabbox.addWidget(self.repfig_nframe)
self.reptabbox.addWidget(self.repfig_controls)
self.reptab.setLayout(self.reptabbox)
self.qefig = Figure()
self.qefig.patch.set_facecolor('white')
self.qecanvas = FigureCanvas(self.qefig)
self.qeaxes = self.qefig.add_subplot(111)
self.qeaxes.axhline(color='k')
self.qeaxes.set_xlabel(r'$|Q| (\mathrm{\AA}^{-1})$')
self.qeaxes.set_ylabel('Energy Transfer (meV)')
self.qefig_controls = NavigationToolbar(self.qecanvas, self)
self.qetabbox = QVBoxLayout()
self.qetabbox.addWidget(self.qecanvas)
self.qetabbox.addWidget(self.qefig_controls)
self.qetab = QWidget(self.tabs)
self.qetab.setLayout(self.qetabbox)
self.scrtab = QWidget(self.tabs)
self.scredt = QTextEdit()
self.scrcls = QPushButton("Clear")
self.scrcls.clicked.connect(lambda: self.scredt.clear())
self.scrbox = QVBoxLayout()
self.scrbox.addWidget(self.scredt)
self.scrbox.addWidget(self.scrcls)
self.scrtab.setLayout(self.scrbox)
self.scrtab.hide()
self.tabs.addTab(self.restab, 'Resolution')
self.tabs.addTab(self.flxtab, 'Flux-Ei')
self.tabs.addTab(self.frqtab, 'Flux-Freq')
self.tabs.addTab(self.reptab, 'Time-Distance')
self.tdtabID = 3
self.tabs.setTabEnabled(self.tdtabID, False)
self.tabs.addTab(self.qetab, 'Q-E')
self.qetabID = 4
self.tabs.setTabEnabled(self.qetabID, False)
self.scrtabID = 5
self.rightPanel.addWidget(self.tabs)
self.menuLoad = QMenu('Load')
self.loadAct = QAction('Load YAML', self.menuLoad)
self.loadAct.triggered.connect(self.loadYaml)
self.menuLoad.addAction(self.loadAct)
self.menuOptions = QMenu('Options')
self.instSciAct = QAction('Instrument Scientist Mode', self.menuOptions, checkable=True)
self.instSciAct.triggered.connect(self.instSciCB)
self.menuOptions.addAction(self.instSciAct)
self.eiPlots = QAction('Press Enter in Ei box updates plots', self.menuOptions, checkable=True)
self.menuOptions.addAction(self.eiPlots)
self.overwriteload = QAction('Always overwrite instruments in memory', self.menuOptions, checkable=True)
self.menuOptions.addAction(self.overwriteload)
self.menuBar().addMenu(self.menuLoad)
self.menuBar().addMenu(self.menuOptions)
self.leftPanelWidget = QWidget()
self.leftPanelWidget.setLayout(self.leftPanel)
self.leftPanelWidget.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred))
self.fullWindow.addWidget(self.leftPanelWidget, 0, 0)
self.fullWindow.addLayout(self.rightPanel, 0, 1)
self.helpbtn = QPushButton("?", self)
self.helpbtn.setMaximumWidth(30)
self.helpbtn.clicked.connect(self.onHelp)
self.fullWindow.addWidget(self.helpbtn, 1, 0, 1, -1)
self.mainWidget = QWidget()
self.mainWidget.setLayout(self.fullWindow)
self.setCentralWidget(self.mainWidget)
self.setWindowTitle('PyChopGUI')
self.show()
def drawLayout(self):
"""
Draws the GUI layout.
"""
self.widgetslist = [[
'pair', 'show', 'Instrument', 'combo', self.instruments,
self.setInstrument, 'InstrumentCombo'
],
[
'pair', 'show', 'Chopper', 'combo', '',
self.setChopper, 'ChopperCombo'
],
[
'pair', 'show', 'Frequency', 'combo', '',
self.setFreq, 'FrequencyCombo'
],
[
'pair', 'hide', 'Pulse remover chopper freq',
'combo', '', self.setFreq, 'PulseRemoverCombo'
],
[
'pair', 'show', 'Ei', 'edit', '', self.setEi,
'EiEdit'
],
[
'pair', 'hide', 'Chopper 2 phase delay time',
'edit', '5', self.setFreq, 'Chopper2Phase'
], ['spacer'],
[
'single', 'show', 'Calculate and Plot',
'button', self.calc_callback, 'CalculateButton'
],
[
'single', 'show', 'Hold current plot', 'check',
lambda: None, 'HoldCheck'
],
[
'single', 'show', 'Show multi-reps', 'check',
lambda: None, 'MultiRepCheck'
], ['spacer'],
[
'single', 'show', 'Show data ascii window',
'button', self.showText, 'ShowAsciiButton'
],
[
'single', 'show', 'Save data as ascii',
'button', self.saveText, 'SaveAsciiButton'
]]
self.droplabels = []
self.dropboxes = []
self.singles = []
self.widgets = {}
self.leftPanel = QVBoxLayout()
self.rightPanel = QVBoxLayout()
self.tabs = QTabWidget(self)
self.fullWindow = QGridLayout()
self.n_indep_phase = -1
idx = 0
for widget in self.widgetslist:
if widget[-1] == 'Chopper2Phase':
self.phase_index = idx
continue
if 'pair' in widget[0]:
self.droplabels.append(QLabel(widget[2]))
if 'combo' in widget[3]:
self.dropboxes.append(QComboBox(self))
self.dropboxes[-1].activated['QString'].connect(widget[5])
for item in widget[4]:
self.dropboxes[-1].addItem(item)
self.widgets[widget[-1]] = {
'Combo': self.dropboxes[-1],
'Label': self.droplabels[-1]
}
elif 'edit' in widget[3]:
self.dropboxes.append(QLineEdit(self))
self.dropboxes[-1].returnPressed.connect(widget[5])
self.widgets[widget[-1]] = {
'Edit': self.dropboxes[-1],
'Label': self.droplabels[-1]
}
else:
raise RuntimeError(
'Bug in code - widget %s is not recognised.' %
(widget[3]))
self.leftPanel.addWidget(self.droplabels[-1])
self.leftPanel.addWidget(self.dropboxes[-1])
idx += 2
if 'hide' in widget[1]:
self.droplabels[-1].hide()
self.dropboxes[-1].hide()
elif 'single' in widget[0]:
if 'check' in widget[3]:
self.singles.append(QCheckBox(widget[2], self))
self.singles[-1].stateChanged.connect(widget[4])
elif 'button' in widget[3]:
self.singles.append(QPushButton(widget[2]))
self.singles[-1].clicked.connect(widget[4])
else:
raise RuntimeError(
'Bug in code - widget %s is not recognised.' %
(widget[3]))
self.leftPanel.addWidget(self.singles[-1])
idx += 1
if 'hide' in widget[1]:
self.singles[-1].hide()
self.widgets[widget[-1]] = self.singles[-1]
elif 'spacer' in widget[0]:
self.leftPanel.addItem(QSpacerItem(0, 35))
idx += 1
else:
raise RuntimeError(
'Bug in code - widget class %s is not recognised.' %
(widget[0]))
# Right panel, matplotlib figures
self.resfig = Figure()
self.resfig.patch.set_facecolor('white')
self.rescanvas = FigureCanvas(self.resfig)
self.resaxes = self.resfig.add_subplot(111)
self.resaxes.axhline(color='k')
self.resaxes.set_xlabel('Energy Transfer (meV)')
self.resaxes.set_ylabel(r'$\Delta$E (meV FWHM)')
self.resfig_controls = NavigationToolbar(self.rescanvas, self)
self.restab = QWidget(self.tabs)
self.restabbox = QVBoxLayout()
self.restabbox.addWidget(self.rescanvas)
self.restabbox.addWidget(self.resfig_controls)
self.restab.setLayout(self.restabbox)
self.flxfig = Figure()
self.flxfig.patch.set_facecolor('white')
self.flxcanvas = FigureCanvas(self.flxfig)
self.flxaxes1 = self.flxfig.add_subplot(121)
self.flxaxes1.set_xlabel('Incident Energy (meV)')
self.flxaxes1.set_ylabel('Flux (n/cm$^2$/s)')
self.flxaxes2 = self.flxfig.add_subplot(122)
self.flxaxes2.set_xlabel('Incident Energy (meV)')
self.flxaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
self.flxfig_controls = NavigationToolbar(self.flxcanvas, self)
self.flxsldfg = Figure()
self.flxsldfg.patch.set_facecolor('white')
self.flxsldcv = FigureCanvas(self.flxsldfg)
self.flxsldax = self.flxsldfg.add_subplot(111)
self.flxslder = Slider(self.flxsldax, 'Ei (meV)', 0, 100, valinit=100)
self.flxslder.valtext.set_visible(False)
self.flxslder.on_changed(self.update_slider)
self.flxedt = QLineEdit()
self.flxedt.setText('1000')
self.flxedt.returnPressed.connect(self.update_slider)
self.flxtab = QWidget(self.tabs)
self.flxsldbox = QHBoxLayout()
self.flxsldbox.addWidget(self.flxsldcv)
self.flxsldbox.addWidget(self.flxedt)
self.flxsldwdg = QWidget()
self.flxsldwdg.setLayout(self.flxsldbox)
sz = self.flxsldwdg.maximumSize()
sz.setHeight(50)
self.flxsldwdg.setMaximumSize(sz)
self.flxtabbox = QVBoxLayout()
self.flxtabbox.addWidget(self.flxcanvas)
self.flxtabbox.addWidget(self.flxsldwdg)
self.flxtabbox.addWidget(self.flxfig_controls)
self.flxtab.setLayout(self.flxtabbox)
self.frqfig = Figure()
self.frqfig.patch.set_facecolor('white')
self.frqcanvas = FigureCanvas(self.frqfig)
self.frqaxes1 = self.frqfig.add_subplot(121)
self.frqaxes1.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes1.set_ylabel('Flux (n/cm$^2$/s)')
self.frqaxes2 = self.frqfig.add_subplot(122)
self.frqaxes1.set_xlabel('Chopper Frequency (Hz)')
self.frqaxes2.set_ylabel('Elastic Resolution FWHM (meV)')
self.frqfig_controls = NavigationToolbar(self.frqcanvas, self)
self.frqtab = QWidget(self.tabs)
self.frqtabbox = QVBoxLayout()
self.frqtabbox.addWidget(self.frqcanvas)
self.frqtabbox.addWidget(self.frqfig_controls)
self.frqtab.setLayout(self.frqtabbox)
self.repfig = Figure()
self.repfig.patch.set_facecolor('white')
self.repcanvas = FigureCanvas(self.repfig)
self.repaxes = self.repfig.add_subplot(111)
self.repaxes.axhline(color='k')
self.repaxes.set_xlabel(r'TOF ($\mu$sec)')
self.repaxes.set_ylabel('Distance (m)')
self.repfig_controls = NavigationToolbar(self.repcanvas, self)
self.repfig_nframe_label = QLabel('Number of frames to plot')
self.repfig_nframe_edit = QLineEdit('1')
self.repfig_nframe_button = QPushButton('Replot')
self.repfig_nframe_button.clicked.connect(lambda: self.plot_frame())
self.repfig_nframe_rep1only = QCheckBox('First Rep Only')
self.repfig_nframe_box = QHBoxLayout()
self.repfig_nframe_box.addWidget(self.repfig_nframe_label)
self.repfig_nframe_box.addWidget(self.repfig_nframe_edit)
self.repfig_nframe_box.addWidget(self.repfig_nframe_button)
self.repfig_nframe_box.addWidget(self.repfig_nframe_rep1only)
self.reptab = QWidget(self.tabs)
self.repfig_nframe = QWidget(self.reptab)
self.repfig_nframe.setLayout(self.repfig_nframe_box)
self.repfig_nframe.setSizePolicy(
QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed))
self.reptabbox = QVBoxLayout()
self.reptabbox.addWidget(self.repcanvas)
self.reptabbox.addWidget(self.repfig_nframe)
self.reptabbox.addWidget(self.repfig_controls)
self.reptab.setLayout(self.reptabbox)
self.qefig = Figure()
self.qefig.patch.set_facecolor('white')
self.qecanvas = FigureCanvas(self.qefig)
self.qeaxes = self.qefig.add_subplot(111)
self.qeaxes.axhline(color='k')
self.qeaxes.set_xlabel(r'$|Q| (\mathrm{\AA}^{-1})$')
self.qeaxes.set_ylabel('Energy Transfer (meV)')
self.qefig_controls = NavigationToolbar(self.qecanvas, self)
self.qetabbox = QVBoxLayout()
self.qetabbox.addWidget(self.qecanvas)
self.qetabbox.addWidget(self.qefig_controls)
self.qetab = QWidget(self.tabs)
self.qetab.setLayout(self.qetabbox)
self.scrtab = QWidget(self.tabs)
self.scredt = QTextEdit()
self.scrcls = QPushButton("Clear")
self.scrcls.clicked.connect(lambda: self.scredt.clear())
self.scrbox = QVBoxLayout()
self.scrbox.addWidget(self.scredt)
self.scrbox.addWidget(self.scrcls)
self.scrtab.setLayout(self.scrbox)
self.scrtab.hide()
self.tabs.addTab(self.restab, 'Resolution')
self.tabs.addTab(self.flxtab, 'Flux-Ei')
self.tabs.addTab(self.frqtab, 'Flux-Freq')
self.tabs.addTab(self.reptab, 'Time-Distance')
self.tdtabID = 3
self.tabs.setTabEnabled(self.tdtabID, False)
self.tabs.addTab(self.qetab, 'Q-E')
self.qetabID = 4
self.tabs.setTabEnabled(self.qetabID, False)
self.scrtabID = 5
self.rightPanel.addWidget(self.tabs)
self.menuLoad = QMenu('Load')
self.loadAct = QAction('Load YAML', self.menuLoad)
self.loadAct.triggered.connect(self.loadYaml)
self.menuLoad.addAction(self.loadAct)
self.menuOptions = QMenu('Options')
self.instSciAct = QAction('Instrument Scientist Mode',
self.menuOptions,
checkable=True)
self.instSciAct.triggered.connect(self.instSciCB)
self.menuOptions.addAction(self.instSciAct)
self.eiPlots = QAction('Press Enter in Ei box updates plots',
self.menuOptions,
checkable=True)
self.menuOptions.addAction(self.eiPlots)
self.overwriteload = QAction('Always overwrite instruments in memory',
self.menuOptions,
checkable=True)
self.menuOptions.addAction(self.overwriteload)
self.menuBar().addMenu(self.menuLoad)
self.menuBar().addMenu(self.menuOptions)
self.leftPanelWidget = QWidget()
self.leftPanelWidget.setLayout(self.leftPanel)
self.leftPanelWidget.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred))
self.fullWindow.addWidget(self.leftPanelWidget, 0, 0)
self.fullWindow.addLayout(self.rightPanel, 0, 1)
self.helpbtn = QPushButton("?", self)
self.helpbtn.setMaximumWidth(30)
self.helpbtn.clicked.connect(self.onHelp)
self.fullWindow.addWidget(self.helpbtn, 1, 0, 1, -1)
self.mainWidget = QWidget()
self.mainWidget.setLayout(self.fullWindow)
self.setCentralWidget(self.mainWidget)
self.setWindowTitle('PyChopGUI')
self.show()
class QtAbout(QDialog):
"""Qt dialog window for displaying 'About napari' information.
Attributes
----------
citationCopyButton : napari._qt.qt_about.QtCopyToClipboardButton
Button to copy citation information to the clipboard.
citationTextBox : qtpy.QtWidgets.QTextEdit
Text box containing napari citation information.
citation_layout : qtpy.QtWidgets.QHBoxLayout
Layout widget for napari citation information.
infoCopyButton : napari._qt.qt_about.QtCopyToClipboardButton
Button to copy napari version information to the clipboard.
info_layout : qtpy.QtWidgets.QHBoxLayout
Layout widget for napari version information.
infoTextBox : qtpy.QtWidgets.QTextEdit
Text box containing napari version information.
layout : qtpy.QtWidgets.QVBoxLayout
Layout widget for the entire 'About napari' dialog.
"""
def __init__(self):
super().__init__()
self.layout = QVBoxLayout()
# Description
title_label = QLabel(
"<b>napari: a multi-dimensional image viewer for python</b>")
title_label.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.layout.addWidget(title_label)
# Add information
self.infoTextBox = QTextEdit()
self.infoTextBox.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.infoTextBox.setLineWrapMode(QTextEdit.NoWrap)
# Add text copy button
self.infoCopyButton = QtCopyToClipboardButton(self.infoTextBox)
self.info_layout = QHBoxLayout()
self.info_layout.addWidget(self.infoTextBox, 1)
self.info_layout.addWidget(self.infoCopyButton, 0, Qt.AlignTop)
self.info_layout.setAlignment(Qt.AlignTop)
self.layout.addLayout(self.info_layout)
self.infoTextBox.setText(sys_info(as_html=True))
self.infoTextBox.setMinimumSize(
self.infoTextBox.document().size().width() + 19,
self.infoTextBox.document().size().height() + 10,
)
self.layout.addWidget(QLabel('<b>citation information:</b>'))
self.citationTextBox = QTextEdit(citation_text)
self.citationTextBox.setFixedHeight(64)
self.citationCopyButton = QtCopyToClipboardButton(self.citationTextBox)
self.citation_layout = QHBoxLayout()
self.citation_layout.addWidget(self.citationTextBox, 1)
self.citation_layout.addWidget(self.citationCopyButton, 0, Qt.AlignTop)
self.layout.addLayout(self.citation_layout)
self.setLayout(self.layout)
@staticmethod
def showAbout(qt_viewer):
"""Display the 'About napari' dialog box.
Paramters
---------
qt_viewer : QtViewer
QtViewer instance that the `About napari` dialog box belongs to.
"""
d = QtAbout()
d.setObjectName('QtAbout')
d.setStyleSheet(qt_viewer.styleSheet())
d.setWindowTitle('About')
d.setWindowModality(Qt.ApplicationModal)
d.exec_()
def setup(self):
for label, value in self.data:
if DEBUG_FORMLAYOUT:
print("value:", value) # spyder: test-skip
if label is None and value is None:
# Separator: (None, None)
self.formlayout.addRow(QLabel(" "), QLabel(" "))
self.widgets.append(None)
continue
elif label is None:
# Comment
self.formlayout.addRow(QLabel(value))
self.widgets.append(None)
continue
elif tuple_to_qfont(value) is not None:
field = FontLayout(value, self)
elif text_to_qcolor(value).isValid():
field = ColorLayout(QColor(value), self)
elif is_text_string(value):
if '\n' in value:
for linesep in (os.linesep, '\n'):
if linesep in value:
value = value.replace(linesep, u"\u2029")
field = QTextEdit(value, self)
else:
field = QLineEdit(value, self)
elif isinstance(value, (list, tuple)):
value = list(value) # in case this is a tuple
selindex = value.pop(0)
field = QComboBox(self)
if isinstance(value[0], (list, tuple)):
keys = [ key for key, _val in value ]
value = [ val for _key, val in value ]
else:
keys = value
field.addItems(value)
if selindex in value:
selindex = value.index(selindex)
elif selindex in keys:
selindex = keys.index(selindex)
elif not isinstance(selindex, int):
print("Warning: '%s' index is invalid (label: "\
"%s, value: %s)" % (selindex, label, value),
file=STDERR)
selindex = 0
field.setCurrentIndex(selindex)
elif isinstance(value, bool):
field = QCheckBox(self)
field.setCheckState(Qt.Checked if value else Qt.Unchecked)
elif isinstance(value, float):
field = QLineEdit(repr(value), self)
field.setValidator(QDoubleValidator(field))
dialog = self.get_dialog()
dialog.register_float_field(field)
field.textChanged.connect(lambda text: dialog.update_buttons())
elif isinstance(value, int):
field = QSpinBox(self)
field.setRange(-1e9, 1e9)
field.setValue(value)
elif isinstance(value, datetime.datetime):
field = QDateTimeEdit(self)
field.setDateTime(value)
elif isinstance(value, datetime.date):
field = QDateEdit(self)
field.setDate(value)
else:
field = QLineEdit(repr(value), self)
self.formlayout.addRow(label, field)
self.widgets.append(field)
def fill_ndabs(self):
o_step2_handler = Step2Utilities(parent=self.parent.parent)
# table status
self.parent.ui.table_status.insertRow(0)
self.parent.ui.table_status.setRowHeight(0, self.row_height)
_widget = QTextEdit()
_text = "Main Table Empty?<br/><b>Post Processing>Table</b>"
_widget.setHtml(_text)
if o_step2_handler.is_table_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(0, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_table_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_table)
self.parent.ui.table_status.setCellWidget(0, 1, _widget_2)
# at least one row checked
self.parent.ui.table_status.insertRow(1)
self.parent.ui.table_status.setRowHeight(1, self.row_height)
_widget = QTextEdit()
_text = "Main Table Row Selected?<br/><b>Post Processing>Table</b>"
_widget.setHtml(_text)
if o_step2_handler.at_least_one_row_checked():
_widget.setStyleSheet(self.widget_ok)
else:
_widget.setStyleSheet(self.widget_bad)
self.parent.ui.table_status.setCellWidget(1, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(not o_step2_handler.at_least_one_row_checked())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_table)
self.parent.ui.table_status.setCellWidget(1, 1, _widget_2)
# missing fields in row checked
self.parent.ui.table_status.insertRow(2)
self.parent.ui.table_status.setRowHeight(2, self.row_height)
_widget = QTextEdit()
_text = "Is missing metadata in row checked?<br/><b>Post Processing>Table</b>"
_widget.setHtml(_text)
if o_step2_handler.are_row_checked_have_missing_fields():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(2, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.are_row_checked_have_missing_fields())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_table)
self.parent.ui.table_status.setCellWidget(2, 1, _widget_2)
# fourier filter from
self.parent.ui.table_status.insertRow(3)
self.parent.ui.table_status.setRowHeight(3, self.row_height)
_widget = QTextEdit()
_text = "Is Fourier From Widgets Empty?<br/><b>Post Processing>Fourier Filter From</b>"
_widget.setHtml(_text)
if o_step2_handler.is_fourier_filter_from_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(3, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_fourier_filter_from_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_fourier_from)
self.parent.ui.table_status.setCellWidget(3, 1, _widget_2)
# fourier filter to
self.parent.ui.table_status.insertRow(4)
self.parent.ui.table_status.setRowHeight(4, self.row_height)
_widget = QTextEdit()
_text = "Is Fourier To Widgets Empty?<br/><b>Post Processing>Fourier Filter To</b>"
_widget.setHtml(_text)
if o_step2_handler.is_fourier_filter_to_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(4, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_fourier_filter_to_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_fourier_to)
self.parent.ui.table_status.setCellWidget(4, 1, _widget_2)
# plazcek filter from
self.parent.ui.table_status.insertRow(5)
self.parent.ui.table_status.setRowHeight(5, self.row_height)
_widget = QTextEdit()
_text = "Is Plazcek From Widgets Empty?<br/><b>Post Processing>Plazcek Filter From</b>"
_widget.setHtml(_text)
if o_step2_handler.is_plazcek_from_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(5, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_plazcek_from_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_plazcek_from)
self.parent.ui.table_status.setCellWidget(5, 1, _widget_2)
# plazcek filter to
self.parent.ui.table_status.insertRow(6)
self.parent.ui.table_status.setRowHeight(6, self.row_height)
_widget = QTextEdit()
_text = "Is Plazcek To Widgets Empty?<br/><b>Post Processing>Plazcek Filter To</b>"
_widget.setHtml(_text)
if o_step2_handler.is_plazcek_to_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(6, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_plazcek_to_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_plazcek_to)
self.parent.ui.table_status.setCellWidget(6, 1, _widget_2)
# q min
self.parent.ui.table_status.insertRow(7)
self.parent.ui.table_status.setRowHeight(7, self.row_height)
_widget = QTextEdit()
_text = "Is Q min Widgets Empty?<br/><b>Post Processing>Q min</b>"
_widget.setHtml(_text)
if o_step2_handler.is_q_min_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(7, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_q_min_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_q_min)
self.parent.ui.table_status.setCellWidget(7, 1, _widget_2)
# q max
self.parent.ui.table_status.insertRow(8)
self.parent.ui.table_status.setRowHeight(8, self.row_height)
_widget = QTextEdit()
_text = "Is Q max Widgets Empty?<br/><b>Post Processing>Q max</b>"
_widget.setHtml(_text)
if o_step2_handler.is_q_max_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(8, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_q_max_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_q_max)
self.parent.ui.table_status.setCellWidget(8, 1, _widget_2)
# output file name
self.parent.ui.table_status.insertRow(9)
self.parent.ui.table_status.setRowHeight(9, self.row_height)
_widget = QTextEdit()
_text = "Is Output File Name Empty?<br/><b>Post Processing>Output File Name</b>"
_widget.setHtml(_text)
if o_step2_handler.is_ndabs_output_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(9, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step2_handler.is_ndabs_output_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step2_output_empty)
self.parent.ui.table_status.setCellWidget(9, 1, _widget_2)
class QtAboutKeyBindings(QDialog):
"""Qt dialog window for displaying keybinding information.
Parameters
----------
viewer : napari.components.ViewerModel
Napari viewer containing the rendered scene, layers, and controls.
key_map_handler : napari.utils.key_bindings.KeyMapHandler
Handler for key mapping and calling functionality.
Attributes
----------
key_bindings_strs : collections.OrderedDict
Ordered dictionary of hotkey shortcuts and associated key bindings.
Dictionary keys include:
- 'All active key bindings'
- 'Image layer'
- 'Labels layer'
- 'Points layer'
- 'Shapes layer'
- 'Surface layer'
- 'Vectors layer'
layout : qtpy.QtWidgets.QVBoxLayout
Layout of the widget.
layerTypeComboBox : qtpy.QtWidgets.QComboBox
Dropdown menu to select layer type.
textEditBox : qtpy.QtWidgets.QTextEdit
Text box widget containing table of key bindings information.
viewer : napari.components.ViewerModel
Napari viewer containing the rendered scene, layers, and controls.
"""
ALL_ACTIVE_KEYBINDINGS = trans._('All active key bindings')
def __init__(self, viewer, key_map_handler, parent=None):
super().__init__(parent=parent)
self.viewer = viewer
self.layout = QVBoxLayout()
self.setWindowTitle(trans._('Keybindings'))
self.setWindowModality(Qt.NonModal)
self.setLayout(self.layout)
# stacked key bindings widgets
self.textEditBox = QTextEdit()
self.textEditBox.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.textEditBox.setMinimumWidth(360)
# Can switch to a normal dict when our minimum Python is 3.7
self.key_bindings_strs = OrderedDict()
self.key_bindings_strs[self.ALL_ACTIVE_KEYBINDINGS] = ''
self.key_map_handler = key_map_handler
theme = get_theme(self.viewer.theme)
col = theme['secondary']
layers = [
napari.layers.Image,
napari.layers.Labels,
napari.layers.Points,
napari.layers.Shapes,
napari.layers.Surface,
napari.layers.Vectors,
]
for layer in layers:
if len(layer.class_keymap) == 0:
text = trans._('No key bindings')
else:
text = get_key_bindings_summary(layer.class_keymap, col=col)
self.key_bindings_strs[f"{layer.__name__} layer"] = text
# layer type selection
self.layerTypeComboBox = QComboBox()
self.layerTypeComboBox.addItems(list(self.key_bindings_strs))
self.layerTypeComboBox.activated[str].connect(self.change_layer_type)
self.layerTypeComboBox.setCurrentText(self.ALL_ACTIVE_KEYBINDINGS)
# self.change_layer_type(current_layer)
layer_type_layout = QHBoxLayout()
layer_type_layout.setContentsMargins(10, 5, 0, 0)
layer_type_layout.addWidget(self.layerTypeComboBox)
layer_type_layout.addStretch(1)
layer_type_layout.setSpacing(0)
self.layout.addLayout(layer_type_layout)
self.layout.addWidget(self.textEditBox, 1)
self.viewer.events.theme.connect(self.update_active_layer)
self.update_active_layer()
def change_layer_type(self, text):
"""Change layer type selected in dropdown menu.
Parameters
----------
text : str
Dictionary key to access key bindings associated with the layer.
Available keys include:
- 'All active key bindings'
- 'Image layer'
- 'Labels layer'
- 'Points layer'
- 'Shapes layer'
- 'Surface layer'
- 'Vectors layer'
"""
self.textEditBox.setHtml(self.key_bindings_strs[text])
def update_active_layer(self, event=None):
"""Update the active layer and display key bindings for that layer type.
Parameters
----------
event : napari.utils.event.Event, optional
The napari event that triggered this method, by default None.
"""
theme = get_theme(self.viewer.theme)
col = theme['secondary']
# Add class and instance viewer key bindings
text = get_key_bindings_summary(self.key_map_handler.active_keymap,
col=col)
# Update layer speficic key bindings if all active are displayed
self.key_bindings_strs[self.ALL_ACTIVE_KEYBINDINGS] = text
if self.layerTypeComboBox.currentText() == self.ALL_ACTIVE_KEYBINDINGS:
self.textEditBox.setHtml(text)
def fill_autonom(self):
o_step1_handler = Step1Utilities(main_window=self.parent.parent)
# diamond
self.parent.ui.table_status.insertRow(0)
self.parent.ui.table_status.setRowHeight(0, self.row_height)
_widget = QTextEdit()
_text = "Diamond Field Empty?<br/><b>AutoNom>Diamond</b>"
_widget.setHtml(_text)
if o_step1_handler.is_diamond_text_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(0, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step1_handler.is_diamond_text_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step1_diamond)
self.parent.ui.table_status.setCellWidget(0, 1, _widget_2)
# diamond background
self.parent.ui.table_status.insertRow(1)
self.parent.ui.table_status.setRowHeight(1, self.row_height)
_widget = QTextEdit()
_text = "Diamond Background Field Empty?<br/><b>AutoNom>Diamond Background</b>"
_widget.setHtml(_text)
if o_step1_handler.is_diamond_background_text_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(1, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step1_handler.is_diamond_background_text_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step1_diamond_background)
self.parent.ui.table_status.setCellWidget(1, 1, _widget_2)
# vanadium
self.parent.ui.table_status.insertRow(2)
self.parent.ui.table_status.setRowHeight(2, self.row_height)
_widget = QTextEdit()
_text = "Vanadium Field Empty?<br/><b>AutoNom>Vanadium</b>"
_widget.setHtml(_text)
if o_step1_handler.is_vanadium_text_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(2, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step1_handler.is_vanadium_text_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step1_vanadium)
self.parent.ui.table_status.setCellWidget(2, 1, _widget_2)
# vanadium background
self.parent.ui.table_status.insertRow(3)
self.parent.ui.table_status.setRowHeight(3, self.row_height)
_widget = QTextEdit()
_text = "Vanadium Background Field Empty?<br/><b>AutoNom>Vanadium Background</b>"
_widget.setHtml(_text)
if o_step1_handler.is_vanadium_background_text_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(3, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step1_handler.is_vanadium_background_text_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step1_vanadium_background)
self.parent.ui.table_status.setCellWidget(3, 1, _widget_2)
# sample background
self.parent.ui.table_status.insertRow(4)
self.parent.ui.table_status.setRowHeight(4, self.row_height)
_widget = QTextEdit()
_text = "Sample Background Field Empty?<br/><b>AutoNom>Sample Background</b>"
_widget.setHtml(_text)
if o_step1_handler.is_sample_background_text_empty():
_widget.setStyleSheet(self.widget_bad)
else:
_widget.setStyleSheet(self.widget_ok)
self.parent.ui.table_status.setCellWidget(4, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(o_step1_handler.is_sample_background_text_empty())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step1_sample_background)
self.parent.ui.table_status.setCellWidget(4, 1, _widget_2)
# create folder button
self.parent.ui.table_status.insertRow(5)
self.parent.ui.table_status.setRowHeight(5, self.row_height + 20)
_widget = QTextEdit()
_text = "Create Folder Button Status?<br/><b>AutoNom>Create New AutoNom Folder</b>"
_widget.setHtml(_text)
if o_step1_handler.is_create_folder_button_status_ok():
_widget.setStyleSheet(self.widget_ok)
else:
_widget.setStyleSheet(self.widget_bad)
self.parent.ui.table_status.setCellWidget(5, 0, _widget)
_widget_2 = QPushButton()
_widget_2.setEnabled(not o_step1_handler.is_create_folder_button_status_ok())
_widget_2.setText(self.jump_message)
_widget_2.clicked.connect(self.jump_to_step1_create_folder)
self.parent.ui.table_status.setCellWidget(5, 1, _widget_2)
class QtPluginDialog(QDialog):
def __init__(self, parent=None):
super().__init__(parent)
self.installer = Installer()
self.setup_ui()
self.installer.set_output_widget(self.stdout_text)
self.installer.process.started.connect(self._on_installer_start)
self.installer.process.finished.connect(self._on_installer_done)
self.refresh()
def _on_installer_start(self):
self.show_status_btn.setChecked(True)
self.working_indicator.show()
self.process_error_indicator.hide()
def _on_installer_done(self, exit_code, exit_status):
self.working_indicator.hide()
if exit_code:
self.process_error_indicator.show()
else:
self.show_status_btn.setChecked(False)
self.refresh()
self.plugin_sorter.refresh()
def refresh(self):
self.installed_list.clear()
self.available_list.clear()
# fetch installed
from ...plugins import plugin_manager
plugin_manager.discover() # since they might not be loaded yet
already_installed = set()
for plugin_name, mod_name, distname in plugin_manager.iter_available():
# not showing these in the plugin dialog
if plugin_name in ('napari_plugin_engine', ):
continue
if distname:
already_installed.add(distname)
meta = standard_metadata(distname)
else:
meta = {}
self.installed_list.addItem(
ProjectInfo(
normalized_name(distname or ''),
meta.get('version', ''),
meta.get('url', ''),
meta.get('summary', ''),
meta.get('author', ''),
meta.get('license', ''),
),
plugin_name=plugin_name,
enabled=plugin_name in plugin_manager.plugins,
)
# self.v_splitter.setSizes([70 * self.installed_list.count(), 10, 10])
# fetch available plugins
self.worker = create_worker(iter_napari_plugin_info)
def _handle_yield(project_info):
if project_info.name in already_installed:
self.installed_list.tag_outdated(project_info)
else:
self.available_list.addItem(project_info)
self.worker.yielded.connect(_handle_yield)
self.worker.finished.connect(self.working_indicator.hide)
self.worker.finished.connect(self._update_count_in_label)
self.worker.start()
def setup_ui(self):
self.resize(1080, 640)
vlay_1 = QVBoxLayout(self)
self.h_splitter = QSplitter(self)
vlay_1.addWidget(self.h_splitter)
self.h_splitter.setOrientation(Qt.Horizontal)
self.v_splitter = QSplitter(self.h_splitter)
self.v_splitter.setOrientation(Qt.Vertical)
self.v_splitter.setMinimumWidth(500)
self.plugin_sorter = QtPluginSorter(parent=self.h_splitter)
self.plugin_sorter.layout().setContentsMargins(2, 0, 0, 0)
self.plugin_sorter.hide()
installed = QWidget(self.v_splitter)
lay = QVBoxLayout(installed)
lay.setContentsMargins(0, 2, 0, 2)
lay.addWidget(QLabel(trans._("Installed Plugins")))
self.installed_list = QPluginList(installed, self.installer)
lay.addWidget(self.installed_list)
uninstalled = QWidget(self.v_splitter)
lay = QVBoxLayout(uninstalled)
lay.setContentsMargins(0, 2, 0, 2)
self.avail_label = QLabel(trans._("Available Plugins"))
lay.addWidget(self.avail_label)
self.available_list = QPluginList(uninstalled, self.installer)
lay.addWidget(self.available_list)
self.stdout_text = QTextEdit(self.v_splitter)
self.stdout_text.setReadOnly(True)
self.stdout_text.setObjectName("pip_install_status")
self.stdout_text.hide()
buttonBox = QHBoxLayout()
self.working_indicator = QLabel(trans._("loading ..."), self)
sp = self.working_indicator.sizePolicy()
sp.setRetainSizeWhenHidden(True)
self.working_indicator.setSizePolicy(sp)
self.process_error_indicator = QLabel(self)
self.process_error_indicator.setObjectName("error_label")
self.process_error_indicator.hide()
load_gif = str(Path(napari.resources.__file__).parent / "loading.gif")
mov = QMovie(load_gif)
mov.setScaledSize(QSize(18, 18))
self.working_indicator.setMovie(mov)
mov.start()
self.direct_entry_edit = QLineEdit(self)
self.direct_entry_edit.installEventFilter(self)
self.direct_entry_edit.setPlaceholderText(
trans._('install by name/url, or drop file...'))
self.direct_entry_btn = QPushButton(trans._("Install"), self)
self.direct_entry_btn.clicked.connect(self._install_packages)
self.show_status_btn = QPushButton(trans._("Show Status"), self)
self.show_status_btn.setFixedWidth(100)
self.show_sorter_btn = QPushButton(trans._("<< Show Sorter"), self)
self.close_btn = QPushButton(trans._("Close"), self)
self.close_btn.clicked.connect(self.accept)
buttonBox.addWidget(self.show_status_btn)
buttonBox.addWidget(self.working_indicator)
buttonBox.addWidget(self.direct_entry_edit)
buttonBox.addWidget(self.direct_entry_btn)
buttonBox.addWidget(self.process_error_indicator)
buttonBox.addSpacing(60)
buttonBox.addWidget(self.show_sorter_btn)
buttonBox.addWidget(self.close_btn)
buttonBox.setContentsMargins(0, 0, 4, 0)
vlay_1.addLayout(buttonBox)
self.show_status_btn.setCheckable(True)
self.show_status_btn.setChecked(False)
self.show_status_btn.toggled.connect(self._toggle_status)
self.show_sorter_btn.setCheckable(True)
self.show_sorter_btn.setChecked(False)
self.show_sorter_btn.toggled.connect(self._toggle_sorter)
self.v_splitter.setStretchFactor(1, 2)
self.h_splitter.setStretchFactor(0, 2)
def _update_count_in_label(self):
count = self.available_list.count()
self.avail_label.setText(
trans._("Available Plugins ({count})", count=count))
def eventFilter(self, watched, event):
if event.type() == QEvent.DragEnter:
# we need to accept this event explicitly to be able
# to receive QDropEvents!
event.accept()
if event.type() == QEvent.Drop:
md = event.mimeData()
if md.hasUrls():
files = [url.toLocalFile() for url in md.urls()]
self.direct_entry_edit.setText(files[0])
return True
return super().eventFilter(watched, event)
def _toggle_sorter(self, show):
if show:
self.show_sorter_btn.setText(trans._(">> Hide Sorter"))
self.plugin_sorter.show()
else:
self.show_sorter_btn.setText(trans._("<< Show Sorter"))
self.plugin_sorter.hide()
def _toggle_status(self, show):
if show:
self.show_status_btn.setText(trans._("Hide Status"))
self.stdout_text.show()
else:
self.show_status_btn.setText(trans._("Show Status"))
self.stdout_text.hide()
def _install_packages(self, packages: Sequence[str] = ()):
if not packages:
_packages = self.direct_entry_edit.text()
if os.path.exists(_packages):
packages = [_packages]
else:
packages = _packages.split()
self.direct_entry_edit.clear()
if packages:
self.installer.install(packages)
def __init__(self, parent, text):
QWidget.__init__(self, parent)
self.text_editor = QTextEdit(self)
self.text_editor.setText(text)
self.text_editor.setReadOnly(True)
# Type frame
type_layout = QHBoxLayout()
type_label = QLabel(_("Import as"))
type_layout.addWidget(type_label)
data_btn = QRadioButton(_("data"))
data_btn.setChecked(True)
self._as_data= True
type_layout.addWidget(data_btn)
code_btn = QRadioButton(_("code"))
self._as_code = False
type_layout.addWidget(code_btn)
txt_btn = QRadioButton(_("text"))
type_layout.addWidget(txt_btn)
h_spacer = QSpacerItem(40, 20,
QSizePolicy.Expanding, QSizePolicy.Minimum)
type_layout.addItem(h_spacer)
type_frame = QFrame()
type_frame.setLayout(type_layout)
# Opts frame
grid_layout = QGridLayout()
grid_layout.setSpacing(0)
col_label = QLabel(_("Column separator:"))
grid_layout.addWidget(col_label, 0, 0)
col_w = QWidget()
col_btn_layout = QHBoxLayout()
self.tab_btn = QRadioButton(_("Tab"))
self.tab_btn.setChecked(False)
col_btn_layout.addWidget(self.tab_btn)
other_btn_col = QRadioButton(_("other"))
other_btn_col.setChecked(True)
col_btn_layout.addWidget(other_btn_col)
col_w.setLayout(col_btn_layout)
grid_layout.addWidget(col_w, 0, 1)
self.line_edt = QLineEdit(",")
self.line_edt.setMaximumWidth(30)
self.line_edt.setEnabled(True)
other_btn_col.toggled.connect(self.line_edt.setEnabled)
grid_layout.addWidget(self.line_edt, 0, 2)
row_label = QLabel(_("Row separator:"))
grid_layout.addWidget(row_label, 1, 0)
row_w = QWidget()
row_btn_layout = QHBoxLayout()
self.eol_btn = QRadioButton(_("EOL"))
self.eol_btn.setChecked(True)
row_btn_layout.addWidget(self.eol_btn)
other_btn_row = QRadioButton(_("other"))
row_btn_layout.addWidget(other_btn_row)
row_w.setLayout(row_btn_layout)
grid_layout.addWidget(row_w, 1, 1)
self.line_edt_row = QLineEdit(";")
self.line_edt_row.setMaximumWidth(30)
self.line_edt_row.setEnabled(False)
other_btn_row.toggled.connect(self.line_edt_row.setEnabled)
grid_layout.addWidget(self.line_edt_row, 1, 2)
grid_layout.setRowMinimumHeight(2, 15)
other_group = QGroupBox(_("Additional options"))
other_layout = QGridLayout()
other_group.setLayout(other_layout)
skiprows_label = QLabel(_("Skip rows:"))
other_layout.addWidget(skiprows_label, 0, 0)
self.skiprows_edt = QLineEdit('0')
self.skiprows_edt.setMaximumWidth(30)
intvalid = QIntValidator(0, len(to_text_string(text).splitlines()),
self.skiprows_edt)
self.skiprows_edt.setValidator(intvalid)
other_layout.addWidget(self.skiprows_edt, 0, 1)
other_layout.setColumnMinimumWidth(2, 5)
comments_label = QLabel(_("Comments:"))
other_layout.addWidget(comments_label, 0, 3)
self.comments_edt = QLineEdit('#')
self.comments_edt.setMaximumWidth(30)
other_layout.addWidget(self.comments_edt, 0, 4)
self.trnsp_box = QCheckBox(_("Transpose"))
#self.trnsp_box.setEnabled(False)
other_layout.addWidget(self.trnsp_box, 1, 0, 2, 0)
grid_layout.addWidget(other_group, 3, 0, 2, 0)
opts_frame = QFrame()
opts_frame.setLayout(grid_layout)
data_btn.toggled.connect(opts_frame.setEnabled)
data_btn.toggled.connect(self.set_as_data)
code_btn.toggled.connect(self.set_as_code)
# self.connect(txt_btn, SIGNAL("toggled(bool)"),
# self, SLOT("is_text(bool)"))
# Final layout
layout = QVBoxLayout()
layout.addWidget(type_frame)
layout.addWidget(self.text_editor)
layout.addWidget(opts_frame)
self.setLayout(layout)
def setup_ui(self):
self.resize(1080, 640)
vlay_1 = QVBoxLayout(self)
self.h_splitter = QSplitter(self)
vlay_1.addWidget(self.h_splitter)
self.h_splitter.setOrientation(Qt.Horizontal)
self.v_splitter = QSplitter(self.h_splitter)
self.v_splitter.setOrientation(Qt.Vertical)
self.v_splitter.setMinimumWidth(500)
self.plugin_sorter = QtPluginSorter(parent=self.h_splitter)
self.plugin_sorter.layout().setContentsMargins(2, 0, 0, 0)
self.plugin_sorter.hide()
installed = QWidget(self.v_splitter)
lay = QVBoxLayout(installed)
lay.setContentsMargins(0, 2, 0, 2)
lay.addWidget(QLabel(trans._("Installed Plugins")))
self.installed_list = QPluginList(installed, self.installer)
lay.addWidget(self.installed_list)
uninstalled = QWidget(self.v_splitter)
lay = QVBoxLayout(uninstalled)
lay.setContentsMargins(0, 2, 0, 2)
self.avail_label = QLabel(trans._("Available Plugins"))
lay.addWidget(self.avail_label)
self.available_list = QPluginList(uninstalled, self.installer)
lay.addWidget(self.available_list)
self.stdout_text = QTextEdit(self.v_splitter)
self.stdout_text.setReadOnly(True)
self.stdout_text.setObjectName("pip_install_status")
self.stdout_text.hide()
buttonBox = QHBoxLayout()
self.working_indicator = QLabel(trans._("loading ..."), self)
sp = self.working_indicator.sizePolicy()
sp.setRetainSizeWhenHidden(True)
self.working_indicator.setSizePolicy(sp)
self.process_error_indicator = QLabel(self)
self.process_error_indicator.setObjectName("error_label")
self.process_error_indicator.hide()
load_gif = str(Path(napari.resources.__file__).parent / "loading.gif")
mov = QMovie(load_gif)
mov.setScaledSize(QSize(18, 18))
self.working_indicator.setMovie(mov)
mov.start()
self.direct_entry_edit = QLineEdit(self)
self.direct_entry_edit.installEventFilter(self)
self.direct_entry_edit.setPlaceholderText(
trans._('install by name/url, or drop file...'))
self.direct_entry_btn = QPushButton(trans._("Install"), self)
self.direct_entry_btn.clicked.connect(self._install_packages)
self.show_status_btn = QPushButton(trans._("Show Status"), self)
self.show_status_btn.setFixedWidth(100)
self.show_sorter_btn = QPushButton(trans._("<< Show Sorter"), self)
self.close_btn = QPushButton(trans._("Close"), self)
self.close_btn.clicked.connect(self.accept)
buttonBox.addWidget(self.show_status_btn)
buttonBox.addWidget(self.working_indicator)
buttonBox.addWidget(self.direct_entry_edit)
buttonBox.addWidget(self.direct_entry_btn)
buttonBox.addWidget(self.process_error_indicator)
buttonBox.addSpacing(60)
buttonBox.addWidget(self.show_sorter_btn)
buttonBox.addWidget(self.close_btn)
buttonBox.setContentsMargins(0, 0, 4, 0)
vlay_1.addLayout(buttonBox)
self.show_status_btn.setCheckable(True)
self.show_status_btn.setChecked(False)
self.show_status_btn.toggled.connect(self._toggle_status)
self.show_sorter_btn.setCheckable(True)
self.show_sorter_btn.setChecked(False)
self.show_sorter_btn.toggled.connect(self._toggle_sorter)
self.v_splitter.setStretchFactor(1, 2)
self.h_splitter.setStretchFactor(0, 2)
def __init__(self, parent=None):
QTextEdit.__init__(self, parent)
BaseEditMixin.__init__(self)
self.found_results = []
def create_widget(self, parent=None):
self.text_widget = QTextEdit(parent)
self.text_widget.setReadOnly(True)
do = self.data_object.convert("text")
self.text_widget.setText(do.inner_data)
return self.text_widget