def setupUi(self):
self.resize(480, 340)
self.vbox = QVBoxLayout(self)
self.presetLabel = QLabel(self)
self.table = QTableWidget(0, 4, self)
self.setAsDefaultCheckbox = QCheckBox("Set as default preset", self)
self.vbox.addWidget(self.presetLabel)
self.vbox.addWidget(self.table)
self.vbox.addWidget(self.setAsDefaultCheckbox)
self.table.setEditTriggers(QTableWidget.NoEditTriggers)
self.table.setSelectionBehavior(QTableWidget.SelectRows)
self.table.setHorizontalHeaderLabels(
["Show", "Level name", "Preview", "Preview (dark)"])
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.table.horizontalHeader().setSectionsClickable(False)
self.table.horizontalHeader().setSectionsMovable(False)
self.table.horizontalHeader().setSectionResizeMode(
0, QHeaderView.ResizeToContents)
self.table.verticalHeader().setVisible(False)
self.table.doubleClicked.connect(self.open_level_edit_dialog)
self.table.setContextMenuPolicy(Qt.CustomContextMenu)
self.table.customContextMenuRequested.connect(self.open_menu)
buttons = QDialogButtonBox.Reset | QDialogButtonBox.Save | QDialogButtonBox.Cancel
self.buttonBox = QDialogButtonBox(buttons, self)
self.vbox.addWidget(self.buttonBox)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.resetButton = self.buttonBox.button(QDialogButtonBox.Reset)
self.resetButton.clicked.connect(self.reset)
def createBottomLeftTabWidget(self):
self.bottomLeftTabWidget = QTabWidget()
self.bottomLeftTabWidget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Ignored)
tab1 = QWidget()
tableWidget = QTableWidget(10, 10)
tab1hbox = QHBoxLayout()
tab1hbox.setContentsMargins(5, 5, 5, 5)
tab1hbox.addWidget(tableWidget)
tab1.setLayout(tab1hbox)
tab2 = QWidget()
textEdit = QTextEdit()
textEdit.setPlainText("Twinkle, twinkle, little star,\n"
"How I wonder what you are.\n"
"Up above the world so high,\n"
"Like a diamond in the sky.\n"
"Twinkle, twinkle, little star,\n"
"How I wonder what you are!\n")
tab2hbox = QHBoxLayout()
tab2hbox.setContentsMargins(5, 5, 5, 5)
tab2hbox.addWidget(textEdit)
tab2.setLayout(tab2hbox)
self.bottomLeftTabWidget.addTab(tab1, "&Table")
self.bottomLeftTabWidget.addTab(tab2, "Text &Edit")
def PropertyDistribtionTable(dict_prop):
"""
-i- dict_prop : dictionary, properties.
-o- table : QTableWidget, for use in PyQt GUI.
Return a table widget of properties data value distribution.
"""
props = [prop for prop in dict_prop]
nrow = len(props)
columnNames = ['Name', 'Min', 'P10', 'P50', 'P90', 'Max']
ncol = len(columnNames)
table = QTableWidget()
table.setRowCount(nrow)
table.setColumnCount(ncol)
table.setHorizontalHeaderLabels(columnNames)
key = 'arrayPercentiles'
for i in range(nrow):
prop = props[i]
if not key in dict_prop[prop]:
add_array_percentile(dict_prop[prop])
p0, p10, p50, p90, p100 = dict_prop[prop][key]
state = [prop, p0, p10, p50, p90, p100]
state = [str(a) for a in state] # convert to string
for j in range(ncol):
table.setItem(i, j, QTableWidgetItem(state[j]))
table.sortItems(0, Qt.AscendingOrder)
return table
def __init__(self, *args, emptyDateValid=True, **kwargs):
super().__init__(*args, **kwargs)
self.headerLabels = ['Date', 'Time', 'Distance (km)', 'Calories', 'Gear']
self.headerLabelColumnOffset = 0
self.table = QTableWidget(0, len(self.headerLabels))
self.table.setHorizontalHeaderLabels(self.headerLabels)
self.table.verticalHeader().setVisible(False)
# dict of methods to validate and cast types for input data in each column
isDatePartial = partial(isDate, allowEmpty=emptyDateValid)
validateMethods = [isDatePartial, isDuration, isFloat,
isFloat, isInt]
parseDatePartial = partial(parseDate, pd_timestamp=True)
castMethods = [parseDatePartial, parseDuration, float, float, int]
self.mthds = {name:{'validate':validateMethods[i], 'cast':castMethods[i]}
for i, name in enumerate(self.headerLabels)}
self.validateTimer = QTimer()
self.validateTimer.setInterval(100)
self.validateTimer.setSingleShot(True)
self.validateTimer.timeout.connect(self._validate)
self.table.cellChanged.connect(self.validateTimer.start)
self.invalid.connect(self._invalid)
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 __init__(self,
layout_dir='v',
title='',
rules: List[Dict[str, Union[bool, int, float, str]]] = None):
super().__init__(layout_dir)
self.table_h_headers = []
self.table_keys = []
self.initial_values = []
for rule in rules:
self.table_h_headers.append(rule['text'])
self.table_keys.append(rule['name'])
self.initial_values.append(rule['init'])
self.regulations_table = QTableWidget(0, len(self.table_h_headers))
self.regulations_table.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.regulations_table.setHorizontalHeaderLabels(self.table_h_headers)
self.layout().addWidget(self.regulations_table)
self.set_layout = QHBoxLayout()
self.layout().addLayout(self.set_layout)
self.button_add = QPushButton('Add')
self.button_remove = QPushButton('Remove')
self.set_layout.addWidget(self.button_add)
self.set_layout.addWidget(self.button_remove)
self.button_add.clicked.connect(self.add_regulation)
self.button_remove.clicked.connect(self.remove_regulation)
def __init__(self, settings: StackSettings, parent=None):
super().__init__(parent)
self.settings = settings
self.calculate_btn = QPushButton("Calculate")
self.calculate_btn.clicked.connect(self.calculate)
self.result_view = QTableWidget()
self.channel_select = ChannelComboBox()
self.units_select = EnumComboBox(Units)
self.units_select.set_value(self.settings.get("simple_measurements.units", Units.nm))
self.units_select.currentIndexChanged.connect(self.change_units)
layout = QHBoxLayout()
self.measurement_layout = QVBoxLayout()
l1 = QHBoxLayout()
l1.addWidget(QLabel("Units"))
l1.addWidget(self.units_select)
self.measurement_layout.addLayout(l1)
l2 = QHBoxLayout()
l2.addWidget(QLabel("Channel"))
l2.addWidget(self.channel_select)
self.measurement_layout.addLayout(l2)
layout.addLayout(self.measurement_layout)
result_layout = QVBoxLayout()
result_layout.addWidget(self.result_view)
result_layout.addWidget(self.calculate_btn)
layout.addLayout(result_layout)
self.setLayout(layout)
self.setWindowTitle("Measurement")
if self.window() == self:
try:
geometry = self.settings.get_from_profile("simple_measurement_window_geometry")
self.restoreGeometry(QByteArray.fromHex(bytes(geometry, "ascii")))
except KeyError:
pass
def _create_table(self) -> QTableWidget:
"""Create and configure a new table widget."""
table = QTableWidget()
table.verticalHeader().setVisible(False)
table.horizontalHeader().setVisible(False)
table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
table.resizeRowsToContents()
table.setShowGrid(False)
return table
def __init__(self, parent=None):
super().__init__(parent=parent)
self._table = QTableWidget()
self._table.setShowGrid(False)
self._populate_table()
layout = QVBoxLayout()
layout.addWidget(self._table)
self.setLayout(layout)
def add_table(self):
"""Add table with info about files to be recovered."""
table = QTableWidget(len(self.data), 3, self)
self.table = table
labels = [_('Original file'), _('Autosave file'), _('Actions')]
table.setHorizontalHeaderLabels(labels)
table.verticalHeader().hide()
table.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
table.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
table.setSelectionMode(QTableWidget.NoSelection)
# Show horizontal grid lines
table.setShowGrid(False)
table.setStyleSheet('::item { border-bottom: 1px solid gray }')
for idx, (original, autosave) in enumerate(self.data):
self.add_label_to_table(idx, 0, file_data_to_str(original))
self.add_label_to_table(idx, 1, file_data_to_str(autosave))
widget = QWidget()
layout = QHBoxLayout()
tooltip = _('Recover the autosave file to its original location, '
'replacing the original if it exists.')
button = QPushButton(_('Restore'))
button.setToolTip(tooltip)
button.clicked.connect(
lambda checked, my_idx=idx: self.restore(my_idx))
layout.addWidget(button)
tooltip = _('Delete the autosave file.')
button = QPushButton(_('Discard'))
button.setToolTip(tooltip)
button.clicked.connect(
lambda checked, my_idx=idx: self.discard(my_idx))
layout.addWidget(button)
tooltip = _('Display the autosave file (and the original, if it '
'exists) in Spyder\'s Editor. You will have to move '
'or delete it manually.')
button = QPushButton(_('Open'))
button.setToolTip(tooltip)
button.clicked.connect(
lambda checked, my_idx=idx: self.open_files(my_idx))
layout.addWidget(button)
widget.setLayout(layout)
self.table.setCellWidget(idx, 2, widget)
table.resizeRowsToContents()
table.resizeColumnsToContents()
self.layout.addWidget(table)
def create_page_game(self):
widget = QTableWidget()
widget.setEditTriggers(QAbstractItemView.NoEditTriggers)
widget.setSortingEnabled(True)
widget.setRowCount(1000)
widget.setColumnCount(len(GAME_LIST))
widget.setHorizontalHeaderLabels(GAME_LIST)
header = widget.horizontalHeader()
for i in range(len(GAME_LIST)):
header.setSectionResizeMode(i, QHeaderView.ResizeToContents)
return widget
def __init__(self, napari_viewer):
super().__init__()
self.viewer = napari_viewer
self.layer_name = ''
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.tableWidget = QTableWidget()
self.tableWidget.setEditTriggers(QAbstractItemView.NoEditTriggers)
layout.addWidget(self.tableWidget)
self.setLayout(layout)
def __init__(self, parent=None):
self._parent = parent
super().__init__(parent)
self.setTitle("Define d₀")
layout = QVBoxLayout()
self.d0_grid_switch = QComboBox()
self.d0_grid_switch.addItems(["Constant", "Field"])
self.d0_grid_switch.currentTextChanged.connect(self.set_case)
layout.addWidget(self.d0_grid_switch)
self.d0_box = QWidget()
d0_box_layout = QHBoxLayout()
d0_box_layout.addWidget(QLabel("d₀"))
validator = QDoubleValidator()
validator.setBottom(0)
self.d0 = QLineEdit()
self.d0.setValidator(validator)
self.d0.editingFinished.connect(self.update_d0)
d0_box_layout.addWidget(self.d0)
d0_box_layout.addWidget(QLabel("Δd₀"))
self.d0e = QLineEdit()
self.d0e.setValidator(validator)
self.d0e.editingFinished.connect(self.update_d0)
d0_box_layout.addWidget(self.d0e)
self.d0_box.setLayout(d0_box_layout)
layout.addWidget(self.d0_box)
load_save = QWidget()
load_save_layout = QHBoxLayout()
self.load_grid = QPushButton("Load d₀ Grid")
self.load_grid.clicked.connect(self.load_d0_field)
load_save_layout.addWidget(self.load_grid)
self.save_grid = QPushButton("Save d₀ Grid")
self.save_grid.clicked.connect(self.save_d0_field)
load_save_layout.addWidget(self.save_grid)
load_save.setLayout(load_save_layout)
layout.addWidget(load_save)
self.d0_grid = QTableWidget()
self.d0_grid.setColumnCount(5)
self.d0_grid.setColumnWidth(0, 60)
self.d0_grid.setColumnWidth(1, 60)
self.d0_grid.setColumnWidth(2, 60)
self.d0_grid.setColumnWidth(3, 60)
self.d0_grid.verticalHeader().setVisible(False)
self.d0_grid.horizontalHeader().setStretchLastSection(True)
self.d0_grid.setHorizontalHeaderLabels(['vx', 'vy', 'vz', "d₀", "Δd₀"])
spinBoxDelegate = SpinBoxDelegate()
self.d0_grid.setItemDelegateForColumn(3, spinBoxDelegate)
self.d0_grid.setItemDelegateForColumn(4, spinBoxDelegate)
layout.addWidget(self.d0_grid)
self.setLayout(layout)
self.set_case('Constant')
def create_page_rank(self):
widget = QTableWidget()
widget.setEditTriggers(QAbstractItemView.NoEditTriggers)
widget.setSortingEnabled(True)
widget.setRowCount(20)
widget.setColumnCount(len(RANK_LIST))
widget.setHorizontalHeaderLabels(RANK_LIST)
header = widget.horizontalHeader()
for i in range(len(RANK_LIST)):
header.setSectionResizeMode(i, QHeaderView.ResizeToContents)
widget.horizontalHeader().sortIndicatorChanged.connect(
self.update_chart)
return widget
def __init__(self, data, win_parent=None):
"""
+--------+
| Camera |
+--------+---------------+
| Camera Name |
| +-------------------+ |
| | | |
| | | |
| | | |
| | | |
| | | |
| +-------------------+ |
| |
| Name xxx Save |
| Delete Set |
| |
| Apply OK Cancel |
+--------+---------------+
"""
PyDialog.__init__(self, data, win_parent)
self.setWindowTitle('Camera Views')
#self.setWindowIcon(view_icon)
self._default_name = 'Camera'
self.out_data['clicked_ok'] = False
self.cameras = deepcopy(data['cameras'])
self.names = sorted(self.cameras.keys())
self.name = QLabel("Name:")
self.name_edit = QLineEdit(str(self._default_name))
self.delete_button = QPushButton("Delete")
self.set_button = QPushButton("Set")
self.save_button = QPushButton("Save")
# closing
self.apply_button = QPushButton("Apply")
#self.ok_button = QPushButton("OK")
self.close_button = QPushButton("Close")
self.cancel_button = QPushButton("Cancel")
self.table = QTableWidget()
names_text = []
for name in self.names:
name_text = QTableWidgetItem(str(name))
names_text.append(name_text)
self.create_layout(names_text)
self.set_connections()
def setup_ui(self):
self.setLayout(QVBoxLayout())
bpm_table = QTableWidget(self)
col_labels = ["X Pos (mm)", "Y Pos (mm)"]
bpm_table.setColumnCount(len(col_labels))
bpm_table.setHorizontalHeaderLabels(col_labels)
data = dev_list(self.start_marker, self.end_marker)
bpm_names = [bpm['device'] for bpm in data]
bpm_table.setRowCount(len(bpm_names))
bpm_table.setVerticalHeaderLabels(bpm_names)
for row, bpm_name in enumerate(bpm_names):
for col, axis in enumerate(("X", "Y")):
pos = PyDMLabel()
pos.channel = "ca://{}:{}".format(bpm_name, axis)
pos.showUnits = True
bpm_table.setCellWidget(row, col, pos)
self.layout().addWidget(bpm_table)
def _setup_table(self):
self._value_keys = ("value", "min", "max")
# Labels for horizontal header
labels_presets = [
fitting_preset_names[_] for _ in self._fit_strategy_list
]
labels_values = [value_names[_] for _ in self._value_keys]
self.tbl_labels = ["Name", "E, keV"] + labels_values + labels_presets
# Labels for editable columns
self.tbl_cols_editable = ("Value", "Min", "Max")
# Labels for the columns that contain combo boxes
self.tbl_cols_combobox = labels_presets
# The list of columns with fixed size
self.tbl_cols_stretch = ("Value", "Min", "Max")
# Table item representation if different from default
self.tbl_format = {
"E, keV": ".4f",
"Value": ".8g",
"Min": ".8g",
"Max": ".8g"
}
# Combobox items. All comboboxes in the table contain identical list of items.
self.combo_items = self._bound_options
self._combo_list = []
self.table = QTableWidget()
self.table.setColumnCount(len(self.tbl_labels))
self.table.verticalHeader().hide()
self.table.setHorizontalHeaderLabels(self.tbl_labels)
self.table.setStyleSheet("QTableWidget::item{color: black;}")
header = self.table.horizontalHeader()
for n, lbl in enumerate(self.tbl_labels):
# Set stretching for the columns
if lbl in self.tbl_cols_stretch:
header.setSectionResizeMode(n, QHeaderView.Stretch)
else:
header.setSectionResizeMode(n, QHeaderView.ResizeToContents)
self.table.itemChanged.connect(self.tbl_elines_item_changed)
def initUI(self):
self.w.setWindowTitle(u'回答結果')
vbox = QVBoxLayout()
ansBtn = QPushButton(u"閉じる")
ansBtn.clicked.connect(self.closeWindow)
self.tabs = QTabWidget()
for i in range(self.numTab):
tab = QTableWidget()
tab.setRowCount(9) # あとで9のところは変更してください。
tab.setColumnCount(2)
self.tabs.addTab(tab, "第" + str(i + 1) + "候補")
self.tables.append(tab)
vbox.addWidget(self.tabs)
vbox.addWidget(ansBtn)
self.w.setLayout(vbox)
def _setup_elines_table(self):
"""The table has only functionality necessary to demonstrate how it is going
to look. A lot more code is needed to actually make it run."""
self._validator_peak_height = QDoubleValidator()
self._validator_peak_height.setBottom(0.01)
self.tbl_elines = QTableWidget()
self.tbl_elines.setStyleSheet(
"QTableWidget::item{color: black;}"
"QTableWidget::item:selected{background-color: red;}"
"QTableWidget::item:selected{color: white;}")
self.tbl_labels = [
"", "Z", "Line", "E, keV", "Peak Int.", "Rel. Int.(%)", "CS"
]
self.tbl_cols_editable = ["Peak Int."]
self.tbl_value_min = {"Rel. Int.(%)": 0.1}
tbl_cols_resize_to_content = ["", "Z", "Line"]
self.tbl_elines.setColumnCount(len(self.tbl_labels))
self.tbl_elines.verticalHeader().hide()
self.tbl_elines.setHorizontalHeaderLabels(self.tbl_labels)
self.tbl_elines.setSelectionBehavior(QTableWidget.SelectRows)
self.tbl_elines.setSelectionMode(QTableWidget.SingleSelection)
self.tbl_elines.itemSelectionChanged.connect(
self.tbl_elines_item_selection_changed)
self.tbl_elines.itemChanged.connect(self.tbl_elines_item_changed)
header = self.tbl_elines.horizontalHeader()
for n, lbl in enumerate(self.tbl_labels):
# Set stretching for the columns
if lbl in tbl_cols_resize_to_content:
header.setSectionResizeMode(n, QHeaderView.ResizeToContents)
else:
header.setSectionResizeMode(n, QHeaderView.Stretch)
# Set alignment for the columns headers (HEADERS only)
if n == 0:
header.setDefaultAlignment(Qt.AlignCenter)
else:
header.setDefaultAlignment(Qt.AlignRight)
self.cb_sel_list = [] # List of checkboxes
def __init__(self, *args, **kwargs):
super(Devices, self).__init__(*args, **kwargs)
self.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.contentLayout = QGridLayout()
self.devices = []
# Current Action Status
self.status = {}
self.devicePrefixFilterLabel = QLabel(
"Device filter (Ion Pump not the channel!)")
self.devicePrefixFilterInp = QLineEdit()
self.devicePrefixFilterInp.setMaximumWidth(100)
self.updateDeviceListButton = QPushButton("Apply Filter")
self.updateDeviceListButton.clicked.connect(self.updateDeviceList)
self.updateDeviceListButton.setToolTip(
"Filter the device prefix list.")
self.contentLayout.addWidget(self.devicePrefixFilterLabel, 0, 0, 1, 2)
self.contentLayout.addWidget(self.devicePrefixFilterInp, 1, 0, 1, 1)
self.contentLayout.addWidget(self.updateDeviceListButton, 1, 1, 1, 1)
self.deviceList = QListWidget()
self.contentLayout.addWidget(self.deviceList, 2, 0, 2, 2)
self.deviceStatus = QTableWidget()
self.deviceStatus.setColumnCount(2)
self.deviceStatus.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.deviceStatus.setHorizontalHeaderLabels(["Device", "Status"])
self.deviceStatusLabel = QLabel("Status")
self.contentLayout.addWidget(self.deviceStatusLabel, 0, 2, 1, 2)
self.contentLayout.addWidget(self.deviceStatus, 1, 2, 4, 2)
self.contentLayout.setRowStretch(2, 2)
self.setLayout(self.contentLayout)
self.deviceList.itemChanged.connect(self.highlightChecked)
self.reloadData()
def _setup_ui(self):
"""Setup the widgets on the screen
"""
# table
nrows, ncols = 0, 2
self._table = QTableWidget(nrows, ncols, self)
self._table.setHorizontalHeaderLabels(
[self.NAME_COLUMN_TITLE, self.CHECKED_COLUMN_TITLE])
# buttons
self._button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self._button_box.accepted.connect(self.accept)
self._button_box.rejected.connect(self.reject)
layout = QVBoxLayout()
layout.addWidget(self._table)
layout.addWidget(self._button_box)
self.setLayout(layout)
def _make_table_widget(self):
"""
Make a table showing the matplotlib figure number of the
plots, the name with close and edit buttons, and a hidden
column for sorting with the last actuve order
:return: A QTableWidget object which will contain plot widgets
"""
table_widget = QTableWidget(0, 3, self)
table_widget.setHorizontalHeaderLabels(
['No.', 'Plot Name', 'Last Active Order (hidden)'])
table_widget.verticalHeader().setVisible(False)
# Fix the size of 'No.' and let 'Plot Name' fill the space
top_header = table_widget.horizontalHeader()
table_widget.horizontalHeaderItem(Column.Number).setToolTip(
'This is the matplotlib figure number.\n\nFrom a '
'script use plt.figure(N), where N is this figure '
'number, to get a handle to the plot.')
table_widget.horizontalHeaderItem(Column.Name).setToolTip(
'The plot name, also used as the file name when '
'saving multiple plots.')
table_widget.setSelectionBehavior(QAbstractItemView.SelectRows)
table_widget.setSelectionMode(QAbstractItemView.ExtendedSelection)
table_widget.setEditTriggers(QAbstractItemView.NoEditTriggers)
table_widget.sortItems(Column.Number, Qt.AscendingOrder)
table_widget.setSortingEnabled(True)
table_widget.horizontalHeader().sectionClicked.connect(
self.update_sort_menu_selection)
if not DEBUG_MODE:
table_widget.setColumnHidden(Column.LastActive, True)
top_header.resizeSection(Column.Number,
top_header.sectionSizeHint(Column.Number))
top_header.setSectionResizeMode(Column.Name, QHeaderView.Stretch)
return table_widget
def __init__(self,
layout_dir: str,
title: List[str],
initial_value: List[List[Union[int, float, str]]],
size_restricted=False,
header_adaption_h=False,
header_adaption_v=False,
background_color: List[List[Union[str]]] = None,
foreground_color: List[List[Union[str]]] = None):
super().__init__(layout_dir=layout_dir)
self.maximum_rows = 100
self.size_restricted = size_restricted
self.header_adaption_h = header_adaption_h
self.header_adaption_v = header_adaption_v
self.background_color = background_color if background_color is not None else ''
self.foreground_color = foreground_color if foreground_color is not None else ''
self.char_width = 15
self.on_check_callback = None
self.title_list = title
entryLayout = QHBoxLayout()
entryLayout.setContentsMargins(0, 0, 0, 0)
self.ctrl = QTableWidget()
self.ctrl.verticalHeader().setVisible(False)
self.set_params(size_restricted, header_adaption_h, header_adaption_v)
self.ctrl.setColumnCount(len(title))
self.ctrl.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
for i, text in enumerate(title):
self.ctrl.setColumnWidth(i, len(text) * self.char_width + 10)
self.ctrl.setHorizontalHeaderItem(i, QTableWidgetItem(text))
self.central_layout.addLayout(entryLayout)
entryLayout.addWidget(self.ctrl)
if initial_value is not None:
for sublist in initial_value:
assert len(sublist) == len(title), \
'title is not as long as sublist,%s,%s' % (repr(title), sublist)
self.ctrl.setRowCount(len(initial_value))
self.set_value(initial_value)
def create_widgets(self):
# main/delete/supergroup
self.set_as_main_button = QPushButton("Set As Main")
self.create_super_group_button = QPushButton("Create Super Group")
self.delete_groups_button = QPushButton("Delete Groups")
self.revert_groups_button = QPushButton("Revert Groups")
self.show_groups_button = QPushButton("Show Groups")
self.hide_groups_button = QPushButton("Hide Groups")
# closing
self.apply_button = QPushButton("Apply")
self.ok_button = QPushButton("OK")
self.cancel_button = QPushButton("Cancel")
#table
self.table = QTableWidget()
self.checks = []
self.names_text = []
bold = QtGui.QFont()
bold.setBold(True)
bold.setItalic(True)
bold.setWeight(75)
anames = array(self.names)
for iname, name in enumerate(anames[self.inames]):
check = QTableWidgetItem()
check.setCheckState(False)
# TODO: create right click menu ???
name_text = QTableWidgetItem(str(name))
if iname == self.imain:
name_text.setFont(bold)
self.shown_set.add(iname)
check.setCheckState(2)
name_text.setBackground(QtGui.QColor(*self.light_grey))
elif iname in self.shown_set:
name_text.setBackground(QtGui.QColor(*self.light_grey))
self.checks.append(check)
self.names_text.append(name_text)
def run_test():
# Third party imports
from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow
# Local imports
from spyder.utils.qthelpers import qapplication
app = qapplication()
main = QMainWindow()
widget = PluginMainWidget('test', main)
widget.get_title = lambda x=None: 'Test title'
widget._setup()
layout = QHBoxLayout()
layout.addWidget(QTableWidget())
widget.setLayout(layout)
widget.start_spinner()
dock, location = widget.create_dockwidget(main)
main.addDockWidget(location, dock)
main.setStyleSheet(str(APP_STYLESHEET))
main.show()
app.exec_()
def __init__(self, parent=None, npe2_readers=None, npe1_readers=None):
super().__init__(parent=parent)
npe2, npe1 = get_all_readers()
if npe2_readers is None:
npe2_readers = npe2
if npe1_readers is None:
npe1_readers = npe1
self._npe2_readers = npe2_readers
self._npe1_readers = npe1_readers
self._table = QTableWidget()
self._table.setShowGrid(False)
self._set_up_table()
self._edit_row = self._make_new_preference_row()
self._populate_table()
instructions = QLabel(
trans.
_('Enter a filename pattern to associate with a reader e.g. "*.tif" for all TIFF files.'
) + trans.
_('Available readers will be filtered to those compatible with your pattern. Hover over a reader to see what patterns it accepts.'
) + trans.
_('\n\nPreference saving for folder readers is not supported, so these readers are not shown.'
) + trans.
_('\n\nFor documentation on valid filename patterns, see https://docs.python.org/3/library/fnmatch.html'
))
instructions.setWordWrap(True)
instructions.setOpenExternalLinks(True)
layout = QVBoxLayout()
instructions.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Expanding)
layout.addWidget(instructions)
layout.addWidget(self._edit_row)
layout.addWidget(self._table)
self.setLayout(layout)
def _setup_tab_widget(self):
self.tab_widget = QTabWidget()
self.loaded_standards = QWidget()
# self.display_loaded_standards()
self.scroll = QScrollArea()
self.scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.scroll.setWidget(self.loaded_standards)
self.tab_widget.addTab(self.scroll, "Loaded Standards")
self.combo_set_table_header = QComboBox()
self.combo_set_table_header.addItems(
["Standard Serial #", "Standard Name"])
self.combo_set_table_header.currentIndexChanged.connect(
self.combo_set_table_header_index_changed)
vbox = QVBoxLayout()
vbox.addSpacing(5)
hbox = QHBoxLayout()
hbox.addWidget(QLabel("Display in table header:"))
hbox.addWidget(self.combo_set_table_header)
hbox.addStretch(1)
vbox.addLayout(hbox)
self.table = QTableWidget()
self.table.verticalHeader().hide()
self.table.setSelectionMode(QTableWidget.NoSelection)
self.table.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.table.horizontalHeader().setMinimumSectionSize(150)
vbox.addWidget(self.table)
self.table.setStyleSheet("QTableWidget::item{color: black;}")
frame = QFrame()
vbox.setContentsMargins(0, 0, 0, 0)
frame.setLayout(vbox)
self.tab_widget.addTab(frame, "Selected Emission Lines")
def _setup_table(self):
# Labels for horizontal header
self.tbl_labels = ["Line", "E, keV", "ROI, keV", "Show", "Reset"]
# The list of columns that stretch with the table
self.tbl_cols_stretch = ("E, keV", "ROI, keV")
# Table item representation if different from default
self.tbl_format = {"E, keV": ".3f"}
# Editable items (highlighted with lighter background)
self.tbl_cols_editable = {"ROI, keV"}
# Columns that contain Range Manager
self.tbl_cols_range_manager = ("ROI, keV", )
self.table = QTableWidget()
self.table.setColumnCount(len(self.tbl_labels))
self.table.setHorizontalHeaderLabels(self.tbl_labels)
self.table.verticalHeader().hide()
self.table.setSelectionMode(QTableWidget.NoSelection)
self.table.setStyleSheet("QTableWidget::item{color: black;}")
header = self.table.horizontalHeader()
for n, lbl in enumerate(self.tbl_labels):
# Set stretching for the columns
if lbl in self.tbl_cols_stretch:
header.setSectionResizeMode(n, QHeaderView.Stretch)
else:
header.setSectionResizeMode(n, QHeaderView.ResizeToContents)
self._table_contents = []
self.cb_list = []
self.range_manager_list = []
self.pb_default_list = []
self.fill_table(self._table_contents)
def __init__(self, parent, onset, duration, description):
super().__init__(parent)
self.setWindowTitle("Edit Annotations")
self.table = QTableWidget(len(onset), 3)
for row, annotation in enumerate(zip(onset, duration, description)):
self.table.setItem(row, 0, IntTableWidgetItem(annotation[0]))
self.table.setItem(row, 1, IntTableWidgetItem(annotation[1]))
self.table.setItem(row, 2, QTableWidgetItem(annotation[2]))
self.table.setHorizontalHeaderLabels(["Onset", "Duration", "Type"])
self.table.horizontalHeader().setStretchLastSection(True)
self.table.verticalHeader().setVisible(False)
self.table.setShowGrid(False)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setSortingEnabled(True)
self.table.sortByColumn(0, Qt.AscendingOrder)
vbox = QVBoxLayout(self)
vbox.addWidget(self.table)
hbox = QHBoxLayout()
self.add_button = QPushButton("+")
self.remove_button = QPushButton("-")
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
hbox.addWidget(self.add_button)
hbox.addWidget(self.remove_button)
hbox.addStretch()
hbox.addWidget(buttonbox)
vbox.addLayout(hbox)
buttonbox.accepted.connect(self.accept)
buttonbox.rejected.connect(self.reject)
self.table.itemSelectionChanged.connect(self.toggle_buttons)
self.remove_button.clicked.connect(self.remove_event)
self.add_button.clicked.connect(self.add_event)
self.toggle_buttons()
self.resize(500, 500)
def _setup_table_widget(self):
"""
Make a table showing
:return: A QTableWidget object which will contain plot widgets
"""
table_widget = QTableWidget(3, 7, self)
table_widget.setVerticalHeaderLabels(['u1', 'u2', 'u3'])
col_headers = [
'a*', 'b*', 'c*'
] if self.frame == SpecialCoordinateSystem.HKL else ['Qx', 'Qy', 'Qz']
col_headers.extend(['start', 'stop', 'nbins', 'step'])
table_widget.setHorizontalHeaderLabels(col_headers)
table_widget.setFixedHeight(
table_widget.verticalHeader().defaultSectionSize() *
(table_widget.rowCount() + 1)) # +1 to include headers
for icol in range(table_widget.columnCount()):
table_widget.setColumnWidth(icol, 50)
table_widget.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
table_widget.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.table = table_widget
self.layout.addWidget(self.table)
