#!/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
from PyQt5.QtWidgets import (
QApplication, QMainWindow, QTabWidget, QVBoxLayout, QHBoxLayout,
QWidget, QPushButton, QLabel, QFileDialog, QMessageBox, QProgressBar,
QTextEdit, QSplitter, QGroupBox, QStatusBar, QStackedWidget, QToolButton,
QDialog
)
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
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 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
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)
self.workflow_tab = WorkflowTab(self)
self.content_stack.addWidget(self.workflow_tab)
# 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 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",
"""
DazedMTLTool GUI
A visual interface for the DazedMTLTool translation system.
This tool helps translate visual novels, RPG games, and other text-based content using AI translation services.
Features:
- Visual configuration management
- Module-specific settings
- Real-time translation monitoring
- File management and organization
"""
)
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
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
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())