def feed(self):
"""
Populate table with result of executed query
:return: None
"""
self.resultTable.clear()
self.resultTable.maxRenderRecords = self.context.editor['result.renderCount']
try:
self.resultTable.setColumnCount(len(self.context.xpqe['execute.header']))
self.resultTable.setRowCount(min(self.resultTable.maxRenderRecords, len(self.result)))
self.resultTable.setHorizontalHeaderLabels(self.context.xpqe['execute.header'])
self.resultTable.setSortingEnabled(True)
for itr, column in enumerate(self.context.xpqe['execute.header']):
self.resultTable.horizontalHeaderItem(itr).setToolTip(column)
for itr_r, row in enumerate(self.result[:self.resultTable.maxRenderRecords]
if len(self.result) >= self.resultTable.maxRenderRecords else self.result):
self.resultTable.setRowHeight(itr_r, 18)
for itr_c, cell in enumerate(row.items()):
cell_value = str('' if cell[1] is None else cell[1])
cell_value_4tooltip = str('NULL' if cell[1] is None else cell[1])
item = QTableWidgetItem(cell_value)
item.setToolTip(cell_value_4tooltip)
self.resultTable.setItem(itr_r, itr_c, item)
self.resultTable.resultCount.setText('Showing {:,} of {:,} records'.format(
self.resultTable.maxRenderRecords if self.cursor.rowcount > self.resultTable.maxRenderRecords else self.cursor.rowcount,
self.cursor.rowcount
))
except Exception as e:
self.log.error(e)
def draw_file_header_table(self):
header_lang = self.parent_.lang.headers_info[1]['file_header']
table = QTableWidget(count_positions(header_lang[2]), 3)
table.setEditTriggers(QAbstractItemView.NoEditTriggers)
table.verticalHeader().setVisible(False)
table.setHorizontalHeaderLabels(header_lang[1])
fill_table(table, self.parent_.exe_file.file_header, header_lang[2])
fields = self.parent_.exe_file.file_header
date_index = (list(fields.keys()).index('creatingTime'))
form = header_lang[2]['creatingTime'][1] if isinstance(
header_lang[2]['creatingTime'],
tuple) else fields['creatingTime'][2]
item = QTableWidgetItem(fields['creatingTime'][1](form))
item.setToolTip(item.text())
table.setItem(date_index, 2, item)
char_index = (list(fields.keys()).index('characteristics'))
item = QPushButton('click me')
item.clicked.connect(self.characteristics.show)
table.setIndexWidget(table.model().index(char_index, 2), item)
return table
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)
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 displayUploads(self, upload_list):
keys = ["State",
"Status",
"File"]
hidden = ["State"]
self.ui.uploadList.setRowCount(len(upload_list))
self.ui.uploadList.setColumnCount(len(keys))
rows = 0
for row in upload_list:
cols = 0
for key in keys:
item = QTableWidgetItem()
value = row.get(key)
text = str(value) or ""
item.setText(text)
item.setToolTip("<span>" + text + "</span>")
self.ui.uploadList.setItem(rows, cols, item)
if key in hidden:
self.ui.uploadList.hideColumn(cols)
cols += 1
rows += 1
self.ui.uploadList.setHorizontalHeaderLabels(keys) # add header names
self.ui.uploadList.horizontalHeader().setDefaultAlignment(Qt.AlignLeft) # set alignment
self.ui.uploadList.resizeColumnToContents(0)
def updatePaybackPeriod(self, value):
'''takes a string. Updates relevant portion in table'''
if float(value) < 0:
value ='Payback not earned.'
widget = QTableWidgetItem(value)
widget.setToolTip(self.paybackToolTip)
self.tableGeneral.setItem(6, 0, widget)
def setup_his_tab(my_app):
""" fills history tab"""
a = my_app
a.tbl_his.clear()
# update with latest results
db = DBHis(ctx.db_his)
r = db.get_recent_records()
for i, h in enumerate(r):
mac, sn = h[1], h[2]
lat, lon, ts = h[3], h[4], h[5]
it = QTableWidgetItem(sn)
it.setToolTip(mac)
a.tbl_his.setItem(i, 0, it)
s = '{}'.format(lat)
s += ',{}'.format(lon) if lon else ''
a.tbl_his.setItem(i, 1, QTableWidgetItem(s))
# 2021/03/01 14:56:34 -> '21/03/01 14:56'
a.tbl_his.setItem(i, 2, QTableWidgetItem(ts[2:-3]))
a.tbl_his.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
labels = ['serial', 'last position', 'last time']
a.tbl_his.setHorizontalHeaderLabels(labels)
# columns table hack
header = a.tbl_his.horizontalHeader()
header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeToContents)
def adornInfoReceived(self, adorn_info):
aid2info = {}
for each in adorn_info['item_list']:
text = eq2s_func.CookItemText(each, short=True).text
text = '{}<br>{}'.format(each['displayname'], text)
aid2info[each['id']] = text
# print(each['id'], '\n', text, '\n')
for each in self.adornIDList:
# get the table position of each adornment
tablePos = eq2s_func.slot2position(each[1])
# attach adorn text into each table item
try:
if tablePos[0] == 'l':
t = self.leftEquipTable.item(tablePos[1], 0).toolTip()
t += '<br>{}'.format(aid2info[each[0]])
self.leftEquipTable.item(tablePos[1], 0).setToolTip(t)
self.leftEquipTable.item(tablePos[1], 1).setToolTip(t)
elif tablePos[0] == 'r':
t = self.rightEquipTable.item(tablePos[1], 0).toolTip()
t += '<br>{}'.format(aid2info[each[0]])
self.rightEquipTable.item(tablePos[1], 0).setToolTip(t)
self.rightEquipTable.item(tablePos[1], 1).setToolTip(t)
except AttributeError:
badPosition = QTableWidgetItem(
'Missing Item from DBG Databases')
badPosition.setTextAlignment(Qt.AlignCenter)
badPosition.setToolTip(aid2info[each[0]])
if tablePos[0] == 'l':
self.leftEquipTable.setItem(tablePos[1], 0, badPosition)
elif tablePos[0] == 'r':
self.rightEquipTable.setItem(tablePos[1], 1, badPosition)
def fillAchTable(self, achs):
tm = []
untm = []
tm_achs = {}
for each in achs:
if each['completed_timestamp']:
tm.append(each['completed_timestamp'])
tm_achs[each['completed_timestamp']] = each
else:
untm.append(each)
r = 0
for each in sorted(tm, reverse=True):
ct = QTableWidgetItem(
datetime.fromtimestamp(each).isoformat().replace('T', ' '))
ct.setTextAlignment(Qt.AlignCenter)
self.achTable.setItem(r, 0, ct)
nm = QTableWidgetItem(tm_achs[each]['name'])
nm.setTextAlignment(Qt.AlignCenter)
nm.setToolTip(tm_achs[each]['desc'])
self.achTable.setItem(r, 1, nm)
pts = QTableWidgetItem(str(tm_achs[each]['points']))
pts.setTextAlignment(Qt.AlignCenter)
self.achTable.setItem(r, 2, pts)
tp = QTableWidgetItem(tm_achs[each]['category'])
tp.setTextAlignment(Qt.AlignCenter)
self.achTable.setItem(r, 3, tp)
cate = QTableWidgetItem(tm_achs[each]['subcategory'])
cate.setTextAlignment(Qt.AlignCenter)
self.achTable.setItem(r, 4, cate)
r += 1
for each in untm:
try:
ct = QTableWidgetItem('Uncompleted')
ct.setTextAlignment(Qt.AlignCenter)
self.achTable.setItem(r, 0, ct)
nm = QTableWidgetItem(each['name'])
nm.setTextAlignment(Qt.AlignCenter)
nm.setToolTip(each['desc'])
self.achTable.setItem(r, 1, nm)
pts = QTableWidgetItem(str(each['points']))
pts.setTextAlignment(Qt.AlignCenter)
self.achTable.setItem(r, 2, pts)
tp = QTableWidgetItem(each['category'])
tp.setTextAlignment(Qt.AlignCenter)
self.achTable.setItem(r, 3, tp)
cate = QTableWidgetItem(each['subcategory'])
cate.setTextAlignment(Qt.AlignCenter)
self.achTable.setItem(r, 4, cate)
except KeyError:
pass
r += 1
self.achTable.horizontalHeader().setSectionResizeMode(
0, QHeaderView.ResizeToContents)
self.achTable.horizontalHeader().setSectionResizeMode(
2, QHeaderView.ResizeToContents)
self.achTable.horizontalHeader().setSectionResizeMode(
3, QHeaderView.ResizeToContents)
self.achTable.horizontalHeader().setSectionResizeMode(
4, QHeaderView.ResizeToContents)
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 updateTableSlot(self, val):
"""线程通过该槽，刷新进度条，表格内容"""
if val:
self.taskVal += val
self.progressVal = self.taskVal / len(self.tableContents) * 100
self.progressBar.setValue(self.progressVal)
self.label.setText("%s/%s" %
(self.taskVal, len(self.tableContents)))
self.tableWidget.setRowCount(len(self.tableContents)) # 行数
for n, i in enumerate(self.tableContents):
items = i.dump()
for j in range(self.tableWidget.columnCount()):
item = QTableWidgetItem(items[j])
if j in [0, 1]:
item.setToolTip(item.text())
self.tableWidget.setItem(n, j, item)
self.setStatusColor(n)
self.setBackgroundColor(self.bgColor)
if self.progressVal == 100:
self.wtime[1] = int(time.time())
self.statusbar.showMessage(
self.tr("finished (work time %ds)") %
(self.wtime[1] - self.wtime[0]))
def _set_col_description(self, col: int, pkg: PackageView):
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
if pkg.model.description is not None or not pkg.model.is_application(
) or pkg.model.status == PackageStatus.READY:
desc = pkg.model.description
else:
desc = '...'
if desc and desc != '...' and len(desc) > DESC_MAX_SIZE:
desc = strip_html(desc[0:DESC_MAX_SIZE - 1]) + '...'
if not desc:
desc = ' ' * DESC_MAX_SIZE
if len(desc) < DESC_MAX_SIZE:
desc = desc + ' ' * (DESC_MAX_SIZE - len(desc))
item.setText(desc)
if pkg.model.description:
item.setToolTip(pkg.model.description)
self.setItem(pkg.table_index, col, item)
def show_local_music_page_data(self):
self.label_2.setText("%d首音乐" % len(self.curWholeMusicList.musics))
self.tb_local_music.clearContents()
self.tb_local_music.setRowCount(len(self.curMusicList.musics))
self.set_tb_local_music_layout()
for i in range(len(self.curMusicList.musics)):
music = self.curMusicList.get(i)
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setText(str(i + 1) + " ")
self.tb_local_music.setItem(i, 0, item)
item = QTableWidgetItem(music.title)
item.setToolTip(str(music.title))
self.tb_local_music.setItem(i, 1, item)
item = QTableWidgetItem(music.artist)
item.setToolTip(str(music.artist))
self.tb_local_music.setItem(i, 2, item)
item = QTableWidgetItem(music.album)
item.setToolTip(str(music.album))
self.tb_local_music.setItem(i, 3, item)
item = QTableWidgetItem(util.format_time(music.duration))
item.setToolTip(util.format_time(music.duration))
self.tb_local_music.setItem(i, 4, item)
item = QTableWidgetItem(music.size)
item.setToolTip(str(music.size))
self.tb_local_music.setItem(i, 5, item)
self.setIconItem()
def fillTableGrouped(self, tableWidget, curaDataMerge):
row = 0
no = curaDataMerge.getSize()
tableWidget.setRowCount(no)
if 'values' in curaDataMerge.sections:
d = curaDataMerge.sections['values']
for gkey in self.AllKeys:
for key in self.AllKeys[gkey]:
if key not in d:
continue
item = QTableWidgetItem(gkey.capitalize())
tableWidget.setItem(row, groupColumn, item)
# for k1, v1 in section.items():
info = findKeyInfo(self.infoJson, key)
if info is not None:
item = QTableWidgetItem(info['label'])
desc = info['description'].replace('.', '.\n')
item.setToolTip(desc.strip())
tableWidget.setItem(row, nameColumn, item)
else:
tableWidget.setItem(row, nameColumn, QTableWidgetItem(""))
self.fillTableValues(row, d, key, tableWidget)
row = row + 1
def add_row(self, row: list) -> None:
if self.scrapeThread.isInterruptionRequested():
self.scrapeThread.terminate()
else:
self.cols = 0
self.table.setRowCount(self.rows + 1)
if self.table.cursor() != Qt.PointingHandCursor:
self.table.setCursor(Qt.PointingHandCursor)
for item in row:
table_item = QTableWidgetItem(item)
table_item.setToolTip(
'%s\n\nDouble-click to view hoster links.' % row[1])
table_item.setFont(QFont('Open Sans', weight=QFont.Normal))
if self.cols == 2:
if sys.platform == 'win32':
table_item.setFont(
QFont('Open Sans Semibold', pointSize=10))
elif sys.platform == 'darwin':
table_item.setFont(
QFont('Open Sans Bold', weight=QFont.Bold))
else:
table_item.setFont(
QFont('Open Sans',
weight=QFont.DemiBold,
pointSize=10))
table_item.setText(' ' + table_item.text())
elif self.cols in (0, 3):
table_item.setTextAlignment(Qt.AlignCenter)
self.table.setItem(self.rows, self.cols, table_item)
self.update_metabar()
self.cols += 1
self.rows += 1
def __init__(self, app: dict, icon_cache: Cache, locale_keys: dict):
super(HistoryDialog, self).__init__()
self.setWindowTitle('{} - {} '.format(
locale_keys['popup.history.title'], app['model'].base_data.name))
layout = QVBoxLayout()
self.setLayout(layout)
table_history = QTableWidget()
table_history.setFocusPolicy(Qt.NoFocus)
table_history.setShowGrid(False)
table_history.verticalHeader().setVisible(False)
table_history.setAlternatingRowColors(True)
table_history.setColumnCount(len(app['history'][0]))
table_history.setRowCount(len(app['history']))
table_history.setHorizontalHeaderLabels([
locale_keys['flatpak.info.' + key].capitalize()
for key in sorted(app['history'][0].keys())
])
for row, commit in enumerate(app['history']):
current_app_commit = app['model'].commit == commit['commit']
for col, key in enumerate(sorted(commit.keys())):
item = QTableWidgetItem()
item.setText(commit[key])
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
if current_app_commit:
item.setBackground(
QColor('#ffbf00' if row != 0 else '#32CD32'))
tip = '{}. {}.'.format(
locale_keys['popup.history.selected.tooltip'],
locale_keys['version.{}'.format(
'updated' if row ==
0 else 'outdated')].capitalize())
item.setToolTip(tip)
table_history.setItem(row, col, item)
layout.addWidget(table_history)
header_horizontal = table_history.horizontalHeader()
for i in range(0, table_history.columnCount()):
header_horizontal.setSectionResizeMode(i, QHeaderView.Stretch)
new_width = reduce(operator.add, [
table_history.columnWidth(i)
for i in range(table_history.columnCount())
])
self.resize(new_width, table_history.height())
icon_data = icon_cache.get(app['model'].base_data.icon_url)
if icon_data and icon_data.get('icon'):
self.setWindowIcon(icon_data.get('icon'))
def populate_table(self, search_by, column_count: int, headers: list):
self.finance_result_table.clearContents()
content = []
if search_by == "flat":
content = get_search_content(
search_by=search_by,
search_attribute=self.flat_combo.currentText())
elif search_by == "date":
date = self.date_line.date().toPyDate()
content = get_search_content(search_by=search_by,
search_attribute=fix_date(str(date)))
elif search_by == "month":
content = get_search_content(search_by=search_by,
search_attribute=str(
self.month_combo.currentIndex()))
self.finance_result_table.setRowCount(len(content))
self.finance_result_table.setColumnCount(column_count)
self.finance_result_table.setHorizontalHeaderLabels(headers)
header = self.finance_result_table.horizontalHeader()
header.setSectionResizeMode(QHeaderView.Stretch)
for index, row in enumerate(content):
for inner_index, row_content in enumerate(row):
table_item = QTableWidgetItem(str(row_content))
table_item.setToolTip(str(row_content))
if 'A - ' in str(row_content) or inner_index == 0:
table_item.setTextAlignment(Qt.AlignCenter)
self.finance_result_table.setItem(index, inner_index,
table_item)
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 updateOverallGainPercent(self, value):
'''takes a string. Updates relevant portion in table'''
widget = QTableWidgetItem(value)
widget.setToolTip(self.gainPctToolTip)
if float(value.replace(',', '')) > 0:
widget.setForeground(QBrush(QColor(0,255,0)))
else:
widget.setForeground(QBrush(QColor(255,0,0)))
self.tableGeneral.setItem(5, 0, widget)
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 create_replay_table_widget_item(text: str, editable: bool = False, tooltip: str = None):
item = QTableWidgetItem(text)
if tooltip is None:
item.setToolTip(text)
else:
item.setToolTip(tooltip)
if not editable:
item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEditable)
return item
def set_data(self, data):
for i, n in enumerate(data):
for j, m in enumerate(n):
item = QTableWidgetItem(str(m))
item.setTextAlignment(Qt.AlignCenter)
try:
item.setToolTip(self.config.names[(i, j)])
except KeyError:
pass
self.tablewidget.setItem(i, j, item)
def update_item_view(self):
"""Update item details view with data from currently selected item."""
try:
selected = self.ui.items.selectedItems()[0].name
except IndexError:
return
try:
item = self.items.get_item(selected)
except TypeError:
logging.warning("Unable to load asset "+selected)
return
image_file = self.items.get_item_image(selected)
if image_file == None:
inv_icon_file = self.items.get_item_icon(selected)
if inv_icon_file != None:
icon = QPixmap.fromImage(ImageQt(inv_icon_file)).scaled(32, 32)
else:
icon = QPixmap.fromImage(QImage.fromData(self.items.missing_icon())).scaled(32, 32)
else:
icon = QPixmap.fromImage(ImageQt(image_file)).scaledToHeight(64)
# last ditch
try:
self.ui.item_icon.setPixmap(icon)
except TypeError:
logging.warning("Unable to load item image: "+selected)
self.ui.item_icon.setPixmap(QPixmap())
# TODO: update qt objectnames, already not making sense
try:
self.ui.item_name.setText(item[0]["shortdescription"])
except KeyError:
self.ui.item_name.setText("Missing short description")
try:
self.ui.short_desc.setText(item[0]["description"])
except KeyError:
self.ui.short_desc.setText("Missing description")
# populate default variant table
row = 0
self.ui.info.setRowCount(len(item[0]))
for key in sorted(item[0].keys()):
try:
text = str(key) + ": " + str(item[0][key])
table_item = QTableWidgetItem(text)
table_item.setToolTip(text)
self.ui.info.setItem(row, 0, table_item)
except TypeError:
pass
row += 1
self.item_browse_select = selected
def fillTable(self, dataframe):
self.setColumnCount(len(dataframe.columns))
self.setRowCount(len(dataframe.index))
for i in range(len(dataframe.index)):
for j in range(len(dataframe.columns)):
item = QTableWidgetItem(str(dataframe.iloc[i, j]))
item.setToolTip(str(dataframe.iloc[i, j]))
self.setItem(i, j, item)
self.setHorizontalHeaderLabels(dataframe.columns)
self.setColumnWidth(0, 300)
self.setColumnWidth(1, 150)
def createDialog(self):
##ADD NEW VI AND THEIR OPTIONS##
VI = [ ["Color",["10m (B3)", "20m(B3,B6)", "60m (B1,B3,B6)"]],
["OTCI", ["10m (B4)", "20m (B4,B5,B6)","60m (B5,B6,B6)"]],
["MCARI",["10m (B3,B4)","20m (B3,B4,B5)","60m (B3,B4,B5)"]],
["IRECI",["10m (B4)","20m (B4,B5,B6,B7)","60m (B4,B5,B6,B7)"]],
["CCCI",["20m (B5,B6,B7)", "60m (B5,B6,B7)"]],
["NDRE",["20m (B5,B6,B7)", "60m (B5,B6,B7)"]],
["MTCI", ["10m (B4)", "20m (B4,B5,B6)","60m(B4,B5,B6)"]],
["CI_redEdge",["20m (B5,B7)","60m (B5,B7)"]],
["CI_greenEdge",["10m (B3)","20m (B3,B7)","60m (B3,B7)"]],
["EVI",["10m (B2,B3,B4)","20m (B2,B3,B4)", "60m (B2,B3,B4)"]],
["NRERI",["10m (B4)","20m (B5,B6,B7)", "60m (B5,B6,B7)"]],
["NDVI705",["20m (B5,B6)", "60m (B5,B6)"]],
["mNDVI705",["20m (B5,B6)", "60m (B1,B5,B6)"]],
["NDI45", ["10m (B4)", "20m (B4,B5)","60m (B4,B5)"]],
["RDVI", ["10m (B4)", "20m (B4,B7)","60m (B4,B7)"]],
["TCARI", ["10m (B3,B4)", "20m (B3,B4,B5)", "60m (B3,B4,B5)"]],
["OSAVI", ["10m (B4)", "20m (B4,B7)", "60m (B4,B7)"]],
["TCARI/OSAVI", ["10m (B3,B4)", "20m (B3,B4,B5,B7)", "60m (B3,B4,B5,B7)"]]
]
self.dlg.tableWidget.setRowCount(0)#Delete al rows before insert
for row in range(len(VI)):
element = VI[row]
item = QTableWidgetItem(element[0])
self.dlg.tableWidget.insertRow(row)
self.dlg.tableWidget.setItem(row,0,item)#VI name
for options_n in range(len(element[1])):
opt = QTableWidgetItem(element[1][options_n])
opt.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
opt.setCheckState(Qt.Unchecked)
self.dlg.tableWidget.setItem(row,options_n+1,opt)#VI options
if element[0] == "CCCI":
#add input boxes for min max resample
item = QTableWidgetItem("0.62")
item2 = QTableWidgetItem("0.24")
item.setFlags(Qt.ItemIsEditable | Qt.ItemIsEnabled )
item2.setFlags(Qt.ItemIsEditable | Qt.ItemIsEnabled)
item.setToolTip("Max value")
item2.setToolTip("Min value")
self.dlg.tableWidget.setItem(row,len(element[1])+1,item)
self.dlg.tableWidget.setItem(row,len(element[1])+2,item2)
self.createdOptions = True
def _set_col_description(self, idx: int, app_v: ApplicationView):
col = QTableWidgetItem()
col.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
desc = app_v.get_async_attr('description', strip_html=True)
if desc:
col.setText(desc[0:25] + '...')
if app_v.model.status == ApplicationStatus.READY:
col.setToolTip(desc)
self.setItem(idx, 2, col)
def displayMembers(self):
rank = {}
for each in self.guildDitail['rank_list']:
rank[each['id']] = each['name']
mlist = {0:[], 1:[], 2:[], 3:[], 4:[], 5:[], 6:[], 7:[], 8:[]}
for each in self.guildDitail['member_list']:
m = {}
if isinstance(each['name'], dict):
m = {'name': each['name']['first']}
elif isinstance(each['name'], str):
m = {'name': each['name']}
try:
m['adclass'] = each['type']['class']
m['adlv'] = each['type']['level']
m['join'] = datetime.fromtimestamp(each['guild']['joined']).isoformat()
m['id'] = each['id']
except:
pass
if 'id' in m.keys():
mlist[each['guild']['rank']].append(m)
else:
mlist[8].append(m)
self.guild_members_table.setRowCount(len(self.guildDitail['member_list']))
r = 0
for e in range(8):
for m in mlist[e]:
try:
rankitem = QTableWidgetItem(rank[e])
rankitem.setTextAlignment(Qt.AlignCenter)
self.guild_members_table.setItem(r, 0, rankitem)
nmitem = QTableWidgetItem(m['name'])
nmitem.setTextAlignment(Qt.AlignCenter)
nmitem.setData(1000, m['id'])
nmitem.setToolTip('Click for character\'s detail')
self.guild_members_table.setItem(r, 1, nmitem)
if 'adclass' in m.keys():
adcls = QTableWidgetItem(m['adclass'])
adcls.setTextAlignment(Qt.AlignCenter)
self.guild_members_table.setItem(r, 2, adcls)
adlv = QTableWidgetItem(str(m['adlv']))
adlv.setTextAlignment(Qt.AlignCenter)
self.guild_members_table.setItem(r, 3, adlv)
jt = QTableWidgetItem(m['join'])
jt.setTextAlignment(Qt.AlignCenter)
self.guild_members_table.setItem(r, 4, jt)
except:
pass
r += 1
self.guild_members_table.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)
self.guild_members_table.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeToContents)
self.guild_members_table.horizontalHeader().setSectionResizeMode(3, QHeaderView.ResizeToContents)
self.guild_members_table.horizontalHeader().setSectionResizeMode(4, QHeaderView.ResizeToContents)
def getFileTableQWidgetItem(self, dp: DataPoint):
shownName = dp.videoName.replace('m0', '')
shownName = ' '.join(shownName.split('_')[2:])
name = QTableWidgetItem(shownName)
name.setData(Qt.UserRole, dp.videoPath)
name.setToolTip(dp.videoPath)
done = QTableWidgetItem(' ')
if dp.hasBeenProcessed:
done = QTableWidgetItem(' ✓')
done.setData(Qt.UserRole, dp.videoPath)
done.setToolTip(dp.videoPath)
return name, done
def update_item_view(self):
"""Update item details view with data from currently selected item."""
try:
selected = self.ui.items.selectedItems()[0].name
except IndexError:
return
try:
item = self.items.get_item(selected)
except TypeError:
logging.warning("Unable to load asset " + selected)
return
inv_icon_file = self.items.get_item_icon(selected)
if inv_icon_file is not None:
icon = QPixmap.fromImage(ImageQt(inv_icon_file))
else:
image_file = self.items.get_item_image(selected)
if image_file is not None:
icon = QPixmap.fromImage(ImageQt(image_file))
else:
icon = QPixmap.fromImage(
QImage.fromData(self.assets.items().missing_icon()))
# last ditch
try:
icon = self.scale_image_icon(icon, 64, 64)
self.ui.item_icon.setPixmap(icon)
except TypeError:
logging.warning("Unable to load item image: " + selected)
self.ui.item_icon.setPixmap(QPixmap())
self.ui.short_desc.setText(generate_item_info(item[0]))
# populate default variant table
try:
row = 0
self.ui.info.setRowCount(len(item[0]))
for key in sorted(item[0].keys()):
text = str(key) + ": " + str(item[0][key])
table_item = QTableWidgetItem(text)
table_item.setToolTip(text)
self.ui.info.setItem(row, 0, table_item)
row += 1
except TypeError:
self.ui.info.setRowCount(0)
logging.error("No item data")
self.item_browse_select = selected
def show_musics_data(self):
self.music_list_name.setText(self.curMusicList.name)
self.music_list_date.setText("%s创建" % self.curMusicList.created)
self.lb_music_count.setText(
"<p>歌曲数</p><p style='text-align: right'>%d</p>" %
len(self.curMusicList.musics))
self.lb_played_count.setText(
"<p>播放数</p><p style='text-align: right'>%d</p>" %
self.curMusicList.play_count)
self.musics.clearContents()
self.musics.setRowCount(len(self.curMusicList.musics))
musics__ = self.curMusicList
for i in range(len(musics__.musics)):
music = musics__.get(i)
item = QTableWidgetItem()
item.setData(Qt.UserRole, music)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setText(str(i + 1) + " ")
self.musics.setItem(i, 0, item)
item = QTableWidgetItem(str(music.title))
item.setToolTip(music.title)
self.musics.setItem(i, 1, item)
item = QTableWidgetItem(music.artist)
item.setToolTip(music.artist)
self.musics.setItem(i, 2, item)
item = QTableWidgetItem(music.album)
item.setToolTip(music.album)
self.musics.setItem(i, 3, item)
item = QTableWidgetItem(util.format_time(music.duration))
item.setToolTip(util.format_time(music.duration))
self.musics.setItem(i, 4, item)
def show_musics_data(self):
self.musics_table.clearContents()
self.musics_table.setRowCount(len(self.cur_music_list.musics_table))
musics__ = self.cur_music_list
for i in range(len(musics__.musics_table)):
music = musics__.get(i)
item = QTableWidgetItem()
item.setData(Qt.UserRole, music)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setText(str(i + 1) + " ")
self.musics_table.setItem(i, 0, item)
item = QTableWidgetItem(str(music.title))
item.setToolTip(music.title)
self.musics_table.setItem(i, 1, item)
item = QTableWidgetItem(music.artist)
item.setToolTip(music.artist)
self.musics_table.setItem(i, 2, item)
item = QTableWidgetItem(music.album)
item.setToolTip(music.album)
self.musics_table.setItem(i, 3, item)
item = QTableWidgetItem(util.format_time(music.duration))
item.setToolTip(util.format_time(music.duration))
self.musics_table.setItem(i, 4, item)
# 若当前播放的音乐属于该歌单, 则为其设置喇叭图标
self.set_icon_item()
def update_item_view(self):
"""Update item details view with data from currently selected item."""
try:
selected = self.ui.items.selectedItems()[0].name
except IndexError:
return
try:
item = self.items.get_item(selected)
except TypeError:
logging.warning("Unable to load asset "+selected)
return
inv_icon_file = self.items.get_item_icon(selected)
if inv_icon_file is not None:
icon = QPixmap.fromImage(ImageQt(inv_icon_file))
else:
image_file = self.items.get_item_image(selected)
if image_file is not None:
icon = QPixmap.fromImage(ImageQt(image_file))
else:
icon = QPixmap.fromImage(QImage.fromData(self.assets.items().missing_icon()))
# last ditch
try:
icon = self.scale_image_icon(icon, 64, 64)
self.ui.item_icon.setPixmap(icon)
except TypeError:
logging.warning("Unable to load item image: "+selected)
self.ui.item_icon.setPixmap(QPixmap())
self.ui.short_desc.setText(generate_item_info(item[0]))
# populate default variant table
try:
row = 0
self.ui.info.setRowCount(len(item[0]))
for key in sorted(item[0].keys()):
text = str(key) + ": " + str(item[0][key])
table_item = QTableWidgetItem(text)
table_item.setToolTip(text)
self.ui.info.setItem(row, 0, table_item)
row += 1
except TypeError:
self.ui.info.setRowCount(0)
logging.error("No item data")
self.item_browse_select = selected
def update_item_view(self):
"""Update item details view with data from currently selected item."""
try:
selected = self.ui.items.selectedItems()[0].text()
except IndexError:
return
item = self.items.get_item(selected)
# don't like so many queries but should be ok for the browser
icon_file = self.items.get_item_image(selected)
# fallback on inventory icon
if icon_file == None:
icon = inv_icon(selected)
else:
icon = QPixmap(icon_file).scaledToHeight(64)
# last ditch, just use x.png
try:
self.ui.item_icon.setPixmap(icon)
except TypeError:
self.ui.item_icon.setPixmap(QPixmap(self.items.missing_icon()))
# TODO: update qt objectnames, already not making sense
try:
self.ui.item_name.setText(item[0]["shortdescription"])
except KeyError:
self.ui.item_name.setText("Missing short description")
try:
self.ui.short_desc.setText(item[0]["description"])
except KeyError:
self.ui.short_desc.setText("Missing description")
# populate default variant table
row = 0
self.ui.info.setRowCount(len(item[0]))
for key in sorted(item[0].keys()):
try:
text = str(key) + ": " + str(item[0][key])
table_item = QTableWidgetItem(text)
table_item.setToolTip(text)
self.ui.info.setItem(row, 0, table_item)
except TypeError:
pass
row += 1
self.item_browse_select = selected
def updateTableSlot(self, val):
"""线程通过该槽，刷新进度条，表格内容"""
if val:
self.taskVal += val
self.progressVal = self.taskVal / len(self.tableContents) * 100
self.progressBar.setValue(self.progressVal)
self.label.setText("%s/%s" % (self.taskVal, len(self.tableContents)))
self.tableWidget.setRowCount(len(self.tableContents)) # 行数
for n, i in enumerate(self.tableContents):
items = i.dump()
for j in range(self.tableWidget.columnCount()):
item = QTableWidgetItem(items[j])
if j in [0, 1]:
item.setToolTip(item.text())
self.tableWidget.setItem(n, j, item)
self.setStatusColor(n)
self.setBackgroundColor(self.bgColor)
if self.progressVal == 100:
self.wtime[1] = int(time.time())
self.statusbar.showMessage(self.tr(
"finished (work time %ds)") % (self.wtime[1] - self.wtime[0]))
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__(self, parent=None):
"""Init class."""
super(MainWindow, self).__init__()
self.setWindowTitle(__doc__.strip().capitalize())
self.statusBar().showMessage(" Choose one App and move the sliders !")
self.setMinimumSize(480, 240)
self.setMaximumSize(640, 2048)
self.setWindowIcon(QIcon.fromTheme("preferences-system"))
self.center()
QShortcut("Ctrl+q", self, activated=lambda: self.close())
self.menuBar().addMenu("&File").addAction("Exit", exit)
windowMenu = self.menuBar().addMenu("&Window")
windowMenu.addAction("Minimize", lambda: self.showMinimized())
windowMenu.addAction("Maximize", lambda: self.showMaximized())
windowMenu.addAction("Restore", lambda: self.showNormal())
windowMenu.addAction("FullScreen", lambda: self.showFullScreen())
windowMenu.addAction("Center", lambda: self.center())
windowMenu.addAction("Top-Left", lambda: self.move(0, 0))
windowMenu.addAction("To Mouse", lambda: self.move_to_mouse_position())
windowMenu.addSeparator()
windowMenu.addAction(
"Increase size", lambda:
self.resize(self.size().width() * 1.4, self.size().height() * 1.4))
windowMenu.addAction("Decrease size", lambda: self.resize(
self.size().width() // 1.4, self.size().height() // 1.4))
windowMenu.addAction("Minimum size", lambda:
self.resize(self.minimumSize()))
windowMenu.addAction("Maximum size", lambda:
self.resize(self.maximumSize()))
windowMenu.addAction("Horizontal Wide", lambda: self.resize(
self.maximumSize().width(), self.minimumSize().height()))
windowMenu.addAction("Vertical Tall", lambda: self.resize(
self.minimumSize().width(), self.maximumSize().height()))
windowMenu.addSeparator()
windowMenu.addAction("Disable Resize", lambda:
self.setFixedSize(self.size()))
windowMenu.addAction("Set Interface Font...", lambda:
self.setFont(QFontDialog.getFont()[0]))
helpMenu = self.menuBar().addMenu("&Help")
helpMenu.addAction("About Qt 5", lambda: QMessageBox.aboutQt(self))
helpMenu.addAction("About Python 3",
lambda: open_new_tab('https://www.python.org'))
helpMenu.addAction("About" + __doc__,
lambda: QMessageBox.about(self, __doc__, HELP))
helpMenu.addSeparator()
helpMenu.addAction(
"Keyboard Shortcut",
lambda: QMessageBox.information(self, __doc__, "<b>Quit = CTRL+Q"))
helpMenu.addAction("View Source Code",
lambda: call('xdg-open ' + __file__, shell=True))
helpMenu.addAction("View GitHub Repo", lambda: open_new_tab(__url__))
helpMenu.addAction("Report Bugs", lambda: open_new_tab(
'https://github.com/juancarlospaco/pyority/issues?state=open'))
helpMenu.addAction("Check Updates", lambda: Downloader(self))
container, child_container = QWidget(), QWidget()
container_layout = QVBoxLayout(container)
child_layout = QHBoxLayout(child_container)
self.setCentralWidget(container)
# widgets
group0 = QGroupBox("My Apps")
group1, group2 = QGroupBox("CPU Priority"), QGroupBox("HDD Priority")
child_layout.addWidget(group0)
child_layout.addWidget(group1)
child_layout.addWidget(group2)
container_layout.addWidget(child_container)
# table
self.table = QTableWidget()
self.table.setColumnCount(1)
self.table.verticalHeader().setVisible(True)
self.table.horizontalHeader().setVisible(False)
self.table.setShowGrid(False)
self.table.setAlternatingRowColors(True)
self.table.setIconSize(QSize(64, 64))
self.table.setSelectionMode(QAbstractItemView.SingleSelection)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
# Graphic effect
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(9)
glow.setColor(QColor(99, 255, 255))
self.table.setGraphicsEffect(glow)
glow.setEnabled(True)
processes = self.generate_process_list()
self.table.setRowCount(len(processes))
for index, process in enumerate(processes):
item = QTableWidgetItem(
QIcon.fromTheme(process.name().split()[0].split('/')[0]),
process.name().split()[0].split('/')[0].strip())
item.setData(Qt.UserRole, process)
item.setToolTip("{}, {}, {}, {}".format(
process.name(), process.nice(),
process.ionice()[1], process.pid))
self.table.setItem(index, 0, item)
self.table.clicked.connect(lambda: self.sliderhdd.setDisabled(False))
self.table.clicked.connect(lambda: self.slidercpu.setDisabled(False))
self.table.clicked.connect(lambda: self.slidercpu.setValue(
int(tuple(self.table.currentItem().toolTip().split(","))[1])))
self.table.clicked.connect(lambda: self.sliderhdd.setValue(
int(tuple(self.table.currentItem().toolTip().split(","))[2])))
self.table.resizeColumnsToContents()
# self.table.resizeRowsToContents()
# sliders
self.slidercpu = QSlider()
self.slidercpu.setRange(0, 19)
self.slidercpu.setSingleStep(1)
self.slidercpu.setTickPosition(3)
self.slidercpu.setDisabled(True)
self.slidercpu.setInvertedAppearance(True)
self.slidercpu.setInvertedControls(True)
self.slidercpu.valueChanged.connect(self.set_cpu_value)
self.slidercpu.valueChanged.connect(
lambda: self.slidercpu.setToolTip(str(self.slidercpu.value())))
# Timer to start
self.slidercpu_timer = QTimer(self)
self.slidercpu_timer.setSingleShot(True)
self.slidercpu_timer.timeout.connect(self.on_slidercpu_timer_timeout)
QLabel(self.slidercpu).setPixmap(
QIcon.fromTheme("list-add").pixmap(16))
QVBoxLayout(group1).addWidget(self.slidercpu)
self.sliderhdd = QSlider()
self.sliderhdd.setRange(0, 7)
self.sliderhdd.setSingleStep(1)
self.sliderhdd.setTickPosition(3)
self.sliderhdd.setDisabled(True)
self.sliderhdd.setInvertedAppearance(True)
self.sliderhdd.setInvertedControls(True)
self.sliderhdd.valueChanged.connect(self.set_hdd_value)
self.sliderhdd.valueChanged.connect(
lambda: self.sliderhdd.setToolTip(str(self.sliderhdd.value())))
# Timer to start
self.sliderhdd_timer = QTimer(self)
self.sliderhdd_timer.setSingleShot(True)
self.sliderhdd_timer.timeout.connect(self.on_sliderhdd_timer_timeout)
QLabel(self.sliderhdd).setPixmap(
QIcon.fromTheme("list-add").pixmap(16))
QVBoxLayout(group2).addWidget(self.sliderhdd)
QVBoxLayout(group0).addWidget(self.table)
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)
def createRow(self, param, name_editable=False, value_editable=True, comments_editable=True, index=-1):
"""
Create a row in the table for a param.
Input:
param: ParamNode
Return:
BaseRowItem derived object
"""
row = self.rowCount()
if index >= 0:
row = index
self.insertRow(row)
name_item = QTableWidgetItem(param.name)
name_item.setData(Qt.UserRole, param)
if not name_editable:
name_item.setFlags(Qt.ItemIsEnabled)
if param.required:
color = QColor(255, 204, 153)
brush = QBrush(color)
name_item.setBackground(brush)
elif param.user_added:
color = QColor("cyan")
brush = QBrush(color)
name_item.setBackground(brush)
name_item.setText(param.name)
self.setItem(row, 0, name_item)
if param.cpp_type == "bool":
checkbox = QCheckBox()
if param.value == "true":
checkbox.setCheckState(Qt.Checked)
else:
checkbox.setCheckState(Qt.Unchecked)
checkbox.pressed.connect(self.changed)
self.setCellWidget(row, 1, checkbox)
else:
value_item = QTableWidgetItem(param.value)
if not value_editable or param.name == "type":
value_item.setFlags(Qt.ItemIsEnabled)
else:
name_item.setToolTip(param.toolTip())
self.setItem(row, 1, value_item)
comments_item = QTableWidgetItem(param.comments)
if not comments_editable:
comments_item.setFlags(Qt.ItemIsEnabled)
self.setItem(row, 3, comments_item)
watch_blocks = self._getChildrenOfNodeOptions(param.cpp_type)
if param.cpp_type == "FileName" or param.cpp_type == "MeshFileName" or param.cpp_type == "FileNameNoExtension":
self._createFilenameOption(param)
elif watch_blocks:
self._createBlockWatcher(param, watch_blocks)
elif param.options:
self._createOptions(param)
elif param.user_added:
button = QPushButton("Remove")
button.clicked.connect(lambda checked: self._removeButtonClicked(name_item))
self.setCellWidget(row, 2, button)
else:
option_item = QTableWidgetItem()
option_item.setFlags(Qt.NoItemFlags)
self.setItem(row, 2, option_item)
