def updateTable(self):
queryset = self.queryset()
self.pagination = paginate(queryset, self.page, perPage=12)
items = self.pagination.items
self.table.setRowCount(len(items))
self.table.setColumnWidth(0, 50)
self.table.setColumnWidth(2, 140)
self.table.setColumnWidth(3, 50)
for row, item in enumerate(items):
self.table.setItem(row, 0, QTableWidgetItem(item.tt))
self.table.setItem(row, 1, QTableWidgetItem(item.rptInline))
if item.sent:
sent = item.sent.strftime('%Y-%m-%d %H:%M:%S')
self.table.setItem(row, 2, QTableWidgetItem(sent))
if item.confirmed:
checkedItem = QTableWidgetItem()
checkedItem.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
checkedItem.setIcon(QIcon(':/checkmark.png'))
self.table.setItem(row, 3, checkedItem)
else:
checkedItem = QTableWidgetItem()
checkedItem.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
checkedItem.setIcon(QIcon(':/cross.png'))
self.table.setItem(row, 3, checkedItem)
if 'COR' in item.rpt or 'AMD' in item.rpt:
self.table.item(row, 0).setForeground(self.color)
self.table.item(row, 1).setForeground(self.color)
self.table.item(row, 2).setForeground(self.color)
self.table.resizeRowsToContents()
def _set_col_name(self, idx: int, app_v: ApplicationView):
col = QTableWidgetItem()
col.setText(app_v.model.base_data.name if app_v.model.base_data.
name else '...')
col.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
col.setToolTip(self.window.locale_keys['app.name'].lower())
if self.disk_cache and app_v.model.supports_disk_cache(
) and os.path.exists(app_v.model.get_disk_icon_path()):
with open(app_v.model.get_disk_icon_path(), 'rb') as f:
icon_bytes = f.read()
pixmap = QPixmap()
pixmap.loadFromData(icon_bytes)
icon = QIcon(pixmap)
self.icon_cache.add_non_existing(
app_v.model.base_data.icon_url, {
'icon': icon,
'bytes': icon_bytes
})
elif not app_v.model.base_data.icon_url:
icon = QIcon(app_v.model.get_default_icon_path())
else:
icon_data = self.icon_cache.get(app_v.model.base_data.icon_url)
icon = icon_data['icon'] if icon_data else QIcon(
app_v.model.get_default_icon_path())
col.setIcon(icon)
self.setItem(idx, 0, col)
def set_model(self, file_items):
self._reset()
self.setRowCount(len(file_items))
self.setSortingEnabled(False)
for i in range(0, len(file_items)):
source = file_items[i][DisplayKeys.source]
target = file_items[i][DisplayKeys.target]
source_item = QTableWidgetItem(source)
target_item = QTableWidgetItem(target)
mime = MainTable._mime_database.mimeTypesForFileName(source)
if len(mime):
source_item.setIcon(QIcon.fromTheme(mime[0].iconName()))
else:
logger.error("Unable to determine mime type for " + source)
source_item.setIcon(QIcon.fromTheme("text-x-generic"))
source_item.setCheckState(Qt.Checked)
_, file_name = os.path.split(target)
if file_name.startswith(_UNKNOWN_KEY):
target_item.setBackground(MainTable._error_brush)
source_item.setBackground(MainTable._error_brush)
source_item.setCheckState(Qt.Unchecked)
self.setItem(i, 0, source_item)
self.setItem(i, 1, target_item)
self.setSortingEnabled(True)
self.model = file_items
def fillEachPieceOfEquip(self, equip, side, pos):
tooltip = eq2s_func.CookItemText(equip['item'])
try:
epnm = QTableWidgetItem(equip['item']['displayname'])
epnm.setToolTip(tooltip.text)
epnm.setData(1001, equip['item']['iconid'])
epnm.setData(1002, equip['item']['displayname'])
if side == 'l':
epnm.setTextAlignment(Qt.AlignRight)
else:
epnm.setTextAlignment(Qt.AlignLeft)
epicon = QTableWidgetItem()
icon = QIcon()
icon.addPixmap(eq2s_func.get_pixmap_in_db(equip['item']['iconid']))
epicon.setIcon(icon)
epicon.setToolTip(tooltip.text)
epicon.setData(1001, equip['item']['iconid'])
epicon.setData(1002, equip['item']['displayname'])
if side == 'l':
self.leftEquipTable.setItem(pos, 0, epnm)
self.leftEquipTable.setItem(pos, 1, epicon)
elif side == 'r':
self.rightEquipTable.setItem(pos, 0, epicon)
self.rightEquipTable.setItem(pos, 1, epnm)
except KeyError:
pass
def assign_mem(self, mem):
self.mem=mem
#UI headers
self.setColumnCount(self.mem.maxplayers+1)
for i, j in enumerate(self.mem.jugadores.arr):
self.setColumnWidth(i, 90)
item = QTableWidgetItem(j.name)
item.setTextAlignment(Qt.AlignHCenter|Qt.AlignVCenter|Qt.AlignCenter)
item.setIcon(j.color.qicon())
self.setHorizontalHeaderItem(i, item)
item = QTableWidgetItem(self.tr("Total"))
item.setTextAlignment(Qt.AlignHCenter|Qt.AlignVCenter|Qt.AlignCenter)
self.setHorizontalHeaderItem(self.mem.maxplayers, item)
#Crea items
for i in range(self.mem.maxplayers+1+1):
for j in range(17):
item=QTableWidgetItem()
item.setTextAlignment(Qt.AlignHCenter|Qt.AlignVCenter|Qt.AlignCenter)
self.setItem( j,i, item )
#Rallando la tabla
for i, j in ((11, self.mem.maxplayers), (12, self.mem.maxplayers), (14, self.mem.maxplayers), (16, self.mem.maxplayers)):
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignRight|Qt.AlignVCenter)
brush = QBrush(QColor(0, 0, 0))
brush.setStyle(Qt.BDiagPattern)
item.setBackground(brush)
self.setItem(i, j, item)
def _set_col_name(self, col: int, pkg: PackageView):
item = QTableWidgetItem()
item.setText(pkg.model.name if pkg.model.name else '...')
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setToolTip(self.i18n['app.name'].lower())
if self.disk_cache and pkg.model.supports_disk_cache(
) and pkg.model.get_disk_icon_path() and os.path.exists(
pkg.model.get_disk_icon_path()):
with open(pkg.model.get_disk_icon_path(), 'rb') as f:
icon_bytes = f.read()
pixmap = QPixmap()
pixmap.loadFromData(icon_bytes)
icon = QIcon(pixmap)
self.icon_cache.add_non_existing(pkg.model.icon_url, {
'icon': icon,
'bytes': icon_bytes
})
elif not pkg.model.icon_url:
icon = QIcon(pkg.model.get_default_icon_path())
else:
icon_data = self.icon_cache.get(pkg.model.icon_url)
icon = icon_data['icon'] if icon_data else QIcon(
pkg.model.get_default_icon_path())
item.setIcon(icon)
self.setItem(pkg.table_index, col, item)
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 generar_tabla(self, p_table_widged):
"""
Genera una tabla con las entradas de la lista del historial
:param p_table_widged: La tabla perteneciente a la interfaz
:return:
"""
p_table_widged.setRowCount(len(self.lista))
for i in range(0, len(self.lista)):
# Rellenamos la tabla
historial = self.lista[i]
newitem = QTableWidgetItem(historial.nombre_script)
p_table_widged.setItem(i, 0, newitem)
newitem = QTableWidgetItem(historial.nombre_tag)
p_table_widged.setItem(i, 1, newitem)
newitem = QTableWidgetItem(historial.nombre_alumno + " " + historial.apellido)
p_table_widged.setItem(i, 2, newitem)
newitem = QTableWidgetItem(historial.nombre_grupo)
p_table_widged.setItem(i, 3, newitem)
if historial.accion == 1:
# Añadir
newitem_anadir = QTableWidgetItem("Añadir")
newitem_anadir.setIcon(QtGui.QIcon("plasma-next-icons/Breeze/actions/toolbar/list-add.svg"))
p_table_widged.setItem(i, 4, newitem_anadir)
else:
# Eliminar
newitem_eliminar = QTableWidgetItem("Eliminar")
newitem_eliminar.setIcon(QtGui.QIcon("plasma-next-icons/Breeze/actions/toolbar/edit-delete.svg"))
p_table_widged.setItem(i, 4, newitem_eliminar)
newitem = QTableWidgetItem(historial.informacion)
p_table_widged.setItem(i, 5, newitem)
newitem = QTableWidgetItem(historial.fecha_creacion_h)
p_table_widged.setItem(i, 6, newitem)
def add_row_to_list_of_users(self, users):
who_is_signed = self.label_user_name.text()
for user in users:
if user['login'] != who_is_signed:
newRowNum = self.table_widget_list_of_users.rowCount()
self.table_widget_list_of_users.insertRow(newRowNum)
self.table_widget_list_of_users.setItem(
newRowNum, 0, QTableWidgetItem(str(user['login'])))
self.table_widget_list_of_users.setItem(
newRowNum, 1, QTableWidgetItem(str(user['status'])))
#print(os.listdir())
#f = open("gui/resources/avatars/lolo.txt", 'r')
#if f.mode == 'r':
# con = f.read()
# print(con)
item = QTableWidgetItem()
item.setIcon(QIcon(QPixmap(":/avatars/" +
str(user['avatar']))))
self.table_widget_list_of_users.setItem(newRowNum, 2, item)
avatar_name = self.client.get_avatar(who_is_signed)
pixmap = QPixmap(':/avatars/' + str(avatar_name))
self.label_avatar.setPixmap(pixmap)
def table_add_rows(self, actor, character, series_star):
"""
Add new row in table.
:param actor: actor name
:param character: character name
:param series_star: start bool value
"""
self.table.insertRow(self.rows)
self.table.setItem(self.rows, 0, QTableWidgetItem(actor))
self.table.setItem(self.rows, 1, QTableWidgetItem(character))
if series_star:
icon = QIcon()
icon.addPixmap(QPixmap('images/star_yellow_16.png'), QIcon.Normal,
QIcon.Off)
star = QTableWidgetItem()
star.setIcon(icon)
self.table.setItem(self.rows, 2, star)
for i in range(2):
self.table.item(self.rows,
i).setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.rows += 1
def taskListCallback(self, result):
self.taskListRefresh += 1
if self.taskListRefresh == 4: #this slowsdown the refresh rate so the buttons work more easily
self.taskListRefresh = 0
self.PriorityQueueTable.setRowCount(0) # clear table
for item in result.taskMsgs:
if item.robotName == "unassigned":
self.PriorityQueueTable.insertRow(
self.PriorityQueueTable.rowCount())
self.PriorityQueueTable.setItem(
self.PriorityQueueTable.rowCount() - 1, 0,
QTableWidgetItem(item.taskName))
self.PriorityQueueTable.setItem(
self.PriorityQueueTable.rowCount() - 1, 1,
QTableWidgetItem(item.ID))
self.PriorityQueueTable.setItem(
self.PriorityQueueTable.rowCount() - 1, 2,
QTableWidgetItem("{:.2f}".format(item.taskPriority)))
icon_item = QTableWidgetItem()
icon_item.setIcon(QIcon(trashIcon))
self.PriorityQueueTable.setItem(
self.PriorityQueueTable.rowCount() - 1, 3, icon_item)
if item.OGSupervisorID != self.id:
self.PriorityQueueTable.item(
self.PriorityQueueTable.rowCount() - 1,
0).setBackground(QColor(245, 167, 66))
self.PriorityQueueTable.item(
self.PriorityQueueTable.rowCount() - 1,
1).setBackground(QColor(245, 167, 66))
self.PriorityQueueTable.item(
self.PriorityQueueTable.rowCount() - 1,
2).setBackground(QColor(245, 167, 66))
self.PriorityQueueTable.item(
self.PriorityQueueTable.rowCount() - 1,
3).setBackground(QColor(245, 167, 66))
class GalleryDownloaderItem(QObject):
"""
Receives a HenItem
"""
d_item_ready = pyqtSignal(object)
def __init__(self, hitem):
super().__init__()
assert isinstance(hitem, pewnet.HenItem)
self.item = hitem
url = self.item.gallery_url
self.profile_item = QTableWidgetItem(self.item.name)
self.profile_item.setToolTip(url)
def set_profile(item):
self.profile_item.setIcon(QIcon(item.thumb))
self.item.thumb_rdy.connect(set_profile)
# status
self.status_item = QTableWidgetItem('Downloading...')
self.status_item.setToolTip(url)
def set_finished(item):
self.status_item.setText('Finished downloading!')
self.d_item_ready.emit(self)
self.item.file_rdy.connect(set_finished)
# other
self.cost_item = QTableWidgetItem(self.item.cost)
self.cost_item.setToolTip(url)
self.size_item = QTableWidgetItem(self.item.size)
self.size_item.setToolTip(url)
type = 'Archive' if hitem.download_type == 0 else 'Torrent'
self.type_item = QTableWidgetItem(type)
self.type_item.setToolTip(url)
def on_scrapped_credits(self, credit: list):
"""
"""
self.tbl_result.setColumnCount(5)
self.tbl_result.setRowCount(len(credit))
self.tbl_result.setHorizontalHeaderLabels([
"Banka",
"Kredi Adı",
"Faiz Oranı",
"Toplam Maliyet",
"Aylık Taksit",
])
self.tbl_result.setIconSize(QSize(60, 60))
self.tbl_result.setSortingEnabled(True)
for row, data in enumerate(credit):
item = QTableWidgetItem()
item.setIcon(QIcon(data.get('logo')))
self.tbl_result.setItem(row, 0, item)
self.tbl_result.setItem(row, 1,
QTableWidgetItem(data.get('BankName')))
self.tbl_result.setItem(row, 2,
QTableWidgetItem(data.get('InterestRate')))
self.tbl_result.setItem(
row, 3, QTableWidgetItem(data.get('TotalPaybackAmnt') + " TL"))
self.tbl_result.setItem(
row, 4,
QTableWidgetItem(data.get('MonthlyInstallment') + " TL"))
def _set_col_name(self, col: int, pkg: PackageView):
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
name = pkg.model.get_display_name()
if name:
item.setToolTip('{}: {}'.format(self.i18n['app.name'].lower(),
pkg.model.get_name_tooltip()))
else:
name = '...'
item.setToolTip(self.i18n['app.name'].lower())
if len(name) > NAME_MAX_SIZE:
name = name[0:NAME_MAX_SIZE - 3] + '...'
if len(name) < NAME_MAX_SIZE:
name = name + ' ' * (NAME_MAX_SIZE - len(name))
item.setText(name)
icon_path = pkg.model.get_disk_icon_path()
if pkg.model.installed and pkg.model.supports_disk_cache(
) and icon_path:
if icon_path.startswith('/'):
if os.path.isfile(icon_path):
with open(icon_path, 'rb') as f:
icon_bytes = f.read()
pixmap = QPixmap()
pixmap.loadFromData(icon_bytes)
icon = QIcon(pixmap)
self.icon_cache.add_non_existing(
pkg.model.icon_url, {
'icon': icon,
'bytes': icon_bytes
})
else:
icon = QIcon(pkg.model.get_default_icon_path())
else:
try:
icon = QIcon.fromTheme(icon_path)
self.icon_cache.add_non_existing(pkg.model.icon_url, {
'icon': icon,
'bytes': None
})
except:
icon = QIcon(pkg.model.get_default_icon_path())
elif not pkg.model.icon_url:
icon = QIcon(pkg.model.get_default_icon_path())
else:
icon_data = self.icon_cache.get(pkg.model.icon_url)
icon = icon_data['icon'] if icon_data else QIcon(
pkg.model.get_default_icon_path())
item.setIcon(icon)
self.setItem(pkg.table_index, col, item)
class GalleryDownloaderItem(QObject):
"""
Receives a HenItem
"""
d_item_ready = pyqtSignal(object)
def __init__(self, hitem):
super().__init__()
assert isinstance(hitem, pewnet.HenItem)
self.d_item_ready.connect(self.done)
self.item = hitem
url = self.item.gallery_url
self.profile_item = QTableWidgetItem(self.item.name)
self.profile_item.setData(Qt.UserRole+1, hitem)
self.profile_item.setToolTip(url)
def set_profile(item):
self.profile_item.setIcon(QIcon(item.thumb))
self.item.thumb_rdy.connect(set_profile)
# status
self.status_item = QTableWidgetItem('In queue...')
self.status_item.setToolTip(url)
def set_finished(item):
self.status_item.setText('Finished!')
self.d_item_ready.emit(self)
self.item.file_rdy.connect(set_finished)
# other
self.cost_item = QTableWidgetItem(self.item.cost)
self.cost_item.setToolTip(url)
self.size_item = QTableWidgetItem(self.item.size)
self.size_item.setToolTip(url)
type = 'Archive' if hitem.download_type == 0 else 'Torrent'
self.type_item = QTableWidgetItem(type)
self.type_item.setToolTip(url)
self.status_timer = QTimer()
self.status_timer.timeout.connect(self.check_progress)
self.status_timer.start(500)
def check_progress(self):
if self.item.current_state == self.item.DOWNLOADING:
btomb = 1048576
self.status_item.setText("{0:.2f}/{1:.2f} MB".format(self.item.current_size/btomb,
self.item.total_size/btomb))
self.size_item.setText("{0:.2f} MB".format(self.item.total_size/btomb))
elif self.item.current_state == self.item.CANCELLED:
self.status_item.setText("Cancelled!")
self.status_timer.stop()
def done(self):
self.status_timer.stop()
if self.item.download_type == 0:
self.status_item.setText("Sent to library!")
else:
self.status_item.setText("Sent to torrent client!")
class GalleryDownloaderItem(QObject):
"""
Receives a HenItem
"""
d_item_ready = pyqtSignal(object)
def __init__(self, hitem):
super().__init__()
assert isinstance(hitem, pewnet.HenItem)
self.d_item_ready.connect(self.done)
self.item = hitem
url = self.item.gallery_url
self.profile_item = QTableWidgetItem(self.item.name)
self.profile_item.setData(Qt.UserRole+1, hitem)
self.profile_item.setToolTip(url)
def set_profile(item):
self.profile_item.setIcon(QIcon(item.thumb))
self.item.thumb_rdy.connect(set_profile)
# status
self.status_item = QTableWidgetItem('In queue...')
self.status_item.setToolTip(url)
def set_finished(item):
self.status_item.setText('Finished!')
self.d_item_ready.emit(self)
self.item.file_rdy.connect(set_finished)
# other
self.cost_item = QTableWidgetItem(self.item.cost)
self.cost_item.setToolTip(url)
self.size_item = QTableWidgetItem(self.item.size)
self.size_item.setToolTip(url)
type = 'Archive' if hitem.download_type == 0 else 'Torrent'
self.type_item = QTableWidgetItem(type)
self.type_item.setToolTip(url)
self.status_timer = QTimer()
self.status_timer.timeout.connect(self.check_progress)
self.status_timer.start(500)
def check_progress(self):
if self.item.current_state == self.item.DOWNLOADING:
btomb = 1048576
self.status_item.setText("{0:.2f}/{1:.2f} MB".format(self.item.current_size/btomb,
self.item.total_size/btomb))
self.size_item.setText("{0:.2f} MB".format(self.item.total_size/btomb))
elif self.item.current_state == self.item.CANCELLED:
self.status_item.setText("Cancelled!")
self.status_timer.stop()
def done(self):
self.status_timer.stop()
if self.item.download_type == 0:
self.status_item.setText("Sent to library!")
else:
self.status_item.setText("Sent to torrent client!")
def build_player_table(self):
"""
:return:
"""
player_widget = QTableWidget(16, 6)
player_widget.setMaximumWidth(270)
player_widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
player_widget.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
player_widget.verticalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
labels = {1: "down", 2: "any", 3: "up", 4: "call", 5: "countercall"}
combos = {
8: "M",
9: "m",
11: "T",
12: "S",
13: "F",
14: "P",
15: "Y",
16: "="
}
for i in range(5):
headerItem = QTableWidgetItem("")
headerItem.setIcon(
QIcon(QPixmap("./img/0{}-{}.png".format(i + 1,
labels[i + 1]))))
headerItem.setTextAlignment(Qt.AlignVCenter)
player_widget.setHorizontalHeaderItem(i, headerItem)
headerItem = QTableWidgetItem("")
headerItem.setTextAlignment(Qt.AlignVCenter)
player_widget.setHorizontalHeaderItem(5, headerItem)
for i in range(6):
headerItem = QTableWidgetItem("")
headerItem.setIcon(
QIcon(QPixmap("./img/dice_{}.png".format(i + 1))))
headerItem.setTextAlignment(Qt.AlignVCenter)
player_widget.setVerticalHeaderItem(i, headerItem)
for i in [6, 9, 16]:
headerItem = QTableWidgetItem("")
headerItem.setTextAlignment(Qt.AlignVCenter)
player_widget.setVerticalHeaderItem(i, headerItem)
for row, label in combos.items():
headerItem = QTableWidgetItem("{}".format(label))
headerItem.setTextAlignment(Qt.AlignVCenter)
player_widget.setVerticalHeaderItem(row - 1, headerItem)
return player_widget
def __createItemsARow(self, rowNo, name, sex, birth, nation, isParty,
score): ##创建一行的items
StudID = 201805000 + rowNo #学号
#姓名
item = QTableWidgetItem(name, CellType.ctName.value)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
font = item.font()
font.setBold(True)
item.setFont(font)
item.setData(Qt.UserRole, StudID) #关联数据
self.ui.tableInfo.setItem(rowNo, FieldColNum.colName.value, item)
#性别
if (sex == "男"):
icon = QIcon(":/icons/images/boy.ico")
else:
icon = QIcon(":/icons/images/girl.ico")
item = QTableWidgetItem(sex, CellType.ctSex.value)
item.setIcon(icon)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.ui.tableInfo.setItem(rowNo, FieldColNum.colSex.value, item)
#出生日期
strBitrh = birth.toString("yyyy-MM-dd") #日期转换为字符串
item = QTableWidgetItem(strBitrh, CellType.ctBirth.value)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.ui.tableInfo.setItem(rowNo, FieldColNum.colBirth.value, item)
#民族
item = QTableWidgetItem(nation, CellType.ctNation.value)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
if (nation != "汉族"):
item.setForeground(QBrush(Qt.blue))
self.ui.tableInfo.setItem(rowNo, FieldColNum.colNation.value, item)
#分数
strScore = str(score)
item = QTableWidgetItem(strScore, CellType.ctScore.value)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.ui.tableInfo.setItem(rowNo, FieldColNum.colScore.value, item)
#党员
item = QTableWidgetItem("党员", CellType.ctPartyM.value)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
if (isParty == True):
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
| Qt.ItemIsUserCheckable) #不允许编辑文字
item.setBackground(QBrush(Qt.yellow)) #Qt::green lightGray yellow
self.ui.tableInfo.setItem(rowNo, FieldColNum.colPartyM.value,
item) #为单元格设置Item
def setMyData(self):
for row, item in enumerate(self.data):
title_item = QTableWidgetItem(item[0])
font = title_item.font()
font.setBold(True)
title_item.setFont(font)
if self.use_icons:
icon = QIcon(icon_dir + QtCore.QUrl(item[1]).host() + '.png')
if icon.pixmap(16, 16).isNull(): icon = QIcon(':/quartz.png')
title_item.setIcon(icon)
self.setItem(row, 0, title_item)
def table_reload(self, table, setamenazas):
table.setRowCount(len(setamenazas.arr))
for i, a in enumerate(setamenazas.arr):
item = QTableWidgetItem()
item.setIcon(a.attacking_pawn.color.qicon())
table.setItem(i, 0, QTableWidgetItem(item))
item = QTableWidgetItem(str(a.attacking_pawn.casilla().id))
item.setTextAlignment(Qt.AlignCenter)
table.setItem(i, 1, item)
item = QTableWidgetItem(a.name())
table.setItem(i, 2, item)
def insert_item(self, identification, name):
status_widget = QTableWidgetItem()
status_widget.setIcon(QtGui.QIcon(":/images/autentication.png"))
self.contacts.insertRow(self.contacts.rowCount())
self.contacts.setItem(self.contacts_count, 0, status_widget)
self.contacts.setItem(self.contacts_count, 1, QTableWidgetItem(identification))
self.contacts.setItem(self.contacts_count, 2, QTableWidgetItem(name))
self.contacts_count += 1
self.status_widgets[identification] = status_widget
self.contacts.resizeColumnsToContents()
def setMyData(self):
for row, item in enumerate(self.data):
title_item = QTableWidgetItem(item[0])
font = title_item.font()
font.setBold(True)
title_item.setFont(font)
if self.use_icons:
icon = QIcon(icon_dir + item[1].split('/')[2] + '.png')
if icon.pixmap(16, 16).isNull():
icon = QIcon.fromTheme('applications-internet')
title_item.setIcon(icon)
self.setItem(row, 0, title_item)
def _generar_tabla_filtrada(self, p_lista_filtrada):
"""
La lista que nos genera la función de filtrado. Es una lista que contiene objetos de tipo historial.
Por ello. La generación de la tabla de filtrado es algo diferente y se debe hacer en éste punto.
:param p_lista_filtrada: La lista que contiene los elementos de historial ya filtrada
:return:
"""
# Bloquemos las señales y vaciamos la tabla
self.ventana.tHistorial.blockSignals(True)
# Cargamos la tabla
self.ventana.tHistorial.setRowCount(len(p_lista_filtrada))
for i in range(0, len(p_lista_filtrada)):
# Rellenamos la tabla
historial = p_lista_filtrada[i]
newitem = QTableWidgetItem(historial.nombre_script)
self.ventana.tHistorial.setItem(i, 0, newitem)
newitem = QTableWidgetItem(historial.nombre_tag)
self.ventana.tHistorial.setItem(i, 1, newitem)
newitem = QTableWidgetItem(historial.nombre_alumno + " " +
historial.apellido)
self.ventana.tHistorial.setItem(i, 2, newitem)
newitem = QTableWidgetItem(historial.nombre_grupo)
self.ventana.tHistorial.setItem(i, 3, newitem)
if historial.accion == 1:
# Añadir
newitem_anadir = QTableWidgetItem("Añadir")
newitem_anadir.setIcon(
QtGui.QIcon(
"plasma-next-icons/Breeze/actions/toolbar/list-add.svg"
))
self.ventana.tHistorial.setItem(i, 4, newitem_anadir)
else:
# Eliminar
newitem_eliminar = QTableWidgetItem("Eliminar")
newitem_eliminar.setIcon(
QtGui.QIcon(
"plasma-next-icons/Breeze/actions/toolbar/edit-delete.svg"
))
self.ventana.tHistorial.setItem(i, 4, newitem_eliminar)
newitem = QTableWidgetItem(historial.informacion)
self.ventana.tHistorial.setItem(i, 5, newitem)
newitem = QTableWidgetItem(historial.fecha_creacion_h)
self.ventana.tHistorial.setItem(i, 6, newitem)
# Liberamos las señales
self.ventana.tHistorial.blockSignals(False)
def add_picture(self):
row = 0
column = 0
language_names = ["python", "golang", "c", "javascript", "html-5", "css3"]
for m in range(len(language_names)):
if m % 3 == 0 and m != 0:
row += 1
column = 0
file_path = os.path.join("03_高级界面控件/示例内容/sources/images", language_names[m]+"-96.png")
table_item = QTableWidgetItem()
table_item.setFlags(Qt.ItemIsEnabled) # 点击时, 图片能选中
table_item.setIcon(QIcon(file_path))
self.table_widget.setItem(row, column, table_item)
column += 1
def loadImages(self, fileNames):
for fileName in fileNames:
row = self.imagesTable.rowCount()
self.imagesTable.setRowCount(row + 1)
fileInfo = QFileInfo(fileName)
imageName = fileInfo.baseName()
fileImage2x = fileInfo.absolutePath(
) + '/' + imageName + "@2x." + fileInfo.suffix()
fileInfo2x = QFileInfo(fileImage2x)
image = QImage(fileName)
toolTip = "Directory: {}\nFile: {}\nFile@2x: {}\nSize: {}x{}".format(
QDir.toNativeSeparators(fileInfo.absolutePath()),
fileInfo.fileName(),
fileInfo2x.fileName() if fileInfo2x.exists else "<None>",
image.width(), image.height())
fileItem = QTableWidgetItem(imageName)
fileItem.setData(Qt.UserRole, fileName)
fileItem.setIcon(QIcon(QPixmap.fromImage(image)))
fileItem.setFlags((fileItem.flags() | Qt.ItemIsUserCheckable)
& ~Qt.ItemIsEditable)
fileItem.setToolTip(toolTip)
self.imagesTable.setItem(row, 0, fileItem)
mode = QIcon.Normal
state = QIcon.Off
if self.guessModeStateAct.isChecked():
if "_act" in imageName:
mode = QIcon.Active
elif "_dis" in imageName:
mode = QIcon.Disabled
elif "_sel" in imageName:
mode = QIcon.Selected
if "_on" in imageName:
mode = QIcon.On
modeItem = QTableWidgetItem(IconPreviewArea.iconModeNames()[
IconPreviewArea.iconModes().index(mode)])
modeItem.setToolTip(toolTip)
self.imagesTable.setItem(row, 1, modeItem)
stateItem = QTableWidgetItem(IconPreviewArea.iconStateNames()[
IconPreviewArea.iconStates().index(state)])
stateItem.setToolTip(toolTip)
self.imagesTable.setItem(row, 2, stateItem)
self.imagesTable.openPersistentEditor(modeItem)
self.imagesTable.openPersistentEditor(stateItem)
fileItem.setCheckState(Qt.Checked)
def widgetInsideTable(self):
# ===== Button view pass inside table =====
# viewPassbtn=QPushButton()
# viewPassbtn.setFixedHeight(self.size_of_btn)
# viewPassbtn.setFixedWidth(self.size_of_btn)
# viewPassbtn.setIcon(QIcon(self._dirIcon+'icons8-eye-1.png'))
# ====== CheckBox ======
checkBox = QTableWidgetItem()
checkBox.setIcon(QIcon(self._dirIcon + 'icons8-checkbox-0.png'))
checkBox.setFlags(Qt.ItemIsEnabled)
ItemViewPass = QTableWidgetItem()
ItemViewPass.setIcon(QIcon(self._dirIcon + 'icons8-eye-1.png'))
ItemViewPass.setFlags(Qt.ItemIsEnabled)
self.table.setIconSize(QSize(self.size, self.size))
return checkBox, ItemViewPass
def __createItemARow(self,rowNo,name,sex,birth,nation,isParty,score):
StudID = 201805000+rowNo
#姓名
item = QTableWidgetItem(name,CellType.ctName.value)#实例一个有姓名的单元格,
item.setTextAlignment(Qt.AlignHCenter|Qt.AlignVCenter)#水平+垂直居中
font = item.font()
font.setBold(True)
item.setFont(font)
item.setData(Qt.UserRole,StudID)#设置自定义数据,将学生ID存入,该数据不会显示在界面
self.ui.tableInfo.setItem(rowNo,FieldColNum.colName.value,item)#第1(0)行1(0)列,设置item单元格
#性别
if sex == '男':
icon = QIcon(":/icons/images/boy.ico")
else:
icon = QIcon(":/icons/images/girl.ico")
item = QTableWidgetItem(sex,CellType.ctSex.value)
item.setIcon(icon)#设置图标
item.setTextAlignment(Qt.AlignHCenter|Qt.AlignVCenter)
self.ui.tableInfo.setItem(rowNo,FieldColNum.colSex.value,item)
#出生日期
strBirth = birth.toString('yyyy-MM-dd')
item = QTableWidgetItem(strBirth,CellType.ctBirth.value)
item.setTextAlignment(Qt.AlignHCenter|Qt.AlignVCenter)
self.ui.tableInfo.setItem(rowNo,FieldColNum.colBirth.value,item)
#民族
item = QTableWidgetItem(nation,CellType.cnNation.value)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
if nation != '汉族':
item.setForeground(QBrush(Qt.blue))#设置文字颜色为蓝色
self.ui.tableInfo.setItem(rowNo,FieldColNum.colNation.value,item)
#党员
item = QTableWidgetItem("党员",CellType.ctPartyM.value)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
if isParty == True:
item.setCheckState(Qt.Checked)#选中
else:
item.setCheckState(Qt.Unchecked)#不选择
item.setFlags(Qt.ItemIsSelectable|Qt.ItemIsEnabled|Qt.ItemIsUserCheckable)#可选,能被选(锁定),可被复选(为True带有复选框)
item.setBackground(QBrush(Qt.yellow))
self.ui.tableInfo.setItem(rowNo,FieldColNum.colParthM.value,item)
#分数
strScore = str(score)
item = QTableWidgetItem(strScore,CellType.cnScore.value)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.ui.tableInfo.setItem(rowNo,FieldColNum.colScore.value,item)
def update_table(self, search=''): # обновить данные таблицы
con = sqlite3.connect('db/L_systems.db')
cur = con.cursor()
head = [
x[1] for x in cur.execute(
"""PRAGMA table_info(draw_l_systems)""").fetchall()
]
if search:
table_values = cur.execute(
f'''select id, name, angle, axiom, drawer, mover,
plus_minus, saver, returner, plus_180,
rules, image from draw_l_systems WHERE name = "{search}"'''
).fetchall()
else:
table_values = cur.execute(
'''select id, name, angle, axiom, drawer, mover,
plus_minus, saver, returner, plus_180,
rules, image from draw_l_systems''').fetchall()
con.close()
self.tableWidget.setColumnCount(len(head))
self.tableWidget.setHorizontalHeaderLabels(head)
self.tableWidget.setRowCount(0)
for i, row in enumerate(table_values):
self.tableWidget.setRowCount(self.tableWidget.rowCount() + 1)
for j, elem in enumerate(row):
try:
if j == len(head) - 1:
#img = open('res.png', 'wb')
#img.write(elem)
#img.close()
icon = QIcon()
icon.addFile('res.jpg')
item = QTableWidgetItem()
item.setIcon(icon)
self.tableWidget.setItem(i, j, item)
else:
self.tableWidget.setItem(i, j,
QTableWidgetItem(str(elem)))
except Exception as e:
print(e)
self.tableWidget.resizeColumnsToContents()
con.close()
def set_row(self, item_info, row_index):
self.insertRow(row_index)
for attr in self.attributes:
value = item_info[attr]
item = QTableWidgetItem()
#item.info = item_info
if attr == 'icon':
item.setIcon(QIcon(value))
else:
item.setText(value)
self.setItem(row_index, self.attributes.index(attr), item)
print(row_index)
row_index += 1
def make_icon(self):
self.tableWidget.setShowGrid(False)
self.tableWidget.verticalHeader().setVisible(False)
self.tableWidget.horizontalHeader().setVisible(False)
self.tableWidget.setStyleSheet('''
QTableWidget {border:10px solid white;background-color:white}
QTableWidget:item:hover {background-color:rgb(230,230,230);}''')
self.tableWidget.setRowCount(6)
self.tableWidget.setColumnCount(12)
self.tableWidget.setIconSize(QtCore.QSize(40, 40))
for i in range(6):
self.tableWidget.setRowHeight(i, 40)
for j in range(12):
self.tableWidget.setColumnWidth(j, 40)
head_pic = QTableWidgetItem()
head_pic.setToolTip(expression_dic["10%d%d.png" % (i, j)])
icon = QtGui.QIcon("expression/fun/10%d%d.png" % (i, j))
head_pic.setIcon(QtGui.QIcon(icon))
self.tableWidget.setItem(i, j, head_pic)
def _generar_tabla_filtrada(self, p_lista_filtrada):
"""
La lista que nos genera la función de filtrado. Es una lista que contiene objetos de tipo historial.
Por ello. La generación de la tabla de filtrado es algo diferente y se debe hacer en éste punto.
:param p_lista_filtrada: La lista que contiene los elementos de historial ya filtrada
:return:
"""
# Bloquemos las señales y vaciamos la tabla
self.ventana.tHistorial.blockSignals(True)
# Cargamos la tabla
self.ventana.tHistorial.setRowCount(len(p_lista_filtrada))
for i in range(0, len(p_lista_filtrada)):
# Rellenamos la tabla
historial = p_lista_filtrada[i]
newitem = QTableWidgetItem(historial.nombre_script)
self.ventana.tHistorial.setItem(i, 0, newitem)
newitem = QTableWidgetItem(historial.nombre_tag)
self.ventana.tHistorial.setItem(i, 1, newitem)
newitem = QTableWidgetItem(historial.nombre_alumno + " " + historial.apellido)
self.ventana.tHistorial.setItem(i, 2, newitem)
newitem = QTableWidgetItem(historial.nombre_grupo)
self.ventana.tHistorial.setItem(i, 3, newitem)
if historial.accion == 1:
# Añadir
newitem_anadir = QTableWidgetItem("Añadir")
newitem_anadir.setIcon(QtGui.QIcon("plasma-next-icons/Breeze/actions/toolbar/list-add.svg"))
self.ventana.tHistorial.setItem(i, 4, newitem_anadir)
else:
# Eliminar
newitem_eliminar = QTableWidgetItem("Eliminar")
newitem_eliminar.setIcon(QtGui.QIcon("plasma-next-icons/Breeze/actions/toolbar/edit-delete.svg"))
self.ventana.tHistorial.setItem(i, 4, newitem_eliminar)
newitem = QTableWidgetItem(historial.informacion)
self.ventana.tHistorial.setItem(i, 5, newitem)
newitem = QTableWidgetItem(historial.fecha_creacion_h)
self.ventana.tHistorial.setItem(i, 6, newitem)
# Liberamos las señales
self.ventana.tHistorial.blockSignals(False)
def setLine(color, row, column, text, icon=None):
try:
brush = QBrush(color)
brush.setStyle(Qt.SolidPattern)
i = Globals.MainWindow.R_RaceLive.item(row, column)
if i == None:
i = QTableWidgetItem(text)
Globals.MainWindow.R_RaceLive.setItem(row, column, i)
else:
i.setText(text)
i.setBackground(brush)
if icon is not None:
i.setIcon(icon)
else:
i.setIcon(QIcon())
except Exception as e:
print("in update, setLine( color,%d,%d,%s)" %
(row, column, text))
print(color)
print(e)
def add_item_on_file_table(cls, package):
"""
像指定表格对象添加指定的特定格式数据数据
"""
for index, file_obj in enumerate(package.data.listdir):
file_obj = Dict(file_obj)
# 插入空行
package.widget.insertRow(index)
# =============文件图标
item0 = QTableWidgetItem()
item0.setText(file_obj.name)
provider = QFileIconProvider()
item0.setIcon(
provider.icon(
QFileInfo(
ICO.FILE_TYPE_ICO.get(file_obj.type, "ico/txt.txt"))))
# f_t_widget.setRowHeight(index, 20)
package.widget.setItem(index, 0, item0)
# =============文件大小
item3 = QTableWidgetItem()
# item3.setFont(self.fileInfoWidget.global_row_font)
item3.setText(file_obj.size)
package.widget.setItem(index, 1, item3)
# =============文件类型
item2 = QTableWidgetItem()
# item2.setFont(self.fileInfoWidget.global_row_font)
# fileType = provider.type(QFileInfo(abs_file_path))
item2.setText(file_obj.type)
package.widget.setItem(index, 2, item2)
# ============最后修改时间
item1 = QTableWidgetItem()
# item1.setFont(self.fileInfoWidget.global_row_font)
# mtime = os.path.getmtime(abs_file_path)
item1.setText(file_obj.last_time)
package.widget.setItem(index, 3, item1)
return True
def _update_dictionaries(self, config_dictionaries=None, loaded_dictionaries=None,
reverse_order=None, record=True, save=True,
reset_undo=False, keep_selection=True):
if reverse_order is None:
reverse_order = self._reverse_order
if config_dictionaries is None:
config_dictionaries = self._config_dictionaries
if config_dictionaries == self._config_dictionaries and \
reverse_order == self._reverse_order and \
loaded_dictionaries is None:
return
if save:
self._engine.config = { 'dictionaries': config_dictionaries }
if record:
self._states.append(self._config_dictionaries)
self.action_Undo.setEnabled(True)
if keep_selection:
selected = [
self._config_dictionaries[row].path
for row in self._get_selection()
]
self._config_dictionaries = config_dictionaries
if loaded_dictionaries is None:
loaded_dictionaries = self._loaded_dictionaries
else:
self._loaded_dictionaries = loaded_dictionaries
self._reverse_order = reverse_order
self._updating = True
self.table.setRowCount(len(config_dictionaries))
favorite_set = False
for n, dictionary in enumerate(config_dictionaries):
row = n
if self._reverse_order:
row = len(config_dictionaries) - row - 1
item = QTableWidgetItem(dictionary.short_path)
item.setFlags((item.flags() | Qt.ItemIsUserCheckable) & ~Qt.ItemIsEditable)
item.setCheckState(Qt.Checked if dictionary.enabled else Qt.Unchecked)
item.setToolTip(dictionary.path)
self.table.setItem(row, 0, item)
item = QTableWidgetItem(str(n + 1))
if dictionary.path not in loaded_dictionaries:
icon = 'loading'
else:
d = loaded_dictionaries.get(dictionary.path)
if isinstance(d, ErroredDictionary):
icon = 'error'
item.setToolTip(str(d.exception))
elif d.readonly:
icon = 'readonly'
elif not favorite_set and dictionary.enabled:
icon = 'favorite'
favorite_set = True
else:
icon = 'normal'
item.setIcon(QIcon(':/dictionary_%s.svg' % icon))
self.table.setVerticalHeaderItem(row, item)
if keep_selection:
row_list = []
for path in selected:
for n, d in enumerate(config_dictionaries):
if d.path == path:
row_list.append(n)
break
self._set_selection(row_list)
if reset_undo:
self.action_Undo.setEnabled(False)
self._states = []
self._updating = False
self.on_selection_changed()
def init_table(self):
"""Generates a table with the song scores."""
# Prepare table for inserting items
self.table.clearContents()
self.table.setSortingEnabled(False)
# Current table row
current_row = 0
for song in self.stats.find("SongScores"):
# Current table row
current_column = 0
# Get the song's group and title
# location[0] should always be "Songs"
location = song.attrib['Dir'].split('/')
# Create group cell
group = QTableWidgetItem(location[1])
self.table.setItem(current_row, current_column, group)
current_column = current_column + 1
# Create title cell
title = QTableWidgetItem(location[2])
self.table.setItem(current_row, current_column, title)
current_column = current_column + 1
# step_counter will be used for traversing the scores in a song
step_counter = 0
for diff in self.difficulties:
try:
if (song[step_counter].attrib['Difficulty'] == diff and
song[step_counter].attrib['StepsType'] == self.mode):
try:
grade = smformat.highscore_grade(song[step_counter], self.theme)
percent = float(parse.highscore_stat(song[step_counter], "PercentDP")) * 100
if self.theme == "sm5" and self.icons_enabled is True:
cell = QTableWidgetItem('{:.2f}%'.format(percent))
cell.setIcon(QIcon(smtracker.__path__[0] + '/images/' + grade + '.png'))
else:
cell = QTableWidgetItem('{} ({:.2f}%)'.format(grade, percent))
# Get the timings for our song
timings = parse.highscore_timings(song[step_counter])
# TODO: Figure out if there's a cleaner way of
# doing this
tooltip = """Marvelous: {}
Perfect: {}
Great: {}
Good: {}
Boo: {}
Miss: {}
-----
Modifiers: {}
-----
SN2 Score: {}
DDRA Score: {}
IIDX EX Score: {}""".format(timings['W1'], timings['W2'], timings['W3'], timings['W4'],
timings['W5'], timings['Miss'],
parse.highscore_stat(song[step_counter], "Modifiers"),
parse.calculate_score_supernova2(song[step_counter]),
parse.calculate_score_ddra(song[step_counter]),
parse.calculate_score_iidx(song[step_counter]))
cell.setToolTip(tooltip)
self.table.setItem(current_row, current_column, cell)
# This exception is reached if a Song was played, but
# has no score (AutoPlay, PlayerAutoPlay)
except AttributeError:
cell = QTableWidgetItem()
self.table.setItem(current_row, current_column, cell)
step_counter = step_counter + 1
# If there are no scores for the current difficulty,
# add an empty cell instead
else:
cell = QTableWidgetItem()
self.table.setItem(current_row, current_column, cell)
# This exception is reached if we already reached the last
# score on a song (using step_counter)
except IndexError:
cell = QTableWidgetItem()
self.table.setItem(current_row, current_column, cell)
current_column = current_column + 1
current_row = current_row + 1
# Final table adjustments
self.table.resizeColumnsToContents()
self.table.setSortingEnabled(True)
self.table.sortByColumn(0, Qt.AscendingOrder)
