def set_data(self, linhas):
if not linhas:
logging.info("[ListaPadrao] Nenhum registro encontrado.")
self.tableWidget_tabela.clear()
self.set_columns()
self.tableWidget_tabela.setRowCount(0)
return
self.tableWidget_tabela.setRowCount(len(linhas))
row = 0
for linha in linhas:
col = 0
for coluna in self.colunas:
valor_tratado = self.tratar_valor(linha, coluna)
valor = valor_tratado[0]
alinhamento = valor_tratado[1]
item = QTableWidgetItem(str(valor))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setTextAlignment(alinhamento)
self.tableWidget_tabela.setItem(row, col, item)
col = col + 1
row = row + 1
self.tableWidget_tabela.resizeColumnsToContents()
# Oculta colunas marcadas como not visible
for coluna in self.colunas.values():
self.tableWidget_tabela.setColumnHidden(coluna[3], not coluna[2])
self.dados_lista_relatorio = linhas
def create_cell(self, data: str):
"""Create data cell on UI."""
cell = QTableWidgetItem(data)
cell.setFont(QFont('Free Mono', 11))
cell.setTextAlignment(Qt.AlignVCenter | Qt.AlignHCenter)
return cell
def populate_table(self, table, terminals, nonterminals):
self.parsing_table.insertColumn(0)
for symbol in terminals:
index = self.parsing_table.columnCount()
self.parsing_table.insertColumn(index)
self.map[symbol] = index
self.parsing_table.setHorizontalHeaderLabels([""] + terminals + ["$"])
for key in table.keys():
row = self.parsing_table.rowCount()
self.parsing_table.insertRow(row)
item = QTableWidgetItem(key)
item.setTextAlignment(QtCore.Qt.AlignCenter)
self.parsing_table.setItem(row, 0, item)
for sec_key in table[key].keys():
column = self.map[sec_key]
item = QTableWidgetItem(table[key][sec_key])
item.setTextAlignment(QtCore.Qt.AlignCenter)
self.parsing_table.setItem(row, column, item)
self.parsing_table.horizontalHeader().setSectionResizeMode(
QtWidgets.QHeaderView.ResizeToContents)
self.parsing_table.horizontalHeader().setDefaultAlignment(
QtCore.Qt.AlignHCenter)
def populate_table(self, firsts, follows):
for key in follows.keys():
newRow_index = self.ff_table.rowCount()
self.ff_table.insertRow(newRow_index)
item = QTableWidgetItem(key)
item.setTextAlignment(QtCore.Qt.AlignCenter)
self.ff_table.setItem(newRow_index, 0, item)
label = "{"
for item in firsts[key]:
label = label + item + ", "
label = label[:-2]
label += "}"
self.ff_table.setItem(newRow_index, 1, QTableWidgetItem(label))
label = "{"
for item in follows[key]:
label = label + item + ", "
label = label[:-2]
label += "}"
self.ff_table.setItem(newRow_index, 2, QTableWidgetItem(label))
self.ff_table.horizontalHeader().setSectionResizeMode(
QtWidgets.QHeaderView.ResizeToContents)
self.ff_table.horizontalHeader().setDefaultAlignment(
QtCore.Qt.AlignHCenter)
def setRequiredBlueprints(self):
"""Compute and display required blueprints"""
for i, target_level in enumerate((5, 10, 15, 20, 25, 30)):
req_bp = self.computeRequiredBlueprintsForStrengthenLevel(
target_level, self.researchShipUserData["level"],
self.researchShipUserData["bp"],
self.isDecisiveShip(self.researchShip.Shipfu))
item = QTableWidgetItem(str(req_bp))
item.setTextAlignment(Qt.AlignCenter)
self.strengthenLevelTableWidget.setItem(0, i, item)
if self.hasFateSimulation(self.researchShip):
req_bp_to_level_30 = \
self.computeRequiredBlueprintsForStrengthenLevel(
30,
self.researchShipUserData["level"],
self.researchShipUserData["bp"],
self.isDecisiveShip(self.researchShip.Shipfu))
for target_phase in range(1, 6):
req_bp = self.computeRequiredBlueprintsForFateSimulation(
target_phase,
self.researchShipUserData["fate_simul_phase"],
self.researchShipUserData["bp"])
req_bp += req_bp_to_level_30
item = QTableWidgetItem(str(req_bp))
item.setTextAlignment(Qt.AlignCenter)
self.fateSimulationTableWidget.setItem(0, target_phase - 1,
item)
def refreshTable(self):
global database
self.cuentas = database.getAllAccounts()
self.tabla_cuentas.clearContents()
row = 0
for entry in self.cuentas:
self.tabla_cuentas.setRowCount(row + 1)
item = QTableWidgetItem(entry[1])
item.setTextAlignment(4)
self.tabla_cuentas.setItem(row, 0, QTableWidgetItem(item))
item.setText(entry[2])
self.tabla_cuentas.setItem(row, 1, QTableWidgetItem(item))
item.setText(entry[3])
self.tabla_cuentas.setItem(row, 2, QTableWidgetItem(item))
item.setText(len(entry[4]) * str("*"))
self.tabla_cuentas.setItem(row, 3, QTableWidgetItem(item))
item.setText(entry[5])
self.tabla_cuentas.setItem(row, 4, QTableWidgetItem(item))
item.setText(str(entry[0]))
self.tabla_cuentas.setItem(row, 5, QTableWidgetItem(item))
row += 1
def rows_text_insert(self,
where_to=None,
editable=None,
clickable=None,
alignment=None): # text -> table item
if where_to is None:
where_to = self.rowCount()
if editable is None:
editable = self.col_editable
if clickable is None:
clickable = self.col_clickable
if alignment is None:
alignment = self.col_alignment
n = 0
while True:
to_insert = (yield)
if to_insert is None: # 꼼수
where_to = self.rowCount()
n = 0
continue
self.insertRow(where_to + n)
for col in range(self.columnCount()):
item = QTableWidgetItem(to_insert[col])
if not editable[col]: # false 일때 플래그 제거
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
if not clickable[col]:
item.setFlags(item.flags() ^ Qt.ItemIsEnabled)
if alignment[col]:
item.setTextAlignment(alignment[col]) # ex) Qt.AlignCenter
self.setItem(where_to + n, col, item)
n += 1
def preencher_tabela(self):
self.tableWidget_items.setRowCount(len(self.pedido.itens))
if len(self.pedido.itens) > 0:
row = 0
for item_pedido in self.pedido.itens:
col = 0
for coluna in self.colunas_item:
valor = item_pedido.to_item_dict()[coluna]
if col in (4, 5, 6):
item = QTableWidgetItem(self.formatar_numero(valor))
item.setTextAlignment(Qt.AlignRight)
if col == 4 and item_pedido.alerta != '':
item.setIcon(self.icone_alerta)
item.setToolTip(item_pedido.alerta)
else:
item = QTableWidgetItem(self.formatar_numero(valor))
self.tableWidget_items.setItem(row, col, item)
col = col + 1
row = row + 1
self.tableWidget_items.setColumnHidden(0, True)
self.tableWidget_items.setColumnHidden(1, True)
self.tableWidget_items.resizeColumnsToContents()
self.limpar_item()
def _makewidget(parent, val, center=False):
""" Small helper function that builds a TableWidgetItem and sets up the font the way we want"""
out = QTableWidgetItem(str(val))
out.setFlags(Qt.ItemIsEnabled)
out.setFont(getMonospaceFont(parent))
if center:
out.setTextAlignment(Qt.AlignCenter)
return out
def generateIdField(id=''):
"""
@rtype: QTableWidgetItem
"""
idField = QTableWidgetItem(str(id))
idField.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
idField.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
return idField
def show_files_after_swapping(self):
files_list = GlobalSetting.CHAPTER_FILES_LIST
for i in range(len(files_list)):
if files_list[i] != self.current_files_list[i]:
item = QTableWidgetItem(" " + files_list[i])
self.table.setItem(i, 0, item)
item = QTableWidgetItem(str(i + 1))
item.setTextAlignment(Qt.AlignCenter)
self.table.setVerticalHeaderItem(i, item)
self.current_files_list[i] = files_list[i]
def fill_table(self, data=None):
data = self._data if not data else data
for step, v_ntot in zip(data['Step'], data['v_ntot']):
step_item = QTableWidgetItem("{:.2f}".format(step))
vntot_item = QTableWidgetItem("{:.2f}".format(v_ntot))
vntot_item.setTextAlignment(Qt.AlignRight)
self.table.insertRow(self.items)
self.table.setItem(self.items, 0, step_item)
self.table.setItem(self.items, 1, vntot_item)
self.items += 1
def fill_table(self, data=None):
data = self._data if not data else data
for desc, price in data.items():
description_item = QTableWidgetItem(desc)
price_item = QTableWidgetItem("{:.2f}".format(price))
price_item.setTextAlignment(Qt.AlignRight)
self.table.insertRow(self.items)
self.table.setItem(self.items, 0, description_item)
self.table.setItem(self.items, 1, price_item)
self.items += 1
def show_files(self):
files_list = GlobalSetting.CHAPTER_FILES_LIST
self.table.setRowCount(len(files_list))
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
for i in range(len(files_list)):
item = QTableWidgetItem(" " + files_list[i])
self.table.setItem(i, 0, item)
item = QTableWidgetItem(str(i + 1))
item.setTextAlignment(Qt.AlignCenter)
self.table.setVerticalHeaderItem(i, item)
self.current_files_list = files_list[:] # for copy the rel elements not refrences
def write(row: int, col: int, value: str):
if isinstance(value, str):
pass
elif isinstance(value, int):
value = str(value)
elif isinstance(value, float):
value = f"{value: 0.2f}"
else:
value = value.__str__()
item = QTableWidgetItem(value)
item.setTextAlignment(Qt.AlignCenter)
self.data_table.setItem(row, col, item)
def show_paramlist(self):
"""Show the list of currently set parameters.
"""
self.parent.dialog = QDialog(self.parent)
table = QTableWidget()
vbox = QVBoxLayout()
self.parent.dialog.setLayout(vbox)
self.parent.dialog.setWindowTitle("Parameters list")
header = ["param", "min", "max", "step", "default"]
lst = []
for key, val in self.parent.current_params.items():
sub = []
sub.append(key)
for head in header:
if head in val:
sub.append(val[head])
lst.append(sub)
table.setColumnCount(len(header))
table.setRowCount(len(self.parent.current_params))
table.setHorizontalHeaderLabels(header)
table.verticalHeader().setVisible(False)
table.setAlternatingRowColors(True)
table.horizontalHeader().setStretchLastSection(True)
table.setEditTriggers(QAbstractItemView.NoEditTriggers)
table.setFocusPolicy(Qt.NoFocus)
for row, content in enumerate(lst):
for col, elem in enumerate(content):
item = QTableWidgetItem(str(elem))
item.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsDragEnabled | Qt.ItemIsUserCheckable
| Qt.ItemIsEnabled)
table.setItem(row, col, item)
table.resizeColumnsToContents()
table.resizeRowsToContents()
table.setColumnWidth(0, 250)
table.setColumnWidth(1, 80)
table.setColumnWidth(2, 80)
table.setColumnWidth(3, 80)
table.setColumnWidth(4, 80)
button = QPushButton("&Ok")
button.clicked.connect(self.close)
button.setAutoDefault(True)
vbox.addWidget(table)
vbox.addWidget(button)
self.parent.dialog.resize(640, 480)
ret = self.parent.dialog.exec_()
def loadStudyData(self):
"""
Function for loading data from our database and
into the application
Parameters
----------
database : [SQL Lite Object]
Database object that we connect to it
through the db_model
Return
----------
None
"""
# initialize ui
ui = self.ui
helper = self.helper
tasks = helper.select_from_db(
"""SELECT task_name, study_time, notes FROM to_do_tasks""")
for row_number, task in enumerate(tasks):
# insert rows into the application for as
# many tasks as we have
ui.studyWidget.insertRow(row_number)
# loop through the task to get the amount of columns
# since we have rows and columns we insert data
# piece by piece
for column_number, data in enumerate(task):
# store the data the appropriate object
# numerics don't get viewed properly in tablewidget items
cell = QTableWidgetItem()
cell.setText(data)
cell.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
# disable functionality for all cells except the notes cell
# and also edit the alignment for the notes
if column_number == 2:
cell.setTextAlignment(Qt.AlignLeft | Qt.AlignTop)
else:
# disable options
cell.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
# add the data into the cell
ui.studyWidget.setItem(row_number, column_number, cell)
# Load finished task functionality into the table
finishedTask = QPushButton('Finished Task')
finishedTask.clicked.connect(self.levelMessageBox)
ui.studyWidget.setCellWidget(
row_number, 3, finishedTask)\
def update_table_item(self, row, timelog_info):
column = -1
for timelog in timelog_info:
column += 1
item = QTableWidgetItem()
item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEditable)
if column == 2:
timelog += " hour"
item.setText(timelog)
if not column == 3:
item.setTextAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignVCenter)
self.tableWidgetTimelog.setItem(row, column, item)
def _table_item(text='', center=True):
item = QTableWidgetItem(text)
font = QFont()
if center: # 행번호
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.NoItemFlags)
item.setFont(font)
font.setPointSize(7)
else:
item.setFlags(Qt.NoItemFlags)
item.setFont(font)
font.setPointSize(9)
return item
def show_data_in_table(self, show_data, header_keys):
""" 将数据在表格中展示出来 """
self.data_table.clear()
self.data_table.setRowCount(0)
self.data_table.setColumnCount(0)
self.tips_animation_timer.stop() # 停止计时
self.timeout_count = 0 # 计数归0
self.tip_label.setText("获取结果成功! ")
# 生成表格的列头
self.data_table.setColumnCount(len(header_keys) * 2)
interval_day = self.interval_days.value()
for count in range(2):
for index, h_key in enumerate(header_keys):
if index == 0:
item = QTableWidgetItem('品种')
elif index == 1:
item = QTableWidgetItem(h_key)
else:
item = QTableWidgetItem(
str((index - 1) * interval_day) + "天前")
setattr(item, 'key', h_key)
self.data_table.setHorizontalHeaderItem(
index + count * len(header_keys), item)
is_pre_half = True
for variety, variety_values in show_data.items():
row = self.data_table.rowCount()
if is_pre_half:
col_start = 0
col_end = len(header_keys)
self.data_table.insertRow(row)
self.data_table.setRowHeight(row, 10)
else:
row -= 1
col_start = len(header_keys)
col_end = self.data_table.columnCount()
for col in range(col_start, col_end):
data_key = getattr(self.data_table.horizontalHeaderItem(col),
'key')
if col == col_start:
v_zh = VARIETY_ZH.get(variety_values['variety_en'],
variety_values['variety_en'])
item = QTableWidgetItem(v_zh)
item.setForeground(QBrush(QColor(180, 60, 60)))
else:
item = QTableWidgetItem(
str(int(variety_values.get(data_key, 0))))
item.setTextAlignment(Qt.AlignCenter)
self.data_table.setItem(row, col, item)
is_pre_half = not is_pre_half
def add_element(self, port, service):
self.table.insertRow(self.items)
port_item = QTableWidgetItem(str(port))
port_item.setTextAlignment(Qt.AlignCenter)
port_item.setFlags(port_item.flags() ^ Qt.ItemIsEditable)
service_item = QTableWidgetItem(str(service))
service_item.setFlags(service_item.flags() ^ Qt.ItemIsEditable)
service_item.setToolTip("Open in Exploit-db")
self.table.setItem(self.items, 0, port_item)
self.table.setItem(self.items, 1, service_item)
self.items += 1
def set_string_list_value(self, value: typing.List[typing.Any]):
if not isinstance(value, list):
raise ValueError('Only Support List Type Value')
if len(value) != self.column_count:
raise ValueError('Value Length Must Equal to TableWidget Column Count')
self.row_count += 1
for col in range(self.column_count):
table_item = QTableWidgetItem(str(value[col]))
table_item.setTextAlignment(Qt.AlignCenter)
self.setItem(self.row_count - 1, col, table_item)
self.index.value = self.row_count - 1
self.auto_resize_column_width()
self.string_list.check_change()
def add_element(self, status_code, url):
self.table.insertRow(self.items)
status_code_item = QTableWidgetItem(str(status_code))
status_code_item.setTextAlignment(Qt.AlignCenter)
status_code_item.setFlags(status_code_item.flags() ^ Qt.ItemIsEditable)
url_item = QTableWidgetItem(url)
url_item.setFlags(url_item.flags() ^ Qt.ItemIsEditable)
url_item.setToolTip("Open in Browser")
self.table.setItem(self.items, 0, status_code_item)
self.table.setItem(self.items, 1, url_item)
self.items += 1
def displayNeededExp(self):
currentLevel = self.currentLevelSpinBox.value()
currentExp = self.currentExpSpinBox.value()
realLevel = self.computeRealLevel(currentLevel, currentExp)
self.realLevelLabel.setText(str(realLevel))
for i, targetLevel in enumerate((100, 105, 110, 115, 120)):
neededExp = self.computeNeededExpForLevel(
targetLevel, currentLevel, currentExp)
item = QTableWidgetItem(f"{neededExp:,}".replace(',', ' '))
item.setTextAlignment(Qt.AlignCenter)
self.tableWidget.setItem(0, i, item)
def create_table(self):
# Create the table if files have successfully been selected
if not len(self.files):
return
if self.ext in YAML_EXTS:
table_files = self.yml_files
else:
table_files = self.files
self.ui.file_options.setRowCount(
len(table_files[self.idx]))
# Create the rows
for row in range(self.ui.file_options.rowCount()):
for column in range(self.ui.file_options.columnCount()):
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignCenter)
self.ui.file_options.setItem(row, column, item)
self.ui.file_options.blockSignals(True)
# Populate the rows
for i in range(self.ui.file_options.rowCount()):
curr = table_files[self.idx][i]
self.ui.file_options.item(i, 0).setText(Path(curr).name)
self.ui.file_options.item(i, 1).setText(str(self.empty_frames))
self.ui.file_options.item(i, 2).setText(str(self.total_frames[i]))
self.ui.file_options.item(i, 3).setText(str(self.omega_min[i]))
self.ui.file_options.item(i, 4).setText(str(self.omega_max[i]))
self.ui.file_options.item(i, 5).setText(
str(self.total_frames[i] - self.empty_frames))
# Set tooltips
self.ui.file_options.item(i, 0).setToolTip(Path(curr).name)
self.ui.file_options.item(i, 3).setToolTip('Start must be set')
self.ui.file_options.item(i, 4).setToolTip('Stop must be set')
self.ui.file_options.item(i, 5).setToolTip('Number of steps')
# Don't allow editing of file name or total frames
self.ui.file_options.item(i, 0).setFlags(Qt.ItemIsEnabled)
self.ui.file_options.item(i, 2).setFlags(Qt.ItemIsEnabled)
self.ui.file_options.item(i, 5).setFlags(Qt.ItemIsEnabled)
# If raw data offset can only be changed in YAML file
if self.ext in YAML_EXTS:
self.ui.file_options.item(i, 1).setFlags(Qt.ItemIsEnabled)
self.ui.file_options.blockSignals(False)
self.ui.file_options.resizeColumnsToContents()
self.ui.file_options.sortByColumn(0, Qt.AscendingOrder)
def add_element(self):
des=self.description.text()
price=self.price.text()
self.table.insertRow(self.items)
description_item = QTableWidgetItem(des)
price_item = QTableWidgetItem("{:.2f}".format(float(price)))
price_item.setTextAlignment(Qt.AlignRight)
self.table.setItem(self.items, 0, description_item)
self.table.setItem(self.items, 1, price_item)
self.description.setText("")
self.price.setText("")
self.items+=1
def setVerticalHeaderItems(self, type):
"""
Sets the vertical header items.
"""
parameter = self.headerItemDefaultParameter(type)
for row in range(0, self.rowCount()):
number = row
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignCenter)
item.setText(self.headerItemText(number, type, parameter))
self.setVerticalHeaderItem(row, item)
def setHorizontalHeaderItems(self, type):
"""
Sets the horizontal header items.
"""
parameter = self.headerItemDefaultParameter(type)
for column in range(0, self.columnCount()):
number = column
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignCenter)
item.setText(self.headerItemText(number, type, parameter))
self.setHorizontalHeaderItem(column, item)
def displayStats(self, *args, **kwargs):
self.table.setRowCount(0)
stats = self.getStats()
for key, val in stats.iteritems():
self.table.insertRow(0)
i1 = QTableWidgetItem(key) # parameter
i2 = QTableWidgetItem(str(val)) # value
i1.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
i2.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
i1.setTextAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter
| QtCore.Qt.AlignCenter)
i2.setTextAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter
| QtCore.Qt.AlignCenter)
self.table.setItem(0, 0, i1)
self.table.setItem(0, 1, i2)
def show_table_fill_contents(self, headers, contents):
""" 查询到的数据填到表格中 """
self.show_table.setColumnCount(len(headers))
self.show_table.setRowCount(len(contents))
headers_keys = list()
headers_labels = list()
for key, value in headers.items():
headers_keys.append(key)
headers_labels.append(value)
self.show_table.setHorizontalHeaderLabels(headers_labels)
for row, row_item in enumerate(contents):
self.show_table.setRowHeight(row, 20)
for col, value_key in enumerate(headers_keys):
item = QTableWidgetItem(str(row_item[value_key]))
item.setTextAlignment(Qt.AlignCenter)
self.show_table.setItem(row, col, item)
def __init__(self, messages, hiddenLifelines, parent = None):
super(HiddenMessageDialog, self).__init__(parent)
self.lifelineList = hiddenLifelines
self.msgList = messages
layout = QVBoxLayout(self)
listTitle = QLabel('Hidden Messages')
layout.addWidget(listTitle)
self.listHiddenMessages = QTableWidget(len(self.msgList),4)
self.listHiddenMessages.setHorizontalHeaderLabels(['Index','Name','Departure','Destination'])
self.listHiddenMessages.setFixedWidth(400)
#self.listHiddenMessages.setSelectionMode(QtGui.QAbstractItemView.MultiSelection)
self.listHiddenMessages.setSelectionBehavior(QAbstractItemView.SelectRows)
for idx, msg in enumerate(self.msgList):
self.listHiddenMessages.setItem(idx,0,QTableWidgetItem("%d" % msg['messageindex']))
self.listHiddenMessages.setItem(idx,1,QTableWidgetItem(msg['message']))
item = QTableWidgetItem(msg['departure']['class'])
item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignRight)
if msg['departure']['class'] in self.lifelineList:
item.setForeground(QColor(200,200,200))
self.listHiddenMessages.setItem(idx,2,item)
item = QTableWidgetItem(msg['dest'])
item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignRight)
if msg['dest'] in self.lifelineList:
item.setForeground(QColor(200,200,200))
self.listHiddenMessages.setItem(idx,3,item)
layout.addWidget(self.listHiddenMessages)
buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, QtCore.Qt.Horizontal, self)
buttons.button(QDialogButtonBox.Ok).setText('Show')
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
layout.addWidget(buttons)
