def mostrar_tabla(self):
self.ui.tabla.setColumnCount(9)
headers = [
"Id", "Origen x", "Origen y", "Destino x", "Destino y",
"Velocidad", "Red", "Green", "Blue"
]
self.ui.tabla.setHorizontalHeaderLabels(headers)
self.ui.tabla.setRowCount(len(self.libreria))
row = 0
for particula in self.libreria:
id_widget = QTableWidgetItem(particula.id)
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(particula.velocidad)
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
self.ui.tabla.setItem(row, 0, id_widget)
self.ui.tabla.setItem(row, 1, origen_x_widget)
self.ui.tabla.setItem(row, 2, origen_y_widget)
self.ui.tabla.setItem(row, 3, destino_x_widget)
self.ui.tabla.setItem(row, 4, destino_y_widget)
self.ui.tabla.setItem(row, 5, velocidad_widget)
self.ui.tabla.setItem(row, 6, red_widget)
self.ui.tabla.setItem(row, 7, green_widget)
self.ui.tabla.setItem(row, 8, blue_widget)
row += 1
def buscar_id(self):
id = self.ui.buscar_lineEdit.text()
encontrado = False
for particula in self.libreria:
if id == particula.id:
self.ui.tabla.clear()
self.ui.tabla.setRowCount(1)
id_widget = QTableWidgetItem(particula.id)
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(particula.velocidad)
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
self.ui.tabla.setItem(0, 0, id_widget)
self.ui.tabla.setItem(0, 1, origen_x_widget)
self.ui.tabla.setItem(0, 2, origen_y_widget)
self.ui.tabla.setItem(0, 3, destino_x_widget)
self.ui.tabla.setItem(0, 4, destino_y_widget)
self.ui.tabla.setItem(0, 5, velocidad_widget)
self.ui.tabla.setItem(0, 6, red_widget)
self.ui.tabla.setItem(0, 7, green_widget)
self.ui.tabla.setItem(0, 8, blue_widget)
encontrado = True
return
if not encontrado:
QMessageBox.warning(
self, "Atención",
f'La particula con id "{id}" no fue encontrada')
def ajoutKeyWord(self):
keyW = self.ui.lEKeyWord.text()
if self.ui.tWKeyWord.rowCount() == 0:
self.ui.tWKeyWord.insertRow(0)
self.ui.tWKeyWord.setItem(0, 0, QTableWidgetItem(keyW))
else:
lgTable = self.ui.tWKeyWord.rowCount()
print(lgTable)
self.ui.tWKeyWord.insertRow(lgTable)
self.ui.tWKeyWord.setItem(lgTable, 0, QTableWidgetItem(keyW))
self.ui.lEKeyWord.clear()
def draw(self):
# Create widgets, table and configure them.
self.update_button = QPushButton("Refresh")
self.options_button = QPushButton("Configure")
self.refresh_bool = QCheckBox("Automatically refresh?")
self.refresh_freq = QComboBox()
self.refresh_freq.addItem("1 hour")
self.refresh_freq.addItem("6 hours")
self.refresh_freq.addItem("12 hour")
self.refresh_freq.addItem("24 hour")
self.refresh_freq.addItem("3 days")
self.refresh_freq.addItem("7 days")
self.refresh_bool.nextCheckState()
button_width = 150
button_height = 20
combo_box_width = 150
combo_box_height = 20
self.update_button.setStyleSheet("max-width:%dpx;height:%dpx;" %
(button_width, button_height))
self.options_button.setStyleSheet("max-width:%dpx;height:%dpx;" %
(button_width, button_height))
self.refresh_freq.setStyleSheet("max-width:%dpx;height:%dpx;" %
(combo_box_width, combo_box_height))
self.tableWidget = QTableWidget(1, 3)
self.tableWidget.setHorizontalHeaderItem(0, QTableWidgetItem('Ship'))
self.tableWidget.setHorizontalHeaderItem(1, QTableWidgetItem('Price'))
self.tableWidget.setHorizontalHeaderItem(
2, QTableWidgetItem('Availability'))
# Size columns.
header = self.tableWidget.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.Stretch)
header.setSectionResizeMode(1, QHeaderView.ResizeToContents)
header.setSectionResizeMode(2, QHeaderView.ResizeToContents)
# Set layout and add widgets to it.
self.layout = QVBoxLayout()
self.layout.addWidget(self.tableWidget)
self.layout.addWidget(self.update_button, 0)
# self.layout.addWidget(self.options_button, 1)
self.setLayout(self.layout)
# Connecting the signal.
self.update_button.clicked.connect(self.refresh)
#TODO self.options_button.clicked.connect(self.show_options)
# Draw the UI to the screen.
self.resize(600, 1400)
self.setWindowTitle("Star Citizen Ship Prices")
self.show()
def widgets(self):
widgets = [
QTableWidgetItem(self.bv.args[0]),
QTableWidgetItem(str(self.bv.length)),
]
for w in widgets:
w.setFlags(w.flags() & ~Qt.ItemIsEditable)
w.setForeground(QColor(0, 0, 0))
return widgets
def funcSearchFacilities(self):
value = self.searchFacilitesEntry.text()
if value == "":
QMessageBox.information(self, "Warning",
"Search string cannot be empty")
self.displayFacilities()
else:
# Erase search entry
self.searchFacilitesEntry.setText("")
try:
query = "SELECT * FROM facilities WHERE " \
"facility_id LIKE ? " \
"OR facility_name LIKE ?" \
"OR facility_location LIKE ?" \
"OR facility_phone LIKE ?" \
"OR facility_email LIKE ?" \
"OR facility_supervisor LIKE ?"
results = db.cur.execute(
query, ('%' + value + '%', '%' + value + '%',
'%' + value + '%', '%' + value + '%',
'%' + value + '%', '%' + value + '%')).fetchall()
if results == []:
QMessageBox.information(self, "Info", "Nothing was found")
self.funcDisplayFacilities()
else:
for i in reversed(range(self.facilitiesTable.rowCount())):
self.facilitiesTable.removeRow(i)
for row_data in results:
row_number = self.facilitiesTable.rowCount()
self.facilitiesTable.insertRow(row_number)
# Add checkboxes to the table
qwidget = QWidget()
checkbox = QCheckBox()
checkbox.setCheckState(Qt.Unchecked)
qhboxlayout = QHBoxLayout(qwidget)
qhboxlayout.addWidget(checkbox)
qhboxlayout.setAlignment(Qt.AlignCenter)
self.facilitiesTable.setCellWidget(
row_number, 0, qwidget)
self.facilitiesTable.setItem(
row_number, 0, QTableWidgetItem(row_number))
for column_number, data in enumerate(row_data,
start=1):
if column_number == 1:
self.facilitiesTable.setItem(
row_number, column_number,
QTableWidgetItem("FCL#" + str(data)))
else:
self.facilitiesTable.setItem(
row_number, column_number,
QTableWidgetItem(str(data)))
except:
QMessageBox.information(self, "Info", "Cannot access database")
def addToTable():
row = self.sorder.twBudget.rowCount()+1
self.sorder.twBudget.setRowCount(row)
desc = self.sorder.cbAddDesc.currentText()
amount = self.sorder.spAddAmount.value()
pvalue = self.sorder.spAddValue.value()
svalue = amount * pvalue
self.sorder.twBudget.setItem(row-1, 0, QTableWidgetItem(desc))
self.sorder.twBudget.setItem(row-1, 1, QTableWidgetItem(str(amount)))
self.sorder.twBudget.setItem(row-1, 2, QTableWidgetItem(str(pvalue)))
self.sorder.twBudget.setItem(row-1, 3, QTableWidgetItem(str(svalue)))
def _fill_list_with_joints(self, controller):
#self.jointTableWidget.clear()
for joint_name in controller.get_animated_joints():
insertRow = self.jointTableWidget.rowCount()
self.jointTableWidget.insertRow(insertRow)
indexItem = QTableWidgetItem("")
indexItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
indexItem.setCheckState(Qt.Unchecked)
self.jointTableWidget.setItem(insertRow, 0, indexItem)
self.jointTableWidget.setItem(insertRow, 1,
QTableWidgetItem(str(joint_name)))
def recalculation(self, data):
for i in range(len(data[0])):
cost = float(data[0][i])
count = float(data[1][i])
koef = float(data[2][i])
calc = str(round(cost * count * koef, 1))
self.setItem(i, 6, QTableWidgetItem(calc.replace('.', ',')))
self.setItem(
i, 7,
QTableWidgetItem(
str(round(float(calc) * 1.2, 1)).replace('.', ',')))
def widgets(self):
widgets = [
QTableWidgetItem(self.key),
QTableWidgetItem(self.friendly_value()),
]
for w in widgets:
w.setFlags(w.flags() & ~Qt.ItemIsEditable)
return widgets
def fill_pd_gain_table(self):
self.pdGainTableWidget.clear()
self.pdGainTableWidget.setRowCount(0)
for j in self._figure_controller.pd_gains:
kp = self._figure_controller.pd_gains[j]["kp"]
kd = self._figure_controller.pd_gains[j]["kd"]
row = self.pdGainTableWidget.rowCount()
self.pdGainTableWidget.insertRow(row)
self.pdGainTableWidget.setItem(row, 0, QTableWidgetItem(j))
self.pdGainTableWidget.setItem(row, 1, QTableWidgetItem(str(kp)))
self.pdGainTableWidget.setItem(row, 2, QTableWidgetItem(str(kd)))
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 init_ui(self):
#Add addtional UI setting
self.ui.tableWidget_categories.setColumnCount(2)
self.ui.tableWidget_categories.setColumnWidth(0, 30)
self.ui.tableWidget_categories.setColumnWidth(1, 98)
self.ui.tableWidget_categories.insertRow(0)
self.ui.tableWidget_categories.setSpan(0, 0, 1, 2)
first_row = QTableWidgetItem(" Category Name")
first_row.setFlags(False)
self.ui.tableWidget_categories.setItem(0, 0, first_row)
self.ui.tableWidget_categories.setVerticalHeaderItem(
0, QTableWidgetItem(""))
def set_item(self, account: dict):
for k, v in account.items():
if k not in G.account_row_map:
row = self.row
G.account_row_map.append(k)
self.tableWidget.insertRow(row)
self.row += 1
else:
row = G.account_row_map.index(k)
key = key_zn(k)
self.tableWidget.setItem(row, 0, QTableWidgetItem(key))
self.tableWidget.setItem(row, 1, QTableWidgetItem(str(v)))
def start_download(self):
row_position = self.tableWidget.rowCount()
self.tableWidget.insertRow(row_position)
self.tableWidget.setItem(row_position,0,
QTableWidgetItem(self.url_input.text()))
self.tableWidget.setItem(row_position,1,
QTableWidgetItem("0%"))
downloader = DownloadThread(self.location_input.text() or os.getcwd(),
self.url_input.text(), row_position)
downloader.data_downloaded.connect(self.on_data_ready)
self.threads.append(downloader)
downloader.start()
def setExistencias(self):
headers = ['Libro', 'Sucursal', 'Existencia']
self.ui.table_existencia.setRowCount(len(self.existencias))
self.ui.table_existencia.setColumnCount(len(headers))
self.ui.table_existencia.setHorizontalHeaderLabels(headers)
for row, existencia in enumerate(self.existencias):
self.ui.table_existencia.setItem(
row, 0, QTableWidgetItem(existencia['libro']))
self.ui.table_existencia.setItem(
row, 1, QTableWidgetItem(existencia['sucursal']))
self.ui.table_existencia.setItem(
row, 2, QTableWidgetItem(str(existencia['existencia'])))
def setSucursales(self):
headers = ['Nombre', 'Direccion', 'Telefono']
self.ui.table_sucursal.setRowCount(len(self.sucursales))
self.ui.table_sucursal.setColumnCount(len(headers))
self.ui.table_sucursal.setHorizontalHeaderLabels(headers)
for row, sucursal in enumerate(self.sucursales):
self.ui.table_sucursal.setItem(
row, 0, QTableWidgetItem(sucursal['nombre']))
self.ui.table_sucursal.setItem(
row, 1, QTableWidgetItem(sucursal['direccion']))
self.ui.table_sucursal.setItem(
row, 2, QTableWidgetItem(str(sucursal['telefono'])))
def write_to_table(self):
row_count = 0
self.tableWidget.setRowCount(len(self.ship_list_table()))
for row in self.ship_list_table():
self.tableWidget.setItem(row_count, 0, QTableWidgetItem(row[0]))
self.tableWidget.setItem(row_count, 1, QTableWidgetItem(row[1]))
self.tableWidget.setItem(row_count, 2, QTableWidgetItem(row[2]))
row_count = row_count + 1
if row_count <= len(self.ship_list_table()):
return True
else:
return False
def update_table(self):
self.table.clearContents()
while self.table.rowCount() > 0:
self.table.removeRow(0)
for book in self.books.keys():
row = self.table.rowCount()
button = QPushButton('Rimuovi')
button.clicked.connect(lambda: self.remove_libro(book))
self.table.insertRow(row)
self.table.setItem(row, 0, QTableWidgetItem(book))
self.table.setItem(row, 1, QTableWidgetItem(str(self.books[book])))
self.table.setCellWidget(row, 2, button)
def update_animation_controller_list(self):
self.animationControllerTableWidget.setRowCount(0)
if self._controller is None:
return
positions = self._controller.get_blend_positions()
for name, position in positions.items():
row = self.animationControllerTableWidget.rowCount()
self.animationControllerTableWidget.insertRow(row)
name_item = QTableWidgetItem(str(name))
position_item = QTableWidgetItem(str(position))
self.animationControllerTableWidget.setItem(row, 0, name_item)
self.animationControllerTableWidget.setItem(row, 1, position_item)
def widgets(self):
widgets = [
QTableWidgetItem(self.plugin),
QTableWidgetItem(self.kind),
QTableWidgetItem(self.image_id),
QTableWidgetItem(self.msg),
]
for w in widgets:
w.setFlags(w.flags() & ~Qt.ItemIsEditable)
return widgets
def show_songs(self):
for i, (tid, info) in enumerate(self.songs_info.items()):
self.songs_table_widget.insertRow(i)
item1 = QTableWidgetItem(info['name'])
item1.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.songs_table_widget.setItem(i, 0, item1)
item2 = QTableWidgetItem(info['file_path'])
item2.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.songs_table_widget.setItem(i, 1, item2)
self.show()
def _init_widgets(self):
_l.debug("QPOI Viewer Initiating")
self.tabView = QTabWidget() # QGraphicsView()
self.tabView.setContentsMargins(0, 0, 0, 0)
#
# POI trace Tab
#
self.POITraceTab = QWidget()
self.POITraceTab.setContentsMargins(0, 0, 0, 0)
singleLayout = QVBoxLayout()
singleLayout.setSpacing(0)
singleLayout.setContentsMargins(0, 0, 0, 0)
self.traceView = QGraphicsView()
self.traceScene = QGraphicsScene()
self.traceView.setScene(self.traceScene)
singleLayout.addWidget(self.traceView)
self.POITraceTab.setLayout(singleLayout)
#
# multiPOI Tab
#
self.multiPOITab = QMultiPOITab(self)
# self.multiPOITab = QWidget()
multiLayout = QVBoxLayout()
multiLayout.setSpacing(0)
multiLayout.setContentsMargins(0, 0, 0, 0)
self.multiPOIList = QTableWidget(0, 4) # row, col
self.multiPOIList.setHorizontalHeaderItem(0, QTableWidgetItem("ID"))
self.multiPOIList.setHorizontalHeaderItem(1, QTableWidgetItem("Crash Point"))
self.multiPOIList.setHorizontalHeaderItem(2, QTableWidgetItem("Tag"))
self.multiPOIList.setHorizontalHeaderItem(3, QTableWidgetItem("Diagnose"))
self.multiPOIList.horizontalHeader().setStretchLastSection(True)
self.multiPOIList.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.multiPOIList.setSelectionBehavior(QAbstractItemView.SelectRows)
multiLayout.addWidget(self.multiPOIList)
self.multiPOITab.setLayout(multiLayout)
self.tabView.addTab(self.multiPOITab, "POI List")
self.tabView.addTab(self.POITraceTab, "POI Trace")
self.POI_TRACE = 1
self.MULTI_POI = 0
layout = QVBoxLayout()
layout.addWidget(self.tabView)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.show()
def add_element(self):
des = self.description.text()
price = self.price.text()
self.table.insertRow(self.items)
self.table.setItem(self.items, 0, QTableWidgetItem(des))
self.table.setItem(self.items, 1, QTableWidgetItem(price))
self.description.setText("")
self.price.setText("")
self.items += 1
def buscar_id(self):
# print("buscar")
id = self.ui.buscar_lineEdit.text(
) #obtener la informacion introducida en el lineEdit
encontrado = False #bandera
for particula in self.contenedor_particulas:
if id == particula.id: #Si el id introducido en el lineEdit es igual al de la particula
#Limpiar la tabla, si se encuentra la particula
# (Si hay info. en la tabla, la limpia e inserta la encontrada)
self.ui.tabla.clear()
self.ui.tabla.setRowCount(
1) #la tabla va a tener una sola fila
#insertar la particula en la tabla
#Cada atributo debe ser un Item, para poder meterlos a la tabla(construir los widgets)
#convertirlos a strings porque son enteros
id_widget = QTableWidgetItem(str(particula.id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
distancia_widget = QTableWidgetItem(str(particula.distancia))
#Meter los items en cada columna que le corresponde
self.ui.tabla.setItem(0, 0, id_widget)
self.ui.tabla.setItem(0, 1, origen_x_widget)
self.ui.tabla.setItem(0, 2, origen_y_widget)
self.ui.tabla.setItem(0, 3, destino_x_widget)
self.ui.tabla.setItem(0, 4, destino_y_widget)
self.ui.tabla.setItem(0, 5, velocidad_widget)
self.ui.tabla.setItem(0, 6, red_widget)
self.ui.tabla.setItem(0, 7, green_widget)
self.ui.tabla.setItem(0, 8, blue_widget)
self.ui.tabla.setItem(0, 9, distancia_widget)
#Si encontro la particula
encontrado = True
return #Para que no siga buscando
if not encontrado:
QMessageBox.warning(
self,
"Atención", #Nombre de la advertencia
f'La particula con el ID "{id}", no fue encontrado' #f -> formato y "{variable}", podemos poner variables
#externas en los strings
)
def update_locations(self):
self.locations_table.setUpdatesEnabled(False)
self.locations_table.setRowCount(0)
for i in range(2):
if i == 0:
if self.scope() == QSettings.SystemScope:
continue
actualScope = QSettings.UserScope
else:
actualScope = QSettings.SystemScope
for j in range(2):
if j == 0:
if not self.application():
continue
actualApplication = self.application()
else:
actualApplication = ''
settings = QSettings(self.format(), actualScope,
self.organization(), actualApplication)
row = self.locations_table.rowCount()
self.locations_table.setRowCount(row + 1)
item0 = QTableWidgetItem()
item0.setText(settings.fileName())
item1 = QTableWidgetItem()
disable = not (settings.childKeys() or settings.childGroups())
if row == 0:
if settings.isWritable():
item1.setText("Read-write")
disable = False
else:
item1.setText("Read-only")
self.button_box.button(QDialogButtonBox.Ok).setDisabled(disable)
else:
item1.setText("Read-only fallback")
if disable:
item0.setFlags(item0.flags() & ~Qt.ItemIsEnabled)
item1.setFlags(item1.flags() & ~Qt.ItemIsEnabled)
self.locations_table.setItem(row, 0, item0)
self.locations_table.setItem(row, 1, item1)
self.locations_table.setUpdatesEnabled(True)
def table_setup(self, series, item):
"""Generates table elements based on series.
Clears any existing elements in the table, then uses series to
generate a two-column table, with headings in the first column
and data in the second. The first column is not editable,
and the second column is editable.
"""
headings = ["Name", "Alt. Names", "Author", "Volumes Owned",
"Next Volume", "Publisher", "Completed"]
data = [series.name, series.alt_names, series.author,
series.volumes_owned_readable, series.next_volume,
series.publisher, "Yes" if series.is_completed else "No"]
# Prepare table
self.edit_series_table.clear()
self.edit_series_table.setRowCount(len(headings))
self.edit_series_table.setColumnCount(2)
self.edit_series_table.setEditTriggers(
QAbstractItemView.AllEditTriggers)
header = self.edit_series_table.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.ResizeToContents)
header.setSectionResizeMode(1, QHeaderView.Stretch)
# Populate table
for i in range(len(headings)):
headerItem = QTableWidgetItem(headings[i])
headerItem.setFlags(headerItem.flags() & ~int(Qt.ItemIsEditable))
dataItem = None
self.edit_series_table.setItem(i, 0, headerItem)
if headings[i] == "Completed":
dataItem = QComboBox()
dataItem.insertItem(0, "No")
dataItem.insertItem(1, "Yes")
if str(data[i]) == "No":
dataItem.setCurrentIndex(0)
else:
dataItem.setCurrentIndex(1)
self.edit_series_table.setCellWidget(i, 1, dataItem)
else:
dataItem = QTableWidgetItem(str(data[i]))
if headings[i] == "Next Volume":
dataItem.setFlags(dataItem.flags()
& ~int(Qt.ItemIsEditable))
self.edit_series_table.setItem(i, 1, dataItem)
# set property editable if series_info_display double-clicked
if headings[i] == item and item not in ["Next Volume",
"Completed"]:
self.edit_series_table.editItem(dataItem)
def addObjectToList(self, sceneId, name, color):
insertRow = self.rowCount()
self.insertRow(insertRow)
indexItem = QTableWidgetItem(str(sceneId))
indexItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
indexItem.setCheckState(Qt.Checked)
self.setItem(insertRow, 0, indexItem)
self.setItem(insertRow, 1, QTableWidgetItem(str(name)))
self.setItem(insertRow, 2, QTableWidgetItem(""))
self.item(insertRow, 2).setBackground(
QColor(255 * color[0], 255 * color[1], 255 * color[2]))
def fill_db_table_with_skeletons(self):
self.db_skeletons = []
self.skeletonDBTableWidget.clear()
skeleton_list = get_skeletons_from_remote_db(self.db_url)
for idx, s in skeleton_list:
insertRow = self.skeletonDBTableWidget.rowCount()
self.skeletonDBTableWidget.insertRow(insertRow)
indexItem = QTableWidgetItem("")
indexItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
indexItem.setCheckState(Qt.Checked)
self.skeletonDBTableWidget.setItem(insertRow, 0, indexItem)
self.skeletonDBTableWidget.setItem(insertRow, 1, QTableWidgetItem(str(s)))
self.db_skeletons.append(s)
def add_account(self, login, password, proxy, record=True):
self.table.insertRow(self.row)
self.table.setItem(self.row, 0, QTableWidgetItem(login))
self.table.setItem(self.row, 1, QTableWidgetItem(password))
self.table.setItem(self.row, 2, QTableWidgetItem(proxy))
self.table.setItem(self.row, 3, QTableWidgetItem('?'))
if record:
self.set_settings('key', self.form_key.text())
self.set_settings('table', [login, password, proxy])
self.row += 1
