def create_table_item(column, itemname, invalid_value_count, log_size,
callable, *args):
item = QStandardItem()
item.setEditable(False)
#format if there is invalid data entries
if invalid_value_count == -1:
item.setData(DEEP_RED, Qt.BackgroundRole)
item.setToolTip(
"All of the values in the log are marked invalid, none of them are filtered."
)
elif invalid_value_count > 0:
saturation = 10 + (170 * (invalid_value_count /
(log_size + invalid_value_count)))
item.setData(QColor.fromHsv(0, saturation, 255),
Qt.BackgroundRole)
aux_verb = "is" if invalid_value_count == 1 else "are"
item.setToolTip(
f"{invalid_value_count}/{log_size+invalid_value_count} of the values in the log"
f" {aux_verb} marked invalid, and {aux_verb} filtered.")
try:
item.setText(callable(*args))
except Exception as exc:
logger.warning("Error setting column {} for log {}: {}".format(
column, itemname, str(exc)))
return item
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 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()
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 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 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 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 __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 _update_stations(self):
self.model_stations.clear()
for mt_obj in list(self._mt_obj_dict.values()):
new_item = QStandardItem()
new_item.setData(mt_obj.station, QtCore.Qt.DisplayRole)
new_item.setData(mt_obj.fn, QtCore.Qt.ToolTipRole)
self.model_stations.appendRow(new_item)
self.model_stations.sort(0)
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 load_kpis(self, rootIndex, topology):
kpis = QStandardItem('kpis')
item = self.itemFromIndex(rootIndex)
item.appendRow(kpis)
for conn_key, conn in topology.connections.items():
conn_item = QStandardItem(conn_key)
kpis.appendRow(conn_item)
for kpi_key, kpi in conn.kpis.items():
kpi_item = QStandardItem(kpi_key)
kpi_item.setData('kpi', self.TYPE_ROLE)
kpi_item.setData(kpi, self.MODEL_ROLE)
conn_item.appendRow(kpi_item)
def add_client(self, client: Client):
self._clients.append(client)
if isinstance(client.backend, JSONBackend):
client_item = QStandardItem(client.backend.path)
elif isinstance(client.backend, MongoBackend):
client_item = QStandardItem(
f"{client.backend._client.HOST}/{client.backend._collection.full_name}"
)
self.appendRow(client_item)
for result in client.search():
# add an OphydItem
self.add_device(client_item, result.item)
client_item.setData(client)
def __init__(self, parent, info, title="Channel Properties"):
super().__init__(parent)
self.setWindowTitle(title)
self.model = QStandardItemModel(info["nchan"], 4)
self.model.setHorizontalHeaderLabels(["#", "Label", "Type", "Bad"])
for index, ch in enumerate(info["chs"]):
item = QStandardItem()
item.setData(index, Qt.DisplayRole)
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.model.setItem(index, 0, item)
self.model.setItem(index, 1, QStandardItem(ch["ch_name"]))
kind = channel_type(info, index).upper()
self.model.setItem(index, 2, QStandardItem(str(kind)))
bad = QStandardItem()
bad.setData(ch["ch_name"] in info["bads"], Qt.UserRole)
bad.setCheckable(True)
bad.setEditable(False)
checked = ch["ch_name"] in info["bads"]
bad.setCheckState(Qt.Checked if checked else Qt.Unchecked)
self.model.setItem(index, 3, bad)
self.model.itemChanged.connect(bad_changed)
self.proxymodel = MySortFilterProxyModel()
self.proxymodel.setDynamicSortFilter(False)
self.proxymodel.setSourceModel(self.model)
self.view = QTableView()
self.view.setModel(self.proxymodel)
self.view.setItemDelegateForColumn(2, ComboBoxDelegate(self.view))
self.view.setEditTriggers(QAbstractItemView.AllEditTriggers)
self.view.verticalHeader().setVisible(False)
self.view.horizontalHeader().setStretchLastSection(True)
self.view.setShowGrid(False)
self.view.setSelectionMode(QAbstractItemView.NoSelection)
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(475, 650)
self.view.setColumnWidth(0, 70)
self.view.setColumnWidth(1, 155)
self.view.setColumnWidth(2, 90)
def add_model(self, model):
model_name = model.__class__.name
model_count = len([
self.item(idx) for idx in range(self.rowCount())
if model.__class__.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()
def test_metadataview(qtbot, catalog):
catalogmodel = QStandardItemModel()
selectionmodel = QItemSelectionModel()
selectionmodel.setModel(catalogmodel)
item = QStandardItem()
item.setData('test catalog', Qt.DisplayRole)
item.setData(catalog, Qt.UserRole)
catalogmodel.appendRow(item)
catalogmodel.dataChanged.emit(item.index(), item.index())
selectionmodel.setCurrentIndex(catalogmodel.indexFromItem(item), selectionmodel.SelectCurrent)
w = MetadataView(catalogmodel, selectionmodel)
w.show()
def _build_GUI(self, linelist, table_view):
panel_layout = QVBoxLayout()
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)
self.button_pane.create_set_button.clicked.connect(self._createSet)
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)
panel_layout.addWidget(table_view)
panel_layout.addWidget(self.button_pane)
def show_results(self):
header_labels_set = False
self.show_results_event.clear()
t0 = time.monotonic()
counter = 0
try:
msg.showBusy()
while not self._new_uids_queue.empty():
counter += 1
row = []
new_uid = self._new_uids_queue.get()
try:
entry = self.get_run_by_uid(new_uid)
row_data = self.apply_search_result_row(entry)
except SkipRow as e:
msg.showMessage(str(msg))
msg.logError(e)
continue
if not header_labels_set:
# Set header labels just once.
threads.invoke_in_main_thread(
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)
item.setData(new_uid, Qt.UserRole)
row.append(item)
if QThread.currentThread().isInterruptionRequested():
self.show_results_event.set()
msg.logMessage("Interrupt requested")
return
threads.invoke_in_main_thread(
self.search_results_model.appendRow, row)
if counter:
self.sig_update_header.emit()
duration = time.monotonic() - t0
msg.showMessage("Displayed {} new results {}.".format(
counter, duration))
self.show_results_event.set()
except Exception as e:
msg.showMessage("Error displaying runs")
msg.logError(e)
finally:
msg.hideBusy()
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 _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 __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 loadServos(self):
model = QStandardItemModel()
net, servo = il.lucky(il.NET_PROT.ETH,
"../../resources/dictionaries/eve-net_1.7.1.xdf",
address_ip='192.168.2.22',
port_ip=1061,
protocol=2)
if net is not None and servo is not None:
item = QStandardItem('0x{:02x} ({})'.format(1, "Everest"))
item.setData(servo, Qt.UserRole)
image = QImage(join(_RESOURCES, 'images', 'eve-xcr.png'))
item.setData(QPixmap.fromImage(image), Qt.DecorationRole)
model.appendRow([item])
self.cboxServos.setModel(model)
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 load(self):
self.clear()
"""Walk the tree starting from topology"""
for el, val in presets.topology.items():
item = QStandardItem(el)
self.appendRow(item)
nodes = QStandardItem('nodes')
item.appendRow(nodes)
# Walk the nodes
for node_name, nvals in val['nodes'].items():
n = QStandardItem(node_name)
nodes.appendRow(n)
for nval in nvals:
node_layout = QStandardItem('')
n.appendRow(node_layout)
p = nval.get('position')
if isinstance(p, dict):
p = 'dict..'
pos = QStandardItem(p)
pos.setData('position', self.TYPE_ROLE)
node_layout.appendRow([QStandardItem('position'), pos])
m = nval.get('motion')
if isinstance(m, dict):
m = 'dict..'
mot = QStandardItem(m)
mot.setData('motion', self.TYPE_ROLE)
node_layout.appendRow([QStandardItem('motion'), mot])
mdl = QStandardItem(nval.get('model'))
node_layout.appendRow([QStandardItem('model'), mdl])
connections = QStandardItem('connections')
item.appendRow(connections)
# Walk the connections
for conn in val['connections']:
c = QStandardItem('')
connections.appendRow(c)
src = QStandardItem('Source:')
src_val = QStandardItem(conn['source'])
src_val.setData('combo', self.TYPE_ROLE)
c.appendRow([src, src_val])
snk = QStandardItem('Sink:')
snk_val = QStandardItem(conn['sink'])
snk_val.setData('combo', self.TYPE_ROLE)
c.appendRow([snk, snk_val])
mdl = QStandardItem('Model:')
mdl_val = QStandardItem(conn['model'])
c.appendRow([mdl, mdl_val])
def add_catalogs(self):
config_file_to_broker = defaultdict(list)
catalog_names = list(catalog)
for name in catalog_names:
broker = Broker.named(name)
if getattr(broker, 'v2', None) is None:
msg.logMessage(
f'The broker named {name} cannot be cast to a v2 Broker.',
msg.WARNING)
continue
# catalog_dir might be in the metadata; if not, let's try to find it
if 'catalog_dir' in broker.v2.metadata:
config_file = broker.v2.metadata["catalog_dir"]
else:
config_file = find_catalog(name)
config_file_to_broker[config_file].append(broker)
for config_file, brokers in config_file_to_broker.items():
config_file_item = QStandardItem()
config_file_item.setData(config_file, Qt.DisplayRole)
self.appendRow(config_file_item)
for broker in brokers:
broker_item = QStandardItem()
broker_item.setData(broker.name, Qt.DisplayRole)
broker_item.setData(broker, self.broker_role)
config_file_item.appendRow(broker_item)
def populatePortList(self, model, tv, ports):
tv.setModel(model)
root = model.invisibleRootItem()
portsdict = {}
for port in ports:
if port.client not in portsdict:
portsdict[port.client] = []
portsdict[port.client].append(port)
for client in humansorted(portsdict):
clientitem = QStandardItem(client)
for port in humansorted(portsdict[client],
key=attrgetter("group", "order", "name")):
portspec = (port.client, port.name)
if port.pretty_name:
label = "%s (%s)" % (port.pretty_name, port.name)
else:
label = port.name
portitem = QStandardItem(label)
portitem.setData(portspec)
portitem.setCheckable(True)
portitem.setUserTristate(False)
# Check box toggling is done in the treeview clicked handler "on_port_clicked"
portitem.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
portitem.setToolTip(self.makePortTooltip(port))
if portspec in self.rec_sources:
portitem.setCheckState(2)
clientitem.appendRow(portitem)
root.appendRow(clientitem)
tv.expandAll()
def addItem(self, text, data=None, toolTip=None):
item = QStandardItem()
item.setText(text)
if data is None:
item.setData(text)
else:
item.setData(data)
if toolTip is not None:
item.setToolTip(toolTip)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable)
item.setData(Qt.Checked if text in self.checkItems else Qt.Unchecked, Qt.CheckStateRole)
self.model().appendRow(item)
def add_catalogs(self):
config_file_to_broker = defaultdict(list)
catalog_names = list(catalog)
for name in catalog_names:
broker = Broker.named(name)
config_file = broker.v2.metadata["catalog_dir"]
config_file_to_broker[config_file].append(broker)
for config_file, brokers in config_file_to_broker.items():
config_file_item = QStandardItem()
config_file_item.setData(config_file, Qt.DisplayRole)
self.appendRow(config_file_item)
for broker in brokers:
broker_item = QStandardItem()
broker_item.setData(broker.name, Qt.DisplayRole)
broker_item.setData(broker, self.broker_role)
config_file_item.appendRow(broker_item)
def append(self, thread):
item = QStandardItem(repr(thread.method))
item.setData(thread, role=self.ThreadRole)
self.appendRow(item)
self._threads.append(thread)
from qtpy.QtCore import Qt, QVariant, QSortFilterProxyModel
from qtpy.QtGui import QStandardItemModel, QStandardItem
from qtpy.QtWidgets import QApplication, QTableView
class NumberSortModel(QSortFilterProxyModel):
def lessThan(self, left, right):
lvalue = float(left.data())
rvalue = float(right.data())
return lvalue < rvalue
if __name__ == "__main__":
app = QApplication(sys.argv)
model = QStandardItemModel(5, 5)
random.seed()
for i in range(5):
for j in range(5):
item = QStandardItem()
item.setData(QVariant(str(random.randint(-500, 500)/10.0)), Qt.DisplayRole)
model.setItem(i, j, item)
proxy = NumberSortModel()
proxy.setSourceModel(model)
view = QTableView()
view.setModel(proxy)
view.setSortingEnabled(True)
view.show()
sys.exit(app.exec_())
def _build_GUI(self, linelist, table_view):
panel_layout = QVBoxLayout()
panel_layout.setSizeConstraint(QLayout.SetMaximumSize)
self.setLayout(panel_layout)
# 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)
# buttons and selectors dedicated to the specific list
# displayed in this pane.
button_pane = QWidget()
hlayout = QGridLayout()
# 'add set' button
self.create_set_button = QPushButton(self)
self.create_set_button.setObjectName("add_set_button")
_translate = QCoreApplication.translate
self.create_set_button.setText(_translate("MainWindow", "Create set"))
self.create_set_button.setToolTip(
"Create new line set from selected lines.")
self.create_set_button.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Minimum)
hlayout.addWidget(self.create_set_button, 1, 0)
# the create_set button is enabled/disabled by logic elsewhere
self.create_set_button.setEnabled(False)
self.create_set_button.clicked.connect(lambda: self._createSet())
# 'deselect all' button
deselect_button = QPushButton(self)
deselect_button.setObjectName("deselect_button")
_translate = QCoreApplication.translate
deselect_button.setText(_translate("MainWindow", "Deselect"))
deselect_button.setToolTip("Un-select everything on this set.")
deselect_button.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
hlayout.addWidget(deselect_button, 1, 1)
deselect_button.clicked.connect(lambda: table_view.clearSelection())
# color picker
self.combo_box_color = QComboBox(self)
self.combo_box_color.setObjectName("color_selector")
self.combo_box_color.setToolTip(
"Color for selected lines in this set.")
model = self.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)
hlayout.addWidget(self.combo_box_color, 1, 2)
hlayout.addWidget(QLabel("Color"), 0, 2)
# plotting height
self.height_textbox = QLineEdit(str(DEFAULT_HEIGHT))
validator = QDoubleValidator()
validator.setRange(0.05, 0.95, decimals=2)
self.height_textbox.setValidator(validator)
self.height_textbox.setFixedWidth(50)
self.height_textbox.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.height_textbox.setToolTip("Relative height to plot.")
hlayout.addWidget(self.height_textbox, 1, 3)
hlayout.addWidget(QLabel("Height"), 0, 3)
# redshift
self.redshift_textbox = QLineEdit(str(0.0))
validator = QDoubleValidator()
validator.setRange(-1.e5, 1.e10, decimals=4)
self.redshift_textbox.setValidator(validator)
self.redshift_textbox.setFixedWidth(70)
self.redshift_textbox.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.Fixed)
self.redshift_textbox.setToolTip("Redshift lines by")
hlayout.addWidget(self.redshift_textbox, 1, 4)
hlayout.addWidget(QLabel("Redshift"), 0, 4)
# redshift units
self.combo_box_z_units = QComboBox(self)
self.combo_box_z_units.setObjectName("redshift_units")
self.combo_box_z_units.setToolTip("Redshift units.")
model = self.combo_box_z_units.model()
for uname in ['z', 'km/s']:
item = QStandardItem(uname)
model.appendRow(item)
hlayout.addWidget(self.combo_box_z_units, 1, 5)
# put it all together.
spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
hlayout.addItem(spacerItem, 1, 6)
button_pane.setLayout(hlayout)
panel_layout.addWidget(info)
panel_layout.addWidget(table_view)
panel_layout.addWidget(button_pane)
app = QApplication([])
window = QMainWindow()
layout = QVBoxLayout()
model = DerivedDataModel()
from xicam.plugins.hints import PlotHint, ImageHint, CoPlotHint
parentItem = QStandardItem("blah")
parentItem.setCheckable(True)
import numpy as np
for i in range(3):
hint = PlotHint(np.arange(10),
np.random.random((10, )),
name=f"1-Time")
item = QStandardItem(hint.group)
item.setData(hint, Qt.UserRole)
item.setCheckable(True)
parentItem.appendRow(item)
hint = ImageHint(np.random.random((100, 100)),
xlabel="x",
ylabel="y",
name="2-Time")
item = QStandardItem(hint.group)
item.setData(hint, Qt.UserRole)
item.setCheckable(True)
parentItem.appendRow(item)
model.appendRow(parentItem)
workflowItem = QStandardItem("A Workflow Result")
workflowItem.setCheckable(True)
hints = []
def add_device(self, client_item: QStandardItem, device: Device):
device_item = QStandardItem(device.name)
device_item.setData(device, self.happiItemRole)
client_item.appendRow(device_item)
