def show_results(self):
header_labels_set = False
self.show_results_event.clear()
t0 = time.monotonic()
counter = 0
while not self._new_entries.empty():
counter += 1
entry = self._new_entries.get()
row = []
try:
row_data = self.apply_search_result_row(entry)
except SkipRow:
continue
if not header_labels_set:
# Set header labels just once.
self.search_results_model.setHorizontalHeaderLabels(list(row_data))
header_labels_set = True
for value in row_data.values():
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
row.append(item)
self.search_results_model.appendRow(row)
if counter:
duration = time.monotonic() - t0
log.debug("Displayed %d new results (%.3f s).", counter, duration)
self.show_results_event.set()
def set_default(self, parameters):
"""Sets the default values from 'parameters' to the model
Sets the data from 'parameters' to the model, overwriting any existing
data in the model. This follows the ``mily.widget`` API.
Parameters
----------
parameters : [dicts]
List of dicts with each dict being a row that maps the column
header to its value.
"""
model = self.model()
# Empty the model.
model.removeRows(0, model.rowCount())
# Add the new data to the model.
for row_params in parameters:
row_data = []
# for each column in the model check if a default is given
for column in range(0, model.columnCount()):
header_item = model.horizontalHeaderItem(column)
header = header_item.text()
item = QStandardItem()
value = row_params.get(header, None)
item.setData(value, Qt.DisplayRole)
row_data.append(item)
model.appendRow(row_data)
def update_channels(self,
channels: List[Channel],
selected_channel: Channel = None):
"""
Update / repopulate the list of selectable channels
Inputs:
channels: List of channel names
"""
self._reset_combo_box(self._combo_channels)
if channels is None or len(channels) == 0:
self._combo_channels.setEnabled(False)
else:
model = QStandardItemModel()
model.appendRow(QStandardItem(self._combo_channels.itemText(0)))
for channel in channels:
item = QStandardItem(channel.display_name)
item.setData(channel, QtCore.Qt.UserRole)
model.appendRow(item)
self._combo_channels.setModel(model)
if selected_channel is not None:
# TODO relying on display name isn't the best as it will probably
# cause issues if channel names aren't unique
# TODO refactor by making Channel derive from QStandardItem and do something like this:
# selected_index = model.indexFromItem(selected_channel)
# self.combo_channels.setCurrentIndex(selected_index)
self._combo_channels.setCurrentText(
selected_channel.display_name)
self._combo_channels.setEnabled(True)
def show_results(self):
header_labels_set = False
self.show_results_event.clear()
t0 = time.monotonic()
counter = 0
for uid, entry in itertools.islice(self._results_catalog.items(), MAX_SEARCH_RESULTS):
if uid in self._results:
continue
counter += 1
self._results.append(uid)
row = []
try:
row_data = self.apply_search_result_row(entry)
except SkipRow:
continue
if not header_labels_set:
# Set header labels just once.
self.search_results_model.setHorizontalHeaderLabels(list(row_data))
header_labels_set = True
for value in row_data.values():
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
row.append(item)
self.search_results_model.appendRow(row)
if counter:
duration = time.monotonic() - t0
log.debug("Displayed %d new results (%.3f s).", counter, duration)
self.show_results_event.set()
def commentaryListView(self):
# https://doc.qt.io/archives/qtforpython-5.12/PySide2/QtCore/QStringListModel.html
# https://gist.github.com/minoue/9f384cd36339429eb0bf
# https://www.pythoncentral.io/pyside-pyqt-tutorial-qlistview-and-qstandarditemmodel/
list = QListView()
list.setEditTriggers(QAbstractItemView.NoEditTriggers)
model = QStandardItemModel(list)
for index, commentary in enumerate(self.parent.commentaryFullNameList):
item = QStandardItem(commentary)
item.setToolTip(self.parent.commentaryList[index])
#item.setCheckable(True)
#item.setCheckState(Qt.CheckState.Checked)
#item.setCheckState(Qt.CheckState.Unchecked)
#print(item.checkState() is Qt.CheckState.Checked)
model.appendRow(item)
#model = QStringListModel(self.parent.commentaryList)
#model = QStringListModel(self.parent.commentaryFullNameList)
list.setModel(model)
if config.commentaryText in self.parent.commentaryList:
list.setCurrentIndex(
model.index(
self.parent.commentaryList.index(config.commentaryText),
0))
list.selectionModel().selectionChanged.connect(self.commentarySelected)
return list
def __init__(self):
QDialog.__init__(self)
# setup UI
self.form = QFormLayout(self)
self.editPosition = QLineEdit('')
self.form.addRow(QLabel('Position'), self.editPosition)
self.editVelocity = QLineEdit('')
self.form.addRow(QLabel('Velocity'), self.editVelocity)
# configure network (take first available servo)
self._net, self._servo = il.lucky(il.NET_PROT.EUSB)
# create data model
model = QStandardItemModel()
pos = QStandardItem()
vel = QStandardItem()
model.appendRow([pos, vel])
# configure and start watcher
self._watcher = RegisterWatcher(self._servo)
self._watcher.add(POS_ACT, 500, pos)
self._watcher.add(VEL_ACT, 100, vel)
self._watcher.start(100)
# map model fields to widgets
self._mapper = QDataWidgetMapper()
self._mapper.setModel(model)
self._mapper.addMapping(self.editPosition, 0)
self._mapper.addMapping(self.editVelocity, 1)
self._mapper.toFirst()
def loadData(self):
# get current map idx
if not self.isMapOpen():
return
# pass the selected map data to plotwidget
self.rawSpectra.setHeader(self.headers[self.selectMapidx], 'spectra')
currentMapItem = self.headermodel.item(self.selectMapidx)
rc2ind = self.rc2indList[self.selectMapidx]
# get current map name
mapName = currentMapItem.data(0)
# get current selected pixels
pixelCoord = currentMapItem.selectedPixels
# get selected specIds
spectraIds = []
if currentMapItem.selectedPixels is None: # select all
spectraIds = list(range(len(rc2ind)))
else:
for i in range(len(pixelCoord)):
row_col = tuple(pixelCoord[i])
spectraIds.append(rc2ind[row_col])
spectraIds = sorted(spectraIds)
# add specitem model
self.specItemModel.clear()
for idx in spectraIds:
item = QStandardItem(mapName + '# ' + str(idx))
item.idx = idx
self.specItemModel.appendRow(item)
def set_plot_list(self, plot_list):
"""
Populate the plot list from the Presenter
:param plot_list: the list of plot names (list of strings)
"""
self.list_view.model().clear()
for plot_name in plot_list:
item = QStandardItem(plot_name)
item.setEditable(False)
self.list_view.model().appendRow(item)
def createIcons(self):
self.contentsModel.clear()
for pluginInfo in pluginmanager.getPluginsOfCategory("SettingsPlugin"):
item = QStandardItem(pluginInfo.plugin_object.icon, pluginInfo.plugin_object.name())
item.widget = pluginInfo.plugin_object.widget
item.setTextAlignment(Qt.AlignHCenter)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setSizeHint(QSize(136, 80))
self.contentsModel.appendRow(item)
def refresh(self):
self.clear()
if not self._proc_interface:
logger.warning('cannot refresh without a procInterface')
return
eprocs = self._proc_interface.eprocs
for device in eprocs.keys():
device_item = QStandardItem(device)
self.appendRow(device_item)
for eproc in eprocs[device]:
eproc_item = QStandardItem(eproc)
device_item.appendRow(eproc_item)
def populate(self, names):
"""
Add a list of names to be displayed as list items in the dialog
Parameters
----------
names : `list`
The list of names to be populated in the dialog
"""
for s in names:
item = QStandardItem(s)
item.setCheckable(True)
item.setCheckState(Qt.Checked)
self._model.appendRow(item)
def resetItems(self):
from qtpy.QtGui import QStandardItem
from qtpy.QtCore import Qt
# Empty the model before reset
self.readingListModel.clear()
# Reset
index = 0
todayIndex = None
filterEntry = self.filterEntry.text()
for key, value in self.plan.items():
checked, passages = value
if not (self.hideCheckedItems and checked) and (
filterEntry == "" or
(filterEntry != ""
and filterEntry.lower() in passages.lower())):
item = QStandardItem("{0}. {1}".format(key, passages))
item.setToolTip("{0}{1}{2}".format(self.translation[8], key,
self.translation[9]))
if key == self.todayNo:
todayIndex = index
item.setCheckable(True)
item.setCheckState(Qt.CheckState.Checked if checked else Qt.
CheckState.Unchecked)
self.readingListModel.appendRow(item)
index += 1
if todayIndex is not None:
self.readingList.setCurrentIndex(
self.readingListModel.index(todayIndex, 0))
def updatePlot(self, item: QStandardItem):
self.clear()
itemIndex = QPersistentModelIndex(item.index())
if item.checkState():
self.checkedItemIndexes.append(itemIndex)
else:
# TODO -- might need try for ValueError
self.checkedItemIndexes.remove(itemIndex)
g2 = list(self.results('norm-0-g2'))
g2Err = list(self.results('norm-0-stderr'))
lagSteps = list(self.results('tau'))
fitCurve = list(self.results('g2avgFIT1'))
roiList = list(self.results('dqlist'))
for roi in range(len(self.checkedItemIndexes)):
yData = g2[roi].squeeze()
xData = lagSteps[roi].squeeze()
color = [
float(roi) / len(self.checkedItemIndexes) * 255,
(1 - float(roi) / len(self.checkedItemIndexes)) * 255, 255
]
self.plotOpts['pen'] = color
err = g2Err[roi].squeeze()
self.plot.addItem(
pg.ErrorBarItem(x=np.log10(xData),
y=yData,
top=err,
bottom=err,
**self.plotOpts))
curve = self.plot.plot(x=xData, y=yData, **self.plotOpts)
opts = self.plotOpts.copy()
opts['pen'] = pg.mkPen(self.plotOpts['pen']) # type: QPen
opts['pen'].setStyle(Qt.DashLine)
name = roiList[roi]
curveItem = CurveItemSample(curve, name=name)
self._curveItems.append(curveItem)
self.legend.addItem(curveItem, curveItem.name)
if len(fitCurve[roi]) > 0:
fit_curve = self.plot.plot(x=xData,
y=fitCurve[roi].squeeze(),
**opts)
fitCurveItem = CurveItemSample(fit_curve, name=f'{name} (fit)')
self._curveItems.append(fitCurveItem)
self.legend.addItem(fitCurveItem, fitCurveItem.name)
self.legend.show()
def insert_child_current_item(self, child_value):
"""
Insert a child item to currently selected item
Args:
child_value:
Returns:
"""
current_index = self.currentIndex()
assert (isinstance(current_index, QModelIndex))
current_row = current_index.row()
print('[DEV] Current Index of Row = %d ' % current_row)
# Get model
my_model = self.model()
assert (isinstance(my_model, QStandardItemModel))
current_item = my_model.itemFromIndex(current_index)
assert (isinstance(current_item, QStandardItem))
print('Add Child Value ', child_value)
# child_item = QStandardItem(child_value)
child_item = QStandardItem(str(child_value))
current_item.insertRow(0, [child_item])
return
def create_table_item(data: Any, editable: bool = False):
"""
Factory function to create a relevant Qt-model item type
for the given parameters. For non-editable items a QStandardItem
can be used with just a string representation of the data. For
editable items we must store the original data such that if editing
fails it can be reset.
:param data: Data to be stored in the item
:param editable: Boolean indicating if the item can be edited
"""
if editable:
return RevertibleItem(data)
else:
item = QStandardItem(str(data))
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
return item
def show_results(self):
header_labels_set = False
t0 = time.monotonic()
counter = 0
for uid, entry in itertools.islice(self._results_catalog.items(),
MAX_SEARCH_RESULTS):
if entry in self._results:
continue
counter += 1
self._results.append(entry)
row = []
try:
row_text = self.apply_search_result_row(entry)
except SkipRow:
continue
if not header_labels_set:
# Set header labels just once.
self.search_results_model.setHorizontalHeaderLabels(
list(row_text))
header_labels_set = True
for text in row_text.values():
item = QStandardItem(text or '')
row.append(item)
self.search_results_model.appendRow(row)
if counter:
duration = time.monotonic() - t0
log.debug("Displayed %d new results (%.3f s)", counter, duration)
def on_debug_message(self, message):
msg = 'DEBUG - occurred at: [ {} ]\n{}'.format(
NotificationsWidget._get_time(),
NotificationsWidget._strip_new_line(message))
notification_item = QStandardItem()
notification_item.setText(msg)
notification_item.setIcon(QIcon.fromTheme('dialog-question'))
notification_item.setEditable(False)
self.all_notification_model.appendRow(notification_item)
def _addRow(self):
"""Inserts an empty row after the (last) currently selected row(s)."""
indices = self.tableView.selectionModel().selectedIndexes()
rows = [index.row() for index in indices]
rows.sort(reverse=True)
empty_row = []
for column in range(self.tableView.model().columnCount()):
item = QStandardItem()
item.setData(None, Qt.DisplayRole)
empty_row.append(item)
if rows: # add an empty row after the last selected row
self.tableView.model().insertRow(rows[0] + 1, empty_row)
else: # If no rows selected add row at end of table
end_row = self.tableView.model().rowCount()
self.tableView.model().insertRow(end_row, empty_row)
self._check_table_after_row_manipulation()
def on_error_message(self, message):
msg = 'ERROR - occurred at: [ {} ]\n{}'.format(
NotificationsWidget._get_time(),
NotificationsWidget._strip_new_line(message))
LOG.debug('-----on_error_message called: {}'.format(message))
notification_item = QStandardItem()
notification_item.setText(msg)
notification_item.setIcon(QIcon.fromTheme('dialog-error'))
notification_item.setEditable(False)
self.all_notification_model.appendRow(notification_item)
def list_subcatalogs(self):
self._subcatalogs.clear()
self.catalog_selection_model.clear()
if not self.root_catalog:
return
for name in self.root_catalog:
self._subcatalogs.append(name)
self.catalog_selection_model.appendRow(QStandardItem(str(name)))
def appendCatalog(self, catalog: BlueskyRun):
# give catalog to out catalog viewer
self.split_widget.catalog_view.setCatalog(catalog, 'primary', 'img')
display_name = f"scan:{catalog.metadata['start']['scan_id']}"
item = QStandardItem()
item.setData(display_name, Qt.DisplayRole)
item.setData(catalog, Qt.UserRole)
self.model.appendRow(item)
# tell our model that the data has been updated, the two parameters are rox index and column index
self.model.dataChanged.emit(item.index(), item.index())
def __init__(self, parent, rows, selected=None, disabled=None):
super().__init__(parent)
self.setWindowTitle("Select XDF Stream")
self.model = QStandardItemModel()
self.model.setHorizontalHeaderLabels(
["ID", "Name", "Type", "Channels", "Format", "Sampling Rate"])
for index, stream in enumerate(rows):
items = []
for item in stream:
tmp = QStandardItem()
tmp.setData(item, Qt.DisplayRole)
items.append(tmp)
for item in items:
item.setEditable(False)
if disabled is not None and index in disabled:
item.setFlags(Qt.NoItemFlags)
self.model.appendRow(items)
self.view = QTableView()
self.view.setModel(self.model)
self.view.verticalHeader().setVisible(False)
self.view.horizontalHeader().setStretchLastSection(True)
self.view.setShowGrid(False)
self.view.setSelectionMode(QAbstractItemView.SingleSelection)
self.view.setSelectionBehavior(QAbstractItemView.SelectRows)
if selected is not None:
self.view.selectRow(selected)
self.view.setSortingEnabled(True)
self.view.sortByColumn(0, Qt.AscendingOrder)
vbox = QVBoxLayout(self)
vbox.addWidget(self.view)
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
vbox.addWidget(self.buttonbox)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
self.resize(775, 650)
self.view.setColumnWidth(0, 100)
self.view.setColumnWidth(1, 200)
self.view.setColumnWidth(2, 120)
def on_debug_message(self, message):
timestamp = time()
dt_object = datetime.fromtimestamp(timestamp)
current_time = str(dt_object)
msg = 'DEBUG\nTIME {}\n {}'.format(current_time, message)
notification_item = QStandardItem()
notification_item.setText(msg)
notification_item.setIcon(QIcon.fromTheme('dialog-question'))
notification_item.setEditable(False)
self.all_notification_model.appendRow(notification_item)
def videoListView(self):
list = QListView()
list.setEditTriggers(QAbstractItemView.NoEditTriggers)
model = QStandardItemModel(list)
for file in self.videoList:
item = QStandardItem(file)
model.appendRow(item)
list.setModel(model)
list.selectionModel().selectionChanged.connect(self.playSelectedVideo)
return list
def _duplicateRow(self):
"""Duplicates the selected row(s) into the table after the row(s)."""
# find the selected row(s)
indices = self.tableView.selectionModel().selectedIndexes()
rows = [index.row() for index in indices]
rows.sort(reverse=True)
if self._check_rows(rows):
model = self.tableView.model()
for row in rows:
row_data = []
for column in range(model.columnCount()):
value = model.item(row, column).data(Qt.DisplayRole)
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
row_data.append(item)
model.insertRow(row + 1, row_data)
self._check_table_after_row_manipulation()
def __call__(self, name, doc):
if name == 'event_page':
for event in unpack_event_page(doc):
self.__call__('event', event)
elif name == 'event':
column = doc['seq_num'] - 1
for row, val in enumerate(
val for _, val in sorted(doc['data'].items())):
self.setItem(row, column, QStandardItem(str(val)))
self.setVerticalHeaderLabels(doc['data'].keys())
def devotionsListView(self):
list = QListView()
list.setEditTriggers(QAbstractItemView.NoEditTriggers)
model = QStandardItemModel(list)
for devotional in self.devotionals:
item = QStandardItem(devotional)
model.appendRow(item)
list.setModel(model)
list.selectionModel().selectionChanged.connect(self.devotionalSelected)
return list
def __init__(self, parent):
super(InfoFrame, self).__init__(parent)
self.widget_layout = QVBoxLayout(self)
self.setLayout(self.widget_layout)
self.section_label = QLabel(self)
self.section_label.setText("Informations")
self.widget_layout.addWidget(self.section_label)
self.label = QLabel(self)
self.label.setText("Select information to collect after successfull connection. Keep in mind that the more "
"data you collect the more suspicious you are for antivirus software. You can "
"change these settings later.")
self.label.setWordWrap(True)
self.widget_layout.addWidget(self.label)
self.list = QListView(self)
self.model = QStandardItemModel(self.list)
self.widget_layout.addWidget(self.list)
self.list.setModel(self.model)
self.item_string = {}
infos = ConfigManager.get_infos()
for info in infos:
self.item_string[info] = {"name": " ".join(info.capitalize().split("_"))}
for string in self.item_string:
item = QStandardItem(self.item_string.get(string).get("name"))
item.setFlags(Qt.ItemIsEnabled)
item.setData(QVariant(Qt.Checked), Qt.CheckStateRole)
self.model.appendRow(item)
def loadServos(self):
model = QStandardItemModel()
devs = il.devices(il.NET_PROT.EUSB)
for dev in devs:
try:
net = il.Network(il.NET_PROT.EUSB, dev)
except il.exceptions.ILCreationError:
continue
found = net.servos()
for servo_id in found:
try:
servo = il.Servo(net, servo_id)
except il.exceptions.ILCreationError:
continue
item = QStandardItem('0x{:02x} ({})'.format(servo_id, dev))
item.setData(servo, Qt.UserRole)
image = QImage(join(_RESOURCES, 'images', 'triton-core.png'))
item.setData(QPixmap.fromImage(image), Qt.DecorationRole)
model.appendRow([item])
self.cboxServos.setModel(model)
def populate(self, item_list):
"""
Creates all of the items from the item list and
appends them to the model.
item_list (list): list of strings to be displayed to the user
this should be set with the setCleanItemsFunction.
"""
self.setItemList(item_list)
for i, item_name in enumerate(self.getItemList()):
item = QStandardItem(item_name)
self.model().setItem(i, 0, item)
self.setExistsFlag(False)
def pdfListView(self):
list = QListView()
list.setEditTriggers(QAbstractItemView.NoEditTriggers)
model = QStandardItemModel(list)
for pdf in self.pdfList:
item = QStandardItem(pdf)
model.appendRow(item)
list.setModel(model)
if config.pdfText in self.parent.pdfList:
list.setCurrentIndex(
model.index(self.parent.pdfList.index(config.pdfText), 0))
list.selectionModel().selectionChanged.connect(self.pdfSelected)
return list
def _build_GUI(self, linelist, table_view):
panel_layout = QGridLayout()
panel_layout.setSizeConstraint(QLayout.SetMaximumSize)
self.setLayout(panel_layout)
# GUI cannot be completely defined in a .ui file.
# It has to be built on-the-fly here.
self.button_pane = QWidget()
loadUi(os.path.join(os.path.dirname(__file__), "ui", "linelists_panel_buttons.ui"), self.button_pane)
# internal signals do not use Hub infrastructure.
self.button_pane.create_set_button.clicked.connect(self._create_set)
self.button_pane.deselect_button.clicked.connect(table_view.clearSelection)
# header with line list metadata.
info = QTextBrowser()
info.setMaximumHeight(100)
info.setAutoFillBackground(True)
info.setStyleSheet("background-color: rgb(230,230,230);")
for comment in linelist.meta['comments']:
info.append(comment)
# populate color picker
model = self.button_pane.combo_box_color.model()
for cname in ID_COLORS:
item = QStandardItem(cname)
item.setForeground(ID_COLORS[cname])
item.setData(QColor(ID_COLORS[cname]), role=Qt.UserRole)
model.appendRow(item)
# set validators
validator = QDoubleValidator()
validator.setRange(0.05, 0.95, decimals=2)
self.button_pane.height_textbox.setValidator(validator)
validator = QDoubleValidator()
validator.setRange(-1.e5, 1.e10, decimals=4)
self.button_pane.redshift_textbox.setValidator(validator)
model = self.button_pane.combo_box_z_units.model()
for uname in ['z', 'km/s']:
item = QStandardItem(uname)
model.appendRow(item)
# put it all together
panel_layout.addWidget(info,0,0)
panel_layout.addWidget(table_view,1,0)
panel_layout.addWidget(self.button_pane,2,0)
def getItemModel(self):
"""Return a QModel made from the current workspace. This should be set
onto a QTableView
"""
model = QStandardItemModel()
model.setHorizontalHeaderLabels(["Name", "Type", "Value", "Units"])
model.setColumnCount(4)
for key in self.get_log_names():
log = self.run.getLogData(key)
name = QStandardItem()
name.setText(log.name)
name.setEditable(False)
log_type = QStandardItem()
log_type.setText(get_type(log))
log_type.setEditable(False)
value = QStandardItem()
value.setText(str(get_value(log)))
value.setEditable(False)
unit = QStandardItem()
unit.setText(log.units)
unit.setEditable(False)
model.appendRow((name, log_type, value, unit))
model.sort(0)
return model
def __init__(self, hub, *args, **kwargs):
super().__init__(*args, **kwargs)
self.hub = hub
self.wave_range = (None, None)
loadUi(os.path.join(os.path.dirname(__file__), "ui", "linelists_window.ui"), self)
# QtDesigner can't add a combo box to a tool bar...
self.line_list_selector = QComboBox()
self.line_list_selector.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.line_list_selector.setMinimumWidth(230)
self.line_list_selector.setToolTip("Select line list from internal library")
self.main_toolbar.addWidget(self.line_list_selector)
# QtDesigner creates tabbed widgets with 2 tabs, and doesn't allow
# removing then in the designer itself. Remove in here then.
while self.tab_widget.count() > 0:
self.tab_widget.removeTab(0)
# Local references for often used objects.
self.plot_window = self.hub.plot_window
# Request that line lists be read from wherever are they sources.
if not hasattr(self, 'linelists'):
self._request_linelists()
# Populate line list selector with internal line lists
model = self.line_list_selector.model()
item = QStandardItem("Select line list")
font = QFont("Monospace")
font.setStyleHint(QFont.TypeWriter)
font.setPointSize(12)
item.setFont(font)
model.appendRow(item)
for description in linelist.descriptions():
item = QStandardItem(str(description))
item.setFont(font)
model.appendRow(item)
self.line_labels_plotter = LineLabelsPlotter(self)
# Connect controls to appropriate signals.
self.draw_button.clicked.connect(
lambda:self.line_labels_plotter._plot_linelists(
table_views=self._get_table_views(),
panes=self._get_panes(),
units=self.hub.plot_widget.spectral_axis_unit,
caller=self.line_labels_plotter))
self.erase_button.clicked.connect(lambda:self.erase_linelabels.emit(self.plot_window.plot_widget))
self.dismiss_button.clicked.connect(self.dismiss_linelists_window.emit)
self.actionOpen.triggered.connect(lambda:self._open_linelist_file(file_name=None))
self.actionExport.triggered.connect(lambda:self._export_to_file(file_name=None))
self.line_list_selector.currentIndexChanged.connect(self._lineList_selection_change)
self.tab_widget.tabCloseRequested.connect(self._on_tab_close)
self.hub.plot_window.window_removed.connect(self.dismiss_linelists_window.emit)
def add_model(self, model):
"""
Adds a model to the internal Qt model.
Parameters
----------
model : :class:`astropy.modeling.FittableModel`
The model instance to add.
Returns
-------
:class:`qtpy.QtCore.QModelIndex`
The index in the Qt model where the new model been added.
"""
model_name = model.name or model.__class__.name
model_count = len([self.item(idx) for idx in range(self.rowCount())
if model_name in self.item(idx).text()])
model_name = model_name + "_" + str(model_count) \
if model_count > 0 else model_name
model_item = QStandardItem(model_name)
model_item.setData(model, Qt.UserRole + 1)
for para_name in model.param_names:
# Retrieve the parameter object from the model
parameter = getattr(model, para_name)
# Store the name value
param_name = QStandardItem(parameter.name)
param_name.setData(parameter.name, Qt.UserRole + 1)
param_name.setEditable(False)
# Store the data value of the parameter
param_value = QStandardItem("{:.5g}".format(parameter.value))
param_value.setData(parameter.value, Qt.UserRole + 1)
# Store the unit information
# param_unit = QStandardItem("{}".format(parameter.unit))
param_unit = QStandardItem("Plot Units")
param_unit.setData(parameter.unit, Qt.UserRole + 1)
param_unit.setEditable(False)
# Store the fixed state of the unit
param_fixed = QStandardItem()
param_fixed.setData(parameter.fixed, Qt.UserRole + 1)
param_fixed.setCheckable(True)
param_fixed.setEditable(False)
model_item.appendRow([param_name, param_value, param_unit, param_fixed])
self.appendRow([model_item, None, None, None])
# Add this model to the model equation string. By default, all models
# are simply added together
self._equation += " + {}".format(model_name) \
if len(self._equation) > 0 else "{}".format(model_name)
return model_item.index()
