def on_customContextMenuRequestedWindow(self, pos):
# gets the position of the right click for the windowing table
it = self.table_view.itemAt(pos)
if it is None:
return
c = it.row()
item_range = QtWidgets.QTableWidgetSelectionRange(
c, 0, c,
self.table_view.columnCount() - 1)
# selects the row
self.table_view.setRangeSelected(item_range, True)
# creates the menu
menu = QtWidgets.QMenu()
modify_row_action = menu.addAction("Modify")
menu.addSeparator()
delete_row_action = menu.addAction("Delete")
action = menu.exec(self.table_view.viewport().mapToGlobal(pos))
if action == delete_row_action:
self.table_view.removeRow(c)
if action == modify_row_action:
# open an input dialog as a pop up with the current values to be modified
dialog = Dialog_Windowing(
self.table_view.item(c, 0).text(),
self.table_view.item(c, 1).text(),
self.table_view.item(c, 2).text(),
self.table_view.item(c, 3).text(),
)
# If Okay is pressed then display the new entries in the table
# They will only be saved if Apply is pressed before exiting Add-On Options
if dialog.exec():
new_data = dialog.getInputs()
self.table_view.setItem(c, 0, QTableWidgetItem(new_data[0]))
self.table_view.setItem(c, 1, QTableWidgetItem(new_data[1]))
self.table_view.setItem(c, 2, QTableWidgetItem(new_data[2]))
self.table_view.setItem(c, 3, QTableWidgetItem(new_data[3]))
def callBack(self, keys):
# do nothing if keys is empty
if not (keys):
return
# check that if shortcut used before.
if keys in self.shortcuts_list:
self.msgBox = QMessageBox()
self.msgBox.setText(
QCoreApplication.translate(
"setting_src_ui_tr",
"<b><center>This shortcut has been used before!\
Use another one!</center></b>"))
self.msgBox.setIcon(QMessageBox.Warning)
reply = self.msgBox.exec_()
# set new shortcut
else:
selected_row = self.shortcut_table.selectionModel().selectedRows(
)[0].row()
item = QTableWidgetItem(keys)
# align center
item.setTextAlignment(0x0004 | 0x0080)
# insert item in shortcut_table
self.shortcut_table.setItem(selected_row, 1, item)
# set keys in shortcuts_list
self.shortcuts_list[selected_row] = keys
def __init__(self) -> None:
super().__init__()
self.resize(500, 300)
# 非组件对象
self.values = {}
self.ut = UpdateValues()
# 界面组件对象
self.centralwidget = QWidget(self)
self.table = QTableWidget(self.centralwidget)
self.startButton = QPushButton(self.centralwidget, text='开始')
self.stopButton = QPushButton(self.centralwidget, text='停止')
self.stopButton.setDisabled(True)
self.table.setColumnCount(3)
self.table.setHorizontalHeaderItem(0, QTableWidgetItem('GID'))
self.table.setHorizontalHeaderItem(2, QTableWidgetItem('name'))
self.table.setHorizontalHeaderItem(1, QTableWidgetItem('speed'))
self.table.horizontalHeader().setStretchLastSection(True)
self.table.setRowCount(1)
self.layout = QGridLayout(self.centralwidget)
self.layout.addWidget(self.startButton)
self.layout.addWidget(self.stopButton)
self.layout.addWidget(self.table)
self.setCentralWidget(self.centralwidget)
self.ut.resultReady.connect(self.on_changeValue)
self.startButton.clicked.connect(self.changeValue)
self.stopButton.clicked.connect(self.stopUpdate)
def on_customContextMenuRequestedVolume(self, pos):
it = self.table_volume.itemAt(pos)
if it is None:
return
c = it.row()
item_range = QtWidgets.QTableWidgetSelectionRange(
c, 0, c,
self.table_volume.columnCount() - 1)
self.table_volume.setRangeSelected(item_range, True)
menu = QtWidgets.QMenu()
modify_row_action = menu.addAction("Modify")
menu.addSeparator()
delete_row_action = menu.addAction("Delete")
action = menu.exec(self.table_volume.viewport().mapToGlobal(pos))
if action == delete_row_action:
self.table_volume.removeRow(c)
if action == modify_row_action:
dialog = Dialog_Volume(
self.table_volume.item(c, 0).text(),
self.table_volume.item(c, 1).text())
if dialog.exec():
new_data = dialog.getInputs()
self.table_volume.setItem(c, 0, QTableWidgetItem(new_data[0]))
self.table_volume.setItem(c, 1, QTableWidgetItem(new_data[1]))
def onCustomContextMenuRequestedRoi(self, pos):
it = self.table_roi.itemAt(pos)
if it is None:
return
c = it.row()
item_range = QtWidgets.QTableWidgetSelectionRange(
c, 0, c,
self.table_roi.columnCount() - 1)
self.table_roi.setRangeSelected(item_range, True)
# Add right click menu
menu = QtWidgets.QMenu()
modify_row_action = menu.addAction("Modify")
menu.addSeparator()
delete_row_action = menu.addAction("Delete")
action = menu.exec(self.table_roi.viewport().mapToGlobal(pos))
# Delete row
if action == delete_row_action:
self.table_roi.removeRow(c)
# Insert row
if action == modify_row_action:
dialog = Dialog_Dose(
self.table_roi.item(c, 0).text(),
self.table_roi.item(c, 3).text())
if dialog.exec():
new_data = dialog.getInputs()
self.table_roi.setItem(c, 0, QTableWidgetItem(new_data[0]))
self.table_roi.setItem(c, 1, QTableWidgetItem(new_data[1]))
self.table_roi.setItem(c, 2, QTableWidgetItem(new_data[2]))
self.table_roi.setItem(c, 3, QTableWidgetItem(new_data[3]))
def __init__(self,
image_sensor: 'Image',
image_view_widget: 'ImageViewWidget',
parent: Optional[QWidget] = None) -> None:
super().__init__(image_sensor.get_num_images(), 2, parent=parent)
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.resizeColumnsToContents()
extension: str = image_sensor.get_file_ext()
timestamps: np.ndarray = image_sensor.get_timestamps().get_timestamps()
self.setHorizontalHeaderLabels(["File Name", "Image Sampled At"])
for (i, timestamp) in enumerate(timestamps):
name: str = f"{round(timestamp)}.{extension}"
date_time: datetime.datetime = datetime.datetime.utcfromtimestamp(timestamp / 1_000_000.0)
self.setItem(i, 0, QTableWidgetItem(name))
self.setItem(i, 1, QTableWidgetItem(str(date_time)))
def __update_image_at_row(row: int) -> None:
buf: bytes = image_sensor.get_samples()[row]
image_view_widget.set_image(buf)
self.currentCellChanged.connect(__update_image_at_row)
def __init__(self, app: "MainWindow", parent=None):
super(FormationExtrapolator, self).__init__(parent)
self.app = app
self.setWindowTitle(self.app.settings.WINDOW_TITLE)
self.setWindowIcon(QIcon(self.app.settings.WINDOW_ICON))
layout = QVBoxLayout()
self.table = QTableWidget(10, 5)
self.table.setMinimumWidth(500)
self.table.setMinimumHeight(500)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table.setFocusPolicy(Qt.NoFocus)
self.table.setSelectionMode(QAbstractItemView.NoSelection)
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.table.verticalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
labels = ["Formation\nAccumulator", "Formation ID", "Enemies", "Enemy\nFormation", "Preemptable"]
for i in range(len(labels)):
self.table.setHorizontalHeaderItem(i, QTableWidgetItem(labels[i]))
for j in range(self.table.rowCount()):
self.table.setCellWidget(j, i, QLabel())
for i in range(self.table.rowCount()):
self.table.setVerticalHeaderItem(i, QTableWidgetItem(""))
layout.addWidget(self.table)
self.setLayout(layout)
self.show()
def run(self,
database: DigestionDatabase) -> Optional[Set[DigestionSettings]]:
# Refreshing anzymes combobox
self.enzymeComboBox.clear()
for enzyme in enzymescollection.available_enzymes():
self.enzymeComboBox.addItem(enzyme)
# Refreshing digestion settings table
self.digestionSettingsTableWidget.setRowCount(0)
self.digestionSettingsTableWidget.setSortingEnabled(False)
for i, digestion in enumerate(database.available_digestions):
self.digestionSettingsTableWidget.insertRow(i)
enzyme_item = QTableWidgetItem(digestion.enzyme)
missed_cleavages_item = QTableWidgetItem(
str(digestion.missed_cleavages))
rule_item = QTableWidgetItem(
enzymescollection.enzyme(digestion.enzyme).description)
self.digestionSettingsTableWidget.setItem(i, 0, enzyme_item)
self.digestionSettingsTableWidget.setItem(i, 1,
missed_cleavages_item)
self.digestionSettingsTableWidget.setItem(i, 2, rule_item)
self.digestionSettingsTableWidget.setSortingEnabled(True)
if self.exec() == QDialog.Accepted:
return self._generateDigestionSettings()
return None
def fill_table(self, data=None):
data = self._data if not data else data
for desc, price in data.items():
self.table.insertRow(self.items)
self.table.setItem(self.items, 0, QTableWidgetItem(desc))
self.table.setItem(self.items, 1, QTableWidgetItem(str(price)))
self.items += 1
def new_volume(self):
dialog = Dialog_Volume("", "")
c = self.table_volume.rowCount()
if dialog.exec():
new_data = dialog.getInputs()
self.table_volume.insertRow(c)
self.table_volume.setItem(c, 0, QTableWidgetItem(new_data[0]))
self.table_volume.setItem(c, 1, QTableWidgetItem(new_data[1]))
def manage_item_changed(self,
table_item: QtWidgets.QTableWidgetItem) -> None:
"""Update the column sizes and information when an item is changed."""
if table_item.column() == 0:
self.table.resize_column_to_contents(0)
elif self._current_route_type is NeutronPlotRow and table_item.column(
) == 3:
self.update_remaining_count(table_item.row())
def refreshProteinsTableWidget(self) -> None:
search_text = self.proteinsSearchLineEdit.text().strip()
search_mode = self.proteinsSearchTypeComboBox.currentIndex()
if not search_text:
return
if search_mode == 0:
results = self._database.search_proteins_by_name(
search_text, limit=10000, callback=self._progressCallback)
elif search_mode == 1:
results = self._database.search_proteins_by_sequence(
search_text, limit=10000, callback=self._progressCallback)
elif search_mode == 2:
try:
digestion_settings = self._working_digestion_action_group.checkedAction(
).data()
except AttributeError:
results = []
else:
results = self._database.search_proteins_by_peptide_sequence(
search_text,
digestion_settings,
limit=10000,
callback=self._progressCallback)
else:
raise ValueError
self.proteinsTableWidget.setRowCount(0)
self.proteinsTableWidget.setSortingEnabled(False)
try:
for i, protein in enumerate(results):
self.proteinsTableWidget.insertRow(i)
index_item = QTableWidgetItem(str(i + 1).zfill(5))
index_item.setData(TableItemDataRole.ROW_OBJECT, protein)
name_item = QTableWidgetItem(protein.name)
self.proteinsTableWidget.setItem(i, 0, index_item)
self.proteinsTableWidget.setItem(i, 1, name_item)
except ResultsLimitExceededError:
commondialog.informationMessage(
self, 'Your search returns too much results.\n'
'Only the 10000 first results will be displayed.',
dismissable=True)
self.proteinsTableWidget.setSortingEnabled(True)
self.proteinsTableWidget.resizeColumnToContents(-1)
# Change search line edit text color to assure the user the search is done
palette = self.proteinsSearchLineEdit.palette()
if self.proteinsTableWidget.rowCount():
palette.setColor(QPalette.Text, QColor(0, 180, 0))
else:
palette.setColor(QPalette.Text, QColor(180, 0, 0))
self.proteinsSearchLineEdit.setPalette(palette)
def new_organ(self):
dialog = Dialog_Organ("", "", "", "")
c = self.table_organ.rowCount()
if dialog.exec():
new_data = dialog.getInputs()
self.table_organ.insertRow(c)
self.table_organ.setItem(c, 0, QTableWidgetItem(new_data[0]))
self.table_organ.setItem(c, 1, QTableWidgetItem(new_data[1]))
self.table_organ.setItem(c, 2, QTableWidgetItem(new_data[2]))
self.table_organ.setItem(c, 3, QTableWidgetItem(new_data[3]))
def new_windowing(self):
dialog = Dialog_Windowing("", "", "", "")
c = self.table_view.rowCount()
if dialog.exec():
new_data = dialog.getInputs()
self.table_view.insertRow(c)
self.table_view.setItem(c, 0, QTableWidgetItem(new_data[0]))
self.table_view.setItem(c, 1, QTableWidgetItem(new_data[1]))
self.table_view.setItem(c, 2, QTableWidgetItem(new_data[2]))
self.table_view.setItem(c, 3, QTableWidgetItem(new_data[3]))
def new_isodose(self):
dialog = Dialog_Dose("", "")
c = self.table_roi.rowCount()
if dialog.exec():
new_data = dialog.getInputs()
self.table_roi.insertRow(c)
self.table_roi.setItem(c, 0, QTableWidgetItem(new_data[0]))
self.table_roi.setItem(c, 1, QTableWidgetItem(new_data[1]))
self.table_roi.setItem(c, 2, QTableWidgetItem(new_data[2]))
self.table_roi.setItem(c, 3, QTableWidgetItem(new_data[3]))
def update_route_from_edit(self,
table_item: QtWidgets.QTableWidgetItem) -> None:
"""Edit the plotter's route with the new data in `table_item`."""
log.debug(
f"Updating info from edited item at x={table_item.row()} y={table_item.column()}."
)
self.plotter_state.route[table_item.row()][
table_item.column()] = table_item.data(
QtCore.Qt.ItemDataRole.DisplayRole)
if table_item.row() == self.plotter_state.route_index:
self.plotter_state.route_index = self.plotter_state.route_index
def add_element(self):
des = self.description.text()
qty = self.quantity.text()
self.table.insertRow(self.items)
self.table.setItem(self.items, 0, QTableWidgetItem(des))
self.table.setItem(self.items, 1, QTableWidgetItem(qty))
self.description.setText("")
self.quantity.setText("")
self.items += 1
def load_data(self, checked):
with open('data.csv', 'r') as f:
reader = csv.reader(f, delimiter=',', quotechar='"')
self.widget.items = 0
self.widget.table.setRowCount(0)
for i, row in enumerate(reader):
des, qty = row
self.widget.table.insertRow(i)
self.widget.table.setItem(i, 0, QTableWidgetItem(des))
self.widget.table.setItem(i, 1, QTableWidgetItem(qty))
self.widget.items += 1
reply = QMessageBox.information(self, "Load", "Load successfully")
reply
def get_user_bookmark(self, request_type, b_id=None):
bookmark_list = get_bookmark_list(request_type, self.uid, b_id)
bookmark_list_length = len(bookmark_list)
table_header = [
'bookmark_id', 'name', 'book_id', 'chapter_id', 'page_num'
]
table_header_length = len(table_header)
self.tableWidget.setRowCount(bookmark_list_length)
for i in range(bookmark_list_length):
bookmark = bookmark_list[i]
if request_type == 'user':
b_id = bookmark['book_id']
else:
assert b_id is not None
for j in range(table_header_length):
is_book_id = table_header[j] == 'book_id'
if is_book_id:
text = get_book('single', b_id)['name']
else:
text = bookmark[table_header[j]]
if type(text) == int: text = str(text)
if is_book_id:
new_item = BookTableItem(b_id, text)
else:
new_item = QTableWidgetItem(text)
new_item.setTextAlignment(Qt.AlignCenter)
self.tableWidget.setItem(i, j, new_item)
remove_button = QPushButton('delete')
remove_button.clicked.connect(self.delete_bookmark_single)
self.tableWidget.setCellWidget(i, table_header_length,
remove_button)
self.tableWidget.resizeColumnsToContents()
def initUI(self):
self.setWindowTitle("QTableWidget 例子")
self.resize(430, 300);
conLayout = QHBoxLayout()
tableWidget = QTableWidget()
tableWidget.setRowCount(4)
tableWidget.setColumnCount(3)
conLayout.addWidget(tableWidget)
tableWidget.setHorizontalHeaderLabels(['姓名', '性别', '体重(kg)'])
newItem = QTableWidgetItem("张三")
tableWidget.setItem(0, 0, newItem)
comBox = QComboBox()
comBox.addItem("男")
comBox.addItem("女")
comBox.setStyleSheet("QComboBox{margin:3px};")
tableWidget.setCellWidget(0, 1, comBox)
searchBtn = QPushButton("修改")
searchBtn.setDown(True)
searchBtn.setStyleSheet("QPushButton{margin:3px};")
tableWidget.setCellWidget(0, 2, searchBtn)
self.setLayout(conLayout)
def on_move_history(self, item_index: int):
assert self.display is not None
history_item = self.display.log_display.items[item_index]
self.display.update_board(history_item.game_state)
choices = self.ui.choices
choices.clear()
choices.setColumnCount(len(history_item.choices))
choices.setVerticalHeaderLabels(['count', 'probability', 'value'])
choices.setHorizontalHeaderLabels(
[choice[0] for choice in history_item.choices])
for i, (choice, probability, count,
value) in enumerate(history_item.choices):
choices.setItem(0, i, QTableWidgetItem(f'{count}'))
choices.setItem(1, i, QTableWidgetItem(f'{probability}'))
choices.setItem(2, i, QTableWidgetItem(f'{value}'))
choices.resizeColumnsToContents()
def import_organs(self):
self.check_change = False
path = QFileDialog.getOpenFileName(self, "Open Data File", "",
"CSV data files (*.csv)")[0]
if path != "":
with open(path, newline="") as stream:
next(stream)
for rowdata in csv.reader(stream):
if len(rowdata) != 3 or len(rowdata) != 4:
buttonReply = QMessageBox.warning(
self,
"Error Message",
"Import a csv with 3 or 4 columns and the data with the displayed order!",
QMessageBox.Ok,
)
if buttonReply == QMessageBox.Ok:
pass
else:
row = self.table_organ.rowCount()
self.table_organ.insertRow(row)
self.table_organ.setColumnCount(len(rowdata))
for column, data in enumerate(rowdata):
item = QTableWidgetItem(data)
self.table_organ.setItem(row, column, item)
self.check_change = True
def display_row(self, data):
self.insertRow(START_ROW)
for column in range(self.columnCount()):
self.setItem(START_ROW, column, QTableWidgetItem(data[self.column_names[column]]))
if self.max_rows:
if self.rowCount() > self.max_rows:
self.removeRow(self.rowCount() - 1)
def from_data(self, data: TreeWidgetItemData):
for key, value in data.to_dict().items():
self.insertRow(self.rowCount())
key_item = QTableWidgetItem(key)
key_item.setFlags(Qt.ItemIsEnabled | Qt.ItemNeverHasChildren)
value_item = QTableWidgetItem(str(value))
value_item.setFlags(Qt.ItemIsEnabled | Qt.ItemNeverHasChildren)
self.setItem(self.rowCount() - 1, 0, key_item)
self.setItem(self.rowCount() - 1, 1, value_item)
def update_list(self):
self.table_widget.clear()
self.table_widget.setHorizontalHeaderLabels([
"Name", "Game", "Status", "Entrants", "Goal", "Info", "Opened At"
])
name_filter = self.filter_name_edit.text().strip()
displayed_status = set()
for (check, status) in self._status_checks:
if check.isChecked():
displayed_status.add(status)
displayed_games = set()
for (check, game) in self._game_checks:
if check.isChecked():
displayed_games.add(game)
visible_races = [
race for race in self.races
if (race.status in displayed_status and name_filter in race.name
and race.game in displayed_games)
]
self.table_widget.setRowCount(len(visible_races))
for i, session in enumerate(visible_races):
name = QTableWidgetItem(session.name)
status = QTableWidgetItem(session.verbose_status)
entrants = QTableWidgetItem(str(session.entrants))
goal = QTableWidgetItem(session.goal)
info = QTableWidgetItem(session.info)
opened_at = QTableWidgetItem(
session.opened_at.astimezone().strftime("%c"))
game_name = QTableWidgetItem(session.game.short_name)
name.setData(Qt.UserRole, session)
self.table_widget.setItem(i, 0, name)
self.table_widget.setItem(i, 1, game_name)
self.table_widget.setItem(i, 2, status)
self.table_widget.setItem(i, 3, entrants)
self.table_widget.setItem(i, 4, goal)
self.table_widget.setItem(i, 5, info)
self.table_widget.setItem(i, 6, opened_at)
self.status_label.setText(
f"{len(self.races)} races total, {len(visible_races)} displayed.")
def report_progress(self, multifile, password):
self.count += 1
index = self.result_table.rowCount()
self.result_table.insertRow(index)
for i, value in enumerate((self.process_name, multifile, password)):
self.result_table.setItem(index, i, QTableWidgetItem(value))
def redraw_table(self, data):
table = self.input_table if self.input else self.output_table
self.input = not self.input
# clear the table and resize
table.clearContents()
table.rowCount = len(data) # type: ignore
table.columnCount = len(self.table_headers) # type: ignore
# set the values of each entry
for row_id, row in enumerate(data):
for col_id, val in enumerate(row):
item = QTableWidgetItem(str(val))
item.setFlags(Qt.ItemFlag.ItemIsEnabled)
table.setItem(row_id, col_id, item)
# resize the table to fit the content
table.resizeColumnsToContents()
def add_event(self):
current_row = self.table.selectedIndexes()[0].row()
pos = int(self.table.item(current_row, 0).data(Qt.DisplayRole))
self.table.setSortingEnabled(False)
self.table.insertRow(current_row)
self.table.setItem(current_row, 0, IntTableWidgetItem(pos))
self.table.setItem(current_row, 1, IntTableWidgetItem(0))
self.table.setItem(current_row, 2, QTableWidgetItem("New Annotation"))
self.table.setSortingEnabled(True)
def CheckNum(self):
'''
'''
#enter check
print(self.window.LEditNum.text())
FourNumStr = self.window.LEditNum.text()
str1 = re.findall(r'\d+', FourNumStr)
if (not self.IsInputNumOK(FourNumStr)):
QMessageBox.about(self.window, 'error', 'please enter again')
return
FourNum = []
for num in str1:
FourNum.append(int(num))
Num1 = FourNum
#compare and output
[a, b] = self.ABNum(self.Num0, Num1)
abstr = str(a) + 'A' + str(b) + 'B'
entercell = QTableWidgetItem(FourNumStr)
resultcell = QTableWidgetItem(abstr)
self.window.tableWidget.setItem(7 - self.life, 0, entercell)
self.window.tableWidget.setItem(7 - self.life, 1, resultcell)
self.window.LEditResult.setReadOnly(False)
self.window.LEditResult.setText(abstr)
self.window.LEditResult.setReadOnly(True)
if (self.ABNum(self.Num0, Num1)[0] == 4):
print("Win")
QMessageBox.about(self.window, 'win', 'game win\n')
self.gameInit()
return
self.life = self.life - 1
self.window.lcdNumber.display(self.life)
if (self.life == 0):
QMessageBox.about(self.window, 'lose',
'game lose\nplease try again')
self.gameInit
def refresh_table(self):
con = sqlite3.connect(self.filepath)
c = con.cursor()
c.execute('SELECT username,url FROM DETAILS')
res = c.fetchall()
for row_count,row_data in enumerate(res):
self.ui.table.insertRow(row_count)
for column_number, data in enumerate(row_data):
self.ui.table.setItem(row_count,column_number,QTableWidgetItem(str(data)))
self.ui.table.setRowCount(len(res))