def table_init(table, column_width_list=(), select_as_columns=False, no_edit=False):
class AlignDelegate(QStyledItemDelegate):
def initStyleOption(self, option, index):
super(AlignDelegate, self).initStyleOption(option, index)
option.displayAlignment = Qt.AlignCenter
delegate = AlignDelegate(table)
# COLUMN_WIDTH
if column_width_list:
for i in range(len(column_width_list)):
table.setColumnWidth(i, column_width_list[i])
table.setItemDelegateForColumn(i, delegate)
else:
table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) # 自适应宽度
table.verticalHeader().setSectionResizeMode(QHeaderView.Stretch) # 自适应高度
for i in range(table.columnCount()):
table.setItemDelegateForColumn(i, delegate) # 居中
# SELECT_TYPE
if select_as_columns: # 整列选中
table.setSelectionBehavior(QAbstractItemView.SelectColumns)
# EDITABLE
if no_edit:
table.setEditTriggers(QAbstractItemView.NoEditTriggers) # 禁止修改表格
# ITEM
for row in range(table.rowCount()):
for col in range(table.columnCount()):
item = table.item(row, col)
if item is None:
item = QTableWidgetItem()
item.setText('')
table.setItem(row, col, item)
def table_loader(qtable):
"""
Responsible for loading data into the QTableWidget
:param qtable: QTableWidget
:return: None
"""
try:
qtable.setColumnCount(3)
qtable.setRowCount(5)
for row in range(0, 5):
for col in range(0, 2):
stringitem = QTableWidgetItem()
stringitem.setText("Test r: " + str(row) + " c: " + str(col))
qtable.setItem(row, col, stringitem)
chkboxitem = QTableWidgetItem()
chkboxitem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
chkboxitem.setCheckState(Qt.Checked)
qtable.setItem(row, 2, chkboxitem)
except Exception as ex:
print_exception(ex)
def create_table(self, tblType):
data = self.db.get_table_data(tblType)
font = QFont('Veranda', 12, QFont.Bold)
blk = QPalette()
blk.setColor(blk.Foreground, Qt.black)
# Check to make sure the list is there and has data, then we go through it and add data to the table.
if data:
self.tblSummary.setRowCount(len(data))
for i, row in enumerate(data):
for j, col in enumerate(row):
item = QTableWidgetItem(str(col))
item.setFont(font)
#item.setForeground(QColor.fr
#item.setFlags(Qt.ItemIsEditable)
if item.text() == "None":
item.setText("")
self.tblSummary.setItem(i, j, item)
else:
self.tblSummary.setRowCount(1)
item = QTableWidgetItem()
item.setText("Nothing Found")
self.tblSummary.setItem(0, 0, item)
def insertRound(self, r):
winner = r.getWinner()
i = r.getNumRound() - 1
self.insertRow(i)
for j, player in enumerate(self.engine.getListPlayers()):
item = QTableWidgetItem()
item.setFlags(item.flags() ^ QtCore.Qt.ItemIsEditable)
item.setTextAlignment(QtCore.Qt.AlignVCenter |
QtCore.Qt.AlignCenter)
if player == winner:
text = i18n(
"Phase10RoundTable", "Winner")
font = item.font()
font.setBold(True)
item.setFont(font)
else:
text = str(r.getPlayerScore(player))
a_phase = r.getPlayerAimedPhase(player)
c_phase = r.getPlayerCompletedPhase(player)
text += i18n(
"Phase10PlayerWidget", " (Phase {})").format(a_phase)
if c_phase != 0:
background = 0xCCFF99 # green
else:
background = 0xFFCC99 # red
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
item.setText(text)
self.setItem(i, j, item)
self.scrollToBottom()
def insertRound(self, r):
closeType = r.getCloseType()
winner = r.getWinner()
background = self.bgcolors[closeType]
i = r.getNumRound() - 1
self.insertRow(i)
for j, player in enumerate(self.engine.getListPlayers()):
item = QTableWidgetItem()
item.setFlags(item.flags() ^ QtCore.Qt.ItemIsEditable)
item.setTextAlignment(QtCore.Qt.AlignVCenter |
QtCore.Qt.AlignCenter)
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
if player == winner:
text = i18n(
"RemigioRoundTable", "Winner ({}x)").format(closeType)
font = item.font()
font.setBold(True)
item.setFont(font)
elif self.engine.wasPlayerOff(
player, r.getNumRound()) or r.getPlayerScore(player) < 0:
if r.getPlayerScore(player) < 0:
text = ""
else:
text = str(r.getPlayerScore(player))
item.setBackground(QtGui.QBrush(QtCore.Qt.gray))
else:
text = str(r.getPlayerScore(player))
item.setText(text)
self.setItem(i, j, item)
self.scrollToBottom()
def setmydata(self):
for row in range(0,16):
for col in range(0,4):
newitem = QTableWidgetItem(str("row %1, col %2")) #,row+1,col+1))
if row == 0 and col == 0:
newitem.setText("click me")
self.setItem(row, col, newitem)
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 render_generic_file_metadata(self):
source_item = self.SourcesList.currentItem()
if source_item:
source = source_item.data(Qt.UserRole)
self.GenericFileMetadataTable.clear()
data = {
'file_name': source.file_name,
'size': source.size,
'url': source.url
}
self.GenericFileMetadataTable.setColumnCount(2)
self.GenericFileMetadataTable.setRowCount(len(data))
for i, (key, value) in enumerate(data.items()):
key_item = QTableWidgetItem()
key_item.setText(key)
key_item.setFlags(key_item.flags() ^ Qt.ItemIsEditable)
value_item = QTableWidgetItem()
value_item.setText(f'{value}')
if key != 'url':
key_item.setBackground(QColor(50, 50, 50))
value_item.setBackground(QColor(50, 50, 50))
value_item.setFlags(value_item.flags() ^ Qt.ItemIsEditable)
entry_data = {
'key': key,
'value': value,
'source': source,
'key_item': key_item,
'value_item': value_item
}
value_item.setData(Qt.UserRole, entry_data)
self.GenericFileMetadataTable.setItem(i, 0, key_item)
self.GenericFileMetadataTable.setItem(i, 1, value_item)
self.GenericFileMetadataTable.resizeColumnsToContents()
def insertRound(self, r):
winner = r.getWinner()
i = r.getNumRound() - 1
self.insertRow(i)
hands = self.engine.getHands(r.getNumRound())
direction = self.engine.getDirection(r.getNumRound())
hitem = QTableWidgetItem("{} {}".format(hands,
i18n("PochaWidget", direction)))
self.setVerticalHeaderItem(i, hitem)
for j, player in enumerate(self.engine.getListPlayers()):
item = QTableWidgetItem()
item.setFlags(item.flags() ^ QtCore.Qt.ItemIsEditable)
item.setTextAlignment(QtCore.Qt.AlignVCenter |
QtCore.Qt.AlignCenter)
score = r.getPlayerScore(player)
if score > 0:
background = self.bgcolors[0]
else:
background = self.bgcolors[1]
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
text = str(score)
if player == winner:
text += i18n("PochaRoundTable", " (Winner)")
item.setText(text)
self.setItem(i, j, item)
self.scrollToBottom()
def _update_joins(self, mi):
combo = self.IDB.sender()
row, col, new_col = combo.itemData(self.temp_col.index(mi))
print(row, col, new_col)
first_row = self.IDB.TWFinalExample.cellWidget(1, row).currentText()
sub_colum_id = self.temp_col.index(first_row)
sub_new_name = new_col
old_row = row
current_data = []
errors_found = []
for i in range(3, 13):
try:
current_data.append(int(self.IDB.TWFinalExample.item(i, old_row).text()))
except ValueError:
errors_found.append(i)
pass
if len(current_data) == 0:
print('no list')
data = self.cursor.execute("select * from {tbl}".format(tbl=self.other_tbls[int(col)]))
data1 = data.fetchall()
matching_ids = []
matching_values = []
for row in data1:
matching_ids.append(row[sub_colum_id])
matching_values.append(row[sub_new_name])
j = -1
for i in range(3, 13):
if i in errors_found:
continue
j += 1
idx = current_data[j]
item = QTableWidgetItem()
new_name = matching_values[matching_ids.index(idx)]
item.setText(str(new_name))
self.IDB.TWFinalExample.setItem(i, old_row, item)
def initFormByLayer(self, layer):
if not layer:
self.showMsg("Error", "Layer failed to load!.", Qgis.Critical, 5)
return
self.dlg.comboBox_Dependent.clear()
self.dlg.listWidget_Independents.clear()
tempItem = QTableWidgetItem()
col = 0
for feild in layer.fields():
tempItem.setText(self.tr(feild.displayName()))
self.dlg.comboBox_Dependent.addItem(feild.displayName())
self.dlg.listWidget_Independents.addItem(feild.displayName())
row = 0
for feature in layer.getFeatures():
tempItem.setText(str(feature.attributes()[col]))
row += 1
col += 1
self.data = []
row = 0
for feature in layer.getFeatures():
rowData = []
col = 0
rowData.append(feature.geometry().asPoint().x())
rowData.append(feature.geometry().asPoint().y())
for feild in layer.fields():
rowData.append(feature.attributes()[col])
self.data.append(rowData)
def update_possessions(self):
tiles = self.current_player.get_possessions()
if tiles:
sorted_tiles = sorted(tiles, key = lambda x: x.get_price())
self.possessions_info.setText("You have these properties:")
if sorted_tiles != []:
color2tiles = {}
for tile in sorted_tiles:
color2tiles.setdefault(tile.get_color(), []).append(tile)
self.possessions.setColumnCount(len(color2tiles))
self.possessions.setRowCount(max((len(v) for k, v in color2tiles.items())))
for column, (color, tiles) in enumerate(color2tiles.items()):
for row, tile in enumerate(tiles):
set_color = QColor()
set_color.setNamedColor(color)
cell = QTableWidgetItem()
cell.setBackground(QBrush(set_color, style = Qt.SolidPattern))
if color == "#000000":
cell.setForeground(QBrush(QColor(255, 255, 255)))
cell.setText(f"{tile.get_name()}")
self.possessions.setItem(row, column, cell)
else:
self.possessions.clearContents()
def fill_table(self, table, headline, data):
cnt = 0
table.clearContents()
table.setRowCount(0)
head = []
headline_strip = []
for i in headline:
if i['hidden'] == False:
head.append(i['title'])
headline_strip.append(i)
table.setColumnCount(headline_strip.__len__())
table.horizontalHeader().setMinimumSectionSize(0)
for i, k in enumerate(headline_strip):
if k['width'] == 'auto':
table.horizontalHeader().setSectionResizeMode(i, QHeaderView.Stretch)
else:
table.horizontalHeader().setSectionResizeMode(i, QHeaderView.Interactive)
table.horizontalHeader().resizeSection(i, k['width'])
table.setHorizontalHeaderLabels(head)
for i in data:
table.insertRow(cnt)
for j, k in enumerate(headline_strip):
if k['hidden'] == False:
cell = QTableWidgetItem()
cell.setText(str(i[k['key']]))
table.setItem(cnt, j, cell)
cnt = cnt + 1
table.setCurrentCell(0, 0)
def set_var(self, i: int, attrs: Dict[str, Any], value: str,
value_type: str) -> None:
name_item = QTableWidgetItem()
name_item.setText(attrs["name"])
self.setItem(i, 0, name_item)
type_item = QTableWidgetItem()
type_item.setText(attrs["type"].strip())
self.setItem(i, 1, type_item)
if attrs["loc"] == 1:
addr_item = QTableWidgetItem()
addr_item.setText(hex(attrs["addr"]))
self.setItem(i, 2, addr_item)
elif attrs["loc"] == 2:
addr_item = QTableWidgetItem()
addr_item.setText(attrs["addr"])
self.setItem(i, 2, addr_item)
value_item = QTableWidgetItem()
value_item.setText(value)
self.setItem(i, 3, value_item)
value_item.value_type = value_type
if value_type == "hex":
value_item.core_value = int(value, 16)
elif value_type == "array":
arr = [] # type: List[int]
for v in value.split(" "):
if v != "**" and v != "Er":
arr[i] = int(v, 16)
value_item.core_value = arr
def printTable(self):
#Display the user input table
self.table.setStyleSheet("background-color: white; border: 1px solid black")
self.table.setRowCount(1)
self.table.setColumnCount(6)
self.table.resize(775,800)
self.table.move(100,50)
font = QFont()
font.setBold(True)
font.setPointSize(11)
columns = ["Description","Amount (g)","Calories","Carbs (g)","Protein (g)","Fat (g)"]
#Set up each of the table's columns
for count, column in enumerate(columns):
item = QTableWidgetItem()
item.setText(column)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.ItemIsEnabled)
self.table.setItem(0,count, item)
self.table.item(0,count).setFont(font)
cursor.execute("SELECT * FROM food_info")
foods = cursor.fetchall()
for x,food in enumerate(foods,1):
self.addRow(self.table)
for y, column in enumerate(columns):
item = QTableWidgetItem()
item.setText(str(food[y]))
self.table.setItem(x,y,item)
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 _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 __init__(self, parent, title, column_names, row_data, style=0):
super(QDialog, self).__init__(parent)
self.setModal(False)
self.ui = Ui_ExpectedResult()
self.ui.setupUi(self)
self.setWindowTitle(title)
self.ui.resultTable.setColumnCount(len(column_names))
self.ui.resultTable.setRowCount(len(row_data))
self.ui.resultTable.clear()
self.ui.resultTable.setHorizontalHeaderLabels(column_names)
for row_num, row in enumerate(row_data):
for col_num, item in enumerate(row):
cell = QTableWidgetItem()
cell.setText(str(item))
self.ui.resultTable.setItem(row_num, col_num, cell)
if style == 1:
self.ui.label_correct.setStyleSheet(
'background-color: rgb(0, 255, 0)')
self.ui.label_correct.setText('Correct! \\o/')
elif style == 2:
self.ui.label_correct.setStyleSheet(
'background-color: rgb(255, 100, 0)')
self.ui.label_correct.setText('Try Again :-(')
def amount_rate_calculation(self, item):
rownum = item.row()
colnum = item.column()
print('the row number is ', rownum)
print('the column number is ', colnum)
if colnum == 4:
rate_value = self.viewtable.item(rownum, 3).text()
print('the rate value is ', rate_value, ' and its type is ',
type(rate_value))
qty_value = self.viewtable.item(rownum, 4).text()
print('the qty value is ', qty_value)
int_rate_value = int(rate_value)
int_qty_value = int(qty_value)
amount_value = int_rate_value * int_qty_value
print('the amount value is', amount_value)
amount_table = QTableWidgetItem()
amount_table.setText(str(amount_value))
amount_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.viewtable.setItem(rownum, 5, amount_table)
def gen_main_table(self):
self.main_table.setShowGrid(True)
self.main_table.setColumnCount(0)
self.main_table.setColumnCount(7)
self.main_table.setHorizontalHeaderLabels(['USER', 'PID', '%CPU', '%MEM', 'STAT', 'STARTED', 'COMMAND'])
# Set column width
self.main_table.setColumnWidth(1, 70)
self.main_table.setColumnWidth(2, 60)
self.main_table.setColumnWidth(3, 60)
self.main_table.setColumnWidth(4, 60)
self.main_table.setColumnWidth(5, 80)
self.main_table.horizontalHeader().setSectionResizeMode(6, QHeaderView.Stretch)
# Set click behavior
self.main_table.itemClicked.connect(self.main_tab_check_click)
# Set item
self.process_dic = self.get_process_info()
self.main_table.setRowCount(len(self.process_dic['pid']))
title_list = ['user', 'pid', 'cpu', 'mem', 'stat', 'started', 'command']
for (row, pid) in enumerate(self.process_dic['pid']):
for (column, title) in enumerate(title_list):
item = QTableWidgetItem()
item.setText(self.process_dic[title][row])
self.main_table.setItem(row, column, item)
def populate_table_from_csv(self, tab, file, delimiter=';', first_item_header=True):
try:
with open(file, 'r') as csv_file:
file_reader = csv.reader(csv_file, delimiter=delimiter)
rows = list(file_reader)
except FileNotFoundError:
self.status_file_not_found(tab, file)
return
tab.table.setColumnCount(len(rows[0]))
# Set headers
if first_item_header:
headers = rows.pop(0)
for header_index, header in enumerate(headers):
item = QTableWidgetItem()
item.setText(header)
tab.table.setHorizontalHeaderItem(header_index, item)
# Set rows data
tab.table.setRowCount(len(rows))
for row_index, row in enumerate(rows):
for column_index, column in enumerate(row):
item = QTableWidgetItem()
item.setText(column)
tab.table.setItem(row_index, column_index, item)
self.status_file_loaded(tab, file)
return tab.table
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 __init__(self, mainwindow):
super().__init__(mainwindow=mainwindow)
self.bd = BdController()
self.preparator = DataPreparator()
self.neurocreator = NeuroWebCreator()
if self.bd.data_exists():
market, trends = self.bd.read_data()
opts, num = self.preparator.forTrainWindow(market, trends)
self.bd.save_options(opts, num)
self.tableOptions.setColumnCount(1)
self.tableOptions.setRowCount(len(opts))
self.tableOptions.setHorizontalHeaderLabels(['Options'])
self.tableOptions.setColumnWidth(0, 500)
for i in range(len(opts)):
for j in range(1):
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled)
chkBoxItem.setCheckState(QtCore.Qt.Unchecked)
chkBoxItem.setText(opts[i])
self.tableOptions.setItem(i, j, chkBoxItem)
self.tableOptions.itemClicked.connect(self.handleItemClicked)
self.listChecked = []
self.mistake.setMaximum(100)
self.mistake.setValue(2.5)
self.spinBox.setMaximum(300)
self.spinBox.setValue(300)
self.fastButton.clicked.connect(self.fast)
self.doubleButton.clicked.connect(self.double)
self.deepButton.clicked.connect(self.deep)
self.fullButton.clicked.connect(self.full)
def gen_main_table(self):
self.main_table.setShowGrid(True)
self.main_table.setColumnCount(0)
self.main_table.setColumnCount(6)
self.main_table.setHorizontalHeaderLabels(['USER', 'SUBMIT_HOST', 'EXECUTE_HOST', 'LICENSE_NUM', 'LICENSE_VERSION', 'START_TIME'])
# Set column width
self.main_table.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
self.main_table.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
self.main_table.horizontalHeader().setSectionResizeMode(2, QHeaderView.Stretch)
self.main_table.setColumnWidth(3, 120)
self.main_table.setColumnWidth(4, 140)
self.main_table.setColumnWidth(5, 140)
# Set item
self.main_table.setRowCount(len(self.license_feature_usage_dic_list))
title_list = ['user', 'submit_host', 'execute_host', 'license_num', 'version', 'start_time']
for (row, license_feature_usage_dic) in enumerate(self.license_feature_usage_dic_list):
for (column, title) in enumerate(title_list):
item = QTableWidgetItem()
item.setText(license_feature_usage_dic[title])
if (column == 5) and license_common.check_long_runtime(license_feature_usage_dic[title]):
item.setForeground(QBrush(Qt.red))
self.main_table.setItem(row, column, item)
def deleterow(self):
rownum = self.viewtable.currentRow()
print('the rownum is ', rownum)
if rownum == -1:
QMessageBox.warning(self, 'Warning',
'Please select a row for delete')
else:
self.viewtable.removeRow(rownum)
rowcount = self.viewtable.rowCount()
print('the row number is ', rowcount)
for i in range(rowcount):
value = i + 1
print('the row numbers is ', i)
rowvalue = QTableWidgetItem()
rowvalue.setText(str(value))
self.viewtable.setItem(i, 0, rowvalue)
total = 0
for row in range(rowcount):
rowvalue = float(self.viewtable.item(row, 5).text())
total += rowvalue
self.total_le.setText(str(total))
def __show_query_result_table(self, students_table):
table = self.ui.query_result_table
column_count = len(students_table[0]) + 1
row_count = len(students_table)
table.setColumnCount(column_count)
table.setRowCount(row_count)
self.students_selection_buttons = []
for i in range(row_count):
for j in range(column_count):
table_item = QTableWidgetItem()
table_item.setFlags(table_item.flags() & ~Qt.ItemIsEditable)
if i == 0 and j == 0:
table_item.setText('Select')
table.setItem(i, j, table_item)
elif i != 0 and j == 0:
#table.setItem(i, j, table_item)
check_box = QCheckBox()
self.students_selection_buttons.append(check_box)
table.setCellWidget(i, j, check_box)
else:
if j > 3:
table_item.setTextAlignment(3)
font = QFont("Times", 14)
if i == 0:
font.setBold(True)
table_item.setFont(font)
table_item.setText(students_table[i][j - 1])
table.setItem(i, j, table_item)
header = table.horizontalHeader()
header.setSectionResizeMode(QHeaderView.ResizeToContents)
def create_table(self, tblType):
data = self.db.get_table_data(tblType)
font = QFont('Veranda', 12, QFont.Bold)
blk = QPalette()
blk.setColor(blk.Foreground, Qt.black)
# Check to make sure the list is there and has data, then we go through it and add data to the table.
if data:
self.tblSummary.setRowCount(len(data))
for i, row in enumerate(data):
for j, col in enumerate(row):
item = QTableWidgetItem(str(col))
item.setFont(font)
#item.setForeground(QColor.fr
#item.setFlags(Qt.ItemIsEditable)
if item.text() == "None":
item.setText("")
self.tblSummary.setItem(i, j, item)
else:
self.tblSummary.setRowCount(1)
item = QTableWidgetItem()
item.setText("Nothing Found")
self.tblSummary.setItem(0, 0, item)
def addSequence(self, name=None, sequence=None):
nameitem = QTableWidgetItem(self.ui.seqTbl.itemPrototype())
seqitem = QTableWidgetItem(self.ui.seqTbl.itemPrototype())
nrow = self.ui.seqTbl.rowCount()
if name:
nameitem.setText(name)
if sequence:
seqitem.setText(sequence)
n = nameitem.text()
s = seqitem.text()
self.byrow[0].append(n)
self.byrow[1].append(s)
self.unique[0][n] = self.unique[0].get(n, 0) + 1
self.unique[1][s] = self.unique[1].get(s, 0) + 1
if self.unique[0][n] > 1 or not name:
self.invalid[0] += 1
if self.unique[1][s] > 1 or not sequence:
self.invalid[1] += 1
self.ui.seqTbl.insertRow(nrow)
self.rowAdded.emit(nrow + 1, nameitem.text())
self.ui.seqTbl.setItem(nrow, 0, nameitem)
self.ui.seqTbl.setItem(nrow, 1, seqitem)
self.ui.seqTbl.setCurrentItem(nameitem)
if not name:
self.ui.seqTbl.editItem(nameitem)
self.valid.emit(self.isValid())
def fill_table(self):
"""Fill the table."""
# Sizes
self.table.setColumnCount(len(self.value))
self.table.setRowCount(1)
# Values filled
for i in range(0, self.table.columnCount()):
column_elem = self.value[i]
item = QTableWidgetItem()
item.setText(str(column_elem))
self.table.setItem(0, i, item)
# Resize
self.table.resizeColumnsToContents()
total_width = 0
total_height = 0
i = 0
while i < self.table.columnCount():
total_width += self.table.columnWidth(i)
total_height += self.table.rowHeight(i)
i += 1
if total_width + 20 < 900:
self.table.setFixedWidth(total_width + 20)
self.table.setFixedHeight(total_height + 25)
else:
self.table.setFixedWidth(900)
self.table.setFixedHeight(total_height + 40)
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_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 fill_headers(self):
"""
Fills the headers of the table depending on the selected tags
"""
idx_end = 0
# Headers
for idx in range(len(self.values_list) - 1):
header_name = self.push_buttons[idx].text()
item = QTableWidgetItem()
item.setText(header_name)
self.table.setHorizontalHeaderItem(idx, item)
idx_end = idx
# idx_last_tag corresponds to the index of the (n-1)th tag
self.idx_last_tag = idx_end
last_tag = self.push_buttons[len(self.values_list) - 1].text()
last_tag_type = self.project.session.get_field(COLLECTION_CURRENT,
last_tag).field_type
for header_name in self.values_list[-1]:
idx_end += 1
item = QTableWidgetItem()
set_item_data(item, header_name, last_tag_type)
self.table.setHorizontalHeaderItem(idx_end, item)
# Adding a "Total" row and to count the scans
self.table.insertRow(self.nb_row)
item = QTableWidgetItem()
item.setText('Total')
item.setFont(self.font)
self.table.setVerticalHeaderItem(self.nb_row, 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 updateTable(self): # Обновление таблицы
self.tableWidget.blockSignals(True)
self.tableWidget.setRowCount(0)
res = self.db.findTableRequest(self.lineEditForSearch.text())
for i, row in enumerate(res):
self.tableWidget.setRowCount(self.tableWidget.rowCount() + 1)
self.tableWidget.blockSignals(True)
for j, elem in enumerate(row):
s = QTableWidgetItem(str(elem))
self.clickedRow(i, j)
if j == 1:
brush = QtGui.QBrush(
QtGui.QPixmap(res[i][1]).scaled(200, 200))
self.tableWidget.setRowHeight(i, 200)
s.setText('')
s.setBackground(brush)
elif j == 6:
self.tableWidget.setItem(i, j, s)
self.checkCount(self.r, self.c)
continue
if self.id != '1':
if str(j) in '012345':
s.setFlags(QtCore.Qt.ItemIsEditable)
else:
if str(j) in '0':
s.setFlags(QtCore.Qt.ItemIsEditable)
self.tableWidget.setItem(i, j, s)
self.tableWidget.blockSignals(False)
self.checkError()
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 update_stats(self):
self.refreshAnonymity()
# Set up rank table dimensions
self.ui.rankTable.setRowCount(len(unstyle.controller.feature_ranks))
# Name the headers of the table
headers = "Text Features", "Target", "Initial"
self.ui.rankTable.setHorizontalHeaderLabels(headers)
headerObj = self.ui.rankTable.horizontalHeader()
headerObj.setSectionResizeMode(0, QHeaderView.ResizeToContents)
tableHeight = (len(unstyle.controller.feature_ranks))
# XXX: Sorting should be handled in the table, not in the
# rank_features methods. This will allow us to fix this embarrassingly
# overcomplicated code.
# Fill in the feature column
for idx, pair in enumerate(unstyle.controller.feature_ranks):
currItem = self.ui.rankTable.item(idx, 0)
# If we are setting up the table for the first time, currItem will
# not exist.
if currItem is None:
currItem = QTableWidgetItem(1)
currItem.setText(self.getFeatureDesc(pair[0])[0])
self.ui.rankTable.setItem(idx, 0, currItem)
else:
currItem.setText(
self.getFeatureDesc(feature_ranks[pair[0]])[0])
# Initialize target and initial columns
for idx, target in enumerate(unstyle.controller.targets):
currItem = self.ui.rankTable.item(idx, 1)
if currItem is None:
currItem = QTableWidgetItem(1)
currItem.setText(str(target))
self.ui.rankTable.setItem(idx, 1, currItem)
currItem2 = QTableWidgetItem(1)
self.ui.rankTable.setItem(idx, 2, currItem2)
# Populate target and current val columns
# Track feature table locations
labelsBeforeSorting = unstyle.controller.featlabels
for idx, label in enumerate(labelsBeforeSorting):
for idx2, item in enumerate(range(tableHeight)):
currItem = self.ui.rankTable.item(item, 0)
if self.getFeatureDesc(label)[0] == currItem.text():
self.featureRows[idx2] = label
print(label, " ", currItem.text(), " ", item)
currItem = self.ui.rankTable.item(item, 1)
currItem.setText(str(unstyle.controller.targets[idx]))
currItem = self.ui.rankTable.item(item, 2)
currItem.setText(
str(unstyle.controller.to_anonymize_features[0][idx]))
def resetTotals(self):
self.totals.setHorizontalHeaderLabels(self.engine.getListPlayers())
self.totals.clearContents()
for row in range(len(self.engine.getEntryKinds())):
background = self.bgcolors[row]
for col in range(len(self.engine.getListPlayers())):
item = QTableWidgetItem()
item.setFlags(item.flags() ^ QtCore.Qt.ItemIsEditable)
item.setTextAlignment(
QtCore.Qt.AlignVCenter | QtCore.Qt.AlignCenter)
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
item.setText("0")
self.totals.setItem(row, col, item)
def addImage(self):
fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Images", '',
"Images (*.png *.xpm *.jpg);;All Files (*)")
for fileName in fileNames:
row = self.imagesTable.rowCount()
self.imagesTable.setRowCount(row + 1)
imageName = QFileInfo(fileName).baseName()
item0 = QTableWidgetItem(imageName)
item0.setData(Qt.UserRole, fileName)
item0.setFlags(item0.flags() & ~Qt.ItemIsEditable)
item1 = QTableWidgetItem("Normal")
item2 = QTableWidgetItem("Off")
if self.guessModeStateAct.isChecked():
if '_act' in fileName:
item1.setText("Active")
elif '_dis' in fileName:
item1.setText("Disabled")
elif '_sel' in fileName:
item1.setText("Selected")
if '_on' in fileName:
item2.setText("On")
self.imagesTable.setItem(row, 0, item0)
self.imagesTable.setItem(row, 1, item1)
self.imagesTable.setItem(row, 2, item2)
self.imagesTable.openPersistentEditor(item1)
self.imagesTable.openPersistentEditor(item2)
item0.setCheckState(Qt.Checked)
def __insertRow(self, repoName, repoAddress):
currentRow = self.settings.repoListView.rowCount()
self.settings.repoListView.insertRow(currentRow)
checkbox = QCheckBox(self.settings.repoListView)
checkbox.toggled.connect(self.markChanged)
self.settings.repoListView.setCellWidget(currentRow, 0, checkbox)
self.settings.repoListView.cellWidget(currentRow, 0).setChecked(self.iface.isRepoActive(repoName))
repoNameItem = QTableWidgetItem()
repoNameItem.setText(repoName)
repoNameItem.setTextAlignment(Qt.AlignLeft|Qt.AlignVCenter)
self.settings.repoListView.setItem(currentRow, 1, repoNameItem)
repoAddressItem = QTableWidgetItem()
repoAddressItem.setText(repoAddress)
repoAddressItem.setTextAlignment(Qt.AlignLeft|Qt.AlignVCenter)
self.settings.repoListView.setItem(currentRow, 2, repoAddressItem)
def updateLocationsTable(self):
self.locationsTable.setUpdatesEnabled(False)
self.locationsTable.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.locationsTable.rowCount()
self.locationsTable.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.buttonBox.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.locationsTable.setItem(row, 0, item0)
self.locationsTable.setItem(row, 1, item1)
self.locationsTable.setUpdatesEnabled(True)
def updateWearableTable(self, wearable, isNew):
if (isNew):
self.tables[TID_W].insertRow(0)
# "Name" item with xmlId data
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(wearable.name)
item.setData(5, wearable.xmlId)
self.tables[TID_W].setItem(0, 0, item)
# "Wearable ID" item
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(str(wearable.hwId))
self.tables[TID_W].setItem(0, 1, item)
else:
items = self.tables[TID_W].selectedItems()
items[0].setText(wearable.name)
items[1].setText(str(wearable.hwId))
def run(self):
data, data_avg = self.db.get_report(self.qtrs, self.yrs, self.lst_type, self.lst_cat, self.lst_sub, self.vendor)
if data:
self.tblReport.setRowCount(len(data))
for i, row in enumerate(data):
for j, col in enumerate(row):
item = QTableWidgetItem(str(col))
if item.text() == "None":
item.setText("")
self.tblReport.setItem(i, j, item)
else:
self.tblReport.setRowCount(1)
item = QTableWidgetItem()
item.setText("No Results")
self.tblReport.setItem(0, 0, item)
self.tblReport.resizeColumnsToContents()
self.tblReport.setSortingEnabled(True)
self.rpt_finished.emit(self.tblReport, data_avg)
def updateDeviceTable(self, device, isNew):
if (isNew):
self.tables[TID_D].insertRow(0)
# "Name" item with xmlId data
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(device.name)
item.setData(5, device.xmlId)
self.tables[TID_D].setItem(0, 0, item)
# "Bluetooth Address" item
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(device.hwId)
self.tables[TID_D].setItem(0, 1, item)
# "Type" item
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(DEVICE_TYPES[device.devType])
self.tables[TID_D].setItem(0, 2, item)
else:
items = self.tables[TID_D].selectedItems()
items[0].setText(device.name)
items[2].setText(device.hwId)
items[2].setText(DEVICE_TYPES[device.devType])
def updateZoneTable(self, zone, isNew):
if (isNew):
self.tables[TID_Z].insertRow(0)
# "Name" item with xmlId data
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(zone.name)
item.setData(5, zone.xmlId)
self.tables[TID_Z].setItem(0, 0, item)
# "Module ID" item
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(str(zone.hwId))
self.tables[TID_Z].setItem(0, 1, item)
# "Threshold" item
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(str(zone.threshold))
self.tables[TID_Z].setItem(0, 2, item)
else:
items = self.tables[TID_Z].selectedItems()
items[0].setText(zone.name)
items[1].setText(str(zone.hwId))
items[2].setText(str(zone.threshold))
def insertRound(self, r):
winner = r.getWinner()
i = r.getNumRound() - 1
self.insertRow(i)
for j, player in enumerate(self.engine.getListPlayers()):
item = QTableWidgetItem()
item.setFlags(item.flags() ^ QtCore.Qt.ItemIsEditable)
item.setTextAlignment(QtCore.Qt.AlignVCenter |
QtCore.Qt.AlignCenter)
score = r.getPlayerScore(player)
if score > 0:
background = self.bgcolors[0]
else:
background = self.bgcolors[1]
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
text = str(score)
if player == winner:
text += i18n(
"RatukiRoundTable", " (Winner)")
item.setText(text)
self.setItem(i, j, item)
self.scrollToBottom()
def createTable(self, data):
tblNextQue = QTableWidget()
h_font = QFont('Seqoe UI', 10, QFont.Bold)
i_font = QFont('Seqoe UI', 10, QFont.Bold)
tblNextQue.setColumnCount(7)
tblNextQue.setAlternatingRowColors(True)
head = tblNextQue.horizontalHeader()
head.setStretchLastSection(True)
head.setFont(h_font)
lstHeader = ["Queue Letter", "Description", "Orders", "Queue Date", "Oldest Order Date", "Queue Pulled Date", "Kornit ID"]
tblNextQue.setHorizontalHeaderLabels(lstHeader)
#tblNextQue.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
tblNextQue.setWordWrap(False)
# Check to make sure the list is there and has data, then we go through it and add data to the table.
if data:
tblNextQue.setRowCount(len(data))
for i, row in enumerate(data):
for j, col in enumerate(row):
item = QTableWidgetItem(str(col))
item.setFont(i_font)
#item.setFlags(Qt.ItemIsEditable)
if item.text() == "None":
item.setText("")
tblNextQue.setItem(i, j, item)
else:
tblNextQue.setRowCount(1)
item = QTableWidgetItem()
item.setText("Nothing Found")
tblNextQue.setItem(0, 0, item)
tblNextQue.resizeColumnsToContents()
tblNextQue.setWindowIcon(QIcon('icon/scanner.png'))
return tblNextQue
def insertRound(self, entry):
kind = entry.getKind()
kinds = self.engine.getEntryKinds()
background = self.bgcolors[kinds.index(kind)]
kind = i18n("CarcassonneInputWidget", kind)
i = entry.getNumRound() - 1
self.insertRow(i)
for j, player in enumerate(self.engine.getListPlayers()):
item = QTableWidgetItem()
item.setFlags(item.flags() ^ QtCore.Qt.ItemIsEditable)
item.setTextAlignment(QtCore.Qt.AlignVCenter |
QtCore.Qt.AlignCenter)
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
if player == entry.getPlayer():
text = "{} ({})".format(entry.getPlayerScore(), kind)
font = item.font()
font.setBold(True)
item.setFont(font)
else:
text = ""
item.setText(text)
self.setItem(i, j, item)
self.scrollToBottom()
def __init__(self, stats, mode, difficulties, theme):
"""Initializes basic information about the Viewer class."""
super().__init__()
### Initialize parameters passed from smtracker.py
self.stats = stats # XML tree
self.mode = mode # Gamemode
self.difficulties = difficulties # Tracked difficulties
### Initialize interface options
self.icons_enabled = True # Icons
### Create an empty table
if self.stats is not None:
song_count = len(self.stats.find("SongScores"))
self.table = QTableWidget(song_count, len(self.difficulties) + 2)
else:
self.table = QTableWidget(0, len(self.difficulties) + 2)
# Set some basic table attributes
self.table.setIconSize(QSize(32, 32))
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table.setSelectionMode(QAbstractItemView.NoSelection)
table_header = ["Group", "Title"]
table_header.extend(self.difficulties)
# Sets the header cells
for head in table_header:
where = table_header.index(head)
headeritem = QTableWidgetItem()
headeritem.setText(head)
self.table.setHorizontalHeaderItem(where, headeritem)
self.theme = theme
self.init_ui()
def createConfigTable(self):
configTable = self.tables[TID_C]
configTable.clearContents()
for i in range(configTable.rowCount()):
configTable.removeRow(0)
for device in self.systemState.dicts[TID_D].values():
configTable.insertRow(0)
# "Device" item with xmlId data
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(device.name)
item.setData(5, device.xmlId)
configTable.setItem(0, 0, item)
# "Containing Zone" item
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
if (device.zone == -1):
text = "[unassigned]"
else:
text = self.systemState.dicts[TID_Z][device.zone].name
item.setText(text)
item.setData(5, device.zone)
configTable.setItem(0, 1, item)
# "Entry Action" item
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(DEVICE_ACTIONS[device.devType][device.enter])
configTable.setItem(0, 2, item)
# "Exit Action" item
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
item.setText(DEVICE_ACTIONS[device.devType][device.exit])
configTable.setItem(0, 3, item)
def add_media(self):
"""Add media files to the list of conversion tasks."""
# Dialog title
title = self.tr('Select Files')
# Media filters
v_filter = (self.tr('Video files') +
'(*.mkv *.ogg *.mp4 *.mpg *.dat '
'*.f4v *.flv *.wv *.3gp *.avi *.webm '
'*.wmv *.mov *.vob *.ogv *.ts)')
# Select media files and store their path
media_paths, _ = QFileDialog.getOpenFileNames(self,
title,
QDir.homePath(),
v_filter)
# If no file is selected then return
if not media_paths:
return
# Count rows in the tasks table
rows = self.tb_tasks.rowCount()
# This rewind the encoding list if the encoding process is not running
if not self.converter.is_running:
self.media_list.running_index = -1
# Add selected medias to the table and to MediaList using threads to
# minimize delay
threads = []
for media_path in media_paths:
t = MediaFileThread(
media_path=media_path,
target_quality=str(self.cb_presets.currentText()),
prober=self.get_prober())
t.start()
threads.append(t)
for t in threads:
t.join()
for thread in threads:
try:
self.media_list.add_file(thread.media_file)
self.tb_tasks.setRowCount(rows + 1)
except FileAddedError:
del thread.media_file
continue
# Test if the file was added to the list
# (0 duration files are not added)
if thread.media_file in self.media_list:
item = QTableWidgetItem()
item.setText(thread.media_file.get_name(with_extension=True))
self.tb_tasks.setItem(rows, NAME, item)
item = QTableWidgetItem()
file_duration = str(
write_time(thread.media_file.info.format_duration))
item.setText(file_duration)
self.tb_tasks.setItem(rows, DURATION, item)
item = QTableWidgetItem()
item.setText(str(self.cb_presets.currentText()))
self.tb_tasks.setItem(rows, QUALITY, item)
item = QTableWidgetItem()
item.setText(self.tr('To convert'))
self.tb_tasks.setItem(rows, PROGRESS, item)
# Next table row
rows += 1
# After adding files to the list, recalculate the list duration
self.total_duration = self.media_list.duration
# Update tool buttons so you can convert, or add_file, or clear...
self.update_interface(stop=False, remove=False)
def insertTableItem(self, row, column, text):
cellitem = QTableWidgetItem()
cellitem.setText(text)
cellitem.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tvResult.setItem(row, column, cellitem)
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)
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!")
