def create_diff_table(self, diffs):
tbl = QTableWidget()
tbl.setRowCount(len(diffs))
tbl.setColumnCount(3)
tbl.setHorizontalHeaderItem(0, QTableWidgetItem('Field'))
tbl.setHorizontalHeaderItem(1, QTableWidgetItem('Current'))
tbl.setHorizontalHeaderItem(2, QTableWidgetItem('Previous'))
from PyQt5.QtGui import QColor
red = QColor()
red.setRed(255)
for row, diff in enumerate(diffs):
tbl.setItem(row, 0, QTableWidgetItem(diff.field_name))
item1 = QTableWidgetItem(to_money(diff.current_amount))
item2 = QTableWidgetItem(to_money(diff.previous_amount))
if self._significant_diff(diff.current_amount, diff.previous_amount):
item1.setForeground(red)
item2.setForeground(red)
tbl.setItem(row, 1, item1)
tbl.setItem(row, 2, item2)
tbl.verticalHeader().setVisible(False)
tbl.resizeColumnsToContents()
ht = tbl.rowHeight(0) * (tbl.rowCount() + 1)
tbl.setFixedSize(tbl.horizontalHeader().length() + 20, ht)
return tbl
def filltabledata(self):
# get ini file data
config = configparser.ConfigParser()
config.read_file(open(self.filename))
sec = config.sections()
lop = []
for i in range(len(sec)):
lop.append(config.options(sec[i]))
# fill data to the table widget
i = 0
for n in range(len(sec)):
self.tableWidget.setRowCount(i + 1)
self.tableWidget.setSpan(i, 0, 1, 3)
secitem = QTableWidgetItem(sec[n])
secitem.setForeground(QColor(Qt.red))
self.tableWidget.setItem(i, 0, secitem)
secitem.setFlags(secitem.flags() & (~Qt.ItemIsEditable))
for j in range(len(lop[n])):
i = i + 1
self.tableWidget.setRowCount(i + 1)
item0 = QTableWidgetItem(lop[n][j])
item0.setFlags(item0.flags() & (~Qt.ItemIsEditable)) # Item name can't edit
s = config.get(sec[n], lop[n][j])
s1, s2 = s.split("#")
item1 = QTableWidgetItem(s1)
item2 = QTableWidgetItem(s2)
self.tableWidget.setItem(i, 0, item0)
self.tableWidget.setItem(i, 1, item1)
self.tableWidget.setItem(i, 2, item2)
# print(n, j, lop[n][j], i)
i = i + 1
self.tableWidget.resizeColumnsToContents()
def save_pxlabel_mat(self):
"""Write pxlabel pickle file and update table_height
"""
if self.pxlabel_frame.any() and not (self.pxlabel_frame == self.pxlabel_frame_ori).all():
self.pxlabel_mat = self.update_pxlabel_mat(self.pxlabel_mat, self.pxlabel_frame, self.pxmarker_table)
item_status = QTableWidgetItem(str(True))
item_status.setForeground(QColor(0,255,0))
item_name = QTableWidgetItem(self.img_filename)
item_name.setForeground(QColor(0,255,0))
self.ui.table_filename.setItem(self.img_table_idx,1,item_status)
self.ui.table_filename.setItem(self.img_table_idx,0,item_name)
with open(self.pxlabel_filename, 'wb') as f:
pickle.dump(self.pxlabel_mat, f)
try:
cv2.imwrite(self.pxlabel_display_filename, self.display_frame)
except:
pass
try:
cv2.imwrite(self.pxlabel_mask_filename, self.pxlabel_frame)
except:
pass
statusText = "Labels for " + self.img_filename + " saved."
self.ui.label_status.setText(statusText)
def show_data_tableWidget_2(self, result):
self.tableWidget_2.setRowCount(len(result))
list_data = []
# 将数据取出 遍历加入数组
for data in result:
list_data.append(data)
# 数组反序 使显示时第一条显示数据库最后一条数据
list_data.reverse()
# 设置行数
self.tableWidget_2.setRowCount(len(result))
# 将数据
for i in range(len(result)):
data = list_data[i]
for index in range(8):
try:
if index == 0:
if i == 0:
newItem = QTableWidgetItem('1')
else:
newItem = QTableWidgetItem(str(i + 1))
else:
newItem = QTableWidgetItem(str(data[index - 1]))
if str(data[index - 1]) == '合格':
newItem.setForeground(QBrush(QColor(11, 166,
120))) # 合格绿色
elif str(data[index - 1]) == '不合格':
newItem.setForeground(QBrush(QColor(168, 28,
66))) # 不合格红色
# 设置字体样式 大小
newItem.setFont(QFont('Microsoft YaHei', 12))
# 文本居中
newItem.setTextAlignment(Qt.AlignCenter)
self.tableWidget_2.setItem(i, index, newItem)
except Exception as e:
print('错误show_data_tebleWidget' + e)
def SetResultFail(self, line, n):
newItem = QTableWidgetItem("测试失败")
textFont = QFont("song", 18)
newItem.setFont(textFont)
newItem.setForeground(QBrush(Qt.red))
newItem.setBackground(QBrush(Qt.gray))
self.table.setItem(line, n, newItem)
def SetWarnResult(self, line, n, str1):
newItem = QTableWidgetItem(str1)
textFont = QFont("song", 18)
newItem.setFont(textFont)
newItem.setForeground(QBrush(Qt.red))
#newItem.setBackground(QBrush(Qt.gray))
self.table.setItem(line, n, newItem)
def _process_row(self, y, row):
cols = self.columnCount()
for x, i in enumerate(range(0, len(row), self._width)):
block = row[i:i+self._width]
item = QTableWidgetItem(codecs.encode(block, 'hex').decode())
item.setBackground(QBrush(QColor('lightgray')))
item.setForeground(QBrush(QColor('black')))
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
item.setData(Qt.UserRole, block) # store original data
if self._read_only:
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
else:
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.setItem(y, x, item)
# process remaining, unfilled cells
for j in range(x+1, cols):
item = QTableWidgetItem()
item.setBackground(QBrush(QColor('white')))
item.setFlags(Qt.NoItemFlags)
item.setTextAlignment(Qt.AlignHCenter)
self.setItem(y, j, item)
text = self._bytes_to_ascii(row)
item = QTableWidgetItem(text)
item.setData(Qt.UserRole, row) # store original data
item.setTextAlignment(Qt.AlignLeft| Qt.AlignVCenter)
item.setBackground(QBrush(QColor('lightblue')))
item.setForeground(QBrush(QColor('black')))
if self._read_only:
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
else:
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.setItem(y, cols - 1, item)
def updateTableUi(self):
self.fileView.setRowCount(0)
end = self.nStart+self.nPageSize if self.nStart+self.nPageSize < self.nTotal else self.nTotal
if end == self.nTotal:
self.nextBtn.setEnabled(False)
for i in range(self.nStart, end):
subDict = self.fileDicts['seq_'+str(i).zfill(4)]
row = self.fileView.rowCount()
self.fileView.setRowCount(row + 1)
item0 = QTableWidgetItem(subDict['filename'])
if (row+1) % 10 == 0:
textFont = QFont("Arial", 9, QFont.Bold)
item0.setFont(textFont)
item0.setForeground(QColor(255,0,0))
item1 = QTableWidgetItem(str(subDict['count']))
#√
item2 = QTableWidgetItem('×')
item2.setForeground(QColor(0,0,0))
item2.setTextAlignment(Qt.AlignCenter)
item3 = QTableWidgetItem(str(row + 1))
item4 = QTableWidgetItem(subDict['content'])
item5 = QTableWidgetItem(subDict['seq'])
self.fileView.setItem(row, 0, item0)
self.fileView.setItem(row, 1, item1)
self.fileView.setItem(row, 2, item2)
self.fileView.setItem(row, 3, item3)
self.fileView.setItem(row, 4, item4)
self.fileView.setItem(row, 5, item5)
item3.setCheckState(Qt.Unchecked)
def __init__(self, stream_type, path, parent=None):
super().__init__(parent=parent)
self.UI = Ui_StreamWindow()
self.UI.setupUi(self)
# self.setWindowFlags(Qt.WindowTitleHint)
self.stream_path = path
if stream_type == StreamerTypes.APPLEWATCH:
self.streamer = AppleWatchStreamer(path=self.stream_path, parent=self)
if self.streamer:
self.streamer.add_log.connect(self.add_to_log)
self.streamer.update_progress.connect(self.update_progress)
self.streamer.finished.connect(self.streaming_server_finished)
self.streamer.file_error_occured.connect(self.streaming_file_error)
# Initial UI state
self.UI.frameProgress.hide()
infos = self.streamer.get_streamer_infos()
row = 0
self.UI.tableInfos.setRowCount(len(infos))
for info_item, info_value in infos.items():
item = QTableWidgetItem(info_item)
item.setBackground(QBrush(Qt.lightGray))
self.UI.tableInfos.setItem(row, 0, item)
item = QTableWidgetItem(info_value)
item.setBackground(QBrush(Qt.white))
item.setForeground(QBrush(Qt.blue))
self.UI.tableInfos.setItem(row, 1, item)
row += 1
# Signals / slots connection
self.UI.btnClose.clicked.connect(self.close_requested)
def showRowContents(self, row_list):
self.clear()
table_headers = ['序号', '创建日期', '标题', '']
self.setColumnCount(len(table_headers))
self.setRowCount(len(row_list))
self.setHorizontalHeaderLabels(table_headers)
self.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)
self.horizontalHeader().setSectionResizeMode(3, QHeaderView.ResizeToContents)
for row, row_item in enumerate(row_list):
item0 = QTableWidgetItem(str(row + 1))
item0.setTextAlignment(Qt.AlignCenter)
item0.id = row_item['id']
self.setItem(row, 0, item0)
item1 = QTableWidgetItem(row_item['create_time'])
item1.setTextAlignment(Qt.AlignCenter)
self.setItem(row, 1, item1)
item2 = QTableWidgetItem(row_item['title'])
item2.setTextAlignment(Qt.AlignCenter)
self.setItem(row, 2, item2)
item3 = QTableWidgetItem('阅读')
item3.setForeground(QBrush(QColor(50, 50, 220)))
item3.setTextAlignment(Qt.AlignCenter)
item3.file_url = row_item['file_url']
self.setItem(row, 3, item3)
def genQueuesTabTable(self):
self.queuesTabTable.setShowGrid(True)
self.queuesTabTable.setColumnCount(3)
self.queuesTabTable.setHorizontalHeaderLabels(['QUEUE', 'PEND', 'RUN'])
# Hide the vertical header.
self.queuesTabTable.verticalHeader().setVisible(False)
queuesDic = common.getBqueuesInfo()
self.queuesTabTable.setRowCount(len(self.queueList))
for i in range(len(self.queueList)):
queue = self.queueList[i]
index = queuesDic['QUEUE_NAME'].index(queue)
j = 0
item = QTableWidgetItem(queue)
self.queuesTabTable.setItem(i, j, item)
j = j + 1
pend = queuesDic['PEND'][index]
item = QTableWidgetItem(pend)
if int(pend) > 0:
item.setFont(QFont('song', 10, QFont.Bold))
item.setForeground(QBrush(Qt.red))
self.queuesTabTable.setItem(i, j, item)
j = j + 1
run = queuesDic['RUN'][index]
item = QTableWidgetItem(run)
self.queuesTabTable.setItem(i, j, item)
def trim_file(self, sound_file):
silence_duration = float(
self.tblFileList.item(self.__currentRow, 2).text())
if silence_duration > self.__fadeDuration:
sound_file.seek(0)
audio_data = sound_file.read()
trim_samples = int((silence_duration - self.__fadeDuration) *
sound_file.samplerate)
# 进行裁剪
audio_data = audio_data[:len(audio_data) - trim_samples]
# 把保留的静音时长做个淡出
AudioEditTools.apply_fade(
audio_data, int(self.__fadeDuration * sound_file.samplerate),
-1)
soundfile.write(file=sound_file.name,
data=audio_data,
samplerate=sound_file.samplerate)
# 更新列表显示
self.tblFileList.setItem(
self.__currentRow, 2,
QTableWidgetItem(str(self.__fadeDuration)))
status_item = QTableWidgetItem('已裁剪')
status_item.setForeground(QColor(0, 200, 0))
self.tblFileList.setItem(self.__currentRow, 3, status_item)
self.__currentRow += 1
def add_quantity_group(self):
if self.sender() == self.ui.toolBtn_plus_1:
tableW_size=self.ui.tableW_size_1
group_no=1
elif self.sender()==self.ui.toolBtn_plus_2:
tableW_size = self.ui.tableW_size_2
group_no = 2
else:
tableW_size = self.ui.tableW_size_3
group_no = 3
columns=tableW_size.columnCount()
#self.ui.tableW_size_1.setFont(QFont('SimHei',11,QFont.Bold))
for index in range(columns):
try:
change = int(tableW_size.item(1,index).text())
except Exception as e:
logger.error(' not int ')
continue
if change!=0:
logger.debug(
' check group {2} change item{0} :{1}'.format(index, tableW_size.item(1, index).text(), group_no))
try:
origin=int(tableW_size.item(0,index).text())
result=origin+change
if result<0:
tableW_size.item(1,index).setBackground(QColor(202,223,79)) #yellow 255,255,79
reply=QMessageBox.information(self,'Warning','Final quantity must not be less than 0',QMessageBox.Ok)
continue
item=QTableWidgetItem(str(origin+change))
item.setForeground(QColor(255, 19, 1))
tableW_size.setItem(0,index,item)
tableW_size.setItem(1,index,QTableWidgetItem('0'))
except Exception as e:
logger.error(' error calculating quantity :{0}'.format(e))
def show_configs(self, records):
self.config_table.cellChanged.disconnect()
self.config_table.clear()
table_headers = ['序号', '客户端名称', '客户端ID', '可登录', '截止日期']
self.config_table.setColumnCount(len(table_headers))
self.config_table.setHorizontalHeaderLabels(table_headers)
self.config_table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.config_table.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
self.config_table.setRowCount(len(records))
for row, row_item in enumerate(records):
item0 = QTableWidgetItem(str(row + 1))
item0.setTextAlignment(Qt.AlignCenter)
item0.id = row_item['id']
self.config_table.setItem(row, 0, item0)
item1 = QTableWidgetItem(row_item['name'])
item1.setTextAlignment(Qt.AlignCenter)
self.config_table.setItem(row, 1, item1)
item2 = QTableWidgetItem(row_item['machine_code'])
item2.setTextAlignment(Qt.AlignCenter)
self.config_table.setItem(row, 2, item2)
if row_item['accessed']:
item3 = QTableWidgetItem('允许登录')
item3.setCheckState(Qt.Checked)
item3.setForeground(QBrush(QColor(100,200,180)))
item4 = QTableWidgetItem(row_item['expire_time'])
else:
item3 = QTableWidgetItem('不能登录')
item3.setCheckState(Qt.Unchecked)
item3.setForeground(QBrush(QColor(200, 100, 80)))
item4 = QTableWidgetItem('')
item3.setTextAlignment(Qt.AlignCenter)
item4.setTextAlignment(Qt.AlignCenter)
self.config_table.setItem(row, 3, item3)
self.config_table.setItem(row, 4, item4)
self.config_table.cellChanged.connect(self.config_table_checked_changed) # 恢复信号
def populate_sudoku(self, table, color=Qt.black, table_init=None):
'''
populates SudokuWidget from the 2D table
color is Qt.Color instance e.g. Qt.Green or setForeground(QColor::fromRgb(255,0,0))
'''
for u in range(9):
for v in range(9):
if (table_init
is not None) and (table[u][v] - table_init[u][v]) == 0:
item = self.item(u, v)
if item is None:
item = QTableWidgetItem()
self.setItem(u, v, item)
else:
element = item.text()
item = QTableWidgetItem(element)
self.setItem(u, v, item)
else:
element = table[u][v]
if element == 0:
item = QTableWidgetItem('')
self.setItem(u, v, item)
else:
item = QTableWidgetItem(str(element))
item.setForeground(color)
self.setItem(u, v, item)
if self.in_quadrant(u, v) % 2 == 0:
item.setBackground(QColor.fromRgb(245, 245, 245))
def setVarietyContents(self, row_contents):
self.variety_table.clear()
table_headers = ['序号', '品种', '权限']
self.variety_table.setColumnCount(len(table_headers))
self.variety_table.setHorizontalHeaderLabels(table_headers)
self.variety_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.variety_table.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)
current_row = 0
for row_item in row_contents:
self.variety_table.insertRow(current_row)
item0 = QTableWidgetItem(str(current_row + 1))
item0.setTextAlignment(Qt.AlignCenter)
item0.id = row_item['id']
self.variety_table.setItem(current_row, 0, item0)
item1 = QTableWidgetItem(row_item['name'])
item1.setTextAlignment(Qt.AlignCenter)
self.variety_table.setItem(current_row, 1, item1)
for variety_item in row_item['subs']:
current_row += 1
self.variety_table.insertRow(current_row)
item0 = QTableWidgetItem(str(current_row + 1))
item0.setTextAlignment(Qt.AlignCenter)
item0.id = variety_item['id']
self.variety_table.setItem(current_row, 0, item0)
item1 = QTableWidgetItem(variety_item['name'])
item1.setTextAlignment(Qt.AlignCenter)
self.variety_table.setItem(current_row, 1, item1)
item2 = QTableWidgetItem("点击开启")
item2.setTextAlignment(Qt.AlignCenter)
item2.setForeground(QBrush(QColor(250,50,50)))
self.variety_table.setItem(current_row, 2, item2)
current_row += 1
def updateGrid(self) -> None:
"""
Refresh the grid values from the current values of the
VM CPU registers
"""
emu = self.emulator
arch = self.root.arch
registers = arch.registers
self.__values.setRowCount(len(registers))
for i, reg in enumerate(registers):
self.__values.setRowHeight(i, self.__row_size)
name = QTableWidgetItem(reg)
name.setFlags(Qt.NoItemFlags)
val = emu.get_register_value(reg) if emu.vm else 0
old_val = self.__old_register_values.get(reg, 0)
if type(val) in (int, int):
value = format_address(val, arch)
else:
value = str(val)
value = QTableWidgetItem( value )
if old_val != val:
self.__old_register_values[reg] = val
value.setForeground(QColor(Qt.red))
value.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsEditable)
self.__values.setItem(i, 0, name)
self.__values.setItem(i, 1, value)
return
def initialize_table_nuclides(self):
new_item1 = QTableWidgetItem()
new_item2 = QTableWidgetItem()
self.tableWidget.insertRow(0)
self.tableWidget.setItem(0, 0, new_item1)
self.tableWidget.setItem(0, 1, new_item2)
self.major_checkBox = QCheckBox(self)
self.major_checkBox.setText('')
self.tableWidget.setCellWidget(0, 0, self.major_checkBox)
self.major_checkBox.setChecked(True)
self.major_checkBox.clicked.connect(self.on_major_check)
self.sub_checkBoxs = {}
for i in range(1, len(self.ordered_nuclides) + 1):
while self.tableWidget.rowCount() <= i:
self.tableWidget.insertRow(self.tableWidget.rowCount())
new_item1 = QTableWidgetItem('')
self.tableWidget.setItem(i, 0, new_item1)
new_item1.setFont(QFont("Times", 10, QFont.Black))
cur_nuclide_name = self.ordered_nuclides[i - 1]
new_item1.setForeground(
QBrush(QColor(self.color_map[cur_nuclide_name])))
self.sub_checkBoxs[cur_nuclide_name] = QCheckBox(self)
#if the concerntration of this nuclide exceeds 1e-10, set checked. else uncheck
if self.nuclides_trans_data[cur_nuclide_name][0] > 1e-10:
self.sub_checkBoxs[cur_nuclide_name].setChecked(True)
else:
self.sub_checkBoxs[cur_nuclide_name].setChecked(False)
self.sub_checkBoxs[cur_nuclide_name].clicked.connect(
self.on_sub_check)
self.tableWidget.setCellWidget(
i, 0, self.sub_checkBoxs[cur_nuclide_name])
new_item2 = QTableWidgetItem(cur_nuclide_name)
new_item2.setForeground(
QBrush(QColor(self.color_map[cur_nuclide_name])))
self.tableWidget.setItem(i, 1, new_item2)
def update_possessions(self):
tiles = self.current_player.get_possessions()
if tiles:
sorted_tiles = sorted(tiles, key = lambda x: x.get_price())
self.possessions_info.setText("You have these properties:")
if sorted_tiles != []:
color2tiles = {}
for tile in sorted_tiles:
color2tiles.setdefault(tile.get_color(), []).append(tile)
self.possessions.setColumnCount(len(color2tiles))
self.possessions.setRowCount(max((len(v) for k, v in color2tiles.items())))
for column, (color, tiles) in enumerate(color2tiles.items()):
for row, tile in enumerate(tiles):
set_color = QColor()
set_color.setNamedColor(color)
cell = QTableWidgetItem()
cell.setBackground(QBrush(set_color, style = Qt.SolidPattern))
if color == "#000000":
cell.setForeground(QBrush(QColor(255, 255, 255)))
cell.setText(f"{tile.get_name()}")
self.possessions.setItem(row, column, cell)
else:
self.possessions.clearContents()
def insertOverallGainPercent(self, value, col):
widget = QTableWidgetItem(value)
if float(value) > 0:
widget.setForeground(QBrush(QColor(0, 255, 0)))
else:
widget.setForeground(QBrush(QColor(255, 0, 0)))
self.comparisonTable.setItem(5, col, widget)
def updateAccountsList(self):
if self.prevUUID == self.state.UUID:
return
self.ui.accountsList.clear()
self.ui.accountsList.setColumnCount(4)
self.ui.accountsList.setRowCount(math.ceil(len(self.sortedAccounts)/2))
self.ui.accountsList.setHorizontalHeaderLabels(["Name", "Balance"]*2)
for i in range(len(self.sortedAccounts)):
if i % 2 == 0:
columnoffset = 0
else:
columnoffset = 2
account = self.sortedAccounts[i]
nameWidget = QTableWidgetItem(account.DisplayName)
self.ui.accountsList.setItem(math.floor(i / 2), 0 + columnoffset, nameWidget)
if account.Balance < 0:
nameWidget.setForeground(QBrush(QColor(249, 71, 71)))
balanceWidget = QTableWidgetItem("%.2f€" % (account.Balance / 100))
balanceWidget.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter)
self.ui.accountsList.setItem(math.floor(i / 2), 1 + columnoffset, balanceWidget)
if account.Balance < 0:
balanceWidget.setForeground(QBrush(QColor(249, 71, 71)))
def set_col(table,
row,
col,
val,
fmt=None,
color=None,
align=None,
editable=None,
data=None,
icon=None):
item = QTableWidgetItem(fmt % val if fmt else str(val))
if color:
item.setForeground(QtGui.QColor(color))
if align == "right":
item.setTextAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
if align == "center":
item.setTextAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
if not (editable is None):
if editable:
item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEditable)
else:
item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
if data:
item.setData(99, data)
if icon:
item.setIcon(icon)
table.setItem(row, col, item)
return item
def logs_change(self):
if not self.data_logs or not self.in_logs_data.text():
return
self.data_temp_logs = []
self.tbw_logs.setRowCount(0)
# header = {'郵件類型':'type', '郵件主旨':'subject', '使用者群組':'user_group', '使用者信箱':'user_email'}
condition = self.cmb_logs_choice.currentText()
content = self.in_logs_data.text()
row_num = len(self.data_logs)
col_num = len(self.data_logs[0])
# self.tbw_logs.setRowCount(row_num)
self.tbw_logs.setColumnCount(col_num)
for i in range(row_num):
switch = False
if condition == 'date' and content in str(self.data_logs[i][condition]):
switch = True
elif self.data_logs[i][condition] == content:
switch = True
if switch:
self.tbw_logs.insertRow(self.tbw_logs.rowCount())
row_data = list(self.data_logs[i].values())
self.data_temp_logs.append(self.data_logs[i])
for j in range(col_num):
temp_data = row_data[j]
item = QTableWidgetItem(str(temp_data))
item.setForeground(QBrush(QColor(144, 182, 240)))
self.tbw_logs.setItem(self.tbw_logs.rowCount()-1, j, item)
def _set_module_auth_options_items(self,
row,
checked,
expire_date,
f_color,
b_color=None):
""" 设置模块管理的操作项目(选择开启或关闭,设置到期时间等) """
text = "开放" if checked else "关闭"
item2 = QTableWidgetItem(text)
item2.setCheckState(checked)
item2.setTextAlignment(Qt.AlignCenter)
item2.setBackground(
QBrush(b_color)) if b_color else item2.setForeground(
QBrush(f_color))
self.module_auth.module_auth_table.setItem(row, 2, item2)
item3 = QTableWidgetItem(expire_date)
item3.setBackground(
QBrush(b_color)) if b_color else item3.setForeground(
QBrush(f_color))
item3.setTextAlignment(Qt.AlignCenter)
self.module_auth.module_auth_table.setItem(row, 3, item3)
item4_widget = QPushButton("确定", self.module_auth.module_auth_table)
item4_widget.clicked.connect(self.edit_user_module_authority)
setattr(item4_widget, "row_index", row)
self.module_auth.module_auth_table.setCellWidget(row, 4, item4_widget)
def initUI(self):
grid = QGridLayout()
self.setLayout(grid)
txt = QTableWidget()
txt.setRowCount(13)
txt.setColumnCount(13)
txt.setEditTriggers(QAbstractItemView.NoEditTriggers)
for r in range(13):
for c in range(13):
val = r * c / 169
item = QTableWidgetItem(f"{val:0.02f}")
rgba = cmap(val, bytes=True)
item.setBackground(
QColor(int(rgba[0]), int(rgba[1]), int(rgba[2])))
item.setForeground(QColor(255, 255, 255))
txt.setItem(r, c, item)
txt.resizeColumnsToContents()
txt.resizeRowsToContents()
grid.addWidget(txt)
self.move(300, 150)
self.setWindowTitle(f"Qt CS Grid")
self.show()
def matrix_solve(self):
try:
for row in range(row_count):
matrix, target = [], []
for etest in cfg.Etest:
col = Header.index(etest)
matrix += [[diff_statistic[etest + str(i+1)][rnd]**2 for rnd in rnd_var_cal]]
fix_sum = [diff_statistic[etest + str(i+1)][rnd]**2 for rnd in rnd_var_fix]
target += [[eval(self.table.item(row,col).text())**2 - sum(fix_sum)]]
result = solve(matrix, target)
for k,rnd in enumerate(rnd_var_cal):
col_rnd = Header.index(rnd)
item = QTableWidgetItem("%.3f" % result[k,0])
item.setForeground(QBrush(QColor(255,0,0)))
self.table.setItem(row, col_rnd, item)
item.setFlags(Qt,ItemIsSelectable | Qt.ItemIsEnabled)
for k,rnd in enumerate(rnd_var_cal):
col_var_sqrt = Header.Index(rnd + '_sqrt')
item = QTableWidgetItem("%.4f" % np.sqrt(result[k,0]) if result[k,0]>=0 else "")
item.setForeground(QBrush(QColor(0,176,80)))
self.table.setItem(row, col_rnd_sqrt, item)
except:
print(" **Error** Matrix solve failed.")
def setData(self, data, patient_info):
bold = QFont()
bold.setBold(True)
red = QColor(Qt.red)
sys_limit = (patient_info["systolic_limit"] if "systolic_limit"
in patient_info else bpm_db.SYSTOLIC_LIMIT)
dia_limit = (patient_info["diastolic_limit"] if "diastolic_limit"
in patient_info else bpm_db.DIASTOLIC_LIMIT)
i = 0
for d in data:
it0 = QTableWidgetItem(str(d["date"].toString(DATETIME_FMT)))
it1 = QTableWidgetItem(str(d["sys"]))
if d["sys"] >= sys_limit: it1.setFont(bold), it1.setForeground(red)
it2 = QTableWidgetItem(str(d["dia"]))
if d["dia"] >= dia_limit: it2.setFont(bold), it2.setForeground(red)
it3 = QTableWidgetItem(str(d["pulse"]))
j = 0
for it in [it0, it1, it2, it3]:
it.setTextAlignment(Qt.AlignCenter)
it.setFlags(it.flags() & ~Qt.ItemIsSelectable)
self.setItem(i, j, it)
j += 1
i += 1
self.setHorizontalHeaderLabels(
[" Date & Time ", "Systolic", "Diastolic", "Pulse"])
self.verticalHeader().setVisible(False)
self.resizeRowsToContents()
self.resizeColumnsToContents()
self.verticalScrollBar().setValue(len(data))
def gen_main_table(self):
self.main_table.setShowGrid(True)
self.main_table.setColumnCount(0)
self.main_table.setColumnCount(6)
self.main_table.setHorizontalHeaderLabels(['USER', 'SUBMIT_HOST', 'EXECUTE_HOST', 'LICENSE_NUM', 'LICENSE_VERSION', 'START_TIME'])
# Set column width
self.main_table.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
self.main_table.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
self.main_table.horizontalHeader().setSectionResizeMode(2, QHeaderView.Stretch)
self.main_table.setColumnWidth(3, 120)
self.main_table.setColumnWidth(4, 140)
self.main_table.setColumnWidth(5, 140)
# Set item
self.main_table.setRowCount(len(self.license_feature_usage_dic_list))
title_list = ['user', 'submit_host', 'execute_host', 'license_num', 'version', 'start_time']
for (row, license_feature_usage_dic) in enumerate(self.license_feature_usage_dic_list):
for (column, title) in enumerate(title_list):
item = QTableWidgetItem()
item.setText(license_feature_usage_dic[title])
if (column == 5) and license_common.check_long_runtime(license_feature_usage_dic[title]):
item.setForeground(QBrush(Qt.red))
self.main_table.setItem(row, column, item)
def updateGrid(self):
emuwin = self.parent.parent
emu = emuwin.emulator
current_mode = emuwin.arch
registers = current_mode.registers
self.values.setRowCount(len(registers))
for i, reg in enumerate(registers):
self.values.setRowHeight(i, self.row_size)
name = QTableWidgetItem(reg)
name.setFlags(Qt.NoItemFlags)
val = emu.get_register_value(reg) if emu.vm else 0
old_val = self.old_register_values.get(reg, 0)
if type(val) in (int, int):
value = format_address(val, current_mode)
else:
value = str(val)
value = QTableWidgetItem(value)
if old_val != val:
self.old_register_values[reg] = val
value.setForeground(QColor(Qt.red))
value.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsEditable)
self.values.setItem(i, 0, name)
self.values.setItem(i, 1, value)
return
def __set_dfa_table(self, state_num, all_chars, dfa, end_state):
show_chars = [] # 将不可打印字符转换
for char in all_chars:
if char == '\n':
show_chars.append('换行符')
elif char == '\t ':
show_chars.append('制表符空格')
elif char == '\0':
show_chars.append('结束符')
else:
show_chars.append(char)
self.__dfa_table.setGeometry(0, bar_height * 2, width * 2 / 3,
height - bar_height * 2)
self.__dfa_table.setHorizontalHeaderLabels(show_chars)
self.__dfa_table.setVerticalHeaderLabels(
[str(idx) for idx in range(0, state_num)]) # 注意str不可少
self.__dfa_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.__dfa_table.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
for idx in range(0, state_num):
if idx in end_state:
self.__dfa_table.verticalHeaderItem(idx).setForeground(
QColor(0, 0, 255))
for idy, char in enumerate(all_chars):
if idx in dfa and char in dfa[idx]:
item = QTableWidgetItem(str(dfa[idx][char]))
if dfa[idx][char] < 0:
item.setForeground(QBrush(QColor(255, 0, 0)))
self.__dfa_table.setItem(idx, idy, item) # 注意item值转换为str
def on_btnSetHeader_clicked(self):
'''
设置表头
表内的每个单元格都是一个QTableWidgetItem对象
QTableWidgetItem对象实例化一共有4种方式
QTableWidgetItem(type: int = QTableWidgetItem.ItemType.Type):构建一个空项
type:默认是0
QTableWidgetItem(str, type: int = QTableWidgetItem.ItemType.Type):构建一个带文本的项
str:字符串
type:是一个int,系统(Qt)保留0~1000,用户自定义需要从1001开始
QTableWidgetItem(QIcon, str, type: int = QTableWidgetItem.ItemType.Type):构建一个带图标和文本的项
QIcon:图标,str:字符串,
QTableWidgetItem(QTableWidgetItem):从other复制项的内容构建一个新项
type 参数主要为为了派生类使用，其类型为枚举类型QTableWidgetItem.ItemType，QTableWidgetItem创建的项使用缺省值QTreeWidgetItem.Type（值为0）。
如果要从QTableWidgetItem派生子类以为应用提供自定义项时，可以为子类定义新类型，以便可以将它们与QTableWidgetItem项区分开来。
需要此功能的子类的构造函数需要使用等于或大于QTableWidgetItem.UserType（对应整型1000）的新类型值。
:return:
'''
headerText = ['姓名','性别','出生日期','民族','是否党员','分数']
self.ui.tableInfo.setColumnCount(len(headerText))#设置列数
for i in range(len(headerText)):
headerItem = QTableWidgetItem(headerText[i])#实例化一个单元格,参数为单元格名称
# print(headerItem.type())
font = headerItem.font()#获取该单元格字体状态
font.setPointSize(11)#为字体设置字号
headerItem.setFont(font)#将字号大小绑定给该单元格
headerItem.setForeground(QBrush(Qt.red))#设置单元格前景色,文字颜色
#将该单元格设置为第i列的表头
self.ui.tableInfo.setHorizontalHeaderItem(i,headerItem)
def show_search_result_on_table(self, ser_results):
# print("\033[1;31m 字体颜色：红色\033[0m")
# if len(ser_results) != 0:
# search_results_one = ser_results[0]
count_row = 1 # 留给英文labels
self.table.setRowCount(len(ser_results) + 1)
for i in ser_results:
search_results_one_sorted = {}
for k, v in self.data_model.items():
search_results_one_sorted[k] = i[k]
count_col = 0
for k, v in search_results_one_sorted.items():
if self.ser_input_content in v:
# ser_input_content_color = "\033[1;31m" + self.ser_input_content + "\033[0m"
# v_split = v.split(self.ser_input_content)
# print(ser_input_content_color)
# v = ser_input_content_color.join(v_split)
# print(v)
# newItem.setBackgroundColor(QColor(0,60,10))
newitem = QTableWidgetItem(v)
newitem.setForeground(QBrush(QColor(255, 0, 0)))
self.table.setItem(count_row, count_col, newitem)
# v_add_color = ""
# for i in v_split:
# v_add_color += i + self.ser_input_content
# self.table.setItem(0, count_col, QTableWidgetItem(str(k)))
# self.table.setEditTriggers(count_row_, 0, QAbstractItemView.NoEditTriggers) # 禁止编辑
else:
newitem = QTableWidgetItem(v)
self.table.setItem(count_row, count_col, newitem)
count_col += 1
# 新插入一行
count_row += 1
def _set_twi(self, row, col, text, bg_color=None, fg_color=None):
twi = QTableWidgetItem(str(text))
if bg_color is not None:
bgb = QBrush(QColor(bg_color), Qt.SolidPattern)
twi.setBackground(bgb)
if fg_color is not None:
fgb = QBrush(QColor(fg_color), Qt.SolidPattern)
twi.setForeground(fgb)
self.ui.tw_flights.setItem(row, col, twi)
def _update_key(self):
"""
Updates the key. Run after the table has been (re)populated.
"""
i = 0
for key in self.color_map.keys():
item = QTableWidgetItem(key)
if self.color_map.get(key):
item.setForeground(QBrush(QColor(self.color_map[key][0])))
item.setBackground(QBrush(QColor(self.color_map[key][1])))
self.ui.keyTableWidget_2.setItem(0, i, item)
i += 1
def update_annotations(self):
"""Update annotations made by the user, including bookmarks and events.
Depending on the settings, it might add the bookmarks to overview and
traces.
"""
start_time = self.parent.overview.start_time
if self.parent.notes.annot is None:
all_annot = []
else:
bookmarks = self.parent.notes.annot.get_bookmarks()
events = self.get_selected_events()
all_annot = bookmarks + events
all_annot = sorted(all_annot, key=lambda x: x['start'])
self.idx_annot_list.clearContents()
self.idx_annot_list.setRowCount(len(all_annot))
lg.info('lenght annotations ' + str(len(all_annot)))
for i, mrk in enumerate(all_annot):
abs_time = (start_time +
timedelta(seconds=mrk['start'])).strftime('%H:%M:%S')
dur = timedelta(seconds=mrk['end'] - mrk['start'])
duration = '{0:02d}.{1:03d}'.format(dur.seconds,
round(dur.microseconds / 1000))
item_time = QTableWidgetItem(abs_time)
item_duration = QTableWidgetItem(duration)
item_name = QTableWidgetItem(mrk['name'])
if mrk in bookmarks:
item_type = QTableWidgetItem('bookmark')
color = self.parent.value('annot_bookmark_color')
else:
item_type = QTableWidgetItem('event')
color = convert_name_to_color(mrk['name'])
item_time.setForeground(QColor(color))
item_duration.setForeground(QColor(color))
item_name.setForeground(QColor(color))
item_type.setForeground(QColor(color))
self.idx_annot_list.setItem(i, 0, item_time)
self.idx_annot_list.setItem(i, 1, item_duration)
self.idx_annot_list.setItem(i, 2, item_name)
self.idx_annot_list.setItem(i, 3, item_type)
# store information about the time as list (easy to access)
annot_start = [ann['start'] for ann in all_annot]
annot_end = [ann['end'] for ann in all_annot]
self.idx_annot_list.setProperty('start', annot_start)
self.idx_annot_list.setProperty('end', annot_end)
if self.parent.traces.data is not None:
self.parent.traces.display_annotations()
self.parent.overview.display_annotations()
def setupMounts(self):
adapter = app.adapterManager[0]
if not adapter.useXwared:
self.tab_mount.setEnabled(False)
return
self.table_mounts.setRowCount(0)
self.table_mounts.clearContents()
mountsMapping = app.adapterManager[0].mountsFaker.getMountsMapping()
for i, mount in enumerate(app.adapterManager[0].mountsFaker.mounts):
self.table_mounts.insertRow(i)
# drive1: the drive letter it should map to, by alphabetical order
drive1 = app.adapterManager[0].mountsFaker.driveIndexToLetter(i)
self.table_mounts.setItem(i, 0, QTableWidgetItem(drive1 + "\\TDDOWNLOAD"))
# mounts = ['/path/to/1', 'path/to/2', ...]
self.table_mounts.setItem(i, 1, QTableWidgetItem(mount))
# drive2: the drive letter it actually is assigned to
drive2 = mountsMapping.get(mount, "无")
errors = []
# check: mapping
if drive1 != drive2:
errors.append(
"错误：盘符映射在'{actual}'，而不是'{should}'。\n"
"如果这是个新挂载的文件夹，请尝试稍等，或重启后端，可能会修复此问题。"
.format(actual = drive2, should = drive1))
brush = QBrush()
if errors:
brush.setColor(Qt.red)
errString = "\n".join(errors)
else:
brush.setColor(Qt.darkGreen)
errString = "正常"
errWidget = QTableWidgetItem(errString)
errWidget.setForeground(brush)
self.table_mounts.setItem(i, 2, errWidget)
del brush, errWidget
self.table_mounts.resizeColumnsToContents()
def set_conflict_tags_table_widget(self):
self.conflict_tag_table_widget.setColumnCount(5)
self.conflict_tag_table_widget.setRowCount(len(self.conflict_tags_message_dict.keys()))
# set table header
self.conflict_tag_table_widget.setHorizontalHeaderItem(0, QTableWidgetItem('标识Id'))
self.conflict_tag_table_widget.setHorizontalHeaderItem(1, QTableWidgetItem('标识名称'))
self.conflict_tag_table_widget.setHorizontalHeaderItem(2, QTableWidgetItem('标识描述'))
self.conflict_tag_table_widget.setHorizontalHeaderItem(3, QTableWidgetItem('现有标识名称'))
self.conflict_tag_table_widget.setHorizontalHeaderItem(4, QTableWidgetItem('现有标识描述'))
self.conflict_tag_table_widget.horizontalHeader().setStyleSheet("QHeaderView::section{background: #ECF5FF;}")
self.conflict_tag_table_widget.horizontalHeader().setStretchLastSection(True)
# set table data
row = 0
for key in self.conflict_tags_message_dict:
conflict_tag = self.conflict_tags_message_dict[key]
self.conflict_tag_table_widget.setItem(row, 0, QTableWidgetItem(str(conflict_tag['id'])))
# tag_name
tag_name_item = QTableWidgetItem(conflict_tag['name'])
tag_name_item.setForeground(Qt.red)
tag_name_item.setFont(QFont("Times", 10, QFont.Black))
self.conflict_tag_table_widget.setItem(row, 1, tag_name_item)
# tag_description
if type(conflict_tag['description']) is float and math.isnan(conflict_tag['description']):
description = ''
else:
description = conflict_tag['description']
self.conflict_tag_table_widget.setItem(row, 2, QTableWidgetItem(description))
src_name_widget_item = QTableWidgetItem(conflict_tag['src_name'])
src_name_widget_item.setFlags(Qt.NoItemFlags)
self.conflict_tag_table_widget.setItem(row, 3, src_name_widget_item)
if type(conflict_tag['src_description']) is float and math.isnan(conflict_tag['src_description']):
src_description = ''
else:
src_description = conflict_tag['src_description']
src_description_widget_item = QTableWidgetItem(src_description)
src_description_widget_item.setFlags(Qt.NoItemFlags)
self.conflict_tag_table_widget.setItem(row, 4, src_description_widget_item)
row += 1
self.conflict_tag_table_widget.setColumnHidden(0, True)
self.conflict_tag_table_widget.setColumnHidden(3, True)
self.conflict_tag_table_widget.setColumnHidden(4, True)
def setupMounts(self):
self.table_mounts.setRowCount(0)
self.table_mounts.clearContents()
permissionCheckResult = app.mountsFaker.permissionCheck()
permissionCheckFailed = ["无法获得检测权限。运行{}查看原因。".format(constants.PERMISSIONCHECK)]
mountsMapping = app.mountsFaker.getMountsMapping()
for i, mount in enumerate(app.mountsFaker.mounts):
# mounts = ['/path/to/1', 'path/to/2', ...]
self.table_mounts.insertRow(i)
self.table_mounts.setItem(i, 0, QTableWidgetItem(mount))
# drive1: the drive letter it should map to, by alphabetical order
drive1 = chr(ord('C') + i) + ":"
self.table_mounts.setItem(i, 1, QTableWidgetItem(drive1))
# drive2: the drive letter it actually is assigned to
drive2 = mountsMapping.get(mount, "无")
# check 1: permission
errors = permissionCheckResult.get(mount, permissionCheckFailed)
# check 2: mapping
if drive1 != drive2:
errors.append(
"警告：盘符映射在'{actual}'，而不是'{should}'。需要重启后端修复。".format(
actual = drive2,
should = drive1))
brush = QBrush()
if errors:
brush.setColor(Qt.red)
errString = "\n".join(errors)
else:
brush.setColor(Qt.darkGreen)
errString = "正常"
errWidget = QTableWidgetItem(errString)
errWidget.setForeground(brush)
self.table_mounts.setItem(i, 2, errWidget)
del brush, errWidget
self.table_mounts.resizeColumnsToContents()
def populate(self):
"""
Populates the table with given string groups
and sets the number of columns.
"""
columns = self.ui.tableWidget_2.width() // 140
logging.debug("columns on resize: " + str(columns))
self._items.clear()
self.ui.tableWidget_2.clear()
self.ui.tableWidget_2.columnWidth(140)
# We build a list of items and set the colors for item.
for key in self._item_dictionary:
for str_item in self._item_dictionary[key]:
item = QTableWidgetItem(str_item)
self._items.append(item)
item.setForeground(QBrush(QColor(self.color_map[key][0])))
item.setBackground(QBrush(QColor(self.color_map[key][1])))
if len(self._items) == 0:
return
self.ui.tableWidget_2.setRowCount(len(self._items)//columns+1)
self.ui.tableWidget_2.setColumnCount(columns)
i = 0
while i < columns:
self.ui.tableWidget_2.setColumnWidth(i, 140)
i += 1
# We set the items to the table.
row = 0
col = 0
for item in self._items:
self.ui.tableWidget_2.setItem(row, col, item)
if col+1 == columns:
col = 0
row += 1
else:
col += 1
self._update_key()
def setupMounts(self):
self.table_mounts.setRowCount(0)
self.table_mounts.clearContents()
PermissionError = self.permissionCheck()
mountsMapping = self.mainWin.mountsFaker.getMountsMapping()
for i, mount in enumerate(self.mainWin.mountsFaker.mounts):
# mounts = ['/path/to/1', 'path/to/2', ...]
self.table_mounts.insertRow(i)
self.table_mounts.setItem(i, 0, QTableWidgetItem(mount))
drive1 = chr(ord('C') + i) + ":" # the drive letter it should map to, by alphabetical order
self.table_mounts.setItem(i, 1, QTableWidgetItem(drive1))
drive2 = mountsMapping.get(mount, "无") # the drive letter it actually is assigned to
# check 1: permission
errors = PermissionError.get(mount, ["无法获得检测权限。运行/opt/xware_desktop/permissioncheck查看原因。"])
# check 2: mapping
if drive1 != drive2:
errors.append("警告：盘符映射在'{actual}'，而不是'{should}'。需要重启后端修复。".format(actual = drive2, should = drive1))
from PyQt5.Qt import Qt
from PyQt5.QtGui import QBrush
brush = QBrush()
if errors:
brush.setColor(Qt.red)
errString = "\n".join(errors)
else:
brush.setColor(Qt.darkGreen)
errString = "正常"
errWidget = QTableWidgetItem(errString)
errWidget.setForeground(brush)
self.table_mounts.setItem(i, 2, errWidget)
del brush, errWidget
self.table_mounts.resizeColumnsToContents()
def updateGrid(self):
emuwin = self.parent.parent
emu = emuwin.emulator
current_mode = emuwin.arch
registers = current_mode.registers
self.values.setRowCount(len(registers))
for i, reg in enumerate(registers):
self.values.setRowHeight(i, self.row_size)
name = QTableWidgetItem(reg)
name.setFlags(Qt.NoItemFlags)
val = emu.get_register_value(reg) if emu.vm else 0
old_val = self.old_register_values.get(reg, 0)
if type(val) in (int, int):
value = format_address(val, current_mode)
else:
value = str(val)
value = QTableWidgetItem( value )
if old_val != val:
self.old_register_values[reg] = val
value.setForeground(QColor(Qt.red))
value.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsEditable)
self.values.setItem(i, 0, name)
self.values.setItem(i, 1, value)
return
def update_dataset_marker(self):
"""Update markers which are in the dataset. It always updates the list
of events. Depending on the settings, it might add the markers to
overview and traces.
"""
start_time = self.parent.overview.start_time
markers = []
if self.parent.info.markers is not None:
markers = self.parent.info.markers
self.idx_marker.clearContents()
self.idx_marker.setRowCount(len(markers))
for i, mrk in enumerate(markers):
abs_time = (start_time +
timedelta(seconds=mrk['start'])).strftime('%H:%M:%S')
dur = timedelta(seconds=mrk['end'] - mrk['start'])
duration = '{0:02d}.{1:03d}'.format(dur.seconds,
round(dur.microseconds / 1000))
item_time = QTableWidgetItem(abs_time)
item_duration = QTableWidgetItem(duration)
item_name = QTableWidgetItem(mrk['name'])
color = self.parent.value('marker_color')
item_time.setForeground(QColor(color))
item_duration.setForeground(QColor(color))
item_name.setForeground(QColor(color))
self.idx_marker.setItem(i, 0, item_time)
self.idx_marker.setItem(i, 1, item_duration)
self.idx_marker.setItem(i, 2, item_name)
# store information about the time as list (easy to access)
marker_start = [mrk['start'] for mrk in markers]
self.idx_marker.setProperty('start', marker_start)
if self.parent.traces.data is not None:
self.parent.traces.display()
self.parent.overview.display_markers()
def initUI(self):
self.setWindowTitle("QTableWidget 例子")
self.resize(430,230);
conLayout = QHBoxLayout()
tableWidget = QTableWidget()
tableWidget.setRowCount(4)
tableWidget.setColumnCount(3)
conLayout.addWidget(tableWidget )
tableWidget.setHorizontalHeaderLabels(['姓名','性别','体重(kg)'])
newItem = QTableWidgetItem("张三")
newItem.setForeground(QBrush(QColor(255, 0, 0)))
tableWidget.setItem(0, 0, newItem)
newItem = QTableWidgetItem("男")
newItem.setForeground(QBrush(QColor(255, 0, 0)))
tableWidget.setItem(0, 1, newItem)
newItem = QTableWidgetItem("160")
newItem.setForeground(QBrush(QColor(255, 0, 0)))
tableWidget.setItem(0, 2, newItem)
self.setLayout(conLayout)
