1266 lines
53 KiB
Python
1266 lines
53 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
Simple Translation Tab for DazedMTLTool GUI
|
||
|
||
Simple file management and translation execution with console log display.
|
||
"""
|
||
|
||
import os
|
||
import subprocess
|
||
import threading
|
||
import sys
|
||
from pathlib import Path
|
||
from concurrent.futures import ThreadPoolExecutor, as_completed, Future
|
||
import traceback
|
||
import signal
|
||
import multiprocessing
|
||
from colorama import Fore
|
||
from tqdm import tqdm
|
||
from dotenv import load_dotenv
|
||
from PyQt5.QtWidgets import (
|
||
QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QGroupBox,
|
||
QTextEdit, QMessageBox, QListWidget, QListWidgetItem,
|
||
QSplitter, QFileDialog, QComboBox, QCheckBox, QProgressBar, QFrame, QFormLayout, QStackedWidget
|
||
)
|
||
from PyQt5.QtCore import Qt, QTimer, pyqtSignal, QThread, QMutex, QProcess
|
||
from PyQt5.QtGui import QFont
|
||
from gui.log_viewer import LogViewer
|
||
|
||
|
||
def create_section_header(title):
|
||
"""Create a clean section header without boxes."""
|
||
label = QLabel(title)
|
||
label.setStyleSheet("""
|
||
QLabel {
|
||
font-size: 13px;
|
||
font-weight: bold;
|
||
color: #007acc;
|
||
padding: 8px 0px 5px 0px;
|
||
background-color: transparent;
|
||
}
|
||
""")
|
||
return label
|
||
|
||
def create_horizontal_line():
|
||
"""Create a horizontal separator line."""
|
||
line = QFrame()
|
||
line.setFrameShape(QFrame.HLine)
|
||
line.setFrameShadow(QFrame.Sunken)
|
||
line.setStyleSheet("QFrame { color: #555555; margin: 5px 0px; }")
|
||
return line
|
||
|
||
|
||
class TranslationWorker(QThread):
|
||
"""Worker thread for running translations without blocking the UI."""
|
||
|
||
log_signal = pyqtSignal(str)
|
||
progress_signal = pyqtSignal(int, int, str) # current_file, total_files, filename
|
||
item_progress_signal = pyqtSignal(str, int, int) # filename, current_item, total_items (for tqdm within file)
|
||
finished_signal = pyqtSignal(bool, str)
|
||
|
||
def __init__(self, project_root, module_info, estimate_only=False, selected_files=None):
|
||
super().__init__()
|
||
self.project_root = project_root
|
||
self.module_info = module_info # [name, extensions, handler_function]
|
||
self.estimate_only = estimate_only
|
||
self.selected_files = selected_files # List of files to process
|
||
self.should_stop = False
|
||
self.mutex = QMutex() # For thread safety
|
||
self.executor = None # Store reference to executor for proper shutdown
|
||
self.running_processes = [] # Track running processes for termination
|
||
|
||
def stop(self):
|
||
"""Stop the translation process."""
|
||
self.mutex.lock()
|
||
try:
|
||
if self.should_stop:
|
||
# Already stopping, don't log again
|
||
return
|
||
|
||
self.should_stop = True
|
||
self.emit_log("🛑 Stopping translation worker and canceling pending tasks...")
|
||
|
||
# Shutdown the executor if it exists
|
||
if self.executor:
|
||
# For older Python versions compatibility, use shutdown(wait=False)
|
||
# and manually cancel futures
|
||
try:
|
||
# Try to use cancel_futures parameter (Python 3.9+)
|
||
self.executor.shutdown(wait=False, cancel_futures=True)
|
||
except TypeError:
|
||
# Fallback for older Python versions
|
||
self.executor.shutdown(wait=False)
|
||
|
||
# Terminate any running processes
|
||
if self.running_processes:
|
||
self.emit_log("🛑 Terminating running translation processes...")
|
||
for process in self.running_processes:
|
||
try:
|
||
if process.poll() is None: # Process is still running
|
||
process.terminate()
|
||
# Give it a moment to terminate gracefully
|
||
try:
|
||
process.wait(timeout=2)
|
||
except subprocess.TimeoutExpired:
|
||
# Force kill if it doesn't terminate
|
||
process.kill()
|
||
process.wait()
|
||
except Exception as e:
|
||
self.emit_log(f"⚠️ Warning: Could not terminate process: {e}")
|
||
self.running_processes.clear()
|
||
finally:
|
||
self.mutex.unlock()
|
||
|
||
def emit_log(self, message):
|
||
"""Thread-safe log emission."""
|
||
self.log_signal.emit(message)
|
||
|
||
def emit_progress(self, current, total, filename):
|
||
"""Thread-safe progress emission."""
|
||
self.progress_signal.emit(current, total, filename)
|
||
|
||
def run_module_in_process(self, filename, estimate_only):
|
||
"""Run a module handler in a separate process for better control."""
|
||
try:
|
||
# Use the external subprocess runner script
|
||
runner_script = self.project_root / "util" / "subprocess_runner.py"
|
||
if not runner_script.exists():
|
||
self.emit_log(f"❌ Subprocess runner script not found: {runner_script}")
|
||
return "Fail"
|
||
|
||
# Run the script in a separate process
|
||
env = os.environ.copy()
|
||
env['PYTHONIOENCODING'] = 'utf-8' # Force UTF-8 encoding
|
||
|
||
process = subprocess.Popen(
|
||
[
|
||
sys.executable,
|
||
str(runner_script),
|
||
str(self.project_root),
|
||
self.module_info[0], # module name
|
||
filename,
|
||
str(estimate_only)
|
||
],
|
||
stdout=subprocess.PIPE,
|
||
stderr=subprocess.PIPE,
|
||
text=True,
|
||
encoding='utf-8',
|
||
errors='replace',
|
||
cwd=str(self.project_root),
|
||
env=env,
|
||
bufsize=1 # Line buffered
|
||
)
|
||
|
||
# Track the process for potential termination
|
||
self.running_processes.append(process)
|
||
|
||
# Read output in real-time to capture progress
|
||
stdout_lines = []
|
||
stderr_lines = []
|
||
|
||
def read_stdout():
|
||
"""Read stdout line by line."""
|
||
for line in iter(process.stdout.readline, ''):
|
||
if not line:
|
||
break
|
||
line = line.strip()
|
||
if line.startswith('PROGRESS:'):
|
||
# Parse progress: PROGRESS:filename:current:total
|
||
try:
|
||
parts = line.split(':', 3)
|
||
if len(parts) == 4:
|
||
_, desc, current, total = parts
|
||
# Emit with filename included
|
||
self.item_progress_signal.emit(desc, int(current), int(total))
|
||
except Exception:
|
||
pass # Ignore malformed progress lines
|
||
else:
|
||
stdout_lines.append(line)
|
||
process.stdout.close()
|
||
|
||
def read_stderr():
|
||
"""Read stderr line by line."""
|
||
for line in iter(process.stderr.readline, ''):
|
||
if not line:
|
||
break
|
||
stderr_lines.append(line.strip())
|
||
process.stderr.close()
|
||
|
||
# Start reader threads
|
||
stdout_thread = threading.Thread(target=read_stdout, daemon=True)
|
||
stderr_thread = threading.Thread(target=read_stderr, daemon=True)
|
||
stdout_thread.start()
|
||
stderr_thread.start()
|
||
|
||
# Wait for process completion
|
||
process.wait()
|
||
|
||
# Wait for reader threads to finish
|
||
stdout_thread.join(timeout=1.0)
|
||
stderr_thread.join(timeout=1.0)
|
||
|
||
# Combine output
|
||
stdout = '\n'.join(stdout_lines)
|
||
stderr = '\n'.join(stderr_lines)
|
||
|
||
# Remove from tracking
|
||
if process in self.running_processes:
|
||
self.running_processes.remove(process)
|
||
|
||
# Check if process was terminated by stop signal
|
||
if self.should_stop:
|
||
return "Stopped"
|
||
|
||
# Forward all stdout output to log (this includes cost information)
|
||
for line in stdout.strip().split('\n'):
|
||
if line.strip() and not line.startswith('RESULT:'):
|
||
self.emit_log(line)
|
||
|
||
# Parse result
|
||
if process.returncode == 0:
|
||
for line in stdout.strip().split('\n'):
|
||
if line.startswith('RESULT:'):
|
||
result_text = line[7:] # Remove 'RESULT:' prefix
|
||
# Clean up any Unicode issues in the result
|
||
try:
|
||
return result_text
|
||
except UnicodeError:
|
||
return result_text.encode('ascii', 'ignore').decode('ascii')
|
||
return "Success"
|
||
else:
|
||
error_msg = stderr.strip() if stderr.strip() else "Unknown error"
|
||
# Handle potential Unicode errors in error messages
|
||
try:
|
||
clean_error = error_msg.encode('ascii', 'ignore').decode('ascii')
|
||
except:
|
||
clean_error = "Unicode encoding error in process output"
|
||
self.emit_log(f"❌ Process error: {clean_error}")
|
||
return "Fail"
|
||
|
||
except Exception as e:
|
||
self.emit_log(f"❌ Failed to run module process: {str(e)}")
|
||
return "Fail"
|
||
|
||
def run(self):
|
||
"""Run the translation process."""
|
||
try:
|
||
# Load environment variables
|
||
load_dotenv()
|
||
|
||
# Check for required environment variables
|
||
required_envs = ["api", "key", "organization", "model", "language", "timeout", "fileThreads", "threads", "width", "listWidth"]
|
||
env_missing = False
|
||
|
||
for env in required_envs:
|
||
if os.getenv(env) is None or str(os.getenv(env))[:1] == "<":
|
||
self.emit_log(f"❌ Environment variable {env} is not set!")
|
||
env_missing = True
|
||
|
||
if env_missing:
|
||
self.emit_log("❌ Some required environment variables are not set. Check your .env file.")
|
||
self.finished_signal.emit(False, "Environment variables missing")
|
||
return
|
||
|
||
# Get files to process
|
||
files_dir = self.project_root / "files"
|
||
if not files_dir.exists():
|
||
self.emit_log("❌ Files directory does not exist!")
|
||
self.finished_signal.emit(False, "Files directory missing")
|
||
return
|
||
|
||
# Use selected files or find all matching files
|
||
if self.selected_files:
|
||
matching_files = self.selected_files
|
||
else:
|
||
# Find files matching the selected module's extensions
|
||
matching_files = []
|
||
for file_path in files_dir.iterdir():
|
||
if file_path.is_file() and file_path.name != '.gitkeep':
|
||
for ext in self.module_info[1]:
|
||
if file_path.name.endswith(ext):
|
||
matching_files.append(file_path.name)
|
||
break
|
||
|
||
if not matching_files:
|
||
self.emit_log(f"❌ No files found matching extensions: {', '.join(self.module_info[1])}")
|
||
self.finished_signal.emit(False, "No matching files")
|
||
return
|
||
|
||
self.emit_log(f"📁 Found {len(matching_files)} files to process:")
|
||
for filename in matching_files:
|
||
self.emit_log(f" • {filename}")
|
||
|
||
self.emit_log(f"🔧 Using module: {self.module_info[0]}")
|
||
self.emit_log(f"📊 Estimate only: {'Yes' if self.estimate_only else 'No'}")
|
||
self.emit_log("")
|
||
|
||
# Process files
|
||
threads = int(os.getenv("fileThreads", "1"))
|
||
total_cost = "Fail"
|
||
|
||
# Change to project directory for module execution
|
||
old_cwd = os.getcwd()
|
||
os.chdir(str(self.project_root))
|
||
|
||
try:
|
||
# Use a simpler approach with limited parallelism
|
||
# to have better control over stopping
|
||
max_workers = min(threads, 2) # Limit to 2 concurrent processes max
|
||
self.executor = ThreadPoolExecutor(max_workers=max_workers)
|
||
|
||
# Submit tasks to run modules in separate processes
|
||
future_to_filename = {
|
||
self.executor.submit(self.run_module_in_process, filename, self.estimate_only): filename
|
||
for filename in matching_files
|
||
}
|
||
|
||
completed_count = 0
|
||
total_files = len(matching_files)
|
||
|
||
for future in as_completed(future_to_filename):
|
||
if self.should_stop:
|
||
# Don't log here, the stop() method already logged
|
||
# Cancel remaining futures
|
||
for remaining_future in future_to_filename:
|
||
if not remaining_future.done():
|
||
remaining_future.cancel()
|
||
break
|
||
|
||
filename = future_to_filename[future]
|
||
completed_count += 1
|
||
|
||
# Emit progress signal (less frequent updates)
|
||
self.emit_progress(completed_count, total_files, filename)
|
||
|
||
try:
|
||
result = future.result()
|
||
if result and result != "Fail" and result != "Stopped":
|
||
total_cost = result
|
||
# Don't log completion here since the module already logged the detailed cost info
|
||
elif result == "Stopped":
|
||
# Don't log here, already handled
|
||
break
|
||
else:
|
||
self.emit_log(f"❌ Failed processing {filename}")
|
||
except Exception as e:
|
||
tb_line = str(traceback.extract_tb(sys.exc_info()[2])[-1].lineno)
|
||
error_msg = f"❌ Error processing {filename}: {str(e)} | Line: {tb_line}"
|
||
self.emit_log(error_msg)
|
||
|
||
finally:
|
||
# Properly shutdown the executor
|
||
if self.executor:
|
||
try:
|
||
# Try to use cancel_futures parameter (Python 3.9+)
|
||
self.executor.shutdown(wait=False, cancel_futures=True)
|
||
except TypeError:
|
||
# Fallback for older Python versions
|
||
self.executor.shutdown(wait=False)
|
||
self.executor = None
|
||
# Change back to original directory
|
||
os.chdir(old_cwd)
|
||
|
||
# Clean up temporary files
|
||
tmp_file = self.project_root / "csv.tmp"
|
||
if tmp_file.exists():
|
||
tmp_file.unlink()
|
||
|
||
# Clean up any remaining temporary scripts
|
||
temp_script = self.project_root / "temp_translation_script.py"
|
||
if temp_script.exists():
|
||
temp_script.unlink()
|
||
|
||
# Ensure all processes are terminated
|
||
if self.running_processes:
|
||
for process in self.running_processes:
|
||
try:
|
||
if process.poll() is None:
|
||
process.terminate()
|
||
process.wait(timeout=1)
|
||
except:
|
||
pass
|
||
self.running_processes.clear()
|
||
|
||
# Report results
|
||
if total_cost != "Fail" and not self.should_stop:
|
||
self.emit_log("")
|
||
self.emit_log(f"💰 {total_cost}")
|
||
if not self.estimate_only:
|
||
self.emit_log("✅ Translation completed successfully!")
|
||
else:
|
||
self.emit_log("✅ Estimation completed!")
|
||
self.finished_signal.emit(True, str(total_cost))
|
||
else:
|
||
if not self.should_stop:
|
||
self.emit_log("❌ Translation failed!")
|
||
self.finished_signal.emit(False, "Translation failed")
|
||
else:
|
||
# Only log the final stop message here
|
||
self.emit_log("🛑 Translation stopped by user")
|
||
self.finished_signal.emit(False, "Translation stopped")
|
||
|
||
except Exception as e:
|
||
error_msg = f"❌ Unexpected error: {str(e)}"
|
||
self.emit_log(error_msg)
|
||
self.finished_signal.emit(False, error_msg)
|
||
|
||
|
||
class TranslationTab(QWidget):
|
||
"""Simple translation tab with file management and console log.
|
||
|
||
Emits engine_changed(str) when the selected module implies a different
|
||
engine configuration tab should be displayed.
|
||
"""
|
||
engine_changed = pyqtSignal(str)
|
||
|
||
def __init__(self, parent=None):
|
||
super().__init__(parent)
|
||
self.parent_window = parent
|
||
self.translation_process = None
|
||
self.log_buffer = [] # Buffer for batching log messages
|
||
self.log_timer = QTimer() # Timer for flushing log buffer
|
||
self.log_timer.timeout.connect(self.flush_log_buffer)
|
||
|
||
# Set up directories
|
||
self.project_root = Path(__file__).parent.parent
|
||
self.files_dir = self.project_root / "files"
|
||
self.translated_dir = self.project_root / "translated"
|
||
|
||
# Ensure directories exist
|
||
self.files_dir.mkdir(exist_ok=True)
|
||
self.translated_dir.mkdir(exist_ok=True)
|
||
|
||
# Initialize tracking variables
|
||
self.files_completed = 0
|
||
self.files_total = 0
|
||
self.file_progress_items = {} # filename -> {widget, label, progress_bar, checkbox}
|
||
self.current_translating_file = None
|
||
|
||
self.setup_ui()
|
||
self.setup_module_list()
|
||
self.refresh_file_lists()
|
||
|
||
def setup_ui(self):
|
||
"""Set up the user interface."""
|
||
# Create main splitter to separate translation controls from log viewer
|
||
main_splitter = QSplitter(Qt.Horizontal)
|
||
|
||
# Left side - translation controls
|
||
left_widget = QWidget()
|
||
layout = QVBoxLayout()
|
||
layout.setSpacing(8)
|
||
layout.setContentsMargins(15, 15, 15, 15)
|
||
|
||
# Files Section (at the top)
|
||
layout.addWidget(create_section_header("📁 Input Files"))
|
||
|
||
# Create stacked widget to switch between file list and progress view
|
||
self.file_stack = QStackedWidget()
|
||
|
||
# Page 0: Normal file list with buttons
|
||
file_list_page = QWidget()
|
||
file_list_layout = QVBoxLayout()
|
||
file_list_layout.setContentsMargins(0, 0, 0, 0)
|
||
|
||
# Files Section with side buttons
|
||
files_container = QHBoxLayout()
|
||
files_container.setSpacing(5) # Add spacing between list and buttons
|
||
|
||
# File list with checkboxes
|
||
self.file_list = QListWidget()
|
||
self.file_list.setMinimumHeight(350)
|
||
# No max height - let it expand
|
||
self.file_list.setSelectionMode(QListWidget.NoSelection) # Disable selection highlighting
|
||
self.file_list.itemClicked.connect(self._toggle_file_checkbox)
|
||
self.file_list.setFocusPolicy(Qt.NoFocus) # Remove focus outline
|
||
self.file_list.setStyleSheet("""
|
||
QListWidget {
|
||
outline: none;
|
||
border: 1px solid #555555;
|
||
}
|
||
QListWidget::item {
|
||
border: none;
|
||
outline: none;
|
||
}
|
||
QListWidget::item:hover {
|
||
background-color: #3e3e42;
|
||
}
|
||
""")
|
||
files_container.addWidget(self.file_list)
|
||
|
||
# File management buttons (icon-based, vertical on the side)
|
||
file_buttons = QVBoxLayout()
|
||
file_buttons.setSpacing(0)
|
||
file_buttons.setContentsMargins(0, 0, 0, 0)
|
||
|
||
# Button style for all icon buttons - all same size
|
||
icon_button_style = """
|
||
QPushButton {
|
||
font-size: 13px;
|
||
padding: 0px;
|
||
min-width: 32px;
|
||
max-width: 32px;
|
||
min-height: 32px;
|
||
max-height: 32px;
|
||
border: 1px solid #555555;
|
||
border-top: none;
|
||
border-radius: 0px;
|
||
background-color: #2d2d30;
|
||
}
|
||
QPushButton:hover {
|
||
background-color: #3e3e42;
|
||
border-left-color: #007acc;
|
||
}
|
||
QPushButton:pressed {
|
||
background-color: #007acc;
|
||
}
|
||
"""
|
||
|
||
# First button style - same size but with top border
|
||
first_button_style = """
|
||
QPushButton {
|
||
font-size: 13px;
|
||
padding: 0px;
|
||
min-width: 32px;
|
||
max-width: 32px;
|
||
min-height: 32px;
|
||
max-height: 32px;
|
||
border: 1px solid #555555;
|
||
border-radius: 0px;
|
||
background-color: #2d2d30;
|
||
}
|
||
QPushButton:hover {
|
||
background-color: #3e3e42;
|
||
border-left-color: #007acc;
|
||
}
|
||
QPushButton:pressed {
|
||
background-color: #007acc;
|
||
}
|
||
"""
|
||
|
||
select_all_btn = QPushButton("✓")
|
||
select_all_btn.setToolTip("Select all files")
|
||
select_all_btn.clicked.connect(self.select_all_files)
|
||
select_all_btn.setStyleSheet(first_button_style)
|
||
file_buttons.addWidget(select_all_btn)
|
||
|
||
deselect_all_btn = QPushButton("✗")
|
||
deselect_all_btn.setToolTip("Deselect all files")
|
||
deselect_all_btn.clicked.connect(self.deselect_all_files)
|
||
deselect_all_btn.setStyleSheet(icon_button_style)
|
||
file_buttons.addWidget(deselect_all_btn)
|
||
|
||
add_files_btn = QPushButton("➕")
|
||
add_files_btn.setToolTip("Add files to translate")
|
||
add_files_btn.clicked.connect(self.add_input_files)
|
||
add_files_btn.setStyleSheet(icon_button_style)
|
||
file_buttons.addWidget(add_files_btn)
|
||
|
||
remove_files_btn = QPushButton("🗑️")
|
||
remove_files_btn.setToolTip("Remove selected files")
|
||
remove_files_btn.clicked.connect(self.remove_selected_files)
|
||
remove_files_btn.setStyleSheet(icon_button_style)
|
||
file_buttons.addWidget(remove_files_btn)
|
||
|
||
open_folder_btn = QPushButton("📁")
|
||
open_folder_btn.setToolTip("Open files folder in explorer")
|
||
open_folder_btn.clicked.connect(self.open_input_folder)
|
||
open_folder_btn.setStyleSheet(icon_button_style)
|
||
file_buttons.addWidget(open_folder_btn)
|
||
|
||
refresh_btn = QPushButton("🔄")
|
||
refresh_btn.setToolTip("Refresh file list")
|
||
refresh_btn.clicked.connect(self.refresh_file_lists)
|
||
refresh_btn.setStyleSheet(icon_button_style)
|
||
file_buttons.addWidget(refresh_btn)
|
||
|
||
# Add stretch to push buttons to top
|
||
file_buttons.addStretch()
|
||
|
||
# Add button column to the container
|
||
files_container.addLayout(file_buttons)
|
||
|
||
# Add the container to file list page
|
||
file_list_layout.addLayout(files_container)
|
||
file_list_page.setLayout(file_list_layout)
|
||
self.file_stack.addWidget(file_list_page) # Index 0
|
||
|
||
# Page 1: Progress view (shown during translation)
|
||
progress_view_page = QWidget()
|
||
progress_view_layout = QVBoxLayout()
|
||
progress_view_layout.setContentsMargins(0, 0, 0, 0)
|
||
|
||
self.progress_list = QListWidget()
|
||
self.progress_list.setMinimumHeight(350)
|
||
self.progress_list.setSelectionMode(QListWidget.NoSelection)
|
||
self.progress_list.setFocusPolicy(Qt.NoFocus)
|
||
self.progress_list.setSpacing(1) # Minimal spacing between items
|
||
self.progress_list.setStyleSheet("""
|
||
QListWidget {
|
||
outline: none;
|
||
border: 1px solid #555555;
|
||
border-radius: 3px;
|
||
background-color: #1e1e1e;
|
||
color: white;
|
||
font-size: 13px;
|
||
}
|
||
QListWidget::item {
|
||
padding: 0px;
|
||
border-bottom: 1px solid #333333;
|
||
}
|
||
QListWidget::item:last {
|
||
border-bottom: none;
|
||
}
|
||
""")
|
||
progress_view_layout.addWidget(self.progress_list)
|
||
|
||
# Summary button (shown after completion)
|
||
self.reset_view_button = QPushButton("Back to File Selection")
|
||
self.reset_view_button.clicked.connect(self.reset_to_file_view)
|
||
self.reset_view_button.setVisible(False)
|
||
self.reset_view_button.setStyleSheet("""
|
||
QPushButton {
|
||
background-color: #0e639c;
|
||
color: white;
|
||
font-weight: bold;
|
||
padding: 8px 16px;
|
||
font-size: 13px;
|
||
border-radius: 3px;
|
||
}
|
||
QPushButton:hover {
|
||
background-color: #1177bb;
|
||
}
|
||
""")
|
||
progress_view_layout.addWidget(self.reset_view_button)
|
||
|
||
progress_view_page.setLayout(progress_view_layout)
|
||
self.file_stack.addWidget(progress_view_page) # Index 1
|
||
|
||
# Add stacked widget to main layout
|
||
layout.addWidget(self.file_stack)
|
||
layout.addWidget(create_horizontal_line())
|
||
|
||
# Translation Settings Section (in the middle)
|
||
layout.addWidget(create_section_header("🌐 Translation Settings"))
|
||
|
||
trans_form = QFormLayout()
|
||
trans_form.setSpacing(6)
|
||
trans_form.setContentsMargins(0, 0, 0, 12)
|
||
trans_form.setFieldGrowthPolicy(QFormLayout.FieldsStayAtSizeHint)
|
||
trans_form.setLabelAlignment(Qt.AlignRight | Qt.AlignVCenter)
|
||
|
||
engine_label = QLabel("Game Engine:")
|
||
engine_label.setFixedWidth(100)
|
||
engine_label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
|
||
self.module_combo = QComboBox()
|
||
self.module_combo.currentTextChanged.connect(self._on_module_changed)
|
||
self.module_combo.setFixedWidth(300)
|
||
trans_form.addRow(engine_label, self.module_combo)
|
||
|
||
mode_label = QLabel("Mode:")
|
||
mode_label.setFixedWidth(100)
|
||
mode_label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
|
||
self.mode_combo = QComboBox()
|
||
self.mode_combo.addItem("Translate")
|
||
self.mode_combo.addItem("Estimate")
|
||
self.mode_combo.setFixedWidth(300)
|
||
self.mode_combo.currentTextChanged.connect(self._on_mode_changed)
|
||
trans_form.addRow(mode_label, self.mode_combo)
|
||
|
||
layout.addLayout(trans_form)
|
||
layout.addWidget(create_horizontal_line())
|
||
|
||
# Spacer to push progress and buttons to bottom
|
||
layout.addStretch()
|
||
|
||
# Progress Section (at the bottom, right above buttons)
|
||
layout.addWidget(create_section_header("📊 Translation Progress"))
|
||
|
||
progress_layout = QVBoxLayout()
|
||
progress_layout.setSpacing(8)
|
||
progress_layout.setContentsMargins(0, 0, 0, 12)
|
||
|
||
# Files Translated counter
|
||
files_layout = QHBoxLayout()
|
||
files_layout.addWidget(QLabel("Files Translated:"))
|
||
self.files_translated_label = QLabel("0/0")
|
||
self.files_translated_label.setStyleSheet("font-weight: bold; color: #007acc;")
|
||
files_layout.addWidget(self.files_translated_label)
|
||
files_layout.addStretch()
|
||
progress_layout.addLayout(files_layout)
|
||
|
||
# Currently translating
|
||
translating_layout = QHBoxLayout()
|
||
translating_layout.addWidget(QLabel("Translating:"))
|
||
self.translating_label = QLabel("—")
|
||
self.translating_label.setStyleSheet("font-weight: bold; color: #cccccc;")
|
||
translating_layout.addWidget(self.translating_label)
|
||
translating_layout.addStretch()
|
||
progress_layout.addLayout(translating_layout)
|
||
|
||
# Progress bar with label
|
||
item_progress_layout = QHBoxLayout()
|
||
item_progress_layout.addWidget(QLabel("Progress:"))
|
||
self.item_progress_label = QLabel("0/0")
|
||
self.item_progress_label.setStyleSheet("font-weight: bold; color: #cccccc;")
|
||
item_progress_layout.addWidget(self.item_progress_label)
|
||
item_progress_layout.addStretch()
|
||
progress_layout.addLayout(item_progress_layout)
|
||
|
||
self.item_progress_bar = QProgressBar()
|
||
self.item_progress_bar.setStyleSheet("""
|
||
QProgressBar {
|
||
border: 1px solid #555555;
|
||
border-radius: 3px;
|
||
text-align: center;
|
||
background-color: #2b2b2b;
|
||
color: white;
|
||
height: 20px;
|
||
}
|
||
QProgressBar::chunk {
|
||
background-color: #007acc;
|
||
border-radius: 2px;
|
||
}
|
||
""")
|
||
progress_layout.addWidget(self.item_progress_bar)
|
||
|
||
layout.addLayout(progress_layout)
|
||
|
||
# Buttons (right below progress section)
|
||
button_layout = QHBoxLayout()
|
||
button_layout.addStretch()
|
||
self.translate_button = QPushButton("Start Translation")
|
||
self.translate_button.clicked.connect(self.start_translation)
|
||
self.translate_button.setStyleSheet("""
|
||
QPushButton {
|
||
background-color: #007acc;
|
||
color: white;
|
||
font-weight: bold;
|
||
padding: 10px 20px;
|
||
font-size: 14px;
|
||
border-radius: 5px;
|
||
}
|
||
QPushButton:hover {
|
||
background-color: #106ebe;
|
||
}
|
||
""")
|
||
button_layout.addWidget(self.translate_button)
|
||
self.stop_button = QPushButton("Stop Translation")
|
||
self.stop_button.clicked.connect(self.stop_translation)
|
||
self.stop_button.setVisible(False) # Hidden by default
|
||
self.stop_button.setStyleSheet("""
|
||
QPushButton {
|
||
background-color: #cc0000;
|
||
color: white;
|
||
font-weight: bold;
|
||
padding: 10px 20px;
|
||
font-size: 14px;
|
||
border-radius: 5px;
|
||
}
|
||
QPushButton:hover {
|
||
background-color: #aa0000;
|
||
}
|
||
""")
|
||
button_layout.addWidget(self.stop_button)
|
||
button_layout.addStretch()
|
||
layout.addLayout(button_layout)
|
||
left_widget.setLayout(layout)
|
||
|
||
# Right side - translation history log viewer
|
||
self.translation_log_viewer = LogViewer()
|
||
|
||
# Add both to splitter
|
||
main_splitter.addWidget(left_widget)
|
||
main_splitter.addWidget(self.translation_log_viewer)
|
||
|
||
# Set proportional sizes (translation controls: 60%, log viewer: 40%)
|
||
main_splitter.setStretchFactor(0, 3)
|
||
main_splitter.setStretchFactor(1, 2)
|
||
|
||
# Set main layout for this tab
|
||
tab_layout = QVBoxLayout()
|
||
tab_layout.addWidget(main_splitter)
|
||
tab_layout.setContentsMargins(0, 0, 0, 0)
|
||
self.setLayout(tab_layout)
|
||
|
||
def setup_module_list(self):
|
||
"""Set up the module selection list."""
|
||
# Import modules to get the list
|
||
try:
|
||
sys.path.append(str(self.project_root))
|
||
from modules.rpgmakermvmz import handleMVMZ
|
||
from modules.rpgmakerace import handleACE
|
||
from modules.csv import handleCSV
|
||
from modules.tyrano import handleTyrano
|
||
from modules.kirikiri import handleKirikiri
|
||
from modules.json import handleJSON
|
||
from modules.lune import handleLune
|
||
from modules.nscript import handleOnscripter
|
||
from modules.wolf import handleWOLF
|
||
from modules.wolf2 import handleWOLF2
|
||
from modules.regex import handleRegex
|
||
from modules.text import handleText
|
||
from modules.renpy import handleRenpy
|
||
from modules.unity import handleUnity
|
||
from modules.images import handleImages
|
||
from modules.rpgmakerplugin import handlePlugin
|
||
|
||
self.modules = [
|
||
["RPG Maker MV/MZ", [".json"], handleMVMZ],
|
||
["RPG Maker Ace", [".yaml"], handleACE],
|
||
["CSV", [".csv"], handleCSV],
|
||
["Tyrano", [".ks"], handleTyrano],
|
||
["Kirikiri", [".ks"], handleKirikiri],
|
||
["JSON", [".json"], handleJSON],
|
||
["Lune", [".l"], handleLune],
|
||
["NScript", [".nscript"], handleOnscripter],
|
||
["Wolf RPG", [".txt"], handleWOLF],
|
||
["Wolf RPG 2", [".txt"], handleWOLF2],
|
||
["Regex", [".txt"], handleRegex],
|
||
["Text", [".txt"], handleText],
|
||
["RenPy", [".rpy"], handleRenpy],
|
||
["Unity", [".unity"], handleUnity],
|
||
["Images", [".png", ".jpg", ".jpeg"], handleImages],
|
||
["RPG Maker Plugin", [".js"], handlePlugin],
|
||
]
|
||
|
||
for module in self.modules:
|
||
extensions = ", ".join(module[1])
|
||
self.module_combo.addItem(f"{module[0]} ({extensions})")
|
||
if self.module_combo.count():
|
||
self._on_module_changed(self.module_combo.currentText())
|
||
|
||
except Exception as e:
|
||
# Store error for later logging since log_display might not exist yet
|
||
self.module_load_error = f"Warning: Could not load modules: {str(e)}"
|
||
# Add a default option
|
||
self.module_combo.addItem("RPG Maker MV/MZ (.json)")
|
||
self.modules = [["RPG Maker MV/MZ", [".json"], None]]
|
||
self._on_module_changed(self.module_combo.currentText())
|
||
|
||
def _on_module_changed(self, text: str):
|
||
lowered = text.lower()
|
||
if "ace" in lowered:
|
||
self.engine_changed.emit("ace")
|
||
elif "wolf" in lowered and "wolf rpg 2" not in lowered:
|
||
self.engine_changed.emit("wolf")
|
||
elif "mv/mz" in lowered:
|
||
self.engine_changed.emit("mvmz")
|
||
|
||
# Update mode dropdown based on engine
|
||
current_mode = self.mode_combo.currentText()
|
||
self.mode_combo.clear()
|
||
self.mode_combo.addItem("Translate")
|
||
self.mode_combo.addItem("Estimate")
|
||
|
||
# Add Parse Speakers for RPG Maker MV/MZ
|
||
if "mv/mz" in lowered:
|
||
self.mode_combo.addItem("Parse Speakers")
|
||
|
||
# Restore previous selection if it still exists
|
||
index = self.mode_combo.findText(current_mode)
|
||
if index >= 0:
|
||
self.mode_combo.setCurrentIndex(index)
|
||
else:
|
||
self.mode_combo.setCurrentIndex(0)
|
||
|
||
def _toggle_file_checkbox(self, item):
|
||
"""Toggle checkbox when clicking anywhere on the item."""
|
||
if item.checkState() == Qt.Checked:
|
||
item.setCheckState(Qt.Unchecked)
|
||
else:
|
||
item.setCheckState(Qt.Checked)
|
||
|
||
def _on_mode_changed(self, mode_text):
|
||
"""Update the translate button text based on selected mode."""
|
||
if mode_text == "Translate":
|
||
self.translate_button.setText("Start Translation")
|
||
elif mode_text == "Estimate":
|
||
self.translate_button.setText("Start Estimation")
|
||
elif mode_text == "Parse Speakers":
|
||
self.translate_button.setText("Parse Speakers")
|
||
|
||
def refresh_file_lists(self):
|
||
"""Refresh the file list with checkboxes, preserving checked states."""
|
||
# Save current check states
|
||
checked_files = set()
|
||
for i in range(self.file_list.count()):
|
||
item = self.file_list.item(i)
|
||
if item.checkState() == Qt.Checked:
|
||
checked_files.add(item.text())
|
||
|
||
# Rebuild the list
|
||
self.file_list.clear()
|
||
if self.files_dir.exists():
|
||
for file_path in self.files_dir.iterdir():
|
||
if file_path.is_file() and file_path.name != '.gitkeep':
|
||
item = QListWidgetItem(file_path.name)
|
||
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
|
||
# Restore checked state if it was previously checked
|
||
if file_path.name in checked_files:
|
||
item.setCheckState(Qt.Checked)
|
||
else:
|
||
item.setCheckState(Qt.Unchecked)
|
||
self.file_list.addItem(item)
|
||
|
||
def select_all_files(self):
|
||
"""Select all files in the list."""
|
||
for i in range(self.file_list.count()):
|
||
item = self.file_list.item(i)
|
||
item.setCheckState(Qt.Checked)
|
||
|
||
def deselect_all_files(self):
|
||
"""Deselect all files in the list."""
|
||
for i in range(self.file_list.count()):
|
||
item = self.file_list.item(i)
|
||
item.setCheckState(Qt.Unchecked)
|
||
|
||
def get_selected_files(self):
|
||
"""Get list of checked files."""
|
||
selected = []
|
||
for i in range(self.file_list.count()):
|
||
item = self.file_list.item(i)
|
||
if item.checkState() == Qt.Checked:
|
||
selected.append(item.text())
|
||
return selected
|
||
|
||
def add_input_files(self):
|
||
"""Add files to the input directory."""
|
||
file_paths, _ = QFileDialog.getOpenFileNames(
|
||
self,
|
||
"Select files to add",
|
||
"",
|
||
"All Files (*)"
|
||
)
|
||
|
||
if file_paths:
|
||
try:
|
||
import shutil
|
||
copied_count = 0
|
||
for file_path in file_paths:
|
||
source = Path(file_path)
|
||
dest = self.files_dir / source.name
|
||
|
||
if dest.exists():
|
||
reply = QMessageBox.question(
|
||
self,
|
||
"File Exists",
|
||
f"File '{source.name}' already exists. Overwrite?",
|
||
QMessageBox.Yes | QMessageBox.No
|
||
)
|
||
if reply == QMessageBox.No:
|
||
continue
|
||
|
||
shutil.copy2(source, dest)
|
||
copied_count += 1
|
||
|
||
self.refresh_file_lists()
|
||
if copied_count > 0:
|
||
QMessageBox.information(self, "Files Added", f"Successfully added {copied_count} files.")
|
||
|
||
except Exception as e:
|
||
QMessageBox.critical(self, "Error", f"Failed to add files:\n{str(e)}")
|
||
|
||
def remove_selected_files(self):
|
||
"""Remove selected (checked) files from the input directory."""
|
||
selected_files = self.get_selected_files()
|
||
|
||
if not selected_files:
|
||
QMessageBox.information(self, "No Selection", "Please check files to remove.")
|
||
return
|
||
|
||
reply = QMessageBox.question(
|
||
self,
|
||
"Confirm Deletion",
|
||
f"Are you sure you want to delete {len(selected_files)} file(s)?",
|
||
QMessageBox.Yes | QMessageBox.No
|
||
)
|
||
|
||
if reply == QMessageBox.Yes:
|
||
try:
|
||
for filename in selected_files:
|
||
file_path = self.files_dir / filename
|
||
file_path.unlink()
|
||
self.refresh_file_lists()
|
||
QMessageBox.information(self, "Files Removed", f"Successfully removed {len(selected_files)} file(s).")
|
||
except Exception as e:
|
||
QMessageBox.critical(self, "Error", f"Failed to delete files:\n{str(e)}")
|
||
|
||
def open_input_folder(self):
|
||
"""Open the input directory."""
|
||
self.open_folder(self.files_dir)
|
||
|
||
def open_output_folder(self):
|
||
"""Open the output directory."""
|
||
self.open_folder(self.translated_dir)
|
||
|
||
def open_folder(self, folder_path):
|
||
"""Open a folder in the file explorer."""
|
||
try:
|
||
import platform
|
||
if platform.system() == "Windows":
|
||
subprocess.run(["explorer", str(folder_path)])
|
||
elif platform.system() == "Darwin": # macOS
|
||
subprocess.run(["open", str(folder_path)])
|
||
else: # Linux
|
||
subprocess.run(["xdg-open", str(folder_path)])
|
||
except Exception as e:
|
||
QMessageBox.warning(self, "Error", f"Failed to open folder:\n{str(e)}")
|
||
|
||
def create_progress_item(self, filename):
|
||
"""Create a progress item widget for a file."""
|
||
widget = QWidget()
|
||
widget.setFixedHeight(36) # Fixed height instead of minimum
|
||
layout = QHBoxLayout()
|
||
layout.setContentsMargins(6, 4, 6, 4) # Reduced margins
|
||
layout.setSpacing(10)
|
||
|
||
# Checkbox (initially unchecked, will check when done)
|
||
checkbox = QCheckBox()
|
||
checkbox.setEnabled(False) # Not interactive
|
||
checkbox.setFixedSize(18, 18) # Slightly smaller
|
||
layout.addWidget(checkbox)
|
||
|
||
# Filename label
|
||
filename_label = QLabel(filename)
|
||
filename_label.setStyleSheet("font-weight: bold; color: white; font-size: 13px;")
|
||
filename_label.setFixedWidth(250) # Fixed width for consistent alignment
|
||
layout.addWidget(filename_label)
|
||
|
||
# Progress label
|
||
progress_label = QLabel("Waiting...")
|
||
progress_label.setStyleSheet("color: #888888; font-size: 12px;")
|
||
progress_label.setFixedWidth(120)
|
||
layout.addWidget(progress_label)
|
||
|
||
# Progress bar (stretch to fill remaining space)
|
||
progress_bar = QProgressBar()
|
||
progress_bar.setMaximum(100)
|
||
progress_bar.setValue(0)
|
||
progress_bar.setFixedHeight(18) # Fixed height instead of minimum
|
||
progress_bar.setStyleSheet("""
|
||
QProgressBar {
|
||
border: 1px solid #555555;
|
||
border-radius: 2px;
|
||
text-align: center;
|
||
background-color: #2b2b2b;
|
||
color: white;
|
||
}
|
||
QProgressBar::chunk {
|
||
background-color: #007acc;
|
||
border-radius: 1px;
|
||
}
|
||
""")
|
||
layout.addWidget(progress_bar, 1) # Stretch factor of 1 to fill remaining space
|
||
|
||
widget.setLayout(layout)
|
||
|
||
# Store references
|
||
self.file_progress_items[filename] = {
|
||
'widget': widget,
|
||
'checkbox': checkbox,
|
||
'label': progress_label,
|
||
'progress_bar': progress_bar
|
||
}
|
||
|
||
return widget
|
||
|
||
def update_file_item_progress(self, filename, current, total):
|
||
"""Update progress for a specific file."""
|
||
if filename in self.file_progress_items:
|
||
item = self.file_progress_items[filename]
|
||
item['progress_bar'].setMaximum(total if total > 0 else 100)
|
||
item['progress_bar'].setValue(current)
|
||
item['label'].setText(f"{current}/{total}")
|
||
item['label'].setStyleSheet("color: #007acc; font-weight: bold;")
|
||
|
||
def mark_file_complete(self, filename, success=True):
|
||
"""Mark a file as complete."""
|
||
if filename in self.file_progress_items:
|
||
item = self.file_progress_items[filename]
|
||
item['checkbox'].setChecked(True)
|
||
if success:
|
||
item['label'].setText("✓ Complete")
|
||
item['label'].setStyleSheet("color: #4ec9b0; font-weight: bold;")
|
||
item['progress_bar'].setValue(item['progress_bar'].maximum())
|
||
else:
|
||
item['label'].setText("✗ Failed")
|
||
item['label'].setStyleSheet("color: #f48771; font-weight: bold;")
|
||
|
||
def reset_to_file_view(self):
|
||
"""Reset back to file selection view."""
|
||
self.file_stack.setCurrentIndex(0)
|
||
self.reset_view_button.setVisible(False)
|
||
self.translate_button.setVisible(True)
|
||
self.stop_button.setVisible(False)
|
||
self.refresh_file_lists()
|
||
|
||
def start_translation(self):
|
||
"""Start the translation process."""
|
||
# Get checked files
|
||
selected_files = self.get_selected_files()
|
||
|
||
if not selected_files:
|
||
QMessageBox.warning(self, "No Files Selected", "Please check at least one file to translate.")
|
||
return
|
||
|
||
# Get selected module
|
||
selected_index = self.module_combo.currentIndex()
|
||
if selected_index < 0 or selected_index >= len(self.modules):
|
||
QMessageBox.warning(self, "No Module", "Please select a translation module.")
|
||
return
|
||
|
||
selected_module = self.modules[selected_index]
|
||
|
||
# Get mode from dropdown
|
||
mode = self.mode_combo.currentText()
|
||
estimate_only = (mode == "Estimate")
|
||
parse_speakers = (mode == "Parse Speakers")
|
||
|
||
# Confirm start
|
||
action = mode.lower()
|
||
reply = QMessageBox.question(
|
||
self,
|
||
f"Start {mode}",
|
||
f"Start {action} for {len(selected_files)} file(s) using {selected_module[0]}?",
|
||
QMessageBox.Yes | QMessageBox.No
|
||
)
|
||
|
||
if reply == QMessageBox.Yes:
|
||
# Switch to progress view
|
||
self.file_stack.setCurrentIndex(1)
|
||
|
||
# Initialize progress list with all files
|
||
self.progress_list.clear()
|
||
self.file_progress_items.clear()
|
||
|
||
for filename in selected_files:
|
||
item_widget = self.create_progress_item(filename)
|
||
list_item = QListWidgetItem(self.progress_list)
|
||
# Set fixed size hint to match widget height
|
||
from PyQt5.QtCore import QSize
|
||
list_item.setSizeHint(QSize(0, 36)) # Width 0 = auto, height 36px
|
||
self.progress_list.addItem(list_item)
|
||
self.progress_list.setItemWidget(list_item, item_widget)
|
||
|
||
# Toggle button visibility
|
||
self.translate_button.setVisible(False)
|
||
self.stop_button.setVisible(True)
|
||
|
||
# Initialize progress tracking
|
||
self.files_completed = 0
|
||
self.files_total = len(selected_files)
|
||
self.files_translated_label.setText(f"0/{self.files_total}")
|
||
self.translating_label.setText("Starting...")
|
||
self.item_progress_label.setText("0/0")
|
||
self.item_progress_bar.setValue(0)
|
||
self.item_progress_bar.setMaximum(100)
|
||
|
||
# Create and start translation worker
|
||
self.translation_worker = TranslationWorker(
|
||
self.project_root,
|
||
selected_module,
|
||
estimate_only,
|
||
selected_files # Pass selected files
|
||
)
|
||
|
||
# Connect signals
|
||
self.translation_worker.log_signal.connect(self.append_log)
|
||
self.translation_worker.progress_signal.connect(self.update_file_progress)
|
||
self.translation_worker.item_progress_signal.connect(self.update_item_progress)
|
||
self.translation_worker.finished_signal.connect(self.on_translation_finished)
|
||
|
||
# Start the worker
|
||
self.translation_worker.start()
|
||
|
||
def append_log(self, message):
|
||
"""Append a message to the log - now just for internal tracking."""
|
||
# We no longer display logs in the UI, but we can keep this for debugging
|
||
# or future use with the log viewer
|
||
pass
|
||
|
||
def update_file_progress(self, current_file, total_files, filename):
|
||
"""Update the file-level progress."""
|
||
self.files_completed = current_file
|
||
self.files_translated_label.setText(f"{current_file}/{total_files}")
|
||
self.translating_label.setText(filename)
|
||
|
||
# Mark previous file as complete if there was one
|
||
if self.current_translating_file and self.current_translating_file != filename:
|
||
self.mark_file_complete(self.current_translating_file, success=True)
|
||
|
||
# Update current file
|
||
self.current_translating_file = filename
|
||
if filename in self.file_progress_items:
|
||
self.file_progress_items[filename]['label'].setText("Translating...")
|
||
self.file_progress_items[filename]['label'].setStyleSheet("color: #007acc; font-weight: bold;")
|
||
|
||
def update_item_progress(self, filename, current_item, total_items):
|
||
"""Update the item-level progress (from tqdm)."""
|
||
# Update the overall progress display with the current file
|
||
self.item_progress_label.setText(f"{current_item}/{total_items}")
|
||
self.item_progress_bar.setMaximum(total_items if total_items > 0 else 100)
|
||
self.item_progress_bar.setValue(current_item)
|
||
self.translating_label.setText(filename)
|
||
|
||
# Update the specific file's progress bar in the list
|
||
if filename in self.file_progress_items:
|
||
self.update_file_item_progress(filename, current_item, total_items)
|
||
# Mark as translating if not already done
|
||
if self.file_progress_items[filename]['label'].text() == "Waiting...":
|
||
self.file_progress_items[filename]['label'].setText("Translating...")
|
||
self.file_progress_items[filename]['label'].setStyleSheet("color: #007acc; font-weight: bold;")
|
||
|
||
def flush_log_buffer(self):
|
||
"""No longer needed - kept for compatibility."""
|
||
self.log_buffer.clear()
|
||
self.log_timer.stop()
|
||
|
||
def update_progress(self, current_file, total_files, filename):
|
||
"""Legacy method - redirect to new method."""
|
||
self.update_file_progress(current_file, total_files, filename)
|
||
|
||
def on_translation_finished(self, success, message):
|
||
"""Handle translation completion."""
|
||
# Mark the last file as complete
|
||
if self.current_translating_file:
|
||
self.mark_file_complete(self.current_translating_file, success=success)
|
||
|
||
# Show reset button instead of translate button
|
||
self.stop_button.setVisible(False)
|
||
self.reset_view_button.setVisible(True)
|
||
|
||
# Update progress display
|
||
if success:
|
||
self.translating_label.setText("Completed!")
|
||
else:
|
||
self.translating_label.setText(f"Failed: {message}")
|
||
|
||
# Refresh file list to show any new translated files
|
||
self.refresh_file_lists()
|
||
|
||
def stop_translation(self):
|
||
"""Stop the translation process."""
|
||
if hasattr(self, 'translation_worker') and self.translation_worker.isRunning():
|
||
self.translation_worker.stop()
|
||
|
||
# Wait for the worker to stop gracefully
|
||
if not self.translation_worker.wait(5000): # Wait up to 5 seconds
|
||
self.translation_worker.terminate()
|
||
self.translation_worker.wait(2000) # Wait for termination
|
||
|
||
# Toggle button visibility
|
||
self.translate_button.setVisible(True)
|
||
self.stop_button.setVisible(False)
|
||
self.translating_label.setText("Stopped")
|
||
|
||
def closeEvent(self, event):
|
||
"""Handle widget close event."""
|
||
if hasattr(self, 'log_timer'):
|
||
self.log_timer.stop()
|
||
if hasattr(self, 'translation_worker') and self.translation_worker.isRunning():
|
||
self.translation_worker.stop()
|
||
if not self.translation_worker.wait(3000):
|
||
self.translation_worker.terminate()
|
||
self.translation_worker.wait(1000)
|
||
event.accept()
|