def __init__(self):
super(LoadDialog, self).__init__()
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.detox_filenames()
self.ui.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
self.ui.listWidget.itemSelectionChanged.connect(self.selected_episode)
self.accepted.connect(self.pressed_ok)
self.episode_data = None
self.okay = False
for k, v in hashes.friendly_names.items():
item = QListWidgetItem()
path1 = (os.path.dirname(os.path.realpath(__file__)) +
"/saved_changes/" + k + ".json")
path2 = (os.path.dirname(os.path.realpath(__file__)) + "/labels/" +
k + ".txt")
if os.path.exists(path1):
item.setData(32, path1)
progress = import_export.check_progress(path1)
item.setText(v + " (" + str(progress) + "% complete)")
if progress == 100:
item.setBackgroundColor(QColor(20, 180, 20))
else:
item.setBackgroundColor(QColor(180, 64, 20))
elif os.path.exists(path2):
item.setData(32, path2)
item.setText(v)
else:
continue
self.ui.listWidget.addItem(item)
def get_list_items(self):
"""Retrieves all series from database and populates list in main window.
Populates the list in the main window with the compact_string()
representations of all the series in the database, sorting by the
given property (default "name") and placing any series with an
unknown value for that property at the end of the list
"""
order = self.get_list_order()
data_mgr = DatabaseManager(Config().database_name, None)
cur = data_mgr.query("SELECT rowid, * FROM Series ORDER BY %s "
"COLLATE NOCASE ASC, name ASC;" % order)
entries = cur.fetchall()
unknown_entries = []
selected_series = None
selected_series_found = False
if self.list_series.currentItem():
selected_series = self.list_series.currentItem().data(Qt.UserRole)
if hasattr(self, "add_window") and self.add_window.added > -1:
selected_series = self.add_window.added
self.add_window.added = -1
self.list_series.clear()
for entry in entries:
if entry[SI[order.upper()]] in ["Unknown", ""]:
unknown_entries.append(entry)
continue
series = entry_to_series(entry)
# Check if any filters are selected.
if not self.check_filters(series):
continue
series_item = QListWidgetItem(series.compact_string())
series_item.setData(Qt.UserRole, series.rowid)
self.list_series.addItem(series_item)
if selected_series and selected_series == series.rowid:
self.list_series.setCurrentItem(series_item)
selected_series_found = True
for entry in unknown_entries:
series = entry_to_series(entry)
series_item = QListWidgetItem(series.compact_string())
series_item.setData(Qt.UserRole, series.rowid)
self.list_series.addItem(series_item)
if selected_series and selected_series == series.rowid:
self.list_series.setCurrentItem(series_item)
selected_series_found = True
# If previous series item no longer exists, select first entry in list
if selected_series and not selected_series_found:
self.list_series.setCurrentRow(0)
if not self.list_series.currentItem():
self.clear_table()
self.filter_series_list()
def add_resztvevo(self, item):
new_item = QListWidgetItem(item)
new_item.setData(Qt.UserRole, item.data(Qt.UserRole))
self.current_players.addItem(new_item)
query = QSqlQuery(
f"insert into torna_resztvevok (player_id, player_name, torna_id) values ({new_item.data(Qt.UserRole)}, '{new_item.text()}', {self.torna_id})"
)
query.exec_()
def _fill_list_with_scene_objects(self, scene):
for sceneObject in get_animation_controllers(scene):
item = QListWidgetItem()
item.setText(sceneObject.name)
item.setData(Qt.UserRole, sceneObject.node_id)
self.sceneObjectListWidget.addItem(item)
self.controllers[sceneObject.name] = sceneObject._components[
"animation_controller"]
def initializePage(self) -> None:
for course in self.courseList:
courseItem = QListWidgetItem()
courseItem.setText(course['courseTitle'])
courseItem.setData(-1, course)
# courseItem.setFlags(courseItem.flags() | Qt.ItemIsUserCheckable)
# courseItem.setCheckState(Qt.Checked)
self.courseListWidget.addItem(courseItem)
def update_action_sequence_list(self):
self.actionListWidget.clear()
if self._action_sequence is None:
return
for action in self._action_sequence:
item = QListWidgetItem()
item.setText(action[0])
item.setData(Qt.UserRole, action[1])
self.actionListWidget.addItem(item)
def load_data(self, tornaid):
self.clear()
query = QSqlQuery(
f"select * from torna_resztvevok where torna_id={tornaid}")
query.exec_()
while query.next():
item = QListWidgetItem(query.value(1))
item.setData(1, query.value(0))
self.addItem(item)
def load_saved_players(self):
players = QSqlQueryModel()
players_query = QSqlQuery("select * from players where aktiv=1")
players.setQuery(players_query)
self.saved_players.clear()
for i in range(players.rowCount()):
item = QListWidgetItem(players.record(i).value(1))
item.setData(Qt.UserRole, players.record(i).value(0))
self.saved_players.addItem(item)
def _update_supports_list(self, character):
supports = self.service.get_supports_for_character(character)
self.listWidget_2.clear()
for support in supports:
model_index = self._get_model_index_of_character(support.character)
display_name = self.model.data(model_index, QtCore.Qt.DisplayRole)
item = QListWidgetItem(display_name)
item.setData(QtCore.Qt.UserRole, support)
self.listWidget_2.addItem(item)
self.current_supports = supports
def go_select(self):
self.ui.list_select.clear()
for name, path in futil.get_name_path_from_dataset():
item = QListWidgetItem(f"{name}")
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
item.setData(Qt.UserRole, path)
self.ui.list_select.addItem(item)
self.ui.front.setCurrentIndex(2)
def go_tanswermenu(self):
self._weight = None
self.ui.list_tanswermenu_stages.clear()
for i, stg in enumerate(self._tds.stage_list):
item = QListWidgetItem(f"{stg}")
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setCheckState(Qt.Checked)
item.setData(Qt.UserRole, i)
self.ui.list_tanswermenu_stages.addItem(item)
self.ui.front.setCurrentIndex(6)
def fill_graph_list(self):
self.graphListWidget.clear()
skeleton = str(self.skeletonListComboBox.currentText())
graph_list = get_graph_list_from_db(self.db_url, skeleton)
if graph_list is None:
return
for graph_id, name in graph_list:
item = QListWidgetItem()
item.setText(name)
item.setData(Qt.UserRole, graph_id)
self.graphListWidget.addItem(item)
def torna_valasztas(self, i):
self.torna_id = self.tournaments.itemData(i)
players = QSqlQueryModel()
players_query = QSqlQuery(
f"select * from torna_resztvevok where torna_id={self.torna_id}")
players.setQuery(players_query)
self.current_players.clear()
for i in range(players.rowCount()):
item = QListWidgetItem(players.record(i).value(1))
item.setData(Qt.UserRole, players.record(i).value(0))
self.current_players.addItem(item)
def add_avoid_address(self, addr):
for i in range(self._avoids_list.count()):
item = self._avoids_list.item(i) # type: QListWidgetItem
if int(item.text(), 16) == addr:
# deduplicate
return
item = QListWidgetItem("%#x" % addr)
item.setData(Qt.CheckStateRole, Qt.Checked)
self._avoids_list.addItem(item)
def load_torna_players(self):
players = QSqlQueryModel()
players_query = QSqlQuery(
"select * from torna_resztvevok where 1 group by player_id, player_name"
)
players.setQuery(players_query)
self.torna_players.clear()
for i in range(players.rowCount()):
item = QListWidgetItem(players.record(i).value(1))
item.setData(Qt.UserRole, players.record(i).value(0))
self.torna_players.addItem(item)
def reset(self, analysis: Analysis):
self._current_analysis_file = None
self._analysis = analysis
self._list.clear()
for analysis in HistoryManager.analysisList():
item = QListWidgetItem("%s (%s)" % (analysis["name"], analysis["date"]))
item.setData(Qt.UserRole, analysis["file"])
item.setData(Qt.UserRole + 1, analysis["name"])
self._list.addItem(item)
self._list.setCurrentRow(0)
def notify(self, updateType):
self.itemSelectionChanged.disconnect(self.selectionSlot)
if updateType == UpdateType.MATERIAL_SELECTION:
self.clearSelection()
else:
self.itemChanged.disconnect(self.itemEditSlot)
self.clear()
for o in self.scene.getObjectIterator():
item = QListWidgetItem(o.name, self)
item.setFlags(item.flags() | Qt.ItemIsEditable)
item.setData(QtCore.Qt.UserRole, o)
self.itemChanged.connect(self.itemEditSlot)
self.itemSelectionChanged.connect(self.selectionSlot)
def _update_add_list(self, character):
supported_characters = self._create_supported_characters_set(character)
module_service = locator.get_scoped("ModuleService")
self.listWidget.clear()
characters = module_service.get_module("Characters").entries
for target_character in characters:
if target_character["PID"] not in supported_characters:
model_index = self._get_model_index_of_character(target_character)
display_name = self.model.data(model_index, QtCore.Qt.DisplayRole)
item = QListWidgetItem(display_name)
item.setData(QtCore.Qt.UserRole, target_character)
self.listWidget.addItem(item)
def insert_accounts(self, sorted_users, avatars):
size = self.switcher.settings.get("display_size", "small")
font = QFont()
def insert(name, qsize, font_size: int, icon_size):
item.setData(2, name)
item.setData(13, qsize)
font.setPixelSize(font_size)
item.setFont(font)
self.accounts_list.setIconSize(icon_size)
for login_name, account in sorted_users:
item = QListWidgetItem()
item.setData(0, account)
sname = str(account.get("steam_name", login_name))
if self.switcher.settings.get("show_avatars"):
item.setData(1, QIcon(avatars.get(login_name, self.switcher.default_avatar)))
item.setData(3, account.get("comment"))
item.setData(5, login_name)
if size == "small":
insert(sname, QSize(0, 20), 12, QSize(20, 20))
elif size == "medium":
insert(sname + "\n" + account.get("comment") if account.get("comment") else sname,
QSize(0, 40), 14, QSize(40, 40))
elif size == "large":
insert(sname + "\n" + account.get("comment") if account.get("comment") else sname,
QSize(0, 60), 18, QSize(60, 60))
self.accounts_list.addItem(item)
def Write(self, files):
self.clear()
for f in files:
item = QListWidgetItem(f, self)
if self._folder is None:
item.setForeground(QBrush(Qt.red))
continue
filename = os.path.join(self._folder, f)
if not os.path.isfile(filename):
item.setForeground(QBrush(Qt.red))
continue
item.setIcon(icons.FileIcon(filename))
item.setData(Qt.UserRole, filename)
self.sortItems()
def uj_ember(self):
ujember, ok = QInputDialog.getText(
self, "Új versenyző",
'<html style="font-size: 15px;">Írd be a versenyző nevét!</html>')
if ok and len(ujember):
item = QListWidgetItem(ujember)
item.setData(Qt.UserRole, self.first_new_id)
self.current_players.addItem(item)
self.first_new_id += 1
query = QSqlQuery(
f"insert into torna_resztvevok (player_id, player_name, torna_id) values ({item.data(Qt.UserRole)}, '{item.text()}', {self.torna_id})"
)
query.exec_()
def selectItem(self):
for _x in self.test.selectedItems():
self.label3.setText(_x.text())
print(_x.text())
print(_x.data(Qt.UserRole))
try:
data = api.task_get(self.api_token, _x.data(Qt.UserRole))
except ApiException:
data = self.db.searchTask(_x.data(Qt.UserRole))
self.tasks.clear()
print(data)
for _x in data:
item = QListWidgetItem(_x["name"], self.tasks)
item.setData(Qt.UserRole, _x["task_id"])
def _add_list_item(self, item_data: ResultItemData) -> None:
new_item = QListWidgetItem(item_data.title)
new_item.setData(Qt.UserRole, item_data.glob_id)
if item_data.rgb is not None:
color = QColor(*item_data.rgb)
brush = QBrush(color)
new_item.setForeground(brush)
icon = self._data_icons.get(item_data.category.lower(), None)
if icon is not None:
new_item.setIcon(icon)
self.ui.search_result_list.addItem(new_item)
def dropEvent(self, event):
if event.mimeData().hasFormat("application/x-lista-item"):
data = event.mimeData().data("application/x-lista-item")
stream = QDataStream(data, QIODevice.ReadOnly)
text = stream.readQString()
id = stream.readInt16()
# icon = QIcon()
# stream >> icon
item = QListWidgetItem(text, self)
item.setData(1, id)
# item.setIcon(icon)
event.setDropAction(Qt.MoveAction)
event.accept()
else:
event.ignore()
def create_history_item(self, c: int, txt: str, icon, redo_idx):
num = c - redo_idx
if num >= 0:
num += 1
item = QListWidgetItem(f'{txt} [{num: 3d}]', self.viewList)
item.setData(Qt.UserRole, c)
item.setFlags(self.enabled_flags)
item.setIcon(icon)
if num > 0:
item.setForeground(self.fg_grey)
item.setFont(FontRsc.italic)
return item
def update_navbar(self):
self.clear()
main_window = self.parent().parent().parent().parent().parent()
progress = QProgressDialog("Loading images...", "Cancel", 0,
len(self.loaded_images), self)
progress.setWindowModality(Qt.WindowModal)
progress.setWindowTitle("Watermark")
progress.setWindowIcon(main_window.icon)
for i, image_path in enumerate(self.loaded_images):
progress.setValue(i)
if progress.wasCanceled():
break
item = QListWidgetItem(os.path.basename(image_path))
item.setData(Qt.UserRole, image_path)
self.addItem(item)
progress.setValue(len(self.loaded_images))
def update_view(self):
self.clear()
self.rows_data = self.filter_view()
for row_data in self.rows_data:
playlist_name = self.manager_model.playlists[row_data].name
item = QListWidgetItem(playlist_name)
item.setData(Qt.UserRole, row_data)
if ord("a") <= ord(playlist_name[0].lower()) <= ord("z"):
item.setIcon(
QIcon(
QPixmap(u":/images/icons/ascii/{}.png".format(
playlist_name[0].lower()))))
else:
item.setIcon(
QIcon(QPixmap(u":/images/icons/ascii/question_mark.svg")))
self.addItem(item)
def _add_file_to_file_list(self,
index,
file_list,
items_dict,
obj_id,
rel_path,
created_time,
was_updated,
is_deleted,
transfered,
size=0,
state=None,
is_file=True):
item = file_list.item(index)
if item:
item.setData(Qt.UserRole, [
rel_path, created_time, size, was_updated, is_deleted,
transfered, state, is_file, obj_id
])
self._update_file_list_item_widget(file_list, item)
items_dict[obj_id].append(item)
return
item = QListWidgetItem()
item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
item.setSizeHint(QSize(file_list.width(), self.FILE_LIST_ITEM_SIZE))
item.setData(Qt.UserRole, [
rel_path, created_time, size, was_updated, is_deleted, transfered,
state, is_file, obj_id
])
file_list.addItem(item)
rect = file_list.viewport().contentsRect()
top = file_list.indexAt(rect.topLeft())
if top.isValid():
bottom = file_list.indexAt(rect.bottomLeft())
if not bottom.isValid():
bottom = file_list.model().index(file_list.count() - 1)
if top.row() <= file_list.row(item) <= bottom.row() + 1:
widget = self._create_file_list_item_widget(
file_list, [
rel_path, created_time, size, was_updated, is_deleted,
transfered, state, is_file, obj_id
])
file_list.setItemWidget(item, widget)
if item not in items_dict[obj_id]:
items_dict[obj_id].append(item)
def _fill_model_list_from_db(self, idx=None):
self.modelListWidget.clear()
col = self.get_collection()
if col is None:
return
c_id, c_name, c_type = col
model_list = get_model_list_from_remote_db(self.db_url, c_id, self.skeleton)
print("model list", model_list)
if model_list is None:
return
for node_id, name in model_list:
item = QListWidgetItem()
item.setText(name)
item.setData(Qt.UserRole, node_id)
self.modelListWidget.addItem(item)
self.update_selected_model()
def update_view(self):
self.clear()
self.rows_data = self.filter_view()
for row_data in self.rows_data:
shown_name = "({})" if len(row_data) > 1 else "{}"
item = QListWidgetItem(
shown_name.format(", ".join([str(i) for i in row_data])))
item.setData(Qt.UserRole, row_data)
if ord("a") <= ord(str(row_data[0])[0].lower()) <= ord("z"):
item.setIcon(
QIcon(
QPixmap(u":/images/icons/ascii/{}.png".format(
str(row_data[0])[0].lower()))))
else:
item.setIcon(
QIcon(QPixmap(u":/images/icons/ascii/question_mark.svg")))
self.addItem(item)