mirror of
https://github.com/KeksPirates/SoftwareManager.git
synced 2026-08-04 01:49:42 +02:00
refactor: remove core/ folder
This commit is contained in:
Vxrtrauter
File diff suppressed because one or more lines are too long
Binary file not shown.
|
After Width: | Height: | Size: 32 KiB |
@@ -0,0 +1,149 @@
|
||||
from utils.logging.logs import consoleLog, remove_download_log
|
||||
from PySide6.QtWidgets import QMessageBox
|
||||
from PySide6.QtCore import Qt, QPoint
|
||||
from utils.data.state import state
|
||||
from PySide6 import QtWidgets
|
||||
import subprocess
|
||||
import platform
|
||||
import time
|
||||
import os
|
||||
|
||||
class ContextMenu:
|
||||
def __init__(self, main_window):
|
||||
self.main_window = main_window
|
||||
self.context_menu = QtWidgets.QMenu(main_window)
|
||||
self.context_menu.addAction("Open Containing Folder", self.openFolderAction)
|
||||
self.context_menu.addAction("Copy Magnet URI", self.copyMagnetURIAction)
|
||||
self.context_menu.addAction("Remove from list", self.cancelDownloadAction)
|
||||
self.context_menu.addAction("Delete File", self.deleteFileAction)
|
||||
|
||||
main_window.downloadList.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
|
||||
main_window.downloadList.customContextMenuRequested.connect(self._show_context_menu)
|
||||
|
||||
@property
|
||||
def downloadList(self):
|
||||
return self.main_window.downloadList
|
||||
|
||||
def _show_context_menu(self, pos: QPoint):
|
||||
index = self.downloadList.indexAt(pos)
|
||||
if index.isValid():
|
||||
self._context_menu_row = index.row()
|
||||
self.context_menu.exec(self.downloadList.viewport().mapToGlobal(pos))
|
||||
|
||||
def openFolderAction(self):
|
||||
if not hasattr(self, '_context_menu_row'):
|
||||
return
|
||||
row = self._context_menu_row
|
||||
if row < 0 or row >= len(state.active_downloads):
|
||||
return
|
||||
magnet_link = list(state.active_downloads.keys())[row]
|
||||
magnetdl = state.active_downloads[magnet_link]
|
||||
download_path = magnetdl.save_path()
|
||||
if download_path and os.path.exists(download_path):
|
||||
if platform.system() == "Windows":
|
||||
os.startfile(os.path.normpath(download_path))
|
||||
elif platform.system() == "Linux":
|
||||
subprocess.Popen(["xdg-open", download_path])
|
||||
elif platform.system() == "Darwin":
|
||||
subprocess.Popen(["open", download_path])
|
||||
|
||||
def copyMagnetURIAction(self):
|
||||
if not hasattr(self, '_context_menu_row'):
|
||||
return
|
||||
row = self._context_menu_row
|
||||
if row < 0 or row >= len(state.active_downloads):
|
||||
return
|
||||
magnet_link = list(state.active_downloads.keys())[row]
|
||||
clipboard = QtWidgets.QApplication.clipboard()
|
||||
clipboard.setText(magnet_link)
|
||||
|
||||
def cancelDownloadAction(self):
|
||||
if not hasattr(self, '_context_menu_row'):
|
||||
return
|
||||
row = self._context_menu_row
|
||||
with state.downloads_lock:
|
||||
if row < 0 or row >= len(state.active_downloads):
|
||||
return
|
||||
magnet_link = list(state.active_downloads.keys())[row]
|
||||
magnetdl = state.active_downloads[magnet_link]
|
||||
|
||||
# Cache the name BEFORE removing from session
|
||||
try:
|
||||
torrent_name = magnetdl.status().name
|
||||
except RuntimeError:
|
||||
torrent_name = "Unknown"
|
||||
|
||||
confirm = QMessageBox.question(
|
||||
self.main_window, "Cancel Download",
|
||||
f"Are you sure you want to cancel the download of '{torrent_name}'?",
|
||||
QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
|
||||
)
|
||||
if confirm == QMessageBox.StandardButton.Yes:
|
||||
with state.downloads_lock:
|
||||
state.active_downloads.pop(magnet_link, None)
|
||||
remove_download_log(magnet_link)
|
||||
|
||||
if state.dl_session:
|
||||
try:
|
||||
state.dl_session.remove_torrent(magnetdl)
|
||||
except Exception as e:
|
||||
consoleLog(f"Exception while removing download from LibTorrent: {e}")
|
||||
|
||||
consoleLog(f"Cancelled download: {torrent_name}", True)
|
||||
|
||||
|
||||
def deleteFileAction(self):
|
||||
if not hasattr(self, '_context_menu_row'):
|
||||
return
|
||||
row = self._context_menu_row
|
||||
with state.downloads_lock:
|
||||
if row < 0 or row >= len(state.active_downloads):
|
||||
return
|
||||
magnet_link = list(state.active_downloads.keys())[row]
|
||||
magnetdl = state.active_downloads[magnet_link]
|
||||
try:
|
||||
status = magnetdl.status()
|
||||
save_path = status.save_path
|
||||
torrent_name = status.name
|
||||
except RuntimeError:
|
||||
consoleLog("Error: torrent handle already invalid", True)
|
||||
with state.downloads_lock:
|
||||
state.active_downloads.pop(magnet_link, None)
|
||||
remove_download_log(magnet_link)
|
||||
return
|
||||
download_path = os.path.join(save_path, torrent_name)
|
||||
confirm = QMessageBox.question(
|
||||
self.main_window, "Delete Files",
|
||||
f"Are you sure you want to delete the downloaded files of '{torrent_name}'? This action cannot be undone.",
|
||||
QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
|
||||
)
|
||||
if confirm == QMessageBox.StandardButton.Yes:
|
||||
with state.downloads_lock:
|
||||
state.active_downloads.pop(magnet_link, None)
|
||||
remove_download_log(magnet_link)
|
||||
if state.dl_session:
|
||||
try:
|
||||
state.dl_session.remove_torrent(magnetdl)
|
||||
time.sleep(0.5)
|
||||
except Exception as e:
|
||||
consoleLog(f"Exception while removing download from LibTorrent: {e}")
|
||||
if download_path and os.path.exists(download_path):
|
||||
import shutil
|
||||
last_error = None
|
||||
for attempt in range(3):
|
||||
try:
|
||||
if os.path.isfile(download_path):
|
||||
os.remove(download_path)
|
||||
else:
|
||||
shutil.rmtree(download_path)
|
||||
consoleLog(f"Deleted files for: {torrent_name}", True)
|
||||
last_error = None
|
||||
break
|
||||
except Exception as e:
|
||||
last_error = e
|
||||
if attempt < 2:
|
||||
time.sleep(0.5)
|
||||
if last_error:
|
||||
consoleLog(f"Error deleting files: {last_error}", True)
|
||||
else:
|
||||
consoleLog(f"Removed entry (files not found): {torrent_name}", True)
|
||||
@@ -0,0 +1,89 @@
|
||||
from interface.dialogs.pauseresumedelegate import PauseResumeDelegate
|
||||
from interface.dialogs.hoverrowdelegate import HoverRowDelegate
|
||||
from interface.dialogs.downloadmodel import DownloadModel
|
||||
from interface.dialogs.theme import _table_stylesheet
|
||||
from PySide6.QtWidgets import QTableView, QHeaderView
|
||||
from utils.logging.logs import consoleLog
|
||||
from PySide6 import QtWidgets
|
||||
from PySide6.QtCore import Qt
|
||||
|
||||
def _create_download_list(self) -> QTableView:
|
||||
self.download_model = DownloadModel()
|
||||
self.downloadList.setModel(self.download_model)
|
||||
self.downloadList.horizontalHeader().setStretchLastSection(False)
|
||||
self.downloadList.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeMode.Fixed)
|
||||
self.downloadList.horizontalHeader().resizeSection(0, 70)
|
||||
self.downloadList.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeMode.Stretch)
|
||||
self.downloadList.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeMode.ResizeToContents)
|
||||
self.downloadList.horizontalHeader().setSectionResizeMode(3, QHeaderView.ResizeMode.ResizeToContents)
|
||||
self.downloadList.horizontalHeader().setSectionResizeMode(4, QHeaderView.ResizeMode.ResizeToContents)
|
||||
self.downloadList.horizontalHeader().setSectionResizeMode(5, QHeaderView.ResizeMode.ResizeToContents)
|
||||
self.downloadList.horizontalHeader().setSectionResizeMode(6, QHeaderView.ResizeMode.ResizeToContents)
|
||||
self.downloadList.horizontalHeader().setMinimumSectionSize(60)
|
||||
self.downloadList.verticalHeader().setDefaultSectionSize(40)
|
||||
self.downloadList.setSelectionBehavior(QTableView.SelectionBehavior.SelectRows)
|
||||
self.downloadList.setSelectionMode(QtWidgets.QAbstractItemView.SelectionMode.ExtendedSelection)
|
||||
self.downloadList.verticalHeader().setVisible(False)
|
||||
self.downloadList.horizontalHeader().setDefaultAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
|
||||
self.downloadList.horizontalHeader().setHighlightSections(False)
|
||||
self.downloadList.setMouseTracking(True)
|
||||
self.downloadList.setShowGrid(False)
|
||||
self.downloadList.setStyleSheet(_table_stylesheet("QTableView"))
|
||||
self.downloadList.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
|
||||
self.downloadList.viewport().setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
|
||||
|
||||
download_model = self.download_model
|
||||
|
||||
def on_pause_resume_clicked(row):
|
||||
download_model.toggle_pause_resume(row)
|
||||
|
||||
self.downloadList.viewport().setMouseTracking(True)
|
||||
hover_delegate = HoverRowDelegate(self.downloadList)
|
||||
self.downloadList.setItemDelegate(hover_delegate)
|
||||
|
||||
delegate = PauseResumeDelegate(self.downloadList)
|
||||
self.downloadList.setItemDelegateForColumn(0, delegate)
|
||||
delegate.clicked.connect(on_pause_resume_clicked)
|
||||
|
||||
return self.downloadList
|
||||
|
||||
def download_list_update(self):
|
||||
self._update_speed_label()
|
||||
if not self.download_model:
|
||||
return
|
||||
|
||||
row_count = self.download_model.rowCount()
|
||||
col_count = self.download_model.columnCount()
|
||||
|
||||
if row_count > 0 and col_count > 0:
|
||||
top_left = self.download_model.index(0, 0)
|
||||
bottom_right = self.download_model.index(row_count - 1, col_count - 1)
|
||||
if top_left.isValid() and bottom_right.isValid():
|
||||
self.download_model.dataChanged.emit(top_left, bottom_right, [Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.UserRole])
|
||||
|
||||
if row_count != self._last_dl_row_count:
|
||||
old_count = self._last_dl_row_count
|
||||
self._last_dl_row_count = row_count
|
||||
if row_count > 0:
|
||||
self.download_model.layoutAboutToBeChanged.emit()
|
||||
self.download_model.layoutChanged.emit()
|
||||
for row in range(row_count):
|
||||
idx = self.download_model.index(row, 0)
|
||||
if idx.isValid():
|
||||
self.downloadList.closePersistentEditor(idx)
|
||||
self.downloadList.openPersistentEditor(idx)
|
||||
elif old_count > 0:
|
||||
self.download_model.layoutAboutToBeChanged.emit()
|
||||
self.download_model.layoutChanged.emit()
|
||||
else:
|
||||
if row_count > 0:
|
||||
delegate = self.downloadList.itemDelegateForColumn(0)
|
||||
for row in range(row_count):
|
||||
idx = self.download_model.index(row, 0)
|
||||
if idx.isValid():
|
||||
editor = self.downloadList.indexWidget(idx)
|
||||
if editor and delegate:
|
||||
try:
|
||||
delegate.setEditorData(editor, idx)
|
||||
except RuntimeError as e:
|
||||
consoleLog(f"Exception while updating download list: {e}")
|
||||
@@ -0,0 +1,136 @@
|
||||
from PySide6.QtCore import QAbstractTableModel, QModelIndex, Qt
|
||||
from utils.logging.logs import consoleLog
|
||||
from utils.data.state import state
|
||||
import libtorrent as lt
|
||||
import subprocess
|
||||
import platform
|
||||
import os
|
||||
|
||||
class DownloadModel(QAbstractTableModel):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.headers = ["Action", "Name", "Status", "Progress", "Speed", "Size", "Total Size"]
|
||||
|
||||
def rowCount(self, parent=QModelIndex()):
|
||||
if parent.isValid():
|
||||
return 0
|
||||
with state.downloads_lock:
|
||||
return len(state.active_downloads)
|
||||
|
||||
def columnCount(self, parent=QModelIndex()):
|
||||
return len(self.headers)
|
||||
|
||||
def headerData(self, section, orientation, role=Qt.ItemDataRole.DisplayRole):
|
||||
if role == Qt.ItemDataRole.DisplayRole and orientation == Qt.Orientation.Horizontal:
|
||||
return self.headers[section]
|
||||
return None
|
||||
|
||||
def data(self, index, role=Qt.ItemDataRole.DisplayRole):
|
||||
if not index.isValid():
|
||||
return None
|
||||
|
||||
with state.downloads_lock:
|
||||
if index.row() >= len(state.active_downloads) or index.row() < 0:
|
||||
return None
|
||||
|
||||
try:
|
||||
magnet_link = list(state.active_downloads.keys())[index.row()]
|
||||
magnetdl = state.active_downloads[magnet_link]
|
||||
status = magnetdl.status()
|
||||
except (IndexError, KeyError, RuntimeError):
|
||||
return None
|
||||
|
||||
if role == Qt.ItemDataRole.DisplayRole:
|
||||
col = index.column()
|
||||
if col == 0:
|
||||
pass
|
||||
elif col == 1:
|
||||
return status.name if status.has_metadata else "Fetching metadata..."
|
||||
elif col == 2:
|
||||
if status.paused:
|
||||
is_auto = getattr(status, 'auto_managed', True)
|
||||
return "Queued" if is_auto else "Paused"
|
||||
elif status.state == lt.torrent_status.downloading:
|
||||
return "Downloading"
|
||||
elif status.state == lt.torrent_status.seeding:
|
||||
return "Seeding"
|
||||
else:
|
||||
return "Queued"
|
||||
elif col == 3:
|
||||
return f"{status.progress * 100:.1f}%"
|
||||
elif col == 4:
|
||||
down_kb = status.download_rate / 1024
|
||||
up_kb = status.upload_rate / 1024
|
||||
down_text = f"{down_kb / 1024:.1f} MB/s" if down_kb > 1024 else f"{down_kb:.1f} kB/s"
|
||||
up_text = f"{up_kb / 1024:.1f} MB/s" if up_kb > 1024 else f"{up_kb:.1f} kB/s"
|
||||
return f"↓ {down_text} ↑ {up_text}"
|
||||
elif col == 5:
|
||||
downloaded_mb = status.total_wanted_done / (1024 * 1024)
|
||||
if downloaded_mb > 1024:
|
||||
return f"{downloaded_mb / 1024:.2f} GB"
|
||||
else:
|
||||
return f"{downloaded_mb:.1f} MB"
|
||||
elif col == 6:
|
||||
total_mb = status.total_wanted / (1024 * 1024)
|
||||
if total_mb > 1024:
|
||||
return f"{total_mb / 1024:.2f} GB"
|
||||
else:
|
||||
return f"{total_mb:.1f} MB"
|
||||
elif col == 7:
|
||||
if status.download_rate > 0:
|
||||
bytes_left = status.total_wanted - status.total_wanted_done
|
||||
eta_seconds = bytes_left / status.download_rate
|
||||
if eta_seconds < 60:
|
||||
return f"{int(eta_seconds)}s"
|
||||
elif eta_seconds < 3600:
|
||||
minutes = int(eta_seconds / 60)
|
||||
seconds = int(eta_seconds % 60)
|
||||
return f"{minutes}m {seconds}s"
|
||||
else:
|
||||
hours = int(eta_seconds / 3600)
|
||||
minutes = int((eta_seconds % 3600) / 60)
|
||||
return f"{hours}h {minutes}m"
|
||||
else:
|
||||
return "∞" if status.paused else "Stalled"
|
||||
if role == Qt.ItemDataRole.UserRole and index.column() == 0:
|
||||
return status.paused
|
||||
return None
|
||||
|
||||
def toggle_pause_resume(self, row):
|
||||
with state.downloads_lock:
|
||||
if row >= len(state.active_downloads) or row < 0:
|
||||
return
|
||||
try:
|
||||
magnet_link = list(state.active_downloads.keys())[row]
|
||||
magnetdl = state.active_downloads[magnet_link]
|
||||
status = magnetdl.status()
|
||||
except (IndexError, KeyError, RuntimeError):
|
||||
return
|
||||
|
||||
if status.state == lt.torrent_status.seeding:
|
||||
try:
|
||||
save_path = magnetdl.save_path()
|
||||
if save_path and os.path.exists(save_path):
|
||||
if platform.system() == "Windows":
|
||||
os.startfile(os.path.normpath(save_path))
|
||||
elif platform.system() == "Linux":
|
||||
subprocess.Popen(["xdg-open", save_path])
|
||||
elif platform.system() == "Darwin":
|
||||
subprocess.Popen(["open", save_path])
|
||||
except Exception as e:
|
||||
consoleLog(f"Exception while opening file: {e}")
|
||||
return
|
||||
|
||||
is_paused = status.paused
|
||||
if is_paused:
|
||||
if hasattr(magnetdl, 'set_flags'):
|
||||
magnetdl.set_flags(lt.torrent_flags.auto_managed)
|
||||
magnetdl.resume()
|
||||
consoleLog(f"Resumed download: {status.name}", True)
|
||||
else:
|
||||
if hasattr(magnetdl, 'unset_flags'):
|
||||
magnetdl.unset_flags(lt.torrent_flags.auto_managed)
|
||||
magnetdl.pause()
|
||||
consoleLog(f"Paused download: {status.name}", True)
|
||||
idx = self.index(row, 0)
|
||||
self.dataChanged.emit(idx, idx, [Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.UserRole])
|
||||
@@ -0,0 +1,22 @@
|
||||
from interface.dialogs.theme import _theme_colors
|
||||
from PySide6.QtWidgets import QStyledItemDelegate
|
||||
from PySide6.QtCore import Qt
|
||||
|
||||
class ElidedItemDelegate(QStyledItemDelegate):
|
||||
def __init__(self, get_hovered_row, parent=None):
|
||||
super().__init__(parent)
|
||||
self._get_hovered_row = get_hovered_row
|
||||
|
||||
def initStyleOption(self, option, index):
|
||||
super().initStyleOption(option, index)
|
||||
if option.text:
|
||||
metrics = option.fontMetrics
|
||||
text_rect = option.rect.adjusted(14, 0, -14, 0)
|
||||
option.text = metrics.elidedText(option.text, Qt.TextElideMode.ElideMiddle, text_rect.width())
|
||||
|
||||
def paint(self, painter, option, index):
|
||||
if index.row() == self._get_hovered_row():
|
||||
painter.save()
|
||||
painter.fillRect(option.rect, _theme_colors()["hover"])
|
||||
painter.restore()
|
||||
super().paint(painter, option, index)
|
||||
@@ -0,0 +1,36 @@
|
||||
from utils.logging.logs import consoleLog
|
||||
from utils.data.state import state
|
||||
from PySide6.QtCore import QEvent
|
||||
|
||||
def eventFilter(self, obj, event):
|
||||
try:
|
||||
if obj == state.trackertable.viewport():
|
||||
if event.type() == QEvent.Type.MouseMove:
|
||||
pos = event.position().toPoint() if hasattr(event, 'position') else event.pos()
|
||||
idx = state.trackertable.indexAt(pos)
|
||||
new_row = idx.row() if idx.isValid() else -1
|
||||
if new_row != self._tracker_hovered_row or state.trackertable is not self._tracker_hovered_table:
|
||||
self._tracker_hovered_row = new_row
|
||||
self._tracker_hovered_table = state.trackertable
|
||||
state.trackertable.viewport().update()
|
||||
elif event.type() == QEvent.Type.Leave:
|
||||
self._tracker_hovered_row = -1
|
||||
self._tracker_hovered_table = None
|
||||
state.trackertable.viewport().update()
|
||||
if obj == self.downloadList.viewport():
|
||||
if event.type() == QEvent.Type.MouseMove:
|
||||
pos = event.position().toPoint() if hasattr(event, 'position') else event.pos()
|
||||
idx = self.downloadList.indexAt(pos)
|
||||
new_row = idx.row() if idx.isValid() else -1
|
||||
if new_row != self._hovered_row:
|
||||
old_row = self._hovered_row
|
||||
self._hovered_row = new_row
|
||||
self._invalidate_hover_row(old_row)
|
||||
self._invalidate_hover_row(new_row)
|
||||
elif event.type() == QEvent.Type.Leave:
|
||||
old_row = self._hovered_row
|
||||
self._hovered_row = -1
|
||||
self._invalidate_hover_row(old_row)
|
||||
except (RuntimeError, AttributeError) as e:
|
||||
consoleLog(f"Exception in EventFilter: {e}")
|
||||
return super(type(self), self).eventFilter(obj, event)
|
||||
@@ -0,0 +1,19 @@
|
||||
from interface.dialogs.theme import _theme_colors
|
||||
from PySide6.QtWidgets import QStyledItemDelegate
|
||||
from PySide6 import QtWidgets
|
||||
|
||||
class HoverRowDelegate(QStyledItemDelegate):
|
||||
|
||||
def paint(self, painter, option, index):
|
||||
from interface.gui import MainWindow
|
||||
|
||||
opt = QtWidgets.QStyleOptionViewItem(option)
|
||||
option.state &= ~QtWidgets.QStyle.StateFlag.State_HasFocus
|
||||
option.state &= ~QtWidgets.QStyle.StateFlag.State_Selected
|
||||
|
||||
hovered_row = MainWindow._instance._hovered_row if MainWindow._instance else -1
|
||||
if index.row() == hovered_row:
|
||||
painter.save()
|
||||
painter.fillRect(option.rect, _theme_colors()["hover"])
|
||||
painter.restore()
|
||||
super().paint(painter, opt, index)
|
||||
@@ -0,0 +1,29 @@
|
||||
from PySide6.QtGui import QImage, QPixmap
|
||||
from PySide6.QtWidgets import QLabel
|
||||
from utils.data.state import state
|
||||
from PySide6.QtCore import Qt
|
||||
import os
|
||||
|
||||
class Image():
|
||||
def __init__(self, parent):
|
||||
self.overlay_label = QLabel(parent)
|
||||
self.overlay_label.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents, True)
|
||||
|
||||
if state.image_path is not None and os.path.exists(state.image_path):
|
||||
self.image = QImage(state.image_path)
|
||||
self.image = self.image.scaledToWidth(300, Qt.TransformationMode.SmoothTransformation)
|
||||
|
||||
self.pixmap = QPixmap.fromImage(self.image)
|
||||
self.overlay_label.setPixmap(self.pixmap)
|
||||
self.overlay_label.adjustSize()
|
||||
self.overlay_label.raise_()
|
||||
|
||||
x = parent.width() - self.overlay_label.width()
|
||||
y = parent.height() - self.overlay_label.height()
|
||||
self.overlay_label.move(x, y)
|
||||
|
||||
def update_image_overlay(self, new_image_path):
|
||||
self.image = QImage(new_image_path)
|
||||
self.pixmap = QPixmap.fromImage(self.image)
|
||||
self.overlay_label.setPixmap(self.pixmap)
|
||||
self.overlay_label.adjustSize()
|
||||
@@ -0,0 +1,86 @@
|
||||
from interface.dialogs.theme import _theme_colors, SVG_PLAY, SVG_PAUSE, SVG_FOLDER
|
||||
from PySide6.QtWidgets import QStyledItemDelegate, QWidget, QHBoxLayout
|
||||
from interface.utils.svghelper import svg_icon
|
||||
from PySide6.QtCore import Qt, QSize, Signal
|
||||
from utils.data.state import state
|
||||
from PySide6 import QtWidgets
|
||||
import libtorrent as lt
|
||||
|
||||
class PauseResumeDelegate(QStyledItemDelegate):
|
||||
clicked = Signal(int)
|
||||
|
||||
def paint(self, painter, option, index):
|
||||
from interface.gui import MainWindow
|
||||
|
||||
opt = QtWidgets.QStyleOptionViewItem(option)
|
||||
option.state &= ~QtWidgets.QStyle.StateFlag.State_HasFocus
|
||||
option.state &= ~QtWidgets.QStyle.StateFlag.State_Selected
|
||||
|
||||
hovered_row = MainWindow._instance._hovered_row if MainWindow._instance else -1
|
||||
if index.row() == hovered_row:
|
||||
painter.save()
|
||||
painter.fillRect(option.rect, _theme_colors()["hover"])
|
||||
painter.restore()
|
||||
super().paint(painter, opt, index)
|
||||
|
||||
def setEditorData(self, editor, index):
|
||||
button = editor.findChild(QtWidgets.QPushButton)
|
||||
if not button:
|
||||
return
|
||||
try:
|
||||
with state.downloads_lock:
|
||||
keys = list(state.active_downloads.keys())
|
||||
if index.row() >= len(keys):
|
||||
return
|
||||
magnet_link = keys[index.row()]
|
||||
magnetdl = state.active_downloads[magnet_link]
|
||||
status = magnetdl.status()
|
||||
except (RuntimeError, IndexError, KeyError):
|
||||
return
|
||||
|
||||
if status.state == lt.torrent_status.seeding:
|
||||
button.setIcon(svg_icon(SVG_FOLDER, 18))
|
||||
button.setText("")
|
||||
else:
|
||||
is_user_paused = status.paused and not status.auto_managed
|
||||
button.setIcon(svg_icon(SVG_PLAY if is_user_paused else SVG_PAUSE, 18))
|
||||
button.setText("")
|
||||
|
||||
|
||||
def createEditor(self, parent, option, index):
|
||||
try:
|
||||
with state.downloads_lock:
|
||||
keys = list(state.active_downloads.keys())
|
||||
if index.row() >= len(keys):
|
||||
return QWidget(parent)
|
||||
magnet_link = keys[index.row()]
|
||||
magnetdl = state.active_downloads[magnet_link]
|
||||
status = magnetdl.status()
|
||||
except (RuntimeError, IndexError, KeyError):
|
||||
return QWidget(parent)
|
||||
|
||||
widget = QWidget(parent)
|
||||
widget.setStyleSheet("border: none; background: transparent;")
|
||||
layout = QHBoxLayout(widget)
|
||||
layout.setContentsMargins(0, 0, 0, 0)
|
||||
if status.state == lt.torrent_status.seeding:
|
||||
btnPause = QtWidgets.QPushButton()
|
||||
btnPause.setIcon(svg_icon(SVG_FOLDER, 18))
|
||||
else:
|
||||
btnPause = QtWidgets.QPushButton()
|
||||
is_user_paused = status.paused and not status.auto_managed
|
||||
btnPause.setIcon(svg_icon(SVG_PLAY if is_user_paused else SVG_PAUSE, 18))
|
||||
btnPause.setIconSize(QSize(18, 18))
|
||||
btnPause.setFixedSize(30, 30)
|
||||
btnPause.setCursor(Qt.CursorShape.PointingHandCursor)
|
||||
btnPause.setStyleSheet("QPushButton { border: none; background: transparent; padding: 0px; }")
|
||||
btnPause.clicked.connect(lambda: self.clicked.emit(index.row()))
|
||||
layout.addStretch()
|
||||
layout.addWidget(btnPause)
|
||||
layout.addStretch()
|
||||
widget.setLayout(layout)
|
||||
return widget
|
||||
|
||||
|
||||
def editorEvent(self, event, model, option, index):
|
||||
return False
|
||||
@@ -0,0 +1,292 @@
|
||||
from interface.utils.tabhelper import general_tab
|
||||
from interface.utils.tabhelper import network_tab
|
||||
from utils.config.settings import save_settings
|
||||
from interface.utils.tabhelper import paths_tab
|
||||
from interface.utils.svghelper import svg_icon
|
||||
from utils.logging.logs import consoleLog
|
||||
from PySide6.QtCore import Qt, QSize
|
||||
from utils.data.state import state
|
||||
from PySide6 import QtWidgets
|
||||
from PySide6.QtWidgets import (
|
||||
QLineEdit,
|
||||
QPushButton,
|
||||
QWidget,
|
||||
QVBoxLayout,
|
||||
QDialog,
|
||||
QLabel,
|
||||
QHBoxLayout,
|
||||
QSpinBox,
|
||||
QCheckBox,
|
||||
QFileDialog,
|
||||
QComboBox,
|
||||
QTabWidget,
|
||||
)
|
||||
|
||||
import platform
|
||||
|
||||
SVG_FOLDER = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M2 6c0-1.1.9-2 2-2h5l2 2h7c1.1 0 2 .9 2 2v10c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6z" fill="{color}"/></svg>'
|
||||
|
||||
|
||||
def settings_dialog(self):
|
||||
|
||||
consoleLog("Settings dialog opened")
|
||||
dialog = QDialog(self)
|
||||
dialog.setWindowTitle("Settings")
|
||||
dialog.setFixedSize(700, 450)
|
||||
|
||||
dialog_layout = QVBoxLayout()
|
||||
dialog.setLayout(dialog_layout)
|
||||
|
||||
if state.window_transparency and platform.system() != "Windows" and dialog:
|
||||
dialog.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
|
||||
|
||||
def close_settings():
|
||||
dialog.reject()
|
||||
|
||||
update_checkbox_container = QWidget()
|
||||
update_checkbox_layout = QHBoxLayout()
|
||||
|
||||
# ignore updates checkbox
|
||||
|
||||
if platform.system() == "Windows":
|
||||
update_checkbox = QCheckBox()
|
||||
update_checkbox_container.setLayout(update_checkbox_layout)
|
||||
update_checkbox_layout.addWidget(QLabel("Ignore Updates: "))
|
||||
update_checkbox_layout.addStretch()
|
||||
update_checkbox.setChecked(state.ignore_updates)
|
||||
update_checkbox.toggled.connect(lambda checked: setattr(state, 'ignore_updates', checked))
|
||||
update_checkbox_layout.addWidget(update_checkbox)
|
||||
|
||||
# auto-resume downloads checkbox
|
||||
|
||||
autoresume_container = QWidget()
|
||||
autoresume_layout = QHBoxLayout()
|
||||
|
||||
autoresume_checkbox = QCheckBox()
|
||||
autoresume_container.setLayout(autoresume_layout)
|
||||
autoresume_layout.addWidget(QLabel("Auto-Resume Downloads: "))
|
||||
|
||||
autoresume_layout.addStretch()
|
||||
autoresume_checkbox.setChecked(state.autoresume)
|
||||
autoresume_layout.addWidget(autoresume_checkbox)
|
||||
|
||||
|
||||
# transparent window checkbox
|
||||
transparent_window_container = QWidget()
|
||||
transparent_window_layout = QHBoxLayout()
|
||||
|
||||
transparent_window_checkbox = QCheckBox()
|
||||
transparent_window_container.setLayout(transparent_window_layout)
|
||||
transparent_window_layout.addWidget(QLabel("Window Transparency (requires restart) (Linux/MacOS only): "))
|
||||
|
||||
transparent_window_layout.addStretch()
|
||||
transparent_window_checkbox.setChecked(state.window_transparency)
|
||||
transparent_window_checkbox.toggled.connect(lambda checked: setattr(state, 'window_transparency', checked))
|
||||
transparent_window_layout.addWidget(transparent_window_checkbox)
|
||||
|
||||
##################
|
||||
# SERVER SETTING #
|
||||
##################
|
||||
|
||||
api_url_container = QWidget()
|
||||
api_url_layout = QHBoxLayout()
|
||||
|
||||
api_url = QLineEdit()
|
||||
api_url_layout.addWidget(QLabel("API Server URL:"))
|
||||
api_url_layout.addWidget(api_url)
|
||||
api_url_container.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
|
||||
api_url_container.setLayout(api_url_layout)
|
||||
api_url.setText(state.api_url)
|
||||
|
||||
#################
|
||||
# DOWNLOAD PATH #
|
||||
#################
|
||||
|
||||
download_path_container = QWidget()
|
||||
download_path_layout = QHBoxLayout()
|
||||
|
||||
download_path = QLineEdit()
|
||||
download_path_layout.addWidget(QLabel("Download Path:"))
|
||||
download_path_layout.addWidget(download_path)
|
||||
download_path_container.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
|
||||
download_path_container.setLayout(download_path_layout)
|
||||
download_path.setText(state.download_path)
|
||||
|
||||
def browse_download_path():
|
||||
dir_path = QFileDialog.getExistingDirectory(dialog, "Select Download Directory", state.download_path)
|
||||
if dir_path:
|
||||
download_path.setText(dir_path)
|
||||
|
||||
browse_button = QPushButton()
|
||||
browse_button.setFixedSize(36, 36)
|
||||
browse_button.setIconSize(QSize(24, 24))
|
||||
browse_button.setIcon(svg_icon(SVG_FOLDER, 24))
|
||||
browse_button.setCursor(Qt.CursorShape.PointingHandCursor)
|
||||
browse_button.setStyleSheet("""
|
||||
QPushButton {
|
||||
border: none;
|
||||
background: transparent;
|
||||
padding: 0px;
|
||||
}
|
||||
""")
|
||||
|
||||
download_path_layout.addWidget(browse_button)
|
||||
browse_button.clicked.connect(browse_download_path)
|
||||
|
||||
###############
|
||||
# IMAGE PATH #
|
||||
###############
|
||||
|
||||
image_path_container = QWidget()
|
||||
image_path_layout = QHBoxLayout()
|
||||
|
||||
image_path = QLineEdit()
|
||||
image_path_layout.addWidget(QLabel("Image Path (requires restart, experimental):"))
|
||||
image_path_layout.addWidget(image_path)
|
||||
image_path_container.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
|
||||
image_path_container.setLayout(image_path_layout)
|
||||
image_path.setText(state.image_path)
|
||||
|
||||
def browse_image_path():
|
||||
file_path = QFileDialog.getOpenFileName(dialog, "Select Image File", state.image_path, "Image Files (*.png *.jpg)")[0]
|
||||
if file_path:
|
||||
image_path.setText(file_path)
|
||||
|
||||
browse_button = QPushButton()
|
||||
browse_button.setFixedSize(36, 36)
|
||||
browse_button.setIconSize(QSize(24, 24))
|
||||
browse_button.setIcon(svg_icon(SVG_FOLDER, 24))
|
||||
browse_button.setCursor(Qt.CursorShape.PointingHandCursor)
|
||||
browse_button.setStyleSheet("""
|
||||
QPushButton {
|
||||
border: none;
|
||||
background: transparent;
|
||||
padding: 0px;
|
||||
}
|
||||
""")
|
||||
image_path_layout.addWidget(browse_button)
|
||||
browse_button.clicked.connect(browse_image_path)
|
||||
|
||||
##################
|
||||
# SPEED LIMITING #
|
||||
##################
|
||||
|
||||
down_speed_limit_container = QWidget()
|
||||
down_speed_limit_layout = QHBoxLayout()
|
||||
|
||||
down_speed_limit_layout.addWidget(QLabel("Max Download Speed (KiB, 0 for unlimited): "))
|
||||
down_speed_limit = QSpinBox()
|
||||
down_speed_limit.setMinimum(0)
|
||||
down_speed_limit.setMaximum(10000000)
|
||||
down_speed_limit.setValue(state.down_speed_limit)
|
||||
down_speed_limit_container.setLayout(down_speed_limit_layout)
|
||||
down_speed_limit_layout.addWidget(down_speed_limit)
|
||||
down_speed_limit.setFixedWidth(180)
|
||||
down_speed_limit.setFixedHeight(30)
|
||||
|
||||
up_speed_limit_container = QWidget()
|
||||
up_speed_limit_layout = QHBoxLayout()
|
||||
|
||||
up_speed_limit_layout.addWidget(QLabel("Max Upload Speed (KiB, 0 for unlimited): "))
|
||||
up_speed_limit = QSpinBox()
|
||||
up_speed_limit.setMinimum(0)
|
||||
up_speed_limit.setMaximum(10000000)
|
||||
up_speed_limit.setValue(state.up_speed_limit)
|
||||
up_speed_limit_container.setLayout(up_speed_limit_layout)
|
||||
up_speed_limit_layout.addWidget(up_speed_limit)
|
||||
up_speed_limit.setFixedWidth(180)
|
||||
up_speed_limit.setFixedHeight(30)
|
||||
|
||||
######################
|
||||
# CONNECTION CONFIGS #
|
||||
######################
|
||||
|
||||
max_connections_container = QWidget()
|
||||
max_connections_layout = QHBoxLayout()
|
||||
|
||||
max_connections_layout.addWidget(QLabel("Max Connections: "))
|
||||
max_connections = QSpinBox()
|
||||
max_connections.setMinimum(0)
|
||||
max_connections.setMaximum(10000000)
|
||||
max_connections.setValue(state.max_connections)
|
||||
max_connections_container.setLayout(max_connections_layout)
|
||||
max_connections_layout.addWidget(max_connections)
|
||||
max_connections.setFixedWidth(180)
|
||||
max_connections.setFixedHeight(30)
|
||||
|
||||
####################
|
||||
# DOWNLOAD CONFIGS #
|
||||
####################
|
||||
|
||||
max_downloads_container = QWidget()
|
||||
max_downloads_layout = QHBoxLayout()
|
||||
|
||||
max_downloads_layout.addWidget(QLabel("Max Downloads: "))
|
||||
max_downloads = QSpinBox()
|
||||
max_downloads.setMinimum(0)
|
||||
max_downloads.setMaximum(10000000)
|
||||
max_downloads.setValue(state.max_downloads)
|
||||
max_downloads_container.setLayout(max_downloads_layout)
|
||||
max_downloads_layout.addWidget(max_downloads)
|
||||
max_downloads.setFixedWidth(180)
|
||||
max_downloads.setFixedHeight(30)
|
||||
|
||||
#####################
|
||||
# INTERFACE BINDING #
|
||||
#####################
|
||||
|
||||
interface_container = QWidget()
|
||||
interface_layout = QHBoxLayout()
|
||||
|
||||
interface_label = QLabel("Network Interface:")
|
||||
interface_layout.addWidget(interface_label)
|
||||
interface_select = QComboBox()
|
||||
interface_select.addItems(["None"] + state.interfaces)
|
||||
|
||||
target = state.bound_interface if state.bound_interface else "None"
|
||||
|
||||
index = interface_select.findText(target)
|
||||
if index >= 0:
|
||||
interface_select.setCurrentIndex(index)
|
||||
else:
|
||||
interface_select.setCurrentIndex(0)
|
||||
|
||||
interface_select.setFixedWidth(180)
|
||||
interface_select.setFixedHeight(30)
|
||||
interface_layout.addWidget(interface_select)
|
||||
interface_container.setLayout(interface_layout)
|
||||
|
||||
|
||||
###############
|
||||
# SAVE/CANCEL #
|
||||
###############
|
||||
|
||||
layout = QHBoxLayout()
|
||||
|
||||
save_btn = QPushButton("Save")
|
||||
cancel_btn = QPushButton("Cancel")
|
||||
save_btn.clicked.connect(lambda: save_settings(
|
||||
close_settings,
|
||||
api_url.text(),
|
||||
download_path.text(),
|
||||
down_speed_limit.value(),
|
||||
up_speed_limit.value(),
|
||||
image_path.text(),
|
||||
autoresume_checkbox.isChecked(),
|
||||
max_connections.value(),
|
||||
max_downloads.value(),
|
||||
interface_select.currentText()))
|
||||
|
||||
cancel_btn.clicked.connect(dialog.reject)
|
||||
layout.addWidget(cancel_btn)
|
||||
layout.addWidget(save_btn)
|
||||
|
||||
self.tabs = QTabWidget()
|
||||
self.tab1 = general_tab("General", autoresume_container, update_checkbox_container, transparent_window_container, self.tabs)
|
||||
self.tab2 = paths_tab("Paths", download_path_container, image_path_container, self.tabs)
|
||||
self.tab3 = network_tab("Network", interface_container, max_connections_container, max_downloads_container, up_speed_limit_container, down_speed_limit_container, api_url_container, self.tabs)
|
||||
|
||||
dialog_layout.addWidget(self.tabs)
|
||||
dialog_layout.addLayout(layout)
|
||||
|
||||
dialog.exec()
|
||||
@@ -0,0 +1,79 @@
|
||||
from PySide6.QtGui import QColor
|
||||
import darkdetect
|
||||
|
||||
def _is_dark_mode():
|
||||
return darkdetect.isDark()
|
||||
|
||||
|
||||
def _theme_colors():
|
||||
dark = _is_dark_mode()
|
||||
if dark:
|
||||
return {
|
||||
"text": "rgba(255, 255, 255, 0.9)",
|
||||
"border": "rgba(255, 255, 255, 0.06)",
|
||||
"selected": "rgba(255, 255, 255, 0.04)",
|
||||
"header_text": "rgba(255, 255, 255, 0.5)",
|
||||
"header_border": "rgba(255, 255, 255, 0.1)",
|
||||
"hover": QColor(255, 255, 255, 15),
|
||||
}
|
||||
else:
|
||||
return {
|
||||
"text": "rgba(0, 0, 0, 0.87)",
|
||||
"border": "rgba(0, 0, 0, 0.08)",
|
||||
"selected": "rgba(0, 0, 0, 0.06)",
|
||||
"header_text": "rgba(0, 0, 0, 0.6)",
|
||||
"header_border": "rgba(0, 0, 0, 0.12)",
|
||||
"hover": QColor(0, 0, 0, 15),
|
||||
}
|
||||
|
||||
|
||||
def _table_stylesheet(view_type="QTableWidget"):
|
||||
c = _theme_colors()
|
||||
dark = _is_dark_mode()
|
||||
color_rule = "" if dark else f"color: {c['text']};"
|
||||
return f"""
|
||||
{view_type} {{
|
||||
border: none;
|
||||
outline: 0;
|
||||
font-size: 13px;
|
||||
{color_rule}
|
||||
}}
|
||||
{view_type}::item {{
|
||||
border-bottom: 1px solid {c["border"]};
|
||||
padding: 6px 14px;
|
||||
outline: none;
|
||||
{color_rule}
|
||||
}}
|
||||
{view_type}::item:selected {{
|
||||
background: {c["selected"]};
|
||||
outline: none;
|
||||
border: none;
|
||||
border-bottom: 1px solid {c["border"]};
|
||||
}}
|
||||
{view_type}::item:focus {{
|
||||
outline: none;
|
||||
border: none;
|
||||
border-bottom: 1px solid {c["border"]};
|
||||
}}
|
||||
QHeaderView {{
|
||||
background: transparent;
|
||||
}}
|
||||
QHeaderView::section {{
|
||||
background: transparent;
|
||||
color: {c["header_text"]};
|
||||
font-weight: normal;
|
||||
border: none;
|
||||
border-bottom: 1px solid {c["header_border"]};
|
||||
padding: 6px 14px;
|
||||
}}
|
||||
QHeaderView::section:checked {{
|
||||
background: transparent;
|
||||
color: {c["header_text"]};
|
||||
font-weight: normal;
|
||||
}}
|
||||
"""
|
||||
|
||||
|
||||
SVG_PLAY = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><polygon points="6,3 20,12 6,21" fill="{color}"/></svg>'
|
||||
SVG_PAUSE = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><rect x="5" y="3" width="4" height="18" rx="1" fill="{color}"/><rect x="15" y="3" width="4" height="18" rx="1" fill="{color}"/></svg>'
|
||||
SVG_FOLDER = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M2 6c0-1.1.9-2 2-2h5l2 2h7c1.1 0 2 .9 2 2v10c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6z" fill="{color}"/></svg>'
|
||||
@@ -0,0 +1,14 @@
|
||||
from interface.dialogs.theme import _theme_colors
|
||||
from PySide6.QtWidgets import QStyledItemDelegate
|
||||
|
||||
class TrackerHoverDelegate(QStyledItemDelegate):
|
||||
def __init__(self, get_hovered_row, parent=None):
|
||||
super().__init__(parent)
|
||||
self._get_hovered_row = get_hovered_row
|
||||
|
||||
def paint(self, painter, option, index):
|
||||
if index.row() == self._get_hovered_row():
|
||||
painter.save()
|
||||
painter.fillRect(option.rect, _theme_colors()["hover"])
|
||||
painter.restore()
|
||||
super().paint(painter, option, index)
|
||||
@@ -0,0 +1,26 @@
|
||||
from interface.dialogs.theme import _table_stylesheet
|
||||
from PySide6.QtWidgets import QTableWidget
|
||||
from PySide6 import QtWidgets
|
||||
from PySide6.QtCore import Qt
|
||||
|
||||
def _create_tracker_table(self):
|
||||
table = QTableWidget()
|
||||
table.setEditTriggers(QtWidgets.QAbstractItemView.EditTrigger.NoEditTriggers)
|
||||
table.verticalHeader().setVisible(False)
|
||||
table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectionBehavior.SelectRows)
|
||||
table.setSelectionMode(QtWidgets.QAbstractItemView.SelectionMode.ExtendedSelection)
|
||||
table.setShowGrid(False)
|
||||
table.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
|
||||
table.viewport().setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
|
||||
table.horizontalHeader().setDefaultAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
|
||||
table.horizontalHeader().setHighlightSections(False)
|
||||
table.horizontalHeader().setStretchLastSection(False)
|
||||
table.setStyleSheet(_table_stylesheet("QTableWidget"))
|
||||
table.setMouseTracking(True)
|
||||
table.viewport().setMouseTracking(True)
|
||||
table.viewport().installEventFilter(self)
|
||||
|
||||
table.setItemDelegateForColumn(0, self._tracker_elided_delegate)
|
||||
|
||||
self._apply_default_headers(table)
|
||||
return table
|
||||
@@ -0,0 +1,49 @@
|
||||
from utils.network.update_checker import get_updates
|
||||
from PySide6.QtWidgets import QDialog, QMessageBox
|
||||
from utils.network.updater import download_update
|
||||
from utils.logging.logs import consoleLog
|
||||
from utils.data.state import state
|
||||
from pathlib import Path
|
||||
import platform
|
||||
import json
|
||||
import os
|
||||
|
||||
def _get_build_info_path() -> (Path | None):
|
||||
current_dir = Path(__file__).resolve().parent
|
||||
|
||||
for _ in range(6): # Climb max 6 directories
|
||||
file = current_dir / "build_info.json"
|
||||
if file.exists():
|
||||
return file
|
||||
# Go up one directory if file isn't found
|
||||
current_dir = current_dir.parent
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def get_version() -> None:
|
||||
# Get build info filepath
|
||||
build_info_path = _get_build_info_path()
|
||||
if build_info_path and os.path.exists(build_info_path):
|
||||
with open(build_info_path, "r") as f:
|
||||
build_info = json.load(f)
|
||||
state.version = build_info.get("version")
|
||||
else:
|
||||
consoleLog(f"Could not find build info file (Path: {build_info_path})")
|
||||
|
||||
class UpdateDialog(QDialog):
|
||||
def __init__(self, parent=None):
|
||||
if state.ignore_updates is False and platform.system() == "Windows":
|
||||
|
||||
assets, latest = get_updates()
|
||||
if assets != None:
|
||||
msg = QMessageBox()
|
||||
msg.setIcon(QMessageBox.Icon.Information)
|
||||
msg.setWindowTitle("Update Available")
|
||||
msg.setText(f"A new version is available\n({latest})")
|
||||
msg.setInformativeText("Press Ok to download.")
|
||||
msg.setStandardButtons(QMessageBox.StandardButton.Ok | QMessageBox.StandardButton.Ignore)
|
||||
response = msg.exec_()
|
||||
if response == QMessageBox.StandardButton.Ok:
|
||||
download_update(assets)
|
||||
|
||||
@@ -0,0 +1,414 @@
|
||||
from interface.dialogs.trackerhoverdelegate import TrackerHoverDelegate
|
||||
from interface.dialogs.elideditemdelegate import ElidedItemDelegate
|
||||
from interface.dialogs.trackertable import _create_tracker_table
|
||||
from interface.dialogs.downloadlist import _create_download_list
|
||||
from interface.assets.base64_icons import settings_white_base64
|
||||
from interface.assets.base64_icons import settings_black_base64
|
||||
from interface.dialogs.downloadlist import download_list_update
|
||||
from interface.dialogs.update import get_version, UpdateDialog
|
||||
from utils.logging.logs import consoleLog, flush_log_buffer
|
||||
from interface.dialogs.downloadmodel import DownloadModel
|
||||
from interface.dialogs.settings import settings_dialog
|
||||
from interface.assets.base64_icons import logo_base64
|
||||
from interface.dialogs.eventfilter import eventFilter
|
||||
from utils.network.download import download_selected
|
||||
from interface.utils.searchhelper import run_search
|
||||
from interface.utils.tabhelper import create_tab
|
||||
from utils.general.shutdown import closehelper
|
||||
from utils.general.wrappers import run_thread
|
||||
from interface.dialogs.image import Image
|
||||
from utils.data.state import state
|
||||
|
||||
import interface.dialogs.contextmenu
|
||||
|
||||
from PySide6 import QtWidgets
|
||||
from PySide6.QtCore import (
|
||||
Qt,
|
||||
QTimer,
|
||||
Signal,
|
||||
QSize
|
||||
)
|
||||
|
||||
from PySide6.QtWidgets import (
|
||||
QLineEdit,
|
||||
QTableView,
|
||||
QWidget,
|
||||
QVBoxLayout,
|
||||
QLabel,
|
||||
QHBoxLayout,
|
||||
QComboBox,
|
||||
QTabWidget,
|
||||
QHeaderView,
|
||||
QTableWidgetItem,
|
||||
QTextEdit,
|
||||
QStatusBar
|
||||
)
|
||||
|
||||
from PySide6.QtGui import (
|
||||
QIcon,
|
||||
QCloseEvent,
|
||||
QPixmap,
|
||||
QGuiApplication,
|
||||
)
|
||||
|
||||
import darkdetect
|
||||
import threading
|
||||
import platform
|
||||
import base64
|
||||
|
||||
def windowCloseHelper():
|
||||
QGuiApplication.quit()
|
||||
|
||||
class MainWindow(QtWidgets.QMainWindow, QWidget):
|
||||
eventFilter = eventFilter
|
||||
log_signal = Signal(str)
|
||||
search_results_signal = Signal(list)
|
||||
_instance = None
|
||||
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
MainWindow._instance = self
|
||||
self.log_signal.connect(self._on_log_signal)
|
||||
self.search_results_signal.connect(self._on_search_results)
|
||||
|
||||
pixmap = QPixmap()
|
||||
image_data = base64.b64decode(logo_base64)
|
||||
pixmap.loadFromData(image_data)
|
||||
self.setWindowIcon(QIcon(pixmap))
|
||||
|
||||
# Set AppID on Windows
|
||||
if platform.system() == "Windows":
|
||||
try:
|
||||
import ctypes
|
||||
appid = 'SoftwareManager'
|
||||
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(appid)
|
||||
except Exception as e:
|
||||
consoleLog(f"Could not set app ID: {e}")
|
||||
|
||||
# Get current version
|
||||
# interface.dialogs.update
|
||||
get_version()
|
||||
UpdateDialog()
|
||||
|
||||
# Initialize Window
|
||||
self.setWindowTitle("Software Manager")
|
||||
self.setGeometry(100, 100, 800, 600)
|
||||
|
||||
self.controls = QWidget()
|
||||
self.controlsLayout = QVBoxLayout()
|
||||
|
||||
# Searchbar
|
||||
self.searchbar = QLineEdit()
|
||||
self.searchbar.setPlaceholderText("Search for software...")
|
||||
self.searchbar.setClearButtonEnabled(True)
|
||||
self.searchbar.setMinimumHeight(30)
|
||||
self.searchbar.returnPressed.connect(self._start_search)
|
||||
|
||||
# Download Button
|
||||
self.dlbutton = QtWidgets.QPushButton("Download")
|
||||
self.dlbutton.setCursor(Qt.CursorShape.PointingHandCursor)
|
||||
|
||||
# Dialog for empty results
|
||||
self.emptyResults = QLabel("No Results")
|
||||
self.emptyResults.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||||
self.emptyResults.hide()
|
||||
|
||||
self.downloadList = QTableView()
|
||||
self.downloadList.setMouseTracking(True)
|
||||
self._hovered_row = -1
|
||||
self._tracker_hovered_row = -1
|
||||
self._tracker_hovered_table = None
|
||||
self._last_dl_row_count = 0
|
||||
self.emptyDownload = QLabel("No items in downloads.")
|
||||
self.emptyDownload.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||||
|
||||
self.consoleLog = QTextEdit()
|
||||
self.statusbar = QStatusBar()
|
||||
|
||||
flush_log_buffer()
|
||||
|
||||
self._tracker_elided_delegate = ElidedItemDelegate(lambda: self._tracker_hovered_row, self)
|
||||
self._tracker_hover_delegate = TrackerHoverDelegate(lambda: self._tracker_hovered_row, self)
|
||||
|
||||
state.trackertable = _create_tracker_table(self)
|
||||
|
||||
container = QWidget()
|
||||
containerLayout = QVBoxLayout()
|
||||
containerLayout.addWidget(self.searchbar)
|
||||
containerLayout.addWidget(state.trackertable)
|
||||
|
||||
# interface.dialogs.hoverrowdelegate
|
||||
self.download_model = DownloadModel()
|
||||
self.downloadList = _create_download_list(self)
|
||||
self.downloadList.viewport().installEventFilter(self)
|
||||
|
||||
self.dlbutton.clicked.connect(lambda: run_thread(threading.Thread(target=download_selected, args=(state.trackertable.selectedItems(),))))
|
||||
|
||||
container.setLayout(containerLayout)
|
||||
self.setCentralWidget(container)
|
||||
|
||||
self.tabs = QTabWidget()
|
||||
self.tabs.setStyleSheet("""
|
||||
QTabBar::tab {
|
||||
font-size: 11px;
|
||||
padding: 2px 8px;
|
||||
height: 25px;
|
||||
}
|
||||
QTabWidget::pane {
|
||||
margin-top: -20px;
|
||||
}
|
||||
""")
|
||||
|
||||
self.horizontal_layout = QHBoxLayout()
|
||||
self.horizontal_layout.addWidget(self.emptyResults, stretch=3)
|
||||
self.horizontal_layout.addWidget(state.trackertable)
|
||||
|
||||
# Tabs
|
||||
self.tab1 = create_tab("Search", self.searchbar, state.trackertable, self.tabs, self.dlbutton, self.horizontal_layout)
|
||||
self.tab2 = create_tab("Downloads", self.emptyDownload, self.downloadList, self.tabs, None, None)
|
||||
|
||||
# Corner Widget (Settings Button, Tracker list, Tab button container)
|
||||
self.corner_widget = QWidget()
|
||||
self.corner_layout = QHBoxLayout(self.corner_widget)
|
||||
self.corner_layout.setContentsMargins(0, 0, 0, 0)
|
||||
|
||||
# Tracker list
|
||||
self.tracker_list = QComboBox()
|
||||
self.tracker_list.addItems(list(state.trackers.keys()))
|
||||
self.tracker_list.setCursor(Qt.CursorShape.PointingHandCursor)
|
||||
self.tracker_list.activated.connect(self.set_tracker)
|
||||
self.corner_layout.addWidget(self.tracker_list)
|
||||
|
||||
# Settings button
|
||||
self.settings_btn = QtWidgets.QToolButton()
|
||||
self.settings_btn.setIconSize(QSize(21, 21))
|
||||
self.settings_btn.setStyleSheet("background: transparent;")
|
||||
self.settings_btn.setToolTip("Settings")
|
||||
self.settings_btn.setCursor(Qt.CursorShape.PointingHandCursor)
|
||||
self.settings_btn.clicked.connect(lambda: settings_dialog(self))
|
||||
self.corner_layout.addWidget(self.settings_btn)
|
||||
|
||||
# Adjust theme based on system preferences
|
||||
if darkdetect.isDark():
|
||||
settings_white_pixmap = QPixmap()
|
||||
settings_white = base64.b64decode(settings_white_base64)
|
||||
settings_white_pixmap.loadFromData(settings_white)
|
||||
self.settings_btn.setIcon(QIcon(settings_white_pixmap))
|
||||
else:
|
||||
settings_black_pixmap = QPixmap()
|
||||
settings_black = base64.b64decode(settings_black_base64)
|
||||
settings_black_pixmap.loadFromData(settings_black)
|
||||
self.settings_btn.setIcon(QIcon(settings_black_pixmap))
|
||||
|
||||
self.tab_wrapper = QWidget()
|
||||
self.tab_layout = QVBoxLayout()
|
||||
self.tab_layout.setContentsMargins(0, 0, 0, 0)
|
||||
self.tab_layout.setSpacing(0)
|
||||
|
||||
self.tab_bar_layout = QHBoxLayout()
|
||||
self.tab_bar_layout.setContentsMargins(0, 0, 0, 0)
|
||||
self.tab_bar_layout.setSpacing(0)
|
||||
|
||||
self.tab_bar_layout.addWidget(self.tabs.tabBar(), stretch=0)
|
||||
self.tab_bar_layout.addStretch()
|
||||
self.tab_bar_layout.addWidget(self.corner_widget, stretch=0)
|
||||
|
||||
self.tab_layout.addLayout(self.tab_bar_layout)
|
||||
self.tab_layout.addWidget(self.tabs)
|
||||
self.tab_wrapper.setLayout(self.tab_layout)
|
||||
|
||||
containerLayout.addWidget(self.tab_wrapper)
|
||||
containerLayout.setAlignment(Qt.AlignmentFlag.AlignTop)
|
||||
|
||||
self.consoleLog.setReadOnly(True)
|
||||
self.consoleLog.setFixedHeight(150)
|
||||
self.consoleLog.setStyleSheet("margin-bottom: 0px; background: transparent;")
|
||||
containerLayout.addWidget(self.consoleLog)
|
||||
|
||||
self.statusbar.show()
|
||||
self.statusbar.setStyleSheet("background: transparent; border: none; padding-right: 1px; padding-left: 6px; padding-bottom: 1px; margin-top: -8px")
|
||||
|
||||
self.version = QLabel(f"Version: {state.version}")
|
||||
self.statusbar.addPermanentWidget(self.version, Qt.AlignmentFlag.AlignLeft)
|
||||
|
||||
# (\u2193) Arrow down, (\u2191) Arrow up
|
||||
self.speed_label = QLabel("\u2193 0.0 kB/s \u2191 0.0 kB/s")
|
||||
self.speed_label.setStyleSheet("padding-right: 6px;")
|
||||
self.statusbar.addPermanentWidget(self.speed_label)
|
||||
|
||||
self.setStatusBar(self.statusbar)
|
||||
|
||||
self.download_timer = QTimer()
|
||||
self.download_timer.timeout.connect(lambda: download_list_update(self))
|
||||
self.download_timer.start(500)
|
||||
|
||||
self.active_timer = QTimer()
|
||||
self.active_timer.timeout.connect(self.show_empty_downloads)
|
||||
self.active_timer.start(500)
|
||||
|
||||
self._context_menu = interface.dialogs.contextmenu.ContextMenu(self)
|
||||
self.image_overlay = Image(self)
|
||||
|
||||
def _apply_default_headers(self, table):
|
||||
tracker_name = state.currenttracker if hasattr(state, 'currenttracker') and state.currenttracker else None
|
||||
if tracker_name is None:
|
||||
keys = list(state.trackers.keys())
|
||||
tracker_name = keys[0] if keys else None
|
||||
|
||||
headers = []
|
||||
if tracker_name and tracker_name in state.trackers:
|
||||
tracker_mod = state.trackers[tracker_name]
|
||||
if hasattr(tracker_mod, 'headers'):
|
||||
headers = tracker_mod.headers
|
||||
elif hasattr(tracker_mod, 'HEADERS'):
|
||||
headers = tracker_mod.HEADERS
|
||||
|
||||
if not headers:
|
||||
if state.currenttracker == "rutracker":
|
||||
headers = ["Post Title", "Author", "Seeders", "Leechers"]
|
||||
elif state.currenttracker == "steamrip":
|
||||
headers = ["Game"]
|
||||
else:
|
||||
headers = ["Post Title", "Author"] # i know this makes it less "modular", but its qol
|
||||
|
||||
table.setRowCount(0)
|
||||
|
||||
col_count = table.columnCount()
|
||||
if col_count != len(headers):
|
||||
for i in range(col_count):
|
||||
table.setItemDelegateForColumn(i, None)
|
||||
table.setColumnCount(len(headers))
|
||||
|
||||
table.setHorizontalHeaderLabels(headers)
|
||||
self._apply_tracker_column_modes(table, len(headers))
|
||||
|
||||
def _apply_tracker_column_modes(self, table, col_count):
|
||||
header = table.horizontalHeader()
|
||||
if col_count > 0:
|
||||
header.setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
|
||||
table.setItemDelegateForColumn(0, self._tracker_elided_delegate)
|
||||
for i in range(1, col_count):
|
||||
header.setSectionResizeMode(i, QHeaderView.ResizeMode.ResizeToContents)
|
||||
table.setItemDelegateForColumn(i, self._tracker_hover_delegate)
|
||||
|
||||
def _start_search(self):
|
||||
self.searchbar.setEnabled(False)
|
||||
def _search_thread():
|
||||
try:
|
||||
run_search(self)
|
||||
except Exception as e:
|
||||
consoleLog(f"Search error: {e}", True)
|
||||
self.search_results_signal.emit([])
|
||||
run_thread(threading.Thread(target=_search_thread))
|
||||
|
||||
@staticmethod
|
||||
def add_log(text):
|
||||
if hasattr(MainWindow, "_instance") and MainWindow._instance:
|
||||
MainWindow._instance.log_signal.emit(text)
|
||||
return True
|
||||
return False
|
||||
|
||||
def _on_log_signal(self, text):
|
||||
if hasattr(self, 'consoleLog'):
|
||||
self.consoleLog.append(text)
|
||||
self.consoleLog.verticalScrollBar().setValue(
|
||||
self.consoleLog.verticalScrollBar().maximum()
|
||||
)
|
||||
|
||||
def _on_search_results(self, headers):
|
||||
if state.posts is None or state.posts == []:
|
||||
self.show_empty_results(True)
|
||||
self.searchbar.setEnabled(True)
|
||||
self.searchbar.setFocus()
|
||||
return
|
||||
|
||||
table = state.trackertable
|
||||
table.setRowCount(0)
|
||||
|
||||
col_count = table.columnCount()
|
||||
need_reconfig = col_count != len(headers)
|
||||
|
||||
if need_reconfig:
|
||||
for i in range(col_count):
|
||||
table.setItemDelegateForColumn(i, None)
|
||||
table.setColumnCount(len(headers))
|
||||
table.setHorizontalHeaderLabels(headers)
|
||||
self._apply_tracker_column_modes(table, len(headers))
|
||||
else:
|
||||
table.setHorizontalHeaderLabels(headers)
|
||||
|
||||
table.setRowCount(len(state.posts))
|
||||
for x, rowdata in enumerate(state.posts):
|
||||
for y, (key, data) in enumerate(rowdata.items()):
|
||||
item = QTableWidgetItem(str(data))
|
||||
item.setData(Qt.ItemDataRole.UserRole, x)
|
||||
table.setItem(x, y, item)
|
||||
|
||||
self.show_empty_results(False)
|
||||
self.searchbar.setEnabled(True)
|
||||
self.searchbar.setFocus()
|
||||
|
||||
self._update_speed_label()
|
||||
|
||||
|
||||
def _update_speed_label(self):
|
||||
total_down = 0
|
||||
total_up = 0
|
||||
with state.downloads_lock:
|
||||
active_items = list(state.active_downloads.values())
|
||||
|
||||
for handle in active_items:
|
||||
try:
|
||||
s = handle.status()
|
||||
total_down += s.download_rate
|
||||
total_up += s.upload_rate
|
||||
except Exception as e:
|
||||
consoleLog(f"Exception while updating speed label: {e}")
|
||||
down_kb = total_down / 1024
|
||||
up_kb = total_up / 1024
|
||||
down_text = f"{down_kb / 1024:.1f} MB/s" if down_kb > 1024 else f"{down_kb:.1f} kB/s"
|
||||
up_text = f"{up_kb / 1024:.1f} MB/s" if up_kb > 1024 else f"{up_kb:.1f} kB/s"
|
||||
|
||||
|
||||
if hasattr(self, 'speed_label'):
|
||||
self.speed_label.setText(f"↓ {down_text} ↑ {up_text}")
|
||||
|
||||
def mousePressEvent(self, event):
|
||||
state.trackertable.clearSelection()
|
||||
self.downloadList.clearSelection()
|
||||
super().mousePressEvent(event)
|
||||
|
||||
def changeEvent(self, event):
|
||||
super().changeEvent(event)
|
||||
|
||||
def closeEvent(self, event: QCloseEvent):
|
||||
closehelper()
|
||||
event.accept()
|
||||
from utils.general.shutdown import force_exit
|
||||
force_exit()
|
||||
|
||||
def _invalidate_hover_row(self, row):
|
||||
if row >= 0 and self.download_model:
|
||||
self.downloadList.viewport().update()
|
||||
|
||||
def set_tracker(self, _):
|
||||
state.currenttracker = self.tracker_list.currentText()
|
||||
self._apply_default_headers(state.trackertable)
|
||||
|
||||
def show_empty_results(self, show: bool):
|
||||
if show:
|
||||
state.trackertable.hide()
|
||||
self.emptyResults.show()
|
||||
else:
|
||||
state.trackertable.show()
|
||||
self.emptyResults.hide()
|
||||
|
||||
def show_empty_downloads(self):
|
||||
with state.downloads_lock:
|
||||
has_downloads = len(state.active_downloads) > 0
|
||||
if has_downloads:
|
||||
self.emptyDownload.hide()
|
||||
self.downloadList.show()
|
||||
else:
|
||||
self.emptyDownload.show()
|
||||
self.downloadList.hide()
|
||||
@@ -0,0 +1,34 @@
|
||||
from data.scrapers.rutracker import init_rutracker
|
||||
from data.scrapers.uztracker import init_uztracker
|
||||
from data.scrapers.steamrip import init_steamrip
|
||||
from data.scrapers.monkrus import init_m0nkrus
|
||||
from utils.logging.logs import consoleLog
|
||||
from utils.data.state import state
|
||||
|
||||
# Call initialization function for each tracker / site
|
||||
init_rutracker()
|
||||
init_uztracker()
|
||||
init_m0nkrus()
|
||||
init_steamrip()
|
||||
|
||||
|
||||
def run_search(self) -> None:
|
||||
self.show_empty_results(False)
|
||||
|
||||
search_text = self.searchbar.text()
|
||||
# Check for empty search
|
||||
if search_text == "":
|
||||
consoleLog("Error: Can't search for nothing")
|
||||
return
|
||||
consoleLog(f"User searched for: {search_text}")
|
||||
|
||||
# Get current tracker and call its search function
|
||||
tracker = state.trackers[state.currenttracker]
|
||||
scrapefunc = tracker["scrapeFunc"]
|
||||
state.posts = scrapefunc(search_text)
|
||||
|
||||
# Late to prevent circular import
|
||||
from interface.gui import MainWindow
|
||||
|
||||
# Update GUI Headers
|
||||
MainWindow._instance.search_results_signal.emit(tracker["headers"])
|
||||
@@ -0,0 +1,27 @@
|
||||
from PySide6.QtGui import QIcon, QPixmap, QPainter
|
||||
from PySide6.QtCore import Qt, QByteArray
|
||||
from PySide6.QtSvg import QSvgRenderer
|
||||
from PySide6 import QtWidgets
|
||||
import darkdetect
|
||||
|
||||
# Check if darkmode is enabled
|
||||
def _is_dark_mode():
|
||||
return darkdetect.isDark()
|
||||
|
||||
def svg_icon(svg_str, size=20):
|
||||
app = QtWidgets.QApplication.instance()
|
||||
if app:
|
||||
if _is_dark_mode():
|
||||
color = "white"
|
||||
else:
|
||||
color = "#555555"
|
||||
else:
|
||||
color = "white"
|
||||
svg = svg_str.replace("{color}", color)
|
||||
renderer = QSvgRenderer(QByteArray(svg.encode()))
|
||||
pixmap = QPixmap(size, size)
|
||||
pixmap.fill(Qt.GlobalColor.transparent)
|
||||
painter = QPainter(pixmap)
|
||||
renderer.render(painter)
|
||||
painter.end()
|
||||
return QIcon(pixmap)
|
||||
@@ -0,0 +1,54 @@
|
||||
from PySide6.QtWidgets import QWidget, QVBoxLayout
|
||||
|
||||
# Tab creation helper function
|
||||
def create_tab(title, searchbar, software_list, tabs, dlbutton, layout2):
|
||||
tab = QWidget()
|
||||
layout = QVBoxLayout()
|
||||
if searchbar:
|
||||
layout.addWidget(searchbar)
|
||||
if layout2:
|
||||
layout.addLayout(layout2)
|
||||
else:
|
||||
layout.addWidget(software_list)
|
||||
if dlbutton:
|
||||
layout.addWidget(dlbutton)
|
||||
tab.setLayout(layout)
|
||||
tabs.addTab(tab, title)
|
||||
return tab
|
||||
|
||||
# Settings Tabs
|
||||
def general_tab(title, autoresume, update_checkbox, transparent_window, tabs):
|
||||
tab = QWidget()
|
||||
layout = QVBoxLayout()
|
||||
layout.addWidget(autoresume)
|
||||
layout.addWidget(update_checkbox)
|
||||
layout.addWidget(transparent_window)
|
||||
layout.addStretch()
|
||||
tab.setLayout(layout)
|
||||
tabs.addTab(tab, title)
|
||||
return tab
|
||||
|
||||
def paths_tab(title, download_path, image_path, tabs):
|
||||
tab = QWidget()
|
||||
layout = QVBoxLayout()
|
||||
layout.addWidget(download_path)
|
||||
layout.addWidget(image_path)
|
||||
layout.addStretch()
|
||||
tab.setLayout(layout)
|
||||
tabs.addTab(tab, title)
|
||||
return tab
|
||||
|
||||
|
||||
def network_tab(title, network_interface, max_connections, max_downloads, up_speed_limit, down_speed_limit, api_url, tabs):
|
||||
tab = QWidget()
|
||||
layout = QVBoxLayout()
|
||||
layout.addWidget(network_interface)
|
||||
layout.addWidget(max_connections)
|
||||
layout.addWidget(max_downloads)
|
||||
layout.addWidget(up_speed_limit)
|
||||
layout.addWidget(down_speed_limit)
|
||||
layout.addWidget(api_url)
|
||||
layout.addStretch()
|
||||
tab.setLayout(layout)
|
||||
tabs.addTab(tab, title)
|
||||
return tab
|
||||
Reference in New Issue
Block a user