1412 lines
50 KiB
Python
1412 lines
50 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
DazedMTLTool GUI - Main Application
|
|
A PyQt-based graphical user interface for the DazedMTLTool translation system.
|
|
"""
|
|
|
|
import re
|
|
import sys
|
|
import os
|
|
import json
|
|
import urllib.request
|
|
import zipfile
|
|
import shutil
|
|
import tempfile
|
|
from pathlib import Path
|
|
|
|
if sys.platform.startswith("linux"):
|
|
from util.linux_desktop import configure_qt_platform
|
|
|
|
configure_qt_platform()
|
|
|
|
from PyQt5.QtWidgets import (
|
|
QApplication, QMainWindow, QTabWidget, QVBoxLayout, QHBoxLayout,
|
|
QWidget, QPushButton, QLabel, QFileDialog, QMessageBox, QProgressBar,
|
|
QTextEdit, QSplitter, QGroupBox, QStatusBar, QStackedWidget, QToolButton,
|
|
QDialog, QComboBox
|
|
)
|
|
from PyQt5.QtCore import Qt, QThread, pyqtSignal, QTimer, QSettings, QCoreApplication
|
|
from PyQt5.QtGui import QIcon, QFont, QPixmap, QScreen, QGuiApplication
|
|
|
|
|
|
from util.paths import PROJECT_ROOT, ICON_PATH, LAST_UPDATE_SHA_PATH
|
|
|
|
|
|
def load_application_icon() -> QIcon:
|
|
"""Prefer ICO on Windows; PNG is fine for all platforms. Empty if missing."""
|
|
for path in (PROJECT_ROOT / "assets/icon.ico", ICON_PATH):
|
|
if path.is_file():
|
|
icon = QIcon(str(path))
|
|
if not icon.isNull():
|
|
return icon
|
|
return QIcon()
|
|
|
|
|
|
def check_tool_update() -> str | None:
|
|
"""Return latest commit SHA when a tool update is available, else None."""
|
|
try:
|
|
api = (
|
|
f"https://gitgud.io/api/v4/projects/"
|
|
f"{UpdateThread.REPO_USER}%2F{UpdateThread.REPO_NAME}"
|
|
f"/repository/branches/{UpdateThread.REPO_BRANCH}"
|
|
)
|
|
req = urllib.request.Request(api, headers={"User-Agent": "DazedMTLTool"})
|
|
with urllib.request.urlopen(req, timeout=15) as resp:
|
|
latest_sha = json.loads(resp.read())["commit"]["id"]
|
|
sha_path = Path(UpdateThread.SHA_FILE)
|
|
current_sha = sha_path.read_text().strip() if sha_path.is_file() else ""
|
|
if latest_sha != current_sha:
|
|
return latest_sha
|
|
except Exception:
|
|
pass
|
|
return None
|
|
|
|
|
|
def check_all_updates() -> dict:
|
|
"""Check tool, Ace, and Forge for available updates."""
|
|
results = {"tool": None, "ace": False, "forge": False}
|
|
results["tool"] = check_tool_update()
|
|
try:
|
|
from util.ace.update_tools import check_ace_tools_update
|
|
results["ace"] = check_ace_tools_update()
|
|
except Exception:
|
|
pass
|
|
try:
|
|
from util.forge.update_tools import check_forge_plugins_update
|
|
results["forge"] = check_forge_plugins_update()
|
|
except Exception:
|
|
pass
|
|
return results
|
|
|
|
|
|
def any_updates_available(results: dict) -> bool:
|
|
return bool(results.get("tool")) or results.get("ace") or results.get("forge")
|
|
|
|
|
|
class BackgroundUpdateCheckThread(QThread):
|
|
"""Checks for tool, Ace, and Forge updates without blocking the UI."""
|
|
|
|
finished = pyqtSignal(dict)
|
|
|
|
def run(self):
|
|
self.finished.emit(check_all_updates())
|
|
|
|
|
|
class AuxToolsUpdateThread(QThread):
|
|
"""Download Ace and/or Forge updates without updating the main tool."""
|
|
|
|
progress = pyqtSignal(str)
|
|
finished = pyqtSignal(bool, str)
|
|
|
|
def __init__(self, update_ace: bool = False, update_forge: bool = False, parent=None):
|
|
super().__init__(parent)
|
|
self.update_ace = update_ace
|
|
self.update_forge = update_forge
|
|
|
|
def run(self):
|
|
try:
|
|
if self.update_ace:
|
|
from util.ace.update_tools import ensure_ace_tools
|
|
self.progress.emit("Updating RPG Maker Ace tools…")
|
|
if not ensure_ace_tools(log_fn=lambda m: self.progress.emit(m)):
|
|
self.finished.emit(False, "Ace tool update failed.")
|
|
return
|
|
if self.update_forge:
|
|
from util.forge.update_tools import ensure_forge_plugins
|
|
self.progress.emit("Updating Forge plugins…")
|
|
if not ensure_forge_plugins(log_fn=lambda m: self.progress.emit(m)):
|
|
self.finished.emit(False, "Forge plugin update failed.")
|
|
return
|
|
self.finished.emit(True, "components_updated")
|
|
except Exception as exc:
|
|
self.finished.emit(False, str(exc))
|
|
|
|
|
|
class UpdateThread(QThread):
|
|
"""Downloads and applies a tool update from the GitGud repository."""
|
|
|
|
REPO_USER = "DazedAnon"
|
|
REPO_NAME = "DazedMTLTool"
|
|
REPO_BRANCH = "main"
|
|
SHA_FILE = str(LAST_UPDATE_SHA_PATH)
|
|
|
|
# Paths (relative, top-level) that should never be touched during update
|
|
PROTECTED = {".env", "venv", "log", "files", "translated", "data"}
|
|
|
|
# GitLab zip archives do not preserve Unix execute bits; restore after apply.
|
|
EXECUTABLE_SUFFIXES = {".sh", ".desktop"}
|
|
|
|
progress = pyqtSignal(str) # status message
|
|
finished = pyqtSignal(bool, str) # (success, message)
|
|
|
|
def __init__(self, check_only=False, parent=None):
|
|
super().__init__(parent)
|
|
self.check_only = check_only
|
|
|
|
# ------------------------------------------------------------------ #
|
|
|
|
def run(self):
|
|
try:
|
|
latest_sha = self._fetch_latest_sha()
|
|
current_sha = self._read_stored_sha()
|
|
|
|
if latest_sha == current_sha:
|
|
self.finished.emit(True, "already_up_to_date")
|
|
return
|
|
|
|
if self.check_only:
|
|
self.finished.emit(True, f"update_available:{latest_sha}")
|
|
return
|
|
|
|
self._download_and_apply(latest_sha)
|
|
|
|
except Exception as exc:
|
|
self.finished.emit(False, str(exc))
|
|
|
|
@classmethod
|
|
def fetch_latest_sha(cls) -> str:
|
|
api = (
|
|
f"https://gitgud.io/api/v4/projects/"
|
|
f"{cls.REPO_USER}%2F{cls.REPO_NAME}"
|
|
f"/repository/branches/{cls.REPO_BRANCH}"
|
|
)
|
|
req = urllib.request.Request(api, headers={"User-Agent": "DazedMTLTool"})
|
|
with urllib.request.urlopen(req, timeout=15) as resp:
|
|
return json.loads(resp.read())["commit"]["id"]
|
|
|
|
# ------------------------------------------------------------------ #
|
|
|
|
def _fetch_latest_sha(self):
|
|
return self.fetch_latest_sha()
|
|
|
|
def _read_stored_sha(self):
|
|
p = Path(self.SHA_FILE)
|
|
return p.read_text().strip() if p.exists() else ""
|
|
|
|
def _download_and_apply(self, latest_sha):
|
|
zip_url = (
|
|
f"https://gitgud.io/{self.REPO_USER}/{self.REPO_NAME}/-/archive/"
|
|
f"{self.REPO_BRANCH}/{self.REPO_NAME}-{self.REPO_BRANCH}.zip"
|
|
)
|
|
|
|
self.progress.emit("Downloading update…")
|
|
with tempfile.TemporaryDirectory() as tmp_dir:
|
|
tmp = Path(tmp_dir)
|
|
zip_path = tmp / "update.zip"
|
|
|
|
req = urllib.request.Request(zip_url, headers={"User-Agent": "DazedMTLTool"})
|
|
with urllib.request.urlopen(req, timeout=120) as resp, \
|
|
open(zip_path, "wb") as fh:
|
|
shutil.copyfileobj(resp, fh)
|
|
|
|
self.progress.emit("Extracting…")
|
|
with zipfile.ZipFile(zip_path, "r") as zf:
|
|
zf.extractall(tmp)
|
|
|
|
extracted = tmp / f"{self.REPO_NAME}-{self.REPO_BRANCH}"
|
|
root = Path(".").resolve()
|
|
|
|
self.progress.emit("Applying update…")
|
|
for src in extracted.rglob("*"):
|
|
rel = src.relative_to(extracted)
|
|
parts = rel.parts
|
|
if not parts or parts[0] in self.PROTECTED:
|
|
continue
|
|
dst = root / rel
|
|
if src.is_dir():
|
|
dst.mkdir(parents=True, exist_ok=True)
|
|
else:
|
|
dst.parent.mkdir(parents=True, exist_ok=True)
|
|
shutil.copy2(src, dst)
|
|
if dst.suffix in self.EXECUTABLE_SUFFIXES:
|
|
mode = dst.stat().st_mode | 0o111
|
|
dst.chmod(mode)
|
|
|
|
Path(self.SHA_FILE).write_text(latest_sha)
|
|
try:
|
|
from util.ace.update_tools import ensure_ace_tools
|
|
self.progress.emit("Updating RPG Maker Ace tools…")
|
|
ensure_ace_tools(log_fn=lambda m: self.progress.emit(m))
|
|
except Exception as exc:
|
|
self.progress.emit(f"Ace tool update skipped: {exc}")
|
|
try:
|
|
from util.forge.update_tools import ensure_forge_plugins
|
|
self.progress.emit("Updating Forge plugins…")
|
|
ensure_forge_plugins(log_fn=lambda m: self.progress.emit(m))
|
|
except Exception as exc:
|
|
self.progress.emit(f"Forge update skipped: {exc}")
|
|
self.finished.emit(True, f"updated:{latest_sha[:8]}")
|
|
|
|
|
|
class UpdateDialog(QDialog):
|
|
"""Modal dialog that shows update progress and result."""
|
|
|
|
def __init__(self, parent=None, pending_updates: dict | None = None):
|
|
super().__init__(parent)
|
|
self.setWindowTitle("Tool Update")
|
|
self.setMinimumWidth(420)
|
|
self.setModal(True)
|
|
|
|
layout = QVBoxLayout(self)
|
|
layout.setSpacing(10)
|
|
|
|
self.status_label = QLabel("Checking for updates…")
|
|
self.status_label.setWordWrap(True)
|
|
layout.addWidget(self.status_label)
|
|
|
|
self.progress_bar = QProgressBar()
|
|
self.progress_bar.setRange(0, 0) # indeterminate
|
|
layout.addWidget(self.progress_bar)
|
|
|
|
self.close_btn = QPushButton("Cancel")
|
|
self.close_btn.clicked.connect(self.reject)
|
|
layout.addWidget(self.close_btn)
|
|
|
|
self._thread = None
|
|
self._pending = pending_updates or {}
|
|
|
|
def start(self, check_only=False):
|
|
if self._pending:
|
|
self._show_pending_updates()
|
|
return
|
|
|
|
self._thread = BackgroundUpdateCheckThread(parent=self)
|
|
self._thread.finished.connect(self._on_check_finished)
|
|
self._thread.start()
|
|
|
|
def _update_labels(self) -> list[str]:
|
|
labels = []
|
|
if self._pending.get("tool"):
|
|
labels.append("DazedMTLTool")
|
|
if self._pending.get("ace"):
|
|
labels.append("RPG Maker Ace tools")
|
|
if self._pending.get("forge"):
|
|
labels.append("Forge plugins")
|
|
return labels
|
|
|
|
def _show_pending_updates(self):
|
|
self.progress_bar.setRange(0, 1)
|
|
self.progress_bar.setValue(1)
|
|
self.close_btn.setText("Close")
|
|
|
|
labels = self._update_labels()
|
|
if not labels:
|
|
self.status_label.setText("✅ Already up to date.")
|
|
return
|
|
|
|
detail = "\n".join(f" • {label}" for label in labels)
|
|
tool_sha = self._pending.get("tool")
|
|
if tool_sha:
|
|
detail = f" • DazedMTLTool ({tool_sha[:8]})\n" + "\n".join(
|
|
f" • {label}" for label in labels if label != "DazedMTLTool"
|
|
)
|
|
self.status_label.setText(
|
|
f"🆕 Updates available:\n{detail}\n\nClick 'Update Now' to install."
|
|
)
|
|
self.close_btn.setText("Cancel")
|
|
update_btn = QPushButton("Update Now")
|
|
update_btn.clicked.connect(self._do_update)
|
|
self.layout().insertWidget(self.layout().count() - 1, update_btn)
|
|
|
|
def _on_check_finished(self, results: dict):
|
|
self._pending = results
|
|
self._show_pending_updates()
|
|
|
|
def _on_finished(self, success, message):
|
|
self.progress_bar.setRange(0, 1)
|
|
self.progress_bar.setValue(1)
|
|
self.close_btn.setText("Close")
|
|
|
|
if not success:
|
|
self.status_label.setText(f"❌ Update failed:\n{message}")
|
|
return
|
|
|
|
if message == "already_up_to_date":
|
|
self.status_label.setText("✅ Already up to date.")
|
|
elif message == "components_updated":
|
|
self._pending = {"tool": None, "ace": False, "forge": False}
|
|
self.status_label.setText("✅ Component updates installed.")
|
|
if isinstance(self.parent(), DazedMTLGUI):
|
|
self.parent().clear_update_indicator()
|
|
elif message.startswith("update_available:"):
|
|
sha = message.split(":", 1)[1]
|
|
self.status_label.setText(
|
|
f"🆕 Update available ({sha[:8]}).\nClick 'Update Now' to install."
|
|
)
|
|
self.close_btn.setText("Cancel")
|
|
update_btn = QPushButton("Update Now")
|
|
update_btn.clicked.connect(self._do_update)
|
|
self.layout().insertWidget(self.layout().count() - 1, update_btn)
|
|
elif message.startswith("updated:"):
|
|
sha = message.split(":", 1)[1]
|
|
self._pending = {"tool": None, "ace": False, "forge": False}
|
|
self.status_label.setText(
|
|
f"✅ Updated to {sha}.\n\nPlease restart the tool for changes to take effect."
|
|
)
|
|
if isinstance(self.parent(), DazedMTLGUI):
|
|
self.parent().clear_update_indicator()
|
|
|
|
def _clear_extra_buttons(self):
|
|
for i in reversed(range(self.layout().count())):
|
|
item = self.layout().itemAt(i)
|
|
if item and item.widget() and item.widget() is not self.close_btn:
|
|
w = item.widget()
|
|
if isinstance(w, QPushButton) and w.text() in ("Update Now", "Cancel"):
|
|
if w.text() != "Close":
|
|
self.layout().removeWidget(w)
|
|
w.deleteLater()
|
|
|
|
def _do_update(self):
|
|
self._clear_extra_buttons()
|
|
self.progress_bar.setRange(0, 0)
|
|
self.close_btn.setText("Cancel")
|
|
|
|
if self._pending.get("tool"):
|
|
self.status_label.setText("Downloading update…")
|
|
self._thread = UpdateThread(check_only=False, parent=self)
|
|
self._thread.progress.connect(self.status_label.setText)
|
|
self._thread.finished.connect(self._on_finished)
|
|
self._thread.start()
|
|
return
|
|
|
|
update_ace = bool(self._pending.get("ace"))
|
|
update_forge = bool(self._pending.get("forge"))
|
|
if update_ace or update_forge:
|
|
self.status_label.setText("Downloading component updates…")
|
|
self._thread = AuxToolsUpdateThread(
|
|
update_ace=update_ace,
|
|
update_forge=update_forge,
|
|
parent=self,
|
|
)
|
|
self._thread.progress.connect(self.status_label.setText)
|
|
self._thread.finished.connect(self._on_finished)
|
|
self._thread.start()
|
|
return
|
|
|
|
self.progress_bar.setRange(0, 1)
|
|
self.progress_bar.setValue(1)
|
|
self.status_label.setText("✅ Already up to date.")
|
|
|
|
# Import configuration widgets
|
|
from gui.config_tab import ConfigTab
|
|
from gui.translation_tab import TranslationTab
|
|
from gui.workflow_tab import WorkflowTab
|
|
from gui.wolf_workflow_tab import WolfWorkflowTab
|
|
|
|
class DazedMTLGUI(QMainWindow):
|
|
"""Main GUI window for the DazedMTLTool."""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.settings = QSettings("DazedTranslations", "DazedMTLTool")
|
|
self._pending_updates: dict = {}
|
|
self._update_check_thread = None
|
|
self._update_icon = "🔄"
|
|
self.btn_update = None
|
|
self.init_ui()
|
|
self.setup_status_bar()
|
|
self.setup_font_scaling()
|
|
self.restore_window_state()
|
|
QTimer.singleShot(500, self.start_background_update_check)
|
|
|
|
def restore_window_state(self):
|
|
"""Restore window geometry and state from settings."""
|
|
try:
|
|
# Restore window geometry
|
|
geometry = self.settings.value("geometry")
|
|
if geometry:
|
|
self.restoreGeometry(geometry)
|
|
|
|
# Restore window state (maximized, etc.)
|
|
window_state = self.settings.value("windowState")
|
|
if window_state:
|
|
self.restoreState(window_state)
|
|
|
|
except Exception as e:
|
|
print(f"Warning: Could not restore window state: {e}")
|
|
|
|
def save_window_state(self):
|
|
"""Save window geometry and state to settings."""
|
|
try:
|
|
self.settings.setValue("geometry", self.saveGeometry())
|
|
self.settings.setValue("windowState", self.saveState())
|
|
except Exception as e:
|
|
print(f"Warning: Could not save window state: {e}")
|
|
|
|
def stop_all_background_threads(self):
|
|
"""Gracefully stop every background ``QThread`` before the process exits.
|
|
|
|
A ``QThread`` that is destroyed while still running aborts the whole
|
|
process with SIGABRT ("QThread: Destroyed while thread is still
|
|
running"). Background workers here (startup update check, model-list
|
|
fetch, workflow/wolf tasks, translation worker) do blocking network or
|
|
subprocess I/O and can outlive the window, so we sweep every live
|
|
``QThread`` and quit/wait it, terminating only as a last resort.
|
|
"""
|
|
import gc
|
|
|
|
current = QThread.currentThread()
|
|
threads = []
|
|
for obj in gc.get_objects():
|
|
try:
|
|
if isinstance(obj, QThread) and obj is not current:
|
|
threads.append(obj)
|
|
except Exception:
|
|
continue
|
|
|
|
for t in threads:
|
|
try:
|
|
if not t.isRunning():
|
|
continue
|
|
# Nudge cooperative workers to stop before we block on them.
|
|
for stopper in ("stop", "requestInterruption"):
|
|
fn = getattr(t, stopper, None)
|
|
if callable(fn):
|
|
try:
|
|
fn()
|
|
except Exception:
|
|
pass
|
|
try:
|
|
t.quit()
|
|
except Exception:
|
|
pass
|
|
if not t.wait(3000):
|
|
try:
|
|
t.terminate()
|
|
t.wait(1000)
|
|
except Exception:
|
|
pass
|
|
except Exception:
|
|
continue
|
|
|
|
def closeEvent(self, event):
|
|
"""Handle application close event."""
|
|
# Save window geometry/state
|
|
try:
|
|
self.save_window_state()
|
|
except Exception:
|
|
pass
|
|
|
|
# Attempt to stop any running translation worker to ensure
|
|
# ThreadPoolExecutors and subprocesses are shut down so the
|
|
# Python process can exit cleanly.
|
|
try:
|
|
if hasattr(self, 'translation_tab') and self.translation_tab:
|
|
tt = self.translation_tab
|
|
# Stop log tailing first (if active)
|
|
try:
|
|
if hasattr(tt, 'translation_log_viewer') and tt.translation_log_viewer:
|
|
tt.translation_log_viewer.stop_tail()
|
|
except Exception:
|
|
pass
|
|
|
|
# If a worker exists and is running, request it to stop and wait
|
|
try:
|
|
if hasattr(tt, 'translation_worker') and tt.translation_worker and tt.translation_worker.isRunning():
|
|
tt.translation_worker.stop()
|
|
# Wait up to 5s for graceful stop, otherwise terminate
|
|
if not tt.translation_worker.wait(5000):
|
|
try:
|
|
tt.translation_worker.terminate()
|
|
tt.translation_worker.wait(2000)
|
|
except Exception:
|
|
pass
|
|
except Exception:
|
|
pass
|
|
except Exception:
|
|
pass
|
|
|
|
# Stop every remaining background thread (model fetch, update check,
|
|
# workflow/wolf workers) so the process can exit without aborting.
|
|
try:
|
|
self.stop_all_background_threads()
|
|
except Exception:
|
|
pass
|
|
|
|
event.accept()
|
|
|
|
def setup_font_scaling(self):
|
|
"""Set up font scaling based on configuration."""
|
|
try:
|
|
from dotenv import load_dotenv
|
|
import os
|
|
|
|
# Load environment variables
|
|
load_dotenv()
|
|
|
|
# Get font scale setting
|
|
font_scale = float(os.getenv("font_scale", "1.0"))
|
|
|
|
# Apply font scaling
|
|
self.apply_font_scaling(font_scale)
|
|
|
|
except Exception as e:
|
|
print(f"Warning: Could not apply font scaling: {e}")
|
|
|
|
def apply_font_scaling(self, scale_factor):
|
|
"""Apply font scaling to the entire application."""
|
|
try:
|
|
app = QApplication.instance()
|
|
if not app:
|
|
return
|
|
|
|
# Scale the application default font (affects widgets without inline font-size)
|
|
font = app.font()
|
|
font.setPointSize(max(6, int(9 * scale_factor)))
|
|
app.setFont(font)
|
|
|
|
# Scale inline font-size values in every widget's individual stylesheet.
|
|
# We store the *original* stylesheet on each widget (using a Qt property)
|
|
# so that re-scaling always starts from the unmodified values.
|
|
for widget in app.allWidgets():
|
|
original = widget.property("_orig_stylesheet")
|
|
if original is None:
|
|
ss = widget.styleSheet()
|
|
if not ss or 'font-size' not in ss:
|
|
continue
|
|
widget.setProperty("_orig_stylesheet", ss)
|
|
original = ss
|
|
|
|
scaled = re.sub(
|
|
r'font-size:\s*(\d+(?:\.\d+)?)px',
|
|
lambda m: f'font-size: {max(6, round(float(m.group(1)) * scale_factor))}px',
|
|
original
|
|
)
|
|
widget.setStyleSheet(scaled)
|
|
|
|
# Update window title only when non-default scale is active
|
|
if scale_factor != 1.0:
|
|
self.setWindowTitle(f"DazedMTLTool - Visual Translation Interface (Font: {scale_factor:.1f}x)")
|
|
else:
|
|
self.setWindowTitle("DazedMTLTool - Visual Translation Interface")
|
|
|
|
except Exception as e:
|
|
print(f"Warning: Could not apply font scaling: {e}")
|
|
|
|
def init_ui(self):
|
|
"""Initialize the user interface."""
|
|
self.setWindowTitle("DazedMTLTool - Visual Translation Interface")
|
|
|
|
# Get screen geometry and set window size more responsively
|
|
screen = QApplication.primaryScreen()
|
|
screen_geometry = screen.availableGeometry()
|
|
|
|
# Set window size to 80% of screen size, with reasonable minimums
|
|
window_width = max(1200, int(screen_geometry.width() * 0.8))
|
|
window_height = max(800, int(screen_geometry.height() * 0.8))
|
|
|
|
# Center the window on screen
|
|
x = (screen_geometry.width() - window_width) // 2
|
|
y = (screen_geometry.height() - window_height) // 2
|
|
|
|
self.setGeometry(x, y, window_width, window_height)
|
|
|
|
# Set minimum size to prevent the window from becoming too small
|
|
self.setMinimumSize(1000, 600)
|
|
|
|
app_icon = load_application_icon()
|
|
if not app_icon.isNull():
|
|
self.setWindowIcon(app_icon)
|
|
|
|
# Create central widget and main layout
|
|
central_widget = QWidget()
|
|
self.setCentralWidget(central_widget)
|
|
|
|
# Create main layout with VSCode-style sidebar
|
|
main_layout = QHBoxLayout()
|
|
main_layout.setContentsMargins(0, 0, 0, 0)
|
|
main_layout.setSpacing(0)
|
|
|
|
# Create sidebar for navigation
|
|
sidebar = QWidget()
|
|
sidebar.setFixedWidth(60)
|
|
sidebar.setStyleSheet("""
|
|
QWidget {
|
|
background-color: #2d2d30;
|
|
}
|
|
""")
|
|
sidebar_layout = QVBoxLayout()
|
|
sidebar_layout.setContentsMargins(0, 10, 0, 10)
|
|
sidebar_layout.setSpacing(2)
|
|
|
|
# Create navigation buttons
|
|
self.nav_buttons = []
|
|
|
|
# Translation button (first)
|
|
btn_translation = self.create_nav_button("🌐", "Translation")
|
|
btn_translation.clicked.connect(lambda: self.switch_page(0))
|
|
sidebar_layout.addWidget(btn_translation)
|
|
self.nav_buttons.append(btn_translation)
|
|
|
|
# Workflow / Automation button (second)
|
|
btn_workflow = self.create_nav_button("⚡", "Workflow")
|
|
btn_workflow.setToolTip("Workflow — automated translation pipeline")
|
|
btn_workflow.clicked.connect(lambda: self.switch_page(1))
|
|
sidebar_layout.addWidget(btn_workflow)
|
|
self.nav_buttons.append(btn_workflow)
|
|
|
|
# Configuration button (third)
|
|
btn_config = self.create_nav_button("⚙️", "Configuration")
|
|
btn_config.clicked.connect(lambda: self.switch_page(2))
|
|
sidebar_layout.addWidget(btn_config)
|
|
self.nav_buttons.append(btn_config)
|
|
|
|
sidebar_layout.addStretch()
|
|
|
|
# Update button at the bottom of the sidebar
|
|
self.btn_update = self.create_nav_button(self._update_icon, "Check for Updates")
|
|
self.btn_update.setCheckable(False)
|
|
self.btn_update.clicked.connect(self.show_update_dialog)
|
|
sidebar_layout.addWidget(self.btn_update)
|
|
|
|
sidebar.setLayout(sidebar_layout)
|
|
|
|
# Create stacked widget for content pages
|
|
self.content_stack = QStackedWidget()
|
|
|
|
# Add tabs to stacked widget
|
|
self.setup_tabs()
|
|
|
|
# Add sidebar and content to main layout
|
|
main_layout.addWidget(sidebar)
|
|
main_layout.addWidget(self.content_stack)
|
|
central_widget.setLayout(main_layout)
|
|
|
|
# Create menu bar
|
|
self.create_menu_bar()
|
|
|
|
# Select first page by default
|
|
self.switch_page(0)
|
|
|
|
def create_nav_button(self, icon_text, tooltip):
|
|
"""Create a navigation button for the sidebar."""
|
|
from gui.platform_glyph import configure_nav_toolbutton
|
|
|
|
btn = QToolButton()
|
|
btn.setToolTip(tooltip)
|
|
btn.setFixedSize(60, 50)
|
|
btn.setCheckable(True)
|
|
configure_nav_toolbutton(btn, icon_text, horizontal=False)
|
|
return btn
|
|
|
|
def switch_page(self, index):
|
|
"""Switch to the specified page and update button states."""
|
|
self.content_stack.setCurrentIndex(index)
|
|
|
|
# Update button checked states
|
|
for i, btn in enumerate(self.nav_buttons):
|
|
btn.setChecked(i == index)
|
|
|
|
def setup_tabs(self):
|
|
"""Set up all the tabs in the interface."""
|
|
# Translation Execution Tab (index 0)
|
|
self.translation_tab = TranslationTab(self)
|
|
self.content_stack.addWidget(self.translation_tab)
|
|
|
|
# Workflow / Automation Tab (index 1) — engine selector swaps between the
|
|
# RPGMaker and Wolf guided panels while keeping a single sidebar button.
|
|
self.content_stack.addWidget(self._create_workflow_container())
|
|
|
|
# Configuration Tab (index 2)
|
|
self.config_tab = ConfigTab()
|
|
self.config_tab.config_changed.connect(self.on_config_changed)
|
|
self.content_stack.addWidget(self.config_tab)
|
|
|
|
def _create_workflow_container(self) -> QWidget:
|
|
"""Wrap the RPGMaker and Wolf guided workflows behind an engine selector."""
|
|
container = QWidget()
|
|
layout = QVBoxLayout(container)
|
|
layout.setContentsMargins(0, 0, 0, 0)
|
|
layout.setSpacing(0)
|
|
|
|
# ── Engine selector bar ──
|
|
bar = QWidget()
|
|
bar.setStyleSheet(
|
|
"QWidget{background-color:#252526;border-bottom:1px solid #3a3a3a;}"
|
|
)
|
|
bar_layout = QHBoxLayout(bar)
|
|
bar_layout.setContentsMargins(16, 6, 16, 6)
|
|
bar_layout.setSpacing(8)
|
|
|
|
engine_label = QLabel("Engine:")
|
|
engine_label.setStyleSheet(
|
|
"color:#9d9d9d;font-size:12px;font-weight:bold;background:transparent;border:none;"
|
|
)
|
|
bar_layout.addWidget(engine_label)
|
|
|
|
self.workflow_engine_combo = QComboBox()
|
|
self.workflow_engine_combo.addItem("RPG Maker (MV/MZ/Ace)")
|
|
self.workflow_engine_combo.addItem("Wolf RPG (WolfDawn)")
|
|
self.workflow_engine_combo.setStyleSheet(
|
|
"QComboBox{background-color:#3c3c3c;color:#cccccc;border:1px solid #555555;"
|
|
"border-radius:4px;padding:3px 8px;font-size:12px;min-width:220px;}"
|
|
"QComboBox:hover{border-color:#007acc;}"
|
|
"QComboBox QAbstractItemView{background-color:#2d2d30;color:#cccccc;"
|
|
"selection-background-color:#007acc;}"
|
|
)
|
|
bar_layout.addWidget(self.workflow_engine_combo)
|
|
bar_layout.addStretch()
|
|
layout.addWidget(bar)
|
|
|
|
# ── Stacked guided panels ──
|
|
self.workflow_stack = QStackedWidget()
|
|
self.workflow_tab = WorkflowTab(self)
|
|
self.wolf_workflow_tab = WolfWorkflowTab(self)
|
|
self.workflow_stack.addWidget(self.workflow_tab)
|
|
self.workflow_stack.addWidget(self.wolf_workflow_tab)
|
|
layout.addWidget(self.workflow_stack, 1)
|
|
|
|
self.workflow_engine_combo.currentIndexChanged.connect(
|
|
self.workflow_stack.setCurrentIndex
|
|
)
|
|
return container
|
|
|
|
def start_background_update_check(self):
|
|
"""Check for tool, Ace, and Forge updates after the GUI is visible."""
|
|
if self._update_check_thread and self._update_check_thread.isRunning():
|
|
return
|
|
self._update_check_thread = BackgroundUpdateCheckThread(self)
|
|
self._update_check_thread.finished.connect(self._on_background_update_check)
|
|
self._update_check_thread.start()
|
|
|
|
def _on_background_update_check(self, results: dict):
|
|
self._pending_updates = results
|
|
if any_updates_available(results):
|
|
self.set_update_indicator()
|
|
else:
|
|
self.clear_update_indicator()
|
|
|
|
def set_update_indicator(self):
|
|
"""Highlight the update button when updates are available."""
|
|
if not self.btn_update:
|
|
return
|
|
self.btn_update.setToolTip("Updates available — click to install")
|
|
from gui.platform_glyph import configure_nav_toolbutton
|
|
configure_nav_toolbutton(
|
|
self.btn_update, self._update_icon, horizontal=False, update_available=True,
|
|
)
|
|
|
|
def clear_update_indicator(self):
|
|
"""Restore the default update button appearance."""
|
|
self._pending_updates = {}
|
|
if not self.btn_update:
|
|
return
|
|
self.btn_update.setToolTip("Check for Updates")
|
|
from gui.platform_glyph import configure_nav_toolbutton
|
|
configure_nav_toolbutton(
|
|
self.btn_update, self._update_icon, horizontal=False, update_available=False,
|
|
)
|
|
|
|
def show_update_dialog(self):
|
|
"""Open the update dialog and check for a newer version."""
|
|
dlg = UpdateDialog(self, pending_updates=self._pending_updates.copy())
|
|
dlg.start(check_only=True)
|
|
dlg.exec_()
|
|
self._pending_updates = dlg._pending
|
|
if any_updates_available(dlg._pending):
|
|
self.set_update_indicator()
|
|
else:
|
|
self.clear_update_indicator()
|
|
|
|
def on_config_changed(self):
|
|
"""Handle configuration changes."""
|
|
# This will be called when font scale or other settings change
|
|
try:
|
|
config = self.config_tab.get_config()
|
|
font_scale = config.get("font_scale", 1.0)
|
|
self.apply_font_scaling(font_scale)
|
|
except Exception as e:
|
|
print(f"Warning: Could not apply configuration changes: {e}")
|
|
|
|
def set_font_scale(self, scale_factor):
|
|
"""Set the font scale and update the configuration."""
|
|
try:
|
|
# Apply the scaling immediately
|
|
self.apply_font_scaling(scale_factor)
|
|
|
|
# Update the configuration tab if it provides a font_scale widget
|
|
try:
|
|
if hasattr(self.config_tab, "font_scale_spin"):
|
|
self.config_tab.font_scale_spin.setValue(scale_factor)
|
|
except Exception:
|
|
# If the widget isn't present or fails to update, continue silently
|
|
pass
|
|
|
|
# Save to .env file if the config tab provides save functionality
|
|
try:
|
|
if hasattr(self.config_tab, "save_to_env"):
|
|
self.config_tab.save_to_env()
|
|
except Exception:
|
|
pass
|
|
|
|
except Exception as e:
|
|
QMessageBox.warning(self, "Warning", f"Failed to set font scale: {str(e)}")
|
|
|
|
def create_menu_bar(self):
|
|
"""Create the menu bar."""
|
|
menubar = self.menuBar()
|
|
|
|
# File menu
|
|
file_menu = menubar.addMenu('File')
|
|
|
|
# Load project action
|
|
load_action = file_menu.addAction('Load Project')
|
|
load_action.triggered.connect(self.load_project)
|
|
|
|
# Save project action
|
|
save_action = file_menu.addAction('Save Project')
|
|
save_action.triggered.connect(self.save_project)
|
|
|
|
file_menu.addSeparator()
|
|
|
|
# Exit action
|
|
exit_action = file_menu.addAction('Exit')
|
|
exit_action.triggered.connect(self.close)
|
|
|
|
# Tools menu
|
|
tools_menu = menubar.addMenu('Tools')
|
|
|
|
# Font Size submenu removed — font scaling menu was unreliable and has been removed
|
|
|
|
tools_menu.addSeparator()
|
|
|
|
# Check for updates
|
|
update_action = tools_menu.addAction('Check for Updates')
|
|
update_action.triggered.connect(self.show_update_dialog)
|
|
|
|
tools_menu.addSeparator()
|
|
|
|
# Reset to defaults
|
|
reset_action = tools_menu.addAction('Reset to Defaults')
|
|
reset_action.triggered.connect(self.reset_to_defaults)
|
|
|
|
# Validate configuration
|
|
validate_action = tools_menu.addAction('Validate Configuration')
|
|
validate_action.triggered.connect(self.validate_configuration)
|
|
|
|
# Help menu
|
|
help_menu = menubar.addMenu('Help')
|
|
|
|
# About action
|
|
about_action = help_menu.addAction('About')
|
|
about_action.triggered.connect(self.show_about)
|
|
|
|
def setup_status_bar(self):
|
|
"""Set up the status bar (removed to save space)."""
|
|
# Status bar removed to maximize space for content
|
|
pass
|
|
|
|
def load_project(self):
|
|
"""Load a project configuration."""
|
|
file_path, _ = QFileDialog.getOpenFileName(
|
|
self,
|
|
"Load Project Configuration",
|
|
"",
|
|
"JSON Files (*.json);;All Files (*)"
|
|
)
|
|
|
|
if file_path:
|
|
try:
|
|
# Load configuration from file
|
|
self.config_tab.load_from_file(file_path)
|
|
except Exception as e:
|
|
QMessageBox.critical(self, "Error", f"Failed to load project:\n{str(e)}")
|
|
|
|
def save_project(self):
|
|
"""Save the current project configuration."""
|
|
file_path, _ = QFileDialog.getSaveFileName(
|
|
self,
|
|
"Save Project Configuration",
|
|
"",
|
|
"JSON Files (*.json);;All Files (*)"
|
|
)
|
|
|
|
if file_path:
|
|
try:
|
|
# Save configuration to file
|
|
config_data = self.config_tab.get_config()
|
|
|
|
import json
|
|
with open(file_path, 'w', encoding='utf-8') as f:
|
|
json.dump(config_data, f, indent=2, ensure_ascii=False)
|
|
|
|
except Exception as e:
|
|
QMessageBox.critical(self, "Error", f"Failed to save project:\n{str(e)}")
|
|
|
|
def reset_to_defaults(self):
|
|
"""Reset all configurations to default values."""
|
|
reply = QMessageBox.question(
|
|
self,
|
|
"Reset to Defaults",
|
|
"Are you sure you want to reset all settings to their default values?",
|
|
QMessageBox.Yes | QMessageBox.No,
|
|
QMessageBox.No
|
|
)
|
|
|
|
if reply == QMessageBox.Yes:
|
|
self.config_tab.reset_to_defaults()
|
|
|
|
def validate_configuration(self):
|
|
"""Validate the current configuration."""
|
|
try:
|
|
# Validate configuration settings
|
|
config_valid = self.config_tab.validate()
|
|
|
|
if config_valid:
|
|
QMessageBox.information(self, "Validation", "Configuration is valid!")
|
|
else:
|
|
QMessageBox.warning(self, "Validation", "Configuration has issues. Check the warnings.")
|
|
|
|
except Exception as e:
|
|
QMessageBox.critical(self, "Validation Error", f"Failed to validate configuration:\n{str(e)}")
|
|
|
|
def show_about(self):
|
|
"""Show the about dialog."""
|
|
QMessageBox.about(
|
|
self,
|
|
"About DazedMTLTool GUI",
|
|
"""
|
|
<h3>DazedMTLTool GUI</h3>
|
|
<p>A visual interface for the DazedMTLTool translation system.</p>
|
|
<p>This tool helps translate visual novels, RPG games, and other text-based content using AI translation services.</p>
|
|
<p><b>Features:</b></p>
|
|
<ul>
|
|
<li>Visual configuration management</li>
|
|
<li>Module-specific settings</li>
|
|
<li>Real-time translation monitoring</li>
|
|
<li>File management and organization</li>
|
|
</ul>
|
|
"""
|
|
)
|
|
|
|
def update_status(self, message):
|
|
"""Update the status bar message (removed to save space)."""
|
|
pass
|
|
|
|
def show_progress(self, show=True):
|
|
"""Show or hide the progress bar (removed to save space)."""
|
|
pass
|
|
|
|
def set_progress(self, value):
|
|
"""Set the progress bar value (removed to save space)."""
|
|
pass
|
|
|
|
|
|
def main():
|
|
"""Main entry point for the GUI application."""
|
|
try:
|
|
# Enable high DPI scaling before creating QApplication
|
|
QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
|
|
QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)
|
|
|
|
# Additional DPI handling for better compatibility
|
|
if hasattr(Qt, 'AA_DisableWindowContextHelpButton'):
|
|
QApplication.setAttribute(Qt.AA_DisableWindowContextHelpButton, True)
|
|
|
|
# Set high DPI scale factor policy
|
|
if hasattr(QApplication, 'setHighDpiScaleFactorRoundingPolicy'):
|
|
QApplication.setHighDpiScaleFactorRoundingPolicy(Qt.HighDpiScaleFactorRoundingPolicy.PassThrough)
|
|
|
|
if sys.platform.startswith("linux"):
|
|
from util.linux_desktop import ensure_linux_desktop_entry, install_qt_message_filter
|
|
|
|
install_qt_message_filter()
|
|
ensure_linux_desktop_entry()
|
|
QGuiApplication.setDesktopFileName("DazedMTLTool")
|
|
|
|
QCoreApplication.setOrganizationName("DazedTranslations")
|
|
QCoreApplication.setApplicationName("DazedMTLTool")
|
|
|
|
app = QApplication(sys.argv)
|
|
|
|
# Windows taskbar groups by executable (python.exe) unless we set an explicit
|
|
# AppUserModelID; combine with QApplication window icon so the pinned icon
|
|
# matches the window instead of the Python launcher.
|
|
if sys.platform == "win32":
|
|
try:
|
|
import ctypes
|
|
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
|
|
"DazedTranslations.DazedMTLTool.1"
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
app_icon = load_application_icon()
|
|
if not app_icon.isNull():
|
|
app.setWindowIcon(app_icon)
|
|
|
|
# Additional screen-aware settings
|
|
screen = app.primaryScreen()
|
|
if screen:
|
|
dpi = screen.logicalDotsPerInch()
|
|
print(f"Screen DPI: {dpi}")
|
|
|
|
except Exception as e:
|
|
print(f"Failed to create QApplication: {e}")
|
|
print("Make sure PyQt5 is properly installed:")
|
|
print(" pip install PyQt5>=5.15.0")
|
|
return 1
|
|
|
|
# Set application properties
|
|
app.setApplicationVersion("1.0")
|
|
|
|
# Apply dark theme with cleaner, more compact styling
|
|
app.setStyleSheet("""
|
|
QMainWindow {
|
|
background-color: #2b2b2b;
|
|
color: #ffffff;
|
|
}
|
|
QWidget {
|
|
background-color: #2b2b2b;
|
|
color: #ffffff;
|
|
}
|
|
QTabWidget::pane {
|
|
border: 1px solid #555555;
|
|
background-color: #3c3c3c;
|
|
padding: 5px;
|
|
}
|
|
QTabBar::tab {
|
|
background-color: #555555;
|
|
color: #ffffff;
|
|
padding: 8px 16px;
|
|
margin-right: 2px;
|
|
border: 1px solid #666666;
|
|
border-bottom: none;
|
|
}
|
|
QTabBar::tab:selected {
|
|
background-color: #007acc;
|
|
color: #ffffff;
|
|
}
|
|
QTabBar::tab:hover {
|
|
background-color: #666666;
|
|
color: #ffffff;
|
|
}
|
|
QGroupBox {
|
|
font-weight: normal;
|
|
border: 1px solid #444444;
|
|
border-radius: 3px;
|
|
margin-top: 8px;
|
|
padding: 8px;
|
|
color: #ffffff;
|
|
background-color: transparent;
|
|
}
|
|
QGroupBox::title {
|
|
subcontrol-origin: margin;
|
|
subcontrol-position: top left;
|
|
left: 8px;
|
|
padding: 2px 5px;
|
|
color: #007acc;
|
|
background-color: #2b2b2b;
|
|
font-weight: bold;
|
|
}
|
|
QPushButton {
|
|
background-color: #0078d4;
|
|
color: white;
|
|
border: none;
|
|
padding: 7px 14px;
|
|
border-radius: 3px;
|
|
font-weight: bold;
|
|
}
|
|
QPushButton:hover {
|
|
background-color: #106ebe;
|
|
}
|
|
QPushButton:pressed {
|
|
background-color: #005a9e;
|
|
}
|
|
QPushButton:disabled {
|
|
background-color: #404040;
|
|
color: #888888;
|
|
}
|
|
QCheckBox {
|
|
color: #ffffff;
|
|
spacing: 6px;
|
|
background-color: transparent;
|
|
padding: 2px;
|
|
}
|
|
QCheckBox::indicator {
|
|
width: 16px;
|
|
height: 16px;
|
|
}
|
|
QCheckBox::indicator:unchecked {
|
|
background-color: #404040;
|
|
border: 1px solid #555555;
|
|
border-radius: 2px;
|
|
}
|
|
QCheckBox::indicator:checked {
|
|
background-color: #0078d4;
|
|
border: 1px solid #0078d4;
|
|
border-radius: 2px;
|
|
}
|
|
QLabel {
|
|
color: #ffffff;
|
|
background-color: transparent;
|
|
padding: 2px;
|
|
}
|
|
QLineEdit {
|
|
background-color: #404040;
|
|
color: #ffffff;
|
|
border: 1px solid #555555;
|
|
padding: 5px 8px;
|
|
border-radius: 2px;
|
|
selection-background-color: #007acc;
|
|
}
|
|
QLineEdit:focus {
|
|
border: 1px solid #007acc;
|
|
}
|
|
QSpinBox, QDoubleSpinBox {
|
|
background-color: #404040;
|
|
color: #ffffff;
|
|
border: 1px solid #555555;
|
|
padding: 5px 8px;
|
|
border-radius: 2px;
|
|
}
|
|
QSpinBox:focus, QDoubleSpinBox:focus {
|
|
border: 1px solid #007acc;
|
|
}
|
|
QSpinBox::up-button, QDoubleSpinBox::up-button {
|
|
background-color: #555555;
|
|
border: none;
|
|
border-radius: 0;
|
|
}
|
|
QSpinBox::down-button, QDoubleSpinBox::down-button {
|
|
background-color: #555555;
|
|
border: none;
|
|
border-radius: 0;
|
|
}
|
|
QComboBox {
|
|
background-color: #404040;
|
|
color: #ffffff;
|
|
border: 1px solid #555555;
|
|
padding: 5px;
|
|
padding-right: 30px;
|
|
border-radius: 2px;
|
|
}
|
|
QComboBox:focus {
|
|
border: 1px solid #007acc;
|
|
}
|
|
QComboBox::drop-down {
|
|
subcontrol-origin: padding;
|
|
subcontrol-position: center right;
|
|
width: 25px;
|
|
border-left: 1px solid #555555;
|
|
background-color: #555555;
|
|
}
|
|
QComboBox::drop-down:hover {
|
|
background-color: #007acc;
|
|
}
|
|
QComboBox::down-arrow {
|
|
width: 0;
|
|
height: 0;
|
|
border-left: 5px solid transparent;
|
|
border-right: 5px solid transparent;
|
|
border-top: 6px solid #ffffff;
|
|
}
|
|
QComboBox QAbstractItemView {
|
|
background-color: #404040;
|
|
color: #ffffff;
|
|
selection-background-color: #007acc;
|
|
border: 1px solid #555555;
|
|
padding: 3px;
|
|
}
|
|
QTextEdit {
|
|
background-color: #1e1e1e;
|
|
color: #ffffff;
|
|
border: 1px solid #555555;
|
|
selection-background-color: #007acc;
|
|
padding: 5px;
|
|
}
|
|
QTextEdit:focus {
|
|
border: 1px solid #007acc;
|
|
}
|
|
QScrollArea {
|
|
background-color: transparent;
|
|
border: none;
|
|
}
|
|
QScrollBar:vertical {
|
|
background-color: #2b2b2b;
|
|
width: 12px;
|
|
border: none;
|
|
}
|
|
QScrollBar::handle:vertical {
|
|
background-color: #555555;
|
|
border-radius: 6px;
|
|
min-height: 20px;
|
|
margin: 2px;
|
|
}
|
|
QScrollBar::handle:vertical:hover {
|
|
background-color: #007acc;
|
|
}
|
|
QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {
|
|
height: 0px;
|
|
}
|
|
QScrollBar:horizontal {
|
|
background-color: #2b2b2b;
|
|
height: 12px;
|
|
border: none;
|
|
}
|
|
QScrollBar::handle:horizontal {
|
|
background-color: #555555;
|
|
border-radius: 6px;
|
|
min-width: 20px;
|
|
margin: 2px;
|
|
}
|
|
QScrollBar::handle:horizontal:hover {
|
|
background-color: #007acc;
|
|
}
|
|
QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal {
|
|
width: 0px;
|
|
}
|
|
QListWidget {
|
|
background-color: #1e1e1e;
|
|
color: #ffffff;
|
|
border: 1px solid #555555;
|
|
selection-background-color: #007acc;
|
|
padding: 3px;
|
|
}
|
|
QListWidget::item {
|
|
padding: 5px;
|
|
border-bottom: 1px solid #333333;
|
|
}
|
|
QListWidget::item:selected {
|
|
background-color: #007acc;
|
|
color: #ffffff;
|
|
}
|
|
QListWidget::item:hover {
|
|
background-color: #404040;
|
|
}
|
|
QHeaderView::section {
|
|
background-color: #555555;
|
|
color: #ffffff;
|
|
padding: 6px;
|
|
border: 1px solid #666666;
|
|
}
|
|
QStatusBar {
|
|
background-color: #2b2b2b;
|
|
color: #ffffff;
|
|
border-top: 1px solid #555555;
|
|
}
|
|
QProgressBar {
|
|
background-color: #404040;
|
|
border: 1px solid #555555;
|
|
border-radius: 3px;
|
|
text-align: center;
|
|
color: #ffffff;
|
|
height: 20px;
|
|
}
|
|
QProgressBar::chunk {
|
|
background-color: #007acc;
|
|
border-radius: 2px;
|
|
}
|
|
QMenuBar {
|
|
background-color: #2b2b2b;
|
|
color: #ffffff;
|
|
border-bottom: 1px solid #555555;
|
|
}
|
|
QMenuBar::item {
|
|
padding: 6px 12px;
|
|
background-color: transparent;
|
|
}
|
|
QMenuBar::item:selected {
|
|
background-color: #007acc;
|
|
}
|
|
QMenu {
|
|
background-color: #404040;
|
|
color: #ffffff;
|
|
border: 1px solid #555555;
|
|
}
|
|
QMenu::item {
|
|
padding: 6px 20px;
|
|
}
|
|
QMenu::item:selected {
|
|
background-color: #007acc;
|
|
}
|
|
QFrame[frameShape="4"], QFrame[frameShape="5"] {
|
|
color: #555555;
|
|
}
|
|
QSplitter::handle {
|
|
background-color: #555555;
|
|
}
|
|
QSplitter::handle:hover {
|
|
background-color: #007acc;
|
|
}
|
|
""")
|
|
|
|
try:
|
|
# Create and show the main window
|
|
window = DazedMTLGUI()
|
|
window.show()
|
|
|
|
# Safety: ensure any running translation worker is stopped when the
|
|
# application is quitting (aboutToQuit). This helps guarantee the
|
|
# ThreadPoolExecutor threads and subprocesses are shut down so the
|
|
# Python interpreter can exit cleanly.
|
|
def _on_about_to_quit():
|
|
try:
|
|
if hasattr(window, 'translation_tab') and window.translation_tab:
|
|
tt = window.translation_tab
|
|
try:
|
|
if hasattr(tt, 'translation_log_viewer') and tt.translation_log_viewer:
|
|
tt.translation_log_viewer.stop_tail()
|
|
except Exception:
|
|
pass
|
|
|
|
try:
|
|
if hasattr(tt, 'translation_worker') and tt.translation_worker and tt.translation_worker.isRunning():
|
|
tt.translation_worker.stop()
|
|
# Wait briefly for graceful shutdown
|
|
if not tt.translation_worker.wait(3000):
|
|
try:
|
|
tt.translation_worker.terminate()
|
|
tt.translation_worker.wait(2000)
|
|
except Exception:
|
|
pass
|
|
except Exception:
|
|
pass
|
|
except Exception:
|
|
pass
|
|
|
|
# Final safety net: stop any remaining background threads so a
|
|
# QThread is never destroyed while still running (SIGABRT).
|
|
try:
|
|
window.stop_all_background_threads()
|
|
except Exception:
|
|
pass
|
|
|
|
try:
|
|
app.aboutToQuit.connect(_on_about_to_quit)
|
|
except Exception:
|
|
pass
|
|
|
|
# Show font adjustment tip on first run (optional)
|
|
try:
|
|
from dotenv import load_dotenv
|
|
load_dotenv()
|
|
show_font_tip = os.getenv("show_font_tip", "true").lower() == "true"
|
|
|
|
if show_font_tip:
|
|
QMessageBox.information(
|
|
window,
|
|
"Font Size Adjustment",
|
|
"💡 Font too small?\n\n"
|
|
"• Use Tools → Font Size menu for quick adjustment\n"
|
|
"• Or go to Configuration tab → UI Settings\n"
|
|
"• Try 'Large (1.5x)' or 'Extra Large (2.0x)' for high DPI displays\n\n"
|
|
"This tip can be disabled in the Configuration tab."
|
|
)
|
|
|
|
# Set flag to not show again
|
|
from dotenv import set_key
|
|
set_key(".env", "show_font_tip", "false")
|
|
|
|
except Exception:
|
|
pass # Ignore if .env operations fail
|
|
|
|
# Start the application
|
|
return app.exec_()
|
|
except Exception as e:
|
|
print(f"Error starting GUI: {e}")
|
|
return 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|