def __clean_and_load_entries__(self, working_date: str):
"""
Cleans entry table when switch working day.
:param working_date:
:return:
"""
row = 0
entries = self.time_capture_service.load_working_entries(working_date)
clean_table(self.ui.table_times)
for e in entries:
self.ui.table_times.insertRow(row)
qte = QTimeEdit(self.ui.table_times)
qte.setTime(e[wek.START_TIME])
self.ui.table_times.setCellWidget(row, E_START_TIME_COL, qte)
qte = QTimeEdit(self.ui.table_times)
qte.setTime(e[wek.END_TIME])
self.ui.table_times.setCellWidget(row, E_END_TIME_COL, qte)
self.ui.table_times.setItem(row, E_ORDER_COL, QTableWidgetItem(e[wek.ORDER]))
self.ui.table_times.setItem(row, E_COMMENT_COL, QTableWidgetItem(e[wek.COMMENT]))
row += 1
self.ui.table_times.resizeRowsToContents()
def __clean_and_load_bookings__(self, working_date: str=None):
"""
Cleans booking table when switch working day.
:param working_date:
:return:
"""
row = 0
t: QTableWidget = self.ui.table_bookings
clean_table(t)
bookings = list()
if working_date is not None:
bookings = self.time_capture_service.load_bookings(working_date)
else:
bookings = self.__convert_entities_to_bookings__()
for b in bookings:
t.insertRow(row)
qcb = QCheckBox(self.ui.table_bookings)
qcb.setChecked(b[bk.BOOKED])
t.setCellWidget(row, B_BOOKED, qcb)
qcb = QCheckBox(self.ui.table_bookings)
qcb.setChecked(b[bk.LOGGED])
t.setCellWidget(row, B_LOGGED, qcb)
qdsb = QDoubleSpinBox(self.ui.table_bookings)
qdsb.setValue(b[bk.HOURS])
t.setCellWidget(row, B_HOURS, qdsb)
t.setItem(row, B_ORDER, QTableWidgetItem(b[bk.ORDER]))
t.setItem(row, B_COMMENT, QTableWidgetItem(b[bk.COMMENT]))
t.resizeRowsToContents()
row += 1
def refresh_view(self):
self.measurements_storage.change_expand(self.expand_mode.isChecked())
self.info_field.clear()
save_orientation = self.horizontal_measurement_present.isChecked()
columns, rows = self.measurements_storage.get_size(save_orientation)
if self.file_names.get_value() == FileNamesEnum.No:
rows -= 1
shift = 1
else:
shift = 0
self.info_field.setColumnCount(columns)
self.info_field.setRowCount(rows)
self.info_field.setHorizontalHeaderLabels(self.measurements_storage.get_header(save_orientation))
self.info_field.setVerticalHeaderLabels(self.measurements_storage.get_rows(save_orientation))
if self.file_names.get_value() == FileNamesEnum.Full:
for y in range(columns):
self.info_field.setItem(
0, y, QTableWidgetItem(self.measurements_storage.get_val_as_str(0, y, save_orientation))
)
elif self.file_names.get_value() == FileNamesEnum.Short:
for y in range(columns):
self.info_field.setItem(
0,
y,
QTableWidgetItem(
os.path.basename(self.measurements_storage.get_val_as_str(0, y, save_orientation))
),
)
for x in range(1, rows + shift):
for y in range(columns):
self.info_field.setItem(
x - shift, y, QTableWidgetItem(self.measurements_storage.get_val_as_str(x, y, save_orientation))
)
def rebin_variable_chosen(self, row):
steps, ok = QtWidgets.QInputDialog.getText(self, 'Bin Boundaries',
'Rebinning creates a new workspace.\n'
'A comma separated list of first bin boundary, width, last bin '
'boundary.\n'
'Optionally this can be followed by a comma and more widths and last'
' boundary pairs.\n'
'Optionally this can also be a single number, which is the bin '
'width.\n'
'Negative width values indicate logarithmic binning.\n\n'
'For example:\n'
'2,-0.035,10: from 2 rebin in Logarithmic bins of 0.035 up to 10;\n'
'0,100,10000,200,20000: from 0 rebin in steps of 100 to 10,000 then '
'steps of 200 to 20,000')
if not ok:
self.grouping_table.cellWidget(row, 4).setCurrentIndex(0)
return
if not steps.strip():
self.grouping_table.cellWidget(row, 4).setCurrentIndex(0)
self.warning_popup("Rebin parameters not given")
return
bin_text = "Bin Boundaries: " + str(steps)
table_item = QTableWidgetItem(bin_text)
table_item.setFlags(TABLE_COLUMN_FLAGS['rebin_options'])
self.grouping_table.setItem(row, 5, table_item)
def createEditor(self, parent, option, index):
ws = option.rect.width()
hs = option.rect.height() + 4
xs = option.rect.x()
ys = option.rect.y() - 2
if index.column() in [2]:
filt = "CGNS Files (*.hdf *.cgns)"
filename = str(QFileDialog.getOpenFileName(self._table,
"Select file",
filter=filt)[0])
(dname, fname) = os.path.split(filename)
if not dname or not fname:
return None
itf = QTableWidgetItem(fname)
itd = QTableWidgetItem(dname)
self._table.setItem(index.row(), 2, itf)
self._table.setItem(index.row(), 4, itd)
return None
if index.column() in [1, 3]:
editor = QLineEdit(parent)
editor.transgeometry = (xs, ys, ws, hs)
editor.installEventFilter(self)
self.setEditorData(editor, index)
return editor
return None
def add_regulation(self):
rc = self.regulations_table.rowCount()
self.regulations_table.setRowCount(rc + 1)
for i, obj in enumerate(self.initial_values):
item = QTableWidgetItem()
item.setData(0, obj)
self.regulations_table.setItem(rc, i, item)
def table_to_widget(table: dict) -> QTableWidget:
view = QTableWidget(len(next(iter(table.values()))), len(table))
for i, column in enumerate(table.keys()):
view.setItem(0, i, QTableWidgetItem(column))
for j, value in enumerate(table.get(column)):
view.setItem(j + 1, i, QTableWidgetItem(str(value)))
return view
def value_changed(self, new_waveform):
"""
Callback invoked when the Channel value is changed.
Parameters
----------
new_waveform : np.ndarray
The new waveform value from the channel.
"""
PyDMWritableWidget.value_changed(self, new_waveform)
self._valueBeingSet = True
self.waveform = new_waveform
col_count = self.columnCount()
len_wave = len(new_waveform)
row_count = len_wave//col_count + (1 if len_wave % col_count else 0)
self.setRowCount(row_count)
for ind, element in enumerate(new_waveform):
i, j = ind//col_count, ind % col_count
value_cell = QTableWidgetItem(str(element))
value_cell.setFlags(self._itemsFlags)
self.setItem(i, j, value_cell)
self.setVerticalHeaderLabels(self._rowHeaders)
self.setHorizontalHeaderLabels(self._columnHeaders)
self._valueBeingSet = False
def on_create_super_group(self):
inames = [
iname for iname, check in enumerate(self.checks)
if bool(check.checkState())
]
if not len(inames):
# TODO: add logging
print('nothing is checked...')
return
if inames[0] == 0:
# TODO: add logging
print("cannot include 'ALL' in supergroup...")
return
name = 'SuperGroup'
# popup gui and get a name
irow = self.table.rowCount()
self.table.insertRow(irow)
check = QTableWidgetItem()
check.setCheckState(False)
name_text = QTableWidgetItem(str(name))
self.names.extend(name)
self.names_text.append(name_text)
self.checks.append(check)
self.table.setItem(irow, 0, check)
self.table.setItem(irow, 1, name_text)
def _add_new_row(self, fn_pattern, reader):
"""Add new reader preference to table"""
last_row = self._table.rowCount()
if (last_row == 1 and 'No filename preferences found'
in self._table.item(0, 0).text()):
self._table.removeRow(0)
last_row = 0
self._table.insertRow(last_row)
item = QTableWidgetItem(fn_pattern)
item.setFlags(Qt.NoItemFlags)
self._table.setItem(last_row, self._fn_pattern_col, item)
plugin_widg = QWidget()
# need object name to easily find row
plugin_widg.setObjectName(f'{fn_pattern}')
plugin_widg.setLayout(QHBoxLayout())
plugin_widg.layout().setContentsMargins(0, 0, 0, 0)
if reader in self._npe2_readers:
reader = self._npe2_readers[reader]
plugin_label = QLabel(reader, objectName=fn_pattern)
# need object name to easily work out which button was clicked
remove_btn = QPushButton('X', objectName=fn_pattern)
remove_btn.setFixedWidth(30)
remove_btn.setStyleSheet('margin: 4px;')
remove_btn.setToolTip(
trans._('Remove this filename pattern to reader association'))
remove_btn.clicked.connect(self.remove_existing_preference)
plugin_widg.layout().addWidget(plugin_label)
plugin_widg.layout().addWidget(remove_btn)
self._table.setCellWidget(last_row, self._reader_col, plugin_widg)
def refresh_table(self, job_list):
for _row in range(self.ui.tableWidget.rowCount()):
self.ui.tableWidget.removeRow(0)
nbr_row = len(job_list)
for _row in range(nbr_row):
_row_job = job_list[_row]
self.ui.tableWidget.insertRow(_row)
# job name
_item = QTableWidgetItem(_row_job['job_name'])
self.ui.tableWidget.setItem(_row, 0, _item)
# time
_item = QTableWidgetItem(_row_job['time'])
self.ui.tableWidget.setItem(_row, 1, _item)
# action
_pid = _row_job['pid']
process = psutil.Process(_pid)
if not process.is_running():
_item = QTableWidgetItem("Done!")
self.ui.tableWidget.setItem(_row, 2, _item)
else:
if _row_job['status'] == 'processing':
_widget = QPushButton()
_widget.setText("Abort!")
_widget.clicked.connect(lambda row=_row:
self.parent.kill_job(row))
self.ui.tableWidget.setCellWidget(_row, 2, _widget)
else:
_item = QTableWidgetItem("Killed!")
self.ui.tableWidget.setItem(_row, 2, _item)
def test_onClickOpenSelectedInScriptWindow(self):
self.prw.ui.tableWidget.selectedItems.return_value = \
[QTableWidgetItem("1"), QTableWidgetItem("2"), QTableWidgetItem("No")]
self.prw.onClickOpenSelectedInScriptWindow()
self.prw.presenter.open_selected_checkpoint_in_editor.assert_called_with(
"1")
def _set_table_item(self, json=None, metadata_filter={}, row=-1, col=-1):
"""Populate the filter metadada table from the oncat json file of only the arguments specified in
the config.json file (oncat_metadata_filters)"""
table_ui = self.table_ui
def _format_proton_charge(raw_proton_charge):
_proton_charge = raw_proton_charge / 1e12
return "{:.3}".format(_proton_charge)
title = metadata_filter['title']
list_args = metadata_filter["path"]
argument_value = json_extractor(json=json,
list_args=copy.deepcopy(list_args))
# if title is "Proton Charge" change format of value displayed
if title == "Proton Charge (C)":
argument_value = _format_proton_charge(argument_value)
if table_ui is None:
table_ui = self.ui.tableWidget_filter_result
if self.parent.first_time_filling_table:
table_ui.insertColumn(col)
_item_title = QTableWidgetItem(title)
table_ui.setHorizontalHeaderItem(col, _item_title)
width = metadata_filter["column_width"]
table_ui.setColumnWidth(col, width)
_item = QTableWidgetItem("{}".format(argument_value))
table_ui.setItem(row, col, _item)
def value_changed(self, new_waveform):
"""
Callback invoked when the Channel value is changed.
Parameters
----------
new_waveform : np.ndarray
The new waveform value from the channel.
"""
PyDMWritableWidget.value_changed(self, new_waveform)
self._valueBeingSet = True
self.waveform = new_waveform
col_count = self.columnCount()
len_wave = len(new_waveform)
row_count = len_wave // col_count + (1 if len_wave % col_count else 0)
self.setRowCount(row_count)
for ind, element in enumerate(new_waveform):
i, j = ind // col_count, ind % col_count
value_cell = QTableWidgetItem(str(element))
value_cell.setFlags(self._itemsFlags)
self.setItem(i, j, value_cell)
self.setVerticalHeaderLabels(self._rowHeaders)
self.setHorizontalHeaderLabels(self._columnHeaders)
self._valueBeingSet = False
def set_data_2d(self,
data: 'Iterable',
rows: int = None,
columns: int = None):
if not hasattr(data, '__len__'):
item = QTableWidgetItem(str(data))
self.setItem(0, 0, item)
return
if rows is None or columns is None:
rows = len(data)
max_cols = 0
for row_contents in data:
if hasattr(row_contents, '__iter__'):
col_span = len(row_contents)
else:
col_span = 1
if col_span > max_cols:
max_cols = col_span
columns = max_cols
self.setColumnCount(columns)
self.setRowCount(rows)
self.setSelectionBehavior(QAbstractItemView.SelectRows)
for row, row_content in enumerate(data):
if hasattr(row_content, '__iter__'):
for col, content in enumerate(row_content):
item = QTableWidgetItem(str(data[row][col]))
self.setItem(row, col, item)
else:
item = QTableWidgetItem(str(data[row]))
self.setItem(row, 0, item)
def reload(self):
"""Reload the tracks features from the layers to the table widget"""
particles = self.viewer.layers[self.layer_name].data
features = self.viewer.layers[self.layer_name].metadata
headers = ['track_id']
for key in features:
if isinstance(features[key], dict):
headers.append(key)
self.tableWidget.setColumnCount(len(headers))
self.tableWidget.setHorizontalHeaderLabels(headers)
self.tableWidget.setRowCount(len(np.unique(particles[:, 0])))
features_dict = dict()
tracks_ids = np.unique(particles[:, 0])
for id_ in tracks_ids:
features_dict[id_] = list()
for key in features:
if isinstance(features[key], dict):
feature_dict = features[key]
for f_key in feature_dict:
if f_key in features_dict:
features_dict[f_key].append(str(feature_dict[f_key]))
line = -1
for key in features_dict:
line += 1
# track_id = key
self.tableWidget.setItem(line, 0, QTableWidgetItem(str(key)))
# add each feature per column
col = 0
for feature in features_dict[key]:
col += 1
self.tableWidget.setItem(line, col, QTableWidgetItem(feature))
def write_info(self, data_stream):
if len(data_stream) < 1:
return
if len(data_stream[0]) > 40:
return
rcount = self.rxtable.rowCount()
####pprint.pprint(data_stream)
cntr = 0
hexstr = ''
intstr = ''
txt = ''
decimals = ''
str_int_digits = []
str_hex_digits = []
str_ampere = ''
for ttx in data_stream:
for itx in ttx:
txt += '{:02X} '.format(int(itx))
cntr += 1
if cntr > 2:
intstr += '{:04d} '.format(int(hexstr, 16))
str_int_digits.append('{:04d}'.format(int(hexstr, 16)))
hexstr = ''
cntr = 1
hexstr += '{:02X}'.format(int(itx))
str_hex_digits.append(hexstr)
if len(str_int_digits) > 7:
try:
#pprint.pprint(str_int_digits)
self.lcddcout.display(str(int(str_int_digits[5])))
self.lcddcin.display(str(int(str_int_digits[6])))
str_ampere = str(
int(str_hex_digits[3][-2:], 16) - 128
) # + '.' + str_hex_digits[2][-1] + str_hex_digits[1][-1]
print('Amp : ' + str_hex_digits[3][-2:])
self.lcddcamp.display(float(str_ampere))
#pprint.pprint(str_hex_digits)
print('KWh : ' + str_hex_digits[9][-2:]
) #+ str(int(str_hex_digits[5][-2:], 16)))
self.lcdkwhob.display(int(str_hex_digits[9][-2:], 16))
self.outback_dcout = str(int(str_int_digits[5]))
self.outback_dcin = str(int(str_int_digits[6]))
self.outback_current = str(
int(str_hex_digits[3][-2:], 16) - 128)
self.outback_kwh = str(int(str_hex_digits[9][-2:], 16))
except Exception as e:
print('exc - lcddcamp : ' + str_hex_digits[3] + ' : ' + str(e))
self.rxtable.insertRow(rcount)
self.rxtable.setItem(rcount, 0, QTableWidgetItem(txt))
self.rxtable.setItem(rcount, 1, QTableWidgetItem(intstr))
if self.isAutoScroll:
self.rxtable.scrollToBottom()
self.rxtable.resizeColumnsToContents()
self.rxtable.resizeRowsToContents()
def updateStatus(self, param):
self.status[param["device"]] = "{}".format(param["status"])
idx = 0
self.deviceStatus.setRowCount(len(self.status))
for k, v in self.status.items():
self.deviceStatus.setItem(idx, 0, QTableWidgetItem(k))
self.deviceStatus.setItem(idx, 1, QTableWidgetItem(v))
idx += 1
def _add_item(data):
row = dc.size()
self._content.data_set_table.insertRow(row)
for i in range(len(data)):
if data[i] is not None:
item = QTableWidgetItem(str(data[i]))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self._content.data_set_table.setItem(row, i, item)
def update_current_position(self, coords: Sequence[Union[_Coord, Tuple[_Coord, _Coord]]]) -> None:
"""Update the current coordinate for a point."""
for i, c in enumerate(coords):
if type(c[0]) is float:
text = f"({c[0]:.06f}, {c[1]:.06f})"
else:
text = "; ".join(f"({x:.06f}, {y:.06f})" for x, y in c)
item = QTableWidgetItem(text)
item.setToolTip(text)
self.setItem(i, 6, item)
def reset_headers(self):
"""Update the column and row numbering in the headers."""
rows = self.rowCount()
cols = self.columnCount()
for r in range(rows):
self.setVerticalHeaderItem(r, QTableWidgetItem(str(r)))
for c in range(cols):
self.setHorizontalHeaderItem(c, QTableWidgetItem(str(c)))
self.setColumnWidth(c, 40)
def set_values(self, values: dict) -> None:
"""Populate the table with keys and values.
values : dict
Populate with these keys and values.
"""
self.setRowCount(len(values))
self.setColumnCount(2)
for i, (key, value) in enumerate(values.items()):
self.setItem(i, 0, QTableWidgetItem(key))
self.setItem(i, 1, QTableWidgetItem(value))
def load_regulations(self, regulations: List[Dict[str,
Union[int, str, float,
bool]]]):
row_count = len(regulations)
self.regulations_table.setRowCount(row_count)
for i, regulation in enumerate(regulations):
l = [regulation[k] for k in self.table_keys]
for j, obj in enumerate(l):
item = QTableWidgetItem()
item.setData(0, obj)
self.regulations_table.setItem(i, j, item)
def initControlTable(self):
ctw = self.controlTable
ctw.control = self
cth = ctw.horizontalHeader()
ctw.verticalHeader().hide()
h = ['S', 'T', 'View', 'Dir', 'File', 'Node']
for i in range(len(h)):
hi = QTableWidgetItem(h[i])
hi.setFont(OCTXT._Label_Font)
ctw.setHorizontalHeaderItem(i, hi)
cth.setSectionResizeMode(i, QHeaderView.ResizeToContents)
cth.setSectionResizeMode(len(h) - 1, QHeaderView.Stretch)
def _rebuild_table(self) -> None:
self.clearContents()
props = list(iter_dev_props(self._mmc))
self.setRowCount(len(props))
for i, (dev, prop) in enumerate(props):
item = QTableWidgetItem(f"{dev}-{prop}")
wdg = PropertyWidget(dev, prop, core=self._mmc)
self.setItem(i, 0, item)
self.setCellWidget(i, 1, wdg)
if wdg.isReadOnly():
# TODO: make this more theme aware
item.setBackground(QColor("#AAA"))
wdg.setStyleSheet("QLabel { background-color : #AAA }")
def __rename(self, new_name: str, args: LinkArgs) -> None:
"""Adjust link name in all dependents, if link name are changed."""
if args.name == new_name:
return
for index in _no_empty(args.points.split(',')):
row = int(index.replace('Point', ''))
item = QTableWidgetItem(','.join(
_no_empty(
link.replace(args.name, new_name)
for link in self.vpoint_list[row].links)))
item.setFlags(_ITEM_FLAGS)
self.point_table.setItem(row, 1, item)
self.vpoint_list[row].replace_link(args.name, new_name)
def populate_plugin_list(self):
col_labels = ["Protocol", "File"]
self.ui.dataPluginsTableWidget.setColumnCount(len(col_labels))
self.ui.dataPluginsTableWidget.setHorizontalHeaderLabels(col_labels)
self.ui.dataPluginsTableWidget.horizontalHeader().setStretchLastSection(True)
self.ui.dataPluginsTableWidget.verticalHeader().setVisible(False)
for (protocol, plugin) in pydm.data_plugins.plugin_modules.items():
protocol_item = QTableWidgetItem(protocol)
file_item = QTableWidgetItem(inspect.getfile(plugin.__class__))
new_row = self.ui.dataPluginsTableWidget.rowCount()
self.ui.dataPluginsTableWidget.insertRow(new_row)
self.ui.dataPluginsTableWidget.setItem(new_row, 0, protocol_item)
self.ui.dataPluginsTableWidget.setItem(new_row, 1, file_item)
def set_data(self, data: List[dict], headers: Optional[List[str]] = None):
"""Set the data in the table, given a list of dicts.
Parameters
----------
data : List[dict]
A list of dicts where each dict in the list is a row, and each key
in the dict is a header, by default None. (call set_data later to
add data)
headers : list of str, optional
If provided, will be used in order as the headers of the table. All
items in ``headers`` must be present in at least one of the dicts.
by default headers will be the set of all keys in all dicts in
``source``
"""
if not isinstance(data, list) or any(
not isinstance(i, dict) for i in data
):
raise ValueError("'data' argument must be a list of dicts")
nrows = len(data)
_headers = sorted(set().union(*data))
if headers:
for h in headers:
if h not in _headers:
raise ValueError(
trans._(
"Argument 'headers' got item '{h}', which was not found in any of the items in 'data'".format(
h=h
)
)
)
_headers = headers
self.setRowCount(nrows)
self.setColumnCount(len(_headers))
for row, elem in enumerate(data):
for key, value in elem.items():
value = value or ''
try:
col = _headers.index(key)
except ValueError:
continue
item = QTableWidgetItem(value)
# underline links
if email_pattern.match(value) or url_pattern.match(value):
font = QFont()
font.setUnderline(True)
item.setFont(font)
self.setItem(row, col, item)
self.setHorizontalHeaderLabels(_headers)
self.resize_to_fit()
def reset(self):
tlvcols = 4
tlvcolsnames = ['S', 'Pattern', 'P', 'Comment']
v = self.patternTable
v.setColumnCount(tlvcols)
lh = v.horizontalHeader()
lv = v.verticalHeader()
h = tlvcolsnames
n = len(h)
for i in range(n):
hi = QTableWidgetItem(h[i])
v.setHorizontalHeaderItem(i, hi)
for profkey in self._profiles:
prof = self._profiles[profkey]
for k in prof:
pentry = prof[k]
v.setRowCount(v.rowCount() + 1)
r = v.rowCount() - 1
it1 = QTableWidgetItem(self.IC(QW.I_EMPTY), '')
it2 = QTableWidgetItem(k)
it2.setFont(QFont("Courier"))
it3 = QTableWidgetItem(profkey)
it4 = QTableWidgetItem(pentry[2])
v.setItem(r, 0, it1)
v.setItem(r, 1, it2)
v.setItem(r, 2, it3)
v.setItem(r, 3, it4)
self.patternTable.resizeColumnsToContents()
self.patternTable.resizeRowsToContents()
plist = []
for i in range(len(plist)):
v.resizeColumnToContents(i)
for i in range(v.rowCount()):
v.resizeRowToContents(i)
self._initialized = True
def reload(self):
"""Reload the particles properties from the layers to the table widget"""
particles = self.viewer.layers[self.layer_name].data
print(particles)
properties = self.viewer.layers[self.layer_name].properties
headers = []
if particles.shape[1] == 3:
headers = ['T', 'Y', 'X']
elif particles.shape[1] == 4:
headers = ['T', 'Z', 'Y', 'X']
for key in properties:
headers.append(key)
self.tableWidget.setColumnCount(len(headers))
self.tableWidget.setHorizontalHeaderLabels(headers)
self.tableWidget.setRowCount(particles.shape[0])
col = 0
for line in range(particles.shape[0]):
col = -1
# T
if particles.shape[1] == 4:
col += 1
self.tableWidget.setItem(line, col,
QTableWidgetItem(
str(particles[line, col])))
# T or Z
if particles.shape[1] >= 3:
col += 1
self.tableWidget.setItem(line, col,
QTableWidgetItem(
str(particles[line, col])))
# Y
col += 1
self.tableWidget.setItem(line, col,
QTableWidgetItem(
str(particles[line, col])))
# X
col += 1
self.tableWidget.setItem(line, col,
QTableWidgetItem(
str(particles[line, col])))
# properties
for key in properties:
col += 1
prop = properties[key]
for line in range(len(prop)):
self.tableWidget.setItem(line, col,
QTableWidgetItem(str(prop[line])))
def display_ranks(self):
if self.ranks is None:
return
# https://stackoverflow.com/questions/7960505/strange-qtablewidget-behavior-not-all-cells-populated-after-sorting-followed-b
self.ranks_tbl.setSortingEnabled(False)
nrow, ncol = self.ranks.shape
irow = 0
for index, row in self.ranks.iterrows():
pcell = QTableWidgetItem()
pcell.setText(index)
self.ranks_tbl.setItem(irow, 0, pcell)
for icol in range(ncol):
cell = QTableWidgetItem()
val = row.iloc[icol]
#if icol in [0, 1]:
# val = str(int(val))
#else:
# val = "{0:.3f}".format(val)
#cell.setText(val)
if icol in [0, 1]:
val = int(val)
else:
val = "{0:.3f}".format(val)
cell.setData(Qt.EditRole, QVariant(val))
self.ranks_tbl.setItem(irow, icol + 1, cell)
irow += 1
self.ranks_tbl.setSortingEnabled(True)
def __init__(self, data, editable=False):
# if not editable just initialise the ItemWidget as string
if isinstance(data, V3D):
self.is_v3d = True
else:
self.is_v3d = False
if not editable:
QTableWidgetItem.__init__(self, str(data))
self.setFlags(self.flags() & ~Qt.ItemIsEditable)
return
QTableWidgetItem.__init__(self)
if isinstance(data, V3D):
data = str(data)
self.display_data = data
# this will correctly turn all number cells into number types
self.reset()
def append_row(self, row_value_list, type_list=None):
"""
append a row to the table
:param row_value_list: row_value_list
:param type_list:
:return: 2-tuple as (boolean, message)
"""
# Check input
assert isinstance(row_value_list, list), 'Row values {0} must be given by a list but ' \
'not a {1}'.format(row_value_list, type(row_value_list))
if type_list is not None:
assert isinstance(type_list, list), 'Value types {0} must be given by a list but ' \
'not a {1}'.format(type_list, type(type_list))
if len(row_value_list) != len(type_list):
raise RuntimeError('If value types are given, then they must have the same '
'numbers ({0}) and values ({1})'.format(len(row_value_list),
len(type_list)))
else:
type_list = self._myColumnTypeList
if len(row_value_list) != self.columnCount():
ret_msg = 'Input number of values (%d) is different from ' \
'column number (%d).' % (len(row_value_list), self.columnCount())
return False, ret_msg
else:
ret_msg = ''
# Insert new row
row_number = self.rowCount()
self.insertRow(row_number)
# Set values
for i_col in range(min(len(row_value_list), self.columnCount())):
item = QTableWidgetItem()
if row_value_list[i_col] is None:
item_value = ''
else:
item_value = str(row_value_list[i_col])
item.setText(_fromUtf8(item_value))
item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEditable)
# Set editable flag! item.setFlags(item.flags() | ~QtCore.Qt.ItemIsEditable)
if type_list[i_col] == 'checkbox':
self.set_check_box(row_number, i_col, False)
else:
self.setItem(row_number, i_col, item)
# END-FOR(i_col)
return True, ret_msg
def set_value_cell(self, row, col, value=''):
"""
Set value to a cell with integer, float or string
:param row:
:param col:
:param value:
:return:
"""
# Check
if row < 0 or row >= self.rowCount() or col < 0 or col >= self.columnCount():
raise IndexError('Input row number or column number is out of range.')
# Init cell
cell_item = QTableWidgetItem()
cell_item.setText(_fromUtf8(str(value)))
cell_item.setFlags(cell_item.flags() & ~QtCore.Qt.ItemIsEditable)
self.setItem(row, col, cell_item)
return
def __init__(self, val=u'', style=None): QTableWidgetItem.__init__(self, safe_decode(val)) self._style = style self.update_style()
def add_row(self, row=-1, check_new_row=False):
self.ui.tableWidget.insertRow(row)
list_of_widgets_to_unlock = []
# group name
_column = 0
_group_name = self.define_unique_group_name(row)
_item = QTableWidgetItem(_group_name)
_item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
self.ui.tableWidget.setItem(row, _column, _item)
# group to group rule
list_options = ["and", "or"]
_column += 1
if row > 0:
_widget = QComboBox()
_widget.addItems(list_options)
self.ui.tableWidget.setCellWidget(row, _column, _widget)
_widget.blockSignals(True)
list_of_widgets_to_unlock.append(_widget)
_widget.currentIndexChanged.connect(lambda value=list_options[0]:
self.combobox_changed(value))
else:
_item = QTableWidgetItem("N/A")
_item.setFlags(QtCore.Qt.ItemIsEnabled)
self.ui.tableWidget.setItem(row, _column, _item)
# rule columns
_column += 1
for _offset in np.arange(len(self.list_of_rule_names)):
_row_layout = QHBoxLayout()
_widget = QCheckBox()
_widget.blockSignals(True)
if check_new_row and _offset == row:
_widget.setCheckState(QtCore.Qt.Checked)
list_of_widgets_to_unlock.append(_widget)
_widget.stateChanged.connect(lambda value=0:
self.checkbox_changed(value))
_spacer1 = QSpacerItem(40,20, QSizePolicy.Expanding, QSizePolicy.Minimum)
_row_layout.addItem(_spacer1)
_row_layout.addWidget(_widget)
_spacer2 = QSpacerItem(40,20, QSizePolicy.Expanding, QSizePolicy.Minimum)
_row_layout.addItem(_spacer2)
_rule_widget = QWidget()
_rule_widget.setLayout(_row_layout)
self.ui.tableWidget.setCellWidget(row, _column+_offset, _rule_widget)
# inner group rule
_column += len(self.list_of_rule_names)
_widget = QComboBox()
_widget.blockSignals(True)
list_of_widgets_to_unlock.append(_widget)
_widget.setEnabled(False)
_widget.currentIndexChanged.connect(lambda value=list_options[0]:
self.combobox_changed(value))
list_options = ["and", "or"]
_widget.addItems(list_options)
self.ui.tableWidget.setCellWidget(row, _column, _widget)
self.unlock_signals_ui(list_of_widgets_to_unlock)
def add_row(self, row=-1):
"""this add a default row to the table that takes care
of the rules"""
_random_key = generate_random_key()
_list_ui_for_this_row = {}
_list_ui_to_unlock = []
self.table_ui.insertRow(row)
self.table_ui.setRowHeight(row, self.row_height)
# key
_item = QTableWidgetItem("{}".format(_random_key))
self.table_ui.setItem(row, 0, _item)
# rule #
_rule_name = self.define_unique_rule_name(row)
_item = QTableWidgetItem("{}".format(_rule_name))
_item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
self.table_ui.setItem(row, 1, _item)
# search argument
_widget = QComboBox()
_list_ui_for_this_row['list_items'] = _widget
list_items = LIST_SEARCH_CRITERIA[self.parent.parent.instrument['short_name'].lower()]
_widget.addItems(list_items)
self.table_ui.setCellWidget(row, 2, _widget)
_widget.blockSignals(True)
_list_ui_to_unlock.append(_widget)
_widget.currentIndexChanged.connect(lambda value=list_items[0],
key = _random_key:
self.parent.list_item_changed(value, key))
# criteria
list_criteria = ['is', 'contains']
_widget = QComboBox()
_list_ui_for_this_row['list_criteria'] = _widget
_widget.addItems(list_criteria)
self.table_ui.setCellWidget(row, 3, _widget)
_widget.blockSignals(True)
_list_ui_to_unlock.append(_widget)
_widget.currentIndexChanged.connect(lambda value=list_criteria[0],
key = _random_key:
self.parent.list_criteria_changed(value, key))
# argument
_widget = QComboBox()
_widget.setEditable(True)
_list_ui_for_this_row['list_items_value'] = _widget
list_values = list(self.parent.metadata['Chemical Formula'])
_widget.addItems(list_values)
self.table_ui.setCellWidget(row, 4, _widget)
_widget.blockSignals(True)
_list_ui_to_unlock.append(_widget)
_widget.editTextChanged.connect(lambda value=list_values[0],
key = _random_key:
self.parent.list_argument_changed(value, key))
_widget.currentIndexChanged.connect(lambda value=list_values[0],
key = _random_key:
self.parent.list_argument_index_changed(value, key))
if row == 0:
self.table_ui.horizontalHeader().setVisible(True)
unlock_signals_ui(list_ui=_list_ui_to_unlock)
self.parent.list_ui[_random_key] = _list_ui_for_this_row
self.parent.check_all_filter_widgets()
